diff --git a/kernel-agentic/Makefile b/kernel-agentic/Makefile
index 0b3857b..f6f4975 100644
--- a/kernel-agentic/Makefile
+++ b/kernel-agentic/Makefile
@@ -2,7 +2,7 @@
 TORCH_FILE_DIR ?= datasets/torch_example_kernels
 KERNEL_FILE_DIR ?= kernel_codes
 KERNEL_LANG ?= hip
-MODE ?= multimodal
+MODE ?= text
 
 ACTIVATE_VENV_CMD = exec bash -c "source .venv/bin/activate && exec bash"
 
diff --git a/kernel-agentic/docs/hip/AMD Instinct MI300 CDNA3 Architecture Guide for High-Quality HIP Kernel Development.md b/kernel-agentic/docs/hip/AMD Instinct MI300 CDNA3 Architecture Guide for High-Quality HIP Kernel Development.md
new file mode 100644
index 0000000..4cb3de0
--- /dev/null
+++ b/kernel-agentic/docs/hip/AMD Instinct MI300 CDNA3 Architecture Guide for High-Quality HIP Kernel Development.md	
@@ -0,0 +1,414 @@
+# AMD Instinct MI300 CDNA3 Architecture Guide for High-Quality HIP Kernel Development
+
+
+## Abstract
+
+This comprehensive guide provides essential knowledge for developing high-performance HIP kernels specifically optimized for the AMD Instinct MI300 CDNA3 architecture. The document focuses on unique architectural features and programming considerations that differentiate MI300 from NVIDIA AI accelerators, enabling developers to leverage the full potential of AMD's latest compute architecture. Key areas covered include the revolutionary Matrix Fused Multiply-Add (MFMA) instructions, novel data formats like FP8 and BF8, structured sparse matrix support, and the dual register file architecture that sets MI300 apart from competing solutions.
+
+## Table of Contents
+
+1. [Introduction](#introduction)
+2. [Matrix Arithmetic Architecture](#matrix-arithmetic-architecture)
+3. [Advanced Data Format Support](#advanced-data-format-support)
+4. [Sparse Matrix Acceleration](#sparse-matrix-acceleration)
+5. [Memory Hierarchy and Operations](#memory-hierarchy-and-operations)
+6. [Register Architecture and Management](#register-architecture-and-management)
+7. [Execution Model and Control Flow](#execution-model-and-control-flow)
+8. [Performance Optimization Strategies](#performance-optimization-strategies)
+9. [Key Differences from NVIDIA Architectures](#key-differences-from-nvidia-architectures)
+10. [Best Practices for HIP Kernel Development](#best-practices-for-hip-kernel-development)
+11. [Conclusion](#conclusion)
+12. [References](#references)
+
+## Introduction
+
+The AMD Instinct MI300 represents a significant advancement in compute architecture, introducing the CDNA3 instruction set architecture specifically designed for artificial intelligence and high-performance computing workloads. Unlike traditional GPU architectures that evolved from graphics processing, CDNA3 was purpose-built for compute-intensive applications, resulting in unique architectural decisions that require specialized knowledge for optimal kernel development.
+
+The MI300's architecture introduces several groundbreaking features that distinguish it from both previous AMD architectures and competing NVIDIA solutions. Most notably, the introduction of dedicated Matrix Arithmetic Instructions (MAI) with a separate accumulation register file, native support for emerging data formats like FP8 and BF8, and hardware-accelerated structured sparse matrix operations represent paradigm shifts in how developers should approach kernel optimization.
+
+This guide synthesizes critical information from the official AMD Instinct MI300 CDNA3 Instruction Set Architecture Reference Guide, focusing specifically on aspects that impact HIP kernel development. Rather than covering general GPU programming concepts that large language models already understand, this document concentrates on MI300-specific features, architectural nuances, and programming patterns that enable developers to write high-performance kernels that fully exploit the hardware's capabilities.
+
+Understanding these architectural details is crucial for several reasons. First, the MI300's dual register file system requires careful management of data movement between architectural and accumulation registers. Second, the extensive MFMA instruction family offers numerous variants optimized for different matrix dimensions and data types, requiring informed selection based on workload characteristics. Third, the hardware's native support for structured sparsity and novel data formats opens new optimization opportunities that don't exist on other platforms.
+
+## Matrix Arithmetic Architecture
+
+The cornerstone of MI300's compute capabilities lies in its revolutionary Matrix Arithmetic Instructions (MFMA), which represent a fundamental departure from traditional vector processing approaches. The MFMA subsystem is built around a dedicated Matrix Core unit that operates independently from the standard SIMD execution units, providing specialized hardware optimized for the matrix operations that dominate modern AI and scientific computing workloads.
+
+### Dual Register File Architecture
+
+The most distinctive aspect of MI300's matrix architecture is its implementation of dual register files. Unlike conventional GPU architectures that utilize a single, unified register file, MI300 maintains separate Architectural VGPRs (Arch VGPRs) and Accumulation VGPRs (AccVGPRs). This architectural decision enables several critical optimizations that directly impact kernel performance.
+
+The Architectural VGPRs serve as the primary register file for standard vector operations and data movement, maintaining compatibility with existing shader instruction sets. These registers handle input data preparation, intermediate computations, and results that don't require matrix-specific processing. In contrast, the AccVGPRs are exclusively dedicated to matrix operations, providing optimized storage and access patterns for matrix data that remains within the matrix computation pipeline.
+
+Data movement between these register files occurs through explicit V_ACCVGPR_READ and V_ACCVGPR_WRITE instructions, giving developers precise control over when and how matrix data transitions between different processing domains. This explicit model requires careful planning but enables sophisticated optimization strategies, such as keeping frequently accessed matrix data resident in AccVGPRs while using Arch VGPRs for auxiliary computations.
+
+The separation also enables concurrent operations, where standard vector instructions can execute on Arch VGPRs while matrix operations proceed on AccVGPRs, effectively increasing the overall computational throughput when workloads can be appropriately decomposed. This parallelism is particularly valuable in complex kernels that combine matrix operations with element-wise processing, memory management, or control flow logic.
+
+### Fundamental Matrix Operations
+
+The Matrix Core unit's fundamental computational primitive is the 4×1 × 1×4 outer product operation, which produces 16 output values in a single operation. This design choice reflects careful analysis of common matrix operation patterns in AI workloads, where outer products serve as building blocks for larger matrix multiplications. By optimizing the hardware for this specific operation size, AMD achieved an optimal balance between hardware complexity and computational efficiency.
+
+The outer product primitive supports both dense and structured sparse inputs, with the sparse variant implementing 4:2 structured sparsity where exactly two out of every four values along the reduction dimension are zero. This flexibility allows the same hardware to efficiently process both dense matrices common in fully-connected layers and sparse matrices increasingly used in modern neural network architectures for improved efficiency.
+
+MFMA instructions combine multiple outer product operations, both in parallel and in series, to implement larger matrix operations. For example, a 32×32×1 MFMA instruction orchestrates 64 parallel 4×1 × 1×4 outer products to compute the full result matrix. This hierarchical approach enables the hardware to scale efficiently across different matrix sizes while maintaining optimal utilization of the underlying computational units.
+
+### MFMA Instruction Variants
+
+The MI300 provides an extensive family of MFMA instructions, each optimized for specific matrix dimensions and data types. The instruction naming convention follows the pattern V_MFMA_[output_type]_[M]X[N]X[K][_[B]B]_[input_type], where M, N, and K represent the matrix dimensions, B indicates the number of matrix blocks processed simultaneously, and the type specifications define the precision of inputs and outputs.
+
+For single-precision floating-point operations, the V_MFMA_F32_*_F32 family provides options ranging from small 4×4×1 matrices processed in 16-block batches to large 32×32×2 single-block operations. The 4×4×1_16B variant completes in just 8 cycles while processing 16 separate matrix operations, making it ideal for scenarios with many small matrices. Conversely, the 32×32×2 variant requires 64 cycles but processes much larger matrices, optimizing for scenarios with fewer, larger computational blocks.
+
+Half-precision operations through the V_MFMA_F32_*_F16 family offer increased throughput by processing more data per instruction. The 32×32×8 variant can process matrices with 8 elements along the K dimension in 32 cycles, effectively doubling the computational density compared to single-precision variants. This capability is particularly valuable for inference workloads where the reduced precision of FP16 is acceptable.
+
+The integer instruction family V_MFMA_I32_*_I8 targets quantized neural network workloads, processing 8-bit integer inputs to produce 32-bit integer outputs. These instructions implement the multiply-accumulate pattern common in quantized inference, where 8-bit weights and activations are multiplied and accumulated into higher-precision results to prevent overflow.
+
+Double-precision support through V_MFMA_F64_*_F64 instructions addresses scientific computing workloads that require maximum numerical precision. While these instructions have lower throughput due to the increased data size and computational complexity, they provide essential capabilities for applications where numerical accuracy is paramount.
+
+### Broadcasting and Data Permutation
+
+MFMA instructions support sophisticated broadcasting and data permutation capabilities that enable efficient implementation of various matrix operation patterns. The CBSZ (Broadcast Size) field controls how data is broadcast within matrix blocks, allowing a single input value to be used across multiple matrix elements. This capability is essential for implementing operations like matrix-vector multiplication or bias addition where one operand has reduced dimensionality.
+
+The ABID (Broadcast ID) field specifies which block should serve as the source for broadcasting operations when multiple blocks are processed simultaneously. This feature enables efficient implementation of operations where one matrix operand is shared across multiple independent matrix operations, reducing memory bandwidth requirements and improving cache efficiency.
+
+The BLGP (Lane Group Permutation) field provides eight different permutation patterns that control how data is distributed across the 64 lanes of a wavefront. These permutations enable efficient mapping of various matrix layouts to the hardware's execution model, allowing developers to optimize data organization for specific access patterns. The permutations include no broadcast, broadcasting from different 32-lane or 16-lane groups, and rotation operations that shift data across lanes.
+
+For double-precision MFMA instructions, the BLGP field serves a different purpose, controlling the implicit negation of input matrices A, B, and C. This repurposing reflects the different optimization priorities for double-precision operations, where numerical precision often takes precedence over complex data permutation patterns.
+
+## Advanced Data Format Support
+
+MI300's support for advanced data formats represents one of its most significant differentiators from competing architectures. The hardware provides native support for emerging 8-bit floating-point formats that are becoming increasingly important in AI workloads, along with sophisticated conversion and rounding capabilities that enable efficient mixed-precision computing.
+
+### FP8 and BF8 Formats
+
+The introduction of 8-bit floating-point formats addresses the growing demand for efficient AI inference while maintaining acceptable numerical accuracy. MI300 supports two distinct 8-bit formats: FP8 (E4M3) and BF8 (E5M2), each optimized for different use cases and numerical requirements.
+
+FP8 (E4M3) utilizes a 4-bit exponent and 3-bit mantissa configuration with a bias of 8, providing a dynamic range suitable for many neural network activation patterns. Notably, FP8 does not support infinity or NaN representations, instead using the maximum representable value to indicate overflow conditions. This design choice reflects the format's optimization for inference workloads where such special values are rarely encountered and the simplified handling can improve performance.
+
+The format's range extends from ±2^(-10) for the smallest denormalized values to 240 for the maximum normalized values, with a minimum normalized value of ±2^(-7). This range covers the typical activation distributions found in many neural network layers, making FP8 particularly suitable for activation storage and computation in inference scenarios.
+
+BF8 (E5M2) employs a 5-bit exponent and 2-bit mantissa with a bias of 16, providing a different trade-off between range and precision. The extended exponent range allows BF8 to represent much larger values, with a maximum of 57,344 compared to FP8's 240. BF8 also supports infinity representations, making it more suitable for scenarios where numerical robustness is important.
+
+The mantissa precision in BF8 is reduced compared to FP8, but the extended range makes it particularly suitable for weight storage in neural networks, where the distribution of values often spans a wider range than activations. The minimum denormalized value is 2^(-17), and the minimum normalized value is ±2^(-15), providing coverage for very small weight values that might be important for model accuracy.
+
+### Conversion and Rounding Operations
+
+MI300 provides comprehensive conversion capabilities between different precision formats, with particular attention to the rounding modes that can significantly impact numerical accuracy in iterative computations. The CVT_PK_FP8_F32 and CVT_PK_BF8_F32 instructions convert pairs of 32-bit floating-point values to packed 8-bit formats, enabling efficient data compression for storage and transmission.
+
+These conversion instructions support standard IEEE rounding modes and provide control over input modifications through absolute value and negation operations. The Op_Sel[3] field controls various aspects of the conversion process, allowing fine-tuned control over how the conversion handles edge cases and precision loss.
+
+The CVT_SR_FP8_F32 instruction introduces stochastic rounding, a technique that has gained attention in machine learning research for its ability to maintain numerical accuracy during training with reduced precision. Instead of always rounding to the nearest representable value, stochastic rounding probabilistically chooses between the two nearest values based on the fractional part of the original value. This approach helps prevent systematic bias that can accumulate during iterative training processes.
+
+Stochastic rounding requires a random number source, which is provided through the second operand of the CVT_SR_FP8_F32 instruction. The Op_Sel[3:2] field controls various aspects of the stochastic rounding process, including how the random bits are interpreted and applied. This capability enables MI300 to support cutting-edge training techniques that rely on stochastic quantization for maintaining model quality while reducing computational and memory requirements.
+
+### Configuration Requirements
+
+Proper utilization of FP8 and BF8 formats requires specific hardware configuration to ensure correct operation. The SH_MEM_CONFIG register's bit[8] must be set to 1 to enable the correct behavior for BF8 and FP8 operations. This configuration bit affects various aspects of the floating-point processing pipeline, ensuring that the specialized handling required for these formats is properly enabled.
+
+The configuration also affects how overflow and underflow conditions are handled during conversions. When FP16_OVFL is set to 1, values that exceed the representable range of the target format are clamped to the maximum representable value rather than being converted to infinity or NaN. This behavior is often preferred in AI workloads where maintaining finite values is more important than preserving the mathematical properties of IEEE floating-point arithmetic.
+
+The interaction between these configuration settings and the various MFMA instructions creates a complex optimization space where developers must carefully balance numerical accuracy, performance, and memory efficiency. Understanding these trade-offs is crucial for developing kernels that effectively leverage the advanced data format capabilities of MI300.
+
+## Sparse Matrix Acceleration
+
+MI300's hardware support for structured sparse matrices represents a significant advancement in accelerating the sparse neural networks that are becoming increasingly important for efficient AI deployment. The V_SMFMAC (Sparse Matrix Fused Multiply-ACcumulate) instruction family provides native hardware acceleration for 4:2 structured sparsity, enabling significant performance improvements for appropriately structured workloads.
+
+### 4:2 Structured Sparsity Pattern
+
+The 4:2 structured sparsity pattern requires that exactly two out of every four consecutive elements along the matrix K-dimension are zero. This constraint might initially seem restrictive, but it provides several important advantages that make it practical for many AI workloads. The regular structure enables efficient hardware implementation while still providing substantial memory and computational savings compared to dense operations.
+
+The sparsity pattern is enforced at the granularity of groups of four elements, meaning that within each group of four consecutive values along the reduction dimension, exactly two positions must contain zeros. The positions of the non-zero elements can vary between groups, providing flexibility in representing various sparsity patterns that arise naturally in neural networks or can be induced through structured pruning techniques.
+
+This structured approach contrasts with unstructured sparsity, where zeros can appear at arbitrary positions. While unstructured sparsity can achieve higher compression ratios, it requires complex indexing schemes and irregular memory access patterns that are difficult to accelerate efficiently in hardware. The 4:2 structure provides a sweet spot between compression efficiency and hardware implementation complexity.
+
+The 2:1 compression ratio achieved by 4:2 sparsity is significant in practical applications. For large neural networks, this compression translates directly to reduced memory bandwidth requirements, smaller model storage, and improved cache efficiency. When combined with the computational savings from skipping zero multiplications, the overall performance improvement can be substantial for workloads that can be structured to match this sparsity pattern.
+
+### Index Encoding and Reconstruction
+
+The sparse matrix representation uses a compact index encoding scheme where pairs of 2-bit values indicate which two positions within each group of four contain non-zero values. This encoding requires only 4 bits to represent the sparsity pattern for each group of four elements, resulting in minimal overhead for the index information.
+
+The index values are stored in separate VGPRs from the non-zero data values, allowing the hardware to process the sparsity pattern and data values through different pathways optimized for their respective characteristics. The index processing logic reconstructs the full matrix structure by inserting zeros at the appropriate positions based on the encoded pattern, enabling the matrix multiplication hardware to operate on the reconstructed dense representation.
+
+This reconstruction process occurs transparently within the hardware, meaning that software developers work with the compressed representation while the execution units operate on appropriately structured data. The hardware manages the complexity of coordinating between the sparse data, index information, and dense operands to produce correct results.
+
+The index encoding supports all possible combinations of two non-zero positions within groups of four, providing complete flexibility in representing any 4:2 sparse pattern. The encoding is designed to be efficiently processed by the hardware's index reconstruction logic, minimizing the overhead associated with sparse processing.
+
+### SMFMAC Instruction Characteristics
+
+The V_SMFMAC instructions implement accumulate-style operations where the output matrix serves as both an input (for accumulation) and the destination for results. This design pattern is common in neural network computations where results are accumulated across multiple matrix operations, such as in attention mechanisms or recurrent neural network implementations.
+
+The instruction format repurposes the C operand input field to hold the index data offset, reflecting the different data flow requirements of sparse operations compared to dense MFMA instructions. This design choice enables efficient encoding while maintaining consistency with the overall instruction format architecture.
+
+Only the A matrix can be sparse in SMFMAC operations; the B and C matrices must be dense. This limitation reflects both hardware complexity considerations and the common usage patterns in neural networks, where weight matrices (typically the A operand) are often sparse while activation matrices (typically the B operand) remain dense.
+
+The performance characteristics of SMFMAC instructions depend heavily on the actual sparsity pattern and data layout. When the sparsity pattern is well-matched to the hardware's expectations and the data is properly organized in memory, SMFMAC operations can provide substantial performance improvements over equivalent dense operations. However, poorly organized sparse data or sparsity patterns that don't align well with the 4:2 structure can result in performance degradation compared to dense alternatives.
+
+## Memory Hierarchy and Operations
+
+MI300's memory hierarchy incorporates several unique features that distinguish it from both previous AMD architectures and competing solutions. Understanding these features is crucial for developing high-performance kernels that effectively utilize the available memory bandwidth and minimize latency through optimal data placement and access patterns.
+
+### Local Data Share (LDS) Architecture
+
+The Local Data Share (LDS) serves as MI300's implementation of fast on-chip shared memory, providing high-bandwidth, low-latency storage that can be shared among all threads within a workgroup. The LDS architecture in MI300 includes several enhancements and unique characteristics that impact kernel design and optimization strategies.
+
+LDS memory is organized as a banked structure that enables concurrent access from multiple threads when accesses target different banks. The banking scheme is designed to support common access patterns found in matrix operations and data sharing scenarios, but developers must understand the banking rules to avoid conflicts that can serialize memory accesses and reduce performance.
+
+The DS_* instruction family provides comprehensive support for LDS operations, including standard loads and stores as well as atomic operations that enable sophisticated synchronization and data sharing patterns. The atomic operations include support for various data types and operation modes, including compare-and-swap operations that enable lock-free algorithms and advanced synchronization primitives.
+
+One unique capability of MI300's LDS implementation is the support for direct loading from global memory buffers to LDS without intermediate storage in VGPRs. The BUFFER_LOAD_* instructions can specify LDS as the destination, enabling efficient data staging operations that bypass the register file. This capability is particularly valuable for kernels that need to load large amounts of data into shared memory for subsequent processing by multiple threads.
+
+The LDS address calculation follows the pattern CalcDsAddr(ADDR, OFFSET0, OFFSET1), where multiple offset components can be combined to support complex addressing patterns. This flexibility enables efficient implementation of multi-dimensional array accesses and other complex data structures that are common in scientific computing and AI workloads.
+
+### Global Wave Sync (GWS) Capabilities
+
+Global Wave Sync represents a unique synchronization primitive that enables coordination between different workgroups executing on the same compute unit. This capability extends beyond the traditional shared memory model where synchronization is limited to threads within a single workgroup, enabling new algorithmic approaches that can improve efficiency for certain classes of problems.
+
+GWS operations use similar instruction patterns to LDS operations but operate at a different scope, allowing workgroups to coordinate their execution and share intermediate results. This capability is particularly valuable for algorithms that have global dependencies or require coordination across large numbers of threads that exceed the capacity of a single workgroup.
+
+The implementation of GWS requires careful consideration of memory consistency and ordering guarantees, as operations that span multiple workgroups must maintain coherent views of shared data. The hardware provides appropriate synchronization mechanisms to ensure that GWS operations complete in a well-defined order and that all participants observe consistent results.
+
+Applications that can effectively utilize GWS include certain types of reductions, prefix scans, and other collective operations where the natural decomposition exceeds workgroup boundaries. However, the use of GWS requires careful algorithm design to ensure that the synchronization overhead doesn't outweigh the benefits of the increased parallelism.
+
+### Buffer Memory Operations
+
+MI300's buffer memory operations provide flexible and efficient mechanisms for accessing global memory through the MUBUF (Memory Untyped Buffer) instruction family. These instructions support various addressing modes and data formats that enable efficient implementation of common memory access patterns found in compute kernels.
+
+Buffer addressing combines multiple components including base addresses, indices, offsets, and strides to support complex data layouts. The addressing calculation can incorporate thread IDs automatically, enabling efficient implementation of per-thread data access patterns without requiring explicit address computation in the kernel code.
+
+The buffer resource descriptor provides comprehensive control over memory access behavior, including stride information, bounds checking, and cache control policies. The stride field supports up to 18 bits for certain instruction types, enabling efficient access to large data structures with regular layouts.
+
+Swizzling support in buffer operations enables optimized memory access patterns that can improve cache efficiency and reduce bank conflicts. The swizzling parameters control how linear addresses are mapped to physical memory locations, allowing developers to optimize for specific access patterns that are common in their workloads.
+
+The buffer operations also support direct loading to LDS memory, as mentioned previously, which enables efficient data staging operations. This capability is particularly valuable for kernels that implement tiling strategies where data is loaded into shared memory for processing by multiple threads.
+
+## Register Architecture and Management
+
+MI300's register architecture presents unique challenges and opportunities that significantly impact kernel performance and resource utilization. The combination of scalar and vector registers, along with the specialized accumulation registers for matrix operations, requires careful management to achieve optimal performance.
+
+### Scalar General Purpose Registers (SGPRs)
+
+SGPRs serve as the primary storage for scalar values, addresses, and control information that is shared across all threads in a wavefront. MI300 provides 102 SGPRs (SGPR0 through SGPR101) plus several special-purpose registers that serve specific architectural functions.
+
+The most significant constraint on SGPR usage is the limitation that at most one SGPR can be read per VALU (Vector ALU) instruction. This restriction requires careful instruction scheduling and register allocation to avoid pipeline stalls. When multiple SGPR values are needed for a single operation, they must be loaded in separate instructions or combined through scalar operations before being used in vector computations.
+
+SGPR alignment requirements are strict for multi-word operations. 64-bit operations require even-aligned SGPR pairs, while larger operations require alignment to multiples of four. These alignment constraints must be considered during register allocation to avoid wasted register space and ensure efficient instruction encoding.
+
+The special-purpose registers include VCC (Vector Condition Code), EXEC (Execution mask), M0 (Memory descriptor), and various trap and system registers. These registers serve specific architectural functions and have unique usage patterns that must be understood for effective kernel development.
+
+VCC serves as the default destination for vector comparison operations and as a source for conditional operations. The 64-bit VCC register provides one bit per thread in the wavefront, enabling efficient implementation of conditional execution patterns.
+
+The EXEC register controls which threads in a wavefront are active for each instruction. Understanding EXEC mask management is crucial for implementing control flow and ensuring that inactive threads don't interfere with computation or memory operations.
+
+M0 serves as a memory descriptor register that provides addressing information for certain memory operations. Its usage is particularly important for LDS operations and other specialized memory access patterns.
+
+### Vector General Purpose Registers (VGPRs)
+
+VGPRs provide per-thread storage for vector operations, with each VGPR containing one value per thread in the 64-thread wavefront. The VGPR file is shared between standard vector operations and serves as the interface to the specialized AccVGPR file used for matrix operations.
+
+VGPR allocation and alignment follow similar rules to SGPRs, with even alignment required for 64-bit operations and higher alignment requirements for larger data types. The alignment requirements can impact register utilization efficiency, particularly in kernels that mix different data types or operation sizes.
+
+VGPR indexing provides dynamic access to the register file using the M0 register as an index. This capability enables implementation of algorithms that require indirect register access, such as certain types of data permutation or dynamic data structure access. However, indexed access typically has higher latency than direct register access and should be used judiciously.
+
+The interaction between VGPRs and AccVGPRs requires explicit management through V_ACCVGPR_READ and V_ACCVGPR_WRITE instructions. These data movement operations have specific latency and throughput characteristics that must be considered when scheduling matrix operations and other computations.
+
+### Accumulation Vector General Purpose Registers (AccVGPRs)
+
+AccVGPRs represent MI300's most distinctive register architecture feature, providing dedicated storage optimized for matrix operations. These registers are physically separate from the standard VGPR file and are accessed exclusively through matrix instructions and explicit data movement operations.
+
+The AccVGPR file is designed to support the data flow patterns common in matrix operations, with optimized connectivity to the matrix execution units. Data stored in AccVGPRs can remain resident across multiple matrix operations, enabling efficient implementation of complex matrix computations without intermediate transfers to the standard register file.
+
+AccVGPR allocation follows the same alignment rules as VGPRs, but the usage patterns are typically different due to the nature of matrix operations. Matrix instructions often require contiguous blocks of registers to store matrix data, leading to different optimization considerations compared to scalar or simple vector operations.
+
+The capacity and organization of the AccVGPR file impact the types of matrix operations that can be efficiently supported. Large matrix operations may require careful blocking and data movement strategies to fit within the available AccVGPR space while maintaining high utilization of the matrix execution units.
+
+Data movement between VGPRs and AccVGPRs introduces latency and throughput considerations that must be balanced against the benefits of keeping data in the specialized register file. Optimal kernel design requires understanding when to keep data in AccVGPRs versus when to move it to the standard register file for other operations.
+
+## Execution Model and Control Flow
+
+MI300's execution model builds upon the traditional SIMD (Single Instruction, Multiple Data) approach while incorporating enhancements that improve efficiency for modern compute workloads. Understanding the execution model is crucial for writing kernels that effectively utilize the hardware's capabilities while avoiding performance pitfalls.
+
+### Wavefront Execution Characteristics
+
+MI300 executes instructions using 64-thread wavefronts, where all active threads in a wavefront execute the same instruction simultaneously. This wavefront size represents a key architectural decision that impacts memory access patterns, synchronization requirements, and overall kernel design strategies.
+
+The 64-thread wavefront size affects memory coalescing requirements, as optimal memory access patterns must align with the 64-thread execution width. Memory operations that can be coalesced across all 64 threads achieve maximum bandwidth utilization, while non-coalesced accesses may result in multiple memory transactions and reduced performance.
+
+Thread divergence within a wavefront is handled through the EXEC mask, which controls which threads participate in each instruction. When threads follow different execution paths due to conditional branches, the hardware executes both paths sequentially while masking inactive threads. This approach ensures correctness but can reduce effective utilization when divergence is frequent or long-lasting.
+
+The wavefront execution model interacts with the memory hierarchy in important ways. LDS operations are shared across all threads in a workgroup, which may span multiple wavefronts. Understanding how wavefronts within a workgroup coordinate their LDS usage is important for avoiding conflicts and ensuring efficient data sharing.
+
+### Arbitrary Divergent Control Flow
+
+MI300 provides hardware support for arbitrary divergent control flow, enabling efficient execution of complex branching patterns that are common in many compute workloads. This capability goes beyond simple conditional execution to support nested loops, function calls, and other complex control structures.
+
+The hardware maintains a stack-based mechanism for tracking divergent execution paths, allowing threads within a wavefront to follow different control flow paths while maintaining the ability to reconverge when the paths merge. This approach provides flexibility for implementing complex algorithms while maintaining reasonable execution efficiency.
+
+The efficiency of divergent control flow depends on the specific branching patterns and the degree of divergence. When most threads follow the same path, the overhead is minimal. However, when threads frequently diverge into many different paths, the sequential execution of different paths can significantly reduce effective throughput.
+
+Kernel developers can optimize for divergent control flow by organizing algorithms to minimize divergence, using techniques such as data reorganization to group threads with similar execution paths, or restructuring algorithms to reduce the complexity of branching patterns.
+
+### Dependency Resolution and Scheduling
+
+MI300's instruction scheduling and dependency resolution mechanisms are designed to hide latency and maximize throughput for typical compute workloads. Understanding these mechanisms enables developers to write kernels that achieve high instruction-level parallelism and efficient resource utilization.
+
+Matrix operations have specific dependency requirements that must be satisfied to ensure correct execution. The hardware requires a certain number of independent instructions between the issuance of a matrix instruction and subsequent accesses to its results or modifications of its input registers. These dependency requirements are documented for each instruction type and must be carefully managed in hand-optimized kernels.
+
+Scalar memory operations use the LGKM_CNT counter to track outstanding memory requests and provide synchronization points for dependent operations. The counter is incremented when memory operations are issued and decremented when they complete, allowing software to determine when data is available for use.
+
+The S_WAITCNT instruction provides comprehensive synchronization capabilities with separate counters for different types of operations. Understanding how to use S_WAITCNT effectively is crucial for ensuring correct execution while minimizing unnecessary stalls that can reduce performance.
+
+## Performance Optimization Strategies
+
+Achieving optimal performance on MI300 requires understanding the unique characteristics of its architecture and applying optimization strategies that are specifically tailored to its capabilities. This section outlines key optimization approaches that can significantly impact kernel performance.
+
+### Matrix Operation Optimization
+
+Optimizing matrix operations on MI300 requires careful consideration of the MFMA instruction variants, data layout, and register management strategies. The choice of MFMA instruction should be based on the specific matrix dimensions, data types, and throughput requirements of the target workload.
+
+For workloads with many small matrices, using MFMA instructions with higher block counts (such as 4x4x1_16B) can provide better throughput by processing multiple independent operations simultaneously. Conversely, workloads with larger matrices may benefit from instructions that process larger matrix dimensions in fewer operations.
+
+Data layout optimization is crucial for achieving optimal memory bandwidth utilization. Matrix data should be organized to enable coalesced memory accesses across the 64-thread wavefront, and the layout should be compatible with the input and output patterns expected by the chosen MFMA instructions.
+
+AccVGPR management strategies can significantly impact performance by minimizing unnecessary data movement between register files. Keeping frequently accessed matrix data in AccVGPRs while using standard VGPRs for auxiliary computations can improve overall efficiency.
+
+The broadcasting and permutation capabilities of MFMA instructions can be leveraged to implement complex matrix operation patterns efficiently. Understanding how to use the CBSZ, ABID, and BLGP fields enables optimization of operations like matrix-vector multiplication, bias addition, and other common neural network primitives.
+
+### Memory Access Optimization
+
+Memory access optimization on MI300 requires understanding the memory hierarchy, cache behavior, and access pattern requirements for different types of operations. The goal is to maximize memory bandwidth utilization while minimizing latency through effective use of the memory hierarchy.
+
+LDS optimization involves understanding the banking structure and organizing data access patterns to avoid bank conflicts. Data should be laid out to enable concurrent access from multiple threads, and algorithms should be structured to take advantage of the high bandwidth and low latency characteristics of LDS memory.
+
+Global memory access optimization focuses on achieving coalesced access patterns that can be efficiently serviced by the memory system. The buffer addressing capabilities should be used to implement efficient strided access patterns, and cache control bits should be used to optimize cache behavior for specific access patterns.
+
+The direct LDS loading capability can be used to implement efficient data staging strategies where global memory data is loaded directly into LDS for subsequent processing. This approach can reduce register pressure and improve memory bandwidth utilization for certain types of algorithms.
+
+### Register Allocation and Management
+
+Effective register allocation on MI300 requires balancing the competing demands of different instruction types while respecting alignment requirements and usage constraints. The dual register file architecture adds complexity but also provides optimization opportunities when properly managed.
+
+SGPR allocation should minimize the number of different SGPRs accessed within individual VALU instructions to avoid violating the single-SGPR-read constraint. Scalar computations should be organized to pre-compute values that will be used multiple times in vector operations.
+
+VGPR allocation should consider the alignment requirements of different operation types and organize data to minimize wasted register space due to alignment padding. The allocation should also consider the data flow between standard vector operations and matrix operations that use AccVGPRs.
+
+AccVGPR allocation should focus on keeping frequently accessed matrix data resident while minimizing unnecessary data movement. The allocation strategy should consider the matrix dimensions and operation patterns to ensure efficient utilization of the specialized register file.
+
+### Instruction Scheduling and Latency Hiding
+
+Instruction scheduling on MI300 should focus on maximizing instruction-level parallelism while respecting dependency constraints and resource limitations. The goal is to keep all execution units busy while minimizing pipeline stalls and resource conflicts.
+
+Matrix instruction scheduling requires careful attention to the dependency requirements between matrix operations and other instruction types. The required number of independent instructions between dependent matrix operations must be maintained to ensure correct execution.
+
+Memory instruction scheduling should balance the need to issue memory operations early (to hide latency) with the need to avoid excessive resource consumption that could limit other operations. The LGKM_CNT counter should be monitored to ensure that memory operations complete in a timely manner.
+
+Mixed instruction scheduling involves coordinating between different instruction types (scalar, vector, matrix, memory) to achieve optimal overall throughput. Understanding the execution unit capabilities and resource requirements of different instruction types enables effective scheduling strategies.
+
+## Key Differences from NVIDIA Architectures
+
+Understanding the differences between MI300 and NVIDIA AI accelerators is crucial for developers who need to port kernels between platforms or optimize for specific architectural characteristics. This section highlights the most significant differences that impact kernel development and performance optimization.
+
+### Matrix Operation Architecture Differences
+
+The most fundamental difference lies in the matrix operation architecture. MI300's dual register file system with separate AccVGPRs contrasts sharply with NVIDIA's unified register file approach. This architectural difference requires different optimization strategies and affects how matrix data is managed throughout kernel execution.
+
+MI300's 4×1 × 1×4 outer product primitive differs from NVIDIA's typical 4×4 × 4×4 matrix operation building blocks. This difference affects how larger matrix operations are decomposed and can influence the optimal blocking strategies for different matrix sizes and shapes.
+
+The explicit data movement between register files in MI300 (via V_ACCVGPR_READ/WRITE) contrasts with NVIDIA's more implicit register management. This difference provides more control but requires more explicit management of data flow in kernel code.
+
+MFMA instruction variants in MI300 offer different trade-offs compared to NVIDIA's WMMA instructions. The extensive family of MFMA instructions provides more granular control over matrix dimensions and block counts, enabling fine-tuned optimization for specific workload characteristics.
+
+### Data Format and Precision Differences
+
+MI300's native support for FP8 and BF8 formats represents a significant advantage for certain AI workloads, particularly when these formats align well with the numerical requirements of the target application. The hardware support for stochastic rounding in FP8 conversions is particularly unique and valuable for training applications.
+
+The specific format definitions (E4M3 for FP8, E5M2 for BF8) may differ from NVIDIA's implementations, requiring careful attention to numerical behavior when porting applications between platforms. The range and precision characteristics of these formats can affect algorithm behavior and numerical stability.
+
+XF32 support in MI300 provides a middle ground between FP16 and FP32 that may not have direct equivalents in NVIDIA architectures. This format can be valuable for applications that need more precision than FP16 but can accept less than full FP32 precision.
+
+### Sparse Matrix Support Differences
+
+MI300's 4:2 structured sparsity support through V_SMFMAC instructions provides hardware acceleration for a specific sparsity pattern that may differ from NVIDIA's sparse matrix capabilities. The 4:2 pattern and its hardware implementation may be more or less suitable than NVIDIA's approaches depending on the specific sparsity characteristics of the target workload.
+
+The index encoding scheme and reconstruction process in MI300 may require different data preparation and layout strategies compared to NVIDIA's sparse matrix implementations. Understanding these differences is crucial for achieving optimal performance with sparse workloads.
+
+### Memory Hierarchy Differences
+
+The LDS implementation in MI300 may have different banking schemes, capacity, and access patterns compared to NVIDIA's shared memory. These differences can affect optimal data layout strategies and access pattern optimization.
+
+MI300's Global Wave Sync capability provides cross-workgroup synchronization primitives that may not have direct equivalents in NVIDIA architectures. This capability enables different algorithmic approaches that may be more or less suitable depending on the target application.
+
+Buffer memory operations and addressing modes in MI300 may differ from NVIDIA's global memory access patterns, requiring different optimization strategies for memory bandwidth utilization and cache efficiency.
+
+### Execution Model Differences
+
+The 64-thread wavefront size in MI300 contrasts with NVIDIA's 32-thread warp size, affecting memory coalescing requirements, synchronization patterns, and optimal workgroup organization strategies.
+
+Divergent control flow handling may differ between the architectures, with different performance characteristics for various branching patterns. Understanding these differences is important for optimizing kernels with complex control flow.
+
+The instruction scheduling and dependency resolution mechanisms may have different characteristics, requiring different approaches to instruction-level parallelism and latency hiding.
+
+## Best Practices for HIP Kernel Development
+
+Based on the architectural characteristics and optimization opportunities outlined in previous sections, this section provides concrete best practices for developing high-performance HIP kernels on MI300.
+
+### Matrix Operation Best Practices
+
+When implementing matrix operations, choose MFMA instruction variants based on the specific requirements of your workload. For applications with many small matrices, prefer higher block count variants (like 4x4x1_16B) to maximize throughput. For applications with larger matrices, use variants that process larger dimensions efficiently.
+
+Organize matrix data layout to align with the input and output patterns expected by your chosen MFMA instructions. Ensure that data can be loaded efficiently into the appropriate register files and that memory access patterns are coalesced across the wavefront.
+
+Minimize data movement between VGPRs and AccVGPRs by keeping frequently accessed matrix data in AccVGPRs when possible. Plan your algorithm to batch matrix operations and minimize the frequency of register file transfers.
+
+Leverage the broadcasting and permutation capabilities of MFMA instructions to implement complex operations efficiently. Use CBSZ for operations that require broadcasting within matrix blocks, and use BLGP to optimize data distribution patterns.
+
+### Memory Access Best Practices
+
+Design LDS usage patterns to avoid bank conflicts by organizing data layout and access patterns appropriately. Use the direct LDS loading capability to stage data efficiently from global memory when implementing tiling strategies.
+
+Optimize global memory access patterns for coalescing by ensuring that consecutive threads access consecutive memory locations when possible. Use the buffer addressing capabilities to implement efficient strided access patterns for multi-dimensional data structures.
+
+Use appropriate cache control bits (GLC, NV) to optimize cache behavior for your specific access patterns. Consider the temporal and spatial locality characteristics of your memory accesses when choosing cache policies.
+
+Plan memory access scheduling to hide latency by issuing memory operations early and overlapping them with computation when possible. Use S_WAITCNT appropriately to synchronize memory operations without introducing unnecessary stalls.
+
+### Register Management Best Practices
+
+Allocate SGPRs carefully to respect the single-SGPR-read constraint for VALU instructions. Pre-compute scalar values that will be used multiple times in vector operations, and organize scalar computations to minimize SGPR pressure.
+
+Plan VGPR allocation to respect alignment requirements while minimizing wasted register space. Consider the data flow between different operation types and organize register usage to support efficient data movement.
+
+Manage AccVGPR allocation to support your matrix operation patterns while minimizing unnecessary data movement. Consider the matrix dimensions and operation sequences when planning AccVGPR usage.
+
+Monitor overall register pressure to ensure that your kernel can achieve good occupancy. Balance register usage against other resource requirements to find the optimal operating point for your specific workload.
+
+### Performance Optimization Best Practices
+
+Profile your kernels to identify performance bottlenecks and optimization opportunities. Use appropriate profiling tools to understand instruction throughput, memory bandwidth utilization, and resource utilization characteristics.
+
+Optimize instruction scheduling to maximize instruction-level parallelism while respecting dependency constraints. Pay particular attention to matrix instruction dependencies and memory operation synchronization requirements.
+
+Consider algorithmic optimizations that can take advantage of MI300's unique capabilities, such as structured sparsity support or advanced data format capabilities. Evaluate whether algorithm modifications can improve performance by better matching the hardware characteristics.
+
+Validate numerical accuracy when using reduced precision formats or optimization techniques that may affect numerical behavior. Ensure that performance optimizations don't compromise the correctness or accuracy requirements of your application.
+
+## Conclusion
+
+The AMD Instinct MI300 CDNA3 architecture represents a significant advancement in compute acceleration, introducing unique features that require specialized knowledge for optimal utilization. The dual register file architecture, extensive MFMA instruction family, native support for emerging data formats, and hardware-accelerated structured sparsity create new optimization opportunities while requiring different approaches compared to traditional GPU architectures.
+
+Success in developing high-performance HIP kernels for MI300 requires understanding these architectural innovations and applying optimization strategies that are specifically tailored to the hardware's capabilities. The matrix arithmetic instructions provide powerful tools for accelerating AI and scientific computing workloads, but they require careful attention to data layout, register management, and instruction scheduling to achieve optimal performance.
+
+The advanced data format support enables efficient implementation of mixed-precision algorithms that can provide significant performance and memory efficiency improvements for appropriate workloads. The sparse matrix acceleration capabilities open new possibilities for deploying efficient neural network models that leverage structured sparsity for improved performance.
+
+Memory hierarchy optimization remains crucial, with the LDS and buffer memory systems providing high-performance data access capabilities when used appropriately. The unique features like Global Wave Sync and direct LDS loading enable algorithmic approaches that may not be possible or efficient on other architectures.
+
+As AI and scientific computing workloads continue to evolve, the architectural innovations in MI300 position it well for emerging requirements around efficiency, precision flexibility, and sparse computation. Developers who master these architectural features will be well-positioned to create high-performance applications that fully leverage the capabilities of this advanced compute platform.
+
+The investment in understanding MI300's unique characteristics pays dividends not only in immediate performance improvements but also in preparing for future architectural developments that will likely build upon these foundational innovations. The principles and techniques outlined in this guide provide a foundation for continued optimization and adaptation as both hardware and software ecosystems evolve.
+
+## References
+
+[1] AMD Instinct MI300 CDNA3 Instruction Set Architecture Reference Guide, Advanced Micro Devices, Inc., June 2025.
+
+[2] AMD GPUOpen Blog: AMD Lab Notes - Matrix Cores README, https://gpuopen.com/learn/amd-lab-notes/amd-lab-notes-matrix-cores-README/
+
+[3] AMD Matrix Instruction Calculator, RadeonOpenCompute, https://github.com/RadeonOpenCompute/amd_matrix_instruction_calculator
+
diff --git a/kernel-agentic/docs/hip/AMD MI300 HIP Kernel Programming Guide_ CDNA3 Architecture Insights.md b/kernel-agentic/docs/hip/AMD MI300 HIP Kernel Programming Guide_ CDNA3 Architecture Insights.md
new file mode 100644
index 0000000..35ed08a
--- /dev/null
+++ b/kernel-agentic/docs/hip/AMD MI300 HIP Kernel Programming Guide_ CDNA3 Architecture Insights.md	
@@ -0,0 +1,331 @@
+# AMD MI300 HIP Kernel Programming Guide: CDNA3 Architecture Insights
+
+
+## Executive Summary
+
+The AMD CDNA3 architecture, embodied in the MI300 series accelerators, represents a paradigmatic shift in GPU design philosophy that fundamentally impacts how high-performance HIP kernels should be written and optimized. Unlike traditional monolithic GPU designs, CDNA3 embraces a heterogeneous chiplet architecture that introduces unique programming considerations, memory hierarchy optimizations, and performance characteristics that differ significantly from NVIDIA's AI accelerators.
+
+This guide synthesizes critical architectural insights from the AMD CDNA3 white paper to provide large language models and developers with the specialized knowledge necessary to generate high-quality HIP kernels optimized for MI300 hardware. The focus is on architectural features that are either unique to AMD or implemented differently from NVIDIA solutions, as general GPU programming concepts are assumed to be well-understood.
+
+The MI300 series introduces revolutionary concepts including memory-side caching through AMD Infinity Cache, 2:4 structured sparsity support, novel data types like TF32 and OCP-compliant FP8, and a relaxed memory coherency model that requires explicit synchronization. These features, combined with the chiplet-based design and enhanced matrix processing capabilities, create both opportunities and challenges for kernel optimization that are distinct from CUDA programming paradigms.
+
+
+
+
+## 1. CDNA3 Architecture Overview: Chiplet-Based Design Implications
+
+The AMD CDNA3 architecture fundamentally departs from traditional monolithic GPU designs by implementing a heterogeneous chiplet approach that has profound implications for kernel programming and optimization strategies. Understanding this architectural foundation is crucial for writing efficient HIP kernels that can fully exploit the hardware capabilities.
+
+### 1.1 Heterogeneous Chiplet Organization
+
+The MI300 series processors are constructed using up to 8 Accelerator Complex Dies (XCDs) and 4 I/O Dies (IODs), each fabricated on different process nodes and optimized for specific functions. The XCDs, manufactured on TSMC's 5nm process, contain the computational elements and lower-level cache hierarchy, while the IODs, built on TSMC's 6nm process, house the memory controllers, AMD Infinity Cache, and system interconnects. This separation allows for specialized optimization of each component while enabling vertical 3D stacking through advanced packaging technologies.
+
+Each XCD contains exactly 40 Compute Units (CUs), with 38 active units and 2 disabled for yield management purposes. This yields a total of 304 active CUs across the full MI300X configuration, representing approximately 40% more computational resources than the previous generation MI250X. The consistent 38-CU configuration per XCD creates predictable resource allocation patterns that kernel developers can exploit for load balancing and work distribution strategies.
+
+The chiplet design introduces unique considerations for memory access patterns and inter-CU communication. Unlike monolithic designs where all CUs share uniform access to memory controllers, the CDNA3 architecture creates a hierarchical access pattern where CUs within the same XCD have lower latency access to the local L2 cache, while cross-XCD communication must traverse the AMD Infinity Fabric network. This architectural characteristic suggests that kernel designs should prioritize data locality within XCD boundaries when possible, and carefully consider the cost of cross-XCD data sharing.
+
+### 1.2 Asynchronous Compute Engine Architecture
+
+Each XCD incorporates 4 Asynchronous Compute Engines (ACEs) that serve as the primary work distribution mechanism for compute shader workgroups. Each ACE is nominally associated with 40 CUs, though the actual active count is 38 due to yield management. This 4-ACE configuration provides fine-grained control over work distribution and enables sophisticated load balancing strategies that can adapt to varying computational workloads.
+
+The ACE architecture differs significantly from NVIDIA's GigaThread Engine approach by providing multiple independent scheduling domains within each XCD. This design enables better isolation between concurrent kernels and can reduce scheduling overhead for workloads that can be effectively partitioned across the available ACEs. Kernel developers should consider designing workgroup distributions that align with the 4-ACE structure to minimize scheduling conflicts and maximize throughput.
+
+The hardware scheduler (HWS) coordinates work distribution across all ACEs and manages the hardware queues (HQDO-7) that feed work to the compute accelerators. Understanding this scheduling hierarchy is important for optimizing kernel launch patterns and minimizing dispatch overhead, particularly for workloads that involve frequent kernel launches or complex dependency chains.
+
+### 1.3 Compute Unit Internal Architecture
+
+The CDNA3 Compute Units represent a comprehensive redesign that doubles or quadruples performance per CU for vector and matrix workloads compared to the previous generation. Each CU functions as a complete, highly threaded parallel processor core that includes instruction fetching and scheduling, execution units for scalar, vector, and matrix operations, and load/store pipelines with integrated L1 cache and Local Data Share (LDS).
+
+A critical architectural innovation is the shared 64KB instruction cache between pairs of CUs, which doubles the capacity from the previous generation while maintaining nearly constant die area. This design exploits the common pattern where adjacent CUs execute identical instruction streams, effectively increasing the cacheable instruction window and improving hit rates. Kernel developers should be aware that instruction cache efficiency is maximized when neighboring CUs execute similar code paths, suggesting that workgroup assignment strategies should consider instruction locality alongside data locality.
+
+The enhanced source caching mechanism provides improved register reuse and bandwidth amplification, allowing each vector register read to support multiple downstream vector or matrix operations. This architectural feature rewards kernel designs that maximize register reuse and minimize redundant memory accesses, particularly for computationally intensive operations where the same data elements are used across multiple computational stages.
+
+
+## 2. Memory Hierarchy and Caching Strategy: The Infinity Cache Revolution
+
+The CDNA3 memory hierarchy represents one of the most significant departures from conventional GPU memory systems and introduces programming considerations that are fundamentally different from NVIDIA architectures. Understanding these differences is crucial for optimizing memory access patterns and achieving peak performance in HIP kernels.
+
+### 2.1 Three-Tier Cache Hierarchy with Memory-Side Caching
+
+The CDNA3 architecture implements a unique three-tier cache hierarchy consisting of L1 vector data cache, L2 cache, and the revolutionary AMD Infinity Cache. This design differs markedly from traditional two-tier GPU cache hierarchies and introduces novel optimization opportunities that kernel developers must understand to achieve optimal performance.
+
+The L1 vector data cache has been substantially enhanced with a doubled cache line size of 128 bytes and doubled capacity to 32KB per CU. This larger cache line size is particularly beneficial for streaming workloads and vectorized operations that access contiguous memory regions. The increased line size also doubles the bandwidth between the L1 cache and the core, providing improved data delivery rates for bandwidth-intensive kernels. However, the larger cache lines also mean that memory access patterns with poor spatial locality may suffer from increased cache pollution, making careful attention to data layout and access patterns even more critical.
+
+The L2 cache serves as a 4MB, 16-way set-associative cache shared by all 38 CUs within an XCD. The L2 is organized into 16 parallel channels of 256KB each, enabling massive parallelism with the ability to sustain four requests from different CUs per cycle. This design provides a combined throughput of 2KB per clock per XCD, with aggregate read bandwidth across all XCDs reaching up to 34.4 TB/s. The L2 cache plays a critical role as the lowest level where hardware coherency is automatically maintained, making it the boundary between coherent and non-coherent memory operations.
+
+### 2.2 AMD Infinity Cache: Memory-Side Cache Innovation
+
+The AMD Infinity Cache represents a paradigm shift in GPU cache design, implementing a memory-side cache architecture that fundamentally differs from traditional cache hierarchies. Unlike conventional caches that can hold dirty data evicted from lower levels, the Infinity Cache is designed as a shared memory-side cache that exclusively caches the contents of memory and cannot hold dirty data.
+
+This design choice provides two significant advantages that impact kernel programming strategies. First, the Infinity Cache does not participate in coherency protocols and does not need to handle snoop traffic, which significantly improves efficiency and reduces latency for coherency operations from lower-level caches. Second, the cache can hold nominally uncacheable memory such as I/O buffers, providing performance benefits for kernels that work with mixed data types or perform I/O operations alongside computation.
+
+The Infinity Cache is organized around 128 parallel channels across 8 HBM stacks, with each channel being 64 bytes wide and connected to 2MB of data arrays. The total capacity of 256MB provides substantial caching capability, while the peak bandwidth of 17.2 TB/s approaches the aggregate bandwidth of previous generation L2 caches. This massive bandwidth makes the Infinity Cache particularly effective for workloads with good temporal locality but poor spatial locality, as it can efficiently serve repeated accesses to scattered memory locations.
+
+### 2.3 Relaxed Coherency Model and Synchronization Requirements
+
+A critical difference from NVIDIA architectures is the CDNA3's relaxed coherency model, which requires explicit synchronization to provide strong coherency and ordering guarantees. The L1 vector data cache operates with very relaxed coherency semantics, meaning that kernel developers must explicitly manage cache coherency through appropriate synchronization primitives and memory fence operations.
+
+This relaxed coherency model provides performance benefits by eliminating the overhead of automatic coherency maintenance, but it places additional responsibility on kernel developers to ensure correct memory ordering. Kernels that share data between workgroups or that require specific memory ordering semantics must use explicit synchronization operations such as memory fences, atomic operations, or barrier synchronization to ensure correctness.
+
+The coherency boundary at the L2 cache level means that operations within a single XCD can rely on hardware-maintained coherency, while operations that span multiple XCDs require explicit synchronization. This architectural characteristic suggests that kernel designs should minimize cross-XCD data sharing when possible, or carefully structure such sharing to use appropriate synchronization mechanisms.
+
+### 2.4 HBM3/HBM3E Memory Interface Optimization
+
+The CDNA3 architecture upgrades to HBM3 for MI300X and MI300A products, and HBM3E for MI325X, providing substantial memory capacity and bandwidth improvements. The MI300X provides 192GB of HBM3 memory with 5.3 TB/s peak bandwidth, while the MI325X offers 256GB of HBM3E with 6.0 TB/s peak bandwidth. These specifications represent significant improvements over previous generations and enable new classes of memory-intensive applications.
+
+The memory controllers are distributed across the IODs and operate at 5.2 Gbps for HBM3 and 6.0 Gbps for HBM3E. Each IOD manages two HBM stacks, creating a distributed memory architecture that can provide excellent bandwidth utilization when memory accesses are properly distributed across all stacks. Kernel developers should consider memory access patterns that can effectively utilize all available memory controllers to achieve peak bandwidth utilization.
+
+The channel-based organization extends from the L2 cache through the Infinity Cache to the HBM interface, with each HBM stack associated with 16 parallel channels. This consistent channel organization provides predictable performance characteristics and enables sophisticated memory access optimization strategies that can align data placement with the underlying hardware organization.
+
+
+## 3. Matrix Core Technology and Advanced Data Type Support
+
+The CDNA3 Matrix Cores represent a substantial evolution in specialized compute capabilities, introducing new data types and computational paradigms that are specifically optimized for modern AI and machine learning workloads. Understanding these capabilities and their optimal usage patterns is essential for developing high-performance HIP kernels for AI applications.
+
+### 3.1 Enhanced Matrix Core Architecture
+
+The Matrix Cores in CDNA3 have been comprehensively redesigned to provide dramatic performance improvements across all supported data types. The architecture delivers generational improvements ranging from 1.7x for FP64 operations to 6.8x for INT8 operations compared to the previous CDNA2 generation. These improvements are achieved through a combination of increased parallelism, enhanced data path widths, and optimized instruction scheduling.
+
+Each Compute Unit contains integrated Matrix Core functionality that can execute matrix operations in parallel with vector operations, enabling sophisticated kernel designs that can overlap different types of computation. The Matrix Cores support a wide range of data types with varying throughput characteristics, allowing kernel developers to choose the optimal precision for their specific workload requirements while maximizing computational throughput.
+
+The peak theoretical performance for matrix operations reaches impressive levels: 163.4 TFLOP/s for FP32 matrix operations, 1,307.4 TFLOP/s for FP16/BF16 operations, and an extraordinary 2,614.9 TFLOP/s for FP8 operations on the MI300X. These performance levels represent substantial improvements over previous generations and enable new classes of computationally intensive applications that were previously impractical.
+
+### 3.2 Novel Data Type Support: TF32 and FP8
+
+The CDNA3 architecture introduces support for two critical new data types that are becoming increasingly important in modern AI workloads: TF32 and FP8. These data types provide different trade-offs between precision, performance, and memory efficiency, enabling kernel developers to optimize for specific application requirements.
+
+TF32 is a 19-bit hybrid data format that combines the 10-bit mantissa precision of FP16 with the 8-bit exponent range of BF16, plus a sign bit. Despite its name suggesting a 32-bit format, TF32 is actually more compact while providing a precision and range combination that can effectively replace FP32 in most machine learning applications without accuracy degradation. The Matrix Cores provide full-rate support for TF32 operations at 1,024 FLOPS per clock per CU, offering a compelling balance between performance and precision for training workloads that require higher precision than FP16 but don't need full FP32 precision.
+
+FP8 support follows the OCP 8-bit Floating Point Specification, providing two variants optimized for different use cases. The E5M2 variant, with a 5-bit exponent and 2-bit mantissa, is optimized for training workloads where the extended range is more important than mantissa precision. The E4M3 variant, with a 4-bit exponent and 3-bit mantissa, is optimized for inference workloads where mantissa precision is more critical than extended range. The Matrix Cores can achieve 4,096 operations per clock per CU for FP8 operations, representing 16x the throughput of FP32 operations while using only 1/4 the memory bandwidth.
+
+### 3.3 Structured Sparsity Support and 2:4 Sparse Operations
+
+One of the most innovative features of the CDNA3 Matrix Cores is native support for structured sparsity, specifically the 2:4 sparse pattern where at least two values within every group of four input values are zero. This sparsity support is available for matrix operations using INT8, FP8, FP16, and BF16 data types, enabling up to double the computational throughput for workloads that can exploit this sparsity pattern.
+
+The sparse matrix support is implemented through a compact representation where non-zero data is stored in dense form with additional metadata tracking the locations of zero values. This approach allows the dense representation to fit directly into the Matrix Core pipeline while enabling the hardware to skip computations involving zero values. When the sparsity requirements are met, the Matrix Cores can achieve up to 8,000 operations per clock per CU, representing a substantial performance improvement for compatible workloads.
+
+The 2:4 sparsity pattern is particularly well-suited to many neural network architectures, especially attention mechanisms in transformer-based models and convolution-based networks. Kernel developers working with these types of models should consider whether their data can be structured to exploit this sparsity support, as the performance benefits can be substantial. However, it's important to note that the sparsity must be structured in the specific 2:4 pattern to be exploitable by the hardware.
+
+### 3.4 Matrix Core Programming Considerations
+
+Effective utilization of the Matrix Cores requires careful attention to data layout, operation scheduling, and memory access patterns. The Matrix Cores are designed to work most efficiently with data that is properly aligned and organized to match the hardware's internal data paths. Kernel developers should ensure that matrix data is laid out in memory with appropriate alignment and that matrix dimensions are chosen to maximize hardware utilization.
+
+The integration of Matrix Cores within the Compute Units enables sophisticated kernel designs that can overlap matrix operations with vector operations and memory accesses. This capability allows for the development of fused kernels that can perform complex operations without intermediate memory round-trips, potentially providing significant performance improvements for workloads that can exploit this parallelism.
+
+Memory bandwidth considerations are particularly important when working with the Matrix Cores, as the high computational throughput can quickly become memory-bound if data access patterns are not optimized. The enhanced cache hierarchy, including the Infinity Cache, can help mitigate memory bandwidth limitations for workloads with good temporal locality, but kernel developers must still carefully consider data reuse patterns and memory access optimization.
+
+### 3.5 Performance Optimization Strategies
+
+Achieving optimal performance with the Matrix Cores requires a holistic approach that considers data types, sparsity patterns, memory access patterns, and operation scheduling. Kernel developers should start by selecting the most appropriate data type for their precision requirements, considering the substantial performance benefits available with lower-precision formats when accuracy requirements permit.
+
+For workloads that can exploit sparsity, restructuring data to match the 2:4 sparse pattern can provide dramatic performance improvements. This may require preprocessing steps to identify and reorganize sparse data, but the computational benefits can justify this overhead for many applications. The sparse support is particularly valuable for inference workloads where the sparsity patterns can be determined offline and optimized for the specific hardware capabilities.
+
+Memory access optimization becomes even more critical when working with the high-throughput Matrix Cores. Kernel designs should prioritize data reuse, minimize memory round-trips, and structure memory accesses to take advantage of the cache hierarchy. The large cache line sizes and substantial cache capacities in CDNA3 can provide significant benefits for workloads that can maintain good spatial and temporal locality.
+
+
+## 4. Key Differences from NVIDIA AI Accelerators
+
+Understanding the fundamental differences between AMD CDNA3 and NVIDIA AI accelerators is crucial for developers transitioning between platforms or optimizing kernels for cross-platform compatibility. These differences span architectural philosophy, memory systems, programming models, and performance characteristics.
+
+### 4.1 Architectural Philosophy: Chiplets vs. Monolithic Design
+
+The most fundamental difference between CDNA3 and NVIDIA architectures lies in the basic design philosophy. NVIDIA's H100 and A100 accelerators follow a monolithic die approach where all computational and memory control functions are integrated onto a single large die. This design provides uniform access patterns and simplified programming models but is limited by the maximum practical die size and manufacturing yield considerations.
+
+In contrast, CDNA3 embraces a heterogeneous chiplet architecture that separates computational functions (XCDs) from memory and I/O functions (IODs). This approach enables specialized optimization of each chiplet type and allows for more flexible scaling through the addition of more chiplets. However, it also introduces hierarchical access patterns and requires more sophisticated programming strategies to achieve optimal performance.
+
+The chiplet approach provides several advantages that impact kernel programming. The ability to disable individual CUs for yield management (2 per XCD) provides more predictable performance characteristics compared to monolithic designs where yield issues might affect larger functional blocks. The separation of compute and memory functions also enables independent optimization of each subsystem, potentially providing better performance for specific workload types.
+
+### 4.2 Memory Hierarchy Differences: Memory-Side Cache vs. Traditional Caching
+
+The memory hierarchy represents one of the most significant differences between CDNA3 and NVIDIA architectures. NVIDIA accelerators typically implement a traditional two-level cache hierarchy (L1 and L2) with write-through L1 caches and hardware-managed coherency. This approach provides predictable behavior and simplified programming models but may not be optimal for all workload types.
+
+CDNA3's three-tier hierarchy with the memory-side Infinity Cache introduces novel optimization opportunities that don't exist in NVIDIA architectures. The memory-side cache design means that the Infinity Cache can hold data that would be uncacheable in traditional architectures, such as I/O buffers or streaming data. This capability can provide significant performance benefits for kernels that work with mixed data types or perform complex memory access patterns.
+
+The relaxed coherency model in CDNA3 contrasts sharply with NVIDIA's hardware-managed coherency. While NVIDIA's approach simplifies programming by automatically maintaining cache coherency, it also introduces overhead that may not be necessary for all workloads. CDNA3's explicit synchronization requirements provide more control over coherency operations but require more sophisticated programming to ensure correctness.
+
+### 4.3 Compute Unit Organization and Scheduling Differences
+
+The organization of computational resources differs significantly between the two architectures. NVIDIA's Streaming Multiprocessors (SMs) typically contain 64-128 CUDA cores along with specialized Tensor Cores, with a single GigaThread Engine managing work distribution across all SMs. This centralized scheduling approach provides good load balancing but may introduce bottlenecks for certain workload types.
+
+CDNA3's approach with 4 Asynchronous Compute Engines per XCD provides more distributed scheduling and can offer better isolation between concurrent workloads. Each ACE manages a subset of the available CUs, enabling more fine-grained control over work distribution and potentially reducing scheduling overhead for workloads that can be effectively partitioned.
+
+The shared instruction cache between pairs of CUs in CDNA3 is another unique feature that doesn't have a direct equivalent in NVIDIA architectures. This design can provide significant benefits for workloads where adjacent CUs execute similar instruction streams, but it also requires careful consideration of workgroup assignment strategies to maximize cache efficiency.
+
+### 4.4 Data Type and Precision Support Variations
+
+While both architectures support a range of data types for AI workloads, there are important differences in implementation and performance characteristics. NVIDIA's Tensor Cores have evolved through multiple generations with different capabilities, and the specific data types and operations supported can vary significantly between different GPU models.
+
+CDNA3's support for TF32 as a native data type represents a unique approach to balancing precision and performance. While NVIDIA accelerators can perform TF32 operations, the implementation details and performance characteristics may differ. The OCP-compliant FP8 support in CDNA3 also follows industry standards that may not be directly compatible with NVIDIA's FP8 implementations.
+
+The structured sparsity support in CDNA3 follows the 2:4 pattern that is also supported by NVIDIA architectures, but the implementation details and performance characteristics can differ significantly. Kernel developers need to understand these differences to optimize sparsity exploitation for each platform.
+
+### 4.5 Programming Model and Software Stack Differences
+
+The programming model differences between HIP and CUDA represent both opportunities and challenges for kernel developers. HIP is designed to provide CUDA-like syntax while enabling cross-platform compatibility, but there are subtle differences in semantics and capabilities that can impact kernel performance and correctness.
+
+The ROCm software stack's open-source nature provides greater visibility into the underlying implementation compared to NVIDIA's closed-source approach. This transparency can enable more sophisticated optimization strategies but also requires developers to have a deeper understanding of the software stack internals.
+
+Memory management approaches also differ between the platforms. NVIDIA's Unified Memory system provides automatic data migration between CPU and GPU memory spaces, while AMD's approach typically requires more explicit memory management. The MI300A APU variant provides true unified memory that eliminates the need for data copies, but this capability is unique to the APU configuration.
+
+### 4.6 Virtualization and Multi-Tenancy Approaches
+
+The virtualization capabilities of CDNA3 and NVIDIA architectures follow different philosophies that impact how kernels can be deployed in multi-tenant environments. NVIDIA's Multi-Instance GPU (MIG) technology provides fixed partition sizes with strong isolation guarantees, but limited flexibility in partition configuration.
+
+CDNA3's spatial partitioning approach based on XCDs provides more flexible partition sizes and can be combined with NUMA memory partitioning for sophisticated resource allocation strategies. The SR-IOV support also provides hardware-level isolation that can be valuable for certain deployment scenarios.
+
+These virtualization differences can impact kernel design strategies, particularly for applications that need to run in multi-tenant environments or that require specific resource allocation patterns. Understanding the capabilities and limitations of each approach is important for developing kernels that can effectively utilize the available hardware resources.
+
+### 4.7 Interconnect and Scaling Characteristics
+
+The interconnect technologies used for multi-GPU scaling also differ between the platforms. NVIDIA's NVLink technology has evolved through multiple generations with varying bandwidth and topology capabilities, while AMD's Infinity Fabric provides a different approach to inter-GPU communication.
+
+The fully connected 8-GPU topologies enabled by CDNA3's Infinity Fabric can provide advantages for certain communication patterns, particularly all-reduce and all-gather operations that are common in distributed machine learning workloads. However, the specific performance characteristics and optimal usage patterns can differ from NVIDIA's NVLink-based solutions.
+
+Understanding these interconnect differences is crucial for developing kernels that will be used in multi-GPU configurations, as the optimal communication strategies and data distribution patterns can vary significantly between platforms.
+
+
+## 5. HIP Kernel Programming Best Practices for CDNA3
+
+Developing high-performance HIP kernels for CDNA3 requires understanding the unique architectural characteristics and optimizing for the specific capabilities and constraints of the platform. This section provides concrete guidance for kernel developers to achieve optimal performance on MI300 hardware.
+
+### 5.1 Memory Access Pattern Optimization
+
+The CDNA3 memory hierarchy with its three-tier cache system and relaxed coherency model requires careful attention to memory access patterns. The doubled cache line size of 128 bytes means that kernels should be designed to maximize spatial locality within these larger cache lines. Sequential memory accesses that can fill entire cache lines will achieve better bandwidth utilization than scattered access patterns.
+
+The memory-side Infinity Cache provides unique optimization opportunities that don't exist in traditional GPU architectures. Kernels that can maintain good temporal locality across large working sets can benefit significantly from the 256MB cache capacity and 17.2 TB/s bandwidth. This is particularly valuable for iterative algorithms or kernels that process the same data multiple times with different operations.
+
+The relaxed coherency model requires explicit synchronization for cross-workgroup communication or when specific memory ordering is required. Kernel developers should use appropriate memory fence operations, atomic operations, or barrier synchronization to ensure correctness. The coherency boundary at the L2 cache level means that operations within a single XCD can rely on hardware coherency, while cross-XCD operations require explicit synchronization.
+
+### 5.2 Workgroup and Thread Block Organization
+
+The 4-ACE architecture within each XCD suggests that workgroup organization should consider the scheduling hierarchy to minimize conflicts and maximize throughput. Workgroups should be sized and distributed to enable effective utilization of all available ACEs while maintaining good load balance across the 38 active CUs per XCD.
+
+The shared instruction cache between pairs of CUs rewards kernel designs where adjacent CUs execute similar instruction streams. This suggests that workgroup assignment strategies should consider instruction locality alongside data locality. Kernels with divergent control flow should be structured to minimize the impact on instruction cache efficiency.
+
+The Local Data Share (LDS) remains at 64KB per CU, consistent with previous generations. Effective utilization of LDS for data sharing between threads within a workgroup can reduce memory traffic and improve performance. The enhanced L1 cache capacity and bandwidth can also reduce the pressure on LDS for certain access patterns.
+
+### 5.3 Matrix Core Utilization Strategies
+
+Achieving optimal performance with the Matrix Cores requires careful attention to data layout, operation scheduling, and precision selection. Matrix data should be organized in memory with appropriate alignment to match the hardware's internal data paths. The specific alignment requirements may vary depending on the data type and operation being performed.
+
+The integration of Matrix Cores within the Compute Units enables sophisticated kernel designs that can overlap matrix operations with vector operations and memory accesses. Kernels should be structured to take advantage of this parallelism by organizing computations to minimize dependencies and enable concurrent execution of different operation types.
+
+Data type selection can have dramatic performance implications. FP8 operations can achieve 16x the throughput of FP32 operations while using only 1/4 the memory bandwidth. TF32 provides a good balance between precision and performance for many applications. Kernel developers should carefully evaluate their precision requirements and select the most appropriate data type to maximize performance.
+
+### 5.4 Sparsity Exploitation Techniques
+
+The 2:4 structured sparsity support in the Matrix Cores can provide up to 2x performance improvements for compatible workloads. However, exploiting this capability requires that data be structured in the specific 2:4 pattern where at least two values in every group of four are zero. This may require preprocessing steps to identify and reorganize sparse data.
+
+Kernels that work with naturally sparse data, such as attention mechanisms in transformer models or certain types of convolution operations, should be evaluated for sparsity exploitation potential. The performance benefits can be substantial, but the overhead of data reorganization must be considered in the overall performance analysis.
+
+The sparse support is available for INT8, FP8, FP16, and BF16 data types, providing flexibility in precision selection while maintaining sparsity benefits. Kernel developers should consider whether lower precision formats can be used to enable both sparsity and precision optimizations simultaneously.
+
+### 5.5 Cross-Platform Compatibility Considerations
+
+When developing kernels that need to run on both AMD and NVIDIA platforms, careful attention to programming model differences is essential. While HIP provides CUDA-like syntax, there are semantic differences that can impact performance and correctness. Memory management approaches, synchronization semantics, and performance characteristics can all differ between platforms.
+
+The relaxed coherency model in CDNA3 may require additional synchronization compared to NVIDIA platforms with hardware-managed coherency. Kernels should be designed with explicit synchronization that ensures correctness on both platforms, even if some synchronization operations may be redundant on certain platforms.
+
+Data type support and performance characteristics can vary significantly between platforms. Kernels should be designed with fallback strategies for data types or features that may not be available on all target platforms. Performance tuning may need to be platform-specific to achieve optimal results on each architecture.
+
+### 5.6 Debugging and Profiling Strategies
+
+The ROCm software stack provides comprehensive debugging and profiling tools that can help identify performance bottlenecks and correctness issues. The open-source nature of the stack provides greater visibility into the underlying implementation compared to closed-source alternatives, enabling more sophisticated debugging strategies.
+
+Memory access pattern analysis is particularly important for CDNA3 kernels due to the complex cache hierarchy and relaxed coherency model. Profiling tools can help identify cache miss patterns, memory bandwidth utilization, and synchronization overhead that may not be apparent from source code analysis alone.
+
+The chiplet architecture can introduce performance variations that may not be present in monolithic designs. Profiling should consider the distribution of work across XCDs and the impact of cross-XCD communication on overall performance. Load balancing strategies may need to be adjusted based on profiling results to achieve optimal performance.
+
+### 5.7 Performance Tuning and Optimization Workflow
+
+Developing high-performance CDNA3 kernels requires an iterative optimization workflow that considers the unique architectural characteristics. Initial kernel development should focus on correctness and basic functionality, followed by systematic optimization of memory access patterns, compute utilization, and synchronization overhead.
+
+Memory hierarchy optimization should be prioritized early in the development process, as the three-tier cache system can have significant impact on performance. Cache-friendly data layouts and access patterns should be established before focusing on computational optimizations.
+
+Matrix Core utilization should be evaluated for any kernels that perform matrix or tensor operations. The substantial performance benefits available through optimal Matrix Core usage can justify significant restructuring of computational algorithms to take advantage of these capabilities.
+
+The iterative nature of performance optimization means that profiling and measurement should be integrated throughout the development process. Performance characteristics can change significantly as kernels are optimized, and continuous measurement ensures that optimizations are providing the expected benefits.
+
+
+## 6. Technical Specifications and Performance Characteristics
+
+### 6.1 MI300 Series Specifications Comparison
+
+| Specification | MI300A APU | MI300X GPU | MI325X GPU |
+|---------------|------------|------------|------------|
+| **Architecture** | AMD CDNA 3 | AMD CDNA 3 | AMD CDNA 3 |
+| **Accelerator Complex Dies (XCD)** | 6 | 8 | 8 |
+| **Active Compute Units** | 228 | 304 | 304 |
+| **Stream Processors** | 14,592 | 19,456 | 19,456 |
+| **Matrix Cores** | 912 | 1,216 | 1,216 |
+| **Max Engine Clock** | 2,100 MHz | 2,100 MHz | 2,100 MHz |
+| **CPU Cores (Zen 4)** | 24 | N/A | N/A |
+| **Memory Capacity** | 128GB HBM3 | 192GB HBM3 | 256GB HBM3E |
+| **Memory Bandwidth** | 5.3 TB/s | 5.3 TB/s | 6.0 TB/s |
+| **Memory Interface** | 1024-bit x 8 | 1024-bit x 8 | 1024-bit x 8 |
+| **L1 Cache per CU** | 32KB | 32KB | 32KB |
+| **L2 Cache per XCD** | 4MB | 4MB | 4MB |
+| **Infinity Cache Total** | 256MB | 256MB | 256MB |
+
+### 6.2 Matrix Core Performance Characteristics
+
+| Data Type | Operations per Clock per CU | MI300X Peak Performance | MI325X Peak Performance | Generational Improvement |
+|-----------|----------------------------|------------------------|------------------------|-------------------------|
+| **FP64 Matrix** | 256 | 163.4 TFLOP/s | 163.4 TFLOP/s | 1.7x |
+| **FP32 Matrix** | 256 | 163.4 TFLOP/s | 163.4 TFLOP/s | 1.7x |
+| **TF32 Matrix** | 1,024 | 653.7 TFLOP/s | 653.7 TFLOP/s | New |
+| **FP16 Matrix** | 2,048 | 1,307.4 TFLOP/s | 1,307.4 TFLOP/s | 3.4x |
+| **BF16 Matrix** | 2,048 | 1,307.4 TFLOP/s | 1,307.4 TFLOP/s | 3.4x |
+| **FP8 Matrix** | 4,096 | 2,614.9 TFLOP/s | 2,614.9 TFLOP/s | New |
+| **INT8 Matrix** | 4,096 | 2,614.9 TOPs | 2,614.9 TOPs | 6.8x |
+| **Sparse (2:4) Performance** | Up to 8,192 | Up to 5,229.8 TFLOP/s | Up to 5,229.8 TFLOP/s | 2x with sparsity |
+
+### 6.3 Memory Hierarchy Performance Characteristics
+
+| Memory Level | Capacity | Bandwidth | Latency Characteristics | Key Features |
+|--------------|----------|-----------|------------------------|--------------|
+| **L1 Vector Cache** | 32KB per CU | 2KB/clock per CU | Lowest latency | 128-byte cache lines, relaxed coherency |
+| **L2 Cache** | 4MB per XCD | 2KB/clock per XCD | Low latency | 16-way associative, coherency boundary |
+| **Infinity Cache** | 256MB total | 17.2 TB/s aggregate | Medium latency | Memory-side cache, no dirty data |
+| **HBM3/HBM3E** | 192-256GB | 5.3-6.0 TB/s | Highest latency | 8 stacks, 128 channels total |
+
+## 7. Conclusion and Future Considerations
+
+The AMD CDNA3 architecture represents a fundamental shift in GPU design philosophy that introduces both opportunities and challenges for HIP kernel developers. The heterogeneous chiplet approach, revolutionary memory hierarchy with Infinity Cache, and advanced Matrix Core capabilities provide substantial performance potential for applications that can effectively exploit these architectural innovations.
+
+### 7.1 Key Takeaways for Kernel Developers
+
+The most critical insight for kernel developers is that CDNA3 requires a different optimization mindset compared to traditional GPU architectures. The memory-side Infinity Cache, relaxed coherency model, and chiplet-based organization create optimization opportunities that don't exist in monolithic designs, but they also require more sophisticated programming strategies to achieve optimal performance.
+
+The Matrix Core enhancements, particularly the support for TF32 and FP8 data types along with structured sparsity, provide dramatic performance improvements for AI workloads. However, achieving these benefits requires careful attention to data layout, precision selection, and sparsity structuring that may require significant algorithmic modifications.
+
+The three-tier cache hierarchy with its unique characteristics demands careful consideration of memory access patterns and explicit synchronization strategies. Kernel developers must understand the coherency boundaries and design their algorithms to work effectively within the relaxed coherency model while taking advantage of the substantial cache bandwidth and capacity.
+
+### 7.2 Architectural Advantages and Unique Capabilities
+
+The CDNA3 architecture provides several unique advantages that distinguish it from competing solutions. The memory-side Infinity Cache design enables caching of data types that would be uncacheable in traditional architectures, potentially providing performance benefits for complex workloads with mixed data types. The chiplet approach enables more flexible scaling and specialized optimization of different functional units.
+
+The unified memory capability in the MI300A APU represents a particularly compelling advantage for certain workload types, eliminating the overhead of host-device data transfers and enabling new programming paradigms that can exploit true CPU-GPU memory sharing. This capability is unique in the current market and provides opportunities for innovative algorithm designs.
+
+The open-source ROCm software stack provides transparency and customization opportunities that are not available with closed-source alternatives. This openness enables more sophisticated optimization strategies and provides developers with greater control over the software stack behavior.
+
+### 7.3 Challenges and Considerations
+
+The complexity of the CDNA3 architecture also introduces challenges that kernel developers must navigate. The relaxed coherency model requires more explicit synchronization management, which can increase development complexity and the potential for subtle correctness issues. The chiplet-based design creates hierarchical access patterns that must be understood and optimized for optimal performance.
+
+Cross-platform compatibility considerations become more complex when targeting both AMD and NVIDIA platforms, as the architectural differences require platform-specific optimization strategies. Kernel developers must balance the benefits of platform-specific optimizations against the complexity of maintaining multiple code paths.
+
+### 7.4 Future Evolution and Ecosystem Development
+
+The CDNA3 architecture represents a significant step forward in GPU design, but it also establishes a foundation for future evolution. The chiplet approach provides a scalable framework for adding new capabilities and increasing computational resources in future generations. The software ecosystem around ROCm and HIP continues to mature, providing increasingly sophisticated tools and libraries for kernel development.
+
+The industry trend toward lower precision data types and structured sparsity is well-supported by CDNA3's capabilities, positioning it well for future AI workload evolution. The architectural innovations in memory hierarchy and compute organization provide a foundation for continued performance improvements as manufacturing processes and packaging technologies advance.
+
+Understanding and effectively utilizing the CDNA3 architecture requires a comprehensive approach that considers the unique architectural characteristics, programming model differences, and optimization opportunities. Kernel developers who invest in understanding these aspects will be well-positioned to achieve exceptional performance on MI300 hardware and contribute to the continued evolution of the AMD GPU computing ecosystem.
+
+The architectural innovations in CDNA3 represent more than incremental improvements; they constitute a new paradigm for GPU design that will likely influence future developments across the industry. Kernel developers who master these concepts will be prepared not only for current MI300 optimization but also for the continued evolution of heterogeneous computing architectures.
+
+---
+
+*This guide represents a comprehensive analysis of the AMD CDNA3 architecture based on official documentation and technical specifications. Kernel developers should consult the latest ROCm documentation and AMD developer resources for the most current programming guidelines and optimization recommendations.*
+
diff --git a/kernel-agentic/docs/hip/HIP Kernel Programming Guide for MI300_ Key Differences from NVIDIA AI Chips.md b/kernel-agentic/docs/hip/HIP Kernel Programming Guide for MI300_ Key Differences from NVIDIA AI Chips.md
new file mode 100644
index 0000000..9905d70
--- /dev/null
+++ b/kernel-agentic/docs/hip/HIP Kernel Programming Guide for MI300_ Key Differences from NVIDIA AI Chips.md	
@@ -0,0 +1,433 @@
+# HIP Kernel Programming Guide for MI300: Key Differences from NVIDIA AI Chips
+
+
+## Abstract
+
+This document provides a comprehensive guide for writing high-quality HIP kernels specifically optimized for AMD MI300 accelerators. It focuses on the unique architectural features and programming considerations that differ from NVIDIA AI chips, enabling developers to leverage the full potential of AMD's CDNA architecture. The guide covers essential topics including wavefront execution models, memory hierarchy optimization, matrix acceleration units, and performance tuning strategies specific to MI300 hardware.
+
+## Table of Contents
+
+1. [Introduction](#introduction)
+2. [Architecture Overview](#architecture-overview)
+3. [Wavefront vs Warp Execution Model](#wavefront-vs-warp-execution-model)
+4. [Memory Hierarchy and Access Patterns](#memory-hierarchy-and-access-patterns)
+5. [CDNA Matrix Acceleration Units](#cdna-matrix-acceleration-units)
+6. [Synchronization and Atomic Operations](#synchronization-and-atomic-operations)
+7. [Compiler Directives and Architecture Detection](#compiler-directives-and-architecture-detection)
+8. [Performance Optimization Strategies](#performance-optimization-strategies)
+9. [Debugging and Profiling](#debugging-and-profiling)
+10. [Best Practices Summary](#best-practices-summary)
+11. [References](#references)
+
+## Introduction
+
+The AMD MI300 series represents a significant advancement in accelerated computing, featuring the CDNA3 architecture specifically designed for high-performance computing and artificial intelligence workloads. Unlike NVIDIA's CUDA-based AI chips, MI300 accelerators utilize AMD's HIP (Heterogeneous-compute Interface for Portability) programming model, which provides both portability and performance optimization opportunities unique to AMD's hardware architecture.
+
+Understanding the fundamental differences between AMD's CDNA architecture and NVIDIA's GPU architectures is crucial for developers seeking to maximize performance on MI300 systems. This guide focuses on the less commonly known aspects of HIP programming that are specific to AMD hardware, particularly those features that distinguish MI300 from NVIDIA AI chips in terms of execution models, memory systems, and optimization strategies.
+
+The MI300 architecture introduces several key innovations including enhanced matrix acceleration units, optimized memory hierarchies, and unique wavefront execution patterns that require specific programming approaches to achieve optimal performance. These architectural differences necessitate a deep understanding of HIP-specific programming techniques that go beyond general GPU programming knowledge.
+
+
+
+## Architecture Overview
+
+### CDNA3 Compute Unit Structure
+
+The MI300 series is built on AMD's CDNA3 architecture, which represents a fundamental departure from traditional GPU designs optimized primarily for graphics workloads. The CDNA (Compute DNA) architecture is purpose-built for compute-intensive applications, particularly those involving machine learning, scientific computing, and data analytics.
+
+Each CDNA3 compute unit (CU) contains several key components that distinguish it from NVIDIA's streaming multiprocessors (SMs). The most significant architectural difference lies in the inclusion of dedicated matrix acceleration units alongside traditional vector arithmetic logic units (VALUs). This hybrid approach allows MI300 to excel at both traditional parallel computing tasks and modern AI workloads that heavily utilize matrix operations.
+
+The compute unit structure includes four Single Instruction Multiple Data (SIMD) units, each capable of executing 16 operations per cycle. This design choice directly impacts the wavefront size, which is typically 64 threads on AMD hardware compared to NVIDIA's 32-thread warps. The larger wavefront size can provide better memory bandwidth utilization and improved occupancy for memory-bound kernels, but requires careful consideration of control flow divergence patterns.
+
+### Memory Hierarchy Differences
+
+The CDNA3 memory hierarchy introduces several unique features that differentiate it from NVIDIA architectures. The local data share (LDS) serves as the equivalent to NVIDIA's shared memory but with distinct performance characteristics and access patterns. The LDS provides high-bandwidth, low-latency storage accessible to all threads within a workgroup, with a capacity that varies by specific MI300 model but typically exceeds comparable NVIDIA offerings.
+
+The vector cache system in CDNA3 operates differently from NVIDIA's L1 cache, with specific optimizations for coalesced memory access patterns common in HPC and AI workloads. Understanding these differences is crucial for optimizing memory access patterns and achieving peak performance on MI300 hardware.
+
+### Shader Engine Organization
+
+MI300 accelerators organize compute units into shader engines, which serve as the primary scheduling and resource management units. Each shader engine contains multiple compute units and shares certain fixed-function resources, including memory controllers and cache hierarchies. This organization affects how workloads are distributed across the device and influences optimal kernel launch configurations.
+
+The shader engine design also impacts the effectiveness of different synchronization strategies and inter-workgroup communication patterns. Developers must consider shader engine boundaries when designing algorithms that require coordination between different parts of the computation.
+
+
+## Wavefront vs Warp Execution Model
+
+### Fundamental Execution Differences
+
+The most critical difference between AMD's HIP and NVIDIA's CUDA lies in the basic execution unit size. While NVIDIA GPUs execute threads in groups of 32 (warps), AMD GPUs traditionally use wavefronts of 64 threads. This difference has profound implications for kernel design, memory access patterns, and performance optimization strategies.
+
+On MI300 and other CDNA architectures, the wavefront size remains 64 threads, which means that the SIMD units execute instructions for 64 threads simultaneously. This larger execution group can provide several advantages, including better memory bandwidth utilization when accessing contiguous memory regions and improved arithmetic intensity for compute-bound kernels.
+
+However, the larger wavefront size also introduces unique challenges. Control flow divergence within a wavefront can be more costly than in NVIDIA's smaller warps, as more threads may be masked out during conditional execution. Developers must carefully structure conditional code to minimize divergence within 64-thread boundaries rather than the 32-thread boundaries familiar to CUDA programmers.
+
+### Wavefront Scheduling and Occupancy
+
+The wavefront scheduling mechanism on MI300 differs significantly from NVIDIA's warp scheduling. Each compute unit can accommodate multiple wavefronts simultaneously, with the exact number depending on register usage and local data share consumption. The larger wavefront size means that each wavefront consumes more resources, potentially reducing the total number of concurrent wavefronts per compute unit.
+
+Occupancy calculations for AMD hardware must account for the 64-thread wavefront size when determining optimal block sizes and resource usage. A kernel that achieves high occupancy on NVIDIA hardware with 32-thread warps may require adjustment to achieve similar occupancy on AMD hardware with 64-thread wavefronts.
+
+The wavefront scheduler prioritizes ready wavefronts based on instruction availability and resource constraints. Understanding this scheduling behavior is crucial for optimizing instruction-level parallelism and hiding memory latency through effective wavefront interleaving.
+
+### RDNA Dual-Mode Execution
+
+While MI300 primarily uses CDNA architecture, it's important to note that some AMD GPUs support dual-mode execution where wavefronts can operate in either 32-thread or 64-thread modes. This flexibility, primarily found in RDNA architectures, allows for better compatibility with code originally designed for NVIDIA hardware while maintaining the performance benefits of larger wavefronts when appropriate.
+
+For MI300 specifically, the CDNA3 architecture maintains the traditional 64-thread wavefront size, providing consistency and predictability for HPC and AI workloads. This design choice reflects AMD's focus on compute performance over graphics compatibility in the CDNA product line.
+
+### Programming Implications
+
+When writing kernels for MI300, developers must consider the wavefront size in several key areas. Thread block dimensions should be chosen to align with 64-thread boundaries to maximize hardware utilization. Memory access patterns should be designed to take advantage of the larger wavefront size for improved coalescing efficiency.
+
+Reduction operations and other collective algorithms must be adapted for 64-thread wavefronts rather than 32-thread warps. HIP provides wavefront-aware intrinsics and functions that automatically adapt to the hardware's native wavefront size, but understanding the underlying execution model is essential for optimal performance.
+
+The larger wavefront size also affects shared memory usage patterns and synchronization requirements. Algorithms that rely on fine-grained synchronization within small thread groups may need restructuring to work efficiently with 64-thread wavefronts.
+
+
+## Memory Hierarchy and Access Patterns
+
+### Local Data Share (LDS) Optimization
+
+The Local Data Share (LDS) in CDNA3 architecture serves as the primary on-chip memory for inter-thread communication within a workgroup, analogous to NVIDIA's shared memory but with distinct characteristics. The LDS on MI300 provides high bandwidth and low latency access, but its optimal usage patterns differ from NVIDIA shared memory due to architectural differences in banking and access scheduling.
+
+LDS memory is organized into banks that can be accessed simultaneously by different threads within a wavefront. However, the banking structure and conflict resolution mechanisms differ from NVIDIA's implementation. Bank conflicts occur when multiple threads within a wavefront attempt to access the same bank simultaneously, leading to serialized access and reduced throughput.
+
+To optimize LDS usage on MI300, developers should structure data layouts to minimize bank conflicts while maximizing memory bandwidth utilization. This often involves careful consideration of stride patterns and data alignment, particularly when implementing algorithms that require frequent data sharing between threads.
+
+The LDS capacity on MI300 varies by specific model but generally provides substantial on-chip storage for complex algorithms. Effective utilization of this capacity can significantly reduce global memory traffic and improve overall kernel performance, particularly for algorithms with high data reuse patterns.
+
+### Global Memory Access Optimization
+
+Global memory access patterns on MI300 require specific optimization strategies that differ from NVIDIA hardware. The memory controllers and cache hierarchy are optimized for different access patterns, with particular emphasis on supporting the larger wavefront size and the specific memory access patterns common in HPC and AI workloads.
+
+Coalesced memory access remains crucial for performance, but the definition of optimal coalescing differs due to the 64-thread wavefront size. Memory transactions are optimized for 64-thread access patterns rather than 32-thread patterns, which can affect the optimal stride and alignment requirements for peak memory bandwidth.
+
+The vector cache system in CDNA3 provides automatic caching of global memory accesses, but its effectiveness depends on access locality and pattern predictability. Understanding the cache line sizes and replacement policies can help developers structure memory access patterns to maximize cache hit rates and minimize memory latency.
+
+### Memory Coalescing Strategies
+
+Effective memory coalescing on MI300 requires understanding the relationship between wavefront execution and memory transaction generation. With 64-thread wavefronts, the memory system can generate larger, more efficient transactions when threads access contiguous memory regions.
+
+The optimal memory access pattern involves having consecutive threads within a wavefront access consecutive memory locations. This pattern allows the memory controller to combine multiple thread requests into fewer, larger memory transactions, maximizing memory bandwidth utilization.
+
+When perfect coalescing is not possible due to algorithm constraints, developers should strive to minimize the number of memory transactions required per wavefront. This may involve restructuring data layouts, using appropriate data types, or implementing software-managed caching strategies using LDS memory.
+
+### Cache Hierarchy Utilization
+
+The CDNA3 cache hierarchy includes multiple levels of caching, each optimized for different access patterns and data types. The L0 vector cache provides the fastest access to recently used data, while higher-level caches provide larger capacity with slightly increased latency.
+
+Understanding the cache hierarchy is crucial for optimizing algorithms with complex memory access patterns. Temporal locality can be exploited by structuring algorithms to reuse data within cache-friendly time windows, while spatial locality can be improved by organizing data structures to maximize cache line utilization.
+
+The cache replacement policies and associativity characteristics of MI300 caches are optimized for compute workloads rather than graphics workloads, which can affect the optimal strategies for data management and algorithm structuring.
+
+### Texture and Surface Memory
+
+While less commonly used in compute kernels, texture and surface memory on MI300 provide specialized access patterns and data filtering capabilities that can be beneficial for certain algorithms. These memory types offer hardware-accelerated interpolation and boundary handling, which can be particularly useful for image processing and scientific computing applications.
+
+The texture cache hierarchy on CDNA3 is optimized for 2D spatial locality, making it effective for algorithms that exhibit spatial access patterns. Understanding when and how to use texture memory can provide performance benefits for appropriate workloads, particularly those involving regular grid-based computations.
+
+
+## CDNA Matrix Acceleration Units
+
+### Matrix Core Architecture
+
+One of the most significant differentiators of the CDNA3 architecture in MI300 is the inclusion of dedicated matrix acceleration units, also known as Matrix Cores or MFMA (Matrix Fused Multiply-Add) units. These specialized processing units are designed specifically for the matrix operations that dominate modern AI and machine learning workloads, providing substantial performance advantages over traditional vector arithmetic units for these operations.
+
+The Matrix Cores in MI300 support multiple data types including FP32, FP16, BF16, and INT8, allowing for flexible precision trade-offs based on application requirements. Each Matrix Core can perform large matrix operations in a single instruction, dramatically reducing the instruction count and improving throughput for matrix-heavy computations.
+
+Unlike NVIDIA's Tensor Cores, which are integrated into the streaming multiprocessors, AMD's Matrix Cores are separate functional units within each compute unit. This architectural choice allows for concurrent execution of matrix operations and traditional vector operations, enabling more sophisticated kernel designs that can overlap different types of computations.
+
+### MFMA Instruction Set
+
+The MFMA instruction set provides direct access to matrix acceleration capabilities through HIP intrinsics and inline assembly. These instructions operate on matrix tiles of various sizes, typically ranging from 4x4 to 32x32 elements, depending on the data type and specific operation requirements.
+
+Programming with MFMA instructions requires careful consideration of data layout and memory access patterns. Matrix data must be organized in specific formats to maximize the efficiency of matrix operations, often requiring data reorganization or specialized loading patterns to achieve optimal performance.
+
+The MFMA instructions support various matrix operation modes, including standard matrix multiplication, accumulation operations, and specialized AI-focused operations such as convolution primitives. Understanding the capabilities and limitations of each instruction variant is crucial for effective utilization of the matrix acceleration hardware.
+
+### Data Type Optimization
+
+The Matrix Cores support multiple precision modes, each with different performance characteristics and accuracy trade-offs. FP16 and BF16 operations typically provide the highest throughput, making them ideal for training and inference workloads where reduced precision is acceptable.
+
+Mixed-precision programming techniques can leverage the Matrix Cores' ability to perform computations in lower precision while maintaining higher precision for accumulation operations. This approach can significantly improve performance while maintaining numerical accuracy for many AI and scientific computing applications.
+
+The choice of data type affects not only computational throughput but also memory bandwidth requirements and cache utilization. Lower precision data types allow for more data to be stored in on-chip memory and reduce memory traffic, but require careful management of numerical precision throughout the computation.
+
+### Integration with Traditional Compute
+
+Effective utilization of Matrix Cores often requires hybrid kernel designs that combine matrix operations with traditional vector computations. This integration allows for complex algorithms that leverage the strengths of both processing units while maintaining high overall utilization.
+
+Scheduling and resource management become more complex when using both Matrix Cores and vector units simultaneously. Developers must consider the resource requirements and execution latencies of both types of operations to achieve optimal overlap and minimize idle time.
+
+The memory hierarchy must be carefully managed when using Matrix Cores, as these units typically require large amounts of data and can quickly saturate memory bandwidth if not properly optimized. Effective use of LDS memory and cache-friendly access patterns becomes even more critical in matrix-accelerated kernels.
+
+### Performance Considerations
+
+Matrix Core utilization requires specific kernel design patterns to achieve peak performance. The matrix operations must be large enough to fully utilize the hardware capabilities while being small enough to fit within the available on-chip memory resources.
+
+Tiling strategies become crucial for large matrix operations that exceed the capacity of individual Matrix Core instructions. Effective tiling must balance computational efficiency with memory access overhead, often requiring sophisticated blocking algorithms and data movement optimization.
+
+The interaction between Matrix Cores and the wavefront execution model requires careful consideration. Matrix operations typically involve multiple wavefronts working cooperatively on different portions of the computation, requiring coordination and synchronization strategies that differ from traditional vector-only kernels.
+
+
+## Synchronization and Atomic Operations
+
+### Wavefront-Level Synchronization
+
+Synchronization mechanisms in HIP differ from CUDA due to the larger wavefront size and different hardware architecture. The fundamental synchronization primitive `__syncthreads()` operates at the workgroup level, ensuring that all threads within a workgroup reach the synchronization point before any thread proceeds.
+
+The larger wavefront size in AMD hardware affects the granularity and cost of synchronization operations. With 64-thread wavefronts, synchronization barriers may involve more threads and potentially more complex coordination mechanisms compared to NVIDIA's 32-thread warps.
+
+HIP provides additional synchronization primitives that are specific to AMD hardware, including wavefront-level synchronization functions that operate within the 64-thread wavefront boundary. These functions can provide more efficient synchronization for algorithms that require coordination only within wavefront boundaries rather than across entire workgroups.
+
+### Atomic Operation Support
+
+The atomic operation capabilities of MI300 include support for various data types and operation modes that may differ from NVIDIA hardware. HIP provides a comprehensive set of atomic functions for both global and shared memory, with specific optimizations for the CDNA architecture.
+
+32-bit and 64-bit integer atomic operations are fully supported across global and LDS memory spaces. The performance characteristics of these operations depend on memory location, access patterns, and contention levels. Understanding the hardware implementation of atomic operations is crucial for designing efficient algorithms that rely on atomic updates.
+
+Floating-point atomic operations, including atomic add operations for both single and double precision, are supported with specific performance characteristics. The atomic floating-point operations on AMD hardware may have different performance profiles compared to NVIDIA implementations, requiring benchmarking and optimization for specific use cases.
+
+### Memory Ordering and Consistency
+
+Memory ordering semantics in HIP follow specific rules that ensure correct behavior across the complex memory hierarchy of MI300. The memory consistency model defines how memory operations are ordered and when they become visible to other threads, which is crucial for correct implementation of synchronization algorithms.
+
+The `__threadfence()` and `__threadfence_block()` functions provide memory ordering guarantees at different scopes, ensuring that memory operations complete before subsequent operations proceed. The implementation and performance of these functions on AMD hardware may differ from NVIDIA implementations.
+
+System-level memory fencing with `__threadfence_system()` provides the strongest ordering guarantees but with potentially higher performance costs. Understanding when each level of memory fencing is required is essential for correct and efficient synchronization in complex algorithms.
+
+### Cooperative Groups Integration
+
+HIP supports cooperative groups, which provide a more flexible and powerful synchronization model compared to traditional block-level synchronization. Cooperative groups allow for dynamic thread grouping and specialized synchronization patterns that can be more efficient for certain algorithms.
+
+The cooperative groups API in HIP provides thread block groups, grid groups, and multi-grid groups, each with different synchronization capabilities and performance characteristics. These groups can be particularly useful for implementing complex algorithms that require hierarchical synchronization patterns.
+
+Wavefront-level cooperative groups provide fine-grained synchronization within the 64-thread wavefront boundary, allowing for efficient implementation of algorithms that require frequent coordination between small groups of threads.
+
+### Performance Optimization Strategies
+
+Synchronization overhead can significantly impact kernel performance, particularly for algorithms with frequent synchronization requirements. Minimizing synchronization frequency and scope is crucial for maintaining high performance on MI300 hardware.
+
+Asynchronous execution patterns can help hide synchronization latency by overlapping computation with synchronization operations. This approach requires careful kernel design to ensure that useful work can be performed while waiting for synchronization to complete.
+
+The interaction between synchronization operations and the memory hierarchy requires careful consideration. Synchronization operations may flush caches or invalidate cached data, affecting subsequent memory access performance. Understanding these interactions is crucial for optimizing algorithms with complex synchronization patterns.
+
+
+## Compiler Directives and Architecture Detection
+
+### HIP-Specific Preprocessor Macros
+
+HIP provides a comprehensive set of preprocessor macros for detecting compilation context and target architecture, which differ significantly from CUDA's macro system. The `__HIP_PLATFORM_AMD__` macro indicates compilation for AMD hardware, while `__HIP_PLATFORM_NVIDIA__` indicates NVIDIA targets, allowing for platform-specific code paths within the same source file.
+
+The `__HIP_DEVICE_COMPILE__` macro distinguishes between host and device compilation passes, enabling conditional compilation of device-specific code. This is particularly important for MI300 kernels that may use AMD-specific intrinsics or optimization techniques not available on other platforms.
+
+Architecture-specific feature detection uses the `__HIP_ARCH_*` macro family, which provides fine-grained capability queries. For example, `__HIP_ARCH_HAS_WARP_SHUFFLE__` indicates support for wavefront shuffle operations, while `__HIP_ARCH_HAS_GLOBAL_FLOAT_ATOMIC_ADD__` indicates atomic floating-point operation support.
+
+### Runtime Architecture Detection
+
+Runtime architecture detection allows kernels to adapt their behavior based on the actual hardware capabilities discovered at execution time. The `hipGetDeviceProperties()` function returns a structure containing detailed information about the target device, including compute capability, memory sizes, and supported features.
+
+For MI300 specifically, the device properties include information about Matrix Core availability, LDS capacity, and wavefront size. This information can be used to select optimal algorithm variants or adjust kernel launch parameters for maximum performance.
+
+The architecture properties structure includes boolean flags for various hardware features, such as `hasSharedInt32Atomics`, `hasWarpVote`, and `hasDoubles`. These flags provide a portable way to query hardware capabilities without relying on specific architecture version numbers.
+
+### Compiler Optimization Directives
+
+The HIP-Clang compiler provides several AMD-specific optimization directives that can significantly impact kernel performance on MI300. The `__attribute__((amdgpu_flat_work_group_size(min, max)))` attribute allows specification of workgroup size ranges, enabling more aggressive compiler optimizations.
+
+The `--offload-arch` compiler flag specifies the target GPU architecture, with `gfx90a` and `gfx940` being relevant for MI300 variants. Proper architecture targeting enables the compiler to generate optimized code that takes advantage of architecture-specific features and instruction sets.
+
+Optimization level selection with `-O2` or `-O3` can significantly impact performance, but the optimal level may depend on the specific kernel characteristics and target workload. The compiler's ability to optimize for MI300's unique architecture features requires appropriate optimization settings.
+
+### Feature-Specific Compilation
+
+Conditional compilation based on architecture features allows for optimized code paths that take advantage of MI300's unique capabilities. For example, Matrix Core utilization can be conditionally compiled based on the availability of MFMA instructions.
+
+```cpp
+#if defined(__HIP_ARCH_HAS_MFMA__)
+    // Use Matrix Core acceleration
+    // MFMA-optimized implementation
+#else
+    // Fallback to traditional vector operations
+    // Standard implementation
+#endif
+```
+
+The wavefront size can be queried at compile time using architecture-specific macros, allowing for optimized algorithms that take advantage of the 64-thread wavefront size on AMD hardware while maintaining compatibility with other architectures.
+
+### Debug and Profiling Support
+
+The HIP compiler provides extensive debugging and profiling support through various compiler flags and runtime options. The `-g` flag enables debug information generation, while `-ggdb` provides GDB-specific tuning for use with ROCm's debugging tools.
+
+The `--save-temps` compiler flag preserves intermediate compilation files, which can be useful for understanding the generated assembly code and identifying optimization opportunities. This is particularly valuable when optimizing for MI300's specific instruction set and execution model.
+
+Runtime logging and tracing can be enabled through environment variables such as `HIP_TRACE_API` and `HIP_VISIBLE_DEVICES`, providing detailed information about kernel execution and performance characteristics on MI300 hardware.
+
+### Cross-Platform Compatibility
+
+Writing portable HIP code that performs optimally on both AMD and NVIDIA hardware requires careful use of conditional compilation and runtime detection. The HIP programming model is designed to support this portability while allowing for platform-specific optimizations.
+
+Platform-specific optimizations can be implemented using the HIP macro system while maintaining a common code base. This approach allows developers to take advantage of MI300's unique features while preserving compatibility with other GPU architectures.
+
+The HIP runtime automatically handles many platform differences, such as memory management and kernel launch mechanisms, but performance-critical code paths may require platform-specific implementations to achieve optimal performance on MI300 hardware.
+
+
+## Performance Optimization Strategies
+
+### Occupancy Optimization for 64-Thread Wavefronts
+
+Achieving optimal occupancy on MI300 requires understanding the relationship between wavefront size, register usage, and LDS consumption. With 64-thread wavefronts, each wavefront consumes more resources than NVIDIA's 32-thread warps, which affects the maximum number of concurrent wavefronts per compute unit.
+
+Register pressure becomes more significant with larger wavefronts, as each wavefront requires 64 times the per-thread register allocation. Careful register usage optimization, including register spilling strategies and algorithm restructuring, can significantly impact occupancy and overall performance.
+
+The LDS usage per workgroup must be balanced against the desired occupancy level. Since LDS is shared among all wavefronts within a workgroup, excessive LDS usage can limit the number of concurrent workgroups and reduce overall hardware utilization.
+
+### Memory Access Pattern Optimization
+
+Memory access optimization for MI300 requires specific attention to the 64-thread wavefront size and the CDNA memory hierarchy. Coalesced access patterns should be designed for 64-thread groups rather than 32-thread groups, which may require different stride patterns and data organization strategies.
+
+The vector cache system in CDNA3 is optimized for specific access patterns that may differ from NVIDIA's cache hierarchy. Understanding cache line sizes, associativity, and replacement policies can help optimize memory access patterns for maximum cache utilization.
+
+Bandwidth optimization requires consideration of the memory controller architecture and the specific memory subsystem configuration of MI300. The high-bandwidth memory (HBM) subsystem provides substantial memory bandwidth, but achieving peak utilization requires careful attention to access patterns and memory controller load balancing.
+
+### Instruction-Level Optimization
+
+The CDNA3 instruction set provides several optimization opportunities that are specific to AMD hardware. Vector ALU utilization can be maximized through careful instruction scheduling and by avoiding instruction dependencies that could cause pipeline stalls.
+
+The scalar unit in CDNA3 compute units can handle uniform computations across wavefronts, reducing pressure on vector resources. Identifying and optimizing scalar operations can improve overall instruction throughput and resource utilization.
+
+Mixed-precision arithmetic can provide significant performance benefits on MI300, particularly when using the Matrix Cores for AI workloads. The ability to perform computations in lower precision while maintaining higher precision for accumulation can dramatically improve throughput for appropriate algorithms.
+
+### Workload Distribution Strategies
+
+Effective workload distribution across MI300's compute units requires understanding the shader engine organization and compute unit capabilities. Load balancing strategies should account for the hierarchical nature of the hardware and the potential for workload imbalances between different parts of the device.
+
+Dynamic load balancing techniques can help address workload irregularities that are common in real-world applications. These techniques may involve work stealing, dynamic work distribution, or adaptive algorithm selection based on runtime characteristics.
+
+The interaction between multiple kernels executing concurrently on MI300 requires careful resource management and scheduling. Understanding the hardware's ability to overlap different types of operations can enable more sophisticated execution strategies.
+
+### Algorithm-Specific Optimizations
+
+Matrix-heavy algorithms can benefit significantly from MI300's Matrix Cores, but effective utilization requires algorithm restructuring to match the hardware capabilities. Tiling strategies, data layout optimization, and mixed-precision techniques are crucial for achieving peak performance.
+
+Reduction operations and other collective algorithms must be adapted for 64-thread wavefronts and the specific characteristics of the CDNA architecture. Wavefront-level primitives and hierarchical reduction strategies can provide better performance than direct ports from NVIDIA-optimized algorithms.
+
+Memory-bound algorithms require specific optimization strategies that account for the CDNA memory hierarchy and bandwidth characteristics. Techniques such as software-managed caching, prefetching, and memory access reordering can significantly improve performance for these workloads.
+
+### Profiling and Performance Analysis
+
+Effective performance optimization requires comprehensive profiling and analysis tools that understand the unique characteristics of MI300 hardware. ROCm's profiling tools provide detailed insights into wavefront execution, memory access patterns, and resource utilization.
+
+Instruction-level profiling can reveal optimization opportunities that are specific to the CDNA instruction set and execution model. Understanding instruction latencies, throughput characteristics, and resource dependencies is crucial for fine-tuning kernel performance.
+
+Memory hierarchy analysis tools can help identify cache utilization patterns, memory bandwidth bottlenecks, and opportunities for access pattern optimization. These tools are essential for understanding the complex interactions between different levels of the memory hierarchy on MI300.
+
+
+## Debugging and Profiling
+
+### ROCm Debugging Tools
+
+The ROCm ecosystem provides specialized debugging tools designed specifically for AMD GPU architectures, including MI300. The ROCgdb debugger extends the standard GDB interface with GPU-specific capabilities, allowing developers to debug kernels at the wavefront and thread level.
+
+Setting breakpoints in HIP kernels requires understanding the wavefront execution model and the potential for divergent execution paths. The debugger can display wavefront state, register contents, and memory values, but interpreting this information requires knowledge of the CDNA execution model.
+
+The debugging experience on MI300 differs from NVIDIA's debugging tools in several key ways. The larger wavefront size affects how thread state is displayed and managed, while the unique memory hierarchy requires different approaches to memory inspection and analysis.
+
+### Performance Profiling with ROCProfiler
+
+ROCProfiler provides comprehensive performance analysis capabilities specifically designed for AMD GPU architectures. The profiler can collect detailed metrics about wavefront execution, memory access patterns, instruction throughput, and resource utilization on MI300 hardware.
+
+Wavefront occupancy analysis reveals how effectively the hardware resources are being utilized and can identify opportunities for optimization. The profiler can show occupancy levels across different compute units and identify bottlenecks that limit overall performance.
+
+Memory access profiling provides insights into cache hit rates, memory bandwidth utilization, and access pattern efficiency. This information is crucial for optimizing memory-bound kernels and understanding the performance characteristics of different memory hierarchy levels.
+
+### Kernel Launch Configuration Analysis
+
+Optimal kernel launch configurations for MI300 require careful analysis of workgroup size, grid dimensions, and resource usage. The profiling tools can help identify the impact of different launch configurations on occupancy, memory access efficiency, and overall performance.
+
+The relationship between workgroup size and wavefront utilization is particularly important on AMD hardware. Since wavefronts contain 64 threads, workgroup sizes that are not multiples of 64 may result in partially filled wavefronts and reduced hardware utilization.
+
+Dynamic shared memory allocation and register usage analysis can reveal opportunities for resource optimization. Understanding how these resources are allocated and used across different wavefronts is crucial for achieving optimal performance.
+
+### Matrix Core Utilization Analysis
+
+Profiling Matrix Core utilization requires specialized tools and metrics that understand the unique characteristics of these acceleration units. The profiler can show Matrix Core occupancy, instruction throughput, and the effectiveness of data movement between Matrix Cores and other compute resources.
+
+Understanding the interaction between Matrix Cores and traditional vector units is crucial for optimizing hybrid kernels that use both types of processing resources. The profiler can reveal resource conflicts, scheduling inefficiencies, and opportunities for better resource utilization.
+
+Data layout analysis for Matrix Core operations can identify opportunities for improved memory access patterns and reduced data movement overhead. The profiler can show how effectively data is being supplied to the Matrix Cores and identify potential bottlenecks.
+
+### Environment Variables and Runtime Configuration
+
+The HIP runtime provides numerous environment variables for controlling debugging and profiling behavior. `HIP_TRACE_API` enables API call tracing, while `HIP_VISIBLE_DEVICES` controls device visibility and can be used to isolate specific MI300 devices for testing.
+
+Logging levels can be controlled through `HIP_LOG_LEVEL` and related variables, providing detailed information about kernel execution, memory operations, and runtime behavior. This information can be invaluable for debugging complex performance issues.
+
+The `HSA_TOOLS_LIB` environment variable enables integration with external profiling and analysis tools, allowing for more sophisticated performance analysis workflows that combine multiple tools and data sources.
+
+### Common Performance Pitfalls
+
+Several common performance pitfalls are specific to MI300 and the CDNA architecture. Wavefront divergence can be more costly than on NVIDIA hardware due to the larger wavefront size, making control flow optimization particularly important.
+
+Memory access patterns that work well on NVIDIA hardware may not be optimal for MI300 due to differences in cache hierarchy and memory controller organization. Understanding these differences is crucial for achieving optimal performance.
+
+Resource allocation imbalances between different types of compute resources (vector units, Matrix Cores, memory bandwidth) can limit overall performance. Effective profiling can identify these imbalances and guide optimization efforts.
+
+
+## Best Practices Summary
+
+### Architecture-Specific Considerations
+
+When developing HIP kernels for MI300, always consider the 64-thread wavefront size in algorithm design and memory access patterns. This fundamental difference from NVIDIA's 32-thread warps affects occupancy calculations, synchronization strategies, and optimal workgroup sizes.
+
+Leverage the Matrix Cores for AI and linear algebra workloads by restructuring algorithms to use matrix operations where possible. The dedicated matrix acceleration units can provide substantial performance improvements for appropriate workloads, but require careful data layout and algorithm design.
+
+Optimize memory access patterns for the CDNA memory hierarchy, which differs significantly from NVIDIA architectures. Pay particular attention to LDS usage, cache-friendly access patterns, and the interaction between different memory hierarchy levels.
+
+### Performance Optimization Guidelines
+
+Design kernels with occupancy optimization in mind, considering the larger resource requirements of 64-thread wavefronts. Balance register usage, LDS consumption, and workgroup size to achieve optimal hardware utilization.
+
+Use HIP's architecture detection capabilities to implement platform-specific optimizations while maintaining code portability. This allows for optimal performance on MI300 while preserving compatibility with other GPU architectures.
+
+Profile extensively using ROCm's specialized tools to understand performance characteristics and identify optimization opportunities. The unique architecture of MI300 requires specific profiling approaches and metrics that differ from NVIDIA-focused tools.
+
+### Code Organization Strategies
+
+Structure code to take advantage of both vector units and Matrix Cores when appropriate, using hybrid approaches that maximize overall hardware utilization. This may require algorithm restructuring and careful resource management.
+
+Implement robust error handling and debugging support using HIP's debugging capabilities and ROCm tools. The complexity of MI300's architecture makes comprehensive debugging support essential for development productivity.
+
+Use conditional compilation and runtime detection to create portable code that performs optimally across different GPU architectures while taking full advantage of MI300's unique capabilities.
+
+### Development Workflow Recommendations
+
+Establish a development workflow that includes regular profiling and performance analysis using ROCm tools. The unique characteristics of MI300 make performance analysis an integral part of the development process rather than an afterthought.
+
+Test kernels across different workload sizes and input characteristics to ensure robust performance across the range of expected use cases. MI300's architecture may exhibit different performance characteristics for different workload patterns.
+
+Maintain awareness of ROCm ecosystem updates and new optimization techniques as the toolchain and hardware capabilities continue to evolve. The rapidly advancing nature of GPU computing makes continuous learning essential.
+
+## References
+
+[1] AMD HIP Documentation, Release 6.1.40092. Advanced Micro Devices, Inc., September 2024. Available at: https://rocm.docs.amd.com/projects/HIP/en/latest/
+
+[2] AMD CDNA3 Architecture Overview. Advanced Micro Devices, Inc. Available at: https://www.amd.com/en/products/accelerators/instinct/mi300
+
+[3] ROCm Documentation. Advanced Micro Devices, Inc. Available at: https://rocm.docs.amd.com/
+
+[4] HIP Programming Guide. Advanced Micro Devices, Inc. Available at: https://rocm.docs.amd.com/projects/HIP/en/latest/user_guide/programming_manual.html
+
+[5] AMD GPU Hardware Specifications. Available at: https://rocm.docs.amd.com/en/latest/reference/gpu-arch-specs.html
+
+[6] HIP API Reference. Advanced Micro Devices, Inc. Available at: https://rocm.docs.amd.com/projects/HIP/en/latest/doxygen/html/
+
+[7] ROCProfiler User Guide. Advanced Micro Devices, Inc. Available at: https://rocm.docs.amd.com/projects/rocprofiler/en/latest/
+
+[8] AMD Matrix Instruction Calculator. Available at: https://github.com/ROCmSoftwarePlatform/amd-matrix-instruction-calculator
+
+---
+
+*This document serves as a comprehensive guide for HIP kernel development on AMD MI300 accelerators. For the most current information and updates, please refer to the official AMD ROCm documentation and release notes.*
+
diff --git a/kernel-agentic/docs/hip/hip_spec.pdf b/kernel-agentic/docs/hip/hip_spec.pdf
deleted file mode 100644
index 4a2a6a4..0000000
Binary files a/kernel-agentic/docs/hip/hip_spec.pdf and /dev/null differ
diff --git a/kernel-agentic/docs/hip/hip_spec_mm/hip_spec-with-image-refs-enhanced.html b/kernel-agentic/docs/hip/hip_spec_mm/hip_spec-with-image-refs-enhanced.html
deleted file mode 100644
index a633576..0000000
--- a/kernel-agentic/docs/hip/hip_spec_mm/hip_spec-with-image-refs-enhanced.html
+++ /dev/null
@@ -1,8151 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-<meta charset="UTF-8">
-<title>hip_spec</title>
-<meta name="generator" content="Docling HTML Serializer">
-<style>
-    html {
-        background-color: #f5f5f5;
-        font-family: Arial, sans-serif;
-        line-height: 1.6;
-    }
-    body {
-        max-width: 800px;
-        margin: 0 auto;
-        padding: 2rem;
-        background-color: white;
-        box-shadow: 0 0 10px rgba(0,0,0,0.1);
-    }
-    h1, h2, h3, h4, h5, h6 {
-        color: #333;
-        margin-top: 1.5em;
-        margin-bottom: 0.5em;
-    }
-    h1 {
-        font-size: 2em;
-        border-bottom: 1px solid #eee;
-        padding-bottom: 0.3em;
-    }
-    table {
-        border-collapse: collapse;
-        margin: 1em 0;
-        width: 100%;
-    }
-    th, td {
-        border: 1px solid #ddd;
-        padding: 8px;
-        text-align: left;
-    }
-    th {
-        background-color: #f2f2f2;
-        font-weight: bold;
-    }
-    figure {
-        margin: 1.5em 0;
-        text-align: center;
-    }
-    figcaption {
-        color: #666;
-        font-style: italic;
-        margin-top: 0.5em;
-    }
-    img {
-        max-width: 100%;
-        height: auto;
-    }
-    pre {
-        background-color: #f6f8fa;
-        border-radius: 3px;
-        padding: 1em;
-        overflow: auto;
-    }
-    code {
-        font-family: monospace;
-        background-color: #f6f8fa;
-        padding: 0.2em 0.4em;
-        border-radius: 3px;
-    }
-    pre code {
-        background-color: transparent;
-        padding: 0;
-    }
-    .formula {
-        text-align: center;
-        padding: 0.5em;
-        margin: 1em 0;
-        background-color: #f9f9f9;
-    }
-    .formula-not-decoded {
-        text-align: center;
-        padding: 0.5em;
-        margin: 1em 0;
-        background: repeating-linear-gradient(
-            45deg,
-            #f0f0f0,
-            #f0f0f0 10px,
-            #f9f9f9 10px,
-            #f9f9f9 20px
-        );
-    }
-    .page-break {
-        page-break-after: always;
-        border-top: 1px dashed #ccc;
-        margin: 2em 0;
-    }
-    .key-value-region {
-        background-color: #f9f9f9;
-        padding: 1em;
-        border-radius: 4px;
-        margin: 1em 0;
-    }
-    .key-value-region dt {
-        font-weight: bold;
-    }
-    .key-value-region dd {
-        margin-left: 1em;
-        margin-bottom: 0.5em;
-    }
-    .form-container {
-        border: 1px solid #ddd;
-        padding: 1em;
-        border-radius: 4px;
-        margin: 1em 0;
-    }
-    .form-item {
-        margin-bottom: 0.5em;
-    }
-    .image-classification {
-        font-size: 0.9em;
-        color: #666;
-        margin-top: 0.5em;
-    }
-</style>
-</head>
-<body>
-<div class='page'>
-<h2>HIP Documentation Release 6.1.40092</h2>
-<p>Advanced Micro Devices, Inc.</p>
-<p>Sep 13, 2024</p>
-<h2>INSTALL</h2>
-<p><strong>**Following table contains:** The table appears to represent a structured outline or table of contents for a document or guide related to installing and building HIP (Heterogeneous-Compute Interface for Portability). Each row corresponds to a section or subsection of the document.
-
-- The first column seems to indicate the main section number or title.
-- The second column provides a more detailed section or subsection number.
-- The third column contains the title or description of the section or subsection.
-- The fourth column appears to indicate a page number where the section or subsection can be found.
-
-Noteworthy values include:
-- The main sections are "1 Overview" and "3 Build HIP from source."
-- Subsections under "Install HIP" include "Prerequisites," "Installation," and "Verify your installation."
-- The page numbers suggest that the "Overview" section spans pages 3 to 6, while "Build HIP from source" starts on page 7.</strong></p>
-<table><tbody><tr><td colspan="3">1 Overview</td><th>3</th></tr><tr><td></td><th colspan="2">Install HIP</th><td></td></tr><tr><th>2</th><td></td><td></td><td>5</td></tr><tr><td></td><th>2.1</th><th>Prerequisites . . . . . . . . .</th><td>5</td></tr><tr><td></td><th>2.2</th><th>Installation . . .</th><td>5</td></tr><tr><td></td><th>2.3</th><th>. . . . . Verify your installation . . .</th><td>6</td></tr><tr><th>3</th><th colspan="2">Build HIP from source</th><th>7</th></tr><tr><td></td><th colspan="2">3.1 Prerequisites</th><td>. . . . . .</td><td></td></tr><tr><td></td><td></td><th>. .</th><td>7</td></tr><tr><td></td><th colspan="2">3.2 Building the HIP runtime 3.3 . .</th><td>.</td><td>7</td></tr><tr><td></td><th colspan="2">Build HIP tests . . .</th><td>10</td></tr><tr><td></td><th colspan="2">. . . 3.4 Run HIP . . . . . . . . . . .</th><td>11</td></tr><tr><th>4</th><th colspan="2">HIP programming model</th><th>13</th></tr><tr><td></td><th colspan="2">4.1</th><td>13</td></tr><tr><th>4.2</th><th colspan="2">RDNA &amp;CDNAarchitecture summary Heterogeneous Programming . .</th><td>14</td></tr><tr><td></td><th colspan="2">Single instruction multiple threads (SIMT) . . .</th><td>14</td></tr><tr><th>4.3 4.4</th><th colspan="2">Inherent thread model . .</th><td>15</td></tr><tr><th>4.5</th><th colspan="2">. . . . 4.4.1 Cooperative groups thread</th><td>16</td></tr><tr><td></td><th colspan="2">Memory model . . . . . . . . .</th><td>16</td></tr><tr><td></td><th colspan="2">4.6 Execution model .</th><td>. . . . .</td><td>17</td></tr><tr><td></td><th colspan="2">4.6.1 Host-side</th><td></td></tr><tr><td></td><td></td><th>execution</th><td>17 17</td></tr><tr><td></td><th>4.6.2</th><th>Device-side execution . .</th><td></td></tr><tr><td></td><th>4.6.3</th><th>Kernel launch .</th><td>18</td></tr><tr><th>5</th><th colspan="2">Hardware implementation</th><th>19</th></tr><tr><td></td><th colspan="2">Compute units</th><td>. . . . . . .</td><td>19</td></tr><tr><td></td><td></td><td>. . . . .</td><td>20</td></tr><tr><th>5.1</th><th>5.1.1 5.1.2</th><th>SIMD . . Vector cache . .</th><td>20</td></tr><tr><td></td><th>5.1.3</th><th>. . Local data share . .</th><td>20</td></tr><tr><td></td><th>5.1.4</th><th>Scalar Unit . . . .</th><td>20</td></tr><tr><td></td><th colspan="2">5.2 CDNA architecture .</th><td>. . . .</td><td>20</td></tr><tr><td></td><th colspan="2">5.3 RDNA architecture . .</th><td>. . . .</td><td>21</td></tr><tr><td></td><th colspan="2">5.4 Shader engines . .</th><td>. . . .</td><td>21</td></tr><tr><td></td><th colspan="2">(CLR)</th><td></td></tr><tr><th>6</th><th colspan="2">AMDcommon language runtimes</th><td>23</td></tr><tr><td></td><th colspan="2">6.1 Project organization</th><td>. . . .</td><td>23</td></tr><tr><td></td><th colspan="2">How to build/install .</th><td>. . .</td><td>23</td></tr><tr><th>6.2</th><th>6.2.1</th><th>Prerequisites . . .</th><td>23</td></tr><tr><td></td><th>6.2.2</th><th>Linux . . . . . . .</th><td>23</td></tr><tr><td></td><th>6.2.3</th><th>Test . . . . . . . .</th><td>24</td></tr></tbody></table>
-<p><strong>**Following table contains:** The table appears to represent a structured outline or index of a document, likely a technical manual or guide related to HIP (Heterogeneous-computing Interface for Portability) programming. Each row corresponds to a section or subsection of the document.
-
-- **Column 0**: This column seems to represent the section numbers or identifiers, which help in organizing the document into a hierarchical structure. For example, "7 7.1" indicates a main section and its subsection.
-
-- **Column 1**: This column contains the titles or headings of the sections and subsections. It provides a brief description of the content covered in each part of the document, such as "Host Memory" or "Coherency Controls."
-
-- **Column 2**: This column appears to contain additional descriptive text or continuation of the section titles, often represented by ellipses, which might indicate omitted or summarized content.
-
-- **Column 3**: This column likely represents page numbers where each section or subsection can be found in the document, aiding in navigation.
-
-Noteworthy values include the presence of ellipses in columns 1 and 2, suggesting that the full text or titles might be truncated or summarized in this preview. Additionally, the consistent page numbers (mostly 25 and 26) suggest that these sections are closely located within the document, possibly indicating a detailed discussion on a specific topic within a few pages.</strong></p>
-<table><tbody><tr><td></td><td>6.2.4</td><td>Release notes . . . . . . . . . . . . . . . . . . . . .</td><td>24</td></tr><tr><th colspan="3">HIP programming manual</th><td>25</td></tr><tr><th>7 7.1</th><th colspan="2">Host Memory . . . . .</th><td>. . . . . . . . . . . . . . . . . . . . .</td><td>25</td></tr><tr><td></td><th>7.1.1</th><th>Introduction . . . . . . . . . . . . . . .</th><td>25</td></tr><tr><td></td><th>7.1.2</th><th>. . . . . . . Memory allocation flags . . . . . . . . .</th><td>25</td></tr><tr><td></td><th>7.1.3</th><th>. . . . . . Numa-aware host memory allocation . . . . . . . . .</th><td>26</td></tr><tr><td></td><th>7.1.4</th><th>Coherency Controls . . . . . . . . .</th><td>26</td></tr><tr><td></td><th>7.1.5</th><th>. . . . . . . . . Visibility of Zero-Copy Host Memory . . . . . . . .</th><td>27</td></tr><tr><td></td><th>7.1.6</th><th>hipEventSynchronize . . . . . . . . . . .</th><td>27</td></tr><tr><td></td><th>7.1.7</th><th>. . . . Summary and Recommendations . . . . . . . . . . .</th><td>27</td></tr><tr><td></td><th>7.1.8</th><th>Managed memory allocation . . . . . . . . . . . . .</th><td>28</td></tr><tr><td></td><th>7.1.9</th><th>HIP Stream Memory Operations . . . . . . . . . . .</th><td>28</td></tr><tr><th>7.2</th><th colspan="2">Direct Dispatch . . . . . .</th><td>. . . . . . . . . . . . . . . . . . .</td><td>28</td></tr><tr><th>7.3</th><th colspan="2">HIP Runtime Compilation</th><td>. . . . . . . . . .</td><td>29</td></tr><tr><th>7.4</th><th colspan="2">. . . . . . . . . HIP Graph . . . . . . . . . . . . . . . . .</th><td>. . . . . . . . . .</td><td>29</td></tr><tr><th>7.5</th><th colspan="2">Device-Side Malloc . . . . . .</th><td>. . . . . . . . . . . . .</td><td>29</td></tr><tr><th>7.6</th><th colspan="2">. . . Use of Per-thread default stream . . .</th><td>. . . . . . . . . . . . .</td><td>29</td></tr><tr><th>7.7</th><th colspan="2">Use of Long Double Type . . . . .</th><td>. . . . . . . . . . . . . .</td><td>30</td></tr><tr><th>7.8</th><th colspan="2">Use of _Float16 Type . . . . . . .</th><td>30</td></tr><tr><th>7.9</th><th colspan="2">. . . . . . . . . . . . . . FMA and contractions . . . . . . . . . . . . . . . . . . . . .</th><td>30</td></tr><tr><th>7.10</th><th colspan="2">Math functions with special rounding modes . . . . . . . . . . . . . . . .</th><td>. . . . .</td><td>30</td></tr><tr><th>7.11</th><th colspan="2">Creating Static Libraries . . .</th><td>. . . . .</td><td>30</td></tr><tr><th colspan="3">8 HIP porting guide . . . . . . . . . . .</th><th>33</th></tr><tr><th>8.1</th><th colspan="2">Porting a New CUDA Project .</th><td>. . . . .</td><td>33</td></tr><tr><td></td><td></td><th>General Tips . .</th><td></td></tr><tr><td></td><th>8.1.1</th><th>. . . . . . . . . . . . . . . . . . .</th><td>33</td></tr><tr><td></td><th>8.1.2</th><th>Scanning existing CUDA code to scope the porting effort &#x27;in-place&#x27; . . . . . . . . . .</th><td>33 34</td></tr><tr><td></td><th>8.1.3</th><th>Converting a project . .</th><td></td></tr><tr><td></td><th>8.1.4</th><th>Library Equivalents . . . . . . . . . . . . . . . . . .</th><td>35 35</td></tr><tr><th>8.2</th><th>Distinguishing 8.2.1</th><th>Compiler Modes . . . . . . . . . . . . . . . . Identifying HIP Target Platform . . .</th><td>35</td></tr><tr><td></td><th>8.2.2</th><th>. . . . . . . . Identifying the Compiler: hip-clang or NVCC . . .</th><td>36</td></tr><tr><td></td><th>8.2.3</th><th>. Identifying Current Compilation Pass: Host or Device</th><td>36</td></tr><tr><td></td><th>8.2.4</th><th>Compiler Defines: Summary . . . . . . . . . . . . . . .</th><td>37</td></tr><tr><th>8.3</th><th colspan="2">Identifying Architecture Features . .</th><td>. . . . . . . . . . . . .</td><td>37</td></tr><tr><td></td><th>8.3.1</th><th>HIP_ARCH Defines . . . . . . . . . . . . . . .</th><td>37</td></tr><tr><td></td><th>8.3.2</th><th>Device-Architecture Properties . . . . . . . . . . . .</th><td>38</td></tr><tr><td></td><th>8.3.3</th><th>Table of Architecture Properties . . . . . . . . . . . . . . . . . .</th><td>38</td></tr><tr><th>8.4</th><th colspan="2">Finding HIP . . . . . . .</th><td>. . . . . . . . . . . .</td><td>39 40</td></tr><tr><th>8.5 8.6</th><th colspan="2">Identifying HIP Runtime . . . . . hipLaunchKernelGGL . . . . .</th><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>40</td></tr><tr><th>8.7</th><th colspan="2">Compiler Options . . . . . . . 8.7.1 Compiler options supported</th><td>. . . . . . . . . . . . . . . .</td><td>40</td></tr><tr><td></td><td></td><td>on AMDplatforms . . .</td><td>40</td></tr><tr><th>8.8</th><th colspan="2">Linking Issues . . .</th><td>. . . . . . . . . . . . . . . . . . . .</td><td>41</td></tr><tr><td></td><th colspan="2">. . 8.8.1 Linking With hipcc</th><td>. . . . . . . . . . . . . . . . . .</td><td>41</td></tr><tr><td></td><th>8.8.2</th><th>-lm Option . . . . . . . . . . . . . . . . .</th><td>41</td></tr><tr><th>8.9</th><th colspan="2">. . . . . Linking Code With Other Compilers</th><td>. . . . . . . . . . . . .</td><td>41</td></tr><tr><td></td><th colspan="2">8.9.1 libc++ and libstdc++</th><td></td></tr><tr><td></td><td></td><td>. . . . . . . . . . . . . . . . .</td><td>41</td></tr><tr><td></td><th>8.9.2</th><th>HIP Headers ( hip_runtime.h , hip_runtime_api.h Compiler . . . . . . . . . . .</th><td>42 42</td></tr><tr><td></td><th colspan="2">8.9.3 Using a Standard C++ 8.9.3.1 . .</th><td>. . . . . . . . . . . .</td><td>42</td></tr><tr><td></td><th colspan="2">cuda.h . . . . . 8.9.4 Choosing HIP File Extensions . .</th><td>. . . . . . . . . . . .</td><td>42</td></tr><tr><th>8.10</th><th colspan="2">Workarounds . . . . . . . . . . . .</th><td>. . . . . . . . . . . .</td><td>43</td></tr></tbody></table>
-<p>8.10.1</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>43</p>
-<p><strong>**Following table contains:** The table represents a comparison of different HIP (Heterogeneous-computing Interface for Portability) API synchronization functions. Each row corresponds to a specific HIP API function and describes its synchronization behavior and memory visibility characteristics.
-
-The columns are as follows:
-1. **HIP API Synchronization Effect**: Describes the synchronization action performed by the HIP API function.
-2. **Fence**: Indicates the type of memory release operation associated with the synchronization (e.g., system-scope release, device-scope release, or none).
-3. **Coherent Memory ity**: Specifies whether coherent memory is supported (notably, there seems to be a typo or truncation in the column name).
-4. **Host Visibil-**: Indicates whether the host has visibility into the memory operations (the column name appears truncated).
-5. **Non-Coherent Host Memory Visi- bility**: Specifies whether non-coherent host memory visibility is supported (the column name appears truncated).
-
-Noteworthy values:
-- All functions listed support coherent memory.
-- The `hipEventSynchronize` function has a "depends - see below" note for non-coherent host memory visibility, suggesting conditional behavior or additional context not provided in the table.
-- The `hipStreamWaitEvent` function does not support non-coherent host memory visibility.</strong></p>
-<table><tbody><tr><td></td><td></td><td></td><th>warpSize</th><td></td></tr><tr><td></td><td></td><td colspan="2">8.10.2 Kernel launch with group size &gt; 256 . . . . . . . . . . . . . . . . . . . . .</td><td>43</td></tr><tr><td></td><th>8.11</th><td colspan="2">memcpyToSymbol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>43</td></tr><tr><td></td><th>8.12</th><td colspan="2">CU_POINTER_ATTRIBUTE_MEMORY_TYPE</td><td>. . .</td><td>44</td></tr><tr><td></td><th>8.13</th><td colspan="2">threadfence_system . . .</td><td>. . . . . . . .</td><td>45</td></tr><tr><td></td><td></td><td colspan="2">. . . . . . 8.13.1 Textures and Cache Control . . .</td><td>. . . . . . . .</td><td>45</td></tr><tr><td></td><th>8.14</th><td colspan="2">More Tips . . . .</td><td>. . . . . . . . .</td><td>46</td></tr><tr><td></td><th>8.14.1</th><td colspan="2">. . . . . . . . . . . HIP Logging . . . . . . . . .</td><td>. . . . . . . . .</td><td>46</td></tr><tr><td></td><th>8.14.2</th><td colspan="2">Debugging hipcc</td><td>. . . . . . . . . . . . . . . .</td><td>47</td></tr><tr><td></td><th>8.14.3</th><td colspan="2">Editor Highlighting . .</td><td>. . . . . . . . . . . . .</td><td>47</td></tr><tr><td>9</td><th colspan="3">Porting CUDA driver API</th><td>49</td></tr><tr><td>9.1</td><th colspan="3">Introduction to the CUDA Driver and Runtime APIs . . . . . . . .</th><td>49</td></tr><tr><td></td><th>9.1.1</th><td colspan="2">cuModule API . . . . . . . . . . . . . .</td><td>49</td></tr><tr><td></td><th>9.1.2</th><td colspan="2">. . . . . . . . . cuCtx API . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>50</td></tr><tr><td>9.2</td><th>HIP</th><td colspan="2">Module and Ctx APIs . . . . . . . . . . . . .</td><td>. . .</td><td>50</td></tr><tr><td></td><th>9.2.1</th><td colspan="2">hipModule API . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>50</td></tr><tr><td></td><th>9.2.2</th><td colspan="2">. hipCtx API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>51</td></tr><tr><td></td><th>9.2.3</th><td colspan="2">hipify translation of CUDA Driver API . . . . . .</td><td>51</td></tr><tr><td></td><td></td><td>9.2.3.1</td><td>Address Spaces . . . . . .</td><td>51</td></tr><tr><td></td><td></td><td>9.2.3.2</td><td>. . . . . . Using hipModuleLaunchKernel . .</td><td>51</td></tr><tr><td></td><td></td><td>9.2.3.3</td><td>Additional Information</td><td>51</td></tr><tr><td></td><th>9.2.4</th><td colspan="2">. . . . . . . . . . . hip-clang Implementation Notes . . . . . . . . . .</td><td>51</td></tr><tr><td></td><td></td><td>9.2.4.1</td><td>.hip_fatbin . . . . . . . . . . . . .</td><td>51</td></tr><tr><td></td><td></td><td>9.2.4.2</td><td>Initialization and Termination Functions</td><td>52</td></tr><tr><td></td><td></td><td>9.2.4.3</td><td>Kernel Launching</td><td>52</td></tr><tr><td></td><th>9.2.5</th><td colspan="2">. . . . . . . . . . . . . . . . . . NVCC Implementation Notes . . . . . . . . . . . . . . . . .</td><td>52</td></tr><tr><td></td><td></td><td colspan="2">. . . . 9.2.5.1 Interoperation between HIP and CUDA Driver . . . . . . .</td><td>52</td></tr><tr><td></td><td></td><td colspan="2">9.2.5.2 Compilation Options . . .</td><td>. . . . . .</td><td>53</td></tr><tr><td>9.3</td><th>HIP</th><td colspan="2">Module and Texture Driver API . . . .</td><td>. . . . . . .</td><td>55</td></tr><tr><td>10</td><th colspan="3">Programming for HIP runtime compiler (RTC)</th><td>57</td></tr><tr><td>10.1</td><th colspan="3">Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</th><td>57</td></tr><tr><td>10.2</td><th>HIPRTC</th><td colspan="2">specific options . . . . . . . .</td><td>. . . . . . . . .</td><td>61</td></tr><tr><td></td><th>10.2.1</th><td colspan="2">Bitcode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>62</td></tr><tr><td></td><th>10.2.2</th><td colspan="2">CU Mode vs WGP mode . . . . . .</td><td>62</td></tr><tr><td>10.3</td><th>Linker</th><td colspan="2">APIs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>62</td></tr><tr><td></td><th>10.3.1</th><td colspan="2">Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>63 63</td></tr><tr><td></td><th>10.3.2</th><td colspan="2">10.3.1.1 Note . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Input Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>64</td></tr><tr><td></td><th>10.3.3</th><td colspan="2">. Backward Compatibility of LLVM Bitcode/IR . . . . . . . . . . . . . .</td><td>64</td></tr><tr><td></td><th>10.3.4</th><td colspan="2">Link Options . . . . . . . . . .</td><td>. . . . . . . .</td><td>64</td></tr><tr><td>10.4</td><th colspan="3">Error Handling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</th><td>65</td></tr><tr><td>10.5</td><th colspan="3">HIPRTC General APIs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</th><td>65</td></tr><tr><td>10.6</td><th colspan="3">Lowered Names (Mangled Names) . . . . . . . . . . .</th><td>66</td></tr><tr><td></td><th>10.6.1 10.6.2</th><td colspan="2">Note . . . . . . . . . . . . . . . . . . . . . . . . . . . Example . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>66 66</td></tr><tr><td>10.7</td><th colspan="3">. . . . . . . . . . .</th><td>67</td></tr><tr><td>10.8</td><th colspan="3">Versioning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . HIP header support . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</th><td>68</td></tr><tr><td>10.9</td><th colspan="3">Deprecation notice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</th><td>68</td></tr><tr><td>11</td><td></td><td></td><td></td><td>69</td></tr><tr><td>11.1</td><th colspan="3">Performance guidelines Parallel</th><td>execution</td><td>. . . . . . . . . . . . . . . . . . . . .</td><td>69</td></tr></tbody></table>
-<p>11.1.2</p>
-<p>Device level</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>69</p>
-<p><strong>**Following table contains:** The table represents a comparison of different libraries available in CUDA, HIP, and ROCm ecosystems, which are used for various computational tasks in high-performance computing. Each row corresponds to a specific library or set of functionalities, and the columns indicate the equivalent library in each ecosystem along with a brief comment describing the library's purpose.
-
-Columns:
-- "CUDA Library": Lists the libraries available in the CUDA ecosystem.
-- "HIP Library": Lists the equivalent libraries available in the HIP ecosystem.
-- "ROCm Library": Lists the equivalent libraries available in the ROCm ecosystem.
-- "Comment": Provides a brief description of the library's functionality or purpose.
-
-Noteworthy values:
-- Some libraries do not have equivalents in all ecosystems, as indicated by "N/A" (e.g., AmgX in the HIP Library column).
-- The "cuBLASLt" library has a "N/A" entry in the ROCm Library column, suggesting there is no direct equivalent in ROCm for this lightweight and flexible API version of cuBLAS.
-- The "AmgX" library is only available in the CUDA ecosystem, with no equivalents in HIP or ROCm, highlighting a unique offering in CUDA for sparse iterative solvers and preconditioners with algebraic multigrid.</strong></p>
-<table><tbody><tr><td></td><td>11.1.3</td><td>Multiprocessor level . . . . . . . . . . . . . .</td><td>70</td></tr><tr><td>11.2</td><td>Memory</td><td>optimization . . . . . . . . . . . .</td><td>70</td></tr><tr><td></td><td>11.2.1</td><td>Data Transfer . . . . . . . . . . . . .</td><td>70</td></tr><tr><td></td><td>11.2.2</td><td>. . Device Memory Access . . . . . . . . . .</td><td>71</td></tr><tr><td>11.3</td><td colspan="2">Optimization for maximum instruction throughput</td><td>71</td></tr><tr><td></td><td>11.3.1</td><td>Arithmetic instructions . . . . . . . . .</td><td>72</td></tr><tr><td></td><td>11.3.2</td><td>. Control flow instructions . . . . . . . . .</td><td>72</td></tr><tr><td></td><td>11.3.3</td><td>Synchronization . . . . . . . . . .</td><td>72</td></tr><tr><td>11.4</td><td colspan="2">. . . . Minimizing memory thrashing .</td><td>. . . . . . . . . .</td><td>73</td></tr><tr><td colspan="3">12 Debugging with HIP</td><td>75</td></tr><tr><td>12.1</td><td colspan="2">Tracing . .</td><td>. . . . . . . . . . . . . . . . . . . . .</td><td>75</td></tr><tr><td>12.2</td><td colspan="2">Debugging . . . . . .</td><td>. . . . . . . .</td><td>77</td></tr><tr><td></td><td colspan="2">. . . . . . . 12.2.1 Debugging HIP applications</td><td>. . . . . . .</td><td>77</td></tr><tr><td>12.3</td><td colspan="2">Useful environment variables</td><td>. . . . . . .</td><td>79</td></tr><tr><td></td><td>12.3.1</td><td>. . . . Kernel enqueue serialization . . . . . . .</td><td>79</td></tr><tr><td></td><td>12.3.2</td><td>Making device visible . . . . . . . . . . .</td><td>79</td></tr><tr><td></td><td>12.3.3</td><td>Dump code object . .</td><td>79</td></tr><tr><td></td><td>12.3.4</td><td>. . . . . . . . . . . HSA-related environment variables (Linux)</td><td>80</td></tr><tr><td></td><td colspan="2">12.3.5 HIP environment variable summary . .</td><td>.</td><td>80</td></tr><tr><td>12.4</td><td colspan="2">General debugging tips . . .</td><td>. . . . . . . . . . . .</td><td>82</td></tr><tr><td colspan="3">13 Logging HIP activity</td><td>83</td></tr><tr><td>13.1</td><td colspan="2">Logging level . . . . . . . .</td><td>. . . . . . . . . . . .</td><td>83</td></tr><tr><td>13.2</td><td colspan="2">Logging mask . . . . .</td><td>. . .</td><td>84</td></tr><tr><td>13.3</td><td colspan="2">. . . . . . . . . . . Logging command . . . . . . . . . . . . . .</td><td>. . .</td><td>84</td></tr><tr><td>13.4</td><td colspan="2">Logging examples . . . . . .</td><td>. . . . . . . . . . .</td><td>85</td></tr><tr><td colspan="3">14 Cooperative groups . . . . . . . . . . . .</td><td>89</td></tr><tr><td>14.1</td><td colspan="2">Cooperative groups thread model . . .</td><td>89</td></tr><tr><td>14.2</td><td colspan="2">Group types . . . . . . . . group</td><td>. . . . . . . . .</td><td>90</td></tr><tr><td></td><td>14.2.1</td><td>Thread-block . . . . . . . . . . . . .</td><td>90</td></tr><tr><td></td><td>14.2.2</td><td>Grid group . . . . . . . . . . . . . .</td><td>90</td></tr><tr><td></td><td>14.2.3</td><td>. Multi-grid group . . . . . . . . . . . . .</td><td>90</td></tr><tr><td></td><td>14.2.4 14.2.5</td><td>Thread-block tile . . . . . . . . . . . . . Coalesced groups . . . . . . . . . . . . .</td><td>91 91</td></tr><tr><td>14.3</td><td colspan="2">Cooperative groups simple example . .</td><td>. . . . . .</td><td>92</td></tr><tr><td>14.4</td><td colspan="2">Synchronization . . . . . .</td><td>. . . . . . . .</td><td>94</td></tr><tr><td>14.5</td><td colspan="2">. . . .</td><td>. . . .</td><td>97</td></tr><tr><td></td><td colspan="2">Unsupported NVIDIA CUDA features . . .</td><td></td></tr><tr><td colspan="3">15 Unified memory</td><td>99</td></tr><tr><td>15.1</td><td colspan="2">Unified memory . . .</td><td>. . . . . . . . . . . . . . .</td><td>99 99</td></tr><tr><td>15.2</td><td colspan="2">System requirements . . . . .</td><td>. . . . . . . . . . .</td><td>100</td></tr><tr><td>15.3</td><td colspan="2">Unified memory programming models</td><td>. . . . . .</td><td></td></tr><tr><td></td><td>15.3.1</td><td>Checking unified memory management support</td><td>100</td></tr><tr><td></td><td colspan="2">15.3.2 Example for unified memory management</td><td>101</td></tr><tr><td>15.4</td><td colspan="2">Using unified memory management (UMM)</td><td>. . .</td><td>104</td></tr><tr><td>15.5</td><td colspan="2">Unified memory HIP runtime hints . . . . .</td><td>for the better performance</td><td>104</td></tr><tr><td></td><td>15.5.1</td><td>Data prefetching . . . . . . . . .</td><td>105</td></tr><tr><td></td><td>15.5.2</td><td>Memory advice . . . . . . . . . . . . . .</td><td>106 107</td></tr><tr><td></td><td>15.5.3 15.5.4</td><td>Memory range attributes . . . . . . . . . Asynchronously attach memory to a stream</td><td>108</td></tr><tr><td colspan="3">16 Virtual memory management</td><td>109</td></tr></tbody></table>
-<p><strong>**Following table contains:** The table represents a comparison of preprocessor defines related to HIP (Heterogeneous-Compute Interface for Portability) and NVCC (NVIDIA CUDA Compiler) across different compiler environments. Each row corresponds to a specific preprocessor define, and the columns indicate the status or value of these defines when using different compilers: HIP-Clang, NVCC, and other compilers like GCC, ICC, or Clang.
-
-- **Columns:**
-  - "Define": Lists the specific preprocessor defines being compared.
-  - "HIP-Clang": Indicates the status or value of each define when using the HIP-Clang compiler.
-  - "NVCC": Indicates the status or value of each define when using the NVCC compiler.
-  - "Other (GCC, ICC, Clang, etc.)": Indicates the status or value of each define when using other compilers such as GCC, ICC, or Clang.
-
-- **Noteworthy Values:**
-  - `__HIP_PLATFORM_AMD__` is defined in HIP-Clang and other compilers if targeting the AMD platform, but undefined in NVCC.
-  - `__HIP_PLATFORM_NVIDIA__` is defined in NVCC and other compilers if targeting the NVIDIA platform, but undefined in HIP-Clang.
-  - `__HIP_DEVICE_COMPILE__` is defined as 1 if compiling for the device in both HIP-Clang and NVCC, but is undefined in other compilers.
-  - `__HIPCC__` is consistently defined in both HIP-Clang and NVCC, but undefined in other compilers.
-  - `__HIP_ARCH_*` can be 0 or 1 depending on feature support in HIP-Clang and NVCC, but is always 0 in other compilers.
-  - `__CUDACC__` is defined if the source code is compiled by NVCC, but undefined in HIP-Clang and other compilers.
-
-This table provides a clear overview of how different compilers handle specific preprocessor defines related to HIP and NVCC, highlighting the differences in platform targeting and compilation contexts.</strong></p>
-<table><tbody><tr><td>16.1</td><td>Memory allocation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16.1.1</td><td>. . . 109 . . .</td></tr><tr><td></td><td>Allocate physical memory . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>109</td></tr><tr><td>16.1.2</td><td>Reserve virtual address range . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . 110</td></tr><tr><td>16.1.3</td><td>Set memory access . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . 110</td></tr><tr><td></td><td>Free virtual memory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . 110</td></tr><tr><td>16.2</td><td>16.1.4 Memory usage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . 111</td></tr><tr><td></td><td>16.2.1 Dynamically increase allocation size . . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . 111</td></tr><tr><td colspan="2">17 Frequently asked questions</td><td>113</td></tr><tr><td>17.1</td><td>What APIs and features does HIP support? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . 113</td></tr><tr><td>17.2</td><td>What is not supported? . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . 113</td></tr><tr><td></td><td>17.2.1 Runtime/Driver API features . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . 113</td></tr><tr><td></td><td>17.2.2 Kernel language features . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . 114</td></tr><tr><td>17.3 Is</td><td>HIP a drop-in replacement for CUDA? . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . 114</td></tr><tr><td>17.4</td><td>What specific version of CUDA does HIP support? . . . . . . . . . . . . . . . . . . . .</td><td>. . . 114</td></tr><tr><td>17.5</td><td>What libraries does HIP support? . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . 115</td></tr><tr><td>17.6</td><td>How does HIP compare with OpenCL? . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . 115</td></tr><tr><td>17.7</td><td>How does porting CUDA to HIP compare to porting CUDA to OpenCL? . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . 115</td></tr><tr><td>17.8</td><td>What hardware does HIP support? . . . . . . . .</td><td>. . . 116</td></tr><tr><td>17.9</td><td>Do HIPIFY tools automatically convert all source code? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . 116</td></tr><tr><td>17.10</td><td>What is NVCC? . . . . . . . . . . . . . . . .</td><td>. . . 116</td></tr><tr><td>17.11</td><td>. . What is HIP-Clang? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . 116</td></tr><tr><td>17.12</td><td>Why use HIP rather than supporting CUDA directly? . . . . . . . . . . . . . . . . . . .</td><td>. . . 116 117</td></tr><tr><td>17.13</td><td>Can I develop HIP code on an NVIDIA CUDA platform? . . . . . . . . . . . . . . . . Can I develop HIP code on an AMDHIP-Clang platform? . . . . . . . . . . . . . . . .</td><td>. . . . . . 117</td></tr><tr><td>17.14</td><td>How to use HIP-Clang to build HIP programs? . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . 117</td></tr><tr><td>17.15</td><td>. . . . . . . . . . . . . .</td><td></td></tr><tr><td>17.16 17.17</td><td>What is AMDclr? . . . . . . . . . . . . . . . . . . . What is hipother? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . 117 . . . 118</td></tr><tr><td>17.18</td><td>Can I get HIP open source repository . . . . . . . . . . . . . . . .</td><td>. . . 118</td></tr><tr><td>17.19</td><td>for Windows? . . . Can a HIP binary run on both AMDand NVIDIA platforms? .</td><td>. . . 118</td></tr><tr><td>17.20 or</td><td>. . . . . . . . . . . . . On HIP-Clang, can I link HIP code with host code compiled with another compiler such clang? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>icc, . . . 118</td></tr><tr><td>17.21</td><td>Can HIP API support C style application? What is the difference between C and C++? . .</td><td>. . . 118</td></tr><tr><td>17.22</td><td>Can I install both CUDA SDK and HIP-Clang on the same machine? . . . . . . . . .</td><td>. . . 119</td></tr><tr><td>17.23</td><td>HIP detected my platform (HIP-Clang vs NVCC) incorrectly * what should I do? . . . . . . . . . . . . . . .</td><td>. . . 119</td></tr><tr><td>17.24</td><td>On CUDA, can I mix CUDA code with HIP code? . . . . . . . . . . . . . .</td><td>. . . 120</td></tr><tr><td>17.25</td><td>How do I trace HIP application flow? . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . 120</td></tr><tr><td>17.26</td><td>What are the maximum limits of kernel launch parameters? . . . . . . . . . . . . . . .</td><td>. . . 120</td></tr><tr><td>17.27</td><td>Are __shfl_*_sync functions supported on HIP platform? . . . . . . . . . . . . . . .</td><td>. . . 120</td></tr><tr><td>17.28</td><td>How to create a guard for code that is specific to the host or the GPU? . . . . . . . . . .</td><td>. . . 120</td></tr><tr><td>17.29</td><td>Why _OpenMP is undefined when compiling with -fopenmp ? . . . . . . . . . . . . . .</td><td>. . . 121</td></tr><tr><td>17.30</td><td>Does the HIP-Clang compiler support extern shared declarations? . . . . . . . . . . . .</td><td>. . . 121 code</td></tr><tr><td>17.31</td><td>I have multiple HIP enabled devices and I am getting an error hipErrorSharedObjectInitFailed with the message &#x27;Error: shared object initialization failed&#x27;? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . 121</td></tr><tr><td>17.32</td><td>How to use per-thread default stream in HIP? . . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . 122</td></tr><tr><td>17.33</td><td>How to use complex multiplication and division operations? . . . . . . . . .</td><td>. . . 122</td></tr><tr><td>17.34</td><td>. . . . . . Can I develop applications with HIP APIs on Windows the same on Linux? . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . 122</td></tr><tr><td>17.35</td><td>Does HIP support LUID? . . . . . . . . . . .</td><td>. . . 123</td></tr><tr><td>17.36</td><td>How can I know the version of HIP? . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . 123</td></tr><tr><td>18 HIP Runtime 18.1 Related</td><td>API Reference Pages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>125 . . . 126</td></tr></tbody></table>
-<p>18.3</p>
-<p>Namespaces</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>126</p>
-<p><strong>**Following table contains:** The table represents a set of device capabilities and properties related to atomic operations and other features in a computing architecture, likely related to GPU programming with HIP (Heterogeneous-Compute Interface for Portability).
-
-- **Rows**: Each row corresponds to a specific feature or set of features that can be queried or defined in the device code. These features are related to atomic operations, double-precision support, and warp-level operations.
-
-- **Columns**:
-  1. **Define (use only in device code)**: This column lists preprocessor macros that can be used in device code to check for the availability of certain features.
-  2. **Device Property (run-time query)**: This column provides the runtime query names that can be used to check if the device supports the corresponding features.
-  3. **Comment**: This column gives a brief description of what each feature or set of features does, such as supporting 32-bit or 64-bit atomic operations, double-precision floating point operations, or warp-level operations.
-
-- **Noteworthy Values**:
-  - The table distinguishes between 32-bit and 64-bit atomic operations, indicating different levels of precision and memory scope (global vs. shared).
-  - The presence of features like `__HIP_ARCH_HAS_DOUBLES__` suggests support for double-precision floating-point operations.
-  - Warp-level operations such as vote, ballot, shuffle, and funnel shift are highlighted, indicating advanced parallel processing capabilities.
-
-Overall, the table provides a concise overview of the capabilities that can be queried or defined in device code for optimizing and utilizing specific hardware features.</strong></p>
-<table><tbody><tr><td></td><td>18.3.1</td><td colspan="2">Namespace List . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td>18.3.2</td><td colspan="2">Namespace Members . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td colspan="2">18.3.2.1 Namespace Members . . . . .</td><td>126</td></tr><tr><td></td><td></td><td colspan="2">18.3.2.2 Namespace Members .</td><td>126</td></tr><tr><td>18.4</td><td colspan="3">. . . . . Data Structures . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td>18.4.1 Data</td><td colspan="2">Structures . . . . . . . .</td><td>. .</td><td>126</td></tr><tr><td></td><td>18.4.2</td><td colspan="2">. . . Data Structure Index . . . . . . . .</td><td>126</td></tr><tr><td></td><td>18.4.3</td><td colspan="2">. . . Class Hierarchy . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td>18.4.4</td><td colspan="2">. . Data Fields . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td colspan="2">18.4.4.1 All . . . . . . . . . . . . . .</td><td>.</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.1</td><td>Data Fields . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.2</td><td>Data Fields . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.3</td><td>Data Fields . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.4</td><td>Data Fields . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.5</td><td>Data Fields . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.6</td><td>Data Fields . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.7</td><td>. Data Fields . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.8</td><td>Data Fields . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.9</td><td>Data Fields . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.10</td><td>Data Fields . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.11</td><td>Data Fields . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.12</td><td>Data Fields . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.13</td><td>Data Fields . . . . . Data Fields .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.14</td><td>. . . . Data Fields</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.15</td><td>. . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.16</td><td>Data Fields . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.17</td><td>Data Fields . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.18</td><td>Data Fields . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.19</td><td>Data Fields . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.20</td><td>Data Fields . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.21</td><td>Data Fields . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.22</td><td>Data Fields . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.23</td><td>Data Fields . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.24</td><td>Data Fields . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.25</td><td>. Data Fields . . . . .</td><td>126 126</td></tr><tr><td></td><td colspan="3">18.4.4.2 Data Fields - Functions . . . . . . . . . . . . . 18.4.4.3 Variables . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.3.1</td><td>Data Fields - Variables</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.3.2</td><td>Data Fields - Variables</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.3.3</td><td>Data Fields - Variables</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.3.4</td><td>Data Fields - Variables</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.3.5</td><td>Data Fields - Variables</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.3.6</td><td>Data Fields - Variables</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.3.7</td><td>Data Fields - Variables</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.3.8</td><td>Data Fields - Variables</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.3.9</td><td>Data Fields - Variables</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.3.10</td><td>Data Fields - Variables</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.3.11</td><td>Data Fields - Variables</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.3.12</td><td>Data Fields - Variables</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.3.13</td><td>Data Fields - Variables</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.3.14 18.4.4.3.15</td><td>Data Fields - Variables Data Fields - Variables</td><td>126 126</td></tr><tr><td></td><td></td><td>18.4.4.3.16</td><td>Data Fields - Variables</td><td>126</td></tr></tbody></table>
-<p>18.4.4.3.17</p>
-<p>Data Fields - Variables</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>126</p>
-<p><strong>**Following table contains:** The table represents a list of compiler options for GPU code generation, specifically related to AMD GPUs. Each row corresponds to a different compiler option that can be used when compiling code for AMD GPUs.
-
-The columns in the table are:
-- "Option": This column lists the command-line options that can be used with the compiler.
-- "Description": This column provides a detailed explanation of what each option does.
-
-Noteworthy values include:
-- The option "--amdgpu-target=<gpu_arch>" is marked as deprecated, indicating that it is being replaced by "--offload-arch=<target>".
-- The option "-ggdb" is specifically recommended for debugging GPU code using ROCm's GDB.
-- The option "--fgpu-rdc" allows for generating relocatable device code, which is useful for calling device functions across different translation units.
-- The "-O<n>" option allows specifying the optimization level, which is a common feature in compilers to control the trade-off between compilation time and performance of the generated code.</strong></p>
-<table><tbody><tr><td></td><td></td><td>18.4.4.3.18</td><td>Data Fields - Variables</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.3.19</td><td>Data Fields - Variables</td><td>. . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.3.20</td><td>Data Fields -</td><td>Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.3.21</td><td>Data Fields - Variables</td><td>. . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.3.22</td><td>Data</td><td>Fields - Variables . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.3.23</td><td>Data Fields -</td><td>. . . . . . Variables . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.3.24</td><td>Data</td><td>Fields - Variables . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.3.25</td><td>Data</td><td>Fields - Variables . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td>18.5</td><td colspan="3">18.4.4.4 Data Fields - Related Symbols . .</td><td>. . . . . . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . 126 . . . . . . . . .</td><td>126</td></tr><tr><td></td><td>Files 18.5.1</td><td>File List . . . . .</td><td>. . . . . . . . . . . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td>18.5.2</td><td>Globals . . .</td><td>. . . . . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.5.2.1 All . .</td><td>. . . . . . . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.5.2.1.1</td><td>Globals . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.5.2.1.2</td><td>Globals . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.5.2.1.3</td><td>Globals . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.5.2.1.4</td><td>Globals . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.5.2.1.5</td><td>Globals . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.5.2.1.6</td><td>Globals . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.5.2.1.7</td><td>Globals . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.5.2.1.8</td><td>Globals . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.5.2.1.9</td><td>Globals</td><td></td><td>126</td></tr><tr><td></td><td></td><td></td><td>. .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.5.2.2 Functions 18.5.2.2.1</td><td>. . . . . . . Globals . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.5.2.2.2</td><td>Globals . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.5.2.2.3</td><td>Globals . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.5.2.3 Globals</td><td>. . . . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.5.2.4 Globals</td><td>. . . . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td></td><td>. . . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.5.2.5 Globals</td><td>Enumerator . . . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.5.2.6 18.5.2.6.1</td><td>Globals . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.5.2.6.2</td><td>Globals .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>Globals</td><td>.</td><td>. . . .</td><td></td></tr><tr><td></td><td>18.5.2.7</td><td></td><td>. . . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td colspan="3">C++ language extensions</td><td></td><td>127</td></tr><tr><td>19.1</td><td>Function-type</td><td>qualifiers</td><td>. . . . . . . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>127 127</td></tr><tr><td></td><td>19.1.1</td><td>__device__ . .</td><td>. . . . . . . . . . . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>128</td></tr><tr><td></td><td>19.1.2</td><td>__global__</td><td>. . . . . .</td><td></td><td></td></tr><tr><td></td><td>19.1.3</td><td>__host__ . . .</td><td>. . . . . . . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>128</td></tr><tr><td>19.2 19.3</td><td colspan="3">Calling __global__ functions . . . . .</td><td>. . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>128 129</td></tr><tr><td>19.4</td><td colspan="3">Kernel launch example . . . . . . . . Variable type qualifiers . . . . . . . .</td><td>. .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>130</td></tr><tr><td></td><td colspan="3">.</td><td></td><td>130</td></tr><tr><td></td><td>19.4.1</td><td>__constant__</td><td>. . . . . . . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td></td></tr><tr><td></td><td>19.4.2</td><td>__shared__ .</td><td>. . . . . . . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>130</td></tr><tr><td></td><td>19.4.3</td><td>__managed__ .</td><td>. . . . . . . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>130</td></tr><tr><td></td><td>19.4.4</td><td>__restrict__</td><td>. . . . . . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>130</td></tr><tr><td>19.5</td><td colspan="3">. Built-in variables . . . . . . . . . . .</td><td>. .</td><td>. . . . . . . . .</td><td>130</td></tr><tr><td></td><td>19.5.1</td><td>Coordinate built-ins</td><td>. . . . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>130</td></tr><tr><td></td><td>19.5.2</td><td>warpSize . . .</td><td>. . . . . . . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>131</td></tr><tr><td>19.6</td><td colspan="3">Vector types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . . . . . . .</td><td>131</td></tr><tr><td></td><td>19.6.1</td><td>Short vector types</td><td>. . . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>131</td></tr><tr><td>19.7</td><td colspan="3">19.6.2 dim3 . . . . . . . . . . . . . . . . . . Memory fence instructions . . . . . . . . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132</td><td>132</td></tr></tbody></table>
-<p>19.8</p>
-<p>Synchronization functions</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>132</p>
-<p><strong>**Following table contains:** The table appears to represent a comparison of different formats used in GPU programming or compilation, specifically focusing on how code objects are handled in different environments or compilers. Each row represents a specific format or method of handling code objects.
-
-- **Columns:**
-  - **Format:** This column lists the type of code object or binary format being discussed.
-  - **APIs:** This column describes the API functions associated with loading or handling the code objects in the specified format.
-  - **NVCC:** This column indicates the file types or formats used when compiling with NVCC (NVIDIA's CUDA Compiler), such as `.cubin` or PTX text, and `.fatbin`.
-  - **HIP-CLANG:** This column specifies the file types or formats used when compiling with HIP-CLANG, such as `.hsaco` and `.hip_fatbin`.
-
-- **Noteworthy Values:**
-  - The table highlights that different compilers or environments (NVCC vs. HIP-CLANG) use different file formats for code objects, with NVCC using `.cubin` or PTX text and `.fatbin`, while HIP-CLANG uses `.hsaco` and `.hip_fatbin`.
-  - The APIs column lists specific functions (`hipModuleLoad`, `hipModuleLoadData`, `hipModuleLoadFatBin`) that are relevant for loading these code objects, indicating a focus on HIP (Heterogeneous-Compute Interface for Portability) API functions.</strong></p>
-<table><tbody><tr><td></td><th>.</th><td>. .</td><td></td></tr><tr><th>19.9</th><th>Math</th><td>functions . . . . . . . . . . .</td><td>132</td></tr><tr><th>19.10</th><th>Texture</th><td>functions . . . . . . . . . . . . .</td><td>133</td></tr><tr><th>19.11</th><th>Surface</th><td>functions . . . . . . . . . . . . .</td><td>133</td></tr><tr><th>19.12</th><th>Timer</th><td>functions . . . . . . . . . . . . . .</td><td>137</td></tr><tr><th>19.13</th><th>Atomic</th><td>functions</td><td>138</td></tr><tr><td></td><th>19.13.1</th><td>. . . . . . . . . . . . . Unsafe floating-point atomic RMWoperations</td><td>139</td></tr><tr><th>19.14</th><th>Warp cross-lane</th><td>functions . .</td><td>140</td></tr><tr><td></td><th>19.14.1</th><td>. . . . . . Warp vote and ballot functions .</td><td>140</td></tr><tr><td></td><th>19.14.2 Warp</th><td>match functions . . . . .</td><td>141</td></tr><tr><td></td><th>19.14.3</th><td>. Warp shuffle functions . . . . .</td><td>142</td></tr><tr><th>19.15</th><th>Cooperative groups</th><td>functions . . . . . .</td><td>142</td></tr><tr><th>19.16</th><th>Warp matrix</th><td>functions . . . . . . .</td><td>143</td></tr><tr><th>19.17</th><th>Independent</th><td>. . . thread scheduling . . . . . .</td><td>144</td></tr><tr><th>19.18</th><th>Profiler</th><td>Counter Function . . . . . . . .</td><td>144</td></tr><tr><th>19.19</th><th>Assert . . . . .</th><td>. . . . . . . . . . . . . .</td><td>144</td></tr><tr><th>19.20</th><th>. . . .</th><td>printf . . . . . . . . . . . . . .</td><td>144</td></tr><tr><th>19.21</th><td></td><td>Device-Side Dynamic Global Memory Allocation . . . . . . . .</td><td>145</td></tr><tr><th>19.22</th><td></td><td>__launch_bounds__ . .</td><td>145</td></tr><tr><td></td><th>19.22.1</th><td>Compiler Impact . . . . . . . .</td><td>145</td></tr><tr><td></td><th>19.22.2</th><td>CU and EU Definitions . . . . .</td><td>146 146</td></tr><tr><td></td><th>19.22.3 19.22.4 maxregcount</th><td>Porting from CUDA __launch_bounds . . . . . . . . . .</td><td>146</td></tr><tr><th>19.23</th><td></td><td>Asynchronous Functions . . . . . . . . .</td><td>147</td></tr><tr><td></td><th>19.23.1</th><td>Memory stream . . . . . . . . .</td><td>147</td></tr><tr><td></td><th>19.23.2</th><td>Peer to peer . . . . . .</td><td>163</td></tr><tr><td></td><th>19.23.3</th><td>. . . . . Memory management . . .</td><td>165</td></tr><tr><td></td><th>19.23.4</th><td>. . . External Resource Interoperability</td><td>195</td></tr><tr><td></td><th>Register</th><td>Keyword . . . . . . . . . . . . .</td><td>197</td></tr><tr><th>19.24</th><th>19.25 Pragma</th><td>Unroll . . . . . . . . . . . . .</td><td>198</td></tr><tr><th>19.26</th><th>In-Line</th><td>Assembly . . . . . . . . . . . .</td><td>198</td></tr><tr><th>19.27</th><th>Kernel</th><td>Compilation . . . . . . . . . . .</td><td>198</td></tr><tr><th>19.28</th><td></td><td></td><td></td></tr><tr><td></td><td></td><td>gfx-arch-specific-kernel . . . . . . . . .</td><td>199</td></tr><tr><th>C++ language 20.1</th><th>20.1.1</th><td>Modern C++ support . . . . . . . . . . . C++11 support . . . . . . . . .</td><td>201 201</td></tr><tr><td></td><th>20.1.2</th><td>C++14 support . . . . . . . . .</td><td>202</td></tr><tr><td></td><th>20.1.3</th><td>C++17 support . . . . . . . . .</td><td>202</td></tr><tr><td></td><th>20.1.4</th><td>C++20 support . . . . . . . . .</td><td>202</td></tr><tr><th>20.2</th><th>Extensions</th><td>and restrictions . . . . . . . .</td><td>202</td></tr><tr><td></td><th>20.2.1</th><td>Global functions . .</td><td>202</td></tr><tr><td></td><th>20.2.2</th><td>. . . . . . Device space memory specifiers . . . .</td><td>202</td></tr><tr><td></td><th>20.2.3</th><td>Exception handling . . . . .</td><td>203</td></tr><tr><td></td><th>20.2.4</th><td>Kernel parameters . . . . . .</td><td>203</td></tr><tr><td></td><th>20.2.5</th><td>Classes . . . .</td><td>203</td></tr><tr><td></td><th>20.2.6</th><td>. . . . . . . . . Polymorphic function wrappers .</td><td>203</td></tr><tr><td></td><th>20.2.7</th><td>Extended lambdas . . . . . . . .</td><td>203</td></tr><tr><td></td><td></td><td>Inline namespaces</td><td></td></tr><tr><td></td><th>20.2.8</th><td>. . . . . . .</td><td>203</td></tr><tr><td></td><td></td><td>.</td><td>205</td></tr><tr><th>21 HIP math</th><th colspan="2">API</th><td>205</td></tr><tr><th>21.1</th><th colspan="2">Single precision mathematical functions . . . . Double precision mathematical functions . . . Integer . . . .</th><td>215</td></tr><tr><th>21.2</th><th colspan="2">intrinsics . . . . . . . . . . . .</th><td></td></tr><tr><th>21.3</th><td></td><td></td><td>225</td></tr></tbody></table>
-<p><strong>**Following table contains:** The table represents a mapping between different types used in HIP (Heterogeneous-Compute Interface for Portability), CUDA Driver API, and CUDA Runtime API. Each row corresponds to a specific type in HIP and its equivalent in the CUDA Driver and CUDA Runtime APIs.
-
-- **Columns:**
-  - **HIP Type:** Lists the types used in the HIP API.
-  - **CU Driver Type:** Lists the corresponding types in the CUDA Driver API.
-  - **CUDA Runtime Type:** Lists the corresponding types in the CUDA Runtime API, if applicable.
-
-- **Noteworthy Values:**
-  - Some HIP types have corresponding types in both the CUDA Driver and CUDA Runtime APIs, such as `hipStream_t` which maps to `CUstream` in the CUDA Driver API and `cudaStream_t` in the CUDA Runtime API.
-  - Other HIP types, like `hipModule_t`, have a corresponding type only in the CUDA Driver API (`CUmodule`) and no equivalent listed in the CUDA Runtime API.
-  - The absence of a CUDA Runtime Type for some HIP types suggests that not all HIP types have direct equivalents in the CUDA Runtime API.</strong></p>
-<table><tbody><tr><td></td><td>21.4</td><td>Floating-point Intrinsics . . . . . . . . . . . . . .</td><td>227</td></tr><tr><td>22</td><td>Table</td><td>comparing syntax for different compute APIs</td><td>231</td></tr><tr><td></td><td>22.1</td><td>Notes . . . . . . . . . . . . . . . . . . . . . . . .</td><td>232</td></tr><tr><td>23</td><td>HIP</td><td>Cooperative groups API</td><td>233</td></tr><tr><td></td><td>23.1</td><td>Cooperative kernel launches . . . . . . . . . . . .</td><td>233</td></tr><tr><td></td><td>23.2</td><td>Cooperative groups classes . . . . . . . . . . . . .</td><td>234</td></tr><tr><td></td><td>23.3</td><td>Cooperative groups construct functions . . . .</td><td>237</td></tr><tr><td></td><td>23.4</td><td>. . Cooperative groups exposed API functions . . . .</td><td>238</td></tr><tr><td>24</td><td colspan="2">HSA runtime API for ROCm</td><td>241</td></tr><tr><td>25</td><td colspan="2">HIP managed memory allocation API</td><td>247</td></tr><tr><td>26</td><td colspan="2">HIP virtual memory management API</td><td>251</td></tr><tr><th>27</th><th>HIP deprecated</th><th>runtime API functions</th><td></td></tr><tr><td></td><td></td><td></td><td>257</td></tr><tr><td></td><td>27.1</td><td>Context management . . . . . . . . . . . . . . . .</td><td>257</td></tr><tr><td></td><td>27.2</td><td>Memory management . . . . . . . . . . . . . . . . . .</td><td>258</td></tr><tr><td></td><td>27.3</td><td>Profiler control . . . . . . . . . . . . . . . .</td><td>258</td></tr><tr><td></td><td>27.4</td><td>Texture management . . . . . . . . . . . . . . . .</td><td>258</td></tr><tr><td>28</td><td colspan="2">SAXPY - Hello, HIP</td><td>261</td></tr><tr><td></td><td colspan="2">28.1 Prerequisites . . . . . .</td><td>. . . . . . . . . . .</td><td>261</td></tr><tr><td></td><td colspan="2">. . . 28.2 Heterogeneous programming</td><td>. . . . . . . . .</td><td>261</td></tr><tr><td></td><td colspan="2">. . 28.3 Your first lines of HIP code . . .</td><td>. . . . . .</td><td>261</td></tr><tr><td></td><td colspan="2">. . . 28.4 Compiling on the command line . . . .</td><td>. . . . . .</td><td>263</td></tr><tr><td></td><td colspan="2">28.4.1 Setting up the command line</td><td>. . . . . . .</td><td>263</td></tr><tr><td></td><td>28.4.2</td><td>Invoking the compiler manually . . . . .</td><td>266</td></tr><tr><td>29</td><td colspan="2">Reduction</td><td>273</td></tr><tr><td></td><td colspan="2">29.1 The algorithm . . . 29.2</td><td>. . . . . . . . . . . . . . . .</td><td>273</td></tr><tr><td></td><td colspan="2">Reduction on GPUs</td><td>. . . . . . . . . . . . . . . .</td><td>273</td></tr><tr><td></td><td colspan="2">29.2.1 Naive shared reduction</td><td>. . . . . . . . . .</td><td>274</td></tr><tr><td></td><td>29.2.2</td><td>Reducing thread divergence . . . . . . . .</td><td>276</td></tr><tr><td></td><td>29.2.3</td><td>Resolving bank conflicts . . . . . . . . .</td><td>276</td></tr><tr><td></td><td>29.2.4</td><td>Utilize upper half of the block . . . . . . . . . . . . .</td><td>277</td></tr><tr><td></td><td>29.2.5</td><td>Unroll all loops . . . . . . .</td><td>281</td></tr><tr><td></td><td>29.2.6</td><td>Communicate using warp-collective functions</td><td>282</td></tr><tr><td></td><td>29.2.7</td><td>Prefer warp communication over shared</td><td>282</td></tr><tr><td></td><td>29.2.8</td><td>. Amortize bookkeeping variable overhead</td><td>284</td></tr><tr><td></td><td colspan="2">29.2.8.1 Reading ItemsPerThread</td><td>. . .</td><td>285</td></tr><tr><td></td><td colspan="2">29.2.8.2 Processing ItemsPerThread</td><td>. .</td><td>286</td></tr><tr><td></td><td colspan="2">29.2.9 Two-pass reduction</td><td>. . . . . . . . . . . .</td><td>286</td></tr><tr><td></td><td colspan="2">29.2.10 Global data share</td><td>. . . . . . . . . . . . .</td><td>286</td></tr><tr><td></td><td colspan="2">29.3 Conclusion . . . . .</td><td>. . . . . . . . . . . . . . . .</td><td>287</td></tr><tr><td>30</td><td colspan="2">Cooperative groups .</td><td>289</td></tr><tr><td></td><td colspan="2">30.1 Prerequisites</td><td>. . . . . . . . . . . . . . . . . . .</td><td>289</td></tr><tr><td></td><td colspan="2">30.2 Simple HIP Code</td><td>. . . . . . . . . . . . . . . . . .</td><td>289</td></tr><tr><td></td><td colspan="2">Tiled partition</td><td>. . . . . . .</td><td>289</td></tr><tr><td></td><td colspan="2">30.3 . . . . . . . . . . . . 30.3.1 Device-side code . . . . . .</td><td>. . .</td><td>290</td></tr><tr><td></td><td colspan="2">. . . . 30.3.1.1 1. Initialization of the reduction</td><td>291</td></tr><tr><td></td><td colspan="2">function variables . . . 30.3.1.2 2. The reduction of thread block . . . . . . . . . . . .</td><td>291</td></tr></tbody></table>
-<p><strong>**Following table contains:** The table represents a list of environment variables related to AMD's HIP (Heterogeneous-compute Interface for Portability) and their configurations. Each row corresponds to a specific environment variable, detailing its default value and usage instructions.
-
-- **Columns:**
-  - **Environment variable:** The name of the environment variable.
-  - **Default value:** The default setting or value assigned to the variable.
-  - **Usage:** A description of how the variable can be used, including possible values and their meanings.
-
-- **Noteworthy Values:**
-  - The `AMD_LOG_LEVEL` and `AMD_LOG_MASK` variables provide detailed logging options, with various levels and masks to control the granularity of the logs.
-  - `HIP_LAUNCH_BLOCKING` and `AMD_SERIALIZE_KERNEL` offer options for controlling kernel execution serialization, which can impact performance and debugging.
-  - `HIP_VISIBLE_DEVICES` allows for the selection of specific devices to be visible to HIP, which is useful in multi-GPU systems.
-  - `GPU_DUMP_CODE_OBJECT` and `HIP_HOST_COHERENT` control debugging and memory coherence settings, respectively.
-
-Overall, the table provides a comprehensive guide for configuring and debugging HIP applications by adjusting environment variables.</strong></p>
-<table><tbody><tr><td></td><td>30.3.1.3 3. The reduction of custom partition . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>291</td></tr><tr><td>30.3.2</td><td>Host-side code . . . . . . . . . . . .</td><td>292</td></tr><tr><td></td><td>30.3.2.1 1. Confirm the cooperative group support on AMDGPUs 30.3.2.2 . . . . .</td><td>292</td></tr><tr><td></td><td>2. Initialize the cooperative group configuration . . . . . . . . . . . . . . . . . . .</td><td>293</td></tr><tr><td>30.3.2.3 Conclusion</td><td>4. Launch the kernel . . . . .</td><td>293</td></tr><tr><td>30.4 .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>293</td></tr><tr><td>31 License</td><td></td><td>295</td></tr></tbody></table>
-<p>Index</p>
-<p>297</p>
-<p>The Heterogeneous-computing Interface for Portability (HIP) API is a C++ runtime API and kernel language that lets developers create portable applications for AMD and NVIDIA GPUs from single source code.</p>
-<p>For HIP supported AMD GPUs on multiple operating systems, see:</p>
-<ul>
-<li style="list-style-type: '· ';">Linux system requirements</li>
-<li style="list-style-type: '· ';">Microsoft Windows system requirements</li>
-</ul>
-<p>The CUDA enabled NVIDIA GPUs are supported by HIP. For more information, see GPU Compute Capability.</p>
-<p>On the AMD ROCm platform, HIP provides header files and runtime library built on top of HIP-Clang compiler in the repository Common Language Runtimes (CLR) , which contains source codes for AMD's compute languages runtimes as follows,</p>
-<p>On non-AMD platforms, like NVIDIA, HIP provides header files required to support non-AMD specific back-end implementation in the repository 'hipother', which translates from the HIP runtime APIs to CUDA runtime APIs.</p>
-<h2>Install</h2>
-<ul>
-<li style="list-style-type: '· ';">Installing HIP</li>
-<li style="list-style-type: '· ';">Building HIP from source</li>
-</ul>
-<h2>Conceptual</h2>
-<ul>
-<li style="list-style-type: '· ';">HIP programming model</li>
-<li style="list-style-type: '· ';">Hardware implementation</li>
-<li style="list-style-type: '· ';">AMD common language runtimes (CLR)</li>
-</ul>
-<h2>How to</h2>
-<ul>
-<li style="list-style-type: '· ';">Programming manual</li>
-<li style="list-style-type: '· ';">HIP porting guide</li>
-<li style="list-style-type: '· ';">HIP porting: driver API guide</li>
-<li style="list-style-type: '· ';">Programming for HIP runtime compiler (RTC)</li>
-<li style="list-style-type: '· ';">Performance guidelines</li>
-<li style="list-style-type: '· ';">Debugging with HIP</li>
-<li style="list-style-type: '· ';">Logging HIP activity</li>
-<li style="list-style-type: '· ';">Unified memory</li>
-<li style="list-style-type: '· ';">Virtual memory</li>
-<li style="list-style-type: '· ';">Cooperative groups</li>
-<li style="list-style-type: '· ';">Frequently asked questions</li>
-</ul>
-<h2>Reference</h2>
-<ul>
-<li style="list-style-type: '· ';">HIP Runtime API Reference</li>
-<li style="list-style-type: '· ';">C++ language extensions</li>
-<li style="list-style-type: '· ';">C++ language support</li>
-<li style="list-style-type: '· ';">HIP math API</li>
-<li style="list-style-type: '· ';">Comparing syntax for different APIs</li>
-<li style="list-style-type: '· ';">HSA runtime API for ROCm</li>
-<li style="list-style-type: '· ';">HIP managed memory allocation API</li>
-</ul>
-<h2>CHAPTER ONE</h2>
-<h2>OVERVIEW</h2>
-<ul>
-<li style="list-style-type: '· ';">HIP virtual memory management API</li>
-<li style="list-style-type: '· ';">HIP Cooperative groups API</li>
-<li style="list-style-type: '· ';">List of deprecated APIs</li>
-</ul>
-<h2>Tutorial</h2>
-<ul>
-<li style="list-style-type: '· ';">HIP basic examples</li>
-<li style="list-style-type: '· ';">HIP examples</li>
-<li style="list-style-type: '· ';">HIP test samples</li>
-<li style="list-style-type: '· ';">SAXPY tutorial</li>
-<li style="list-style-type: '· ';">Reduction tutorial</li>
-<li style="list-style-type: '· ';">Cooperative groups tutorial</li>
-</ul>
-<p>Known issues are listed on the HIP GitHub repository.</p>
-<p>To contribute features or functions to the HIP project, refer to Contributing to HIP. To contribute to the documentation, refer to Contributing to ROCm docs page.</p>
-<p>You can find licensing information on the Licensing page.</p>
-<h2>CHAPTER</h2>
-<h2>TWO</h2>
-<h2>INSTALL HIP</h2>
-<p>HIP can be installed on AMD (ROCm with HIP-Clang) and NVIDIA (CUDA with NVCC) platforms.</p>
-<p>Note: The version definition for the HIP runtime is different from CUDA. On an AMD platform, the hipRuntimeGerVersion function returns the HIP runtime version; on an NVIDIA platform, this function returns the CUDA runtime version.</p>
-<h2>2.1 Prerequisites</h2>
-<h2>AMD</h2>
-<p>Refer to the Prerequisites section in the ROCm install guides:</p>
-<ul>
-<li style="list-style-type: '· ';">System requirements (Linux)</li>
-<li style="list-style-type: '· ';">System requirements (Windows)</li>
-</ul>
-<h2>NVIDIA</h2>
-<p>Check the system requirements in the NVIDIA CUDA Installation Guide.</p>
-<h2>2.2 Installation</h2>
-<h2>AMD</h2>
-<p>HIP is automatically installed during the ROCm installation. If you haven't yet installed ROCm, you can find installation instructions here:</p>
-<ul>
-<li style="list-style-type: '· ';">ROCm installation for Linux</li>
-<li style="list-style-type: '· ';">HIP SDK installation for Windows</li>
-</ul>
-<p>By default, HIP is installed into /opt/rocm/hip .</p>
-<p>Note: There is no autodetection for the HIP installation. If you choose to install it somewhere other than the default location, you must set the HIP_PATH environment variable as explained in Build HIP from source.</p>
-<h2>NVIDIA</h2>
-<ol>
-<li style="list-style-type: '1. ';">Install the NVIDIA driver.</li>
-</ol>
-<p>sudo apt-get install ubuntu-drivers-common &amp;&amp; sudo ubuntu-drivers autoinstall sudo reboot</p>
-<p>Alternatively, you can download the latest CUDA Toolkit.</p>
-<ol>
-<li style="list-style-type: '2. ';">Install the hip-runtime-nvidia and hip-dev packages. This installs the CUDA SDK and HIP porting layer.</li>
-</ol>
-<p><strong>**Following code does:** This code snippet defines an enumeration `hipMemoryType` in C/C++ for the AMD platform, specifically within the HIP (Heterogeneous-Compute Interface for Portability) runtime API. The enumeration categorizes different types of memory based on their physical location and management. The types include:
-
-- `hipMemoryTypeHost`: Memory located on the host (CPU).
-- `hipMemoryTypeDevice`: Memory located on a specific device (GPU).
-- `hipMemoryTypeArray`: Array memory located on a specific device.
-- `hipMemoryTypeUnified`: Currently not used.
-- `hipMemoryTypeManaged`: Managed memory that is automatically handled by the unified memory system.
-
-This enumeration helps in identifying and managing different memory types in heterogeneous computing environments.</strong></p>
-<pre><code>  | apt-get install hi</code></pre>
-<p><strong>**Following code does:** The code snippet `<_Cuda_>` appears to be a placeholder or a symbolic representation rather than actual executable code. In the context of programming, particularly with Python, it might suggest a reference to CUDA, which is a parallel computing platform and application programming interface (API) model created by NVIDIA. CUDA allows developers to use a GPU for general purpose processing, which can significantly accelerate computations. However, without additional context or actual code, it is not possible to determine any specific functionality or purpose from this snippet alone.</strong></p>
-<pre><code>tall hip-runtime-nvidia hip-dev</code></pre>
-<h2>The default paths are:</h2>
-<ul>
-<li style="list-style-type: '· ';">CUDA SDK: /usr/local/cuda</li>
-<li style="list-style-type: '· ';">HIP: /opt/rocm/hip</li>
-</ul>
-<p>You can optionally add /opt/rocm/bin to your path, which can make it easier to use the tools.</p>
-<h2>2.3 Verify your installation</h2>
-<p>Run hipconfig in your installation path.</p>
-<p>/opt/rocm/bin/hipconfig --full</p>
-<p>CHAPTER</p>
-<h2>THREE</h2>
-<h2>BUILD HIP FROM SOURCE</h2>
-<h2>3.1 Prerequisites</h2>
-<p>HIP code can be developed either on AMD ROCm platform using HIP-Clang compiler, or a CUDA platform with nvcc installed. Before building and running HIP, make sure drivers and prebuilt packages are installed properly on the platform.</p>
-<p>You also need to install Python 3, which includes the CppHeaderParser package. Install Python 3 using the following command:</p>
-<p><strong>**Following code does:** It seems there is a formatting error in your request. The code snippet is labeled as C++ but is enclosed within Python code tags. Please provide the correct code snippet or clarify the language so I can assist you accurately.</strong></p>
-<pre><code>    | apt-get install python3</code></pre>
-<p>Check and install CppHeaderParser package using the command:</p>
-<p><strong>**Following code does:** It seems there is a formatting error in your request. The code snippet is labeled as Python, but it contains a placeholder that suggests it should be C++ code. Please provide the correct code snippet or clarify the language so I can assist you accurately.</strong></p>
-<pre><code>      | pip3 install CppHeaderParser</code></pre>
-<h2>3.2 Building the HIP runtime</h2>
-<p>Set the repository branch using the variable: ROCM_BRANCH . For example, for ROCm 6.1, use:</p>
-<p><strong>**Following code does:** This code snippet is part of a build process for a project that involves compiling CUDA code using the HIP (Heterogeneous-Compute Interface for Portability) compiler. The `export HIPCC_VERBOSE=1` command sets an environment variable to enable verbose output from the HIP compiler, which provides detailed information about the compilation process. The `make` command is then executed, which typically runs a Makefile to build the project. The output shown (`hipcc-cmd: ...`) indicates that the HIP compiler (`hipcc`) is being invoked to compile a CUDA source file (`backprop_cuda.cu`) with specific options, such as targeting the native architecture for offloading. This process is likely part of porting or optimizing CUDA code for different hardware using HIP.</strong></p>
-<pre><code>| export</code></pre>
-<p><strong>**Following code does:** The code snippet `<_Cuda_>` appears to be a placeholder or a symbolic representation rather than actual executable code. In the context of programming, "Cuda" typically refers to NVIDIA's parallel computing platform and application programming interface (API) model, which allows developers to use a CUDA-enabled graphics processing unit (GPU) for general purpose processing. However, without additional context or actual code, it's not possible to determine the specific functionality or purpose of this snippet. It might be used in documentation, pseudocode, or as a marker in a larger codebase to indicate where CUDA-related code or functionality is intended to be implemented.</strong></p>
-<pre><code><_Bash_></code></pre>
-<h2>AMD</h2>
-<ol>
-<li style="list-style-type: '1. ';">Get HIP source code.</li>
-</ol>
-<p>Note: Starting in ROCM 5.6, CLR is a new repository that includes the former ROCclr, HIPAMD and OpenCl repositories. OpenCL provides headers that ROCclr runtime depends on.</p>
-<p>Note: Starting in ROCM 6.1, a new repository hipother is added to ROCm, which is branched out from HIP. hipother provides files required to support the HIP back-end implementation on some non-AMD platforms, like NVIDIA.</p>
-<p><strong>**Following code does:** The provided code snippet appears to be a series of malformed XML declarations interspersed with various symbols and whitespace. It does not perform any functional operations or represent valid XML or Python code. Its high-level purpose is unclear, as it does not conform to any recognizable programming or markup language syntax. It seems to be a nonsensical or corrupted text rather than executable code.</strong></p>
-<pre><code><_Bash_></code></pre>
-<p><strong>**Following code does:** This code snippet is the beginning of a C++ program that is set up to use the HIP (Heterogeneous-computing Interface for Portability) API, which is designed for writing portable code that can run on both AMD and NVIDIA GPUs. The `#include` directives are used to include the necessary headers for HIP runtime functions (`hip_runtime.h` and `hip_runtime_api.h`) and standard C++ functionalities (`iostream` for input/output stream operations, `fstream` for file stream operations, and `vector` for using the vector container). This setup suggests that the program will likely involve GPU computations and possibly handle input/output operations and data storage using vectors.</strong></p>
-<pre><code>:lone -b "$ROCM_BRANCH" https://github.com/ROCm/clr.git
-:lone -b "$ROCM_BRANCH" https://github.com/ROCm/hip.git</code></pre>
-<p>CLR (Common Language Runtime) repository includes ROCclr, HIPAMD and OpenCL.</p>
-<p>ROCclr (Radeon Open Compute Common Language Runtime) is a virtual device interface which is defined on the AMD platform. HIP runtime uses ROCclr to interact with different backends.</p>
-<p>HIPAMD provides implementation specifically for HIP on the AMD platform.</p>
-<p>OpenCL provides headers that ROCclr runtime currently depends on. hipother provides headers and implementation specifically for non-AMD HIP platforms, like NVIDIA.</p>
-<ol>
-<li style="list-style-type: '2. ';">Set the environment variables.</li>
-<li style="list-style-type: '3. ';">Build HIP.</li>
-</ol>
-<p><strong>**Following code does:** This code snippet is a C++ program that includes headers for HIP (Heterogeneous-Compute Interface for Portability) runtime and API, which are used for GPU programming, particularly with AMD hardware. Additionally, it includes standard C++ headers for input/output operations (`iostream`), file handling (`fstream`), and using the vector container (`vector`). The purpose of this setup is likely to perform GPU-accelerated computations while also handling input/output operations and managing data using vectors in a C++ application.</strong></p>
-<pre><code><_Bash_></code></pre>
-<p><strong>**Following code does:** This code snippet is a C++ program that uses the HIP (Heterogeneous-Compute Interface for Portability) API to perform a vector copy operation on a GPU. The program is designed to work on both AMD and NVIDIA platforms, as indicated by the conditional compilation directives. Here's a high-level summary of what the code does:
-
-1. **Define Constants**: It defines constants for the length of the vectors (`LEN`) and the size in bytes (`SIZE`).
-
-2. **Platform-Specific File Names**: Depending on whether the code is compiled for an AMD or NVIDIA platform, it sets the appropriate file name for the compiled GPU kernel.
-
-3. **Initialize Vectors**: It allocates and initializes two float arrays, `A` and `B`, each of length `LEN`. Array `A` is initialized with sequential float values, while `B` is initialized with zeros.
-
-4. **GPU Initialization (NVIDIA only)**: If compiled for an NVIDIA platform, it initializes the HIP runtime, gets a device, and creates a context.
-
-5. **Memory Allocation on GPU**: It allocates memory on the GPU for both arrays `A` and `B`.
-
-6. **Data Transfer to GPU**: It copies the contents of arrays `A` and `B` from host memory to the allocated GPU memory.
-
-7. **Kernel Loading and Execution Setup**: It loads a GPU module from a file and retrieves a function (kernel) named "hello_world" from the module. It prepares the arguments for the kernel launch.
-
-The code is incomplete, as it ends abruptly, but it appears to be setting up for launching a GPU kernel that would likely perform some operation on the vectors `A` and `B`.</strong></p>
-<pre><code>        cd "$CLR_DIR"
-        mkdir -p build; cd build
-        cmake -DHIP_COMMON_DIR=$HIP_DIR -DHIP_PLATFORM=amd -DCMAKE_PREFIX_PATH="/opt/rocm/"_
-        ---DCMAKE_INSTALL_PREFIX=$PWD/install -DHIP_CATCH_TEST=0 -DCLR_BUILD_HIP=ON -DCLR_
-        --BUILD_OCL=OFF..
-        
-        make -j$(nproc)
-        sudo make install</code></pre>
-<p>Note: Note, if you don't specify CMAKE_INSTALL_PREFIX , the HIP runtime is installed at &lt;ROCM_PATH&gt;/hip .</p>
-<p>By default, release version of HIP is built. If need debug version, you can put the option CMAKE_BUILD_TYPE=Debug in the command line.</p>
-<p>Default paths and environment variables:</p>
-<ul>
-<li style="list-style-type: '· ';">HIP is installed into &lt;ROCM_PATH&gt;/hip . This can be overridden by setting the HIP_PATH environment variable.</li>
-</ul>
-<p>•</p>
-<p>HSA is in</p>
-<p>&lt;ROCM_PATH&gt;/hsa</p>
-<p>. This can be overridden by setting the</p>
-<p>HSA_PATH</p>
-<p>environment variable.</p>
-<ul>
-<li style="list-style-type: '· ';">Clang is in &lt;ROCM_PATH&gt;/llvm/bin . This can be overridden by setting the HIP_CLANG_PATH environment variable.</li>
-<li style="list-style-type: '· ';">The device library is in &lt;ROCM_PATH&gt;/lib . This can be overridden by setting the DEVICE_LIB_PATH environment variable.</li>
-<li style="list-style-type: '· ';">Optionally, you can add &lt;ROCM_PATH&gt;/bin to your PATH , which can make it easier to use the tools.</li>
-<li style="list-style-type: '· ';">Optionally, you can set HIPCC_VERBOSE=7 to output the command line for compilation.</li>
-</ul>
-<p>After you run the make install command, make sure HIP_PATH points to $PWD/install/hip .</p>
-<ol>
-<li style="list-style-type: '1. ';">Generate a profiling header after adding/changing a HIP API.</li>
-</ol>
-<p>Whenyouadd or change a HIP API, you may need to generate a new hip_prof_str.h header. This header is used by ROCm tools to track HIP APIs, such as rocprofiler and roctracer .</p>
-<p>To generate the header after your change, use the hip_prof_gen.py tool located in hipamd/src .</p>
-<p>Usage:</p>
-<p><strong>**Following code does:** The code snippet appears to be part of a larger program that utilizes HIP (Heterogeneous-Compute Interface for Portability) to perform parallel computation on a GPU. Here's a high-level summary of what the code does:
-
-1. **Kernel Launch**: It launches a GPU kernel using `hipModuleLaunchKernel`. The kernel is specified by `Function`, and it is configured to execute with a grid size of 1x1x1 and a block size of `LEN`x1x1. The kernel is passed a configuration parameter `config`.
-
-2. **Data Transfer**: After the kernel execution, the code copies data from the device (GPU) to the host (CPU) using `hipMemcpyDtoH`. The data is copied from `Bd` (device memory) to `B` (host memory), with the size specified by `SIZE`.
-
-3. **Output**: It iterates over the length `LEN` and prints the values of arrays `A` and `B` to the standard output, displaying them in a formatted manner.
-
-4. **Context Detachment**: If the code is compiled for an NVIDIA platform (`__HIP_PLATFORM_NVIDIA__`), it detaches the HIP context using `hipCtxDetach`.
-
-5. **Return**: The function returns 0, indicating successful execution.
-
-Overall, this code is part of a GPU computing application that sets up and executes a kernel on a GPU, retrieves the results, and prints them.</strong></p>
-<pre><code><_PHP_></code></pre>
-<p><strong>**Following code does:** This code snippet is part of a CUDA or HIP (Heterogeneous-Compute Interface for Portability) program, which is used for parallel computing on GPUs. It declares an external 2D texture reference named `tex` that holds floating-point data. The snippet also includes the beginning of a kernel function definition, `tex2dKernel`, which is intended to be executed on the GPU. This kernel function takes a parameter `outputData`, which is likely an array where the results of the texture operations will be stored. The `hipLaunchParm lp` is a parameter used for launching the kernel with specific execution configurations. The code is incomplete, so the specific operations performed by the kernel are not shown.</strong></p>
-<pre><code>                                                                                                                                                                                                        |                                                                                                                                                                                                       
-                                                                                                                                                                                                        <! hip_prof_gen.py                                                                                                                                                                                                        </!                                                                                                                                                                                                        >
-                                                                                                                                                                                                       <?php                                                                                                                                                                                                        +</code></pre>
-<h2>Flags:</h2>
-<ul>
-<li style="list-style-type: '· ';">-v : Verbose messages</li>
-<li style="list-style-type: '· ';">-r : Process source directory recursively</li>
-<li style="list-style-type: '· ';">-t : API types matching check</li>
-<li style="list-style-type: '· ';">--priv : Private API check</li>
-<li style="list-style-type: '· ';">-e : On error exit mode</li>
-<li style="list-style-type: '· ';">-p : HIP_INIT_API macro patching mode</li>
-</ul>
-<p>Example usage:</p>
-<p><strong>**Following code does:** This code snippet is part of a host program that interacts with a GPU using the HIP (Heterogeneous-Compute Interface for Portability) API, which is used for writing portable applications across different GPU architectures. The code sets up a 2D texture reference for use in GPU computations. Specifically, it retrieves a texture reference from a module, sets the address mode for both dimensions to wrap (which means texture coordinates will wrap around), and sets the filter mode to point sampling (which means the nearest texel value will be used). This setup is typically used to configure how textures are accessed and sampled in GPU kernels.</strong></p>
-<pre><code><_Bash_></code></pre>
-<h2>NVIDIA</h2>
-<p><strong>**Following code does:** This code snippet is configuring a texture reference in a HIP (Heterogeneous-Compute Interface for Portability) application, which is used for GPU programming. Specifically, it sets the flags for the texture reference to zero, specifies the format of the texture data as a single-channel floating-point format, and associates the texture reference with a specified array while overriding the format. This setup is typically used to prepare texture data for use in GPU computations, such as in graphics or parallel processing tasks.</strong></p>
-<pre><code>git clone -b "$ROCM_BRANCH" https://github.com/ROCm/clr.git
-git clone -b "$ROCM_BRANCH" https://github.com/ROCm/hip.git
-git clone -b "$ROCM_BRANCH" https://github.com/ROCm/hipother.git</code></pre>
-<p><strong>**Following code does:** The code snippet `<_C_>` appears to be incomplete or not a valid Python code. It does not represent any recognizable Python construct or functionality. It might be a placeholder or a typo. Without additional context or surrounding code, it's not possible to determine its purpose or functionality.</strong></p>
-<pre><code>--- ---
-
-    1. Get the HIP source code.
-        git clone -b "$ROCM_BRANCH"
-        git clone -b "$ROCM_BRANCH"
-        git clone -b "$ROCM_BRANCH"
-
-    2. Set the environment variables.</code></pre>
-<p><strong>**Following code does:** This code snippet is a call to the `hiprtcCreateProgram` function, which is part of the HIP Runtime Compilation (HIPRTC) API. The function is used to create a program object for a GPU kernel written in CUDA C/C++. The parameters provided include the kernel source code as a string, the name of the file for the kernel, the number of header files, and arrays containing the header source code and their corresponding names. This setup is typically used to compile and execute GPU kernels dynamically at runtime.</strong></p>
-<pre><code>export CLR_DIR="$(readlink -f clr)"
-export HIP_DIR="$(readlink -f hip)"
-export HIP_OTHER="$(readlink -f hipother)"</code></pre>
-<p><strong>**Following code does:** This code snippet appears to be a call to the `hiprtcCompileProgram` function, which is part of the HIP (Heterogeneous-Compute Interface for Portability) runtime compilation library. The function is used to compile a HIPRTC program, which is typically written in a CUDA-like language, into a binary that can be executed on a GPU. In this specific call, the function is provided with a `hiprtcProgram` object (`prog`) and is instructed to compile it with zero additional options (`0`), although there is a placeholder for options (`options`) which suggests that options could be passed if needed. The comment indicates that supported Clang options can be used, but none are specified here.</strong></p>
-<pre><code>3.  Build HIP.</code></pre>
-<p><strong>**Following code does:** It seems there is a formatting error in your request. The code snippet is labeled as Python, but the placeholder `<_C++_>` suggests it might be intended for C++. Please provide the correct code snippet or clarify the language so I can assist you accurately.</strong></p>
-<pre><code>cd "$CLR_DIR"
-mkdir -p build; cd build
-cmake -DHIP_COMMON_DIR=$HIP_DIR -DHIP_PLATFORM=nvidia -DCMAKE_INSTALL_PREFIX=$PWD/
- --install -DHIP_CATCH_TEST=0 -DCLR_BUILD_HIP=ON -DCLR_BUILD_OCL=OFF -DHIPNV_DIR=
- --$HIP_OTHER/hipnv..
-make -j$(nproc)
-sudo make install</code></pre>
-<h2>3.3 Build HIP tests</h2>
-<h2>AMD</h2>
-<ul>
-<li style="list-style-type: '· ';">Build HIP catch tests.</li>
-</ul>
-<p><strong>**Following code does:** This code snippet retrieves the compiled binary code of a GPU kernel using the HIP runtime compilation (hipRTC) API. It first determines the size of the compiled code with `hiprtcGetCodeSize`, storing it in `codeSize`. Then, it allocates a vector `kernel_binary` of the appropriate size to hold the binary data. Finally, it populates this vector with the actual compiled kernel code using `hiprtcGetCode`. This process is typically part of a workflow where GPU kernels are dynamically compiled and executed.</strong></p>
-<pre><code>git clone -b "$ROCM_BRANCH" https://github.com/ROCm/hip-tests.git  |</code></pre>
-<p><strong>**Following code does:** This code snippet is using the HIP (Heterogeneous-Compute Interface for Portability) API to load and prepare a GPU kernel for execution. Specifically, it performs the following high-level tasks:
-
-1. Loads a compiled GPU kernel binary into a HIP module using `hipModuleLoadData`.
-2. Retrieves a specific function, named "vector_add", from the loaded module using `hipModuleGetFunction`.
-
-This setup is typically used in GPU programming to execute parallel computations on a GPU, where "vector_add" likely refers to a kernel function that performs vector addition.</strong></p>
-<pre><code>        - npm -m -cos no-source.
-
-            export HIPTESTS_DIR="$(readlink -f hip-tests)"
-            cd "$HIPTESTS_DIR"
-            mkdir -p build; cd build
-            cmake../catch -DHIP_PLATFORM=amd -DHIP_PATH=$CLR_DIR/build/
-            --install  # or any path where HIP is installed; for example: ``/
-            --opt/rocm``
-            make build_tests
-            ctest # run tests</code></pre>
-<p><strong>**Following code does:** The code snippet provided is essentially empty and does not perform any operations or have any functionality. It consists only of whitespace and a comment symbol (`//`), which is typically used for comments in languages like C, C++, and Java, but not in Python. In Python, comments are denoted by the `#` symbol. Therefore, this snippet does not execute any code or serve any purpose.</strong></p>
-<pre><code>AMD
-
-     *  Build HIP catch tests.
-
-                HIP catch tests are separate from the HIP project and use Catch2.
-
-                    - Get HIP tests source code.</code></pre>
-<p><strong>**Following code does:** The code snippet provided consists entirely of a series of angle brackets (`<` and `>`) and hyphens (`-`). It does not contain any executable Python code or meaningful syntax. Therefore, it does not perform any operations or have any functional purpose in a Python program. It appears to be a visual pattern or placeholder rather than actual code.</strong></p>
-<pre><code>      - command: command.json.
-        
-          cd "$HIPTESTS_DIR"
-          hipcc $HIPTESTS_DIR/catch/unit/memory/hipPointerGetAttributes.cc \
-          -I./catch/include./catch/hipTestMain/standalone_main.cc \
-          -I./catch/external/Catch2 -o hipPointerGetAttributes
-         ./hipPointerGetAttributes
-         ...
-
-          All tests passed</code></pre>
-<h2>NVIDIA</h2>
-<p>The commands to build HIP tests on an NVIDIA platform are the same as on an AMD platform. However, you must first set -DHIP_PLATFORM=nvidia .</p>
-<h2>3.4 Run HIP</h2>
-<p>After installation and building HIP, you can compile your application and run. A simple example is square sample.</p>
-<h2>FOUR</h2>
-<h2>HIP PROGRAMMING MODEL</h2>
-<p>The HIP programming model makes it easy to map data-parallel C/C++ algorithms to massively parallel, wide single instruction, multiple data (SIMD) architectures, such as GPUs.</p>
-<p>While the model may be expressed in most imperative languages, (for example Python via PyHIP) this document will focus on the original C/C++ API of HIP.</p>
-<p>A basic understanding of the underlying device architecture helps you make efficient use of HIP and general purpose graphics processing unit (GPGPU) programming in general.</p>
-<h2>4.1 RDNA &amp; CDNA architecture summary</h2>
-<p>GPUs in general are made up of basic building blocks called compute units (CUs), that execute the threads of a kernel. These CUs provide the necessary resources for the threads: the Arithmetic Logical Units (ALUs), register files, caches and shared memory for efficient communication between the threads.</p>
-<p>This design allows for efficient execution of kernels while also being able to scale from small GPUs embedded in APUs with few CUs up to GPUs designed for data centers with hundreds of CUs. Figure Block Diagram of an RDNA3 Compute Unit. and Block Diagram of a CDNA3 Compute Unit. show examples of such compute units.</p>
-<p>For architecture details, check Hardware implementation .</p>
-<figure><figcaption><div class="caption">Fig. 1: Block Diagram of an RDNA3 Compute Unit.</div> <div data-annotation-kind="description">Schedule.</div></figcaption><p><strong>**Image description:** The image is a block diagram representing the architecture of a graphics processing unit (GPU). It is divided into two main sections, each containing multiple components that are responsible for different computational tasks. 
-
-On the left side, there are two identical blocks labeled "Scheduler," each containing:
-- Vector GPR (General Purpose Registers) for handling operations like Float/INT/Matrix SIMD32, Float/Matrix SIMD32, and Transcendental SIMD8.
-- AI MATRIX Accelerator for artificial intelligence matrix operations.
-- DPFP (Double Precision Floating Point) unit.
-- Scalar GPR and Scalar ALU (Arithmetic Logic Unit) for scalar operations.
-
-In the center, there are two caches:
-- Scalar Cache for storing scalar data.
-- Shader Instruction Cache for storing shader instructions.
-
-On the right side, there are two identical blocks labeled "Scheduler," each containing:
-- Scalar GPR and Scalar ALU.
-- Vector GPR for similar operations as the left side.
-- AI MATRIX Accelerator and DPFP unit.
-
-Adjacent to these blocks is a section labeled "Shared Memory," which is used for data exchange between different processing units.
-
-Finally, on the far right, there are components for handling graphics-specific tasks:
-- Ray Accelerator for ray tracing operations.
-- Texture Filters for texture processing.
-- LD/ST/Tex Addr for load/store and texture addressing.
-- L0 cache for fast data access.
-
-The diagram uses red to highlight the functional units and white for the cache and shared memory areas, indicating a focus on computational and memory management capabilities within the GPU architecture.</strong></p>
-<img src="hip_spec-with-image-refs_artifacts/image_000000_5208c655dc4611802372524b387216259e5e5c3c192ee9dd1c1c8e76383cd3f6.png"></figure>
-<figure><figcaption><div class="caption">Fig. 2: Block Diagram of a CDNA3 Compute Unit.</div> <div data-annotation-kind="description">The image depicts a horizontal bar chart titled &quot;Local Data Share.&quot; The chart is divided into two main sections: the left section and the right section.
-
-### Left Section:
-- **Title:** &quot;Local Data Share&quot;
-- **X-axis:** Labeled &quot;Schedule&quot;
-- **Y-axis:** Labeled &quot;Matrix Core Unit&quot;
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
--</div></figcaption><p><strong>**Image description:** The image depicts a horizontal bar chart titled "Local Data Share." The chart is divided into two main sections: the left section and the right section.
-
-### Left Section:
-- **Title:** "Local Data Share"
-- **X-axis:** Labeled "Schedule"
-- **Y-axis:** Labeled "Matrix Core Unit"
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
--</strong></p>
-<img src="hip_spec-with-image-refs_artifacts/image_000001_bfcf0651eef1f236f619420b33a1d732aeb71e35bd879a965fdc6375d5204886.png"></figure>
-<h2>4.2 Heterogeneous Programming</h2>
-<p>The HIP programming model assumes two execution contexts. One is referred to as host while compute kernels execute on a device . These contexts have different capabilities, therefor slightly different rules apply. The host execution is defined by the C++ abstract machine, while device execution follows the SIMT model of HIP. These execution contexts in code are signified by the __host__ and __device__ decorators. There are a few key differences between the two:</p>
-<ul>
-<li style="list-style-type: '· ';">The C++ abstract machine assumes a unified memory address space, meaning that one can always access any given address in memory (assuming the absence of data races). HIP however introduces several memory namespaces, an address from one means nothing in another. Moreover, not all address spaces are accessible from all contexts.</li>
-<li>Looking at Block Diagram of an RDNA3 Compute Unit. and Block Diagram of a CDNA3 Compute Unit. , you can see that every CU has an instance of storage backing the namespace __shared__ . Even if the host were to have access to these regions of memory, the performance benefits of the segmented memory subsystem are supported by the inability of asynchronous access from the host.</li>
-<li style="list-style-type: '· ';">Not all C++ language features map cleanly to typical device architectures, some are very expensive (meaning slow) to implement on GPU devices, therefor they are forbidden in device contexts to avoid users tapping into features that unexpectedly decimate their program's performance. Offload devices targeted by HIP aren't general purpose devices, at least not in the sense that a CPU is. HIP focuses on data parallel computations and as such caters to throughput optimized architectures, such as GPUs or accelerators derived from GPU architectures.</li>
-<li style="list-style-type: '· ';">Asynchrony is at the forefront of the HIP API. Computations launched on the device execute asynchronously with respect to the host, and it is the user's responsibility to synchronize their data dispatch/fetch with computations on the device.</li>
-</ul>
-<p>Note: HIP does perform implicit synchronization on occasions, more advanced than other APIs such as OpenCL or SYCL, in which the responsibility of synchronization mostly depends on the user.</p>
-<h2>4.3 Single instruction multiple threads (SIMT)</h2>
-<p>The SIMT programming model behind the HIP device-side execution is a middle-ground between SMT (Simultaneous Multi-Threading) programming known from multicore CPUs, and SIMD (Single Instruction, Multiple Data) programming mostly known from exploiting relevant instruction sets on CPUs (for example SSE/AVX/Neon).</p>
-<p>A HIP device compiler maps SIMT code written in HIP C++ to an inherently SIMD architecture (like GPUs). This is done by scalarizing the entire kernel and issuing the scalar instructions of multiple kernel instances (called threads) to each of the SIMD engine lanes, rather than exploiting data parallelism within a single instance of a kernel and spreading identical instructions over the available SIMD engines.</p>
-<p>Consider the following kernel:</p>
-<p><strong>**Following code does:** The code snippet appears to be a fragment of a documentation header or title, rather than executable code. It likely indicates the version of a software release, specifically version 6.1.40092, for a project or product abbreviated as "HIP." This kind of line is typically used to label or identify the version of documentation associated with a particular release of the software.</strong></p>
-<pre><code>__global__ void k(float4* a, const float4* b)
-{
-  int tid = threadIdx.x;
-  int bid = blockIdx.x;
-  int dim = blockDim.x;
-
-  a[tid] += (tid + bid - dim) * b[tid];
-}</code></pre>
-<p>The incoming four-vector of floating-point values b is multiplied by a scalar and then added element-wise to the fourvector floating-point values of a . On modern SIMD-capable architectures, the four-vector ops are expected to compile to a single SIMD instruction. However, GPU execution of this kernel will typically break down the vector elements into 4 separate threads for parallel execution, as seen in the following figure:</p>
-<p>Fig. 3: Instruction flow of the sample SIMT program.</p>
-<p>In HIP, lanes of the SIMD architecture are fed by mapping threads of a SIMT execution, one thread down each lane of an SIMD engine. Execution parallelism usually isn't exploited from the width of the built-in vector types, but across multiple threads via the thread ID constants threadIdx.x , blockIdx.x , etc.</p>
-<h2>4.4 Inherent thread model</h2>
-<p>The SIMT nature of HIP is captured by the ability to execute user-provided device programs, expressed as single-source C/C++ functions or sources compiled online/offline to binaries, in bulk.</p>
-<p>All threads of a kernel are uniquely identified by a set of integral values, called thread IDs. The set of integers identifying a thread relate to the hierarchy in which the threads execute.</p>
-<p>The thread hierarchy inherent to how AMD GPUs operate is depicted in the following figure.</p>
-<p>Fig. 4: Hierarchy of thread groups.</p>
-<h2>Warp (or Wavefront)</h2>
-<p>The innermost grouping of threads is called a warp, or a wavefront in ISA terms. A warp is the most tightly coupled groups of threads, both physically and logically. Threads inside a warp are also called lanes, and the integral value identifying them is the lane ID.</p>
-<p>Tip: Lane IDs aren't queried like other thread IDs, but are user-calculated. As a consequence, they are only as multidimensional as the user interprets the calculated values to be.</p>
-<p>The size of a warp is architecture dependent and always fixed. For AMD GPUs the wavefront is typically 64 threads, though sometimes 32 threads. Warps are signified by the set of communication primitives at their disposal, as discussed in Warp cross-lane functions .</p>
-<p>The middle grouping is called a block or thread block. The defining feature of a block is that all threads in a block will share an instance of memory which they may use to share data or synchronize with one another.</p>
-<p>The size of a block is user-configurable but is limited by the queryable capabilities of the executing hardware. The unique ID of the thread within a block is 3-dimensional as provided by the API. When linearizing thread IDs within a block, assume the 'fast index' being dimension x , followed by the y and z dimensions.</p>
-<h2>Block</h2>
-<h2>Grid</h2>
-<p>The outermost grouping is called a grid. A grid manifests as a single dispatch of kernels for execution. The unique ID of each block within a grid is 3-dimensional, as provided by the API and is queryable by every thread within the block.</p>
-<h2>4.4.1 Cooperative groups thread model</h2>
-<p>The Cooperative groups API introduces new APIs to launch, group, subdivide, synchronize and identify threads, as well as some predefined group-collective algorithms, but most importantly a matching threading model to think in terms of. It relaxes some restrictions of the Inherent thread model imposed by the strict 1:1 mapping of architectural details to the programming model. Cooperative groups let you define your own set of thread groups which may fit your user-cases better than the defaults defined by the hardware.</p>
-<p>Note: The implicit groups defined by kernel launch parameters are still available when working with cooperative groups.</p>
-<p>For further information, see Cooperative groups.</p>
-<h2>4.5 Memory model</h2>
-<p>The hierarchy of threads introduced by the Inherent thread model is induced by the memory subsystem of GPUs. The following figure summarizes the memory namespaces and how they relate to the various levels of the threading model.</p>
-<p>Fig. 5: Memory hierarchy.</p>
-<h2>Local or per-thread memory</h2>
-<p>Read-write storage only visible to the threads defining the given variables, also called per-thread memory. The size of a block for a given kernel, and thereby the number of concurrent warps, are limited by local memory usage. This relates to an important aspect: occupancy. This is the default memory namespace.</p>
-<h2>Shared memory</h2>
-<p>Read-write storage visible to all the threads in a given block.</p>
-<h2>Global</h2>
-<p>Read-write storage visible to all threads in a given grid. There are specialized versions of global memory with different usage semantics which are typically backed by the same hardware storing global.</p>
-<h2>Constant</h2>
-<p>Read-only storage visible to all threads in a given grid. It is a limited segment of global with queryable size.</p>
-<h2>Texture</h2>
-<p>Read-only storage visible to all threads in a given grid and accessible through additional APIs.</p>
-<h2>Surface</h2>
-<p>A read-write version of texture memory.</p>
-<h2>4.6 Execution model</h2>
-<p>HIP programs consist of two distinct scopes:</p>
-<ul>
-<li style="list-style-type: '· ';">The host-side API running on the host processor. There are two APIs available:</li>
-<li>-The HIP runtime API which enables use of the single-source programming model.</li>
-<li>-The HIP driver API which sits at a lower level and most importantly differs by removing some facilities provided by the runtime API, most importantly around kernel launching and argument setting. It is geared towards implementing abstractions atop, such as the runtime API itself. Offers two additional pieces of functionality not provided by the Runtime API: hipModule and hipCtx APIs. For further details, check HIP driver API.</li>
-<li style="list-style-type: '· ';">The device-side kernels running on GPUs. Both the host and the device-side APIs have synchronous and asynchronous functions in them.</li>
-</ul>
-<p>Note: The HIP does not present two separate APIs link NVIDIA CUDA. HIP only extends the HIP runtime API with new APIs for hipModule and hipCtx .</p>
-<h2>4.6.1 Host-side execution</h2>
-<p>The part of the host-side API which deals with device management and their queries are synchronous. All asynchronous APIs, such as kernel execution, data movement and potentially data allocation/freeing all happen in the context of device streams.</p>
-<p>Streams are FIFO buffers of commands to execute relating to a given device. Commands which enqueue tasks on a stream all return promptly and the command is executed asynchronously. All side effects of a command on a stream are visible to all subsequent commands on the same stream. Multiple streams may point to the same device and those streams may be fed from multiple concurrent host-side threads. Execution on multiple streams may be concurrent but isn't required to be.</p>
-<p>Asynchronous APIs involving a stream all return a stream event which may be used to synchronize the execution of multiple streams. A user may enqueue a barrier onto a stream referencing an event. The barrier will block until the command related to the event does not complete, at which point all side effects of the command shall be visible to commands following the barrier, even if those side effects manifest on different devices.</p>
-<p>Streams also support executing user-defined functions as callbacks on the host. The stream will not launch subsequent commands until the callback completes.</p>
-<h2>4.6.2 Device-side execution</h2>
-<p>The SIMT programming model behind the HIP device-side execution is a middle-ground between SMT (Simultaneous Multi-Threading) programming known from multicore CPUs, and SIMD (Single Instruction, Multiple Data) programming mostly known from exploiting relevant instruction sets on CPUs (for example SSE/AVX/Neon).</p>
-<h2>4.6.3 Kernel launch</h2>
-<p>Kernels may be launched in multiple ways all with different syntaxes and intended use-cases.</p>
-<ul>
-<li style="list-style-type: '· ';">Using the triple-chevron &lt;&lt;&lt;...&gt;&gt;&gt; operator on a __global__ annotated function.</li>
-<li style="list-style-type: '· ';">Using hipLaunchKernelGGL() on a __global__ annotated function.</li>
-</ul>
-<p>Tip: This name by default is a macro expanding to triple-chevron. In cases where language syntax extensions are undesirable, or where launching templated and/or overloaded kernel functions define the HIP_TEMPLATE_KERNEL_LAUNCH preprocessor macro before including the HIP headers to turn it into a templated function.</p>
-<ul>
-<li style="list-style-type: '· ';">Using the launch APIs supporting the triple-chevron syntax directly.</li>
-</ul>
-<p>Caution: These APIs are intended to be used/generated by tools such as the HIP compiler itself and not intended towards end-user code. Should you be writing a tool having to launch device code using HIP, consider using these over the alternatives.</p>
-<h2>HARDWARE IMPLEMENTATION</h2>
-<p>This chapter describes the typical hardware implementation of GPUs supported by HIP, and how the Inherent thread model maps to the hardware.</p>
-<h2>5.1 Compute units</h2>
-<p>The basic building block of a GPU is a compute unit (CU), also known as streaming multiprocessor (SM) on NVIDIA GPUs. The thread blocks making up a grid are scheduled for execution on CUs. Each block is assigned to an individual CU, and a CU can accommodate several blocks. Depending on their resource usage up to thousands of threads can reside on a CU.</p>
-<p>CUs contain an array of processing elements, referred to as vector ALU (VALU), that execute the actual instructions of the threads according to the SIMT model , together with the necessary registers and caches.</p>
-<p>The threads are executed in groupings called warps. The amount of threads making up a warp is architecture dependent. On AMD GPUs the warp size is commonly 64 threads, except in RDNA architectures which can utilize a warp size of 32 or 64 respectively. The warp size of supported AMD GPUs is listed in the Accelerator and GPU hardware specifications. NVIDIA GPUs have a warp size of 32.</p>
-<p>In contrast to CPUs, GPUs generally do not employ complex cache structures or control logic, like branch prediction or out-of-order execution, but instead rely on massive hardware multithreading to hide latency.</p>
-<p>Context switching between warps residing on a CU incurs no overhead, as the context for the warps is stored on the CU and does not need to be fetched from memory. If there are not enough free registers to accommodate all warps of a block, the block can not be scheduled to that CU and it has to wait until other blocks finish execution.</p>
-<p>The amount of warps that can reside concurrently on a CU, known as occupancy, is determined by the warp's resource usage of registers and shared memory.</p>
-<p>Fig. 1: An AMD Graphics Core Next (GCN) CU. The CDNA and RDNA CUs are based on variations of the GCN CU.</p>
-<p>On AMD GCN GPUs the basic structure of a CU is:</p>
-<ul>
-<li style="list-style-type: '· ';">four Single Instruction Multiple Data units (SIMDs)</li>
-<li style="list-style-type: '· ';">a vector cache</li>
-<li style="list-style-type: '· ';">a local data share</li>
-<li style="list-style-type: '· ';">and a scalar unit</li>
-</ul>
-<h2>5.1.1 SIMD</h2>
-<p>A SIMD consists of a VALU, that executes the instruction of a warp, together with a register file, that provides the registers warps.</p>
-<p>The size of the warp is inherently related to the width of the vector ALU of the SIMD. On GCN compute units the width of the VALU is 16, so a warp can be issued to a SIMD every 4 cycles. Since a CU has 4 SIMDs it issues one warp per cycle. The instructions of a warp are effectively executed in lock-step.</p>
-<p>A SIMD always executes the same instruction for the whole VALU. If the control flow of a warp diverges, the performance is decreased, as the results for the threads that do not participate in that branch have to be masked out, and the instructions of the other branch have to be executed in the same way. The best performance can therefore be achieved when thread divergence is kept to a warp level, i.e. when all threads in a warp take the same execution path.</p>
-<h2>5.1.2 Vector cache</h2>
-<p>The usage of cache on a GPU differs from that on a CPU, as there is less cache available per thread. Its main purpose is to coalesce memory accesses of the warps in order to reduce the amount of accesses to device memory, and make that memory available for other warps that currently reside on the compute unit, that also need to load those values.</p>
-<h2>5.1.3 Local data share</h2>
-<p>The local data share is memory that is accessible to all threads within a block. Its latency and bandwidth is comparable to that of the vector cache. It can be used to share memory between the threads in a block, or as a software managed cache.</p>
-<h2>5.1.4 Scalar Unit</h2>
-<p>The scalar unit performs instructions that are uniform within a warp. It thereby improves efficiency and reduces the pressure on the vector ALUs and the vector register file.</p>
-<h2>5.2 CDNA architecture</h2>
-<p>The general structure of CUs stays mostly as it is in GCN architectures. The most prominent change is the addition of matrix ALUs, which can greatly improve the performance of algorithms involving matrix multiply-accumulate operations for int8, float16, bfloat16 or float32.</p>
-<figure><figcaption><div class="caption">Fig. 2: Block Diagram of a CDNA3 Compute Unit.</div> <div data-annotation-kind="description">The image depicts a horizontal bar chart titled &quot;Local Data Share.&quot; The chart is divided into two main sections: the left section and the right section.
-
-### Left Section:
-- **Title:** Local Data Share
-- **X-Axis:** Labeled as &quot;Scheduler&quot; and &quot;Matrix Core Unit&quot;
-- **Y-Axis:** Labeled as &quot;Local Data Share&quot;
-- **Data Points:**
-  - **Leftmost Data Point:** 100
-  - **Rightmost Data Point:** 100
-  - **Leftmost Data Point:** 100
-  - **Rightmost Data Point:** 100
-
-### Right Section:
-- **Title:** Shader Core
-- **X-Axis:** Labeled as &quot;L1 Cache&quot;
-- **Y-Axis:** Labeled as &quot;Shader Core&quot;
-- **Data Points:**
-  - **Leftmost Data Point:** 100
-  - **Rightmost</div></figcaption><p><strong>**Image description:** The image depicts a horizontal bar chart titled "Local Data Share." The chart is divided into two main sections: the left section and the right section.
-
-### Left Section:
-- **Title:** Local Data Share
-- **X-Axis:** Labeled as "Scheduler" and "Matrix Core Unit"
-- **Y-Axis:** Labeled as "Local Data Share"
-- **Data Points:**
-  - **Leftmost Data Point:** 100
-  - **Rightmost Data Point:** 100
-  - **Leftmost Data Point:** 100
-  - **Rightmost Data Point:** 100
-
-### Right Section:
-- **Title:** Shader Core
-- **X-Axis:** Labeled as "L1 Cache"
-- **Y-Axis:** Labeled as "Shader Core"
-- **Data Points:**
-  - **Leftmost Data Point:** 100
-  - **Rightmost</strong></p>
-<img src="hip_spec-with-image-refs_artifacts/image_000002_cfbddcc77ec59fe03ed26460c2aa6a54c9646387476d59ddc5eaabf5c6641187.png"></figure>
-<h2>5.3 RDNA architecture</h2>
-<p>RDNA makes a fundamental change to CU design, by changing the size of a warp to 32 threads. This is done by effectively combining two GCN5 SIMDs, creating a VALU of width 32, so that a whole warp can be issued in one cycle. The CU is also replaced by the work group processor (WGP), which encompasses two CUs. For backwards compatibility the WGP can also run in wave64 mode, in which it issues a warp of size 64 in two cycles.</p>
-<p>It also adds an extra layer of cache to the WGP, shared by the CUs within it. This cache is referred to as L1 cache, promoting the per-CU cache to an L0 cache.</p>
-<figure><figcaption><div class="caption">Fig. 3: Block Diagram of an RDNA3 work group processor.</div> <div data-annotation-kind="description">Scheduler Vector GPR.</div></figcaption><p><strong>**Image description:** The image is a block diagram illustrating the architecture of a graphics processing unit (GPU) or a similar parallel processing unit. The diagram is divided into two main sections, each representing a compute unit with various components.
-
-Each compute unit contains:
-- **Scheduler**: Manages the execution of instructions.
-- **Vector GPR (General Purpose Registers)**: Handles vector operations with components like "Float/INT/Matrix SIMD32" for single instruction, multiple data operations, "AI MATRIX Accelerator" for AI-related tasks, and "Transcendental SIMD8" for complex mathematical functions.
-- **Scalar GPR**: Manages scalar operations.
-- **Scalar ALU (Arithmetic Logic Unit)**: Performs arithmetic and logical operations on scalar data.
-- **DPFP (Double Precision Floating Point)**: Indicates support for double precision calculations.
-
-The central part of the diagram shows:
-- **Scalar Cache** and **Shader Instruction Cache**: These are shared resources for storing scalar data and shader instructions, respectively.
-
-On the right side of the diagram:
-- **Shared Memory**: A memory space accessible by all units for efficient data sharing.
-- **Ray Accelerator**: Dedicated hardware for accelerating ray tracing operations.
-- **LD/ST/Tex Addr**: Likely stands for Load/Store/Texture Address, handling memory operations and texture addressing.
-- **Texture Filters**: Processes texture data for rendering.
-- **L0**: Possibly indicates a level of cache or memory hierarchy.
-
-The diagram uses a consistent color scheme with red blocks indicating functional units and white/grey blocks for caches and shared resources. The layout suggests a focus on parallel processing capabilities, with emphasis on both vector and scalar operations, AI acceleration, and ray tracing support.</strong></p>
-<img src="hip_spec-with-image-refs_artifacts/image_000003_8ba501e7c1e4fd45f649ac07d48e9985a382fa290507dbd9ebd5ecafa7f23bd2.png"></figure>
-<h2>5.4 Shader engines</h2>
-<p>For hardware implementation's sake, multiple CUs are grouped together into a Shader Engine or Compute Engine, typically sharing some fixed function units or memory subsystem resources.</p>
-<figure><figcaption><div class="caption">Fig. 4: Block Diagram of a CDNA2 Graphics Compute Die.</div> <div data-annotation-kind="description">The image is a table that contains data about different types of fabric. The table is divided into rows and columns, with each row representing a different type of fabric. The columns are labeled as follows:
-
-- Memory
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller</div></figcaption><p><strong>**Image description:** The image is a table that contains data about different types of fabric. The table is divided into rows and columns, with each row representing a different type of fabric. The columns are labeled as follows:
-
-- Memory
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller</strong></p>
-<img src="hip_spec-with-image-refs_artifacts/image_000004_b494ff70840b694ceb0cb8c49613faf77041d4148e4ceb04903608a8022e3cbd.png"></figure>
-<h2>CHAPTER</h2>
-<h2>SIX</h2>
-<h2>AMD COMMON LANGUAGE RUNTIMES (CLR)</h2>
-<p>CLRcontains source codes for AMD's compute languages runtimes: HIP and OpenCL ™ . CLR is the part of HIP runtime which is supported on the AMD ROCm platform, it provides a header and runtime library built on top of HIP-Clang compiler. For developers and users, CLR implements HIP runtime APIs including streams, events, and memory APIs, which is a object library that is linked with the application. The source codes for all headers and the library implementation are available on GitHub in the CLR repository.</p>
-<h2>6.1 Project organization</h2>
-<p>CLR includes the following source code,</p>
-<ul>
-<li style="list-style-type: '· ';">hipamd - contains implementation of HIP language on the AMD platform. It is hosted at clr/hipamd.</li>
-<li style="list-style-type: '· ';">opencl - contains implementation of OpenCL™ on AMD platform. It is hosted at clr/opencl.</li>
-<li style="list-style-type: '· ';">rocclr - contains common runtime used in HIP and OpenCL™ . This is hosted at clr/rocclr.</li>
-</ul>
-<h2>6.2 How to build/install</h2>
-<h2>6.2.1 Prerequisites</h2>
-<p>Please refer to Quick Start Guide in ROCm Docs.</p>
-<p>Building CLR requires rocm-hip-libraries meta package, which provides the pre-requisites for CLR.</p>
-<h2>6.2.2 Linux</h2>
-<ul>
-<li style="list-style-type: '· ';">Clone this repository</li>
-<li style="list-style-type: '· ';">For OpenCL ™</li>
-</ul>
-<p><strong>**Following code does:** The provided code snippet appears to be a series of closing curly braces (`}`) with no accompanying opening braces or any other code. In most programming languages, such as C, C++, Java, or JavaScript, curly braces are used to define blocks of code, such as functions, loops, or conditional statements. However, without any opening braces or context, this snippet does not perform any meaningful operation or represent a valid code structure. It is likely incomplete or incorrectly formatted.</strong></p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        * For HIP</code></pre>
-<p><strong>**Following code does:** This code snippet is written in C++ and is used to compile a HIP (Heterogeneous-Compute Interface for Portability) runtime compilation program. It sets up a compilation option for the program by creating a string `sarg` with the value "-fgpu-rdc", which is a flag typically used to enable relocatable device code in GPU programming. This string is then converted to a C-style string and stored in an array `options`. The `hiprtcCompileProgram` function is called with the program `prog`, specifying that there is one compilation option, and passing the `options` array to apply the "-fgpu-rdc" flag during the compilation process.</strong></p>
-<pre><code><_Bash_></code></pre>
-<p><strong>**Following code does:** This code snippet is used to retrieve the compiled bitcode of a HIP (Heterogeneous-Compute Interface for Portability) program. It first determines the size of the bitcode using `hiprtcGetBitcodeSize`, storing the size in `bitCodeSize`. Then, it creates a vector `kernel_bitcode` of the appropriate size to hold the bitcode. Finally, it retrieves the actual bitcode from the program `prog` and stores it in the `kernel_bitcode` vector using `hiprtcGetBitcode`. This process is typically part of compiling and managing GPU kernels in a HIP runtime environment.</strong></p>
-<pre><code><_Haskell_></code></pre>
-<p>Users can also build OCL and HIP at the same time by passing -DCLR_BUILD_HIP=ON -DCLR_BUILD_OCL=ON to configure command.</p>
-<p>For detail instructions, please refer to build HIP.</p>
-<h2>6.2.3 Test</h2>
-<p>hip-tests is a separate repository hosted at hip-tests.</p>
-<p>To run hip-tests please go to the repository and follow the steps.</p>
-<h2>6.2.4 Release notes</h2>
-<p>HIP provides release notes in CLR change log, which has records of changes in each release.</p>
-<h2>7.1 Host Memory</h2>
-<h2>7.1.1 Introduction</h2>
-<p>hipHostMalloc allocates pinned host memory which is mapped into the address space of all GPUs in the system, the memory can be accessed directly by the GPU device, and can be read or written with much higher bandwidth than pageable memory obtained with functions such as malloc() . There are two use cases for this host memory:</p>
-<ul>
-<li style="list-style-type: '· ';">Faster HostToDevice and DeviceToHost Data Transfers: The runtime tracks the hipHostMalloc allocations and can avoid some of the setup required for regular unpinned memory. For exact measurements on a specific system, experiment with --unpinned and --pinned switches for the hipBusBandwidth tool.</li>
-<li style="list-style-type: '· ';">Zero-Copy GPU Access: GPU can directly access the host memory over the CPU/GPU interconnect, without need to copy the data. This avoids the need for the copy, but during the kernel access each memory access must traverse the interconnect, which can be tens of times slower than accessing the GPU's local device memory. Zerocopy memory can be a good choice when the memory accesses are infrequent (perhaps only once). Zero-copy memory is typically 'Coherent' and thus not cached by the GPU but this can be overridden if desired.</li>
-</ul>
-<h2>7.1.2 Memory allocation flags</h2>
-<p>There are flags parameter which can specify options how to allocate the memory, for example, hipHostMallocPortable , the memory is considered allocated by all contexts, not just the one on which the allocation is made. hipHostMallocMapped , will map the allocation into the address space for the current device, and the device pointer can be obtained with the API hipHostGetDevicePointer() . hipHostMallocNumaUser is the flag to allow host memory allocation to follow Numa policy by user. Please note this flag is currently only applicable on Linux, under development on Windows.</p>
-<p>All allocation flags are independent, and can be used in any combination without restriction, for instance, hipHostMalloc can be called with both hipHostMallocPortable and hipHostMallocMapped flags set. Both usage models described above use the same allocation flags, and the difference is in how the surrounding code uses the host memory.</p>
-<h2>HIP PROGRAMMING MANUAL</h2>
-<h2>7.1.3 Numa-aware host memory allocation</h2>
-<p>Numa policy determines how memory is allocated. Target of Numa policy is to select a CPU that is closest to each GPU. Numa distance is the measurement of how far between GPU and CPU devices.</p>
-<p>By default, each GPU selects a Numa CPU node that has the least Numa distance between them, that is, host memory will be automatically allocated closest on the memory pool of Numa node of the current GPU device. Using hipSetDevice API to a different GPU will still be able to access the host allocation, but can have longer Numa distance. Note, Numa policy is so far implemented on Linux, and under development on Windows.</p>
-<h2>7.1.4 Coherency Controls</h2>
-<p>ROCm defines two coherency options for host memory:</p>
-<ul>
-<li style="list-style-type: '· ';">Coherent memory : Supports fine-grain synchronization while the kernel is running. For example, a kernel can perform atomic operations that are visible to the host CPU or to other (peer) GPUs. Synchronization instructions include threadfence_system and C++11-style atomic operations. In order to achieve this fine-grained coherence, many AMD GPUs use a limited cache policy, such as leaving these allocations uncached by the GPU, or making them read-only.</li>
-<li style="list-style-type: '· ';">Non-coherent memory : Can be cached by GPU, but cannot support synchronization while the kernel is running. Non-coherent memory can be optionally synchronized only at command (end-of-kernel or copy command) boundaries. This memory is appropriate for high-performance access when fine-grain synchronization is not required.</li>
-</ul>
-<p>HIP provides the developer with controls to select which type of memory is used via allocation flags passed to hipHostMalloc and the HIP_HOST_COHERENT environment variable. By default, the environment variable HIP_HOST_COHERENT is set to 0 in HIP. The control logic in the current version of HIP is as follows:</p>
-<ul>
-<li style="list-style-type: '· ';">No flags are passed in: the host memory allocation is coherent, the HIP_HOST_COHERENT environment variable is ignored.</li>
-<li style="list-style-type: '· ';">hipHostMallocCoherent=1 : The host memory allocation will be coherent, the HIP_HOST_COHERENT environment variable is ignored.</li>
-<li style="list-style-type: '· ';">hipHostMallocMapped=1 : The host memory allocation will be coherent, the HIP_HOST_COHERENT environment variable is ignored.</li>
-<li style="list-style-type: '· ';">hipHostMallocNonCoherent=1 , hipHostMallocCoherent=0 , and hipHostMallocMapped=0 : The host memory will be non-coherent, the HIP_HOST_COHERENT environment variable is ignored.</li>
-<li style="list-style-type: '· ';">hipHostMallocCoherent=0 , hipHostMallocNonCoherent=0 , hipHostMallocMapped=0 , but one of the other HostMalloc flags is set:</li>
-<li>-If HIP_HOST_COHERENT is defined as 1, the host memory allocation is coherent.</li>
-<li>-If HIP_HOST_COHERENT is not defined, or defined as 0, the host memory allocation is non-coherent.</li>
-<li style="list-style-type: '· ';">hipHostMallocCoherent=1 , hipHostMallocNonCoherent=1 : Illegal.</li>
-</ul>
-<h2>7.1.5 Visibility of Zero-Copy Host Memory</h2>
-<p>Coherent host memory is automatically visible at synchronization points. Non-coherent</p>
-<p><strong>**Following table contains:** The table appears to represent different series of graphics architectures and their compatibility or usage with various memory allocation methods in a computing context. Each row corresponds to a specific series of graphics architectures, while the columns indicate different memory allocation methods or features.
-
-- **Rows:**
-  - Each row represents a specific series of graphics architectures. The series listed are "MI200, MI300 Series," "MI100," "RDNA (Navi) Series," and "GCN5 (Vega) Series."
-
-- **Columns:**
-  - **Architecture:** This column lists the name of the graphics architecture series.
-  - **hipMallocManaged():** This column likely indicates whether the architecture series supports or utilizes the `hipMallocManaged()` memory allocation method, which is commonly used in GPU programming for unified memory management.
-  - **__managed__:** This column might represent the use of `__managed__` memory, which is a feature in some programming environments for managing memory in a unified manner across CPU and GPU.
-  - **malloc():** This column indicates the use of the standard `malloc()` function, which is a basic memory allocation method in C/C++ programming.
-
-- **Noteworthy Values:**
-  - The "MI200, MI300 Series" row has a value of "1" under the "malloc()" column, suggesting that this series uses or supports the `malloc()` function, while the other columns for this series are empty, indicating no information or support for `hipMallocManaged()` and `__managed__`.
-  - The other architecture series ("MI100," "RDNA (Navi) Series," and "GCN5 (Vega) Series") have no values in any of the columns, which might imply a lack of information or support for the listed memory allocation methods.</strong></p>
-<table><tbody><tr><th>HIP API Synchronization Effect</th><th>Fence</th><th>Coherent Memory ity</th><th>Host Visibil-</th><th>Non-Coherent Host Memory Visi- bility</th></tr><tr><td>hipStreamSynchronize host waits for all commands in the spec- ified stream to complete</td><td>system- scope release</td><td>yes</td><td></td><td>yes</td></tr><tr><td>hipDeviceSynchronize host waits for all commands in all streams on the specified device to com- plete</td><td>system- scope release</td><td>yes</td><td></td><td>yes</td></tr><tr><td>hipEventSynchronize host waits for the specified event to com- plete</td><td>device- scope release</td><td>yes</td><td></td><td>depends - see below</td></tr><tr><td>hipStreamWaitEvent stream waits for the specified event to complete</td><td>none</td><td>yes</td><td></td><td>no</td></tr></tbody></table>
-<h2>7.1.6 hipEventSynchronize</h2>
-<p>Developers can control the release scope for hipEvents :</p>
-<ul>
-<li style="list-style-type: '· ';">By default, the GPU performs a device-scope acquire and release operation with each recorded event. This will make host and device memory visible to other commands executing on the same device.</li>
-</ul>
-<p>A stronger system-level fence can be specified when the event is created with hipEventCreateWithFlags :</p>
-<ul>
-<li style="list-style-type: '· ';">hipEventReleaseToSystem : Perform a system-scope release operation when the event is recorded. This will make both Coherent and Non-Coherent host memory visible to other agents in the system, but may involve heavyweight operations such as cache flushing. Coherent memory will typically use lighter-weight in-kernel synchronization mechanisms such as an atomic operation and thus does not need to use hipEventReleaseToSystem .</li>
-<li style="list-style-type: '· ';">hipEventDisableTiming : Events created with this flag will not record profiling data and provide the best performance if used for synchronization.</li>
-</ul>
-<h2>7.1.7 Summary and Recommendations</h2>
-<ul>
-<li style="list-style-type: '· ';">Coherent host memory is the default and is the easiest to use since the memory is visible to the CPU at typical synchronization points. This memory allows in-kernel synchronization commands such as threadfence_system to work transparently.</li>
-<li style="list-style-type: '· ';">HIP/ROCm also supports the ability to cache host memory in the GPU using the 'Non-Coherent' host memory allocations. This can provide performance benefit, but care must be taken to use the correct synchronization.</li>
-</ul>
-<h2>7.1.8 Managed memory allocation</h2>
-<p>Managed memory, including the __managed__ keyword, is supported in HIP combined host/device compilation, on Linux, not on Windows (under development).</p>
-<p>Managed memory, via unified memory allocation, allows data be shared and accessible to both the CPU and GPU using a single pointer. The allocation will be managed by AMD GPU driver using the Linux HMM (Heterogeneous Memory Management) mechanism, the user can call managed memory API hipMallocManaged to allocate a large chunk of HMMmemory, execute kernels on device and fetch data between the host and device as needed.</p>
-<p>In HIP application, it is recommended to do the capability check before calling the managed memory APIs. For example:</p>
-<p><strong>**Following code does:** It seems there is a formatting error in your request. The code snippet is labeled as C++ but is enclosed within Python code tags. Please provide the correct code snippet or clarify the language so I can assist you accurately.</strong></p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?>                                                                                                                                                                                                        </?></code></pre>
-<p>Please note, the managed memory capability check may not be necessary, but if HMM is not supported, then managed malloc will fall back to using system memory and other managed memory API calls will have undefined behavior.</p>
-<p>Note, managed memory management is implemented on Linux, not supported on Windows yet.</p>
-<h2>7.1.9 HIP Stream Memory Operations</h2>
-<p>HIP supports Stream Memory Operations to enable direct synchronization between Network Nodes and GPU. Following new APIs are added, hipStreamWaitValue32 hipStreamWaitValue64 hipStreamWriteValue32 hipStreamWriteValue64</p>
-<p>Note, CPU access to the semaphore's memory requires volatile keyword to disable CPU compiler's optimizations on memory access. For more details, please check the documentation HIP-API.pdf .</p>
-<p>Please note, HIP stream does not guarantee concurrency on AMD hardware for the case of multiple (at least 6) longrunning streams executing concurrently, using hipStreamSynchronize(nullptr) for synchronization.</p>
-<h2>7.2 Direct Dispatch</h2>
-<p>HIP runtime has Direct Dispatch enabled by default in ROCM 4.4 on Linux. With this feature we move away from our conventional producer-consumer model where the runtime creates a worker thread(consumer) for each HIP Stream, and the host thread(producer) enqueues commands to a command queue(per stream).</p>
-<p>For Direct Dispatch, HIP runtime would directly enqueue a packet to the AQL queue (user mode queue on GPU) on the Dispatch API call from the application. That has shown to reduce the latency to launch the first wave on the idle GPU and total time of tiny dispatches synchronized with the host.</p>
-<p>In addition, eliminating the threads in runtime has reduced the variance in the dispatch numbers as the thread scheduling delays and atomics/locks synchronization latencies are reduced.</p>
-<p>This feature can be disabled via setting the following environment variable, AMD_DIRECT_DISPATCH=0</p>
-<p>Note, Direct Dispatch is implemented on Linux. It is currently not supported on Windows.</p>
-<h2>7.3 HIP Runtime Compilation</h2>
-<p>HIP now supports runtime compilation (HIP RTC), the usage of which will provide the possibility of optimizations and performance improvement compared with other APIs via regular offline static compilation.</p>
-<p>HIP RTC APIs accept HIP source files in character string format as input parameters and create handles of programs by compiling the HIP source files without spawning separate processes.</p>
-<p>For more details on HIP RTC APIs, refer to HIP Runtime API Reference .</p>
-<p>For Linux developers, the link here shows an example how to program HIP application using runtime compilation mechanism, and a detailed HIP RTC programming guide is also available.</p>
-<h2>7.4 HIP Graph</h2>
-<p>HIP graph is supported. For more details, refer to the HIP API Guide.</p>
-<h2>7.5 Device-Side Malloc</h2>
-<p>HIP-Clang now supports device-side malloc and free. This implementation does not require the use of hipDeviceSetLimit(hipLimitMallocHeapSize,value) nor respects any setting. The heap is fully dynamic and can grow until the available free memory on the device is consumed.</p>
-<h2>7.6 Use of Per-thread default stream</h2>
-<p>The per-thread default stream is supported in HIP. It is an implicit stream local to both the thread and the current device. This means that the command issued to the per-thread default stream by the thread does not implicitly synchronize with other streams (like explicitly created streams), or default per-thread stream on other threads. The per-thread default stream is a blocking stream and will synchronize with the default null stream if both are used in a program. The per-thread default stream can be enabled via adding a compilation option, -fgpu-default-stream=per-thread .</p>
-<p>And users can explicitly use hipStreamPerThread as per-thread default stream handle as input in API commands. There are test codes as examples in the link.</p>
-<h2>7.7 Use of Long Double Type</h2>
-<p>In HIP-Clang, long double type is 80-bit extended precision format for x86_64, which is not supported by AMDGPU. HIP-Clang treats long double type as IEEE double type for AMDGPU. Using long double type in HIP source code will not cause issue as long as data of long double type is not transferred between host and device. However, long double type should not be used as kernel argument type.</p>
-<h2>7.8 Use of _Float16 Type</h2>
-<p>If a host function is to be used between clang (or hipcc) and gcc for x86_64, i.e. its definition is compiled by one compiler but the caller is compiled by a different compiler, _Float16 or aggregates containing _Float16 should not be used as function argument or return type. This is due to lack of stable ABI for _Float16 on x86_64. Passing _Float16 or aggregates containing _Float16 between clang and gcc could cause undefined behavior.</p>
-<h2>7.9 FMA and contractions</h2>
-<p>By default HIP-Clang assumes -ffp-contract=fast-honor-pragmas . Users can use #pragma clang fp contract(on|off|fast) to control fp contraction of a block of code. For x86_64, FMA is off by default since the generic x86_64 target does not support FMA by default. To turn on FMA on x86_64, either use -mfma or -march=native on CPU's supporting FMA.</p>
-<p>When contractions are enabled and the CPU has not enabled FMA instructions, the GPU can produce different numerical results than the CPU for expressions that can be contracted. Tolerance should be used for floating point comparisons.</p>
-<h2>7.10 Math functions with special rounding modes</h2>
-<p>Note: Currently, HIP only supports basic math functions with rounding modern (round to nearest). HIP does not support basic math functions with rounding modes ru (round up), rd (round down), and rz (round towards zero).</p>
-<h2>7.11 Creating Static Libraries</h2>
-<p>HIP-Clang supports generating two types of static libraries. The first type of static library does not export device functions, and only exports and launches host functions within the same library. The advantage of this type is the ability to link with a non-hipcc compiler such as gcc. The second type exports device functions to be linked by other code objects. However, this requires using hipcc as the linker.</p>
-<p>In addition, the first type of library contains host objects with device code embedded as fat binaries. It is generated using the flag -emit-static-lib. The second type of library contains relocatable device objects and is generated using ar .</p>
-<p>Here is an example to create and use static libraries:</p>
-<ul>
-<li style="list-style-type: '· ';">Type 1 using --emit-static-lib :</li>
-<li style="list-style-type: '· ';">Type 2 using system ar :</li>
-</ul>
-<p><strong>**Following code does:** This code snippet is a function call to `hiprtcLinkAddData`, which is part of the HIPRTC (Heterogeneous Interface for Portability Runtime Compilation) API. The function is used to add input data, such as bitcode or other types of data, to a HIPRTC link state object. This is typically part of a process to compile or link GPU code at runtime. The parameters specify the link state object, the type and size of the input data, an optional name for the input, and any options or option values that might be applied to this input. In this case, no options or option values are provided.</strong></p>
-<pre><code><_Bash_></code></pre>
-<p><strong>**Following code does:** This code snippet is a function call to `hiprtcLinkAddFile`, which is part of the HIPRTC (Heterogeneous-Compute Interface for Portability Runtime Compilation) API. The function is used to add a file to the HIPRTC link state. Specifically, it adds a file containing input data or bitcode to the current link state, which is a part of the process of compiling and linking GPU code at runtime. The parameters specify the link state, the type of input, the file path to the bitcode, and options related to the input, although in this case, no additional options are provided (indicated by the zero values).</strong></p>
-<pre><code>hipcc hipDevice.cpp -c -fgpu-rdc -o hipDevice.o
-ar rcsD libHipDevice.a hipDevice.o
-hipcc libHipDevice.a test.cpp -fgpu-rdc -o test.out</code></pre>
-<p>For more information, please see HIP samples host functions and device_functions.</p>
-<p>CHAPTER</p>
-<h2>EIGHT</h2>
-<h2>HIP PORTING GUIDE</h2>
-<p>In addition to providing a portable C++ programming environment for GPUs, HIP is designed to ease the porting of existing CUDA code into the HIP environment. This section describes the available tools and provides practical suggestions on how to port CUDA code and work through common issues.</p>
-<h2>8.1 Porting a New CUDA Project</h2>
-<h2>8.1.1 General Tips</h2>
-<ul>
-<li style="list-style-type: '· ';">Starting the port on a CUDA machine is often the easiest approach, since you can incrementally port pieces of the code to HIP while leaving the rest in CUDA. (Recall that on CUDA machines HIP is just a thin layer over CUDA, so the two code types can interoperate on NVCC platforms.) Also, the HIP port can be compared with the original CUDA code for function and performance.</li>
-<li style="list-style-type: '· ';">Once the CUDA code is ported to HIP and is running on the CUDA machine, compile the HIP code using the HIP compiler on an AMD machine.</li>
-<li style="list-style-type: '· ';">HIP ports can replace CUDA versions: HIP can deliver the same performance as a native CUDA implementation, with the benefit of portability to both NVIDIA and AMD architectures as well as a path to future C++ standard support. You can handle platform-specific features through conditional compilation or by adding them to the open-source HIP infrastructure.</li>
-<li style="list-style-type: '· ';">Use hipconvertinplace-perl.sh to hipify all code files in the CUDA source directory.</li>
-</ul>
-<h2>8.1.2 Scanning existing CUDA code to scope the porting effort</h2>
-<p>The hipexamine-perl.sh tool will scan a source directory to determine which files contain CUDA code and how much of that code can be automatically hipified.</p>
-<p><strong>**Following code does:** The code snippet `<_C_>` is not a valid or recognizable Python code. It appears to be a placeholder or a typographical error rather than functional code. Without additional context or correction, it is not possible to determine its purpose or functionality.</strong></p>
-<pre><code><_Cuda_></code></pre>
-<p>(continued from previous page)</p>
-<p><strong>**Following code does:** The code snippet appears to be part of a larger program written in C++ that uses the HIP (Heterogeneous-Compute Interface for Portability) API, which is designed for writing portable code that can run on both AMD and NVIDIA GPUs. The specific function call `hipModuleLoadData(&module, bina)` is used to load a compiled GPU module from binary data into the `module` variable. This is typically a step in preparing GPU code for execution, where `bina` represents the binary data of the compiled GPU program.</strong></p>
-<pre><code>                                                                                                                                                                                                        (continued from previous page)</code></pre>
-<p>hipexamine-perl scans each code file (cpp, c, h, hpp, etc.) found in the specified directory:</p>
-<ul>
-<li style="list-style-type: '· ';">Files with no CUDA code ( kmeans.h ) print one line summary just listing the source file name.</li>
-<li style="list-style-type: '· ';">Files with CUDA code print a summary of what was found - for example the kmeans_cuda_kernel.cu file:</li>
-<li style="list-style-type: '· ';">Interesting information in kmeans_cuda_kernel.cu :</li>
-<li>-How many CUDA calls were converted to HIP (40)</li>
-<li>-Breakdown of the CUDA functionality used ( dev:0 mem:0 etc). This file uses many CUDA builtins (37) and texture functions (3).</li>
-<li>-Warning for code that looks like CUDA API but was not converted (0 in this file).</li>
-<li>-Count Lines-of-Code (LOC) - 185 for this file.</li>
-<li style="list-style-type: '· ';">hipexamine-perl also presents a summary at the end of the process for the statistics collected across all files. This has similar format to the per-file reporting, and also includes a list of all kernels which have been called. An example from above:</li>
-</ul>
-<p><strong>**Following code does:** The code snippet you provided, `binary);`, appears to be incomplete and does not represent a valid or meaningful Python statement on its own. It seems like it might be a fragment of a larger piece of code or a typographical error. Without additional context or surrounding code, it's not possible to determine its purpose or functionality.</strong></p>
-<pre><code><_SQL_></code></pre>
-<p><strong>**Following code does:** The code snippet `<_Cuda_>` appears to be a placeholder or a symbolic representation rather than actual executable code. In the context of programming, "Cuda" typically refers to NVIDIA's parallel computing platform and application programming interface (API) model, which allows developers to use a CUDA-enabled graphics processing unit (GPU) for general purpose processing. However, without additional context or actual code, it is not possible to determine the specific functionality or purpose of this snippet.</strong></p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        --event:0                                                                                                                                                                                                        -event:0</code></pre>
-<h2>8.1.3 Converting a project 'in-place'</h2>
-<p><strong>**Following code does:** This code snippet is setting up options for a Just-In-Time (JIT) compilation process, likely related to GPU programming using the HIP (Heterogeneous-Compute Interface for Portability) runtime. The `isaopts` array contains command-line options for the LLVM compiler, specifically to set the inline threshold to 1, which influences function inlining decisions during compilation. The `jit_options` vector is initialized with specific JIT options that are likely used to configure the compilation process to include these LLVM options. The `isaoptssize` variable indicates the size of the `isaopts` array, which is used to pass these options to the compiler. Overall, this setup is preparing to customize the behavior of the JIT compiler with specific optimization settings.</strong></p>
-<pre><code>></code></pre>
-<p><strong>**Following code does:** This code snippet is setting up and initiating a linking process for a HIP (Heterogeneous-Compute Interface for Portability) runtime compilation. It creates an array `lopts` containing pointers to ISA (Instruction Set Architecture) options and their size, which are then used as input parameters for the `hiprtcLinkCreate` function. This function initializes a `hiprtcLinkState` object, `linkstate`, which represents the state of the linking process. The purpose of this code is to configure and start the linking of compiled code for execution on a GPU using HIP.</strong></p>
-<pre><code>| > hipify-perl --inplace</code></pre>
-<p>For each input file FILE, this script will:</p>
-<ul>
-<li style="list-style-type: '· ';">If FILE.prehip file does not exist, copy the original code to a new file with extension .prehip . Then hipify the code file.</li>
-<li style="list-style-type: '· ';">If FILE.prehip file exists, hipify FILE.prehip and save to FILE.</li>
-</ul>
-<p>This is useful for testing improvements to the hipify toolset.</p>
-<p>The hipconvertinplace-perl.sh script will perform inplace conversion for all code files in the specified directory. This can be quite handy when dealing with an existing CUDA code base since the script preserves the existing directory structure and filenames - and includes work. After converting in-place, you can review the code to add additional parameters to directory names.</p>
-<ul>
-<li>&gt; hipconvertinplace-perl.sh MY_SRC_DIR</li>
-</ul>
-<h2>8.1.4 Library Equivalents</h2>
-<p>Most CUDA libraries have a corresponding ROCm library with similar functionality and APIs. However, ROCm also provides HIP marshalling libraries that greatly simplify the porting process because they more precisely reflect their CUDAcounterparts and can be used with either the AMD or NVIDIA platforms (see 'Identifying HIP Target Platform' below). There are a few notable exceptions:</p>
-<ul>
-<li style="list-style-type: '· ';">MIOpen does not have a marshalling library interface to ease porting from cuDNN.</li>
-<li style="list-style-type: '· ';">RCCL is a drop-in replacement for NCCL and implements the NCCL APIs.</li>
-<li style="list-style-type: '· ';">hipBLASLt does not have a ROCm library but can still target the NVIDIA platform, as needed.</li>
-<li style="list-style-type: '· ';">EIGEN's HIP support is part of the library.</li>
-</ul>
-<p><strong>**Following table contains:** The table appears to represent attributes related to memory management capabilities of a HIP (Heterogeneous-computing Interface for Portability) device, which is likely a GPU or similar hardware. Each row describes a specific attribute of the device's memory management features.
-
-- **Rows**: Each row represents a distinct attribute of the HIP device's memory management capabilities.
-- **Columns**: 
-  - The first column lists the attribute names, which are specific features or capabilities of the device.
-  - The second column provides a description of what each attribute means or supports.
-
-Noteworthy values include:
-- "hipDeviceAttributeManagedMemory" indicates that unified addressing is supported, which means the device can access both host and device memory using a single address space.
-- "hipDeviceAttributeConcurrentManagedAccess" suggests that the device supports full managed memory with concurrent access, allowing simultaneous access to managed memory by both the host and the device.
-- "hipDeviceAttributePageableMemoryAccess" implies that both managed and system memory allocation APIs are supported, indicating flexibility in memory allocation methods.</strong></p>
-<table><tbody><tr><th>CUDA brary</th><th>Li-</th><th>HIP Li- brary</th><th>ROCm Li- brary</th><th>Comment</th></tr><tr><td>cuBLAS</td><td></td><td>hipBLAS</td><td>rocBLAS</td><td>Basic Linear Algebra Subroutines</td></tr><tr><td>cuBLASLt</td><td></td><td>hip- BLASLt</td><td>N/A</td><td>Basic Linear Algebra Subroutines, lightweight and new flexible API</td></tr><tr><td>cuFFT</td><td></td><td>hipFFT</td><td>rocFFT</td><td>Fast Fourier Transfer Library</td></tr><tr><td>cuSPARSE</td><td></td><td>hipSPARSE</td><td>rocSPARSE</td><td>Sparse BLAS + SPMV</td></tr><tr><td>cuSOLVER</td><td></td><td>hip- SOLVER</td><td>rocSOLVER</td><td>Lapack library</td></tr><tr><td>AmgX</td><td></td><td>N/A</td><td>rocALU- TION</td><td>Sparse iterative solvers and preconditioners with algebraic multigrid</td></tr><tr><td>Thrust</td><td></td><td>N/A</td><td>rocThrust</td><td>C++ parallel algorithms library</td></tr><tr><td>CUB</td><td></td><td>hipCUB</td><td>rocPRIM</td><td>Low Level Optimized Parallel Primitives</td></tr><tr><td>cuDNN</td><td></td><td>N/A</td><td>MIOpen</td><td>Deep learning Solver Library</td></tr><tr><td>cuRAND</td><td></td><td>hipRAND</td><td>rocRAND</td><td>Random Number Generator Library</td></tr><tr><td>EIGEN</td><td></td><td>EIGEN</td><td>N/A</td><td>C++ template library for linear algebra: matrices, vectors, numeri- cal solvers,</td></tr><tr><td>NCCL</td><td></td><td>N/A</td><td>RCCL</td><td>Communications Primitives Library based on the MPI equivalents</td></tr></tbody></table>
-<h2>8.2 Distinguishing Compiler Modes</h2>
-<h2>8.2.1 Identifying HIP Target Platform</h2>
-<p>All HIP projects target either AMD or NVIDIA platform. The platform affects which headers are included and which libraries are used for linking.</p>
-<ul>
-<li style="list-style-type: '· ';">HIP_PLATFORM_AMD is defined if the HIP platform targets AMD. Note, HIP_PLATFORM_HCC was previously defined if the HIP platform targeted AMD, it is deprecated.</li>
-<li style="list-style-type: '· ';">HIP_PLATFORM_NVDIA is defined if the HIP platform targets NVIDIA. Note, HIP_PLATFORM_NVCC was previously defined if the HIP platform targeted NVIDIA, it is deprecated.</li>
-</ul>
-<h2>8.2.2 Identifying the Compiler: hip-clang or NVCC</h2>
-<p>Often, it's useful to know whether the underlying compiler is HIP-Clang or NVCC. This knowledge can guard platformspecific code or aid in platform-specific performance tuning.</p>
-<p><strong>**Following code does:** It seems like you've provided a placeholder or incomplete code snippet. If you have a specific Python code snippet you'd like me to explain, please provide the actual code, and I'll be happy to help!</strong></p>
-<pre><code>    #ifdef __HIP_PLATFORM_AMD__
-    // Compiled with HIP-Clang
-    #endif</code></pre>
-<p><strong>**Following code does:** This code snippet is part of a program that uses the HIPRTC (Heterogeneous-Compute Interface for Portability Runtime Compilation) API to compile a GPU program at runtime. It attempts to compile a program represented by `prog` with a single compilation option specified in `opts`. The result of the compilation is stored in `result`. If the compilation fails (i.e., `result` is not `HIPRTC_SUCCESS`), it outputs an error message to the standard output, including the error string corresponding to the failure.</strong></p>
-<pre><code>#ifdef __HIP_PLATFORM_NVIDIA__
-// Compiled with nvcc
-//  Could be compiling with CUDA language extensions enabled (for example, a ".cu file)
-//  Could be in pass-through mode to an underlying host compile OR (for example, a.cpp_
---file)</code></pre>
-<p><strong>**Following code does:** The code snippet appears to be the beginning of a C++ declaration for a static constant character array named `gpu_program`. This array is likely intended to store a sequence of characters, which could represent a GPU program or shader code. The `static constexpr` keywords suggest that this array is both constant and has static storage duration, meaning its value is fixed at compile time and it is shared across all instances of the class or file in which it is declared. The actual content of the array is not shown in the snippet.</strong></p>
-<pre><code>        #ifdef __CUDACC__
-        // Compiled with nvcc (CUDA language extensions enabled)</code></pre>
-<p><strong>**Following code does:** This code snippet is written in C++ and is part of a program that likely involves GPU programming, possibly using the HIP runtime for compiling and managing GPU kernels. The code performs the following high-level tasks:
-
-1. It initializes a vector `kernel_name_vec` with strings representing kernel function names or expressions. These names include `&f1`, `N1::N2::f2`, and `f3<int>`, which suggest different ways of referring to functions or templates in C++.
-
-2. It iterates over each element in `kernel_name_vec` and calls the function `hiprtcAddNameExpression` with the current element converted to a C-style string (`c_str()`) and a program object `prog`. This function is likely used to register or associate these kernel names with the program for later compilation or execution on a GPU.
-
-3. It initializes another vector `variable_name_vec` with a single string `&V1`, which might represent a variable name or address that could be used later in the program.
-
-Overall, the code is setting up kernel and possibly variable names for a GPU program, preparing them for further processing or compilation.</strong></p>
-<pre><code>; enab1ed)</code></pre>
-<p>Compiler directly generates the host code (using the Clang x86 target) and passes the code to another host compiler. Thus, they have no equivalent of the __CUDACC__ define.</p>
-<h2>8.2.3 Identifying Current Compilation Pass: Host or Device</h2>
-<p>NVCCmakestwo passes over the code: one for host code and one for device code. HIP-Clang will have multiple passes over the code: one for the host code, and one for each architecture on the device code. __HIP_DEVICE_COMPILE__ is set to a nonzero value when the compiler (HIP-Clang or NVCC) is compiling code for a device inside a __global__ kernel or for a device function. __HIP_DEVICE_COMPILE__ can replace #ifdef checks on the __CUDA_ARCH__ define.</p>
-<p><strong>**Following code does:** This code snippet appears to be part of a loop in C++ (though it is formatted like Python, it is not valid Python syntax). It iterates over a collection named `variable_name_vec`, which is likely a vector or similar container of strings or string-like objects. For each element `x` in this collection, it calls the function `hiprtcAddNameExpression`, passing `prog` and `x.c_str()` as arguments. The purpose of this operation is to add name expressions to a HIPRTC (Heterogeneous-Compute Interface for Portability Runtime Compilation) program, where `prog` is likely a handle or reference to a runtime compilation program, and `x.c_str()` converts the string `x` to a C-style string (null-terminated character array). This is typically used in GPU programming to manage and compile code at runtime.</strong></p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                        #if __HIP__DEVICE__COMPILE__</code></pre>
-<p>Unlike __CUDA_ARCH__ , the __HIP_DEVICE_COMPILE__ value is 1 or undefined, and it doesn't represent the feature capability of the target device.</p>
-<h2>8.2.4 Compiler Defines: Summary</h2>
-<p><strong>**Following table contains:** The table appears to represent a structured outline or index of topics related to a technical document, possibly a programming or software development guide. Each row corresponds to a specific section or subsection within the document, and the columns provide details about these sections.
-
-- **Rows**: Each row represents a different section or subsection of the document. The sections are numbered hierarchically (e.g., 8.10.2, 8.11, 8.12), indicating their position within the larger document structure.
-
-- **Columns**:
-  - The first column seems to be a placeholder or separator, as it is mostly empty.
-  - The second column contains the section numbers, which help in identifying the hierarchical structure of the document.
-  - The third column provides the title or description of the section, which gives an idea of the content covered in that part of the document.
-  - The fourth column appears to be a repetition of the third column, possibly for emphasis or formatting purposes.
-  - The fifth column contains numerical values, which might represent page numbers, section identifiers, or reference codes.
-
-- **Noteworthy Values**:
-  - The repeated section titles in the third and fourth columns suggest a formatting choice that might be used for emphasis or alignment.
-  - The numerical values in the fifth column are sequential, indicating a structured progression through the document.
-  - The presence of technical terms such as "memcpyToSymbol," "CU_POINTER_ATTRIBUTE_MEMORY_TYPE," and "threadfence_system" suggests that the document is related to programming, possibly focusing on GPU computing or parallel processing.
-
-Overall, the table provides an organized view of the document's contents, helping readers navigate through various technical topics.</strong></p>
-<table><tbody><tr><th>Define</th><th>HIP-Clang</th><th>NVCC</th><th>Other (GCC, ICC, Clang, etc.)</th></tr><tr><th>HIP-related defines:</th><td></td><td></td><td></td></tr><tr><td>__HIP_PLATFORM_AMD__</td><td>Defined</td><td>Undefined</td><td>Defined if targetingAMD platform; undefined oth- erwise</td></tr><tr><td>__HIP_PLATFORM_NVIDIA__</td><td>Undefined</td><td>Defined</td><td>Defined if targeting NVIDIA platform; unde- fined otherwise</td></tr><tr><td>__HIP_DEVICE_COMPILE__</td><td>1 if compiling for device; un- defined if compiling for host</td><td>1 if compiling for device; undefined if compiling for host</td><td>Undefined</td></tr><tr><td>__HIPCC__</td><td>Defined</td><td>Defined</td><td>Undefined</td></tr><tr><td>__HIP_ARCH_*</td><td>0 or 1 depending on feature support (see below)</td><td>0 or 1 depending on feature support (see below)</td><td>0</td></tr><tr><th>NVCC- related defines:</th><td></td><td></td><td></td></tr><tr><td>__CUDACC__</td><td>Defined if source code is compiled by NVCC; unde- fined otherwise</td><td>Undefined</td><td></td></tr><tr><td>__NVCC__ Undefined</td><td>Defined</td><td>Undefined</td><td></td></tr><tr><td>__CUDA_ARCH__</td><td>Undefined</td><td>Unsigned representing compute capa- bility (e.g., &#x27;130&#x27;) if in device code; 0 if in host code</td><td>Undefined</td></tr><tr><th>hip-clang- related defines:</th><td></td><td></td><td></td></tr><tr><td>__HIP__ HIP-Clang common</td><td>Defined</td><td>Undefined</td><td>Undefined</td></tr><tr><td>defines: __clang__</td><td>Defined</td><td>Defined</td><td>Undefined</td></tr></tbody></table>
-<h2>8.3 Identifying Architecture Features</h2>
-<h2>8.3.1 HIP_ARCH Defines</h2>
-<p>Some CUDA code tests __CUDA_ARCH__ for a specific value to determine whether the machine supports a certain architectural feature. For instance,</p>
-<p><strong>**Following code does:** This code snippet appears to be part of a C++ program. It performs the following high-level actions:
-
-1. It adds a string literal `"&N1::N2::V2"` to a vector named `variable_name_vec`. This vector is likely intended to store names or identifiers, possibly for variables or functions.
-
-2. It then iterates over each element in `variable_name_vec` using a range-based for loop. For each element `x`, it calls a function or macro `hiprtcAddNameExp`. This function or macro is likely related to the HIP runtime compilation (hiprtc) library, which is used for compiling and managing GPU kernels in AMD's ROCm platform. The purpose of `hiprtcAddNameExp` is probably to register or process the names stored in the vector for use in GPU kernel compilation or execution.
-
-Overall, the code is managing a collection of names and performing an operation on each name, likely in the context of GPU programming.</strong></p>
-<pre><code>        | #if (__CUDA_ARCH__ >= 13 0)</code></pre>
-<p><strong>**Following code does:** This code snippet iterates over a vector named `variable_name_vec` and retrieves the "lowered" name for each element in the vector using the `hiprtcGetLoweredName` function. The `decltype(variable_name_vec.size())` is used to ensure the loop index `i` is of the same type as the size of the vector. The `hiprtcGetLoweredName` function is likely part of the HIP runtime compilation (hipRTC) API, which is used for compiling and managing GPU kernels. The lowered name is stored in the `name` pointer for each variable in the vector.</strong></p>
-<pre><code>    |// doubles are supported</code></pre>
-<p>This type of code requires special attention, since AMD and CUDA devices have different architectural capabilities. Moreover, you can't determine the presence of a feature using a simple comparison against an architecture's version</p>
-<p>number. HIP provides a set of defines and device properties to query whether a specific architectural feature is supported.</p>
-<p>The __HIP_ARCH_* defines can replace comparisons of __CUDA_ARCH__ values:</p>
-<p><strong>**Following code does:** This code snippet iterates over a vector named `kernel_name_vec`, which presumably contains kernel names as strings. For each kernel name in the vector, it calls the function `hiprtcGetLoweredName`, passing in a program object `prog`, the current kernel name, and a pointer to a `const char*` variable `name`. The purpose of this function call is likely to retrieve the "lowered" or transformed version of the kernel name, which is stored in the `name` variable. This is typically used in the context of GPU programming, where kernel names might need to be transformed or resolved for further processing or compilation.</strong></p>
-<pre><code>//#if (__CUDA_ARCH__ >= 130)   // non-portable
-if __HIP_ARCH_HAS_DOUBLES__ {  // portable HIP feature query
-    // doubles are supported
-}</code></pre>
-<p>For host code, the __HIP_ARCH__* defines are set to 0. You should only use the __HIP_ARCH__ fields in device code.</p>
-<h2>8.3.2 Device-Architecture Properties</h2>
-<p>Host code should query the architecture feature flags in the device properties that hipGetDeviceProperties returns, rather than testing the 'major' and 'minor' fields directly:</p>
-<p><strong>**Following code does:** This code snippet is part of a GPU programming workflow using the HIP (Heterogeneous-Compute Interface for Portability) API, which is designed for writing portable applications that can run on AMD and NVIDIA GPUs. The code performs the following high-level tasks:
-
-1. It declares a variable `variable_addr` to hold the device pointer to a global variable within a GPU module, and a `bytes` variable to store the size of this global variable.
-2. It retrieves the address and size of a global variable from a specified GPU module using `hipModuleGetGlobal`.
-3. It copies an initial value from the host (CPU) memory to the device (GPU) memory at the location specified by `variable_addr` using `hipMemcpyHtoD`.
-
-Overall, this code initializes a global variable in a GPU module with a specified initial value from the host.</strong></p>
-<pre><code>hipGetDeviceProperties(&deviceProp, device);
-//if ((deviceProp.major == 1 && deviceProp.minor < 2))  // non-portable
-if (deviceProp.arch.hasSharedInt32Atomics) {            // portable HIP feature query
-    // has shared int32 atomic operations...
-}</code></pre>
-<h2>8.3.3 Table of Architecture Properties</h2>
-<p>The table below shows the full set of architectural properties that HIP supports.</p>
-<p><strong>**Following table contains:** The provided CSV preview appears to represent a table of atomic operations, likely related to programming or computing, specifically dealing with atomic functions in a parallel computing context such as CUDA or similar environments. Each row seems to describe a different atomic function or a variant of an atomic function, detailing its signature and possibly its system-specific variant.
-
-- **Rows**: Each row represents a different atomic operation function, including its type (e.g., `int`, `unsigned int`, `float`, `double`, `unsigned long long`) and the parameters it takes (e.g., `address`, `val`).
-
-- **Columns**: The columns are not explicitly defined in the preview, but it seems like the data is structured to show the function signature and possibly its system-specific variant. The functions include operations like `atomicAdd`, `atomicSub`, and `atomicExch`, each with different data types.
-
-- **Noteworthy Values**: 
-  - The presence of both `atomicAdd` and `atomicAdd_system` suggests that there are standard and system-specific implementations of these functions.
-  - Functions are defined for multiple data types, including `int`, `unsigned int`, `float`, `double`, and `unsigned long long`, indicating a wide applicability across different numeric types.
-  - The mention of `unsafeAtomicAdd` and `safeAtomicAdd` implies there are considerations for safety or atomicity in certain operations.
-
-Overall, this table seems to be a reference for developers working with atomic operations in a high-performance computing environment, providing details on function signatures for various data types and system-specific implementations.</strong></p>
-<table><tbody><tr><th>Define (use only in device code)</th><th>Device Property (run- time query)</th><th>Comment</th></tr><tr><th>32-bit atomics:</th><td></td><td></td></tr><tr><td>__HIP_ARCH_HAS_GLOBAL_INT32_ATOMICS__ __HIP_ARCH_HAS_GLOBAL_FLOAT_ATOMIC_EXCH__</td><td>hasGlobalInt32Atomics hasGlobalFloatAtomicExch</td><td>32-bit integer atomics for global memory 32-bit float atomic exchange for global mem- ory</td></tr><tr><td>__HIP_ARCH_HAS_SHARED_INT32_ATOMICS__ __HIP_ARCH_HAS_SHARED_FLOAT_ATOMIC_EXCH__</td><td>hasSharedInt32Atomics hasSharedFloatAtomicExch</td><td>32-bit integer atomics for shared memory 32-bit float atomic exchange for shared mem- ory</td></tr><tr><td>__HIP_ARCH_HAS_FLOAT_ATOMIC_ADD__</td><td>hasFloatAtomicAdd</td><td>32-bit float atomic add in global and shared memory</td></tr><tr><th>64-bit atomics:</th><td></td><td></td></tr><tr><td>__HIP_ARCH_HAS_GLOBAL_INT64_ATOMICS__ __HIP_ARCH_HAS_SHARED_INT64_ATOMICS__ Doubles:</td><td>hasGlobalInt64Atomics hasSharedInt64Atomics</td><td>64-bit integer atomics for global memory 64-bit integer atomics for shared memory</td></tr><tr><td>__HIP_ARCH_HAS_DOUBLES__ Warp cross-lane operations:</td><td>hasDoubles</td><td>Double-precision floating point</td></tr><tr><td>__HIP_ARCH_HAS_WARP_VOTE__ __HIP_ARCH_HAS_WARP_BALLOT__ __HIP_ARCH_HAS_WARP_SHUFFLE__ __HIP_ARCH_HAS_WARP_FUNNEL_SHIFT__ Sync:</td><td>hasWarpVote hasWarpBallot hasWarpShuffle hasFunnelShift</td><td>Warp vote instructions ( any , all ) Warp ballot instructions Warp shuffle operations ( shfl_* ) Funnel shift two input words into one</td></tr><tr><td></td><td>hasThreadFenceSystem hasSyncThreadsExt</td><td>threadfence_system syncthreads_count , syncthreads_and</td></tr><tr><td>__HIP_ARCH_HAS_THREAD_FENCE_SYSTEM__</td><td></td><td></td></tr><tr><td>__HIP_ARCH_HAS_SYNC_THREAD_EXT__</td><td></td><td>, syncthreads_or</td></tr><tr><th>Miscellaneous:</th><td></td><td></td></tr><tr><td>__HIP_ARCH_HAS_SURFACE_FUNCS__</td><td>hasSurfaceFuncs</td><td></td></tr><tr><td>__HIP_ARCH_HAS_3DGRID__</td><td>has3dGrid</td><td>Grids and groups are 3D</td></tr><tr><td>__HIP_ARCH_HAS_DYNAMIC_PARALLEL__</td><td>hasDynamicParallelism</td><td></td></tr></tbody></table>
-<h2>8.4 Finding HIP</h2>
-<p>Makefiles can use the following syntax to conditionally provide a default HIP_PATH if one does not exist:</p>
-<p>HIP_PATH ?= $( shell hipconfig --path )</p>
-<h2>8.5 Identifying HIP Runtime</h2>
-<p>HIP can depend on rocclr, or CUDA as runtime</p>
-<ul>
-<li style="list-style-type: '· ';">AMDplatform On AMD platform, HIP uses Radeon Open Compute Common Language Runtime, called ROCclr. ROCclr is a virtual device interface that HIP runtimes interact with different backends which allows runtimes to work on Linux , as well as Windows without much efforts.</li>
-<li style="list-style-type: '· ';">NVIDIA platform On NVIDIA platform, HIP is just a thin layer on top of CUDA. On non-AMD platform, HIP runtime determines if CUDA is available and can be used. If available, HIP_PLATFORM is set to nvidia and underneath CUDA path is used.</li>
-</ul>
-<h2>8.6 hipLaunchKernelGGL</h2>
-<p>hipLaunchKernelGGL is a macro that can serve as an alternative way to launch kernel, which accepts parameters of launch configurations (grid dims, group dims, stream, dynamic shared size) followed by a variable number of kernel arguments. It can replace &lt;&lt;&lt; &gt;&gt;&gt;, if the user so desires.</p>
-<h2>8.7 Compiler Options</h2>
-<p>hipcc is a portable compiler driver that will call NVCC or HIP-Clang (depending on the target system) and attach all required include and library options. It passes options through to the target compiler. Tools that call hipcc must ensure the compiler options are appropriate for the target compiler. The hipconfig script may helpful in identifying the target platform, compiler and runtime. It can also help set options appropriately.</p>
-<h2>8.7.1 Compiler options supported on AMD platforms</h2>
-<p>Here are the main compiler options supported on AMD platforms by HIP-Clang.</p>
-<p><strong>**Following table contains:** The table appears to represent a list of atomic operations, likely related to programming or computing, specifically in the context of concurrent or parallel processing. Each row seems to describe a different atomic function or a variation of a function, possibly from a programming library or API.
-
-- **Rows**: Each row represents a different atomic operation function, including its signature and possibly its system-specific variant. These functions are typically used in low-level programming to perform thread-safe operations on shared variables.
-
-- **Columns**: The table seems to have only one column, which contains the function signatures. These signatures include the return type, function name, and parameters, which specify the data types and names of the arguments the function takes. Some rows also mention system-specific versions of these functions, indicated by the suffix "_system".
-
-- **Noteworthy Values**: 
-  - The presence of both standard and system-specific versions of functions (e.g., `atomicCAS` and `atomicCAS_system`) suggests that these operations might have different implementations or optimizations depending on the system.
-  - The functions cover a range of operations such as `atomicDec`, `atomicCAS`, `atomicAnd`, and `atomicOr`, which are common atomic operations used to ensure data integrity in concurrent programming.
-  - The use of different data types like `int`, `unsigned int`, and `unsigned long long` indicates that these operations can be applied to variables of varying sizes and signedness.
-
-Overall, this table is likely a reference for developers working with atomic operations in a specific programming environment.</strong></p>
-<table><tbody><tr><th>Option</th><th>Description</th></tr><tr><td></td><td>--amdgpu-target=&lt;gpu_arch&gt; [DEPRECATED] This option is being replaced by --offload-arch=&lt;target&gt; . Generate code for the given GPU target. Supported targets are gfx701, gfx801, gfx802, gfx803, gfx900, gfx906, gfx908, gfx1010, gfx1011, gfx1012, gfx1030, gfx1031. This option could appear multiple times on the same command line to generate a fat binary for multiple targets.</td></tr><tr><td>--fgpu-rdc</td><td>Generate relocatable device code, which allows kernels or device functions calling device functions in different translation units.</td></tr><tr><td>-ggdb</td><td>Equivalent to -g plus tuning for GDB. This is recommended when using ROCm&#x27;s GDB to debug GPU code.</td></tr><tr><td></td><td>--gpu-max-threads-per-block=&lt;num&gt; Generate code to support up to the specified number of threads per block.</td></tr><tr><td>-O&lt;n&gt;</td><td>Specify the optimization level.</td></tr><tr><td></td><td>-offload-arch=&lt;target&gt; Specify the AMDGPUtarget ID.</td></tr><tr><td>-save-temps</td><td>Save the compiler generated intermediate files.</td></tr><tr><td>-v</td><td>Show the compilation steps.</td></tr></tbody></table>
-<h2>8.8 Linking Issues</h2>
-<h2>8.8.1 Linking With hipcc</h2>
-<p>hipcc adds the necessary libraries for HIP as well as for the accelerator compiler (NVCC or AMD compiler). We recommend linking with hipcc since it automatically links the binary to the necessary HIP runtime libraries. It also has knowledge on how to link and to manage the GPU objects.</p>
-<h2>8.8.2 -lm Option</h2>
-<p>hipcc adds -lm by default to the link command.</p>
-<h2>8.9 Linking Code With Other Compilers</h2>
-<p>CUDA code often uses NVCC for accelerator code (defining and launching kernels, typically defined in .cu or .cuh files). It also uses a standard compiler (g++) for the rest of the application. NVCC is a preprocessor that employs a standard host compiler (gcc) to generate the host code. Code compiled using this tool can employ only the intersection of language features supported by both NVCC and the host compiler. In some cases, you must take care to ensure the data types and alignment of the host compiler are identical to those of the device compiler. Only some host compilers are supported-for example, recent NVCC versions lack Clang host-compiler capability.</p>
-<p>HIP-Clang generates both device and host code using the same Clang-based compiler. The code uses the same API as gcc, which allows code generated by different gcc-compatible compilers to be linked together. For example, code compiled using HIP-Clang can link with code compiled using 'standard' compilers (such as gcc, ICC and Clang). Take care to ensure all compilers use the same standard C++ header and library formats.</p>
-<h2>8.9.1 libc++ and libstdc++</h2>
-<p>hipcc links to libstdc++ by default. This provides better compatibility between g++ and HIP.</p>
-<p>If you pass --stdlib=libc++ to hipcc, hipcc will use the libc++ library. Generally, libc++ provides a broader set of C++ features while libstdc++ is the standard for more compilers (notably including g++).</p>
-<p>When cross-linking C++ code, any C++ functions that use types from the C++ standard library (including std::string, std::vector and other containers) must use the same standard-library implementation. They include the following:</p>
-<ul>
-<li style="list-style-type: '· ';">Functions or kernels defined in HIP-Clang that are called from a standard compiler</li>
-<li style="list-style-type: '· ';">Functions defined in a standard compiler that are called from HIP-Clang.</li>
-</ul>
-<p>Applications with these interfaces should use the default libstdc++ linking.</p>
-<p>Applications which are compiled entirely with hipcc, and which benefit from advanced C++ features not supported in libstdc++, and which do not require portability to NVCC, may choose to use libc++.</p>
-<h2>8.9.2 HIP Headers ( hip_runtime.h , hip_runtime_api.h )</h2>
-<p>The hip_runtime.h and hip_runtime_api.h files define the types, functions and enumerations needed to compile a HIP program:</p>
-<ul>
-<li style="list-style-type: '· ';">hip_runtime_api.h : defines all the HIP runtime APIs (e.g., hipMalloc ) and the types required to call them. A source file that is only calling HIP APIs but neither defines nor launches any kernels can include hip_runtime_api.h . hip_runtime_api.h uses no custom Heterogeneous Compute (HC) language features and can be compiled using a standard C++ compiler.</li>
-<li style="list-style-type: '· ';">hip_runtime.h : included in hip_runtime_api.h . It additionally provides the types and defines required to create and launch kernels. hip_runtime.h can be compiled using a standard C++ compiler but will expose a subset of the available functions.</li>
-</ul>
-<p>CUDAhasslightly different contents for these two files. In some cases you may need to convert hipified code to include the richer hip_runtime.h instead of hip_runtime_api.h .</p>
-<h2>8.9.3 Using a Standard C++ Compiler</h2>
-<p>You can compile hip_runtime_api.h using a standard C or C++ compiler (e.g., gcc or ICC). The HIP include paths and defines ( __HIP_PLATFORM_AMD__ or __HIP_PLATFORM_NVIDIA__ ) must pass to the standard compiler; hipconfig then returns the necessary options:</p>
-<ul>
-<li>&gt;</li>
-</ul>
-<p><strong>**Following code does:** This code snippet is part of a HIP (Heterogeneous-Compute Interface for Portability) application, which is used for running code on GPUs. The code performs the following high-level tasks:
-
-1. It retrieves a GPU kernel function from a given module using `hipModuleGetFunction`, storing the function in the `kernel` variable.
-2. It then launches this kernel function on the GPU using `hipModuleLaunchKernel`. The kernel is launched with a grid and block size of 1x1x1, meaning it will execute a single thread. The function is executed with no shared memory (`0`), no stream (`nullptr`), no extra arguments (`nullptr`), and a configuration specified by `config`.
-
-Overall, this code is setting up and executing a GPU kernel with minimal configuration, likely for testing or demonstration purposes.</strong></p>
-<pre><code>|> hipconfig --cxx_config</code></pre>
-<p><strong>**Following code does:** The provided code snippet appears to be a mix of PHP and HTML-like syntax, but it is mostly nonsensical and does not form a valid or functional script. It includes PHP opening and closing tags (`<?php` and `?>`), but the content within these tags is not meaningful or executable PHP code. The snippet also contains HTML-like tags (`<!`, `<%`, `</%>`) that do not correspond to any standard HTML or server-side scripting language syntax. Overall, this code does not serve any practical purpose and seems to be a random or corrupted text rather than a functional script.</strong></p>
-<pre><code>                                                                                                                                                                                                        |  -D___HIP_PLATFORM_AMD___ -I/home/user1/hip/include</code></pre>
-<p>You can capture the hipconfig output and passed it to the standard compiler; below is a sample makefile syntax:</p>
-<p><strong>**Following code does:** This code snippet is an example of using the `ltrace` command to trace calls to HSA (Heterogeneous System Architecture) APIs. The command `ltrace -C -e "hsa*" ./hipGetChanDesc` is executed to monitor and log the function calls made by the `hipGetChanDesc` program that involve HSA-related libraries. The output shows a sequence of HSA API calls, including initialization, memory allocation, and event creation, along with their parameters and return values. This is useful for debugging or understanding the interactions between the program and the HSA runtime.</strong></p>
-<pre><code>            |CPPFLAGS += $(shell $(HIP_PATH)/bin/hipconfig --cpp_config)</code></pre>
-<p><strong>**Following code does:** The line you provided appears to be a version identifier or a header comment, rather than executable code. It likely indicates the version of a software release or documentation for a project named "HIP." This version is labeled as "6.1.40092." Such a line is typically used in documentation files to specify the version of the document or software it pertains to, helping users identify the correct version they are referencing or using.</strong></p>
-<pre><code>
-)</code></pre>
-<p>NVCC includes some headers by default. However, HIP does not include default headers, and instead all required files must be explicitly included. Specifically, files that call HIP run-time APIs or define HIP kernels must explicitly include the appropriate HIP headers. If the compilation process reports that it cannot find necessary APIs (for example, error: identifier hipSetDevice is undefined ), ensure that the file includes hip_runtime.h (or hip_runtime_api.h, if appropriate). The hipify-perl script automatically converts cuda_runtime.h to hip_runtime.h , and it converts cuda_runtime_api.h to hip_runtime_api.h , but it may miss nested headers or macros.</p>
-<h2>8.9.3.1 cuda.h</h2>
-<p>The HIP-Clang path provides an empty cuda.h file. Some existing CUDA programs include this file but don't require any of the functions.</p>
-<h2>8.9.4 Choosing HIP File Extensions</h2>
-<p>Many existing CUDA projects use the .cu and .cuh file extensions to indicate code that should be run through the NVCC compiler. For quick HIP ports, leaving these file extensions unchanged is often easier, as it minimizes the work required to change file names in the directory and #include statements in the files.</p>
-<p>For new projects or ports which can be re-factored, we recommend the use of the extension .hip.cpp for source files, and .hip.h or .hip.hpp for header files. This indicates that the code is standard C++ code, but also provides a unique indication for make tools to run hipcc when appropriate.</p>
-<h2>8.10 Workarounds</h2>
-<h2>8.10.1 warpSize</h2>
-<p>Code should not assume a warp size of 32 or 64. See Warp Cross-Lane Functions for information on how to write portable wave-aware code.</p>
-<h2>8.10.2 Kernel launch with group size &gt; 256</h2>
-<p>Kernel code should use __attribute__((amdgpu_flat_work_group_size(&lt;min&gt;,&lt;max&gt;))) . For example:</p>
-<p><strong>**Following code does:** The provided code snippet appears to be a mix of HTML tags with unusual formatting and indentation. However, it does not form a valid or meaningful HTML structure. The code includes opening and closing tags for paragraphs (`<p>`), headings (`<h1>`), anchors (`<a>`), and bold text (`<b>`), but they are not properly nested or used in a coherent way. As it stands, this code does not serve any functional purpose in a web page and would not render any meaningful content. It seems to be a collection of HTML tags without a clear intent or structure.</strong></p>
-<pre><code><_SQL_></code></pre>
-<h2>8.11 memcpyToSymbol</h2>
-<p>HIP support for hipMemcpyToSymbol is complete. This feature allows a kernel to define a device-side data symbol which can be accessed on the host side. The symbol can be in __constant or device space.</p>
-<p>Note that the symbol name needs to be encased in the HIP_SYMBOL macro, as shown in the code example below. This also applies to hipMemcpyFromSymbol , hipGetSymbolAddress , and hipGetSymbolSize .</p>
-<p>For example:</p>
-<p>Device Code:</p>
-<p><strong>**Following code does:** The provided snippet appears to be a fragment of HTML code rather than a complete Python script. It includes an HTML paragraph (`<p>`) and an anchor (`<a>`) tag. The paragraph contains a brief description mentioning a "test" that caused a "segmentation fault issue." The anchor tag seems to reference a URL or file path related to a source file (`hipMemcpy_simple.cpp`) at a specific line (147), which is likely part of a test or example code related to memory operations in a runtime API, possibly for a GPU or parallel computing context. The snippet is incomplete and lacks context, but it suggests documentation or a report of a specific issue in a codebase.</strong></p>
-<pre><code><_C++_></code></pre>
-<p>(continued from previous page)</p>
-<p><strong>**Following code does:** The provided text does not appear to be a functional code snippet. Instead, it seems to be a fragment of a document or a placeholder text, possibly from a documentation file related to a software release (HIP Documentation, Release 6.1.40092). The text includes various symbols and characters that do not form a coherent or executable code. It might be part of a larger document or a formatting artifact.</strong></p>
-<pre><code>        {
-            A[i] = -1*i;
-            B[i] = 0;
-        }
-
-        HIP_ASSERT(hipMalloc((void**)&Ad, SIZE));
-
-        HIP_ASSERT(hipMemcpyToSymbol(HIP_SYMBOL(Value), A, SIZE, 0, hipMemcpyHostToDevice));
-        hipLaunchKernelGGL(Get, dim3(1,1,1), dim3(LEN,1,1), 0, 0, Ad);
-        HIP_ASSERT(hipMemcpy(B, Ad, SIZE, hipMemcpyDeviceToHost));
-
-        for(unsigned i=0;i<LEN;i++)
-        {
-            assert(A[i] == B[i]);
-        }
-        std::cout<<"Passed"<<std::endl;
-    }
-    
-    
-    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -</code></pre>
-<h2>8.12 CU_POINTER_ATTRIBUTE_MEMORY_TYPE</h2>
-<p>To get pointer's memory type in HIP/HIP-Clang, developers should use hipPointerGetAttributes API. First parameter of the API is hipPointerAttribute_t which has 'type' as member variable. 'type' indicates input pointer is allocated on device or host.</p>
-<p>For example:</p>
-<p><strong>**Following code does:** This code snippet is a shell command that sets the environment variable `HIP_VISIBLE_DEVICES` to `0,1`. This variable is used in systems with AMD GPUs to specify which GPUs should be visible and accessible to applications using the HIP (Heterogeneous-Compute Interface for Portability) platform. By setting it to `0,1`, the command is indicating that only the GPUs with IDs 0 and 1 should be available for use by HIP-enabled applications. This is useful for managing GPU resources and controlling which GPUs are used for specific tasks.</strong></p>
-<pre><code>            For example:
-            double * ptr;
-            hipMalloc(reinterpret_cast<void**>(&ptr), sizeof(double));
-            hipPointerAttribute_t attr;
-            hipPointerGetAttributes(&attr, ptr); /*attr.type will have value as hipMemoryTypeDevice*/
-
-            double* ptrHost;
-            hipHostMalloc(&ptrHost, sizeof(double));
-            hipPointerAttribute_t attr;
-            hipPointerGetAttributes(&attr, ptrHost); /*attr.type will have value as _
-           ...hipMemoryTypeHost*/
-
-            Data data file.MaximumTime amount value as different from end.MaximumTime amount value</code></pre>
-<p>Please note, hipMemoryType enum values are different from cudaMemoryType enum values.</p>
-<p>For example, on AMD platform, hipMemoryType is defined in hip_runtime_api.h ,</p>
-<p><strong>**Following code does:** It seems like you've provided a placeholder or incomplete code snippet. If you have a specific Python code snippet you'd like me to explain, please provide the actual code, and I'll be happy to help!</strong></p>
-<pre><code>            For example, on AMD platform, hipMemoryType is defined in hip_runtime_api.h,
-            
-        typedef enum hipMemoryType {
-            hipMemoryTypeHost = 0,     ///< Memory is physically located on host
-            hipMemoryTypeDevice = 1,  ///< Memory is physically located on device. (see deviceId,
-        --for specific device)
-            hipMemoryTypeArray = 2,   ///< Array memory, physically located on device. (see_,
-        --deviceId for specific device)
-            hipMemoryTypeUnified = 3, ///< Not used currently
-            hipMemoryTypeManaged = 4  ///< Managed memory, automatically managed by the unified.
-        --memory system
-        } hipMemoryType;</code></pre>
-<p>Looking into CUDA toolkit, it defines cudaMemoryType as following,</p>
-<p><strong>**Following code does:** This code snippet is part of a larger program that is likely managing GPU devices for computation. It checks if the total number of devices (`totalDeviceNum`) is greater than 2. If this condition is true, it sets an environment variable `HIP_VISIBLE_DEVICES` to "0,1,2", which specifies that only the first three devices (indexed 0, 1, and 2) should be visible and used by the program. The `setenv` function is used to set this environment variable, with the last argument `1` indicating that it should overwrite any existing value. The `assert` statement then checks that the function `getDeviceNumber(false)` returns 3, ensuring that exactly three devices are recognized as available for use. This setup is likely part of a configuration process for a program that utilizes GPU resources.</strong></p>
-<pre><code><_Cuda_></code></pre>
-<p>In this case, memory type translation for hipPointerGetAttributes needs to be handled properly on NVIDIA platform to get the correct memory type in CUDA, which is done in the file nvidia_hip_runtime_api.h .</p>
-<p>So in any HIP applications which use HIP APIs involving memory types, developers should use #ifdef in order to assign the correct enum values depending on NVIDIA or AMD platform.</p>
-<p>As an example, please see the code from the link.</p>
-<p>With the #ifdef condition, HIP APIs work as expected on both AMD and NVIDIA platforms.</p>
-<p>Note, cudaMemoryTypeUnregstered is currently not supported in hipMemoryType enum, due to HIP functionality backward compatibility.</p>
-<h2>8.13 threadfence_system</h2>
-<p>threadfence_system makes all device memory writes, all writes to mapped host memory, and all writes to peer memory visible to CPU and other GPU devices. Some implementations can provide this behavior by flushing the GPU L2 cache. HIP/HIP-Clang does not provide this functionality. As a workaround, users can set the environment variable HSA_DISABLE_CACHE=1 to disable the GPU L2 cache. This will affect all accesses and for all kernels and so may have a performance impact.</p>
-<h2>8.13.1 Textures and Cache Control</h2>
-<p>Compute programs sometimes use textures either to access dedicated texture caches or to use the texture-sampling hardware for interpolation and clamping. The former approach uses simple point samplers with linear interpolation, essentially only reading a single point. The latter approach uses the sampler hardware to interpolate and combine multiple samples. AMD hardware, as well as recent competing hardware, has a unified texture/L1 cache, so it no longer has a dedicated texture cache. But the NVCC path often caches global loads in the L2 cache, and some programs may benefit from explicit control of the L1 cache contents. We recommend the __ldg instruction for this purpose.</p>
-<p>AMDcompilers currently load all data into both the L1 and L2 caches, so __ldg is treated as a no-op.</p>
-<p>We recommend the following for functional portability:</p>
-<ul>
-<li style="list-style-type: '· ';">For programs that use textures only to benefit from improved caching, use the __ldg instruction</li>
-<li style="list-style-type: '· ';">Programs that use texture object and reference APIs, work well on HIP</li>
-</ul>
-<h2>8.14 More Tips</h2>
-<h2>8.14.1 HIP Logging</h2>
-<p>Onan AMDplatform, set the AMD_LOG_LEVEL environment variable to log HIP application execution information.</p>
-<p>The value of the setting controls different logging level,</p>
-<p><strong>**Following code does:** This code snippet is a command used in the GNU Debugger (GDB) environment. It sets an environment variable named `AND_SERIALIZE_KERNEL` to the value `3` for the program being debugged. This can be used to influence the behavior of the program during debugging, potentially enabling or configuring specific features or modes related to kernel serialization, depending on how the program interprets this environment variable.</strong></p>
-<pre><code><_C++_></code></pre>
-<p>Logging mask is used to print types of functionalities during the execution of HIP application. It can be set as one of the following values,</p>
-<p><strong>**Following code does:** The code snippet is a shell command that executes a program named `hipinfo` located in the `~/hip/bin` directory. The output of this program is redirected twice: first to a file named `~/hipinfo` and then to another file named `~/hip_log.txt`. However, due to the syntax used, the output will only be redirected to `~/hip_log.txt`, as the second redirection overwrites the first one.</strong></p>
-<pre><code><_C++_></code></pre>
-<h2>8.14.2 Debugging hipcc</h2>
-<p>To see the detailed commands that hipcc issues, set the environment variable HIPCC_VERBOSE to 1. Doing so will print to stderr the HIP-clang (or NVCC) commands that hipcc generates.</p>
-<p><strong>**Following code does:** This code defines an enumeration called `LogLevel` in Python, which is used to represent different levels of logging severity. Each log level is associated with an integer value, starting from 0 for `LOG_NONE` (indicating no logging) up to 4 for `LOG_DEBUG` (indicating the most detailed logging). This enumeration can be used in a logging system to categorize and filter log messages based on their severity.</strong></p>
-<pre><code>export HIPCC_VERBOSE=1
-make
-
-...
-hipcc-cmd: /opt/rcm/bin/hipcc --offload-arch=native -x hip backprop_cuda.cu</code></pre>
-<h2>8.14.3 Editor Highlighting</h2>
-<p>See the utils/vim or utils/gedit directories to add handy highlighting to hip files.</p>
-<h2>PORTING CUDA DRIVER API</h2>
-<h2>9.1 Introduction to the CUDA Driver and Runtime APIs</h2>
-<p>CUDA provides a separate CUDA Driver and Runtime APIs. The two APIs have significant overlap in functionality:</p>
-<ul>
-<li style="list-style-type: '· ';">Both APIs support events, streams, memory management, memory copy, and error handling.</li>
-<li style="list-style-type: '· ';">Both APIs deliver similar performance.</li>
-<li style="list-style-type: '· ';">Driver APIs calls begin with the prefix cu while Runtime APIs begin with the prefix cuda . For example, the Driver API API contains cuEventCreate while the Runtime API contains cudaEventCreate , with similar functionality.</li>
-<li style="list-style-type: '· ';">The Driver API defines a different but largely overlapping error code space than the Runtime API, and uses a different coding convention. For example, Driver API defines CUDA_ERROR_INVALID_VALUE while the Runtime API defines cudaErrorInvalidValue</li>
-</ul>
-<p>The Driver API offers two additional pieces of functionality not provided by the Runtime API: cuModule and cuCtx APIs.</p>
-<h2>9.1.1 cuModule API</h2>
-<p>The Module section of the Driver API provides additional control over how and when accelerator code objects are loaded. For example, the driver API allows code objects to be loaded from files or memory pointers. Symbols for kernels or global data can be extracted from the loaded code objects. In contrast, the Runtime API automatically loads and (if necessary) compiles all of the kernels from an executable binary when run. In this mode, NVCC must be used to compile kernel code so the automatic loading can function correctly.</p>
-<p>Both Driver and Runtime APIs define a function for launching kernels (called cuLaunchKernel or cudaLaunchKernel . The kernel arguments and the execution configuration (grid dimensions, group dimensions, dynamic shared memory, and stream) are passed as arguments to the launch function. The Runtime additionally provides the &lt;&lt;&lt; &gt;&gt;&gt; syntax for launching kernels, which resembles a special function call and is easier to use than explicit launch API (in particular with respect to handling of kernel arguments). However, this syntax is not standard C++ and is available only when NVCC is used to compile the host code.</p>
-<p>The Module features are useful in an environment which generates the code objects directly, such as a new accelerator language front-end. Here, NVCC is not used. Instead, the environment may have a different kernel language or different compilation flow. Other environments have many kernels and do not want them to be all loaded automatically. The Module functions can be used to load the generated code objects and launch kernels. As we will see below, HIP defines a Module API which provides similar explicit control over code object management.</p>
-<h2>9.1.2 cuCtx API</h2>
-<p>The Driver API defines 'Context' and 'Devices' as separate entities. Contexts contain a single device, and a device can theoretically have multiple contexts. Each context contains a set of streams and events specific to the context. Historically contexts also defined a unique address space for the GPU, though this may no longer be the case in Unified Memory platforms (since the CPU and all the devices in the same process share a single unified address space). The Context APIs also provide a mechanism to switch between devices, which allowed a single CPU thread to send commands to different GPUs. HIP as well as a recent versions of CUDA Runtime provide other mechanisms to accomplish this feat - for example using streams or cudaSetDevice .</p>
-<p>The CUDA Runtime API unifies the Context API with the Device API. This simplifies the APIs and has little loss of functionality since each Context can contain a single device, and the benefits of multiple contexts has been replaced with other interfaces. HIP provides a context API to facilitate easy porting from existing Driver codes. In HIP, the Ctx functions largely provide an alternate syntax for changing the active device.</p>
-<p>Most new applications will prefer to use hipSetDevice or the stream APIs, therefore HIP has marked hipCtx APIs as deprecated . Support for these APIs may not be available in future releases. For more details on deprecated APIs please refer HIP deprecated APIs .</p>
-<h2>9.2 HIP Module and Ctx APIs</h2>
-<p>Rather than present two separate APIs, HIP extends the HIP API with new APIs for Modules and Ctx control.</p>
-<h2>9.2.1 hipModule API</h2>
-<p>Like the CUDA Driver API, the Module API provides additional control over how code is loaded, including options to load code from files or from in-memory pointers. NVCC and HIP-Clang target different architectures and use different code object formats: NVCC is cubin or ptx files, while the HIP-Clang path is the hsaco format. The external compilers which generate these code objects are responsible for generating and loading the correct code object for each platform. Notably, there is not a fat binary format that can contain code for both NVCC and HIP-Clang platforms. The following table summarizes the formats used on each platform:</p>
-<p><strong>**Following table contains:** The table represents a list of functions related to thread and grid group operations, likely in the context of parallel computing or GPU programming. Each row corresponds to a specific function, detailing its support across different platforms or frameworks.
-
-The columns are as follows:
-- **Function**: This column lists the name and signature of the function.
-- **Supported in HIP**: This column indicates whether the function is supported in the HIP (Heterogeneous-Compute Interface for Portability) framework, with a "✓" symbol denoting support.
-- **Supported in CUDA**: This column indicates whether the function is supported in the CUDA (Compute Unified Device Architecture) framework, also using a "✓" symbol to denote support.
-
-Noteworthy observations:
-- All listed functions are supported in both HIP and CUDA, as indicated by the "✓" symbols in both columns for each function. This suggests a high level of compatibility or standardization for these functions across the two frameworks.</strong></p>
-<table><tbody><tr><th>Format</th><th>APIs</th><th>NVCC</th><th>HIP-CLANG</th></tr><tr><td>Code Object Fat Binary</td><td>hipModuleLoad , hipModuleLoadData hipModuleLoadFatBin</td><td>.cubin or PTX text .fatbin</td><td>.hsaco .hip_fatbin</td></tr></tbody></table>
-<p>hipcc uses HIP-Clang or NVCC to compile host codes. Both of these may embed code objects into the final executable, and these code objects will be automatically loaded when the application starts. The hipModule API can be used to load additional code objects, and in this way provides an extended capability to the automatically loaded code objects. HIP-Clang allows both of these capabilities to be used together, if desired. Of course it is possible to create a program with no kernels and thus no automatic loading.</p>
-<h2>9.2.2 hipCtx API</h2>
-<p>HIP provides a Ctx API as a thin layer over the existing Device functions. This Ctx API can be used to set the current context, or to query properties of the device associated with the context. The current context is implicitly used by other APIs such as hipStreamCreate .</p>
-<h2>9.2.3 hipify translation of CUDA Driver API</h2>
-<p>The HIPIFY tools convert CUDA Driver APIs for streams, events, modules, devices, memory management, context, profiler to the equivalent HIP driver calls. For example, cuEventCreate will be translated to hipEventCreate . HIPIFY tools also convert error codes from the Driver namespace and coding convention to the equivalent HIP error code. Thus, HIP unifies the APIs for these common functions.</p>
-<p>The memory copy API requires additional explanation. The CUDA driver includes the memory direction in the name of the API ( cuMemcpyH2D ) while the CUDA driver API provides a single memory copy API with a parameter that specifies the direction and additionally supports a 'default' direction where the runtime determines the direction automatically. HIP provides APIs with both styles: for example, hipMemcpyH2D as well as hipMemcpy . The first flavor may be faster in some cases since they avoid host overhead to detect the different memory directions.</p>
-<p>HIP defines a single error space, and uses camel-case for all errors (i.e. hipErrorInvalidValue ).</p>
-<h2>9.2.3.1 Address Spaces</h2>
-<p>HIP-Clang defines a process-wide address space where the CPU and all devices allocate addresses from a single unified pool. Thus addresses may be shared between contexts, and unlike the original CUDA definition a new context does not create a new address space for the device.</p>
-<h2>9.2.3.2 Using hipModuleLaunchKernel</h2>
-<p>hipModuleLaunchKernel is cuLaunchKernel in HIP world. It takes the same arguments as cuLaunchKernel .</p>
-<h2>9.2.3.3 Additional Information</h2>
-<ul>
-<li style="list-style-type: '· ';">HIP-Clang creates a primary context when the HIP API is called. So in a pure driver API code, HIP-Clang will create a primary context while HIP/NVCC will have empty context stack. HIP-Clang will push primary context to context stack when it is empty. This can have subtle differences on applications which mix the runtime and driver APIs.</li>
-</ul>
-<h2>9.2.4 hip-clang Implementation Notes</h2>
-<h2>9.2.4.1 .hip_fatbin</h2>
-<p>hip-clang links device code from different translation units together. For each device target, a code object is generated. Code objects for different device targets are bundled by clang-offload-bundler as one fatbinary, which is embeded as a global symbol __hip_fatbin in the .hip_fatbin section of the ELF file of the executable or shared object.</p>
-<h2>9.2.4.2 Initialization and Termination Functions</h2>
-<p>hip-clang generates initialization and termination functions for each translation unit for host code compilation. The initialization functions call __hipRegisterFatBinary to register the fatbinary embeded in the ELF file. They also call __hipRegisterFunction and __hipRegisterVar to register kernel functions and device side global variables. The termination functions call __hipUnregisterFatBinary . hip-clang emits a global variable __hip_gpubin_handle of void** type with linkonce linkage and inital value 0 for each host translation unit. Each initialization function checks __hip_gpubin_handle and register the fatbinary only if __hip_gpubin_handle is 0 and saves the return value of __hip_gpubin_handle to __hip_gpubin_handle . This is to guarantee that the fatbinary is only registered once. Similar check is done in the termination functions.</p>
-<h2>9.2.4.3 Kernel Launching</h2>
-<p>hip-clang supports kernel launching by CUDA &lt;&lt;&lt;&gt;&gt;&gt; syntax, hipLaunchKernelGGL. The latter one is macro which expand to CUDA &lt;&lt;&lt;&gt;&gt;&gt; syntax.</p>
-<p>When the executable or shared library is loaded by the dynamic linker, the initialization functions are called. In the initialization functions, when __hipRegisterFatBinary is called, the code objects containing all kernels are loaded; when __hipRegisterFunction is called, the stub functions are associated with the corresponding kernels in code objects.</p>
-<p>hip-clang implements two sets of kernel launching APIs.</p>
-<p>By default, in the host code, for the &lt;&lt;&lt;&gt;&gt;&gt; statement, hip-clang first emits call of hipConfigureCall to set up the threads and grids, then emits call of the stub function with the given arguments. In the stub function, hipSetupArgument is called for each kernel argument, then hipLaunchByPtr is called with a function pointer to the stub function. In hipLaunchByPtr , the real kernel associated with the stub function is launched.</p>
-<h2>9.2.5 NVCC Implementation Notes</h2>
-<h2>9.2.5.1 Interoperation between HIP and CUDA Driver</h2>
-<p>CUDA applications may want to mix CUDA driver code with HIP code (see example below). This table shows the type equivalence to enable this interaction.</p>
-<p><strong>**Following table contains:** The table represents a list of functions related to matrix operations, specifically in the context of GPU programming. Each row corresponds to a different function, detailing its signature and the environments in which it is supported.
-
-The columns are as follows:
-- **Function**: This column lists the function signatures, which include the function name and parameters. These functions appear to be related to matrix operations such as loading, storing, filling, and performing matrix multiplication.
-- **Supported in HIP**: This column indicates whether the function is supported in the HIP (Heterogeneous-Compute Interface for Portability) environment. In this preview, none of the functions are marked as supported in HIP.
-- **Supported in CUDA**: This column indicates whether the function is supported in the CUDA (Compute Unified Device Architecture) environment. All functions in this preview are marked with a check (✓), indicating they are supported in CUDA.
-
-A noteworthy observation is that all the functions listed are supported in CUDA but not in HIP, suggesting a potential limitation or gap in HIP support for these specific matrix operations.</strong></p>
-<table><tbody><tr><th>HIP Type</th><th>CU Driver Type</th><th>CUDA Runtime Type</th></tr><tr><td>hipModule_t</td><td>CUmodule</td><td></td></tr><tr><td>hipFunction_t</td><td>CUfunction</td><td></td></tr><tr><td>hipCtx_t</td><td>CUcontext</td><td></td></tr><tr><td>hipDevice_t</td><td>CUdevice</td><td></td></tr><tr><td>hipStream_t</td><td>CUstream</td><td>cudaStream_t</td></tr><tr><td>hipEvent_t</td><td>CUevent</td><td>cudaEvent_t</td></tr><tr><td>hipArray</td><td>CUarray</td><td>cudaArray</td></tr></tbody></table>
-<h2>9.2.5.2 Compilation Options</h2>
-<p>The hipModule_t interface does not support cuModuleLoadDataEx function, which is used to control PTX compilation options. HIP-Clang does not use PTX and does not support these compilation options. In fact, HIP-Clang code objects always contain fully compiled ISA and do not require additional compilation as a part of the load step. The corresponding HIP function hipModuleLoadDataEx behaves as hipModuleLoadData on HIP-Clang path (compilation options are not used) and as cuModuleLoadDataEx on NVCC path. For example (CUDA):</p>
-<p><strong>**Following code does:** This code snippet describes a logging system for a HIP (Heterogeneous-Compute Interface for Portability) application. It defines an enumeration `LogMask` with various bitmask values, each representing a different type of logging functionality, such as API calls, synchronization, memory allocation, and more. The logging mask is used to control which types of log messages are printed during the execution of a HIP application. By default, the logging mask is set to a value that enables all logging types, but it can be customized by setting the `AMD_LOG_MASK` environment variable to include only specific types of logs. This allows developers to filter and focus on particular areas of interest when debugging or monitoring the application.</strong></p>
-<pre><code><_Cuda_></code></pre>
-<p>HIP:</p>
-<p><strong>**Following code does:** The code snippet provided is not a valid or meaningful Python code. It appears to be a collection of random characters, including HTML-like tags and whitespace, but it does not perform any computational task or serve any functional purpose. It might be an accidental paste or a placeholder.</strong></p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?xml version="1.0" encoding="UTF-8" />
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        </?xml version="2.0" encoding="UTF-8" />
-                                                                                                                                                                                             <?xml version="3.0" encoding="UTF-8" />
-                                                                                                                                                                                            
-	         
-                                                                                                                                                                                             
-         
-                                                                                                                                                                                              <?xml version="4.0" encoding="UTF-8" />
-                                                                                                                                                                                             </?xml version="5.0" encoding="UTF-8" />
-                                                                                                                                                                                            
-
-          
-                                                                                                                                                                                             <?xml version="6.0" encoding="UTF-8" />
-                                                                                                                                                                                             >
-                                                                                                                                                                                                       <!xml version="7.0" encoding="UTF-8" />
-                                                                                                                                                                                             //
-                                                                                                                                                                                                       </!xml version="8.0" encoding="UTF-8" />
-                                                                                                                                                                                             }</code></pre>
-<p>The below sample shows how to use hipModuleGetFunction .</p>
-<p><strong>**Following code does:** This code snippet logs a message indicating that the HSA (Heterogeneous System Architecture) stack is being initialized. It uses a logging function `ClPrint` from the `amd` namespace, specifying the log level as `LOG_INFO` and the log category as `LOG_INIT`. This is likely part of a larger system where logging is used to track the initialization process of various components.</strong></p>
-<pre><code>#include<hip_runtime.h>
-#include<hip_runtime_api.h>
-#include<iostream>
-#include<fstream>
-#include<vector></code></pre>
-<p><strong>**Following code does:** The provided code snippet appears to be a fragment of HTML or a similar markup language. It includes various HTML tags such as `<HR>`, `<HIP Documentation, Release 6.1.40092>`, `<BR>`, and `<B>`. However, the snippet is mostly empty or improperly formatted, with many tags not closed or used incorrectly. The high-level purpose seems to be related to documentation, possibly for a software release (version 6.1.40092), and it might be intended to format or display logging examples. However, due to the lack of proper structure and content, it does not achieve any meaningful functionality or display.</strong></p>
-<pre><code>#include<hip_runtime.h>
-#include<hip_runtime_api.h>
-#include<iostream>
-#include<fstream>
-#include<vector></code></pre>
-<p><strong>**Following code does:** This line appears to be a version identifier or header for a document related to "HIP Documentation." It indicates that the document is associated with a release version "6.1.40092." This is not executable code but rather a label or title that likely precedes detailed documentation about a software product or library named "HIP."</strong></p>
-<pre><code>HIP Documentation, Release 6.1.40092
-
-
-
-
-#define LEN 64
-#define SIZE LEN<<2
-
-#ifdef __HIP_PLATFORM_AMD__
-#define fileName "vcpy_isa.co"
-#endif
-
-#ifdef __HIP_PLATFORM_NVIDIA__
-#define fileName "vcpy_isa.ptx"
-#endif
-
-#define kernel_name "hello_world"
-
-int main(){
-	float *A, *B;
-	hipDeviceptr_t Ad, Bd;
-	A = new float[LEN];
-	B = new float[LEN];
-
-	for(uint32_t i=0;i<LEN;i++){
-		A[i] = i*1.0f;
-		B[i] = 0.0f;
-		std::cout<<A[i] << " "<<B[i]<<std::endl;
-	}
-
-
-#ifdef __HIP_PLATFORM_NVIDIA__
-		hipInit(0);
-		hipDevice_t device;
-		hipCtx_t context;
-		hipDeviceGet(&device, 0);
-		hipCtxCreate(&context, 0, device);
-#endif
-
-	hipMalloc((void**)&Ad, SIZE);
-	hipMalloc((void**)&Bd, SIZE);
-
-	hipMemcpyHtoD(Ad, A, SIZE);
-	hipMemcpyHtoD(Bd, B, SIZE);
-	hipModule_t Module;
-	hipFunction_t Function;
-	hipModuleLoad(&Module, fileName);
-	hipModuleGetFunction(&Function, Module, kernel_name);
-
-	std::vector<void*>argBuffer(2);
-	memcpy(&argBuffer[0], &Ad, sizeof(void*));
-	memcpy(&argBuffer[1], &Bd, sizeof(void*));
-
-	size_t size = argBuffer.size()*sizeof(void*);
-
-	void *config[] = {
-		HIP_LAUNCH_PARAM_BUFFER_POINTER, &argBuffer[0],
-
-
-
-54</code></pre>
-<p>(continued from previous page)</p>
-<p>(continues on next page)</p>
-<p>(continued from previous page)</p>
-<p><strong>**Following code does:** The code snippet provided appears to be malformed or corrupted, as it contains excessive whitespace and incomplete or nonsensical elements. Specifically, it includes what looks like an HTML/XML-like tag `<kendo runume. </kendo>runume.`, which is not valid Python syntax. Without additional context or correction, it is not possible to determine a high-level purpose for this code.</strong></p>
-<pre><code>        HIP_LAUNCH_PARAM_BUFFER_SIZE, &size,
-        HIP_LAUNCH_PARAM_END
-    };
-
-    hipModuleLaunchKernel(Function, 1, 1, 1, LEN, 1, 1, 0, 0, NULL, (void**)&config);
-
-    hipMemcpyDtoH(B, Bd, SIZE);
-    for(uint32_t i=0;i<LEN;i++){
-        std::cout<<A[i]<<" - "<<B[i]<<std::endl;
-    }
-
-#ifdef __HIP_PLATFORM_NVIDIA__
-          hipCtxDetach(context);
-#endif
-
-    return 0;
-}
-
-__A__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ ======"__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__= "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "_ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = '__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ from "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "___ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "'</code></pre>
-<h2>9.3 HIP Module and Texture Driver API</h2>
-<p>HIP supports texture driver APIs however texture reference should be declared in host scope. Following code explains the use of texture reference for __HIP_PLATFORM_AMD__ platform.</p>
-<p><strong>**Following code does:** The provided code snippet does not contain any valid Python code. Instead, it appears to be a malformed and nonsensical mix of XML-like tags and URLs, specifically referencing "amazonaws.com" multiple times. This could potentially be an attempt at obfuscation or a corrupted piece of data, but it does not perform any meaningful function or operation as it stands.</strong></p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        // Code to generate code object
-
-                                                                                                                                                                                                      
-#include "hip/hip_runtime.h"
-                                                                                                                                                                                                      
-extern texture<float, 2, hipReadModeElementType> tex;
-
-        __global__ void tex2dKernel(hipLaunchParm lp, float* outputData,
-                                                                                                                                                                                                       //</code></pre>
-<p><strong>**Following code does:** This code snippet appears to be a log output from a graphics or compute driver, specifically related to memory allocation and management. It logs the allocation of memory buffers, including the size of the allocation (100,000 bytes in each case), the memory address ranges for the allocated pointers, and the associated objects. Additionally, it logs a call to `hipMemGetInfo`, which returns the total and free memory available, indicating that the system has 12.06 GB of total memory with 11.93 GB free, representing 99% availability. The log entries include timestamps and thread identifiers for context.</strong></p>
-<pre><code>  }
-
-  // Host code:
-
-  texture<float, 2, hipReadModeElementType> tex;
-
-  void myFunc ()
-  {
-
-      //...
-
-      textureReference* texref;
-      hipModuleGetTexRef(&texref, Module1, "tex");
-      hipTexRefSetAddressMode(texref, 0, hipAddressModeWrap);
-      hipTexRefSetAddressMode(texref, 1, hipAddressModeWrap);
-      hipTexRefSetFilterMode(texref, hipFilterModePoint);</code></pre>
-<p>(continues on next page)</p>
-<p><strong>**Following code does:** This code snippet appears to be a part of a parallel programming framework, likely related to GPU programming, such as CUDA. The `thread_block` class is used to represent a group of threads that can cooperate and synchronize with each other during execution. The line `thread_block g = this_thread_block();` constructs an instance `g` of the `thread_block` class, which represents the current block of threads that the executing thread belongs to. This allows the thread to access information and perform operations specific to its block, such as synchronization or shared memory access.</strong></p>
-<pre><code>    hipTexRefSetFlags(texref, 0);
-    hipTexRefSetFormat(texref, HIP_AD_FORMAT_FLOAT, 1);
-    hipTexRefSetArray(texref, array, HIP_TRSA_OVERRIDE_FORMAT);
-
-    //...
-}</code></pre>
-<p>(continued from previous page)</p>
-<h2>TEN</h2>
-<h2>PROGRAMMING FOR HIP RUNTIME COMPILER (RTC)</h2>
-<p>HIP lets you compile kernels at runtime with the hiprtc* APIs. Kernels can be stored as a text string and can be passed to HIPRTC APIs alongside options to guide the compilation.</p>
-<p>NOTE:</p>
-<ul>
-<li style="list-style-type: '· ';">This library can be used on systems without HIP installed nor AMD GPU driver installed at all (offline compilation). Therefore, it does not depend on any HIP runtime library.</li>
-<li style="list-style-type: '· ';">But it does depend on comgr. You may try to statically link comgr into HIPRTC to avoid any ambiguity.</li>
-<li style="list-style-type: '· ';">Developers can decide to bundle this library with their application.</li>
-</ul>
-<h2>10.1 Example</h2>
-<p>To use HIPRTC functionality, HIPRTC header needs to be included first. #include &lt;hip/hiprtc.h&gt;</p>
-<p>Kernels can be stored in a string:</p>
-<p><strong>**Following code does:** The code snippet appears to be a fragment of a larger codebase, likely related to a grid or parallel computing framework. The `grid_group` is defined as a class, but the snippet does not provide its implementation details. The comment "Constructed via:" suggests that instances of `grid_group` are created using a function or method called `this_grid()`. This implies that `this_grid()` is a factory function or method that returns an instance of `grid_group`, possibly representing a group or collection of grid elements or processes. The purpose of this setup is likely to manage or interact with a grid structure in a computational context.</strong></p>
-<pre><code><_C_></code></pre>
-<p>Now to compile this kernel, it needs to be associated with hiprtcProgram type, which is done by declaring hiprtcProgram prog; and associating the string of kernel with this program:</p>
-<p><strong>**Following code does:** The code snippet appears to be a syntax error or incomplete code. In Python, the `class` keyword is used to define a new class, but the snippet includes a `|` character at the beginning and ends with a semicolon, both of which are not valid in Python class definitions. Additionally, the class body is missing. If this were intended to be a Python class definition, it should start with `class multi_grid_group:` followed by an indented block defining the class's attributes and methods.</strong></p>
-<pre><code>hiprtcCreateProgram(&prog,                    // HIPRTC program
-                       kernel,                // kernel string
-                       "gpu_kernel.cu",       // Name of the file
-                       num_headers,            // Number of headers
-                       &header_sources[0],     // Header sources
-                       &header_names[0]);      // Name of header files</code></pre>
-<p>hiprtcCreateProgram API also allows you to add headers which can be included in your RTC program. For online compilation, the compiler pre-defines HIP device API functions, HIP specific types and macros for device compilation, but does not include standard C/C++ headers by default. Users can only include header files provided to hiprtcCreateProgram .</p>
-<p>After associating the kernel string with hiprtcProgram , you can now compile this program using:</p>
-<p><strong>**Following code does:** The code snippet provided is a single semicolon (`;`). In Python, a semicolon is used to separate multiple statements on a single line, but on its own, it does nothing and has no effect. Therefore, this code snippet does not perform any operation or have any functional purpose.</strong></p>
-<pre><code>
-
-hiprtcCompileProgram(prog,     // hiprtcProgram
-                         0,          // Number of options
-                          options);  // Clang Options [Supported Clang Options](clang_options.
-
---md)</code></pre>
-<p>hiprtcCompileProgram returns a status value which can be converted to string via hiprtcGetErrorString . If compilation is successful, hiprtcCompileProgram will return HIPRTC_SUCCESS .</p>
-<p>If the compilation fails, you can look up the logs via:</p>
-<p><strong>**Following code does:** The code snippet `<_C_>` appears to be a placeholder or a non-functional piece of code. It does not represent any valid Python syntax or operation. It might be used as a marker or a template in a larger codebase where actual code is intended to be inserted later.</strong></p>
-<pre><code><_C++_></code></pre>
-<p>If the compilation is successful, you can load the compiled binary in a local variable.</p>
-<p><strong>**Following code does:** The code snippet you provided seems to be a placeholder or a tag indicating a YAML (YAML Ain't Markup Language) document or section, rather than actual executable code. YAML is a human-readable data serialization standard often used for configuration files and data exchange between languages with different data structures. Without specific YAML content, it's not possible to determine the exact purpose or functionality. If you have a YAML document or configuration, it typically defines settings, parameters, or data structures in a structured format.</strong></p>
-<pre><code>  size_t codeSize;
-  hiprtcGetCodeSize(prog, &codeSize);
-
-  vector<char> kernel_binary(codeSize);
-  hiprtcGetCode(prog, kernel_binary.data());</code></pre>
-<p>After loading the binary, hiprtcProgram can be destroyed. hiprtcDestroyProgram(&amp;prog);</p>
-<p>The binary present in kernel_binary can now be loaded via hipModuleLoadData API.</p>
-<p><strong>**Following code does:** It seems there is a formatting error in your request. The code snippet is labeled as Python, but the placeholder `<_C++_>` suggests it might be intended for C++. Please provide the correct code snippet or clarify the language so I can assist you accurately.</strong></p>
-<pre><code>hipModule_t module;
-hipFunction_t kernel;
-
-hipModuleLoadData(&module, kernel_binary.data());
-hipModuleGetFunction(&kernel, module, "vector_add");</code></pre>
-<p>And now this kernel can be launched via hipModule APIs.</p>
-<p>The full example is below:</p>
-<p><strong>**Following code does:** The placeholder `<_SQL_>` suggests that this is not actual code but rather a placeholder for SQL code. In this context, it indicates that the code snippet is intended to represent a section where SQL queries or statements would be placed. Without specific SQL code, it's not possible to determine the exact functionality, but generally, SQL code is used to interact with databases, performing operations such as querying data, updating records, inserting new data, or deleting existing data.</strong></p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        //</code></pre>
-<p>(continued from previous page)</p>
-<p><strong>**Following code does:** The code snippet appears to be a fragment of code that is not complete or syntactically correct in Python. The line seems to be attempting to define a class named `coalesced_group`, but it includes a syntax error with the presence of the `|` character at the beginning, which is not valid in Python class definitions. In a correct context, this line would be part of a class definition, but as it stands, it does not perform any function or operation.</strong></p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        </----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                    <-----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        >----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                   
-    <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                <----------------------------------------------------------------------------------------------------------------------    <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                               
-        <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                            <----------------------------------------------------------------------------------------------------------------------        <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                           
-            <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                        <----------------------------------------------------------------------------------------------------------------------            <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                       
-                <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                    <----------------------------------------------------------------------------------------------------------------------                <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                   
-                    <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                <----------------------------------------------------------------------------------------------------------------------                    <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                               
-                        <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                            <----------------------------------------------------------------------------------------------------------------------                        <----------------------------------------------------------------------------------------------------------------------</code></pre>
-<p><strong>**Following code does:** The code snippet appears to be a fragment of a larger codebase, likely related to parallel computing or GPU programming. The line seems to be attempting to define a variable named `active` within a group or context, possibly using a syntax specific to a particular framework or language extension. The `coalesced_threads()` function or method is likely intended to return a set of threads that are coalesced, meaning they are grouped together to execute in a more efficient manner, often to optimize memory access patterns in parallel processing environments. However, the syntax is unusual and may contain typographical errors or be specific to a non-standard language or domain-specific language.</strong></p>
-<pre><code>HIP Documentation,Release 6.1.40092</code></pre>
-<p>(continued from previous page)</p>
-<p><strong>**Following code does:** The code snippet `<_Cuda_>` appears to be a placeholder or a symbolic representation rather than actual executable Python code. In the context of programming, "Cuda" typically refers to NVIDIA's parallel computing platform and application programming interface (API) model, which allows developers to use a CUDA-enabled graphics processing unit (GPU) for general purpose processing. However, without additional context or actual code, it's not possible to determine the specific functionality or purpose of this placeholder.</strong></p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        }
-                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       }
-
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                       	                                                                                                                                                                                                      
-
-                                                                                                                                                                                                      
-                                                                                                                                                                                                     
-
-                                                                                                                                                                                                    
- 
-                                                                                                                                                                                                    
-
-                                                                                                                                                                                                      
-
- 
-                                                                                                                                                                                                     }
- 
-                                                                                                                                                                                                    }
-  
-                                                                                                                                                                                                    }
-
-  
-                                                                                                                                                                                                   
-  
-                                                                                                                                                                                                   }</code></pre>
-<h2>10.2 HIPRTC specific options</h2>
-<p>HIPRTC provides a few HIPRTC specific flags</p>
-<ul>
-<li style="list-style-type: '· ';">--gpu-architecture : This flag can guide the code object generation for a specific gpu arch. Example: --gpu-architecture=gfx906:sramecc+:xnack, its equivalent to --offload-arch .</li>
-<li>-This option is compulsory if compilation is done on a system without AMD GPUs supported by HIP runtime.</li>
-<li>-Otherwise, HIPRTC will load the hip runtime and gather the current device and its architecture info and use it as option.</li>
-<li style="list-style-type: '· ';">-fgpu-rdc : This flag when provided during the hiprtcCompileProgram generates the bitcode (HIPRTC doesn't convert this bitcode into ISA and binary). This bitcode can later be fetched using hiprtcGetBitcode and hiprtcGetBitcodeSize APIs.</li>
-</ul>
-<h2>10.2.1 Bitcode</h2>
-<p>In the usual scenario, the kernel associated with hiprtcProgram is compiled into the binary which can be loaded and run. However, if -fpu-rdc option is provided in the compile options, HIPRTC calls comgr and generates only the LLVM bitcode. It doesn't convert this bitcode to ISA and generate the final binary.</p>
-<p><strong>**Following code does:** The code snippet provided is not functional Python code. It consists mostly of whitespace and a few non-Python elements such as `//`, `/*`, and `*/`, which are comment syntax from languages like C or C++. The snippet appears to be an attempt to create a comment block, but it is not valid in Python. Therefore, it does not perform any operations or have any high-level purpose in a Python context.</strong></p>
-<pre><code>  std::string sarg = std::string("-fgpu-rdc");
-  const char* options[] = {
-      sarg.c_str() };
-  hiprtcCompileProgram(prog, // hiprtcProgram
-                        1,     // Number of options
-                        options);</code></pre>
-<p>If the compilation is successful, one can load the bitcode in a local variable using the bitcode APIs provided by HIPRTC.</p>
-<p><strong>**Following code does:** This code snippet is part of a parallel reduction algorithm, typically used in GPU programming or multi-threaded environments. The purpose of this code is to perform a reduction operation, specifically summing up elements in a data set using a hierarchical approach. Here's a high-level summary of what it does:
-
-1. **Initialization**: The loop starts with `i` set to half the size of the group `g`, which likely represents a group of threads or processing units.
-
-2. **Shared Memory Usage**: Each thread stores its value (`val`) in a shared memory array indexed by its thread ID (`group_thread_id`).
-
-3. **Synchronization**: The `g.sync()` calls ensure that all threads in the group reach the same point in the code before proceeding, which is crucial for correct data sharing and avoiding race conditions.
-
-4. **Reduction Step**: Threads with IDs less than `i` add the value from another thread (offset by `i`) to their own value. This effectively reduces the number of active threads by half each iteration, combining values in a tree-like structure.
-
-5. **Iterative Halving**: The loop continues, halving `i` each time, until `i` becomes zero, at which point the reduction is complete, and the final sum is likely stored in one of the threads.
-
-Overall, this code is implementing a parallel reduction to sum up values efficiently across multiple threads, leveraging shared memory and synchronization to ensure correct results.</strong></p>
-<pre><code>size_t bitCodeSize;
-hiprtcGetBitcodeSize(prog, &bitCodeSize);
-
-vector<char> kernel_bitcode(bitCodeSize);
-hiprtcGetBitcode(prog, kernel_bitcode.data());</code></pre>
-<h2>10.2.2 CU Mode vs WGP mode</h2>
-<p>AMDGPUs consist of an array of workgroup processors, each built with 2 compute units (CUs) capable of executing SIMD32. All the CUs inside a workgroup processor use local data share (LDS).</p>
-<p>gfx10+ support execution of wavefront in CU mode and work-group processor mode (WGP). Please refer to section 2.3 of RDNA3 ISA reference.</p>
-<p>gfx9 and below only supports CU mode.</p>
-<p>In WGP mode, 4 warps of a block can simultaneously be executed on the workgroup processor, where as in CU mode only 2 warps of a block can simultaneously execute on a CU. In theory, WGP mode might help with occupancy and increase the performance of certain HIP programs (if not bound to inter warp communication), but might incur performance penalty on other HIP programs which rely on atomics and inter warp communication. This also has effect of how the LDS is split between warps, please refer to RDNA3 ISA reference for more information.</p>
-<p>HIPRTCassumes WGPmodebydefault for gfx10+. This can be overridden by passing -mcumode to HIPRTC compile options in hiprtcCompileProgram .</p>
-<h2>10.3 Linker APIs</h2>
-<p>The bitcode generated using the HIPRTC Bitcode APIs can be loaded using hipModule APIs and also can be linked with other generated bitcodes with appropriate linker flags using the HIPRTC linker APIs. This also provides more flexibility and optimizations to the applications who want to generate the binary dynamically according to their needs. The input bitcodes can be generated only for a specific architecture or it can be a bundled bitcode which is generated for multiple architectures.</p>
-<h2>10.3.1 Example</h2>
-<p>Firstly, HIPRTC link instance or a pending linker invocation must be created using hiprtcLinkCreate , with the appropriate linker options provided.</p>
-<p><strong>**Following code does:** This code snippet is part of a CUDA kernel function, which is designed to run on a GPU. The kernel, named `sum_kernel`, performs a parallel reduction operation. It utilizes shared memory, specifically an array named `workspace`, to efficiently compute the sum of elements from an input array. The `reduce_sum` function is likely responsible for aggregating the values stored in `workspace` and `input`, ultimately producing a single output value that represents the sum of the input elements. This approach leverages the parallel processing capabilities of the GPU to accelerate the summation process.</strong></p>
-<pre><code><_C++_></code></pre>
-<p>Following which, the bitcode data can be added to this link instance via hiprtcLinkAddData (if the data is present as a string) or hiprtcLinkAddFile (if the data is present as a file) with the appropriate input type according to the data or the bitcode used.</p>
-<p><strong>**Following code does:** The provided code snippet is a mix of Python and C++ syntax, but it is mostly composed of whitespace and special characters. It does not form any valid or meaningful code in either language. The snippet includes C++ keywords like `const` and `auto`, as well as comment syntax (`//` and `/* */`), but they are not used in a coherent or executable manner. Therefore, this code does not perform any specific function or task.</strong></p>
-<pre><code>
-hiprtcLinkAddData(rtc_link_state,        // HIPRTC link state
-                         input_type,            // type of the input data or bitcode
-                         bit_code_ptr,           // input data which is null terminated
-                         bit_code_size,          // size of the input data
-                          "a",                   // optional name for this input
-                          0,                     // size of the options
-                          0,                     // Array of options applied to this input
-                          0);                      // Array of option values cast to void*</code></pre>
-<p><strong>**Following code does:** This code snippet is part of a parallel computing operation, likely using a GPU programming model such as CUDA. It involves two main steps:
-
-1. **Thread Block Initialization**: The `this_thread_block()` function is called to obtain a `thread_block` object, which represents a group of threads that can cooperate and share data during execution.
-
-2. **Reduction Operation**: The `reduce_sum` function is used to perform a reduction operation on the `input` data. This operation typically involves summing up elements across the threads within the `thread_block_group`, storing the result in `output`. The `workspace` parameter likely provides temporary storage needed for the reduction process.
-
-Overall, the code is designed to efficiently compute the sum of elements in parallel using a group of threads.</strong></p>
-<pre><code>hiprtcLinkAddFile(rtc_link_state,        // HIPRTC link state
-                         input_type,            // type of the input data or bitcode
-                         bc_file_path.c_str(),  // path to the input file where bitcode is_
---present
-                         0,                   // size of the options
-                          0,                    // Array of options applied to this input
-                          0);                    // Array of option values cast to void*</code></pre>
-<p>Once the bitcodes for multiple architectures are added to the link instance, the linking of the device code must be completed using hiprtcLinkComplete which generates the final binary.</p>
-<p><strong>**Following code does:** This code snippet is written in C++ using the HIP (Heterogeneous-Compute Interface for Portability) API, which is used for GPU programming. The code checks if a single AMD GPU supports cooperative launch capabilities. It first retrieves the current GPU device ID and then queries the device to determine if it supports cooperative launch features. If the device does not support cooperative groups, it outputs a message indicating this and exits the program. This check is important for ensuring that the GPU can handle tasks that require cooperation between multiple threads or blocks.</strong></p>
-<pre><code><_C_></code></pre>
-<p>If the hiprtcLinkComplete returns successfully, the generated binary can be loaded and run using the hipModule* APIs.</p>
-<p><strong>**Following code does:** This code snippet is designed to check the capability of multiple GPUs to support cooperative group launches, specifically in a multi-GPU environment. It iterates over available devices, checking each one for support of the `hipDeviceAttributeCooperativeMultiDeviceLaunch` attribute, which indicates whether the device can participate in cooperative multi-device launches. If a device supports this feature, its ID is added to a list of valid device IDs. If not, a message is printed indicating that the device does not support cooperative groups. This setup is typically used in scenarios where tasks need to be distributed across multiple GPUs that can work together cooperatively.</strong></p>
-<pre><code>      |hipModuleLoadData(&module, bina</code></pre>
-<p><strong>**Following code does:** The code snippet provided is not a valid Python code. It appears to contain a comment written in C/C++ style (using `//` for comments), which suggests that it might be part of a larger C/C++ program. The comment indicates that the code is related to launching a kernel from the host, which is a common operation in parallel computing environments such as CUDA or OpenCL. In such contexts, "launching a kernel" typically means executing a function (the kernel) on a GPU or other parallel processing device from the host CPU. However, without additional context or code, this snippet alone does not perform any operations.</strong></p>
-<pre><code>binary);</code></pre>
-<h2>10.3.1.1 Note</h2>
-<ul>
-<li style="list-style-type: '· ';">The compiled binary must be loaded before HIPRTC link instance is destroyed using the hiprtcLinkDestroy API.</li>
-</ul>
-<h2>hiprtcLinkDestroy(rtc_link_state);</h2>
-<ul>
-<li style="list-style-type: '· ';">The correct sequence of calls is : hiprtcLinkCreate , hiprtcLinkAddData or hiprtcLinkAddFile , hiprtcLinkComplete , hiprtcModuleLoadData , hiprtcLinkDestroy .</li>
-</ul>
-<h2>10.3.2 Input Types</h2>
-<p>HIPRTC provides hiprtcJITInputType enumeration type which defines the input types accepted by the Linker APIs. Here are the enum values of hiprtcJITInputType . However only the input types HIPRTC_JIT_INPUT_LLVM_BITCODE , HIPRTC_JIT_INPUT_LLVM_BUNDLED_BITCODE and HIPRTC_JIT_INPUT_LLVM_ARCHIVES_OF_BUNDLED_BITCODE are supported currently.</p>
-<p>HIPRTC_JIT_INPUT_LLVM_BITCODE can be used to load both LLVM bitcode or LLVM IR assembly code. However, HIPRTC_JIT_INPUT_LLVM_BUNDLED_BITCODE and HIPRTC_JIT_INPUT_LLVM_ARCHIVES_OF_BUNDLED_BITCODE are only for bundled bitcode and archive of bundled bitcode.</p>
-<p><strong>**Following code does:** The code snippet `<_C_>` appears to be a placeholder or a fragment that does not represent any valid or complete Python code. It might be intended as a marker or a template for something to be filled in later. Without additional context or surrounding code, it does not perform any specific function or operation.</strong></p>
-<pre><code><_Cuda_></code></pre>
-<h2>10.3.3 Backward Compatibility of LLVM Bitcode/IR</h2>
-<p>For HIP applications utilizing HIPRTC to compile LLVM bitcode/IR, compatibility is assured only when the ROCm or HIP SDK version used for generating the LLVM bitcode/IR matches the version used during the runtime compilation. When an application requires the ingestion of bitcode/IR not derived from the currently installed AMD compiler, it must run with HIPRTC and comgr dynamic libraries that are compatible with the version of the bitcode/IR.</p>
-<p>comgr, a shared library, incorporates the LLVM/Clang compiler that HIPRTC relies on. To identify the bitcode/IR version that comgr is compatible with, one can execute 'clang -v' using the clang binary from the same ROCm or HIP SDK package. For instance, if compiling bitcode/IR version 14, the HIPRTC and comgr libraries released by AMD around mid 2022 would be the best choice, assuming the LLVM/Clang version included in the package is also version 14.</p>
-<p>To ensure smooth operation and compatibility, an application may choose to ship the specific versions of HIPRTC and comgr dynamic libraries, or it may opt to clearly specify the version requirements and dependencies. This approach guarantees that the application can correctly compile the specified version of bitcode/IR.</p>
-<h2>10.3.4 Link Options</h2>
-<ul>
-<li style="list-style-type: '· ';">HIPRTC_JIT_IR_TO_ISA_OPT_EXT - AMD Only. Options to be passed on to link step of compiler by hiprtcLinkCreate .</li>
-<li style="list-style-type: '· ';">HIPRTC_JIT_IR_TO_ISA_OPT_COUNT_EXT - AMD Only. Count of options passed on to link step of compiler.</li>
-</ul>
-<p>Example:</p>
-<p><strong>**Following code does:** This code snippet is designed to launch a cooperative kernel across multiple GPUs using the HIP (Heterogeneous-Compute Interface for Portability) API. It sets up and manages the execution of a parallel computation task on multiple devices. The code performs the following high-level tasks:
-
-1. Allocates memory for an array of `hipLaunchParams` structures, which will hold the configuration for launching kernels on each GPU.
-2. Iterates over a list of device IDs to configure each GPU:
-   - Sets the current device to the specified GPU.
-   - Creates a stream for asynchronous execution on the GPU.
-   - Prepares the kernel parameters, which include pointers to device memory arrays.
-   - Configures the launch parameters for the kernel, including the function to execute, grid and block dimensions, shared memory size, and the stream.
-3. Launches the cooperative kernel across all specified GPUs using `hipLaunchCooperativeKernelMultiDevice`, allowing the kernels to work together across devices.
-4. The code implies that there is synchronization on the device side after the kernel execution, ensuring that all operations are completed before proceeding.
-
-Overall, this code is used for executing a parallel reduction operation across multiple GPUs in a coordinated manner.</strong></p>
-<pre><code>const char* isaopts[] = {"-mllvm", "-inline-threshold=1", "-mllvm", "-inlinehint-
---threshold=1"};
-std::vector<hiprtcJIT_option> jit_options = {HIPRTC_JIT_IR_TO_ISA_OPT_EXT,
-                                                                                                                                                                                                         HIPRTC_JIT_IR_TO_ISA_OPT_COUNT_EXT};
-size_t isaoptssize = 4;
-                                                                                                                                                                                                       (continues on next page)</code></pre>
-<p><strong>**Following code does:** The code snippet `<_C_>` appears to be a placeholder or a non-functional piece of code. It does not represent any valid Python syntax or operation. It might be used as a marker or a template in a larger codebase where actual code is intended to be inserted later.</strong></p>
-<pre><code>        const void* lopts[] = {(void*)isaopts, (void*)(isaoptssize)};
-        hiprtcLinkState linkstate;
-        hiprtcLinkCreate(2, jit_options.data(), (void**)lopts, &linkstate);</code></pre>
-<h2>10.4 Error Handling</h2>
-<p>HIPRTC defines the hiprtcResult enumeration type and a function hiprtcGetErrorString for API call error handling. hiprtcResult enum defines the API result codes. HIPRTC APIs return hiprtcResult to indicate the call result. hiprtcGetErrorString function returns a string describing the given hiprtcResult code, e.g., HIPRTC_SUCCESS to 'HIPRTC_SUCCESS'. For unrecognized enumeration values, it returns 'Invalid HIPRTC error code'.</p>
-<p>hiprtcResult enum supported values and the hiprtcGetErrorString usage are mentioned below.</p>
-<p><strong>**Following code does:** The code snippet `<_Cython_>` appears to be a placeholder or a reference to Cython, which is a programming language that makes writing C extensions for Python as easy as Python itself. Cython is used to improve the performance of Python code by compiling it into C, which can then be executed more efficiently. However, the snippet itself does not contain any executable code or functionality; it simply seems to indicate the use of Cython in some context. Without additional context or code, it does not perform any specific action.</strong></p>
-<pre><code><_Python_></code></pre>
-<p><strong>**Following code does:** The code snippet appears to be incomplete or malformed, as it starts with an assignment operator (`=`) without a variable on the left-hand side. However, the part `this._grid()` suggests that it is calling a method named `_grid` on an object referred to by `this`. In a complete and correctly formatted context, this line would typically assign the result of the `_grid()` method to a variable. The purpose of the `_grid()` method would depend on its implementation, but it likely relates to some grid-related functionality within the object.</strong></p>
-<pre><code>hiprtcResult result;
-result = hiprtcCompileProgram(prog, 1, opts);
-if (result!= HIPRTC_SUCCESS) {
-std::cout << "hiprtcCompileProgram fails with error " << hiprtcGetErrorString(result);
-}</code></pre>
-<h2>10.5 HIPRTC General APIs</h2>
-<p>HIPRTC provides the following API for querying the version.</p>
-<p>hiprtcVersion(int* major, int* minor) - This sets the output parameters major and minor with the HIP Runtime compilation major version and minor version number respectively.</p>
-<p>Currently, it returns hardcoded value. This should be implemented to return HIP runtime major and minor version in the future releases.</p>
-<p>(continued from previous page)</p>
-<h2>10.6 Lowered Names (Mangled Names)</h2>
-<p>HIPRTC mangles the __global__ function names and names of __device__ and __constant__ variables. If the generated binary is being loaded using the HIP Runtime API, the kernel function or __device__/__constant__ variable must be looked up by name, but this is very hard when the name has been mangled. To overcome this, HIPRTC provides API functions that map __global__ function or __device__/__constant__ variable names in the source to the mangled names present in the generated binary.</p>
-<p>The two APIs hiprtcAddNameExpression and hiprtcGetLoweredName provide this functionality. First, a 'name expression' string denoting the address for the __global__ function or __device__/__constant__ variable is provided to hiprtcAddNameExpression . Then, the program is compiled with hiprtcCompileProgram . During compilation, HIPRTC will parse the name expression string as a C++ constant expression at the end of the user program. Finally, the function hiprtcGetLoweredName is called with the original name expression and it returns a pointer to the lowered name. The lowered name can be used to refer to the kernel or variable in the HIP Runtime API.</p>
-<h2>10.6.1 Note</h2>
-<ul>
-<li style="list-style-type: '· ';">The identical name expression string must be provided on a subsequent call to hiprtcGetLoweredName to extract the lowered name.</li>
-<li style="list-style-type: '· ';">The correct sequence of calls is : hiprtcAddNameExpression , hiprtcCompileProgram , hiprtcGetLoweredName , hiprtcDestroyProgram .</li>
-<li style="list-style-type: '· ';">The lowered names must be fetched using hiprtcGetLoweredName only after the HIPRTC program has been compiled, and before it has been destroyed.</li>
-</ul>
-<h2>10.6.2 Example</h2>
-<p>kernel containing various definitions __global__ functions/function templates and __device__/__constant__ variables can be stored in a string.</p>
-<p><strong>**Following code does:** This code snippet appears to be part of a larger codebase, likely written in a language that supports object-oriented programming, such as C++ or a similar language. The line of code is performing the following high-level operation:
-
-- It declares a variable named `multi_grid` of type `multi_grid_group`.
-- It initializes this variable by calling a function or method named `this_multi_grid()`, which presumably returns an object or value of type `multi_grid_group`.
-
-The purpose of this line is to create an instance of `multi_grid_group` and assign it to the variable `multi_grid`, using the result from `this_multi_grid()`. This suggests that `this_multi_grid()` is a function that provides or constructs a `multi_grid_group` object, possibly representing a grid or a collection of grids in a multi-grid system.</strong></p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-        static constexpr const char gpu_program[] {</code></pre>
-<p>hiprtcAddNameExpression is called with various name expressions referring to the address of __global__ functions and __device__/__constant__ variables.</p>
-<p><strong>**Following code does:** This code snippet appears to be a method call on an object or module named `multi_grid`. The method `sync()` is likely intended to synchronize or coordinate data or processes across multiple grids or components within a system. This could involve ensuring that all parts of a distributed system are updated to the same state or that parallel computations are aligned. The exact functionality would depend on the implementation details of the `multi_grid` object and its `sync()` method.</strong></p>
-<pre><code>kernel_name_vec.push_back("&f1");
-kernel_name_vec.push_back("N1::N2::f2");
-kernel_name_vec.push_back("f3<int>");
-for (auto&& x : kernel_name_vec) hiprtcAddNameExpression(prog, x.c_str());
-variable_name_vec.push_back("&V1");</code></pre>
-<p>(continues on next page)</p>
-<p>(continued from previous page)</p>
-<p><strong>**Following code does:** This code is a C++ program that uses the HIP (Heterogeneous-Compute Interface for Portability) runtime API to check if the current GPU device supports concurrent managed memory access. It retrieves the current GPU device, checks the `hipDeviceAttributeConcurrentManagedAccess` attribute, and then prints a message to the console indicating whether concurrent managed memory access is supported by the device.</strong></p>
-<pre><code>auto&& x : variable_name_vec) hiprtcAddNameExpression(prog, x.c_str());</code></pre>
-<p><strong>**Following code does:** The code snippet provided appears to be mostly empty space with some scattered characters, including slashes and curly braces, which are typically used in programming languages like C, C++, or Java for comments and code blocks. However, the snippet does not contain any functional code or meaningful structure. It seems to be either incomplete or corrupted, and thus does not perform any specific operation or serve a high-level purpose.</strong></p>
-<pre><code>        | variable_name_vec.push_back("&N1::N2::V2");
-        for (auto&& x : variable_name_vec) hiprtcAddNameExp</code></pre>
-<p>After which, the program is compiled using hiprtcCompileProgram and the generated binary is loaded using hipModuleLoadData . And the mangled names can be fetched using hirtcGetLoweredName .</p>
-<p><strong>**Following code does:** This code is a simple GPU program using HIP (Heterogeneous-Compute Interface for Portability) to perform the addition of two integers on a GPU. It defines a kernel function `add` that takes pointers to three integers and computes the sum of the first two, storing the result in the third. The variables `a`, `b`, and `c` are declared as managed memory, allowing them to be accessed by both the host (CPU) and the device (GPU). The `main` function initializes `a` and `b` with values 1 and 2, respectively, and then launches the `add` kernel on the GPU. After ensuring the GPU computation is complete with `hipDeviceSynchronize`, it prints the result of the addition. The code demonstrates basic GPU computation and memory management using HIP.</strong></p>
-<pre><code>for (decltype(variable_name_vec.size()) i = 0; i!= variable_name_vec.size(); ++i) {
-  const char* name;
-  hiprtcGetLoweredName(prog, variable_name_vec[i].c_str(), &name);
-}</code></pre>
-<p><strong>**Following code does:** This code snippet is a partial implementation of a program using HIP (Heterogeneous-Compute Interface for Portability) to perform addition on a GPU. It defines a simple CUDA kernel function `add` that takes pointers to three integers and assigns the sum of the first two integers to the third. In the `main` function, memory is allocated on the host for three integer pointers `a`, `b`, and `c`, and initial values are assigned to `a` and `b`. The code is incomplete as it does not include the necessary steps to allocate memory on the GPU, copy data to the GPU, launch the kernel, or retrieve the result from the GPU.</strong></p>
-<pre><code>    for (decltype(kernel_name_vec.size()) i = 0; i!= kernel_name_vec.size(); ++i) {
-      const char* name;
-      hiprtcGetLoweredName(prog, kernel_name_vec[i].c_str(), &name);
-    }</code></pre>
-<p>The mangled name of the variables are used to look up the variable in the module and update its value.</p>
-<p><strong>**Following code does:** This code snippet is part of a program that performs a simple addition operation on a GPU using the HIP (Heterogeneous-Compute Interface for Portability) API. It launches a kernel function named `add` on the GPU with a single thread block and a single thread. After the kernel execution, it synchronizes the device to ensure the GPU has finished processing before accessing the results on the host. The result of the addition is then printed to the console. Finally, it frees the allocated memory for the variables `a`, `b`, and `c` before the program terminates.</strong></p>
-<pre><code>        hipDeviceptr_t variable_addr;
-        size_t bytes{};
-        hipModuleGetGlobal(&variable_addr, &bytes, module, name);
-        hipMemcpyHtoD(variable_addr, &initial_value, sizeof(initial_value));</code></pre>
-<p>Finally, the mangled name of the kernel is used to launch it using the hipModule APIs.</p>
-<p><strong>**Following code does:** This code snippet is a simple example of using HIP (Heterogeneous-Compute Interface for Portability) to perform addition on a GPU. It demonstrates explicit memory management in a GPU programming context. The code allocates memory on the GPU for three integers, copies two input values from the host (CPU) to the GPU, and then launches a kernel function `add` on the GPU to compute the sum of these two values. The result is then copied back from the GPU to the host. This example illustrates basic GPU programming concepts such as memory allocation, data transfer between host and device, and kernel execution.</strong></p>
-<pre><code>        hipFunction_t kernel;
-        hipModuleGetFunction(&kernel, module, name);
-        hipModuleLaunchKernel(kernel, 1, 1, 1, 1, 1, 0, nullptr, nullptr, config);</code></pre>
-<p>Please have a look at hiprtcGetLoweredName.cpp for the detailed example.</p>
-<h2>10.7 Versioning</h2>
-<p>HIPRTC follows the below versioning.</p>
-<ul>
-<li style="list-style-type: '· ';">Linux</li>
-<li>-HIPRTC follows the same versioning as HIP runtime library.</li>
-<li>-The so name field for the shared library is set to MAJOR version. For example, for HIP 5.3 the so name is set to 5 ( hiprtc.so.5 ).</li>
-<li style="list-style-type: '• ';">Windows</li>
-<li>-HIPRTC dll is named as hiprtcXXYY.dll where XX is MAJOR version and YY is MINOR version. For example, for HIP 5.3 the name is hiprtc0503.dll .</li>
-</ul>
-<h2>10.8 HIP header support</h2>
-<ul>
-<li style="list-style-type: '· ';">Added HIPRTC support for all the hip common header files such as library_types.h, hip_math_constants.h, hip_complex.h, math_functions.h, surface_types.h etc. from 6.1. HIPRTC users need not include any HIP macros or constants explicitly in their header files. All of these should get included via HIPRTC builtins when the app links to HIPRTC library.</li>
-</ul>
-<h2>10.9 Deprecation notice</h2>
-<ul>
-<li style="list-style-type: '· ';">Currently HIPRTC APIs are separated from HIP APIs and HIPRTC is available as a separate library libhiprtc. so / libhiprtc.dll . But on Linux, HIPRTC symbols are also present in libamdhip64.so in order to support the existing applications. Gradually, these symbols will be removed from HIP library and applications using HIPRTC will be required to explicitly link to HIPRTC library. However, on Windows hiprtc.dll must be used as the amdhip64.dll doesn't contain the HIPRTC symbols.</li>
-<li style="list-style-type: '· ';">Data types such as uint32_t , uint64_t , int32_t , int64_t defined in std namespace in HIPRTC are deprecated earlier and are being removed from ROCm release 6.1 since these can conflict with the standard C++ data types. These data types are now prefixed with __hip__ , e.g. __hip_uint32_t . Applications previously using std::uint32_t or similar types can use __hip_ prefixed types to avoid conflicts with standard std namespace or application can have their own definitions for these types. Also, type_traits templates previously defined in std namespace are moved to __hip_internal namespace as implementation details.</li>
-</ul>
-<h2>CHAPTER</h2>
-<h2>ELEVEN</h2>
-<h2>PERFORMANCE GUIDELINES</h2>
-<p>The AMDHIPPerformance Guidelines are a set of best practices designed to help developers optimize the performance of AMD GPUs. They cover established parallelization and optimization techniques, coding metaphors, and idioms that can greatly simplify programming for HIP-capable GPU architectures.</p>
-<p>By following four main cornerstones, we can exploit the performance optimization potential of HIP.</p>
-<ul>
-<li style="list-style-type: '· ';">parallel execution</li>
-<li style="list-style-type: '· ';">memory usage optimization</li>
-<li style="list-style-type: '· ';">optimization for maximum throughput</li>
-<li style="list-style-type: '· ';">minimizing memory thrashing</li>
-</ul>
-<p>In the following chapters, we will show you their benefits and how to use them effectively.</p>
-<h2>11.1 Parallel execution</h2>
-<p>For optimal use, the application should reveal and efficiently imply as much parallelism as possible to keep all system components active.</p>
-<h2>11.1.1 Application level</h2>
-<p>The application should optimize parallel execution across the host and devices using asynchronous calls and streams. Workloads should be assigned based on efficiency: serial to the host, parallel to the devices.</p>
-<p>For parallel workloads, when threads need to synchronize to share data, if they belong to the same block, they should use __syncthreads() (see: Synchronization functions ) within the same kernel invocation. If they belong to different blocks, they must use global memory with two separate kernel invocations. The latter should be minimized as it adds overhead.</p>
-<h2>11.1.2 Device level</h2>
-<p>Device-level optimization primarily involves maximizing parallel execution across the multiprocessors of the device. This can be achieved by executing multiple kernels concurrently on a device. The management of these kernels is facilitated by streams, which allow for the overlapping of computation and data transfers, enhancing performance. The aim is to keep all multiprocessors busy by executing enough kernels concurrently. However, launching too many kernels can lead to resource contention, so a balance must be found for optimal performance. This approach helps in achieving maximum utilization of the resources of the device.</p>
-<h2>11.1.3 Multiprocessor level</h2>
-<p>Multiprocessor-level optimization involves maximizing parallel execution within each multiprocessor on a device. Each multiprocessor can execute a number of threads concurrently, and the total number of threads that can run in parallel is determined by the number of concurrent threads each multiprocessor can handle.</p>
-<p>The key to multiprocessor-level optimization is to efficiently utilize the various functional units within a multiprocessor. This can be achieved by ensuring a sufficient number of resident warps, as at every instruction issue time, a warp scheduler selects an instruction that is ready to execute. This instruction can be another independent instruction of the same warp, exploiting Optimization for maximum instruction throughput , or more commonly an instruction of another warp, exploiting thread-level parallelism.</p>
-<p>In comparison, device-level optimization focuses on the device as a whole, aiming to keep all multiprocessors busy by executing enough kernels concurrently. Both levels of optimization are crucial for achieving maximum performance. They work together to ensure efficient utilization of the resources of the GPU, from the individual multiprocessors to the device as a whole.</p>
-<h2>11.2 Memory optimization</h2>
-<p>The first step in maximizing memory throughput is to minimize low-bandwidth data transfers. This involves reducing data transfers between the host and the device, as these have lower bandwidth than transfers between global memory and the device.</p>
-<p>Additionally, data transfers between global memory and the device should be minimized by maximizing the use of on-chip memory: shared memory and caches. Shared memory acts as a user-managed cache, where the application explicitly allocates and accesses it. A common programming pattern is to stage data from device memory into shared memory. This involves each thread of a block loading data from device memory to shared memory, synchronizing with all other threads of the block, processing the data in shared memory, synchronizing again if necessary, and writing the results back to device global memory.</p>
-<p>For some applications, a traditional hardware-managed cache is more appropriate to exploit data locality. On devices of certain compute capabilities, the same on-chip memory is used for both L1 and shared memory, and the amount dedicated to each is configurable for each kernel call.</p>
-<p>Finally, the throughput of memory accesses by a kernel can vary significantly depending on the access pattern for each type of memory. Therefore, the next step in maximizing memory throughput is to organize memory accesses as optimally as possible. This is especially important for global memory accesses, as global memory bandwidth is low compared to available on-chip bandwidths and arithmetic instruction throughput. Thus, non-optimal global memory accesses generally have a high impact on performance.</p>
-<h2>11.2.1 Data Transfer</h2>
-<p>Applications should aim to minimize data transfers between the host and the device. This can be achieved by moving more computations from the host to the device, even if it means running kernels that do not fully utilize the parallelism for device. Intermediate data structures can be created, used, and discarded in device memory without being mapped or copied to host memory.</p>
-<p>Batching small transfers into a single large transfer can improve performance due to the overhead associated with each transfer. On systems with a front-side bus, using page-locked host memory can enhance data transfer performance.</p>
-<p>When using mapped page-locked memory, there is no need to allocate device memory or explicitly copy data between device and host memory. Data transfers occur implicitly each time the kernel accesses the mapped memory. For optimal performance, these memory accesses should be coalesced, similar to global memory accesses.</p>
-<p>On integrated systems where device and host memory are physically the same, any copy operation between host and device memory is unnecessary, and mapped page-locked memory should be used instead. Applications can check if a device is integrated by querying the integrated device property.</p>
-<h2>11.2.2 Device Memory Access</h2>
-<p>Memory access instructions may be repeated due to the spread of memory addresses across warp threads. The impact on throughput varies with memory type and is generally reduced when addresses are more scattered, especially in global memory.</p>
-<p>Device memory is accessed via 32-, 64-, or 128-byte transactions that must be naturally aligned. Maximizing memory throughput involves coalescing memory accesses of threads within a warp into minimal transactions, following optimal access patterns, using properly sized and aligned data types, and padding data when necessary.</p>
-<p>Global memory instructions support reading or writing data of specific sizes (1, 2, 4, 8, or 16 bytes) that are naturally aligned. If the size and alignment requirements are not met, it leads to multiple instructions, reducing performance. Therefore, using data types that meet these requirements, ensuring alignment for structures, and maintaining alignment for all values or arrays is crucial for correct results and optimal performance.</p>
-<p>Threads often access 2D arrays at an address calculated as BaseAddress + xIndex + width * yIndex . For efficient memory access, the array and thread block widths should be multiples of the warp size. If the array width is not a multiple of the warp size, it is usually more efficient to allocate it with a width rounded up to the nearest multiple and pad the rows accordingly.</p>
-<p>Local memory is used for certain automatic variables, such as arrays with non-constant indices, large structures or arrays, and any variable when the kernel uses more registers than available. Local memory resides in device memory, leading to high latency and low bandwidth similar to global memory accesses. However, it is organized for consecutive 32-bit words to be accessed by consecutive thread IDs, allowing full coalescing when all threads in a warp access the same relative address.</p>
-<p>Shared memory, located on-chip, provides higher bandwidth and lower latency than local or global memory. It is divided into banks that can be simultaneously accessed, boosting bandwidth. However, bank conflicts, where two addresses fall in the same bank, lead to serialized access and decreased throughput. Therefore, understanding how memory addresses map to banks and scheduling requests to minimize conflicts is crucial for optimal performance.</p>
-<p>Constant memory is in device memory and cached in the constant cache. Requests are split based on different memory addresses, affecting throughput, and are serviced at the throughput of the constant cache for cache hits, or the throughput of the device memory otherwise.</p>
-<p>Texture and surface memory are stored in device memory and cached in texture cache. This setup optimizes 2D spatial locality, leading to better performance for threads reading close 2D addresses. Reading device memory through texture or surface fetching can be advantageous, offering higher bandwidth for local texture fetches or surface reads, offloading addressing calculations, allowing data broadcasting, and optional conversion of 8-bit and 16-bit integer input data to 32-bit floating-point values on-the-fly.</p>
-<h2>11.3 Optimization for maximum instruction throughput</h2>
-<p>To maximize instruction throughput:</p>
-<ul>
-<li style="list-style-type: '· ';">minimize low throughput arithmetic instructions</li>
-<li style="list-style-type: '· ';">minimize divergent warps inflicted by control flow instructions</li>
-<li style="list-style-type: '· ';">minimize the number of instruction as possible</li>
-<li style="list-style-type: '· ';">maximize instruction parallelism</li>
-</ul>
-<h2>11.3.1 Arithmetic instructions</h2>
-<p>The type and complexity of arithmetic operations can significantly impact the performance of your application. We are highlighting some hints how to maximize it.</p>
-<p>Using efficient operations: Some arithmetic operations are more costly than others. For example, multiplication is typically faster than division, and integer operations are usually faster than floating-point operations, especially with double-precision.</p>
-<p>Minimizing low-throughput instructions: This might involve trading precision for speed when it does not affect the final result. For instance, consider using single-precision arithmetic instead of double-precision.</p>
-<p>Leverage intrinsic functions: Intrinsic functions are pre-defined functions available in HIP that can often be executed faster than equivalent arithmetic operations (subject to some input or accuracy restrictions). They can help optimize performance by replacing more complex arithmetic operations.</p>
-<p>Avoiding divergent warps: Divergent warps occur when threads within the same warp follow different execution paths. This can happen due to conditional statements that lead to different arithmetic operations being performed by different threads. Divergent warps can significantly reduce instruction throughput, so try to structure your code to minimize divergence.</p>
-<p>Optimizing memory access: The efficiency of memory access can impact the speed of arithmetic operations. Coalesced memory access, where threads in a warp access consecutive memory locations, can improve memory throughput and thus the speed of arithmetic operations.</p>
-<p>Maximizing instruction parallelism: Some GPU architectures could issue parallel independent instructions simultaneously, for example integer and floating point, or two operations with independent inputs and outputs. Mostly this is a work for compiler, but expressing parallelism in the code explicitly can improve instructions throughput.</p>
-<h2>11.3.2 Control flow instructions</h2>
-<p>Flow control instructions ( if , else , for , do , while , break , continue , switch ) can impact instruction throughput by causing threads within a warp to diverge and follow different execution paths. To optimize performance, control conditions should be written to minimize divergent warps. For example, when the control condition depends on ( threadIdx / warpSize ), no warp diverges. The compiler may optimize loops or short if or switch blocks using branch predication, preventing warp divergence. With branch predication, instructions associated with a false predicate are scheduled but not executed, avoiding unnecessary operations.</p>
-<h2>11.3.3 Synchronization</h2>
-<p>Synchronization ensures that all threads within a block have completed their computations and memory accesses before moving forward, which is critical when threads are dependent on the results of other threads. However, synchronization can also lead to performance overhead, as it requires threads to wait, potentially leading to idle GPU resources.</p>
-<p>__syncthreads() is used to synchronize all threads in a block, ensuring that all threads have reached the same point in the code and that shared memory is visible to all threads after the point of synchronization.</p>
-<p>An alternative way to synchronize is using streams. Different streams can execute commands out of order with respect to one another or concurrently. This allows for more fine-grained control over the execution order of commands, which can be beneficial in certain scenarios.</p>
-<h2>11.4 Minimizing memory thrashing</h2>
-<p>Applications frequently allocating and freeing memory may experience slower allocation calls over time. This is expected as memory is released back to the operating system. To optimize performance in such scenarios, consider some recommendations:</p>
-<ul>
-<li style="list-style-type: '· ';">avoid allocating all available memory with hipMalloc / hipHostMalloc , as this immediately reserves memory and can block other applications from using it. This could strain the operating system schedulers or even prevent other applications from running on the same GPU.</li>
-<li style="list-style-type: '· ';">aim to allocate memory in suitably sized blocks early in the lifecycle of the application and deallocate only when the application no longer needs it. Minimize the number of hipMalloc and hipFree calls in your application, particularly in areas critical to performance.</li>
-<li style="list-style-type: '· ';">if an application is unable to allocate sufficient device memory, consider resorting to other memory types such as hipHostMalloc or hipMallocManaged . While these may not offer the same performance, they can allow the application to continue running.</li>
-<li style="list-style-type: '· ';">For supported platforms, hipMallocManaged allows for oversubscription. With the right memory advise policies, it can maintain most, if not all, of the performance of hipMalloc . hipMallocManaged does not require an allocation to be resident until it is needed or prefetched, easing the load on the operating system schedulers and facilitating multi-tenant scenarios.</li>
-</ul>
-<p>CHAPTER</p>
-<h2>TWELVE</h2>
-<h2>DEBUGGING WITH HIP</h2>
-<p>AMDdebugging tools include ltrace and ROCgdb . External tools are available and can be found online. For example, if you're using Windows, you can use Microsoft Visual Studio and WinGDB .</p>
-<p>You can trace and debug your code using the following tools and techniques.</p>
-<h2>12.1 Tracing</h2>
-<p>You can use tracing to quickly observe the flow of an application before reviewing the detailed information provided by a command-line debugger. Tracing can be used to identify issues ranging from accidental API calls to calls made on a critical path.</p>
-<p>ltrace is a standard Linux tool that provides a message to stderr on every dynamic library call. You can use ltrace to visualize the runtime behavior of the entire ROCm software stack.</p>
-<p>Here's a simple command-line example that uses ltrace to trace HIP APIs and output:</p>
-<p><strong>**Following code does:** This code snippet is part of a larger program that uses HIP, a C++ runtime API for GPU programming. The snippet performs two main tasks: 
-
-1. It frees up memory that was previously allocated on the GPU for three variables (`d_a`, `d_b`, and `d_c`) using the `hipFree` function. This is a cleanup operation to release resources and prevent memory leaks.
-
-2. It prints the result of an addition operation to the console, displaying the values of `a`, `b`, and their sum `c` in the format "a + b = c".
-
-Finally, the function returns 0, indicating successful execution.</strong></p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?php?^"./hipGetChanDesc
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        </?php?^"
-	                                                                                                                                                                                                     
-		                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       <!
-                                                                                                                                                                                                      
-
-	                                                                                                                                                                                                       <%
-                                                                                                                                                                                                       </%
-                                                                                                                                                                                                      <?>
-                                                                                                                                                                                                       ></code></pre>
-<p>Here's another example that uses ltrace to trace hsa APIs and output:</p>
-<p><strong>**Following code does:** This code snippet appears to be a collection of comments and symbols that do not form a valid or functional piece of code. It seems to be a mix of comment syntax from different programming languages (e.g., `//`, `/* ... */`) and other characters, but it does not perform any operations or have any executable logic. It might be a placeholder or an artifact from code formatting or editing.</strong></p>
-<pre><code>        Here's another example that uses ltrace to trace hsa APIs and output:
-        $ ltrace  -C -e "hsa*"./hipGetChanDesc
-        libamdhip64.so.4->hsa_init(0, 0x7fff325a69d0, 0x9c80e0, 0 <unfinished...>
-        libhsa-runtime64.so.1->hsaKmtOpenKFD(0x7fff325a6590, 0x9c38c0, 0, 1) = 0
-        libhsa-runtime64.so.1->hsaKmtGetVersion(0x7fff325a6608, 0, 0, 0) = 0
-        libhsa-runtime64.so.1->hsaKmtReleaseSystemProperties(3, 0x80084b01, 0, 0) = 0
-        libhsa-runtime64.so.1->hsaKmtAcquireSystemProperties(0x7fff325a6610, 0, 0, 1) = 0
-        libhsa-runtime64.so.1->hsaKmtGetNodeProperties(0, 0x7fff325a66a0, 0, 0) = 0
-        libhsa-runtime64.so.1->hsaKmtGetNodeMemoryProperties(0, 1, 0x9c42b0, 0x936012) = 0
-       ...
-        <... hsaKmtCreateEvent  resumed> )                                                                                                                                                                                                        
-        libhsa-runtime64.so.1->hsaKmtAllocMemory(0, 4096, 64, 0x7fff325a6690) = 0
-        libhsa-runtime64.so.1->hsaKmtMapMemoryToGPUNodes(0x7f1202749000, 4096, 0x7fff325a6690,,...
-        --0) = 0
-        libhsa-runtime64.so.1->hsaKmtCreateEvent(0x7fff325a6700, 0, 0, 0x7fff325a66f0) = 0
-                                                                                                                                                                                                        (continues on next page)</code></pre>
-<p>(continues on next page)</p>
-<p>(continued from previous page)</p>
-<p><strong>**Following code does:** This code snippet demonstrates a simple GPU-accelerated program using HIP (Heterogeneous-Compute Interface for Portability) to perform the addition of two integers. It allocates managed memory for three integers (`a`, `b`, and `c`) that can be accessed by both the CPU and GPU. The program sets memory advice to optimize data placement and access patterns, indicating that the memory should be preferred for CPU access and read mostly from the GPU. It initializes the values of `a` and `b`, launches a GPU kernel to compute their sum, synchronizes the device to ensure computation is complete, and then prints the result. Finally, it frees the allocated memory. The use of `hipMemAdvise` helps optimize performance by guiding the runtime on how to handle memory access efficiently.</strong></p>
-<pre><code>HIP Documentation, Release 6.1.40092</code></pre>
-<h2>12.2 Debugging</h2>
-<p>You can use ROCgdb for debugging and profiling.</p>
-<p>ROCgdbis the ROCm source-level debugger for Linux and is based on GNU Project debugger (GDB). the GNU sourcelevel debugger, equivalent of CUDA-GDB, can be used with debugger frontends, such as Eclipse, Visual Studio Code, or GDB dashboard. For details, see (https://github.com/ROCm/ROCgdb).</p>
-<p>Below is a sample how to use ROCgdb run and debug HIP application, ROCgdb is installed with ROCM package in the folder /opt/rocm/bin.</p>
-<p><strong>**Following code does:** This code snippet is part of a larger program that uses the HIP (Heterogeneous-Compute Interface for Portability) API, which is designed for GPU programming. The specific lines shown here are responsible for freeing or deallocating memory that was previously allocated on the GPU for the variables `b` and `c`. This is done using the `hipFree` function, which releases the memory resources associated with these variables. The `return 0;` statement indicates that the program is terminating successfully. Overall, this snippet is part of the cleanup process in a GPU-accelerated application.</strong></p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <p>
-                                                                                                                                                                                                       <h1>
-                                                                                                                                                                                                      <p/>
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        </p>
-                                                                                                                                                                                                     <p>
-
-                                                                                                                                                                                                       <a>
-                                                                                                                                                                                                     
- 	                                                                                                                                                                                                       <b>
-                                                                                                                                                                                                      </a>
-                                                                                                                                                                                                     <a>
-
-                                                                                                                                                                                                      <b/>
-                                                                                                                                                                                                      <a/>
-                                                                                                                                                                                                     
-		                                                                                                                                                                                                      
-
-	                                                                                                                                                                                                      <a></b></code></pre>
-<h2>12.2.1 Debugging HIP applications</h2>
-<p>The following Linux example shows how to get useful information from the debugger while running a simple memory copy test, which caused a segmentation fault issue.</p>
-<p><strong>**Following code does:** This code snippet demonstrates a simple example of using HIP (Heterogeneous-Compute Interface for Portability) to perform a basic addition operation on a GPU. It allocates managed memory for three integers (`a`, `b`, and `c`) that can be accessed by both the host (CPU) and the device (GPU). The `add` kernel function is launched on the GPU to compute the sum of `a` and `b`, storing the result in `c`. After synchronizing the device to ensure the computation is complete, the code queries a memory range attribute (`hipMemRangeAttributeReadMostly`) for the memory range pointed to by `a` and stores the result in `attributeValue`. Finally, it prints the result of the addition. The code illustrates basic memory management and kernel execution in a HIP environment.</strong></p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <p>test, which caused a segmentation fault issue.                                                                                                                                                                                                        </p>                                                                                                                                                                                                        >
-                                                                                                                                                                                                       <a>http://tests/src/runtimeApi/memory/hipMemcpy_simple.cpp:147</code></pre>
-<p>(continues on next page)</p>
-<p>(continued from previous page)</p>
-<p><strong>**Following code does:** This code snippet is part of a C++ program that outputs the value of a queried attribute to the console. After displaying the attribute value, it performs cleanup by freeing memory that was previously allocated for three variables (`a`, `b`, and `c`) using the `hipFree` function, which is typically used in programs that utilize HIP (Heterogeneous-Compute Interface for Portability) for managing GPU memory. Finally, the program returns 0, indicating successful execution.</strong></p>
-<pre><code>HIP Documentation, Release 6.1.40092
-
-
-                                                                                                                                                                                                         (continued from previous page)                                                                                                                                                                                                       
-                                                                                                                                                                                                      
-1                                                                                                                                                                                                        "                                                                                                                                                                                                        <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        </----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                    <-----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        >----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                   
-1   //                                                                                                                                                                                                        :                                                                                                                                                                                                        |                                                                                                                                                                                                        -                                                                                                                                                                                                        +                                                                                                                                                                                                        \
-                                                                                                                                                                                                       |
-                                                                                                                                                                                                       <============================================================================================                                                                                                                                                                                                        }                                                                                                                                                                                                        )</code></pre>
-<p>Debugging HIP applications using Windows tools can be more informative than on Linux. Windows tools provides more visibility into debug codes, which makes it easier to inspect variables, watch multiple details, and examine call stacks.</p>
-<h2>12.3 Useful environment variables</h2>
-<p>HIP provides environment variables that allow HIP, hip-clang, or HSA drivers to prevent certain features and optimizations. These are not intended for production, but can be useful to diagnose synchronization problems in the application (or driver).</p>
-<p>Some of the more widely used environment variables are described in this section. These are supported on the Linux ROCm path and Windows.</p>
-<h2>12.3.1 Kernel enqueue serialization</h2>
-<p>You can control kernel command serialization from the host:</p>
-<h2>AMD_SERIALIZE_KERNEL , for serializing kernel enqueue</h2>
-<p>AMD_SERIALIZE_KERNEL = 1 , Wait for completion before enqueue AMD_SERIALIZE_KERNEL = 2 , Wait for completion after enqueue AMD_SERIALIZE_KERNEL = 3 , Both</p>
-<p>Or</p>
-<h2>AMD_SERIALIZE_COPY , for serializing copies</h2>
-<p>AMD_SERIALIZE_COPY = 1 , Wait for completion before enqueue AMD_SERIALIZE_COPY = 2 , Wait for completion after enqueue AMD_SERIALIZE_COPY = 3 , Both</p>
-<p>So HIP runtime can wait for GPU idle before/after any GPU command depending on the environment setting.</p>
-<h2>12.3.2 Making device visible</h2>
-<p>For systems with multiple devices, you can choose to make only certain device(s) visible to HIP using HIP_VISIBLE_DEVICES (or CUDA_VISIBLE_DEVICES on an NVIDIA platform). Once enabled, HIP can only view devices that have indices present in the sequence. For example:</p>
-<p><strong>**Following code does:** The code snippet `<_C_>` appears to be a placeholder or a non-functional piece of code. It does not represent any valid Python syntax or operation. It might be intended as a marker or a template for where actual code should be inserted.</strong></p>
-<pre><code>    | $ HIP_VISIBLE_DEVICES=0,1</code></pre>
-<p><strong>**Following code does:** The code snippet `0) ;` is not valid Python code. It appears to be a fragment or typo, as it does not form a complete or meaningful statement in Python.</strong></p>
-<pre><code><_Python_></code></pre>
-<p><strong>**Following code does:** It seems there is a formatting error in your request. The code snippet is labeled as Python, but the content is marked as C++. Please provide the correct code snippet or clarify the language so I can assist you accurately.</strong></p>
-<pre><code>if (totalDeviceNum > 2) {
-setenv("HIP_VISIBLE_DEVICES", "0,1,2", 1);
-assert(getDeviceNumber(false) == 3);
-
-.......
-}</code></pre>
-<h2>12.3.3 Dump code object</h2>
-<p>To analyze compiler-related issues, you can use the dump code object: GPU_DUMP_CODE_OBJECT .</p>
-<h2>12.3.4 HSA-related environment variables (Linux)</h2>
-<p>HSA provides environment variables that help analyze issues in drivers or hardware.</p>
-<ul>
-<li style="list-style-type: '· ';">To isolate issues with hardware copy engines, you can use HSA_ENABLE_SDMA .</li>
-<li>HSA_ENABLE_SDMA=0 causes host-to-device and device-to-host copies to use compute shader blit kernels, rather than the dedicated DMA copy engines. Compute shader copies have low latency (typically &lt; 5 us) and can achieve approximately 80% of the bandwidth of the DMA copy engine.</li>
-<li style="list-style-type: '· ';">To diagnose interrupt storm issues in the driver, you can use HSA_ENABLE_INTERRUPT .</li>
-</ul>
-<p>HSA_ENABLE_INTERRUPT=0 causes completion signals to be detected with memory-based polling, rather than interrupts.</p>
-<h2>12.3.5 HIP environment variable summary</h2>
-<p>Here are some of the more commonly used environment variables:</p>
-<p><strong>**Following table contains:** The table represents a list of mathematical functions, specifically focusing on their support across different platforms or environments. Each row corresponds to a specific mathematical function, detailing its purpose and support status.
-
-- The "Function" column describes the function's name and its mathematical operation, including a brief explanation of what the function does (e.g., calculating the absolute value, arc cosine, etc.).
-- The "Supported on Host" column indicates whether the function is supported on the host environment, with a "✓" symbol denoting support.
-- The "Supported on Device" column shows whether the function is supported on the device environment, also using a "✓" symbol to denote support.
-
-Noteworthy is that all functions listed in the preview are supported on both the host and device environments, as indicated by the "✓" symbols in both the "Supported on Host" and "Supported on Device" columns.</strong></p>
-<table><tbody><tr><th>Environment variable</th><th>De- fault value</th><th>Usage</th></tr><tr><td>AMD_LOG_LEVEL Enable HIP log on different Level</td><td>0</td><td>0: Disable log. 1: Enable log on error level 2: Enable log on warning and below levels 0x3: Enable log on information and below levels 0x4: Decode and display AQL packets</td></tr><tr><td>AMD_LOG_MASK Enable HIP log on different Level</td><td></td><td>0x7FFFFFFF 0x1: Log API calls 0x02: Kernel and Copy Commands and Barriers 0x4: Synchroniza- tion and waiting for commands to finish 0x8: Enable log on information and below levels 0x20: Queue commands and queue contents 0x40: Signal creation, allocation, pool 0x80: Locks and thread-safety code 0x100: Copy debug 0x200: Detailed copy debug 0x400: Resource allocation, performance-impacting events 0x800: Initialization and shutdown 0x1000: Misc debug, not yet classified 0x2000: Show raw bytes of AQL packet 0x4000: Show code creation debug 0x8000: More detailed command info, including barrier com- mands 0x10000: Log message location 0xFFFFFFFF: Log always even mask flag is zero</td></tr><tr><td>HIP_LAUNCH_BLOCKING Used for serial- ization on kernel execution.</td><td>0</td><td>0: Disable. Kernel executes normally. 1: Enable. Serializes kernel enqueue, behaves the same as AMD_SERIALIZE_KERNEL.</td></tr><tr><td>HIP_VISIBLE_DEVICES (or CUDA_VISIBLE_DEVICES) Only devices whose index is present in the sequence are visible to HIP</td><td></td><td>0,1,2: Depending on the number of devices on the system</td></tr><tr><td>GPU_DUMP_CODE_OBJECT Dump code ob- ject</td><td>0</td><td>0: Disable 1: Enable</td></tr><tr><td>AMD_SERIALIZE_KERNEL Serialize kernel enqueue</td><td>0</td><td>1: Wait for completion before enqueue 2: Wait for completion after enqueue 3: Both</td></tr><tr><td>AMD_SERIALIZE_COPY Serialize copies</td><td>0</td><td>1: Wait for completion before enqueue 2: Wait for completion after enqueue 3: Both</td></tr><tr><td>HIP_HOST_COHERENT Coherent mem-</td><td>0</td><td>0: memory is not coherent between host and GPU 1: memory is coherent with host</td></tr><tr><td>ory in hipHost- Malloc AMD_DIRECT_DISPATCH Enable direct kernel dispatch (Currently for Linux; under development for Windows)</td><td>1</td><td>0: Disable 1: Enable</td></tr><tr><td>GPU_MAX_HW_QUEUES The maximum number of hard- ware queues allocated per device</td><td>4</td><td>The variable controls how many independent hardware queues HIP runtime can create per process, per device. If an application allocates more HIP streams than this number, then HIP runtime reuses the same hardware queues for the new streams in a round-robin manner. Note that this maximum number does not apply to hardware queues that are created for CU-masked HIP streams, or cooperative queues for HIP Cooperative Groups (single queue per device).</td></tr></tbody></table>
-<h2>12.4 General debugging tips</h2>
-<ul>
-<li style="list-style-type: '· ';">gdb --args can be used to pass the executable and arguments to gdb .</li>
-<li style="list-style-type: '· ';">You can set environment variables ( set env ) from within GDB on Linux:</li>
-</ul>
-<p><strong>**Following code does:** This code snippet is configuring memory access permissions for a specific memory region in a HIP (Heterogeneous-Compute Interface for Portability) application, which is used for GPU programming. It sets up a `hipMemAccessDesc` structure to specify that a memory region, identified by `ptr` and of size `padded_size`, should be accessible for both reading and writing on a specific GPU device (`currentDev`). The `hipMemSetAccess` function is then called to apply these access permissions.</strong></p>
-<pre><code>        | (gdb)  set env  AND_SERIALIZE_KERNEL  3</code></pre>
-<p>Note: This gdb command does not use an equal (=) sign.</p>
-<ul>
-<li style="list-style-type: '· ';">The GDB backtrace shows a path in the runtime. This is because a fault is caught by the runtime, but it is generated by an asynchronous command running on the GPU.</li>
-<li style="list-style-type: '· ';">To determine the true location of a fault, you can force the kernels to run synchronously by setting the environment variables AMD_SERIALIZE_KERNEL=3 and AMD_SERIALIZE_COPY=3 . This forces HIP runtime to wait for the kernel to finish running before returning. If the fault occurs when a kernel is running, you can see the code that launched the kernel inside the backtrace. The thread that's causing the issue is typically the one inside libhsa-runtime64.so .</li>
-<li style="list-style-type: '· ';">VMfaults inside kernels can be caused by:</li>
-<li>-Incorrect code (e.g., a for loop that extends past array boundaries)</li>
-<li>-Memory issues, such as invalid kernel arguments (null pointers, unregistered host pointers, bad pointers)</li>
-<li>-Synchronization issues</li>
-<li>-Compiler issues (incorrect code generation from the compiler)</li>
-<li>-Runtime issues</li>
-</ul>
-<h2>CHAPTER</h2>
-<h2>THIRTEEN</h2>
-<h2>LOGGING HIP ACTIVITY</h2>
-<p>HIP provides a logging mechanism that allows you to trace HIP API and runtime codes when running a HIP application. In addition to being useful to our users/developers, the HIP development team uses these logs to improve the HIP runtime.</p>
-<p>By adjusting the logging settings and logging mask, you can get different types of information for different functionalities, such as HIP APIs, executed kernels, queue commands, and queue contents. Refer to the following sections for examples.</p>
-<p>Tip: Logging works for the release and debug versions of HIP. If you want to save logging output in a file, define the file when running the application via command line. For example:</p>
-<p><strong>**Following code does:** This code snippet is related to memory management in a GPU context using the HIP (Heterogeneous-Compute Interface for Portability) API, which is used for writing portable applications that can run on AMD and NVIDIA GPUs. 
-
-The two functions perform the following high-level tasks:
-
-1. `hipMemUnmap(ptr, size);`: This function unmaps a previously mapped memory region from the host's address space. The `ptr` is the pointer to the memory region, and `size` specifies the size of the memory to be unmapped.
-
-2. `hipMemRelease(allocHandle);`: This function releases or deallocates the memory associated with a given allocation handle (`allocHandle`). It effectively frees the memory resources that were previously allocated.
-
-Overall, the code is responsible for cleaning up GPU memory resources by unmapping and releasing them, which is crucial for preventing memory leaks and ensuring efficient memory usage in GPU applications.</strong></p>
-<pre><code>            |user@user-test:~/hip/bin$./hipinfo > ~/hipinfo > ~/hip_log.txt</code></pre>
-<h2>13.1 Logging level</h2>
-<p>HIP logging is disabled by default. You can enable it via the AMD_LOG_LEVEL environment variable. The value of this variable controls your logging level. Levels are defined as follows:</p>
-<p><strong>**Following code does:** This code snippet appears to be a call to a function named `hipMemAddressFree`, which is likely part of the HIP (Heterogeneous-Compute Interface for Portability) API used for GPU programming. The function is intended to free or release a block of memory that was previously allocated, identified by the pointer `ptr`, and of a specified `size`. This operation is typically used to manage memory resources efficiently in GPU applications. The vertical bar `|` at the beginning seems to be a typographical error or an artifact, as it is not standard syntax in Python or C/C++.</strong></p>
-<pre><code>                                                                                                                                                                                                       
-  enum LogLevel {
-      LOG_NONE       = 0,
-      LOG_ERROR     = 1,
-      LOG_WARNING = 2,
-      LOG_INFO       = 3,
-      LOG_DEBUG     = 4
-  };</code></pre>
-<p>Tip: You can call a logging function with different logging levels. All information under the value set for AMD_LOG_LEVEL is printed.</p>
-<h2>13.2 Logging mask</h2>
-<p>The logging mask is designed to print functionality types when you're running a HIP application. Once you set AMD_LOG_LEVEL , the logging mask is set as the default value ( 0x7FFFFFFF ). You can change this to any of the valid values:</p>
-<p><strong>**Following code does:** This code snippet is part of a memory management process using HIP (Heterogeneous-Compute Interface for Portability), which is a framework for GPU programming. The code performs the following high-level tasks:
-
-1. **Memory Reservation**: It reserves a block of memory starting at a specified address (`ptr + padded_size`) with a size of `new_size - padded_size`. This is done using `hipMemAddressReserve`, which allocates a virtual address space without actually allocating physical memory.
-
-2. **Memory Mapping**: It maps the reserved virtual memory to a physical memory allocation using `hipMemMap`. This associates the reserved address space (`new_ptr`) with a physical memory allocation identified by `newAllocHandle`.
-
-3. **Setting Memory Access**: It sets the access permissions for the mapped memory using `hipMemSetAccess`. This specifies how the memory can be accessed (e.g., read, write) based on the provided `accessDesc`.
-
-Overall, this code is setting up a reserved and mapped memory region with specific access permissions in a GPU context.</strong></p>
-<pre><code>        The logging mask is designed to print functionality types when you're running a HIP application.  Once you set
-        AMD_LOG_LEVEL, the logging mask is set as the default value (0x7FFFFFFF). You can change this to any of the valid
-        values:
-
-        enum LogMask {
-          LOG_API         = 0x000000001,  //!< API call
-          LOG_CMD         = 0x000000002,  //!< Kernel and Copy Commands and Barriers
-          LOG_WAIT        = 0x000000004,  //!< Synchronization and waiting for commands to finish
-          LOG_AQL         = 0x000000008,  //!< Decode and display AQL packets
-          LOG_QUEUE      = 0x00000010,  //!< Queue commands and queue contents
-          LOG_SIG         = 0x00000020,  //!< Signal creation, allocation, pool
-          LOG_LOCK        = 0x00000040,  //!< Locks and thread-safety code.
-          LOG_KERN        = 0x00000080,  //!< kernel creations and arguments, etc.
-          LOG_COPY        = 0x000000100,  //!< Copy debug
-          LOG_COPY2       = 0x000000200,  //!< Detailed copy debug
-          LOG_RESOURCE   = 0x000000400,  //!< Resource allocation, performance-impacting events.
-          LOG_INIT        = 0x00000080,  //!< Initialization and shutdown
-          LOG_MISC        = 0x00001000,  //!< misc debug, not yet classified
-          LOG_AQL2        = 0x00002000,  //!< Show raw bytes of AQL packet
-          LOG_CODE        = 0x00004000,  //!< Show code creation debug
-          LOG_CMD2        = 0x00008000,  //!< More detailed command info, including barrier commands
-          LOG_LOCATION   = 0x00010000,  //!< Log message location
-          LOG_MEM         = 0x0000200000,  //!< Memory allocation
-          LOG_MEM_POOL   = 0x00040000,  //!< Memory pool allocation, including memory in graphs
-          LOG_ALWAYS     = 0xFFFFFFFF,  //!< Log always even mask flag is zero
-        };
-
-        You can also define the logging mask via the AMD_LOG_MASK environment variable.</code></pre>
-<p>You can also define the logging mask via the AMD_LOG_MASK environment variable.</p>
-<h2>13.3 Logging command</h2>
-<p>You can use the following code to print HIP logging information:</p>
-<p><strong>**Following code does:** This code snippet is a simple C++ program that uses the HIP API, which is a C++ runtime API for GPU programming. The program initializes two `dim3` objects, which are typically used to define the dimensions of a grid or block in GPU programming. The first `dim3` object, `grid1`, is default-initialized, meaning its dimensions are set to zero. The second `dim3` object, `grid2`, is explicitly initialized with dimensions (1, 1, 1). The program then prints the dimensions of both `dim3` objects to the console. The purpose of this code is to demonstrate the initialization and usage of `dim3` objects in HIP.</strong></p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?                                                                                                                                                                                                        </?                                                                                                                                                                                                       <!                                                                                                                                                                                                        >
-                                                                                                                                                                                                       <&                                                                                                                                                                                                        &
-                                                                                                                                                                                                      
-																																																																																																																																																																																																								                                                                                                                                                                                                       																																																																																																																																																																																																							<?                                                                                                                                                                                                      	                                                                                                                                                                                                      	
-																																																																																																																																																																																																						 																																																																																																																																																																																																						  <?</code></pre>
-<p>Using HIP code, call the ClPrint() function with the desired input variables. For example:</p>
-<p><strong>**Following code does:** This code snippet compiles and runs a C++ program that likely involves GPU programming using the HIP (Heterogeneous-Compute Interface for Portability) API, which is used for writing portable code that can run on both AMD and NVIDIA GPUs. 
-
-1. The first line is a shell command that compiles a C++ source file named `test3.hip.cpp` using the `gcc` compiler. The `-x c++` flag specifies that the input file is a C++ source file. The `$(hipconfig --cpp_config)` part dynamically inserts the necessary compiler flags for HIP, which are obtained by running the `hipconfig --cpp_config` command. The output of the compilation is an executable named `test`.
-
-2. The second line executes the compiled program `./test`. The output suggests that the program is demonstrating the initialization and use of `dim3` objects, which are typically used in GPU programming to specify the dimensions of grid and block structures for kernel launches. The output shows two `dim3` objects, `grid1` and `grid2`, both initialized with dimensions `x=1, y=1, z=1`. This indicates that the program is likely testing or demonstrating basic grid configuration for GPU kernels.</strong></p>
-<pre><code>            |ClPrint(amd::LOG_INFO, amd::LOG_INIT, "Initializing HSA stack.");</code></pre>
-<h2>13.4 Logging examples</h2>
-<p>On Linux , you can enable HIP logging and retrieve logging information when you run hipinfo .</p>
-<p><strong>**Following code does:** This code snippet appears to be a comment in Python that is referencing a C++ style of initialization. The comment suggests that there is a variable `grid` of type `dim3` being initialized with the values `{1,1,1}`. In C++, `dim3` is typically used in CUDA programming to specify the dimensions of a grid or block for parallel execution on a GPU. The comment is likely indicating that the `grid` variable is being set to a 1x1x1 configuration, which means it is a single block with a single thread in each dimension (x, y, z). However, since this is a comment in Python, it does not execute any code but rather provides information or context about how a similar operation might be performed in C++.</strong></p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <HR>
-                                                                                                                                                                                                       <HIP Documentation, Release 6.1.40092                                                                                                                                                                                                        </HIP Documentation, Release 6.1.40092                                                                                                                                                                                             <HR>
-        Loggging examples                                                                                                                                                                                                        >
-                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       >
-
-                                                                                                                                                                                                       <BR>
-                                                                                                                                                                                                      <BR><BR>
-                                                                                                                                                                                                     <BR>
-
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                       	                                                                                                                                                                                                       <B>
-                                                                                                                                                                                                     
-  <B>
-                                                                                                                                                                                                   <BR>
-  <B>
-                                                                                                                                                                                                  <BR></code></pre>
-<p>(continues on next page)</p>
-<p>(continued from previous page)</p>
-<p><strong>**Following code does:** The code snippet you provided appears to be a mistake or a mix-up. It seems to be an attempt to specify a programming language (C++) rather than actual code. If you intended to provide a C++ code snippet, please include the relevant code so I can help explain its purpose.</strong></p>
-<pre><code>HIP Documentation, Release 6.1.40092</code></pre>
-<p>On Windows , you can set AMD_LOG_LEVEL via environment variable from the advanced system settings or the command prompt (when run as administrator). The following example shows debug log information when calling the backend runtime.</p>
-<p><strong>**Following code does:** The code snippet `| export` appears to be incomplete or out of context for a typical Python script. In Python, the `|` character is not used in this way, and `export` is not a standard Python keyword. This snippet might be part of a shell command or a configuration file where `export` is used to set environment variables, but as it stands, it does not represent a valid or complete Python statement.</strong></p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <kendo runume.                                                                                                                                                                                                        </kendo>runume.</code></pre>
-<p>(continues on next page)</p>
-<p>(continued from previous page)</p>
-<p><strong>**Following code does:** The code snippet appears to be a shell command that sets an environment variable named `HIP_PLATFORM` to the value `amd`. This is typically used in a shell or terminal to configure the environment for software that relies on the HIP (Heterogeneous-Compute Interface for Portability) platform, indicating that the target platform for HIP operations should be AMD hardware.</strong></p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <![
-                                                                                                                                                                                                       <?xml:%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/.%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/)
-                                                                                                                                                                                                      
-
-                                                                                                                                                                                                      
-
-
-                                                                                                                                                                                                       </?xml:%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazon AWS.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazon AWS.com/.%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazon AWS.com%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/"
-                                                                                                                                                                                                       :
-                                                                                                                                                                                                       >
-                                                                                                                                                                                                      ?xml:%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws,com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws,com%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.</code></pre>
-<p>(continues on next page)</p>
-<p>(continued from previous page)</p>
-<p><strong>**Following code does:** It seems like you've provided a placeholder instead of actual code. If you provide the actual Python code snippet, I'd be happy to help explain its purpose.</strong></p>
-<pre><code>  --copyBuffer
-...
-:4:C:\constructicon\builds\gfx\two\22.40\drivers\compute\vdi\device\pal\palmemory.
-  --cpp:206 : 605414523422 us: 29864: [tid:0x9298] Alloc: 100000 bytes,_,
-  --ptr[0000003008D0000-0000003009D0000], obj[0000003007D0000-0000003047D0000]
-:4:C:\constructicon\builds\gfx\two\22.40\drivers\compute\vdi\device\pal\palmemory.
-  --cpp:206 : 605414523767 us: 29864: [tid:0x9298] Alloc: 100000 bytes,_,
-  --ptr[0000003009D0000-000000300AD0000], obj[0000003007D0000-0000003047D0000]
-:3:C:\constructicon\builds\gfx\two\22.40\drivers\compute\hipamd\src\hip_memory.cpp:681 :_,
-  --605414524092 us: 29864: [tid:0x9298] hipMemGetInfo: Returned hipSuccess :
-memInfo.total:                     12.06 GB
-memInfo.free:                     11.93 GB (99%)</code></pre>
-<h2>CHAPTER</h2>
-<h2>FOURTEEN</h2>
-<h2>COOPERATIVE GROUPS</h2>
-<p>Cooperative groups API is an extension to the HIP programming model, which provides developers with a flexible, dynamic grouping mechanism for the communicating threads. Cooperative groups let you define your own set of thread groups which may fit your user-cases better than those defined by the hardware. This lets you specify the level of granularity for thread communication which can lead to more efficient parallel decompositions.</p>
-<p>The API is accessible in the cooperative_groups namespace after the hip_cooperative_groups.h is included. The header contains the following elements:</p>
-<ul>
-<li style="list-style-type: '· ';">Static functions to create groups and subgroups.</li>
-<li style="list-style-type: '· ';">Hardware-accelerated operations over the whole group, like shuffles.</li>
-<li style="list-style-type: '· ';">Data types of cooperative groups.</li>
-<li style="list-style-type: '· ';">Synchronize member function of the groups.</li>
-<li style="list-style-type: '· ';">Get group properties member functions.</li>
-</ul>
-<h2>14.1 Cooperative groups thread model</h2>
-<p>The thread hierarchy abstraction of cooperative groups are in grid hierarchy and block hierarchy .</p>
-<p>Fig. 1: Cooperative group thread hierarchy in grids.</p>
-<p>The multi grid is an abstraction of potentially multiple simultaneous launches of the same kernel over multiple devices (Deprecated since 5.0). The grid in cooperative groups is a single dispatch of kernels for execution like the original grid.</p>
-<p>Note: The ability to synchronize over a grid or multi grid requires the kernel to be launched using the specific cooperative groups API.</p>
-<p>The block is the same as the Inherent thread model block entity.</p>
-<p>Note: Explicit warp-level thread handling is absent from the Cooperative groups API. In order to exploit the known hardware SIMD width on which built-in functionality translates to simpler logic, you can use the group partitioning part of the API, such as tiled_partition .</p>
-<p>Fig. 2: Cooperative group thread hierarchy in blocks.</p>
-<p>The cooperative groups API introduce a new level between block thread and threads. The thread-block tile give the opportunity to have tiles in the thread block, while the coalesced group holds the active threads of the parent group. These groups further discussed in the groups types section.</p>
-<p>For details on memory model, check the memory model description .</p>
-<h2>14.2 Group types</h2>
-<p>Group types are based on the levels of synchronization and data sharing among threads.</p>
-<h2>14.2.1 Thread-block group</h2>
-<p>Represents an intra-block cooperative groups type where the participating threads within the group are the same threads that participated in the currently executing block .</p>
-<p><strong>**Following code does:** This code snippet is a configuration or environment variable assignment in a shell or script. It sets the `HIP_COMPILER` variable to the value `cuda`. This is likely used in the context of configuring the HIP (Heterogeneous-Compute Interface for Portability) framework, which is designed to allow code to run on both AMD and NVIDIA GPUs. By setting `HIP_COMPILER` to `cuda`, it indicates that the HIP code should be compiled using the CUDA compiler, targeting NVIDIA GPUs.</strong></p>
-<pre><code>    class thread_block;
-
-    Constructed via:
-
-    thread_block g = this_thread_block();</code></pre>
-<p>The group_index() , thread_index() , thread_rank() , size() , cg_type() , is_valid() , sync() and group_dim() member functions are public of the thread_block class. For further details, check the thread_block references .</p>
-<h2>14.2.2 Grid group</h2>
-<p>Represents an inter-block cooperative groups type where the group's participating threads span multiple blocks running the same kernel on the same device. Use the cooperative launch API to enable synchronization across the grid group.</p>
-<p><strong>**Following code does:** This code snippet sets an environment variable named `HIP_RUNTIME` to the value `nvcc`. This is typically used in the context of configuring or building software that involves GPU programming, particularly when working with HIP (Heterogeneous-Compute Interface for Portability) and CUDA. By setting `HIP_RUNTIME` to `nvcc`, it indicates that the HIP code should be compiled using NVIDIA's CUDA compiler (`nvcc`), which is part of the CUDA toolkit. This setup is often used to ensure compatibility or optimize performance on NVIDIA GPUs.</strong></p>
-<pre><code>class grid_group;
-
- Constructed via:
-
-grid_group g = this_grid();</code></pre>
-<p>The thread_rank() , size() , cg_type() , is_valid() and sync() member functions are public of the grid_group class. For further details, check the grid_group references .</p>
-<h2>14.2.3 Multi-grid group</h2>
-<p>Represents an inter-device cooperative groups type where the participating threads within the group span multiple devices that run the same kernel on the devices. Use the cooperative launch API to enable synchronization across the multi-grid group.</p>
-<p><strong>**Following code does:** The code snippet `<_C_>` appears to be incomplete or not a valid Python code. It does not represent any recognizable Python syntax or functionality. It might be a placeholder or a typographical error. Without additional context or information, it's not possible to determine its purpose or functionality.</strong></p>
-<pre><code>    |class multi_grid_group;</code></pre>
-<p><strong>**Following code does:** The code snippet `<_SQL_>` appears to be a placeholder or a tag indicating that the actual SQL code is not provided. It suggests that the content is intended to be SQL-related, possibly involving database queries or operations. Without the actual SQL code, it's not possible to determine the specific functionality or purpose. If you have the actual SQL code, I can help explain what it does.</strong></p>
-<pre><code>;</code></pre>
-<p>Constructed via:</p>
-<p><strong>**Following code does:** The code snippet you provided appears to be a comment or placeholder text rather than actual executable code. It seems to be referencing an example of using `hipLaunchKernelGGL`, which is a macro used in the HIP (Heterogeneous-Compute Interface for Portability) API. HIP is a C++ runtime API that allows developers to write portable code that can run on both AMD and NVIDIA GPUs.
-
-The purpose of `hipLaunchKernelGGL` is to launch a kernel function on a GPU. It abstracts the details of setting up the execution configuration (such as grid and block dimensions) and launching the kernel. However, without the actual code or context, this snippet doesn't perform any operations or provide further details.</strong></p>
-<pre><code><_C_></code></pre>
-<p><strong>**Following code does:** The provided code snippet appears to be incomplete and contains a syntax error. It seems to be a fragment of a function signature or declaration, possibly from a C or C++ program, rather than Python. The term `size_t` is a data type commonly used in C/C++ to represent sizes and is typically used for array indexing and loop counting. The `N` likely represents a parameter name. However, without additional context or code, it's not possible to determine the exact purpose or functionality of this snippet.</strong></p>
-<pre><code><_YAML_></code></pre>
-<p>The num_grids() , grid_rank() , thread_rank() , size() , cg_type() , is_valid() , and sync() member functions are public of the multi_grid_group class. For further details check the multi_grid_group references .</p>
-<h2>14.2.4 Thread-block tile</h2>
-<p>This constructs a templated class derived from thread_group . The template defines the tile size of the new thread group at compile time. This group type also supports sub-wave level intrinsics.</p>
-<p><strong>**Following code does:** This code snippet is related to launching a GPU kernel using HIP, which is a C++ runtime API and kernel language that allows developers to write portable code that can run on AMD and NVIDIA GPUs. The code launches a kernel function named `MyKernel` on the GPU. The kernel is executed with a specified grid and block (group) dimensions, which are defined by `gridDim` and `groupDim`, respectively. The parameters `a`, `b`, `c`, and `n` are passed to the kernel function, which likely represent data or configuration settings needed for the computation. The snippet also includes an alternative way to launch the kernel using the `hipLaunchKernelGGL` macro, which provides more flexibility, such as specifying a stream for asynchronous execution.</strong></p>
-<pre><code><_C++_></code></pre>
-<p>Constructed via:</p>
-<p><strong>**Following code does:** This code snippet is a GPU kernel implementation using HIP, a C++ runtime API and kernel language that allows developers to write portable code for AMD and NVIDIA GPUs. The code defines a simple kernel function `MyKernel` that operates on arrays of floating-point numbers. The kernel adds each element of array `a` to the corresponding element of array `b` after incrementing it by one, storing the result in array `c`. The `PlusOne` function is defined to increment a float by 1.0 and is marked to be compiled for both the host and device. The `callMyKernel` function sets up the necessary parameters and launches the kernel on the GPU, processing `N` elements with a specified block size.</strong></p>
-<pre><code><_SQL_></code></pre>
-<h2>Note:</h2>
-<ul>
-<li style="list-style-type: '· ';">Size must be a power of 2 and not larger than warp (wavefront) size.</li>
-<li style="list-style-type: '· ';">shfl() functions support integer or float type.</li>
-</ul>
-<p>The thread_rank() , size() , cg_type() , is_valid() , sync() , meta_group_rank() , meta_group_size() , shfl() , shfl_down() , shfl_up() , shfl_xor() , ballot() , any() , all() , match_any() and match_all() member functions are public of the thread_block_tile class. For further details, check the thread_block_tile references .</p>
-<h2>14.2.5 Coalesced groups</h2>
-<p>Threads (64 threads on CDNA and 32 threads on RDNA) in a warp cannot execute different instructions simultaneously, so conditional branches are executed serially within the warp. When threads encounter a conditional branch, they can diverge, resulting in some threads being disabled, if they do not meet the condition to execute that branch. The active threads referred as coalesced, and coalesced group represents an active thread group within a warp.</p>
-<p>Note: The NVIDIA GPU's independent thread scheduling presents the appearance that threads on different branches execute concurrently.</p>
-<p>Warning: AMD GPUs do not support independent thread scheduling. Some CUDA application can rely on this feature and the ported HIP version on AMD GPUs can deadlock, when they try to make use of independent thread scheduling.</p>
-<p>This group type also supports sub-wave level intrinsics.</p>
-<p><strong>**Following code does:** The code snippet `<_C_>` appears to be incomplete or not a valid Python code. It does not represent any recognizable Python syntax or functionality. It might be a placeholder or a typographical error. Without additional context or information, it's not possible to determine its purpose or functionality.</strong></p>
-<pre><code>    | class coalesced_group;</code></pre>
-<p>Constructed via:</p>
-<p>coalesced_group</p>
-<p><strong>**Following code does:** The code snippet `<_SQL_>` appears to be a placeholder or a tag indicating where SQL-related code or content should be inserted. It does not perform any operations or have any functionality on its own. Its purpose is likely to serve as a marker within a larger codebase or documentation to denote the section where SQL code is relevant or expected to be included.</strong></p>
-<pre><code>    |roup active  = coalesced_threads() ;</code></pre>
-<p>Note: shfl() functions support integer or float type.</p>
-<p>The thread_rank() , size() , cg_type() , is_valid() , sync() , meta_group_rank() , meta_group_size() , shfl() , shfl_down() , shfl_up() , ballot() , any() , all() , match_any() and match_all() member functions are public of the coalesced_group class. For more information, see coalesced_group references .</p>
-<h2>14.3 Cooperative groups simple example</h2>
-<p>The difference to the original block model in the reduce_sum device function is the following.</p>
-<h2>Original Block</h2>
-<p><strong>**Following code does:** The provided code snippet appears to be incomplete and contains syntax errors, making it difficult to determine its exact purpose. However, it seems to be attempting to use or declare variables related to time measurement, possibly involving a clock function and a variable named `close`. Without additional context or corrections, it's not possible to provide a meaningful high-level summary of its functionality.</strong></p>
-<pre><code><_Cuda_></code></pre>
-<h2>Cooperative groups</h2>
-<p><strong>**Following code does:** The code snippet appears to be a malformed or incomplete line of Python code. It seems to be attempting to declare a variable `w` with a type annotation of `long long int`, which is not a valid type in Python. In Python, type annotations typically use Python's built-in types or types from the `typing` module, and `long long int` is a C/C++ type, not a Python type. Therefore, this line does not serve any functional purpose in Python as it stands.</strong></p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        // Thread ID
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        /                                                                                                                                                                                                        *                                                                                                                                                                                                        /*                                                                                                                                                                                                        */
-                                                                                                                                                                                                       */</code></pre>
-<p>(continues on next page)</p>
-<p>(continued from previous page)</p>
-<p><strong>**Following code does:** The code snippet `it will_clock64()` appears to be a function call in Python. However, without additional context or definition of the function `it will_clock64`, it's not possible to determine its purpose or functionality. The name suggests it might be related to a clock or timing mechanism, possibly involving 64-bit operations, but this is purely speculative. To understand what this code does, one would need to see the implementation or documentation of the `it will_clock64` function.</strong></p>
-<pre><code>      for(unsigned int i = g.size() / 2; i > 0; i /= 2) {
-          // Store value in shared memory with thread ID
-          shared[group_thread_id] = val;
-
-          // Synchronize all threads in the group
-          g.sync();
-
-          // Active thread sum up
-          if(group_thread_id < i)
-               val += shared[group_thread_id + i];
-
-          // Synchronize all threads in the group
-          g.sync();
-      }
-
-      //...
-}
-
-The reduce_sum() function call and input data initialization difference to the origin.</code></pre>
-<p>The reduce_sum() function call and input data initialization difference to the original block model is the following.</p>
-<h2>Original Block</h2>
-<p><strong>**Following code does:** This code snippet is written in C++ and uses the HIP (Heterogeneous-Compute Interface for Portability) API, which is designed for writing portable applications that can run on both AMD and NVIDIA GPUs. The code retrieves the wall clock rate of a GPU device in kilohertz. Specifically, it initializes an integer variable `wallClkRate` to store the clock rate, and then calls the `hipDeviceGetAttribute` function to obtain the wall clock rate attribute (`hipDeviceAttributeWallClockRate`) for a specific GPU device identified by `deviceId`. The `HIPCHECK` macro is likely used to check for errors in the HIP API call.</strong></p>
-<pre><code>Original Block
-
-__global__ void sum_kernel(...) {
-
-    //...
-
-    // Workspace array in shared memory
-    __shared__ unsigned int workspace[2048];
-
-    //...
-
-    // Perform reduction
-    output = reduce_sum(workspace, input);
-
-    //...
-}</code></pre>
-<h2>Cooperative groups</h2>
-<p><strong>**Following code does:** This code snippet retrieves the properties of a CUDA-enabled device specified by `deviceID` and stores them in a `cudaDeviceProp` structure named `props`. It then extracts the `warpSize` property, which indicates the number of threads in a warp for that device, and assigns it to the variable `w`. The comment suggests that the subsequent code will implement an algorithm that adapts to the device's warp size, ensuring portability across devices with different warp sizes, rather than assuming a fixed size like 32 or 64.</strong></p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        //                                                                                                                                                                                                        const auto                                                                                                                                                                                                        }                                                                                                                                                                                                        /*                                                                                                                                                                                                        */                                                                                                                                                                                                        *</code></pre>
-<p>(continued from previous page)</p>
-<p><strong>**Following code does:** This code snippet appears to define a set of functions typically used in parallel computing environments, such as CUDA for GPU programming. These functions are likely intended for use in managing and synchronizing threads within a warp (a group of threads that execute instructions in lockstep on a GPU). Here's a high-level summary of each function's purpose:
-
-1. `__all(int predicate)`: This function checks if a given condition (predicate) is true for all threads in a warp. It returns a non-zero value if the condition is true for all threads, otherwise it returns zero.
-
-2. `__any(int predicate)`: This function checks if a given condition (predicate) is true for any thread in a warp. It returns a non-zero value if the condition is true for at least one thread, otherwise it returns zero.
-
-3. `__ballot(int predicate)`: This function returns a bitmask representing which threads in a warp have a true predicate. Each bit in the returned value corresponds to a thread in the warp, with the bit set if the predicate is true for that thread.
-
-4. `__activemask()`: This function returns a bitmask indicating which threads in the warp are currently active. Active threads are those that are currently participating in the execution of the warp.
-
-5. `__all_sync(unsigned long long mask, int predicate)`: This function is similar to `__all`, but it allows specifying a mask to indicate which threads should be considered in the check. It synchronizes the threads specified by the mask and checks if the predicate is true for all of them.
-
-These functions are useful for coordinating and synchronizing operations across threads within a warp, ensuring that certain conditions are met before proceeding with further computations.</strong></p>
-<pre><code>    thread_block thread_block_group = this_thread_block();
-    // Perform reduction
-    output = reduce_sum(thread_block_group, workspace, input);
-
-    //...
-}</code></pre>
-<p>At the device function, the input group type is the thread_group , which is the parent class of all the cooperative groups type. With this, you can write generic functions, which can work with any type of cooperative groups.</p>
-<h2>14.4 Synchronization</h2>
-<p>With each group type, the synchronization requires using the correct cooperative groups launch API.</p>
-<h2>Check the kernel launch capability</h2>
-<h2>Thread-block</h2>
-<p>Do not need kernel launch validation.</p>
-<h2>Grid</h2>
-<p>Confirm the cooperative launch capability on the single AMD GPU:</p>
-<p><strong>**Following code does:** It seems like there is a placeholder or a formatting error in your request, as the code snippet is not visible. Please provide the actual code snippet so I can help explain its purpose.</strong></p>
-<pre><code>    Confirm the cooperative launch capability on the single AMD GPU:
-
-    int device                       = 0;
-    int supports_coop_launch = 0;
-    // Check support
-    // Use hipDeviceAttributeCooperativeMultiDeviceLaunch when launching across multiple_
-    --devices
-    HIP_CHECK(hipGetDevice(&device));
-    HIP_CHECK(
-        hipDeviceGetAttribute(&supports_coop_launch, hipDeviceAttributeCooperativeLaunch,\
-    --device));
-    if(!supports_coop_launch)
-    {
-        std::cout << "Skipping, device " << device << " does not support cooperative groups"
-                       << std::endl;
-        return 0;
-    }</code></pre>
-<h2>Multi-grid</h2>
-<p>Confirm the cooperative launch capability over multiple GPUs:</p>
-<p><strong>**Following code does:** This code snippet appears to define function prototypes for a set of operations that involve matching values in a parallel computing context, likely using CUDA or a similar parallel processing framework. The functions are designed to perform matching operations across multiple threads or processing units:
-
-1. `__match_any(T value)`: This function likely checks if any thread in a group has a value that matches the specified `value`.
-
-2. `__match_all(T value, int *pred)`: This function probably checks if all threads in a group have a value that matches the specified `value`, and it might use the `pred` pointer to store or influence the result.
-
-3. `__match_any_sync(unsigned long long mask, T value)`: Similar to `__match_any`, but includes a `mask` parameter to specify which threads participate in the operation, ensuring synchronization among them.
-
-4. `__match_all_sync(unsigned long long mask, T value, int *pred)`: Similar to `__match_all`, but includes a `mask` parameter for synchronized participation and possibly uses `pred` for additional logic or result storage.
-
-Overall, these functions are likely used for efficient data comparison and synchronization across multiple threads in a parallel processing environment.</strong></p>
-<pre><code>    Multi-grid
-
-    Confirm the cooperative launch capability over multiple GPUs:
-
-    // Check support of cooperative groups
-    std::vector<int> deviceIDs;
-    for(int deviceID = 0; deviceID < device_count; deviceID++) {
-    #ifdef __HIP_PLATFORM_AMD__
-        int supports_coop_launch = 0;
-        HIP_CHECK(
-            hipDeviceGetAttribute(
-                &supports_coop_launch,
-                hipDeviceAttributeCooperativeMultiDeviceLaunch,
-                deviceID));
-        if(!supports_coop_launch) {
-            std::cout << "Skipping, device " << deviceID << " does not support cooperative_
-    --groups"
-                        << std::endl;
-        }
-        else
-    #endif
-        {
-            std::cout << deviceID << std::endl;
-            // Collect valid deviceIDs.
-            deviceIDs.push_back(deviceID);
-        }
-    }
-
-    Kernel launch
-
-    __   ...  .</code></pre>
-<h2>Kernel launch</h2>
-<h2>Thread-block</h2>
-<p>You can access the new block representation using the original kernel launch methods.</p>
-<p><strong>**Following code does:** The code snippet is a description of a CUDA intrinsic function `__shfl`. This function is used in parallel programming with NVIDIA GPUs to perform a shuffle operation within a warp. Specifically, it allows threads within a warp to exchange data. The function takes three parameters: `var`, which is the variable to be shuffled; `srcLane`, which specifies the source lane (or thread) from which to copy the value; and `width`, which defines the width of the shuffle operation, defaulting to the warp size. The note mentions that half-float data types are not supported for this shuffle operation.</strong></p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        // Launching kernel  from host.</code></pre>
-<h2>Grid</h2>
-<p>Launch the cooperative kernel on a single GPU:</p>
-<p><strong>**Following code does:** The code snippet appears to be incomplete and contains a syntax error. It seems to be a mix of Python and C/C++ syntax, as it starts with a pipe character (`|`) and uses a C/C++ style function declaration (`void assert(int ir`). However, based on the visible part, it seems intended to define a function named `assert` that takes an integer parameter `ir` and returns no value (`void`). Without more context or the rest of the code, it's not possible to determine the specific purpose or functionality of this function.</strong></p>
-<pre><code><_C_></code></pre>
-<h2>Multi-grid</h2>
-<p>Launch the cooperative kernel over multiple GPUs:</p>
-<p><strong>**Following code does:** This code snippet waits for the user to input data from the standard input (typically the keyboard) and press Enter. It effectively pauses the program's execution until the user provides some input. The input function can also be used to capture the user's input as a string, but in this case, since the result is not assigned to any variable, the input is simply discarded.</strong></p>
-<pre><code>    Multi-grid
-
-    Launch the cooperative kernel over multiple GPUs:
-
-    hipLaunchParams *launchParamsList = (hipLaunchParams*)malloc(sizeof(hipLaunchParams) *_
-    --deviceIDs.size());
-    for(int deviceID : deviceIDs) {
-
-        // Set device
-        HIP_CHECK(hipSetDevice(deviceID));
-
-        // Create stream
-        hipStream_t stream;
-        HIP_CHECK(hipStreamCreate(&stream));
-
-        // Parameters
-        void* params[] = {&(d_vector[deviceID]), &(d_block_reduced[deviceID]), &(d_partition_
-    --reduced[deviceID])};
-
-        // Set launchParams
-        launchParamsList[deviceID].func = (void*)vector_reduce_kernel<partition_size>;
-        launchParamsList[deviceID].gridDim = dim3(1);
-        launchParamsList[deviceID].blockDim = dim3(threads_per_block);
-        launchParamsList[deviceID].sharedMem = 0;
-        launchParamsList[deviceID].stream = stream;
-        launchParamsList[deviceID].args = params;
-    }
-
-    HIP_CHECK(hipLaunchCooperativeKernelMultiDevice(launchParamsList,
-                                                                                                                                                                                                         (int)deviceIDs.size(),
-                                                                                                                                                                                                       )
-    --hipCooperativeLaunchMultiDeviceNoPreSync));
-
-    Device side synchronization</code></pre>
-<p>Device side synchronization</p>
-<h2>Thread-block</h2>
-<p>The device side code of the thread_block synchronization over single GPUs:</p>
-<p><strong>**Following code does:** This code is a simple CUDA program using the HIP (Heterogeneous-Compute Interface for Portability) API, which is designed to run on AMD GPUs. The program defines a kernel function `run_printf` that prints "Hello World" to the console. The `main` function launches this kernel with a single thread block and a single thread, effectively executing the `printf` statement on the GPU. The purpose of this code is to demonstrate how to execute a basic "Hello World" program using GPU parallel computing with HIP.</strong></p>
-<pre><code><_C_></code></pre>
-<h2>Grid</h2>
-<p>The device side code of the grid synchronization over single GPUs:</p>
-<p><strong>**Following code does:** The code snippet `<_Cython_>` appears to be a placeholder or a tag rather than actual executable code. In a typical context, "Cython" refers to a programming language that makes writing C extensions for Python as easy as Python itself. It is used to improve the performance of Python code by compiling it into C. However, without additional context or actual code, this snippet does not perform any specific function or operation.</strong></p>
-<pre><code><_Cython_></code></pre>
-<p><strong>**Following code does:** The code snippet appears to define a constant named `MIN_WARPS_PER_EXECUTION_UNIT`. This constant is calculated by dividing the product of `MIN_BLOCKS_PER_MULTIPROCESSOR` and `MAX_THREADS_PER_BLOCK` by an unknown operator represented by `/_\`. However, the snippet includes a series of unusual characters and formatting that suggest it might be incomplete or corrupted. In a typical context, such a calculation might be used to determine the minimum number of warps (groups of threads) that can be executed per unit in a parallel computing environment, such as on a GPU. However, without a clear definition of `/_\`, the exact calculation is unclear.</strong></p>
-<pre><code>  =  this._grid() ;</code></pre>
-<h2>Multi-grid</h2>
-<p>The device side code of the multi-grid synchronization over multiple GPUs:</p>
-<p><strong>**Following code does:** The code snippet appears to be a warning message indicating that a particular API is deprecated. Specifically, it suggests that the user should replace the deprecated API with `hipHostMalloc()`. This message is likely part of a larger codebase or documentation related to memory allocation in a computing environment that uses the HIP (Heterogeneous-Compute Interface for Portability) API, which is commonly used for GPU programming. The purpose of the message is to inform developers to update their code to use the recommended function for host memory allocation.</strong></p>
-<pre><code>            |multi_grid_group multi_grid = this_multi_grid();</code></pre>
-<p><strong>**Following code does:** The provided text appears to be a fragment of a warning message rather than a complete code snippet. It indicates that a particular API is deprecated and suggests using `hipHostFree()` as an alternative. This typically means that the current API or function being used is outdated and may be removed in future versions, so developers are advised to switch to the recommended `hipHostFree()` function for managing host memory in HIP (Heterogeneous-Compute Interface for Portability) applications.</strong></p>
-<pre><code>|multi_grid.sync();</code></pre>
-<h2>14.5 Unsupported NVIDIA CUDA features</h2>
-<p>HIP doesn't support the following NVIDIA CUDA optional headers:</p>
-<ul>
-<li style="list-style-type: '· ';">cooperative_groups/memcpy_async.h</li>
-<li style="list-style-type: '· ';">cooperative_groups/reduce.h</li>
-<li style="list-style-type: '· ';">cooperative_groups/scan.h</li>
-</ul>
-<p>HIP doesn't support the following CUDA class in cooperative_groups namespace:</p>
-<ul>
-<li style="list-style-type: '· ';">cluster_group</li>
-</ul>
-<p>HIP doesn't support the following CUDA functions/operators in cooperative_groups namespace:</p>
-<ul>
-<li style="list-style-type: '· ';">synchronize</li>
-<li style="list-style-type: '· ';">memcpy_async</li>
-<li style="list-style-type: '· ';">wait and wait_prior</li>
-<li style="list-style-type: '· ';">barrier_arrive and barrier_wait</li>
-<li style="list-style-type: '· ';">invoke_one and invoke_one_broadcast</li>
-<li style="list-style-type: '· ';">reduce</li>
-<li style="list-style-type: '· ';">reduce_update_async and reduce_store_async</li>
-<li style="list-style-type: '· ';">Reduce operators plus , less , greater , bit_and , bit_xor and bit_or</li>
-<li style="list-style-type: '· ';">inclusive_scan and exclusive_scan</li>
-</ul>
-<h2>CHAPTER</h2>
-<h2>FIFTEEN</h2>
-<h2>UNIFIED MEMORY</h2>
-<p>In conventional architectures, CPUs and GPUs have dedicated memory like Random Access Memory (RAM) and Video Random Access Memory (VRAM). This architectural design, while effective, can be limiting in terms of memory capacity and bandwidth, as continuous memory copying is required to allow the processors to access the appropriate data. New architectural features like Heterogeneous System Architectures (HSA) and Unified Memory (UM) help avoid these limitations and promise increased efficiency and innovation.</p>
-<h2>15.1 Unified memory</h2>
-<p>Unified Memory is a single memory address space accessible from any processor within a system. This setup simplifies memory management processes and enables applications to allocate data that can be read or written by code running on either CPUs or GPUs. The Unified memory model is shown in the following figure.</p>
-<p>AMD Accelerated Processing Unit (APU) is a typical example of a Unified Memory Architecture. On a single die, a central processing unit (CPU) is combined with an integrated graphics processing unit (iGPU), and both have access to a high-bandwidth memory (HBM) module named Unified Memory. The CPU enables high-performance, low-latency operations, while the GPU is optimized for high throughput (data processed by unit time).</p>
-<h2>15.2 System requirements</h2>
-<p>Unified memory is supported on Linux by all modern AMD GPUs from the Vega series onward. Unified memory management can be achieved with managed memory allocation and, for the latest GPUs, with a system allocator.</p>
-<p>The table below lists the supported allocators. The allocators are described in the next section.</p>
-<p><strong>**Following table contains:** The table represents a list of mathematical functions, specifically those that operate on floating-point numbers in programming or computational contexts. Each row corresponds to a different mathematical function, detailing its purpose and operation.
-
-The columns appear to indicate the availability or implementation status of these functions, marked by checkmarks (✓). Although the exact meaning of each column is not explicitly stated, it is likely that they represent different programming environments, libraries, or standards where these functions are available or supported.
-
-Noteworthy values include:
-- The functions cover a range of mathematical operations, including trigonometric functions (e.g., `cosf`, `cospif`), hyperbolic functions (e.g., `coshf`, `atanhf`), and other mathematical operations like `ceilf` and `cbrtf`.
-- The consistent presence of checkmarks (✓) across all rows suggests that all listed functions are supported or available in the contexts represented by the columns.</strong></p>
-<table><caption><div class="caption">Table 1: Supported Unified Memory Allocators</div></caption><tbody><tr><th>Architecture</th><th>hipMallocManaged()</th><th>__managed__</th><th>malloc()</th></tr><tr><td>MI200, MI300 Series</td><td></td><td></td><td>1</td></tr><tr><td>MI100</td><td></td><td></td><td></td></tr><tr><td>RDNA (Navi) Series</td><td></td><td></td><td></td></tr><tr><td>GCN5 (Vega) Series</td><td></td><td></td><td></td></tr></tbody></table>
-<h2>: Supported</h2>
-<ul>
-<li>: Unsupported</li>
-</ul>
-<p>1 Works only with XNACK=1 . First GPU access causes recoverable page-fault. For more details, visit GPU memory.</p>
-<h2>15.3 Unified memory programming models</h2>
-<p>Showcasing various unified memory programming models, the model availability depends on your architecture. For more information, see System requirements and Checking unified memory management support .</p>
-<ul>
-<li style="list-style-type: '· ';">HIP managed memory allocation API :</li>
-</ul>
-<p>The hipMallocManaged() is a dynamic memory allocator available on all GPUs with unified memory support. For more details, visit HIP managed memory allocation API .</p>
-<ul>
-<li style="list-style-type: '· ';">HIP managed variables :</li>
-</ul>
-<p>The __managed__ declaration specifier, which serves as its counterpart, is supported on all modern AMD cards and can be utilized for static allocation.</p>
-<ul>
-<li style="list-style-type: '· ';">System allocation API :</li>
-</ul>
-<p>Starting with the AMD MI300 series, the malloc() system allocator allows you to reserve unified memory. The system allocator is more versatile and offers an easy transition from a CPU written C++ code to a HIP code as the same system allocation API is used.</p>
-<h2>15.3.1 Checking unified memory management support</h2>
-<p>Some device attributes can offer information about which Unified memory programming models are supported. The attribute value is 1 if the functionality is supported, and 0 if it is not supported.</p>
-<p><strong>**Following table contains:** The table appears to represent a list of mathematical functions, specifically focusing on special functions and exponential functions. Each row corresponds to a different function, providing a brief description of what the function does.
-
-- **Rows**: Each row represents a specific mathematical function, detailing its name, input type, and a brief description of its purpose or calculation.
-  
-- **Columns**:
-  - **Column 0**: Contains the function signature, including the return type and the function name with its parameter(s).
-  - **Column 1**: Provides a description of what the function does, often explaining the mathematical operation or the specific function it computes.
-  - **Column 2**: Contains checkmarks (✓) indicating some form of validation or availability status for the functions listed. The presence of checkmarks suggests that these functions are available or supported in the context being described.
-
-- **Noteworthy Values**: 
-  - The function `float cyl_bessel_i1f(float x)` does not have checkmarks in column 2, unlike the other functions, which might indicate that it is not supported or validated in the same way as the others.
-  - All other functions listed have checkmarks in column 2, suggesting they are validated or supported.</strong></p>
-<table><caption><div class="caption">Table 2: Device attributes for unified memory management</div></caption><tbody><tr><th>attribute description</th></tr><tr><td>hipDeviceAttributeManagedMemory unified addressing is supported</td></tr><tr><td>hipDeviceAttributeConcurrentManagedAccess full managed memory support, concurrent access is supported</td></tr><tr><td>hipDeviceAttributePageableMemoryAccess both managed and system memory allocation API is supported</td></tr></tbody></table>
-<p>The following examples show how to use device attributes:</p>
-<p><strong>**Following code does:** The code snippet is a command intended to be run in a Unix-like terminal that uses the Advanced Package Tool (APT) package management system. The command `apt-get install hi` attempts to install a software package named "hi" from the system's package repositories. If the package "hi" exists in the repositories and the user has the necessary permissions, it will be downloaded and installed on the system.</strong></p>
-<pre><code>
-
-#include <hip/hip_runtime.h>
-#include <iostream>
-
-int main()  {
-        int d;
-        hipGetDevice(&d);
-
-        int  is_cma = 0;
-        hipDeviceGetAttribute(&is_cma, hipDeviceAttributeConcurrentManagedAccess, d);
-        std::cout << "HIP Managed Memory: "
-                       << (is_cma == 1? "is" : "NOT")
-                        << " " supported" << std::endl;
-        return 0;
-}</code></pre>
-<h2>15.3.2 Example for unified memory management</h2>
-<p>The following example shows how to use unified memory management with hipMallocManaged() , function, with __managed__ attribute for static allocation and standard malloc() allocation. For comparison, the Explicit Memory Management example is presented in the last tab.</p>
-<h2>hipMallocManaged()</h2>
-<p><strong>**Following code does:** The code snippet you provided appears to be a fragment of a command or a list of package names, but it is not a complete or valid Python code. It seems to be related to package management, possibly for installing or managing software packages related to HIP (Heterogeneous-Compute Interface for Portability) and NVIDIA GPU support. However, without additional context or a complete command, it's difficult to determine its exact purpose.</strong></p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        //                                                                                                                                                                                                        }                                                                                                                                                                                                        */
-                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       //
-                                                                                                                                                                                                      
-
-
-                                                                                                                                                                                                       }
-                                                                                                                                                                                                       */</code></pre>
-<p>__managed__</p>
-<p><strong>**Following code does:** This code is a command-line instruction used in a Unix-based operating system, such as Linux, to install Python 3 using the package manager `apt-get`. The command fetches the Python 3 package from the software repositories and installs it on the system, making Python 3 available for use.</strong></p>
-<pre><code>__managed__
-
-#include <hip/hip_runtime.h>
-#include <iostream>
-
-// Addition of two values.
-__global__ void add(int *a, int *b, int *c) {
-    *c = *a + *b;
-}
-
-// Declare a, b and c as static variables.
-__managed__ int a, b, c;
-
-int main() {
-    // Setup input values.
-    a = 1;
-    b = 2;
-
-    // Launch add() kernel on GPU.
-    hipLaunchKernelGGL(add, dim3(1), dim3(1), 0, 0, &a, &b, &c);
-
-    // Wait for GPU to finish before accessing on host.
-    hipDeviceSynchronize();
-
-    // Prints the result.
-    std::cout << a << " + " << b << " = " << c << std::endl;
-
-    return 0;
-}
-
-
-malloc()</code></pre>
-<h2>malloc()</h2>
-<p><strong>**Following code does:** This code installs the Python package `CppHeaderParser` using the `pip3` package manager. `CppHeaderParser` is a library that allows users to parse C++ header files, extracting information such as classes, functions, and other declarations. The `pip3` command specifically uses Python 3's package manager to perform the installation.</strong></p>
-<pre><code>malloc()
-
-#include <hip/hip_runtime.h>
-#include <iostream>
-
-// Addition of two values.
-__global__ void add(int* a, int* b, int* c) {
-    *c = *a + *b;
-}
-
-int main() {
-    int* a, * b, * c;
-
-    // Allocate memory for a, b, and c.
-    a = (int*)malloc(sizeof(*a));
-    b = (int*)malloc(sizeof(*b));
-    c = (int*)malloc(sizeof(*c));
-
-    // Setup input values.
-    *a = 1;
-    *b = 2;</code></pre>
-<p>(continues on next page)</p>
-<p>(continued from previous page)</p>
-<p><strong>**Following code does:** The code snippet `| export` appears to be incomplete or out of context. In Python, this syntax is not valid. It might be part of a larger script or command in a different context, such as a shell command or a configuration file, where `export` is used to set environment variables. Without additional context, it's unclear what the intended purpose is.</strong></p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-        // Launch add() kernel on GPU.
-        hipLaunchKernelGGL(add, dim3(1), dim3(1), 0, 0, a, b, c);
-
-        // Wait for GPU to finish before accessing on host.
-        hipDeviceSynchronize();
-
-        // Prints the result.
-        std::cout << *a << " + " << *b << " = " << *c << std::endl;
-
-        // Cleanup allocated memory.
-        free(a);
-        free(b);
-        free(c);
-
-        return 0;
-    }</code></pre>
-<p><strong>**Following code does:** The code snippet you provided appears to be a placeholder or a tag indicating that the actual code is written in Bash, a Unix shell and command language. However, without the actual Bash code, it's not possible to determine its functionality or purpose. If you have a specific Bash script or command, please provide it for a more detailed explanation.</strong></p>
-<pre><code>        tree<J;
-
-        return 0;
-    }
-
-
-    Explicit Memory Management
-
-    #include <hip/hip_runtime.h>
-    #include <iostream>
-
-    // Addition of two values.
-    __global__ void add(int *a, int *b, int *c) {
-        *c = *a + *b;
-    }
-
-    int main() {
-        int a, b, c;
-        int *d_a, *d_b, *d_c;
-
-        // Setup input values.
-        a = 1;
-        b = 2;
-
-        // Allocate device copies of a, b and c.
-        hipMalloc(&d_a, sizeof(*d_a));
-        hipMalloc(&d_b, sizeof(*d_b));
-        hipMalloc(&d_c, sizeof(*d_c));
-
-        // Copy input values to device.
-        hipMemcpy(d_a, &a, sizeof(*d_a), hipMemcpyHostToDevice);
-        hipMemcpy(d_b, &b, sizeof(*d_b), hipMemcpyHostToDevice);
-
-        // Launch add() kernel on GPU.
-        hipLaunchKernelGGL(add, dim3(1), dim3(1), 0, 0, d_a, d_b, d_c);
-
-        // Copy the result back to the host.
-        hipMemcpy(&c, d_c, sizeof(*d_c), hipMemcpyDeviceToHost);
-                                                                                                                                                                                                         (continues on next page)
-
-
-    15.3. Unified memory programming models                                                                                                                                                                                                        103</code></pre>
-<p><strong>**Following code does:** The code snippet `<_Bash_>` appears to be a placeholder or a tag indicating that a section of code written in the Bash scripting language should be inserted or is expected there. It does not perform any specific function or operation by itself. Instead, it likely serves as a marker within a larger document or system to denote where Bash code is relevant or should be included.</strong></p>
-<pre><code>
-    // Cleanup allocated memory.
-    hipFree(d_a);
-    hipFree(d_b);
-    hipFree(d_c);
-
-    // Prints the result.
-    std::cout << a << " + " << b << " = " << c << std::endl;
-
-    return 0;
-}</code></pre>
-<h2>15.4 Using unified memory management (UMM)</h2>
-<p>Unified memory management (UMM) is a feature that can simplify the complexities of memory management in GPU computing. It is particularly useful in heterogeneous computing environments with heavy memory usage with both a CPU and a GPU, which would require large memory transfers. Here are some areas where UMM can be beneficial:</p>
-<ul>
-<li style="list-style-type: '· ';">Simplification of Memory Management :</li>
-</ul>
-<p>UMMcan help to simplify the complexities of memory management. This can make it easier for developers to write code without worrying about memory allocation and deallocation details.</p>
-<ul>
-<li style="list-style-type: '· ';">Data Migration :</li>
-</ul>
-<p>UMMallows for efficient data migration between the host (CPU) and the device (GPU). This can be particularly useful for applications that need to move data back and forth between the device and host.</p>
-<ul>
-<li style="list-style-type: '· ';">Improved Programming Productivity :</li>
-</ul>
-<p>As a positive side effect, UMM can reduce the lines of code, thereby improving programming productivity.</p>
-<p>In HIP, pinned memory allocations are coherent by default. Pinned memory is host memory mapped into the address space of all GPUs, meaning that the pointer can be used on both host and device. Using pinned memory instead of pageable memory on the host can improve bandwidth.</p>
-<p>While UMMcanprovide numerous benefits, it's important to be aware of the potential performance overhead associated with UMM. You must thoroughly test and profile your code to ensure it's the most suitable choice for your use case.</p>
-<h2>15.5 Unified memory HIP runtime hints for the better performance</h2>
-<p>Unified memory HIP runtime hints can help improve the performance of your code if you know your code's ability and infrastructure. Some hint techniques are presented in this section.</p>
-<p>Thehint functions can set actions on a selected device, which can be identified by hipGetDeviceProperties(&amp;prop, device_id) . There are two special device_id values:</p>
-<ul>
-<li style="list-style-type: '· ';">hipCpuDeviceId = -1 means that the advised device is the CPU.</li>
-<li style="list-style-type: '· ';">hipInvalidDeviceId = -2 means that the device is invalid.</li>
-</ul>
-<p>For the best performance, profile your application to optimize the utilization of HIP runtime hints.</p>
-<p>(continued from previous page)</p>
-<h2>15.5.1 Data prefetching</h2>
-<p>Data prefetching is a technique used to improve the performance of your application by moving data closer to the processing unit before it's actually needed.</p>
-<p><strong>**Following code does:** The code snippet appears to be a malformed attempt to clone specific branches of two Git repositories from GitHub using the `git clone` command. The intention is to clone the repositories `clr` and `hip` from the `ROCm` organization, checking out the branch specified by the environment variable `ROCM_BRANCH`. However, the command is incorrectly written with `:lone` instead of `git clone`, which would result in an error if executed as is.</strong></p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        // All                                                                                                                                                                                                        }
-                                                                                                                                                                                                      
-//                                                                                                                                                                                                        #                                                                                                                                                                                                        */
-                                                                                                                                                                                                       //                                                                                                                                                                                                        *
-                                                                                                                                                                                                       */
-
-                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       *
-
-                                                                                                                                                                                                       *                                                                                                                                                                                                        /*
-                                                                                                                                                                                                       /*
-
-                                                                                                                                                                                                       */                                                                                                                                                                                                        /
-                                                                                                                                                                                                       }</code></pre>
-<p>Remember to check the return status of hipMemPrefetchAsync() to ensure that the prefetch operations are completed successfully.</p>
-<h2>15.5.2 Memory advice</h2>
-<p>The effectiveness of hipMemAdvise() comes from its ability to inform the runtime system of the developer's intentions regarding memory usage. When the runtime system has knowledge of the expected memory access patterns, it can make better decisions about data placement and caching, leading to more efficient execution of the application. However, the actual impact on performance can vary based on the specific use case and the hardware architecture.</p>
-<p>For the description of hipMemAdvise() and the detailed list of advice, visit the HIP managed memory allocation API .</p>
-<p>Here is the updated version of the example above with memory advice.</p>
-<p><strong>**Following code does:** The code snippet `<_Bash_>` appears to be a placeholder or a tag indicating that a Bash script or command is expected to be inserted or referenced there. It does not contain any actual executable code or commands. Therefore, it does not perform any operations or have a specific functionality on its own.</strong></p>
-<pre><code>
-    The effectiveness of nipMemAdvise() comes from its ability to inform the runtime system at the developer's intentions
-    regarding memory usage. When the runtime system has knowledge of the expected memory access patterns, it can make
-    better decisions about data placement and caching, leading to more efficient execution of the application. However, the
-    actual impact on performance can vary based on the specific use case and the hardware architecture.
-    For the description of hipMemAdvise() and the detailed list of advice, visit the HIP managed memory allocation API.
-    Here is the updated version of the example above with memory advice.
-    
-  #include <hip/hip_runtime.h>
-  #include <iostream>
-    
-  // Addition of two values.
-  __global__ void add(int *a, int *b, int *c) {
-      *c = *a + *b;
-  }
-  
-  int main() {
-      int *a, *b, *c;
-      
-      // Allocate memory for a, b, and c accessible to both device and host codes.
-      hipMallocManaged(&a, sizeof(*a));
-      hipMallocManaged(&b, sizeof(*b));
-      hipMallocManaged(&c, sizeof(*c));
-      
-      // Set memory advice for a, b, and c to be accessed by the CPU.
-      hipMemAdvise(a, sizeof(*a), hipMemAdviseSetPreferredLocation, hipCpuDeviceId);
-      hipMemAdvise(b, sizeof(*b), hipMemAdviseSetPreferredLocation, hipCpuDeviceId);
-      hipMemAdvise(c, sizeof(*c), hipMemAdviseSetPreferredLocation, hipCpuDeviceId);
-      
-      // Additionally, set memory advice for a, b, and c to be read mostly from the device.
-  __0.
-      constexpr int device = 0;
-      hipMemAdvise(a, sizeof(*a), hipMemAdviseSetReadMostly, device);
-      hipMemAdvise(b, sizeof(*b), hipMemAdviseSetReadMostly, device);
-      hipMemAdvise(c, sizeof(*c), hipMemAdviseSetReadMostly, device);
-      
-      // Setup input values.
-      *a = 1;
-      *b = 2;
-      
-      // Launch add() kernel on GPU.
-      hipLaunchKernelGGL(add, dim3(1), dim3(1), 0, 0, a, b, c);
-      
-      // Wait for GPU to finish before accessing on host.
-      hipDeviceSynchronize();
-      
-      // Prints the result.
-      std::cout << *a << " + " << *b << " = " << *c << std::endl;
-      
-      // Cleanup allocated memory.
-      hipFree(a);
-      
-                                                                                                                                                                                                         (continues on next page)
-      
-      
-      
-  106</code></pre>
-<p>(continues on next page)</p>
-<p><strong>**Following code does:** This code snippet is a shell script that automates the process of building and installing a software project using CMake and Make. Here's a high-level summary of what it does:
-
-1. It changes the current directory to the one specified by the `CLR_DIR` environment variable.
-2. It creates a `build` directory if it doesn't already exist and then changes into that directory.
-3. It runs the `cmake` command to configure the build system. This command specifies various options, such as the HIP common directory, the HIP platform, and the CMake prefix path. It also sets certain build flags, like enabling HIP support and disabling OpenCL support.
-4. It compiles the project using `make`, utilizing all available CPU cores (`-j$(nproc)`).
-5. Finally, it installs the compiled software using `sudo make install`, which typically requires administrative privileges.</strong></p>
-<pre><code>      hipFree(b);
-      hipFree(c);
-
-      return 0;
-}</code></pre>
-<h2>15.5.3 Memory range attributes</h2>
-<p>Memory Range attributes allow you to query attributes of a given memory range.</p>
-<p>The hipMemRangeGetAttribute() is added to the example to query the hipMemRangeAttributeReadMostly attribute of the memory range pointed to by a . The result is stored in attributeValue and then printed out.</p>
-<p>For more details, visit the HIP managed memory allocation API .</p>
-<p><strong>**Following code does:** The code snippet you provided seems to be a placeholder or a tag indicating PHP code, but it does not contain any actual PHP code to analyze. If you have a specific PHP code snippet you'd like me to explain, please provide the actual code, and I'd be happy to help!</strong></p>
-<pre><code>
-        Memory Range attributes allow you to query attributes of a given memory range.
-        The hipMemRangeGetAttribute() is added to the example to query the hipMemRangeAttributeReadMostly at-
-        title of the memory range pointed to by a. The result is stored in attributeValue and then printed out.
-        For more details, visit the HIP managed memory allocation API.
-        #include <hip/hip_runtime.h>
-        #include <iostream>
-        
-        // Addition of two values.
-        __global__ void add(int *a, int *b, int *c) {
-            *c = *a + *b;
-        }
-        
-        int main() {
-            int *a, *b, *c;
-            unsigned int attributeValue;
-            constexpr size_t attributeSize = sizeof(attributeValue);
-            
-            // Allocate memory for a, b and c that is accessible to both device and host codes.
-            hipMallocManaged(&a, sizeof(*a));
-            hipMallocManaged(&b, sizeof(*b));
-            hipMallocManaged(&c, sizeof(*c));
-            
-            // Setup input values.
-            *a = 1;
-            *b = 2;
-            
-            // Launch add() kernel on GPU.
-            hipLaunchKernelGGL(add, dim3(1), dim3(1), 0, 0, a, b, c);
-            
-            // Wait for GPU to finish before accessing on host.
-            hipDeviceSynchronize();
-            
-            // Query an attribute of the memory range.
-            hipMemRangeGetAttribute(&attributeValue,
-                                             attributeSize,
-                                              hipMemRangeAttributeReadMostly,
-                                              a,
-                                               sizeof(*a));
-             
-            // Prints the result.
-            std::cout << *a << " + " << *b << " = " << *c << std::endl;
-                                                                                                                                                                                                         (continues on next page)
-                                                                                                                                                                                                      
-                                                                                                                                                                                                       )
-                                                                                                                                                                                                       (Continues on next page)</code></pre>
-<p>(continues on next page)</p>
-<p>(continued from previous page)</p>
-<p>(continued from previous page)</p>
-<p><strong>**Following code does:** The code snippet provided appears to be a malformed or corrupted text, possibly due to formatting issues or errors in copying. It includes a mix of symbols and text that do not form a valid or meaningful Python code. Therefore, it does not perform any specific function or task in its current state.</strong></p>
-<pre><code>    std::cout << "The queried attribute value is: " << attributeValue << std::endl;
-
-    // Cleanup allocated memory.
-    hipFree(a);
-    hipFree(b);
-    hipFree(c);
-
-    return 0;
-}</code></pre>
-<h2>15.5.4 Asynchronously attach memory to a stream</h2>
-<p>The hipStreamAttachMemAsync function would be able to asynchronously attach memory to a stream, which can help concurrent execution when using streams.</p>
-<p>Currently, this function is a no-operation (NOP) function on AMD GPUs. It simply returns success after the runtime memory validation passed. This function is necessary on Microsoft Windows, and UMM is not supported on this operating system with AMD GPUs at the moment.</p>
-<p>CHAPTER</p>
-<h2>SIXTEEN</h2>
-<h2>VIRTUAL MEMORY MANAGEMENT</h2>
-<p>Memorymanagement is important when creating high-performance applications in the HIP ecosystem. Both allocating and copying memory can result in bottlenecks, which can significantly impact performance.</p>
-<p>Global memory allocation in HIP uses the C language style allocation function. This works fine for simple cases but can cause problems if your memory needs change. If you need to increase the size of your memory, you must allocate a second larger buffer and copy the data to it before you can free the original buffer. This increases overall memory usage and causes unnecessary memcpy calls. Another solution is to allocate a larger buffer than you initially need. However, this isn't an efficient way to handle resources and doesn't solve the issue of reallocation when the extra buffer runs out.</p>
-<p>Virtual memory management solves these memory management problems. It helps to reduce memory usage and unnecessary memcpy calls.</p>
-<h2>16.1 Memory allocation</h2>
-<p>Standard memory allocation uses the hipMalloc function to allocate a block of memory on the device. However, when using virtual memory, this process is separated into multiple steps using the hipMemCreate , hipMemAddressReserve , hipMemMap , and hipMemSetAccess functions. This guide explains what these functions do and how you can use them for virtual memory management.</p>
-<h2>16.1.1 Allocate physical memory</h2>
-<p>The first step is to allocate the physical memory itself with the hipMemCreate function. This function accepts the size of the buffer, an unsigned long long variable for the flags, and a hipMemAllocationProp variable. hipMemAllocationProp contains the properties of the memory to be allocated, such as where the memory is physically located and what kind of shareable handles are available. If the allocation is successful, the function returns a value of hipSuccess , with hipMemGenericAllocationHandle_t representing a valid physical memory allocation. The allocated memory size must be aligned with the granularity appropriate for the properties of the allocation. You can use the hipMemGetAllocationGranularity function to determine the correct granularity.</p>
-<p><strong>**Following code does:** The code snippet you provided seems to be a placeholder or an incomplete representation of a code block, as it only contains `<_Bash_>`. This suggests that it might be intended to indicate a section where Bash script or commands should be inserted. Without actual Bash code or commands, it's not possible to determine its purpose or functionality. If you have a specific Bash script or command in mind, please provide the complete code for a more detailed explanation.</strong></p>
-<pre><code><_C_></code></pre>
-<h2>16.1.2 Reserve virtual address range</h2>
-<p>After you have acquired an allocation of physical memory, you must map it before you can use it. To do so, you need a virtual address to map it to. Mapping means the physical memory allocation is available from the virtual address range it is mapped to. To reserve a virtual memory range, use the hipMemAddressReserve function. The size of the virtual memory must match the amount of physical memory previously allocated. You can then map the physical memory allocation to the newly-acquired virtual memory address range using the hipMemMap function.</p>
-<p><strong>**Following code does:** The code snippet appears to be a mix of Python and C/C++ style comments and directives. However, it is mostly composed of whitespace and does not contain any executable code. The only meaningful part is the `#pragma unroll 16`, which is a compiler directive typically used in C/C++ to suggest that the compiler should unroll the following loop 16 times to potentially optimize performance. However, without any actual loop or surrounding code, this directive has no effect. Overall, the snippet does not perform any operations or have a functional purpose.</strong></p>
-<pre><code>0) ;</code></pre>
-<p><strong>**Following code does:** The code snippet appears to be malformed and does not represent valid Python code. It seems to contain HTML-like tags (`<img>` and `</img>`) with the word "void" inside them, but these are not valid in Python. The snippet does not perform any meaningful operation or serve a functional purpose in a Python context.</strong></p>
-<pre><code><_C++_></code></pre>
-<h2>16.1.3 Set memory access</h2>
-<p>Finally, use the hipMemSetAccess function to enable memory access. It accepts the pointer to the virtual memory, the size, and a hipMemAccessDesc descriptor as parameters. In a multi-GPU environment, you can map the device memory of one GPU to another. This feature also works with the traditional memory management system, but isn't as scalable as with virtual memory. When memory is allocated with hipMalloc , hipDeviceEnablePeerAccess is used to enable peer access. This function enables access between two devices, but it means that every call to hipMalloc takes more time to perform the checks and the mapping between the devices. When using virtual memory management, peer access is enabled by hipMemSetAccess , which provides a finer level of control over what is shared. This has no performance impact on memory allocation and gives you more control over what memory buffers are shared with which devices.</p>
-<p><strong>**Following code does:** This code snippet is a command-line instruction using `hipcc`, which is a compiler for HIP (Heterogeneous-Compute Interface for Portability) programs. The command is used to generate a code object file for a specific GPU architecture. It takes an input file containing GPU kernels, compiles it for the specified target GPU architecture, and outputs the compiled code into a designated output file. The `--genco` flag indicates that the command is specifically for generating code objects, and `--offload-arch` specifies the target GPU architecture for which the code should be compiled.</strong></p>
-<pre><code>hipMemAccessDesc accessDesc = {};
-accessDesc.location.type = HIP_MEM_LOCATION_TYPE_DEVICE;
-accessDesc.location.id = currentDev;
-accessDesc.flags = HIP_MEM_ACCESS_FLAGS_PROT_READWRITE;
-hipMemSetAccess(ptr, padded_size, &accessDesc, 1);</code></pre>
-<p>At this point the memory is allocated, mapped, and ready for use. You can read and write to it, just like you would a C style memory allocation.</p>
-<h2>16.1.4 Free virtual memory</h2>
-<p>To free the memory allocated in this manner, use the corresponding free functions. To unmap the memory, use hipMemUnmap . To release the virtual address range, use hipMemAddressFree . Finally, to release the physical memory, use hipMemRelease . A side effect of these functions is the lack of synchronization when memory is released. If you call hipFree when you have multiple streams running in parallel, it synchronizes the device. This causes worse resource usage and performance.</p>
-<p><strong>**Following code does:** This code snippet is a series of shell commands that clone specific branches of three different repositories from GitHub. The repositories are related to the ROCm (Radeon Open Compute) platform, which is an open-source software platform for GPU computing. The branches being cloned are specified by the environment variable `ROCM_BRANCH`. The repositories being cloned are `clr`, `hip`, and `hipother`, all from the ROCm organization on GitHub. This setup is typically used to obtain specific versions of these projects for development or deployment purposes.</strong></p>
-<pre><code>        |hipMemUnmap(ptr, size);
-        |hipMemRelease(allocHandle);</code></pre>
-<p><strong>**Following code does:** The code snippet appears to be part of a script or instructions for setting up a development environment related to HIP (Heterogeneous-Compute Interface for Portability). It outlines two main steps: 
-
-1. Cloning the HIP source code from a repository using Git, specifically checking out a branch specified by the environment variable `$ROCM_BRANCH`. The repetition of the `git clone` command suggests either a mistake or an incomplete snippet where different repositories or directories might be intended.
-
-2. Setting environment variables, which is a common step in configuring a development environment to ensure that the necessary paths and settings are available for building or running the software.
-
-Overall, the snippet is part of a setup process for working with HIP, likely in the context of ROCm (Radeon Open Compute), a platform for GPU computing.</strong></p>
-<pre><code>        |hipMemAddressFree(ptr,  size);</code></pre>
-<h2>16.2 Memory usage</h2>
-<h2>16.2.1 Dynamically increase allocation size</h2>
-<p>The hipMemAddressReserve function allows you to increase the amount of pre-allocated memory. This function accepts a parameter representing the requested starting address of the virtual memory. This allows you to have a continuous virtual address space without worrying about the underlying physical allocation.</p>
-<p><strong>**Following code does:** This code snippet sets three environment variables (`CLR_DIR`, `HIP_DIR`, and `HIP_OTHER`) to the absolute paths of the directories named `clr`, `hip`, and `hipother`, respectively. The `readlink -f` command is used to resolve and return the full path of each directory, ensuring that any symbolic links are followed to their final target locations. This setup is typically used in shell scripts to configure paths for use in subsequent commands or scripts.</strong></p>
-<pre><code>            hipMemAddressReserve(&new_ptr, (new_size - padded_size), 0, ptr + padded_size, 0);
-            hipMemMap(new_ptr, (new_size - padded_size), 0, newAllocHandle, 0);
-            hipMemSetAccess(new_ptr, (new_size - padded_size), &accessDesc, 1);</code></pre>
-<p>The code sample above assumes that hipMemAddressReserve was able to reserve the memory address at the specified location. However, this isn't guaranteed to be true, so you should validate that new_ptr points to a specific virtual address before using it.</p>
-<h2>CHAPTER</h2>
-<h2>SEVENTEEN</h2>
-<h2>FREQUENTLY ASKED QUESTIONS</h2>
-<h2>17.1 What APIs and features does HIP support?</h2>
-<p>HIP provides the following:</p>
-<ul>
-<li style="list-style-type: '· ';">Devices ( hipSetDevice() , hipGetDeviceProperties() , etc.)</li>
-<li style="list-style-type: '· ';">Memory management ( hipMalloc() , hipMemcpy() , hipFree() , etc.)</li>
-<li style="list-style-type: '· ';">Streams ( hipStreamCreate() , hipStreamSynchronize() , hipStreamWaitEvent() , etc.)</li>
-<li style="list-style-type: '· ';">Events ( hipEventRecord() , hipEventElapsedTime() , etc.)</li>
-<li style="list-style-type: '· ';">Kernel launching ( hipLaunchKernel / hipLaunchKernelGGL is the preferred way of launching kernels. hipLaunchKernelGGL is a standard C/C++ macro that can serve as an alternative way to launch kernels, replacing the CUDA triple-chevron ( &lt;&lt;&lt; &gt;&gt;&gt; ) syntax).</li>
-<li style="list-style-type: '· ';">HIP Module API to control when and how code is loaded.</li>
-<li style="list-style-type: '· ';">CUDA-style kernel coordinate functions ( threadIdx , blockIdx , blockDim , gridDim )</li>
-<li style="list-style-type: '· ';">Cross-lane instructions including shfl , ballot , any , all</li>
-<li style="list-style-type: '· ';">Most device-side math built-ins</li>
-<li style="list-style-type: '· ';">Error reporting ( hipGetLastError() , hipGetErrorString() )</li>
-</ul>
-<p>The HIP API documentation describes each API and its limitations, if any, compared with the equivalent CUDA API.</p>
-<h2>17.2 What is not supported?</h2>
-<h2>17.2.1 Runtime/Driver API features</h2>
-<p>At a high-level, the following features are not supported:</p>
-<ul>
-<li style="list-style-type: '· ';">Textures (partial support available)</li>
-<li style="list-style-type: '· ';">Dynamic parallelism (CUDA 5.0)</li>
-<li style="list-style-type: '· ';">Graphics interoperability with OpenGL or Direct3D</li>
-<li style="list-style-type: '· ';">CUDA IPC Functions (Under Development)</li>
-<li style="list-style-type: '· ';">CUDA array, mipmappedArray and pitched memory</li>
-<li style="list-style-type: '· ';">Queue priority controls</li>
-</ul>
-<p>See the API Support Table for more detailed information.</p>
-<h2>17.2.2 Kernel language features</h2>
-<ul>
-<li style="list-style-type: '· ';">C+ ± style device-side dynamic memory allocations (free, new, delete) (CUDA 4.0)</li>
-<li style="list-style-type: '· ';">Virtual functions, indirect functions and try/catch (CUDA 4.0)</li>
-<li style="list-style-type: '· ';">__prof_trigger</li>
-<li style="list-style-type: '· ';">PTX assembly (CUDA 4.0). HIP-Clang supports inline GCN assembly.</li>
-<li style="list-style-type: '· ';">Several kernel features are under development. See the C++ language extensions for more information.</li>
-</ul>
-<h2>17.3 Is HIP a drop-in replacement for CUDA?</h2>
-<p>No. HIP provides porting tools which do most of the work to convert CUDA code into portable C++ code that uses the HIP APIs. Most developers will port their code from CUDA to HIP and then maintain the HIP version. HIP code provides the same performance as native CUDA code, plus the benefits of running on AMD platforms.</p>
-<h2>17.4 What specific version of CUDA does HIP support?</h2>
-<p>HIP APIs and features do not map to a specific CUDA version. HIP provides a strong subset of the functionality provided in CUDA, and the hipify tools can scan code to identify any unsupported CUDA functions - this is useful for identifying the specific features required by a given application.</p>
-<p>However, we can provide a rough summary of the features included in each CUDA SDK and the support level in HIP. Each bullet below lists the major new language features in each CUDA release and then indicate which are supported/not supported in HIP:</p>
-<ul>
-<li style="list-style-type: '· ';">CUDA 4.0 and earlier :</li>
-<li>-HIP supports CUDA 4.0 except for the limitations described above.</li>
-<li style="list-style-type: '· ';">CUDA 5.0 :</li>
-<li>-Dynamic Parallelism (not supported)</li>
-<li>-cuIpc functions (under development).</li>
-<li style="list-style-type: '· ';">CUDA 6.0 :</li>
-<li>-Managed memory (under development)</li>
-<li style="list-style-type: '· ';">CUDA 6.5 :</li>
-<li>-__shfl intrinsic (supported)</li>
-<li style="list-style-type: '· ';">CUDA 7.0 :</li>
-<li>-Per-thread default streams (supported)</li>
-<li>-C++11 (Hip-Clang supports all of C++11, all of C++14 and some C++17 features)</li>
-<li style="list-style-type: '· ';">CUDA 7.5 :</li>
-<li>-float16 (supported)</li>
-<li style="list-style-type: '· ';">CUDA 8.0 :</li>
-<li>-Page Migration including cudaMemAdvise , cudaMemPrefetch , other cudaMem* APIs(not supported)</li>
-<li style="list-style-type: '· ';">CUDA 9.0 :</li>
-</ul>
-<ul>
-<li>-Cooperative Launch, Surface Object Management, Version Management</li>
-</ul>
-<h2>17.5 What libraries does HIP support?</h2>
-<p>HIP includes growing support for the four key math libraries using hipBLAS, hipFFT, hipRAND and hipSPARSE, as well as MIOpen for machine intelligence applications. These offer pointer-based memory interfaces (as opposed to opaque buffers) and can be easily interfaced with other HIP applications. The hip interfaces support both ROCm and CUDA paths, with familiar library interfaces.</p>
-<ul>
-<li style="list-style-type: '· ';">hipBLAS, which utilizes rocBlas.</li>
-<li style="list-style-type: '• ';">hipFFT</li>
-<li style="list-style-type: '• ';">hipsSPARSE</li>
-<li style="list-style-type: '• ';">hipRAND</li>
-<li style="list-style-type: '• ';">MIOpen</li>
-</ul>
-<p>Additionally, some of the cuBLAS routines are automatically converted to hipblas equivalents by the HIPIFY tools. These APIs use cuBLAS or hcBLAS depending on the platform and replace the need to use conditional compilation.</p>
-<h2>17.6 How does HIP compare with OpenCL?</h2>
-<p>Both AMD and NVIDIA support OpenCL 1.2 on their devices so that developers can write portable code. HIP offers several benefits over OpenCL:</p>
-<ul>
-<li style="list-style-type: '· ';">Developers can code in C++ as well as mix host and device C++ code in their source files. HIP C++ code can use templates, lambdas, classes and so on.</li>
-<li style="list-style-type: '· ';">The HIP API is less verbose than OpenCL and is familiar to CUDA developers.</li>
-<li style="list-style-type: '· ';">Because both CUDA and HIP are C++ languages, porting from CUDA to HIP is significantly easier than porting from CUDA to OpenCL.</li>
-<li style="list-style-type: '· ';">HIP uses the best available development tools on each platform: on NVIDIA GPUs, HIP code compiles using NVCC and can employ the Nsight profiler and debugger (unlike OpenCL on NVIDIA GPUs).</li>
-<li style="list-style-type: '· ';">HIP provides pointers and host-side pointer arithmetic.</li>
-<li style="list-style-type: '· ';">HIP provides device-level control over memory allocation and placement.</li>
-<li style="list-style-type: '· ';">HIP offers an offline compilation model.</li>
-</ul>
-<h2>17.7 How does porting CUDA to HIP compare to porting CUDA to OpenCL?</h2>
-<p>Both HIP and CUDA are dialects of C++, and thus porting between them is relatively straightforward. Both dialects support templates, classes, lambdas, and other C++ constructs. As one example, the hipify-perl tool was originally a Perl script that used simple text conversions from CUDA to HIP. HIP and CUDA provide similar math library calls as well. In summary, the HIP philosophy was to make the HIP language close enough to CUDA that the porting effort is relatively simple. This reduces the potential for error, and also makes it easy to automate the translation. HIP goal is to quickly get the ported program running on both platforms with little manual intervention, so that the programmer can focus on performance optimizations.</p>
-<p>There have been several tools that have attempted to convert CUDA into OpenCL, such as CU2CL. OpenCL is a C99based kernel language (rather than C++) and also does not support single-source compilation. As a result, the OpenCL syntax is different from CUDA, and the porting tools have to perform some heroic transformations to bridge this gap. The tools also struggle with more complex CUDA applications, in particular, those that use templates, classes, or other C++ features inside the kernel.</p>
-<h2>17.8 What hardware does HIP support?</h2>
-<ul>
-<li style="list-style-type: '· ';">For AMD platforms, see the ROCm documentation for the list of supported platforms.</li>
-<li style="list-style-type: '· ';">For NVIDIA platforms, HIP requires unified memory and should run on any device supporting CUDA SDK 6.0 or newer. We have tested the NVIDIA Titan and Tesla K40.</li>
-</ul>
-<h2>17.9 Do HIPIFY tools automatically convert all source code?</h2>
-<p>Typically, HIPIFY tools can automatically convert almost all run-time code. Most device code needs no additional conversion since HIP and CUDA have similar names for math and built-in functions. The hipify-clang tool will automatically modify the kernel signature as needed (automating a step that used to be done manually). Additional porting may be required to deal with architecture feature queries or with CUDA capabilities that HIP doesn't support. In general, developers should always expect to perform some platform-specific tuning and optimization.</p>
-<h2>17.10 What is NVCC?</h2>
-<p>NVCC is NVIDIA's compiler driver for compiling 'CUDA C++' code into PTX or device code for NVIDIA GPUs. It's a closed-source binary compiler that is provided by the CUDA SDK.</p>
-<h2>17.11 What is HIP-Clang?</h2>
-<p>HIP-Clang is a Clang/LLVM based compiler to compile HIP programs which can run on AMD platform.</p>
-<h2>17.12 Why use HIP rather than supporting CUDA directly?</h2>
-<p>While HIP is a strong subset of the CUDA, it is a subset. The HIP layer allows that subset to be clearly defined and documented. Developers who code to the HIP API can be assured their code will remain portable across NVIDIA and AMD platforms. In addition, HIP defines portable mechanisms to query architectural features and supports a larger 64-bit WaveSize which expands the return type for cross-lane functions like ballot and shuffle from 32-bit integers to 64-bit integers.</p>
-<h2>17.13 Can I develop HIP code on an NVIDIA CUDA platform?</h2>
-<p>Yes. HIP's CUDA path only exposes the APIs and functionality that work on both NVCC and AMDGPU back-ends. 'Extra' APIs, parameters, and features which exist in CUDA but not in HIP-Clang will typically result in compile-time or run-time errors. Developers need to use the HIP API for most accelerator code and bracket any CUDA-specific code with preprocessor conditionals. Developers concerned about portability should, of course, run on both platforms, and should expect to tune for performance. In some cases, CUDA has a richer set of modes for some APIs, and some C++ capabilities such as virtual functions - see the HIP @API documentation for more details.</p>
-<h2>17.14 Can I develop HIP code on an AMD HIP-Clang platform?</h2>
-<p>Yes. HIP's HIP-Clang path only exposes the APIs and functions that work on AMD runtime back ends. 'Extra' APIs, parameters and features that appear in HIP-Clang but not CUDA will typically cause compile- or run-time errors. Developers must use the HIP API for most accelerator code and bracket any HIP-Clang specific code with preprocessor conditionals. Those concerned about portability should, of course, test their code on both platforms and should tune it for performance. Typically, HIP-Clang supports a more modern set of C++11/C++14/C++17 features, so HIP developers who want portability should be careful when using advanced C++ features on the HIP-Clang path.</p>
-<h2>17.15 How to use HIP-Clang to build HIP programs?</h2>
-<p>The environment variable can be used to set compiler path:</p>
-<ul>
-<li style="list-style-type: '· ';">HIP_CLANG_PATH: path to hip-clang. When set, this variable let hipcc to use hip-clang for compilation/linking.</li>
-</ul>
-<p>There is an alternative environment variable to set compiler path:</p>
-<ul>
-<li style="list-style-type: '· ';">HIP_ROCCLR_HOME: path to root directory of the HIP-ROCclr runtime. When set, this variable let hipcc use hip-clang from the ROCclr distribution. NOTE: If HIP_ROCCLR_HOME is set, there is no need to set HIP_CLANG_PATH since hipcc will deduce them from HIP_ROCCLR_HOME.</li>
-</ul>
-<h2>17.16 What is AMD clr?</h2>
-<p>AMD Common Language Runtime (CLR) is a repository for the AMD platform, which contains source codes for AMD's compute languages runtimes as follows,</p>
-<ul>
-<li style="list-style-type: '· ';">hipamd - contains implementation of HIP language for AMD GPU.</li>
-<li style="list-style-type: '· ';">rocclr - contains virtual device interfaces that compute runtimes interact with backends, such as ROCr on Linux and PAL on Windows.</li>
-<li style="list-style-type: '· ';">opencl - contains implementation of OpenCL™ on the AMD platform.</li>
-</ul>
-<h2>17.17 What is hipother?</h2>
-<p>A new repository 'hipother' is added in the ROCm 6.1 release, which is branched out from HIP. hipother supports the HIP back-end implementation on some non-AMD platforms, like NVIDIA.</p>
-<h2>17.18 Can I get HIP open source repository for Windows?</h2>
-<p>No, there is no HIP repository open publicly on Windows.</p>
-<h2>17.19 Can a HIP binary run on both AMD and NVIDIA platforms?</h2>
-<p>HIP is a source-portable language that can be compiled to run on either AMD or NVIDIA platform. HIP tools don't create a 'fat binary' that can run on either platform, however.</p>
-<h2>17.20 On HIP-Clang, can I link HIP code with host code compiled with another compiler such as gcc, icc, or clang?</h2>
-<p>Yes. HIP generates the object code which conforms to the GCC ABI, and also links with libstdc++. This means you can compile host code with the compiler of your choice and link the generated object code with GPU code compiled with HIP. Larger projects often contain a mixture of accelerator code (initially written in CUDA with NVCC) and host code (compiled with gcc, icc, or clang). These projects can convert the accelerator code to HIP, compile that code with hipcc, and link with object code from their preferred compiler.</p>
-<h2>17.21 Can HIP API support C style application? What is the difference between C and C++?</h2>
-<p>HIP is C++ runtime API that supports C style applications as well.</p>
-<p>Some C style applications (and interfaces to other languages (FORTRAN, Python)) would call certain HIP APIs but not use kernel programming. They can be compiled with a C compiler and run correctly, however, small details must be considered in the code. For example, initialization, as shown in the simple application below, uses HIP structs dim3 with the file name 'test.hip.cpp'</p>
-<p><strong>**Following code does:** The code snippet provided is not a valid Python code. It appears to be a fragment of a list or a set of instructions, specifically the third step in a sequence, which is "Build HIP." Without additional context, it's unclear what "HIP" refers to, but it could be an acronym or a specific component in a larger process. The snippet suggests that this step involves constructing or assembling something referred to as HIP.</strong></p>
-<pre><code>                                                                                                                                                                                                        //the file name `test.hip.cpp`
-                                                                                                                                                                                                       
-                                                                                                                                                                                                      
-#include "hip/hip_runtime_api.h"
-                                                                                                                                                                                                       //this file name `test.hip.cpp`
-                                                                                                                                                                                             
-          int main(int argc, char** argv) {
-            dim3 grid1;
-            printf("dim3 grid1; x=%d, y=%d, z=%d\n",grid1.x,grid1.y,grid1.z);
-            dim3 grid2 = {1,1,1};
-            printf("dim3 grid2 = {1,1,1}; x=%d, y=%d, z=%d\n",grid2.x,grid2.y,grid2.z);
-            return 0;
-            }</code></pre>
-<p>When using a C++ compiler,</p>
-<p><strong>**Following code does:** This code snippet is a shell script that automates the process of building and installing a software project using CMake and Make, specifically targeting a HIP (Heterogeneous-Compute Interface for Portability) platform with NVIDIA support. Here's a high-level breakdown of its purpose:
-
-1. **Change Directory**: It navigates to a directory specified by the environment variable `CLR_DIR`.
-
-2. **Create and Navigate to Build Directory**: It creates a `build` directory if it doesn't exist and then changes into it.
-
-3. **Configure the Build with CMake**: It runs the `cmake` command to configure the build system. Various options are set, such as:
-   - `HIP_COMMON_DIR` and `HIPNV_DIR` for specifying directories related to HIP.
-   - `HIP_PLATFORM=nvidia` to target NVIDIA GPUs.
-   - `CMAKE_INSTALL_PREFIX` to set the installation directory to the current working directory.
-   - Disabling certain build options like `HIP_CATCH_TEST` and `CLR_BUILD_OCL`.
-
-4. **Compile the Project**: It uses `make` with parallel execution (`-j$(nproc)`) to compile the project, utilizing all available CPU cores.
-
-5. **Install the Compiled Software**: It runs `sudo make install` to install the compiled software, which typically requires superuser privileges.
-
-Overall, this script is used to build and install a HIP-based software project configured for NVIDIA GPUs.</strong></p>
-<pre><code>$ gcc -x c++  $(hipconfig --cpp_config) test3.hip.cpp -o test
-$./test
-dim3 grid1; x=1, y=1, z=1
-dim3 grid2 = {1,1,1}; x=1, y=1, z=1</code></pre>
-<p>In which 'dim3 grid1;' will yield a dim3 grid with all dimensional members x,y,z initialized to 1, as the default constructor behaves that way. Further, if written: dim3 grid(2); // yields {2,1,1} dim3 grid(2,3); yields {2,3,1} In comparison, when using the C compiler, $ gcc -x c $( hipconfig --cpp_config ) test.hip.cpp -o test $ ./test dim3 grid1; x=646881376, y=21975, z=1517277280 dim3 grid2 = {1,1,1}; x=1, y=1, z=1 In which 'dim3 grid;' does not imply any initialization, no constructor is called, and dimensional values x,y,z of grid are undefined. NOTE: To get the C++ default behavior, C programmers must additionally specify the right-hand side as shown below,</p>
-<p><strong>**Following code does:** This code snippet is a shell command that uses `git` to clone a specific branch of a repository from GitHub. It clones the `hip-tests` repository from the ROCm (Radeon Open Compute) GitHub organization. The branch to be cloned is specified by the environment variable `ROCM_BRANCH`. This command is typically used to obtain a local copy of the code from a particular branch of the repository for development, testing, or deployment purposes.</strong></p>
-<pre><code>        |dim3 grid = {1,1,1}; // initialized as in C++</code></pre>
-<p><strong>**Following code does:** This code snippet appears to be a shell script intended for setting up and running tests for a project that uses HIP (Heterogeneous-Compute Interface for Portability), which is a C++ runtime API and kernel language that allows developers to create portable applications across different GPU platforms. Here's a high-level summary of what it does:
-
-1. **Set Environment Variable**: It sets the `HIPTESTS_DIR` environment variable to the absolute path of the `hip-tests` directory using `readlink -f`.
-
-2. **Navigate to Directory**: It changes the current directory to `HIPTESTS_DIR`.
-
-3. **Create and Navigate to Build Directory**: It creates a `build` directory if it doesn't exist and navigates into it.
-
-4. **Configure Build with CMake**: It runs `cmake` to configure the build system for the project, specifying the HIP platform as AMD and setting the HIP path to a specified directory.
-
-5. **Build Tests**: It compiles the test suite using `make build_tests`.
-
-6. **Run Tests**: It executes the tests using `ctest`.
-
-Overall, this script automates the process of setting up the environment, configuring, building, and running tests for a HIP-based project.</strong></p>
-<pre><code>C++</code></pre>
-<h2>17.22 Can I install both CUDA SDK and HIP-Clang on the same machine?</h2>
-<p>Yes. You can use HIP_PLATFORM to choose which path hipcc targets. This configuration can be useful when using HIP to develop an application which is portable to both AMD and NVIDIA.</p>
-<h2>17.23 HIP detected my platform (HIP-Clang vs NVCC) incorrectly * what should I do?</h2>
-<p>HIP will set the platform to AMD and use HIP-Clang as compiler if it sees that the AMD graphics driver is installed and has detected an AMD GPU. Sometimes this isn't what you want * you can force HIP to recognize the platform by setting the following,</p>
-<p><strong>**Following code does:** The code snippet defines a function `ynf` that calculates and returns the value of the Bessel function of the second kind of order `n` for a given input `x`. Bessel functions are a family of solutions to Bessel's differential equation and are commonly used in various fields such as physics and engineering, particularly in problems involving cylindrical or spherical symmetry.</strong></p>
-<pre><code>| export</code></pre>
-<p><strong>**Following code does:** The code snippet appears to be a comment or documentation rather than executable code. It describes the process of building HIP (Heterogeneous-Compute Interface for Portability) tests using Catch2, a unit testing framework. Specifically, it mentions that these HIP tests are separate from the main HIP project and outlines a step to obtain the source code for these tests.</strong></p>
-<pre><code>rt HIP_PLATFORM=amd</code></pre>
-<p><strong>**Following code does:** This code snippet appears to be a part of a script or configuration file that compiles and runs a specific test for a HIP (Heterogeneous-Compute Interface for Portability) application. It navigates to a directory specified by the environment variable `HIPTESTS_DIR`, then uses the `hipcc` compiler to compile a C++ test file named `hipPointerGetAttributes.cc` along with some include directories. The compiled output is an executable named `hipPointerGetAttributes`, which is then executed. The purpose of this script is to test the functionality related to HIP pointer attributes, and it concludes with a message indicating that all tests have passed.</strong></p>
-<pre><code><_Python_></code></pre>
-<p><strong>**Following code does:** The code snippet `++i)` appears to be a syntax error in Python. In Python, the `++` operator does not exist as it does in languages like C++ or JavaScript. Instead, Python uses `i += 1` to increment a variable. The snippet seems to be an incomplete or incorrect attempt to increment a variable, possibly influenced by syntax from another programming language.</strong></p>
-<pre><code>  | HIP_COMPILER=cuda</code></pre>
-<p><strong>**Following code does:** The code snippet `<_SQL_>` appears to be a placeholder or a tag indicating that the actual SQL code is not provided. It suggests that the content is related to SQL, which is a language used for managing and manipulating relational databases. Without the actual SQL code, it's not possible to determine the specific operations or queries being performed. The placeholder might be used in documentation, templates, or code generation tools to signify where SQL code should be inserted or referenced.</strong></p>
-<pre><code>  | HIP_RUNTIME=nvcc</code></pre>
-<p>One symptom of this problem is the message 'error: 'unknown error'(11) at square.hipref.cpp:56 . This can occur if you have a CUDA installation on an AMD platform, and HIP incorrectly detects the platform as NVCC. HIP may be able to compile the application using the NVCC tool-chain but will generate this error at runtime since the platform does not have a CUDA device.</p>
-<h2>17.24 On CUDA, can I mix CUDA code with HIP code?</h2>
-<p>Yes. Most HIP data structures ( hipStream_t , hipEvent_t ) are typedefs to CUDA equivalents and can be intermixed. Both CUDA and HIP use integer device ids. One notable exception is that hipError_t is a new type, and cannot be used where a cudaError_t is expected. In these cases, refactor the code to remove the expectation. Alternatively, hip_runtime_api.h defines functions which convert between the error code spaces:</p>
-<p>hipErrorToCudaError hipCUDAErrorTohipError hipCUResultTohipError</p>
-<p>If platform portability is important, use #ifdef __HIP_PLATFORM_NVIDIA__ to guard the CUDA-specific code.</p>
-<h2>17.25 How do I trace HIP application flow?</h2>
-<p>See Logging HIP activity for more information.</p>
-<h2>17.26 What are the maximum limits of kernel launch parameters?</h2>
-<p>Product of block.x, block.y, and block.z should be less than 1024. Please note, HIP does not support kernel launch with total work items defined in dimension with size gridDim x blockDim &gt;= 2^32 , so gridDim.x * blockDim.x, gridDim.y * blockDim.y and gridDim.z * blockDim.z are always less than 2^32.</p>
-<h2>17.27 Are __shfl_*_sync functions supported on HIP platform?</h2>
-<p>__shfl_*_sync is not supported on HIP but for NVCC path CUDA 9.0 and above all shuffle calls get redirected to it's sync version.</p>
-<h2>17.28 How to create a guard for code that is specific to the host or the GPU?</h2>
-<p>The compiler defines the __HIP_DEVICE_COMPILE__ macro only when compiling the code for the GPU. It could be used to guard code that is specific to the host or the GPU.</p>
-<h2>17.29 Why _OpenMP is undefined when compiling with -fopenmp ?</h2>
-<p>When compiling an OpenMP source file with hipcc -fopenmp , the compiler may generate error if there is a reference to the _OPENMP macro. This is due to a limitation in hipcc that treats any source file type (for example .cpp ) as an HIP translation unit leading to some conflicts with the OpenMP language switch. If the OpenMP source file doesn't contain any HIP language constructs you could work around this issue by adding the -x c++ switch to force the compiler to treat the file as regular C++. Another approach would be to guard the OpenMP code with #ifdef _OPENMP so that the code block is disabled when compiling for the GPU. The __HIP_DEVICE_COMPILE__ macro defined by the HIP compiler when compiling GPU code could also be used for guarding code paths specific to the host or the GPU.</p>
-<h2>17.30 Does the HIP-Clang compiler support extern shared declarations?</h2>
-<p>Previously, it was essential to declare dynamic shared memory using the HIP_DYNAMIC_SHARED macro for accuracy, as using static shared memory in the same kernel could result in overlapping memory ranges and data-races.</p>
-<p>Now, the HIP-Clang compiler provides support for extern shared declarations, and the HIP_DYNAMIC_SHARED option is no longer required. You may use the standard extern definition: extern shared type var[];</p>
-<h2>17.31 I have multiple HIP enabled devices and I am getting an error code hipErrorSharedObjectInitFailed with the message 'Error: shared object initialization failed'?</h2>
-<p>This error message is seen due to the fact that you do not have valid code object for all of your devices.</p>
-<p>If you have compiled the application yourself, make sure you have given the correct device name(s) and its features via: --offload-arch . If you are not mentioning the --offload-arch , make sure that hipcc is using the correct offload arch by verifying the hipcc output generated by setting the environment variable HIPCC_VERBOSE=1 .</p>
-<p>If you have a precompiled application/library (like rocblas, TensorFlow etc) which gives you such error, there are one of two possibilities.</p>
-<ul>
-<li style="list-style-type: '· ';">The application/library does not ship code object bundles for all of your device(s): in this case you need to recompile the application/library yourself with correct --offload-arch .</li>
-<li style="list-style-type: '· ';">The application/library does not ship code object bundles for some of your device(s), for example you have a system with an APU + GPU and the library does not ship code objects for your APU. For this you can set the environment variable HIP_VISIBLE_DEVICES or CUDA_VISIBLE_DEVICES on NVIDIA platform, to only enable GPUs for which code object is available. This will limit the GPUs visible to your application and allow it to run.</li>
-</ul>
-<p>Note: In previous releases, the error code is hipErrorNoBinaryForGpu with message 'Unable to find code object for all current devices'. The error code handling behavior is changed. HIP runtime shows the error code hipErrorSharedObjectInitFailed with message 'Error: shared object initialization failed' on unsupported GPU.</p>
-<h2>17.32 How to use per-thread default stream in HIP?</h2>
-<p>The per-thread default stream is an implicit stream local to both the thread and the current device. It does not do any implicit synchronization with other streams (like explicitly created streams), or default per-thread stream on other threads.</p>
-<p>The per-thread default stream is a blocking stream and will synchronize with the default null stream if both are used in a program.</p>
-<p>In ROCm, a compilation option should be added in order to compile the translation unit with per-thread default stream enabled. -fgpu-default-stream=per-thread . Once source is compiled with per-thread default stream enabled, all APIs will be executed on per thread default stream, hence there will not be any implicit synchronization with other streams.</p>
-<p>Besides, per-thread default stream be enabled per translation unit, users can compile some files with feature enabled and some with feature disabled. Feature enabled translation unit will have default stream as per thread and there will not be any implicit synchronization done but other modules will have legacy default stream which will do implicit synchronization.</p>
-<h2>17.33 How to use complex multiplication and division operations?</h2>
-<p>In HIP, hipFloatComplex and hipDoubleComplex are defined as complex data types,</p>
-<p><strong>**Following code does:** This code is a command-line instruction that uses the `git` version control system to create a local copy (clone) of the repository located at the specified URL, `https://github.com/amd/rcm-examples.git`. This repository is hosted on GitHub and likely contains example code or resources related to AMD's RCM (Resource and Configuration Management) tools or projects. The cloned repository will be downloaded to the current directory where the command is executed.</strong></p>
-<pre><code><_C_></code></pre>
-<p>Any application uses complex multiplication and division operations, need to replace '*' and '/' operators with the following,</p>
-<ul>
-<li style="list-style-type: '· ';">hipCmulf() and hipCdivf() for hipFloatComplex</li>
-<li style="list-style-type: '· ';">hipCmul() and hipCdiv() for hipDoubleComplex</li>
-</ul>
-<p>Note: These complex operations are equivalent to corresponding types/functions on the NVIDIA platform.</p>
-<h2>17.34 Can I develop applications with HIP APIs on Windows the same on Linux?</h2>
-<p>Yes, HIP APIs are available to use on both Linux and Windows. Due to different working mechanisms on operating systems like Windows vs Linux, HIP APIs call corresponding lower level backend runtime libraries and kernel drivers for the OS, in order to control the executions on GPU hardware accordingly. There might be a few differences on the related backend software and driver support, which might affect usage of HIP APIs. See OS support details in HIP API document.</p>
-<h2>17.35 Does HIP support LUID?</h2>
-<p>Starting ROCm 6.0, HIP runtime supports Locally Unique Identifier (LUID). This feature enables the local physical device(s) to interoperate with other devices. For example, DirectX 12.</p>
-<p>HIP runtime sets device LUID properties so the driver can query LUID to identify each device for interoperability.</p>
-<p>Note: HIP supports LUID only on Windows OS.</p>
-<h2>17.36 How can I know the version of HIP?</h2>
-<p>HIP version definition has been updated since ROCm 4.2 release as the following:</p>
-<p><strong>**Following code does:** This code snippet is written in C++ using the HIP API, which is used for GPU programming. The code's high-level purpose is to allocate memory on a GPU device and copy data from the host (CPU) to the device (GPU). Specifically, it allocates memory for two float arrays (`d_x` and `d_y`) on the GPU, each with a size specified by `size_bytes`. It then copies data from two host arrays (`x` and `y`) to these newly allocated device arrays. The `HIP_CHECK` macro is likely used to handle errors that may occur during these operations.</strong></p>
-<pre><code><_SQL_></code></pre>
-<p>HIP version can be queried from HIP API call, hipRuntimeGetVersion(&amp;runtimeVersion);</p>
-<p>The version returned will always be greater than the versions in previous ROCm releases.</p>
-<p>Note: The version definition of HIP runtime is different from CUDA. On AMD platform, the function returns HIP runtime version, while on NVIDIA platform, it returns CUDA runtime version. And there is no mapping/correlation between HIP version and CUDA version.</p>
-<h2>18.1 Related Pages</h2>
-<p>18.2 Topics</p>
-<h2>18.3 Namespaces</h2>
-<p>18.3.1 Namespace List</p>
-<p>18.3.2 Namespace Members</p>
-<p>18.3.2.1 Namespace Members</p>
-<p>18.3.2.2 Namespace Members</p>
-<h2>18.4 Data Structures</h2>
-<ul>
-<li>18.4.1 Data Structures</li>
-<li>18.4.2 Data Structure Index</li>
-<li>18.4.3 Class Hierarchy</li>
-</ul>
-<p>18.4.4 Data Fields</p>
-<p>18.4.4.1 All</p>
-<p>18.4.4.1.1 Data Fields</p>
-<p>18.4.4.1.2 Data Fields</p>
-<p>18.4.4.1.3 Data Fields</p>
-<p>18.4.4.1.4 Data Fields</p>
-<p>18.4.4.1.5 Data Fields</p>
-<p>18.4.4.1.6 Data Fields 26</p>
-<p>18.4.4.1.7 Data Fields</p>
-<p>CHAPTER</p>
-<h2>EIGHTEEN</h2>
-<h2>HIP RUNTIME API REFERENCE</h2>
-<h2>CHAPTER</h2>
-<h2>NINETEEN</h2>
-<h2>C++ LANGUAGE EXTENSIONS</h2>
-<p>HIP provides a C++ syntax that is suitable for compiling most code that commonly appears in compute kernels (classes, namespaces, operator overloading, and templates). HIP also defines other language features that are designed to target accelerators, such as:</p>
-<ul>
-<li style="list-style-type: '· ';">A kernel-launch syntax that uses standard C++ (this resembles a function call and is portable to all HIP targets)</li>
-<li style="list-style-type: '· ';">Short-vector headers that can serve on a host or device</li>
-<li style="list-style-type: '· ';">Math functions that resemble those in math.h , which is included with standard C++ compilers</li>
-<li style="list-style-type: '· ';">Built-in functions for accessing specific GPU hardware capabilities</li>
-</ul>
-<p>Note: This chapter describes the built-in variables and functions that are accessible from the HIP kernel. It's intended for users who are familiar with CUDA kernel syntax and want to learn how HIP differs from CUDA.</p>
-<p>Features are labeled with one of the following keywords:</p>
-<ul>
-<li style="list-style-type: '· ';">Supported : HIP supports the feature with a CUDA-equivalent function</li>
-<li style="list-style-type: '· ';">Not supported : HIP does not support the feature</li>
-<li style="list-style-type: '· ';">Under development : The feature is under development and not yet available</li>
-</ul>
-<h2>19.1 Function-type qualifiers</h2>
-<h2>19.1.1 __device__</h2>
-<p>Supported __device__ functions are:</p>
-<ul>
-<li style="list-style-type: '· ';">Run on the device</li>
-<li style="list-style-type: '· ';">Called from the device only</li>
-</ul>
-<p>You can combine __device__ with the host keyword ( __host__ ).</p>
-<h2>19.1.2 __global__</h2>
-<p>Supported __global__ functions are:</p>
-<ul>
-<li style="list-style-type: '· ';">Run on the device</li>
-<li style="list-style-type: '· ';">Called (launched) from the host</li>
-</ul>
-<p>HIP __global__ functions must have a void return type.</p>
-<p>HIP doesn't support dynamic-parallelism, which means that you can't call __global__ functions from the device.</p>
-<h2>19.1.3 __host__</h2>
-<p>Supported __host__ functions are:</p>
-<ul>
-<li style="list-style-type: '· ';">Run on the host</li>
-<li style="list-style-type: '· ';">Called from the host</li>
-</ul>
-<p>You can combine __host__ with __device__ ; in this case, the function compiles for the host and the device. Note that these functions can't use the HIP grid coordinate functions (e.g., threadIdx.x ). If you need to use HIP grid coordinate functions, you can pass the necessary coordinate information as an argument.</p>
-<p>You can't combine __host__ with __global__ .</p>
-<p>HIP parses the __noinline__ and __forceinline__ keywords and converts them into the appropriate Clang attributes.</p>
-<h2>19.2 Calling __global__ functions</h2>
-<p>__global__ functions are often referred to as kernels . When you call a global function, you're launching a kernel . When launching a kernel, you must specify an execution configuration that includes the grid and block dimensions. The execution configuration can also include other information for the launch, such as the amount of additional shared memory to allocate and the stream where you want to execute the kernel.</p>
-<p>HIP introduces a standard C++ calling convention ( hipLaunchKernelGGL ) to pass the run configuration to the kernel. However, you can also use the CUDA &lt;&lt;&lt; &gt;&gt;&gt; syntax.</p>
-<p>When using hipLaunchKernelGGL , your first five parameters must be:</p>
-<ul>
-<li style="list-style-type: '· ';">symbol kernelName : The name of the kernel you want to launch. To support template kernels that contain "," , use the HIP_KERNEL_NAME macro (HIPIFY tools insert this automatically).</li>
-<li style="list-style-type: '· ';">dim3 gridDim : 3D-grid dimensions that specify the number of blocks to launch.</li>
-<li style="list-style-type: '· ';">dim3 blockDim : 3D-block dimensions that specify the number of threads in each block.</li>
-<li style="list-style-type: '· ';">size_t dynamicShared : The amount of additional shared memory that you want to allocate when launching the kernel (see __shared__ ).</li>
-<li style="list-style-type: '· ';">hipStream_t : The stream where you want to run the kernel. A value of 0 corresponds to the NULL stream (see Synchronization functions ).</li>
-</ul>
-<p>You can include your kernel arguments after these parameters.</p>
-<p><strong>**Following code does:** This code snippet is part of a GPU programming context, likely using a framework like CUDA or HIP for parallel computing. The high-level purpose of the code is to perform a SAXPY operation (Single-Precision A·X Plus Y) on a GPU. The `saxpy_kernel` function is a kernel function that runs on the GPU and performs the SAXPY operation on arrays `d_x` and `d_y` with a scalar `a`. The `main` function sets up the execution environment and launches this kernel on the GPU using a specified grid and block size configuration. The kernel is executed on the default stream, which is a queue for managing the execution order of operations on the GPU.</strong></p>
-<pre><code>                                                                                                                                                                                                        // Example hipLaunchKernelGGL pseudocode:</code></pre>
-<p><strong>**Following code does:** The code snippet `<_Cuda_>` appears to be a placeholder or a symbolic representation rather than actual executable Python code. In a typical context, "Cuda" refers to NVIDIA's parallel computing platform and application programming interface (API) model, which allows developers to use a CUDA-enabled graphics processing unit (GPU) for general purpose processing. However, without additional context or surrounding code, it is not possible to determine the specific functionality or purpose of this snippet.</strong></p>
-<pre><code>
-ize_t  N)</code></pre>
-<p>(continued from previous page)</p>
-<p><strong>**Following code does:** This code snippet is part of a program that uses HIP, a C++ runtime API and kernel language that allows developers to write portable code to run on AMD and NVIDIA GPUs. The specific line of code is performing a memory copy operation from a GPU device to the host (CPU) memory. 
-
-Here's a high-level explanation of what it does:
-
-- `hipMemcpy` is a function that copies data between host and device memory.
-- `y.data()` is likely a pointer or an array on the host where the data will be copied to.
-- `d_y` is a pointer or an array on the device (GPU) from which the data will be copied.
-- `size_bytes` specifies the number of bytes to copy.
-- `hipMemcpyDeviceToHost` is an enumeration that indicates the direction of the copy, from device to host.
-
-The `HIP_CHECK` macro is likely used to check for errors in the `hipMemcpy` operation, ensuring that the memory copy was successful.</strong></p>
-<pre><code>                                                                                                                                                                                                        (continued from previous page)
-                                                                                                                                                                                                       
-                                                                                                                                                                                                      
-}
-
-MyKernel<<<dim3(gridDim), dim3(groupDim), 0, 0>>> (a,b,c,n);
-
-// Alternatively, you can launch the kernel using:
-// hipLaunchKernelGGL(MyKernel, dim3(gridDim), dim3(groupDim), 0/*dynamicShared*/, 0/
-                                                                                                                                                                                                       :*stream), a, b, c, n);</code></pre>
-<p>You can use HIPIFY tools to convert CUDA launch syntax to hipLaunchKernelGGL . This includes the conversion of optional &lt;&lt;&lt; &gt;&gt;&gt; arguments into the five required hipLaunchKernelGGL parameters. Note: HIP doesn't support dimension sizes of 𝑔𝑟𝑖𝑑𝐷𝑖𝑚 * 𝑏𝑙𝑜𝑐𝑘𝐷𝑖𝑚 ≥ 2 32 when launching a kernel.</p>
-<h2>19.3 Kernel launch example</h2>
-<p><strong>**Following code does:** This code snippet is a shell command that modifies the `PATH` environment variable. It prepends the directory `/opt/rcm/bin` to the existing `PATH`. This means that when the system searches for executable files, it will first look in `/opt/rcm/bin` before checking the other directories listed in the current `PATH`. This is typically done to prioritize custom or specific versions of executables located in `/opt/rcm/bin` over those in other directories.</strong></p>
-<pre><code>
-// Example showing device function, __device__ __host__
-// <- compile for both device and host
-float PlusOne(float x)
-{
-  return x + 1.0;
-}
-
-__global__
-void
-MyKernel (hipLaunchParm lp, /*lp parm for execution configuration */
-          const float *a, const float *b, float *c, unsigned N)
-{
-  unsigned gid = threadIdx.x; // <- coordinate index function
-  if (gid < N) {
-    c[gid] = a[gid] + PlusOne(b[gid]);
-  }
-}
-void callMyKernel()
-{
-  float *a, *b, *c; // initialization not shown...
-  unsigned N = 1000000;
-  const unsigned blockSize = 256;
-
-  MyKernel<<<dim3(gridDim), dim3(groupDim), 0, 0>>> (a,b,c,n);
-  // Alternatively, kernel can be launched by
-  // hipLaunchKernelGGL(MyKernel, dim3(N/blockSize), dim3(blockSize), 0, 0, a,b,c,N);
-}</code></pre>
-<h2>19.4 Variable type qualifiers</h2>
-<h2>19.4.1 __constant__</h2>
-<p>The host writes constant memory before launching the kernel. This memory is read-only from the GPU while the kernel is running. The functions for accessing constant memory are:</p>
-<ul>
-<li style="list-style-type: '· ';">hipGetSymbolAddress()</li>
-<li style="list-style-type: '· ';">hipGetSymbolSize()</li>
-<li style="list-style-type: '· ';">hipMemcpyToSymbol()</li>
-<li style="list-style-type: '· ';">hipMemcpyToSymbolAsync()</li>
-<li style="list-style-type: '· ';">hipMemcpyFromSymbol()</li>
-<li style="list-style-type: '· ';">hipMemcpyFromSymbolAsync()</li>
-</ul>
-<h2>19.4.2 __shared__</h2>
-<p>To allow the host to dynamically allocate shared memory, you can specify extern __shared__ as a launch parameter.</p>
-<p>Note: Prior to the HIP-Clang compiler, dynamic shared memory had to be declared using the HIP_DYNAMIC_SHARED macro in order to ensure accuracy. This is because using static shared memory in the same kernel could've resulted in overlapping memory ranges and data-races. The HIP-Clang compiler provides support for extern __shared_ declarations, so HIP_DYNAMIC_SHARED is no longer required.</p>
-<h2>19.4.3 __managed__</h2>
-<p>Managed memory, including the __managed__ keyword, is supported in HIP combined host/device compilation.</p>
-<h2>19.4.4 __restrict__</h2>
-<p>__restrict__ tells the compiler that the associated memory pointer not to alias with any other pointer in the kernel or function. This can help the compiler generate better code. In most use cases, every pointer argument should use this keyword in order to achieve the benefit.</p>
-<h2>19.5 Built-in variables</h2>
-<h2>19.5.1 Coordinate built-ins</h2>
-<p>The kernel uses coordinate built-ins ( thread* , block* , grid* ) to determine the coordinate index and bounds for the active work item.</p>
-<p>Built-ins are defined in amd_hip_runtime.h , rather than being implicitly defined by the compiler.</p>
-<p>Coordinate variable definitions for built-ins are the same for HIP and CUDA. For example: threadIdx.x , blockIdx. y , and gridDim.y . The products gridDim.x * blockDim.x , gridDim.y * blockDim.y , and gridDim.z * blockDim.z are always less than 2^32 .</p>
-<p>Coordinate built-ins are implemented as structures for improved performance. When used with printf , they must be explicitly cast to integer types.</p>
-<h2>19.5.2 warpSize</h2>
-<p>The warpSize variable type is int . It contains the warp size (in threads) for the target device. warpSize should only be used in device functions that develop portable wave-aware code.</p>
-<p>Note: NVIDIA devices return 32 for this variable; AMD devices return 64 for gfx9 and 32 for gfx10 and above.</p>
-<h2>19.6 Vector types</h2>
-<p>The following vector types are defined in hip_runtime.h . They are not automatically provided by the compiler.</p>
-<h2>19.6.1 Short vector types</h2>
-<p>Short vector types derive from basic integer and floating-point types. These structures are defined in hip_vector_types.h . The first, second, third, and fourth components of the vector are defined by the x , y , z , and w fields, respectively. All short vector types support a constructor function of the form make_&lt;type_name&gt;() . For example, float4 make_float4(float x, float y, float z, float w) creates a vector with type float4 and value (x,y,z,w) .</p>
-<p>HIP supports the following short vector formats:</p>
-<ul>
-<li style="list-style-type: '· ';">Signed Integers:</li>
-<li>-char1 , char2 , char3 , char4</li>
-<li>-short1 , short2 , short3 , short4</li>
-<li>-int1 , int2 , int3 , int4</li>
-<li>-long1 , long2 , long3 , long4</li>
-<li>-longlong1 , longlong2 , longlong3 , longlong4</li>
-<li style="list-style-type: '· ';">Unsigned Integers:</li>
-<li>-uchar1 , uchar2 , uchar3 , uchar4</li>
-<li>-ushort1 , ushort2 , ushort3 , ushort4</li>
-<li>-uint1 , uint2 , uint3 , uint4</li>
-<li>-ulong1 , ulong2 , ulong3 , ulong4</li>
-<li>-ulonglong1 , ulonglong2 , ulonglong3 , ulonglong4</li>
-<li style="list-style-type: '· ';">Floating Points:</li>
-<li>-float1 , float2 , float3 , float4</li>
-<li>-double1 , double2 , double3 , double4</li>
-</ul>
-<h2>19.6.2 dim3</h2>
-<p>dim3 is a three-dimensional integer vector type that is commonly used to specify grid and group dimensions.</p>
-<p>The dim3 constructor accepts between zero and three arguments. By default, it initializes unspecified dimensions to 1.</p>
-<p><strong>**Following code does:** The code snippet provided is not valid Python code. It consists of a single closing curly brace `}`, which is not used in Python syntax. Curly braces are typically used in languages like C, C++, Java, and JavaScript to denote blocks of code, but in Python, indentation is used instead. Therefore, this snippet does not perform any function or operation in Python.</strong></p>
-<pre><code><_C_></code></pre>
-<h2>19.7 Memory fence instructions</h2>
-<p>HIP supports __threadfence() and __threadfence_block() . If you're using threadfence_system() in the HIP-Clang path, you can use the following workaround:</p>
-<ol>
-<li style="list-style-type: '1. ';">Build HIP with the HIP_COHERENT_HOST_ALLOC environment variable enabled.</li>
-<li style="list-style-type: '2. ';">Modify kernels that use __threadfence_system() as follows:</li>
-<li style="list-style-type: '· ';">Ensure the kernel operates only on fine-grained system memory, which should be allocated with hipHostMalloc() .</li>
-<li style="list-style-type: '· ';">Remove memcpy for all allocated fine-grained system memory regions.</li>
-</ol>
-<h2>19.8 Synchronization functions</h2>
-<p>Synchronization functions causes all threads in the group to wait at this synchronization point, and for all shared and global memory accesses by the threads to complete, before running synchronization. This guarantees the visibility of accessed data for all threads in the group.</p>
-<p>The __syncthreads() built-in function is supported in HIP. The __syncthreads_count(int) , __syncthreads_and(int) , and __syncthreads_or(int) functions are under development.</p>
-<p>The Cooperative Groups API offer options to do synchronization on a developer defined set of thread groups. For further information, check Cooperative Groups API or Cooperative Groups how to .</p>
-<h2>19.9 Math functions</h2>
-<p>HIP-Clang supports a set of math operations that are callable from the device. HIP supports most of the device functions supported by CUDA. These are described on Math API page .</p>
-<h2>19.10 Texture functions</h2>
-<p>The supported texture functions are listed in texture_fetch_functions.h and texture_indirect_functions. h header files in the HIP-AMD backend repository.</p>
-<p>Texture functions are not supported on some devices. To determine if texture functions are supported on your device, use Macro __HIP_NO_IMAGE_SUPPORT == 1 . You can query the attribute hipDeviceAttributeImageSupport to check if texture functions are supported in the host runtime code.</p>
-<h2>19.11 Surface functions</h2>
-<p>The following surface functions are supported in HIP:</p>
-<p>hipError_t hipCreateSurfaceObject ( hipSurfaceObject_t *pSurfObject, const hipResourceDesc *pResDesc )</p>
-<p>Create a surface object.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">pSurfObject -[out] Pointer of surface object to be created.</li>
-<li style="list-style-type: '· ';">pResDesc -[in] Pointer of suface object descriptor.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipError_t hipDestroySurfaceObject ( hipSurfaceObject_t surfaceObject )</p>
-<p>Destroy a surface object.</p>
-<h2>Parameters</h2>
-<p>surfaceObject -[in] Surface object to be destroyed.</p>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue template&lt;typename T , typename std::enable_if&lt;__hip_is_tex_surf_channel_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf1Dread ( T *data, hipSurfaceObject_t surfObj, int x, int boundaryMode = hipBoundaryModeZero )</p>
-<p>Reads the value at coordinate x from the one-dimensional surface.</p>
-<h2>Template Parameters</h2>
-<p>T - The data type of the surface.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">data - [out] The T type result is stored in this pointer.</li>
-<li style="list-style-type: '· ';">surfObj - [in] The surface descriptor.</li>
-<li style="list-style-type: '· ';">x - [in] The coordinate where the value will be read out.</li>
-<li style="list-style-type: '· ';">boundaryMode - [in] The boundary mode is currently ignored.</li>
-</ul>
-<p>template&lt;typename T , typename std::enable_if&lt;__hip_is_tex_surf_channel_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf1Dwrite ( T data, hipSurfaceObject_t surfObj, int x )</p>
-<p>Writes the value data to the one-dimensional surface at coordinate x.</p>
-<h2>Template Parameters</h2>
-<p>T - The data type of the surface.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">data - [in] The T type value is written to surface.</li>
-</ul>
-<ul>
-<li style="list-style-type: '· ';">surfObj - [in] The surface descriptor.</li>
-<li style="list-style-type: '· ';">x - [in] The coordinate where the data will be written.</li>
-</ul>
-<p>template&lt;typename T , typename std::enable_if&lt;__hip_is_tex_surf_channel_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf2Dread ( T *data, hipSurfaceObject_t surfObj, int x, int y )</p>
-<p>Reads the value from the two-dimensional surface at coordinate x, y.</p>
-<h2>Template Parameters</h2>
-<p>T - The data type of the surface.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">data - [out] The T type result is stored in this pointer.</li>
-<li style="list-style-type: '· ';">surfObj - [in] The surface descriptor.</li>
-<li style="list-style-type: '· ';">x - [in] The x coordinate where the value will be read out.</li>
-<li style="list-style-type: '· ';">y - [in] The y coordinate where the value will be read out.</li>
-</ul>
-<p>template&lt;typename T , typename std::enable_if&lt;__hip_is_tex_surf_channel_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf2Dwrite ( T data, hipSurfaceObject_t surfObj, int x, int y )</p>
-<p>Writes the value data to the two-dimensional surface at coordinate x, y.</p>
-<h2>Template Parameters</h2>
-<p>T - The data type of the surface.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">data - [in] The T type value is written to surface.</li>
-<li style="list-style-type: '· ';">surfObj - [in] The surface descriptor.</li>
-<li style="list-style-type: '· ';">x - [in] The x coordinate where the data will be written.</li>
-<li style="list-style-type: '· ';">y - [in] The y coordinate where the data will be written.</li>
-</ul>
-<p>template&lt;typename T , typename std::enable_if&lt;__hip_is_tex_surf_channel_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf3Dread ( T *data, hipSurfaceObject_t surfObj, int x, int y, int z )</p>
-<p>Reads the value from the three-dimensional surface at coordinate x, y, z.</p>
-<h2>Template Parameters</h2>
-<p>T - The data type of the surface.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">data - [out] The T type result is stored in this pointer.</li>
-<li style="list-style-type: '· ';">surfObj - [in] The surface descriptor.</li>
-<li style="list-style-type: '· ';">x - [in] The x coordinate where the value will be read out.</li>
-<li style="list-style-type: '· ';">y - [in] The y coordinate where the value will be read out.</li>
-<li style="list-style-type: '· ';">z - [in] The z coordinate where the value will be read out.</li>
-</ul>
-<p>template&lt;typename T , typename std::enable_if&lt;__hip_is_tex_surf_channel_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf3Dwrite ( T data, hipSurfaceObject_t surfObj, int x, int y, int z )</p>
-<p>Writes the value data to the three-dimensional surface at coordinate x, y, z.</p>
-<h2>Template Parameters</h2>
-<p>T - The data type of the surface.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">data - [in] The T type value is written to surface.</li>
-<li style="list-style-type: '· ';">surfObj - [in] The surface descriptor.</li>
-<li style="list-style-type: '· ';">x - [in] The x coordinate where the data will be written.</li>
-<li style="list-style-type: '· ';">y - [in] The y coordinate where the data will be written.</li>
-<li style="list-style-type: '· ';">z - [in] The z coordinate where the data will be written.</li>
-</ul>
-<p>template&lt;typename T , typename std::enable_if&lt;__hip_is_tex_surf_channel_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf1DLayeredread ( T *data, hipSurfaceObject_t surfObj, int x, int layer )</p>
-<p>Reads the value from the one-dimensional layered surface at coordinate x and layer index.</p>
-<h2>Template Parameters</h2>
-<p>T - The data type of the surface.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">data - [out] The T type result is stored in this pointer.</li>
-<li style="list-style-type: '· ';">surfObj - [in] The surface descriptor.</li>
-<li style="list-style-type: '· ';">x - [in] The coordinate where the value will be read out.</li>
-<li style="list-style-type: '· ';">layer - [in] The layer index where the value will be read out.</li>
-</ul>
-<p>template&lt;typename T , typename std::enable_if&lt;__hip_is_tex_surf_channel_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf1DLayeredwrite ( T data, hipSurfaceObject_t surfObj, int x, int layer )</p>
-<p>Writes the value data to the one-dimensional layered surface at coordinate x and layer index.</p>
-<h2>Template Parameters</h2>
-<p>T - The data type of the surface.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">data - [in] The T type value is written to surface.</li>
-<li style="list-style-type: '· ';">surfObj - [in] The surface descriptor.</li>
-<li style="list-style-type: '· ';">x - [in] The x coordinate where the data will be written.</li>
-<li style="list-style-type: '· ';">layer - [in] The layer index where the data will be written.</li>
-</ul>
-<p>template&lt;typename T , typename std::enable_if&lt;__hip_is_tex_surf_channel_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf2DLayeredread ( T *data, hipSurfaceObject_t surfObj, int x, int y, int layer )</p>
-<p>Reads the value from the two-dimensional layered surface at coordinate x, y and layer index.</p>
-<h2>Template Parameters</h2>
-<p>T - The data type of the surface.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">data - [out] The T type result is stored in this pointer.</li>
-<li style="list-style-type: '· ';">surfObj - [in] The surface descriptor.</li>
-<li style="list-style-type: '· ';">x - [in] The x coordinate where the value will be read out.</li>
-<li style="list-style-type: '· ';">y - [in] The y coordinate where the value will be read out.</li>
-<li style="list-style-type: '· ';">layer - [in] The layer index where the value will be read out.</li>
-</ul>
-<p>template&lt;typename T , typename std::enable_if&lt;__hip_is_tex_surf_channel_type&lt; T &gt;::value&gt;::type* = nullptr&gt;</p>
-<p>static void surf2DLayeredwrite ( T data, hipSurfaceObject_t surfObj, int x, int y, int layer )</p>
-<p>Writes the value data to the two-dimensional layered surface at coordinate x, y and layer index.</p>
-<h2>Template Parameters</h2>
-<p>T - The data type of the surface.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">data - [in] The T type value is written to surface.</li>
-<li style="list-style-type: '· ';">surfObj - [in] The surface descriptor.</li>
-<li style="list-style-type: '· ';">x - [in] The x coordinate where the data will be written.</li>
-<li style="list-style-type: '· ';">y - [in] The y coordinate where the data will be written.</li>
-<li style="list-style-type: '· ';">layer - [in] The layer index where the data will be written.</li>
-</ul>
-<p>template&lt;typename T , typename std::enable_if&lt;__hip_is_tex_surf_channel_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surfCubemapread ( T *data, hipSurfaceObject_t surfObj, int x, int y, int face )</p>
-<p>Reads the value from the cubemap surface at coordinate x, y and face index.</p>
-<h2>Template Parameters</h2>
-<p>T - The data type of the surface.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">data - [out] The T type result is stored in this pointer.</li>
-<li style="list-style-type: '· ';">surfObj - [in] The surface descriptor.</li>
-<li style="list-style-type: '· ';">x - [in] The x coordinate where the value will be read out.</li>
-<li style="list-style-type: '· ';">y - [in] The y coordinate where the value will be read out.</li>
-<li style="list-style-type: '· ';">face - [in] The face index where the value will be read out.</li>
-</ul>
-<p>template&lt;typename T , typename std::enable_if&lt;__hip_is_tex_surf_channel_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surfCubemapwrite ( T data, hipSurfaceObject_t surfObj, int x, int y, int face )</p>
-<p>Writes the value data to the cubemap surface at coordinate x, y and face index.</p>
-<h2>Template Parameters</h2>
-<p>T - The data type of the surface.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">data - [in] The T type value is written to surface.</li>
-<li style="list-style-type: '· ';">surfObj - [in] The surface descriptor.</li>
-<li style="list-style-type: '· ';">x - [in] The x coordinate where the data will be written.</li>
-<li style="list-style-type: '· ';">y - [in] The y coordinate where the data will be written.</li>
-<li style="list-style-type: '· ';">face - [in] The face index where the data will be written.</li>
-</ul>
-<p>template&lt;typename T , typename std::enable_if&lt;__hip_is_tex_surf_channel_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surfCubemapLayeredread ( T *data, hipSurfaceObject_t surfObj, int x, int y, int face, int layer )</p>
-<p>Reads the value from the layered cubemap surface at coordinate x, y and face, layer index.</p>
-<h2>Template Parameters</h2>
-<p>T - The data type of the surface.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">data - [out] The T type result is stored in this pointer.</li>
-</ul>
-<ul>
-<li style="list-style-type: '· ';">surfObj - [in] The surface descriptor.</li>
-<li style="list-style-type: '· ';">x - [in] The x coordinate where the value will be read out.</li>
-<li style="list-style-type: '· ';">y - [in] The y coordinate where the value will be read out.</li>
-<li style="list-style-type: '· ';">face - [in] The face index where the value will be read out.</li>
-<li style="list-style-type: '· ';">layer - [in] The layer index where the data will be written.</li>
-</ul>
-<p>template&lt;typename T , typename std::enable_if&lt;__hip_is_tex_surf_channel_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surfCubemapLayeredwrite ( T *data, hipSurfaceObject_t surfObj, int x, int y, int face, int layer )</p>
-<p>Writes the value data to the layered cubemap surface at coordinate x, y and face, layer index.</p>
-<h2>Template Parameters</h2>
-<p>T - The data type of the surface.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">data - [in] The T type value to write to the surface.</li>
-<li style="list-style-type: '· ';">surfObj - [in] The surface descriptor.</li>
-<li style="list-style-type: '· ';">x - [in] The x coordinate where the data will be written.</li>
-<li style="list-style-type: '· ';">y - [in] The y coordinate where the data will be written.</li>
-<li style="list-style-type: '· ';">face - [in] The face index where the data will be written.</li>
-<li style="list-style-type: '· ';">layer - [in] The layer index where the data will be written.</li>
-</ul>
-<h2>19.12 Timer functions</h2>
-<p>To read a high-resolution timer from the device, HIP provides the following built-in functions:</p>
-<ul>
-<li style="list-style-type: '· ';">Returning the incremental counter value for every clock cycle on a device:</li>
-</ul>
-<p><strong>**Following code does:** The code snippet is not actually a code but rather an instruction. It suggests that you should be able to execute a command in the command line to check the version of a compiler named `amdclang++`. This implies that `amdclang++` is a C++ compiler, likely provided by AMD, and the command `amdclang++ --version` is used to display the version information of this compiler.</strong></p>
-<pre><code><_SQL_></code></pre>
-<p><strong>**Following code does:** This code snippet is a shell command that checks the version of the NVIDIA CUDA Compiler (nvcc) installed on the system. By executing `nvcc --version`, it outputs the version information of the nvcc tool, which is part of the CUDA Toolkit used for compiling CUDA programs. This is useful for verifying the installation and version of CUDA on a machine.</strong></p>
-<pre><code>    [clock_t clock()
-    long long int close</code></pre>
-<p>The difference between the values that are returned represents the cycles used.</p>
-<ul>
-<li style="list-style-type: '· ';">Returning the wall clock count at a constant frequency on the device:</li>
-</ul>
-<p><strong>**Following code does:** This PowerShell script is designed to set up a development environment for Visual Studio. Here's a high-level summary of what it does:
-
-1. **Locate Visual Studio Installation**: It retrieves a list of installed Visual Studio instances, sorts them by version in descending order, and selects the most recent one. It then extracts the installation path of this latest version.
-
-2. **Import Visual Studio Module**: It imports a specific Visual Studio module (`Microsoft.VisualStudio.DevShell.dll`) from the installation path. This module is likely used to facilitate the setup of a development shell environment.
-
-3. **Enter Visual Studio Developer Shell**: It enters the Visual Studio Developer Shell using the installation path determined earlier. It specifies the architecture as `amd64` for both the host and the development environment, and it suppresses the display of the logo with the `-no_logo` argument.
-
-4. **Modify Environment Path**: It updates the system's `PATH` environment variable by prepending a directory (`bin` subdirectory of `HIP_PATH`) to the existing `PATH`. This ensures that executables in this directory are prioritized when running commands.
-
-Overall, the script automates the process of setting up a Visual Studio development environment with specific configurations and updates the system path to include additional tools.</strong></p>
-<pre><code>  | long long int w:</code></pre>
-<p><strong>**Following code does:** This code snippet is a shell command that checks the version of the `clang++` compiler installed on the system. `clang++` is the C++ compiler that is part of the LLVM project. Running this command will output the version information of the `clang++` compiler, including details like the version number, target architecture, and possibly the build date.</strong></p>
-<pre><code>    it will_clock64()</code></pre>
-<p>This can be queried using the HIP API with the hipDeviceAttributeWallClockRate attribute of the device in HIP application code. For example:</p>
-<p><strong>**Following code does:** This PowerShell script is designed to set up a development environment for Visual Studio. It performs the following high-level tasks:
-
-1. **Retrieve Visual Studio Installation Path**: It queries the system for installed Visual Studio instances, sorts them by version in descending order, and selects the installation path of the latest version.
-
-2. **Import Visual Studio Development Shell Module**: It imports a specific module (`Microsoft.VisualStudio.DevShell.dll`) from the selected Visual Studio installation. This module is used to configure the development environment.
-
-3. **Enter Visual Studio Development Shell**: It initializes the Visual Studio Developer Command Prompt environment for the specified installation path, targeting the `amd64` architecture for both the host and the development environment, while suppressing the display of the logo. This sets up the necessary environment variables and paths for development tasks.</strong></p>
-<pre><code>            int wallClkRate = 0; //in kilohertz
-            HIPCHECK(hipDeviceGetAttribute(&wallClkRate, hipDeviceAttributeWallClockRate, _
-            --deviceId));</code></pre>
-<p>Where hipDeviceAttributeWallClockRate is a device attribute. Note that wall clock frequency is a perdevice attribute.</p>
-<p>Note that clock() and clock64() do not work properly on AMD RDNA3 (GFX11) graphic processors.</p>
-<h2>19.13 Atomic functions</h2>
-<p>Atomic functions are run as read-modify-write (RMW) operations that reside in global or shared memory. No other device or thread can observe or modify the memory location during an atomic operation. If multiple instructions from different devices or threads target the same memory location, the instructions are serialized in an undefined order.</p>
-<p>To support system scope atomic operations, you can use the HIP APIs that contain the _system suffix. For example:</p>
-<ul>
-<li style="list-style-type: '· ';">atomicAnd : This function is atomic and coherent within the GPU device running the function</li>
-<li style="list-style-type: '· ';">atomicAnd_system : This function extends the atomic operation from the GPU device to other CPUs and GPU devices in the system.</li>
-</ul>
-<p>HIP supports the following atomic operations.</p>
-<p>Table 1: Atomic operations</p>
-<p><strong>**Following table contains:** The table represents a list of mathematical functions, specifically those related to floating-point operations in programming or computational contexts. Each row corresponds to a different function, providing a brief description of what the function does.
-
-The columns are as follows:
-- Column 0: Contains the function signature and a description of what the function does.
-- Column 1: Contains a checkmark (✓), which might indicate that the function is supported or verified in some context.
-- Column 2: Also contains a checkmark (✓), possibly indicating another layer of support or verification, or perhaps compatibility with another system or standard.
-
-Noteworthy observations:
-- All functions listed are related to floating-point arithmetic operations, such as absolute value, division, floor, fused multiply-add, maximum, minimum, and modulus.
-- Every function in the table has checkmarks in both Column 1 and Column 2, suggesting that all functions meet the criteria or standards represented by these columns.</strong></p>
-<table><tbody><tr><td>Function int atomicAdd(int* address, int val) int atomicAdd_system(int* address, int val) unsigned int atomicAdd(unsigned int* address,unsigned unsigned int atomicAdd_system(unsigned int* address, unsigned long long atomicAdd(unsigned long long* unsigned long long atomicAdd_system(unsigned long long* float atomicAdd(float* address, float val) float atomicAdd_system(float* address, float val) double atomicAdd(double* address, double val) double atomicAdd_system(double* address, double val) float unsafeAtomicAdd(float* address, float val) float safeAtomicAdd(float* address, float val)</td></tr><tr><td>int val) unsigned int val) address,unsigned long long val)</td></tr><tr><td>address, unsigned long long val) double unsafeAtomicAdd(double* address, double val) double safeAtomicAdd(double* address, double val) int atomicSub(int* address, int val) int atomicSub_system(int* address, int val) unsigned int atomicSub(unsigned int* address,unsigned int val) unsigned int atomicSub_system(unsigned int* address, unsigned int val)</td></tr><tr><td>int atomicExch(int* address, int val)</td></tr><tr><td>int atomicExch_system(int* address, int val) unsigned int atomicExch(unsigned int* address,unsigned int val) unsigned int atomicExch_system(unsigned int* address, unsigned int val)</td></tr><tr><td>unsigned long long atomicExch(unsigned long long int* address,unsigned long val)</td></tr><tr><td>long unsigned long long atomicExch_system(unsigned long long* address, unsigned long</td></tr><tr><td>int long val) unsigned long long atomicExch_system(unsigned long long* address, unsigned long long val)</td></tr><tr><td>float atomicExch(float* address, float val) int atomicMin(int* address, int val)</td></tr><tr><td>int atomicMin_system(int* address, int val) unsigned int atomicMin(unsigned int* address,unsigned int</td></tr><tr><td>val) unsigned int atomicMin_system(unsigned int* address, unsigned int</td></tr><tr><td>val) unsigned long long atomicMin(unsigned long long* address,unsigned long long val)</td></tr><tr><td>atomicMax(int* address, int val) atomicMax_system(int* address, int val)</td></tr><tr><td>int unsigned int atomicMax(unsigned int* address,unsigned int val)</td></tr><tr><td>unsigned int atomicMax_system(unsigned int* address, unsigned int</td></tr><tr><td>int</td></tr><tr><td>val)</td></tr><tr><td>unsigned long long atomicMax(unsigned long long* address,unsigned long long val)</td></tr></tbody></table>
-<p><strong>**Following table contains:** The table represents a list of mathematical functions, likely from a programming library or API, along with a status indicator. Each row corresponds to a specific function.
-
-- The first column contains the function signature and a brief description of what the function does. It includes the return type, the function name, and the parameters it takes, followed by a description of the function's purpose.
-- The second column contains a checkmark (✓), which likely indicates that the function is available, implemented, or verified.
-
-Noteworthy values:
-- All functions listed are related to mathematical operations, such as extracting components of a number, calculating square roots, determining properties of numbers (finite, infinite, NaN), and evaluating Bessel functions.
-- Each function description is followed by a checkmark, suggesting that all functions in this preview are confirmed or validated in some way.</strong></p>
-<table><caption><div class="caption">Table 1 - continued from previous page</div></caption><tbody><tr><td>unsigned int atomicDec(unsigned int* address)</td></tr><tr><td>int atomicCAS(int* address, int compare, int val)</td></tr><tr><td>int atomicCAS_system(int* address, int compare, int val)</td></tr><tr><td>unsigned int atomicCAS(unsigned int* address,unsigned int compare,unsigned int val) unsigned int atomicCAS_system(unsigned int* address, unsigned int compare, unsigned int val) unsigned long long atomicCAS(unsigned long long* address,unsigned long long compare,unsigned long long unsigned long long atomicCAS_system(unsigned long long* address, unsigned long long compare, unsigned int atomicAnd(int* address, int val) int atomicAnd_system(int* address, int val)</td></tr><tr><td>unsigned int atomicAnd(unsigned int* address,unsigned int val) unsigned int atomicAnd_system(unsigned int* address, unsigned int val)</td></tr><tr><td>unsigned long long atomicAnd(unsigned long long* address,unsigned long long val) unsigned long long atomicAnd_system(unsigned long long* address, unsigned long</td></tr><tr><td>long val) int atomicOr(int* address, int val)</td></tr><tr><td>int atomicOr_system(int* address, int val)</td></tr><tr><td>unsigned int atomicOr(unsigned int* address,unsigned int val) unsigned int atomicOr_system(unsigned int* address, unsigned</td></tr><tr><td>int val) unsigned int atomicOr_system(unsigned int* address, unsigned int val)</td></tr><tr><td>unsigned long long atomicOr(unsigned long long int* address,unsigned long long val)</td></tr><tr><td>unsigned long long atomicOr_system(unsigned long long* address, unsigned long long val)</td></tr><tr><td>int atomicXor(int* address, int val)</td></tr><tr><td>int atomicXor_system(int* address, int val)</td></tr><tr><td>unsigned int atomicXor(unsigned int* address,unsigned int val)</td></tr><tr><td>unsigned int atomicXor_system(unsigned int* address, unsigned int val)</td></tr><tr><td>unsigned long long atomicXor(unsigned long long* address,unsigned long long val)</td></tr><tr><td>unsigned long long atomicXor_system(unsigned long long* address, unsigned long long</td></tr><tr><td>val)</td></tr></tbody></table>
-<h2>19.13.1 Unsafe floating-point atomic RMW operations</h2>
-<p>Some HIP devices support fast atomic RMW operations on floating-point values. For example, atomicAdd on singleor double-precision floating-point values may generate a hardware RMW instruction that is faster than emulating the atomic operation using an atomic compare-and-swap (CAS) loop.</p>
-<p>On some devices, fast atomic RMW instructions can produce results that differ from the same functions implemented with atomic CAS loops. For example, some devices will use different rounding or denormal modes, and some devices produce incorrect answers if fast floating-point atomic RMW instructions target fine-grained memory allocations.</p>
-<p>The HIP-Clang compiler offers a compile-time option, so you can choose fast-but potentially unsafe-atomic instructions for your code. On devices that support these instructions, you can include the -munsafe-fp-atomics option. This flag indicates to the compiler that all floating-point atomic function calls are allowed to use an unsafe version, if one exists. For example, on some devices, this flag indicates to the compiler that no floating-point atomicAdd function can target fine-grained memory.</p>
-<p>If you want to avoid using unsafe use a floating-point atomic RMW operations, you can use the -mno-unsafe-fp-atomics option. Note that the compiler default is to not produce unsafe floating-point atomic RMW instructions, so the -mno-unsafe-fp-atomics option is not necessarily required. However, passing this option to the compiler is good practice.</p>
-<p>When you pass -munsafe-fp-atomics or -mno-unsafe-fp-atomics to the compiler's command line, the option is applied globally for the entire compilation. Note that if some of the atomic RMW function calls cannot safely use the faster floating-point atomic RMW instructions, you must use -mno-unsafe-fp-atomics in order to ensure that your atomic RMW function calls produce correct results.</p>
-<p>HIP has four extra functions that you can use to more precisely control which floating-point atomic RMW functions produce unsafe atomic RMW instructions:</p>
-<ul>
-<li style="list-style-type: '· ';">float unsafeAtomicAdd(float* address, float val)</li>
-<li style="list-style-type: '· ';">double unsafeAtomicAdd(double* address, double val) (Always produces fast atomic RMW instructions on devices that have them, even when -mno-unsafe-fp-atomics is used)</li>
-<li style="list-style-type: '· ';">float safeAtomicAdd(float* address, float val)</li>
-<li style="list-style-type: '· ';">double safeAtomicAdd(double* address, double val) (Always produces safe atomic RMW operations, even when -munsafe-fp-atomics is used)</li>
-</ul>
-<h2>19.14 Warp cross-lane functions</h2>
-<p>Threads in a warp are referred to as lanes and are numbered from 0 to warpSize - 1 . Warp cross-lane functions operate across all lanes in a warp. The hardware guarantees that all warp lanes will execute in lockstep, so additional synchronization is unnecessary, and the instructions use no shared memory.</p>
-<p>Note that NVIDIA and AMD devices have different warp sizes. You can use warpSize built-ins in you portable code to query the warp size.</p>
-<p>Tip: Be sure to review HIP code generated from the CUDA path to ensure that it doesn't assume a waveSize of 32. 'Wave-aware' code that assumes a waveSize of 32 can run on a wave-64 machine, but it only utilizes half of the machine's resources.</p>
-<p>To get the default warp size of a GPU device, use hipGetDeviceProperties in you host functions.</p>
-<p><strong>**Following code does:** This code snippet is a shell command that checks the version of the NVIDIA CUDA Compiler (nvcc) installed on the system. By executing `nvcc --version`, it outputs information about the installed version of nvcc, which is part of the CUDA toolkit used for compiling CUDA programs that run on NVIDIA GPUs.</strong></p>
-<pre><code>    cudaDeviceProp props;
-    cudaGetDeviceProperties(&props, deviceID);
-    int w = props.warpSize;
-    // implement portable algorithm based on w (rather than assume 32 or 64)</code></pre>
-<p>Only use warpSize built-ins in device functions, and don't assume warpSize to be a compile-time constant.</p>
-<p>Note that assembly kernels may be built for a warp size that is different from the default. All mask values either returned or accepted by these builtins are 64-bit unsigned integer values, even when compiled for a wave-32 device, where all the higher bits are unused. CUDA code ported to HIP requires changes to ensure that the correct type is used.</p>
-<p>Note that the __sync variants are made available in ROCm 6.2, but disabled by default to help with the transition to 64-bit masks. They can be enabled by setting the preprocessor macro HIP_ENABLE_WARP_SYNC_BUILTINS . These builtins will be enabled unconditionally in ROCm 6.3. Wherever possible, the implementation includes a static assert to check that the program source uses the correct type for the mask.</p>
-<h2>19.14.1 Warp vote and ballot functions</h2>
-<p><strong>**Following code does:** The code snippet provided appears to be a series of ASCII art arrows and lines, rather than functional code. It does not perform any computational tasks or have any executable logic. Its high-level purpose seems to be purely decorative or illustrative, possibly intended to visually represent directional arrows or boundaries.</strong></p>
-<pre><code>int __all(int predicate)
-int __any(int predicate)
-unsigned long long __ballot(int predicate)
-unsigned long long __activemask()
-
-int __all_sync(unsigned long long mask, int predicate)</code></pre>
-<p>(continued from previous page)</p>
-<p><strong>**Following code does:** This code snippet is a command-line instruction for compiling a HIP (Heterogeneous-Compute Interface for Portability) program using the NVIDIA CUDA Compiler (`nvcc`). The command is set to compile a source file located at `./HIP-Basic/saxpy/main.hip` into an executable named `saxpy`. It includes additional header files from the directories `./Common` and `/opt/rocm/include`. The `-O2` flag is used to optimize the code for better performance. The `-x cu` flag specifies that the input file is a CUDA source file. This setup is typically used for compiling GPU-accelerated applications that can run on both NVIDIA and AMD hardware using HIP.</strong></p>
-<pre><code><_Python_></code></pre>
-<p>You can use __any and __all to get a summary view of the predicates evaluated by the participating lanes.</p>
-<ul>
-<li style="list-style-type: '· ';">__any() : Returns 1 if the predicate is non-zero for any participating lane, otherwise it returns 0.</li>
-<li style="list-style-type: '· ';">__all() : Returns 1 if the predicate is non-zero for all participating lanes, otherwise it returns 0.</li>
-</ul>
-<p>To determine if the target platform supports the any/all instruction, you can use the hasWarpVote device property or the HIP_ARCH_HAS_WARP_VOTE compiler definition.</p>
-<p>__ballot returns a bit mask containing the 1-bit predicate value from each lane. The nth bit of the result contains the 1 bit contributed by the nth warp lane.</p>
-<p>__activemask() returns a bit mask of currently active warp lanes. The nth bit of the result is 1 if the nth warp lane is active.</p>
-<p>Note that the __ballot and __activemask builtins in HIP have a 64-bit return value (unlike the 32-bit value returned by the CUDA builtins). Code ported from CUDA should be adapted to support the larger warp sizes that the HIP version requires.</p>
-<p>Applications can test whether the target platform supports the __ballot or __activemask instructions using the hasWarpBallot device property in host code or the HIP_ARCH_HAS_WARP_BALLOT macro defined by the compiler for device code.</p>
-<p>The _sync variants require a 64-bit unsigned integer mask argument that specifies the lanes in the warp that will participate in cross-lane communication with the calling lane. Each participating thread must have its own bit set in its mask argument, and all active threads specified in any mask argument must execute the same call with the same mask, otherwise the result is undefined.</p>
-<h2>19.14.2 Warp match functions</h2>
-<p><strong>**Following code does:** This code snippet is a command to compile a C++ program using the `clang++` compiler. It specifically compiles a file named `main.hip` located in the `HIP-Basic\saxpy` directory into an executable named `saxpy.exe`. The command includes several options:
-
-- `-I.\Common`: Specifies an additional directory (`.\Common`) to search for header files.
-- `-lamdhip64`: Links against the `amdhip64` library, which is likely related to AMD's HIP (Heterogeneous-Compute Interface for Portability) framework.
-- `-L ${env:HIP_PATH}`: Adds the directory specified by the environment variable `HIP_PATH` to the library search path.
-- `-lib`: Indicates that the output should be a library (though this seems inconsistent with the `-o saxpy.exe` option for an executable).
-- `-02`: This appears to be a typo or misconfiguration; it might be intended to be `-O2`, which is an optimization flag for the compiler.
-
-Overall, the command is intended to compile a HIP-based C++ program, linking it with necessary libraries and including specific directories for headers and libraries.</strong></p>
-<pre><code>    unsigned long long __match_any(T value)
-    unsigned long long __match_all(T value, int *pred)
-
-    unsigned long long __match_any_sync(unsigned long long mask, T value)
-    unsigned long long __match_all_sync(unsigned long long mask, T value, int *pred)</code></pre>
-<p>T can be a 32-bit integer type, 64-bit integer type or a single precision or double precision floating point type.</p>
-<p>__match_any returns a bit mask containing a 1-bit for every participating lane if and only if that lane has the same value in value as the current lane, and a 0-bit for all other lanes.</p>
-<p>__match_all returns a bit mask containing a 1-bit for every participating lane if and only if they all have the same value in value as the current lane, and a 0-bit for all other lanes. The predicate pred is set to true if and only if all participating threads have the same value in value .</p>
-<p>The _sync variants require a 64-bit unsigned integer mask argument that specifies the lanes in the warp that will participate in cross-lane communication with the calling lane. Each participating thread must have its own bit set in its mask argument, and all active threads specified in any mask argument must execute the same call with the same mask, otherwise the result is undefined.</p>
-<h2>19.14.3 Warp shuffle functions</h2>
-<p>The default width is warpSize (see Warp cross-lane functions ). Half-float shuffles are not supported.</p>
-<p><strong>**Following code does:** The code snippet appears to be a command for compiling a HIP (Heterogeneous-Compute Interface for Portability) program using the `nvcc` compiler. The command is intended to compile a source file named `main.hip` located in the `saxpy` directory under `HIP-Basic`, and produce an executable named `saxpy.exe`. The command includes options to specify include directories (`-I ${env:HIP_PATH}include` and `-I.\Common`) and an optimization level (`-O2`). However, the snippet seems to be corrupted or improperly formatted, as it contains extraneous characters and symbols that do not form a valid command.</strong></p>
-<pre><code>            The default width is warpSize (see Warp cross-lane functions). Half-float shuffles are not supported.
-                                                                                                                                                                                                        
-                                                                                                                                                                                                      
-int       __shfl           (T var,     int srcLane,  int width=warpSize);</code></pre>
-<p>T can be a 32-bit integer type, 64-bit integer type or a single precision or double precision floating point type.</p>
-<p>The _sync variants require a 64-bit unsigned integer mask argument that specifies the lanes in the warp that will participate in cross-lane communication with the calling lane. Each participating thread must have its own bit set in its mask argument, and all active threads specified in any mask argument must execute the same call with the same mask, otherwise the result is undefined.</p>
-<h2>19.15 Cooperative groups functions</h2>
-<p>You can use cooperative groups to synchronize groups of threads. Cooperative groups also provide a way of communicating between groups of threads at a granularity that is different from the block.</p>
-<p>HIP supports the following kernel language cooperative groups types and functions:</p>
-<p><strong>**Following table contains:** The table represents a list of mathematical functions, likely from a programming library or API, with their descriptions and some form of validation or support status indicated by checkmarks. Each row corresponds to a specific function, detailing its return type, name, parameters, and a brief description of its purpose.
-
-The columns are as follows:
-- Column 0: Contains the function signature and description, specifying the return type, function name, parameters, and what the function does.
-- Column 1: Contains a checkmark (✓) indicating some form of validation, support, or availability status for the function.
-- Column 2: Similar to Column 1, it contains a checkmark (✓) which might indicate another aspect of validation, support, or availability.
-
-Noteworthy values:
-- All functions listed have a checkmark in Column 1, suggesting they all meet a certain criterion or are supported in a specific context.
-- Most functions also have a checkmark in Column 2, except for "float lgammaf(float x)", which lacks a checkmark in this column, indicating it might not meet the same criteria as the others or is not supported in the same context.</strong></p>
-<table><caption><div class="caption">Table 2: Cooperative groups functions</div></caption><tbody><tr><th>Function</th><th>Supported in HIP</th><th>Supported in CUDA</th></tr><tr><th>void thread_group.sync();</th><td>✓</td><td>✓</td></tr><tr><th>unsigned thread_group.size();</th><td>✓</td><td>✓</td></tr><tr><th>unsigned thread_group.thread_rank()</th><td>✓</td><td>✓</td></tr><tr><th>bool thread_group.is_valid();</th><td>✓</td><td>✓</td></tr><tr><th>grid_group this_grid()</th><td>✓</td><td>✓</td></tr><tr><th>void grid_group.sync()</th><td>✓</td><td>✓</td></tr><tr><th>unsigned grid_group.size()</th><td>✓</td><td>✓</td></tr><tr><th>unsigned grid_group.thread_rank()</th><td>✓</td><td>✓</td></tr><tr><th>bool grid_group.is_valid()</th><td>✓</td><td>✓</td></tr><tr><th>multi_grid_group this_multi_grid()</th><td>✓</td><td>✓</td></tr><tr><th>void multi_grid_group.sync()</th><td>✓</td><td>✓</td></tr><tr><th>unsigned multi_grid_group.size()</th><td>✓</td><td>✓</td></tr><tr><th>unsigned multi_grid_group.thread_rank()</th><td>✓</td><td>✓</td></tr><tr><th>bool multi_grid_group.is_valid()</th><td>✓</td><td>✓</td></tr><tr><th>unsigned multi_grid_group.num_grids()</th><td>✓</td><td>✓</td></tr><tr><th>unsigned multi_grid_group.grid_rank()</th><td>✓</td><td>✓</td></tr><tr><th>thread_block this_thread_block()</th><td>✓</td><td>✓</td></tr><tr><th>multi_grid_group this_multi_grid()</th><td>✓</td><td>✓</td></tr><tr><th>void multi_grid_group.sync()</th><td>✓</td><td>✓</td></tr><tr><th>void thread_block.sync()</th><td>✓</td><td>✓</td></tr><tr><th>unsigned thread_block.size()</th><td>✓</td><td>✓</td></tr><tr><th>unsigned thread_block.thread_rank()</th><td>✓</td><td>✓</td></tr><tr><th>bool thread_block.is_valid()</th><td>✓</td><td>✓</td></tr><tr><th>dim3 thread_block.group_index()</th><td>✓</td><td>✓</td></tr><tr><th>dim3 thread_block.thread_index()</th><td>✓</td><td>✓</td></tr></tbody></table>
-<p>For further information, check Cooperative Groups API or Cooperative Groups how to .</p>
-<h2>19.16 Warp matrix functions</h2>
-<p>Warp matrix functions allow a warp to cooperatively operate on small matrices that have elements spread over lanes in an unspecified manner.</p>
-<p>HIP does not support kernel language warp matrix types or functions.</p>
-<p><strong>**Following table contains:** The table appears to represent a hierarchical structure of topics related to computer architecture or programming optimization, possibly from a technical document or textbook. Each row represents a specific topic or subtopic, with indentation indicating the level of hierarchy.
-
-- **Column 0**: This column seems to contain section numbers or identifiers, which help in organizing the topics hierarchically. For example, "11.2" is a main topic, while "11.2.1" and "11.2.2" are subtopics under it.
-
-- **Column 1**: This column contains the main topic or subtopic names. For instance, "Memory" and "Optimization for maximum instruction throughput" are main topics, while "Data Transfer" and "Arithmetic instructions" are subtopics.
-
-- **Column 2**: This column provides a more detailed description or continuation of the topic names, often with ellipses indicating continuation or truncation.
-
-- **Column 3**: This column seems to contain numerical values, possibly page numbers or reference numbers, which are consistently around 70-72.
-
-Noteworthy values include the consistent numerical values in column 3, suggesting they might be page numbers from a document. The hierarchical structure indicated by the section numbers in column 0 and the indentation in column 1 suggests a detailed breakdown of topics, possibly for educational or reference purposes.</strong></p>
-<table><caption><div class="caption">Table 3: Warp matrix functions</div></caption><tbody><tr><th>Function</th><th>Sup- ported in HIP</th><th>Supported in CUDA</th></tr><tr><td>void load_matrix_sync(fragment&lt;...&gt; &amp;a, const T* mptr, unsigned lda)</td><td></td><td>✓</td></tr><tr><td>void load_matrix_sync(fragment&lt;...&gt; &amp;a, const T* mptr, unsigned lda, layout_t layout)</td><td></td><td>✓</td></tr><tr><td>void store_matrix_sync(T* mptr, fragment&lt;...&gt; &amp;a, unsigned lda, layout_t layout)</td><td></td><td>✓</td></tr><tr><td>void fill_fragment(fragment&lt;...&gt; &amp;a, const T &amp;value) void mma_sync(fragment&lt;...&gt; &amp;d, const fragment&lt;...&gt; &amp;a,</td><td></td><td>✓</td></tr><tr><td>const fragment&lt;...&gt; &amp;b, const fragment&lt;...&gt; &amp;c , bool sat)</td><td></td><td>✓</td></tr></tbody></table>
-<h2>19.17 Independent thread scheduling</h2>
-<p>Certain architectures that support CUDA allow threads to progress independently of each other. This independent thread scheduling makes intra-warp synchronization possible.</p>
-<p>HIP does not support this type of scheduling.</p>
-<h2>19.18 Profiler Counter Function</h2>
-<p>The CUDA __prof_trigger() instruction is not supported.</p>
-<h2>19.19 Assert</h2>
-<p>The assert function is supported in HIP. Assert function is used for debugging purpose, when the input expression equals to zero, the execution will be stopped.</p>
-<p><strong>**Following code does:** This code snippet appears to be a series of special characters and whitespace, but it does not represent any valid or meaningful Python code. It seems to be a random arrangement of symbols and spaces without any executable purpose or functionality in a programming context.</strong></p>
-<pre><code>|void assert(int ir</code></pre>
-<p><strong>**Following code does:** The code snippet `<_SQL_>` appears to be a placeholder or a tag indicating that the actual SQL code is not provided. Without the specific SQL code, it's not possible to determine its functionality. Typically, SQL code is used for interacting with databases, such as querying data, updating records, or managing database structures. If you have the actual SQL code, I can help explain its purpose.</strong></p>
-<pre><code>    input()</code></pre>
-<p>There are two kinds of implementations for assert functions depending on the use sceneries, - One is for the host version of assert, which is defined in assert.h , - Another is the device version of assert, which is implemented in hip/hip_runtime.h . Users need to include assert.h to use assert . For assert to work in both device and host functions, users need to include "hip/hip_runtime.h" .</p>
-<p>HIP provides the function abort() which can be used to terminate the application when terminal failures are detected. It is implemented using the __builtin_trap() function.</p>
-<p>This function produces a similar effect of using asm("trap") in the CUDA code.</p>
-<p>Note: In HIP, the function terminates the entire application, while in CUDA, asm("trap") only terminates the dispatch and the application continues to run.</p>
-<h2>19.20 printf</h2>
-<p>printf function is supported in HIP. The following is a simple example to print information in the kernel.</p>
-<p><strong>**Following code does:** The code snippet you've provided appears to be a command line instruction rather than a typical Python code snippet. It seems to be a command for a build or compilation tool, possibly related to a makefile or a build script. Here's a breakdown of its components:
-
-- `|` and `\` are shell operators. `|` is used for piping the output of one command into another, and `\` is used to escape characters or continue a command on the next line.
-- `roc-obj` could be a reference to a specific object file or a target within a build system.
-- `-t` and `-d` are likely flags or options for the command being executed.
-- `gfx803` might refer to a specific architecture or hardware target, possibly related to AMD's GCN (Graphics Core Next) architecture.
-- `./saxpy` suggests that the command is operating on or with a file or executable named `saxpy` in the current directory.
-
-Overall, this command seems to be part of a build process, possibly compiling or linking code for a specific hardware target.</strong></p>
-<pre><code>                                                                                                                                                                                                       
-#include <hip/hip_runtime.h>
-
-    __global__ void run_printf() { printf("Hello World\n"); }
-
-    int main() {
-      run_printf<<<dim3(1), dim3(1), 0, 0>>>();
-    }</code></pre>
-<h2>19.21 Device-Side Dynamic Global Memory Allocation</h2>
-<p>Device-side dynamic global memory allocation is under development. HIP now includes a preliminary implementation of malloc and free that can be called from device functions.</p>
-<h2>19.22 __launch_bounds__</h2>
-<p>GPU multiprocessors have a fixed pool of resources (primarily registers and shared memory) which are shared by the actively running warps. Using more resources can increase IPC of the kernel but reduces the resources available for other warps and limits the number of warps that can be simultaneously running. Thus GPUs have a complex relationship between resource usage and performance.</p>
-<p>__launch_bounds__ allows the application to provide usage hints that influence the resources (primarily registers) used by the generated code. It is a function attribute that must be attached to a __global__ function:</p>
-<p><strong>**Following code does:** The code snippet `<_XML_>` appears to be a placeholder or a tag, rather than actual executable Python code. It might be used in a larger context to denote a section where XML data or XML-related processing is expected. Without additional context or surrounding code, it does not perform any specific function or operation by itself.</strong></p>
-<pre><code><_Cython_></code></pre>
-<p>__launch_bounds__ supports two parameters: - MAX_THREADS_PER_BLOCK - The programmers guarantees that kernel will be launched with threads less than MAX_THREADS_PER_BLOCK. (On NVCC this maps to the . maxntid PTX directive). If no launch_bounds is specified, MAX_THREADS_PER_BLOCK is the maximum block size supported by the device (typically 1024 or larger). Specifying MAX_THREADS_PER_BLOCK less than the maximum effectively allows the compiler to use more resources than a default unconstrained compilation that supports all possible block sizes at launch time. The threads-per-block is the product of ( blockDim.x * blockDim. y * blockDim.z ). - MIN_WARPS_PER_EXECUTION_UNIT - directs the compiler to minimize resource usage so that the requested number of warps can be simultaneously active on a multi-processor. Since active warps compete for the same fixed pool of resources, the compiler must reduce resources required by each warp(primarily registers). MIN_WARPS_PER_EXECUTION_UNIT is optional and defaults to 1 if not specified. Specifying a MIN_WARPS_PER_EXECUTION_UNIT greater than the default 1 effectively constrains the compiler's resource usage.</p>
-<p>When launch kernel with HIP APIs, for example, hipModuleLaunchKernel() , HIP will do validation to make sure input kernel dimension size is not larger than specified launch_bounds. In case exceeded, HIP would return launch failure, if AMD_LOG_LEVEL is set with proper value (for details, please refer to docs/markdown/hip_logging. md ), detail information will be shown in the error log message, including launch parameters of kernel dim size, launch bounds, and the name of the faulting kernel. It's helpful to figure out which is the faulting kernel, besides, the kernel dim size and launch bounds values will also assist in debugging such failures.</p>
-<h2>19.22.1 Compiler Impact</h2>
-<p>The compiler uses these parameters as follows: - The compiler uses the hints only to manage register usage, and does not automatically reduce shared memory or other resources. - Compilation fails if compiler cannot generate a kernel which meets the requirements of the specified launch bounds. - From MAX_THREADS_PER_BLOCK, the compiler derives the maximum number of warps/block that can be used at launch time. Values of MAX_THREADS_PER_BLOCK less than the default allows the compiler to use a larger pool of registers : each warp uses registers, and this hint constrains the launch to a warps/block size which is less than maximum. - From MIN_WARPS_PER_EXECUTION_UNIT, the compiler derives a maximum number of registers that can be used by the kernel (to meet the required #simultaneous active blocks). If MIN_WARPS_PER_EXECUTION_UNIT is 1, then the kernel can use all registers supported by the multiprocessor. - The compiler ensures that the registers used in the kernel is less than both allowed maximums, typically by spilling registers (to shared or global memory), or by using more instructions. - The compiler may use heuristics to increase register usage, or may simply be able to avoid spilling. The MAX_THREADS_PER_BLOCK</p>
-<p>is particularly useful in this cases, since it allows the compiler to use more registers and avoid situations where the compiler constrains the register usage (potentially spilling) to meet the requirements of a large block size that is never used at launch time.</p>
-<h2>19.22.2 CU and EU Definitions</h2>
-<p>A compute unit (CU) is responsible for executing the waves of a work-group. It is composed of one or more execution units (EU) which are responsible for executing waves. An EU can have enough resources to maintain the state of more than one executing wave. This allows an EU to hide latency by switching between waves in a similar way to symmetric multithreading on a CPU. In order to allow the state for multiple waves to fit on an EU, the resources used by a single wave have to be limited. Limiting such resources can allow greater latency hiding, but can result in having to spill some register state to memory. This attribute allows an advanced developer to tune the number of waves that are capable of fitting within the resources of an EU. It can be used to ensure at least a certain number will fit to help hide latency, and can also be used to ensure no more than a certain number will fit to limit cache thrashing.</p>
-<h2>19.22.3 Porting from CUDA __launch_bounds</h2>
-<p>CUDA defines a __launch_bounds which is also designed to control occupancy:</p>
-<ul>
-<li>__launch_bounds(MAX_THREADS_PER_BLOCK, MIN_BLOCKS_PER_MULTIPROCESSOR)</li>
-<li style="list-style-type: '· ';">The second parameter __launch_bounds parameters must be converted to the format used __hip_launch_bounds, which uses warps and execution-units rather than blocks and multi-processors (this conversion is performed automatically by HIPIFY tools).</li>
-</ul>
-<p><strong>**Following code does:** This code snippet appears to be a collection of various symbols and characters arranged in a seemingly random manner. It does not form a valid or meaningful Python program. The arrangement of characters does not follow any recognizable syntax or structure that would perform a specific function or task in Python. Therefore, it does not have a high-level purpose or functionality.</strong></p>
-<pre><code>                                                                                                                                                                                                        | MIN_WARPS_PER_EXECUTION_UNIT  =  (MIN_BLOCKS_PER_MULTIPROCESSOR  *  MAX_THREADS_PER_BLOCK)  /_\                                                                                                                                                                                                       
-                                                                                                                                                                                                        :                                                                                                                                                                                                        --                                                                                                                                                                                                        <                                                                                                                                                                                                        </                                                                                                                                                                                                        >                                                                                                                                                                                                        }</code></pre>
-<p>The key differences in the interface are: - Warps (rather than blocks): The developer is trying to tell the compiler to control resource utilization to guarantee some amount of active Warps/EU for latency hiding. Specifying active warps in terms of blocks appears to hide the micro-architectural details of the warp size, but makes the interface more confusing since the developer ultimately needs to compute the number of warps to obtain the desired level of control. - Execution Units (rather than multiprocessor): The use of execution units rather than multiprocessors provides support for architectures with multiple execution units/multi-processor. For example, the AMD GCN architecture has 4 execution units per multiprocessor. The hipDeviceProps has a field executionUnitsPerMultiprocessor . Platform-specific coding techniques such as #ifdef can be used to specify different launch_bounds for NVCC and HIP-Clang platforms, if desired.</p>
-<h2>19.22.4 maxregcount</h2>
-<p>Unlike NVCC, HIP-Clang does not support the --maxregcount option. Instead, users are encouraged to use the hip_launch_bounds directive since the parameters are more intuitive and portable than micro-architecture details like registers, and also the directive allows per-kernel control rather than an entire file. hip_launch_bounds works on both HIP-Clang and NVCC targets.</p>
-<h2>19.23 Asynchronous Functions</h2>
-<h2>19.23.1 Memory stream</h2>
-<p>typedef void (* hipStreamCallback_t )(hipStream_t stream, hipError_t status, void *userData)</p>
-<p>Stream CallBack struct hipError_t hipStreamCreate ( hipStream_t *stream )</p>
-<p>Create an asynchronous stream.</p>
-<p>Create a new asynchronous stream. stream returns an opaque handle that can be used to reference the newly created stream in subsequent hipStream* commands. The stream is allocated on the heap and will remain allocated even if the handle goes out-of-scope. To release the memory used by the stream, application must call hipStreamDestroy.</p>
-<h2>See also:</h2>
-<p>hipStreamCreateWithFlags , hipStreamCreateWithPriority , hipStreamSynchronize , hipStreamWaitEvent , hipStreamDestroy</p>
-<h2>Parameters</h2>
-<p>stream -[inout] Valid pointer to hipStream_t. This function writes the memory with the newly created stream.</p>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue</p>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipError_t hipStreamCreateWithFlags ( hipStream_t *stream, unsigned int flags )</p>
-<p>Create an asynchronous stream.</p>
-<p>Create a new asynchronous stream. stream returns an opaque handle that can be used to reference the newly created stream in subsequent hipStream* commands. The stream is allocated on the heap and will remain allocated even if the handle goes out-of-scope. To release the memory used by the stream, application must call hipStreamDestroy. Flags controls behavior of the stream. See hipStreamDefault, hipStreamNonBlocking.</p>
-<h2>See also:</h2>
-<p>hipStreamCreate , hipStreamCreateWithPriority , hipStreamSynchronize , hipStreamWaitEvent , hipStreamDestroy</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">stream -[inout] Pointer to new stream</li>
-<li style="list-style-type: '· ';">flags -[in] to control stream creation.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue</p>
-<p>hipError_t hipStreamCreateWithPriority ( hipStream_t *stream, unsigned int flags, int priority )</p>
-<p>Create an asynchronous stream with the specified priority.</p>
-<p>Create a new asynchronous stream with the specified priority. stream returns an opaque handle that can be used to reference the newly created stream in subsequent hipStream* commands. The stream is allocated on the heap and will remain allocated even if the handle goes out-of-scope. To release the memory used by the stream, application must call hipStreamDestroy. Flags controls behavior of the stream. See hipStreamDefault, hipStreamNonBlocking.</p>
-<h2>See also:</h2>
-<p>hipStreamCreate , hipStreamSynchronize , hipStreamWaitEvent , hipStreamDestroy</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">stream -[inout] Pointer to new stream</li>
-<li style="list-style-type: '· ';">flags -[in] to control stream creation.</li>
-<li style="list-style-type: '· ';">priority -[in] of the stream. Lower numbers represent higher priorities.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipError_t hipDeviceGetStreamPriorityRange ( int *leastPriority, int *greatestPriority )</p>
-<p>Returns numerical values that correspond to the least and greatest stream priority.</p>
-<p>Returns in *leastPriority and *greatestPriority the numerical values that correspond to the least and greatest stream priority respectively. Stream priorities follow a convention where lower numbers imply greater priorities. The range of meaningful stream priorities is given by [*greatestPriority, *leastPriority]. If the user attempts to create a stream with a priority value that is outside the meaningful range as specified by this API, the priority is automatically clamped to within the valid range.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">leastPriority -[inout] pointer in which value corresponding to least priority is returned.</li>
-<li style="list-style-type: '· ';">greatestPriority -[inout] pointer in which value corresponding to greatest priority is returned.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess hipError_t hipStreamDestroy ( hipStream_t stream )</p>
-<p>Destroys the specified stream.</p>
-<p>Destroys the specified stream.</p>
-<p>If commands are still executing on the specified stream, some may complete execution before the queue is deleted.</p>
-<p>The queue may be destroyed while some commands are still inflight, or may wait for all commands queued to the stream before destroying it.</p>
-<h2>See also:</h2>
-<p>hipStreamCreate , hipStreamCreateWithFlags , hipStreamCreateWithPriority , hipStreamQuery , hipStreamWaitEvent , hipStreamSynchronize</p>
-<h2>Parameters</h2>
-<p>stream -[in] stream identifier.</p>
-<h2>Returns</h2>
-<p>hipSuccess hipErrorInvalidHandle</p>
-<h2>hipError_t hipStreamQuery ( hipStream_t stream )</h2>
-<p>Return hipSuccess if all of the operations in the specified stream have completed, or hipErrorNotReady if not.</p>
-<p>This is thread-safe and returns a snapshot of the current state of the queue. However, if other host threads are sending work to the stream, the status may change immediately after the function is called. It is typically used for debug.</p>
-<h2>See also:</h2>
-<p>hipStreamCreate , hipStreamCreateWithFlags , hipStreamCreateWithPriority , hipStreamWaitEvent , hipStreamSynchronize , hipStreamDestroy</p>
-<h2>Parameters</h2>
-<p>stream -[in] stream to query</p>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorNotReady, hipErrorInvalidHandle</p>
-<h2>hipError_t hipStreamSynchronize ( hipStream_t stream )</h2>
-<p>Wait for all commands in stream to complete.</p>
-<p>This command is host-synchronous : the host will block until the specified stream is empty.</p>
-<p>This command follows standard null-stream semantics. Specifically, specifying the null stream will cause the command to wait for other streams on the same device to complete all pending operations.</p>
-<p>This command honors the hipDeviceLaunchBlocking flag, which controls whether the wait is active or blocking.</p>
-<h2>See also:</h2>
-<p>hipStreamCreate , hipStreamCreateWithFlags , hipStreamCreateWithPriority , hipStreamWaitEvent , hipStreamDestroy</p>
-<h2>Parameters</h2>
-<p>stream -[in] stream identifier.</p>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidHandle</p>
-<p>hipError_t hipStreamWaitEvent ( hipStream_t stream, hipEvent_t event, unsigned int flags )</p>
-<p>Make the specified compute stream wait for an event.</p>
-<p>This function inserts a wait operation into the specified stream. All future work submitted to stream will wait until event reports completion before beginning execution.</p>
-<p>This function only waits for commands in the current stream to complete. Notably, this function does not implicitly wait for commands in the default stream to complete, even if the specified stream is created with hipStreamNonBlocking = 0.</p>
-<h2>See also:</h2>
-<p>hipStreamCreate , hipStreamCreateWithFlags , hipStreamCreateWithPriority , hipStreamSynchronize , hipStreamDestroy</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">stream -[in] stream to make wait.</li>
-<li style="list-style-type: '· ';">event -[in] event to wait on</li>
-<li style="list-style-type: '· ';">flags -[in] control operation [must be 0]</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidHandle hipError_t hipStreamGetFlags ( hipStream_t stream, unsigned int *flags )</p>
-<p>Return flags associated with this stream.</p>
-<p>Return flags associated with this stream in * flags .</p>
-<h2>See also:</h2>
-<p>hipStreamCreateWithFlags</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">stream -[in] stream to be queried</li>
-<li style="list-style-type: '· ';">flags -[inout] Pointer to an unsigned integer in which the stream's flags are returned</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorInvalidHandle</p>
-<h2>Returns</h2>
-<p>hipSuccess hipErrorInvalidValue hipErrorInvalidHandle hipError_t hipStreamGetPriority ( hipStream_t stream, int *priority )</p>
-<p>Query the priority of a stream.</p>
-<p>Query the priority of a stream. The priority is returned in in priority.</p>
-<h2>See also:</h2>
-<p>hipStreamCreateWithFlags</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">stream -[in] stream to be queried</li>
-<li style="list-style-type: '· ';">priority -[inout] Pointer to an unsigned integer in which the stream's priority is returned</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorInvalidHandle</p>
-<h2>Returns</h2>
-<p>hipSuccess hipErrorInvalidValue hipErrorInvalidHandle hipError_t hipStreamGetDevice ( hipStream_t stream, hipDevice_t *device )</p>
-<p>Get the device assocaited with the stream.</p>
-<h2>See also:</h2>
-<p>hipStreamCreate , hipStreamDestroy , hipDeviceGetStreamPriorityRange</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">stream -[in] stream to be queried</li>
-<li style="list-style-type: '· ';">device -[out] device associated with the stream</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorContextIsDestroyed, hipErrorInvalidHandle, hipErrorNotInitialized, hipErrorDeinitialized, hipErrorInvalidContext hipError_t hipExtStreamCreateWithCUMask ( hipStream_t *stream, uint32_t cuMaskSize, const uint32_t *cuMask )</p>
-<p>Create an asynchronous stream with the specified CU mask.</p>
-<p>Create a new asynchronous stream with the specified CU mask. stream returns an opaque handle that can be used to reference the newly created stream in subsequent hipStream* commands. The stream is allocated on the heap and will remain allocated even if the handle goes out-of-scope. To release the memory used by the stream, application must call hipStreamDestroy.</p>
-<h2>See also:</h2>
-<p>hipStreamCreate , hipStreamSynchronize , hipStreamWaitEvent , hipStreamDestroy</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">stream -[inout] Pointer to new stream</li>
-<li style="list-style-type: '· ';">cuMaskSize -[in] Size of CU mask bit array passed in.</li>
-<li style="list-style-type: '· ';">cuMask -[in] Bit-vector representing the CU mask. Each active bit represents using one CU. The first 32 bits represent the first 32 CUs, and so on. If its size is greater than physical CU number (i.e., multiProcessorCount member of hipDeviceProp_t), the extra elements are ignored. It is user's responsibility to make sure the input is meaningful.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidHandle, hipErrorInvalidValue hipError_t hipExtStreamGetCUMask ( hipStream_t stream, uint32_t cuMaskSize, uint32_t *cuMask )</p>
-<p>Get CU mask associated with an asynchronous stream.</p>
-<h2>See also:</h2>
-<p>hipStreamCreate , hipStreamSynchronize , hipStreamWaitEvent , hipStreamDestroy</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">stream -[in] stream to be queried</li>
-<li style="list-style-type: '· ';">cuMaskSize -[in] number of the block of memories (uint32_t *) allocated by user</li>
-<li style="list-style-type: '· ';">cuMask -[out] Pointer to a pre-allocated block of memories (uint32_t *) in which the stream's CU mask is returned. The CU mask is returned in a chunck of 32 bits where each active bit represents one active CU</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidHandle, hipErrorInvalidValue hipError_t hipStreamAddCallback ( hipStream_t stream, hipStreamCallback_t callback, void *userData, unsigned int flags )</p>
-<p>Adds a callback to be called on the host after all currently enqueued items in the stream have completed. For each hipStreamAddCallback call, a callback will be executed exactly once. The callback will block later work in the stream until it is finished.</p>
-<h2>See also:</h2>
-<p>hipStreamCreate , hipStreamCreateWithFlags , hipStreamQuery , hipStreamSynchronize , hipStreamWaitEvent , hipStreamDestroy , hipStreamCreateWithPriority</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">stream -[in] - Stream to add callback to</li>
-<li style="list-style-type: '· ';">callback -[in] - The function to call once preceding stream operations are complete</li>
-<li style="list-style-type: '· ';">userData -[in] - User specified data to be passed to the callback function</li>
-<li style="list-style-type: '· ';">flags -[in] - Reserved for future use, must be 0</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidHandle, hipErrorNotSupported static inline hipError_t hipMallocAsync ( void **dev_ptr, size_t size, hipMemPool_t mem_pool, hipStream_t stream )</p>
-<p>C++ wrappers for allocations from a memory pool.</p>
-<p>This section describes wrappers for stream Ordered allocation from memory pool functions of HIP runtime API.</p>
-<p>This is an alternate C++ calls for hipMallocFromPoolAsync made available through function overloading.</p>
-<h2>See also:</h2>
-<p>hipMallocFromPoolAsync</p>
-<p>Note: APIs in this section are implemented on Linux, under development on Windows.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<h2>template&lt;class T &gt;</h2>
-<p>static inline hipError_t hipMallocAsync ( T **dev_ptr, size_t size, hipMemPool_t mem_pool, hipStream_t stream C++ wrappers for allocations from a memory pool on the stream.</p>
-<p>This is an alternate C++ calls for hipMallocFromPoolAsync made available through function overloading.</p>
-<h2>See also:</h2>
-<p>hipMallocFromPoolAsync</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<h2>template&lt;class T &gt;</h2>
-<p>static inline hipError_t hipMallocAsync ( T **dev_ptr, size_t size, hipStream_t stream )</p>
-<p>C++ wrappers for allocations from a memory pool.</p>
-<p>This is an alternate C++ calls for hipMallocFromPoolAsync made available through function overloading.</p>
-<h2>See also:</h2>
-<p>hipMallocFromPoolAsync</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<h2>template&lt;class T &gt;</h2>
-<p>static inline hipError_t hipMallocFromPoolAsync ( T **dev_ptr, size_t size, hipMemPool_t mem_pool, hipStream_t stream )</p>
-<p>C++ wrappers for allocations from a memory pool.</p>
-<p>This is an alternate C++ calls for hipMallocFromPoolAsync made available through function overloading.</p>
-<h2>See also:</h2>
-<p>hipMallocFromPoolAsync</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>)</p>
-<p>hipError_t hipMallocAsync ( void **dev_ptr, size_t size, hipStream_t stream )</p>
-<p>Allocates memory with stream ordered semantics.</p>
-<p>Inserts a memory allocation operation into stream . A pointer to the allocated memory is returned immediately in *dptr. The allocation must not be accessed until the allocation operation completes. The allocation comes from the memory pool associated with the stream's device.</p>
-<h2>See also:</h2>
-<p>hipMallocFromPoolAsync , hipFreeAsync , hipMemPoolTrimTo , hipMemPoolGetAttribute , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess , hipMemPoolGetAccess</p>
-<p>Note: The default memory pool of a device contains device memory from that device.</p>
-<p>Note: Basic stream ordering allows future work submitted into the same stream to use the allocation. Stream query, stream synchronize, and HIP events can be used to guarantee that the allocation operation completes before work submitted in a separate stream runs.</p>
-<p>Note: During stream capture, this function results in the creation of an allocation node. In this case, the allocation is owned by the graph instead of the memory pool. The memory pool's properties are used to set the node's creation parameters.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dev_ptr -[out] Returned device pointer of memory allocation</li>
-<li style="list-style-type: '· ';">size -[in] Number of bytes to allocate</li>
-<li style="list-style-type: '· ';">stream -[in] The stream establishing the stream ordering contract and the memory pool to allocate from</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotSupported, hipErrorOutOfMemory hipError_t hipFreeAsync ( void *dev_ptr, hipStream_t stream )</p>
-<p>Frees memory with stream ordered semantics.</p>
-<p>Inserts a free operation into stream . The allocation must not be used after stream execution reaches the free. After this API returns, accessing the memory from any subsequent work launched on the GPU or querying its pointer attributes results in undefined behavior.</p>
-<h2>See also:</h2>
-<p>hipMallocFromPoolAsync , hipMallocAsync , hipMemPoolTrimTo , hipMemPoolGetAttribute , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess , hipMemPoolGetAccess</p>
-<p>Note: During stream capture, this function results in the creation of a free node and must therefore be passed the address of a graph allocation.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dev_ptr -[in] Pointer to device memory to free</li>
-<li style="list-style-type: '· ';">stream -[in] The stream, where the destruciton will occur according to the execution order</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError_t hipMemPoolTrimTo ( hipMemPool_t mem_pool, size_t min_bytes_to_hold )</p>
-<p>Releases freed memory back to the OS.</p>
-<p>Releases memory back to the OS until the pool contains fewer than min_bytes_to_keep reserved bytes, or there is no more memory that the allocator can safely release. The allocator cannot release OS allocations that back outstanding asynchronous allocations. The OS allocations may happen at different granularity from the user allocations.</p>
-<h2>See also:</h2>
-<p>hipMallocFromPoolAsync , hipMallocAsync , hipFreeAsync , hipMemPoolGetAttribute , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess , hipMemPoolGetAccess</p>
-<p>Note: Allocations that have not been freed count as outstanding.</p>
-<p>Note: Allocations that have been asynchronously freed but whose completion has not been observed on the host (eg. by a synchronize) can count as outstanding.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">mem_pool -[in] The memory pool to trim allocations</li>
-<li style="list-style-type: '· ';">min_bytes_to_hold -[in] If the pool has less than min_bytes_to_hold reserved, then the TrimTo operation is a no-op. Otherwise the memory pool will contain at least min_bytes_to_hold bytes reserved after the operation.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipError_t hipMemPoolSetAttribute ( hipMemPool_t mem_pool, hipMemPoolAttr attr, void *value )</p>
-<p>Sets attributes of a memory pool.</p>
-<p>Supported attributes are:</p>
-<ul>
-<li style="list-style-type: '· ';">hipMemPoolAttrReleaseThreshold: (value type = cuuint64_t) Amount of reserved memory in bytes to hold onto before trying to release memory back to the OS. When more than the release threshold bytes of memory are held by the memory pool, the allocator will try to release memory back to the OS on the next call to stream, event or context synchronize. (default 0)</li>
-<li style="list-style-type: '· ';">hipMemPoolReuseFollowEventDependencies: (value type = int) Allow hipMallocAsync to use memory asynchronously freed in another stream as long as a stream ordering dependency of the allocating stream on the free action exists. HIP events and null stream interactions can create the required stream ordered dependencies. (default enabled)</li>
-<li style="list-style-type: '· ';">hipMemPoolReuseAllowOpportunistic: (value type = int) Allow reuse of already completed frees when there is no dependency between the free and allocation. (default enabled)</li>
-<li style="list-style-type: '· ';">hipMemPoolReuseAllowInternalDependencies: (value type = int) Allow hipMallocAsync to insert new stream dependencies in order to establish the stream ordering required to reuse a piece of memory released by hipFreeAsync (default enabled).</li>
-</ul>
-<h2>See also:</h2>
-<p>hipMallocFromPoolAsync , hipMallocAsync , hipFreeAsync , hipMemPoolGetAttribute , hipMemPoolTrimTo , hipDeviceSetMemPool, hipMemPoolSetAccess , hipMemPoolGetAccess</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">mem_pool -[in] The memory pool to modify</li>
-<li style="list-style-type: '· ';">attr -[in] The attribute to modify</li>
-<li style="list-style-type: '· ';">value -[in] Pointer to the value to assign</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue</p>
-<p>hipError_t hipMemPoolGetAttribute ( hipMemPool_t mem_pool, hipMemPoolAttr attr, void *value )</p>
-<p>Gets attributes of a memory pool.</p>
-<p>Supported attributes are:</p>
-<ul>
-<li style="list-style-type: '· ';">hipMemPoolAttrReleaseThreshold: (value type = cuuint64_t) Amount of reserved memory in bytes to hold onto before trying to release memory back to the OS. When more than the release threshold bytes of memory are held by the memory pool, the allocator will try to release memory back to the OS on the next call to stream, event or context synchronize. (default 0)</li>
-<li style="list-style-type: '· ';">hipMemPoolReuseFollowEventDependencies: (value type = int) Allow hipMallocAsync to use memory asynchronously freed in another stream as long as a stream ordering dependency of the allocating stream on the free action exists. HIP events and null stream interactions can create the required stream ordered dependencies. (default enabled)</li>
-<li style="list-style-type: '· ';">hipMemPoolReuseAllowOpportunistic: (value type = int) Allow reuse of already completed frees when there is no dependency between the free and allocation. (default enabled)</li>
-<li style="list-style-type: '· ';">hipMemPoolReuseAllowInternalDependencies: (value type = int) Allow hipMallocAsync to insert new stream dependencies in order to establish the stream ordering required to reuse a piece of memory released by hipFreeAsync (default enabled).</li>
-</ul>
-<h2>See also:</h2>
-<p>hipMallocFromPoolAsync , hipMallocAsync , hipFreeAsync , hipMemPoolTrimTo , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess , hipMemPoolGetAccess</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">mem_pool -[in] The memory pool to get attributes of</li>
-<li style="list-style-type: '· ';">attr -[in] The attribute to get</li>
-<li style="list-style-type: '· ';">value -[in] Retrieved value</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipError_t hipMemPoolSetAccess ( hipMemPool_t mem_pool, const hipMemAccessDesc *desc_list, size_t count ) Controls visibility of the specified pool between devices.</p>
-<h2>See also:</h2>
-<p>hipMallocFromPoolAsync , hipMallocAsync , hipFreeAsync , hipMemPoolGetAttribute , hipMemPoolTrimTo , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolGetAccess</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">mem_pool -[in] Memory pool for acccess change</li>
-<li style="list-style-type: '· ';">desc_list -[in] Array of access descriptors. Each descriptor instructs the access to enable for a single gpu</li>
-<li style="list-style-type: '· ';">count -[in] Number of descriptors in the map array.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipError_t hipMemPoolGetAccess ( hipMemAccessFlags *flags, hipMemPool_t mem_pool, hipMemLocation *location )</p>
-<p>Returns the accessibility of a pool from a device.</p>
-<p>Returns the accessibility of the pool's memory from the specified location.</p>
-<h2>See also:</h2>
-<p>hipMallocFromPoolAsync , hipMallocAsync , hipFreeAsync , hipMemPoolGetAttribute , hipMemPoolTrimTo , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">flags -[out] Accessibility of the memory pool from the specified location/device</li>
-<li style="list-style-type: '· ';">mem_pool -[in] Memory pool being queried</li>
-<li style="list-style-type: '· ';">location -[in] Location/device for memory pool access</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipError_t hipMemPoolCreate ( hipMemPool_t *mem_pool, const hipMemPoolProps *pool_props )</p>
-<p>Creates a memory pool.</p>
-<p>Creates a HIP memory pool and returns the handle in mem_pool . The pool_props determines the properties of the pool such as the backing device and IPC capabilities.</p>
-<p>By default, the memory pool will be accessible from the device it is allocated on.</p>
-<h2>See also:</h2>
-<p>hipMallocFromPoolAsync , hipMallocAsync , hipFreeAsync , hipMemPoolGetAttribute , hipMemPoolDestroy , hipMemPoolTrimTo , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess , hipMemPoolGetAccess</p>
-<p>Note: Specifying hipMemHandleTypeNone creates a memory pool that will not support IPC.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">mem_pool -[out] Contains createed memory pool</li>
-<li style="list-style-type: '· ';">pool_props -[in] Memory pool properties</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError_t hipMemPoolDestroy ( hipMemPool_t mem_pool )</p>
-<p>Destroys the specified memory pool.</p>
-<p>If any pointers obtained from this pool haven't been freed or the pool has free operations that haven't completed when hipMemPoolDestroy is invoked, the function will return immediately and the resources associated with the pool will be released automatically once there are no more outstanding allocations.</p>
-<p>Destroying the current mempool of a device sets the default mempool of that device as the current mempool for that device.</p>
-<h2>See also:</h2>
-<p>hipMallocFromPoolAsync , hipMallocAsync , hipFreeAsync , hipMemPoolGetAttribute , hipMemPoolCreate hipMemPoolTrimTo , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess , hipMemPoolGetAccess</p>
-<p>Note: A device's default memory pool cannot be destroyed.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<p>mem_pool -[in] Memory pool for destruction</p>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipError_t void **dev_ptr, size_t size, hipMemPool_t mem_pool, hipStream_t stream</p>
-<p>hipMallocFromPoolAsync ( ) Allocates memory from a specified pool with stream ordered semantics.</p>
-<p>Inserts an allocation operation into stream . A pointer to the allocated memory is returned immediately in dev_ptr . The allocation must not be accessed until the allocation operation completes. The allocation comes from the specified memory pool.</p>
-<p>Basic stream ordering allows future work submitted into the same stream to use the allocation. Stream query, stream synchronize, and HIP events can be used to guarantee that the allocation operation completes before work submitted in a separate stream runs.</p>
-<h2>See also:</h2>
-<p>hipMallocAsync , hipFreeAsync , hipMemPoolGetAttribute , hipMemPoolCreate hipMemPoolTrimTo , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess , hipMemPoolGetAccess ,</p>
-<p>Note: The specified memory pool may be from a device different than that of the specified stream .</p>
-<p>Note: During stream capture, this function results in the creation of an allocation node. In this case, the allocation is owned by the graph instead of the memory pool. The memory pool's properties are used to set the node's creation parameters.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dev_ptr -[out] Returned device pointer</li>
-<li style="list-style-type: '· ';">size -[in] Number of bytes to allocate</li>
-<li style="list-style-type: '· ';">mem_pool -[in] The pool to allocate from</li>
-<li style="list-style-type: '· ';">stream -[in] The stream establishing the stream ordering semantic</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotSupported, hipErrorOutOfMemory hipError_t hipMemPoolExportToShareableHandle ( void *shared_handle, hipMemPool_t mem_pool, hipMemAllocationHandleType handle_type, unsigned int flags )</p>
-<p>Exports a memory pool to the requested handle type.</p>
-<p>Given an IPC capable mempool, create an OS handle to share the pool with another process. A recipient process can convert the shareable handle into a mempool with hipMemPoolImportFromShareableHandle . Individual pointers can then be shared with the hipMemPoolExportPointer and hipMemPoolImportPointer APIs. The implementation of what the shareable handle is and how it can be transferred is defined by the requested handle type.</p>
-<h2>See also:</h2>
-<p>hipMemPoolImportFromShareableHandle</p>
-<p>Note: To create an IPC capable mempool, create a mempool with a hipMemAllocationHandleType other than hipMemHandleTypeNone .</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">shared_handle -[out] Pointer to the location in which to store the requested handle</li>
-<li style="list-style-type: '· ';">mem_pool -[in] Pool to export</li>
-<li style="list-style-type: '· ';">handle_type -[in] The type of handle to create</li>
-<li style="list-style-type: '· ';">flags -[in] Must be 0</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorOutOfMemory hipError_t hipMemPoolImportFromShareableHandle ( hipMemPool_t *mem_pool, void *shared_handle, hipMemAllocationHandleType handle_type, unsigned int flags )</p>
-<p>Imports a memory pool from a shared handle.</p>
-<p>Specific allocations can be imported from the imported pool with hipMemPoolImportPointer .</p>
-<h2>See also:</h2>
-<p>hipMemPoolExportToShareableHandle</p>
-<p>Note: Imported memory pools do not support creating new allocations. As such imported memory pools may not be used in hipDeviceSetMemPool or hipMallocFromPoolAsync calls.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">mem_pool -[out] Returned memory pool</li>
-<li style="list-style-type: '· ';">shared_handle -[in] OS handle of the pool to open</li>
-<li style="list-style-type: '· ';">handle_type -[in] The type of handle being imported</li>
-<li style="list-style-type: '· ';">flags -[in] Must be 0</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorOutOfMemory hipError_t hipMemPoolExportPointer ( hipMemPoolPtrExportData *export_data, void *dev_ptr )</p>
-<p>Export data to share a memory pool allocation between processes.</p>
-<p>Constructs export_data for sharing a specific allocation from an already shared memory pool. The recipient process can import the allocation with the hipMemPoolImportPointer api. The data is not a handle and may be shared through any IPC mechanism.</p>
-<h2>See also:</h2>
-<p>hipMemPoolImportPointer</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">export_data -[out] Returned export data</li>
-<li style="list-style-type: '· ';">dev_ptr -[in] Pointer to memory being exported</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorOutOfMemory hipError_t hipMemPoolImportPointer ( void **dev_ptr, hipMemPool_t mem_pool, hipMemPoolPtrExportData *export_data )</p>
-<p>Import a memory pool allocation from another process.</p>
-<p>Returns in dev_ptr a pointer to the imported memory. The imported memory must not be accessed before the allocation operation completes in the exporting process. The imported memory must be freed from all importing processes before being freed in the exporting process. The pointer may be freed with hipFree or hipFreeAsync . If hipFreeAsync is used, the free must be completed on the importing process before the free operation on the exporting process.</p>
-<h2>See also:</h2>
-<p>hipMemPoolExportPointer</p>
-<p>Note: The hipFreeAsync api may be used in the exporting process before the hipFreeAsync operation completes in its stream as long as the hipFreeAsync in the exporting process specifies a stream with a stream dependency on the importing process's hipFreeAsync .</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dev_ptr -[out] Pointer to imported memory</li>
-<li style="list-style-type: '· ';">mem_pool -[in] Memory pool from which to import a pointer</li>
-<li style="list-style-type: '· ';">export_data -[in] Data specifying the memory to import</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized, hipErrorOutOfMemory</p>
-<h2>19.23.2 Peer to peer</h2>
-<p>hipError_t hipDeviceCanAccessPeer ( int *canAccessPeer, int deviceId, int peerDeviceId )</p>
-<p>Determine if a device can access a peer's memory.</p>
-<p>Returns '1' in canAccessPeer if the specified device is capable of directly accessing memory physically located on peerDevice , or '0' if not.</p>
-<p>Returns '0' in canAccessPeer if deviceId == peerDeviceId, and both are valid devices : a device is not a peer of itself.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">canAccessPeer -[out] Returns the peer access capability (0 or 1)</li>
-<li style="list-style-type: '· ';">deviceId -[in] - device from where memory may be accessed.</li>
-<li style="list-style-type: '· ';">peerDeviceId -[in] - device where memory is physically located</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess,</p>
-<h2>Returns</h2>
-<p>hipErrorInvalidDevice if deviceId or peerDeviceId are not valid devices hipError_t hipDeviceEnablePeerAccess ( int peerDeviceId, unsigned int flags )</p>
-<p>Enable direct access from current device's virtual address space to memory allocations physically located on a peer device.</p>
-<p>Memory which already allocated on peer device will be mapped into the address space of the current device. In addition, all future memory allocations on peerDeviceId will be mapped into the address space of the current device when the memory is allocated. The peer memory remains accessible from the current device until a call to hipDeviceDisablePeerAccess or hipDeviceReset.</p>
-<p>Returns hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue,</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">peerDeviceId -[in] Peer device to enable direct access to from the current device</li>
-<li style="list-style-type: '· ';">flags -[in] Reserved for future use, must be zero</li>
-</ul>
-<h2>Returns</h2>
-<p>hipErrorPeerAccessAlreadyEnabled if peer access is already enabled for this device.</p>
-<h2>hipError_t hipDeviceDisablePeerAccess ( int peerDeviceId )</h2>
-<p>Disable direct access from current device's virtual address space to memory allocations physically located on a peer device.</p>
-<p>Returns hipErrorPeerAccessNotEnabled if direct access to memory on peerDevice has not yet been enabled from the current device.</p>
-<h2>Parameters</h2>
-<p>peerDeviceId -[in] Peer device to disable direct access to</p>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorPeerAccessNotEnabled hipError_t hipMemGetAddressRange ( hipDeviceptr_t *pbase, size_t *psize, hipDeviceptr_t dptr )</p>
-<p>Get information on memory allocations.</p>
-<h2>See also:</h2>
-<p>hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent, hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">pbase -[out] - BAse pointer address</li>
-<li style="list-style-type: '· ';">psize -[out] - Size of allocation</li>
-<li style="list-style-type: '· ';">dptr--[in] Device Pointer</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorNotFound</p>
-<h2>USE_PEER_NON_UNIFIED</h2>
-<h2>19.23.3 Memory management</h2>
-<p>hipError_t hipPointerSetAttribute ( const void *value, hipPointer_attribute attribute, hipDeviceptr_t ptr )</p>
-<p>Sets information on the specified pointer.[BETA].</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">value -[in] Sets pointer attribute value</li>
-<li style="list-style-type: '· ';">attribute -[in] Attribute to set</li>
-<li style="list-style-type: '· ';">ptr -[in] Pointer to set attributes for</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError_t hipPointerGetAttributes ( hipPointerAttribute_t *attributes, const void *ptr )</p>
-<p>Returns attributes for the specified pointer.</p>
-<p>The output parameter 'attributes' has a member named 'type' that describes what memory the pointer is associated with, such as device memory, host memory, managed memory, and others. Otherwise, the API cannot handle the pointer and returns hipErrorInvalidValue.</p>
-<h2>See also:</h2>
-<p>hipPointerGetAttribute</p>
-<p>Note: The unrecognized memory type is unsupported to keep the HIP functionality backward compatibility due to hipMemoryType enum values.</p>
-<p>Note: The current behavior of this HIP API corresponds to the CUDA API before version 11.0.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">attributes -[out] attributes for the specified pointer</li>
-<li style="list-style-type: '· ';">ptr -[in] pointer to get attributes for</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError_t hipPointerGetAttribute ( void *data, hipPointer_attribute attribute, hipDeviceptr_t ptr ) Returns information about the specified pointer.[BETA].</p>
-<h2>See also:</h2>
-<p>hipPointerGetAttributes</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">data -[inout] Returned pointer attribute value</li>
-<li style="list-style-type: '· ';">attribute -[in] Attribute to query for</li>
-<li style="list-style-type: '· ';">ptr -[in] Pointer to get attributes for</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError_t hipDrvPointerGetAttributes ( unsigned int numAttributes, hipPointer_attribute *attributes, void **data, hipDeviceptr_t ptr )</p>
-<p>Returns information about the specified pointer.[BETA].</p>
-<h2>See also:</h2>
-<p>hipPointerGetAttribute</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">numAttributes -[in] number of attributes to query for</li>
-<li style="list-style-type: '· ';">attributes -[in] attributes to query for</li>
-<li style="list-style-type: '· ';">data -[inout] a two-dimensional containing pointers to memory locations where the result of each attribute query will be written to</li>
-<li style="list-style-type: '· ';">ptr -[in] pointer to get attributes for</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError_t hipMalloc ( void **ptr, size_t size )</p>
-<p>Allocate memory on the default accelerator.</p>
-<p>If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.</p>
-<h2>See also:</h2>
-<p>hipMallocPitch , hipFree , hipMallocArray , hipFreeArray , hipMalloc3D , hipMalloc3DArray , hipHostFree , hipHostMalloc</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">ptr -[out] Pointer to the allocated memory</li>
-<li style="list-style-type: '· ';">size -[in] Requested memory size</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorOutOfMemory, hipErrorInvalidValue (bad context, null *ptr)</p>
-<p>hipError_t hipExtMallocWithFlags ( void **ptr, size_t sizeBytes, unsigned int flags )</p>
-<p>Allocate memory on the default accelerator.</p>
-<p>If requested memory size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.</p>
-<p>The memory allocation flag should be either hipDeviceMallocDefault, hipDeviceMallocFinegrained, hipDeviceMallocUncached, or hipMallocSignalMemory. If the flag is any other value, the API returns hipErrorInvalidValue.</p>
-<h2>See also:</h2>
-<p>hipMallocPitch , hipFree , hipMallocArray , hipFreeArray , hipMalloc3D , hipMalloc3DArray , hipHostFree , hipHostMalloc</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">ptr -[out] Pointer to the allocated memory</li>
-<li style="list-style-type: '· ';">sizeBytes -[in] Requested memory size</li>
-<li style="list-style-type: '· ';">flags -[in] Type of memory allocation</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorOutOfMemory, hipErrorInvalidValue (bad context, null *ptr)</p>
-<p>hipError_t hipMallocHost ( void **ptr, size_t size )</p>
-<p>Allocate pinned host memory [Deprecated].</p>
-<p>If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.</p>
-<p>Warning:</p>
-<p><strong>**Following code does:** The code snippet is a shell command that lists files in the current directory with names starting with "main-hip-amdgcn-amd-amdhsa-" and ending with any extension. The output shows a list of files that match this pattern, indicating that these files are likely related to a project or build process involving AMD GPU architecture (specifically the GFX803 series) and the HIP (Heterogeneous-Compute Interface for Portability) platform. The files have various extensions, suggesting they are different types of build artifacts, such as bytecode (.bc), object files (.o), assembly (.s), and output files (.out).</strong></p>
-<pre><code>
-
-arning:   This API is deprecated, use hipHostMalloc() instead</code></pre>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">ptr -[out] Pointer to the allocated host pinned memory</li>
-<li style="list-style-type: '· ';">size -[in] Requested memory size</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorOutOfMemory</p>
-<h2>hipError_t hipMemAllocHost ( void **ptr, size_t size )</h2>
-<p>Allocate pinned host memory [Deprecated].</p>
-<p>If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.</p>
-<p>Warning: This API is deprecated, use hipHostMalloc() instead</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">ptr -[out] Pointer to the allocated host pinned memory</li>
-<li style="list-style-type: '· ';">size -[in] Requested memory size</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorOutOfMemory hipError_t hipHostMalloc ( void **ptr, size_t size, unsigned int flags )</p>
-<p>Allocates device accessible page locked (pinned) host memory.</p>
-<p>This API allocates pinned host memory which is mapped into the address space of all GPUs in the system, the memory can be accessed directly by the GPU device, and can be read or written with much higher bandwidth than pageable memory obtained with functions such as malloc().</p>
-<p>Using the pinned host memory, applications can implement faster data transfers for HostToDevice and DeviceToHost. The runtime tracks the hipHostMalloc allocations and can avoid some of the setup required for regular unpinned memory.</p>
-<p>When the memory accesses are infrequent, zero-copy memory can be a good choice, for coherent allocation. GPU can directly access the host memory over the CPU/GPU interconnect, without need to copy the data.</p>
-<p>Currently the allocation granularity is 4KB for the API.</p>
-<p>Developers need to choose proper allocation flag with consideration of synchronization.</p>
-<p>If no input for flags, it will be the default pinned memory allocation on the host.</p>
-<h2>See also:</h2>
-<p>hipSetDeviceFlags, hipHostFree</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">ptr -[out] Pointer to the allocated host pinned memory</li>
-<li style="list-style-type: '· ';">size -[in] Requested memory size in bytes If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.</li>
-<li style="list-style-type: '· ';">flags -[in] Type of host memory allocation. See the description of flags in hipSetDeviceFlags.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorOutOfMemory hipError_t hipHostAlloc ( void **ptr, size_t size, unsigned int flags )</p>
-<p>Allocate device accessible page locked host memory [Deprecated].</p>
-<p>If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.</p>
-<p>Warning: This API is deprecated, use hipHostMalloc() instead</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">ptr -[out] Pointer to the allocated host pinned memory</li>
-</ul>
-<ul>
-<li style="list-style-type: '· ';">size -[in] Requested memory size in bytes</li>
-<li style="list-style-type: '· ';">flags -[in] Type of host memory allocation</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorOutOfMemory hipError_t hipHostGetDevicePointer ( void **devPtr, void *hstPtr, unsigned int flags )</p>
-<p>Get Device pointer from Host Pointer allocated through hipHostMalloc.</p>
-<h2>See also:</h2>
-<p>hipSetDeviceFlags, hipHostMalloc</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">devPtr -[out] Device Pointer mapped to passed host pointer</li>
-<li style="list-style-type: '· ';">hstPtr -[in] Host Pointer allocated through hipHostMalloc</li>
-<li style="list-style-type: '· ';">flags -[in] Flags to be passed for extension</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorOutOfMemory hipError_t hipHostGetFlags ( unsigned int *flagsPtr, void *hostPtr )</p>
-<p>Return flags associated with host pointer.</p>
-<h2>See also:</h2>
-<h2>hipHostMalloc</h2>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">flagsPtr -[out] Memory location to store flags</li>
-<li style="list-style-type: '· ';">hostPtr -[in] Host Pointer allocated through hipHostMalloc</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipError_t hipHostRegister ( void *hostPtr, size_t sizeBytes, unsigned int flags )</p>
-<p>Register host memory so it can be accessed from the current device.</p>
-<h2>Flags:</h2>
-<ul>
-<li style="list-style-type: '· ';">hipHostRegisterDefault Memory is Mapped and Portable</li>
-<li style="list-style-type: '· ';">hipHostRegisterPortable Memory is considered registered by all contexts. HIP only supports one context so this is always assumed true.</li>
-<li style="list-style-type: '· ';">hipHostRegisterMapped Map the allocation into the address space for the current device. The device pointer can be obtained with hipHostGetDevicePointer .</li>
-</ul>
-<p>After registering the memory, use hipHostGetDevicePointer to obtain the mapped device pointer. On many systems, the mapped device pointer will have a different value than the mapped host pointer. Applications must use the device pointer in device code, and the host pointer in host code.</p>
-<p>On some systems, registered memory is pinned. On some systems, registered memory may not be actually be pinned but uses OS or hardware facilities to all GPU access to the host memory.</p>
-<p>Developers are strongly encouraged to register memory blocks which are aligned to the host cache-line size. (typically 64-bytes but can be obtains from the CPUID instruction).</p>
-<p>If registering non-aligned pointers, the application must take care when register pointers from the same cache line on different devices. HIP's coarse-grained synchronization model does not guarantee correct results if different devices write to different parts of the same cache block - typically one of the writes will 'win' and overwrite data from the other registered memory region.</p>
-<h2>See also:</h2>
-<p>hipHostUnregister , hipHostGetFlags , hipHostGetDevicePointer</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">hostPtr -[out] Pointer to host memory to be registered.</li>
-<li style="list-style-type: '· ';">sizeBytes -[in] Size of the host memory</li>
-<li style="list-style-type: '· ';">flags -[in] See below.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorOutOfMemory hipError_t hipHostUnregister ( void *hostPtr )</p>
-<p>Un-register host pointer.</p>
-<h2>See also:</h2>
-<p>hipHostRegister</p>
-<h2>Parameters</h2>
-<p>hostPtr -[in] Host pointer previously registered with hipHostRegister</p>
-<h2>Returns</h2>
-<p>Error code hipError_t hipMallocPitch ( void **ptr, size_t *pitch, size_t width, size_t height )</p>
-<p>Allocates at least width (in bytes) * height bytes of linear memory Padding may occur to ensure alighnment requirements are met for the given row The change in width size due to padding will be returned in *pitch. Currently the alignment is set to 128 bytes</p>
-<p>If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.</p>
-<h2>See also:</h2>
-<p>hipMalloc , hipFree , hipMallocArray , hipFreeArray , hipHostFree , hipMalloc3D , hipMalloc3DArray , hipHostMalloc</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">ptr -[out] Pointer to the allocated device memory</li>
-</ul>
-<ul>
-<li style="list-style-type: '· ';">pitch -[out] Pitch for allocation (in bytes)</li>
-<li style="list-style-type: '· ';">width -[in] Requested pitched allocation width (in bytes)</li>
-<li style="list-style-type: '· ';">height -[in] Requested pitched allocation height</li>
-</ul>
-<h2>Returns</h2>
-<p>Error code hipError_t hipMemAllocPitch ( hipDeviceptr_t *dptr, size_t *pitch, size_t widthInBytes, size_t height, unsigned int elementSizeBytes )</p>
-<p>Allocates at least width (in bytes) * height bytes of linear memory Padding may occur to ensure alighnment requirements are met for the given row The change in width size due to padding will be returned in *pitch. Currently the alignment is set to 128 bytes</p>
-<p>If size is 0, no memory is allocated, ptr returns nullptr, and hipSuccess is returned. The intended usage of pitch is as a separate parameter of the allocation, used to compute addresses within the 2D array. Given the row and column of an array element of type T, the address is computed as: T pElement = (T*)((char*)BaseAddress + Row * Pitch) + Column;</p>
-<h2>See also:</h2>
-<p>hipMalloc , hipFree , hipMallocArray , hipFreeArray , hipHostFree , hipMalloc3D , hipMalloc3DArray , hipHostMalloc</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dptr -[out] Pointer to the allocated device memory</li>
-<li style="list-style-type: '· ';">pitch -[out] Pitch for allocation (in bytes)</li>
-<li style="list-style-type: '· ';">widthInBytes -[in] Requested pitched allocation width (in bytes)</li>
-<li style="list-style-type: '· ';">height -[in] Requested pitched allocation height</li>
-<li style="list-style-type: '· ';">elementSizeBytes -[in] The size of element bytes, should be 4, 8 or 16</li>
-</ul>
-<h2>Returns</h2>
-<p>Error code</p>
-<h2>hipError_t hipFree ( void *ptr )</h2>
-<p>Free memory allocated by the hcc hip memory allocation API. This API performs an implicit hipDeviceSynchronize() call. If pointer is NULL, the hip runtime is initialized and hipSuccess is returned.</p>
-<h2>See also:</h2>
-<p>hipMalloc , hipMallocPitch , hipMallocArray , hipFreeArray , hipHostFree , hipMalloc3D , hipMalloc3DArray , hipHostMalloc</p>
-<h2>Parameters</h2>
-<p>ptr -[in] Pointer to memory to be freed</p>
-<h2>Returns</h2>
-<p>hipSuccess</p>
-<h2>Returns</h2>
-<p>hipErrorInvalidDevicePointer (if pointer is invalid, including host pointers allocated with hipHostMalloc)</p>
-<h2>hipError_t hipFreeHost ( void *ptr )</h2>
-<p>Free memory allocated by the hcc hip host memory allocation API [Deprecated].</p>
-<p>Warning:</p>
-<p><strong>**Following code does:** The code snippet appears to be a command intended to be run in a terminal or command line interface, rather than a Python script. The command `cuobjdump --list-ptx ./saxpy` is used to extract and list the PTX (Parallel Thread Execution) code from a compiled CUDA binary file, in this case, named `saxpy`. PTX is an intermediate representation of CUDA code that is closer to assembly language. This command is typically used by developers to inspect the PTX code generated by the CUDA compiler for debugging or optimization purposes. The output of this command would display the PTX code sections contained within the `saxpy` binary.</strong></p>
-<pre><code>
-
-urning:   This API is deprecated, use hipHostFree() instead</code></pre>
-<h2>Parameters</h2>
-<p>ptr -[in] Pointer to memory to be freed</p>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue (if pointer is invalid, including device pointers allocated with hipMalloc)</p>
-<h2>hipError_t hipHostFree ( void *ptr )</h2>
-<p>Free memory allocated by the hcc hip host memory allocation API This API performs an implicit hipDeviceSynchronize() call. If pointer is NULL, the hip runtime is initialized and hipSuccess is returned.</p>
-<h2>See also:</h2>
-<p>hipMalloc , hipMallocPitch , hipFree , hipMallocArray , hipFreeArray , hipMalloc3D , hipMalloc3DArray , hipHostMalloc</p>
-<h2>Parameters</h2>
-<p>ptr -[in] Pointer to memory to be freed</p>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue (if pointer is invalid, including device pointers allocated with hipMalloc)</p>
-<p>hipError_t hipMemcpy ( void *dst, const void *src, size_t sizeBytes, hipMemcpyKind kind )</p>
-<p>Copy data from src to dst.</p>
-<p>It supports memory from host to device, device to host, device to device and host to host The src and dst must not overlap.</p>
-<p>For hipMemcpy, the copy is always performed by the current device (set by hipSetDevice). For multi-gpu or peerto-peer configurations, it is recommended to set the current device to the device where the src data is physically located. For optimal peer-to-peer copies, the copy device must be able to access the src and dst pointers (by calling hipDeviceEnablePeerAccess with copy agent as the current device and src/dest as the peerDevice argument. if this is not done, the hipMemcpy will still work, but will perform the copy using a staging buffer on the host. Calling hipMemcpy with dst and src pointers that do not match the hipMemcpyKind results in undefined behavior.</p>
-<h2>See also:</h2>
-<p>hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[out] Data being copy to</li>
-<li style="list-style-type: '· ';">src -[in] Data being copy from</li>
-<li style="list-style-type: '· ';">sizeBytes -[in] Data size in bytes</li>
-<li style="list-style-type: '· ';">kind -[in] Kind of transfer</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorUnknown hipError_t hipMemcpyWithStream ( void *dst, const void *src, size_t sizeBytes, hipMemcpyKind kind, hipStream_t stream )</p>
-<p>Memory copy on the stream. It allows single or multiple devices to do memory copy on single or multiple streams.</p>
-<h2>See also:</h2>
-<p>hipMemcpy , hipStreamCreate , hipStreamSynchronize , hipStreamDestroy , hipSetDevice, hipLaunchKernelGGL</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[out] Data being copy to</li>
-<li style="list-style-type: '· ';">src -[in] Data being copy from</li>
-<li style="list-style-type: '· ';">sizeBytes -[in] Data size in bytes</li>
-<li style="list-style-type: '· ';">kind -[in] Kind of transfer</li>
-<li style="list-style-type: '· ';">stream -[in] Valid stream</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorUnknown, hipErrorContextIsDestroyed hipError_t hipMemcpyHtoD ( hipDeviceptr_t dst, void *src, size_t sizeBytes )</p>
-<p>Copy data from Host to Device.</p>
-<h2>See also:</h2>
-<p>hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[out] Data being copy to</li>
-<li style="list-style-type: '· ';">src -[in] Data being copy from</li>
-<li style="list-style-type: '· ';">sizeBytes -[in] Data size in bytes</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue</p>
-<p>hipError_t hipMemcpyDtoH ( void *dst, hipDeviceptr_t src, size_t sizeBytes )</p>
-<p>Copy data from Device to Host.</p>
-<h2>See also:</h2>
-<p>hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[out] Data being copy to</li>
-<li style="list-style-type: '· ';">src -[in] Data being copy from</li>
-<li style="list-style-type: '· ';">sizeBytes -[in] Data size in bytes</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue hipError_t hipMemcpyDtoD ( hipDeviceptr_t dst, hipDeviceptr_t src, size_t sizeBytes )</p>
-<p>Copy data from Device to Device.</p>
-<h2>See also:</h2>
-<p>hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[out] Data being copy to</li>
-<li style="list-style-type: '· ';">src -[in] Data being copy from</li>
-<li style="list-style-type: '· ';">sizeBytes -[in] Data size in bytes</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue hipError_t hipMemcpyHtoDAsync ( hipDeviceptr_t dst, void *src, size_t sizeBytes, hipStream_t stream )</p>
-<p>Copy data from Host to Device asynchronously.</p>
-<h2>See also:</h2>
-<p>hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpyAtoA, hipMemcpyAtoD,</p>
-<p>hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[out] Data being copy to</li>
-<li style="list-style-type: '· ';">src -[in] Data being copy from</li>
-<li style="list-style-type: '· ';">sizeBytes -[in] Data size in bytes</li>
-<li style="list-style-type: '· ';">stream -[in] Stream identifier</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue hipError_t hipMemcpyDtoHAsync ( void *dst, hipDeviceptr_t src, size_t sizeBytes, hipStream_t stream )</p>
-<p>Copy data from Device to Host asynchronously.</p>
-<h2>See also:</h2>
-<p>hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[out] Data being copy to</li>
-<li style="list-style-type: '· ';">src -[in] Data being copy from</li>
-<li style="list-style-type: '· ';">sizeBytes -[in] Data size in bytes</li>
-<li style="list-style-type: '· ';">stream -[in] Stream identifier</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue hipError_t hipMemcpyDtoDAsync ( hipDeviceptr_t dst, hipDeviceptr_t src, size_t sizeBytes, hipStream_t stream )</p>
-<p>Copy data from Device to Device asynchronously.</p>
-<h2>See also:</h2>
-<p>hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[out] Data being copy to</li>
-<li style="list-style-type: '· ';">src -[in] Data being copy from</li>
-<li style="list-style-type: '· ';">sizeBytes -[in] Data size in bytes</li>
-<li style="list-style-type: '· ';">stream -[in] Stream identifier</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue hipError_t hipModuleGetGlobal ( hipDeviceptr_t *dptr, size_t *bytes, hipModule_t hmod, const char *name )</p>
-<p>Returns a global pointer from a module. Returns in *dptr and *bytes the pointer and size of the global of name name located in module hmod. If no variable of that name exists, it returns hipErrorNotFound. Both parameters dptr and bytes are optional. If one of them is NULL, it is ignored and hipSuccess is returned.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dptr -[out] Returns global device pointer</li>
-<li style="list-style-type: '· ';">bytes -[out] Returns global size in bytes</li>
-<li style="list-style-type: '· ';">hmod -[in] Module to retrieve global from</li>
-<li style="list-style-type: '· ';">name -[in] Name of global to retrieve</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotFound, hipErrorInvalidContext hipError_t hipGetSymbolAddress ( void **devPtr, const void *symbol )</p>
-<p>Gets device pointer associated with symbol on the device.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">devPtr -[out] pointer to the device associated the symbole</li>
-<li style="list-style-type: '· ';">symbol -[in] pointer to the symbole of the device</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipError_t hipGetSymbolSize ( size_t *size, const void *symbol )</p>
-<p>Gets the size of the given symbol on the device.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">symbol -[in] pointer to the device symbole</li>
-<li style="list-style-type: '· ';">size -[out] pointer to the size</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipError_t hipGetProcAddress ( const char *symbol, void **pfn, int hipVersion, uint64_t flags, hipDriverProcAddressQueryResult *symbolStatus )</p>
-<p>Gets the pointer of requested HIP driver function.</p>
-<p>Returns hipSuccess if the returned pfn is addressed to the pointer of found driver function.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">symbol -[in] The Symbol name of the driver function to request.</li>
-<li style="list-style-type: '· ';">pfn -[out] Output pointer to the requested driver function.</li>
-<li style="list-style-type: '· ';">hipVersion -[in] The HIP version for the requested driver function symbol. HIP version is defined as 100*version_major + version_minor. For example, in HIP 6.1, the hipversion is 601, for the symbol function 'hipGetDeviceProperties', the specified hipVersion 601 is greater or equal to the version 600, the symbol function will be handle properly as backend compatible function.</li>
-<li style="list-style-type: '· ';">flags -[in] Currently only default flag is suppported.</li>
-<li style="list-style-type: '· ';">symbolStatus -[out] Optional enumeration for returned status of searching for symbol driver function based on the input hipVersion.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue.</p>
-<p>hipError_t hipMemcpyToSymbol ( const void *symbol, const void *src, size_t sizeBytes, size_t offset, hipMemcpyKind kind )</p>
-<p>Copies data to the given symbol on the device. Symbol HIP APIs allow a kernel to define a device-side data symbol which can be accessed on the host side. The symbol can be in __constant or device space. Note that the symbol name needs to be encased in the HIP_SYMBOL macro. This also applies to hipMemcpyFromSymbol, hipGetSymbolAddress, and hipGetSymbolSize. For detailed usage, see the memcpyToSymbol example in the HIP Porting Guide.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">symbol -[out] pointer to the device symbole</li>
-<li style="list-style-type: '· ';">src -[in] pointer to the source address</li>
-<li style="list-style-type: '· ';">sizeBytes -[in] size in bytes to copy</li>
-<li style="list-style-type: '· ';">offset -[in] offset in bytes from start of symbole</li>
-<li style="list-style-type: '· ';">kind -[in] type of memory transfer</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipError_t hipMemcpyToSymbolAsync ( const void *symbol, const void *src, size_t sizeBytes, size_t offset, hipMemcpyKind kind, hipStream_t stream )</p>
-<p>Copies data to the given symbol on the device asynchronously.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">symbol -[out] pointer to the device symbole</li>
-<li style="list-style-type: '· ';">src -[in] pointer to the source address</li>
-<li style="list-style-type: '· ';">sizeBytes -[in] size in bytes to copy</li>
-<li style="list-style-type: '· ';">offset -[in] offset in bytes from start of symbole</li>
-<li style="list-style-type: '· ';">kind -[in] type of memory transfer</li>
-<li style="list-style-type: '· ';">stream -[in] stream identifier</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue</p>
-<p>hipError_t hipMemcpyFromSymbol ( void *dst, const void *symbol, size_t sizeBytes, size_t offset, hipMemcpyKind kind )</p>
-<p>Copies data from the given symbol on the device.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[out] Returns pointer to destinition memory address</li>
-<li style="list-style-type: '· ';">symbol -[in] Pointer to the symbole address on the device</li>
-<li style="list-style-type: '· ';">sizeBytes -[in] Size in bytes to copy</li>
-<li style="list-style-type: '· ';">offset -[in] Offset in bytes from the start of symbole</li>
-<li style="list-style-type: '· ';">kind -[in] Type of memory transfer</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipError_t hipMemcpyFromSymbolAsync ( void *dst, const void *symbol, size_t sizeBytes, size_t offset, hipMemcpyKind kind, hipStream_t stream )</p>
-<p>Copies data from the given symbol on the device asynchronously.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[out] Returns pointer to destinition memory address</li>
-<li style="list-style-type: '· ';">symbol -[in] pointer to the symbole address on the device</li>
-<li style="list-style-type: '· ';">sizeBytes -[in] size in bytes to copy</li>
-<li style="list-style-type: '· ';">offset -[in] offset in bytes from the start of symbole</li>
-<li style="list-style-type: '· ';">kind -[in] type of memory transfer</li>
-<li style="list-style-type: '· ';">stream -[in] stream identifier</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipError_t hipMemcpyAsync ( void *dst, const void *src, size_t sizeBytes, hipMemcpyKind kind, hipStream_t stream )</p>
-<p>Copy data from src to dst asynchronously.</p>
-<p>For multi-gpu or peer-to-peer configurations, it is recommended to use a stream which is a attached to the device where the src data is physically located. For optimal peer-to-peer copies, the copy device must be able to access the src and dst pointers (by calling hipDeviceEnablePeerAccess with copy agent as the current device and src/dest as the peerDevice argument. if this is not done, the hipMemcpy will still work, but will perform the copy using a staging buffer on the host.</p>
-<h2>See also:</h2>
-<p>hipMemcpy , hipMemcpy2D , hipMemcpyToArray , hipMemcpy2DToArray , hipMemcpyFromArray , hipMemcpy2DFromArray , hipMemcpyArrayToArray, hipMemcpy2DArrayToArray, hipMemcpyToSymbol , hipMemcpyFromSymbol , hipMemcpy2DAsync , hipMemcpyToArrayAsync, hipMemcpy2DToArrayAsync , hipMemcpyFromArrayAsync, hipMemcpy2DFromArrayAsync , hipMemcpyToSymbolAsync , hipMemcpyFromSymbolAsync</p>
-<p>Warning: If host or dest are not pinned, the memory copy will be performed synchronously. For best performance, use hipHostMalloc to allocate host memory that is transferred asynchronously.</p>
-<p>Warning: on HCC hipMemcpyAsync does not support overlapped H2D and D2H copies. For hipMemcpy, the copy is always performed by the device associated with the specified stream.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[out] Data being copy to</li>
-<li style="list-style-type: '· ';">src -[in] Data being copy from</li>
-<li style="list-style-type: '· ';">sizeBytes -[in] Data size in bytes</li>
-<li style="list-style-type: '· ';">kind -[in] Type of memory transfer</li>
-<li style="list-style-type: '· ';">stream -[in] Stream identifier</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorUnknown hipError_t hipMemset ( void *dst, int value, size_t sizeBytes )</p>
-<p>Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant byte value value.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[out] Data being filled</li>
-<li style="list-style-type: '· ';">value -[in] Value to be set</li>
-<li style="list-style-type: '· ';">sizeBytes -[in] Data size in bytes</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized hipError_t hipMemsetD8 ( hipDeviceptr_t dest, unsigned char value, size_t count )</p>
-<p>Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant byte value value.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dest -[out] Data ptr to be filled</li>
-<li style="list-style-type: '· ';">value -[in] Value to be set</li>
-<li style="list-style-type: '· ';">count -[in] Number of values to be set</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized hipError_t hipMemsetD8Async ( hipDeviceptr_t dest, unsigned char value, size_t count, hipStream_t stream )</p>
-<p>Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant byte value value.</p>
-<p>hipMemsetD8Async() is asynchronous with respect to the host, so the call may return before the memset is complete. The operation can optionally be associated to a stream by passing a non-zero stream argument. If stream is non-zero, the operation may overlap with operations in other streams.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dest -[out] Data ptr to be filled</li>
-<li style="list-style-type: '· ';">value -[in] Constant value to be set</li>
-</ul>
-<ul>
-<li style="list-style-type: '· ';">count -[in] Number of values to be set</li>
-<li style="list-style-type: '· ';">stream -[in] Stream identifier</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized hipError_t hipMemsetD16 ( hipDeviceptr_t dest, unsigned short value, size_t count )</p>
-<p>Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant short value value.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dest -[out] Data ptr to be filled</li>
-<li style="list-style-type: '· ';">value -[in] Constant value to be set</li>
-<li style="list-style-type: '· ';">count -[in] Number of values to be set</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized hipError_t hipMemsetD16Async ( hipDeviceptr_t dest, unsigned short value, size_t count, hipStream_t stream )</p>
-<p>Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant short value value.</p>
-<p>hipMemsetD16Async() is asynchronous with respect to the host, so the call may return before the memset is complete. The operation can optionally be associated to a stream by passing a non-zero stream argument. If stream is non-zero, the operation may overlap with operations in other streams.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dest -[out] Data ptr to be filled</li>
-<li style="list-style-type: '· ';">value -[in] Constant value to be set</li>
-<li style="list-style-type: '· ';">count -[in] Number of values to be set</li>
-<li style="list-style-type: '· ';">stream -[in] Stream identifier</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized hipError_t hipMemsetD32 ( hipDeviceptr_t dest, int value, size_t count )</p>
-<p>Fills the memory area pointed to by dest with the constant integer value for specified number of times.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dest -[out] Data being filled</li>
-<li style="list-style-type: '· ';">value -[in] Constant value to be set</li>
-<li style="list-style-type: '· ';">count -[in] Number of values to be set</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized hipError_t hipMemsetAsync ( void *dst, int value, size_t sizeBytes, hipStream_t stream )</p>
-<p>Fills the first sizeBytes bytes of the memory area pointed to by dev with the constant byte value value.</p>
-<p>hipMemsetAsync() is asynchronous with respect to the host, so the call may return before the memset is complete. The operation can optionally be associated to a stream by passing a non-zero stream argument. If stream is nonzero, the operation may overlap with operations in other streams.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[out] Pointer to device memory</li>
-</ul>
-<ul>
-<li style="list-style-type: '· ';">value -[in] Value to set for each byte of specified memory</li>
-<li style="list-style-type: '· ';">sizeBytes -[in] Size in bytes to set</li>
-<li style="list-style-type: '· ';">stream -[in] Stream identifier</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipError_t hipMemsetD32Async ( hipDeviceptr_t dst, int value, size_t count, hipStream_t stream )</p>
-<p>Fills the memory area pointed to by dev with the constant integer value for specified number of times.</p>
-<p>hipMemsetD32Async() is asynchronous with respect to the host, so the call may return before the memset is complete. The operation can optionally be associated to a stream by passing a non-zero stream argument. If stream is non-zero, the operation may overlap with operations in other streams.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[out] Pointer to device memory</li>
-<li style="list-style-type: '· ';">value -[in] Value to set for each byte of specified memory</li>
-<li style="list-style-type: '· ';">count -[in] Number of values to be set</li>
-<li style="list-style-type: '· ';">stream -[in] Stream identifier</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipError_t hipMemset2D ( void *dst, size_t pitch, int value, size_t width, size_t height )</p>
-<p>Fills the memory area pointed to by dst with the constant value.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[out] Pointer to device memory</li>
-<li style="list-style-type: '· ';">pitch -[in] Data size in bytes</li>
-<li style="list-style-type: '· ';">value -[in] Constant value to be set</li>
-<li style="list-style-type: '· ';">width -[in]</li>
-<li style="list-style-type: '· ';">height -[in]</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipError_t hipMemset2DAsync ( void *dst, size_t pitch, int value, size_t width, size_t height, hipStream_t stream ) Fills asynchronously the memory area pointed to by dst with the constant value.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[in] Pointer to 2D device memory</li>
-<li style="list-style-type: '· ';">pitch -[in] Pitch size in bytes</li>
-<li style="list-style-type: '· ';">value -[in] Value to be set for each byte of specified memory</li>
-<li style="list-style-type: '· ';">width -[in] Width of matrix set columns in bytes</li>
-<li style="list-style-type: '· ';">height -[in] Height of matrix set rows in bytes</li>
-<li style="list-style-type: '· ';">stream -[in] Stream identifier</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue</p>
-<p>hipError_t hipMemset3D ( hipPitchedPtr pitchedDevPtr, int value, hipExtent extent )</p>
-<p>Fills synchronously the memory area pointed to by pitchedDevPtr with the constant value.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">pitchedDevPtr -[in] Pointer to pitched device memory</li>
-<li style="list-style-type: '· ';">value -[in] Value to set for each byte of specified memory</li>
-<li style="list-style-type: '· ';">extent -[in] Size parameters for width field in bytes in device memory</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipError_t hipMemset3DAsync ( hipPitchedPtr pitchedDevPtr, int value, hipExtent extent, hipStream_t stream )</p>
-<p>Fills asynchronously the memory area pointed to by pitchedDevPtr with the constant value.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">pitchedDevPtr -[in] Pointer to pitched device memory</li>
-<li style="list-style-type: '· ';">value -[in] Value to set for each byte of specified memory</li>
-<li style="list-style-type: '· ';">extent -[in] Size parameters for width field in bytes in device memory</li>
-<li style="list-style-type: '· ';">stream -[in] Stream identifier</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipError_t hipMemGetInfo ( size_t *free, size_t *total )</p>
-<p>Query memory info.</p>
-<p>On ROCM, this function gets the actual free memory left on the current device, so supports the cases while running multi-workload (such as multiple processes, multiple threads, and multiple GPUs).</p>
-<p>Warning: On Windows, the free memory only accounts for memory allocated by this process and may be optimistic.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">free -[out] Returns free memory on the current device in bytes</li>
-<li style="list-style-type: '· ';">total -[out] Returns total allocatable memory on the current device in bytes</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError_t hipMemPtrGetInfo ( void *ptr, size_t *size )</p>
-<p>Get allocated memory size via memory pointer.</p>
-<p>This function gets the allocated shared virtual memory size from memory pointer.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">ptr -[in] Pointer to allocated memory</li>
-<li style="list-style-type: '· ';">size -[out] Returns the allocated memory size in bytes</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue</p>
-<p>hipError_t hipMallocArray ( hipArray_t *array, const hipChannelFormatDesc *desc, size_t width, size_t height, unsigned int flags )</p>
-<p>Allocate an array on the device.</p>
-<h2>See also:</h2>
-<p>hipMalloc , hipMallocPitch , hipFree , hipFreeArray , hipHostMalloc , hipHostFree</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">array -[out] Pointer to allocated array in device memory</li>
-<li style="list-style-type: '· ';">desc -[in] Requested channel format</li>
-<li style="list-style-type: '· ';">width -[in] Requested array allocation width</li>
-<li style="list-style-type: '· ';">height -[in] Requested array allocation height</li>
-<li style="list-style-type: '· ';">flags -[in] Requested properties of allocated array</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorOutOfMemory hipError_t hipArrayCreate ( hipArray_t *pHandle, const HIP_ARRAY_DESCRIPTOR *pAllocateArray )</p>
-<p>Create an array memory pointer on the device.</p>
-<h2>See also:</h2>
-<p>hipMallocArray , hipArrayDestroy , hipFreeArray</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">pHandle -[out] Pointer to the array memory</li>
-<li style="list-style-type: '· ';">pAllocateArray -[in] Requested array desciptor</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError_t hipArrayDestroy ( hipArray_t array )</p>
-<p>Destroy an array memory pointer on the device.</p>
-<h2>See also:</h2>
-<p>hipArrayCreate , hipArrayDestroy , hipFreeArray</p>
-<h2>Parameters</h2>
-<p>array -[in] Pointer to the array memory</p>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue</p>
-<p>hipError_t hipArray3DCreate ( hipArray_t *array, const HIP_ARRAY3D_DESCRIPTOR *pAllocateArray )</p>
-<p>Create a 3D array memory pointer on the device.</p>
-<h2>See also:</h2>
-<p>hipMallocArray , hipArrayDestroy , hipFreeArray</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">array -[out] Pointer to the 3D array memory</li>
-<li style="list-style-type: '· ';">pAllocateArray -[in] Requested array desciptor</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError_t hipMalloc3D ( hipPitchedPtr *pitchedDevPtr, hipExtent extent )</p>
-<p>Create a 3D memory pointer on the device.</p>
-<h2>See also:</h2>
-<p>hipMallocPitch , hipMemGetInfo , hipFree</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">pitchedDevPtr -[out] Pointer to the 3D memory</li>
-<li style="list-style-type: '· ';">extent -[in] Requested extent</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError_t hipFreeArray ( hipArray_t array )</p>
-<p>Frees an array on the device.</p>
-<h2>See also:</h2>
-<p>hipMalloc , hipMallocPitch , hipFree , hipMallocArray , hipHostMalloc , hipHostFree</p>
-<h2>Parameters</h2>
-<p>array -[in] Pointer to array to free</p>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized hipError_t hipMalloc3DArray ( hipArray_t *array, const struct hipChannelFormatDesc *desc, struct hipExtent extent, unsigned int flags )</p>
-<p>Allocate an array on the device.</p>
-<h2>See also:</h2>
-<p>hipMalloc , hipMallocPitch , hipFree , hipFreeArray , hipHostMalloc , hipHostFree</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">array -[out] Pointer to allocated array in device memory</li>
-<li style="list-style-type: '· ';">desc -[in] Requested channel format</li>
-<li style="list-style-type: '· ';">extent -[in] Requested array allocation width, height and depth</li>
-<li style="list-style-type: '· ';">flags -[in] Requested properties of allocated array</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorOutOfMemory hipError_t hipArrayGetInfo ( hipChannelFormatDesc *desc, hipExtent *extent, unsigned int *flags, hipArray_t array )</p>
-<p>Gets info about the specified array.</p>
-<h2>See also:</h2>
-<p>hipArrayGetDescriptor , hipArray3DGetDescriptor</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">desc -[out] - Returned array type</li>
-<li style="list-style-type: '· ';">extent -[out] - Returned array shape. 2D arrays will have depth of zero</li>
-<li style="list-style-type: '· ';">flags -[out] - Returned array flags</li>
-<li style="list-style-type: '· ';">array -[in] - The HIP array to get info for</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipErrorInvalidHandle hipError_t hipArrayGetDescriptor ( HIP_ARRAY_DESCRIPTOR *pArrayDescriptor, hipArray_t array )</p>
-<p>Gets a 1D or 2D array descriptor.</p>
-<h2>See also:</h2>
-<p>hipArray3DCreate , hipArray3DGetDescriptor , hipArrayCreate , hipArrayDestroy , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpy3D , hipMemcpy3DAsync , hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoD , hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer, hipMemsetD8 , hipMemsetD16 , hipMemsetD32 , hipArrayGetInfo</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">pArrayDescriptor -[out] - Returned array descriptor</li>
-<li style="list-style-type: '· ';">array -[in] - Array to get descriptor of</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue hipErrorInvalidHandle</p>
-<p>hipError_t hipArray3DGetDescriptor ( HIP_ARRAY3D_DESCRIPTOR *pArrayDescriptor, hipArray_t array )</p>
-<p>Gets a 3D array descriptor.</p>
-<h2>See also:</h2>
-<p>hipArray3DCreate , hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpy3D , hipMemcpy3DAsync , hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoD , hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer, hipMemsetD8 , hipMemsetD16 , hipMemsetD32 , hipArrayGetInfo</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">pArrayDescriptor -[out] - Returned 3D array descriptor</li>
-<li style="list-style-type: '· ';">array -[in] - 3D array to get descriptor of</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue hipErrorInvalidHandle, hipErrorContextIsDestroyed hipError_t hipMemcpy2D ( void *dst, size_t dpitch, const void *src, size_t spitch, size_t width, size_t height, hipMemcpyKind kind )</p>
-<p>Copies data between host and device.</p>
-<h2>See also:</h2>
-<p>hipMemcpy , hipMemcpyToArray , hipMemcpy2DToArray , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[in] Destination memory address</li>
-<li style="list-style-type: '· ';">dpitch -[in] Pitch of destination memory</li>
-<li style="list-style-type: '· ';">src -[in] Source memory address</li>
-<li style="list-style-type: '· ';">spitch -[in] Pitch of source memory</li>
-<li style="list-style-type: '· ';">width -[in] Width of matrix transfer (columns in bytes)</li>
-<li style="list-style-type: '· ';">height -[in] Height of matrix transfer (rows)</li>
-<li style="list-style-type: '· ';">kind -[in] Type of transfer</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError_t hipMemcpyParam2D ( const hip_Memcpy2D *pCopy )</p>
-<p>Copies memory for 2D arrays.</p>
-<h2>See also:</h2>
-<p>hipMemcpy , hipMemcpy2D , hipMemcpyToArray , hipMemcpy2DToArray , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync</p>
-<h2>Parameters</h2>
-<p>pCopy -[in] Parameters for the memory copy</p>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError_t hipMemcpyParam2DAsync ( const hip_Memcpy2D *pCopy, hipStream_t stream )</p>
-<p>Copies memory for 2D arrays.</p>
-<h2>See also:</h2>
-<p>hipMemcpy , hipMemcpy2D , hipMemcpyToArray , hipMemcpy2DToArray , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">pCopy -[in] Parameters for the memory copy</li>
-<li style="list-style-type: '· ';">stream -[in] Stream to use</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError_t hipMemcpy2DAsync ( void *dst, size_t dpitch, const void *src, size_t spitch, size_t width, size_t height, hipMemcpyKind kind, hipStream_t stream )</p>
-<p>Copies data between host and device.</p>
-<h2>See also:</h2>
-<p>hipMemcpy , hipMemcpyToArray , hipMemcpy2DToArray , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[in] Destination memory address</li>
-<li style="list-style-type: '· ';">dpitch -[in] Pitch of destination memory</li>
-<li style="list-style-type: '· ';">src -[in] Source memory address</li>
-<li style="list-style-type: '· ';">spitch -[in] Pitch of source memory</li>
-<li style="list-style-type: '· ';">width -[in] Width of matrix transfer (columns in bytes)</li>
-<li style="list-style-type: '· ';">height -[in] Height of matrix transfer (rows)</li>
-<li style="list-style-type: '· ';">kind -[in] Type of transfer</li>
-<li style="list-style-type: '· ';">stream -[in] Stream to use</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError_t hipMemcpy2DToArray ( hipArray_t dst, size_t wOffset, size_t hOffset, const void *src, size_t spitch, size_t width, size_t height, hipMemcpyKind kind )</p>
-<p>Copies data between host and device.</p>
-<h2>See also:</h2>
-<p>hipMemcpy , hipMemcpyToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[in] Destination memory address</li>
-<li style="list-style-type: '· ';">wOffset -[in] Destination starting X offset</li>
-<li style="list-style-type: '· ';">hOffset -[in] Destination starting Y offset</li>
-<li style="list-style-type: '· ';">src -[in] Source memory address</li>
-<li style="list-style-type: '· ';">spitch -[in] Pitch of source memory</li>
-<li style="list-style-type: '· ';">width -[in] Width of matrix transfer (columns in bytes)</li>
-<li style="list-style-type: '· ';">height -[in] Height of matrix transfer (rows)</li>
-<li style="list-style-type: '· ';">kind -[in] Type of transfer</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError_t hipMemcpy2DToArrayAsync ( hipArray_t dst, size_t wOffset, size_t hOffset, const void *src, size_t spitch, size_t width, size_t height, hipMemcpyKind kind, hipStream_t stream )</p>
-<p>Copies data between host and device.</p>
-<h2>See also:</h2>
-<p>hipMemcpy , hipMemcpyToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[in] Destination memory address</li>
-<li style="list-style-type: '· ';">wOffset -[in] Destination starting X offset</li>
-<li style="list-style-type: '· ';">hOffset -[in] Destination starting Y offset</li>
-<li style="list-style-type: '· ';">src -[in] Source memory address</li>
-<li style="list-style-type: '· ';">spitch -[in] Pitch of source memory</li>
-<li style="list-style-type: '· ';">width -[in] Width of matrix transfer (columns in bytes)</li>
-<li style="list-style-type: '· ';">height -[in] Height of matrix transfer (rows)</li>
-</ul>
-<ul>
-<li style="list-style-type: '· ';">kind -[in] Type of transfer</li>
-<li style="list-style-type: '· ';">stream -[in] Accelerator view which the copy is being enqueued</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError_t hipMemcpyToArray ( hipArray_t dst, size_t wOffset, size_t hOffset, const void *src, size_t count, hipMemcpyKind kind )</p>
-<p>Copies data between host and device.</p>
-<h2>See also:</h2>
-<p>hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync</p>
-<p>Warning: This API is deprecated.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[in] Destination memory address</li>
-<li style="list-style-type: '· ';">wOffset -[in] Destination starting X offset</li>
-<li style="list-style-type: '· ';">hOffset -[in] Destination starting Y offset</li>
-<li style="list-style-type: '· ';">src -[in] Source memory address</li>
-<li style="list-style-type: '· ';">count -[in] size in bytes to copy</li>
-<li style="list-style-type: '· ';">kind -[in] Type of transfer</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError_t hipMemcpyFromArray ( void *dst, hipArray_const_t srcArray, size_t wOffset, size_t hOffset, size_t count, hipMemcpyKind kind )</p>
-<p>Copies data between host and device.</p>
-<h2>See also:</h2>
-<p>hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync</p>
-<p>Warning: This API is deprecated.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[in] Destination memory address</li>
-<li style="list-style-type: '· ';">srcArray -[in] Source memory address</li>
-<li style="list-style-type: '· ';">wOffset -[in] Source starting X offset</li>
-</ul>
-<ul>
-<li style="list-style-type: '· ';">hOffset -[in] Source starting Y offset</li>
-<li style="list-style-type: '· ';">count -[in] Size in bytes to copy</li>
-<li style="list-style-type: '· ';">kind -[in] Type of transfer</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError_t hipMemcpy2DFromArray ( void *dst, size_t dpitch, hipArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, hipMemcpyKind kind )</p>
-<p>Copies data between host and device.</p>
-<h2>See also:</h2>
-<p>hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[in] Destination memory address</li>
-<li style="list-style-type: '· ';">dpitch -[in] Pitch of destination memory</li>
-<li style="list-style-type: '· ';">src -[in] Source memory address</li>
-<li style="list-style-type: '· ';">wOffset -[in] Source starting X offset</li>
-<li style="list-style-type: '· ';">hOffset -[in] Source starting Y offset</li>
-<li style="list-style-type: '· ';">width -[in] Width of matrix transfer (columns in bytes)</li>
-<li style="list-style-type: '· ';">height -[in] Height of matrix transfer (rows)</li>
-<li style="list-style-type: '· ';">kind -[in] Type of transfer</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError_t hipMemcpy2DFromArrayAsync ( void *dst, size_t dpitch, hipArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, hipMemcpyKind kind, hipStream_t stream )</p>
-<p>Copies data between host and device asynchronously.</p>
-<h2>See also:</h2>
-<p>hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[in] Destination memory address</li>
-<li style="list-style-type: '· ';">dpitch -[in] Pitch of destination memory</li>
-<li style="list-style-type: '· ';">src -[in] Source memory address</li>
-<li style="list-style-type: '· ';">wOffset -[in] Source starting X offset</li>
-</ul>
-<ul>
-<li style="list-style-type: '· ';">hOffset -[in] Source starting Y offset</li>
-<li style="list-style-type: '· ';">width -[in] Width of matrix transfer (columns in bytes)</li>
-<li style="list-style-type: '· ';">height -[in] Height of matrix transfer (rows)</li>
-<li style="list-style-type: '· ';">kind -[in] Type of transfer</li>
-<li style="list-style-type: '· ';">stream -[in] Accelerator view which the copy is being enqueued</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError_t hipMemcpyAtoH ( void *dst, hipArray_t srcArray, size_t srcOffset, size_t count )</p>
-<p>Copies data between host and device.</p>
-<h2>See also:</h2>
-<p>hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[in] Destination memory address</li>
-<li style="list-style-type: '· ';">srcArray -[in] Source array</li>
-<li style="list-style-type: '· ';">srcOffset -[in] Offset in bytes of source array</li>
-<li style="list-style-type: '· ';">count -[in] Size of memory copy in bytes</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError_t hipMemcpyHtoA ( hipArray_t dstArray, size_t dstOffset, const void *srcHost, size_t count )</p>
-<p>Copies data between host and device.</p>
-<h2>See also:</h2>
-<p>hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dstArray -[in] Destination memory address</li>
-<li style="list-style-type: '· ';">dstOffset -[in] Offset in bytes of destination array</li>
-<li style="list-style-type: '· ';">srcHost -[in] Source host pointer</li>
-<li style="list-style-type: '· ';">count -[in] Size of memory copy in bytes</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection</p>
-<p>hipError_t hipMemcpy3D ( const struct hipMemcpy3DParms *p )</p>
-<p>Copies data between host and device.</p>
-<h2>See also:</h2>
-<p>hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync</p>
-<h2>Parameters</h2>
-<p>p -[in] 3D memory copy parameters</p>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError_t hipMemcpy3DAsync ( const struct hipMemcpy3DParms *p, hipStream_t stream )</p>
-<p>Copies data between host and device asynchronously.</p>
-<h2>See also:</h2>
-<p>hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">p -[in] 3D memory copy parameters</li>
-<li style="list-style-type: '· ';">stream -[in] Stream to use</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError_t hipDrvMemcpy3D ( const HIP_MEMCPY3D *pCopy )</p>
-<p>Copies data between host and device.</p>
-<h2>See also:</h2>
-<p>hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync</p>
-<h2>Parameters</h2>
-<p>pCopy -[in] 3D memory copy parameters</p>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError_t hipDrvMemcpy3DAsync ( const HIP_MEMCPY3D *pCopy, hipStream_t stream )</p>
-<p>Copies data between host and device asynchronously.</p>
-<h2>See also:</h2>
-<p>hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">pCopy -[in] 3D memory copy parameters</li>
-<li style="list-style-type: '· ';">stream -[in] Stream to use</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection template&lt;typename T &gt; hipError_t hipGetSymbolAddress ( void **devPtr, const T &amp;symbol ) Gets the address of a symbol.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">devPtr -[out] - Returns device pointer associated with symbol.</li>
-<li style="list-style-type: '· ';">symbol -[in] - Device symbol.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue template&lt;typename T &gt; hipError_t hipGetSymbolSize ( size_t *size, const T &amp;symbol ) Gets the size of a symbol.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">size -[out] - Returns the size of a symbol.</li>
-<li style="list-style-type: '· ';">symbol -[in] - Device symbol address.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue template&lt;typename T &gt;</p>
-<p>hipError_t hipMemcpyToSymbol ( const T &amp;symbol, const void *src, size_t sizeBytes, size_t offset, hipMemcpyKind kind )</p>
-<p>Copies data to the given symbol on the device.</p>
-<h2>See also:</h2>
-<p>hipMemcpyToSymbol</p>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidMemcpyDirection, hipErrorInvalidValue template&lt;typename T &gt;</p>
-<p>hipError_t hipMemcpyToSymbolAsync ( const T &amp;symbol, const void *src, size_t sizeBytes, size_t offset, hipMemcpyKind kind, hipStream_t stream )</p>
-<p>Copies data to the given symbol on the device asynchronously on the stream.</p>
-<h2>See also:</h2>
-<p>hipMemcpyToSymbolAsync</p>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidMemcpyDirection, hipErrorInvalidValue template&lt;typename T &gt;</p>
-<p>hipError_t hipMemcpyFromSymbol ( void *dst, const T &amp;symbol, size_t sizeBytes, size_t offset, hipMemcpyKind kind )</p>
-<p>Copies data from the given symbol on the device.</p>
-<h2>See also:</h2>
-<p>hipMemcpyFromSymbol</p>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidMemcpyDirection, hipErrorInvalidValue template&lt;typename T &gt;</p>
-<p>hipError_t hipMemcpyFromSymbolAsync ( void *dst, const T &amp;symbol, size_t sizeBytes, size_t offset, hipMemcpyKind kind, hipStream_t stream )</p>
-<p>Copies data from the given symbol on the device asynchronously on the stream.</p>
-<h2>See also:</h2>
-<p>hipMemcpyFromSymbolAsync</p>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidMemcpyDirection, hipErrorInvalidValue template&lt;class T &gt;</p>
-<p>static inline hipError_t hipMalloc ( T **devPtr, size_t size )</p>
-<ul>
-<li>: C++ wrapper for hipMalloc</li>
-</ul>
-<p>Perform automatic type conversion to eliminate need for excessive typecasting (ie void**)</p>
-<p>HIP_DISABLE_CPP_FUNCTIONS macro can be defined to suppress these wrappers. It is useful for applications which need to obtain decltypes of HIP runtime APIs.</p>
-<h2>See also:</h2>
-<p>hipMalloc</p>
-<h2>template&lt;class T &gt;</h2>
-<p>static inline hipError_t hipHostMalloc ( T **ptr, size_t size, unsigned int flags = hipHostMallocDefault )</p>
-<ul>
-<li>: C++ wrapper for hipHostMalloc</li>
-</ul>
-<p>Provide an override to automatically typecast the pointer type from void**, and also provide a default for the flags.</p>
-<p>HIP_DISABLE_CPP_FUNCTIONS macro can be defined to suppress these wrappers. It is useful for applications which need to obtain decltypes of HIP runtime APIs.</p>
-<h2>See also:</h2>
-<p>hipHostMalloc</p>
-<h2>19.23.4 External Resource Interoperability</h2>
-<p>hipError_t hipImportExternalSemaphore ( hipExternalSemaphore_t *extSem_out, const hipExternalSemaphoreHandleDesc *semHandleDesc )</p>
-<p>Imports an external semaphore.</p>
-<p>See also:</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">extSem_out -[out] External semaphores to be waited on</li>
-<li style="list-style-type: '· ';">semHandleDesc -[in] Semaphore import handle descriptor</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError_t hipSignalExternalSemaphoresAsync ( const hipExternalSemaphore_t *extSemArray, const hipExternalSemaphoreSignalParams *paramsArray, unsigned int numExtSems, hipStream_t stream )</p>
-<p>Signals a set of external semaphore objects.</p>
-<h2>See also:</h2>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">extSemArray -[in] External semaphores to be waited on</li>
-<li style="list-style-type: '· ';">paramsArray -[in] Array of semaphore parameters</li>
-<li style="list-style-type: '· ';">numExtSems -[in] Number of semaphores to wait on</li>
-<li style="list-style-type: '· ';">stream -[in] Stream to enqueue the wait operations in</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError_t hipWaitExternalSemaphoresAsync ( const hipExternalSemaphore_t *extSemArray, const hipExternalSemaphoreWaitParams *paramsArray, unsigned int numExtSems, hipStream_t stream )</p>
-<p>Waits on a set of external semaphore objects.</p>
-<p>See also:</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">extSemArray -[in] External semaphores to be waited on</li>
-<li style="list-style-type: '· ';">paramsArray -[in] Array of semaphore parameters</li>
-<li style="list-style-type: '· ';">numExtSems -[in] Number of semaphores to wait on</li>
-<li style="list-style-type: '· ';">stream -[in] Stream to enqueue the wait operations in</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue</p>
-<h2>hipError_t hipDestroyExternalSemaphore ( hipExternalSemaphore_t extSem )</h2>
-<p>Destroys an external semaphore object and releases any references to the underlying resource. Any outstanding signals or waits must have completed before the semaphore is destroyed.</p>
-<h2>See also:</h2>
-<h2>Parameters</h2>
-<p>extSem -[in] handle to an external memory object</p>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError_t hipImportExternalMemory ( hipExternalMemory_t *extMem_out, const hipExternalMemoryHandleDesc *memHandleDesc )</p>
-<p>Imports an external memory object.</p>
-<h2>See also:</h2>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">extMem_out -[out] Returned handle to an external memory object</li>
-<li style="list-style-type: '· ';">memHandleDesc -[in] Memory import handle descriptor</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError_t hipExternalMemoryGetMappedBuffer ( void **devPtr, hipExternalMemory_t extMem, const hipExternalMemoryBufferDesc *bufferDesc )</p>
-<p>Maps a buffer onto an imported memory object.</p>
-<h2>See also:</h2>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">devPtr -[out] Returned device pointer to buffer</li>
-<li style="list-style-type: '· ';">extMem -[in] Handle to external memory object</li>
-<li style="list-style-type: '· ';">bufferDesc -[in] Buffer descriptor</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue</p>
-<h2>hipError_t hipDestroyExternalMemory ( hipExternalMemory_t extMem )</h2>
-<p>Destroys an external memory object.</p>
-<p>See also:</p>
-<h2>Parameters</h2>
-<p>extMem -[in] External memory object to be destroyed</p>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError_t hipExternalMemoryGetMappedMipmappedArray ( hipMipmappedArray_t *mipmap,</p>
-<p>hipExternalMemory_t extMem, const hipExternalMemoryMipmappedArrayDesc *mipmapDesc )</p>
-<p>Maps a mipmapped array onto an external memory object.</p>
-<p>Returned mipmapped array must be freed using hipFreeMipmappedArray.</p>
-<h2>See also:</h2>
-<p>hipImportExternalMemory , hipFreeMipmappedArray</p>
-<p>hipDestroyExternalMemory ,</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">mipmap -[out] mipmapped array to return</li>
-<li style="list-style-type: '· ';">extMem -[in] external memory object handle</li>
-<li style="list-style-type: '· ';">mipmapDesc -[in] external mipmapped array descriptor</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorInvalidResourceHandle</p>
-<h2>19.24 Register Keyword</h2>
-<p>The register keyword is deprecated in C++, and is silently ignored by both NVCC and HIP-Clang. You can pass the option -Wdeprecated-register the compiler warning message.</p>
-<p>hipExternalMemoryGetMappedBuffer ,</p>
-<h2>19.25 Pragma Unroll</h2>
-<p>Unroll with a bounds that is known at compile-time is supported. For example:</p>
-<p><strong>**Following code does:** The code snippet appears to be a corrupted or incorrectly formatted text, possibly due to a copy-paste error or encoding issue. It does not represent valid Python code or any recognizable programming construct. Therefore, it does not perform any specific function or task in its current form.</strong></p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        //                                                                                                                                                                                                        #pragma unroll 16 /* hint to compiler to unroll next loop by 16 */
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        }                                                                                                                                                                                                        /*                                                                                                                                                                                                        */
-                                                                                                                                                                                                     
-		                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       //
-                                                                                                                                                                                                       }
-                                                                                                                                                                                                       */</code></pre>
-<h2>19.26 In-Line Assembly</h2>
-<p>GCN ISA In-line assembly, is supported. For example:</p>
-<p><strong>**Following code does:** The code snippet you provided appears to be a command or a reference to a file rather than a typical code snippet. It seems to be related to a SAXPY operation, which stands for "Single-Precision A·X Plus Y." SAXPY is a common operation in linear algebra used to perform a scaled vector addition. The rest of the line suggests it might be related to a specific implementation or version (possibly for a GPU architecture, given the "sm_5" which could refer to a specific compute capability of NVIDIA GPUs) and "ptx" which typically refers to Parallel Thread Execution, NVIDIA's intermediate representation for GPU code. Overall, this line likely refers to a file or command related to executing or compiling a SAXPY operation for a specific GPU architecture.</strong></p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <img>void                                                                                                                                                                                                        </img>void</code></pre>
-<p>We insert the GCN isa into the kernel using asm() Assembler statement. volatile keyword is used so that the optimizers must not change the number of volatile operations or change their order of execution relative to other volatile operations. v_mac_f32_e32 is the GCN instruction, for more information please refer - [AMD GCN3 ISA architecture manual](http://gpuopen.com/compute-product/amd-gcn3-isa-architecture-manual/) Index for the respective operand in the ordered fashion is provided by % followed by position in the list of operands 'v' is the constraint code (for target-specific AMDGPU) for 32-bit VGPR register, for more info please refer - [Supported Constraint Code List for AMDGPU](https://llvm.org/docs/LangRef.html#supported-constraint-code-list) Output Constraints are specified by an '=' prefix as shown above ('=v'). This indicate that assembly will write to this operand, and the operand will then be made available as a return value of the asm expression. Input constraints do not have a prefix - just the constraint code. The constraint string of '0' says to use the assigned register for output as an input as well (it being the 0'th constraint).</p>
-<p>## C++ Support The following C++ features are not supported: - Run-time-type information (RTTI) - Try/catch Virtual functions Virtual functions are not supported if objects containing virtual function tables are passed between GPU's of different offload arch's, e.g. between gfx906 and gfx1030. Otherwise virtual functions are supported.</p>
-<h2>19.27 Kernel Compilation</h2>
-<p>hipcc now supports compiling C++/HIP kernels to binary code objects. The file format for binary is .co which means Code Object. The following command builds the code object using hipcc .</p>
-<p><strong>**Following code does:** The code snippet appears to be a command-line operation that uses `dumpbin.exe` to analyze a specific section of an executable file (`saxpy.exe`). It targets the `.hip_fat` section and extracts raw data with a specified format. The output is then piped into a `select` command, which skips the first 20 lines and selects the next 12 lines from the output. This operation is likely used for inspecting or debugging specific parts of the executable's binary data.</strong></p>
-<pre><code>hipcc --genco --offload-arch=[TARGET GPU] [INPUT FILE] -o [OUTPUT FILE]
-
-[TARGET GPU] = GPU architecture
-[INPUT FILE] = Name of the file containing kernels
-[OUTPUT FILE] = Name of the generated code object file</code></pre>
-<p>Note: When using binary code objects is that the number of arguments to the kernel is different on HIP-Clang and NVCC path. Refer to the HIP module_api sample for differences in the arguments to be passed to the kernel.</p>
-<h2>19.28 gfx-arch-specific-kernel</h2>
-<p>Clang defined '__gfx*__' macros can be used to execute gfx arch specific codes inside the kernel. Refer to the sample in HIP 14_gpu_arch sample.</p>
-<h2>CHAPTER</h2>
-<h2>TWENTY</h2>
-<h2>C++ LANGUAGE SUPPORT</h2>
-<p>The ROCm platform enables the power of combined C++ and HIP (Heterogeneous-computing Interface for Portability) code. This code is compiled with a clang or clang++ compiler. The official compilers support the HIP platform, or you can use the amdclang or amdclang++ included in the ROCm installation, which are a wrapper for the official versions.</p>
-<p>The source code is compiled according to the C++03 , C++11 , C++14 , C++17 , and C++20 standards, along with HIPspecific extensions, but is subject to restrictions. The key restriction is the reduced support of standard library in device code. This is due to the fact that by default a function is considered to run on host, except for constexpr functions, which can run on host and device as well.</p>
-<h2>20.1 Modern C++ support</h2>
-<p>C++ is considered a modern programming language as of C++11. This section describes how HIP supports these new C++ features.</p>
-<h2>20.1.1 C++11 support</h2>
-<p>The C++11 standard introduced many new features. These features are supported in HIP host code, with some notable omissions on the device side. The rule of thumb here is that constexpr functions work on device, the rest doesn't. This means that some important functionality like std::function is missing on the device, but unfortunately the standard library wasn't designed with HIP in mind, which means that the support is in a state of 'works as-is'.</p>
-<p>Certain features have restrictions and clarifications. For example, any functions using the constexpr qualifier or the new initializer lists , std::move or std::forward features are implicitly considered to have the __host__ and __device__ execution space specifier. Also, constexpr variables that are static members or namespace scoped can be used from both host and device, but only for read access. Dereferencing a static constexpr outside its specified execution space causes an error.</p>
-<p>Lambdas are supported, but there are some extensions and restrictions on their usage. For more information, see the Extended lambdas section below.</p>
-<h2>20.1.2 C++14 support</h2>
-<p>The C++14 language features are supported.</p>
-<h2>20.1.3 C++17 support</h2>
-<p>All C++17 language features are supported.</p>
-<h2>20.1.4 C++20 support</h2>
-<p>All C++20 language features are supported, but extensions and restrictions apply. C++20 introduced coroutines and modules, which fundamentally changed how programs are written. HIP doesn't support these features. However, consteval functions can be called from host and device, even if specified for host use only.</p>
-<p>The three-way comparison operator (spaceship operator &lt;=&gt; ) works with host and device code.</p>
-<h2>20.2 Extensions and restrictions</h2>
-<p>In addition to the deviations from the standard, there are some general extensions and restrictions to consider.</p>
-<h2>20.2.1 Global functions</h2>
-<p>Functions that serve as an entry point for device execution are called kernels and are specified with the __global__ qualifier. To call a kernel function, use the triple chevron operator: &lt;&lt;&lt; &gt;&gt;&gt; . Kernel functions must have a void return type. These functions can't:</p>
-<ul>
-<li style="list-style-type: '· ';">have a constexpr specifier</li>
-<li style="list-style-type: '· ';">have a parameter of type std::initializer_list or va_list</li>
-<li style="list-style-type: '· ';">use an rvalue reference as a parameter.</li>
-<li style="list-style-type: '· ';">use parameters having different sizes in host and device code, e.g. long double arguments, or structs containing long double members.</li>
-<li style="list-style-type: '· ';">use struct-type arguments which have different layout in host and device code.</li>
-</ul>
-<p>Kernels can have variadic template parameters, but only one parameter pack, which must be the last item in the template parameter list.</p>
-<h2>20.2.2 Device space memory specifiers</h2>
-<p>HIP includes device space memory specifiers to indicate whether a variable is allocated in host or device memory and howits memory should be allocated. HIP supports the __device__ , __shared__ , __managed__ , and __constant__ specifiers.</p>
-<p>The __device__ and __constant__ specifiers define global variables, which are allocated within global memory on the HIP devices. The only difference is that __constant__ variables can't be changed after allocation. The __shared__ specifier allocates the variable within shared memory, which is available for all threads in a block.</p>
-<p>The __managed__ variable specifier creates global variables that are initially undefined and unaddressed within the global symbol table. The HIP runtime allocates managed memory and defines the symbol when it loads the device binary. A managed variable can be accessed in both device and host code.</p>
-<p>It's important to know where a variable is stored because it is only available from certain locations. Generally, variables allocated in the host memory are not accessible from the device code, while variables allocated in the device memory are not directly accessible from the host code. Dereferencing a pointer to device memory on the host results in a segmentation fault. Accessing device variables in host code should be done through kernel execution or HIP functions like hipMemCpyToSymbol .</p>
-<h2>20.2.3 Exception handling</h2>
-<p>An important difference between the host and device code is exception handling. In device code, this control flow isn't available due to the hardware architecture. The device code must use return codes to handle errors.</p>
-<h2>20.2.4 Kernel parameters</h2>
-<p>There are some restrictions on kernel function parameters. They cannot be passed by reference, because these functions are called from the host but run on the device. Also, a variable number of arguments is not allowed.</p>
-<h2>20.2.5 Classes</h2>
-<p>Classes work on both the host and device side, but there are some constraints. The static member functions can't be __global__ . Virtual member functions work, but a virtual function must not be called from the host if the parent object was created on the device, or the other way around, because this behavior is undefined. Another minor restriction is that __device__ variables, that are global scoped must have trivial constructors.</p>
-<h2>20.2.6 Polymorphic function wrappers</h2>
-<p>HIP doesn't support the polymorphic function wrapper std::function , which was introduced in C++11.</p>
-<h2>20.2.7 Extended lambdas</h2>
-<p>HIP supports Lambdas, which by default work as expected.</p>
-<p>Lambdas have implicit host device attributes. This means that they can be executed by both host and device code, and works the way you would expect. To make a lambda callable only by host or device code, users can add __host__ or __device__ attribute. The only restriction is that host variables can only be accessed through copy on the device. Accessing through reference will cause undefined behavior.</p>
-<h2>20.2.8 Inline namespaces</h2>
-<p>Inline namespaces are supported, but with a few exceptions. The following entities can't be declared in namespace scope within an inline unnamed namespace:</p>
-<ul>
-<li style="list-style-type: '· ';">__managed__ , __device__ , __shared__ and __constant__ variables</li>
-<li style="list-style-type: '· ';">__global__ function and function templates</li>
-<li style="list-style-type: '· ';">variables with surface or texture type</li>
-</ul>
-<h2>CHAPTER</h2>
-<h2>TWENTYONE</h2>
-<h2>HIP MATH API</h2>
-<p>HIP-Clang supports a set of math operations that are callable from the device. HIP supports most of the device functions supported by NVIDIA CUDA. These are described in the following sections.</p>
-<h2>21.1 Single precision mathematical functions</h2>
-<p>Following is the list of supported single precision mathematical functions.</p>
-<p><strong>**Following table contains:** The table represents a list of mathematical functions, likely from a programming library or API, with details about their purpose and usage. Each row corresponds to a specific function, providing a brief description of what the function does.
-
-The columns appear to be structured as follows:
-- The first column contains the function signature, including the return type and parameters.
-- The second column provides a description of the function's purpose or behavior.
-- The third and fourth columns seem to indicate some form of categorization or feature presence, marked by checkmarks (✓).
-
-Noteworthy observations:
-- All functions listed are related to mathematical operations, particularly involving floating-point numbers.
-- Functions like `nanf`, `nearbyintf`, and `nextafterf` are related to floating-point arithmetic and handling special cases like 'Not a Number' (NaN).
-- Functions such as `norm3df`, `norm4df`, `normcdff`, and `normcdfinvf` are related to mathematical norms and statistical functions, indicating a focus on vector operations and probability distributions.
-- The presence of checkmarks in the third and fourth columns suggests these functions might be categorized based on certain criteria, such as availability in different environments or support for specific features.</strong></p>
-<table><caption><div class="caption">Table 1: Single precision mathematical functions</div></caption><tbody><tr><th>Function</th><th>Supported on Host</th><th>Supported on Device</th></tr><tr><td>float abs(float x) Returns the absolute value of 𝑥</td><td>✓</td><td>✓</td></tr><tr><td>float acosf(float x) Returns the arc cosine of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float acoshf(float x) Returns the nonnegative arc hyperbolic cosine of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float asinf(float x) Returns the arc sine of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float asinhf(float x) Returns the arc hyperbolic sine of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float atanf(float x) Returns the arc tangent of 𝑥 .</td><td>✓</td><td>✓</td></tr></tbody></table>
-<p>continues on next page</p>
-<p><strong>**Following table contains:** The table appears to represent a list of mathematical functions, specifically those related to floating-point operations in programming or computational contexts. Each row corresponds to a different function, providing a brief description of what the function does.
-
-The columns are as follows:
-- The first column contains the function signature and a description of its purpose or operation.
-- The second and third columns, both marked with "✓", likely indicate the presence or support of these functions in specific contexts or libraries, though the exact meaning of the checkmarks is not provided in the preview.
-
-Noteworthy observations:
-- All functions listed are related to floating-point arithmetic, such as power functions, remainder calculations, rounding, and reciprocal operations.
-- Each function is prefixed with "float," indicating they operate on single-precision floating-point numbers.
-- The consistent presence of checkmarks in the second and third columns suggests that all these functions are uniformly supported or available in the contexts being referenced.</strong></p>
-<table><tbody><tr><td></td><th>Table</th><th>1 - continued from previous page</th></tr><tr><td>float atan2f(float x, float y) Returns the arc tangent of the ratio of 𝑥 and 𝑦 .</td><td>✓</td><td>✓</td></tr><tr><td>float atanhf(float x) Returns the arc hyperbolic tangent of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float cbrtf(float x) Returns the cube root of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float ceilf(float x) Returns ceiling of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float copysignf(float x, float y) Create value with given magnitude, copying sign of second value.</td><td>✓</td><td>✓</td></tr><tr><td>float cosf(float x) Returns the cosine of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float coshf(float x) Returns the hyperbolic cosine of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float cospif(float x) Returns the cosine of 𝜋 · 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float cyl_bessel_i0f(float x) Returns the value of the regular modified cylindrical Bessel function of order 0 for 𝑥 .</td><td></td><td></td></tr></tbody></table>
-<p>continues on next page</p>
-<p><strong>**Following table contains:** The table represents a list of mathematical functions, likely from a programming library or API, with each row detailing a specific function. 
-
-- **Rows**: Each row corresponds to a different mathematical function, providing a brief description of what the function does.
-
-- **Columns**:
-  - **Column 0**: Contains the function signature and a description of its purpose or operation.
-  - **Column 1**: Appears to indicate whether the function is available or supported, marked with a check (✓).
-  - **Column 2**: Also seems to indicate availability or support, similarly marked with a check (✓).
-
-- **Noteworthy Values**: All functions listed have checks in both Column 1 and Column 2, suggesting that all functions are available or supported without exception. The functions cover a range of mathematical operations, including normalization, scaling, and trigonometric calculations.</strong></p>
-<table><caption><div class="caption">Table 1 - continued from previous page</div></caption><tbody><tr><td>float cyl_bessel_i1f(float x) Returns the value of the regular modified cylindrical Bessel function of order 1 for 𝑥 .</td><td></td><td></td></tr><tr><td>float erff(float x) Returns the error function of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float erfcf(float x) Returns the complementary error function of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float erfcinvf(float x) Returns the inverse complementary function of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float erfcxf(float x) Returns the scaled complementary error function of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float erfinvf(float x) Returns the inverse error function of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float expf(float x) Returns 𝑒 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float exp10f(float x) Returns 10 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float exp2f( float x) Returns 2 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float expm1f(float x) Returns 𝑙𝑛 ( 𝑥 - 1)</td><td>✓</td><td>✓</td></tr></tbody></table>
-<p>continues on next page</p>
-<p>Table</p>
-<p>1 - continued from previous page</p>
-<p><strong>**Following table contains:** The table represents a list of mathematical functions, likely from a programming library or API, with each row corresponding to a specific function. The columns provide information about the availability or support of these functions in different contexts or systems.
-
-- **Column 0**: Describes the function signature and its purpose. It includes the return type, function name, parameters, and a brief description of what the function does.
-- **Column 1**: Indicates whether the function is supported or available in a particular context, marked by a check (✓).
-- **Column 2**: Similar to Column 1, it indicates support or availability in another context, also marked by a check (✓).
-
-Noteworthy values:
-- The function `float rsqrtf(float x)` does not have a check in Column 1, suggesting it might not be supported or available in the context represented by this column.
-- All other functions have checks in both columns, indicating they are supported or available in both contexts.</strong></p>
-<table><tbody><tr><td>float fabsf(float x) Returns the absolute value of x</td><td>✓</td><td>✓</td></tr><tr><td>float fdimf(float x, float y) Returns the positive difference between 𝑥 and 𝑦 .</td><td>✓</td><td>✓</td></tr><tr><td>float fdividef(float x, float y) Divide two floating point values.</td><td>✓</td><td>✓</td></tr><tr><td>float floorf(float x) Returns the largest integer less than or equal to 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float fmaf(float x, float y, float z) Returns 𝑥 · 𝑦 + 𝑧 as a single operation.</td><td>✓</td><td>✓</td></tr><tr><td>float fmaxf(float x, float y) Determine the maximum numeric value of 𝑥 and 𝑦 .</td><td>✓</td><td>✓</td></tr><tr><td>float fminf(float x, float y) Determine the minimum numeric value of 𝑥 and 𝑦 .</td><td>✓</td><td>✓</td></tr><tr><td>float fmodf(float x, float y) Returns the floating-point remainder of 𝑥/𝑦 .</td><td>✓</td><td>✓</td></tr><tr><td>float modff(float x, float* iptr) Break down 𝑥 into fractional and integral parts.</td><td>✓</td><td></td></tr></tbody></table>
-<p>continues on next page</p>
-<p><strong>**Following table contains:** The table represents a list of mathematical functions and their support status on different platforms. Each row corresponds to a specific mathematical function, detailing its purpose and whether it is supported on a host system and a device.
-
-The columns are as follows:
-- **Function**: Describes the mathematical function, including its return type and parameters, along with a brief explanation of what the function does.
-- **Supported on Host**: Indicates whether the function is supported on a host system, marked with a "✓" for supported.
-- **Supported on Device**: Indicates whether the function is supported on a device, also marked with a "✓" for supported.
-
-Noteworthy observations include:
-- All listed functions are supported on both the host and the device, as indicated by the "✓" in both the "Supported on Host" and "Supported on Device" columns.
-- The functions cover a range of trigonometric and hyperbolic operations, such as `abs`, `acos`, `acosh`, `asin`, `asinh`, `atan`, and `atan2`.</strong></p>
-<table><caption><div class="caption">Table 1 - continued from previous page</div></caption><tbody><tr><td>float frexpf(float x, int* nptr) Extract mantissa and exponent of 𝑥 .</td><td>✓</td></tr><tr><td>float hypotf(float x, float y) Returns the square root of the sum of squares of 𝑥 and 𝑦 .</td><td>✓</td></tr><tr><td>int ilogbf(float x) Returns the unbiased integer exponent of 𝑥 .</td><td>✓</td></tr><tr><td>bool isfinite(float x) Determine whether 𝑥 is finite.</td><td>✓</td></tr><tr><td>bool isinf(float x) Determine whether 𝑥 is infinite.</td><td>✓</td></tr><tr><td>bool isnan(float x) Determine whether 𝑥 is a NAN .</td><td>✓</td></tr><tr><td>float j0f(float x) Returns the value of the Bessel function of the first kind of order 0 for 𝑥 .</td><td>✓</td></tr><tr><td>float j1f(float x) Returns the value of the Bessel function of the first kind of order 1 for 𝑥 .</td><td>✓</td></tr><tr><td>float jnf(int n, float x) Returns the value of the Bessel function of the first kind of order n for 𝑥 .</td><td>✓</td></tr></tbody></table>
-<p>continues on next page</p>
-<p>Table</p>
-<p>1 - continued from previous page</p>
-<p><strong>**Following table contains:** The table appears to represent a list of mathematical functions, likely from a programming library or a mathematical software package. Each row corresponds to a specific function, detailing its purpose and behavior.
-
-- **Rows**: Each row represents a different mathematical function, including its name, a brief description of what it does, and potentially some metadata or status indicators.
-
-- **Columns**: 
-  1. The first column contains the function signature and a brief description of what the function does. For example, "double atanh(double x) Returns the arc hyperbolic tangent of 𝑥."
-  2. The second and third columns seem to contain checkmarks (✓), which might indicate the availability, implementation status, or some form of validation or approval for the function.
-
-- **Noteworthy Values**: 
-  - Most functions have checkmarks in the second and third columns, suggesting they are available or validated.
-  - The functions `cyl_bessel_i0` and `cyl_bessel_i1` do not have checkmarks in these columns, which might indicate they are not available, not implemented, or not validated in the same way as the others.</strong></p>
-<table><tbody><tr><td>float ldexpf(float x, int exp) Returns the natural logarithm of the absolute value of the gamma function of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float lgammaf(float x) Returns the natural logarithm of the absolute value of the gamma function of 𝑥 .</td><td>✓</td><td></td></tr><tr><td>long int lrintf(float x) Round 𝑥 to nearest integer value.</td><td>✓</td><td>✓</td></tr><tr><td>long long int llrintf(float x) Round 𝑥 to nearest integer value.</td><td>✓</td><td>✓</td></tr><tr><td>long int lroundf(float x) Round to nearest integer value.</td><td>✓</td><td>✓</td></tr><tr><td>long long int llroundf(float x) Round to nearest integer value.</td><td>✓</td><td>✓</td></tr><tr><td>float log10f(float x) Returns the base 10 logarithm of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float log1pf(float x) Returns the natural logarithm of 𝑥 +1 .</td><td>✓</td><td>✓</td></tr><tr><td>float log2f(float x) Returns the base 2 logarithm of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float logf(float x) Returns the natural logarithm of 𝑥 .</td><td>✓</td><td>✓</td></tr></tbody></table>
-<p>continues on next page</p>
-<p><strong>**Following table contains:** The table represents a list of mathematical functions and their descriptions, along with indicators of their availability or implementation status. Each row corresponds to a specific mathematical function, detailing its purpose and the mathematical operation it performs.
-
-The columns are as follows:
-- Column 0: Contains the function signature, which includes the return type (`double`), the function name, and the parameter (`double x`).
-- Column 1: Provides a brief description of what the function does, typically explaining the mathematical operation or transformation it performs on the input `x`.
-- Column 2 and Column 3: Both contain checkmarks (✓), which likely indicate that the function is implemented or available in two different contexts, environments, or versions.
-
-Noteworthy values:
-- All functions listed have checkmarks in both Column 2 and Column 3, suggesting that they are consistently available or implemented across the contexts or versions represented by these columns.
-- The functions cover a range of mathematical operations related to error functions and exponential calculations, which are common in scientific and engineering computations.</strong></p>
-<table><caption><div class="caption">Table 1 - continued from previous page</div></caption><tbody><tr><td></td><td></td><th>✓</th></tr><tr><td>float logbf(float x) Returns the floating point representation of the exponent of 𝑥 .</td><td>✓</td><td></td></tr><tr><td>float nanf(const char* tagp) Returns &#x27;Not a Number&#x27; value.</td><td></td><td>✓</td></tr><tr><td>float nearbyintf(float x) Round 𝑥 to the nearest integer.</td><td>✓</td><td>✓</td></tr><tr><td>float nextafterf(float x, float y) Returns next representable single-precision floating-point value after argument.</td><td>✓</td><td></td></tr><tr><td>float norm3df(float x, float y, float z) Returns the square root of the sum of squares of 𝑥 , 𝑦 and 𝑧 .</td><td>✓</td><td>✓</td></tr><tr><td>float norm4df(float x, float y, float z, float w) Returns the square root of the sum of squares of 𝑥 , 𝑦 , 𝑧 and 𝑤 .</td><td>✓</td><td>✓</td></tr><tr><td>float normcdff(float y) Returns the standard normal cumulative distribution function.</td><td>✓</td><td>✓</td></tr><tr><td>float normcdfinvf(float y) Returns the inverse of the standard normal cumulative distribution function.</td><td>✓</td><td>✓</td></tr><tr><td>float normf(int dim, const float *a) Returns the square root of the sum of squares of any number of coordinates.</td><td>✓</td><td>✓</td></tr></tbody></table>
-<p>continues on next page</p>
-<p><strong>**Following table contains:** The table represents a list of mathematical functions, likely from a programming library or API, with their descriptions and availability across different platforms or versions.
-
-- **Rows**: Each row corresponds to a specific mathematical function, detailing its purpose and behavior.
-  
-- **Columns**:
-  1. **Function Description**: This column provides the function signature and a brief description of what the function does. For example, "double floor(double x)" returns the largest integer less than or equal to x.
-  2. **Availability Indicator 1**: This column seems to indicate whether the function is available or supported in a certain context, marked with a "✓" for available.
-  3. **Availability Indicator 2**: Similar to the second column, this column also indicates availability or support, again marked with a "✓".
-
-- **Noteworthy Values**:
-  - All functions except "modf" and "frexp" have a "✓" in both availability columns, suggesting they are widely supported.
-  - "modf" and "frexp" have a missing "✓" in the third column, indicating they might not be available or supported in the same context as the others.</strong></p>
-<table><tbody><tr><td></td><th>Table</th><th>1 - continued from previous page</th></tr><tr><td>float powf(float x, float y) Returns 𝑥 𝑦 .</td><td>✓</td><td>✓</td></tr><tr><td>float powif(float base, int iexp) Returns the value of first argument to the power of second argument.</td><td>✓</td><td>✓</td></tr><tr><td>float remainderf(float x, float y) Returns single-precision floating-point remainder.</td><td>✓</td><td>✓</td></tr><tr><td>float remquof(float x, float y, int* quo) Returns single-precision floating-point remainder and part of quotient.</td><td>✓</td><td>✓</td></tr><tr><td>float roundf(float x) Round to nearest integer value in floating-point.</td><td>✓</td><td>✓</td></tr><tr><td>float rcbrtf(float x) Returns the reciprocal cube root function.</td><td>✓</td><td>✓</td></tr><tr><td>float rhypotf(float x, float y) Returns one over the square root of the sum of squares of two arguments.</td><td>✓</td><td>✓</td></tr><tr><td>float rintf(float x) Round input to nearest integer value in floating-point.</td><td>✓</td><td>✓</td></tr></tbody></table>
-<p>continues on next page</p>
-<p>Table</p>
-<p>1 - continued from previous page</p>
-<p><strong>**Following table contains:** The table appears to represent a list of mathematical functions, likely from a programming library or documentation, with each row corresponding to a specific function. The columns provide information about these functions:
-
-- **Column 0**: Contains the function signature and a brief description of what the function does. This includes the return type, function name, and parameters, followed by a description of the function's purpose.
-- **Column 1**: Contains a checkmark (✓) indicating some form of validation or support for the function, possibly denoting that the function is implemented or available.
-- **Column 2**: Also contains a checkmark (✓), which might indicate another layer of validation or support, such as compatibility with a specific version or platform.
-
-Noteworthy observations:
-- All functions except for `lgamma(double x)` have checkmarks in both columns 1 and 2, suggesting that `lgamma(double x)` might be missing some form of validation or support compared to the others.
-- The functions cover a range of mathematical operations, including checks for finite, infinite, and NaN values, as well as calculations involving Bessel functions and logarithmic operations.</strong></p>
-<table><tbody><tr><td>float rnorm3df(float x, float y, float z) Returns one over the square root of the sum of squares of three coordinates of the argument.</td><td>✓</td><td>✓</td></tr><tr><th>float rnorm4df(float x, float y, float z, float w) Returns one over the square root of the sum of squares of four coordinates of the argument.</th><td>✓</td><td>✓</td></tr><tr><th>float rnormf(int dim, const float *a) Returns the reciprocal of square root of the sum of squares of any number of coordinates.</th><td>✓</td><td>✓</td></tr><tr><th>float scalblnf(float x, long int n) Scale 𝑥 by 2 𝑛 .</th><td>✓</td><td>✓</td></tr><tr><th>float scalbnf(float x, int n) Scale 𝑥 by 2 𝑛 .</th><td>✓</td><td>✓</td></tr><tr><th>bool signbit(float x) Return the sign bit of 𝑥 .</th><td>✓</td><td>✓</td></tr><tr><th>float sinf(float x) Returns the sine of 𝑥 .</th><td>✓</td><td>✓</td></tr><tr><th>float sinhf(float x) Returns the hyperbolic sine of 𝑥 .</th><td>✓</td><td>✓</td></tr><tr><th>float sinpif(float x) Returns the hyperbolic sine of 𝜋 · 𝑥 .</th><td>✓</td><td>✓</td></tr></tbody></table>
-<p>continues on next page</p>
-<p>Table</p>
-<p>1 - continued from previous page</p>
-<p><strong>**Following table contains:** The table represents a list of mathematical functions, likely from a programming or mathematical library, with each row detailing a specific function. 
-
-- **Rows**: Each row corresponds to a different mathematical function, providing its return type, function name, and a brief description of what the function does.
-
-- **Columns**:
-  - Column 0: Contains the return type and the function signature, including the function name and its parameter(s).
-  - Column 1: Appears to indicate whether the function is available or supported, marked with a "✓".
-  - Column 2: Also seems to indicate availability or support, similarly marked with a "✓".
-
-- **Noteworthy Values**: All functions listed have checkmarks in both columns 1 and 2, suggesting that they are all supported or available in the context being described. The functions cover a range of mathematical operations, primarily focusing on rounding and logarithmic calculations.</strong></p>
-<table><tbody><tr><td>void sincosf(float x, float *sptr, float *cptr) Returns the sine and cosine of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>void sincospif(float x, float *sptr, float *cptr) Returns the sine and cosine of 𝜋 · 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float sqrtf(float x) Returns the square root of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float rsqrtf(float x) Returns the reciprocal of the square root of 𝑥 .</td><td></td><td>✓</td></tr><tr><td>float tanf(float x) Returns the tangent of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float tanhf(float x) Returns the hyperbolic tangent of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float tgammaf(float x) Returns the gamma function of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float truncf(float x) Truncate 𝑥 to the integral part.</td><td>✓</td><td>✓</td></tr><tr><td>float y0f(float x) Returns the value of the Bessel function of the second kind of order 0 for 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float y1f(float x) Returns the value of the Bessel function of the second kind of order 1 for 𝑥 .</td><td>✓</td><td>✓</td></tr></tbody></table>
-<p>continues on next page</p>
-<p><strong>**Following code does:** It seems like there is a placeholder or an error in your request, as the code snippet is missing. Please provide the actual code snippet you would like me to analyze, and I'll be happy to help!</strong></p>
-<pre><code>                                                                                                                                                                                                        \
-    float  ynf(int  n,  float  x)
-    Returns the value of the Bessel
-    function of the second kind of order
-    n for x.</code></pre>
-<h2>21.2 Double precision mathematical functions</h2>
-<p>Following is the list of supported double precision mathematical functions.</p>
-<p><strong>**Following table contains:** The table appears to represent a structured outline or index of a document, likely related to memory management in computing. Each row corresponds to a specific section or subsection of the document, with the columns providing different pieces of information about each section.
-
-- **Column 0**: This column seems to contain section numbers or identifiers, which help in organizing the document into a hierarchical structure. For example, "16.1" and "16.1.1" indicate a main section and its subsection, respectively.
-
-- **Column 1**: This column contains the titles or descriptions of the sections. These titles describe various topics related to memory management, such as "Memory allocation," "Allocate physical memory," "Reserve virtual address range," and "Set memory access."
-
-- **Column 2**: This column appears to contain page numbers or reference numbers, which likely indicate where in the document the section can be found. For example, "109" and "110" are associated with specific subsections.
-
-Noteworthy values include:
-- The section "17 Frequently asked questions" is repeated in both columns 0 and 1, suggesting it might be a standalone section or a significant part of the document.
-- The consistent use of ellipses in the titles and page numbers suggests a formatting style typical of an index or table of contents.</strong></p>
-<table><caption><div class="caption">Table 2: Double precision mathematical functions</div></caption><tbody><tr><th>Function</th><th>Supported on Host</th><th>Supported on Device</th></tr><tr><td>double abs(double x) Returns the absolute value of 𝑥</td><td>✓</td><td>✓</td></tr><tr><td>double acos(double x) Returns the arc cosine of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>double acosh(double x) Returns the nonnegative arc hyperbolic cosine of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>double asin(double x) Returns the arc sine of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>double asinh(double x) Returns the arc hyperbolic sine of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>double atan(double x) Returns the arc tangent of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>double atan2(double x, double y) Returns the arc tangent of the ratio of 𝑥 and 𝑦 .</td><td>✓</td><td>✓</td></tr></tbody></table>
-<p>continues on next page</p>
-<p><strong>**Following table contains:** The table appears to represent a list of mathematical functions, likely from a programming library or API, with each row detailing a specific function. 
-
-- **Rows**: Each row corresponds to a different mathematical function, providing a brief description of what the function does.
-  
-- **Columns**: 
-  - The first column contains the function signature and a description of its purpose.
-  - The second and third columns seem to indicate some form of categorization or feature availability, marked by checkmarks (✓).
-
-- **Noteworthy Values**: 
-  - All functions listed have a checkmark in the second column, suggesting they all share a common characteristic or are available in a particular context.
-  - Most functions also have a checkmark in the third column, except for the first function, "double nextafter(double x, double y)", which lacks a checkmark in this column. This might indicate a difference in availability or feature set compared to the others.</strong></p>
-<table><caption><div class="caption">Table 2 - continued from previous page</div></caption><tbody><tr><td>double atanh(double x) Returns the arc hyperbolic tangent of 𝑥 .</td><th>✓</th><th>✓</th></tr><tr><th>double cbrt(double x) Returns the cube root of 𝑥 .</th><td>✓</td><td>✓</td></tr><tr><th>double ceil(double x) Returns ceiling of 𝑥 .</th><td>✓</td><td>✓</td></tr><tr><th>double copysign(double x, double y) Create value with given magnitude, copying sign of second value.</th><td>✓</td><td>✓</td></tr><tr><th>double cos(double x) Returns the cosine of 𝑥 .</th><td>✓</td><td>✓</td></tr><tr><th>double cosh(double x) Returns the hyperbolic cosine of 𝑥 .</th><td>✓</td><td>✓</td></tr><tr><th>double cospi(double x) Returns the cosine of 𝜋 · 𝑥 .</th><td>✓</td><td>✓</td></tr><tr><th>double cyl_bessel_i0(double x) Returns the value of the regular modified cylindrical Bessel function of order 0 for 𝑥 .</th><td></td><td></td></tr><tr><th>double cyl_bessel_i1(double x) Returns the value of the regular modified cylindrical Bessel function of order 1 for</th><td>𝑥 .</td><td></td></tr><tr><th>double erf(double x) Returns the error function of 𝑥 .</th><td>✓</td><td>✓</td></tr></tbody></table>
-<p>continues on next page</p>
-<p><strong>**Following table contains:** The table appears to represent a list of mathematical functions, specifically those related to floating-point operations in programming or computational contexts. Each row corresponds to a different function, providing a brief description of what the function does.
-
-The columns in the table seem to indicate some form of categorization or availability of these functions, with checkmarks (✓) suggesting that the function is available or applicable in certain contexts. The second column consistently contains checkmarks, while the third column mostly contains checkmarks, with one exception where it contains the word "of."
-
-Noteworthy observations include:
-- The functions listed are primarily related to mathematical operations involving floating-point numbers, such as calculating remainders, rounding, and computing reciprocal roots.
-- The presence of "of" in the third column for the function `double remquo(double x, double y, int* quo)` suggests a possible error or inconsistency in the data entry for that particular row.</strong></p>
-<table><caption><div class="caption">Table 2 - continued from previous page</div></caption><tbody><tr><td>double erfc(double x) Returns the complementary error function of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><th>double erfcinv(double x) Returns the inverse complementary function of 𝑥 .</th><td>✓</td><td>✓</td></tr><tr><th>double erfcx(double x) Returns the scaled complementary error function of 𝑥 .</th><td>✓</td><td>✓</td></tr><tr><th>double erfinv(double x) Returns the inverse error function of 𝑥 .</th><td>✓</td><td>✓</td></tr><tr><th>double exp(double x) Returns 𝑒 𝑥 .</th><td>✓</td><td>✓</td></tr><tr><th>double exp10(double x) Returns 10 𝑥 .</th><td>✓</td><td>✓</td></tr><tr><th>double exp2( double x) Returns 2 𝑥 .</th><td>✓</td><td>✓</td></tr><tr><th>double expm1(double x) Returns 𝑙𝑛 ( 𝑥 - 1)</th><td>✓</td><td>✓</td></tr><tr><th>double fabs(double x) Returns the absolute value of x</th><td>✓</td><td>✓</td></tr><tr><th>double fdim(double x, double y) Returns the positive difference between 𝑥 and 𝑦 .</th><td>✓</td><td>✓</td></tr></tbody></table>
-<p>continues on next page</p>
-<p><strong>**Following table contains:** The table appears to represent a list of mathematical or computational functions, likely from a programming library or documentation. Each row corresponds to a different function, providing a brief description of what the function does.
-
-The columns are as follows:
-- Column 0: Contains the function signature and a brief description of its purpose.
-- Column 1: Contains a checkmark (✓) indicating some form of validation or availability of the function.
-- Column 2: Also contains a checkmark (✓), possibly indicating another form of validation or compatibility.
-
-Noteworthy values:
-- The first row in Column 0 is empty, which might indicate a header or a placeholder.
-- All functions listed have checkmarks in both Column 1 and Column 2, suggesting that they are all validated or available in the context being described.
-- The function descriptions include mathematical operations such as scaling, sine, and hyperbolic sine, which are common in mathematical libraries.</strong></p>
-<table><caption><div class="caption">Table 2 - continued from previous page</div></caption><tbody><tr><td>double floor(double x) Returns the largest integer less than or equal to 𝑥 .</td><th>✓</th><th>✓</th></tr><tr><th>double fma(double x, double y, double z) Returns 𝑥 · 𝑦 + 𝑧 as a single operation.</th><td>✓</td><td>✓</td></tr><tr><th>double fmax(double x, double y) Determine the maximum numeric value of 𝑥 and 𝑦 .</th><td>✓</td><td>✓</td></tr><tr><th>double fmin(double x, double y) Determine the minimum numeric value of 𝑥 and 𝑦 .</th><td>✓</td><td>✓</td></tr><tr><th>double fmod(double x, double y) Returns the floating-point remainder of 𝑥/𝑦 .</th><td>✓</td><td>✓</td></tr><tr><th>double modf(double x, double* iptr) Break down 𝑥 into fractional and integral parts.</th><td>✓</td><td></td></tr><tr><th>double frexp(double x, int* nptr) Extract mantissa and exponent of 𝑥 .</th><td>✓</td><td></td></tr><tr><th>double hypot(double x, double y) Returns the square root of the sum of squares of 𝑥 and 𝑦 .</th><td>✓</td><td>✓</td></tr><tr><th>int ilogb(double x) Returns the unbiased integer exponent of 𝑥 .</th><td>✓</td><td>✓</td></tr></tbody></table>
-<p>continues on next page</p>
-<p><strong>**Following table contains:** The table appears to represent a list of mathematical functions, specifically those that are likely part of a programming or mathematical library, possibly for a language like C or C++. Each row represents a different mathematical function that can be applied to a variable \( x \).
-
-The columns in the table are as follows:
-- The first column provides the function signature, which includes the return type (`double`), the function name, and the parameters it takes (e.g., `double x` or `int n, double x`).
-- The second column provides a brief description of what the function does, such as calculating the reciprocal of the square root, the tangent, or the Bessel function of a given order.
-- The third column, marked with a check (✓), likely indicates that the function is available or supported in the context being described.
-
-Noteworthy values:
-- All functions listed return a `double` type, indicating they are designed to handle floating-point arithmetic.
-- The functions cover a range of mathematical operations, including trigonometric functions (`tan`, `tanh`), special functions (`tgamma`, Bessel functions `y0`, `y1`, `yn`), and basic arithmetic operations (`trunc`).
-- The presence of Bessel functions of different orders suggests that the library or context is equipped to handle advanced mathematical computations.</strong></p>
-<table><caption><div class="caption">Table 2 - continued from previous page</div></caption><tbody><tr><th>bool isfinite(double x) Determine whether 𝑥 is finite.</th><td>✓</td><td>✓</td></tr><tr><th>bool isin(double x) Determine whether 𝑥 is infinite.</th><td>✓</td><td>✓</td></tr><tr><th>bool isnan(double x) Determine whether 𝑥 is a NAN .</th><td>✓</td><td>✓</td></tr><tr><th>double j0(double x) Returns the value of the Bessel function of the first kind of order 0 for 𝑥 .</th><td>✓</td><td>✓</td></tr><tr><th>double j1(double x) Returns the value of the Bessel function of the first kind of order 1 for 𝑥 .</th><td>✓</td><td>✓</td></tr><tr><th>double jn(int n, double x) Returns the value of the Bessel function of the first kind of order n for 𝑥 .</th><td>✓</td><td>✓</td></tr><tr><th>double ldexp(double x, int exp) Returns the natural logarithm of the absolute value of the gamma function of 𝑥 .</th><td>✓</td><td>✓</td></tr><tr><th>double lgamma(double x) Returns the natural logarithm of the absolute value of the gamma function of 𝑥 .</th><td>✓</td><td></td></tr><tr><th>long int lrint(double x) Round 𝑥 to nearest integer value.</th><td>✓</td><td>✓</td></tr></tbody></table>
-<p>continues on next page</p>
-<p><strong>**Following table contains:** The table represents a comparison of different parallel computing platforms and their respective terminologies or constructs. Each row corresponds to a specific concept or component used in parallel computing, while the columns represent three different platforms: CUDA, HIP, and OpenCL.
-
-- **Columns:**
-  - **Term:** Lists the general concept or component used in parallel computing.
-  - **CUDA:** Shows the specific term or data type used in NVIDIA's CUDA platform for each concept.
-  - **HIP:** Displays the equivalent term or data type used in AMD's HIP (Heterogeneous-Compute Interface for Portability) platform.
-  - **OpenCL:** Provides the corresponding term or data type used in the OpenCL (Open Computing Language) platform.
-
-- **Rows:**
-  - **Device:** Refers to the identifier for a compute device in each platform.
-  - **Queue:** Represents the command queue or stream used to manage execution order.
-  - **Event:** Denotes the event object used for synchronization.
-  - **Memory:** Indicates the data type used for memory objects.
-  - **Grid/NDRange:** Refers to the execution configuration for launching kernels.
-  - **Block/work-group:** Represents a group of threads or work-items.
-  - **Thread/work-item:** Denotes the smallest unit of execution.
-  - **Warp/sub-group:** Refers to a group of threads or work-items that execute together.
-
-- **Noteworthy Values:**
-  - The table highlights the differences and similarities in terminology across the three platforms, which is crucial for developers working with multiple parallel computing environments.
-  - The use of specific data types like `cudaStream_t`, `hipStream_t`, and `cl_command_queue` for queues, and `cudaEvent_t`, `hipEvent_t`, and `cl_event` for events, shows how each platform handles these constructs differently.</strong></p>
-<table><caption><div class="caption">Table 2 - continued from previous page</div></caption><tbody><tr><td>long long int llrint(double x) Round 𝑥 to nearest integer value.</td><td>✓</td><td>✓</td></tr><tr><td>long int lround(double x) Round to nearest integer value.</td><td>✓</td><td>✓</td></tr><tr><td>long long int llround(double x) Round to nearest integer value.</td><td>✓</td><td>✓</td></tr><tr><td>double log10(double x) Returns the base 10 logarithm of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>double log1p(double x) Returns the natural logarithm of 𝑥 +1 .</td><td>✓</td><td>✓</td></tr><tr><td>double log2(double x) Returns the base 2 logarithm of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>double log(double x) Returns the natural logarithm of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>double logb(double x) Returns the floating point representation of the exponent of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>double nan(const char* tagp) Returns &#x27;Not a Number&#x27; value.</td><td></td><td>✓</td></tr><tr><td>double nearbyint(double x) Round 𝑥 to the nearest integer.</td><td>✓</td><td>✓</td></tr></tbody></table>
-<p>continues on next page</p>
-<p><strong>**Following table contains:** The table appears to represent a log or report of warnings generated during the documentation process for a software project, specifically related to the HIP (Heterogeneous-Compute Interface for Portability) project version 6.1.40092. Each row seems to represent a separate warning or issue encountered.
-
-The columns in the table are not clearly defined due to the formatting, but they seem to include:
-- A repeated "Warning:" label, indicating the presence of a warning.
-- A repeated "doxygenfunction:" label, suggesting the context or type of warning related to Doxygen, a documentation generator.
-- A message indicating the inability to find the function 'hipLaunchCooperativeKernel' in the Doxygen XML output.
-- The directory path where the documentation process was executed, which is repeated across the rows.
-
-Noteworthy values include:
-- The specific function 'hipLaunchCooperativeKernel' that could not be found in the documentation, which might be a critical issue if this function is expected to be documented.
-- The consistent directory path suggests that all warnings are related to the same documentation build process, possibly indicating a systemic issue with the documentation generation for this particular version of the HIP project.</strong></p>
-<table><caption><div class="caption">Table 2 - continued from previous page</div></caption><tbody><tr><td></td><td></td><th>✓</th></tr><tr><td>double nextafter(double x, double y) Returns next representable double-precision floating-point value after argument.</td><td>✓</td><td></td></tr><tr><th>double norm3d(double x, double y, double z) Returns the square root of the sum of squares of 𝑥 , 𝑦 and 𝑧 .</th><td>✓</td><td>✓</td></tr><tr><th>double norm4d(double x, double y, double z, double w) Returns the square root of the sum of squares of 𝑥 , 𝑦 , 𝑧 and 𝑤 .</th><td>✓</td><td>✓</td></tr><tr><th>double normcdf(double y) Returns the standard normal cumulative distribution function.</th><td>✓</td><td>✓</td></tr><tr><th>double normcdfinv(double y) Returns the inverse of the standard normal cumulative distribution function.</th><td>✓</td><td>✓</td></tr><tr><th>double norm(int dim, const double *a) Returns the square root of the sum of squares of any number of coordinates.</th><td>✓</td><td>✓</td></tr><tr><th>double pow(double x, double y) Returns 𝑥 𝑦 .</th><td>✓</td><td>✓</td></tr><tr><th>double powi(double base, int iexp) Returns the value of first argument to the power of second argument.</th><td>✓</td><td>✓</td></tr></tbody></table>
-<p>continues on next page</p>
-<p><strong>**Following table contains:** The table appears to represent a log or error report related to the documentation generation process for a software project, specifically the HIP (Heterogeneous-Compute Interface for Portability) project. Each row seems to represent an instance of a warning or error encountered during the documentation build process.
-
-The columns in the table are not clearly defined due to the formatting, but they seem to include:
-- Warning messages indicating issues encountered.
-- References to specific functions or components, such as 'hipLaunchCooperativeKernel', which could not be found in the documentation output.
-- Paths to the location in the file system where the documentation generation process was executed, specifically pointing to directories related to Doxygen XML output.
-
-A noteworthy value is the repeated mention of the function 'hipLaunchCooperativeKernel', which suggests that this function is missing or not properly documented in the generated output. This could be a critical issue if this function is important for the project's documentation. Additionally, the version '6.1.40092' of the HIP documentation is mentioned, indicating the specific version of the documentation that was being processed.</strong></p>
-<table><tbody><tr><td></td><th>Table</th><th>2 - continued from previous page</th></tr><tr><td>double remainder(double x, double y) Returns double-precision floating-point remainder.</td><td>✓</td><td>✓</td></tr><tr><td>double remquo(double x, double y, int* quo) Returns double-precision floating-point remainder and part quotient.</td><td>✓</td><td>of</td></tr><tr><td>double round(double x) Round to nearest integer value in floating-point.</td><td>✓</td><td>✓</td></tr><tr><td>double rcbrt(double x) Returns the reciprocal cube root function.</td><td>✓</td><td>✓</td></tr><tr><td>double rhypot(double x, double y) Returns one over the square root of the sum of squares of two arguments.</td><td>✓</td><td>✓</td></tr><tr><td>double rint(double x) Round input to nearest integer value in floating-point.</td><td>✓</td><td>✓</td></tr><tr><td>double rnorm3d(double x, double y, double z) Returns one over the square root of the sum of squares of three coordinates of the argument.</td><td>✓</td><td>✓</td></tr><tr><td>double rnorm4d(double x, double y, double z, double w) Returns one over the square root of the sum of squares of four coordinates of the argument.</td><td>✓</td><td>✓</td></tr></tbody></table>
-<p>continues on next page</p>
-<p><strong>**Following table contains:** The table appears to represent a log or error report related to the documentation generation process for a project named "HIP" with version "6.1.40092". Each row seems to indicate an instance where a specific function, 'hipLaunchCooperativeKernelMultiDevice', could not be found in the Doxygen XML output. 
-
-The columns are not clearly defined in the preview, but they seem to include:
-- Warning messages indicating the issue.
-- The function name that could not be found.
-- The project name and version.
-- The directory path where the Doxygen XML output was expected to be found.
-
-Noteworthy values include the repeated mention of the function 'hipLaunchCooperativeKernelMultiDevice' and the consistent directory path '/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-6.1.2/docs/doxygen/xml', suggesting that the issue is persistent across multiple attempts or checks.</strong></p>
-<table><caption><div class="caption">Table 2 - continued from previous page</div></caption><tbody><tr><td></td><td>✓</td><td></td></tr><tr><td>double rnorm(int dim, const double *a) Returns the reciprocal of square root of the sum of squares of any number of coordinates.</td><td></td><td>✓</td></tr><tr><td>double scalbln(double x, long int n) Scale 𝑥 by 2 𝑛 .</td><td>✓</td><td>✓</td></tr><tr><td>double scalbn(double x, int n) Scale 𝑥 by 2 𝑛 .</td><td>✓</td><td>✓</td></tr><tr><td>bool signbit(double x) Return the sign bit of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>double sin(double x) Returns the sine of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>double sinh(double x) Returns the hyperbolic sine of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>double sinpi(double x) Returns the hyperbolic sine of 𝜋 · 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>void sincos(double x, double *sptr, double *cptr) Returns the sine and cosine of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>void sincospi(double x, double *sptr, double *cptr) Returns the sine and cosine of 𝜋 · 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>double sqrt(double x) Returns the square root of 𝑥 .</td><td>✓</td><td>✓</td></tr></tbody></table>
-<p>continues on next page</p>
-<p><strong>**Following table contains:** The table appears to represent log entries or error messages related to the documentation generation process for a project named 'HIP' (likely referring to Heterogeneous-Compute Interface for Portability). Each row seems to represent a separate log entry or error message.
-
-The columns in the table include:
-1. **Warning**: This column likely contains the type or category of the message, in this case, a warning.
-2. **in,doxygenfunction**: This column seems to indicate the context or function within which the warning occurred, specifically related to Doxygen, a documentation generator.
-3. **Cannot find xml output for project 'HIP**: This column likely contains the specific warning message, indicating that the XML output for the HIP project could not be found.
-4. **nel',function 6.1.40092**: This column might contain additional details about the function or version number related to the warning.
-5. **'hipModuleLaunchCooperativeKer- Documentation' from directory:**: This column seems to specify the documentation or directory path involved in the warning.
-6. **/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-**: This column provides the file path where the issue occurred.
-
-Noteworthy values include the repeated mention of the inability to find XML output for the HIP project, which suggests a recurring issue in the documentation generation process. The directory paths are consistent across entries, indicating that the problem might be localized to a specific directory or setup.</strong></p>
-<table><caption><div class="caption">Table 2 - continued from previous page</div></caption><tbody><tr><td>double rsqrt(double x) Returns the reciprocal of the square root of 𝑥 .</td><th>✓</th></tr><tr><td>double tan(double x) Returns the tangent of 𝑥 .</td><td>✓</td></tr><tr><td>double tanh(double x) Returns the hyperbolic tangent of 𝑥 .</td><td>✓</td></tr><tr><td>double tgamma(double x) Returns the gamma function of 𝑥 .</td><td>✓</td></tr><tr><td>double trunc(double x) Truncate 𝑥 to the integral part.</td><td>✓</td></tr><tr><td>double y0(double x) Returns the value of the Bessel function of the second kind of order 0 for 𝑥 .</td><td>✓</td></tr><tr><td>double y1(double x) Returns the value of the Bessel function of the second kind of order 1 for 𝑥 .</td><td>✓</td></tr><tr><td>double yn(int n, double x) Returns the value of the Bessel function of the second kind of order n for 𝑥 .</td><td>✓</td></tr></tbody></table>
-<h2>21.3 Integer intrinsics</h2>
-<p>Following is the list of supported integer intrinsics. Note that intrinsics are supported on device only.</p>
-<p>Table 3: Integer intrinsics mathematical functions</p>
-<h2>Function</h2>
-<p>unsigned int __brev(unsigned int x) Reverse the bit order of a 32 bit unsigned integer.</p>
-<p>unsigned long long int __brevll(unsigned long long int x) Reverse the bit order of a 64 bit unsigned integer.</p>
-<p>unsigned int __byte_perm(unsigned int x, unsigned int y, unsigned int z) Return selected bytes from two 32-bit unsigned integers.</p>
-<p>unsigned int __clz(int x) Return the number of consecutive high-order zero bits in 32 bit integer.</p>
-<p>unsigned int __clzll(long long int x) Return the number of consecutive high-order zero bits in 64 bit integer.</p>
-<p>unsigned int __ffs(int x) Find the position of least significant bit set to 1 in a 32 bit integer.</p>
-<p>unsigned int __ffsll(long long int x) Find the position of least significant bit set to 1 in a 64 bit signed integer.</p>
-<p>unsigned int __fns32(unsigned long long mask, unsigned int base, int offset) Find the position of the n-th set to 1 bit in a 32-bit integer.</p>
-<p>unsigned int __fns64(unsigned long long int mask, unsigned int base, int offset) Find the position of the n-th set to 1 bit in a 64-bit integer.</p>
-<p>unsigned int __funnelshift_l(unsigned int lo, unsigned int hi, unsigned int shift) Concatenate ℎ𝑖 and 𝑙𝑜 , shift left by shift &amp; 31 bits, return the most significant 32 bits.</p>
-<p>unsigned int __funnelshift_lc(unsigned int lo, unsigned int hi, unsigned int shift) Concatenate ℎ𝑖 and 𝑙𝑜 , shift left by min(shift, 32) bits, return the most significant 32 bits.</p>
-<p>unsigned int __funnelshift_r(unsigned int lo, unsigned int hi, unsigned int shift) Concatenate ℎ𝑖 and 𝑙𝑜 , shift right by shift &amp; 31 bits, return the least significant 32 bits. 226 Chapter 21. HIP math API</p>
-<p>The HIP-Clang implementation of __ffs() and __ffsll() contains code to add a constant +1 to produce the ffs result format. For the cases where this overhead is not acceptable and programmer is willing to specialize for the platform, HIP-Clang provides __lastbit_u32_u32(unsigned int input) and __lastbit_u32_u64(unsigned long long int input) . The index returned by __lastbit_ instructions starts at -1, while for ffs the index starts at 0.</p>
-<h2>21.4 Floating-point Intrinsics</h2>
-<p>Following is the list of supported floating-point intrinsics. Note that intrinsics are supported on device only.</p>
-<p>Note: Only the nearest even rounding mode supported on AMD GPUs by defaults. The _rz , _ru and _rd suffixed intrinsic functions are existing in HIP AMD backend, if the OCML_BASIC_ROUNDED_OPERATIONS macro is defined.</p>
-<p>Table 4: Single precision intrinsics mathematical functions</p>
-<p>Function float __cosf(float x) Returns the fast approximate cosine of 𝑥 . float __exp10f(float x) Returns the fast approximate for 10 x . float __expf(float x) Returns the fast approximate for e x . float __fadd_rn(float x, float y) Add two floating-point values in round-to-nearest-even mode. float __fdiv_rn(float x, float y) Divide two floating point values in round-to-nearest-even mode. float __fmaf_rn(float x, float y, float z) Returns x × y + z as a single operation in round-to-nearest-even mode. float __fmul_rn(float x, float y) Multiply two floating-point values in round-to-nearest-even mode. float __frcp_rn(float x, float y) Returns 1 / x in round-to-nearest-even mode. float __frsqrt_rn(float x) Returns 1 / x in round-to-nearest-even mode. float __fsqrt_rn(float x) Returns x in round-to-nearest-even mode. float __fsub_rn(float x, float y) Subtract two floating-point values in round-to-nearest-even mode. float __log10f(float x) Returns the fast approximate for base 10 logarithm of 𝑥 . 228 Chapter 21. HIP math API</p>
-<p>Table 5: Double precision intrinsics mathematical functions</p>
-<p>Function double __dadd_rn(double x, double y) Add two floating-point values in round-to-nearest-even mode. double __ddiv_rn(double x, double y) Divide two floating-point values in round-to-nearest-even mode. double __dmul_rn(double x, double y) Multiply two floating-point values in round-to-nearest-even mode. double __drcp_rn(double x, double y) Returns 1 / x in round-to-nearest-even mode. double __dsqrt_rn(double x) Returns x in round-to-nearest-even mode. double __dsub_rn(double x, double y) Subtract two floating-point values in round-to-nearest-even mode. double __fma_rn(double x, double y, double z) Returns x × y + z as a single operation in round-to-nearest-even mode.</p>
-<h2>CHAPTER</h2>
-<h2>TWENTYTWO</h2>
-<h2>TABLE COMPARING SYNTAX FOR DIFFERENT COMPUTE APIS</h2>
-<p><strong>**Following table contains:** The table appears to represent a log or error report related to the documentation generation process for a software project, specifically the HIP (Heterogeneous-Compute Interface for Portability) project version 6.1.40092. Each row seems to capture a specific warning or error message encountered during the process.
-
-- **Rows**: Each row represents a part of the error message or warning related to the documentation generation process using Doxygen, a documentation generator tool.
-
-- **Columns**: 
-  - Columns 0 and 1 contain the word "Warning:", indicating the presence of a warning message.
-  - Columns 2 to 4 contain the word "doxygenfunction:", suggesting that the warning is related to a function within the Doxygen documentation.
-  - Columns 5 and 6 contain the phrase "Cannot find", indicating a missing element in the documentation.
-  - Columns 7 to 9 specify the function 'cooperative_groups::this_multi_grid', which is the subject of the warning.
-  - Column 10 contains the project name and version 'HIP,6.1.40092,Documentation'.
-  - Column 11 indicates the directory path where the issue was encountered.
-
-- **Noteworthy Values**: 
-  - The repeated mention of 'cooperative_groups::this_multi_grid' suggests that this specific function is missing or not documented properly in the Doxygen XML output.
-  - The directory path '/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-' is repeated across the table, indicating the location where the documentation generation process is being executed.
-  - The consistent version '6.1.2/docs/doxygen/xml' in the last column suggests that the issue is specific to this version of the documentation files.</strong></p>
-<table><tbody><tr><th>Term</th><th>CUDA</th><th>HIP</th><th>OpenCL</th></tr><tr><td>Device</td><td>int deviceId</td><td>int deviceId</td><td>cl_device</td></tr><tr><td>Queue</td><td>cudaStream_t</td><td>hipStream_t</td><td>cl_command_queue</td></tr><tr><td>Event</td><td>cudaEvent_t</td><td>hipEvent_t</td><td>cl_event</td></tr><tr><td>Memory</td><td>void *</td><td>void *</td><td>cl_mem</td></tr><tr><td></td><td>grid</td><td>grid</td><td>NDRange</td></tr><tr><td></td><td>block</td><td>block</td><td>work-group</td></tr><tr><td></td><td>thread</td><td>thread</td><td>work-item</td></tr><tr><td></td><td>warp</td><td>warp</td><td>sub-group</td></tr><tr><td>Thread-index</td><td>threadIdx.x</td><td>threadIdx.x</td><td>get_local_id(0)</td></tr><tr><td>Block-index</td><td>blockIdx.x</td><td>blockIdx.x</td><td>get_group_id(0)</td></tr><tr><td>Block-dim</td><td>blockDim.x</td><td>blockDim.x</td><td>get_local_size(0)</td></tr><tr><td>Grid-dim</td><td>gridDim.x</td><td>gridDim.x</td><td>get_num_groups(0)</td></tr><tr><td>Device Kernel</td><td>__global__</td><td>__global__</td><td>__kernel</td></tr><tr><td>Device Function</td><td>__device__</td><td>__device__</td><td>Implied in device com</td></tr><tr><td>Host Function</td><td>__host_ (default)</td><td>__host_ (default)</td><td>Implied in host compil</td></tr><tr><td>Host + Device Function</td><td>__host__ __device__</td><td>__host__ __device__</td><td>No equivalent</td></tr><tr><td>Kernel Launch</td><td>&lt;&lt;&lt; &gt;&gt;&gt;</td><td>hipLaunchKernel / hipLaunchKernelGGL / &lt;&lt;&lt;</td><td>clEnqueueNDRangeK</td></tr><tr><td>Global Memory</td><td>__global__</td><td>__global__</td><td>__global</td></tr><tr><td>Group Memory</td><td>__shared__</td><td>__shared__</td><td>__local</td></tr><tr><td>Constant</td><td>__constant__</td><td>__constant__</td><td>__constant</td></tr><tr><td></td><td>__syncthreads</td><td>__syncthreads</td><td>barrier(CLK_LOCAL</td></tr><tr><td>Atomic Builtins</td><td>atomicAdd</td><td>atomicAdd</td><td>atomic_add</td></tr><tr><td>Precise Math</td><td>cos(f)</td><td>cos(f)</td><td>cos(f)</td></tr><tr><td>Fast Math</td><td>__cos(f)</td><td>__cos(f)</td><td>native_cos(f)</td></tr><tr><td>Vector</td><td>float4</td><td>float4</td><td>float4</td></tr></tbody></table>
-<h2>22.1 Notes</h2>
-<p>The indexing functions (starting with thread-index ) show the terminology for a 1D grid. Some APIs use reverse order of xyz / 012 indexing for 3D grids.</p>
-<h2>CHAPTER</h2>
-<h2>TWENTYTHREE</h2>
-<h2>HIP COOPERATIVE GROUPS API</h2>
-<h2>23.1 Cooperative kernel launches</h2>
-<p>The following host-side functions are used for cooperative kernel launches.</p>
-<p><strong>**Following table contains:** The table appears to represent a structured outline or index, possibly from a documentation or technical manual. Each row represents a different section or subsection of the document, with hierarchical numbering indicating the level of each section.
-
-The columns are as follows:
-- Column 0: Contains section numbers, indicating the hierarchy and order of sections.
-- Column 1: Contains the section titles or descriptions, often with ellipses suggesting continuation or truncation.
-- Column 2: Appears to repeat the section titles or descriptions from Column 1.
-- Column 3: Again repeats the section titles or descriptions, similar to Columns 1 and 2.
-- Column 4: Contains a numeric value, "126," which is consistent across all rows. This could represent a page number, a reference ID, or another form of categorization.
-
-Noteworthy values:
-- The consistent repetition of section titles across Columns 1, 2, and 3 suggests redundancy, possibly for formatting or alignment purposes.
-- The uniform value "126" in Column 4 across all rows is notable, indicating a common attribute or reference for all sections listed.</strong></p>
-<table><tbody><tr><th colspan="2">Warning:</th><th colspan="3">doxygenfunction:</th><th>Cannot</th><th colspan="2">find function</th><th colspan="2">&#x27;hipLaunchCooperativeKernel&#x27; Documentation&#x27;</th><td></td></tr><tr><td>in</td><td>doxygen</td><td>xml</td><td>output</td><td>for project</td><td>&#x27;HIP</td><td>6.1.40092</td><td>from</td><td>directory:</td><td></td></tr><tr><td colspan="11">/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-</td></tr><tr><td colspan="11">6.1.2/docs/doxygen/xml</td></tr></tbody></table>
-<p><strong>**Following table contains:** The table appears to be a log or error message related to the generation of documentation using Doxygen, a tool for generating documentation from annotated source code. The rows represent individual entries or lines in the log file. The columns seem to be parts of a single message rather than distinct data fields, as they are separated by commas but form a continuous sentence when read together.
-
-The columns contain the following information:
-- The first two columns contain the word "Warning:", indicating that the message is a warning.
-- The next several columns contain the word "doxygenfunction:", which might be a tag or label used in the log.
-- The message then states "Cannot find function 'cooperative_groups::coalesced_threads','cooperative_groups::coalesced_threads'", indicating that there is a missing function or reference in the Doxygen XML output.
-- The message specifies that this issue is related to the project 'HIP 6.1.40092 Documentation', suggesting that the documentation for this specific version of the HIP project is incomplete or has errors.
-- The final part of the message mentions "from directory:", which might indicate the location where the Doxygen tool was searching for the function or where the documentation files are stored.
-
-Noteworthy values:
-- The repeated mention of "cooperative_groups::coalesced_threads" suggests that this specific function is missing or not properly documented.
-- The warning is associated with the 'HIP 6.1.40092 Documentation', which could be important for developers or users relying on this version of the documentation.</strong></p>
-<table><tbody><tr><th colspan="2">Warning:</th><th colspan="3">doxygenfunction: project</th><th colspan="2">Cannot</th><th colspan="2">find function</th><th colspan="3">&#x27;hipLaunchCooperativeKernel&#x27;</th></tr><tr><td>in</td><td>doxygen</td><td>xml</td><td>output</td><td>for</td><td></td><td>&#x27;HIP</td><td colspan="2">6.1.40092</td><td>Documentation&#x27;</td><td>from</td></tr><tr><td colspan="12">/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-</td></tr><tr><td colspan="12">6.1.2/docs/doxygen/xml</td></tr></tbody></table>
-<p><strong>**Following table contains:** The table appears to represent a log or error report related to the documentation generation process for a software project, specifically the HIP (Heterogeneous-Compute Interface for Portability) version 6.1.40092. Each row seems to indicate an instance where a specific function, `cooperative_groups::tiled_partition`, could not be found in the Doxygen XML output for the project.
-
-### Rows:
-- Each row represents a repeated warning message indicating the absence of a specific function in the generated documentation files.
-
-### Columns:
-- The columns contain parts of the warning message, which are repeated across the table. The message indicates:
-  - A warning about the inability to find a function.
-  - The specific function name: `cooperative_groups::tiled_partition`.
-  - The project name and version: 'HIP,6.1.40092,Documentation'.
-  - The directory path where the documentation was expected to be found.
-
-### Noteworthy Values:
-- The function `cooperative_groups::tiled_partition` is consistently mentioned as missing in the documentation output.
-- The directory path is repeated multiple times, indicating that the issue might be persistent across different documentation builds or checks.
-- The repetition of the warning message suggests a systematic issue in the documentation generation process for this particular function.</strong></p>
-<table><tbody><tr><th colspan="2">Warning:</th><th colspan="3">doxygenfunction:</th><th>Cannot</th><th>find</th><th>function</th><th colspan="3">&#x27;hipLaunchCooperativeKernelMultiDe-</th></tr><tr><td>vice&#x27;</td><td>in</td><td>doxygen</td><td>xml</td><td>output for</td><td>project</td><td>&#x27;HIP</td><td>6.1.40092</td><td>Documentation&#x27;</td><td>from</td><td>directory:</td></tr><tr><td colspan="11">/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-</td></tr><tr><td colspan="11">6.1.2/docs/doxygen/xml</td></tr></tbody></table>
-<p><strong>**Following table contains:** The table appears to represent a log or report related to documentation generation for a project named 'HIP Documentation'. Each row seems to indicate a specific instance or occurrence of a warning or error related to the documentation process.
-
-- **Rows**: Each row represents a specific warning or error message encountered during the generation of documentation using Doxygen for the HIP project.
-
-- **Columns**: 
-  - The first few columns contain repeated warnings about the inability to find a specific function, 'cooperative_groups::tiled_partition', in the Doxygen XML output.
-  - The subsequent columns provide details about the project and directory path where the issue was encountered, specifically pointing to the directory path where the Doxygen XML files are located.
-
-- **Noteworthy Values**: 
-  - The repeated warning about the missing function 'cooperative_groups::tiled_partition' suggests a persistent issue in the documentation generation process.
-  - The directory path is consistently pointing to a specific location under '/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-', indicating where the documentation files are being processed.
-
-Overall, the table highlights a documentation generation issue that needs to be addressed, specifically related to the missing function in the Doxygen output.</strong></p>
-<table><tbody><tr><th colspan="2">Warning: in</th><th colspan="2">doxygenfunction: Cannot find xml output for project &#x27;HIP</th><td></td></tr><tr><td>nel&#x27;</td><td>function 6.1.40092</td><td>&#x27;hipModuleLaunchCooperativeKer- Documentation&#x27; from directory:</td><td></td></tr><tr><td colspan="4">/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-</td></tr><tr><td colspan="4">6.1.2/docs/doxygen/xml</td></tr></tbody></table>
-<p>Warning: doxygenfunction: Cannot find function 'hipModuleLaunchCooperativeKernelMultiDevice' in doxygen xml output for project 'HIP 6.1.40092 Documentation' from directory: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs6.1.2/docs/doxygen/xml</p>
-<h2>23.2 Cooperative groups classes</h2>
-<p>The following cooperative groups classes can be used on the device side.</p>
-<h2>class thread_group</h2>
-<p>The base type of all cooperative group types.</p>
-<p>Holds the key properties of a constructed cooperative group types object, like the group type, its size, etc.</p>
-<p>Note: Cooperative groups feature is implemented on Linux, under development on Microsoft Windows.</p>
-<p>Subclassed by cooperative_groups::coalesced_group , cooperative_groups::grid_group , coopera-tive_groups::multi_grid_group , cooperative_groups::thread_block , cooperative_groups::tiled_group class thread_block : public cooperative_groups:: thread_group</p>
-<p>The workgroup (thread-block in CUDA terminology) cooperative group type.</p>
-<p>Represents an intra-workgroup cooperative group type, where the participating threads within the group are the same threads that participated in the currently executing workgroup .</p>
-<p>Note: This function is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>class grid_group : public cooperative_groups:: thread_group</p>
-<p>The grid cooperative group type.</p>
-<p>Represents an inter-workgroup cooperative group type, where the participating threads within the group spans across multiple workgroups running the (same) kernel on the same device.</p>
-<p>Note: This is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>class multi_grid_group : public cooperative_groups:: thread_group</p>
-<p>The multi-grid cooperative group type.</p>
-<p>Represents an inter-device cooperative group type, where the participating threads within the group span across multiple devices, running the (same) kernel on these devices.</p>
-<p>Note: The multi-grid cooperative group type is implemented on Linux, under development on Microsoft Windows.</p>
-<h2>template&lt;unsigned int size , class ParentCGTy &gt;</h2>
-<p>class thread_block_tile : public cooperative_groups::impl::thread_block_tile_internal&lt; size , ParentCGTy &gt; Group type -thread_block_tile .</p>
-<p>Represents one tiled thread group in a wavefront. This group type also supports sub-wave level intrinsics.</p>
-<p>Note: This type is implemented on Linux, under development on Microsoft Windows.</p>
-<h2>Public Functions</h2>
-<p>unsigned int thread_rank () const</p>
-<p>Rank of the calling thread within [0, size() ).</p>
-<h2>void sync ()</h2>
-<p>Synchronizes the threads in the group.</p>
-<p>Causes all threads in the group to wait at this synchronization point, and for all shared and global memory accesses by the threads to complete, before running synchronization. This guarantees the visibility of accessed data for all threads in the group.</p>
-<p>Note: There are potential read-after-write (RAW), write-after-read (WAR), or write-after-write (WAW) hazards, when threads in the group access the same addresses in shared or global memory. The data hazards can be avoided with synchronization of the group.</p>
-<h2>unsigned int meta_group_rank () const</h2>
-<p>Returns the linear rank of the group within the set of tiles partitioned from a parent group (bounded by meta_group_size)</p>
-<p>unsigned int meta_group_size () const</p>
-<p>Returns the number of groups created when the parent group was partitioned.</p>
-<h2>template&lt;class T &gt;</h2>
-<p>T shfl ( T var, int srcRank ) const</p>
-<p>Shuffle operation on group level.</p>
-<p>Exchanging variables between threads without use of shared memory. Shuffle operation is a direct copy of var from srcRank thread ID of group.</p>
-<h2>Template Parameters</h2>
-<p>T - The type can be a 32-bit integer or single-precision floating point.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">var - [in] The source variable to copy. Only the srcRank thread ID of group is copied to other threads.</li>
-<li style="list-style-type: '· ';">srcRank - [in] The source thread ID of the group for copy.</li>
-</ul>
-<h2>template&lt;class T &gt;</h2>
-<p>T shfl_down ( T var, unsigned int lane_delta ) const</p>
-<p>Shuffle down operation on group level.</p>
-<p>Exchanging variables between threads without use of shared memory. Shuffle down operation is copy of var from thread with thread ID of group relative higher with lane_delta to caller thread ID.</p>
-<h2>Template Parameters</h2>
-<p>T - The type can be a 32-bit integer or single-precision floating point.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">var - [in] The source variable to copy.</li>
-<li style="list-style-type: '· ';">lane_delta - [in] The lane_delta is the relative thread ID difference between caller thread ID and source of copy thread ID. sourceID = (threadID + lane_delta) % size()</li>
-</ul>
-<p>template&lt;class T &gt;</p>
-<h2>T shfl_up ( T var, unsigned int lane_delta ) const</h2>
-<p>Shuffle up operation on group level.</p>
-<p>Exchanging variables between threads without use of shared memory. Shuffle up operation is copy of var from thread with thread ID of group relative lower with lane_delta to caller thread ID.</p>
-<h2>Template Parameters</h2>
-<p>T - The type can be a 32-bit integer or single-precision floating point.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">var - [in] The source variable to copy.</li>
-<li style="list-style-type: '· ';">lane_delta - [in] The lane_delta is the relative thread ID difference between caller thread ID and source of copy thread ID. sourceID = (threadID - lane_delta) % size()</li>
-</ul>
-<h2>template&lt;class T &gt;</h2>
-<p>T shfl_xor ( T var, unsigned int laneMask ) const</p>
-<p>Shuffle xor operation on group level.</p>
-<p>Exchanging variables between threads without use of shared memory. Shuffle xor operation is copy of var from thread with thread ID of group based on laneMask XOR of the caller thread ID.</p>
-<h2>Template Parameters</h2>
-<ul>
-<li>T - The type can be a 32-bit integer or single-precision floating point.</li>
-</ul>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">var - [in] The source variable to copy.</li>
-<li style="list-style-type: '· ';">laneMask - [in] The laneMask is the mask for XOR operation. sourceID = threadID ^ laneMask</li>
-</ul>
-<p>unsigned long long ballot ( int pred ) const</p>
-<p>Ballot function on group level.</p>
-<p>Returns a bit mask with the Nth bit set to one if the Nth thread predicate evaluates true.</p>
-<h2>Parameters</h2>
-<p>pred - [in] The predicate to evaluate on group threads.</p>
-<p>int any ( int pred ) const</p>
-<p>Any function on group level.</p>
-<p>Returns non-zero if a predicate evaluates true for any threads.</p>
-<h2>Parameters</h2>
-<p>pred - [in] The predicate to evaluate on group threads.</p>
-<p>int all ( int pred ) const</p>
-<p>All function on group level.</p>
-<p>Returns non-zero if a predicate evaluates true for all threads.</p>
-<h2>Parameters</h2>
-<p>pred - [in] The predicate to evaluate on group threads.</p>
-<p>template&lt;typename T &gt;</p>
-<p>unsigned long long match_any ( T value ) const</p>
-<p>Match any function on group level.</p>
-<p>Returns a bit mask containing a 1-bit for every participating thread if that thread has the same value in value as the caller thread.</p>
-<h2>Parameters</h2>
-<p>value - [in] The value to examine on the current thread in group.</p>
-<p>template&lt;typename T &gt; unsigned long long match_all ( T value, int &amp;pred ) const</p>
-<p>Match all function on group level.</p>
-<p>Returns a bit mask containing a 1-bit for every participating thread if they all have the same value in value as the caller thread. The predicate pred is set to true if all participating threads have the same value in value .</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">value - [in] The value to examine on the current thread in group.</li>
-<li style="list-style-type: '· ';">pred - [out] The predicate is set to true if all participating threads in the thread group have the same value.</li>
-</ul>
-<p>class coalesced_group : public cooperative_groups:: thread_group</p>
-<p>The coalesced_group cooperative group type.</p>
-<p>Represents an active thread group in a wavefront. This group type also supports sub-wave level intrinsics.</p>
-<p>Note: This is implemented on Linux and is under development on Microsoft Windows.</p>
-<h2>23.3 Cooperative groups construct functions</h2>
-<p>The following functions are used to construct different group-type instances on the device side.</p>
-<p><strong>**Following table contains:** The table appears to represent a log or error report related to the generation of documentation for a software project, specifically the HIP (Heterogeneous-Compute Interface for Portability) project. Each row seems to represent a specific warning or error message encountered during the documentation generation process.
-
-The columns in the table include:
-- Repeated "Warning:" labels, indicating that each entry is a warning message.
-- "doxygenfunction:" labels, suggesting that the warnings are related to specific functions or elements within the Doxygen documentation tool.
-- "Cannot find" and "function" columns, which specify the particular function or element that could not be found in the Doxygen XML output.
-- Specific function names, such as 'cooperative_groups::binary_partition', indicating the functions that are missing or causing issues.
-
-A noteworthy value is the repeated mention of the function 'cooperative_groups::binary_partition', which suggests that this function is consistently not found in the Doxygen XML output, potentially indicating a documentation or code issue that needs to be addressed. Additionally, the path '/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-' is repeated, indicating the location where the documentation build process is taking place.</strong></p>
-<table><tbody><tr><td colspan="2">Warning:</td><td colspan="3">doxygenfunction:</td><td colspan="2">Cannot find</td><td colspan="2">function</td><td colspan="3">&#x27;cooperative_groups::this_multi_grid&#x27;</td><td></td></tr><tr><td>in</td><td>doxygen</td><td>xml</td><td>output</td><td>for</td><td>project</td><td>&#x27;HIP</td><td>6.1.40092</td><td>Documentation&#x27;</td><td>from</td><td>directory:</td><td></td></tr><tr><td colspan="12">/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-</td></tr><tr><td colspan="12">6.1.2/docs/doxygen/xml</td></tr></tbody></table>
-<p>Warning: doxygenfunction: Cannot find function 'cooperative_groups::this_grid' in doxygen xml output for project 'HIP 6.1.40092 Documentation' from directory: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs6.1.2/docs/doxygen/xml</p>
-<p>Warning: doxygenfunction: Cannot find function 'cooperative_groups::this_thread_block' in doxygen xml output for project 'HIP 6.1.40092 Documentation' from directory: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs6.1.2/docs/doxygen/xml</p>
-<p><strong>**Following table contains:** The table appears to represent a log or error report related to the generation of documentation using Doxygen for a project named 'HIP Documentation'. Each row seems to capture a specific warning or error message encountered during this process.
-
-- **Rows**: Each row represents a specific instance of a warning or error message related to the Doxygen documentation generation process for the HIP project.
-
-- **Columns**: 
-  - The first few columns contain repeated warnings and references to a specific function, `cooperative_groups::binary_partition`, indicating that there is an issue with finding this function in the Doxygen XML output.
-  - The subsequent columns provide context about the project ('HIP Documentation') and the directory path where the documentation generation was attempted.
-
-- **Noteworthy Values**: 
-  - The repeated mention of the function `cooperative_groups::binary_partition` suggests a recurring issue with this specific function not being found in the Doxygen XML output.
-  - The directory path `/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-` indicates where the documentation files are located, and the version `6.1.2` is specified, which might be relevant for troubleshooting or version control.</strong></p>
-<table><tbody><tr><th colspan="2">Warning:</th><th colspan="3">doxygenfunction:</th><th>Cannot</th><th>find</th><th>function</th><th colspan="2">&#x27;cooperative_groups::coalesced_threads&#x27;</th><td></td></tr><tr><td>in</td><td>doxygen</td><td>xml</td><td>output</td><td>for</td><td>project</td><td>&#x27;HIP</td><td>6.1.40092</td><td>Documentation&#x27;</td><td>from</td><td>directory:</td></tr></tbody></table>
-<p>/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs6.1.2/docs/doxygen/xml</p>
-<p><strong>**Following table contains:** The table appears to represent a log or error report related to the documentation generation process for a software project, specifically the HIP (Heterogeneous-Compute Interface for Portability) project. Each row seems to represent a specific warning or error encountered during the documentation generation process using Doxygen, a documentation generator tool.
-
-The columns in the table include:
-- Repeated "Warning:" labels, indicating that the entries are warnings.
-- "doxygenfunction: project" repeated multiple times, suggesting that the warnings are related to a specific function or feature within the project.
-- "Cannot find function 'cooperative_groups::group_size'", indicating a specific function that could not be found in the documentation output.
-- Additional columns appear to be empty or contain repeated directory paths.
-
-Noteworthy values include:
-- The repeated mention of the function 'cooperative_groups::group_size', which suggests that this function is missing or not properly documented in the Doxygen output.
-- The directory paths indicate the location where the documentation generation process was attempted, specifically within the version 6.1.2 of the HIP project documentation.
-
-Overall, the table highlights issues in the documentation process, specifically the inability to locate a particular function in the generated documentation.</strong></p>
-<table><tbody><tr><th colspan="2">Warning:</th><th colspan="3">doxygenfunction:</th><th colspan="2">Cannot find</th><th colspan="2">function</th><th colspan="3">&#x27;cooperative_groups::tiled_partition&#x27;</th><td></td></tr><tr><td>in</td><td>doxygen</td><td>xml</td><td>output</td><td>for</td><td>project</td><td>&#x27;HIP</td><td>6.1.40092</td><td>Documentation&#x27;</td><td>from</td><td>directory:</td><td></td></tr><tr><td colspan="12">/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-</td></tr><tr><td colspan="12">6.1.2/docs/doxygen/xml</td></tr></tbody></table>
-<p><strong>**Following table contains:** The table appears to represent a log or error report related to documentation generation for a project associated with Advanced Micro Devices (AMD) HIP (Heterogeneous-Compute Interface for Portability). Each row seems to represent an instance of a warning or error encountered during the documentation generation process using Doxygen, a documentation generator tool.
-
-The columns in the table include:
-- Repeated warnings indicating issues with finding specific functions or components ('HIP', 'cooperative_groups::thread_rank') in the Doxygen XML output.
-- The project version or identifier ('6.1.40092') and the directory path where the documentation generation was attempted.
-
-Noteworthy values include:
-- The repeated mention of the inability to find 'HIP' and 'cooperative_groups::thread_rank' functions, suggesting a persistent issue in the documentation process.
-- The directory path '/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-' indicates the location where the documentation build was attempted, which might be useful for troubleshooting.
-- The version '6.1.40092' could be relevant for identifying the specific build or release of the project being documented.</strong></p>
-<table><tbody><tr><td colspan="2">Warning:</td><th colspan="3">doxygenfunction:</th><th colspan="2">Cannot</th><th colspan="2">find</th><th colspan="3">function &#x27;cooperative_groups::tiled_partition&#x27; 6.1.40092</th><td></td><td></td></tr><tr><td>in</td><td>doxygen</td><td>xml</td><td>output</td><td>for</td><td>project</td><td>&#x27;HIP</td><td>Documentation&#x27;</td><td>from</td><td>directory:</td><td></td><td></td></tr><tr><td colspan="12">/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-</td></tr><tr><td colspan="12">6.1.2/docs/doxygen/xml</td></tr></tbody></table>
-<p><strong>**Following table contains:** The table appears to represent a list of C++ functions and classes related to a programming library, possibly for GPU computing given the context of "hip" functions, which are associated with the HIP (Heterogeneous-Compute Interface for Portability) API. Each row seems to represent a specific C++ class or function, along with associated functions or methods.
-
-### Columns:
-- **Column 0**: Appears to list C++ classes or functions, possibly from a cooperative groups library or similar.
-- **Column 1**: Lists associated C++ functions, possibly indicating dependencies or related operations, along with a numerical value that could represent a reference page, version number, or some form of identifier.
-- **Columns 2-6**: These columns are mostly empty, suggesting they might be placeholders for additional information or metadata that is not included in this preview.
-
-### Noteworthy Values:
-- The repeated mention of "hip" functions suggests a focus on GPU or parallel computing.
-- The numerical values following the function names (e.g., 183, 237, 234) might indicate reference pages, version numbers, or identifiers, but their exact meaning is not clear from the preview.
-- The presence of cooperative group classes (e.g., `cooperative_groups::coalesced_group`, `cooperative_groups::grid_group`) suggests a focus on parallel computing constructs.
-
-Overall, the table seems to be a reference or index of C++ functions and classes, possibly for developers working with GPU computing libraries.</strong></p>
-<table><tbody><tr><th colspan="2">Warning:</th><th colspan="3">doxygenfunction:</th><th colspan="2">Cannot find</th><th colspan="2">function</th><th colspan="3">&#x27;cooperative_groups::binary_partition&#x27;</th></tr><tr><td>in</td><td>doxygen</td><td>xml</td><td>output</td><td>for</td><td>project</td><td>&#x27;HIP</td><td></td><td>6.1.40092</td><td>Documentation&#x27;</td><td>from</td></tr><tr><td colspan="12">/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-</td></tr><tr><td colspan="12">6.1.2/docs/doxygen/xml</td></tr></tbody></table>
-<p><strong>**Following table contains:** The table appears to represent a list of C++ functions related to memory management, likely in the context of GPU programming with HIP (Heterogeneous-Compute Interface for Portability). Each row corresponds to a specific C++ function, and the columns provide additional information about these functions.
-
-- The first column lists the name of the C++ function, which is related to memory allocation or management.
-- The subsequent columns seem to contain numerical values, which could represent line numbers, error codes, or some form of identifiers associated with these functions.
-
-Noteworthy observations:
-- The function `hipMallocManaged` is associated with the numbers 247 and 249, suggesting it might have multiple entries or references.
-- The functions `hipMemAddressFree` and `hipMemAddressReserve` both have the number 251, indicating a possible shared characteristic or reference point.
-- The function `hipMallocFromPoolAsync` has two numbers, 153 and 160, which might indicate different contexts or usages.
-
-Overall, the table provides a structured overview of various HIP memory management functions and their associated numerical data, which could be useful for debugging, documentation, or analysis purposes.</strong></p>
-<table><tbody><tr><td colspan="2">Warning:</td><th colspan="3">doxygenfunction:</th><th colspan="2">Cannot find</th><th colspan="3">function &#x27;cooperative_groups::binary_partition&#x27; 6.1.40092</th></tr><tr><td>in</td><td>doxygen</td><td>xml</td><td>output</td><td>for</td><td>project</td><td>&#x27;HIP</td><td>Documentation&#x27;</td><td>from</td><td>directory:</td></tr><tr><td colspan="11">/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-</td></tr><tr><td colspan="11">6.1.2/docs/doxygen/xml</td></tr></tbody></table>
-<h2>23.4 Cooperative groups exposed API functions</h2>
-<p>The following functions are the exposed API for different group-type instances on the device side.</p>
-<p><strong>**Following table contains:** The table appears to represent a list of C++ functions related to memory pool operations, possibly from a library or API documentation. Each row corresponds to a specific function or a set of functions, along with an associated numerical value, which might represent a version number, an identifier, or a priority level.
-
-The columns are as follows:
-- The first column lists the function names along with their associated numerical values. Some entries contain multiple functions separated by spaces.
-- The second column seems to duplicate the first column, suggesting that the table might be intended for comparison or verification purposes.
-
-Noteworthy values:
-- The functions listed are all related to memory pool operations, such as exporting, importing, setting attributes, and prefetching.
-- The numerical values associated with each function range from 155 to 247, with "hipMemPrefetchAsync" having the highest value of 247, which might indicate its significance or a different categorization compared to the others.
-- There is a noticeable repetition of function names and values across both columns, indicating potential redundancy or a need for data cleaning.</strong></p>
-<table><tbody><tr><th colspan="2">Warning:</th><th colspan="4">doxygenfunction: project</th><th colspan="2">Cannot find</th><th colspan="2">function</th><th colspan="3">&#x27;cooperative_groups::group_size&#x27;</th><td></td><td></td><td></td></tr><tr><td>in</td><td>doxygen</td><td>xml</td><td>output</td><td>for</td><td>&#x27;HIP</td><td>6.1.40092</td><td>Documentation&#x27;</td><td>from</td><td>directory:</td><td></td><td></td><td></td></tr><tr><td colspan="13">/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-</td></tr><tr><td colspan="13">6.1.2/docs/doxygen/xml</td></tr></tbody></table>
-<p><strong>**Following table contains:** The table appears to represent a dataset where each row corresponds to a specific data field or variable, as indicated by the sequence numbers in the third column (e.g., 18.4.4.3.18, 18.4.4.3.19, etc.). The columns are as follows:
-
-- Column 0 and 1: These columns are empty and do not contain any data.
-- Column 2: Contains identifiers for each data field or variable, formatted as a sequence of numbers (e.g., 18.4.4.3.18).
-- Column 3: Describes the type or category of the data field, consistently labeled as "Data Fields - Variables."
-- Column 4: Appears to contain a placeholder or repeated pattern of dots, possibly indicating missing or unspecified information.
-- Column 5: Contains the value "126" for each row, which might represent a code, category, or a constant value associated with each data field.
-
-Noteworthy observations include the consistent use of "126" in the last column for all rows, suggesting a uniform characteristic or classification across all data fields. Additionally, the repetitive pattern of dots in column 4 might indicate incomplete data or a placeholder for future information.</strong></p>
-<table><tbody><tr><th colspan="2">Warning:</th><th colspan="5">doxygenfunction: Cannot</th><th colspan="3">find &#x27;HIP</th><th colspan="3">function &#x27;cooperative_groups::thread_rank&#x27;</th><td></td></tr><tr><td>in</td><td>doxygen</td><td>xml</td><td>output</td><td>for</td><td>project</td><td></td><td>6.1.40092</td><td>Documentation&#x27;</td><td>from</td><td>directory:</td><td></td></tr><tr><td colspan="13">/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-</td></tr><tr><td colspan="13">6.1.2/docs/doxygen/xml</td></tr></tbody></table>
-<p>Warning: doxygenfunction: Cannot find function 'cooperative_groups::is_valid' in doxygen xml output for project 'HIP 6.1.40092 Documentation' from directory: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs6.1.2/docs/doxygen/xml</p>
-<p>Warning: doxygenfunction: Cannot find function 'cooperative_groups::sync' in doxygen xml output for project 'HIP 6.1.40092 Documentation' from directory: /home/docs/checkouts/readthedocs.org/user_builds/advancedmicro-devices-hip/checkouts/docs-6.1.2/docs/doxygen/xml</p>
-<h2>CHAPTER</h2>
-<h2>TWENTYFOUR</h2>
-<h2>HSA RUNTIME API FOR ROCM</h2>
-<p>The following functions are located in the https://github.com/ROCm/ROCR-Runtime repository.</p>
-<p>hsa_status_t hsa_amd_vmem_address_reserve ( void **va, size_t size, uint64_t address, uint64_t flags )</p>
-<p>Allocate a reserved address range.</p>
-<p>Reserve a virtual address range. The size must be a multiple of the system page size. If it is not possible to allocate the address specified by address , then va will be a different address range. Address range should be released by calling hsa_amd_vmem_address_free.</p>
-<p>Note that this API will be deprecated in a future release and replaced by hsa_amd_vmem_address_reserve_align</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">va -[out] virtual address allocated</li>
-<li style="list-style-type: '· ';">size -[in] of address range requested</li>
-<li style="list-style-type: '· ';">address -[in] requested</li>
-<li style="list-style-type: '· ';">flags -[in] currently unsupported</li>
-</ul>
-<h2>Return values</h2>
-<ul>
-<li style="list-style-type: '· ';">::HSA_STATUS_SUCCESS - Address range allocated successfully</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_NOT_INITIALIZED - The HSA runtime has not been initialized.</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_OUT_OF_RESOURCES - Insufficient resources to allocate an address range of this size.</li>
-</ul>
-<p>hsa_status_t hsa_amd_vmem_address_free ( void *va, size_t size )</p>
-<p>Free a reserved address range.</p>
-<p>Free a previously allocated address range. The size must match the size of a previously allocated address range.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">va -[out] virtual address to be freed</li>
-<li style="list-style-type: '· ';">size -[in] of address range</li>
-</ul>
-<h2>Return values</h2>
-<ul>
-<li style="list-style-type: '· ';">::HSA_STATUS_SUCCESS - Address range released successfully</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_INVALID_ALLOCATION - Invalid va specified</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_INVALID_ARGUMENT - Invalid size specified</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_RESOURCE_FREE - Address range is still in use</li>
-</ul>
-<p>· ::HSA_STATUS_ERROR - Internal unexpected error</p>
-<p>hsa_status_t hsa_amd_vmem_handle_create ( hsa_amd_memory_pool_t pool, size_t size, hsa_amd_memory_type_t type, uint64_t flags, hsa_amd_vmem_alloc_handle_t *memory_handle</p>
-<p>)</p>
-<p>Create a virtual memory handle.</p>
-<p>Create a virtual memory handle within this pool size must be a aligned to allocation granule size for this memory pool, see HSA_AMD_MEMORY_POOL_INFO_RUNTIME_ALLOC_GRANULE To minimize internal memory fragmentation, align the size to the recommended allocation granule size, see HSA_AMD_MEMORY_POOL_INFO_RUNTIME_ALLOC_REC_GRANULE</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">pool -[in] memory to use</li>
-<li style="list-style-type: '· ';">size -[in] of the memory allocation</li>
-<li style="list-style-type: '· ';">type -[in] of memory</li>
-<li style="list-style-type: '· ';">flags -[in] - currently unsupported</li>
-<li style="list-style-type: '· ';">memory_handle -[out] - handle for the allocation</li>
-</ul>
-<h2>Return values</h2>
-<ul>
-<li style="list-style-type: '· ';">::HSA_STATUS_SUCCESS - memory allocated successfully</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_NOT_INITIALIZED - The HSA runtime has not been initialized.</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_INVALID_ARGUMENT - Invalid arguments</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_INVALID_ALLOCATION - This memory pool does not support allocations</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_OUT_OF_RESOURCES - Insufficient resources to allocate this memory</li>
-</ul>
-<p>hsa_status_t hsa_amd_vmem_handle_release ( hsa_amd_vmem_alloc_handle_t memory_handle )</p>
-<p>Release a virtual memory handle.</p>
-<h2>Parameters</h2>
-<p>memory -[in] handle that was previously allocated</p>
-<h2>Return values</h2>
-<ul>
-<li style="list-style-type: '· ';">::HSA_STATUS_SUCCESS - Address range allocated successfully</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_INVALID_ALLOCATION - Invalid memory handle</li>
-</ul>
-<p>hsa_status_t hsa_amd_vmem_map ( void *va, size_t size, size_t in_offset, hsa_amd_vmem_alloc_handle_t memory_handle, uint64_t flags )</p>
-<p>Map a virtual memory handle.</p>
-<p>Map a virtual memory handle to a reserved address range. The virtual address requested must be within a previously reserved address range. va and ( va + size) must be must be within (va + size) of the previous allocated address range. size must be equal to size of the memory_handle hsa_amd_vmem_set_access needs to be called to make the memory accessible to specific agents</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">va -[in] virtual address range where memory will be mapped</li>
-<li style="list-style-type: '· ';">size -[in] of memory mapping</li>
-<li style="list-style-type: '· ';">in_offset -[in] offset into memory. Currently unsupported</li>
-</ul>
-<ul>
-<li style="list-style-type: '· ';">memory_handle -[in] virtual memory handle to be mapped</li>
-<li style="list-style-type: '· ';">flags. -[in] Currently unsupported</li>
-</ul>
-<h2>Return values</h2>
-<ul>
-<li style="list-style-type: '· ';">::HSA_STATUS_SUCCESS - Memory mapped successfully</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_INVALID_ARGUMENT - va, size or memory_handle are invalid</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_OUT_OF_RESOURCES - Insufficient resources</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR - Unexpected internal error</li>
-</ul>
-<h2>hsa_status_t hsa_amd_vmem_unmap ( void *va, size_t size )</h2>
-<p>Unmap a virtual memory handle.</p>
-<p>Unmap previously mapped virtual address range</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">va -[in] virtual address range where memory will be mapped</li>
-<li style="list-style-type: '· ';">size -[in] of memory mapping</li>
-</ul>
-<h2>Return values</h2>
-<ul>
-<li style="list-style-type: '· ';">::HSA_STATUS_SUCCESS - Memory backing unmapped successfully</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_INVALID_ALLOCATION - memory_handle is invalid</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_INVALID_ARGUMENT - size is invalid</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR - Unexpected internal error</li>
-</ul>
-<p>hsa_status_t hsa_amd_vmem_set_access ( void *va, size_t size, const hsa_amd_memory_access_desc_t *desc, size_t desc_cnt )</p>
-<p>Make a memory mapping accessible.</p>
-<p>Make previously mapped virtual address accessible to specific agents. size must be equal to size of previously mapped virtual memory handle. Calling hsa_amd_vmem_set_access multiple times on the same va will overwrite previous permissions for all agents</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">va -[in] previously mapped virtual address</li>
-<li style="list-style-type: '· ';">size -[in] of memory mapping</li>
-<li style="list-style-type: '· ';">desc -[in] list of access permissions for each agent</li>
-<li style="list-style-type: '· ';">desc_cnt -[in] number of elements in desc</li>
-</ul>
-<h2>Return values</h2>
-<ul>
-<li style="list-style-type: '· ';">::HSA_STATUS_SUCCESS -</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_INVALID_ARGUMENT - va, size or memory_handle are invalid</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_INVALID_ALLOCATION - memory_handle is invalid</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_OUT_OF_RESOURCES - Insufficient resources</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_INVALID_AGENT - Invalid agent in desc</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR - Unexpected internal error</li>
-</ul>
-<p>hsa_status_t hsa_amd_vmem_get_access ( void *va, hsa_access_permission_t *perms, hsa_agent_t agent_handle )</p>
-<p>Get current access permissions for memory mapping.</p>
-<p>Get access permissions for memory mapping for specific agent.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">va -[in] previously mapped virtual address</li>
-<li style="list-style-type: '· ';">perms -[in] current permissions</li>
-<li style="list-style-type: '· ';">agent_handle -[in] agent</li>
-</ul>
-<h2>Return values</h2>
-<ul>
-<li style="list-style-type: '· ';">::HSA_STATUS_SUCCESS -</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_INVALID_AGENT - Invalid agent</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_INVALID_ALLOCATION - va is not mapped or permissions never set for this agent</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR - Unexpected internal error</li>
-</ul>
-<p>hsa_status_t hsa_amd_vmem_export_shareable_handle ( int *dmabuf_fd, hsa_amd_vmem_alloc_handle_t handle, uint64_t flags )</p>
-<p>Get an exportable shareable handle.</p>
-<p>Get an exportable shareable handle for a memory_handle. This shareabl handle can then be used to re-create a virtual memory handle using hsa_amd_vmem_import_shareable_handle. The shareable handle can be transferred using mechanisms that support posix file descriptors Once all shareable handles are closed, the memory_handle is released.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dmabuf_fd -[out] shareable handle</li>
-<li style="list-style-type: '· ';">handle -[in] previously allocated virtual memory handle</li>
-<li style="list-style-type: '· ';">flags -[in] Currently unsupported</li>
-</ul>
-<h2>Return values</h2>
-<ul>
-<li style="list-style-type: '· ';">::HSA_STATUS_SUCCESS -</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_INVALID_ALLOCATION - Invalid memory handle</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_OUT_OF_RESOURCES - Out of resources</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR - Unexpected internal error</li>
-</ul>
-<h2>hsa_status_t hsa_amd_vmem_import_shareable_handle ( int dmabuf_fd, hsa_amd_vmem_alloc_handle_t *handle )</h2>
-<p>Import a shareable handle.</p>
-<p>Import a shareable handle for a memory handle. Importing a shareable handle that has been closed and released results in undefined behavior.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dmabuf_fd -[in] shareable handle exported with hsa_amd_vmem_export_shareable_handle</li>
-<li style="list-style-type: '· ';">handle -[out] virtual memory handle</li>
-</ul>
-<h2>Return values</h2>
-<ul>
-<li style="list-style-type: '· ';">::HSA_STATUS_SUCCESS -</li>
-</ul>
-<ul>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_INVALID_ALLOCATION - Invalid memory handle</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_OUT_OF_RESOURCES - Out of resources</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR - Unexpected internal error</li>
-</ul>
-<p>hsa_status_t hsa_amd_vmem_retain_alloc_handle ( hsa_amd_vmem_alloc_handle_t *memory_handle, void *addr )</p>
-<p>Returns memory handle for mapped memory.</p>
-<p>Return a memory handle for previously mapped memory. The handle will be the same value of handle used to map the memory. The returned handle must be released with corresponding number of calls to hsa_amd_vmem_handle_release.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">memory_handle -[out] memory handle for this mapped address</li>
-<li style="list-style-type: '· ';">mapped -[in] address</li>
-</ul>
-<h2>Return values</h2>
-<ul>
-<li style="list-style-type: '· ';">::HSA_STATUS_SUCCESS -</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_INVALID_ALLOCATION - Invalid address</li>
-</ul>
-<p>hsa_status_t hsa_amd_vmem_get_alloc_properties_from_handle ( hsa_amd_vmem_alloc_handle_t memory_handle, hsa_amd_memory_pool_t *pool, hsa_amd_memory_type_t *type )</p>
-<p>Returns the current allocation properties of a handle.</p>
-<p>Returns the allocation properties of an existing handle</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">memory_handle -[in] memory handle to be queried</li>
-<li style="list-style-type: '· ';">pool -[out] memory pool that owns this handle</li>
-<li style="list-style-type: '· ';">memory -[out] type</li>
-</ul>
-<h2>Return values</h2>
-<ul>
-<li style="list-style-type: '· ';">::HSA_STATUS_SUCCESS -</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_INVALID_ALLOCATION - Invalid memory_handle</li>
-</ul>
-<h2>CHAPTER</h2>
-<h2>TWENTYFIVE</h2>
-<h2>HIP MANAGED MEMORY ALLOCATION API</h2>
-<p>hipError_t hipMallocManaged ( void **dev_ptr, size_t size, unsigned int flags )</p>
-<p>Allocates memory that will be automatically managed by HIP.</p>
-<p>This API is used for managed memory, allows data be shared and accessible to both CPU and GPU using a single pointer.</p>
-<p>The API returns the allocation pointer, managed by HMM, can be used further to execute kernels on device and fetch data between the host and device as needed.</p>
-<p>Note: It is recommend to do the capability check before call this API.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dev_ptr -[out] - pointer to allocated device memory</li>
-<li style="list-style-type: '· ';">size -[in] - requested allocation size in bytes, it should be granularity of 4KB</li>
-<li style="list-style-type: '· ';">flags -[in] - must be either hipMemAttachGlobal or hipMemAttachHost (defaults to hipMemAttachGlobal)</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorMemoryAllocation, hipErrorNotSupported, hipErrorInvalidValue hipError_t hipMemPrefetchAsync ( const void *dev_ptr, size_t count, int device, hipStream_t stream</p>
-<p>) Prefetches memory to the specified destination device using HIP.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dev_ptr -[in] pointer to be prefetched</li>
-<li style="list-style-type: '· ';">count -[in] size in bytes for prefetching</li>
-<li style="list-style-type: '· ';">device -[in] destination device to prefetch to</li>
-<li style="list-style-type: '· ';">stream -[in] stream to enqueue prefetch operation</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue</p>
-<p>hipError_t hipMemAdvise ( const void *dev_ptr, size_t count, hipMemoryAdvise advice, int device )</p>
-<p>Advise about the usage of a given memory range to HIP.</p>
-<p>This HIP API advises about the usage to be applied on unified memory allocation in the range starting from the pointer address devPtr, with the size of count bytes. The memory range must refer to managed memory allocated via the API hipMallocManaged, and the range will be handled with proper round down and round up respectively in the driver to be aligned to CPU page size, the same way as corresponding CUDA API behaves in CUDA version 8.0 and afterwards.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dev_ptr -[in] pointer to memory to set the advice for</li>
-<li style="list-style-type: '· ';">count -[in] size in bytes of the memory range, it should be CPU page size alligned.</li>
-<li style="list-style-type: '· ';">advice -[in] advice to be applied for the specified memory range</li>
-<li style="list-style-type: '· ';">device -[in] device to apply the advice for</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipError_t hipMemRangeGetAttribute ( void *data, size_t data_size, hipMemRangeAttribute attribute, const void *dev_ptr, size_t count )</p>
-<p>Query an attribute of a given memory range in HIP.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">data -[inout] a pointer to a memory location where the result of each attribute query will be written to</li>
-<li style="list-style-type: '· ';">data_size -[in] the size of data</li>
-<li style="list-style-type: '· ';">attribute -[in] the attribute to query</li>
-<li style="list-style-type: '· ';">dev_ptr -[in] start of the range to query</li>
-<li style="list-style-type: '· ';">count -[in] size of the range to query</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipError_t hipMemRangeGetAttributes ( void **data, size_t *data_sizes, hipMemRangeAttribute *attributes, size_t num_attributes, const void *dev_ptr, size_t count )</p>
-<p>Query attributes of a given memory range in HIP.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">data -[inout] a two-dimensional array containing pointers to memory locations where the result of each attribute query will be written to</li>
-<li style="list-style-type: '· ';">data_sizes -[in] an array, containing the sizes of each result</li>
-<li style="list-style-type: '· ';">attributes -[in] the attribute to query</li>
-<li style="list-style-type: '· ';">num_attributes -[in] an array of attributes to query (numAttributes and the number of attributes in this array should match)</li>
-<li style="list-style-type: '· ';">dev_ptr -[in] start of the range to query</li>
-<li style="list-style-type: '· ';">count -[in] size of the range to query</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipError_t hipStreamAttachMemAsync ( hipStream_t stream, void *dev_ptr, size_t length, unsigned int flags ) Attach memory to a stream asynchronously in HIP.</p>
-<p>Warning: This API is under development. Currently it is a no-operation (NOP) function on AMD GPUs and returns hipSuccess.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">stream -[in] - stream in which to enqueue the attach operation</li>
-<li style="list-style-type: '· ';">dev_ptr -[in] - pointer to memory (must be a pointer to managed memory or to a valid host-accessible region of system-allocated memory)</li>
-<li style="list-style-type: '· ';">length -[in] - length of memory (defaults to zero)</li>
-<li style="list-style-type: '· ';">flags -[in] - must be one of hipMemAttachGlobal, hipMemAttachHost or hipMemAttachSingle (defaults to hipMemAttachSingle)</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue</p>
-<h2>template&lt;class T &gt;</h2>
-<p>static inline hipError_t hipMallocManaged ( T **devPtr, size_t size, unsigned int flags = hipMemAttachGlobal )</p>
-<ul>
-<li>: C++ wrapper for hipMallocManaged</li>
-</ul>
-<p>Provide an override to automatically typecast the pointer type from void**, and also provide a default for the flags.</p>
-<p>HIP_DISABLE_CPP_FUNCTIONS macro can be defined to suppress these wrappers. It is useful for applications which need to obtain decltypes of HIP runtime APIs.</p>
-<h2>See also:</h2>
-<p>hipMallocManaged</p>
-<h2>CHAPTER</h2>
-<h2>TWENTYSIX</h2>
-<h2>HIP VIRTUAL MEMORY MANAGEMENT API</h2>
-<p>hipError_t hipMemAddressFree ( void *devPtr, size_t size )</p>
-<p>Frees an address range reservation made via hipMemAddressReserve.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">devPtr -[in] - starting address of the range.</li>
-<li style="list-style-type: '· ';">size -[in] - size of the range.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError_t hipMemAddressReserve ( void **ptr, size_t size, size_t alignment, void *addr, unsigned long long flags )</p>
-<p>Reserves an address range.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">ptr -[out] - starting address of the reserved range.</li>
-<li style="list-style-type: '· ';">size -[in] - size of the reservation.</li>
-<li style="list-style-type: '· ';">alignment -[in] - alignment of the address.</li>
-<li style="list-style-type: '· ';">addr -[in] - requested starting address of the range.</li>
-<li style="list-style-type: '· ';">flags -[in] - currently unused, must be zero.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotSupported</p>
-<p>hipError_t hipMemCreate ( hipMemGenericAllocationHandle_t *handle, size_t size, const hipMemAllocationProp *prop, unsigned long long flags )</p>
-<p>Creates a memory allocation described by the properties and size.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">handle -[out] - value of the returned handle.</li>
-<li style="list-style-type: '· ';">size -[in] - size of the allocation.</li>
-<li style="list-style-type: '· ';">prop -[in] - properties of the allocation.</li>
-<li style="list-style-type: '· ';">flags -[in] - currently unused, must be zero.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError_t hipMemExportToShareableHandle ( void *shareableHandle, hipMemGenericAllocationHandle_t handle, hipMemAllocationHandleType handleType, unsigned long long flags )</p>
-<p>Exports an allocation to a requested shareable handle type.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">shareableHandle -[out] - value of the returned handle.</li>
-<li style="list-style-type: '· ';">handle -[in] - handle to share.</li>
-<li style="list-style-type: '· ';">handleType -[in] - type of the shareable handle.</li>
-<li style="list-style-type: '· ';">flags -[in] - currently unused, must be zero.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError_t hipMemGetAccess ( unsigned long long *flags, const hipMemLocation *location, void *ptr</p>
-<p>) Get the access flags set for the given location and ptr.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">flags -[out] - flags for this location.</li>
-<li style="list-style-type: '· ';">location -[in] - target location.</li>
-<li style="list-style-type: '· ';">ptr -[in] - address to check the access flags.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError_t hipMemGetAllocationGranularity ( size_t *granularity, const hipMemAllocationProp *prop, hipMemAllocationGranularity_flags option )</p>
-<p>Calculates either the minimal or recommended granularity.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">granularity -[out] - returned granularity.</li>
-<li style="list-style-type: '· ';">prop -[in] - location properties.</li>
-<li style="list-style-type: '· ';">option -[in] - determines which granularity to return.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError_t hipMemGetAllocationPropertiesFromHandle ( hipMemAllocationProp *prop,</p>
-<p>hipMemGenericAllocationHandle_t handle )</p>
-<p>Retrieve the property structure of the given handle.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">prop -[out] - properties of the given handle.</li>
-<li style="list-style-type: '· ';">handle -[in] - handle to perform the query on.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotSupported</p>
-<p>hipError_t hipMemImportFromShareableHandle ( hipMemGenericAllocationHandle_t *handle, void *osHandle, hipMemAllocationHandleType shHandleType )</p>
-<p>Imports an allocation from a requested shareable handle type.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">handle -[out] - returned value.</li>
-<li style="list-style-type: '· ';">osHandle -[in] - shareable handle representing the memory allocation.</li>
-<li style="list-style-type: '· ';">shHandleType -[in] - handle type.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError_t hipMemMap ( void *ptr, size_t size, size_t offset, hipMemGenericAllocationHandle_t handle, unsigned long long flags )</p>
-<p>Maps an allocation handle to a reserved virtual address range.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">ptr -[in] - address where the memory will be mapped.</li>
-<li style="list-style-type: '· ';">size -[in] - size of the mapping.</li>
-<li style="list-style-type: '· ';">offset -[in] - offset into the memory, currently must be zero.</li>
-<li style="list-style-type: '· ';">handle -[in] - memory allocation to be mapped.</li>
-<li style="list-style-type: '· ';">flags -[in] - currently unused, must be zero.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError_t hipMemMapArrayAsync ( hipArrayMapInfo *mapInfoList, unsigned int count, hipStream_t stream )</p>
-<p>Maps or unmaps subregions of sparse HIP arrays and sparse HIP mipmapped arrays.</p>
-<p>Warning: This API is under development. Currently it is not supported on AMD GPUs and returns hipErrorNotSupported.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">mapInfoList -[in] - list of hipArrayMapInfo.</li>
-<li style="list-style-type: '· ';">count -[in] - number of hipArrayMapInfo in mapInfoList.</li>
-<li style="list-style-type: '· ';">stream -[in] - stream identifier for the stream to use for map or unmap operations.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError_t hipMemRelease ( hipMemGenericAllocationHandle_t handle )</p>
-<p>Release a memory handle representing a memory allocation which was previously allocated through hipMemCreate.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<p>handle -[in] - handle of the memory allocation.</p>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError_t hipMemRetainAllocationHandle ( hipMemGenericAllocationHandle_t *handle, void *addr )</p>
-<p>Returns the allocation handle of the backing memory allocation given the address.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">handle -[out] - handle representing addr.</li>
-<li style="list-style-type: '· ';">addr -[in] - address to look up.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError_t hipMemSetAccess ( void *ptr, size_t size, const hipMemAccessDesc *desc, size_t count )</p>
-<p>Set the access flags for each location specified in desc for the given virtual address range.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">ptr -[in] - starting address of the virtual address range.</li>
-<li style="list-style-type: '· ';">size -[in] - size of the range.</li>
-<li style="list-style-type: '· ';">desc -[in] - array of hipMemAccessDesc.</li>
-<li style="list-style-type: '· ';">count -[in] - number of hipMemAccessDesc in desc.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotSupported</p>
-<h2>hipError_t hipMemUnmap ( void *ptr, size_t size )</h2>
-<p>Unmap memory allocation of a given address range.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">ptr -[in] - starting address of the range to unmap.</li>
-<li style="list-style-type: '· ';">size -[in] - size of the virtual address range.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotSupported</p>
-<h2>CHAPTER</h2>
-<h2>TWENTYSEVEN</h2>
-<h2>HIP DEPRECATED RUNTIME API FUNCTIONS</h2>
-<p>Several of our API functions have been flagged for deprecation. Using the following functions results in errors and unexpected results, so we encourage you to update your code accordingly.</p>
-<h2>27.1 Context management</h2>
-<p>CUDAsupports cuCtx API, which is the driver API that defines 'Context' and 'Devices' as separate entities. Context contains a single device, and a device can theoretically have multiple contexts. HIP initially added limited support for these APIs in order to facilitate porting from existing driver codes. These APIs are now marked as deprecated because there are better alternate interfaces (such as hipSetDevice or the stream API) to achieve these functions.</p>
-<ul>
-<li style="list-style-type: '· ';">hipCtxCreate</li>
-<li style="list-style-type: '· ';">hipCtxDestroy</li>
-<li style="list-style-type: '· ';">hipCtxPopCurrent</li>
-<li style="list-style-type: '· ';">hipCtxPushCurrent</li>
-<li style="list-style-type: '· ';">hipCtxSetCurrent</li>
-<li style="list-style-type: '· ';">hipCtxGetCurrent</li>
-<li style="list-style-type: '· ';">hipCtxGetDevice</li>
-<li style="list-style-type: '· ';">hipCtxGetApiVersion</li>
-<li style="list-style-type: '· ';">hipCtxGetCacheConfig</li>
-<li style="list-style-type: '· ';">hipCtxSetCacheConfig</li>
-<li style="list-style-type: '· ';">hipCtxSetSharedMemConfig</li>
-<li style="list-style-type: '· ';">hipCtxGetSharedMemConfig</li>
-<li style="list-style-type: '· ';">hipCtxSynchronize</li>
-<li style="list-style-type: '· ';">hipCtxGetFlags</li>
-<li style="list-style-type: '· ';">hipCtxEnablePeerAccess</li>
-<li style="list-style-type: '· ';">hipCtxDisablePeerAccess</li>
-<li style="list-style-type: '· ';">hipDevicePrimaryCtxGetState</li>
-<li style="list-style-type: '· ';">hipDevicePrimaryCtxRelease</li>
-<li style="list-style-type: '· ';">hipDevicePrimaryCtxRetain</li>
-<li style="list-style-type: '· ';">hipDevicePrimaryCtxReset</li>
-</ul>
-<ul>
-<li style="list-style-type: '· ';">hipDevicePrimaryCtxSetFlags</li>
-</ul>
-<h2>27.2 Memory management</h2>
-<ul>
-<li style="list-style-type: '· ';">hipMallocHost (replaced with hipHostMalloc )</li>
-<li style="list-style-type: '· ';">hipMemAllocHost (replaced with hipHostMalloc )</li>
-<li style="list-style-type: '· ';">hipHostAlloc (replaced with hipHostMalloc )</li>
-<li style="list-style-type: '· ';">hipFreeHost (replaced with hipHostFree )</li>
-<li style="list-style-type: '· ';">hipMemcpyToArray</li>
-<li style="list-style-type: '· ';">hipMemcpyFromArray</li>
-</ul>
-<h2>27.3 Profiler control</h2>
-<ul>
-<li style="list-style-type: '· ';">hipProfilerStart (use roctracer/rocTX)</li>
-<li style="list-style-type: '· ';">hipProfilerStop (use roctracer/rocTX)</li>
-</ul>
-<h2>27.4 Texture management</h2>
-<ul>
-<li style="list-style-type: '· ';">hipGetTextureReference</li>
-<li style="list-style-type: '· ';">hipTexRefSetAddressMode</li>
-<li style="list-style-type: '· ';">hipTexRefSetArray</li>
-<li style="list-style-type: '· ';">hipTexRefSetFilterMode</li>
-<li style="list-style-type: '· ';">hipTexRefSetFlags</li>
-<li style="list-style-type: '· ';">hipTexRefSetFormat</li>
-<li style="list-style-type: '· ';">hipTexRefGetAddress</li>
-<li style="list-style-type: '· ';">hipTexRefGetAddressMode</li>
-<li style="list-style-type: '· ';">hipTexRefGetFilterMode</li>
-<li style="list-style-type: '· ';">hipTexRefGetFlags</li>
-<li style="list-style-type: '· ';">hipTexRefGetFormat</li>
-<li style="list-style-type: '· ';">hipTexRefGetMaxAnisotropy</li>
-<li style="list-style-type: '· ';">hipTexRefGetMipmapFilterMode</li>
-<li style="list-style-type: '· ';">hipTexRefGetMipmapLevelBias</li>
-<li style="list-style-type: '· ';">hipTexRefGetMipmapLevelClamp</li>
-<li style="list-style-type: '· ';">hipTexRefGetMipMappedArray</li>
-<li style="list-style-type: '· ';">hipTexRefSetAddress</li>
-<li style="list-style-type: '· ';">hipTexRefSetAddress2D</li>
-<li style="list-style-type: '· ';">hipTexRefSetMaxAnisotropy</li>
-</ul>
-<ul>
-<li style="list-style-type: '· ';">hipTexRefSetBorderColor</li>
-<li style="list-style-type: '· ';">hipTexRefSetMipmapFilterMode</li>
-<li style="list-style-type: '· ';">hipTexRefSetMipmapLevelBias</li>
-<li style="list-style-type: '· ';">hipTexRefSetMipmapLevelClamp</li>
-<li style="list-style-type: '· ';">hipTexRefSetMipmappedArray</li>
-<li style="list-style-type: '· ';">hipTexRefGetBorderColor</li>
-<li style="list-style-type: '· ';">hipTexRefGetArray</li>
-<li style="list-style-type: '· ';">hipBindTexture</li>
-<li style="list-style-type: '· ';">hipBindTexture2D</li>
-<li style="list-style-type: '· ';">hipBindTextureToArray</li>
-<li style="list-style-type: '· ';">hipGetTextureAlignmentOffset</li>
-<li style="list-style-type: '· ';">hipUnbindTexture</li>
-<li style="list-style-type: '· ';">hipBindTextureToMipmappedArray</li>
-</ul>
-<h2>CHAPTER</h2>
-<h2>TWENTYEIGHT</h2>
-<h2>SAXPY - HELLO, HIP</h2>
-<p>This tutorial explains the basic concepts of the single-source Heterogeneous-computing Interface for Portability (HIP) programming model and the essential tooling around it. It also reviews some commonalities of heterogenous APIs in general. This topic assumes basic familiarity with the C/C++ compilation model and language.</p>
-<h2>28.1 Prerequisites</h2>
-<p>To follow this tutorial, you'll need installed drivers and a HIP compiler toolchain to compile your code. Because HIP for ROCm supports compiling and running on Linux and Windows with AMD and NVIDIA GPUs, the combination of install instructions is more than worth covering as part of this tutorial. For more information about installing HIP development packages, see Install HIP .</p>
-<h2>28.2 Heterogeneous programming</h2>
-<p>Heterogeneous programming and offloading APIs are often mentioned together. Heterogeneous programming deals with devices of varying capabilities simultaneously. Offloading focuses on the 'remote' and asynchronous aspects of computation. HIP encompasses both. It exposes GPGPU (general-purpose GPU) programming much like ordinary host-side CPU programming and lets you move data across various devices.</p>
-<p>When programming in HIP (and other heterogenous APIs for that matter), remember that target devices are built for a specific purpose. They are designed with different tradeoffs than traditional CPUs and therefore have very different performance characteristics. Even subtle changes in code might adversely affect execution time.</p>
-<h2>28.3 Your first lines of HIP code</h2>
-<p>First, let's do the 'Hello, World!' of GPGPU: SAXPY. Single-precision A times X Plus Y ( SAXPY ) is a mathematical acronym; a vector equation 𝑎 · 𝑥 + 𝑦 = 𝑧 where 𝑎 ∈ R is a scalar and 𝑥, 𝑦, 𝑧 ∈ V are vector quantities of some large dimensionality. This vector space is defined over the set of reals. Practically speaking, you can compute this using a single for loop over three arrays.</p>
-<p><strong>**Following code does:** This code snippet is a command to compile a C++ program using the `clang++` compiler. It is specifically compiling a HIP (Heterogeneous-Compute Interface for Portability) program, which is used for writing portable code that can run on both AMD and NVIDIA GPUs. The command compiles the source file `main.hip` located in the `HIP-Basic\saxpy` directory into an executable named `saxpy.exe`. It includes headers from the `.\Common` directory, links against the `amdhip64` library, and uses the library path specified by the `HIP_PATH` environment variable. The `-O2` flag is used for optimization, and `--save-temps` is used to save intermediate compilation files.</strong></p>
-<pre><code>++i)</code></pre>
-<p><strong>**Following code does:** This code snippet is a partial command written in PowerShell. It uses the `Get-ChildItem` cmdlet to list items (files and directories) in the current directory that match a specific pattern. The `-Filter main-hip-*` option specifies that only items with names starting with "main-hip-" should be included in the output. The command is incomplete, as it ends with `selec`, which is likely intended to be `Select-Object` to further process or filter the properties of the listed items.</strong></p>
-<pre><code><_SQL_></code></pre>
-<p>In linear algebra libraries, such as BLAS (Basic Linear Algebra Subsystem) this operation is defined as AXPY 'A times X Plus Y'. The 'S' comes from single-precision , meaning that array element is float -s (IEEE 754 binary32 representation).</p>
-<p>To quickly get started, use the set of HIP samples from GitHub. With Git configured on your machine, open a commandline and navigate to your desired working directory, then run:</p>
-<p><strong>**Following code does:** The code snippet appears to be incomplete and seems to be a mix of Python and PowerShell syntax. The part `n-hip-* | select -Property Name` resembles a PowerShell command rather than Python. In PowerShell, this command would filter objects whose names match the pattern `n-hip-*` and then select only the `Name` property of those objects. However, without additional context or a complete command, it's difficult to provide a precise explanation.</strong></p>
-<pre><code>            |git clone https://github.com/amd/rcm-examples.git</code></pre>
-<p>A simple implementation of SAXPY resides in the HIP-Basic/saxpy/main.hip file in this repository. The HIP code here mostly deals with where data has to be and when, and how devices transform this data. The first HIP calls deal with allocating device-side memory and copying data from host-side memory to device side in a C runtime-like fashion.</p>
-<p><strong>**Following code does:** The code snippet appears to be a list of filenames rather than executable code. These filenames suggest that they are related to a project or compilation process targeting the AMD GCN (Graphics Core Next) architecture, specifically the gfx906 variant, which is used in AMD GPUs. The files likely represent different stages or outputs of compiling a program using the HIP (Heterogeneous-Compute Interface for Portability) framework for AMD hardware. The extensions indicate various file types: 
-
-- `.bc` is likely a LLVM bitcode file.
-- `.hipi` could be an intermediate file specific to HIP.
-- `.o` is an object file.
-- `.out` is an executable or output file.
-- `.out.resolution.txt` might be a text file containing resolution or linking information.
-- `.s` is an assembly file.
-
-Overall, these files are part of the build process for a HIP application targeting AMD GPUs.</strong></p>
-<pre><code>// Allocate and copy vectors to device memory.
-float* d_x{};
-float* d_y{};
-HIP_CHECK(hipMalloc(&d_x, size_bytes));
-HIP_CHECK(hipMalloc(&d_y, size_bytes));
-HIP_CHECK(hipMemcpy(d_x, x.data(), size_bytes, hipMemcpyHostToDevice));
-HIP_CHECK(hipMemcpy(d_y, y.data(), size_bytes, hipMemcpyHostToDevice));</code></pre>
-<p>HIP_CHECK is a custom macro borrowed from the examples utilities which checks the error code returned by API functions for errors and reports them to the console. It is not essential to the API, but it is a good practice to check the error codes of the HIP APIs in case you pass on incorrect values to the API, or the API might be out of resources.</p>
-<p>The code selects the device to allocate to and to copy to. Commands are issued to the HIP runtime per thread, and every thread has a device set as the target of commands. The default device is 0 , which is equivalent to calling hipSetDevice(0) .</p>
-<p>Launch the calculation on the device after the input data has been prepared.</p>
-<p><strong>**Following code does:** This code snippet appears to be a disassembled output of a compiled program targeting AMD's GCN (Graphics Core Next) architecture, specifically the gfx906 variant. The disassembly is likely generated from a HIP (Heterogeneous-Compute Interface for Portability) application, which is used for GPU programming on AMD hardware.
-
-The code includes assembly instructions for a function named `_Z12saxpy_kernelPKfPfj`, which suggests it is implementing a SAXPY (Single-Precision A·X Plus Y) operation, a common vector operation in linear algebra. The SAXPY operation computes the result of `Y = a * X + Y`, where `a` is a scalar and `X` and `Y` are vectors.
-
-The assembly instructions involve loading data, performing arithmetic operations, and storing results back to memory, which are typical steps in executing a SAXPY operation on a GPU. The use of specific instructions like `s_load_dword`, `v_add_u32_e32`, and `global_store_dword` indicates manipulation of scalar and vector registers, memory access, and arithmetic operations optimized for parallel execution on the GPU.</strong></p>
-<pre><code>    Launch the calculation on the device after the input data has been prepared.
-    __global__ void saxpy_kernel(const float a, const float* d_x, float* d_y, const unsigned_
-    __int size)
-    {
-        //...
-    }
-
-    int main()
-    {
-        //...
-
-        // Launch the kernel on the default stream.
-        saxpy_kernel<<<dim3(grid_size), dim3(block_size), 0, hipStreamDefault>>>(a, d_x, d_y,
-    -- size);
-    }
-
-    Analyze at the signature of the offloaded function:</code></pre>
-<p>Analyze at the signature of the offloaded function:</p>
-<ul>
-<li style="list-style-type: '· ';">__global__ instructs the compiler to generate code for this function as an entrypoint to a device program, such that it can be launched from the host.</li>
-<li style="list-style-type: '· ';">The function does not return anything, because there is no trivial way to construct a return channel of a parallel invocation. Device-side entrypoints may not return a value, their results should be communicated using output parameters.</li>
-<li style="list-style-type: '· ';">Device-side functions are typically called compute kernels, or just kernels for short. This is to distinguish them from non-graphics-related graphics shaders, or just shaders for short.</li>
-<li style="list-style-type: '· ';">Arguments are taken by value and all arguments shall be TriviallyCopyable, meaning they should be memcpy -friendly. (Imagine if they had custom copy constructors. Where would that logic execute? On the host? On the device?) Pointer arguments are pointers to device memory, one typically backed by VRAM.</li>
-</ul>
-<ul>
-<li style="list-style-type: '· ';">We said that we'll be computing 𝑎 · 𝑥 + 𝑦 = 𝑧 , however we only pass two pointers to the function. We'll be canonically reusing one of the inputs as outputs.</li>
-</ul>
-<p>This function is launched from the host using a language extension often called the triple chevron syntax. Inside the angle brackets, provide the following.</p>
-<ul>
-<li style="list-style-type: '· ';">The number of blocks to launch (our grid size)</li>
-<li style="list-style-type: '· ';">The number of threads in a block (our block size)</li>
-<li style="list-style-type: '· ';">The amount of shared memory to allocate by the host</li>
-<li style="list-style-type: '· ';">The device stream to enqueue the operation on</li>
-</ul>
-<p>The block size and shared memory become important later in Reduction . For now, a hardcoded 256 is a safe default for simple kernels such as this. Following the triple chevron is ordinary function argument passing.</p>
-<p>Look at how the kernel is implemented.</p>
-<p><strong>**Following code does:** The code snippet you provided seems to be a placeholder or an incomplete representation of a Bash script. The `<_Bash_>` tag does not contain any actual Bash code or commands. Therefore, it does not perform any specific function or task. If you have a specific Bash script or code snippet you would like explained, please provide the actual code.</strong></p>
-<pre><code><_Cuda_></code></pre>
-<ul>
-<li style="list-style-type: '· ';">The unique linear index identifying the thread is computed from the block ID the thread is a member of, the block 's size and the ID of the thread within the block .</li>
-<li style="list-style-type: '· ';">A check is made to avoid overindexing the input.</li>
-<li style="list-style-type: '· ';">The useful part of the computation is carried out.</li>
-</ul>
-<p>Retrieval of the result from the device is done much like input data copy. In this current step the results copied from device to host. The opposite direction of the input data copy:</p>
-<p><strong>**Following code does:** The code snippet you've provided appears to be a corrupted or improperly formatted text, possibly due to a copy-paste error or encoding issue. It does not represent valid Python code or any recognizable programming construct. If you intended to share a specific piece of code, please ensure it is correctly formatted and complete.</strong></p>
-<pre><code>                |HIP_CHECK(hipMemcpy(y.data()),  d_y,  size_bytes,  hipMemcpyDeviceToHost));</code></pre>
-<h2>28.4 Compiling on the command line</h2>
-<h2>28.4.1 Setting up the command line</h2>
-<p>Strictly speaking there's no such thing as 'setting up the command-line for compilation' on Linux. To make invocations more terse, Linux and Windows example follow.</p>
-<h2>Linux and AMD</h2>
-<p>While distro maintainers might package ROCm so that it installs to system-default locations, AMD's packages aren't installed that way. They need to be added to the PATH by the user.</p>
-<p><strong>**Following code does:** The code snippet you provided appears to be a command or a reference to a file rather than a typical code snippet. It seems to be related to a SAXPY operation, which stands for "Single-Precision A·X Plus Y." SAXPY is a common operation in linear algebra used to scale a vector `X` by a scalar `A` and add it to another vector `Y`. The term "sm_5" likely refers to a specific compute capability or architecture version for NVIDIA GPUs, and "ptx" indicates that this is a PTX (Parallel Thread Execution) file, which is an intermediate representation used in CUDA programming for NVIDIA GPUs. Overall, this line likely refers to a compiled or source file related to performing a SAXPY operation on a GPU.</strong></p>
-<pre><code>        | export PATH=/opt/rcm/bin:${PATH}</code></pre>
-<p><strong>**Following code does:** The code snippet appears to be a mix of Python and PHP syntax, but it is not valid code in either language. It seems to be an attempt to execute a shell command using PHP tags, specifically running `rocminfo` and filtering the output with `grep gfx`. The intention might be to extract information about AMD GPU architectures (gfx) from the `rocminfo` command output. However, due to the incorrect syntax and formatting, this code will not execute as intended in any programming environment.</strong></p>
-<pre><code>}</code></pre>
-<p><strong>**Following code does:** This code snippet appears to be a series of special characters and symbols arranged in a specific pattern. However, it does not constitute valid or meaningful Python code. It seems to be more of an artistic or visual arrangement of characters rather than a functional code snippet with a high-level purpose.</strong></p>
-<pre><code>    You should be able to call the compiler on the command line now:
-    
-    amdclang++  --version</code></pre>
-<p>Note: Docker images distributed by AMD, such as rocm-terminal already have /opt/rocm/bin on the Path for convenience. This subtly affects CMake package detection logic of ROCm libraries.</p>
-<h2>Linux and NVIDIA</h2>
-<p>Both distro maintainers and NVIDIA package CUDA so that nvcc and related tools are available on the command line by default. You can call the compiler on the command line with:</p>
-<p><strong>**Following code does:** The code snippet describes a SAXPY operation, which stands for "Single-Precision A·X Plus Y". It performs a linear algebra operation where each element of an array `y` is updated by multiplying a scalar `a` with the corresponding element of another array `x` and then adding the result to the original element in `y`. This operation is applied over 10,000,000 elements. The snippet also provides the first 10 elements of the resulting array `y` after the operation, which are `[3, 5, 7, 9, 11, 13, 15, 17, 19, 21]`.</strong></p>
-<pre><code>| nvcc --version</code></pre>
-<h2>Windows and AMD</h2>
-<p>Windows compilers and command line tooling have traditionally relied on extra environmental variables and PATH entries to function correctly. Visual Studio refers to command lines with this setup as 'Developer Command Prompt' or 'Developer PowerShell' for cmd.exe and PowerShell respectively.</p>
-<p>The HIP SDK on Windows doesn't include a complete toolchain. You will also need:</p>
-<ul>
-<li style="list-style-type: '· ';">The Microsoft Windows SDK. It provides the import libs to crucial system libraries that all executables must link to and some auxiliary compiler tooling.</li>
-<li style="list-style-type: '· ';">A Standard Template Library (STL). Installed as part of the Microsoft Visual C++ compiler (MSVC) or with Visual Studio.</li>
-</ul>
-<p>If you don't have a version of Visual Studio 2022 installed, for a minimal command line experience, install the Build Tools for Visual Studio 2022 with the Desktop Developemnt Workload. Under Individual Components select:</p>
-<ul>
-<li style="list-style-type: '· ';">A version of the Windows SDK</li>
-<li style="list-style-type: '· ';">'MSVC v143 - VS 2022 C++ x64/x86 build tools (Latest)'</li>
-<li style="list-style-type: '· ';">'C++ CMake tools for Windows' (optional)</li>
-</ul>
-<p>Note: The 'C++ CMake tools for Windows' individual component is a convenience which puts both cmake.exe and ninja.exe onto the PATH inside developer command prompts. You can install these manually, but then you must manage them manually.</p>
-<p>Visual Studio 2017 and later are detectable as COM object instances via WMI. To setup a command line from any shell for the latest Visual Studio's default Visual C++ toolset issue:</p>
-<p><strong>**Following code does:** It seems like there is a placeholder `<_Python_>` instead of actual code. Please provide the code snippet you would like me to explain.</strong></p>
-<pre><code>$InstallationPath = Get-CimInstance MSFT_VSInstance | Sort-Object -Property Version -
- --Descending | Select-Object -First 1 -ExpandProperty InstallLocation
- Import-Module $InstallationPath\Common?\Tools\Microsoft.VisualStudio.DevShell.dll
-Enter-VsDevShell -InstallPath $InstallationPath -SkipAutomaticLocation -Arch amd64 -
- --HostArch amd64 -DevCmdArguments '-no_logo'
-$env:PATH = "${env:HIP_PATH}bin;${env:PATH}"</code></pre>
-<p>You should be able to call the compiler on the command line now:</p>
-<p><strong>**Following code does:** This code snippet appears to be a series of symbols and numbers, but it does not represent valid or meaningful Python code. It seems to be a random arrangement of characters and does not perform any computational task or serve any high-level purpose in programming.</strong></p>
-<pre><code>  | clang++ --version</code></pre>
-<h2>Windows and NVIDIA</h2>
-<p>Windows compilers and command line tooling have traditionally relied on extra environmental variables and PATH entries to function correctly. Visual Studio refers to command lines with this setup as 'Developer Command Prompt' or 'Developer PowerShell' for cmd.exe and PowerShell respectively.</p>
-<p>The HIP and CUDA SDKs on Windows don't include complete toolchains. You will also need:</p>
-<ul>
-<li style="list-style-type: '· ';">The Microsoft Windows SDK. It provides the import libs to crucial system libraries that all executables must link to and some auxiliary compiler tooling.</li>
-<li style="list-style-type: '· ';">A Standard Template Library (STL). Installed as part of the Microsoft Visual C++ compiler (MSVC) or with Visual Studio.</li>
-</ul>
-<p>If you don't have a version of Visual Studio 2022 installed, for a minimal command line experience, install the Build Tools for Visual Studio 2022 with the Desktop Developemnt Workload. Under Individual Components select:</p>
-<ul>
-<li style="list-style-type: '· ';">A version of the Windows SDK</li>
-<li style="list-style-type: '· ';">'MSVC v143 - VS 2022 C++ x64/x86 build tools (Latest)'</li>
-<li style="list-style-type: '· ';">'C++ CMake tools for Windows' (optional)</li>
-</ul>
-<p>Note: The 'C++ CMake tools for Windows' individual component is a convenience which puts both cmake.exe and ninja.exe onto the PATH inside developer command prompts. You can install these manually, but then you must manage them manually.</p>
-<p>Visual Studio 2017 and later are detectable as COM object instances via WMI. To setup a command line from any shell for the latest Visual Studio's default Visual C++ toolset issue:</p>
-<p><strong>**Following code does:** The code snippet you provided seems to be a placeholder or a tag indicating a YAML (YAML Ain't Markup Language) document or section, rather than actual executable code. YAML is a human-readable data serialization standard often used for configuration files or data exchange between languages with different data structures. Without specific YAML content, it's not possible to determine what data or configuration it represents. If you have a YAML file or content, it would typically define structured data in a readable format, such as lists, dictionaries, or configuration settings.</strong></p>
-<pre><code>$InstallationPath = Get-CimInstance MSFT_VSInstance | Sort-Object -Property Version -
---Descending | Select-Object -First 1 -ExpandProperty InstallLocation
-Import-Module $InstallationPath\Common7\Tools\Microsoft.VisualStudio.DevShell.dll
-Enter-VsDevShell -InstallPath $InstallationPath -SkipAutomaticLocation -Arch amd64 -
---HostArch amd64 -DevCmdArguments '-no_logo'</code></pre>
-<p>You should be able to call the compiler on the command line now:</p>
-<p><strong>**Following code does:** The code snippet provided is not a valid or complete Python code. It appears to be a fragment with a lot of whitespace and a string that looks like a comment or a directive related to architecture specifications, possibly for CUDA (Compute Unified Device Architecture) which is used for programming NVIDIA GPUs. The `<_arch=sm_70,sm_86` part suggests specifying the compute capabilities (sm_70 and sm_86) for which the code might be intended to run. However, without additional context or surrounding code, it's not possible to determine its exact purpose or functionality.</strong></p>
-<pre><code>| nvcc --version</code></pre>
-<h2>28.4.2 Invoking the compiler manually</h2>
-<p>To compile and link a single-file application, use the following commands:</p>
-<h2>Linux and AMD</h2>
-<p><strong>**Following code does:** The code snippet appears to be executing a program or script named `saxpy`, which performs the SAXPY operation (Single-Precision A·X Plus Y). This operation is a common vector operation in numerical computing, where each element of a vector `y` is updated by multiplying a scalar `a` with the corresponding element of another vector `x` and then adding the result to the original element of `y`. The operation is performed over 10,000,000 elements. After the computation, the first 10 elements of the resulting vector `y` are displayed, showing a sequence of odd numbers starting from 3.</strong></p>
-<pre><code>                                                                                                                                                                                                        |                                                                                                                                                                                                       
-                                                                                                                                                                                                        <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        </----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                    <---------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        >----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                    |   
-                                                                                                                                                                                                    |   
-
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                   
-    </----------------------------------------------------------------------------------------------------------------------</code></pre>
-<h2>Linux and NVIDIA</h2>
-<p><strong>**Following code does:** This code snippet is a PowerShell command that executes the `hipInfo.exe` program located in the `bin` directory of the path specified by the `HIP_PATH` environment variable. The output of this program is then filtered using `Select-String` to search for lines containing the string "gfx". The purpose of this command is to extract and display information related to graphics architecture names (e.g., `gfx1032`, `gfx1035`) from the output of `hipInfo.exe`.</strong></p>
-<pre><code>                                                                                                                                                                                                        | nvcc ./HIP-Basic/saxpy/main.hip  -o  saxpy  -I ./Common  -I  /opt/rocm/include  -02  -x  cu                                                                                                                                                                                                       
-                                                                                                                                                                                                        -x  cu                                                                                                                                                                                                  |                                                                                                                                                                                                        }</code></pre>
-<h2>Windows and AMD</h2>
-<p><strong>**Following code does:** This code snippet is a command line instruction for compiling a HIP (Heterogeneous-Compute Interface for Portability) program using the `clang++` compiler. The command is set up to compile a source file named `main.hip` located in the `HIP-Basic\saxpy` directory into an executable named `saxpy.exe`. It includes a directory `.\Common` for header files and links against the `amdhip64` library. The command also specifies the HIP installation path using the environment variable `${env:HIP_PATH}`. Additionally, it targets specific GPU architectures (`gfx1032` and `gfx1035`) for offloading, and uses optimization level `-O2` for the compilation process.</strong></p>
-<pre><code>                                                                                                                                                                                                        |clang++.\HIP-Basic\saxpy\main.hip -o saxpy.exe -I.\Common -lamdhip64 -L ${env:HIP_PATH}                                                                                                                                                                                                       
-                                                                                                                                                                                                        -lib -02</code></pre>
-<h2>Windows and NVIDIA</h2>
-<p><strong>**Following code does:** This code snippet appears to be executing a compiled program named `saxpy.exe`, which performs the SAXPY operation (Single-Precision A·X Plus Y). The operation involves scaling a vector `x` by a scalar `a` and adding it to another vector `y`, element-wise. The program processes 10,000,000 elements and outputs the first 10 elements of the resulting vector `y` after the computation. The output suggests that the operation has been successfully completed, showing the first 10 elements of the updated vector `y`.</strong></p>
-<pre><code>                                                                                                                                                                                                        | nvcc.\HIP-Basic\saxpy\main.hip -o saxpy.exe -I ${env:HIP_PATH}include -I.\Common -02 - -
-                                                                                                                                                                                                        -x                                                                                                                                                                                                       
-                                                                                                                                                                                                       |                                                                                                                                                                                                        +x                                                                                                                                                                                                       |</code></pre>
-<p>Depending on your computer, the resulting binary might or might not run. If not, it typically complains about 'Invalid device function'. That error (corresponding to the hipErrorInvalidDeviceFunction entry of hipError_t ) means that the runtime could not find a device program binary of the appropriate flavor embedded into the executable.</p>
-<p>So far, the discussion has covered how data makes it from the host to the device and back. It has also discussed the device code as source, with the HIP runtime arguing that the correct binary to dispatch for execution. How can you find out what device binary flavors are embedded into the executable?</p>
-<h2>Linux and AMD</h2>
-<p>The utilities included with ROCm help significantly to inspect binary artifacts on disk. Add the ROCmCC installation folder to your PATH if you want to use these utilities (the utilities expect them to be on the PATH).</p>
-<p>You can list embedded program binaries using roc-obj-ls .</p>
-<p><strong>**Following code does:** The code snippet appears to be a command for compiling a C++ program using `nvcc`, which is the NVIDIA CUDA Compiler. The command is intended to compile a source file named `main.cpp` located in the `HIP-Basic/device_query` directory, and produce an executable named `device_query.exe`. It includes additional directories for header files specified by `-I.\Common` and `-I ${env:HIP_PATH}`. However, the command seems to be malformed or incomplete, as it includes unusual formatting and options like `-include -02` and `--include -0022`, which are not standard or correctly formatted compiler options. This suggests that the command might be incorrectly copied or formatted.</strong></p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?>
-                                                                                                                                                                                                       <!>
-                                                                                                                                                                                                      <!>"</code></pre>
-<p><strong>**Following code does:** This code snippet executes a command-line program called `device_query.exe` and pipes its output to the `Select-String` command, which searches for occurrences of the string "major.minor". The output shows that the program found two instances of "major.minor" with associated version numbers, 8.6 and 7.0. This suggests that the code is used to query and display the major and minor version numbers of certain devices or software components.</strong></p>
-<pre><code><_SQL_></code></pre>
-<p>The compiler embeds a version 4 code object (more on code object versions) and used the LLVM target triple amdgcnamd-amdhsa-gfx803 (more on target triples). You can extract that program object in a disassembled fashion for human consumption via roc-obj .</p>
-<p><strong>**Following code does:** The code snippet provided appears to be a series of whitespace characters followed by two lines with the decrement operation `--x` and `-x`. However, this is not valid Python code due to the excessive whitespace and lack of context or structure. In Python, `--x` is not a valid operation as it would be interpreted as two separate unary negations, effectively leaving `x` unchanged. Similarly, `-x` is a unary negation that simply returns the negative value of `x`. Without additional context or surrounding code, this snippet does not perform any meaningful operation.</strong></p>
-<pre><code>        | r o c - o b j \ - t \ g f x 8 0 3 \ - d \. / s a x p y</code></pre>
-<p>This creates two files on disk and .s extension is of most interest. Opening this file or dumping it to the console using cat lets find the disassembled binary of the SAXPY compute kernel, something similar to:</p>
-<p><strong>**Following code does:** This code snippet appears to be executing a compiled program named `saxpy.exe`, which performs the SAXPY operation (Single-Precision A·X Plus Y). The operation involves scaling a vector `x` by a scalar `a` and adding it to another vector `y`, element-wise, over 10,000,000 elements. The output shows the first 10 elements of the resulting vector `y` after the operation has been completed.</strong></p>
-<pre><code><_XML_></code></pre>
-<p>Alternatively, call the compiler with --save-temps to dump all device binary to disk in separate files.</p>
-<p><strong>**Following code does:** It seems like you've provided a placeholder or incomplete code snippet. Please provide the actual code so I can help explain its purpose.</strong></p>
-<pre><code>                                                                                                                                                                                                        |                                                                                                                                                                                                       
-                                                                                                                                                                                                        -                                                                                                                                                                                                        --                                                                                                                                                                                                        \                                                                                                                                                                                                        +                                                                                                                                                                                                        <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        }                                                                                                                                                                                                        </----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                    |   
-                                                                                                                                                                                                    |    -                                                                                                                                                                                                    |    0                                                                                                                                                                                                        ]                                                                                                                                                                                                        )                                                                                                                                                                                                       .                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        :                                                                                                                                                                                                       '</code></pre>
-<p>List all the temporaries created while compiling main.hip with:</p>
-<p><strong>**Following code does:** This code defines a CUDA kernel function named `k` that operates on arrays of `float4` structures. The kernel is intended to be executed on a GPU, where each thread in a block performs a computation on elements of the input arrays `a` and `b`. Specifically, for each thread, it calculates an index using the thread ID (`tid`), block ID (`bid`), and block dimension (`dim`). It then updates the element in array `a` at the current thread index by adding the product of the calculated index and the corresponding element in array `b`. This operation is performed in parallel across all threads in a block.</strong></p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-    ls main-hip-amdgcn-amd-amdhsa-*
-    main-hip-amdgcn-amd-amdhsa-gfx803.bc
-    main-hip-amdgcn-amd-amdhsa-gfx803.cui
-    main-hip-amdgcn-amd-amdhsa-gfx803.o
-    main-hip-amdgcn-amd-amdhsa-gfx803.out
-    main-hip-amdgcn-amd-amdhsa-gfx803.out.resolution.txt
-    main-hip-amdgcn-amd-amdhsa-gfx803.s</code></pre>
-<p>Files with the .s extension hold the disassembled contents of the binary. The filename notes the graphics IPs used by the compiler. The contents of this file are similar to what roc-obj printed to the console.</p>
-<h2>Linux and NVIDIA</h2>
-<p>Unlike HIP on AMD, when compiling using the NVIDIA support of HIP the resulting binary will be a valid CUDA executable as far as the binary goes. Therefor it'll incorporate PTX ISA (Parallel Thread eXecution Instruction Set Architecture) instead of AMDGPU binary. As s result, tooling shipping with the CUDA SDK can be used to inspect which device ISA got compiled into a specific executable. The tool most useful to us currently is cuobjdump .</p>
-<p><strong>**Following code does:** The provided code snippet appears to be a mix of Python and C++ syntax, but it is largely nonsensical and does not perform any meaningful operation. It includes fragments of C++ code, such as `<std::size_t factor = block_size;` and `</std::endl;`, which are not valid in Python. Additionally, there are scattered mathematical operators and comments that do not form a coherent program. Overall, this snippet does not achieve any functional purpose and seems to be a collection of random code fragments.</strong></p>
-<pre><code>  cuobjdump --list-ptx./saxpy
-
-  Which will print something like:</code></pre>
-<p><strong>**Following code does:** The provided code snippet appears to be a series of `<void>` and `</void>` tags interspersed with whitespace. It does not contain any executable Python code or meaningful logic. It seems to be a nonsensical or malformed attempt at using XML-like tags, but without any context or structure that would give it a functional purpose. Therefore, the code does not perform any operations or have a high-level purpose.</strong></p>
-<pre><code>| P T X \ f i l e</code></pre>
-<p><strong>**Following code does:** This code snippet appears to be part of a loop that launches a GPU kernel using the HIP (Heterogeneous-Compute Interface for Portability) API. The loop iterates in reverse, starting from `input_count` and decrementing until it is greater than 1. Within the loop, the `hipLaunchKernelGGL` function is called to execute a kernel function named `kernel` on the GPU. The kernel is launched with a grid configuration determined by `dim3(new_size(curr))` and a block size of `dim3(block_size)`. The kernel is provided with shared memory of size `factor * sizeof(unsigned)` and is executed on the default HIP stream. The parameters `front`, `back`, and `kernel_op` are passed to the kernel, likely as arguments for processing data. The purpose of this code is to perform parallel computations on a GPU, potentially for tasks like data processing or transformation, by repeatedly launching a kernel with varying configurations.</strong></p>
-<pre><code>1:  saxpy. 1. sm_5. ptx</code></pre>
-<p>From this we can see that the saxpy kernel is stored as sm_52 , which shows that a compute capability 5.2 ISA got embedded into the executable, so devices which sport compute capability 5.2 or newer will be able to run this code.</p>
-<h2>Windows and AMD</h2>
-<p>The HIP SDK for Windows don't yet sport the roc-* set of utilities to work with binary artifacts. To find out what binary formats are embedded into an executable, one may use dumpbin tool from the Windows SDK to obtain the raw data of the .hip_fat section of an executable. (This binary payload is what gets parsed by the roc-* set of utilities on Linux.) Skipping over the reported header, the rendered raw data as ASCII has ~3 lines per entries. Depending on how many binaries are embedded, you may need to alter the number of rendered lines. An invocation such as:</p>
-<p><strong>**Following code does:** The code snippet `1;)` is not valid Python code. It appears to be a syntax error, as Python does not allow a semicolon to follow a number without a preceding valid statement. This snippet will result in a syntax error if executed in a Python interpreter.</strong></p>
-<pre><code>                                                                                                                                                                                                        | dumpbin.exe  /nologo  /section:.hip_fat  /rawdata:8 .\saxpy.exe  |  select  -Skip  20  -First  12                                                                                                                                                                                                       
-                                                                                                                                                                                                        -                                                                                                                                                                                                        --                                                                                                                                                                                                        +                                                                                                                                                                                                        <--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        </--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                   | dumpbin .exe  /nologo  /section:.hip_fat  /rawdata:8 .\saxpy.exe  |  select  -Skip  20  -First  12                                                                                                                                                             |                                                                                                                                                                                                        >--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                  
-     |  dumpbin.exe  /nologo  /section:.hip_fat  /rawdata:8 .\saxpy.exe  |  select  -Skip  20  -First  12                                                                                                                                                        |                                               
-     |                                                                                                                                                                                                   |                                          
-     |                                                                                                                                                       
-     |                                                                                                                                                   |                                                    
-     |                                                                                                                                             
-     |                                                    
-     |                                                                                                                                        
-     |                                                         
-     |</code></pre>
-<p>The output may look like:</p>
-<p><strong>**Following code does:** This code snippet appears to be part of a larger function or program, likely written in C++ given the use of `std::swap`. The code performs the following high-level operations:
-
-1. It assigns a new value to the variable `curr` by calling a function `new_size(curr)`.
-2. It checks if the updated value of `curr` is greater than 1.
-3. If `curr` is greater than 1, it swaps the values of two variables, `front` and `back`, using the `std::swap` function.
-
-Overall, the code seems to be adjusting the size of something (possibly a container or data structure) and conditionally swapping two elements based on the new size.</strong></p>
-<pre><code><_Python_></code></pre>
-<p>We can see that the compiler embedded a version 4 code object (more on code object versions) and used the LLVM target triple amdgcn-amd-amdhsa-gfx906 (more on target triples). Don't be alarmed about linux showing up as a binary format, AMDGPU binaries uploaded to the GPU for execution are proper linux ELF binaries in their format.</p>
-<p>Alternatively we can call the compiler with --save-temps to dump all device binary to disk in separate files.</p>
-<p><strong>**Following code does:** The code snippet `<_Cuda_>` appears to be a placeholder or a symbolic representation rather than actual executable code. In the context of programming, particularly with Python, it might be intended to represent a CUDA-related object or module. CUDA (Compute Unified Device Architecture) is a parallel computing platform and application programming interface (API) model created by NVIDIA, which allows developers to use a GPU for general purpose processing. However, without additional context or actual code, it's not possible to determine the specific functionality or purpose of this placeholder.</strong></p>
-<pre><code>                                                                                                                                                                                                        |clang++.\HIP-Basic\saxpy\main.hip -o saxpy.exe -I.\Common -lamdhip64 -L ${env:HIP_PATH}                                                                                                                                                                                                       
-                                                                                                                                                                                                        -lib -02 --save-temps                                                                                                                                                                                                        \</code></pre>
-<p>Now we can list all the temporaries created while compiling main.hip via</p>
-<p><strong>**Following code does:** This code snippet is part of a parallel reduction algorithm typically used in GPU programming, such as with CUDA. The purpose of this code is to perform a reduction operation (e.g., summation, finding the maximum) on an array of data stored in shared memory (`shared`). The reduction is done in parallel by multiple threads within a block.
-
-The loop iteratively reduces the number of elements by combining pairs of elements using a binary operation `op`. The `for` loop iterates over increasing powers of two, effectively halving the number of active elements in each iteration. The `__syncthreads()` function is used to synchronize all threads in the block, ensuring that all threads have completed their operations before proceeding to the next iteration.
-
-The code has been modified to use a different indexing strategy, where the index `j` is calculated based on the thread ID (`tid`) and the current step size (`i`). This change aims to ensure that only valid indices within the bounds of the block are accessed, preventing out-of-bounds memory access.</strong></p>
-<pre><code>        |Get-ChildItem -Filter main-hip-* | selec</code></pre>
-<p><strong>**Following code does:** The provided code snippet appears to be a fragment of a larger codebase, possibly related to parallel computing or GPU programming, given the use of `blockDim.x` which is common in CUDA programming for defining the number of threads in a block. The snippet seems to be part of a loop intended for a shared reduction operation, which is a common parallel algorithm used to reduce an array of values to a single value (e.g., sum, max). However, the snippet is incomplete and contains some formatting artifacts (e.g., `-` and `+` symbols), which suggest it might be part of a diff or patch file showing changes to the code. The high-level purpose of this snippet is likely to perform a reduction operation across threads within a block.</strong></p>
-<pre><code>n-hip-* | select -Property Name
-                                                                                                                                                                                                         (continues on next page)</code></pre>
-<p>(continued from previous page)</p>
-<p><strong>**Following code does:** The code snippet `<_Cuda_>` appears to be a placeholder or a symbolic representation rather than actual executable Python code. In the context of programming, "Cuda" typically refers to NVIDIA's parallel computing platform and application programming interface (API) model, which allows developers to use a CUDA-enabled graphics processing unit (GPU) for general purpose processing. However, without additional context or actual code, it's not possible to determine the specific functionality or purpose of this placeholder.</strong></p>
-<pre><code>Name
------
-main-hip-amdgcn-amd-amdhsa-gfx906.bc
-main-hip-amdgcn-amd-amdhsa-gfx906.hipi
-main-hip-amdgcn-amd-amdhsa-gfx906.o
-main-hip-amdgcn-amd-amdhsa-gfx906.out
-main-hip-amdgcn-amd-amdhsa-gfx906.out.resolution.txt
-main-hip-amdgcn-amd-amdhsa-gfx906.s</code></pre>
-<p>Files with the .s extension hold the disassembled contents of the binary and the filename directly informs us of the graphics IPs used by the compiler.</p>
-<p><strong>**Following code does:** This code snippet is written in C++ and its purpose is to print the numbers from 0 to 3 sequentially. It uses a `for` loop to iterate over a range of integers starting from 0 up to, but not including, 4. During each iteration, it prints the current value of the loop variable `i` using the `printf` function.</strong></p>
-<pre><code>main-hip-amdgcn-amd-amdsha-gfx906.out
-main-hip-amdgcn-amd-amdsha-gfx906.out.resolution.txt
-main-hip-amdgcn-amd-amdsha-gfx906.s
-
-Files with the.s extension hold the disassembled contents of the binary and the filename directly informs us of the
-graphics IPs used by the compiler.
-
-Get-ChildItem main-hip-*.s | Get-Content
-           .text
-           .amdgcn_target "amdgcn-amd-amdsha--gfx906"
-           .protected        _Z12saxpy_kernelPKfPfj ; -- Begin  function _Z12saxpy_
-  --kernelPKfPfj
-           .glob1   _Z12saxpy_kernelPKfPfj
-           .p2align           8
-           .type     _Z12saxpy_kernelPKfPfj,@function
-_Z12saxpy_kernelPKfPfj:                                                                                                                                                                                                        
-  ; %bb.0:
-            s_load_dword s0, s[4:5], 0x4
-            s_load_dword s1, s[6:7], 0x18
-            s_waitcnt lgkmcnt(0)
-            s_and_b32 s0, s0, 0xffff
-            s_mul_i32 s8, s8, s0
-            v_add_u32_e32 v0, s8, v0
-            v_cmp_gt_u32_e32 vcc,  s1, v0
-            s_and_saveexec_b64 s[0:1], vcc
-            s_cbranch_execz.LBB0_2
-  ; %bb.1:
-            s_load_dwordx4 s[0:3], s[6:7], 0x8
-            v_mov_b32_e32 v1, 0
-            v_lshlrev_b64 v[0:1], 2, v[0:1]
-            s_waitcnt lgkmcnt(0)
-            v_mov_b32_e32 v3, s1
-            v_add_co_u32_e32 v2, vcc, s0, v0
-            v_addc_co_u32_e32 v3, vcc, v3, v1, vcc
-            global_load_dword v2, v[2:3], off
-            v_mov_b32_e32 v3, s3
-            v_add_co_u32_e32 v0, vcc, s2, v0
-            v_addc_co_u32_e32 v1, vcc, v3, v1, vcc
-            global_load_dword v3, v[0:1], off
-            s_load_dword s0, s[6:7], 0x0
-            s_waitcnt vmcnt(0) lgkmcnt(0)
-            v_fmac_f32_e32 v3, s0, v2
-            global_store_dword v[0:1], v3, off
- .LBB0_2:
-            s_endpgm
-           ...</code></pre>
-<h2>Windows and NVIDIA</h2>
-<p>Unlike HIP on AMD, when compiling using the NVIDIA support for HIP, the resulting binary will be a valid CUDA executable. Therefore, it'll incorporate PTX ISA (Parallel Thread eXecution Instruction Set Architecture) instead of AMDGPU binary. As a result, tooling included with the CUDA SDK can be used to inspect which device ISA was compiled into a specific executable. The most helpful to us currently is cuobjdump .</p>
-<p><strong>**Following code does:** This code snippet is a portion of assembly code that is part of a function, likely the `main` function of a program. It primarily performs the following actions:
-
-1. It saves the `rbx` register onto the stack to preserve its value.
-2. It loads the address of a string (likely a format string) into the `rbx` register.
-3. It sets up arguments for the `printf` function call by moving the address of the string into the `rdi` register and zeroing out the `esi` and `eax` registers, which are used for additional arguments and return values, respectively.
-4. It calls the `printf` function twice, first with `esi` set to zero and then with `esi` set to one, likely printing the same string twice with different formatting or arguments.
-5. The code does not show the complete function, but it is likely part of a simple program that prints a string to the console using the `printf` function from the C standard library.
-
-Overall, the code is focused on printing a string to the console using the `printf` function.</strong></p>
-<pre><code><_Bash_></code></pre>
-<p><strong>**Following code does:** This code snippet is a fragment of assembly code, likely generated by the GCC compiler, that involves calling the `printf` function twice. The purpose of this code is to print two integers to the standard output using the format string "%d". 
-
-1. The first `printf` call prints the integer `2`.
-2. The second `printf` call prints the integer `3`.
-
-The code uses the `printf` function from the Procedure Linkage Table (PLT), which is a common technique in dynamically linked executables to resolve function addresses at runtime. The `xor eax, eax` instructions are used to set the `eax` register to zero, which is a common way to prepare for a function call in x86-64 assembly. The `pop rbx` and `ret` instructions are used to restore the base pointer and return from the function, respectively.</strong></p>
-<pre><code>| P T X \ f i l e</code></pre>
-<p><strong>**Following code does:** This code is a low-level assembly representation of a simple C program that prints the numbers 0 through 3, each on a new line. It uses a loop to increment a counter (`ebx`) from 0 to 3, and in each iteration, it calls the `printf` function to print the current value of the counter. The loop continues until the counter reaches 4, at which point the program exits. The `.string "%d"` is used as the format string for `printf` to print integers.</strong></p>
-<pre><code>1:  saxpy. 1. sm_5. ptx</code></pre>
-<p>This example shows that the SAXPY kernel is stored as sm_52 . It also shows that a compute capability 5.2 ISA was embedded into the executable, so devices that support compute capability 5.2 or newer will be able to run this code.</p>
-<p>Now that you've found what binary got embedded into the executable, find which format our available devices use.</p>
-<h2>Linux and AMD</h2>
-<p>On Linux a utility called rocminfo helps us list all the properties of the devices available on the system, including which version of graphics IP ( gfxXYZ ) they employ. You can filter the output to have only these lines:</p>
-<p><strong>**Following code does:** This code is an assembly routine for a function named `main`, likely compiled from a C/C++ program using the Microsoft Visual C++ (MSVC) compiler. The function's high-level purpose is to print a string (referred to as `'string'` in the code) four times using a loop. It uses the `printf` function to output the string. The loop is controlled by the `ebx` register, which is incremented each iteration until it reaches 4. The function sets up and cleans up the stack frame before and after the loop, respectively, and returns 0 upon completion.</strong></p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?php?com/bin/rocminfo | grep gfx
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        </?php?com/bin/rocminfo | grep gfx
-                                                                                                                                                                                        
-	              Name:                                                                                                                                                                                                        &</code></pre>
-<p>Now that you know which graphics IPs our devices use, recompile your program with the appropriate parameters.</p>
-<p><strong>**Following code does:** This code snippet sequentially prints the integers 0, 1, 2, and 3 to the standard output. Each `printf` function call outputs one integer, formatted as a decimal integer (`%d`).</strong></p>
-<pre><code>                                                                                                                                                                                                        |                                                                                                                                                                                                       
-                                                                                                                                                                                                        -                                                                                                                                                                                                        --                                                                                                                                                                                                        \                                                                                                                                                                                                        +                                                                                                                                                                                                        <                                                                                                                                                                                                        </                                                                                                                                                                                                        }                                                                                                                                                                                                        >                                                                                                                                                                                                        &                                                                                                                                                                                                        )                                                                                                                                                                                                        ]                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        :                                                                                                                                                                                                        ;                                                                                                                                                                                                       .                                                                                                                                                                                                        "</code></pre>
-<p>Now the sample will run.</p>
-<p><strong>**Following code does:** The code snippet appears to be an incorrectly formatted XML declaration. It contains two XML declaration lines, which are not valid in XML syntax. The first line is a correctly formatted XML declaration, while the second line is incorrectly closed with a question mark before the "xml" keyword. This snippet does not perform any functional operation and would likely result in a parsing error if used in an XML document.</strong></p>
-<pre><code>        /saxpy
-        Calculating y[i] = a * x[i] + y[i] over 10000000 elements.
-        First 10 elements of the results: [ 3, 5, 7, 9, 11, 13, 15, 17, 19, 21 ]</code></pre>
-<p><strong>**Following code does:** This code snippet is written in C++ and is used in a GPU programming context, likely with the HIP (Heterogeneous-Compute Interface for Portability) API, which is used for writing portable code across AMD and NVIDIA GPUs. The code retrieves the warp size from the device properties and uses a switch statement to launch a GPU kernel with a template parameter that matches the warp size. Specifically, if the warp size is 32, it launches a kernel with a template argument of 32; if the warp size is 64, it launches a kernel with a template argument of 64. This allows the kernel to be optimized based on the warp size of the GPU being used.</strong></p>
-<pre><code><_Python_></code></pre>
-<h2>Linux and NVIDIA</h2>
-<p>On Linux HIP with the NVIDIA back-end, the deviceQuery CUDA SDK sample can help us list all the properties of the devices available on the system, including which version of compute capability a device sports. &lt;major&gt;.&lt;minor&gt; compute capability is passed to nvcc on the command-line as sm_&lt;major&gt;&lt;minor&gt; , for eg. 8.6 is sm_86 .</p>
-<p>Because it's not included as a binary, compile the matching example from ROCm.</p>
-<p><strong>**Following code does:** This code snippet is a template-based mechanism that uses a static switch to select between different compile-time options for a CUDA or HIP kernel launch. Specifically, it uses `tmp::static_switch` to choose between two possible values for `warp_size` (32 or 64). Depending on the selected value, it launches a GPU kernel (`kernel`) with the corresponding warp size as a template parameter. This allows the code to optimize the kernel execution for different warp sizes at compile time, potentially improving performance by tailoring the execution to the specific hardware configuration.</strong></p>
-<pre><code>                                                                                                                                                                                                        |                                                                                                                                                                                                       
-                                                                                                                                                                                                        <.02                                                                                                                                                                                                        </.00                                                                                                                                                                                                        >.00                                                                                                                                                                                                      <.00                                                                                                                                                                                                      </.01                                                                                                                                                                                                        }</code></pre>
-<p>Filter the output to have only the lines of interest, for example:</p>
-<p><strong>**Following code does:** The code snippet appears to be incomplete or malformed. It seems to be missing context or additional code that would clarify its purpose. The snippet includes a generic placeholder `t WarpSize>()`, which might suggest a template or a function call in a language like C++ rather than Python. However, without additional context or surrounding code, it's not possible to determine its high-level purpose or functionality.</strong></p>
-<pre><code><_YAML_></code></pre>
-<p>Note: In addition to the nvcc executable is another tool called __nvcc_device_query which prints the SM Architecture numbers to standard out as a comma separated list of numbers. The utility's name suggests it's not a user-facing executable but is used by nvcc to determine what devices are in the system at hand.</p>
-<p>Now that you know which graphics IPs our devices use, recompile your program with the appropriate parameters.</p>
-<p><strong>**Following code does:** This code snippet is a modification of a GPU kernel function written in HIP (Heterogeneous-Compute Interface for Portability), which is used for parallel computing on AMD and NVIDIA GPUs. The changes introduce a template parameter `WarpSize` to the kernel, allowing it to handle different warp sizes (32 for NVIDIA and RDNA AMD GPUs, 64 for CDNA AMD GPUs) more flexibly. The shared memory reduction loop is adjusted to stop at the warp size, and a new warp-level reduction is added using a static loop unrolling technique (`tmp::static_for`). This ensures that the kernel can efficiently perform reductions across threads within a warp, adapting to the specific warp size of the target hardware.</strong></p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <_arch=sm_70,sm_86</code></pre>
-<p>Note: If you want to portably target the development machine which is compiling, you may specify -arch=native instead.</p>
-<p>Now the sample will run.</p>
-<p><strong>**Following code does:** It seems there is a formatting error in your request. The code snippet is labeled as C++ but is enclosed within Python code tags. Please provide the correct code snippet or clarify the language so I can assist you accurately.</strong></p>
-<pre><code>           ./saxpy
-            Calculating y[i] = a * x[i] + y[i] over 10000000 elements.
-            First 10 elements of the results: [ 3, 5, 7, 9, 11, 13, 15, 17, 19, 21 ]</code></pre>
-<h2>Windows and AMD</h2>
-<p>On Windows, a utility called hipInfo.exe helps us list all the properties of the devices available on the system, including which version of graphics IP ( gfxXYZ ) they employ. Filter the output to have only these lines:</p>
-<p><strong>**Following code does:** The provided code snippet appears to be a collection of random characters and symbols, including some that resemble HTML/XML tags and others that are typical in programming syntax. However, it does not form any valid or meaningful code in Python or any other programming language. It seems to be a nonsensical or corrupted text rather than a functional code snippet.</strong></p>
-<pre><code>& ${env:HIP_PATH}bin\hipInfo.exe | Select-String gfx
-
-gcnArchName:                    gfx1032
-gcnArchName:                    gfx1035</code></pre>
-<p>Now that you know which graphics IPs our devices use, recompile your program with the appropriate parameters.</p>
-<p><strong>**Following code does:** The code snippet provided is incomplete and contains only a comment: `// Warp reduction`. This comment suggests that the code is likely part of a larger program, possibly written in a language like CUDA C/C++ for GPU programming, where "warp reduction" is a common technique. Warp reduction is used to efficiently perform parallel reduction operations (such as summing elements) within a warp, which is a group of threads that execute the same instruction simultaneously on a GPU. However, without additional context or code, it's not possible to describe the specific implementation or purpose beyond this general concept.</strong></p>
-<pre><code>                                                                                                                                                                                                        |clang++.\HIP-Basic\saxpy\main.hip -o saxpy.exe -I.\Common -lamdhip64 -L ${env:HIP_PATH}                                                                                                                                                                                                       
-                                                                                                                                                                                                        -lib -02 --offload-arch=gfx1032 --offload-arch=gfx1035                                                                                                                                                                                                        --lib -02 --offload-arch=gfx1035</code></pre>
-<p>Now the sample will run.</p>
-<p><strong>**Following code does:** The provided code snippet is a partial definition of a CUDA kernel function template in C++. This kernel is designed to be executed on a GPU. It uses template parameters to allow flexibility in specifying the block size, warp size, data type, and operation type. The kernel function, named `kernel`, takes several parameters: pointers to two arrays (`front` and `back`), an operation (`op`), a zero element (`zero_elem`), and the size of the `front` array (`front_size`). The `__launch_bounds__(BlockSize)` attribute is used to specify the maximum number of threads per block, optimizing the kernel's execution configuration. The actual implementation of the kernel is not provided in the snippet.</strong></p>
-<pre><code>       .\saxpy.exe
-        Calculating y[i] = a * x[i] + y[i] over 10000000 elements.
-        First 10 elements of the results: [ 3, 5, 7, 9, 11, 13, 15, 17, 19, 21 ]</code></pre>
-<h2>Windows and NVIDIA</h2>
-<p>On Windows HIP with the NVIDIA back-end, the deviceQuery CUDASDKsample can help us list all the properties of the devices available on the system, including which version of compute capability a device sports. &lt;major&gt;. &lt;minor&gt; compute capability is passed to nvcc on the command-line as sm_&lt;major&gt;&lt;minor&gt; , for eg. 8.6 is sm_86 .</p>
-<p>Because it's not included as a binary, compile the matching example from ROCm.</p>
-<p><strong>**Following code does:** This code snippet is part of a CUDA kernel designed for parallel computation on a GPU. It involves reading data from a global memory buffer (`front`) and performing operations on it using shared memory to optimize performance. Here's a high-level summary of what the code does:
-
-1. **Warp and Block Configuration**: It calculates the number of warps (`WarpCount`) within a block based on the block size and warp size. Warps are groups of threads that execute instructions in lockstep.
-
-2. **Shared Memory Allocation**: It allocates shared memory (`shared`) for storing intermediate results. The size of this shared memory is determined by the number of warps in the block.
-
-3. **Safe Reading Functions**: It defines two lambda functions, `read_global_safe` and `read_shared_safe`, to safely read elements from global and shared memory, respectively. These functions ensure that reads do not exceed the bounds of the memory arrays.
-
-4. **Thread and Block Indexing**: It calculates various indices (`tid`, `bid`, `gid`, `wid`, `lid`) to identify the thread's position within the block and grid. These indices are used to determine which data elements each thread should process.
-
-5. **Data Processing**: Each thread reads two elements from the global memory (`front`) using the `read_global_safe` function and applies an operation (`op`) on them. The result is stored in a local variable (`res`).
-
-Overall, this code is part of a larger CUDA kernel that performs parallel data processing using shared memory to improve performance by reducing global memory accesses. The use of shared memory allows for efficient communication of results between threads within the same block.</strong></p>
-<pre><code>                                                                                                                                                                                                        |nvcc.\HIP-Basic\device_query\main.cpp -o device_query.exe -I.\Common -I ${env:HIP_PATH}                                                                                                                                                                                                       
-                                                                                                                                                                                                        -include -02                                                                                                                                                                                                        --include -0022</code></pre>
-<p>Filter the output to have only the lines of interest, for example:</p>
-<p><strong>**Following code does:** This code snippet appears to be part of a parallel computing or multi-threading context, likely using a GPU or a similar architecture where threads are organized into blocks. The code checks if the current thread's identifier (`tid`) is zero, which typically means it is the first thread in a block. If this condition is true, it writes a computed result (`res`) from local memory to a shared or global memory location (`back`) indexed by the block identifier (`bid`). This pattern is often used to consolidate results from multiple threads within a block into a single output.</strong></p>
-<pre><code> .\device_query.exe | Select-String "major.minor"
-
-  major.minor:              8.6
-  major.minor:              7.0</code></pre>
-<p>Note: Next to the nvcc executable is another tool called __nvcc_device_query.exe which simply prints the SM Architecture numbers to standard out as a comma separated list of numbers. The naming of this utility suggests it's not a user facing executable but is used by nvcc to determine what devices are in the system at hand.</p>
-<p>Now that you know which graphics IPs our devices use, recompile your program with the appropriate parameters.</p>
-<p><strong>**Following code does:** The code snippet appears to be incomplete and contains a syntax error. It seems like it might be part of a larger piece of code, possibly involving threading or parallel processing, given the mention of "ItemsPerThread". However, without additional context or complete code, it's not possible to determine its high-level purpose.</strong></p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        --x                                                                                                                                                                                                        -x</code></pre>
-<p>Note: If you want to portably target the development machine which is compiling, you may specify -arch=native instead.</p>
-<p>Now the sample will run.</p>
-<p><strong>**Following code does:** The code snippet provided is a fragment of a CUDA kernel function declaration in C++. CUDA is a parallel computing platform and application programming interface model created by NVIDIA. The purpose of this code is to define a GPU kernel function that can be executed on an NVIDIA GPU.
-
-- `__global__`: This keyword indicates that the function is a CUDA kernel, which means it is executed on the GPU but can be called from the host (CPU) code.
-- `static`: This keyword suggests that the kernel function has internal linkage, meaning it is only visible within the translation unit it is defined in.
-- `__launch_bounds__(BlockSize)`: This is an optional CUDA attribute that specifies the maximum number of threads per block (`BlockSize`) that the kernel is optimized for. It helps the compiler optimize the kernel for specific execution configurations.
-
-The ellipsis (`...`) indicates that the function's parameters and body are not shown. Overall, this snippet is part of a larger CUDA program designed to perform parallel computations on a GPU.</strong></p>
-<pre><code>       .\saxpy.exe
-        Calculating y[i] = a * x[i] + y[i] over 10000000 elements.
-        First 10 elements of the results: [ 3, 5, 7, 9, 11, 13, 15, 17, 19, 21 ]</code></pre>
-<p><strong>**Following code does:** The code snippet `<_C_>` appears to be a placeholder or a symbolic representation rather than actual executable code. It does not perform any operations or have any functionality in Python as it stands. It might be used as a marker or a template in a larger context where specific code or content is meant to be inserted.</strong></p>
-<pre><code><_Python_></code></pre>
-<h2>CHAPTER</h2>
-<h2>TWENTYNINE</h2>
-<h2>REDUCTION</h2>
-<p>Reduction is a common algorithmic operation used in parallel programming to reduce an array of elements into a shorter array of elements or a single value. This document exploits reduction to introduce some key considerations while designing and optimizing GPU algorithms.</p>
-<p>This document is a rejuvenation and extension of the invaluable work of Mark Harris. While the author approaches the topic with a less naive approach, reviewing some original material is valuable to see how much the underlying hardware has changed. This document provides a greater insight to demonstrate progress.</p>
-<h2>29.1 The algorithm</h2>
-<p>Reduction has many names depending on the domain; in functional programming it's referred to as fold, in C++, it's called std::accumulate and in C++17, as std::reduce . A reduction takes a range of inputs and 'reduces' the given range with a binary operation to a singular or scalar output. Canonically, a reduction requires a 'zero' element that bootstraps the algorithm and serves as one of the initial operands to the binary operation. The 'zero' element is generally called identity or neutral element in the group theory, which implies that it is an operand that doesn't change the result. Some typical use cases are: calculating a sum or normalizing a dataset and finding the maximum value in the dataset. The latter use case is discussed further in this tutorial.</p>
-<p>There are multiple variations of reduction that allow parallel processing. The approach taken by std::reduce requires the user-provided binary operator to operate on any combination of identity and input range elements, or even exclusively on any of them. This allows you to insert any number of identities to facilitate parallel processing and then combine the partial results of parallel execution.</p>
-<h2>29.2 Reduction on GPUs</h2>
-<p>Implementing reductions on GPUs requires a basic understanding of the /understand/programming_model_reference. The document explores aspects of low-level optimization best discussed through the Inherent thread model , and refrains from using cooperative groups.</p>
-<p>Synchronizing parallel threads of execution across a GPU is crucial for correctness as the partial results can't be synchronized before they manifest. Synchronizing all the threads running on a GPU at any given time is possible, however, it is a costly and intricate operation. If synchronization is not absolutely necessary, map the parallel algorithm so that multiprocessors and blocks can make independent progress and need not sync frequently.</p>
-<p>There are ten reduction implementations in the rocm-examples, which are described in the following sections.</p>
-<h2>29.2.1 Naive shared reduction</h2>
-<p>The naive algorithm takes a tree-like shape, where the computational domain is purposefully distributed among blocks. In all blocks, all threads participate in loading data from persistent (from the kernel's perspective) global memory into the shared memory. This helps to perform tree-like reduction for a single thread by writing the partial result to global, in a location unique to the block, which allows the block to make independent progress. The partial results are combined in subsequent launches of the same kernel until a scalar result is reached.</p>
-<p>This approach requires temporary storage based on the number of blocks launched, as each block outputs a scalar partial result. Depending on the need to store or destroy the input, a second temporary storage might be needed, which could be large enough to store the results of the second kernel launch. Alternatively, you can reuse the storage of the larger than necessary original input. These implementations differ so slightly that the document only considers the use case where the input could be destroyed.</p>
-<p><strong>**Following code does:** The code snippet defines a lambda function `read_global_safe` in C++ that reads a sequence of elements from an array `front` into a static array of a specified size `ItemsPerThread`. The lambda uses a template parameter pack and `std::integer_sequence` to iterate over indices. If the index plus the number of items per thread is within the bounds of `front_size`, it directly loads elements from `front`. Otherwise, it loads elements conditionally, substituting a `zero_elem` for out-of-bounds indices. This ensures safe reading from the array without exceeding its bounds.</strong></p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <std::size_t factor = block_size; // block_size from hipGetDeviceProperties()
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        </std::endl;
-                                                                                                                                                                                                       <int>                                                                                                                                                                                                        //                                                                                                                                                                                                       	                                                                                                                                                                                                      
-//                                                                                                                                                                                                        +                                                                                                                                                                                                        -                                                                                                                                                                                                        *                                                                                                                                                                                                        /                                                                                                                                                                                                        */
-                                                                                                                                                                                                       +
-                                                                                                                                                                                                       *
-                                                                                                                                                                                                       -
-                                                                                                                                                                                                       */</code></pre>
-<p>For threads that don't have unique inputs, feed zero_elem instances to threads. The backing of double-buffering is allocated as such:</p>
-<p><strong>**Following code does:** This code snippet initializes an array `arr` of size 4 with elements from another array or list called `front`. The elements are selected based on an index `gid`, such that `arr` contains four consecutive elements starting from `front[gid]` to `front[gid + 3]`. The type of the elements in `arr` is denoted by `T`, which suggests that this code is likely written in a language that uses templates or generics, such as C++ or a similar language. The purpose of this code is to create a subarray or slice of four elements from the `front` array starting at a specific index `gid`.</strong></p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <void>                                                                                                                                                                                                        </void>                                                                                                                                                                                                     
- 
-                                                                                                                                                                                                      <void><void>                                                                                                                                                                                                      <void></void>                                                                                                                                                                                                     
-
- 
-                                                                                                                                                                                                     
- 
-
-                                                                                                                                                                                                      <void>"                                                                                                                                                                                                        >void>                                                                                                                                                                                                      </void></void>                                                                                                                                                                                                    <void> 
-                                                                                                                                                                                                      </void><void>                                                                                                                                                                                                    <void></void></void>                                                                                                                                                                                                   
-   
-                                                                                                                                                                                                    <void></code></pre>
-<p>Data is initialized on the host and dispatched to the device followed by the commencement of device-side reduction. The swapping of the double-buffer on the last iteration is omitted, therefore the result is in the back-buffer irrespective of the input size.</p>
-<p><strong>**Following code does:** This code snippet initializes an array `arr` of size 4 with elements from another array `front`. It uses a conditional expression to fill each position in `arr`. For each index `i` from 0 to 3, it checks if `i` is within the bounds of `front` (i.e., `i < front_size`). If it is, the corresponding element from `front` is used; otherwise, a default value `zero_elem` is used. This effectively copies up to four elements from `front` into `arr`, filling any out-of-bounds positions with `zero_elem`.</strong></p>
-<pre><code>of the input size.
-
-for (uint32_t curr = input_count; curr > 1;)
-{
-      hipLaunchKernelGGL(
-           kernel,
-           dim3(new_size(curr)),
-           dim3(block_size),
-           factor * sizeof(unsigned),
-           hipStreamDefault,
-           front,
-           back,
-           kernel_op,</code></pre>
-<p><strong>**Following code does:** This code snippet appears to be a series of empty lines with a placeholder or invalid tag `<?>` in the middle. It doesn't perform any functional operation or have any meaningful purpose in its current form. It might be intended as a placeholder or a template for future code development.</strong></p>
-<pre><code>1;)</code></pre>
-<p>(continues on next page)</p>
-<p>(continued from previous page)</p>
-<p><strong>**Following code does:** This code snippet is a host-side reference implementation of a reduction operation typically executed on a GPU. It processes an input vector of unsigned integers by dividing it into partitions of a specified size (`partition_size`). For each partition, it calculates the sum of its elements and stores the result in a new vector (`result`). The size of the result vector is determined by dividing the total input size by the partition size, effectively reducing the input data by aggregating sums of each partition. This operation is useful for tasks like parallel processing where data needs to be reduced or aggregated efficiently.</strong></p>
-<pre><code>        zero_elem,
-        curr);
-
-     curr = new_size(curr);
-     if (curr > 1)
-        std::swap(front, back);
-}</code></pre>
-<p>This structure persists in the kernel throughout all the variations of reduction with slight modifications to factor and shared memory allocation:</p>
-<p><strong>**Following code does:** The code snippet appears to be part of a function in a programming language that uses semicolons to terminate statements, likely C, C++, or Java. It seems to be iterating over some collection or array, assigning a value `partition_result` to an element at index `i` in an array or list called `result`. After the loop completes, the function returns the `result` array or list. The high-level purpose of this code is to populate the `result` array with values computed or retrieved during the loop and then return this populated array.</strong></p>
-<pre><code><_Cuda_></code></pre>
-<p>While the tid % (2 * i) == 0 indexing scheme yields correct results, it also leads to high thread divergence. Thread divergence indicates the event when the threads in a warp diverge, which implies that the threads have to execute different instructions in a given clock cycle. This is easily manifested using if-else statements as shown here, but can also be manifested as for loop dependent on thread ID lengths. Even though the number of active threads participating in the reduction reduces, warps remain active longer than necessary, as at least one lane in a warp hits the if statement.</p>
-<h2>29.2.2 Reducing thread divergence</h2>
-<p>You can reduce divergence by keeping dataflow between memory addresses identical but reassigning the thread ids.</p>
-<p><strong>**Following code does:** The provided code snippet is a CUDA device function named `reduce_sum` that performs a parallel reduction to compute the sum of unsigned integer values within a thread group using shared memory. The function takes a `thread_group` object `g`, a shared memory pointer `x`, and an unsigned integer `val` as inputs. It uses a loop to iteratively halve the number of active threads, synchronizing them at each step, and accumulates the sum of values from different threads. The final result of the reduction is stored in the first thread of the group, while other threads return 0. This function is typically used in GPU programming to efficiently compute sums across threads in a block or custom partition.</strong></p>
-<pre><code>// Shared reduction
-for (uint32_t i = 1; i < blockDim.x; i *= 2)
-{
--    if (tid % (2 * i) == 0)
--        shared[tid] = op(shared[tid], shared[tid + i]);
-+    if (uint32_t j = 2 * i * tid; j < blockDim.x)
-+        shared[j] = op(shared[j], shared[j + i]);
-    __syncthreads();
-}</code></pre>
-<p>This way inactive threads start accumulating uniformly towards the higher thread ID index range and might uniformly skip to __syncthreads() . However, this introduces a bank conflicts issue.</p>
-<h2>29.2.3 Resolving bank conflicts</h2>
-<p>Both AMD and NVIDIA implement shared memory in the hardware by organizing storage into banks of various sizes. This hardware element is known as Local Data Share (LDS) on AMD hardware. On NVIDIA hardware, it's implemented using the same silicon as the L1 data cache. You can think of shared memory as a striped 2-dimensional range of memory. Shared memory bank's count, width, and depth depend on the architecture. A bank conflict occurs when different threads in a warp access the same bank during the same operation. In this case, the hardware prevents the attempted concurrent accesses to the same bank by converting them into serial accesses.</p>
-<ul>
-<li style="list-style-type: '· ';">'AMD Instinct MI200' Instruction Set Architecture, Chapter 11.1</li>
-<li style="list-style-type: '· ';">'RDNA 2' Instruction Set Architecture, Chapter 10.1</li>
-</ul>
-<p>A notable exception is when the shared read uniformly broadcasts to the same address across the entire warp. A better implementation of the naive algorithm is to form continuous ranges of the threads activities and their memory accesses.</p>
-<p><strong>**Following code does:** This code snippet is part of a CUDA program, which is designed to run on NVIDIA GPUs. Its high-level purpose is to set up a parallel computation environment using CUDA's thread block and shared memory features. Specifically, it:
-
-1. Declares shared memory (`workspace`) to be used by threads within a block for operations like reduction, which is a common parallel algorithm for combining elements (e.g., summing an array).
-2. Defines a `thread_block` object (`thread_block_group`) that represents all threads within a CUDA block, allowing them to coordinate and share data.
-3. Loads an input value from global memory (`d_vector`) into a local variable (`input`) for each thread, based on the thread's rank within the block.
-4. Creates a `custom_partition` of threads within the block, where each partition consists of 16 threads. This partitioning allows for more fine-grained control over thread collaboration and data sharing within the block.
-
-Overall, the code sets up the necessary structures for performing parallel computations on a GPU, leveraging shared memory and thread coordination to optimize performance.</strong></p>
-<pre><code>
-        implementation of the naive algorithm is to form continuous ranges of the threads activ
-        
-        // Shared reduction
-        -for (uint32_t i = 1; i < blockDim.x; i *= 2)
-        -{
-        -                                                                                                                                                                                                        
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        -f                                                                                                                                                                                                        +f</code></pre>
-<p>Note: To avoid bank conflicts, read shared memory in a coalesced manner, which implies that reads/writes of each lane in a warp evaluate to consecutive locations. Analyzing the read/write patterns could help you to understand the cause of bank conflicts. For more details, check CDNA3 ISA or RDNA3 ISA data share operations chapter.</p>
-<h2>29.2.4 Utilize upper half of the block</h2>
-<p>The preceding implementation is free of low-level GPU-specific anti-patterns. However, it still exhibits some common shortcomings. The loop performing the reduction in the shared memory starts from i = blockDim.x / 2 and the first predicate if (tid &lt; i) immediately disables half of the block, which only helps load the data into the shared memory. You can change the kernel along with the calculation of factor on the host, as shown here:</p>
-<p><strong>**Following code does:** This code snippet performs a parallel reduction operation on a set of input data using a thread block group, which is a collection of threads that work together. The `reduce_sum` function aggregates the input data into a single sum, storing the result in the `output` variable. After the reduction, only the first thread in the thread block group (determined by checking if its rank is 0) writes the computed sum to the first element of the `d_block_reduced_vector` array. This ensures that only one thread outputs the final reduced value, preventing race conditions or redundant writes.</strong></p>
-<pre><code><_Cuda_></code></pre>
-<p>By eliminating half of the threads and giving meaningful work to all the threads by unconditionally performing a binary op , you can prevent the wastage of half of the threads.</p>
-<p>Even though global memory is read in a coalesced fashion, as preferred by the memory controller, optimal performance is still limited by the instruction throughput. Omit superfluous synchronization -----------</p>
-<p>Warps are known to execute in a strict lockstep fashion. Therefore, once shared reduction reaches a point where only a single warp participates meaningfully, you can cut short the loop and let the rest of the warps terminate. Moreover, you can also unroll the loop without syncing the entire block.</p>
-<p>The tmp namespace used beyond this point in this document holds a handful of template meta-programmed utilities to facilitate writing flexible and optimal code.</p>
-<p>tmp::static_for is not just a constant folding within the optimizer but a variation of the language for loop, where the running index is a compile-time constant and is eligible for use in compile-time evaluated contexts.</p>
-<p>Consider the following code:</p>
-<p><strong>**Following code does:** This code snippet appears to be part of a parallel computing or GPU programming context, where it performs a reduction operation. The `reduce_sum` function is used to sum elements within a specified partition of data. The `custom_partition` likely defines how the data is divided, and `workspace[group_offset]` and `input` are the data sources involved in the reduction. The comment indicates that only the first thread in each partition will return a valid result, which is a common pattern in parallel reductions to ensure that only one thread writes the final result of the reduction for each partition.</strong></p>
-<pre><code>constexpr int size = 4;
-for (int i = 0 ; i < size ; ++i)
-{
-    printf("%d", i);
-}</code></pre>
-<p>This compiles to the following binaries:</p>
-<h2>LLVM Block</h2>
-<p><strong>**Following code does:** This code snippet appears to be part of a parallel computing operation, likely using CUDA or a similar framework for GPU programming. The code calculates a `partition_id` for a thread within a block by dividing the thread's rank by a constant `PartitionSize`. It then assigns a value `output` to an element in the `d_partition_reduced_vector` array at the index corresponding to this `partition_id`. The purpose is to organize or reduce data into partitions based on thread ranks within a block.</strong></p>
-<pre><code>LLVM Block
-main:
-    push    rbx
-    lea      rbx, [rip +.L.str]
-    mov     rdi, rbx
-    xor     esi, esi
-    xor     eax, eax
-    call    printf@PLT
-    mov     rdi, rbx
-    mov     esi, 1
-    xor     eax, eax
-    call    printf@PLT
-    mov     rdi, rbx</code></pre>
-<p>(continues on next page)</p>
-<p><strong>**Following code does:** It seems there is a formatting error in your request. The code snippet is labeled as Python, but it contains a placeholder that suggests it might be C++ code. Please provide the actual code snippet you would like me to analyze, and I'll be happy to help!</strong></p>
-<pre><code>      mov     esi, 2
-      xor     eax, eax
-      call    printf@PLT
-      mov     rdi, rbx
-      mov     esi, 3
-      xor     eax, eax
-      call    printf@PLT
-      xor     eax, eax
-      pop     rbx
-      ret
-.L.str:
-     .asciz  "%d"
-      
- GCC</code></pre>
-<h2>GCC</h2>
-<p><strong>**Following code does:** The code snippet `<_C_>` appears to be incomplete or not a valid Python code. It does not represent any known Python syntax or construct. It might be a placeholder or a typo. Without additional context or surrounding code, it's not possible to determine its purpose or functionality.</strong></p>
-<pre><code>  GCC
- .LC0:
-     .string "%d"
-  main:
-      push    rbx
-      xor     ebx, ebx
- .L2:
-      mov     esi, ebx
-      mov     edi, 0FFSET FLAT:.LC0
-      xor     eax, eax
-      add     ebx, 1
-      call    printf
-      cmp     ebx, 4
-      jne    .L2
-      xor     eax, eax
-      pop     rbx
-      ret
-
-  MSVC</code></pre>
-<h2>MSVC</h2>
-<p><strong>**Following code does:** This code snippet is part of a program that uses the HIP (Heterogeneous-Compute Interface for Portability) API to launch a cooperative kernel on a GPU. The cooperative kernel is likely designed to perform a reduction operation on a vector, as suggested by the variable names. The `hipLaunchCooperativeKernel` function is used to initiate the execution of the `vector_reduce_kernel` on the GPU, with `params` being an array of pointers to the data structures (`d_vector`, `d_block_reduced`, and `d_partition_reduced`) that the kernel will operate on. The cooperative groups API allows for more efficient synchronization and communication between threads within a GPU kernel.</strong></p>
-<pre><code>  MSVC
-
-main     PROC
-      $LN12:
-      push    rbx
-      sub     rsp, 32
-      xor     ebx, ebx
-      npad    8
-  $LL4@main:
-      mov     edx, ebx
-      lea     rcx, OFFSET FLAT:'string'
-      call    printf
-      inc     ebx
-      cmp     ebx, 4
-      jl      SHORT $LL4@main
-      xor     eax, eax
-      add     rsp, 32
-      pop     rbx
-      ret     0
-  main    ENDP</code></pre>
-<p>(continued from previous page)</p>
-<p>LLVM unrolls the loop and compiles to a flat series of printf invocations, while both GCC and MSVC keep the loop intact, as visible from the compare ( cmp ) and the jump ( jne , jl ) instructions. LLVM code generation is identical to manually writing the unrolled loop:</p>
-<p><strong>**Following code does:** The provided snippet appears to be incomplete and lacks any functional code. It only contains a comment line that reads "* For HIP". This suggests that the code might be related to or intended for use with HIP, which is a C++ runtime API and kernel language that allows developers to create portable applications that can run on AMD and NVIDIA GPUs. However, without additional context or code, it's not possible to determine any specific functionality or purpose.</strong></p>
-<pre><code>printf("%d", 0);
-printf("%d", 1);
-printf("%d", 2);
-printf("%d", 3);</code></pre>
-<p>While various non-standard pragmas are available to hint or force the compiler to unroll the loop, we instead use template meta-programming to force feed the compiler the unrolled loop.</p>
-<p><strong>**Following code does:** The code snippet `<_Bash_>` appears to be a placeholder or a tag indicating that a section of code written in the Bash scripting language should be inserted or is expected in that location. It does not perform any operations or have any functionality on its own. Instead, it likely serves as a marker for where Bash code should be included or referenced in a larger context, such as in documentation, a template, or a code generation tool.</strong></p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?xml version="1.0" encoding="UTF-8" />
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        </?xml version="1.0" encoding="UTF-8" /></code></pre>
-<p>The most notable structural difference is that in the language for loop, the loop variable is given a name in the beginning, while in the static_for utility, the loop variable is given a name in the end. An important bonus is that in the loop's body, you can use the running index i in contexts requiring constant expressions such as template arguments or inside if constexpr .</p>
-<p>tmp::static_switch takes runtime value and runtime dispatches to a range of set of tabulated functions, where said value is a compile-time constant and is eligible for use in compile-time evaluated contexts.</p>
-<p>Consider the following code:</p>
-<p><strong>**Following code does:** It seems there is a misunderstanding in the code snippet provided. The snippet `<_Haskell_>` does not represent valid Python code or any executable code in any programming language. It appears to be a placeholder or a tag indicating that Haskell code might be expected or referenced. If you intended to provide a Haskell code snippet, please share the correct code so I can help explain its purpose.</strong></p>
-<pre><code>        Consider the following code:
-
-        int  warp_size  = device_props.warpSize;
-
-        switch  (warp_size)
-
-        {
-
-        case  32:
-
-            hipLaunchKernelGGL(kernel<32>, ...);
-
-            break;
-
-        case  64:
-
-            hipLaunchKernelGGL(kernel<64>, ...);
-
-            break;
-
-        }</code></pre>
-<p>In the preceding code, note the code repetition for all possible values of warp_size , the code is prepared to handle. To avoid this, use tmp::static_switch , as shown:</p>
-<p><strong>**Following code does:** This code snippet appears to be a series of empty lines with a placeholder or invalid tag `<?>` in the middle. It doesn't perform any functional operation or have any meaningful purpose in its current form. It might be intended as a placeholder or template for further development, but as it stands, it doesn't execute any logic or serve a specific function.</strong></p>
-<pre><code>  tmp::static_switch<std::array{32, 64}>(warp_size, [&]<int WarpSize>
-  {
-      hipLaunchKernelGGL(kernel<WarpSize>,...);
-  });</code></pre>
-<p><strong>**Following code does:** The code snippet `<_Bash_>` appears to be a placeholder or a formatting artifact rather than actual executable code. It does not perform any operations or have any functionality as it stands. If this is meant to indicate a section where Bash code should be inserted, it would typically be replaced with actual Bash script content to perform specific tasks in a Unix-like shell environment.</strong></p>
-<pre><code>
-t WarpSize>()</code></pre>
-<p><strong>**Following code does:** This code snippet is a sequence of shell commands used to compile and link a C++ program that utilizes GPU resources with the HIP (Heterogeneous-Compute Interface for Portability) compiler, `hipcc`. 
-
-1. The first command compiles `hipDevice.cpp` into an object file `hipDevice.o` with GPU relocatable device code enabled (`-fgpu-rdc`).
-2. The second command creates a static library `libHipDevice.a` from the object file `hipDevice.o` using the `ar` archiving tool.
-3. The third command links the static library `libHipDevice.a` with another source file `test.cpp`, again with GPU relocatable device code enabled, and produces an executable `test.out`.
-
-Overall, this process compiles and links a GPU-accelerated application using HIP, organizing the code into a static library before creating the final executable.</strong></p>
-<pre><code>
-        HIP Documentation, Release 6.1.40092
-
-
-        
-        -template<typename T, typename F>
-        +template<uint32_t WarpSize, typename T, typename F>
-        __global__ void kernel(
-           ...
-        )
-        {
-           ...
-        // Shared reduction
-        -for (uint32_t i = blockDim.x / 2; i!= 0; i /= 2)
-        +for (uint32_t i = blockDim.x / 2; i > WarpSize; i /= 2)
-        {
-            if (tid < i)
-                shared[tid] = op(shared[tid], shared[tid + i]);
-            __syncthreads();
-        }
-        +// Warp reduction
-        +tmp::static_for<WarpSize, tmp::not_equal<0>, tmp::divide<2>>([&]<int I>()
-        +{
-        +     if (tid < I)
-        +          shared[tid] = op(shared[tid], shared[tid + I]);
-        +#ifdef __HIP_PLATFORM_NVIDIA__
-        +     __syncwarp(0xffffffff >> (WarpSize - I));
-        +#endif
-        +});
-
-        Because HIP typically targets hardware with warp sizes of 32(NVIDIA GPUs and RDNA AMD GPUs) and 64 (CD!
-        AMD GPUs), portable HIP code must handle both. That is why instead of assuming a warp size of 32, make the w:
-        size a template argument of the kernel. This allows you to unroll the final loop using tmp::static_for in a paramet</code></pre>
-<p>Because HIP typically targets hardware with warp sizes of 32 (NVIDIA GPUs and RDNA AMD GPUs) and 64 (CDNA AMDGPUs), portable HIP code must handle both. That is why instead of assuming a warp size of 32, make the warp size a template argument of the kernel. This allows you to unroll the final loop using tmp::static_for in a parametric way but still having the code read much like an ordinary loop.</p>
-<p>Promoting the warp size to being a compile-time constant also requires you to handle it similarly on the host-side. You can sandwich the kernel launch with tmp::static_switch , promoting the snake-case run-time warp_size variable to a camel-case compile-time constant WarpSize .</p>
-<p><strong>**Following code does:** The code snippet `<_Cuda_>` appears to be a placeholder or a symbolic representation rather than actual executable Python code. In the context of programming, "Cuda" typically refers to NVIDIA's parallel computing platform and application programming interface (API) model, which allows developers to use a CUDA-enabled graphics processing unit (GPU) for general purpose processing. However, without additional context or actual code, it's not possible to determine the specific functionality or purpose of this placeholder.</strong></p>
-<pre><code><_C++_></code></pre>
-<p>Note: Neither RDNA- nor CDNA-based AMD hardware provides guaranteed independent progress to lanes of the same warp. When targeting NVIDIA hardware, lanes of a warp might execute somewhat independently as long as the programmer assists the compiler using dedicated built-in functions. This feature is called Independent Thread Scheduling. The HIP headers don't expose the necessary warp primitives and their overloads.</p>
-<p>Portable applications can still tap into this feature with carefully #ifdef -ed code, but at this particular optimization level, it's a requirement. The code implicitly relies on the lockstep behavior of an ROCm wavefront, but CUDA warps don't share this property. You must synchronize all the active lanes of a warp to avoid a data race with some lanes progressing faster than others in the same warp.</p>
-<h2>29.2.5 Unroll all loops</h2>
-<p>While the previous step primarily aims to remove unnecessary syncing, it also unrolls the end of the loop. However, you could also force unrolling the first part of the loop. This saves a few scalar registers (values the compiler can prove to be uniform across warps).</p>
-<p><strong>**Following code does:** The provided text appears to be a continuation marker from a previous page, indicating that the code snippet is incomplete. Without the actual code, it's not possible to determine its purpose or functionality. If you can provide the complete code snippet, I would be happy to help explain what it does.</strong></p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <Linear                                                                                                                                                                                                        </Linear                                                                                                                                                                                                      <Linar                                                                                                                                                                                                        >                                                                                                                                                                                                        &Linear                                                                                                                                                                                                     
- 
-                                                                                                                                                                                                      <Lin                                                                                                                                                                                                        +                                                                                                                                                                                                        -                                                                                                                                                                                                        |                                                                                                                                                                                                        }                                                                                                                                                                                                        \
-                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       <L                                                                                                                                                                                                        1                                                                                                                                                                                                        0</code></pre>
-<p>Introducing yet another template argument for the kernel and moving from for to tmp::static_for leads to the following two notable improvements:</p>
-<ul>
-<li style="list-style-type: '· ';">Introducing new attribute __launch_bounds__(BlockSize) to the kernel instructs the compiler that the kernel will only be launched using the designated block size. This implies that the launches of differing block sizes will fail. This allows the optimizer to enroll the blockDim.x variable in constant folding as well as get information about register usage.</li>
-<li style="list-style-type: '· ';">Turning the block size into a compile-time constant allows you to statically allocate the shared memory.</li>
-</ul>
-<h2>29.2.6 Communicate using warp-collective functions</h2>
-<p>Shared memory provides a fast communication path within a block, however when performing reduction within the last warp, you can use faster means of communication, which is warp-collective or cross-lane functions. Instead of using the hardware-backed shared memory, you can directly copy between the local memory (registers) of each lane in a warp. This can be achieve using the shuffle functions.</p>
-<p>See how to use __shfl_down() , which is one of the most restrictive but also the most structured communication schemes.</p>
-<p><strong>**Following code does:** The placeholder `<_SQL_>` suggests that this is not actual code but rather a placeholder indicating where SQL code would be inserted. Without specific SQL statements, it's not possible to determine the exact functionality. However, generally, SQL code is used for interacting with databases, which can include operations such as querying data, updating records, inserting new data, or deleting existing records. The high-level purpose of SQL code is to manage and manipulate data stored in a relational database.</strong></p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        // Warp reduction</code></pre>
-<p>Using warp-collective functions for communication requires the control flow to be uniform across warps, as the name warp-collective implies. Therefore, you can see that the thread ID is being checked outside the loop, but the result is written inside due to variable scoping.</p>
-<h2>29.2.7 Prefer warp communication over shared</h2>
-<p>As mentioned in the previous step, communication between local memory is faster than shared memory. Instead of relying on the local memory only at the end of the tree-like reduction, a better approach is to turn the tree reduction inside out and perform multiple warp reductions in parallel on all active threads, thus communicating only their partial results through the shared memory.</p>
-<p>The kernel versions differ significantly enough to be described using a diff; use afresh instead.</p>
-<p><strong>**Following code does:** The provided code snippet appears to be malformed or incomplete. It consists of a series of spaces and dashes followed by the text `--event:0` and `-event:0`. This does not represent valid or executable Python code. It seems more like a formatting error or a placeholder rather than a functional script. Without additional context or correction, it is not possible to determine a high-level purpose for this snippet.</strong></p>
-<pre><code>        The kernel versions differ significantly enough to be described using a diff; use afresh instead.
-
-        template<uint32_t BlockSize,  uint32_t WarpSize,  typename  T,  typename  F>
-        __global__ __launch_bounds__(BlockSize)  void kernel(
-            T*  front,
-            T*  back,
-            F  op,
-            T zero_elem,
-            uint32_t  front_size)
-        {
-            // ...
-        }
-
-        The kernel estimate and the reduction factor as the comma as in variance access only the imlamantation diffar.</code></pre>
-<p>The kernel signature and the reduction factor are the same as in previous cases; only the implementation differs.</p>
-<p><strong>**Following code does:** It seems that you've provided a single character `>` instead of a code snippet. Could you please provide the complete code so I can help explain its purpose?</strong></p>
-<pre><code>static constexpr uint32_t WarpCount = BlockSize / WarpSize;
-
-__shared__ T shared[WarpCount];
-
-auto read_global_safe =
-    [&](const uint32_t i) { return i < front_size? front[i] : zero_elem; };
-auto read_shared_safe =
-    [&](const uint32_t i) { return i < WarpCount? shared[i] : zero_elem; };
-
-const uint32_t tid = threadIdx.x,
-                     bid = blockIdx.x,
-                     gid = bid * (blockDim.x * 2) + tid,
-                     wid = tid / WarpSize,
-                     lid = tid % WarpSize;
-
-// Read input from front buffer to local
-T res = op(read_global_safe(gid), read_global_safe(gid + blockDim.x));
-
-As we communicate the results of warps through shared memory, the same number of elements are required in the
-shared memory as warps within the block. Similar to how you can only launch kernels at block granularity. you can</code></pre>
-<p>As we communicate the results of warps through shared memory, the same number of elements are required in the shared memory as warps within the block. Similar to how you can only launch kernels at block granularity, you can only warp reduce with WarpSize granularity due to the collective nature of the cross-lane builtins. To address this, you can use read_shared_safe to pad overindexing by reading zero_elem . Reading from global remains unaffected. // Perform warp reductions and communicate results via shared // for (uint32_t ActiveWarps = WarpCount; // ActiveWarps != 0; // ActiveWarps = ActiveWarps != 1 ? // divide_ceil(ActiveWarps, WarpSize) : // ActiveWarps = 0) tmp::static_for&lt; WarpCount, tmp::not_equal&lt;0&gt;, tmp::select&lt; tmp::not_equal&lt;1&gt;, tmp::divide_ceil&lt;WarpSize&gt;, tmp::constant&lt;0&gt;&gt;&gt;([&amp;]&lt; uint32_t ActiveWarps&gt;() { if (wid &lt; ActiveWarps) { // Warp reduction tmp::static_for&lt;WarpSize / 2, tmp::not_equal&lt;0&gt;, tmp::divide&lt;2&gt;&gt;([&amp;]&lt; int Delta&gt;() { res = op(res, __shfl_down(res, Delta)); }); // Write warp result from local to shared if (lid == 0) shared[wid] = res; } __syncthreads(); // Read warp result from shared to local res = read_shared_safe(tid); (continues on next page)</p>
-<p>(continued from previous page)</p>
-<p><strong>**Following code does:** The code snippet is a command-line instruction that uses the `hipify-perl` tool to convert CUDA code into HIP (Heterogeneous-Compute Interface for Portability) code. The `--inplace` option indicates that the conversion should be done directly in the original files, modifying them in place rather than creating new output files. This is typically used to facilitate the migration of CUDA applications to run on AMD GPUs by translating CUDA-specific syntax and API calls to their HIP equivalents.</strong></p>
-<pre><code>});
-
-// Write result from local to back buffer
-if(tid == 0)
-    back[bid] = res;</code></pre>
-<p>ActiveWarps iterates from WarpCount until it reaches 0 . Every iteration of ActiveWarps reduces the WarpSize . In cases where the partial result count isn't a divisor of ActiveWarps and you need to launch an extra warp, use tmp::divide_ceil , which always rounds to positive infinity. The tertiary tmp::select is required because such division never reaches 0 , so you must terminate the loop after the last warp concludes.</p>
-<p>In each iteration, if the warp is active, which means it has at least a single valid input, it carries out a pass of warp reduction and writes output based on warp ID. Reading is carried out based on thread ID. Global output continues to be based on block ID.</p>
-<h2>29.2.8 Amortize bookkeeping variable overhead</h2>
-<p>The previous sections explained how to reduce register usage to improve occupancy. This allows more blocks to execute in parallel on all multiprocessors, leading to more global store/load latency to be hidden. Reducing the number of kernels in flight while still carrying out the same workload reduces the wastage of registers while loading and maintaining bookkeeping variables such as kernel indices.</p>
-<p>An example of this optimization is performing one binary op while loading input from global. Even though the operation is said to be carried out 'in flight', the two values are loaded into local memory (registers) before op is called.</p>
-<p>Amore general form of this optimization is wrapping most kernel logic in loops that carry out the workload of multiple kernel instances but require storing only a single instance of most of the bookkeeping logic. In code, this multiplicity factor is referred to via the ItemsPerThread compile-time constant, which is supplied by a template argument to allow for loop unrolling.</p>
-<p>This kernel variant utilizes another generally applicable utility known as hip::static_array , which is a more restrictive wrapper over the builtin array than std::array , as it allows indexing only compile-time constants using the usual tuple-like template &lt;size_t I&gt; auto get&lt;I&gt;(...) interface.</p>
-<p>Note: On a GPU, there is no stack, and the local memory is provisioned from the register file. This provisioning takes place statically. To paraphrase, the address range of a thread's local memory is determined at compile-time. When an array is defined and used in the local storage, the compiler can only maintain its storage in the register file as long as all accesses to the array are computable by the compiler at compile-time. It doesn't need to be a compile-time constant as long as the compiler can resolve the addresses of the accesses through constant folding or some other means. If the compiler fails to do so, the array will be backed by global memory, which is indicated by allocating a non-zero number of spill registers observable using static analysis tools. However, this is slower by the magnitude of multiple order. hip::static_array via its hip::get&lt;&gt; interface ensures that no such spills occur.</p>
-<p><strong>**Following code does:** This code snippet is a preprocessor directive used in C/C++ programming, specifically when working with the HIP (Heterogeneous-Compute Interface for Portability) framework. The `#ifdef __HIP_PLATFORM_AMD__` checks if the macro `__HIP_PLATFORM_AMD__` is defined, which indicates that the code is being compiled for AMD platforms using HIP-Clang. If this condition is true, the comment `// Compiled with HIP-Clang` is included in the code. This is typically used to conditionally compile code specific to AMD hardware when using the HIP framework.</strong></p>
-<pre><code>_t  ItemsPerThread></code></pre>
-<p><strong>**Following code does:** This code snippet is a preprocessor directive used in a C/C++ program to conditionally compile code based on the target platform. Specifically, it checks if the code is being compiled for an NVIDIA platform using the HIP (Heterogeneous-Compute Interface for Portability) API. If the `__HIP_PLATFORM_NVIDIA__` macro is defined, it indicates that the code is being compiled with NVIDIA's CUDA compiler (`nvcc`). The comments suggest that the code could be using CUDA language extensions or be in a pass-through mode to an underlying host compiler, depending on the file type or compilation settings.</strong></p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        --global__ static __launch_bounds__(BlockSize) void kernel(...)</code></pre>
-<p>The kernel now has three compile-time configurable parameters. The only part of the kernel that changes depends on how you load data from global and perform the binary operation on those loaded values. So, the following step to read input from front buffer to global is now split into two steps: reading ``ItemsPerThread` &lt;reading-items&gt;`and processing ``ItemsPerThread` &lt;processing-items&gt;`.</p>
-<p><strong>**Following code does:** This code snippet is a preprocessor directive used in C/C++ programming to check if the code is being compiled with NVIDIA's CUDA Compiler (nvcc). The `#ifdef __CUDACC__` checks if the `__CUDACC__` macro is defined, which indicates that the CUDA language extensions are enabled. This is typically used to conditionally include or exclude code that is specific to CUDA, allowing the same source file to be compiled with or without CUDA support.</strong></p>
-<pre><code><_C_></code></pre>
-<h2>29.2.8.1 Reading ItemsPerThread</h2>
-<p>The change to reading happens inside read_global_safe :</p>
-<p><strong>**Following code does:** The code snippet you provided appears to be incomplete or malformed. It does not represent valid Python code, as it contains a semicolon at the beginning and a misspelled or incorrectly formatted word "enab1ed" (with a numeral '1' instead of the letter 'l'). Without additional context or correction, it's not possible to determine its high-level purpose.</strong></p>
-<pre><code>        The change to reading happens inside read_global_safe:
-        auto  read_global_safe = [&](const  int32_t  i)  -> hip::static_array<T,  ItemsPerThread>
-        {
-            return  [&]<int32_t...  I>(std::integer_sequence<int32_t,  I...>)
-            {
-                if(i + ItemsPerThread < front_size)
-                        return hip::static_array<T,  ItemsPerThread>{
-                              front[i + I]...
-                        };
-                else
-                        return hip::static_array<T,  ItemsPerThread>{
-                              (i + I < front_size? front[i + I] : zero_elem)...
-                        };
-            }(std::make_integer_sequence<int32_t,  ItemsPerThread>());
-        };
-
-        Note that each array element is being loaded consecutively without the flexibility of a configurable ItemsPerThread</code></pre>
-<p>Note that each array element is being loaded consecutively without the flexibility of a configurable ItemsPerThread property. This is morally equivalent to:</p>
-<p><strong>**Following code does:** This code snippet is a preprocessor directive used in the context of HIP (Heterogeneous-Compute Interface for Portability), which is a C++ runtime API that allows developers to write portable code to run on AMD and NVIDIA GPUs. The line `#if __HIP__DEVICE__COMPILE__` is a conditional compilation directive that checks if the code is being compiled for a GPU device. If the condition is true, the code following this directive will be included in the compilation process for the device. This is typically used to separate code that should only be executed on the GPU from code that runs on the host (CPU).</strong></p>
-<pre><code>T arr[4] = {
-    front[gid + 0],
-    front[gid + 1],
-    front[gid + 2],
-    front[gid + 3]
-}</code></pre>
-<p>This is exactly what's happening in the front[i + I]... fold-expression. However, this can only be issued if the entire read operates on real input without padding using zero_elem . If some reads over-index the input, the read turns into:</p>
-<p><strong>**Following code does:** This code snippet is a preprocessor directive used in CUDA programming, which is a parallel computing platform and application programming interface model created by NVIDIA. The directive `#if (__CUDA_ARCH__ >= 130)` checks if the code is being compiled for a CUDA architecture version that is 1.3 or higher. If the condition is true, the code following this directive will be included in the compilation process. This is typically used to ensure that certain code segments are only compiled for specific GPU architectures that support the required features or capabilities.</strong></p>
-<pre><code>T arr[4] = {
-    i + 0 < front_size? front[i + 0] : zero_elem,
-    i + 1 < front_size? front[i + 1] : zero_elem,
-    i + 2 < front_size? front[i + 2] : zero_elem,
-    i + 3 < front_size? front[i + 3] : zero_elem
-}</code></pre>
-<p>This makes it easier for the compiler to recognize vector loads from global. As the performance at large is dominated by how you move the data, it's only natural to utilize dedicated instructions to move more data with less binary. This is evident by the huge performance improvement when loading two values per thread. For more information, see the compiler explorer to learn how loading for AMD (both RDNA and CDNA) compiles to global_load_dwordx4 , where x4 denotes the 4-vector variant of the instruction.</p>
-<p>Note: Note that read_global_safe , which used to take an uint32_t as the index type, now takes a signed integer. When indexing an array with unsigned integers, the compiler has to handle integer overflows, as the C/C++ standards defined them. It might happen that some part of the vector load indices overflow, thus resulting in a non-contiguous</p>
-<p>read. If you change the previously linked code to use an unsigned integer as the thread ID, the compiler won't emit a vector load. Signed integer overflow is an undefined behavior, and hence, unknown to the optimizer. To convey the absence of overflow to the compiler with unsigned indices, add __builtin_assume(gid + 4 &gt; gid) , or the more portable [[assume]](gid + 4 &gt; gid) , once amdclang++ supports it.</p>
-<p>read_global_safe implementation is an Immediately Invoked Lambda Expression (IILE), because ItemsPerThread is an integer value, while you need a compile-time iota -like sequence of integers as a pack for the fold-expressions to expand on. This can only occur as part of template argument deduction on the IILE.</p>
-<h2>29.2.8.2 Processing ItemsPerThread</h2>
-<p>Once the kernel reads ItemsPerThread number of inputs to local, it immediately reduces them to a scalar. There is no reason to propagate the input element multiplicity to the warp reduction phase.</p>
-<p><strong>**Following code does:** This code snippet appears to be a comment rather than executable code. It suggests that the programming environment or language being used supports the use of "doubles," which typically refers to double-precision floating-point numbers. This comment might be indicating that the code or system can handle numerical data types that require more precision than single-precision floating-point numbers.</strong></p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?>                                                                                                                                                                                                        </?></code></pre>
-<h2>29.2.9 Two-pass reduction</h2>
-<p>Alter kernel launch and input fetching such that no more blocks are launched than what a subsequent kernel launch's single block can conveniently reduce, while performing multiple passes of input reading from global and combining their results before engaging in the end game tree-like reduction.</p>
-<p>With this method, you can save at least one to two kernel launches for large inputs.</p>
-<h2>29.2.10 Global data share</h2>
-<p>Warning: This modification can only be executed on AMD hardware.</p>
-<p>Perform the first step of the two-pass reduction, but in the end, instead of writing to global and reading it back in a subsequent kernel, write the partial results to the Global Data Share (GDS). This is an N+1 th shared memory that is accessed by all multiprocessors and is also on-chip memory.</p>
-<p>Note: The API doesn't guarantee the order in which blocks are scheduled even though all GPUs schedule them in the same monotonically increasing order of block ids. Relying on this implicitly, the last block of a grid is in the optimal position to observe the side effects of all other blocks (using spinlocks or other methods) without occupying a multiprocessor for longer than necessary.</p>
-<p>Without launching a second kernel, you can make the last block collect the results of all other blocks from GDS by implicitly exploiting the scheduling behavior or relying on another AMD-specific feature called Global Wave Sync (GWS) to merge them for a final tree-like reduction.</p>
-<p>Note: GDS and GWS are reserved runtime features that the HIP API doesn't cover. Invoking these functionalities requires inline AMDGCN assembly. Moreover, the fact that the runtime doesn't virtualize the GDS, imposes further restrictions on concurrent scheduling of other kernels.</p>
-<h2>29.3 Conclusion</h2>
-<p>Optimizing code on GPUs, like on any other architecture, requires careful consideration and balancing of resources and costs of various operations to obtain optimal performance. This document explored optimizing reductions much beyond the territory of diminishing returns. This approach introduced multiple optimization techniques and discussed opportunities.</p>
-<p>The document focused on reductions when an entire device participates in it. Still, the choice of optimal compile-time constants or even the algorithm itself might not be optimal when its multiple blocks participate in multiple parallel reductions or when each thread performs its reduction. However, when multiple devices participate in the same reduction, other aspects must be considered.</p>
-<p>Most solutions, including the ones covered in this document, are given to the end users in a turnkey fashion via algorithm primitive libraries. These solutions might not be the fastest in all cases, but they are close to being the gold standard for carrying out certain operations as reasonably as possible.</p>
-<p>CHAPTER</p>
-<h2>THIRTY</h2>
-<h2>COOPERATIVE GROUPS</h2>
-<p>This tutorial demonstrates the basic concepts of cooperative groups in the HIP (Heterogeneous-computing Interface for Portability) programming model and the most essential tooling supporting it. This topic also reviews the commonalities of heterogeneous APIs. Familiarity with the C/C++ compilation model and the language is assumed.</p>
-<h2>30.1 Prerequisites</h2>
-<p>To follow this tutorial, you'll need properly installed drivers and a HIP compiler toolchain to compile your code. Because ROCm HIP supports compiling and running on Linux and Microsoft Windows with AMD and NVIDIA GPUs, review the HIP development package installation before starting this tutorial. For more information, see Install HIP .</p>
-<h2>30.2 Simple HIP Code</h2>
-<p>To become familiar with heterogeneous programming, review the SAXPY tutorial and the first HIP code subsection. Compiling is also described in that tutorial.</p>
-<h2>30.3 Tiled partition</h2>
-<p>You can use tiled partition to calculate the sum of partition_size length sequences and the sum of result_size / BlockSize length sequences. The host-side reference implementation is the following:</p>
-<p><strong>**Following code does:** This code snippet is a conditional check to determine if the hardware architecture supports double-precision floating-point operations. The commented-out line `//#if (__CUDA_ARCH__ >= 130)` is a non-portable way to check for this support in CUDA, which is specific to NVIDIA GPUs. The active line `if __HIP_ARCH_HAS_DOUBLES__` is a portable way to perform a similar check in HIP, which is a framework designed to run on both NVIDIA and AMD GPUs. If the condition is true, it indicates that the architecture supports double-precision operations, and the code within the block can safely use double-precision data types.</strong></p>
-<pre><code>    You can use ued partition to calculate the sum or partition_size length sequences and the sum or result_size/
-    BlockSize length sequences. The host-side reference implementation is the following:
-    
-    // Host-side function to perform the same reductions as executed on the GPU
-    std::vector<unsigned int> ref_reduced(const unsigned int          partition_size,
-                                                   std::vector<unsigned int> input)
-    {
-        const unsigned int          input_size  = input.size();
-        const unsigned int          result_size = input_size / partition_size;
-        std::vector<unsigned int> result(result_size);
-
-        for(unsigned int i = 0; i < result_size; i++)
-        {
-            unsigned int partition_result = 0;
-            for(unsigned int j = 0; j < partition_size; j++)
-            {
-                partition_result += input[partition_size * i + j];
-            }
-                                                                                                                                                                                                         (continues on next page)</code></pre>
-<p>(continues on next page)</p>
-<p><strong>**Following code does:** This code snippet is querying the properties of a GPU device using the HIP (Heterogeneous-Compute Interface for Portability) API. It retrieves the properties of a specified device and checks if the device supports shared 32-bit integer atomic operations. The commented-out line suggests an alternative, non-portable way of checking device capabilities based on major and minor version numbers, but the actual code uses a more portable method by directly querying the `hasSharedInt32Atomics` feature of the device architecture. If the device supports this feature, the code within the conditional block (not shown) would execute.</strong></p>
-<pre><code>            result[i] = partition_result;
-        }
-
-        return result;
-    }</code></pre>
-<h2>30.3.1 Device-side code</h2>
-<p>To calculate the sum of the sets of numbers, the tutorial uses the shared memory-based reduction on the device side. The warp level intrinsics usage is not covered in this tutorial, unlike in the reduction tutorial. x input variable is a shared pointer, which needs to be synchronized after every value change. The thread_group input parameter can be thread_block_tile or thread_block because the thread_group is the parent class of these types. The val are the numbers to calculate the sum of. The returned results of this function return the final results of the reduction on thread ID 0 of the thread_group , and for every other thread, the function results are 0.</p>
-<p><strong>**Following code does:** The code snippet is a command-line instruction that uses the `hipconfig` tool with the `--cxx_config` option. `hipconfig` is a utility associated with the HIP (Heterogeneous-Compute Interface for Portability) framework, which is used for developing applications that can run on both AMD and NVIDIA GPUs. The `--cxx_config` option specifically retrieves and displays the C++ compiler configuration settings used by HIP. This information is useful for developers to understand or verify the compiler settings being applied in their HIP-based projects.</strong></p>
-<pre><code>        The warp level intrinsics usage is not covered in this tutorial, unlike in the reduction tutorial. x input variable is a
-        shared pointer, which needs to be synchronized after every value change. The thread_group input parameter can be
-        thread_block_tile or thread_block because the thread_group is the parent class of these types. The val are
-        the numbers to calculate the sum of. The returned results of this function return the final results of the reduction on
-        thread ID 0 of the thread_group, and for every other thread, the function results are 0.
-
-        /// \brief Summation of `unsigned int val`s in `thread_group g` using shared memory `x`
-        __device__ unsigned int reduce_sum(thread_group g, unsigned int* x, unsigned int val)
-    {
-            // Rank of this thread in the group
-            const unsigned int group_thread_id = g.thread_rank();
-
-            // We start with half the group size as active threads
-            // Every iteration the number of active threads halves, until we processed all values
-            for(unsigned int i = g.size() / 2; i > 0; i /= 2)
-            {
-                // Store value for this thread in a shared, temporary array
-                x[group_thread_id] = val;
-
-                // Synchronize all threads in the group
-                g.sync();
-
-                // If our thread is still active, sum with its counterpart in the other half
-                if(group_thread_id < i)
-                {
-                    val += x[group_thread_id + i];
-                }
-
-                // Synchronize all threads in the group
-                g.sync();
-            }
-
-            // Only the first thread returns a valid value
-            if(g.thread_rank() == 0)
-                return val;
-            else
-                return 0;
-    }
-
-        The reduce_sum device function is reused to calculate the block and custom partition sum of the input numbers. The
-        kernel has three sections:
-
-        1. Initialization of the reduction function variables.</code></pre>
-<p>The reduce_sum device function is reused to calculate the block and custom partition sum of the input numbers. The kernel has three sections:</p>
-<ol>
-<li style="list-style-type: '1. ';">Initialization of the reduction function variables.</li>
-</ol>
-<p>(continued from previous page)</p>
-<ol>
-<li style="list-style-type: '2. ';">The reduction of thread block and store the results in global memory.</li>
-<li style="list-style-type: '3. ';">The reduction of custom partition and store the results in global memory.</li>
-</ol>
-<h2>30.3.1.1 1. Initialization of the reduction function variables</h2>
-<p>In this code section, the shared memory is declared, the thread_block_group and custom_partition are defined, and the input variables are loaded from global memory.</p>
-<p><strong>**Following code does:** The code snippet appears to be a fragment of a command or configuration related to compiling or building software that uses the HIP (Heterogeneous-Compute Interface for Portability) platform. Specifically, it includes a compiler definition `-D___HIP_PLATFORM_AMD___`, which indicates that the target platform is AMD, and an include path `-I/home/user1/hip/include`, which specifies where to find the HIP header files during compilation. This setup is typically used in environments where code is being prepared to run on AMD GPUs using HIP.</strong></p>
-<pre><code>
-
-in this code section, the shared memory is declared, the thread_block_group and custom_partition are define
-input variables are loaded from global memory.
-
-// threadBlockGroup consists of all threads in the block
-thread_block thread_block_group = this_thread_block();
-
-// Workspace array in shared memory required for reduction
-__shared__ unsigned int workspace[2048];
-
-unsigned int output;
-
-// Input to reduce
-const unsigned int input = d_vector[thread_block_group.thread_rank()];
-
-//...
-
-// Every custom_partition group consists of 16 threads
-thread_block_tile<PartitionSize> custom_partition
-           = tiled_partition<PartitionSize>(thread_block_group);
-
-
-
-as a 2 - 2 The read-line of thread block</code></pre>
-<h2>30.3.1.2 2. The reduction of thread block</h2>
-<p>In this code section, the sum is calculated on thread_block_group level, then the results are stored in global memory.</p>
-<p><strong>**Following code does:** This code snippet is a Makefile command that appends additional preprocessor flags to the `CPPFLAGS` variable. It uses the `hipconfig` tool, which is part of the HIP (Heterogeneous-Compute Interface for Portability) framework, to generate the necessary preprocessor configuration flags for compiling HIP code. The `$(shell ...)` function executes the `hipconfig --cpp_config` command and captures its output, which is then added to `CPPFLAGS`. This setup is typically used to ensure that the correct compiler flags are used when building applications that utilize HIP for GPU programming.</strong></p>
-<pre><code>// Perform reduction
-output = reduce_sum(thread_block_group, workspace, input);
-
-// Only the first thread returns a valid value
-if(thread_block_group.thread_rank() == 0)
-{
-    d_block_reduced_vector[0] = output;
-}</code></pre>
-<h2>30.3.1.3 3. The reduction of custom partition</h2>
-<p>In this code section, the sum is calculated on the custom partition level, then the results are stored in global memory. The custom partition is a partial block of the thread block, it means the reduction calculates on a shorter sequence of input numbers than at the thread_block_group case.</p>
-<p><strong>**Following code does:** The code snippet you provided appears to be incomplete or malformed, as it only contains a closing parenthesis `)`. Without additional context or surrounding code, it is not possible to determine its purpose or functionality.</strong></p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        // Perform reduction                                                                                                                                                                                                        }
-                                                                                                                                                                                                      
-output = reduce_sum(custom_partition, &workspace[group_offset], input);
-
-                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       // Only the first thread in each partition returns a valid value                                                                                                                                                                                                        \
-                                                                                                                                                                                                       \
-
-                                                                                                                                                                                                       \</code></pre>
-<p>(continued from previous page)</p>
-<p><strong>**Following code does:** The code snippet `<_SQL_>` appears to be a placeholder or a tag indicating that the actual SQL code is not provided. In this context, it suggests that the code is related to SQL (Structured Query Language), which is used for managing and manipulating relational databases. Without the actual SQL code, it's not possible to determine the specific operations or queries being performed. The placeholder might be used in documentation, templates, or code generation tools to signify where SQL code should be inserted or processed.</strong></p>
-<pre><code>        const unsigned int partition_id           = thread_block_group.thread_rank() /\__
-        ~PartitionSize;
-        d_partition_reduced_vector[partition_id] = output;
-    }</code></pre>
-<h2>30.3.2 Host-side code</h2>
-<p>On the host-side, the following steps are done in the example:</p>
-<ol>
-<li style="list-style-type: '1. ';">Confirm the cooperative group support on AMD GPUs.</li>
-<li style="list-style-type: '2. ';">Initialize the cooperative group configuration.</li>
-<li style="list-style-type: '3. ';">Allocate and copy input to global memory.</li>
-<li style="list-style-type: '4. ';">Launch the cooperative kernel.</li>
-<li style="list-style-type: '5. ';">Save the results from global memory.</li>
-<li style="list-style-type: '6. ';">Free the global memory.</li>
-</ol>
-<p>Only the first, second and fourth steps are important from the cooperative groups aspect, that's why those steps are detailed further.</p>
-<h2>30.3.2.1 1. Confirm the cooperative group support on AMD GPUs</h2>
-<p>Not all AMD GPUs support cooperative groups. You can confirm support with the following code:</p>
-<p><strong>**Following code does:** It seems there is a formatting error in your request. The code snippet is labeled as Python, but it contains a placeholder that suggests it should be C++ code. Please provide the correct code snippet or clarify the language so I can assist you accurately.</strong></p>
-<pre><code><_C++_></code></pre>
-<h2>30.3.2.2 2. Initialize the cooperative group configuration</h2>
-<p>In the example, there is only one block in the grid, and the threads_per_block must be dividable with partition_size .</p>
-<p><strong>**Following code does:** This code snippet is part of a GPU programming workflow using HIP, a C++ runtime API and kernel language that allows developers to write portable code for AMD and NVIDIA GPUs. The code performs the following high-level tasks:
-
-1. **Initialization**: It initializes two arrays, `A` and `B`, where `A` is filled with negative indices and `B` is initialized to zero.
-
-2. **Memory Allocation**: It allocates memory on the GPU for the array `Ad` using `hipMalloc`.
-
-3. **Data Transfer to GPU**: It copies the contents of array `A` from the host (CPU) to a symbol on the device (GPU) using `hipMemcpyToSymbol`.
-
-4. **Kernel Launch**: It launches a GPU kernel named `Get` with a specific grid and block configuration to perform operations on the data stored in `Ad`.
-
-5. **Data Transfer to Host**: It copies the results from the device array `Ad` back to the host array `B` using `hipMemcpy`.
-
-6. **Validation**: It checks if the contents of arrays `A` and `B` are equal, asserting that the GPU computation was performed correctly.
-
-7. **Output**: If the assertion passes, it prints "Passed" to indicate successful execution and validation of the GPU operations.
-
-Overall, this code tests the correctness of a GPU computation by comparing the results with expected values.</strong></p>
-<pre><code><_C_></code></pre>
-<h2>30.3.2.3 4. Launch the kernel</h2>
-<p>The kernel launch is done with the hipLaunchCooperativeKernel of the cooperative groups API.</p>
-<p><strong>**Following code does:** This code snippet demonstrates the allocation of memory on both the device (GPU) and the host (CPU) using HIP, a C++ runtime API for GPU programming. It first allocates memory on the device for a double pointer using `hipMalloc` and retrieves its attributes with `hipPointerGetAttributes`, which would indicate that the memory type is `hipMemoryTypeDevice`. Then, it allocates memory on the host using `hipHostMalloc` for another double pointer and again retrieves its attributes, which would indicate that the memory type is `hipMemoryTypeHost`. The comments suggest that the code is checking the type of memory allocated (device vs. host). The last line seems to be incomplete and unrelated to the memory operations shown.</strong></p>
-<pre><code>        The kernel launch is done with the hipLaunchCooperativeKernel of the cooperative groups API.
-        void* params[] = {&d_vector,  &d_block_reduced,  &d_partition_reduced};
-        // Launching kernel from host.
-        HIP_CHECK(hipLaunchCooperativeKernel(vector_reduce_kernel<partition_size>,</code></pre>
-<h2>30.4 Conclusion</h2>
-<p>With cooperative groups, you can easily use custom partitions to create custom tiles for custom solutions. You can find the complete code at cooperative groups ROCm example.</p>
-<h2>CHAPTER</h2>
-<h2>THIRTYONE</h2>
-<h2>LICENSE</h2>
-<p>Copyright © 2008 - 2024 Advanced Micro Devices, Inc.</p>
-<p>Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:</p>
-<p>The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.</p>
-<p>THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.</p>
-<h2>INDEX</h2>
-<p><strong>**Following table contains:** The table appears to represent a list of C++ functions related to AMD virtual memory (vmem) operations, possibly from a software library or API documentation. Each row corresponds to a specific function, and the columns provide details about these functions.
-
-- **Rows**: Each row represents a specific function related to AMD virtual memory operations. The functions seem to be part of a larger set of operations, possibly for handling memory allocation, access, and management.
-
-- **Columns**:
-  - **Column 0**: Contains the name of the function along with a description or identifier. It appears to include the function name followed by a brief description or a numerical identifier in parentheses.
-  - **Column 1**: Seems to repeat the information from Column 0, possibly indicating a duplication or a formatting error in the data.
-
-- **Noteworthy Values**: 
-  - There are several instances where the function names and descriptions are repeated across both columns, suggesting a potential issue with data duplication or formatting.
-  - Some function names are truncated or have formatting issues, such as "hsa_amd_vmem_import_shareable_handle function ), 244" and "hsa_amd_vmem_retain_alloc_handle ( C++ tion ), 245", indicating possible data entry errors or incomplete data extraction.
-
-Overall, the table seems to be a list of functions related to AMD virtual memory operations, but it may require cleaning or correction for accurate interpretation.</strong></p>
-<table><tbody><tr><td>C</td><td>hipArrayCreate ( C++ function ), 183</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>cooperative_groups::coalesced_group class ), 237</td><td>C++ hipArrayDestroy ( C++ function ), 183 hipArrayGetDescriptor ( C++ function ), 185 ( C++ function ), 185</td><td>(</td><td></td><td></td><td></td><td></td></tr><tr><td>cooperative_groups::grid_group ( C++ class ), 234</td><td>hipArrayGetInfo hipCreateSurfaceObject ( C++ function ), 133</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>cooperative_groups::multi_grid_group ( C++</td><td>( C++ function ), 197</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>class ), 234 cooperative_groups::thread_block ( C++</td><td>), hipDestroyExternalMemory ( C++ function ), 196</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>class 234</td><td>hipDestroyExternalSemaphore hipDestroySurfaceObject ( C++ function ), 133 C++ function</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>cooperative_groups::thread_block_tile ( C++ class ), 234</td><td>hipDeviceCanAccessPeer ( ), 163 hipDeviceDisablePeerAccess ( C++ function ), 164 ( C++ function ), 163</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>cooperative_groups::thread_block_tile::all ( C++ function ), 236 cooperative_groups::thread_block_tile::any</td><td>hipDeviceEnablePeerAccess hipDeviceGetStreamPriorityRange ( C++ function ), 148</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>( C++ function ), 236</td><td>hipDrvMemcpy3D ( C++ function ), 192</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>cooperative_groups::thread_block_tile::ballot</td><td>hipDrvMemcpy3DAsync ( C++ function ), 192</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>hipDrvPointerGetAttributes ( C++ function ), 166</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>( C++ function ), 236</td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>cooperative_groups::thread_block_tile::match_all</td><td>hipExternalMemoryGetMappedBuffer ( C++ func- tion ), 196</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>( C++ function ), 237 cooperative_groups::thread_block_tile::match_any</td><td>hipExternalMemoryGetMappedMipmappedArray ( C++ function ), 197 hipExtMallocWithFlags ( C++ function ), 167</td><td></td><td>236</td><td>( ),</td><td>C++</td><td>function</td></tr><tr><td>cooperative_groups::thread_block_tile::meta_group_rank ( C++ function ), 235</td><td>hipExtStreamCreateWithCUMask ( C++function ), 151 hipExtStreamGetCUMask ( C++ function ), 152</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>hipFree ( C++ function ), 171 hipFreeArray ( C++ function ), 184</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>cooperative_groups::thread_block_tile::meta_group_size ( C++ function ), 235</td><td>hipFreeAsync</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>cooperative_groups::thread_block_tile::shfl ( C++ function ), 235</td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>( C++ function ), 154</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>cooperative_groups::thread_block_tile::shfl_down</td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>( C++ function ), 235</td><td>hipFreeHost ( C++ function ), 172 hipGetProcAddress ( C++ function ), 176</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>cooperative_groups::thread_block_tile::shfl_up</td><td>hipGetSymbolAddress ( C++ function ), 176, 193 ( C++ function ), 176, 193</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>( C++ function ), 235</td><td>hipHostAlloc ( C++ function ), 168 hipHostFree ( C++ function ), 172</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>( C++ function ), 236</td><td>( C++ function ),</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>cooperative_groups::thread_block_tile::sync ( C++ function ), 235</td><td>169 ( C++ function ), 169</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>cooperative_groups::thread_block_tile::thread_rank ( C++ function ), 235 ),</td><td>( C++ function ), 169</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>cooperative_groups::thread_group ( C++ class</td><td>( C++ function ), 170 ( C++ function ),</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>234</td><td>196 ( C++ function ),</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>( C++ function ), 166, 194</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>H</td><td>hipMalloc hipMalloc3D</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>( C++ function ), 184</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>hipArray3DCreate ( C++ function ), 183</td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>185</td><td>hipMalloc3DArray ( C++ function ),</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>hipArray3DGetDescriptor ( C++ function ),</td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>195</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>184</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>hipImportExternalSemaphore</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>hipImportExternalMemory</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>hipHostMalloc ( C++ function ), 168, 194 hipHostRegister hipHostUnregister</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>hipHostGetDevicePointer hipHostGetFlags</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>hipGetSymbolSize</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>cooperative_groups::thread_block_tile::shfl_xor</td><td></td><td></td><td></td><td></td><td></td></tr></tbody></table>
-<p><strong>**Following table contains:** The table appears to represent a list of C++ functions related to surface memory operations, specifically reading and writing operations in one-dimensional and two-dimensional contexts. Each row corresponds to a different function, and the columns seem to indicate the function name followed by a numerical value, which could represent a performance metric, version number, or some other quantitative measure associated with the function.
-
-The columns are structured as follows:
-- The first column lists the function names, which include operations like `surf1DLayeredread`, `surf1DLayeredwrite`, `surf1Dread`, `surf1Dwrite`, `surf2DLayeredread`, `surf2DLayeredwrite`, `surf2Dread`, and `surf2Dwrite`.
-- The second column, which is not explicitly labeled, contains numerical values associated with each function. These values are 133, 134, or 135.
-
-Noteworthy observations include:
-- The functions `surf1DLayeredwrite`, `surf2DLayeredread`, and `surf2DLayeredwrite` all have the highest value of 135.
-- The functions `surf1Dread` and `surf1Dwrite` share the same value of 133.
-- The functions `surf2Dread` and `surf2Dwrite` both have a value of 134.
-
-These values might suggest a categorization or ranking of the functions, potentially indicating performance or compatibility levels.</strong></p>
-<table><tbody><tr><td>hipMallocArray ( C++ function ), 182 ( C++ function ), 152,</td></tr><tr><td>153 hipMallocFromPoolAsync ( C++ function ), 153, 160</td></tr><tr><td>hipMallocHost ( C++ function ), 167</td></tr><tr><td>hipMallocManaged ( C++ function ), 247, 249</td></tr><tr><td>hipMallocPitch ( C++ function ), 170</td></tr><tr><td>hipMemAddressFree ( C++ function ), 251</td></tr><tr><td>hipMemAddressReserve ( C++ function ), 251</td></tr><tr><td>hipMemAdvise ( C++ function ), 247</td></tr><tr><td>hipMemAllocHost ( C++ function ), 167</td></tr><tr><td>hipMemAllocPitch ( C++ function ), 171</td></tr><tr><td>hipMemcpy ( C++ function ), 172</td></tr><tr><td>hipMemcpy2D ( C++ function ), 186</td></tr><tr><td>hipMemcpy2DAsync ( C++ function ), 187</td></tr><tr><td>hipMemcpy2DFromArray ( C++ function ), 190</td></tr><tr><td>hipMemcpy2DFromArrayAsync ( C++ function ), 190</td></tr><tr><td>hipMemcpy2DToArray ( C++ function ), 188</td></tr><tr><td>hipMemcpy2DToArrayAsync ( C++ function ), 188</td></tr><tr><td>hipMemcpy3D ( C++ function ), 191</td></tr><tr><td>hipMemcpy3DAsync ( C++ function ), 192</td></tr><tr><td>hipMemcpyAsync ( C++ function ), 178</td></tr><tr><td>hipMemcpyAtoH ( C++ function ), 191</td></tr><tr><td>hipMemcpyDtoD ( C++ function ), 174</td></tr><tr><td>hipMemcpyDtoDAsync ( C++ function ), 175 hipMemcpyDtoH ( C++ function ), 174</td></tr><tr><td>hipMemcpyDtoHAsync ( C++ function ), 175</td></tr><tr><td>hipMemcpyFromArray ( C++ function ), 189</td></tr><tr><td>hipMemcpyFromSymbol ( C++ function ),</td></tr><tr><td>177,</td></tr><tr><td>194 hipMemcpyFromSymbolAsync ( C++ function ), 178, 194</td></tr><tr><td>hipMemcpyHtoA ( C++ function ), 191</td></tr><tr><td>hipMemcpyHtoD ( C++ function ), 173 hipMemcpyHtoDAsync ( C++ function ),</td></tr><tr><td>hipMemcpyParam2D ( C++ function ),</td></tr><tr><td>174 186</td></tr><tr><td>hipMemcpyParam2DAsync ( C++ function ),</td></tr><tr><td>187 hipMemcpyToArray ( C++ function ), 189 ( C++ function ), 177,</td></tr><tr><td>hipMemcpyToSymbol 193 hipMemcpyToSymbolAsync ( C++ function ), 193</td></tr><tr><td>177, ( C++ function ), 173</td></tr><tr><td>hipMemcpyWithStream hipMemCreate ( C++ function ), 252</td></tr><tr><td>hipMemExportToShareableHandle (</td></tr><tr><td>C++ function 252 ( C++ function ), 252</td></tr><tr><td>hipMemGetAddressRange ( C++ function ), 164 hipMemGetAllocationGranularity ( C++</td></tr><tr><td>function 253 hipMemGetAllocationPropertiesFromHandle</td></tr><tr><td>( C++ function ), 253</td></tr><tr><td>hipMemGetInfo ( C++ function ), 182 hipMemImportFromShareableHandle ( C++ function</td></tr><tr><td>253 hipMemMap ( C++ function ), 254 hipMemMapArrayAsync ( C++ function ), hipMemPoolCreate</td></tr><tr><td>254 ( C++ function ), 158</td></tr><tr><td>hipMemPoolDestroy 159</td></tr><tr><td>( C++ function ),</td></tr></tbody></table>
-<p>C++ function</p>
-<p>(</p>
-<p>), 162</p>
-<p><strong>**Following table contains:** The table appears to represent a list of functions or operations, possibly related to a programming or computational context, given the mention of terms like "Atomic" and "Warp cross-lane." Each row seems to describe a specific function or category of functions.
-
-- **Rows**: Each row represents a specific function or a sub-category of functions, possibly organized by a version or section number (e.g., 19.9, 19.10, etc.).
-
-- **Columns**:
-  - **Column 0**: This column seems to contain version or section numbers, which might indicate the order or hierarchy of the functions listed.
-  - **Column 1**: This column provides a brief descriptor or category name for the function (e.g., Math, Texture, Surface).
-  - **Column 2**: This column contains a more detailed description of the function or operation, although it is often abbreviated or truncated with ellipses.
-  - **Column 3**: This column appears to contain numerical identifiers or codes associated with each function or category.
-
-- **Noteworthy Values**:
-  - The entry "19.13.1" in Column 0 suggests a sub-section under "Atomic" functions, indicating a more detailed breakdown within that category.
-  - The description in Column 2 for "19.13.1" mentions "Unsafe floating-point atomic RMW operations," which could be a specific type of operation that warrants caution or special handling.
-  - The numerical values in Column 3 are sequential but not strictly incremental, suggesting they might be identifiers rather than simple counts.
-
-Overall, the table seems to be a structured list of functions or operations, possibly from a technical manual or documentation, organized by categories and sub-categories.</strong></p>
-<table><tbody><tr><td>hipMemPoolExportPointer hipMemPoolExportToShareableHandle ( C++</td><td>func-</td></tr><tr><td colspan="2">tion ), 160</td></tr><tr><td colspan="2">hipMemPoolGetAccess ( C++ function ), 158 hipMemPoolGetAttribute ( C++ function ), 156</td></tr><tr><td>hipMemPoolImportFromShareableHandle function ), 161</td><td>( C++</td></tr><tr><td colspan="2">hipMemPoolImportPointer ( C++ function ), 162 hipMemPoolSetAccess ( C++ function ), 157</td></tr><tr><td colspan="2">hipMemPoolSetAttribute ( C++ function ), 156</td></tr><tr><td colspan="2">hipMemPoolTrimTo ( C++ function ), 155</td></tr><tr><td colspan="2">hipMemPrefetchAsync ( C++ function ), 247</td></tr><tr><td colspan="2">hipMemPtrGetInfo ( C++ function ), 182</td></tr><tr><td colspan="2">hipMemRangeGetAttribute ( C++ function ), 248</td></tr><tr><td colspan="2">hipMemRangeGetAttributes ( C++ function ), 248</td></tr><tr><td colspan="2">hipMemRelease ( C++ function ), 255</td></tr><tr><td colspan="2">hipMemRetainAllocationHandle ( C++function ), 255</td></tr><tr><td colspan="2">hipMemset ( C++ function ), 179</td></tr><tr><td colspan="2">hipMemset2D ( C++ function ), 181</td></tr><tr><td colspan="2">hipMemset2DAsync ( C++ function ), 181</td></tr><tr><td colspan="2">hipMemset3D ( C++ function ), 181</td></tr><tr><td colspan="2">hipMemset3DAsync ( C++ function ), 182</td></tr><tr><td colspan="2">hipMemSetAccess ( C++ function ), 255</td></tr><tr><td colspan="2">hipMemsetAsync ( C++ function ), 180</td></tr><tr><td colspan="2">hipMemsetD16 ( C++ function ), 180 hipMemsetD16Async ( C++ function ), 180</td></tr><tr><td colspan="2">hipMemsetD32 ( C++ function ), 180</td></tr><tr><td colspan="2">hipMemsetD32Async ( C++ function ), 181</td></tr><tr><td colspan="2">hipMemsetD8 ( C++ function ), 179</td></tr><tr><td colspan="2">hipMemsetD8Async ( C++ function ), 179</td></tr><tr><td colspan="2">hipMemUnmap ( C++ function ), 256</td></tr><tr><td colspan="2">hipModuleGetGlobal ( C++ function ), 176</td></tr><tr><td colspan="2">( C++ function ), 165</td></tr><tr><td colspan="2">hipPointerGetAttribute hipPointerGetAttributes ( C++ function ), 165</td></tr><tr><td colspan="2">hipPointerSetAttribute ( C++ function ), 165</td></tr><tr><td colspan="2">hipSignalExternalSemaphoresAsync ( C++ func- tion ), 195</td></tr><tr><td colspan="2">hipStreamAddCallback ( C++ function ), 152 hipStreamAttachMemAsync ( C++ function ), 249</td></tr><tr><td colspan="2">hipStreamCallback_t ( C++ type ), 147 ( C++ function ), 147</td></tr><tr><td colspan="2">hipStreamCreate hipStreamCreateWithFlags ( C++ function ), 147</td></tr><tr><td colspan="2">hipStreamCreateWithPriority ( C++ function ), 147 hipStreamDestroy ( C++ function ), 148</td></tr><tr><td colspan="2">hipStreamGetDevice ( C++ function ), 151</td></tr><tr><td colspan="2">hipStreamGetFlags ( C++ function ), 150</td></tr><tr><td colspan="2">hipStreamGetPriority ( C++ function ), 150 hipStreamQuery ( C++ function ), 149</td></tr><tr><td colspan="2">hipStreamSynchronize ( C++ function ), 149</td></tr><tr><td colspan="2">hipStreamWaitEvent</td></tr><tr><td colspan="2">( C++ function ), 149</td></tr><tr><td colspan="2">hipWaitExternalSemaphoresAsync ( C++ function ), 195</td></tr><tr><td colspan="2">hsa_amd_vmem_address_free ( C++ function ), 241</td></tr><tr><td>hsa_amd_vmem_address_reserve ( C++function ),</td><td></td></tr><tr><td colspan="2">241</td></tr></tbody></table>
-<p><strong>**Following table contains:** The table appears to represent a structured outline or index of a document, possibly a technical manual or guide related to computing or programming. Each row corresponds to a specific section or subsection of the document.
-
-- **Column 0**: This column seems to represent the section or subsection number, indicating the hierarchical structure of the document.
-- **Column 1**: This column contains the main title or heading of each section or subsection.
-- **Column 2**: This column provides a brief description or additional details about the content of the section.
-- **Column 3**: This column likely represents a page number or reference number where the section can be found in the document.
-
-Noteworthy values include:
-- The presence of both main sections (e.g., "21.4 Floating-point Intrinsics") and subsections (e.g., "23.1 Cooperative kernel launches"), indicating a detailed breakdown of topics.
-- The use of ellipses in the descriptions suggests that these are truncated or summarized titles, possibly indicating longer, more detailed content in the actual document.
-- The section "22 Table, comparing syntax for different compute APIs" suggests a comparative analysis, which might be a key part of the document for readers interested in different computing APIs.</strong></p>
-<table><tbody><tr><td>hsa_amd_vmem_export_shareable_handle function ), 244</td><td></td></tr><tr><td colspan="2">hsa_amd_vmem_get_access ( C++ function ), 243</td></tr><tr><td colspan="2">hsa_amd_vmem_get_alloc_properties_from_handle ( C++ function ), 245</td></tr><tr><td colspan="2">hsa_amd_vmem_handle_create ( C++ function ), 242</td></tr><tr><td colspan="2">hsa_amd_vmem_handle_release ( C++ function ), 242</td></tr><tr><td>hsa_amd_vmem_import_shareable_handle function ), 244</td><td>( C++</td></tr><tr><td colspan="2">hsa_amd_vmem_map ( C++ function ), 242</td></tr><tr><td>hsa_amd_vmem_retain_alloc_handle ( C++ tion ), 245</td><td>func-</td></tr><tr><td colspan="2">hsa_amd_vmem_set_access ( C++ function ), 243</td></tr><tr><td colspan="2">hsa_amd_vmem_unmap ( C++ function ), 243</td></tr></tbody></table>
-<h2>S</h2>
-<p><strong>**Following table contains:** The table appears to represent a structured outline or index of a document, possibly a technical manual or report. Each row corresponds to a section or subsection of the document, with the columns providing different pieces of information about each section.
-
-- **Column 0**: This column seems to contain section numbers, indicating the hierarchical structure of the document. For example, "30.3.1.3" and "30.3.2" suggest subsections within a larger section 30.
-
-- **Column 1**: This column contains the titles or descriptions of the sections. These descriptions provide a brief overview of the content covered in each section, such as "The reduction of custom partition" and "Host-side code."
-
-- **Column 2**: This column likely represents page numbers where each section begins, helping readers locate the sections within the document. For instance, section "30.3.1.3" starts on page 291, and "31 License" starts on page 295.
-
-Noteworthy values include the presence of detailed subsections under "30.3.2," indicating a focus on cooperative group support and configuration on AMDGPUs, and the "31 License" section, which might contain legal or usage information. The document seems to be technical, possibly related to programming or hardware configuration.</strong></p>
-<table><tbody><tr><td>surf1DLayeredread</td></tr><tr><td>surf1DLayeredwrite ( C++ function ), 135</td></tr><tr><td>surf1Dread ( C++ function ), 133</td></tr><tr><td>surf1Dwrite ( C++ function ), 133</td></tr><tr><td>surf2DLayeredread ( C++ function ), 135</td></tr><tr><td>surf2DLayeredwrite ( C++ function ), 135</td></tr><tr><td>surf2Dread ( C++ function ), 134</td></tr><tr><td>surf2Dwrite ( C++ function ), 134</td></tr><tr><td>surf3Dread ( C++ function ), 134</td></tr><tr><td>surf3Dwrite ( C++ function ), 134</td></tr><tr><td>surfCubemapLayeredread ( C++ function ), 136</td></tr><tr><td>surfCubemapLayeredwrite ( C++ function ), 137</td></tr><tr><td>surfCubemapread ( C++ function ), 136</td></tr><tr><td>surfCubemapwrite ( C++ function ), 136</td></tr></tbody></table>
-<h2>U</h2>
-<p>USE_PEER_NON_UNIFIED ( C macro ), 164</p>
-</div>
-</body>
-</html>
\ No newline at end of file
diff --git a/kernel-agentic/docs/hip/hip_spec_mm/hip_spec-with-image-refs-enhanced.md b/kernel-agentic/docs/hip/hip_spec_mm/hip_spec-with-image-refs-enhanced.md
deleted file mode 100644
index 0220af6..0000000
--- a/kernel-agentic/docs/hip/hip_spec_mm/hip_spec-with-image-refs-enhanced.md
+++ /dev/null
@@ -1,12243 +0,0 @@
-## HIP Documentation Release 6.1.40092
-
-Advanced Micro Devices, Inc.
-
-Sep 13, 2024
-
-## INSTALL
-**Following table contains:** The table appears to represent a structured outline or table of contents for a document or guide related to installing and building HIP (Heterogeneous-Compute Interface for Portability). Each row corresponds to a section or subsection of the document.
-
-- The first column seems to indicate the main section number or title.
-- The second column provides a more detailed section or subsection number.
-- The third column contains the title or description of the section or subsection.
-- The fourth column appears to indicate a page number where the section or subsection can be found.
-
-Noteworthy values include:
-- The main sections are "1 Overview" and "3 Build HIP from source."
-- Subsections under "Install HIP" include "Prerequisites," "Installation," and "Verify your installation."
-- The page numbers suggest that the "Overview" section spans pages 3 to 6, while "Build HIP from source" starts on page 7.
-
-
-| 1 Overview   | 1 Overview                                                   | 1 Overview                                                   | 3     |
-|--------------|--------------------------------------------------------------|--------------------------------------------------------------|-------|
-|              | Install HIP                                                  | Install HIP                                                  |       |
-| 2            |                                                              |                                                              | 5     |
-|              | 2.1                                                          | Prerequisites . . . . . . . . .                              | 5     |
-|              | 2.2                                                          | Installation . . .                                           | 5     |
-|              | 2.3                                                          | . . . . . Verify your installation . . .                     | 6     |
-| 3            | Build HIP from source                                        | Build HIP from source                                        | 7     |
-|              | 3.1 Prerequisites                                            | . . . . . .                                                  |       |
-|              |                                                              | . .                                                          | 7     |
-|              | 3.2 Building the HIP runtime 3.3 . .                         | .                                                            | 7     |
-|              | Build HIP tests . . .                                        | Build HIP tests . . .                                        | 10    |
-|              | . . . 3.4 Run HIP . . . . . . . . . . .                      | . . . 3.4 Run HIP . . . . . . . . . . .                      | 11    |
-| 4            | HIP programming model                                        | HIP programming model                                        | 13    |
-|              | 4.1                                                          | 4.1                                                          | 13    |
-| 4.2          | RDNA &CDNAarchitecture summary Heterogeneous Programming . . | RDNA &CDNAarchitecture summary Heterogeneous Programming . . | 14    |
-|              | Single instruction multiple threads (SIMT) . . .             | Single instruction multiple threads (SIMT) . . .             | 14    |
-| 4.3 4.4      | Inherent thread model . .                                    | Inherent thread model . .                                    | 15    |
-| 4.5          | . . . . 4.4.1 Cooperative groups thread                      | . . . . 4.4.1 Cooperative groups thread                      | 16    |
-|              | Memory model . . . . . . . . .                               | Memory model . . . . . . . . .                               | 16    |
-|              | 4.6 Execution model .                                        | . . . . .                                                    | 17    |
-|              | 4.6.1 Host-side                                              | 4.6.1 Host-side                                              |       |
-|              |                                                              | execution                                                    | 17 17 |
-|              | 4.6.2                                                        | Device-side execution . .                                    |       |
-|              | 4.6.3                                                        | Kernel launch .                                              | 18    |
-| 5            | Hardware implementation                                      | Hardware implementation                                      | 19    |
-|              | Compute units                                                | . . . . . . .                                                | 19    |
-|              |                                                              | . . . . .                                                    | 20    |
-| 5.1          | 5.1.1 5.1.2                                                  | SIMD . . Vector cache . .                                    | 20    |
-|              | 5.1.3                                                        | . . Local data share . .                                     | 20    |
-|              | 5.1.4                                                        | Scalar Unit . . . .                                          | 20    |
-|              | 5.2 CDNA architecture .                                      | . . . .                                                      | 20    |
-|              | 5.3 RDNA architecture . .                                    | . . . .                                                      | 21    |
-|              | 5.4 Shader engines . .                                       | . . . .                                                      | 21    |
-|              | (CLR)                                                        | (CLR)                                                        |       |
-| 6            | AMDcommon language runtimes                                  | AMDcommon language runtimes                                  | 23    |
-|              | 6.1 Project organization                                     | . . . .                                                      | 23    |
-|              | How to build/install .                                       | . . .                                                        | 23    |
-| 6.2          | 6.2.1                                                        | Prerequisites . . .                                          | 23    |
-|              | 6.2.2                                                        | Linux . . . . . . .                                          | 23    |
-|              | 6.2.3                                                        | Test . . . . . . . .                                         | 24    |
-
-|                                           | 6.2.4                                                                                      | Release notes . . . . . . . . . . . . . . . . . . . . .                                    | 24    |
-|-------------------------------------------|--------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------|-------|
-| HIP programming manual                    | HIP programming manual                                                                     | HIP programming manual                                                                     | 25    |
-| 7 7.1                                     | Host Memory . . . . .                                                                      | . . . . . . . . . . . . . . . . . . . . .                                                  | 25    |
-|                                           | 7.1.1                                                                                      | Introduction . . . . . . . . . . . . . . .                                                 | 25    |
-|                                           | 7.1.2                                                                                      | . . . . . . . Memory allocation flags . . . . . . . . .                                    | 25    |
-|                                           | 7.1.3                                                                                      | . . . . . . Numa-aware host memory allocation . . . . . . . . .                            | 26    |
-|                                           | 7.1.4                                                                                      | Coherency Controls . . . . . . . . .                                                       | 26    |
-|                                           | 7.1.5                                                                                      | . . . . . . . . . Visibility of Zero-Copy Host Memory . . . . . . . .                      | 27    |
-|                                           | 7.1.6                                                                                      | hipEventSynchronize . . . . . . . . . . .                                                  | 27    |
-|                                           | 7.1.7                                                                                      | . . . . Summary and Recommendations . . . . . . . . . . .                                  | 27    |
-|                                           | 7.1.8                                                                                      | Managed memory allocation . . . . . . . . . . . . .                                        | 28    |
-|                                           | 7.1.9                                                                                      | HIP Stream Memory Operations . . . . . . . . . . .                                         | 28    |
-| 7.2                                       | Direct Dispatch . . . . . .                                                                | . . . . . . . . . . . . . . . . . . .                                                      | 28    |
-| 7.3                                       | HIP Runtime Compilation                                                                    | . . . . . . . . . .                                                                        | 29    |
-| 7.4                                       | . . . . . . . . . HIP Graph . . . . . . . . . . . . . . . . .                              | . . . . . . . . . .                                                                        | 29    |
-| 7.5                                       | Device-Side Malloc . . . . . .                                                             | . . . . . . . . . . . . .                                                                  | 29    |
-| 7.6                                       | . . . Use of Per-thread default stream . . .                                               | . . . . . . . . . . . . .                                                                  | 29    |
-| 7.7                                       | Use of Long Double Type . . . . .                                                          | . . . . . . . . . . . . . .                                                                | 30    |
-| 7.8                                       | Use of _Float16 Type . . . . . . .                                                         | Use of _Float16 Type . . . . . . .                                                         | 30    |
-| 7.9                                       | . . . . . . . . . . . . . . FMA and contractions . . . . . . . . . . . . . . . . . . . . . | . . . . . . . . . . . . . . FMA and contractions . . . . . . . . . . . . . . . . . . . . . | 30    |
-| 7.10                                      | Math functions with special rounding modes . . . . . . . . . . . . . . . .                 | . . . . .                                                                                  | 30    |
-| 7.11                                      | Creating Static Libraries . . .                                                            | . . . . .                                                                                  | 30    |
-| 8 HIP porting guide . . . . . . . . . . . | 8 HIP porting guide . . . . . . . . . . .                                                  | 8 HIP porting guide . . . . . . . . . . .                                                  | 33    |
-| 8.1                                       | Porting a New CUDA Project .                                                               | . . . . .                                                                                  | 33    |
-|                                           |                                                                                            | General Tips . .                                                                           |       |
-|                                           | 8.1.1                                                                                      | . . . . . . . . . . . . . . . . . . .                                                      | 33    |
-|                                           | 8.1.2                                                                                      | Scanning existing CUDA code to scope the porting effort 'in-place' . . . . . . . . . .     | 33 34 |
-|                                           | 8.1.3                                                                                      | Converting a project . .                                                                   |       |
-|                                           | 8.1.4                                                                                      | Library Equivalents . . . . . . . . . . . . . . . . . .                                    | 35 35 |
-| 8.2                                       | Distinguishing 8.2.1                                                                       | Compiler Modes . . . . . . . . . . . . . . . . Identifying HIP Target Platform . . .       | 35    |
-|                                           | 8.2.2                                                                                      | . . . . . . . . Identifying the Compiler: hip-clang or NVCC . . .                          | 36    |
-|                                           | 8.2.3                                                                                      | . Identifying Current Compilation Pass: Host or Device                                     | 36    |
-|                                           | 8.2.4                                                                                      | Compiler Defines: Summary . . . . . . . . . . . . . . .                                    | 37    |
-| 8.3                                       | Identifying Architecture Features . .                                                      | . . . . . . . . . . . . .                                                                  | 37    |
-|                                           | 8.3.1                                                                                      | HIP_ARCH Defines . . . . . . . . . . . . . . .                                             | 37    |
-|                                           | 8.3.2                                                                                      | Device-Architecture Properties . . . . . . . . . . . .                                     | 38    |
-|                                           | 8.3.3                                                                                      | Table of Architecture Properties . . . . . . . . . . . . . . . . . .                       | 38    |
-| 8.4                                       | Finding HIP . . . . . . .                                                                  | . . . . . . . . . . . .                                                                    | 39 40 |
-| 8.5 8.6                                   | Identifying HIP Runtime . . . . . hipLaunchKernelGGL . . . . .                             | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                | 40    |
-| 8.7                                       | Compiler Options . . . . . . . 8.7.1 Compiler options supported                            | . . . . . . . . . . . . . . . .                                                            | 40    |
-|                                           |                                                                                            | on AMDplatforms . . .                                                                      | 40    |
-| 8.8                                       | Linking Issues . . .                                                                       | . . . . . . . . . . . . . . . . . . . .                                                    | 41    |
-|                                           | . . 8.8.1 Linking With hipcc                                                               | . . . . . . . . . . . . . . . . . .                                                        | 41    |
-|                                           | 8.8.2                                                                                      | -lm Option . . . . . . . . . . . . . . . . .                                               | 41    |
-| 8.9                                       | . . . . . Linking Code With Other Compilers                                                | . . . . . . . . . . . . .                                                                  | 41    |
-|                                           | 8.9.1 libc++ and libstdc++                                                                 | 8.9.1 libc++ and libstdc++                                                                 |       |
-|                                           |                                                                                            | . . . . . . . . . . . . . . . . .                                                          | 41    |
-|                                           | 8.9.2                                                                                      | HIP Headers ( hip_runtime.h , hip_runtime_api.h Compiler . . . . . . . . . . .             | 42 42 |
-|                                           | 8.9.3 Using a Standard C++ 8.9.3.1 . .                                                     | . . . . . . . . . . . .                                                                    | 42    |
-|                                           | cuda.h . . . . . 8.9.4 Choosing HIP File Extensions . .                                    | . . . . . . . . . . . .                                                                    | 42    |
-| 8.10                                      | Workarounds . . . . . . . . . . . .                                                        | . . . . . . . . . . . .                                                                    | 43    |
-
-8.10.1
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-43
-
-|      |                                                                                                                                                                           |                                                                                                                                                                           | warpSize                                                                                                                                                                  |       |
-|------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------|
-|      |                                                                                                                                                                           | 8.10.2 Kernel launch with group size > 256 . . . . . . . . . . . . . . . . . . . . .                                                                                      | 8.10.2 Kernel launch with group size > 256 . . . . . . . . . . . . . . . . . . . . .                                                                                      | 43    |
-|      | 8.11                                                                                                                                                                      | memcpyToSymbol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                            | memcpyToSymbol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                            | 43    |
-|      | 8.12                                                                                                                                                                      | CU_POINTER_ATTRIBUTE_MEMORY_TYPE                                                                                                                                          | . . .                                                                                                                                                                     | 44    |
-|      | 8.13                                                                                                                                                                      | threadfence_system . . .                                                                                                                                                  | . . . . . . . .                                                                                                                                                           | 45    |
-|      |                                                                                                                                                                           | . . . . . . 8.13.1 Textures and Cache Control . . .                                                                                                                       | . . . . . . . .                                                                                                                                                           | 45    |
-|      | 8.14                                                                                                                                                                      | More Tips . . . .                                                                                                                                                         | . . . . . . . . .                                                                                                                                                         | 46    |
-|      | 8.14.1                                                                                                                                                                    | . . . . . . . . . . . HIP Logging . . . . . . . . .                                                                                                                       | . . . . . . . . .                                                                                                                                                         | 46    |
-|      | 8.14.2                                                                                                                                                                    | Debugging hipcc                                                                                                                                                           | . . . . . . . . . . . . . . . .                                                                                                                                           | 47    |
-|      | 8.14.3                                                                                                                                                                    | Editor Highlighting . .                                                                                                                                                   | . . . . . . . . . . . . .                                                                                                                                                 | 47    |
-| 9    | Porting CUDA driver API                                                                                                                                                   | Porting CUDA driver API                                                                                                                                                   | Porting CUDA driver API                                                                                                                                                   | 49    |
-| 9.1  | Introduction to the CUDA Driver and Runtime APIs . . . . . . . .                                                                                                          | Introduction to the CUDA Driver and Runtime APIs . . . . . . . .                                                                                                          | Introduction to the CUDA Driver and Runtime APIs . . . . . . . .                                                                                                          | 49    |
-|      | 9.1.1                                                                                                                                                                     | cuModule API . . . . . . . . . . . . . .                                                                                                                                  | cuModule API . . . . . . . . . . . . . .                                                                                                                                  | 49    |
-|      | 9.1.2                                                                                                                                                                     | . . . . . . . . . cuCtx API . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                             | . . . . . . . . . cuCtx API . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                             | 50    |
-| 9.2  | HIP                                                                                                                                                                       | Module and Ctx APIs . . . . . . . . . . . . .                                                                                                                             | . . .                                                                                                                                                                     | 50    |
-|      | 9.2.1                                                                                                                                                                     | hipModule API . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                       | hipModule API . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                       | 50    |
-|      | 9.2.2                                                                                                                                                                     | . hipCtx API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                  | . hipCtx API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                  | 51    |
-|      | 9.2.3                                                                                                                                                                     | hipify translation of CUDA Driver API . . . . . .                                                                                                                         | hipify translation of CUDA Driver API . . . . . .                                                                                                                         | 51    |
-|      |                                                                                                                                                                           | 9.2.3.1                                                                                                                                                                   | Address Spaces . . . . . .                                                                                                                                                | 51    |
-|      |                                                                                                                                                                           | 9.2.3.2                                                                                                                                                                   | . . . . . . Using hipModuleLaunchKernel . .                                                                                                                               | 51    |
-|      |                                                                                                                                                                           | 9.2.3.3                                                                                                                                                                   | Additional Information                                                                                                                                                    | 51    |
-|      | 9.2.4                                                                                                                                                                     | . . . . . . . . . . . hip-clang Implementation Notes . . . . . . . . . .                                                                                                  | . . . . . . . . . . . hip-clang Implementation Notes . . . . . . . . . .                                                                                                  | 51    |
-|      |                                                                                                                                                                           | 9.2.4.1                                                                                                                                                                   | .hip_fatbin . . . . . . . . . . . . .                                                                                                                                     | 51    |
-|      |                                                                                                                                                                           | 9.2.4.2                                                                                                                                                                   | Initialization and Termination Functions                                                                                                                                  | 52    |
-|      |                                                                                                                                                                           | 9.2.4.3                                                                                                                                                                   | Kernel Launching                                                                                                                                                          | 52    |
-|      | 9.2.5                                                                                                                                                                     | . . . . . . . . . . . . . . . . . . NVCC Implementation Notes . . . . . . . . . . . . . . . . .                                                                           | . . . . . . . . . . . . . . . . . . NVCC Implementation Notes . . . . . . . . . . . . . . . . .                                                                           | 52    |
-|      |                                                                                                                                                                           | . . . . 9.2.5.1 Interoperation between HIP and CUDA Driver . . . . . . .                                                                                                  | . . . . 9.2.5.1 Interoperation between HIP and CUDA Driver . . . . . . .                                                                                                  | 52    |
-|      |                                                                                                                                                                           | 9.2.5.2 Compilation Options . . .                                                                                                                                         | . . . . . .                                                                                                                                                               | 53    |
-| 9.3  | HIP                                                                                                                                                                       | Module and Texture Driver API . . . .                                                                                                                                     | . . . . . . .                                                                                                                                                             | 55    |
-| 10   | Programming for HIP runtime compiler (RTC)                                                                                                                                | Programming for HIP runtime compiler (RTC)                                                                                                                                | Programming for HIP runtime compiler (RTC)                                                                                                                                | 57    |
-| 10.1 | Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                       | Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                       | Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                       | 57    |
-| 10.2 | HIPRTC                                                                                                                                                                    | specific options . . . . . . . .                                                                                                                                          | . . . . . . . . .                                                                                                                                                         | 61    |
-|      | 10.2.1                                                                                                                                                                    | Bitcode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                             | Bitcode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                             | 62    |
-|      | 10.2.2                                                                                                                                                                    | CU Mode vs WGP mode . . . . . .                                                                                                                                           | CU Mode vs WGP mode . . . . . .                                                                                                                                           | 62    |
-| 10.3 | Linker                                                                                                                                                                    | APIs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                        | APIs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                        | 62    |
-|      | 10.3.1                                                                                                                                                                    | Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                 | Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                 | 63 63 |
-|      | 10.3.2                                                                                                                                                                    | 10.3.1.1 Note . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Input Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                     | 10.3.1.1 Note . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Input Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                     | 64    |
-|      | 10.3.3                                                                                                                                                                    | . Backward Compatibility of LLVM Bitcode/IR . . . . . . . . . . . . . .                                                                                                   | . Backward Compatibility of LLVM Bitcode/IR . . . . . . . . . . . . . .                                                                                                   | 64    |
-|      | 10.3.4                                                                                                                                                                    | Link Options . . . . . . . . . .                                                                                                                                          | . . . . . . . .                                                                                                                                                           | 64    |
-| 10.4 | Error Handling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                | Error Handling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                | Error Handling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                | 65    |
-| 10.5 | HIPRTC General APIs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                   | HIPRTC General APIs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                   | HIPRTC General APIs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                   | 65    |
-| 10.6 | Lowered Names (Mangled Names) . . . . . . . . . . .                                                                                                                       | Lowered Names (Mangled Names) . . . . . . . . . . .                                                                                                                       | Lowered Names (Mangled Names) . . . . . . . . . . .                                                                                                                       | 66    |
-|      | 10.6.1 10.6.2                                                                                                                                                             | Note . . . . . . . . . . . . . . . . . . . . . . . . . . . Example . . . . . . . . . . . . . . . . . . . . . . . . .                                                      | Note . . . . . . . . . . . . . . . . . . . . . . . . . . . Example . . . . . . . . . . . . . . . . . . . . . . . . .                                                      | 66 66 |
-| 10.7 | . . . . . . . . . . .                                                                                                                                                     | . . . . . . . . . . .                                                                                                                                                     | . . . . . . . . . . .                                                                                                                                                     | 67    |
-| 10.8 | Versioning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . HIP header support . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . | Versioning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . HIP header support . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . | Versioning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . HIP header support . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . | 68    |
-| 10.9 | Deprecation notice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                      | Deprecation notice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                      | Deprecation notice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                      | 68    |
-| 11   |                                                                                                                                                                           |                                                                                                                                                                           |                                                                                                                                                                           | 69    |
-| 11.1 | Performance guidelines Parallel                                                                                                                                           | execution                                                                                                                                                                 | . . . . . . . . . . . . . . . . . . . . .                                                                                                                                 | 69    |
-
-11.1.2
-
-Device level
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-69
-
-|                                               | 11.1.3                                                            | Multiprocessor level . . . . . . . . . . . . . .                                       | 70      |
-|-----------------------------------------------|-------------------------------------------------------------------|----------------------------------------------------------------------------------------|---------|
-| 11.2                                          | Memory                                                            | optimization . . . . . . . . . . . .                                                   | 70      |
-|                                               | 11.2.1                                                            | Data Transfer . . . . . . . . . . . . .                                                | 70      |
-|                                               | 11.2.2                                                            | . . Device Memory Access . . . . . . . . . .                                           | 71      |
-| 11.3                                          | Optimization for maximum instruction throughput                   | Optimization for maximum instruction throughput                                        | 71      |
-|                                               | 11.3.1                                                            | Arithmetic instructions . . . . . . . . .                                              | 72      |
-|                                               | 11.3.2                                                            | . Control flow instructions . . . . . . . . .                                          | 72      |
-|                                               | 11.3.3                                                            | Synchronization . . . . . . . . . .                                                    | 72      |
-| 11.4                                          | . . . . Minimizing memory thrashing .                             | . . . . . . . . . .                                                                    | 73      |
-| 12 Debugging with HIP                         | 12 Debugging with HIP                                             | 12 Debugging with HIP                                                                  | 75      |
-| 12.1                                          | Tracing . .                                                       | . . . . . . . . . . . . . . . . . . . . .                                              | 75      |
-| 12.2                                          | Debugging . . . . . .                                             | . . . . . . . .                                                                        | 77      |
-|                                               | . . . . . . . 12.2.1 Debugging HIP applications                   | . . . . . . .                                                                          | 77      |
-| 12.3                                          | Useful environment variables                                      | . . . . . . .                                                                          | 79      |
-|                                               | 12.3.1                                                            | . . . . Kernel enqueue serialization . . . . . . .                                     | 79      |
-|                                               | 12.3.2                                                            | Making device visible . . . . . . . . . . .                                            | 79      |
-|                                               | 12.3.3                                                            | Dump code object . .                                                                   | 79      |
-|                                               | 12.3.4                                                            | . . . . . . . . . . . HSA-related environment variables (Linux)                        | 80      |
-|                                               | 12.3.5 HIP environment variable summary . .                       | .                                                                                      | 80      |
-| 12.4                                          | General debugging tips . . .                                      | . . . . . . . . . . . .                                                                | 82      |
-| 13 Logging HIP activity                       | 13 Logging HIP activity                                           | 13 Logging HIP activity                                                                | 83      |
-| 13.1                                          | Logging level . . . . . . . .                                     | . . . . . . . . . . . .                                                                | 83      |
-| 13.2                                          | Logging mask . . . . .                                            | . . .                                                                                  | 84      |
-| 13.3                                          | . . . . . . . . . . . Logging command . . . . . . . . . . . . . . | . . .                                                                                  | 84      |
-| 13.4                                          | Logging examples . . . . . .                                      | . . . . . . . . . . .                                                                  | 85      |
-| 14 Cooperative groups . . . . . . . . . . . . | 14 Cooperative groups . . . . . . . . . . . .                     | 14 Cooperative groups . . . . . . . . . . . .                                          | 89      |
-| 14.1                                          | Cooperative groups thread model . . .                             | Cooperative groups thread model . . .                                                  | 89      |
-| 14.2                                          | Group types . . . . . . . . group                                 | . . . . . . . . .                                                                      | 90      |
-|                                               | 14.2.1                                                            | Thread-block . . . . . . . . . . . . .                                                 | 90      |
-|                                               | 14.2.2                                                            | Grid group . . . . . . . . . . . . . .                                                 | 90      |
-|                                               | 14.2.3                                                            | . Multi-grid group . . . . . . . . . . . . .                                           | 90      |
-|                                               | 14.2.4 14.2.5                                                     | Thread-block tile . . . . . . . . . . . . . Coalesced groups . . . . . . . . . . . . . | 91 91   |
-| 14.3                                          | Cooperative groups simple example . .                             | . . . . . .                                                                            | 92      |
-| 14.4                                          | Synchronization . . . . . .                                       | . . . . . . . .                                                                        | 94      |
-| 14.5                                          | . . . .                                                           | . . . .                                                                                | 97      |
-|                                               | Unsupported NVIDIA CUDA features . . .                            | Unsupported NVIDIA CUDA features . . .                                                 |         |
-| 15 Unified memory                             | 15 Unified memory                                                 | 15 Unified memory                                                                      | 99      |
-| 15.1                                          | Unified memory . . .                                              | . . . . . . . . . . . . . . .                                                          | 99 99   |
-| 15.2                                          | System requirements . . . . .                                     | . . . . . . . . . . .                                                                  | 100     |
-| 15.3                                          | Unified memory programming models                                 | . . . . . .                                                                            |         |
-|                                               | 15.3.1                                                            | Checking unified memory management support                                             | 100     |
-|                                               | 15.3.2 Example for unified memory management                      | 15.3.2 Example for unified memory management                                           | 101     |
-| 15.4                                          | Using unified memory management (UMM)                             | . . .                                                                                  | 104     |
-| 15.5                                          | Unified memory HIP runtime hints . . . . .                        | for the better performance                                                             | 104     |
-|                                               | 15.5.1                                                            | Data prefetching . . . . . . . . .                                                     | 105     |
-|                                               | 15.5.2                                                            | Memory advice . . . . . . . . . . . . . .                                              | 106 107 |
-|                                               | 15.5.3 15.5.4                                                     | Memory range attributes . . . . . . . . . Asynchronously attach memory to a stream     | 108     |
-| 16 Virtual memory management                  | 16 Virtual memory management                                      | 16 Virtual memory management                                                           | 109     |
-
-| 16.1                          | Memory allocation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16.1.1                                                                                                                                                | . . . 109 . . .     |
-|-------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------|
-|                               | Allocate physical memory . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                                  | 109                 |
-| 16.1.2                        | Reserve virtual address range . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                               | . . . 110           |
-| 16.1.3                        | Set memory access . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                                 | . . . 110           |
-|                               | Free virtual memory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                                 | . . . 110           |
-| 16.2                          | 16.1.4 Memory usage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                 | . . . 111           |
-|                               | 16.2.1 Dynamically increase allocation size . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                         | . . . 111           |
-| 17 Frequently asked questions | 17 Frequently asked questions                                                                                                                                                                                                                     | 113                 |
-| 17.1                          | What APIs and features does HIP support? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                      | . . . 113           |
-| 17.2                          | What is not supported? . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                                          | . . . 113           |
-|                               | 17.2.1 Runtime/Driver API features . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                          | . . . 113           |
-|                               | 17.2.2 Kernel language features . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                         | . . . 114           |
-| 17.3 Is                       | HIP a drop-in replacement for CUDA? . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                             | . . . 114           |
-| 17.4                          | What specific version of CUDA does HIP support? . . . . . . . . . . . . . . . . . . . .                                                                                                                                                           | . . . 114           |
-| 17.5                          | What libraries does HIP support? . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                        | . . . 115           |
-| 17.6                          | How does HIP compare with OpenCL? . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                             | . . . 115           |
-| 17.7                          | How does porting CUDA to HIP compare to porting CUDA to OpenCL? . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                         | . . . 115           |
-| 17.8                          | What hardware does HIP support? . . . . . . . .                                                                                                                                                                                                   | . . . 116           |
-| 17.9                          | Do HIPIFY tools automatically convert all source code? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                  | . . . 116           |
-| 17.10                         | What is NVCC? . . . . . . . . . . . . . . . .                                                                                                                                                                                                     | . . . 116           |
-| 17.11                         | . . What is HIP-Clang? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                    | . . . 116           |
-| 17.12                         | Why use HIP rather than supporting CUDA directly? . . . . . . . . . . . . . . . . . . .                                                                                                                                                           | . . . 116 117       |
-| 17.13                         | Can I develop HIP code on an NVIDIA CUDA platform? . . . . . . . . . . . . . . . . Can I develop HIP code on an AMDHIP-Clang platform? . . . . . . . . . . . . . . . .                                                                            | . . . . . . 117     |
-| 17.14                         | How to use HIP-Clang to build HIP programs? . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                   | . . . 117           |
-| 17.15                         | . . . . . . . . . . . . . .                                                                                                                                                                                                                       |                     |
-| 17.16 17.17                   | What is AMDclr? . . . . . . . . . . . . . . . . . . . What is hipother? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                               | . . . 117 . . . 118 |
-| 17.18                         | Can I get HIP open source repository . . . . . . . . . . . . . . . .                                                                                                                                                                              | . . . 118           |
-| 17.19                         | for Windows? . . . Can a HIP binary run on both AMDand NVIDIA platforms? .                                                                                                                                                                        | . . . 118           |
-| 17.20 or                      | . . . . . . . . . . . . . On HIP-Clang, can I link HIP code with host code compiled with another compiler such clang? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                         | icc, . . . 118      |
-| 17.21                         | Can HIP API support C style application? What is the difference between C and C++? . .                                                                                                                                                            | . . . 118           |
-| 17.22                         | Can I install both CUDA SDK and HIP-Clang on the same machine? . . . . . . . . .                                                                                                                                                                  | . . . 119           |
-| 17.23                         | HIP detected my platform (HIP-Clang vs NVCC) incorrectly * what should I do? . . . . . . . . . . . . . . .                                                                                                                                        | . . . 119           |
-| 17.24                         | On CUDA, can I mix CUDA code with HIP code? . . . . . . . . . . . . . .                                                                                                                                                                           | . . . 120           |
-| 17.25                         | How do I trace HIP application flow? . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                                  | . . . 120           |
-| 17.26                         | What are the maximum limits of kernel launch parameters? . . . . . . . . . . . . . . .                                                                                                                                                            | . . . 120           |
-| 17.27                         | Are __shfl_*_sync functions supported on HIP platform? . . . . . . . . . . . . . . .                                                                                                                                                              | . . . 120           |
-| 17.28                         | How to create a guard for code that is specific to the host or the GPU? . . . . . . . . . .                                                                                                                                                       | . . . 120           |
-| 17.29                         | Why _OpenMP is undefined when compiling with -fopenmp ? . . . . . . . . . . . . . .                                                                                                                                                               | . . . 121           |
-| 17.30                         | Does the HIP-Clang compiler support extern shared declarations? . . . . . . . . . . . .                                                                                                                                                           | . . . 121 code      |
-| 17.31                         | I have multiple HIP enabled devices and I am getting an error hipErrorSharedObjectInitFailed with the message 'Error: shared object initialization failed'? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . | . . . 121           |
-| 17.32                         | How to use per-thread default stream in HIP? . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                        | . . . 122           |
-| 17.33                         | How to use complex multiplication and division operations? . . . . . . . . .                                                                                                                                                                      | . . . 122           |
-| 17.34                         | . . . . . . Can I develop applications with HIP APIs on Windows the same on Linux? . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                      | . . . 122           |
-| 17.35                         | Does HIP support LUID? . . . . . . . . . . .                                                                                                                                                                                                      | . . . 123           |
-| 17.36                         | How can I know the version of HIP? . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                        | . . . 123           |
-| 18 HIP Runtime 18.1 Related   | API Reference Pages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                               | 125 . . . 126       |
-
-18.3
-
-Namespaces
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-126
-
-|      | 18.3.1                                                                                                                  | Namespace List . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                        | Namespace List . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                        | 126     |
-|------|-------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------|---------|
-|      | 18.3.2                                                                                                                  | Namespace Members . . . . . . . . . . . . . .                                                                           | Namespace Members . . . . . . . . . . . . . .                                                                           | 126     |
-|      |                                                                                                                         | 18.3.2.1 Namespace Members . . . . .                                                                                    | 18.3.2.1 Namespace Members . . . . .                                                                                    | 126     |
-|      |                                                                                                                         | 18.3.2.2 Namespace Members .                                                                                            | 18.3.2.2 Namespace Members .                                                                                            | 126     |
-| 18.4 | . . . . . Data Structures . . . . . . . . . . . . . . . . . . .                                                         | . . . . . Data Structures . . . . . . . . . . . . . . . . . . .                                                         | . . . . . Data Structures . . . . . . . . . . . . . . . . . . .                                                         | 126     |
-|      | 18.4.1 Data                                                                                                             | Structures . . . . . . . .                                                                                              | . .                                                                                                                     | 126     |
-|      | 18.4.2                                                                                                                  | . . . Data Structure Index . . . . . . . .                                                                              | . . . Data Structure Index . . . . . . . .                                                                              | 126     |
-|      | 18.4.3                                                                                                                  | . . . Class Hierarchy . . . . . . . . . . . . . .                                                                       | . . . Class Hierarchy . . . . . . . . . . . . . .                                                                       | 126     |
-|      | 18.4.4                                                                                                                  | . . Data Fields . . . . . . . . . . . . . . . . . .                                                                     | . . Data Fields . . . . . . . . . . . . . . . . . .                                                                     | 126     |
-|      |                                                                                                                         | 18.4.4.1 All . . . . . . . . . . . . . .                                                                                | .                                                                                                                       | 126     |
-|      |                                                                                                                         | 18.4.4.1.1                                                                                                              | Data Fields . . . . .                                                                                                   | 126     |
-|      |                                                                                                                         | 18.4.4.1.2                                                                                                              | Data Fields . . . . .                                                                                                   | 126     |
-|      |                                                                                                                         | 18.4.4.1.3                                                                                                              | Data Fields . . . . .                                                                                                   | 126     |
-|      |                                                                                                                         | 18.4.4.1.4                                                                                                              | Data Fields . . . . .                                                                                                   | 126     |
-|      |                                                                                                                         | 18.4.4.1.5                                                                                                              | Data Fields . . . . .                                                                                                   | 126     |
-|      |                                                                                                                         | 18.4.4.1.6                                                                                                              | Data Fields . . . .                                                                                                     | 126     |
-|      |                                                                                                                         | 18.4.4.1.7                                                                                                              | . Data Fields . . . . . .                                                                                               | 126     |
-|      |                                                                                                                         | 18.4.4.1.8                                                                                                              | Data Fields . . . .                                                                                                     | 126     |
-|      |                                                                                                                         | 18.4.4.1.9                                                                                                              | Data Fields . . . . . . .                                                                                               | 126     |
-|      |                                                                                                                         | 18.4.4.1.10                                                                                                             | Data Fields . . .                                                                                                       | 126     |
-|      |                                                                                                                         | 18.4.4.1.11                                                                                                             | Data Fields . . . . . . .                                                                                               | 126     |
-|      |                                                                                                                         | 18.4.4.1.12                                                                                                             | Data Fields . . .                                                                                                       | 126     |
-|      |                                                                                                                         | 18.4.4.1.13                                                                                                             | Data Fields . . . . . Data Fields .                                                                                     | 126     |
-|      |                                                                                                                         | 18.4.4.1.14                                                                                                             | . . . . Data Fields                                                                                                     | 126     |
-|      |                                                                                                                         | 18.4.4.1.15                                                                                                             | . . . . . .                                                                                                             | 126     |
-|      |                                                                                                                         | 18.4.4.1.16                                                                                                             | Data Fields . . . .                                                                                                     | 126     |
-|      |                                                                                                                         | 18.4.4.1.17                                                                                                             | Data Fields . . . . .                                                                                                   | 126     |
-|      |                                                                                                                         | 18.4.4.1.18                                                                                                             | Data Fields . . . . .                                                                                                   | 126     |
-|      |                                                                                                                         | 18.4.4.1.19                                                                                                             | Data Fields . . . . .                                                                                                   | 126     |
-|      |                                                                                                                         | 18.4.4.1.20                                                                                                             | Data Fields . . . . . .                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.1.21                                                                                                             | Data Fields . . . .                                                                                                     | 126     |
-|      |                                                                                                                         | 18.4.4.1.22                                                                                                             | Data Fields . . . . .                                                                                                   | 126     |
-|      |                                                                                                                         | 18.4.4.1.23                                                                                                             | Data Fields . . . . .                                                                                                   | 126     |
-|      |                                                                                                                         | 18.4.4.1.24                                                                                                             | Data Fields . . . .                                                                                                     | 126     |
-|      |                                                                                                                         | 18.4.4.1.25                                                                                                             | . Data Fields . . . . .                                                                                                 | 126 126 |
-|      | 18.4.4.2 Data Fields - Functions . . . . . . . . . . . . . 18.4.4.3 Variables . . . . . . . . . . . . . . . . . . . . . | 18.4.4.2 Data Fields - Functions . . . . . . . . . . . . . 18.4.4.3 Variables . . . . . . . . . . . . . . . . . . . . . | 18.4.4.2 Data Fields - Functions . . . . . . . . . . . . . 18.4.4.3 Variables . . . . . . . . . . . . . . . . . . . . . | 126     |
-|      |                                                                                                                         | 18.4.4.3.1                                                                                                              | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.2                                                                                                              | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.3                                                                                                              | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.4                                                                                                              | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.5                                                                                                              | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.6                                                                                                              | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.7                                                                                                              | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.8                                                                                                              | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.9                                                                                                              | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.10                                                                                                             | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.11                                                                                                             | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.12                                                                                                             | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.13                                                                                                             | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.14 18.4.4.3.15                                                                                                 | Data Fields - Variables Data Fields - Variables                                                                         | 126 126 |
-|      |                                                                                                                         | 18.4.4.3.16                                                                                                             | Data Fields - Variables                                                                                                 | 126     |
-
-18.4.4.3.17
-
-Data Fields - Variables
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-126
-
-|           |                                                                                                 | 18.4.4.3.18                                                                                     | Data Fields - Variables                                                                         | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                               | 126     |
-|-----------|-------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------|---------|
-|           |                                                                                                 | 18.4.4.3.19                                                                                     | Data Fields - Variables                                                                         | . . . . . . . . . . . . . . . . . . . . .                                                                                       | 126     |
-|           |                                                                                                 | 18.4.4.3.20                                                                                     | Data Fields -                                                                                   | Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                       | 126     |
-|           |                                                                                                 | 18.4.4.3.21                                                                                     | Data Fields - Variables                                                                         | . . . . . . . . . . . . . . . . . . . . . .                                                                                     | 126     |
-|           |                                                                                                 | 18.4.4.3.22                                                                                     | Data                                                                                            | Fields - Variables . . . . . . . . . . . . . . . . . . . . .                                                                    | 126     |
-|           |                                                                                                 | 18.4.4.3.23                                                                                     | Data Fields -                                                                                   | . . . . . . Variables . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                     | 126     |
-|           |                                                                                                 | 18.4.4.3.24                                                                                     | Data                                                                                            | Fields - Variables . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                        | 126     |
-|           |                                                                                                 | 18.4.4.3.25                                                                                     | Data                                                                                            | Fields - Variables . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                        | 126     |
-| 18.5      | 18.4.4.4 Data Fields - Related Symbols . .                                                      | . . . . . . . . .                                                                               | 18.4.4.4 Data Fields - Related Symbols . .                                                      | . . . . . . . . . . . . . . . . . . . . . . . . . . 126 . . . . . . . . .                                                       | 126     |
-|           | Files 18.5.1                                                                                    | File List . . . . .                                                                             | . . . . . . . . . . . . . .                                                                     | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .           | 126     |
-|           | 18.5.2                                                                                          | Globals . . .                                                                                   | . . . . . . . .                                                                                 | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                               | 126     |
-|           |                                                                                                 | 18.5.2.1 All . .                                                                                | . . . . . . . . . .                                                                             | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 126     |
-|           |                                                                                                 | 18.5.2.1.1                                                                                      | Globals . . . .                                                                                 | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 126     |
-|           |                                                                                                 | 18.5.2.1.2                                                                                      | Globals . . . .                                                                                 | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 126     |
-|           |                                                                                                 | 18.5.2.1.3                                                                                      | Globals . . . .                                                                                 | . . . . . . . . . . . . . . . . . . . . . . . . .                                                                               | 126     |
-|           |                                                                                                 | 18.5.2.1.4                                                                                      | Globals . . . .                                                                                 | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                       | 126     |
-|           |                                                                                                 | 18.5.2.1.5                                                                                      | Globals . . . .                                                                                 | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 126     |
-|           |                                                                                                 | 18.5.2.1.6                                                                                      | Globals . . . .                                                                                 | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 126     |
-|           |                                                                                                 | 18.5.2.1.7                                                                                      | Globals . . . .                                                                                 | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                     | 126     |
-|           |                                                                                                 | 18.5.2.1.8                                                                                      | Globals . .                                                                                     | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 126     |
-|           |                                                                                                 | 18.5.2.1.9                                                                                      | Globals                                                                                         |                                                                                                                                 | 126     |
-|           |                                                                                                 |                                                                                                 | . .                                                                                             | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                         | 126     |
-|           |                                                                                                 | 18.5.2.2 Functions 18.5.2.2.1                                                                   | . . . . . . . Globals . . .                                                                     | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . | 126     |
-|           |                                                                                                 | 18.5.2.2.2                                                                                      | Globals . .                                                                                     | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 126     |
-|           |                                                                                                 | 18.5.2.2.3                                                                                      | Globals . .                                                                                     | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                             | 126     |
-|           |                                                                                                 | 18.5.2.3 Globals                                                                                | . . . . . . .                                                                                   | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                             | 126     |
-|           |                                                                                                 | 18.5.2.4 Globals                                                                                | . . . . . . .                                                                                   | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                               | 126     |
-|           |                                                                                                 |                                                                                                 | . . . . . .                                                                                     | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                       | 126     |
-|           |                                                                                                 | 18.5.2.5 Globals                                                                                | Enumerator . . . . . .                                                                          | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                 | 126     |
-|           |                                                                                                 | 18.5.2.6 18.5.2.6.1                                                                             | Globals . . . .                                                                                 | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 126     |
-|           |                                                                                                 | 18.5.2.6.2                                                                                      | Globals .                                                                                       | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                     | 126     |
-|           |                                                                                                 | Globals                                                                                         | .                                                                                               | . . . .                                                                                                                         |         |
-|           | 18.5.2.7                                                                                        |                                                                                                 | . . . . . .                                                                                     | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                             | 126     |
-|           | C++ language extensions                                                                         | C++ language extensions                                                                         | C++ language extensions                                                                         |                                                                                                                                 | 127     |
-| 19.1      | Function-type                                                                                   | qualifiers                                                                                      | . . . . . . . . . .                                                                             | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 127 127 |
-|           | 19.1.1                                                                                          | __device__ . .                                                                                  | . . . . . . . . . . . . . .                                                                     | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .     | 128     |
-|           | 19.1.2                                                                                          | __global__                                                                                      | . . . . . .                                                                                     |                                                                                                                                 |         |
-|           | 19.1.3                                                                                          | __host__ . . .                                                                                  | . . . . . . . . . .                                                                             | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 128     |
-| 19.2 19.3 | Calling __global__ functions . . . . .                                                          | Calling __global__ functions . . . . .                                                          | . . . .                                                                                         | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .     | 128 129 |
-| 19.4      | Kernel launch example . . . . . . . . Variable type qualifiers . . . . . . . .                  | Kernel launch example . . . . . . . . Variable type qualifiers . . . . . . . .                  | . .                                                                                             | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 130     |
-|           | .                                                                                               | .                                                                                               | .                                                                                               |                                                                                                                                 | 130     |
-|           | 19.4.1                                                                                          | __constant__                                                                                    | . . . . . . . . . .                                                                             | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                 |         |
-|           | 19.4.2                                                                                          | __shared__ .                                                                                    | . . . . . . . . . .                                                                             | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                     | 130     |
-|           | 19.4.3                                                                                          | __managed__ .                                                                                   | . . . . . . . . . .                                                                             | . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                             | 130     |
-|           | 19.4.4                                                                                          | __restrict__                                                                                    | . . . . . . . . .                                                                               | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                         | 130     |
-| 19.5      | . Built-in variables . . . . . . . . . . .                                                      | . Built-in variables . . . . . . . . . . .                                                      | . .                                                                                             | . . . . . . . . .                                                                                                               | 130     |
-|           | 19.5.1                                                                                          | Coordinate built-ins                                                                            | . . . . . . .                                                                                   | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                   | 130     |
-|           | 19.5.2                                                                                          | warpSize . . .                                                                                  | . . . . . . . . . .                                                                             | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 131     |
-| 19.6      | Vector types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                    | Vector types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                    | Vector types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                    | . . . . . . . . .                                                                                                               | 131     |
-|           | 19.6.1                                                                                          | Short vector types                                                                              | . . . . . .                                                                                     | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                 | 131     |
-| 19.7      | 19.6.2 dim3 . . . . . . . . . . . . . . . . . . Memory fence instructions . . . . . . . . . . . | 19.6.2 dim3 . . . . . . . . . . . . . . . . . . Memory fence instructions . . . . . . . . . . . | 19.6.2 dim3 . . . . . . . . . . . . . . . . . . Memory fence instructions . . . . . . . . . . . | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132         | 132     |
-
-19.8
-
-Synchronization functions
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-132
-
-|                   | .                                                                                                             | . .                                                                                                           |         |
-|-------------------|---------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------|---------|
-| 19.9              | Math                                                                                                          | functions . . . . . . . . . . .                                                                               | 132     |
-| 19.10             | Texture                                                                                                       | functions . . . . . . . . . . . . .                                                                           | 133     |
-| 19.11             | Surface                                                                                                       | functions . . . . . . . . . . . . .                                                                           | 133     |
-| 19.12             | Timer                                                                                                         | functions . . . . . . . . . . . . . .                                                                         | 137     |
-| 19.13             | Atomic                                                                                                        | functions                                                                                                     | 138     |
-|                   | 19.13.1                                                                                                       | . . . . . . . . . . . . . Unsafe floating-point atomic RMWoperations                                          | 139     |
-| 19.14             | Warp cross-lane                                                                                               | functions . .                                                                                                 | 140     |
-|                   | 19.14.1                                                                                                       | . . . . . . Warp vote and ballot functions .                                                                  | 140     |
-|                   | 19.14.2 Warp                                                                                                  | match functions . . . . .                                                                                     | 141     |
-|                   | 19.14.3                                                                                                       | . Warp shuffle functions . . . . .                                                                            | 142     |
-| 19.15             | Cooperative groups                                                                                            | functions . . . . . .                                                                                         | 142     |
-| 19.16             | Warp matrix                                                                                                   | functions . . . . . . .                                                                                       | 143     |
-| 19.17             | Independent                                                                                                   | . . . thread scheduling . . . . . .                                                                           | 144     |
-| 19.18             | Profiler                                                                                                      | Counter Function . . . . . . . .                                                                              | 144     |
-| 19.19             | Assert . . . . .                                                                                              | . . . . . . . . . . . . . .                                                                                   | 144     |
-| 19.20             | . . . .                                                                                                       | printf . . . . . . . . . . . . . .                                                                            | 144     |
-| 19.21             |                                                                                                               | Device-Side Dynamic Global Memory Allocation . . . . . . . .                                                  | 145     |
-| 19.22             |                                                                                                               | __launch_bounds__ . .                                                                                         | 145     |
-|                   | 19.22.1                                                                                                       | Compiler Impact . . . . . . . .                                                                               | 145     |
-|                   | 19.22.2                                                                                                       | CU and EU Definitions . . . . .                                                                               | 146 146 |
-|                   | 19.22.3 19.22.4 maxregcount                                                                                   | Porting from CUDA __launch_bounds . . . . . . . . . .                                                         | 146     |
-| 19.23             |                                                                                                               | Asynchronous Functions . . . . . . . . .                                                                      | 147     |
-|                   | 19.23.1                                                                                                       | Memory stream . . . . . . . . .                                                                               | 147     |
-|                   | 19.23.2                                                                                                       | Peer to peer . . . . . .                                                                                      | 163     |
-|                   | 19.23.3                                                                                                       | . . . . . Memory management . . .                                                                             | 165     |
-|                   | 19.23.4                                                                                                       | . . . External Resource Interoperability                                                                      | 195     |
-|                   | Register                                                                                                      | Keyword . . . . . . . . . . . . .                                                                             | 197     |
-| 19.24             | 19.25 Pragma                                                                                                  | Unroll . . . . . . . . . . . . .                                                                              | 198     |
-| 19.26             | In-Line                                                                                                       | Assembly . . . . . . . . . . . .                                                                              | 198     |
-| 19.27             | Kernel                                                                                                        | Compilation . . . . . . . . . . .                                                                             | 198     |
-| 19.28             |                                                                                                               |                                                                                                               |         |
-|                   |                                                                                                               | gfx-arch-specific-kernel . . . . . . . . .                                                                    | 199     |
-| C++ language 20.1 | 20.1.1                                                                                                        | Modern C++ support . . . . . . . . . . . C++11 support . . . . . . . . .                                      | 201 201 |
-|                   | 20.1.2                                                                                                        | C++14 support . . . . . . . . .                                                                               | 202     |
-|                   | 20.1.3                                                                                                        | C++17 support . . . . . . . . .                                                                               | 202     |
-|                   | 20.1.4                                                                                                        | C++20 support . . . . . . . . .                                                                               | 202     |
-| 20.2              | Extensions                                                                                                    | and restrictions . . . . . . . .                                                                              | 202     |
-|                   | 20.2.1                                                                                                        | Global functions . .                                                                                          | 202     |
-|                   | 20.2.2                                                                                                        | . . . . . . Device space memory specifiers . . . .                                                            | 202     |
-|                   | 20.2.3                                                                                                        | Exception handling . . . . .                                                                                  | 203     |
-|                   | 20.2.4                                                                                                        | Kernel parameters . . . . . .                                                                                 | 203     |
-|                   | 20.2.5                                                                                                        | Classes . . . .                                                                                               | 203     |
-|                   | 20.2.6                                                                                                        | . . . . . . . . . Polymorphic function wrappers .                                                             | 203     |
-|                   | 20.2.7                                                                                                        | Extended lambdas . . . . . . . .                                                                              | 203     |
-|                   |                                                                                                               | Inline namespaces                                                                                             |         |
-|                   | 20.2.8                                                                                                        | . . . . . . .                                                                                                 | 203     |
-|                   |                                                                                                               | .                                                                                                             | 205     |
-| 21 HIP math       | API                                                                                                           | API                                                                                                           | 205     |
-| 21.1              | Single precision mathematical functions . . . . Double precision mathematical functions . . . Integer . . . . | Single precision mathematical functions . . . . Double precision mathematical functions . . . Integer . . . . | 215     |
-| 21.2              | intrinsics . . . . . . . . . . . .                                                                            | intrinsics . . . . . . . . . . . .                                                                            |         |
-| 21.3              |                                                                                                               |                                                                                                               | 225     |
-
-|    | 21.4                                                                                       | Floating-point Intrinsics . . . . . . . . . . . . . .                                      | 227   |
-|----|--------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------|-------|
-| 22 | Table                                                                                      | comparing syntax for different compute APIs                                                | 231   |
-|    | 22.1                                                                                       | Notes . . . . . . . . . . . . . . . . . . . . . . . .                                      | 232   |
-| 23 | HIP                                                                                        | Cooperative groups API                                                                     | 233   |
-|    | 23.1                                                                                       | Cooperative kernel launches . . . . . . . . . . . .                                        | 233   |
-|    | 23.2                                                                                       | Cooperative groups classes . . . . . . . . . . . . .                                       | 234   |
-|    | 23.3                                                                                       | Cooperative groups construct functions . . . .                                             | 237   |
-|    | 23.4                                                                                       | . . Cooperative groups exposed API functions . . . .                                       | 238   |
-| 24 | HSA runtime API for ROCm                                                                   | HSA runtime API for ROCm                                                                   | 241   |
-| 25 | HIP managed memory allocation API                                                          | HIP managed memory allocation API                                                          | 247   |
-| 26 | HIP virtual memory management API                                                          | HIP virtual memory management API                                                          | 251   |
-| 27 | HIP deprecated                                                                             | runtime API functions                                                                      |       |
-|    |                                                                                            |                                                                                            | 257   |
-|    | 27.1                                                                                       | Context management . . . . . . . . . . . . . . . .                                         | 257   |
-|    | 27.2                                                                                       | Memory management . . . . . . . . . . . . . . . . . .                                      | 258   |
-|    | 27.3                                                                                       | Profiler control . . . . . . . . . . . . . . . .                                           | 258   |
-|    | 27.4                                                                                       | Texture management . . . . . . . . . . . . . . . .                                         | 258   |
-| 28 | SAXPY - Hello, HIP                                                                         | SAXPY - Hello, HIP                                                                         | 261   |
-|    | 28.1 Prerequisites . . . . . .                                                             | . . . . . . . . . . .                                                                      | 261   |
-|    | . . . 28.2 Heterogeneous programming                                                       | . . . . . . . . .                                                                          | 261   |
-|    | . . 28.3 Your first lines of HIP code . . .                                                | . . . . . .                                                                                | 261   |
-|    | . . . 28.4 Compiling on the command line . . . .                                           | . . . . . .                                                                                | 263   |
-|    | 28.4.1 Setting up the command line                                                         | . . . . . . .                                                                              | 263   |
-|    | 28.4.2                                                                                     | Invoking the compiler manually . . . . .                                                   | 266   |
-| 29 | Reduction                                                                                  | Reduction                                                                                  | 273   |
-|    | 29.1 The algorithm . . . 29.2                                                              | . . . . . . . . . . . . . . . .                                                            | 273   |
-|    | Reduction on GPUs                                                                          | . . . . . . . . . . . . . . . .                                                            | 273   |
-|    | 29.2.1 Naive shared reduction                                                              | . . . . . . . . . .                                                                        | 274   |
-|    | 29.2.2                                                                                     | Reducing thread divergence . . . . . . . .                                                 | 276   |
-|    | 29.2.3                                                                                     | Resolving bank conflicts . . . . . . . . .                                                 | 276   |
-|    | 29.2.4                                                                                     | Utilize upper half of the block . . . . . . . . . . . . .                                  | 277   |
-|    | 29.2.5                                                                                     | Unroll all loops . . . . . . .                                                             | 281   |
-|    | 29.2.6                                                                                     | Communicate using warp-collective functions                                                | 282   |
-|    | 29.2.7                                                                                     | Prefer warp communication over shared                                                      | 282   |
-|    | 29.2.8                                                                                     | . Amortize bookkeeping variable overhead                                                   | 284   |
-|    | 29.2.8.1 Reading ItemsPerThread                                                            | . . .                                                                                      | 285   |
-|    | 29.2.8.2 Processing ItemsPerThread                                                         | . .                                                                                        | 286   |
-|    | 29.2.9 Two-pass reduction                                                                  | . . . . . . . . . . . .                                                                    | 286   |
-|    | 29.2.10 Global data share                                                                  | . . . . . . . . . . . . .                                                                  | 286   |
-|    | 29.3 Conclusion . . . . .                                                                  | . . . . . . . . . . . . . . . .                                                            | 287   |
-| 30 | Cooperative groups .                                                                       | Cooperative groups .                                                                       | 289   |
-|    | 30.1 Prerequisites                                                                         | . . . . . . . . . . . . . . . . . . .                                                      | 289   |
-|    | 30.2 Simple HIP Code                                                                       | . . . . . . . . . . . . . . . . . .                                                        | 289   |
-|    | Tiled partition                                                                            | . . . . . . .                                                                              | 289   |
-|    | 30.3 . . . . . . . . . . . . 30.3.1 Device-side code . . . . . .                           | . . .                                                                                      | 290   |
-|    | . . . . 30.3.1.1 1. Initialization of the reduction                                        | . . . . 30.3.1.1 1. Initialization of the reduction                                        | 291   |
-|    | function variables . . . 30.3.1.2 2. The reduction of thread block . . . . . . . . . . . . | function variables . . . 30.3.1.2 2. The reduction of thread block . . . . . . . . . . . . | 291   |
-
-|                     | 30.3.1.3 3. The reduction of custom partition . . . . . . . . . . . . . . . . . . . . . . . . . .   |   291 |
-|---------------------|-----------------------------------------------------------------------------------------------------|-------|
-| 30.3.2              | Host-side code . . . . . . . . . . . .                                                              |   292 |
-|                     | 30.3.2.1 1. Confirm the cooperative group support on AMDGPUs 30.3.2.2 . . . . .                     |   292 |
-|                     | 2. Initialize the cooperative group configuration . . . . . . . . . . . . . . . . . . .             |   293 |
-| 30.3.2.3 Conclusion | 4. Launch the kernel . . . . .                                                                      |   293 |
-| 30.4 .              | . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                           |   293 |
-| 31 License          |                                                                                                     |   295 |
-
-Index
-
-297
-
-The Heterogeneous-computing Interface for Portability (HIP) API is a C++ runtime API and kernel language that lets developers create portable applications for AMD and NVIDIA GPUs from single source code.
-
-For HIP supported AMD GPUs on multiple operating systems, see:
-
-- Linux system requirements
-- Microsoft Windows system requirements
-
-The CUDA enabled NVIDIA GPUs are supported by HIP. For more information, see GPU Compute Capability.
-
-On the AMD ROCm platform, HIP provides header files and runtime library built on top of HIP-Clang compiler in the repository Common Language Runtimes (CLR) , which contains source codes for AMD's compute languages runtimes as follows,
-
-On non-AMD platforms, like NVIDIA, HIP provides header files required to support non-AMD specific back-end implementation in the repository 'hipother', which translates from the HIP runtime APIs to CUDA runtime APIs.
-
-## Install
-
-- Installing HIP
-- Building HIP from source
-
-## Conceptual
-
-- HIP programming model
-- Hardware implementation
-- AMD common language runtimes (CLR)
-
-## How to
-
-- Programming manual
-- HIP porting guide
-- HIP porting: driver API guide
-- Programming for HIP runtime compiler (RTC)
-- Performance guidelines
-- Debugging with HIP
-- Logging HIP activity
-- Unified memory
-- Virtual memory
-- Cooperative groups
-- Frequently asked questions
-
-## Reference
-
-- HIP Runtime API Reference
-- C++ language extensions
-- C++ language support
-- HIP math API
-- Comparing syntax for different APIs
-- HSA runtime API for ROCm
-- HIP managed memory allocation API
-
-## CHAPTER ONE
-
-## OVERVIEW
-
-- HIP virtual memory management API
-- HIP Cooperative groups API
-- List of deprecated APIs
-
-## Tutorial
-
-- HIP basic examples
-- HIP examples
-- HIP test samples
-- SAXPY tutorial
-- Reduction tutorial
-- Cooperative groups tutorial
-
-Known issues are listed on the HIP GitHub repository.
-
-To contribute features or functions to the HIP project, refer to Contributing to HIP. To contribute to the documentation, refer to Contributing to ROCm docs page.
-
-You can find licensing information on the Licensing page.
-
-## CHAPTER
-
-## TWO
-
-## INSTALL HIP
-
-HIP can be installed on AMD (ROCm with HIP-Clang) and NVIDIA (CUDA with NVCC) platforms.
-
-Note: The version definition for the HIP runtime is different from CUDA. On an AMD platform, the hipRuntimeGerVersion function returns the HIP runtime version; on an NVIDIA platform, this function returns the CUDA runtime version.
-
-## 2.1 Prerequisites
-
-## AMD
-
-Refer to the Prerequisites section in the ROCm install guides:
-
-- System requirements (Linux)
-- System requirements (Windows)
-
-## NVIDIA
-
-Check the system requirements in the NVIDIA CUDA Installation Guide.
-
-## 2.2 Installation
-
-## AMD
-
-HIP is automatically installed during the ROCm installation. If you haven't yet installed ROCm, you can find installation instructions here:
-
-- ROCm installation for Linux
-- HIP SDK installation for Windows
-
-By default, HIP is installed into /opt/rocm/hip .
-
-Note: There is no autodetection for the HIP installation. If you choose to install it somewhere other than the default location, you must set the HIP\_PATH environment variable as explained in Build HIP from source.
-
-## NVIDIA
-
-1. Install the NVIDIA driver.
-
-sudo apt-get install ubuntu-drivers-common &amp;&amp; sudo ubuntu-drivers autoinstall sudo reboot
-
-Alternatively, you can download the latest CUDA Toolkit.
-
-2. Install the hip-runtime-nvidia and hip-dev packages. This installs the CUDA SDK and HIP porting layer.
-**Following code does:** This code snippet defines an enumeration `hipMemoryType` in C/C++ for the AMD platform, specifically within the HIP (Heterogeneous-Compute Interface for Portability) runtime API. The enumeration categorizes different types of memory based on their physical location and management. The types include:
-
-- `hipMemoryTypeHost`: Memory located on the host (CPU).
-- `hipMemoryTypeDevice`: Memory located on a specific device (GPU).
-- `hipMemoryTypeArray`: Array memory located on a specific device.
-- `hipMemoryTypeUnified`: Currently not used.
-- `hipMemoryTypeManaged`: Managed memory that is automatically handled by the unified memory system.
-
-This enumeration helps in identifying and managing different memory types in heterogeneous computing environments.
-
-
-```
-  | apt-get install hi
-```
-**Following code does:** The code snippet `<_Cuda_>` appears to be a placeholder or a symbolic representation rather than actual executable code. In the context of programming, particularly with Python, it might suggest a reference to CUDA, which is a parallel computing platform and application programming interface (API) model created by NVIDIA. CUDA allows developers to use a GPU for general purpose processing, which can significantly accelerate computations. However, without additional context or actual code, it is not possible to determine any specific functionality or purpose from this snippet alone.
-
-
-```
-tall hip-runtime-nvidia hip-dev
-```
-
-## The default paths are:
-
-- CUDA SDK: /usr/local/cuda
-- HIP: /opt/rocm/hip
-
-You can optionally add /opt/rocm/bin to your path, which can make it easier to use the tools.
-
-## 2.3 Verify your installation
-
-Run hipconfig in your installation path.
-
-/opt/rocm/bin/hipconfig --full
-
-CHAPTER
-
-## THREE
-
-## BUILD HIP FROM SOURCE
-
-## 3.1 Prerequisites
-
-HIP code can be developed either on AMD ROCm platform using HIP-Clang compiler, or a CUDA platform with nvcc installed. Before building and running HIP, make sure drivers and prebuilt packages are installed properly on the platform.
-
-You also need to install Python 3, which includes the CppHeaderParser package. Install Python 3 using the following command:
-**Following code does:** It seems there is a formatting error in your request. The code snippet is labeled as C++ but is enclosed within Python code tags. Please provide the correct code snippet or clarify the language so I can assist you accurately.
-
-
-```
-    | apt-get install python3
-```
-
-Check and install CppHeaderParser package using the command:
-**Following code does:** It seems there is a formatting error in your request. The code snippet is labeled as Python, but it contains a placeholder that suggests it should be C++ code. Please provide the correct code snippet or clarify the language so I can assist you accurately.
-
-
-```
-      | pip3 install CppHeaderParser
-```
-
-## 3.2 Building the HIP runtime
-
-Set the repository branch using the variable: ROCM\_BRANCH . For example, for ROCm 6.1, use:
-**Following code does:** This code snippet is part of a build process for a project that involves compiling CUDA code using the HIP (Heterogeneous-Compute Interface for Portability) compiler. The `export HIPCC_VERBOSE=1` command sets an environment variable to enable verbose output from the HIP compiler, which provides detailed information about the compilation process. The `make` command is then executed, which typically runs a Makefile to build the project. The output shown (`hipcc-cmd: ...`) indicates that the HIP compiler (`hipcc`) is being invoked to compile a CUDA source file (`backprop_cuda.cu`) with specific options, such as targeting the native architecture for offloading. This process is likely part of porting or optimizing CUDA code for different hardware using HIP.
-
-
-```
-| export
-```
-**Following code does:** The code snippet `<_Cuda_>` appears to be a placeholder or a symbolic representation rather than actual executable code. In the context of programming, "Cuda" typically refers to NVIDIA's parallel computing platform and application programming interface (API) model, which allows developers to use a CUDA-enabled graphics processing unit (GPU) for general purpose processing. However, without additional context or actual code, it's not possible to determine the specific functionality or purpose of this snippet. It might be used in documentation, pseudocode, or as a marker in a larger codebase to indicate where CUDA-related code or functionality is intended to be implemented.
-
-
-```
-<_Bash_>
-```
-
-## AMD
-
-1. Get HIP source code.
-
-Note: Starting in ROCM 5.6, CLR is a new repository that includes the former ROCclr, HIPAMD and OpenCl repositories. OpenCL provides headers that ROCclr runtime depends on.
-
-Note: Starting in ROCM 6.1, a new repository hipother is added to ROCm, which is branched out from HIP. hipother provides files required to support the HIP back-end implementation on some non-AMD platforms, like NVIDIA.
-**Following code does:** The provided code snippet appears to be a series of malformed XML declarations interspersed with various symbols and whitespace. It does not perform any functional operations or represent valid XML or Python code. Its high-level purpose is unclear, as it does not conform to any recognizable programming or markup language syntax. It seems to be a nonsensical or corrupted text rather than executable code.
-
-
-```
-<_Bash_>
-```
-**Following code does:** This code snippet is the beginning of a C++ program that is set up to use the HIP (Heterogeneous-computing Interface for Portability) API, which is designed for writing portable code that can run on both AMD and NVIDIA GPUs. The `#include` directives are used to include the necessary headers for HIP runtime functions (`hip_runtime.h` and `hip_runtime_api.h`) and standard C++ functionalities (`iostream` for input/output stream operations, `fstream` for file stream operations, and `vector` for using the vector container). This setup suggests that the program will likely involve GPU computations and possibly handle input/output operations and data storage using vectors.
-
-
-```
-:lone -b "$ROCM_BRANCH" https://github.com/ROCm/clr.git
-:lone -b "$ROCM_BRANCH" https://github.com/ROCm/hip.git
-```
-
-CLR (Common Language Runtime) repository includes ROCclr, HIPAMD and OpenCL.
-
-ROCclr (Radeon Open Compute Common Language Runtime) is a virtual device interface which is defined on the AMD platform. HIP runtime uses ROCclr to interact with different backends.
-
-HIPAMD provides implementation specifically for HIP on the AMD platform.
-
-OpenCL provides headers that ROCclr runtime currently depends on. hipother provides headers and implementation specifically for non-AMD HIP platforms, like NVIDIA.
-
-2. Set the environment variables.
-3. Build HIP.
-**Following code does:** This code snippet is a C++ program that includes headers for HIP (Heterogeneous-Compute Interface for Portability) runtime and API, which are used for GPU programming, particularly with AMD hardware. Additionally, it includes standard C++ headers for input/output operations (`iostream`), file handling (`fstream`), and using the vector container (`vector`). The purpose of this setup is likely to perform GPU-accelerated computations while also handling input/output operations and managing data using vectors in a C++ application.
-
-
-```
-<_Bash_>
-```
-**Following code does:** This code snippet is a C++ program that uses the HIP (Heterogeneous-Compute Interface for Portability) API to perform a vector copy operation on a GPU. The program is designed to work on both AMD and NVIDIA platforms, as indicated by the conditional compilation directives. Here's a high-level summary of what the code does:
-
-1. **Define Constants**: It defines constants for the length of the vectors (`LEN`) and the size in bytes (`SIZE`).
-
-2. **Platform-Specific File Names**: Depending on whether the code is compiled for an AMD or NVIDIA platform, it sets the appropriate file name for the compiled GPU kernel.
-
-3. **Initialize Vectors**: It allocates and initializes two float arrays, `A` and `B`, each of length `LEN`. Array `A` is initialized with sequential float values, while `B` is initialized with zeros.
-
-4. **GPU Initialization (NVIDIA only)**: If compiled for an NVIDIA platform, it initializes the HIP runtime, gets a device, and creates a context.
-
-5. **Memory Allocation on GPU**: It allocates memory on the GPU for both arrays `A` and `B`.
-
-6. **Data Transfer to GPU**: It copies the contents of arrays `A` and `B` from host memory to the allocated GPU memory.
-
-7. **Kernel Loading and Execution Setup**: It loads a GPU module from a file and retrieves a function (kernel) named "hello_world" from the module. It prepares the arguments for the kernel launch.
-
-The code is incomplete, as it ends abruptly, but it appears to be setting up for launching a GPU kernel that would likely perform some operation on the vectors `A` and `B`.
-
-
-```
-        cd "$CLR_DIR"
-        mkdir -p build; cd build
-        cmake -DHIP_COMMON_DIR=$HIP_DIR -DHIP_PLATFORM=amd -DCMAKE_PREFIX_PATH="/opt/rocm/"_
-        ---DCMAKE_INSTALL_PREFIX=$PWD/install -DHIP_CATCH_TEST=0 -DCLR_BUILD_HIP=ON -DCLR_
-        --BUILD_OCL=OFF..
-        
-        make -j$(nproc)
-        sudo make install
-```
-
-Note: Note, if you don't specify CMAKE\_INSTALL\_PREFIX , the HIP runtime is installed at &lt;ROCM\_PATH&gt;/hip .
-
-By default, release version of HIP is built. If need debug version, you can put the option CMAKE\_BUILD\_TYPE=Debug in the command line.
-
-Default paths and environment variables:
-
-- HIP is installed into &lt;ROCM\_PATH&gt;/hip . This can be overridden by setting the HIP\_PATH environment variable.
-
-•
-
-HSA is in
-
-&lt;ROCM\_PATH&gt;/hsa
-
-. This can be overridden by setting the
-
-HSA\_PATH
-
-environment variable.
-
-- Clang is in &lt;ROCM\_PATH&gt;/llvm/bin . This can be overridden by setting the HIP\_CLANG\_PATH environment variable.
-- The device library is in &lt;ROCM\_PATH&gt;/lib . This can be overridden by setting the DEVICE\_LIB\_PATH environment variable.
-- Optionally, you can add &lt;ROCM\_PATH&gt;/bin to your PATH , which can make it easier to use the tools.
-- Optionally, you can set HIPCC\_VERBOSE=7 to output the command line for compilation.
-
-After you run the make install command, make sure HIP\_PATH points to $PWD/install/hip .
-
-1. Generate a profiling header after adding/changing a HIP API.
-
-Whenyouadd or change a HIP API, you may need to generate a new hip\_prof\_str.h header. This header is used by ROCm tools to track HIP APIs, such as rocprofiler and roctracer .
-
-To generate the header after your change, use the hip\_prof\_gen.py tool located in hipamd/src .
-
-Usage:
-**Following code does:** The code snippet appears to be part of a larger program that utilizes HIP (Heterogeneous-Compute Interface for Portability) to perform parallel computation on a GPU. Here's a high-level summary of what the code does:
-
-1. **Kernel Launch**: It launches a GPU kernel using `hipModuleLaunchKernel`. The kernel is specified by `Function`, and it is configured to execute with a grid size of 1x1x1 and a block size of `LEN`x1x1. The kernel is passed a configuration parameter `config`.
-
-2. **Data Transfer**: After the kernel execution, the code copies data from the device (GPU) to the host (CPU) using `hipMemcpyDtoH`. The data is copied from `Bd` (device memory) to `B` (host memory), with the size specified by `SIZE`.
-
-3. **Output**: It iterates over the length `LEN` and prints the values of arrays `A` and `B` to the standard output, displaying them in a formatted manner.
-
-4. **Context Detachment**: If the code is compiled for an NVIDIA platform (`__HIP_PLATFORM_NVIDIA__`), it detaches the HIP context using `hipCtxDetach`.
-
-5. **Return**: The function returns 0, indicating successful execution.
-
-Overall, this code is part of a GPU computing application that sets up and executes a kernel on a GPU, retrieves the results, and prints them.
-
-
-```
-<_PHP_>
-```
-**Following code does:** This code snippet is part of a CUDA or HIP (Heterogeneous-Compute Interface for Portability) program, which is used for parallel computing on GPUs. It declares an external 2D texture reference named `tex` that holds floating-point data. The snippet also includes the beginning of a kernel function definition, `tex2dKernel`, which is intended to be executed on the GPU. This kernel function takes a parameter `outputData`, which is likely an array where the results of the texture operations will be stored. The `hipLaunchParm lp` is a parameter used for launching the kernel with specific execution configurations. The code is incomplete, so the specific operations performed by the kernel are not shown.
-
-
-```
-                                                                                                                                                                                                        |                                                                                                                                                                                                       
-                                                                                                                                                                                                        <! hip_prof_gen.py                                                                                                                                                                                                        </!                                                                                                                                                                                                        >
-                                                                                                                                                                                                       <?php                                                                                                                                                                                                        +
-```
-
-## Flags:
-
-- -v : Verbose messages
-- -r : Process source directory recursively
-- -t : API types matching check
-- --priv : Private API check
-- -e : On error exit mode
-- -p : HIP\_INIT\_API macro patching mode
-
-Example usage:
-**Following code does:** This code snippet is part of a host program that interacts with a GPU using the HIP (Heterogeneous-Compute Interface for Portability) API, which is used for writing portable applications across different GPU architectures. The code sets up a 2D texture reference for use in GPU computations. Specifically, it retrieves a texture reference from a module, sets the address mode for both dimensions to wrap (which means texture coordinates will wrap around), and sets the filter mode to point sampling (which means the nearest texel value will be used). This setup is typically used to configure how textures are accessed and sampled in GPU kernels.
-
-
-```
-<_Bash_>
-```
-
-## NVIDIA
-**Following code does:** This code snippet is configuring a texture reference in a HIP (Heterogeneous-Compute Interface for Portability) application, which is used for GPU programming. Specifically, it sets the flags for the texture reference to zero, specifies the format of the texture data as a single-channel floating-point format, and associates the texture reference with a specified array while overriding the format. This setup is typically used to prepare texture data for use in GPU computations, such as in graphics or parallel processing tasks.
-
-
-```
-git clone -b "$ROCM_BRANCH" https://github.com/ROCm/clr.git
-git clone -b "$ROCM_BRANCH" https://github.com/ROCm/hip.git
-git clone -b "$ROCM_BRANCH" https://github.com/ROCm/hipother.git
-```
-**Following code does:** The code snippet `<_C_>` appears to be incomplete or not a valid Python code. It does not represent any recognizable Python construct or functionality. It might be a placeholder or a typo. Without additional context or surrounding code, it's not possible to determine its purpose or functionality.
-
-
-```
---- ---
-
-    1. Get the HIP source code.
-        git clone -b "$ROCM_BRANCH"
-        git clone -b "$ROCM_BRANCH"
-        git clone -b "$ROCM_BRANCH"
-
-    2. Set the environment variables.
-```
-**Following code does:** This code snippet is a call to the `hiprtcCreateProgram` function, which is part of the HIP Runtime Compilation (HIPRTC) API. The function is used to create a program object for a GPU kernel written in CUDA C/C++. The parameters provided include the kernel source code as a string, the name of the file for the kernel, the number of header files, and arrays containing the header source code and their corresponding names. This setup is typically used to compile and execute GPU kernels dynamically at runtime.
-
-
-```
-export CLR_DIR="$(readlink -f clr)"
-export HIP_DIR="$(readlink -f hip)"
-export HIP_OTHER="$(readlink -f hipother)"
-```
-**Following code does:** This code snippet appears to be a call to the `hiprtcCompileProgram` function, which is part of the HIP (Heterogeneous-Compute Interface for Portability) runtime compilation library. The function is used to compile a HIPRTC program, which is typically written in a CUDA-like language, into a binary that can be executed on a GPU. In this specific call, the function is provided with a `hiprtcProgram` object (`prog`) and is instructed to compile it with zero additional options (`0`), although there is a placeholder for options (`options`) which suggests that options could be passed if needed. The comment indicates that supported Clang options can be used, but none are specified here.
-
-
-```
-3.  Build HIP.
-```
-**Following code does:** It seems there is a formatting error in your request. The code snippet is labeled as Python, but the placeholder `<_C++_>` suggests it might be intended for C++. Please provide the correct code snippet or clarify the language so I can assist you accurately.
-
-
-```
-cd "$CLR_DIR"
-mkdir -p build; cd build
-cmake -DHIP_COMMON_DIR=$HIP_DIR -DHIP_PLATFORM=nvidia -DCMAKE_INSTALL_PREFIX=$PWD/
- --install -DHIP_CATCH_TEST=0 -DCLR_BUILD_HIP=ON -DCLR_BUILD_OCL=OFF -DHIPNV_DIR=
- --$HIP_OTHER/hipnv..
-make -j$(nproc)
-sudo make install
-```
-
-## 3.3 Build HIP tests
-
-## AMD
-
-- Build HIP catch tests.
-**Following code does:** This code snippet retrieves the compiled binary code of a GPU kernel using the HIP runtime compilation (hipRTC) API. It first determines the size of the compiled code with `hiprtcGetCodeSize`, storing it in `codeSize`. Then, it allocates a vector `kernel_binary` of the appropriate size to hold the binary data. Finally, it populates this vector with the actual compiled kernel code using `hiprtcGetCode`. This process is typically part of a workflow where GPU kernels are dynamically compiled and executed.
-
-
-```
-git clone -b "$ROCM_BRANCH" https://github.com/ROCm/hip-tests.git  |
-```
-**Following code does:** This code snippet is using the HIP (Heterogeneous-Compute Interface for Portability) API to load and prepare a GPU kernel for execution. Specifically, it performs the following high-level tasks:
-
-1. Loads a compiled GPU kernel binary into a HIP module using `hipModuleLoadData`.
-2. Retrieves a specific function, named "vector_add", from the loaded module using `hipModuleGetFunction`.
-
-This setup is typically used in GPU programming to execute parallel computations on a GPU, where "vector_add" likely refers to a kernel function that performs vector addition.
-
-
-```
-        - npm -m -cos no-source.
-
-            export HIPTESTS_DIR="$(readlink -f hip-tests)"
-            cd "$HIPTESTS_DIR"
-            mkdir -p build; cd build
-            cmake../catch -DHIP_PLATFORM=amd -DHIP_PATH=$CLR_DIR/build/
-            --install  # or any path where HIP is installed; for example: ``/
-            --opt/rocm``
-            make build_tests
-            ctest # run tests
-```
-**Following code does:** The code snippet provided is essentially empty and does not perform any operations or have any functionality. It consists only of whitespace and a comment symbol (`//`), which is typically used for comments in languages like C, C++, and Java, but not in Python. In Python, comments are denoted by the `#` symbol. Therefore, this snippet does not execute any code or serve any purpose.
-
-
-```
-AMD
-
-     *  Build HIP catch tests.
-
-                HIP catch tests are separate from the HIP project and use Catch2.
-
-                    - Get HIP tests source code.
-```
-**Following code does:** The code snippet provided consists entirely of a series of angle brackets (`<` and `>`) and hyphens (`-`). It does not contain any executable Python code or meaningful syntax. Therefore, it does not perform any operations or have any functional purpose in a Python program. It appears to be a visual pattern or placeholder rather than actual code.
-
-
-```
-      - command: command.json.
-        
-          cd "$HIPTESTS_DIR"
-          hipcc $HIPTESTS_DIR/catch/unit/memory/hipPointerGetAttributes.cc \
-          -I./catch/include./catch/hipTestMain/standalone_main.cc \
-          -I./catch/external/Catch2 -o hipPointerGetAttributes
-         ./hipPointerGetAttributes
-         ...
-
-          All tests passed
-```
-
-## NVIDIA
-
-The commands to build HIP tests on an NVIDIA platform are the same as on an AMD platform. However, you must first set -DHIP\_PLATFORM=nvidia .
-
-## 3.4 Run HIP
-
-After installation and building HIP, you can compile your application and run. A simple example is square sample.
-
-## FOUR
-
-## HIP PROGRAMMING MODEL
-
-The HIP programming model makes it easy to map data-parallel C/C++ algorithms to massively parallel, wide single instruction, multiple data (SIMD) architectures, such as GPUs.
-
-While the model may be expressed in most imperative languages, (for example Python via PyHIP) this document will focus on the original C/C++ API of HIP.
-
-A basic understanding of the underlying device architecture helps you make efficient use of HIP and general purpose graphics processing unit (GPGPU) programming in general.
-
-## 4.1 RDNA &amp; CDNA architecture summary
-
-GPUs in general are made up of basic building blocks called compute units (CUs), that execute the threads of a kernel. These CUs provide the necessary resources for the threads: the Arithmetic Logical Units (ALUs), register files, caches and shared memory for efficient communication between the threads.
-
-This design allows for efficient execution of kernels while also being able to scale from small GPUs embedded in APUs with few CUs up to GPUs designed for data centers with hundreds of CUs. Figure Block Diagram of an RDNA3 Compute Unit. and Block Diagram of a CDNA3 Compute Unit. show examples of such compute units.
-
-For architecture details, check Hardware implementation .
-
-Fig. 1: Block Diagram of an RDNA3 Compute Unit.
-
-Schedule.
-
-**Image description:** The image is a block diagram representing the architecture of a graphics processing unit (GPU). It is divided into two main sections, each containing multiple components that are responsible for different computational tasks. 
-
-On the left side, there are two identical blocks labeled "Scheduler," each containing:
-- Vector GPR (General Purpose Registers) for handling operations like Float/INT/Matrix SIMD32, Float/Matrix SIMD32, and Transcendental SIMD8.
-- AI MATRIX Accelerator for artificial intelligence matrix operations.
-- DPFP (Double Precision Floating Point) unit.
-- Scalar GPR and Scalar ALU (Arithmetic Logic Unit) for scalar operations.
-
-In the center, there are two caches:
-- Scalar Cache for storing scalar data.
-- Shader Instruction Cache for storing shader instructions.
-
-On the right side, there are two identical blocks labeled "Scheduler," each containing:
-- Scalar GPR and Scalar ALU.
-- Vector GPR for similar operations as the left side.
-- AI MATRIX Accelerator and DPFP unit.
-
-Adjacent to these blocks is a section labeled "Shared Memory," which is used for data exchange between different processing units.
-
-Finally, on the far right, there are components for handling graphics-specific tasks:
-- Ray Accelerator for ray tracing operations.
-- Texture Filters for texture processing.
-- LD/ST/Tex Addr for load/store and texture addressing.
-- L0 cache for fast data access.
-
-The diagram uses red to highlight the functional units and white for the cache and shared memory areas, indicating a focus on computational and memory management capabilities within the GPU architecture.
-
-![Image](hip_spec-with-image-refs_artifacts/image_000000_5208c655dc4611802372524b387216259e5e5c3c192ee9dd1c1c8e76383cd3f6.png)
-
-Fig. 2: Block Diagram of a CDNA3 Compute Unit.
-
-The image depicts a horizontal bar chart titled "Local Data Share." The chart is divided into two main sections: the left section and the right section.
-
-### Left Section:
-- **Title:** "Local Data Share"
-- **X-axis:** Labeled "Schedule"
-- **Y-axis:** Labeled "Matrix Core Unit"
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
--
-
-**Image description:** The image depicts a horizontal bar chart titled "Local Data Share." The chart is divided into two main sections: the left section and the right section.
-
-### Left Section:
-- **Title:** "Local Data Share"
-- **X-axis:** Labeled "Schedule"
-- **Y-axis:** Labeled "Matrix Core Unit"
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
--
-
-![Image](hip_spec-with-image-refs_artifacts/image_000001_bfcf0651eef1f236f619420b33a1d732aeb71e35bd879a965fdc6375d5204886.png)
-
-## 4.2 Heterogeneous Programming
-
-The HIP programming model assumes two execution contexts. One is referred to as host while compute kernels execute on a device . These contexts have different capabilities, therefor slightly different rules apply. The host execution is defined by the C++ abstract machine, while device execution follows the SIMT model of HIP. These execution contexts in code are signified by the \_\_host\_\_ and \_\_device\_\_ decorators. There are a few key differences between the two:
-
-- The C++ abstract machine assumes a unified memory address space, meaning that one can always access any given address in memory (assuming the absence of data races). HIP however introduces several memory namespaces, an address from one means nothing in another. Moreover, not all address spaces are accessible from all contexts.
-- Looking at Block Diagram of an RDNA3 Compute Unit. and Block Diagram of a CDNA3 Compute Unit. , you can see that every CU has an instance of storage backing the namespace \_\_shared\_\_ . Even if the host were to have access to these regions of memory, the performance benefits of the segmented memory subsystem are supported by the inability of asynchronous access from the host.
-- Not all C++ language features map cleanly to typical device architectures, some are very expensive (meaning slow) to implement on GPU devices, therefor they are forbidden in device contexts to avoid users tapping into features that unexpectedly decimate their program's performance. Offload devices targeted by HIP aren't general purpose devices, at least not in the sense that a CPU is. HIP focuses on data parallel computations and as such caters to throughput optimized architectures, such as GPUs or accelerators derived from GPU architectures.
-- Asynchrony is at the forefront of the HIP API. Computations launched on the device execute asynchronously with respect to the host, and it is the user's responsibility to synchronize their data dispatch/fetch with computations on the device.
-
-Note: HIP does perform implicit synchronization on occasions, more advanced than other APIs such as OpenCL or SYCL, in which the responsibility of synchronization mostly depends on the user.
-
-## 4.3 Single instruction multiple threads (SIMT)
-
-The SIMT programming model behind the HIP device-side execution is a middle-ground between SMT (Simultaneous Multi-Threading) programming known from multicore CPUs, and SIMD (Single Instruction, Multiple Data) programming mostly known from exploiting relevant instruction sets on CPUs (for example SSE/AVX/Neon).
-
-A HIP device compiler maps SIMT code written in HIP C++ to an inherently SIMD architecture (like GPUs). This is done by scalarizing the entire kernel and issuing the scalar instructions of multiple kernel instances (called threads) to each of the SIMD engine lanes, rather than exploiting data parallelism within a single instance of a kernel and spreading identical instructions over the available SIMD engines.
-
-Consider the following kernel:
-**Following code does:** The code snippet appears to be a fragment of a documentation header or title, rather than executable code. It likely indicates the version of a software release, specifically version 6.1.40092, for a project or product abbreviated as "HIP." This kind of line is typically used to label or identify the version of documentation associated with a particular release of the software.
-
-
-```
-__global__ void k(float4* a, const float4* b)
-{
-  int tid = threadIdx.x;
-  int bid = blockIdx.x;
-  int dim = blockDim.x;
-
-  a[tid] += (tid + bid - dim) * b[tid];
-}
-```
-
-The incoming four-vector of floating-point values b is multiplied by a scalar and then added element-wise to the fourvector floating-point values of a . On modern SIMD-capable architectures, the four-vector ops are expected to compile to a single SIMD instruction. However, GPU execution of this kernel will typically break down the vector elements into 4 separate threads for parallel execution, as seen in the following figure:
-
-Fig. 3: Instruction flow of the sample SIMT program.
-
-In HIP, lanes of the SIMD architecture are fed by mapping threads of a SIMT execution, one thread down each lane of an SIMD engine. Execution parallelism usually isn't exploited from the width of the built-in vector types, but across multiple threads via the thread ID constants threadIdx.x , blockIdx.x , etc.
-
-## 4.4 Inherent thread model
-
-The SIMT nature of HIP is captured by the ability to execute user-provided device programs, expressed as single-source C/C++ functions or sources compiled online/offline to binaries, in bulk.
-
-All threads of a kernel are uniquely identified by a set of integral values, called thread IDs. The set of integers identifying a thread relate to the hierarchy in which the threads execute.
-
-The thread hierarchy inherent to how AMD GPUs operate is depicted in the following figure.
-
-Fig. 4: Hierarchy of thread groups.
-
-## Warp (or Wavefront)
-
-The innermost grouping of threads is called a warp, or a wavefront in ISA terms. A warp is the most tightly coupled groups of threads, both physically and logically. Threads inside a warp are also called lanes, and the integral value identifying them is the lane ID.
-
-Tip: Lane IDs aren't queried like other thread IDs, but are user-calculated. As a consequence, they are only as multidimensional as the user interprets the calculated values to be.
-
-The size of a warp is architecture dependent and always fixed. For AMD GPUs the wavefront is typically 64 threads, though sometimes 32 threads. Warps are signified by the set of communication primitives at their disposal, as discussed in Warp cross-lane functions .
-
-The middle grouping is called a block or thread block. The defining feature of a block is that all threads in a block will share an instance of memory which they may use to share data or synchronize with one another.
-
-The size of a block is user-configurable but is limited by the queryable capabilities of the executing hardware. The unique ID of the thread within a block is 3-dimensional as provided by the API. When linearizing thread IDs within a block, assume the 'fast index' being dimension x , followed by the y and z dimensions.
-
-## Block
-
-## Grid
-
-The outermost grouping is called a grid. A grid manifests as a single dispatch of kernels for execution. The unique ID of each block within a grid is 3-dimensional, as provided by the API and is queryable by every thread within the block.
-
-## 4.4.1 Cooperative groups thread model
-
-The Cooperative groups API introduces new APIs to launch, group, subdivide, synchronize and identify threads, as well as some predefined group-collective algorithms, but most importantly a matching threading model to think in terms of. It relaxes some restrictions of the Inherent thread model imposed by the strict 1:1 mapping of architectural details to the programming model. Cooperative groups let you define your own set of thread groups which may fit your user-cases better than the defaults defined by the hardware.
-
-Note: The implicit groups defined by kernel launch parameters are still available when working with cooperative groups.
-
-For further information, see Cooperative groups.
-
-## 4.5 Memory model
-
-The hierarchy of threads introduced by the Inherent thread model is induced by the memory subsystem of GPUs. The following figure summarizes the memory namespaces and how they relate to the various levels of the threading model.
-
-Fig. 5: Memory hierarchy.
-
-## Local or per-thread memory
-
-Read-write storage only visible to the threads defining the given variables, also called per-thread memory. The size of a block for a given kernel, and thereby the number of concurrent warps, are limited by local memory usage. This relates to an important aspect: occupancy. This is the default memory namespace.
-
-## Shared memory
-
-Read-write storage visible to all the threads in a given block.
-
-## Global
-
-Read-write storage visible to all threads in a given grid. There are specialized versions of global memory with different usage semantics which are typically backed by the same hardware storing global.
-
-## Constant
-
-Read-only storage visible to all threads in a given grid. It is a limited segment of global with queryable size.
-
-## Texture
-
-Read-only storage visible to all threads in a given grid and accessible through additional APIs.
-
-## Surface
-
-A read-write version of texture memory.
-
-## 4.6 Execution model
-
-HIP programs consist of two distinct scopes:
-
-- The host-side API running on the host processor. There are two APIs available:
-- -The HIP runtime API which enables use of the single-source programming model.
-- -The HIP driver API which sits at a lower level and most importantly differs by removing some facilities provided by the runtime API, most importantly around kernel launching and argument setting. It is geared towards implementing abstractions atop, such as the runtime API itself. Offers two additional pieces of functionality not provided by the Runtime API: hipModule and hipCtx APIs. For further details, check HIP driver API.
-- The device-side kernels running on GPUs. Both the host and the device-side APIs have synchronous and asynchronous functions in them.
-
-Note: The HIP does not present two separate APIs link NVIDIA CUDA. HIP only extends the HIP runtime API with new APIs for hipModule and hipCtx .
-
-## 4.6.1 Host-side execution
-
-The part of the host-side API which deals with device management and their queries are synchronous. All asynchronous APIs, such as kernel execution, data movement and potentially data allocation/freeing all happen in the context of device streams.
-
-Streams are FIFO buffers of commands to execute relating to a given device. Commands which enqueue tasks on a stream all return promptly and the command is executed asynchronously. All side effects of a command on a stream are visible to all subsequent commands on the same stream. Multiple streams may point to the same device and those streams may be fed from multiple concurrent host-side threads. Execution on multiple streams may be concurrent but isn't required to be.
-
-Asynchronous APIs involving a stream all return a stream event which may be used to synchronize the execution of multiple streams. A user may enqueue a barrier onto a stream referencing an event. The barrier will block until the command related to the event does not complete, at which point all side effects of the command shall be visible to commands following the barrier, even if those side effects manifest on different devices.
-
-Streams also support executing user-defined functions as callbacks on the host. The stream will not launch subsequent commands until the callback completes.
-
-## 4.6.2 Device-side execution
-
-The SIMT programming model behind the HIP device-side execution is a middle-ground between SMT (Simultaneous Multi-Threading) programming known from multicore CPUs, and SIMD (Single Instruction, Multiple Data) programming mostly known from exploiting relevant instruction sets on CPUs (for example SSE/AVX/Neon).
-
-## 4.6.3 Kernel launch
-
-Kernels may be launched in multiple ways all with different syntaxes and intended use-cases.
-
-- Using the triple-chevron &lt;&lt;&lt;...&gt;&gt;&gt; operator on a \_\_global\_\_ annotated function.
-- Using hipLaunchKernelGGL() on a \_\_global\_\_ annotated function.
-
-Tip: This name by default is a macro expanding to triple-chevron. In cases where language syntax extensions are undesirable, or where launching templated and/or overloaded kernel functions define the HIP\_TEMPLATE\_KERNEL\_LAUNCH preprocessor macro before including the HIP headers to turn it into a templated function.
-
-- Using the launch APIs supporting the triple-chevron syntax directly.
-
-Caution: These APIs are intended to be used/generated by tools such as the HIP compiler itself and not intended towards end-user code. Should you be writing a tool having to launch device code using HIP, consider using these over the alternatives.
-
-## HARDWARE IMPLEMENTATION
-
-This chapter describes the typical hardware implementation of GPUs supported by HIP, and how the Inherent thread model maps to the hardware.
-
-## 5.1 Compute units
-
-The basic building block of a GPU is a compute unit (CU), also known as streaming multiprocessor (SM) on NVIDIA GPUs. The thread blocks making up a grid are scheduled for execution on CUs. Each block is assigned to an individual CU, and a CU can accommodate several blocks. Depending on their resource usage up to thousands of threads can reside on a CU.
-
-CUs contain an array of processing elements, referred to as vector ALU (VALU), that execute the actual instructions of the threads according to the SIMT model , together with the necessary registers and caches.
-
-The threads are executed in groupings called warps. The amount of threads making up a warp is architecture dependent. On AMD GPUs the warp size is commonly 64 threads, except in RDNA architectures which can utilize a warp size of 32 or 64 respectively. The warp size of supported AMD GPUs is listed in the Accelerator and GPU hardware specifications. NVIDIA GPUs have a warp size of 32.
-
-In contrast to CPUs, GPUs generally do not employ complex cache structures or control logic, like branch prediction or out-of-order execution, but instead rely on massive hardware multithreading to hide latency.
-
-Context switching between warps residing on a CU incurs no overhead, as the context for the warps is stored on the CU and does not need to be fetched from memory. If there are not enough free registers to accommodate all warps of a block, the block can not be scheduled to that CU and it has to wait until other blocks finish execution.
-
-The amount of warps that can reside concurrently on a CU, known as occupancy, is determined by the warp's resource usage of registers and shared memory.
-
-Fig. 1: An AMD Graphics Core Next (GCN) CU. The CDNA and RDNA CUs are based on variations of the GCN CU.
-
-On AMD GCN GPUs the basic structure of a CU is:
-
-- four Single Instruction Multiple Data units (SIMDs)
-- a vector cache
-- a local data share
-- and a scalar unit
-
-## 5.1.1 SIMD
-
-A SIMD consists of a VALU, that executes the instruction of a warp, together with a register file, that provides the registers warps.
-
-The size of the warp is inherently related to the width of the vector ALU of the SIMD. On GCN compute units the width of the VALU is 16, so a warp can be issued to a SIMD every 4 cycles. Since a CU has 4 SIMDs it issues one warp per cycle. The instructions of a warp are effectively executed in lock-step.
-
-A SIMD always executes the same instruction for the whole VALU. If the control flow of a warp diverges, the performance is decreased, as the results for the threads that do not participate in that branch have to be masked out, and the instructions of the other branch have to be executed in the same way. The best performance can therefore be achieved when thread divergence is kept to a warp level, i.e. when all threads in a warp take the same execution path.
-
-## 5.1.2 Vector cache
-
-The usage of cache on a GPU differs from that on a CPU, as there is less cache available per thread. Its main purpose is to coalesce memory accesses of the warps in order to reduce the amount of accesses to device memory, and make that memory available for other warps that currently reside on the compute unit, that also need to load those values.
-
-## 5.1.3 Local data share
-
-The local data share is memory that is accessible to all threads within a block. Its latency and bandwidth is comparable to that of the vector cache. It can be used to share memory between the threads in a block, or as a software managed cache.
-
-## 5.1.4 Scalar Unit
-
-The scalar unit performs instructions that are uniform within a warp. It thereby improves efficiency and reduces the pressure on the vector ALUs and the vector register file.
-
-## 5.2 CDNA architecture
-
-The general structure of CUs stays mostly as it is in GCN architectures. The most prominent change is the addition of matrix ALUs, which can greatly improve the performance of algorithms involving matrix multiply-accumulate operations for int8, float16, bfloat16 or float32.
-
-Fig. 2: Block Diagram of a CDNA3 Compute Unit.
-
-The image depicts a horizontal bar chart titled "Local Data Share." The chart is divided into two main sections: the left section and the right section.
-
-### Left Section:
-- **Title:** Local Data Share
-- **X-Axis:** Labeled as "Scheduler" and "Matrix Core Unit"
-- **Y-Axis:** Labeled as "Local Data Share"
-- **Data Points:**
-  - **Leftmost Data Point:** 100
-  - **Rightmost Data Point:** 100
-  - **Leftmost Data Point:** 100
-  - **Rightmost Data Point:** 100
-
-### Right Section:
-- **Title:** Shader Core
-- **X-Axis:** Labeled as "L1 Cache"
-- **Y-Axis:** Labeled as "Shader Core"
-- **Data Points:**
-  - **Leftmost Data Point:** 100
-  - **Rightmost
-
-**Image description:** The image depicts a horizontal bar chart titled "Local Data Share." The chart is divided into two main sections: the left section and the right section.
-
-### Left Section:
-- **Title:** Local Data Share
-- **X-Axis:** Labeled as "Scheduler" and "Matrix Core Unit"
-- **Y-Axis:** Labeled as "Local Data Share"
-- **Data Points:**
-  - **Leftmost Data Point:** 100
-  - **Rightmost Data Point:** 100
-  - **Leftmost Data Point:** 100
-  - **Rightmost Data Point:** 100
-
-### Right Section:
-- **Title:** Shader Core
-- **X-Axis:** Labeled as "L1 Cache"
-- **Y-Axis:** Labeled as "Shader Core"
-- **Data Points:**
-  - **Leftmost Data Point:** 100
-  - **Rightmost
-
-![Image](hip_spec-with-image-refs_artifacts/image_000002_cfbddcc77ec59fe03ed26460c2aa6a54c9646387476d59ddc5eaabf5c6641187.png)
-
-## 5.3 RDNA architecture
-
-RDNA makes a fundamental change to CU design, by changing the size of a warp to 32 threads. This is done by effectively combining two GCN5 SIMDs, creating a VALU of width 32, so that a whole warp can be issued in one cycle. The CU is also replaced by the work group processor (WGP), which encompasses two CUs. For backwards compatibility the WGP can also run in wave64 mode, in which it issues a warp of size 64 in two cycles.
-
-It also adds an extra layer of cache to the WGP, shared by the CUs within it. This cache is referred to as L1 cache, promoting the per-CU cache to an L0 cache.
-
-Fig. 3: Block Diagram of an RDNA3 work group processor.
-
-Scheduler Vector GPR.
-
-**Image description:** The image is a block diagram illustrating the architecture of a graphics processing unit (GPU) or a similar parallel processing unit. The diagram is divided into two main sections, each representing a compute unit with various components.
-
-Each compute unit contains:
-- **Scheduler**: Manages the execution of instructions.
-- **Vector GPR (General Purpose Registers)**: Handles vector operations with components like "Float/INT/Matrix SIMD32" for single instruction, multiple data operations, "AI MATRIX Accelerator" for AI-related tasks, and "Transcendental SIMD8" for complex mathematical functions.
-- **Scalar GPR**: Manages scalar operations.
-- **Scalar ALU (Arithmetic Logic Unit)**: Performs arithmetic and logical operations on scalar data.
-- **DPFP (Double Precision Floating Point)**: Indicates support for double precision calculations.
-
-The central part of the diagram shows:
-- **Scalar Cache** and **Shader Instruction Cache**: These are shared resources for storing scalar data and shader instructions, respectively.
-
-On the right side of the diagram:
-- **Shared Memory**: A memory space accessible by all units for efficient data sharing.
-- **Ray Accelerator**: Dedicated hardware for accelerating ray tracing operations.
-- **LD/ST/Tex Addr**: Likely stands for Load/Store/Texture Address, handling memory operations and texture addressing.
-- **Texture Filters**: Processes texture data for rendering.
-- **L0**: Possibly indicates a level of cache or memory hierarchy.
-
-The diagram uses a consistent color scheme with red blocks indicating functional units and white/grey blocks for caches and shared resources. The layout suggests a focus on parallel processing capabilities, with emphasis on both vector and scalar operations, AI acceleration, and ray tracing support.
-
-![Image](hip_spec-with-image-refs_artifacts/image_000003_8ba501e7c1e4fd45f649ac07d48e9985a382fa290507dbd9ebd5ecafa7f23bd2.png)
-
-## 5.4 Shader engines
-
-For hardware implementation's sake, multiple CUs are grouped together into a Shader Engine or Compute Engine, typically sharing some fixed function units or memory subsystem resources.
-
-Fig. 4: Block Diagram of a CDNA2 Graphics Compute Die.
-
-The image is a table that contains data about different types of fabric. The table is divided into rows and columns, with each row representing a different type of fabric. The columns are labeled as follows:
-
-- Memory
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-
-**Image description:** The image is a table that contains data about different types of fabric. The table is divided into rows and columns, with each row representing a different type of fabric. The columns are labeled as follows:
-
-- Memory
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-
-![Image](hip_spec-with-image-refs_artifacts/image_000004_b494ff70840b694ceb0cb8c49613faf77041d4148e4ceb04903608a8022e3cbd.png)
-
-## CHAPTER
-
-## SIX
-
-## AMD COMMON LANGUAGE RUNTIMES (CLR)
-
-CLRcontains source codes for AMD's compute languages runtimes: HIP and OpenCL ™ . CLR is the part of HIP runtime which is supported on the AMD ROCm platform, it provides a header and runtime library built on top of HIP-Clang compiler. For developers and users, CLR implements HIP runtime APIs including streams, events, and memory APIs, which is a object library that is linked with the application. The source codes for all headers and the library implementation are available on GitHub in the CLR repository.
-
-## 6.1 Project organization
-
-CLR includes the following source code,
-
-- hipamd - contains implementation of HIP language on the AMD platform. It is hosted at clr/hipamd.
-- opencl - contains implementation of OpenCL™ on AMD platform. It is hosted at clr/opencl.
-- rocclr - contains common runtime used in HIP and OpenCL™ . This is hosted at clr/rocclr.
-
-## 6.2 How to build/install
-
-## 6.2.1 Prerequisites
-
-Please refer to Quick Start Guide in ROCm Docs.
-
-Building CLR requires rocm-hip-libraries meta package, which provides the pre-requisites for CLR.
-
-## 6.2.2 Linux
-
-- Clone this repository
-- For OpenCL ™
-**Following code does:** The provided code snippet appears to be a series of closing curly braces (`}`) with no accompanying opening braces or any other code. In most programming languages, such as C, C++, Java, or JavaScript, curly braces are used to define blocks of code, such as functions, loops, or conditional statements. However, without any opening braces or context, this snippet does not perform any meaningful operation or represent a valid code structure. It is likely incomplete or incorrectly formatted.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        * For HIP
-```
-**Following code does:** This code snippet is written in C++ and is used to compile a HIP (Heterogeneous-Compute Interface for Portability) runtime compilation program. It sets up a compilation option for the program by creating a string `sarg` with the value "-fgpu-rdc", which is a flag typically used to enable relocatable device code in GPU programming. This string is then converted to a C-style string and stored in an array `options`. The `hiprtcCompileProgram` function is called with the program `prog`, specifying that there is one compilation option, and passing the `options` array to apply the "-fgpu-rdc" flag during the compilation process.
-
-
-```
-<_Bash_>
-```
-**Following code does:** This code snippet is used to retrieve the compiled bitcode of a HIP (Heterogeneous-Compute Interface for Portability) program. It first determines the size of the bitcode using `hiprtcGetBitcodeSize`, storing the size in `bitCodeSize`. Then, it creates a vector `kernel_bitcode` of the appropriate size to hold the bitcode. Finally, it retrieves the actual bitcode from the program `prog` and stores it in the `kernel_bitcode` vector using `hiprtcGetBitcode`. This process is typically part of compiling and managing GPU kernels in a HIP runtime environment.
-
-
-```
-<_Haskell_>
-```
-
-Users can also build OCL and HIP at the same time by passing -DCLR\_BUILD\_HIP=ON -DCLR\_BUILD\_OCL=ON to configure command.
-
-For detail instructions, please refer to build HIP.
-
-## 6.2.3 Test
-
-hip-tests is a separate repository hosted at hip-tests.
-
-To run hip-tests please go to the repository and follow the steps.
-
-## 6.2.4 Release notes
-
-HIP provides release notes in CLR change log, which has records of changes in each release.
-
-## 7.1 Host Memory
-
-## 7.1.1 Introduction
-
-hipHostMalloc allocates pinned host memory which is mapped into the address space of all GPUs in the system, the memory can be accessed directly by the GPU device, and can be read or written with much higher bandwidth than pageable memory obtained with functions such as malloc() . There are two use cases for this host memory:
-
-- Faster HostToDevice and DeviceToHost Data Transfers: The runtime tracks the hipHostMalloc allocations and can avoid some of the setup required for regular unpinned memory. For exact measurements on a specific system, experiment with --unpinned and --pinned switches for the hipBusBandwidth tool.
-- Zero-Copy GPU Access: GPU can directly access the host memory over the CPU/GPU interconnect, without need to copy the data. This avoids the need for the copy, but during the kernel access each memory access must traverse the interconnect, which can be tens of times slower than accessing the GPU's local device memory. Zerocopy memory can be a good choice when the memory accesses are infrequent (perhaps only once). Zero-copy memory is typically 'Coherent' and thus not cached by the GPU but this can be overridden if desired.
-
-## 7.1.2 Memory allocation flags
-
-There are flags parameter which can specify options how to allocate the memory, for example, hipHostMallocPortable , the memory is considered allocated by all contexts, not just the one on which the allocation is made. hipHostMallocMapped , will map the allocation into the address space for the current device, and the device pointer can be obtained with the API hipHostGetDevicePointer() . hipHostMallocNumaUser is the flag to allow host memory allocation to follow Numa policy by user. Please note this flag is currently only applicable on Linux, under development on Windows.
-
-All allocation flags are independent, and can be used in any combination without restriction, for instance, hipHostMalloc can be called with both hipHostMallocPortable and hipHostMallocMapped flags set. Both usage models described above use the same allocation flags, and the difference is in how the surrounding code uses the host memory.
-
-## HIP PROGRAMMING MANUAL
-
-## 7.1.3 Numa-aware host memory allocation
-
-Numa policy determines how memory is allocated. Target of Numa policy is to select a CPU that is closest to each GPU. Numa distance is the measurement of how far between GPU and CPU devices.
-
-By default, each GPU selects a Numa CPU node that has the least Numa distance between them, that is, host memory will be automatically allocated closest on the memory pool of Numa node of the current GPU device. Using hipSetDevice API to a different GPU will still be able to access the host allocation, but can have longer Numa distance. Note, Numa policy is so far implemented on Linux, and under development on Windows.
-
-## 7.1.4 Coherency Controls
-
-ROCm defines two coherency options for host memory:
-
-- Coherent memory : Supports fine-grain synchronization while the kernel is running. For example, a kernel can perform atomic operations that are visible to the host CPU or to other (peer) GPUs. Synchronization instructions include threadfence\_system and C++11-style atomic operations. In order to achieve this fine-grained coherence, many AMD GPUs use a limited cache policy, such as leaving these allocations uncached by the GPU, or making them read-only.
-- Non-coherent memory : Can be cached by GPU, but cannot support synchronization while the kernel is running. Non-coherent memory can be optionally synchronized only at command (end-of-kernel or copy command) boundaries. This memory is appropriate for high-performance access when fine-grain synchronization is not required.
-
-HIP provides the developer with controls to select which type of memory is used via allocation flags passed to hipHostMalloc and the HIP\_HOST\_COHERENT environment variable. By default, the environment variable HIP\_HOST\_COHERENT is set to 0 in HIP. The control logic in the current version of HIP is as follows:
-
-- No flags are passed in: the host memory allocation is coherent, the HIP\_HOST\_COHERENT environment variable is ignored.
-- hipHostMallocCoherent=1 : The host memory allocation will be coherent, the HIP\_HOST\_COHERENT environment variable is ignored.
-- hipHostMallocMapped=1 : The host memory allocation will be coherent, the HIP\_HOST\_COHERENT environment variable is ignored.
-- hipHostMallocNonCoherent=1 , hipHostMallocCoherent=0 , and hipHostMallocMapped=0 : The host memory will be non-coherent, the HIP\_HOST\_COHERENT environment variable is ignored.
-- hipHostMallocCoherent=0 , hipHostMallocNonCoherent=0 , hipHostMallocMapped=0 , but one of the other HostMalloc flags is set:
-- -If HIP\_HOST\_COHERENT is defined as 1, the host memory allocation is coherent.
-- -If HIP\_HOST\_COHERENT is not defined, or defined as 0, the host memory allocation is non-coherent.
-- hipHostMallocCoherent=1 , hipHostMallocNonCoherent=1 : Illegal.
-
-## 7.1.5 Visibility of Zero-Copy Host Memory
-
-Coherent host memory is automatically visible at synchronization points. Non-coherent
-
-| HIP API Synchronization Effect                                                                        | Fence                 | Coherent Memory ity   | Host Visibil-   | Non-Coherent Host Memory Visi- bility   |
-|-------------------------------------------------------------------------------------------------------|-----------------------|-----------------------|-----------------|-----------------------------------------|
-| hipStreamSynchronize host waits for all commands in the spec- ified stream to complete                | system- scope release | yes                   |                 | yes                                     |
-| hipDeviceSynchronize host waits for all commands in all streams on the specified device to com- plete | system- scope release | yes                   |                 | yes                                     |
-| hipEventSynchronize host waits for the specified event to com- plete                                  | device- scope release | yes                   |                 | depends - see below                     |
-| hipStreamWaitEvent stream waits for the specified event to complete                                   | none                  | yes                   |                 | no                                      |
-
-## 7.1.6 hipEventSynchronize
-
-Developers can control the release scope for hipEvents :
-
-- By default, the GPU performs a device-scope acquire and release operation with each recorded event. This will make host and device memory visible to other commands executing on the same device.
-
-A stronger system-level fence can be specified when the event is created with hipEventCreateWithFlags :
-
-- hipEventReleaseToSystem : Perform a system-scope release operation when the event is recorded. This will make both Coherent and Non-Coherent host memory visible to other agents in the system, but may involve heavyweight operations such as cache flushing. Coherent memory will typically use lighter-weight in-kernel synchronization mechanisms such as an atomic operation and thus does not need to use hipEventReleaseToSystem .
-- hipEventDisableTiming : Events created with this flag will not record profiling data and provide the best performance if used for synchronization.
-
-## 7.1.7 Summary and Recommendations
-
-- Coherent host memory is the default and is the easiest to use since the memory is visible to the CPU at typical synchronization points. This memory allows in-kernel synchronization commands such as threadfence\_system to work transparently.
-- HIP/ROCm also supports the ability to cache host memory in the GPU using the 'Non-Coherent' host memory allocations. This can provide performance benefit, but care must be taken to use the correct synchronization.
-
-## 7.1.8 Managed memory allocation
-
-Managed memory, including the \_\_managed\_\_ keyword, is supported in HIP combined host/device compilation, on Linux, not on Windows (under development).
-
-Managed memory, via unified memory allocation, allows data be shared and accessible to both the CPU and GPU using a single pointer. The allocation will be managed by AMD GPU driver using the Linux HMM (Heterogeneous Memory Management) mechanism, the user can call managed memory API hipMallocManaged to allocate a large chunk of HMMmemory, execute kernels on device and fetch data between the host and device as needed.
-
-In HIP application, it is recommended to do the capability check before calling the managed memory APIs. For example:
-**Following code does:** It seems there is a formatting error in your request. The code snippet is labeled as C++ but is enclosed within Python code tags. Please provide the correct code snippet or clarify the language so I can assist you accurately.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?>                                                                                                                                                                                                        </?>
-```
-
-Please note, the managed memory capability check may not be necessary, but if HMM is not supported, then managed malloc will fall back to using system memory and other managed memory API calls will have undefined behavior.
-
-Note, managed memory management is implemented on Linux, not supported on Windows yet.
-
-## 7.1.9 HIP Stream Memory Operations
-
-HIP supports Stream Memory Operations to enable direct synchronization between Network Nodes and GPU. Following new APIs are added, hipStreamWaitValue32 hipStreamWaitValue64 hipStreamWriteValue32 hipStreamWriteValue64
-
-Note, CPU access to the semaphore's memory requires volatile keyword to disable CPU compiler's optimizations on memory access. For more details, please check the documentation HIP-API.pdf .
-
-Please note, HIP stream does not guarantee concurrency on AMD hardware for the case of multiple (at least 6) longrunning streams executing concurrently, using hipStreamSynchronize(nullptr) for synchronization.
-
-## 7.2 Direct Dispatch
-
-HIP runtime has Direct Dispatch enabled by default in ROCM 4.4 on Linux. With this feature we move away from our conventional producer-consumer model where the runtime creates a worker thread(consumer) for each HIP Stream, and the host thread(producer) enqueues commands to a command queue(per stream).
-
-For Direct Dispatch, HIP runtime would directly enqueue a packet to the AQL queue (user mode queue on GPU) on the Dispatch API call from the application. That has shown to reduce the latency to launch the first wave on the idle GPU and total time of tiny dispatches synchronized with the host.
-
-In addition, eliminating the threads in runtime has reduced the variance in the dispatch numbers as the thread scheduling delays and atomics/locks synchronization latencies are reduced.
-
-This feature can be disabled via setting the following environment variable, AMD\_DIRECT\_DISPATCH=0
-
-Note, Direct Dispatch is implemented on Linux. It is currently not supported on Windows.
-
-## 7.3 HIP Runtime Compilation
-
-HIP now supports runtime compilation (HIP RTC), the usage of which will provide the possibility of optimizations and performance improvement compared with other APIs via regular offline static compilation.
-
-HIP RTC APIs accept HIP source files in character string format as input parameters and create handles of programs by compiling the HIP source files without spawning separate processes.
-
-For more details on HIP RTC APIs, refer to HIP Runtime API Reference .
-
-For Linux developers, the link here shows an example how to program HIP application using runtime compilation mechanism, and a detailed HIP RTC programming guide is also available.
-
-## 7.4 HIP Graph
-
-HIP graph is supported. For more details, refer to the HIP API Guide.
-
-## 7.5 Device-Side Malloc
-
-HIP-Clang now supports device-side malloc and free. This implementation does not require the use of hipDeviceSetLimit(hipLimitMallocHeapSize,value) nor respects any setting. The heap is fully dynamic and can grow until the available free memory on the device is consumed.
-
-## 7.6 Use of Per-thread default stream
-
-The per-thread default stream is supported in HIP. It is an implicit stream local to both the thread and the current device. This means that the command issued to the per-thread default stream by the thread does not implicitly synchronize with other streams (like explicitly created streams), or default per-thread stream on other threads. The per-thread default stream is a blocking stream and will synchronize with the default null stream if both are used in a program. The per-thread default stream can be enabled via adding a compilation option, -fgpu-default-stream=per-thread .
-
-And users can explicitly use hipStreamPerThread as per-thread default stream handle as input in API commands. There are test codes as examples in the link.
-
-## 7.7 Use of Long Double Type
-
-In HIP-Clang, long double type is 80-bit extended precision format for x86\_64, which is not supported by AMDGPU. HIP-Clang treats long double type as IEEE double type for AMDGPU. Using long double type in HIP source code will not cause issue as long as data of long double type is not transferred between host and device. However, long double type should not be used as kernel argument type.
-
-## 7.8 Use of \_Float16 Type
-
-If a host function is to be used between clang (or hipcc) and gcc for x86\_64, i.e. its definition is compiled by one compiler but the caller is compiled by a different compiler, \_Float16 or aggregates containing \_Float16 should not be used as function argument or return type. This is due to lack of stable ABI for \_Float16 on x86\_64. Passing \_Float16 or aggregates containing \_Float16 between clang and gcc could cause undefined behavior.
-
-## 7.9 FMA and contractions
-
-By default HIP-Clang assumes -ffp-contract=fast-honor-pragmas . Users can use #pragma clang fp contract(on|off|fast) to control fp contraction of a block of code. For x86\_64, FMA is off by default since the generic x86\_64 target does not support FMA by default. To turn on FMA on x86\_64, either use -mfma or -march=native on CPU's supporting FMA.
-
-When contractions are enabled and the CPU has not enabled FMA instructions, the GPU can produce different numerical results than the CPU for expressions that can be contracted. Tolerance should be used for floating point comparisons.
-
-## 7.10 Math functions with special rounding modes
-
-Note: Currently, HIP only supports basic math functions with rounding modern (round to nearest). HIP does not support basic math functions with rounding modes ru (round up), rd (round down), and rz (round towards zero).
-
-## 7.11 Creating Static Libraries
-
-HIP-Clang supports generating two types of static libraries. The first type of static library does not export device functions, and only exports and launches host functions within the same library. The advantage of this type is the ability to link with a non-hipcc compiler such as gcc. The second type exports device functions to be linked by other code objects. However, this requires using hipcc as the linker.
-
-In addition, the first type of library contains host objects with device code embedded as fat binaries. It is generated using the flag -emit-static-lib. The second type of library contains relocatable device objects and is generated using ar .
-
-Here is an example to create and use static libraries:
-
-- Type 1 using --emit-static-lib :
-- Type 2 using system ar :
-**Following code does:** This code snippet is a function call to `hiprtcLinkAddData`, which is part of the HIPRTC (Heterogeneous Interface for Portability Runtime Compilation) API. The function is used to add input data, such as bitcode or other types of data, to a HIPRTC link state object. This is typically part of a process to compile or link GPU code at runtime. The parameters specify the link state object, the type and size of the input data, an optional name for the input, and any options or option values that might be applied to this input. In this case, no options or option values are provided.
-
-
-```
-<_Bash_>
-```
-**Following code does:** This code snippet is a function call to `hiprtcLinkAddFile`, which is part of the HIPRTC (Heterogeneous-Compute Interface for Portability Runtime Compilation) API. The function is used to add a file to the HIPRTC link state. Specifically, it adds a file containing input data or bitcode to the current link state, which is a part of the process of compiling and linking GPU code at runtime. The parameters specify the link state, the type of input, the file path to the bitcode, and options related to the input, although in this case, no additional options are provided (indicated by the zero values).
-
-
-```
-hipcc hipDevice.cpp -c -fgpu-rdc -o hipDevice.o
-ar rcsD libHipDevice.a hipDevice.o
-hipcc libHipDevice.a test.cpp -fgpu-rdc -o test.out
-```
-
-For more information, please see HIP samples host functions and device\_functions.
-
-CHAPTER
-
-## EIGHT
-
-## HIP PORTING GUIDE
-
-In addition to providing a portable C++ programming environment for GPUs, HIP is designed to ease the porting of existing CUDA code into the HIP environment. This section describes the available tools and provides practical suggestions on how to port CUDA code and work through common issues.
-
-## 8.1 Porting a New CUDA Project
-
-## 8.1.1 General Tips
-
-- Starting the port on a CUDA machine is often the easiest approach, since you can incrementally port pieces of the code to HIP while leaving the rest in CUDA. (Recall that on CUDA machines HIP is just a thin layer over CUDA, so the two code types can interoperate on NVCC platforms.) Also, the HIP port can be compared with the original CUDA code for function and performance.
-- Once the CUDA code is ported to HIP and is running on the CUDA machine, compile the HIP code using the HIP compiler on an AMD machine.
-- HIP ports can replace CUDA versions: HIP can deliver the same performance as a native CUDA implementation, with the benefit of portability to both NVIDIA and AMD architectures as well as a path to future C++ standard support. You can handle platform-specific features through conditional compilation or by adding them to the open-source HIP infrastructure.
-- Use hipconvertinplace-perl.sh to hipify all code files in the CUDA source directory.
-
-## 8.1.2 Scanning existing CUDA code to scope the porting effort
-
-The hipexamine-perl.sh tool will scan a source directory to determine which files contain CUDA code and how much of that code can be automatically hipified.
-**Following code does:** The code snippet `<_C_>` is not a valid or recognizable Python code. It appears to be a placeholder or a typographical error rather than functional code. Without additional context or correction, it is not possible to determine its purpose or functionality.
-
-
-```
-<_Cuda_>
-```
-
-(continued from previous page)
-**Following code does:** The code snippet appears to be part of a larger program written in C++ that uses the HIP (Heterogeneous-Compute Interface for Portability) API, which is designed for writing portable code that can run on both AMD and NVIDIA GPUs. The specific function call `hipModuleLoadData(&module, bina)` is used to load a compiled GPU module from binary data into the `module` variable. This is typically a step in preparing GPU code for execution, where `bina` represents the binary data of the compiled GPU program.
-
-
-```
-                                                                                                                                                                                                        (continued from previous page)
-```
-
-hipexamine-perl scans each code file (cpp, c, h, hpp, etc.) found in the specified directory:
-
-- Files with no CUDA code ( kmeans.h ) print one line summary just listing the source file name.
-- Files with CUDA code print a summary of what was found - for example the kmeans\_cuda\_kernel.cu file:
-- Interesting information in kmeans\_cuda\_kernel.cu :
-- -How many CUDA calls were converted to HIP (40)
-- -Breakdown of the CUDA functionality used ( dev:0 mem:0 etc). This file uses many CUDA builtins (37) and texture functions (3).
-- -Warning for code that looks like CUDA API but was not converted (0 in this file).
-- -Count Lines-of-Code (LOC) - 185 for this file.
-- hipexamine-perl also presents a summary at the end of the process for the statistics collected across all files. This has similar format to the per-file reporting, and also includes a list of all kernels which have been called. An example from above:
-**Following code does:** The code snippet you provided, `binary);`, appears to be incomplete and does not represent a valid or meaningful Python statement on its own. It seems like it might be a fragment of a larger piece of code or a typographical error. Without additional context or surrounding code, it's not possible to determine its purpose or functionality.
-
-
-```
-<_SQL_>
-```
-**Following code does:** The code snippet `<_Cuda_>` appears to be a placeholder or a symbolic representation rather than actual executable code. In the context of programming, "Cuda" typically refers to NVIDIA's parallel computing platform and application programming interface (API) model, which allows developers to use a CUDA-enabled graphics processing unit (GPU) for general purpose processing. However, without additional context or actual code, it is not possible to determine the specific functionality or purpose of this snippet.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        --event:0                                                                                                                                                                                                        -event:0
-```
-
-## 8.1.3 Converting a project 'in-place'
-**Following code does:** This code snippet is setting up options for a Just-In-Time (JIT) compilation process, likely related to GPU programming using the HIP (Heterogeneous-Compute Interface for Portability) runtime. The `isaopts` array contains command-line options for the LLVM compiler, specifically to set the inline threshold to 1, which influences function inlining decisions during compilation. The `jit_options` vector is initialized with specific JIT options that are likely used to configure the compilation process to include these LLVM options. The `isaoptssize` variable indicates the size of the `isaopts` array, which is used to pass these options to the compiler. Overall, this setup is preparing to customize the behavior of the JIT compiler with specific optimization settings.
-
-
-```
->
-```
-**Following code does:** This code snippet is setting up and initiating a linking process for a HIP (Heterogeneous-Compute Interface for Portability) runtime compilation. It creates an array `lopts` containing pointers to ISA (Instruction Set Architecture) options and their size, which are then used as input parameters for the `hiprtcLinkCreate` function. This function initializes a `hiprtcLinkState` object, `linkstate`, which represents the state of the linking process. The purpose of this code is to configure and start the linking of compiled code for execution on a GPU using HIP.
-
-
-```
-| > hipify-perl --inplace
-```
-
-For each input file FILE, this script will:
-
-- If FILE.prehip file does not exist, copy the original code to a new file with extension .prehip . Then hipify the code file.
-- If FILE.prehip file exists, hipify FILE.prehip and save to FILE.
-
-This is useful for testing improvements to the hipify toolset.
-
-The hipconvertinplace-perl.sh script will perform inplace conversion for all code files in the specified directory. This can be quite handy when dealing with an existing CUDA code base since the script preserves the existing directory structure and filenames - and includes work. After converting in-place, you can review the code to add additional parameters to directory names.
-
-- &gt; hipconvertinplace-perl.sh MY\_SRC\_DIR
-
-## 8.1.4 Library Equivalents
-
-Most CUDA libraries have a corresponding ROCm library with similar functionality and APIs. However, ROCm also provides HIP marshalling libraries that greatly simplify the porting process because they more precisely reflect their CUDAcounterparts and can be used with either the AMD or NVIDIA platforms (see 'Identifying HIP Target Platform' below). There are a few notable exceptions:
-
-- MIOpen does not have a marshalling library interface to ease porting from cuDNN.
-- RCCL is a drop-in replacement for NCCL and implements the NCCL APIs.
-- hipBLASLt does not have a ROCm library but can still target the NVIDIA platform, as needed.
-- EIGEN's HIP support is part of the library.
-
-| CUDA brary   | Li-   | HIP Li- brary   | ROCm Li- brary   | Comment                                                                          |
-|--------------|-------|-----------------|------------------|----------------------------------------------------------------------------------|
-| cuBLAS       |       | hipBLAS         | rocBLAS          | Basic Linear Algebra Subroutines                                                 |
-| cuBLASLt     |       | hip- BLASLt     | N/A              | Basic Linear Algebra Subroutines, lightweight and new flexible API               |
-| cuFFT        |       | hipFFT          | rocFFT           | Fast Fourier Transfer Library                                                    |
-| cuSPARSE     |       | hipSPARSE       | rocSPARSE        | Sparse BLAS + SPMV                                                               |
-| cuSOLVER     |       | hip- SOLVER     | rocSOLVER        | Lapack library                                                                   |
-| AmgX         |       | N/A             | rocALU- TION     | Sparse iterative solvers and preconditioners with algebraic multigrid            |
-| Thrust       |       | N/A             | rocThrust        | C++ parallel algorithms library                                                  |
-| CUB          |       | hipCUB          | rocPRIM          | Low Level Optimized Parallel Primitives                                          |
-| cuDNN        |       | N/A             | MIOpen           | Deep learning Solver Library                                                     |
-| cuRAND       |       | hipRAND         | rocRAND          | Random Number Generator Library                                                  |
-| EIGEN        |       | EIGEN           | N/A              | C++ template library for linear algebra: matrices, vectors, numeri- cal solvers, |
-| NCCL         |       | N/A             | RCCL             | Communications Primitives Library based on the MPI equivalents                   |
-
-## 8.2 Distinguishing Compiler Modes
-
-## 8.2.1 Identifying HIP Target Platform
-
-All HIP projects target either AMD or NVIDIA platform. The platform affects which headers are included and which libraries are used for linking.
-
-- HIP\_PLATFORM\_AMD is defined if the HIP platform targets AMD. Note, HIP\_PLATFORM\_HCC was previously defined if the HIP platform targeted AMD, it is deprecated.
-- HIP\_PLATFORM\_NVDIA is defined if the HIP platform targets NVIDIA. Note, HIP\_PLATFORM\_NVCC was previously defined if the HIP platform targeted NVIDIA, it is deprecated.
-
-## 8.2.2 Identifying the Compiler: hip-clang or NVCC
-
-Often, it's useful to know whether the underlying compiler is HIP-Clang or NVCC. This knowledge can guard platformspecific code or aid in platform-specific performance tuning.
-**Following code does:** It seems like you've provided a placeholder or incomplete code snippet. If you have a specific Python code snippet you'd like me to explain, please provide the actual code, and I'll be happy to help!
-
-
-```
-    #ifdef __HIP_PLATFORM_AMD__
-    // Compiled with HIP-Clang
-    #endif
-```
-**Following code does:** This code snippet is part of a program that uses the HIPRTC (Heterogeneous-Compute Interface for Portability Runtime Compilation) API to compile a GPU program at runtime. It attempts to compile a program represented by `prog` with a single compilation option specified in `opts`. The result of the compilation is stored in `result`. If the compilation fails (i.e., `result` is not `HIPRTC_SUCCESS`), it outputs an error message to the standard output, including the error string corresponding to the failure.
-
-
-```
-#ifdef __HIP_PLATFORM_NVIDIA__
-// Compiled with nvcc
-//  Could be compiling with CUDA language extensions enabled (for example, a ".cu file)
-//  Could be in pass-through mode to an underlying host compile OR (for example, a.cpp_
---file)
-```
-**Following code does:** The code snippet appears to be the beginning of a C++ declaration for a static constant character array named `gpu_program`. This array is likely intended to store a sequence of characters, which could represent a GPU program or shader code. The `static constexpr` keywords suggest that this array is both constant and has static storage duration, meaning its value is fixed at compile time and it is shared across all instances of the class or file in which it is declared. The actual content of the array is not shown in the snippet.
-
-
-```
-        #ifdef __CUDACC__
-        // Compiled with nvcc (CUDA language extensions enabled)
-```
-**Following code does:** This code snippet is written in C++ and is part of a program that likely involves GPU programming, possibly using the HIP runtime for compiling and managing GPU kernels. The code performs the following high-level tasks:
-
-1. It initializes a vector `kernel_name_vec` with strings representing kernel function names or expressions. These names include `&f1`, `N1::N2::f2`, and `f3<int>`, which suggest different ways of referring to functions or templates in C++.
-
-2. It iterates over each element in `kernel_name_vec` and calls the function `hiprtcAddNameExpression` with the current element converted to a C-style string (`c_str()`) and a program object `prog`. This function is likely used to register or associate these kernel names with the program for later compilation or execution on a GPU.
-
-3. It initializes another vector `variable_name_vec` with a single string `&V1`, which might represent a variable name or address that could be used later in the program.
-
-Overall, the code is setting up kernel and possibly variable names for a GPU program, preparing them for further processing or compilation.
-
-
-```
-; enab1ed)
-```
-
-Compiler directly generates the host code (using the Clang x86 target) and passes the code to another host compiler. Thus, they have no equivalent of the \_\_CUDACC\_\_ define.
-
-## 8.2.3 Identifying Current Compilation Pass: Host or Device
-
-NVCCmakestwo passes over the code: one for host code and one for device code. HIP-Clang will have multiple passes over the code: one for the host code, and one for each architecture on the device code. \_\_HIP\_DEVICE\_COMPILE\_\_ is set to a nonzero value when the compiler (HIP-Clang or NVCC) is compiling code for a device inside a \_\_global\_\_ kernel or for a device function. \_\_HIP\_DEVICE\_COMPILE\_\_ can replace #ifdef checks on the \_\_CUDA\_ARCH\_\_ define.
-**Following code does:** This code snippet appears to be part of a loop in C++ (though it is formatted like Python, it is not valid Python syntax). It iterates over a collection named `variable_name_vec`, which is likely a vector or similar container of strings or string-like objects. For each element `x` in this collection, it calls the function `hiprtcAddNameExpression`, passing `prog` and `x.c_str()` as arguments. The purpose of this operation is to add name expressions to a HIPRTC (Heterogeneous-Compute Interface for Portability Runtime Compilation) program, where `prog` is likely a handle or reference to a runtime compilation program, and `x.c_str()` converts the string `x` to a C-style string (null-terminated character array). This is typically used in GPU programming to manage and compile code at runtime.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                        #if __HIP__DEVICE__COMPILE__
-```
-
-Unlike \_\_CUDA\_ARCH\_\_ , the \_\_HIP\_DEVICE\_COMPILE\_\_ value is 1 or undefined, and it doesn't represent the feature capability of the target device.
-
-## 8.2.4 Compiler Defines: Summary
-
-| Define                      | HIP-Clang                                                         | NVCC                                                                                          | Other (GCC, ICC, Clang, etc.)                               |
-|-----------------------------|-------------------------------------------------------------------|-----------------------------------------------------------------------------------------------|-------------------------------------------------------------|
-| HIP-related defines:        |                                                                   |                                                                                               |                                                             |
-| __HIP_PLATFORM_AMD__        | Defined                                                           | Undefined                                                                                     | Defined if targetingAMD platform; undefined oth- erwise     |
-| __HIP_PLATFORM_NVIDIA__     | Undefined                                                         | Defined                                                                                       | Defined if targeting NVIDIA platform; unde- fined otherwise |
-| __HIP_DEVICE_COMPILE__      | 1 if compiling for device; un- defined if compiling for host      | 1 if compiling for device; undefined if compiling for host                                    | Undefined                                                   |
-| __HIPCC__                   | Defined                                                           | Defined                                                                                       | Undefined                                                   |
-| __HIP_ARCH_*                | 0 or 1 depending on feature support (see below)                   | 0 or 1 depending on feature support (see below)                                               | 0                                                           |
-| NVCC- related defines:      |                                                                   |                                                                                               |                                                             |
-| __CUDACC__                  | Defined if source code is compiled by NVCC; unde- fined otherwise | Undefined                                                                                     |                                                             |
-| __NVCC__ Undefined          | Defined                                                           | Undefined                                                                                     |                                                             |
-| __CUDA_ARCH__               | Undefined                                                         | Unsigned representing compute capa- bility (e.g., '130') if in device code; 0 if in host code | Undefined                                                   |
-| hip-clang- related defines: |                                                                   |                                                                                               |                                                             |
-| __HIP__ HIP-Clang common    | Defined                                                           | Undefined                                                                                     | Undefined                                                   |
-| defines: __clang__          | Defined                                                           | Defined                                                                                       | Undefined                                                   |
-
-## 8.3 Identifying Architecture Features
-
-## 8.3.1 HIP\_ARCH Defines
-
-Some CUDA code tests \_\_CUDA\_ARCH\_\_ for a specific value to determine whether the machine supports a certain architectural feature. For instance,
-**Following code does:** This code snippet appears to be part of a C++ program. It performs the following high-level actions:
-
-1. It adds a string literal `"&N1::N2::V2"` to a vector named `variable_name_vec`. This vector is likely intended to store names or identifiers, possibly for variables or functions.
-
-2. It then iterates over each element in `variable_name_vec` using a range-based for loop. For each element `x`, it calls a function or macro `hiprtcAddNameExp`. This function or macro is likely related to the HIP runtime compilation (hiprtc) library, which is used for compiling and managing GPU kernels in AMD's ROCm platform. The purpose of `hiprtcAddNameExp` is probably to register or process the names stored in the vector for use in GPU kernel compilation or execution.
-
-Overall, the code is managing a collection of names and performing an operation on each name, likely in the context of GPU programming.
-
-
-```
-        | #if (__CUDA_ARCH__ >= 13 0)
-```
-**Following code does:** This code snippet iterates over a vector named `variable_name_vec` and retrieves the "lowered" name for each element in the vector using the `hiprtcGetLoweredName` function. The `decltype(variable_name_vec.size())` is used to ensure the loop index `i` is of the same type as the size of the vector. The `hiprtcGetLoweredName` function is likely part of the HIP runtime compilation (hipRTC) API, which is used for compiling and managing GPU kernels. The lowered name is stored in the `name` pointer for each variable in the vector.
-
-
-```
-    |// doubles are supported
-```
-
-This type of code requires special attention, since AMD and CUDA devices have different architectural capabilities. Moreover, you can't determine the presence of a feature using a simple comparison against an architecture's version
-
-number. HIP provides a set of defines and device properties to query whether a specific architectural feature is supported.
-
-The \_\_HIP\_ARCH\_* defines can replace comparisons of \_\_CUDA\_ARCH\_\_ values:
-**Following code does:** This code snippet iterates over a vector named `kernel_name_vec`, which presumably contains kernel names as strings. For each kernel name in the vector, it calls the function `hiprtcGetLoweredName`, passing in a program object `prog`, the current kernel name, and a pointer to a `const char*` variable `name`. The purpose of this function call is likely to retrieve the "lowered" or transformed version of the kernel name, which is stored in the `name` variable. This is typically used in the context of GPU programming, where kernel names might need to be transformed or resolved for further processing or compilation.
-
-
-```
-//#if (__CUDA_ARCH__ >= 130)   // non-portable
-if __HIP_ARCH_HAS_DOUBLES__ {  // portable HIP feature query
-    // doubles are supported
-}
-```
-
-For host code, the \_\_HIP\_ARCH\_\_* defines are set to 0. You should only use the \_\_HIP\_ARCH\_\_ fields in device code.
-
-## 8.3.2 Device-Architecture Properties
-
-Host code should query the architecture feature flags in the device properties that hipGetDeviceProperties returns, rather than testing the 'major' and 'minor' fields directly:
-**Following code does:** This code snippet is part of a GPU programming workflow using the HIP (Heterogeneous-Compute Interface for Portability) API, which is designed for writing portable applications that can run on AMD and NVIDIA GPUs. The code performs the following high-level tasks:
-
-1. It declares a variable `variable_addr` to hold the device pointer to a global variable within a GPU module, and a `bytes` variable to store the size of this global variable.
-2. It retrieves the address and size of a global variable from a specified GPU module using `hipModuleGetGlobal`.
-3. It copies an initial value from the host (CPU) memory to the device (GPU) memory at the location specified by `variable_addr` using `hipMemcpyHtoD`.
-
-Overall, this code initializes a global variable in a GPU module with a specified initial value from the host.
-
-
-```
-hipGetDeviceProperties(&deviceProp, device);
-//if ((deviceProp.major == 1 && deviceProp.minor < 2))  // non-portable
-if (deviceProp.arch.hasSharedInt32Atomics) {            // portable HIP feature query
-    // has shared int32 atomic operations...
-}
-```
-
-## 8.3.3 Table of Architecture Properties
-
-The table below shows the full set of architectural properties that HIP supports.
-
-| Define (use only in device code)                                                                                               | Device Property (run- time query)                       | Comment                                                                                                                                |
-|--------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------|
-| 32-bit atomics:                                                                                                                |                                                         |                                                                                                                                        |
-| __HIP_ARCH_HAS_GLOBAL_INT32_ATOMICS__ __HIP_ARCH_HAS_GLOBAL_FLOAT_ATOMIC_EXCH__                                                | hasGlobalInt32Atomics hasGlobalFloatAtomicExch          | 32-bit integer atomics for global memory 32-bit float atomic exchange for global mem- ory                                              |
-| __HIP_ARCH_HAS_SHARED_INT32_ATOMICS__ __HIP_ARCH_HAS_SHARED_FLOAT_ATOMIC_EXCH__                                                | hasSharedInt32Atomics hasSharedFloatAtomicExch          | 32-bit integer atomics for shared memory 32-bit float atomic exchange for shared mem- ory                                              |
-| __HIP_ARCH_HAS_FLOAT_ATOMIC_ADD__                                                                                              | hasFloatAtomicAdd                                       | 32-bit float atomic add in global and shared memory                                                                                    |
-| 64-bit atomics:                                                                                                                |                                                         |                                                                                                                                        |
-| __HIP_ARCH_HAS_GLOBAL_INT64_ATOMICS__ __HIP_ARCH_HAS_SHARED_INT64_ATOMICS__ Doubles:                                           | hasGlobalInt64Atomics hasSharedInt64Atomics             | 64-bit integer atomics for global memory 64-bit integer atomics for shared memory                                                      |
-| __HIP_ARCH_HAS_DOUBLES__ Warp cross-lane operations:                                                                           | hasDoubles                                              | Double-precision floating point                                                                                                        |
-| __HIP_ARCH_HAS_WARP_VOTE__ __HIP_ARCH_HAS_WARP_BALLOT__ __HIP_ARCH_HAS_WARP_SHUFFLE__ __HIP_ARCH_HAS_WARP_FUNNEL_SHIFT__ Sync: | hasWarpVote hasWarpBallot hasWarpShuffle hasFunnelShift | Warp vote instructions ( any , all ) Warp ballot instructions Warp shuffle operations ( shfl_* ) Funnel shift two input words into one |
-|                                                                                                                                | hasThreadFenceSystem hasSyncThreadsExt                  | threadfence_system syncthreads_count , syncthreads_and                                                                                 |
-| __HIP_ARCH_HAS_THREAD_FENCE_SYSTEM__                                                                                           |                                                         |                                                                                                                                        |
-| __HIP_ARCH_HAS_SYNC_THREAD_EXT__                                                                                               |                                                         | , syncthreads_or                                                                                                                       |
-| Miscellaneous:                                                                                                                 |                                                         |                                                                                                                                        |
-| __HIP_ARCH_HAS_SURFACE_FUNCS__                                                                                                 | hasSurfaceFuncs                                         |                                                                                                                                        |
-| __HIP_ARCH_HAS_3DGRID__                                                                                                        | has3dGrid                                               | Grids and groups are 3D                                                                                                                |
-| __HIP_ARCH_HAS_DYNAMIC_PARALLEL__                                                                                              | hasDynamicParallelism                                   |                                                                                                                                        |
-
-## 8.4 Finding HIP
-
-Makefiles can use the following syntax to conditionally provide a default HIP\_PATH if one does not exist:
-
-HIP\_PATH ?= $( shell hipconfig --path )
-
-## 8.5 Identifying HIP Runtime
-
-HIP can depend on rocclr, or CUDA as runtime
-
-- AMDplatform On AMD platform, HIP uses Radeon Open Compute Common Language Runtime, called ROCclr. ROCclr is a virtual device interface that HIP runtimes interact with different backends which allows runtimes to work on Linux , as well as Windows without much efforts.
-- NVIDIA platform On NVIDIA platform, HIP is just a thin layer on top of CUDA. On non-AMD platform, HIP runtime determines if CUDA is available and can be used. If available, HIP\_PLATFORM is set to nvidia and underneath CUDA path is used.
-
-## 8.6 hipLaunchKernelGGL
-
-hipLaunchKernelGGL is a macro that can serve as an alternative way to launch kernel, which accepts parameters of launch configurations (grid dims, group dims, stream, dynamic shared size) followed by a variable number of kernel arguments. It can replace &lt;&lt;&lt; &gt;&gt;&gt;, if the user so desires.
-
-## 8.7 Compiler Options
-
-hipcc is a portable compiler driver that will call NVCC or HIP-Clang (depending on the target system) and attach all required include and library options. It passes options through to the target compiler. Tools that call hipcc must ensure the compiler options are appropriate for the target compiler. The hipconfig script may helpful in identifying the target platform, compiler and runtime. It can also help set options appropriately.
-
-## 8.7.1 Compiler options supported on AMD platforms
-
-Here are the main compiler options supported on AMD platforms by HIP-Clang.
-
-| Option      | Description                                                                                                                                                                                                                                                                                                                                                                           |
-|-------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-|             | --amdgpu-target=<gpu_arch> [DEPRECATED] This option is being replaced by --offload-arch=<target> . Generate code for the given GPU target. Supported targets are gfx701, gfx801, gfx802, gfx803, gfx900, gfx906, gfx908, gfx1010, gfx1011, gfx1012, gfx1030, gfx1031. This option could appear multiple times on the same command line to generate a fat binary for multiple targets. |
-| --fgpu-rdc  | Generate relocatable device code, which allows kernels or device functions calling device functions in different translation units.                                                                                                                                                                                                                                                   |
-| -ggdb       | Equivalent to -g plus tuning for GDB. This is recommended when using ROCm's GDB to debug GPU code.                                                                                                                                                                                                                                                                                    |
-|             | --gpu-max-threads-per-block=<num> Generate code to support up to the specified number of threads per block.                                                                                                                                                                                                                                                                           |
-| -O<n>       | Specify the optimization level.                                                                                                                                                                                                                                                                                                                                                       |
-|             | -offload-arch=<target> Specify the AMDGPUtarget ID.                                                                                                                                                                                                                                                                                                                                   |
-| -save-temps | Save the compiler generated intermediate files.                                                                                                                                                                                                                                                                                                                                       |
-| -v          | Show the compilation steps.                                                                                                                                                                                                                                                                                                                                                           |
-
-## 8.8 Linking Issues
-
-## 8.8.1 Linking With hipcc
-
-hipcc adds the necessary libraries for HIP as well as for the accelerator compiler (NVCC or AMD compiler). We recommend linking with hipcc since it automatically links the binary to the necessary HIP runtime libraries. It also has knowledge on how to link and to manage the GPU objects.
-
-## 8.8.2 -lm Option
-
-hipcc adds -lm by default to the link command.
-
-## 8.9 Linking Code With Other Compilers
-
-CUDA code often uses NVCC for accelerator code (defining and launching kernels, typically defined in .cu or .cuh files). It also uses a standard compiler (g++) for the rest of the application. NVCC is a preprocessor that employs a standard host compiler (gcc) to generate the host code. Code compiled using this tool can employ only the intersection of language features supported by both NVCC and the host compiler. In some cases, you must take care to ensure the data types and alignment of the host compiler are identical to those of the device compiler. Only some host compilers are supported-for example, recent NVCC versions lack Clang host-compiler capability.
-
-HIP-Clang generates both device and host code using the same Clang-based compiler. The code uses the same API as gcc, which allows code generated by different gcc-compatible compilers to be linked together. For example, code compiled using HIP-Clang can link with code compiled using 'standard' compilers (such as gcc, ICC and Clang). Take care to ensure all compilers use the same standard C++ header and library formats.
-
-## 8.9.1 libc++ and libstdc++
-
-hipcc links to libstdc++ by default. This provides better compatibility between g++ and HIP.
-
-If you pass --stdlib=libc++ to hipcc, hipcc will use the libc++ library. Generally, libc++ provides a broader set of C++ features while libstdc++ is the standard for more compilers (notably including g++).
-
-When cross-linking C++ code, any C++ functions that use types from the C++ standard library (including std::string, std::vector and other containers) must use the same standard-library implementation. They include the following:
-
-- Functions or kernels defined in HIP-Clang that are called from a standard compiler
-- Functions defined in a standard compiler that are called from HIP-Clang.
-
-Applications with these interfaces should use the default libstdc++ linking.
-
-Applications which are compiled entirely with hipcc, and which benefit from advanced C++ features not supported in libstdc++, and which do not require portability to NVCC, may choose to use libc++.
-
-## 8.9.2 HIP Headers ( hip\_runtime.h , hip\_runtime\_api.h )
-
-The hip\_runtime.h and hip\_runtime\_api.h files define the types, functions and enumerations needed to compile a HIP program:
-
-- hip\_runtime\_api.h : defines all the HIP runtime APIs (e.g., hipMalloc ) and the types required to call them. A source file that is only calling HIP APIs but neither defines nor launches any kernels can include hip\_runtime\_api.h . hip\_runtime\_api.h uses no custom Heterogeneous Compute (HC) language features and can be compiled using a standard C++ compiler.
-- hip\_runtime.h : included in hip\_runtime\_api.h . It additionally provides the types and defines required to create and launch kernels. hip\_runtime.h can be compiled using a standard C++ compiler but will expose a subset of the available functions.
-
-CUDAhasslightly different contents for these two files. In some cases you may need to convert hipified code to include the richer hip\_runtime.h instead of hip\_runtime\_api.h .
-
-## 8.9.3 Using a Standard C++ Compiler
-
-You can compile hip\_runtime\_api.h using a standard C or C++ compiler (e.g., gcc or ICC). The HIP include paths and defines ( \_\_HIP\_PLATFORM\_AMD\_\_ or \_\_HIP\_PLATFORM\_NVIDIA\_\_ ) must pass to the standard compiler; hipconfig then returns the necessary options:
-
-- &gt;
-**Following code does:** This code snippet is part of a HIP (Heterogeneous-Compute Interface for Portability) application, which is used for running code on GPUs. The code performs the following high-level tasks:
-
-1. It retrieves a GPU kernel function from a given module using `hipModuleGetFunction`, storing the function in the `kernel` variable.
-2. It then launches this kernel function on the GPU using `hipModuleLaunchKernel`. The kernel is launched with a grid and block size of 1x1x1, meaning it will execute a single thread. The function is executed with no shared memory (`0`), no stream (`nullptr`), no extra arguments (`nullptr`), and a configuration specified by `config`.
-
-Overall, this code is setting up and executing a GPU kernel with minimal configuration, likely for testing or demonstration purposes.
-
-
-```
-|> hipconfig --cxx_config
-```
-**Following code does:** The provided code snippet appears to be a mix of PHP and HTML-like syntax, but it is mostly nonsensical and does not form a valid or functional script. It includes PHP opening and closing tags (`<?php` and `?>`), but the content within these tags is not meaningful or executable PHP code. The snippet also contains HTML-like tags (`<!`, `<%`, `</%>`) that do not correspond to any standard HTML or server-side scripting language syntax. Overall, this code does not serve any practical purpose and seems to be a random or corrupted text rather than a functional script.
-
-
-```
-                                                                                                                                                                                                        |  -D___HIP_PLATFORM_AMD___ -I/home/user1/hip/include
-```
-
-You can capture the hipconfig output and passed it to the standard compiler; below is a sample makefile syntax:
-**Following code does:** This code snippet is an example of using the `ltrace` command to trace calls to HSA (Heterogeneous System Architecture) APIs. The command `ltrace -C -e "hsa*" ./hipGetChanDesc` is executed to monitor and log the function calls made by the `hipGetChanDesc` program that involve HSA-related libraries. The output shows a sequence of HSA API calls, including initialization, memory allocation, and event creation, along with their parameters and return values. This is useful for debugging or understanding the interactions between the program and the HSA runtime.
-
-
-```
-            |CPPFLAGS += $(shell $(HIP_PATH)/bin/hipconfig --cpp_config)
-```
-**Following code does:** The line you provided appears to be a version identifier or a header comment, rather than executable code. It likely indicates the version of a software release or documentation for a project named "HIP." This version is labeled as "6.1.40092." Such a line is typically used in documentation files to specify the version of the document or software it pertains to, helping users identify the correct version they are referencing or using.
-
-
-```
-
-)
-```
-
-NVCC includes some headers by default. However, HIP does not include default headers, and instead all required files must be explicitly included. Specifically, files that call HIP run-time APIs or define HIP kernels must explicitly include the appropriate HIP headers. If the compilation process reports that it cannot find necessary APIs (for example, error: identifier hipSetDevice is undefined ), ensure that the file includes hip\_runtime.h (or hip\_runtime\_api.h, if appropriate). The hipify-perl script automatically converts cuda\_runtime.h to hip\_runtime.h , and it converts cuda\_runtime\_api.h to hip\_runtime\_api.h , but it may miss nested headers or macros.
-
-## 8.9.3.1 cuda.h
-
-The HIP-Clang path provides an empty cuda.h file. Some existing CUDA programs include this file but don't require any of the functions.
-
-## 8.9.4 Choosing HIP File Extensions
-
-Many existing CUDA projects use the .cu and .cuh file extensions to indicate code that should be run through the NVCC compiler. For quick HIP ports, leaving these file extensions unchanged is often easier, as it minimizes the work required to change file names in the directory and #include statements in the files.
-
-For new projects or ports which can be re-factored, we recommend the use of the extension .hip.cpp for source files, and .hip.h or .hip.hpp for header files. This indicates that the code is standard C++ code, but also provides a unique indication for make tools to run hipcc when appropriate.
-
-## 8.10 Workarounds
-
-## 8.10.1 warpSize
-
-Code should not assume a warp size of 32 or 64. See Warp Cross-Lane Functions for information on how to write portable wave-aware code.
-
-## 8.10.2 Kernel launch with group size &gt; 256
-
-Kernel code should use \_\_attribute\_\_((amdgpu\_flat\_work\_group\_size(&lt;min&gt;,&lt;max&gt;))) . For example:
-**Following code does:** The provided code snippet appears to be a mix of HTML tags with unusual formatting and indentation. However, it does not form a valid or meaningful HTML structure. The code includes opening and closing tags for paragraphs (`<p>`), headings (`<h1>`), anchors (`<a>`), and bold text (`<b>`), but they are not properly nested or used in a coherent way. As it stands, this code does not serve any functional purpose in a web page and would not render any meaningful content. It seems to be a collection of HTML tags without a clear intent or structure.
-
-
-```
-<_SQL_>
-```
-
-## 8.11 memcpyToSymbol
-
-HIP support for hipMemcpyToSymbol is complete. This feature allows a kernel to define a device-side data symbol which can be accessed on the host side. The symbol can be in \_\_constant or device space.
-
-Note that the symbol name needs to be encased in the HIP\_SYMBOL macro, as shown in the code example below. This also applies to hipMemcpyFromSymbol , hipGetSymbolAddress , and hipGetSymbolSize .
-
-For example:
-
-Device Code:
-**Following code does:** The provided snippet appears to be a fragment of HTML code rather than a complete Python script. It includes an HTML paragraph (`<p>`) and an anchor (`<a>`) tag. The paragraph contains a brief description mentioning a "test" that caused a "segmentation fault issue." The anchor tag seems to reference a URL or file path related to a source file (`hipMemcpy_simple.cpp`) at a specific line (147), which is likely part of a test or example code related to memory operations in a runtime API, possibly for a GPU or parallel computing context. The snippet is incomplete and lacks context, but it suggests documentation or a report of a specific issue in a codebase.
-
-
-```
-<_C++_>
-```
-
-(continued from previous page)
-**Following code does:** The provided text does not appear to be a functional code snippet. Instead, it seems to be a fragment of a document or a placeholder text, possibly from a documentation file related to a software release (HIP Documentation, Release 6.1.40092). The text includes various symbols and characters that do not form a coherent or executable code. It might be part of a larger document or a formatting artifact.
-
-
-```
-        {
-            A[i] = -1*i;
-            B[i] = 0;
-        }
-
-        HIP_ASSERT(hipMalloc((void**)&Ad, SIZE));
-
-        HIP_ASSERT(hipMemcpyToSymbol(HIP_SYMBOL(Value), A, SIZE, 0, hipMemcpyHostToDevice));
-        hipLaunchKernelGGL(Get, dim3(1,1,1), dim3(LEN,1,1), 0, 0, Ad);
-        HIP_ASSERT(hipMemcpy(B, Ad, SIZE, hipMemcpyDeviceToHost));
-
-        for(unsigned i=0;i<LEN;i++)
-        {
-            assert(A[i] == B[i]);
-        }
-        std::cout<<"Passed"<<std::endl;
-    }
-    
-    
-    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-```
-
-## 8.12 CU\_POINTER\_ATTRIBUTE\_MEMORY\_TYPE
-
-To get pointer's memory type in HIP/HIP-Clang, developers should use hipPointerGetAttributes API. First parameter of the API is hipPointerAttribute\_t which has 'type' as member variable. 'type' indicates input pointer is allocated on device or host.
-
-For example:
-**Following code does:** This code snippet is a shell command that sets the environment variable `HIP_VISIBLE_DEVICES` to `0,1`. This variable is used in systems with AMD GPUs to specify which GPUs should be visible and accessible to applications using the HIP (Heterogeneous-Compute Interface for Portability) platform. By setting it to `0,1`, the command is indicating that only the GPUs with IDs 0 and 1 should be available for use by HIP-enabled applications. This is useful for managing GPU resources and controlling which GPUs are used for specific tasks.
-
-
-```
-            For example:
-            double * ptr;
-            hipMalloc(reinterpret_cast<void**>(&ptr), sizeof(double));
-            hipPointerAttribute_t attr;
-            hipPointerGetAttributes(&attr, ptr); /*attr.type will have value as hipMemoryTypeDevice*/
-
-            double* ptrHost;
-            hipHostMalloc(&ptrHost, sizeof(double));
-            hipPointerAttribute_t attr;
-            hipPointerGetAttributes(&attr, ptrHost); /*attr.type will have value as _
-           ...hipMemoryTypeHost*/
-
-            Data data file.MaximumTime amount value as different from end.MaximumTime amount value
-```
-
-Please note, hipMemoryType enum values are different from cudaMemoryType enum values.
-
-For example, on AMD platform, hipMemoryType is defined in hip\_runtime\_api.h ,
-**Following code does:** It seems like you've provided a placeholder or incomplete code snippet. If you have a specific Python code snippet you'd like me to explain, please provide the actual code, and I'll be happy to help!
-
-
-```
-            For example, on AMD platform, hipMemoryType is defined in hip_runtime_api.h,
-            
-        typedef enum hipMemoryType {
-            hipMemoryTypeHost = 0,     ///< Memory is physically located on host
-            hipMemoryTypeDevice = 1,  ///< Memory is physically located on device. (see deviceId,
-        --for specific device)
-            hipMemoryTypeArray = 2,   ///< Array memory, physically located on device. (see_,
-        --deviceId for specific device)
-            hipMemoryTypeUnified = 3, ///< Not used currently
-            hipMemoryTypeManaged = 4  ///< Managed memory, automatically managed by the unified.
-        --memory system
-        } hipMemoryType;
-```
-
-Looking into CUDA toolkit, it defines cudaMemoryType as following,
-**Following code does:** This code snippet is part of a larger program that is likely managing GPU devices for computation. It checks if the total number of devices (`totalDeviceNum`) is greater than 2. If this condition is true, it sets an environment variable `HIP_VISIBLE_DEVICES` to "0,1,2", which specifies that only the first three devices (indexed 0, 1, and 2) should be visible and used by the program. The `setenv` function is used to set this environment variable, with the last argument `1` indicating that it should overwrite any existing value. The `assert` statement then checks that the function `getDeviceNumber(false)` returns 3, ensuring that exactly three devices are recognized as available for use. This setup is likely part of a configuration process for a program that utilizes GPU resources.
-
-
-```
-<_Cuda_>
-```
-
-In this case, memory type translation for hipPointerGetAttributes needs to be handled properly on NVIDIA platform to get the correct memory type in CUDA, which is done in the file nvidia\_hip\_runtime\_api.h .
-
-So in any HIP applications which use HIP APIs involving memory types, developers should use #ifdef in order to assign the correct enum values depending on NVIDIA or AMD platform.
-
-As an example, please see the code from the link.
-
-With the #ifdef condition, HIP APIs work as expected on both AMD and NVIDIA platforms.
-
-Note, cudaMemoryTypeUnregstered is currently not supported in hipMemoryType enum, due to HIP functionality backward compatibility.
-
-## 8.13 threadfence\_system
-
-threadfence\_system makes all device memory writes, all writes to mapped host memory, and all writes to peer memory visible to CPU and other GPU devices. Some implementations can provide this behavior by flushing the GPU L2 cache. HIP/HIP-Clang does not provide this functionality. As a workaround, users can set the environment variable HSA\_DISABLE\_CACHE=1 to disable the GPU L2 cache. This will affect all accesses and for all kernels and so may have a performance impact.
-
-## 8.13.1 Textures and Cache Control
-
-Compute programs sometimes use textures either to access dedicated texture caches or to use the texture-sampling hardware for interpolation and clamping. The former approach uses simple point samplers with linear interpolation, essentially only reading a single point. The latter approach uses the sampler hardware to interpolate and combine multiple samples. AMD hardware, as well as recent competing hardware, has a unified texture/L1 cache, so it no longer has a dedicated texture cache. But the NVCC path often caches global loads in the L2 cache, and some programs may benefit from explicit control of the L1 cache contents. We recommend the \_\_ldg instruction for this purpose.
-
-AMDcompilers currently load all data into both the L1 and L2 caches, so \_\_ldg is treated as a no-op.
-
-We recommend the following for functional portability:
-
-- For programs that use textures only to benefit from improved caching, use the \_\_ldg instruction
-- Programs that use texture object and reference APIs, work well on HIP
-
-## 8.14 More Tips
-
-## 8.14.1 HIP Logging
-
-Onan AMDplatform, set the AMD\_LOG\_LEVEL environment variable to log HIP application execution information.
-
-The value of the setting controls different logging level,
-**Following code does:** This code snippet is a command used in the GNU Debugger (GDB) environment. It sets an environment variable named `AND_SERIALIZE_KERNEL` to the value `3` for the program being debugged. This can be used to influence the behavior of the program during debugging, potentially enabling or configuring specific features or modes related to kernel serialization, depending on how the program interprets this environment variable.
-
-
-```
-<_C++_>
-```
-
-Logging mask is used to print types of functionalities during the execution of HIP application. It can be set as one of the following values,
-**Following code does:** The code snippet is a shell command that executes a program named `hipinfo` located in the `~/hip/bin` directory. The output of this program is redirected twice: first to a file named `~/hipinfo` and then to another file named `~/hip_log.txt`. However, due to the syntax used, the output will only be redirected to `~/hip_log.txt`, as the second redirection overwrites the first one.
-
-
-```
-<_C++_>
-```
-
-## 8.14.2 Debugging hipcc
-
-To see the detailed commands that hipcc issues, set the environment variable HIPCC\_VERBOSE to 1. Doing so will print to stderr the HIP-clang (or NVCC) commands that hipcc generates.
-**Following code does:** This code defines an enumeration called `LogLevel` in Python, which is used to represent different levels of logging severity. Each log level is associated with an integer value, starting from 0 for `LOG_NONE` (indicating no logging) up to 4 for `LOG_DEBUG` (indicating the most detailed logging). This enumeration can be used in a logging system to categorize and filter log messages based on their severity.
-
-
-```
-export HIPCC_VERBOSE=1
-make
-
-...
-hipcc-cmd: /opt/rcm/bin/hipcc --offload-arch=native -x hip backprop_cuda.cu
-```
-
-## 8.14.3 Editor Highlighting
-
-See the utils/vim or utils/gedit directories to add handy highlighting to hip files.
-
-## PORTING CUDA DRIVER API
-
-## 9.1 Introduction to the CUDA Driver and Runtime APIs
-
-CUDA provides a separate CUDA Driver and Runtime APIs. The two APIs have significant overlap in functionality:
-
-- Both APIs support events, streams, memory management, memory copy, and error handling.
-- Both APIs deliver similar performance.
-- Driver APIs calls begin with the prefix cu while Runtime APIs begin with the prefix cuda . For example, the Driver API API contains cuEventCreate while the Runtime API contains cudaEventCreate , with similar functionality.
-- The Driver API defines a different but largely overlapping error code space than the Runtime API, and uses a different coding convention. For example, Driver API defines CUDA\_ERROR\_INVALID\_VALUE while the Runtime API defines cudaErrorInvalidValue
-
-The Driver API offers two additional pieces of functionality not provided by the Runtime API: cuModule and cuCtx APIs.
-
-## 9.1.1 cuModule API
-
-The Module section of the Driver API provides additional control over how and when accelerator code objects are loaded. For example, the driver API allows code objects to be loaded from files or memory pointers. Symbols for kernels or global data can be extracted from the loaded code objects. In contrast, the Runtime API automatically loads and (if necessary) compiles all of the kernels from an executable binary when run. In this mode, NVCC must be used to compile kernel code so the automatic loading can function correctly.
-
-Both Driver and Runtime APIs define a function for launching kernels (called cuLaunchKernel or cudaLaunchKernel . The kernel arguments and the execution configuration (grid dimensions, group dimensions, dynamic shared memory, and stream) are passed as arguments to the launch function. The Runtime additionally provides the &lt;&lt;&lt; &gt;&gt;&gt; syntax for launching kernels, which resembles a special function call and is easier to use than explicit launch API (in particular with respect to handling of kernel arguments). However, this syntax is not standard C++ and is available only when NVCC is used to compile the host code.
-
-The Module features are useful in an environment which generates the code objects directly, such as a new accelerator language front-end. Here, NVCC is not used. Instead, the environment may have a different kernel language or different compilation flow. Other environments have many kernels and do not want them to be all loaded automatically. The Module functions can be used to load the generated code objects and launch kernels. As we will see below, HIP defines a Module API which provides similar explicit control over code object management.
-
-## 9.1.2 cuCtx API
-
-The Driver API defines 'Context' and 'Devices' as separate entities. Contexts contain a single device, and a device can theoretically have multiple contexts. Each context contains a set of streams and events specific to the context. Historically contexts also defined a unique address space for the GPU, though this may no longer be the case in Unified Memory platforms (since the CPU and all the devices in the same process share a single unified address space). The Context APIs also provide a mechanism to switch between devices, which allowed a single CPU thread to send commands to different GPUs. HIP as well as a recent versions of CUDA Runtime provide other mechanisms to accomplish this feat - for example using streams or cudaSetDevice .
-
-The CUDA Runtime API unifies the Context API with the Device API. This simplifies the APIs and has little loss of functionality since each Context can contain a single device, and the benefits of multiple contexts has been replaced with other interfaces. HIP provides a context API to facilitate easy porting from existing Driver codes. In HIP, the Ctx functions largely provide an alternate syntax for changing the active device.
-
-Most new applications will prefer to use hipSetDevice or the stream APIs, therefore HIP has marked hipCtx APIs as deprecated . Support for these APIs may not be available in future releases. For more details on deprecated APIs please refer HIP deprecated APIs .
-
-## 9.2 HIP Module and Ctx APIs
-
-Rather than present two separate APIs, HIP extends the HIP API with new APIs for Modules and Ctx control.
-
-## 9.2.1 hipModule API
-
-Like the CUDA Driver API, the Module API provides additional control over how code is loaded, including options to load code from files or from in-memory pointers. NVCC and HIP-Clang target different architectures and use different code object formats: NVCC is cubin or ptx files, while the HIP-Clang path is the hsaco format. The external compilers which generate these code objects are responsible for generating and loading the correct code object for each platform. Notably, there is not a fat binary format that can contain code for both NVCC and HIP-Clang platforms. The following table summarizes the formats used on each platform:
-
-| Format                 | APIs                                                  | NVCC                       | HIP-CLANG          |
-|------------------------|-------------------------------------------------------|----------------------------|--------------------|
-| Code Object Fat Binary | hipModuleLoad , hipModuleLoadData hipModuleLoadFatBin | .cubin or PTX text .fatbin | .hsaco .hip_fatbin |
-
-hipcc uses HIP-Clang or NVCC to compile host codes. Both of these may embed code objects into the final executable, and these code objects will be automatically loaded when the application starts. The hipModule API can be used to load additional code objects, and in this way provides an extended capability to the automatically loaded code objects. HIP-Clang allows both of these capabilities to be used together, if desired. Of course it is possible to create a program with no kernels and thus no automatic loading.
-
-## 9.2.2 hipCtx API
-
-HIP provides a Ctx API as a thin layer over the existing Device functions. This Ctx API can be used to set the current context, or to query properties of the device associated with the context. The current context is implicitly used by other APIs such as hipStreamCreate .
-
-## 9.2.3 hipify translation of CUDA Driver API
-
-The HIPIFY tools convert CUDA Driver APIs for streams, events, modules, devices, memory management, context, profiler to the equivalent HIP driver calls. For example, cuEventCreate will be translated to hipEventCreate . HIPIFY tools also convert error codes from the Driver namespace and coding convention to the equivalent HIP error code. Thus, HIP unifies the APIs for these common functions.
-
-The memory copy API requires additional explanation. The CUDA driver includes the memory direction in the name of the API ( cuMemcpyH2D ) while the CUDA driver API provides a single memory copy API with a parameter that specifies the direction and additionally supports a 'default' direction where the runtime determines the direction automatically. HIP provides APIs with both styles: for example, hipMemcpyH2D as well as hipMemcpy . The first flavor may be faster in some cases since they avoid host overhead to detect the different memory directions.
-
-HIP defines a single error space, and uses camel-case for all errors (i.e. hipErrorInvalidValue ).
-
-## 9.2.3.1 Address Spaces
-
-HIP-Clang defines a process-wide address space where the CPU and all devices allocate addresses from a single unified pool. Thus addresses may be shared between contexts, and unlike the original CUDA definition a new context does not create a new address space for the device.
-
-## 9.2.3.2 Using hipModuleLaunchKernel
-
-hipModuleLaunchKernel is cuLaunchKernel in HIP world. It takes the same arguments as cuLaunchKernel .
-
-## 9.2.3.3 Additional Information
-
-- HIP-Clang creates a primary context when the HIP API is called. So in a pure driver API code, HIP-Clang will create a primary context while HIP/NVCC will have empty context stack. HIP-Clang will push primary context to context stack when it is empty. This can have subtle differences on applications which mix the runtime and driver APIs.
-
-## 9.2.4 hip-clang Implementation Notes
-
-## 9.2.4.1 .hip\_fatbin
-
-hip-clang links device code from different translation units together. For each device target, a code object is generated. Code objects for different device targets are bundled by clang-offload-bundler as one fatbinary, which is embeded as a global symbol \_\_hip\_fatbin in the .hip\_fatbin section of the ELF file of the executable or shared object.
-
-## 9.2.4.2 Initialization and Termination Functions
-
-hip-clang generates initialization and termination functions for each translation unit for host code compilation. The initialization functions call \_\_hipRegisterFatBinary to register the fatbinary embeded in the ELF file. They also call \_\_hipRegisterFunction and \_\_hipRegisterVar to register kernel functions and device side global variables. The termination functions call \_\_hipUnregisterFatBinary . hip-clang emits a global variable \_\_hip\_gpubin\_handle of void** type with linkonce linkage and inital value 0 for each host translation unit. Each initialization function checks \_\_hip\_gpubin\_handle and register the fatbinary only if \_\_hip\_gpubin\_handle is 0 and saves the return value of \_\_hip\_gpubin\_handle to \_\_hip\_gpubin\_handle . This is to guarantee that the fatbinary is only registered once. Similar check is done in the termination functions.
-
-## 9.2.4.3 Kernel Launching
-
-hip-clang supports kernel launching by CUDA &lt;&lt;&lt;&gt;&gt;&gt; syntax, hipLaunchKernelGGL. The latter one is macro which expand to CUDA &lt;&lt;&lt;&gt;&gt;&gt; syntax.
-
-When the executable or shared library is loaded by the dynamic linker, the initialization functions are called. In the initialization functions, when \_\_hipRegisterFatBinary is called, the code objects containing all kernels are loaded; when \_\_hipRegisterFunction is called, the stub functions are associated with the corresponding kernels in code objects.
-
-hip-clang implements two sets of kernel launching APIs.
-
-By default, in the host code, for the &lt;&lt;&lt;&gt;&gt;&gt; statement, hip-clang first emits call of hipConfigureCall to set up the threads and grids, then emits call of the stub function with the given arguments. In the stub function, hipSetupArgument is called for each kernel argument, then hipLaunchByPtr is called with a function pointer to the stub function. In hipLaunchByPtr , the real kernel associated with the stub function is launched.
-
-## 9.2.5 NVCC Implementation Notes
-
-## 9.2.5.1 Interoperation between HIP and CUDA Driver
-
-CUDA applications may want to mix CUDA driver code with HIP code (see example below). This table shows the type equivalence to enable this interaction.
-
-| HIP Type      | CU Driver Type   | CUDA Runtime Type   |
-|---------------|------------------|---------------------|
-| hipModule_t   | CUmodule         |                     |
-| hipFunction_t | CUfunction       |                     |
-| hipCtx_t      | CUcontext        |                     |
-| hipDevice_t   | CUdevice         |                     |
-| hipStream_t   | CUstream         | cudaStream_t        |
-| hipEvent_t    | CUevent          | cudaEvent_t         |
-| hipArray      | CUarray          | cudaArray           |
-
-## 9.2.5.2 Compilation Options
-
-The hipModule\_t interface does not support cuModuleLoadDataEx function, which is used to control PTX compilation options. HIP-Clang does not use PTX and does not support these compilation options. In fact, HIP-Clang code objects always contain fully compiled ISA and do not require additional compilation as a part of the load step. The corresponding HIP function hipModuleLoadDataEx behaves as hipModuleLoadData on HIP-Clang path (compilation options are not used) and as cuModuleLoadDataEx on NVCC path. For example (CUDA):
-**Following code does:** This code snippet describes a logging system for a HIP (Heterogeneous-Compute Interface for Portability) application. It defines an enumeration `LogMask` with various bitmask values, each representing a different type of logging functionality, such as API calls, synchronization, memory allocation, and more. The logging mask is used to control which types of log messages are printed during the execution of a HIP application. By default, the logging mask is set to a value that enables all logging types, but it can be customized by setting the `AMD_LOG_MASK` environment variable to include only specific types of logs. This allows developers to filter and focus on particular areas of interest when debugging or monitoring the application.
-
-
-```
-<_Cuda_>
-```
-
-HIP:
-**Following code does:** The code snippet provided is not a valid or meaningful Python code. It appears to be a collection of random characters, including HTML-like tags and whitespace, but it does not perform any computational task or serve any functional purpose. It might be an accidental paste or a placeholder.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?xml version="1.0" encoding="UTF-8" />
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        </?xml version="2.0" encoding="UTF-8" />
-                                                                                                                                                                                             <?xml version="3.0" encoding="UTF-8" />
-                                                                                                                                                                                            
-	         
-                                                                                                                                                                                             
-         
-                                                                                                                                                                                              <?xml version="4.0" encoding="UTF-8" />
-                                                                                                                                                                                             </?xml version="5.0" encoding="UTF-8" />
-                                                                                                                                                                                            
-
-          
-                                                                                                                                                                                             <?xml version="6.0" encoding="UTF-8" />
-                                                                                                                                                                                             >
-                                                                                                                                                                                                       <!xml version="7.0" encoding="UTF-8" />
-                                                                                                                                                                                             //
-                                                                                                                                                                                                       </!xml version="8.0" encoding="UTF-8" />
-                                                                                                                                                                                             }
-```
-
-The below sample shows how to use hipModuleGetFunction .
-**Following code does:** This code snippet logs a message indicating that the HSA (Heterogeneous System Architecture) stack is being initialized. It uses a logging function `ClPrint` from the `amd` namespace, specifying the log level as `LOG_INFO` and the log category as `LOG_INIT`. This is likely part of a larger system where logging is used to track the initialization process of various components.
-
-
-```
-#include<hip_runtime.h>
-#include<hip_runtime_api.h>
-#include<iostream>
-#include<fstream>
-#include<vector>
-```
-**Following code does:** The provided code snippet appears to be a fragment of HTML or a similar markup language. It includes various HTML tags such as `<HR>`, `<HIP Documentation, Release 6.1.40092>`, `<BR>`, and `<B>`. However, the snippet is mostly empty or improperly formatted, with many tags not closed or used incorrectly. The high-level purpose seems to be related to documentation, possibly for a software release (version 6.1.40092), and it might be intended to format or display logging examples. However, due to the lack of proper structure and content, it does not achieve any meaningful functionality or display.
-
-
-```
-#include<hip_runtime.h>
-#include<hip_runtime_api.h>
-#include<iostream>
-#include<fstream>
-#include<vector>
-```
-**Following code does:** This line appears to be a version identifier or header for a document related to "HIP Documentation." It indicates that the document is associated with a release version "6.1.40092." This is not executable code but rather a label or title that likely precedes detailed documentation about a software product or library named "HIP."
-
-
-```
-HIP Documentation, Release 6.1.40092
-
-
-
-
-#define LEN 64
-#define SIZE LEN<<2
-
-#ifdef __HIP_PLATFORM_AMD__
-#define fileName "vcpy_isa.co"
-#endif
-
-#ifdef __HIP_PLATFORM_NVIDIA__
-#define fileName "vcpy_isa.ptx"
-#endif
-
-#define kernel_name "hello_world"
-
-int main(){
-	float *A, *B;
-	hipDeviceptr_t Ad, Bd;
-	A = new float[LEN];
-	B = new float[LEN];
-
-	for(uint32_t i=0;i<LEN;i++){
-		A[i] = i*1.0f;
-		B[i] = 0.0f;
-		std::cout<<A[i] << " "<<B[i]<<std::endl;
-	}
-
-
-#ifdef __HIP_PLATFORM_NVIDIA__
-		hipInit(0);
-		hipDevice_t device;
-		hipCtx_t context;
-		hipDeviceGet(&device, 0);
-		hipCtxCreate(&context, 0, device);
-#endif
-
-	hipMalloc((void**)&Ad, SIZE);
-	hipMalloc((void**)&Bd, SIZE);
-
-	hipMemcpyHtoD(Ad, A, SIZE);
-	hipMemcpyHtoD(Bd, B, SIZE);
-	hipModule_t Module;
-	hipFunction_t Function;
-	hipModuleLoad(&Module, fileName);
-	hipModuleGetFunction(&Function, Module, kernel_name);
-
-	std::vector<void*>argBuffer(2);
-	memcpy(&argBuffer[0], &Ad, sizeof(void*));
-	memcpy(&argBuffer[1], &Bd, sizeof(void*));
-
-	size_t size = argBuffer.size()*sizeof(void*);
-
-	void *config[] = {
-		HIP_LAUNCH_PARAM_BUFFER_POINTER, &argBuffer[0],
-
-
-
-54
-```
-
-(continued from previous page)
-
-(continues on next page)
-
-(continued from previous page)
-**Following code does:** The code snippet provided appears to be malformed or corrupted, as it contains excessive whitespace and incomplete or nonsensical elements. Specifically, it includes what looks like an HTML/XML-like tag `<kendo runume. </kendo>runume.`, which is not valid Python syntax. Without additional context or correction, it is not possible to determine a high-level purpose for this code.
-
-
-```
-        HIP_LAUNCH_PARAM_BUFFER_SIZE, &size,
-        HIP_LAUNCH_PARAM_END
-    };
-
-    hipModuleLaunchKernel(Function, 1, 1, 1, LEN, 1, 1, 0, 0, NULL, (void**)&config);
-
-    hipMemcpyDtoH(B, Bd, SIZE);
-    for(uint32_t i=0;i<LEN;i++){
-        std::cout<<A[i]<<" - "<<B[i]<<std::endl;
-    }
-
-#ifdef __HIP_PLATFORM_NVIDIA__
-          hipCtxDetach(context);
-#endif
-
-    return 0;
-}
-
-__A__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ ======"__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__= "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "_ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = '__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ from "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "___ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "'
-```
-
-## 9.3 HIP Module and Texture Driver API
-
-HIP supports texture driver APIs however texture reference should be declared in host scope. Following code explains the use of texture reference for \_\_HIP\_PLATFORM\_AMD\_\_ platform.
-**Following code does:** The provided code snippet does not contain any valid Python code. Instead, it appears to be a malformed and nonsensical mix of XML-like tags and URLs, specifically referencing "amazonaws.com" multiple times. This could potentially be an attempt at obfuscation or a corrupted piece of data, but it does not perform any meaningful function or operation as it stands.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        // Code to generate code object
-
-                                                                                                                                                                                                      
-#include "hip/hip_runtime.h"
-                                                                                                                                                                                                      
-extern texture<float, 2, hipReadModeElementType> tex;
-
-        __global__ void tex2dKernel(hipLaunchParm lp, float* outputData,
-                                                                                                                                                                                                       //
-```
-**Following code does:** This code snippet appears to be a log output from a graphics or compute driver, specifically related to memory allocation and management. It logs the allocation of memory buffers, including the size of the allocation (100,000 bytes in each case), the memory address ranges for the allocated pointers, and the associated objects. Additionally, it logs a call to `hipMemGetInfo`, which returns the total and free memory available, indicating that the system has 12.06 GB of total memory with 11.93 GB free, representing 99% availability. The log entries include timestamps and thread identifiers for context.
-
-
-```
-  }
-
-  // Host code:
-
-  texture<float, 2, hipReadModeElementType> tex;
-
-  void myFunc ()
-  {
-
-      //...
-
-      textureReference* texref;
-      hipModuleGetTexRef(&texref, Module1, "tex");
-      hipTexRefSetAddressMode(texref, 0, hipAddressModeWrap);
-      hipTexRefSetAddressMode(texref, 1, hipAddressModeWrap);
-      hipTexRefSetFilterMode(texref, hipFilterModePoint);
-```
-
-(continues on next page)
-**Following code does:** This code snippet appears to be a part of a parallel programming framework, likely related to GPU programming, such as CUDA. The `thread_block` class is used to represent a group of threads that can cooperate and synchronize with each other during execution. The line `thread_block g = this_thread_block();` constructs an instance `g` of the `thread_block` class, which represents the current block of threads that the executing thread belongs to. This allows the thread to access information and perform operations specific to its block, such as synchronization or shared memory access.
-
-
-```
-    hipTexRefSetFlags(texref, 0);
-    hipTexRefSetFormat(texref, HIP_AD_FORMAT_FLOAT, 1);
-    hipTexRefSetArray(texref, array, HIP_TRSA_OVERRIDE_FORMAT);
-
-    //...
-}
-```
-
-(continued from previous page)
-
-## TEN
-
-## PROGRAMMING FOR HIP RUNTIME COMPILER (RTC)
-
-HIP lets you compile kernels at runtime with the hiprtc* APIs. Kernels can be stored as a text string and can be passed to HIPRTC APIs alongside options to guide the compilation.
-
-NOTE:
-
-- This library can be used on systems without HIP installed nor AMD GPU driver installed at all (offline compilation). Therefore, it does not depend on any HIP runtime library.
-- But it does depend on comgr. You may try to statically link comgr into HIPRTC to avoid any ambiguity.
-- Developers can decide to bundle this library with their application.
-
-## 10.1 Example
-
-To use HIPRTC functionality, HIPRTC header needs to be included first. #include &lt;hip/hiprtc.h&gt;
-
-Kernels can be stored in a string:
-**Following code does:** The code snippet appears to be a fragment of a larger codebase, likely related to a grid or parallel computing framework. The `grid_group` is defined as a class, but the snippet does not provide its implementation details. The comment "Constructed via:" suggests that instances of `grid_group` are created using a function or method called `this_grid()`. This implies that `this_grid()` is a factory function or method that returns an instance of `grid_group`, possibly representing a group or collection of grid elements or processes. The purpose of this setup is likely to manage or interact with a grid structure in a computational context.
-
-
-```
-<_C_>
-```
-
-Now to compile this kernel, it needs to be associated with hiprtcProgram type, which is done by declaring hiprtcProgram prog; and associating the string of kernel with this program:
-**Following code does:** The code snippet appears to be a syntax error or incomplete code. In Python, the `class` keyword is used to define a new class, but the snippet includes a `|` character at the beginning and ends with a semicolon, both of which are not valid in Python class definitions. Additionally, the class body is missing. If this were intended to be a Python class definition, it should start with `class multi_grid_group:` followed by an indented block defining the class's attributes and methods.
-
-
-```
-hiprtcCreateProgram(&prog,                    // HIPRTC program
-                       kernel,                // kernel string
-                       "gpu_kernel.cu",       // Name of the file
-                       num_headers,            // Number of headers
-                       &header_sources[0],     // Header sources
-                       &header_names[0]);      // Name of header files
-```
-
-hiprtcCreateProgram API also allows you to add headers which can be included in your RTC program. For online compilation, the compiler pre-defines HIP device API functions, HIP specific types and macros for device compilation, but does not include standard C/C++ headers by default. Users can only include header files provided to hiprtcCreateProgram .
-
-After associating the kernel string with hiprtcProgram , you can now compile this program using:
-**Following code does:** The code snippet provided is a single semicolon (`;`). In Python, a semicolon is used to separate multiple statements on a single line, but on its own, it does nothing and has no effect. Therefore, this code snippet does not perform any operation or have any functional purpose.
-
-
-```
-
-
-hiprtcCompileProgram(prog,     // hiprtcProgram
-                         0,          // Number of options
-                          options);  // Clang Options [Supported Clang Options](clang_options.
-
---md)
-```
-
-hiprtcCompileProgram returns a status value which can be converted to string via hiprtcGetErrorString . If compilation is successful, hiprtcCompileProgram will return HIPRTC\_SUCCESS .
-
-If the compilation fails, you can look up the logs via:
-**Following code does:** The code snippet `<_C_>` appears to be a placeholder or a non-functional piece of code. It does not represent any valid Python syntax or operation. It might be used as a marker or a template in a larger codebase where actual code is intended to be inserted later.
-
-
-```
-<_C++_>
-```
-
-If the compilation is successful, you can load the compiled binary in a local variable.
-**Following code does:** The code snippet you provided seems to be a placeholder or a tag indicating a YAML (YAML Ain't Markup Language) document or section, rather than actual executable code. YAML is a human-readable data serialization standard often used for configuration files and data exchange between languages with different data structures. Without specific YAML content, it's not possible to determine the exact purpose or functionality. If you have a YAML document or configuration, it typically defines settings, parameters, or data structures in a structured format.
-
-
-```
-  size_t codeSize;
-  hiprtcGetCodeSize(prog, &codeSize);
-
-  vector<char> kernel_binary(codeSize);
-  hiprtcGetCode(prog, kernel_binary.data());
-```
-
-After loading the binary, hiprtcProgram can be destroyed. hiprtcDestroyProgram(&amp;prog);
-
-The binary present in kernel\_binary can now be loaded via hipModuleLoadData API.
-**Following code does:** It seems there is a formatting error in your request. The code snippet is labeled as Python, but the placeholder `<_C++_>` suggests it might be intended for C++. Please provide the correct code snippet or clarify the language so I can assist you accurately.
-
-
-```
-hipModule_t module;
-hipFunction_t kernel;
-
-hipModuleLoadData(&module, kernel_binary.data());
-hipModuleGetFunction(&kernel, module, "vector_add");
-```
-
-And now this kernel can be launched via hipModule APIs.
-
-The full example is below:
-**Following code does:** The placeholder `<_SQL_>` suggests that this is not actual code but rather a placeholder for SQL code. In this context, it indicates that the code snippet is intended to represent a section where SQL queries or statements would be placed. Without specific SQL code, it's not possible to determine the exact functionality, but generally, SQL code is used to interact with databases, performing operations such as querying data, updating records, inserting new data, or deleting existing data.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        //
-```
-
-(continued from previous page)
-**Following code does:** The code snippet appears to be a fragment of code that is not complete or syntactically correct in Python. The line seems to be attempting to define a class named `coalesced_group`, but it includes a syntax error with the presence of the `|` character at the beginning, which is not valid in Python class definitions. In a correct context, this line would be part of a class definition, but as it stands, it does not perform any function or operation.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        </----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                    <-----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        >----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                   
-    <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                <----------------------------------------------------------------------------------------------------------------------    <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                               
-        <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                            <----------------------------------------------------------------------------------------------------------------------        <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                           
-            <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                        <----------------------------------------------------------------------------------------------------------------------            <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                       
-                <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                    <----------------------------------------------------------------------------------------------------------------------                <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                   
-                    <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                <----------------------------------------------------------------------------------------------------------------------                    <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                               
-                        <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                            <----------------------------------------------------------------------------------------------------------------------                        <----------------------------------------------------------------------------------------------------------------------
-```
-**Following code does:** The code snippet appears to be a fragment of a larger codebase, likely related to parallel computing or GPU programming. The line seems to be attempting to define a variable named `active` within a group or context, possibly using a syntax specific to a particular framework or language extension. The `coalesced_threads()` function or method is likely intended to return a set of threads that are coalesced, meaning they are grouped together to execute in a more efficient manner, often to optimize memory access patterns in parallel processing environments. However, the syntax is unusual and may contain typographical errors or be specific to a non-standard language or domain-specific language.
-
-
-```
-HIP Documentation,Release 6.1.40092
-```
-
-(continued from previous page)
-**Following code does:** The code snippet `<_Cuda_>` appears to be a placeholder or a symbolic representation rather than actual executable Python code. In the context of programming, "Cuda" typically refers to NVIDIA's parallel computing platform and application programming interface (API) model, which allows developers to use a CUDA-enabled graphics processing unit (GPU) for general purpose processing. However, without additional context or actual code, it's not possible to determine the specific functionality or purpose of this placeholder.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        }
-                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       }
-
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                       	                                                                                                                                                                                                      
-
-                                                                                                                                                                                                      
-                                                                                                                                                                                                     
-
-                                                                                                                                                                                                    
- 
-                                                                                                                                                                                                    
-
-                                                                                                                                                                                                      
-
- 
-                                                                                                                                                                                                     }
- 
-                                                                                                                                                                                                    }
-  
-                                                                                                                                                                                                    }
-
-  
-                                                                                                                                                                                                   
-  
-                                                                                                                                                                                                   }
-```
-
-## 10.2 HIPRTC specific options
-
-HIPRTC provides a few HIPRTC specific flags
-
-- --gpu-architecture : This flag can guide the code object generation for a specific gpu arch. Example: --gpu-architecture=gfx906:sramecc+:xnack, its equivalent to --offload-arch .
-- -This option is compulsory if compilation is done on a system without AMD GPUs supported by HIP runtime.
-- -Otherwise, HIPRTC will load the hip runtime and gather the current device and its architecture info and use it as option.
-- -fgpu-rdc : This flag when provided during the hiprtcCompileProgram generates the bitcode (HIPRTC doesn't convert this bitcode into ISA and binary). This bitcode can later be fetched using hiprtcGetBitcode and hiprtcGetBitcodeSize APIs.
-
-## 10.2.1 Bitcode
-
-In the usual scenario, the kernel associated with hiprtcProgram is compiled into the binary which can be loaded and run. However, if -fpu-rdc option is provided in the compile options, HIPRTC calls comgr and generates only the LLVM bitcode. It doesn't convert this bitcode to ISA and generate the final binary.
-**Following code does:** The code snippet provided is not functional Python code. It consists mostly of whitespace and a few non-Python elements such as `//`, `/*`, and `*/`, which are comment syntax from languages like C or C++. The snippet appears to be an attempt to create a comment block, but it is not valid in Python. Therefore, it does not perform any operations or have any high-level purpose in a Python context.
-
-
-```
-  std::string sarg = std::string("-fgpu-rdc");
-  const char* options[] = {
-      sarg.c_str() };
-  hiprtcCompileProgram(prog, // hiprtcProgram
-                        1,     // Number of options
-                        options);
-```
-
-If the compilation is successful, one can load the bitcode in a local variable using the bitcode APIs provided by HIPRTC.
-**Following code does:** This code snippet is part of a parallel reduction algorithm, typically used in GPU programming or multi-threaded environments. The purpose of this code is to perform a reduction operation, specifically summing up elements in a data set using a hierarchical approach. Here's a high-level summary of what it does:
-
-1. **Initialization**: The loop starts with `i` set to half the size of the group `g`, which likely represents a group of threads or processing units.
-
-2. **Shared Memory Usage**: Each thread stores its value (`val`) in a shared memory array indexed by its thread ID (`group_thread_id`).
-
-3. **Synchronization**: The `g.sync()` calls ensure that all threads in the group reach the same point in the code before proceeding, which is crucial for correct data sharing and avoiding race conditions.
-
-4. **Reduction Step**: Threads with IDs less than `i` add the value from another thread (offset by `i`) to their own value. This effectively reduces the number of active threads by half each iteration, combining values in a tree-like structure.
-
-5. **Iterative Halving**: The loop continues, halving `i` each time, until `i` becomes zero, at which point the reduction is complete, and the final sum is likely stored in one of the threads.
-
-Overall, this code is implementing a parallel reduction to sum up values efficiently across multiple threads, leveraging shared memory and synchronization to ensure correct results.
-
-
-```
-size_t bitCodeSize;
-hiprtcGetBitcodeSize(prog, &bitCodeSize);
-
-vector<char> kernel_bitcode(bitCodeSize);
-hiprtcGetBitcode(prog, kernel_bitcode.data());
-```
-
-## 10.2.2 CU Mode vs WGP mode
-
-AMDGPUs consist of an array of workgroup processors, each built with 2 compute units (CUs) capable of executing SIMD32. All the CUs inside a workgroup processor use local data share (LDS).
-
-gfx10+ support execution of wavefront in CU mode and work-group processor mode (WGP). Please refer to section 2.3 of RDNA3 ISA reference.
-
-gfx9 and below only supports CU mode.
-
-In WGP mode, 4 warps of a block can simultaneously be executed on the workgroup processor, where as in CU mode only 2 warps of a block can simultaneously execute on a CU. In theory, WGP mode might help with occupancy and increase the performance of certain HIP programs (if not bound to inter warp communication), but might incur performance penalty on other HIP programs which rely on atomics and inter warp communication. This also has effect of how the LDS is split between warps, please refer to RDNA3 ISA reference for more information.
-
-HIPRTCassumes WGPmodebydefault for gfx10+. This can be overridden by passing -mcumode to HIPRTC compile options in hiprtcCompileProgram .
-
-## 10.3 Linker APIs
-
-The bitcode generated using the HIPRTC Bitcode APIs can be loaded using hipModule APIs and also can be linked with other generated bitcodes with appropriate linker flags using the HIPRTC linker APIs. This also provides more flexibility and optimizations to the applications who want to generate the binary dynamically according to their needs. The input bitcodes can be generated only for a specific architecture or it can be a bundled bitcode which is generated for multiple architectures.
-
-## 10.3.1 Example
-
-Firstly, HIPRTC link instance or a pending linker invocation must be created using hiprtcLinkCreate , with the appropriate linker options provided.
-**Following code does:** This code snippet is part of a CUDA kernel function, which is designed to run on a GPU. The kernel, named `sum_kernel`, performs a parallel reduction operation. It utilizes shared memory, specifically an array named `workspace`, to efficiently compute the sum of elements from an input array. The `reduce_sum` function is likely responsible for aggregating the values stored in `workspace` and `input`, ultimately producing a single output value that represents the sum of the input elements. This approach leverages the parallel processing capabilities of the GPU to accelerate the summation process.
-
-
-```
-<_C++_>
-```
-
-Following which, the bitcode data can be added to this link instance via hiprtcLinkAddData (if the data is present as a string) or hiprtcLinkAddFile (if the data is present as a file) with the appropriate input type according to the data or the bitcode used.
-**Following code does:** The provided code snippet is a mix of Python and C++ syntax, but it is mostly composed of whitespace and special characters. It does not form any valid or meaningful code in either language. The snippet includes C++ keywords like `const` and `auto`, as well as comment syntax (`//` and `/* */`), but they are not used in a coherent or executable manner. Therefore, this code does not perform any specific function or task.
-
-
-```
-
-hiprtcLinkAddData(rtc_link_state,        // HIPRTC link state
-                         input_type,            // type of the input data or bitcode
-                         bit_code_ptr,           // input data which is null terminated
-                         bit_code_size,          // size of the input data
-                          "a",                   // optional name for this input
-                          0,                     // size of the options
-                          0,                     // Array of options applied to this input
-                          0);                      // Array of option values cast to void*
-```
-**Following code does:** This code snippet is part of a parallel computing operation, likely using a GPU programming model such as CUDA. It involves two main steps:
-
-1. **Thread Block Initialization**: The `this_thread_block()` function is called to obtain a `thread_block` object, which represents a group of threads that can cooperate and share data during execution.
-
-2. **Reduction Operation**: The `reduce_sum` function is used to perform a reduction operation on the `input` data. This operation typically involves summing up elements across the threads within the `thread_block_group`, storing the result in `output`. The `workspace` parameter likely provides temporary storage needed for the reduction process.
-
-Overall, the code is designed to efficiently compute the sum of elements in parallel using a group of threads.
-
-
-```
-hiprtcLinkAddFile(rtc_link_state,        // HIPRTC link state
-                         input_type,            // type of the input data or bitcode
-                         bc_file_path.c_str(),  // path to the input file where bitcode is_
---present
-                         0,                   // size of the options
-                          0,                    // Array of options applied to this input
-                          0);                    // Array of option values cast to void*
-```
-
-Once the bitcodes for multiple architectures are added to the link instance, the linking of the device code must be completed using hiprtcLinkComplete which generates the final binary.
-**Following code does:** This code snippet is written in C++ using the HIP (Heterogeneous-Compute Interface for Portability) API, which is used for GPU programming. The code checks if a single AMD GPU supports cooperative launch capabilities. It first retrieves the current GPU device ID and then queries the device to determine if it supports cooperative launch features. If the device does not support cooperative groups, it outputs a message indicating this and exits the program. This check is important for ensuring that the GPU can handle tasks that require cooperation between multiple threads or blocks.
-
-
-```
-<_C_>
-```
-
-If the hiprtcLinkComplete returns successfully, the generated binary can be loaded and run using the hipModule* APIs.
-**Following code does:** This code snippet is designed to check the capability of multiple GPUs to support cooperative group launches, specifically in a multi-GPU environment. It iterates over available devices, checking each one for support of the `hipDeviceAttributeCooperativeMultiDeviceLaunch` attribute, which indicates whether the device can participate in cooperative multi-device launches. If a device supports this feature, its ID is added to a list of valid device IDs. If not, a message is printed indicating that the device does not support cooperative groups. This setup is typically used in scenarios where tasks need to be distributed across multiple GPUs that can work together cooperatively.
-
-
-```
-      |hipModuleLoadData(&module, bina
-```
-**Following code does:** The code snippet provided is not a valid Python code. It appears to contain a comment written in C/C++ style (using `//` for comments), which suggests that it might be part of a larger C/C++ program. The comment indicates that the code is related to launching a kernel from the host, which is a common operation in parallel computing environments such as CUDA or OpenCL. In such contexts, "launching a kernel" typically means executing a function (the kernel) on a GPU or other parallel processing device from the host CPU. However, without additional context or code, this snippet alone does not perform any operations.
-
-
-```
-binary);
-```
-
-## 10.3.1.1 Note
-
-- The compiled binary must be loaded before HIPRTC link instance is destroyed using the hiprtcLinkDestroy API.
-
-## hiprtcLinkDestroy(rtc\_link\_state);
-
-- The correct sequence of calls is : hiprtcLinkCreate , hiprtcLinkAddData or hiprtcLinkAddFile , hiprtcLinkComplete , hiprtcModuleLoadData , hiprtcLinkDestroy .
-
-## 10.3.2 Input Types
-
-HIPRTC provides hiprtcJITInputType enumeration type which defines the input types accepted by the Linker APIs. Here are the enum values of hiprtcJITInputType . However only the input types HIPRTC\_JIT\_INPUT\_LLVM\_BITCODE , HIPRTC\_JIT\_INPUT\_LLVM\_BUNDLED\_BITCODE and HIPRTC\_JIT\_INPUT\_LLVM\_ARCHIVES\_OF\_BUNDLED\_BITCODE are supported currently.
-
-HIPRTC\_JIT\_INPUT\_LLVM\_BITCODE can be used to load both LLVM bitcode or LLVM IR assembly code. However, HIPRTC\_JIT\_INPUT\_LLVM\_BUNDLED\_BITCODE and HIPRTC\_JIT\_INPUT\_LLVM\_ARCHIVES\_OF\_BUNDLED\_BITCODE are only for bundled bitcode and archive of bundled bitcode.
-**Following code does:** The code snippet `<_C_>` appears to be a placeholder or a fragment that does not represent any valid or complete Python code. It might be intended as a marker or a template for something to be filled in later. Without additional context or surrounding code, it does not perform any specific function or operation.
-
-
-```
-<_Cuda_>
-```
-
-## 10.3.3 Backward Compatibility of LLVM Bitcode/IR
-
-For HIP applications utilizing HIPRTC to compile LLVM bitcode/IR, compatibility is assured only when the ROCm or HIP SDK version used for generating the LLVM bitcode/IR matches the version used during the runtime compilation. When an application requires the ingestion of bitcode/IR not derived from the currently installed AMD compiler, it must run with HIPRTC and comgr dynamic libraries that are compatible with the version of the bitcode/IR.
-
-comgr, a shared library, incorporates the LLVM/Clang compiler that HIPRTC relies on. To identify the bitcode/IR version that comgr is compatible with, one can execute 'clang -v' using the clang binary from the same ROCm or HIP SDK package. For instance, if compiling bitcode/IR version 14, the HIPRTC and comgr libraries released by AMD around mid 2022 would be the best choice, assuming the LLVM/Clang version included in the package is also version 14.
-
-To ensure smooth operation and compatibility, an application may choose to ship the specific versions of HIPRTC and comgr dynamic libraries, or it may opt to clearly specify the version requirements and dependencies. This approach guarantees that the application can correctly compile the specified version of bitcode/IR.
-
-## 10.3.4 Link Options
-
-- HIPRTC\_JIT\_IR\_TO\_ISA\_OPT\_EXT - AMD Only. Options to be passed on to link step of compiler by hiprtcLinkCreate .
-- HIPRTC\_JIT\_IR\_TO\_ISA\_OPT\_COUNT\_EXT - AMD Only. Count of options passed on to link step of compiler.
-
-Example:
-**Following code does:** This code snippet is designed to launch a cooperative kernel across multiple GPUs using the HIP (Heterogeneous-Compute Interface for Portability) API. It sets up and manages the execution of a parallel computation task on multiple devices. The code performs the following high-level tasks:
-
-1. Allocates memory for an array of `hipLaunchParams` structures, which will hold the configuration for launching kernels on each GPU.
-2. Iterates over a list of device IDs to configure each GPU:
-   - Sets the current device to the specified GPU.
-   - Creates a stream for asynchronous execution on the GPU.
-   - Prepares the kernel parameters, which include pointers to device memory arrays.
-   - Configures the launch parameters for the kernel, including the function to execute, grid and block dimensions, shared memory size, and the stream.
-3. Launches the cooperative kernel across all specified GPUs using `hipLaunchCooperativeKernelMultiDevice`, allowing the kernels to work together across devices.
-4. The code implies that there is synchronization on the device side after the kernel execution, ensuring that all operations are completed before proceeding.
-
-Overall, this code is used for executing a parallel reduction operation across multiple GPUs in a coordinated manner.
-
-
-```
-const char* isaopts[] = {"-mllvm", "-inline-threshold=1", "-mllvm", "-inlinehint-
---threshold=1"};
-std::vector<hiprtcJIT_option> jit_options = {HIPRTC_JIT_IR_TO_ISA_OPT_EXT,
-                                                                                                                                                                                                         HIPRTC_JIT_IR_TO_ISA_OPT_COUNT_EXT};
-size_t isaoptssize = 4;
-                                                                                                                                                                                                       (continues on next page)
-```
-**Following code does:** The code snippet `<_C_>` appears to be a placeholder or a non-functional piece of code. It does not represent any valid Python syntax or operation. It might be used as a marker or a template in a larger codebase where actual code is intended to be inserted later.
-
-
-```
-        const void* lopts[] = {(void*)isaopts, (void*)(isaoptssize)};
-        hiprtcLinkState linkstate;
-        hiprtcLinkCreate(2, jit_options.data(), (void**)lopts, &linkstate);
-```
-
-## 10.4 Error Handling
-
-HIPRTC defines the hiprtcResult enumeration type and a function hiprtcGetErrorString for API call error handling. hiprtcResult enum defines the API result codes. HIPRTC APIs return hiprtcResult to indicate the call result. hiprtcGetErrorString function returns a string describing the given hiprtcResult code, e.g., HIPRTC\_SUCCESS to 'HIPRTC\_SUCCESS'. For unrecognized enumeration values, it returns 'Invalid HIPRTC error code'.
-
-hiprtcResult enum supported values and the hiprtcGetErrorString usage are mentioned below.
-**Following code does:** The code snippet `<_Cython_>` appears to be a placeholder or a reference to Cython, which is a programming language that makes writing C extensions for Python as easy as Python itself. Cython is used to improve the performance of Python code by compiling it into C, which can then be executed more efficiently. However, the snippet itself does not contain any executable code or functionality; it simply seems to indicate the use of Cython in some context. Without additional context or code, it does not perform any specific action.
-
-
-```
-<_Python_>
-```
-**Following code does:** The code snippet appears to be incomplete or malformed, as it starts with an assignment operator (`=`) without a variable on the left-hand side. However, the part `this._grid()` suggests that it is calling a method named `_grid` on an object referred to by `this`. In a complete and correctly formatted context, this line would typically assign the result of the `_grid()` method to a variable. The purpose of the `_grid()` method would depend on its implementation, but it likely relates to some grid-related functionality within the object.
-
-
-```
-hiprtcResult result;
-result = hiprtcCompileProgram(prog, 1, opts);
-if (result!= HIPRTC_SUCCESS) {
-std::cout << "hiprtcCompileProgram fails with error " << hiprtcGetErrorString(result);
-}
-```
-
-## 10.5 HIPRTC General APIs
-
-HIPRTC provides the following API for querying the version.
-
-hiprtcVersion(int* major, int* minor) - This sets the output parameters major and minor with the HIP Runtime compilation major version and minor version number respectively.
-
-Currently, it returns hardcoded value. This should be implemented to return HIP runtime major and minor version in the future releases.
-
-(continued from previous page)
-
-## 10.6 Lowered Names (Mangled Names)
-
-HIPRTC mangles the \_\_global\_\_ function names and names of \_\_device\_\_ and \_\_constant\_\_ variables. If the generated binary is being loaded using the HIP Runtime API, the kernel function or \_\_device\_\_/\_\_constant\_\_ variable must be looked up by name, but this is very hard when the name has been mangled. To overcome this, HIPRTC provides API functions that map \_\_global\_\_ function or \_\_device\_\_/\_\_constant\_\_ variable names in the source to the mangled names present in the generated binary.
-
-The two APIs hiprtcAddNameExpression and hiprtcGetLoweredName provide this functionality. First, a 'name expression' string denoting the address for the \_\_global\_\_ function or \_\_device\_\_/\_\_constant\_\_ variable is provided to hiprtcAddNameExpression . Then, the program is compiled with hiprtcCompileProgram . During compilation, HIPRTC will parse the name expression string as a C++ constant expression at the end of the user program. Finally, the function hiprtcGetLoweredName is called with the original name expression and it returns a pointer to the lowered name. The lowered name can be used to refer to the kernel or variable in the HIP Runtime API.
-
-## 10.6.1 Note
-
-- The identical name expression string must be provided on a subsequent call to hiprtcGetLoweredName to extract the lowered name.
-- The correct sequence of calls is : hiprtcAddNameExpression , hiprtcCompileProgram , hiprtcGetLoweredName , hiprtcDestroyProgram .
-- The lowered names must be fetched using hiprtcGetLoweredName only after the HIPRTC program has been compiled, and before it has been destroyed.
-
-## 10.6.2 Example
-
-kernel containing various definitions \_\_global\_\_ functions/function templates and \_\_device\_\_/\_\_constant\_\_ variables can be stored in a string.
-**Following code does:** This code snippet appears to be part of a larger codebase, likely written in a language that supports object-oriented programming, such as C++ or a similar language. The line of code is performing the following high-level operation:
-
-- It declares a variable named `multi_grid` of type `multi_grid_group`.
-- It initializes this variable by calling a function or method named `this_multi_grid()`, which presumably returns an object or value of type `multi_grid_group`.
-
-The purpose of this line is to create an instance of `multi_grid_group` and assign it to the variable `multi_grid`, using the result from `this_multi_grid()`. This suggests that `this_multi_grid()` is a function that provides or constructs a `multi_grid_group` object, possibly representing a grid or a collection of grids in a multi-grid system.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-        static constexpr const char gpu_program[] {
-```
-
-hiprtcAddNameExpression is called with various name expressions referring to the address of \_\_global\_\_ functions and \_\_device\_\_/\_\_constant\_\_ variables.
-**Following code does:** This code snippet appears to be a method call on an object or module named `multi_grid`. The method `sync()` is likely intended to synchronize or coordinate data or processes across multiple grids or components within a system. This could involve ensuring that all parts of a distributed system are updated to the same state or that parallel computations are aligned. The exact functionality would depend on the implementation details of the `multi_grid` object and its `sync()` method.
-
-
-```
-kernel_name_vec.push_back("&f1");
-kernel_name_vec.push_back("N1::N2::f2");
-kernel_name_vec.push_back("f3<int>");
-for (auto&& x : kernel_name_vec) hiprtcAddNameExpression(prog, x.c_str());
-variable_name_vec.push_back("&V1");
-```
-
-(continues on next page)
-
-(continued from previous page)
-**Following code does:** This code is a C++ program that uses the HIP (Heterogeneous-Compute Interface for Portability) runtime API to check if the current GPU device supports concurrent managed memory access. It retrieves the current GPU device, checks the `hipDeviceAttributeConcurrentManagedAccess` attribute, and then prints a message to the console indicating whether concurrent managed memory access is supported by the device.
-
-
-```
-auto&& x : variable_name_vec) hiprtcAddNameExpression(prog, x.c_str());
-```
-**Following code does:** The code snippet provided appears to be mostly empty space with some scattered characters, including slashes and curly braces, which are typically used in programming languages like C, C++, or Java for comments and code blocks. However, the snippet does not contain any functional code or meaningful structure. It seems to be either incomplete or corrupted, and thus does not perform any specific operation or serve a high-level purpose.
-
-
-```
-        | variable_name_vec.push_back("&N1::N2::V2");
-        for (auto&& x : variable_name_vec) hiprtcAddNameExp
-```
-
-After which, the program is compiled using hiprtcCompileProgram and the generated binary is loaded using hipModuleLoadData . And the mangled names can be fetched using hirtcGetLoweredName .
-**Following code does:** This code is a simple GPU program using HIP (Heterogeneous-Compute Interface for Portability) to perform the addition of two integers on a GPU. It defines a kernel function `add` that takes pointers to three integers and computes the sum of the first two, storing the result in the third. The variables `a`, `b`, and `c` are declared as managed memory, allowing them to be accessed by both the host (CPU) and the device (GPU). The `main` function initializes `a` and `b` with values 1 and 2, respectively, and then launches the `add` kernel on the GPU. After ensuring the GPU computation is complete with `hipDeviceSynchronize`, it prints the result of the addition. The code demonstrates basic GPU computation and memory management using HIP.
-
-
-```
-for (decltype(variable_name_vec.size()) i = 0; i!= variable_name_vec.size(); ++i) {
-  const char* name;
-  hiprtcGetLoweredName(prog, variable_name_vec[i].c_str(), &name);
-}
-```
-**Following code does:** This code snippet is a partial implementation of a program using HIP (Heterogeneous-Compute Interface for Portability) to perform addition on a GPU. It defines a simple CUDA kernel function `add` that takes pointers to three integers and assigns the sum of the first two integers to the third. In the `main` function, memory is allocated on the host for three integer pointers `a`, `b`, and `c`, and initial values are assigned to `a` and `b`. The code is incomplete as it does not include the necessary steps to allocate memory on the GPU, copy data to the GPU, launch the kernel, or retrieve the result from the GPU.
-
-
-```
-    for (decltype(kernel_name_vec.size()) i = 0; i!= kernel_name_vec.size(); ++i) {
-      const char* name;
-      hiprtcGetLoweredName(prog, kernel_name_vec[i].c_str(), &name);
-    }
-```
-
-The mangled name of the variables are used to look up the variable in the module and update its value.
-**Following code does:** This code snippet is part of a program that performs a simple addition operation on a GPU using the HIP (Heterogeneous-Compute Interface for Portability) API. It launches a kernel function named `add` on the GPU with a single thread block and a single thread. After the kernel execution, it synchronizes the device to ensure the GPU has finished processing before accessing the results on the host. The result of the addition is then printed to the console. Finally, it frees the allocated memory for the variables `a`, `b`, and `c` before the program terminates.
-
-
-```
-        hipDeviceptr_t variable_addr;
-        size_t bytes{};
-        hipModuleGetGlobal(&variable_addr, &bytes, module, name);
-        hipMemcpyHtoD(variable_addr, &initial_value, sizeof(initial_value));
-```
-
-Finally, the mangled name of the kernel is used to launch it using the hipModule APIs.
-**Following code does:** This code snippet is a simple example of using HIP (Heterogeneous-Compute Interface for Portability) to perform addition on a GPU. It demonstrates explicit memory management in a GPU programming context. The code allocates memory on the GPU for three integers, copies two input values from the host (CPU) to the GPU, and then launches a kernel function `add` on the GPU to compute the sum of these two values. The result is then copied back from the GPU to the host. This example illustrates basic GPU programming concepts such as memory allocation, data transfer between host and device, and kernel execution.
-
-
-```
-        hipFunction_t kernel;
-        hipModuleGetFunction(&kernel, module, name);
-        hipModuleLaunchKernel(kernel, 1, 1, 1, 1, 1, 0, nullptr, nullptr, config);
-```
-
-Please have a look at hiprtcGetLoweredName.cpp for the detailed example.
-
-## 10.7 Versioning
-
-HIPRTC follows the below versioning.
-
-- Linux
-- -HIPRTC follows the same versioning as HIP runtime library.
-- -The so name field for the shared library is set to MAJOR version. For example, for HIP 5.3 the so name is set to 5 ( hiprtc.so.5 ).
-- Windows
-- -HIPRTC dll is named as hiprtcXXYY.dll where XX is MAJOR version and YY is MINOR version. For example, for HIP 5.3 the name is hiprtc0503.dll .
-
-## 10.8 HIP header support
-
-- Added HIPRTC support for all the hip common header files such as library\_types.h, hip\_math\_constants.h, hip\_complex.h, math\_functions.h, surface\_types.h etc. from 6.1. HIPRTC users need not include any HIP macros or constants explicitly in their header files. All of these should get included via HIPRTC builtins when the app links to HIPRTC library.
-
-## 10.9 Deprecation notice
-
-- Currently HIPRTC APIs are separated from HIP APIs and HIPRTC is available as a separate library libhiprtc. so / libhiprtc.dll . But on Linux, HIPRTC symbols are also present in libamdhip64.so in order to support the existing applications. Gradually, these symbols will be removed from HIP library and applications using HIPRTC will be required to explicitly link to HIPRTC library. However, on Windows hiprtc.dll must be used as the amdhip64.dll doesn't contain the HIPRTC symbols.
-- Data types such as uint32\_t , uint64\_t , int32\_t , int64\_t defined in std namespace in HIPRTC are deprecated earlier and are being removed from ROCm release 6.1 since these can conflict with the standard C++ data types. These data types are now prefixed with \_\_hip\_\_ , e.g. \_\_hip\_uint32\_t . Applications previously using std::uint32\_t or similar types can use \_\_hip\_ prefixed types to avoid conflicts with standard std namespace or application can have their own definitions for these types. Also, type\_traits templates previously defined in std namespace are moved to \_\_hip\_internal namespace as implementation details.
-
-## CHAPTER
-
-## ELEVEN
-
-## PERFORMANCE GUIDELINES
-
-The AMDHIPPerformance Guidelines are a set of best practices designed to help developers optimize the performance of AMD GPUs. They cover established parallelization and optimization techniques, coding metaphors, and idioms that can greatly simplify programming for HIP-capable GPU architectures.
-
-By following four main cornerstones, we can exploit the performance optimization potential of HIP.
-
-- parallel execution
-- memory usage optimization
-- optimization for maximum throughput
-- minimizing memory thrashing
-
-In the following chapters, we will show you their benefits and how to use them effectively.
-
-## 11.1 Parallel execution
-
-For optimal use, the application should reveal and efficiently imply as much parallelism as possible to keep all system components active.
-
-## 11.1.1 Application level
-
-The application should optimize parallel execution across the host and devices using asynchronous calls and streams. Workloads should be assigned based on efficiency: serial to the host, parallel to the devices.
-
-For parallel workloads, when threads need to synchronize to share data, if they belong to the same block, they should use \_\_syncthreads() (see: Synchronization functions ) within the same kernel invocation. If they belong to different blocks, they must use global memory with two separate kernel invocations. The latter should be minimized as it adds overhead.
-
-## 11.1.2 Device level
-
-Device-level optimization primarily involves maximizing parallel execution across the multiprocessors of the device. This can be achieved by executing multiple kernels concurrently on a device. The management of these kernels is facilitated by streams, which allow for the overlapping of computation and data transfers, enhancing performance. The aim is to keep all multiprocessors busy by executing enough kernels concurrently. However, launching too many kernels can lead to resource contention, so a balance must be found for optimal performance. This approach helps in achieving maximum utilization of the resources of the device.
-
-## 11.1.3 Multiprocessor level
-
-Multiprocessor-level optimization involves maximizing parallel execution within each multiprocessor on a device. Each multiprocessor can execute a number of threads concurrently, and the total number of threads that can run in parallel is determined by the number of concurrent threads each multiprocessor can handle.
-
-The key to multiprocessor-level optimization is to efficiently utilize the various functional units within a multiprocessor. This can be achieved by ensuring a sufficient number of resident warps, as at every instruction issue time, a warp scheduler selects an instruction that is ready to execute. This instruction can be another independent instruction of the same warp, exploiting Optimization for maximum instruction throughput , or more commonly an instruction of another warp, exploiting thread-level parallelism.
-
-In comparison, device-level optimization focuses on the device as a whole, aiming to keep all multiprocessors busy by executing enough kernels concurrently. Both levels of optimization are crucial for achieving maximum performance. They work together to ensure efficient utilization of the resources of the GPU, from the individual multiprocessors to the device as a whole.
-
-## 11.2 Memory optimization
-
-The first step in maximizing memory throughput is to minimize low-bandwidth data transfers. This involves reducing data transfers between the host and the device, as these have lower bandwidth than transfers between global memory and the device.
-
-Additionally, data transfers between global memory and the device should be minimized by maximizing the use of on-chip memory: shared memory and caches. Shared memory acts as a user-managed cache, where the application explicitly allocates and accesses it. A common programming pattern is to stage data from device memory into shared memory. This involves each thread of a block loading data from device memory to shared memory, synchronizing with all other threads of the block, processing the data in shared memory, synchronizing again if necessary, and writing the results back to device global memory.
-
-For some applications, a traditional hardware-managed cache is more appropriate to exploit data locality. On devices of certain compute capabilities, the same on-chip memory is used for both L1 and shared memory, and the amount dedicated to each is configurable for each kernel call.
-
-Finally, the throughput of memory accesses by a kernel can vary significantly depending on the access pattern for each type of memory. Therefore, the next step in maximizing memory throughput is to organize memory accesses as optimally as possible. This is especially important for global memory accesses, as global memory bandwidth is low compared to available on-chip bandwidths and arithmetic instruction throughput. Thus, non-optimal global memory accesses generally have a high impact on performance.
-
-## 11.2.1 Data Transfer
-
-Applications should aim to minimize data transfers between the host and the device. This can be achieved by moving more computations from the host to the device, even if it means running kernels that do not fully utilize the parallelism for device. Intermediate data structures can be created, used, and discarded in device memory without being mapped or copied to host memory.
-
-Batching small transfers into a single large transfer can improve performance due to the overhead associated with each transfer. On systems with a front-side bus, using page-locked host memory can enhance data transfer performance.
-
-When using mapped page-locked memory, there is no need to allocate device memory or explicitly copy data between device and host memory. Data transfers occur implicitly each time the kernel accesses the mapped memory. For optimal performance, these memory accesses should be coalesced, similar to global memory accesses.
-
-On integrated systems where device and host memory are physically the same, any copy operation between host and device memory is unnecessary, and mapped page-locked memory should be used instead. Applications can check if a device is integrated by querying the integrated device property.
-
-## 11.2.2 Device Memory Access
-
-Memory access instructions may be repeated due to the spread of memory addresses across warp threads. The impact on throughput varies with memory type and is generally reduced when addresses are more scattered, especially in global memory.
-
-Device memory is accessed via 32-, 64-, or 128-byte transactions that must be naturally aligned. Maximizing memory throughput involves coalescing memory accesses of threads within a warp into minimal transactions, following optimal access patterns, using properly sized and aligned data types, and padding data when necessary.
-
-Global memory instructions support reading or writing data of specific sizes (1, 2, 4, 8, or 16 bytes) that are naturally aligned. If the size and alignment requirements are not met, it leads to multiple instructions, reducing performance. Therefore, using data types that meet these requirements, ensuring alignment for structures, and maintaining alignment for all values or arrays is crucial for correct results and optimal performance.
-
-Threads often access 2D arrays at an address calculated as BaseAddress + xIndex + width * yIndex . For efficient memory access, the array and thread block widths should be multiples of the warp size. If the array width is not a multiple of the warp size, it is usually more efficient to allocate it with a width rounded up to the nearest multiple and pad the rows accordingly.
-
-Local memory is used for certain automatic variables, such as arrays with non-constant indices, large structures or arrays, and any variable when the kernel uses more registers than available. Local memory resides in device memory, leading to high latency and low bandwidth similar to global memory accesses. However, it is organized for consecutive 32-bit words to be accessed by consecutive thread IDs, allowing full coalescing when all threads in a warp access the same relative address.
-
-Shared memory, located on-chip, provides higher bandwidth and lower latency than local or global memory. It is divided into banks that can be simultaneously accessed, boosting bandwidth. However, bank conflicts, where two addresses fall in the same bank, lead to serialized access and decreased throughput. Therefore, understanding how memory addresses map to banks and scheduling requests to minimize conflicts is crucial for optimal performance.
-
-Constant memory is in device memory and cached in the constant cache. Requests are split based on different memory addresses, affecting throughput, and are serviced at the throughput of the constant cache for cache hits, or the throughput of the device memory otherwise.
-
-Texture and surface memory are stored in device memory and cached in texture cache. This setup optimizes 2D spatial locality, leading to better performance for threads reading close 2D addresses. Reading device memory through texture or surface fetching can be advantageous, offering higher bandwidth for local texture fetches or surface reads, offloading addressing calculations, allowing data broadcasting, and optional conversion of 8-bit and 16-bit integer input data to 32-bit floating-point values on-the-fly.
-
-## 11.3 Optimization for maximum instruction throughput
-
-To maximize instruction throughput:
-
-- minimize low throughput arithmetic instructions
-- minimize divergent warps inflicted by control flow instructions
-- minimize the number of instruction as possible
-- maximize instruction parallelism
-
-## 11.3.1 Arithmetic instructions
-
-The type and complexity of arithmetic operations can significantly impact the performance of your application. We are highlighting some hints how to maximize it.
-
-Using efficient operations: Some arithmetic operations are more costly than others. For example, multiplication is typically faster than division, and integer operations are usually faster than floating-point operations, especially with double-precision.
-
-Minimizing low-throughput instructions: This might involve trading precision for speed when it does not affect the final result. For instance, consider using single-precision arithmetic instead of double-precision.
-
-Leverage intrinsic functions: Intrinsic functions are pre-defined functions available in HIP that can often be executed faster than equivalent arithmetic operations (subject to some input or accuracy restrictions). They can help optimize performance by replacing more complex arithmetic operations.
-
-Avoiding divergent warps: Divergent warps occur when threads within the same warp follow different execution paths. This can happen due to conditional statements that lead to different arithmetic operations being performed by different threads. Divergent warps can significantly reduce instruction throughput, so try to structure your code to minimize divergence.
-
-Optimizing memory access: The efficiency of memory access can impact the speed of arithmetic operations. Coalesced memory access, where threads in a warp access consecutive memory locations, can improve memory throughput and thus the speed of arithmetic operations.
-
-Maximizing instruction parallelism: Some GPU architectures could issue parallel independent instructions simultaneously, for example integer and floating point, or two operations with independent inputs and outputs. Mostly this is a work for compiler, but expressing parallelism in the code explicitly can improve instructions throughput.
-
-## 11.3.2 Control flow instructions
-
-Flow control instructions ( if , else , for , do , while , break , continue , switch ) can impact instruction throughput by causing threads within a warp to diverge and follow different execution paths. To optimize performance, control conditions should be written to minimize divergent warps. For example, when the control condition depends on ( threadIdx / warpSize ), no warp diverges. The compiler may optimize loops or short if or switch blocks using branch predication, preventing warp divergence. With branch predication, instructions associated with a false predicate are scheduled but not executed, avoiding unnecessary operations.
-
-## 11.3.3 Synchronization
-
-Synchronization ensures that all threads within a block have completed their computations and memory accesses before moving forward, which is critical when threads are dependent on the results of other threads. However, synchronization can also lead to performance overhead, as it requires threads to wait, potentially leading to idle GPU resources.
-
-\_\_syncthreads() is used to synchronize all threads in a block, ensuring that all threads have reached the same point in the code and that shared memory is visible to all threads after the point of synchronization.
-
-An alternative way to synchronize is using streams. Different streams can execute commands out of order with respect to one another or concurrently. This allows for more fine-grained control over the execution order of commands, which can be beneficial in certain scenarios.
-
-## 11.4 Minimizing memory thrashing
-
-Applications frequently allocating and freeing memory may experience slower allocation calls over time. This is expected as memory is released back to the operating system. To optimize performance in such scenarios, consider some recommendations:
-
-- avoid allocating all available memory with hipMalloc / hipHostMalloc , as this immediately reserves memory and can block other applications from using it. This could strain the operating system schedulers or even prevent other applications from running on the same GPU.
-- aim to allocate memory in suitably sized blocks early in the lifecycle of the application and deallocate only when the application no longer needs it. Minimize the number of hipMalloc and hipFree calls in your application, particularly in areas critical to performance.
-- if an application is unable to allocate sufficient device memory, consider resorting to other memory types such as hipHostMalloc or hipMallocManaged . While these may not offer the same performance, they can allow the application to continue running.
-- For supported platforms, hipMallocManaged allows for oversubscription. With the right memory advise policies, it can maintain most, if not all, of the performance of hipMalloc . hipMallocManaged does not require an allocation to be resident until it is needed or prefetched, easing the load on the operating system schedulers and facilitating multi-tenant scenarios.
-
-CHAPTER
-
-## TWELVE
-
-## DEBUGGING WITH HIP
-
-AMDdebugging tools include ltrace and ROCgdb . External tools are available and can be found online. For example, if you're using Windows, you can use Microsoft Visual Studio and WinGDB .
-
-You can trace and debug your code using the following tools and techniques.
-
-## 12.1 Tracing
-
-You can use tracing to quickly observe the flow of an application before reviewing the detailed information provided by a command-line debugger. Tracing can be used to identify issues ranging from accidental API calls to calls made on a critical path.
-
-ltrace is a standard Linux tool that provides a message to stderr on every dynamic library call. You can use ltrace to visualize the runtime behavior of the entire ROCm software stack.
-
-Here's a simple command-line example that uses ltrace to trace HIP APIs and output:
-**Following code does:** This code snippet is part of a larger program that uses HIP, a C++ runtime API for GPU programming. The snippet performs two main tasks: 
-
-1. It frees up memory that was previously allocated on the GPU for three variables (`d_a`, `d_b`, and `d_c`) using the `hipFree` function. This is a cleanup operation to release resources and prevent memory leaks.
-
-2. It prints the result of an addition operation to the console, displaying the values of `a`, `b`, and their sum `c` in the format "a + b = c".
-
-Finally, the function returns 0, indicating successful execution.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?php?^"./hipGetChanDesc
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        </?php?^"
-	                                                                                                                                                                                                     
-		                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       <!
-                                                                                                                                                                                                      
-
-	                                                                                                                                                                                                       <%
-                                                                                                                                                                                                       </%
-                                                                                                                                                                                                      <?>
-                                                                                                                                                                                                       >
-```
-
-Here's another example that uses ltrace to trace hsa APIs and output:
-**Following code does:** This code snippet appears to be a collection of comments and symbols that do not form a valid or functional piece of code. It seems to be a mix of comment syntax from different programming languages (e.g., `//`, `/* ... */`) and other characters, but it does not perform any operations or have any executable logic. It might be a placeholder or an artifact from code formatting or editing.
-
-
-```
-        Here's another example that uses ltrace to trace hsa APIs and output:
-        $ ltrace  -C -e "hsa*"./hipGetChanDesc
-        libamdhip64.so.4->hsa_init(0, 0x7fff325a69d0, 0x9c80e0, 0 <unfinished...>
-        libhsa-runtime64.so.1->hsaKmtOpenKFD(0x7fff325a6590, 0x9c38c0, 0, 1) = 0
-        libhsa-runtime64.so.1->hsaKmtGetVersion(0x7fff325a6608, 0, 0, 0) = 0
-        libhsa-runtime64.so.1->hsaKmtReleaseSystemProperties(3, 0x80084b01, 0, 0) = 0
-        libhsa-runtime64.so.1->hsaKmtAcquireSystemProperties(0x7fff325a6610, 0, 0, 1) = 0
-        libhsa-runtime64.so.1->hsaKmtGetNodeProperties(0, 0x7fff325a66a0, 0, 0) = 0
-        libhsa-runtime64.so.1->hsaKmtGetNodeMemoryProperties(0, 1, 0x9c42b0, 0x936012) = 0
-       ...
-        <... hsaKmtCreateEvent  resumed> )                                                                                                                                                                                                        
-        libhsa-runtime64.so.1->hsaKmtAllocMemory(0, 4096, 64, 0x7fff325a6690) = 0
-        libhsa-runtime64.so.1->hsaKmtMapMemoryToGPUNodes(0x7f1202749000, 4096, 0x7fff325a6690,,...
-        --0) = 0
-        libhsa-runtime64.so.1->hsaKmtCreateEvent(0x7fff325a6700, 0, 0, 0x7fff325a66f0) = 0
-                                                                                                                                                                                                        (continues on next page)
-```
-
-(continues on next page)
-
-(continued from previous page)
-**Following code does:** This code snippet demonstrates a simple GPU-accelerated program using HIP (Heterogeneous-Compute Interface for Portability) to perform the addition of two integers. It allocates managed memory for three integers (`a`, `b`, and `c`) that can be accessed by both the CPU and GPU. The program sets memory advice to optimize data placement and access patterns, indicating that the memory should be preferred for CPU access and read mostly from the GPU. It initializes the values of `a` and `b`, launches a GPU kernel to compute their sum, synchronizes the device to ensure computation is complete, and then prints the result. Finally, it frees the allocated memory. The use of `hipMemAdvise` helps optimize performance by guiding the runtime on how to handle memory access efficiently.
-
-
-```
-HIP Documentation, Release 6.1.40092
-```
-
-## 12.2 Debugging
-
-You can use ROCgdb for debugging and profiling.
-
-ROCgdbis the ROCm source-level debugger for Linux and is based on GNU Project debugger (GDB). the GNU sourcelevel debugger, equivalent of CUDA-GDB, can be used with debugger frontends, such as Eclipse, Visual Studio Code, or GDB dashboard. For details, see (https://github.com/ROCm/ROCgdb).
-
-Below is a sample how to use ROCgdb run and debug HIP application, ROCgdb is installed with ROCM package in the folder /opt/rocm/bin.
-**Following code does:** This code snippet is part of a larger program that uses the HIP (Heterogeneous-Compute Interface for Portability) API, which is designed for GPU programming. The specific lines shown here are responsible for freeing or deallocating memory that was previously allocated on the GPU for the variables `b` and `c`. This is done using the `hipFree` function, which releases the memory resources associated with these variables. The `return 0;` statement indicates that the program is terminating successfully. Overall, this snippet is part of the cleanup process in a GPU-accelerated application.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <p>
-                                                                                                                                                                                                       <h1>
-                                                                                                                                                                                                      <p/>
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        </p>
-                                                                                                                                                                                                     <p>
-
-                                                                                                                                                                                                       <a>
-                                                                                                                                                                                                     
- 	                                                                                                                                                                                                       <b>
-                                                                                                                                                                                                      </a>
-                                                                                                                                                                                                     <a>
-
-                                                                                                                                                                                                      <b/>
-                                                                                                                                                                                                      <a/>
-                                                                                                                                                                                                     
-		                                                                                                                                                                                                      
-
-	                                                                                                                                                                                                      <a></b>
-```
-
-## 12.2.1 Debugging HIP applications
-
-The following Linux example shows how to get useful information from the debugger while running a simple memory copy test, which caused a segmentation fault issue.
-**Following code does:** This code snippet demonstrates a simple example of using HIP (Heterogeneous-Compute Interface for Portability) to perform a basic addition operation on a GPU. It allocates managed memory for three integers (`a`, `b`, and `c`) that can be accessed by both the host (CPU) and the device (GPU). The `add` kernel function is launched on the GPU to compute the sum of `a` and `b`, storing the result in `c`. After synchronizing the device to ensure the computation is complete, the code queries a memory range attribute (`hipMemRangeAttributeReadMostly`) for the memory range pointed to by `a` and stores the result in `attributeValue`. Finally, it prints the result of the addition. The code illustrates basic memory management and kernel execution in a HIP environment.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <p>test, which caused a segmentation fault issue.                                                                                                                                                                                                        </p>                                                                                                                                                                                                        >
-                                                                                                                                                                                                       <a>http://tests/src/runtimeApi/memory/hipMemcpy_simple.cpp:147
-```
-
-(continues on next page)
-
-(continued from previous page)
-**Following code does:** This code snippet is part of a C++ program that outputs the value of a queried attribute to the console. After displaying the attribute value, it performs cleanup by freeing memory that was previously allocated for three variables (`a`, `b`, and `c`) using the `hipFree` function, which is typically used in programs that utilize HIP (Heterogeneous-Compute Interface for Portability) for managing GPU memory. Finally, the program returns 0, indicating successful execution.
-
-
-```
-HIP Documentation, Release 6.1.40092
-
-
-                                                                                                                                                                                                         (continued from previous page)                                                                                                                                                                                                       
-                                                                                                                                                                                                      
-1                                                                                                                                                                                                        "                                                                                                                                                                                                        <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        </----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                    <-----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        >----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                   
-1   //                                                                                                                                                                                                        :                                                                                                                                                                                                        |                                                                                                                                                                                                        -                                                                                                                                                                                                        +                                                                                                                                                                                                        \
-                                                                                                                                                                                                       |
-                                                                                                                                                                                                       <============================================================================================                                                                                                                                                                                                        }                                                                                                                                                                                                        )
-```
-
-Debugging HIP applications using Windows tools can be more informative than on Linux. Windows tools provides more visibility into debug codes, which makes it easier to inspect variables, watch multiple details, and examine call stacks.
-
-## 12.3 Useful environment variables
-
-HIP provides environment variables that allow HIP, hip-clang, or HSA drivers to prevent certain features and optimizations. These are not intended for production, but can be useful to diagnose synchronization problems in the application (or driver).
-
-Some of the more widely used environment variables are described in this section. These are supported on the Linux ROCm path and Windows.
-
-## 12.3.1 Kernel enqueue serialization
-
-You can control kernel command serialization from the host:
-
-## AMD\_SERIALIZE\_KERNEL , for serializing kernel enqueue
-
-AMD\_SERIALIZE\_KERNEL = 1 , Wait for completion before enqueue AMD\_SERIALIZE\_KERNEL = 2 , Wait for completion after enqueue AMD\_SERIALIZE\_KERNEL = 3 , Both
-
-Or
-
-## AMD\_SERIALIZE\_COPY , for serializing copies
-
-AMD\_SERIALIZE\_COPY = 1 , Wait for completion before enqueue AMD\_SERIALIZE\_COPY = 2 , Wait for completion after enqueue AMD\_SERIALIZE\_COPY = 3 , Both
-
-So HIP runtime can wait for GPU idle before/after any GPU command depending on the environment setting.
-
-## 12.3.2 Making device visible
-
-For systems with multiple devices, you can choose to make only certain device(s) visible to HIP using HIP\_VISIBLE\_DEVICES (or CUDA\_VISIBLE\_DEVICES on an NVIDIA platform). Once enabled, HIP can only view devices that have indices present in the sequence. For example:
-**Following code does:** The code snippet `<_C_>` appears to be a placeholder or a non-functional piece of code. It does not represent any valid Python syntax or operation. It might be intended as a marker or a template for where actual code should be inserted.
-
-
-```
-    | $ HIP_VISIBLE_DEVICES=0,1
-```
-**Following code does:** The code snippet `0) ;` is not valid Python code. It appears to be a fragment or typo, as it does not form a complete or meaningful statement in Python.
-
-
-```
-<_Python_>
-```
-**Following code does:** It seems there is a formatting error in your request. The code snippet is labeled as Python, but the content is marked as C++. Please provide the correct code snippet or clarify the language so I can assist you accurately.
-
-
-```
-if (totalDeviceNum > 2) {
-setenv("HIP_VISIBLE_DEVICES", "0,1,2", 1);
-assert(getDeviceNumber(false) == 3);
-
-.......
-}
-```
-
-## 12.3.3 Dump code object
-
-To analyze compiler-related issues, you can use the dump code object: GPU\_DUMP\_CODE\_OBJECT .
-
-## 12.3.4 HSA-related environment variables (Linux)
-
-HSA provides environment variables that help analyze issues in drivers or hardware.
-
-- To isolate issues with hardware copy engines, you can use HSA\_ENABLE\_SDMA .
-- HSA\_ENABLE\_SDMA=0 causes host-to-device and device-to-host copies to use compute shader blit kernels, rather than the dedicated DMA copy engines. Compute shader copies have low latency (typically &lt; 5 us) and can achieve approximately 80% of the bandwidth of the DMA copy engine.
-- To diagnose interrupt storm issues in the driver, you can use HSA\_ENABLE\_INTERRUPT .
-
-HSA\_ENABLE\_INTERRUPT=0 causes completion signals to be detected with memory-based polling, rather than interrupts.
-
-## 12.3.5 HIP environment variable summary
-
-Here are some of the more commonly used environment variables:
-
-| Environment variable                                                                                                          | De- fault value   | Usage                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-|-------------------------------------------------------------------------------------------------------------------------------|-------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| AMD_LOG_LEVEL Enable HIP log on different Level                                                                               | 0                 | 0: Disable log. 1: Enable log on error level 2: Enable log on warning and below levels 0x3: Enable log on information and below levels 0x4: Decode and display AQL packets                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-| AMD_LOG_MASK Enable HIP log on different Level                                                                                |                   | 0x7FFFFFFF 0x1: Log API calls 0x02: Kernel and Copy Commands and Barriers 0x4: Synchroniza- tion and waiting for commands to finish 0x8: Enable log on information and below levels 0x20: Queue commands and queue contents 0x40: Signal creation, allocation, pool 0x80: Locks and thread-safety code 0x100: Copy debug 0x200: Detailed copy debug 0x400: Resource allocation, performance-impacting events 0x800: Initialization and shutdown 0x1000: Misc debug, not yet classified 0x2000: Show raw bytes of AQL packet 0x4000: Show code creation debug 0x8000: More detailed command info, including barrier com- mands 0x10000: Log message location 0xFFFFFFFF: Log always even mask flag is zero |
-| HIP_LAUNCH_BLOCKING Used for serial- ization on kernel execution.                                                             | 0                 | 0: Disable. Kernel executes normally. 1: Enable. Serializes kernel enqueue, behaves the same as AMD_SERIALIZE_KERNEL.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| HIP_VISIBLE_DEVICES (or CUDA_VISIBLE_DEVICES) Only devices whose index is present in the sequence are visible to HIP          |                   | 0,1,2: Depending on the number of devices on the system                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| GPU_DUMP_CODE_OBJECT Dump code ob- ject                                                                                       | 0                 | 0: Disable 1: Enable                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| AMD_SERIALIZE_KERNEL Serialize kernel enqueue                                                                                 | 0                 | 1: Wait for completion before enqueue 2: Wait for completion after enqueue 3: Both                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
-| AMD_SERIALIZE_COPY Serialize copies                                                                                           | 0                 | 1: Wait for completion before enqueue 2: Wait for completion after enqueue 3: Both                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
-| HIP_HOST_COHERENT Coherent mem-                                                                                               | 0                 | 0: memory is not coherent between host and GPU 1: memory is coherent with host                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
-| ory in hipHost- Malloc AMD_DIRECT_DISPATCH Enable direct kernel dispatch (Currently for Linux; under development for Windows) | 1                 | 0: Disable 1: Enable                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| GPU_MAX_HW_QUEUES The maximum number of hard- ware queues allocated per device                                                | 4                 | The variable controls how many independent hardware queues HIP runtime can create per process, per device. If an application allocates more HIP streams than this number, then HIP runtime reuses the same hardware queues for the new streams in a round-robin manner. Note that this maximum number does not apply to hardware queues that are created for CU-masked HIP streams, or cooperative queues for HIP Cooperative Groups (single queue per device).                                                                                                                                                                                                                                           |
-
-## 12.4 General debugging tips
-
-- gdb --args can be used to pass the executable and arguments to gdb .
-- You can set environment variables ( set env ) from within GDB on Linux:
-**Following code does:** This code snippet is configuring memory access permissions for a specific memory region in a HIP (Heterogeneous-Compute Interface for Portability) application, which is used for GPU programming. It sets up a `hipMemAccessDesc` structure to specify that a memory region, identified by `ptr` and of size `padded_size`, should be accessible for both reading and writing on a specific GPU device (`currentDev`). The `hipMemSetAccess` function is then called to apply these access permissions.
-
-
-```
-        | (gdb)  set env  AND_SERIALIZE_KERNEL  3
-```
-
-Note: This gdb command does not use an equal (=) sign.
-
-- The GDB backtrace shows a path in the runtime. This is because a fault is caught by the runtime, but it is generated by an asynchronous command running on the GPU.
-- To determine the true location of a fault, you can force the kernels to run synchronously by setting the environment variables AMD\_SERIALIZE\_KERNEL=3 and AMD\_SERIALIZE\_COPY=3 . This forces HIP runtime to wait for the kernel to finish running before returning. If the fault occurs when a kernel is running, you can see the code that launched the kernel inside the backtrace. The thread that's causing the issue is typically the one inside libhsa-runtime64.so .
-- VMfaults inside kernels can be caused by:
-- -Incorrect code (e.g., a for loop that extends past array boundaries)
-- -Memory issues, such as invalid kernel arguments (null pointers, unregistered host pointers, bad pointers)
-- -Synchronization issues
-- -Compiler issues (incorrect code generation from the compiler)
-- -Runtime issues
-
-## CHAPTER
-
-## THIRTEEN
-
-## LOGGING HIP ACTIVITY
-
-HIP provides a logging mechanism that allows you to trace HIP API and runtime codes when running a HIP application. In addition to being useful to our users/developers, the HIP development team uses these logs to improve the HIP runtime.
-
-By adjusting the logging settings and logging mask, you can get different types of information for different functionalities, such as HIP APIs, executed kernels, queue commands, and queue contents. Refer to the following sections for examples.
-
-Tip: Logging works for the release and debug versions of HIP. If you want to save logging output in a file, define the file when running the application via command line. For example:
-**Following code does:** This code snippet is related to memory management in a GPU context using the HIP (Heterogeneous-Compute Interface for Portability) API, which is used for writing portable applications that can run on AMD and NVIDIA GPUs. 
-
-The two functions perform the following high-level tasks:
-
-1. `hipMemUnmap(ptr, size);`: This function unmaps a previously mapped memory region from the host's address space. The `ptr` is the pointer to the memory region, and `size` specifies the size of the memory to be unmapped.
-
-2. `hipMemRelease(allocHandle);`: This function releases or deallocates the memory associated with a given allocation handle (`allocHandle`). It effectively frees the memory resources that were previously allocated.
-
-Overall, the code is responsible for cleaning up GPU memory resources by unmapping and releasing them, which is crucial for preventing memory leaks and ensuring efficient memory usage in GPU applications.
-
-
-```
-            |user@user-test:~/hip/bin$./hipinfo > ~/hipinfo > ~/hip_log.txt
-```
-
-## 13.1 Logging level
-
-HIP logging is disabled by default. You can enable it via the AMD\_LOG\_LEVEL environment variable. The value of this variable controls your logging level. Levels are defined as follows:
-**Following code does:** This code snippet appears to be a call to a function named `hipMemAddressFree`, which is likely part of the HIP (Heterogeneous-Compute Interface for Portability) API used for GPU programming. The function is intended to free or release a block of memory that was previously allocated, identified by the pointer `ptr`, and of a specified `size`. This operation is typically used to manage memory resources efficiently in GPU applications. The vertical bar `|` at the beginning seems to be a typographical error or an artifact, as it is not standard syntax in Python or C/C++.
-
-
-```
-                                                                                                                                                                                                       
-  enum LogLevel {
-      LOG_NONE       = 0,
-      LOG_ERROR     = 1,
-      LOG_WARNING = 2,
-      LOG_INFO       = 3,
-      LOG_DEBUG     = 4
-  };
-```
-
-Tip: You can call a logging function with different logging levels. All information under the value set for AMD\_LOG\_LEVEL is printed.
-
-## 13.2 Logging mask
-
-The logging mask is designed to print functionality types when you're running a HIP application. Once you set AMD\_LOG\_LEVEL , the logging mask is set as the default value ( 0x7FFFFFFF ). You can change this to any of the valid values:
-**Following code does:** This code snippet is part of a memory management process using HIP (Heterogeneous-Compute Interface for Portability), which is a framework for GPU programming. The code performs the following high-level tasks:
-
-1. **Memory Reservation**: It reserves a block of memory starting at a specified address (`ptr + padded_size`) with a size of `new_size - padded_size`. This is done using `hipMemAddressReserve`, which allocates a virtual address space without actually allocating physical memory.
-
-2. **Memory Mapping**: It maps the reserved virtual memory to a physical memory allocation using `hipMemMap`. This associates the reserved address space (`new_ptr`) with a physical memory allocation identified by `newAllocHandle`.
-
-3. **Setting Memory Access**: It sets the access permissions for the mapped memory using `hipMemSetAccess`. This specifies how the memory can be accessed (e.g., read, write) based on the provided `accessDesc`.
-
-Overall, this code is setting up a reserved and mapped memory region with specific access permissions in a GPU context.
-
-
-```
-        The logging mask is designed to print functionality types when you're running a HIP application.  Once you set
-        AMD_LOG_LEVEL, the logging mask is set as the default value (0x7FFFFFFF). You can change this to any of the valid
-        values:
-
-        enum LogMask {
-          LOG_API         = 0x000000001,  //!< API call
-          LOG_CMD         = 0x000000002,  //!< Kernel and Copy Commands and Barriers
-          LOG_WAIT        = 0x000000004,  //!< Synchronization and waiting for commands to finish
-          LOG_AQL         = 0x000000008,  //!< Decode and display AQL packets
-          LOG_QUEUE      = 0x00000010,  //!< Queue commands and queue contents
-          LOG_SIG         = 0x00000020,  //!< Signal creation, allocation, pool
-          LOG_LOCK        = 0x00000040,  //!< Locks and thread-safety code.
-          LOG_KERN        = 0x00000080,  //!< kernel creations and arguments, etc.
-          LOG_COPY        = 0x000000100,  //!< Copy debug
-          LOG_COPY2       = 0x000000200,  //!< Detailed copy debug
-          LOG_RESOURCE   = 0x000000400,  //!< Resource allocation, performance-impacting events.
-          LOG_INIT        = 0x00000080,  //!< Initialization and shutdown
-          LOG_MISC        = 0x00001000,  //!< misc debug, not yet classified
-          LOG_AQL2        = 0x00002000,  //!< Show raw bytes of AQL packet
-          LOG_CODE        = 0x00004000,  //!< Show code creation debug
-          LOG_CMD2        = 0x00008000,  //!< More detailed command info, including barrier commands
-          LOG_LOCATION   = 0x00010000,  //!< Log message location
-          LOG_MEM         = 0x0000200000,  //!< Memory allocation
-          LOG_MEM_POOL   = 0x00040000,  //!< Memory pool allocation, including memory in graphs
-          LOG_ALWAYS     = 0xFFFFFFFF,  //!< Log always even mask flag is zero
-        };
-
-        You can also define the logging mask via the AMD_LOG_MASK environment variable.
-```
-
-You can also define the logging mask via the AMD\_LOG\_MASK environment variable.
-
-## 13.3 Logging command
-
-You can use the following code to print HIP logging information:
-**Following code does:** This code snippet is a simple C++ program that uses the HIP API, which is a C++ runtime API for GPU programming. The program initializes two `dim3` objects, which are typically used to define the dimensions of a grid or block in GPU programming. The first `dim3` object, `grid1`, is default-initialized, meaning its dimensions are set to zero. The second `dim3` object, `grid2`, is explicitly initialized with dimensions (1, 1, 1). The program then prints the dimensions of both `dim3` objects to the console. The purpose of this code is to demonstrate the initialization and usage of `dim3` objects in HIP.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?                                                                                                                                                                                                        </?                                                                                                                                                                                                       <!                                                                                                                                                                                                        >
-                                                                                                                                                                                                       <&                                                                                                                                                                                                        &
-                                                                                                                                                                                                      
-																																																																																																																																																																																																								                                                                                                                                                                                                       																																																																																																																																																																																																							<?                                                                                                                                                                                                      	                                                                                                                                                                                                      	
-																																																																																																																																																																																																						 																																																																																																																																																																																																						  <?
-```
-
-Using HIP code, call the ClPrint() function with the desired input variables. For example:
-**Following code does:** This code snippet compiles and runs a C++ program that likely involves GPU programming using the HIP (Heterogeneous-Compute Interface for Portability) API, which is used for writing portable code that can run on both AMD and NVIDIA GPUs. 
-
-1. The first line is a shell command that compiles a C++ source file named `test3.hip.cpp` using the `gcc` compiler. The `-x c++` flag specifies that the input file is a C++ source file. The `$(hipconfig --cpp_config)` part dynamically inserts the necessary compiler flags for HIP, which are obtained by running the `hipconfig --cpp_config` command. The output of the compilation is an executable named `test`.
-
-2. The second line executes the compiled program `./test`. The output suggests that the program is demonstrating the initialization and use of `dim3` objects, which are typically used in GPU programming to specify the dimensions of grid and block structures for kernel launches. The output shows two `dim3` objects, `grid1` and `grid2`, both initialized with dimensions `x=1, y=1, z=1`. This indicates that the program is likely testing or demonstrating basic grid configuration for GPU kernels.
-
-
-```
-            |ClPrint(amd::LOG_INFO, amd::LOG_INIT, "Initializing HSA stack.");
-```
-
-## 13.4 Logging examples
-
-On Linux , you can enable HIP logging and retrieve logging information when you run hipinfo .
-**Following code does:** This code snippet appears to be a comment in Python that is referencing a C++ style of initialization. The comment suggests that there is a variable `grid` of type `dim3` being initialized with the values `{1,1,1}`. In C++, `dim3` is typically used in CUDA programming to specify the dimensions of a grid or block for parallel execution on a GPU. The comment is likely indicating that the `grid` variable is being set to a 1x1x1 configuration, which means it is a single block with a single thread in each dimension (x, y, z). However, since this is a comment in Python, it does not execute any code but rather provides information or context about how a similar operation might be performed in C++.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <HR>
-                                                                                                                                                                                                       <HIP Documentation, Release 6.1.40092                                                                                                                                                                                                        </HIP Documentation, Release 6.1.40092                                                                                                                                                                                             <HR>
-        Loggging examples                                                                                                                                                                                                        >
-                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       >
-
-                                                                                                                                                                                                       <BR>
-                                                                                                                                                                                                      <BR><BR>
-                                                                                                                                                                                                     <BR>
-
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                       	                                                                                                                                                                                                       <B>
-                                                                                                                                                                                                     
-  <B>
-                                                                                                                                                                                                   <BR>
-  <B>
-                                                                                                                                                                                                  <BR>
-```
-
-(continues on next page)
-
-(continued from previous page)
-**Following code does:** The code snippet you provided appears to be a mistake or a mix-up. It seems to be an attempt to specify a programming language (C++) rather than actual code. If you intended to provide a C++ code snippet, please include the relevant code so I can help explain its purpose.
-
-
-```
-HIP Documentation, Release 6.1.40092
-```
-
-On Windows , you can set AMD\_LOG\_LEVEL via environment variable from the advanced system settings or the command prompt (when run as administrator). The following example shows debug log information when calling the backend runtime.
-**Following code does:** The code snippet `| export` appears to be incomplete or out of context for a typical Python script. In Python, the `|` character is not used in this way, and `export` is not a standard Python keyword. This snippet might be part of a shell command or a configuration file where `export` is used to set environment variables, but as it stands, it does not represent a valid or complete Python statement.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <kendo runume.                                                                                                                                                                                                        </kendo>runume.
-```
-
-(continues on next page)
-
-(continued from previous page)
-**Following code does:** The code snippet appears to be a shell command that sets an environment variable named `HIP_PLATFORM` to the value `amd`. This is typically used in a shell or terminal to configure the environment for software that relies on the HIP (Heterogeneous-Compute Interface for Portability) platform, indicating that the target platform for HIP operations should be AMD hardware.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <![
-                                                                                                                                                                                                       <?xml:%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/.%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/)
-                                                                                                                                                                                                      
-
-                                                                                                                                                                                                      
-
-
-                                                                                                                                                                                                       </?xml:%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazon AWS.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazon AWS.com/.%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazon AWS.com%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/"
-                                                                                                                                                                                                       :
-                                                                                                                                                                                                       >
-                                                                                                                                                                                                      ?xml:%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws,com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws,com%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.
-```
-
-(continues on next page)
-
-(continued from previous page)
-**Following code does:** It seems like you've provided a placeholder instead of actual code. If you provide the actual Python code snippet, I'd be happy to help explain its purpose.
-
-
-```
-  --copyBuffer
-...
-:4:C:\constructicon\builds\gfx\two\22.40\drivers\compute\vdi\device\pal\palmemory.
-  --cpp:206 : 605414523422 us: 29864: [tid:0x9298] Alloc: 100000 bytes,_,
-  --ptr[0000003008D0000-0000003009D0000], obj[0000003007D0000-0000003047D0000]
-:4:C:\constructicon\builds\gfx\two\22.40\drivers\compute\vdi\device\pal\palmemory.
-  --cpp:206 : 605414523767 us: 29864: [tid:0x9298] Alloc: 100000 bytes,_,
-  --ptr[0000003009D0000-000000300AD0000], obj[0000003007D0000-0000003047D0000]
-:3:C:\constructicon\builds\gfx\two\22.40\drivers\compute\hipamd\src\hip_memory.cpp:681 :_,
-  --605414524092 us: 29864: [tid:0x9298] hipMemGetInfo: Returned hipSuccess :
-memInfo.total:                     12.06 GB
-memInfo.free:                     11.93 GB (99%)
-```
-
-## CHAPTER
-
-## FOURTEEN
-
-## COOPERATIVE GROUPS
-
-Cooperative groups API is an extension to the HIP programming model, which provides developers with a flexible, dynamic grouping mechanism for the communicating threads. Cooperative groups let you define your own set of thread groups which may fit your user-cases better than those defined by the hardware. This lets you specify the level of granularity for thread communication which can lead to more efficient parallel decompositions.
-
-The API is accessible in the cooperative\_groups namespace after the hip\_cooperative\_groups.h is included. The header contains the following elements:
-
-- Static functions to create groups and subgroups.
-- Hardware-accelerated operations over the whole group, like shuffles.
-- Data types of cooperative groups.
-- Synchronize member function of the groups.
-- Get group properties member functions.
-
-## 14.1 Cooperative groups thread model
-
-The thread hierarchy abstraction of cooperative groups are in grid hierarchy and block hierarchy .
-
-Fig. 1: Cooperative group thread hierarchy in grids.
-
-The multi grid is an abstraction of potentially multiple simultaneous launches of the same kernel over multiple devices (Deprecated since 5.0). The grid in cooperative groups is a single dispatch of kernels for execution like the original grid.
-
-Note: The ability to synchronize over a grid or multi grid requires the kernel to be launched using the specific cooperative groups API.
-
-The block is the same as the Inherent thread model block entity.
-
-Note: Explicit warp-level thread handling is absent from the Cooperative groups API. In order to exploit the known hardware SIMD width on which built-in functionality translates to simpler logic, you can use the group partitioning part of the API, such as tiled\_partition .
-
-Fig. 2: Cooperative group thread hierarchy in blocks.
-
-The cooperative groups API introduce a new level between block thread and threads. The thread-block tile give the opportunity to have tiles in the thread block, while the coalesced group holds the active threads of the parent group. These groups further discussed in the groups types section.
-
-For details on memory model, check the memory model description .
-
-## 14.2 Group types
-
-Group types are based on the levels of synchronization and data sharing among threads.
-
-## 14.2.1 Thread-block group
-
-Represents an intra-block cooperative groups type where the participating threads within the group are the same threads that participated in the currently executing block .
-**Following code does:** This code snippet is a configuration or environment variable assignment in a shell or script. It sets the `HIP_COMPILER` variable to the value `cuda`. This is likely used in the context of configuring the HIP (Heterogeneous-Compute Interface for Portability) framework, which is designed to allow code to run on both AMD and NVIDIA GPUs. By setting `HIP_COMPILER` to `cuda`, it indicates that the HIP code should be compiled using the CUDA compiler, targeting NVIDIA GPUs.
-
-
-```
-    class thread_block;
-
-    Constructed via:
-
-    thread_block g = this_thread_block();
-```
-
-The group\_index() , thread\_index() , thread\_rank() , size() , cg\_type() , is\_valid() , sync() and group\_dim() member functions are public of the thread\_block class. For further details, check the thread\_block references .
-
-## 14.2.2 Grid group
-
-Represents an inter-block cooperative groups type where the group's participating threads span multiple blocks running the same kernel on the same device. Use the cooperative launch API to enable synchronization across the grid group.
-**Following code does:** This code snippet sets an environment variable named `HIP_RUNTIME` to the value `nvcc`. This is typically used in the context of configuring or building software that involves GPU programming, particularly when working with HIP (Heterogeneous-Compute Interface for Portability) and CUDA. By setting `HIP_RUNTIME` to `nvcc`, it indicates that the HIP code should be compiled using NVIDIA's CUDA compiler (`nvcc`), which is part of the CUDA toolkit. This setup is often used to ensure compatibility or optimize performance on NVIDIA GPUs.
-
-
-```
-class grid_group;
-
- Constructed via:
-
-grid_group g = this_grid();
-```
-
-The thread\_rank() , size() , cg\_type() , is\_valid() and sync() member functions are public of the grid\_group class. For further details, check the grid\_group references .
-
-## 14.2.3 Multi-grid group
-
-Represents an inter-device cooperative groups type where the participating threads within the group span multiple devices that run the same kernel on the devices. Use the cooperative launch API to enable synchronization across the multi-grid group.
-**Following code does:** The code snippet `<_C_>` appears to be incomplete or not a valid Python code. It does not represent any recognizable Python syntax or functionality. It might be a placeholder or a typographical error. Without additional context or information, it's not possible to determine its purpose or functionality.
-
-
-```
-    |class multi_grid_group;
-```
-**Following code does:** The code snippet `<_SQL_>` appears to be a placeholder or a tag indicating that the actual SQL code is not provided. It suggests that the content is intended to be SQL-related, possibly involving database queries or operations. Without the actual SQL code, it's not possible to determine the specific functionality or purpose. If you have the actual SQL code, I can help explain what it does.
-
-
-```
-;
-```
-
-Constructed via:
-**Following code does:** The code snippet you provided appears to be a comment or placeholder text rather than actual executable code. It seems to be referencing an example of using `hipLaunchKernelGGL`, which is a macro used in the HIP (Heterogeneous-Compute Interface for Portability) API. HIP is a C++ runtime API that allows developers to write portable code that can run on both AMD and NVIDIA GPUs.
-
-The purpose of `hipLaunchKernelGGL` is to launch a kernel function on a GPU. It abstracts the details of setting up the execution configuration (such as grid and block dimensions) and launching the kernel. However, without the actual code or context, this snippet doesn't perform any operations or provide further details.
-
-
-```
-<_C_>
-```
-**Following code does:** The provided code snippet appears to be incomplete and contains a syntax error. It seems to be a fragment of a function signature or declaration, possibly from a C or C++ program, rather than Python. The term `size_t` is a data type commonly used in C/C++ to represent sizes and is typically used for array indexing and loop counting. The `N` likely represents a parameter name. However, without additional context or code, it's not possible to determine the exact purpose or functionality of this snippet.
-
-
-```
-<_YAML_>
-```
-
-The num\_grids() , grid\_rank() , thread\_rank() , size() , cg\_type() , is\_valid() , and sync() member functions are public of the multi\_grid\_group class. For further details check the multi\_grid\_group references .
-
-## 14.2.4 Thread-block tile
-
-This constructs a templated class derived from thread\_group . The template defines the tile size of the new thread group at compile time. This group type also supports sub-wave level intrinsics.
-**Following code does:** This code snippet is related to launching a GPU kernel using HIP, which is a C++ runtime API and kernel language that allows developers to write portable code that can run on AMD and NVIDIA GPUs. The code launches a kernel function named `MyKernel` on the GPU. The kernel is executed with a specified grid and block (group) dimensions, which are defined by `gridDim` and `groupDim`, respectively. The parameters `a`, `b`, `c`, and `n` are passed to the kernel function, which likely represent data or configuration settings needed for the computation. The snippet also includes an alternative way to launch the kernel using the `hipLaunchKernelGGL` macro, which provides more flexibility, such as specifying a stream for asynchronous execution.
-
-
-```
-<_C++_>
-```
-
-Constructed via:
-**Following code does:** This code snippet is a GPU kernel implementation using HIP, a C++ runtime API and kernel language that allows developers to write portable code for AMD and NVIDIA GPUs. The code defines a simple kernel function `MyKernel` that operates on arrays of floating-point numbers. The kernel adds each element of array `a` to the corresponding element of array `b` after incrementing it by one, storing the result in array `c`. The `PlusOne` function is defined to increment a float by 1.0 and is marked to be compiled for both the host and device. The `callMyKernel` function sets up the necessary parameters and launches the kernel on the GPU, processing `N` elements with a specified block size.
-
-
-```
-<_SQL_>
-```
-
-## Note:
-
-- Size must be a power of 2 and not larger than warp (wavefront) size.
-- shfl() functions support integer or float type.
-
-The thread\_rank() , size() , cg\_type() , is\_valid() , sync() , meta\_group\_rank() , meta\_group\_size() , shfl() , shfl\_down() , shfl\_up() , shfl\_xor() , ballot() , any() , all() , match\_any() and match\_all() member functions are public of the thread\_block\_tile class. For further details, check the thread\_block\_tile references .
-
-## 14.2.5 Coalesced groups
-
-Threads (64 threads on CDNA and 32 threads on RDNA) in a warp cannot execute different instructions simultaneously, so conditional branches are executed serially within the warp. When threads encounter a conditional branch, they can diverge, resulting in some threads being disabled, if they do not meet the condition to execute that branch. The active threads referred as coalesced, and coalesced group represents an active thread group within a warp.
-
-Note: The NVIDIA GPU's independent thread scheduling presents the appearance that threads on different branches execute concurrently.
-
-Warning: AMD GPUs do not support independent thread scheduling. Some CUDA application can rely on this feature and the ported HIP version on AMD GPUs can deadlock, when they try to make use of independent thread scheduling.
-
-This group type also supports sub-wave level intrinsics.
-**Following code does:** The code snippet `<_C_>` appears to be incomplete or not a valid Python code. It does not represent any recognizable Python syntax or functionality. It might be a placeholder or a typographical error. Without additional context or information, it's not possible to determine its purpose or functionality.
-
-
-```
-    | class coalesced_group;
-```
-
-Constructed via:
-
-coalesced\_group
-**Following code does:** The code snippet `<_SQL_>` appears to be a placeholder or a tag indicating where SQL-related code or content should be inserted. It does not perform any operations or have any functionality on its own. Its purpose is likely to serve as a marker within a larger codebase or documentation to denote the section where SQL code is relevant or expected to be included.
-
-
-```
-    |roup active  = coalesced_threads() ;
-```
-
-Note: shfl() functions support integer or float type.
-
-The thread\_rank() , size() , cg\_type() , is\_valid() , sync() , meta\_group\_rank() , meta\_group\_size() , shfl() , shfl\_down() , shfl\_up() , ballot() , any() , all() , match\_any() and match\_all() member functions are public of the coalesced\_group class. For more information, see coalesced\_group references .
-
-## 14.3 Cooperative groups simple example
-
-The difference to the original block model in the reduce\_sum device function is the following.
-
-## Original Block
-**Following code does:** The provided code snippet appears to be incomplete and contains syntax errors, making it difficult to determine its exact purpose. However, it seems to be attempting to use or declare variables related to time measurement, possibly involving a clock function and a variable named `close`. Without additional context or corrections, it's not possible to provide a meaningful high-level summary of its functionality.
-
-
-```
-<_Cuda_>
-```
-
-## Cooperative groups
-**Following code does:** The code snippet appears to be a malformed or incomplete line of Python code. It seems to be attempting to declare a variable `w` with a type annotation of `long long int`, which is not a valid type in Python. In Python, type annotations typically use Python's built-in types or types from the `typing` module, and `long long int` is a C/C++ type, not a Python type. Therefore, this line does not serve any functional purpose in Python as it stands.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        // Thread ID
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        /                                                                                                                                                                                                        *                                                                                                                                                                                                        /*                                                                                                                                                                                                        */
-                                                                                                                                                                                                       */
-```
-
-(continues on next page)
-
-(continued from previous page)
-**Following code does:** The code snippet `it will_clock64()` appears to be a function call in Python. However, without additional context or definition of the function `it will_clock64`, it's not possible to determine its purpose or functionality. The name suggests it might be related to a clock or timing mechanism, possibly involving 64-bit operations, but this is purely speculative. To understand what this code does, one would need to see the implementation or documentation of the `it will_clock64` function.
-
-
-```
-      for(unsigned int i = g.size() / 2; i > 0; i /= 2) {
-          // Store value in shared memory with thread ID
-          shared[group_thread_id] = val;
-
-          // Synchronize all threads in the group
-          g.sync();
-
-          // Active thread sum up
-          if(group_thread_id < i)
-               val += shared[group_thread_id + i];
-
-          // Synchronize all threads in the group
-          g.sync();
-      }
-
-      //...
-}
-
-The reduce_sum() function call and input data initialization difference to the origin.
-```
-
-The reduce\_sum() function call and input data initialization difference to the original block model is the following.
-
-## Original Block
-**Following code does:** This code snippet is written in C++ and uses the HIP (Heterogeneous-Compute Interface for Portability) API, which is designed for writing portable applications that can run on both AMD and NVIDIA GPUs. The code retrieves the wall clock rate of a GPU device in kilohertz. Specifically, it initializes an integer variable `wallClkRate` to store the clock rate, and then calls the `hipDeviceGetAttribute` function to obtain the wall clock rate attribute (`hipDeviceAttributeWallClockRate`) for a specific GPU device identified by `deviceId`. The `HIPCHECK` macro is likely used to check for errors in the HIP API call.
-
-
-```
-Original Block
-
-__global__ void sum_kernel(...) {
-
-    //...
-
-    // Workspace array in shared memory
-    __shared__ unsigned int workspace[2048];
-
-    //...
-
-    // Perform reduction
-    output = reduce_sum(workspace, input);
-
-    //...
-}
-```
-
-## Cooperative groups
-**Following code does:** This code snippet retrieves the properties of a CUDA-enabled device specified by `deviceID` and stores them in a `cudaDeviceProp` structure named `props`. It then extracts the `warpSize` property, which indicates the number of threads in a warp for that device, and assigns it to the variable `w`. The comment suggests that the subsequent code will implement an algorithm that adapts to the device's warp size, ensuring portability across devices with different warp sizes, rather than assuming a fixed size like 32 or 64.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        //                                                                                                                                                                                                        const auto                                                                                                                                                                                                        }                                                                                                                                                                                                        /*                                                                                                                                                                                                        */                                                                                                                                                                                                        *
-```
-
-(continued from previous page)
-**Following code does:** This code snippet appears to define a set of functions typically used in parallel computing environments, such as CUDA for GPU programming. These functions are likely intended for use in managing and synchronizing threads within a warp (a group of threads that execute instructions in lockstep on a GPU). Here's a high-level summary of each function's purpose:
-
-1. `__all(int predicate)`: This function checks if a given condition (predicate) is true for all threads in a warp. It returns a non-zero value if the condition is true for all threads, otherwise it returns zero.
-
-2. `__any(int predicate)`: This function checks if a given condition (predicate) is true for any thread in a warp. It returns a non-zero value if the condition is true for at least one thread, otherwise it returns zero.
-
-3. `__ballot(int predicate)`: This function returns a bitmask representing which threads in a warp have a true predicate. Each bit in the returned value corresponds to a thread in the warp, with the bit set if the predicate is true for that thread.
-
-4. `__activemask()`: This function returns a bitmask indicating which threads in the warp are currently active. Active threads are those that are currently participating in the execution of the warp.
-
-5. `__all_sync(unsigned long long mask, int predicate)`: This function is similar to `__all`, but it allows specifying a mask to indicate which threads should be considered in the check. It synchronizes the threads specified by the mask and checks if the predicate is true for all of them.
-
-These functions are useful for coordinating and synchronizing operations across threads within a warp, ensuring that certain conditions are met before proceeding with further computations.
-
-
-```
-    thread_block thread_block_group = this_thread_block();
-    // Perform reduction
-    output = reduce_sum(thread_block_group, workspace, input);
-
-    //...
-}
-```
-
-At the device function, the input group type is the thread\_group , which is the parent class of all the cooperative groups type. With this, you can write generic functions, which can work with any type of cooperative groups.
-
-## 14.4 Synchronization
-
-With each group type, the synchronization requires using the correct cooperative groups launch API.
-
-## Check the kernel launch capability
-
-## Thread-block
-
-Do not need kernel launch validation.
-
-## Grid
-
-Confirm the cooperative launch capability on the single AMD GPU:
-**Following code does:** It seems like there is a placeholder or a formatting error in your request, as the code snippet is not visible. Please provide the actual code snippet so I can help explain its purpose.
-
-
-```
-    Confirm the cooperative launch capability on the single AMD GPU:
-
-    int device                       = 0;
-    int supports_coop_launch = 0;
-    // Check support
-    // Use hipDeviceAttributeCooperativeMultiDeviceLaunch when launching across multiple_
-    --devices
-    HIP_CHECK(hipGetDevice(&device));
-    HIP_CHECK(
-        hipDeviceGetAttribute(&supports_coop_launch, hipDeviceAttributeCooperativeLaunch,\
-    --device));
-    if(!supports_coop_launch)
-    {
-        std::cout << "Skipping, device " << device << " does not support cooperative groups"
-                       << std::endl;
-        return 0;
-    }
-```
-
-## Multi-grid
-
-Confirm the cooperative launch capability over multiple GPUs:
-**Following code does:** This code snippet appears to define function prototypes for a set of operations that involve matching values in a parallel computing context, likely using CUDA or a similar parallel processing framework. The functions are designed to perform matching operations across multiple threads or processing units:
-
-1. `__match_any(T value)`: This function likely checks if any thread in a group has a value that matches the specified `value`.
-
-2. `__match_all(T value, int *pred)`: This function probably checks if all threads in a group have a value that matches the specified `value`, and it might use the `pred` pointer to store or influence the result.
-
-3. `__match_any_sync(unsigned long long mask, T value)`: Similar to `__match_any`, but includes a `mask` parameter to specify which threads participate in the operation, ensuring synchronization among them.
-
-4. `__match_all_sync(unsigned long long mask, T value, int *pred)`: Similar to `__match_all`, but includes a `mask` parameter for synchronized participation and possibly uses `pred` for additional logic or result storage.
-
-Overall, these functions are likely used for efficient data comparison and synchronization across multiple threads in a parallel processing environment.
-
-
-```
-    Multi-grid
-
-    Confirm the cooperative launch capability over multiple GPUs:
-
-    // Check support of cooperative groups
-    std::vector<int> deviceIDs;
-    for(int deviceID = 0; deviceID < device_count; deviceID++) {
-    #ifdef __HIP_PLATFORM_AMD__
-        int supports_coop_launch = 0;
-        HIP_CHECK(
-            hipDeviceGetAttribute(
-                &supports_coop_launch,
-                hipDeviceAttributeCooperativeMultiDeviceLaunch,
-                deviceID));
-        if(!supports_coop_launch) {
-            std::cout << "Skipping, device " << deviceID << " does not support cooperative_
-    --groups"
-                        << std::endl;
-        }
-        else
-    #endif
-        {
-            std::cout << deviceID << std::endl;
-            // Collect valid deviceIDs.
-            deviceIDs.push_back(deviceID);
-        }
-    }
-
-    Kernel launch
-
-    __   ...  .
-```
-
-## Kernel launch
-
-## Thread-block
-
-You can access the new block representation using the original kernel launch methods.
-**Following code does:** The code snippet is a description of a CUDA intrinsic function `__shfl`. This function is used in parallel programming with NVIDIA GPUs to perform a shuffle operation within a warp. Specifically, it allows threads within a warp to exchange data. The function takes three parameters: `var`, which is the variable to be shuffled; `srcLane`, which specifies the source lane (or thread) from which to copy the value; and `width`, which defines the width of the shuffle operation, defaulting to the warp size. The note mentions that half-float data types are not supported for this shuffle operation.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        // Launching kernel  from host.
-```
-
-## Grid
-
-Launch the cooperative kernel on a single GPU:
-**Following code does:** The code snippet appears to be incomplete and contains a syntax error. It seems to be a mix of Python and C/C++ syntax, as it starts with a pipe character (`|`) and uses a C/C++ style function declaration (`void assert(int ir`). However, based on the visible part, it seems intended to define a function named `assert` that takes an integer parameter `ir` and returns no value (`void`). Without more context or the rest of the code, it's not possible to determine the specific purpose or functionality of this function.
-
-
-```
-<_C_>
-```
-
-## Multi-grid
-
-Launch the cooperative kernel over multiple GPUs:
-**Following code does:** This code snippet waits for the user to input data from the standard input (typically the keyboard) and press Enter. It effectively pauses the program's execution until the user provides some input. The input function can also be used to capture the user's input as a string, but in this case, since the result is not assigned to any variable, the input is simply discarded.
-
-
-```
-    Multi-grid
-
-    Launch the cooperative kernel over multiple GPUs:
-
-    hipLaunchParams *launchParamsList = (hipLaunchParams*)malloc(sizeof(hipLaunchParams) *_
-    --deviceIDs.size());
-    for(int deviceID : deviceIDs) {
-
-        // Set device
-        HIP_CHECK(hipSetDevice(deviceID));
-
-        // Create stream
-        hipStream_t stream;
-        HIP_CHECK(hipStreamCreate(&stream));
-
-        // Parameters
-        void* params[] = {&(d_vector[deviceID]), &(d_block_reduced[deviceID]), &(d_partition_
-    --reduced[deviceID])};
-
-        // Set launchParams
-        launchParamsList[deviceID].func = (void*)vector_reduce_kernel<partition_size>;
-        launchParamsList[deviceID].gridDim = dim3(1);
-        launchParamsList[deviceID].blockDim = dim3(threads_per_block);
-        launchParamsList[deviceID].sharedMem = 0;
-        launchParamsList[deviceID].stream = stream;
-        launchParamsList[deviceID].args = params;
-    }
-
-    HIP_CHECK(hipLaunchCooperativeKernelMultiDevice(launchParamsList,
-                                                                                                                                                                                                         (int)deviceIDs.size(),
-                                                                                                                                                                                                       )
-    --hipCooperativeLaunchMultiDeviceNoPreSync));
-
-    Device side synchronization
-```
-
-Device side synchronization
-
-## Thread-block
-
-The device side code of the thread\_block synchronization over single GPUs:
-**Following code does:** This code is a simple CUDA program using the HIP (Heterogeneous-Compute Interface for Portability) API, which is designed to run on AMD GPUs. The program defines a kernel function `run_printf` that prints "Hello World" to the console. The `main` function launches this kernel with a single thread block and a single thread, effectively executing the `printf` statement on the GPU. The purpose of this code is to demonstrate how to execute a basic "Hello World" program using GPU parallel computing with HIP.
-
-
-```
-<_C_>
-```
-
-## Grid
-
-The device side code of the grid synchronization over single GPUs:
-**Following code does:** The code snippet `<_Cython_>` appears to be a placeholder or a tag rather than actual executable code. In a typical context, "Cython" refers to a programming language that makes writing C extensions for Python as easy as Python itself. It is used to improve the performance of Python code by compiling it into C. However, without additional context or actual code, this snippet does not perform any specific function or operation.
-
-
-```
-<_Cython_>
-```
-**Following code does:** The code snippet appears to define a constant named `MIN_WARPS_PER_EXECUTION_UNIT`. This constant is calculated by dividing the product of `MIN_BLOCKS_PER_MULTIPROCESSOR` and `MAX_THREADS_PER_BLOCK` by an unknown operator represented by `/_\`. However, the snippet includes a series of unusual characters and formatting that suggest it might be incomplete or corrupted. In a typical context, such a calculation might be used to determine the minimum number of warps (groups of threads) that can be executed per unit in a parallel computing environment, such as on a GPU. However, without a clear definition of `/_\`, the exact calculation is unclear.
-
-
-```
-  =  this._grid() ;
-```
-
-## Multi-grid
-
-The device side code of the multi-grid synchronization over multiple GPUs:
-**Following code does:** The code snippet appears to be a warning message indicating that a particular API is deprecated. Specifically, it suggests that the user should replace the deprecated API with `hipHostMalloc()`. This message is likely part of a larger codebase or documentation related to memory allocation in a computing environment that uses the HIP (Heterogeneous-Compute Interface for Portability) API, which is commonly used for GPU programming. The purpose of the message is to inform developers to update their code to use the recommended function for host memory allocation.
-
-
-```
-            |multi_grid_group multi_grid = this_multi_grid();
-```
-**Following code does:** The provided text appears to be a fragment of a warning message rather than a complete code snippet. It indicates that a particular API is deprecated and suggests using `hipHostFree()` as an alternative. This typically means that the current API or function being used is outdated and may be removed in future versions, so developers are advised to switch to the recommended `hipHostFree()` function for managing host memory in HIP (Heterogeneous-Compute Interface for Portability) applications.
-
-
-```
-|multi_grid.sync();
-```
-
-## 14.5 Unsupported NVIDIA CUDA features
-
-HIP doesn't support the following NVIDIA CUDA optional headers:
-
-- cooperative\_groups/memcpy\_async.h
-- cooperative\_groups/reduce.h
-- cooperative\_groups/scan.h
-
-HIP doesn't support the following CUDA class in cooperative\_groups namespace:
-
-- cluster\_group
-
-HIP doesn't support the following CUDA functions/operators in cooperative\_groups namespace:
-
-- synchronize
-- memcpy\_async
-- wait and wait\_prior
-- barrier\_arrive and barrier\_wait
-- invoke\_one and invoke\_one\_broadcast
-- reduce
-- reduce\_update\_async and reduce\_store\_async
-- Reduce operators plus , less , greater , bit\_and , bit\_xor and bit\_or
-- inclusive\_scan and exclusive\_scan
-
-## CHAPTER
-
-## FIFTEEN
-
-## UNIFIED MEMORY
-
-In conventional architectures, CPUs and GPUs have dedicated memory like Random Access Memory (RAM) and Video Random Access Memory (VRAM). This architectural design, while effective, can be limiting in terms of memory capacity and bandwidth, as continuous memory copying is required to allow the processors to access the appropriate data. New architectural features like Heterogeneous System Architectures (HSA) and Unified Memory (UM) help avoid these limitations and promise increased efficiency and innovation.
-
-## 15.1 Unified memory
-
-Unified Memory is a single memory address space accessible from any processor within a system. This setup simplifies memory management processes and enables applications to allocate data that can be read or written by code running on either CPUs or GPUs. The Unified memory model is shown in the following figure.
-
-AMD Accelerated Processing Unit (APU) is a typical example of a Unified Memory Architecture. On a single die, a central processing unit (CPU) is combined with an integrated graphics processing unit (iGPU), and both have access to a high-bandwidth memory (HBM) module named Unified Memory. The CPU enables high-performance, low-latency operations, while the GPU is optimized for high throughput (data processed by unit time).
-
-## 15.2 System requirements
-
-Unified memory is supported on Linux by all modern AMD GPUs from the Vega series onward. Unified memory management can be achieved with managed memory allocation and, for the latest GPUs, with a system allocator.
-
-The table below lists the supported allocators. The allocators are described in the next section.
-
-Table 1: Supported Unified Memory Allocators
-
-| Architecture        | hipMallocManaged()   | __managed__   | malloc()   |
-|---------------------|----------------------|---------------|------------|
-| MI200, MI300 Series |                      |               | 1          |
-| MI100               |                      |               |            |
-| RDNA (Navi) Series  |                      |               |            |
-| GCN5 (Vega) Series  |                      |               |            |
-
-## : Supported
-
-- : Unsupported
-
-1 Works only with XNACK=1 . First GPU access causes recoverable page-fault. For more details, visit GPU memory.
-
-## 15.3 Unified memory programming models
-
-Showcasing various unified memory programming models, the model availability depends on your architecture. For more information, see System requirements and Checking unified memory management support .
-
-- HIP managed memory allocation API :
-
-The hipMallocManaged() is a dynamic memory allocator available on all GPUs with unified memory support. For more details, visit HIP managed memory allocation API .
-
-- HIP managed variables :
-
-The \_\_managed\_\_ declaration specifier, which serves as its counterpart, is supported on all modern AMD cards and can be utilized for static allocation.
-
-- System allocation API :
-
-Starting with the AMD MI300 series, the malloc() system allocator allows you to reserve unified memory. The system allocator is more versatile and offers an easy transition from a CPU written C++ code to a HIP code as the same system allocation API is used.
-
-## 15.3.1 Checking unified memory management support
-
-Some device attributes can offer information about which Unified memory programming models are supported. The attribute value is 1 if the functionality is supported, and 0 if it is not supported.
-
-Table 2: Device attributes for unified memory management
-
-| attribute description                                                                                 |
-|-------------------------------------------------------------------------------------------------------|
-| hipDeviceAttributeManagedMemory unified addressing is supported                                       |
-| hipDeviceAttributeConcurrentManagedAccess full managed memory support, concurrent access is supported |
-| hipDeviceAttributePageableMemoryAccess both managed and system memory allocation API is supported     |
-
-The following examples show how to use device attributes:
-**Following code does:** The code snippet is a command intended to be run in a Unix-like terminal that uses the Advanced Package Tool (APT) package management system. The command `apt-get install hi` attempts to install a software package named "hi" from the system's package repositories. If the package "hi" exists in the repositories and the user has the necessary permissions, it will be downloaded and installed on the system.
-
-
-```
-
-
-#include <hip/hip_runtime.h>
-#include <iostream>
-
-int main()  {
-        int d;
-        hipGetDevice(&d);
-
-        int  is_cma = 0;
-        hipDeviceGetAttribute(&is_cma, hipDeviceAttributeConcurrentManagedAccess, d);
-        std::cout << "HIP Managed Memory: "
-                       << (is_cma == 1? "is" : "NOT")
-                        << " " supported" << std::endl;
-        return 0;
-}
-```
-
-## 15.3.2 Example for unified memory management
-
-The following example shows how to use unified memory management with hipMallocManaged() , function, with \_\_managed\_\_ attribute for static allocation and standard malloc() allocation. For comparison, the Explicit Memory Management example is presented in the last tab.
-
-## hipMallocManaged()
-**Following code does:** The code snippet you provided appears to be a fragment of a command or a list of package names, but it is not a complete or valid Python code. It seems to be related to package management, possibly for installing or managing software packages related to HIP (Heterogeneous-Compute Interface for Portability) and NVIDIA GPU support. However, without additional context or a complete command, it's difficult to determine its exact purpose.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        //                                                                                                                                                                                                        }                                                                                                                                                                                                        */
-                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       //
-                                                                                                                                                                                                      
-
-
-                                                                                                                                                                                                       }
-                                                                                                                                                                                                       */
-```
-
-\_\_managed\_\_
-**Following code does:** This code is a command-line instruction used in a Unix-based operating system, such as Linux, to install Python 3 using the package manager `apt-get`. The command fetches the Python 3 package from the software repositories and installs it on the system, making Python 3 available for use.
-
-
-```
-__managed__
-
-#include <hip/hip_runtime.h>
-#include <iostream>
-
-// Addition of two values.
-__global__ void add(int *a, int *b, int *c) {
-    *c = *a + *b;
-}
-
-// Declare a, b and c as static variables.
-__managed__ int a, b, c;
-
-int main() {
-    // Setup input values.
-    a = 1;
-    b = 2;
-
-    // Launch add() kernel on GPU.
-    hipLaunchKernelGGL(add, dim3(1), dim3(1), 0, 0, &a, &b, &c);
-
-    // Wait for GPU to finish before accessing on host.
-    hipDeviceSynchronize();
-
-    // Prints the result.
-    std::cout << a << " + " << b << " = " << c << std::endl;
-
-    return 0;
-}
-
-
-malloc()
-```
-
-## malloc()
-**Following code does:** This code installs the Python package `CppHeaderParser` using the `pip3` package manager. `CppHeaderParser` is a library that allows users to parse C++ header files, extracting information such as classes, functions, and other declarations. The `pip3` command specifically uses Python 3's package manager to perform the installation.
-
-
-```
-malloc()
-
-#include <hip/hip_runtime.h>
-#include <iostream>
-
-// Addition of two values.
-__global__ void add(int* a, int* b, int* c) {
-    *c = *a + *b;
-}
-
-int main() {
-    int* a, * b, * c;
-
-    // Allocate memory for a, b, and c.
-    a = (int*)malloc(sizeof(*a));
-    b = (int*)malloc(sizeof(*b));
-    c = (int*)malloc(sizeof(*c));
-
-    // Setup input values.
-    *a = 1;
-    *b = 2;
-```
-
-(continues on next page)
-
-(continued from previous page)
-**Following code does:** The code snippet `| export` appears to be incomplete or out of context. In Python, this syntax is not valid. It might be part of a larger script or command in a different context, such as a shell command or a configuration file, where `export` is used to set environment variables. Without additional context, it's unclear what the intended purpose is.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-        // Launch add() kernel on GPU.
-        hipLaunchKernelGGL(add, dim3(1), dim3(1), 0, 0, a, b, c);
-
-        // Wait for GPU to finish before accessing on host.
-        hipDeviceSynchronize();
-
-        // Prints the result.
-        std::cout << *a << " + " << *b << " = " << *c << std::endl;
-
-        // Cleanup allocated memory.
-        free(a);
-        free(b);
-        free(c);
-
-        return 0;
-    }
-```
-**Following code does:** The code snippet you provided appears to be a placeholder or a tag indicating that the actual code is written in Bash, a Unix shell and command language. However, without the actual Bash code, it's not possible to determine its functionality or purpose. If you have a specific Bash script or command, please provide it for a more detailed explanation.
-
-
-```
-        tree<J;
-
-        return 0;
-    }
-
-
-    Explicit Memory Management
-
-    #include <hip/hip_runtime.h>
-    #include <iostream>
-
-    // Addition of two values.
-    __global__ void add(int *a, int *b, int *c) {
-        *c = *a + *b;
-    }
-
-    int main() {
-        int a, b, c;
-        int *d_a, *d_b, *d_c;
-
-        // Setup input values.
-        a = 1;
-        b = 2;
-
-        // Allocate device copies of a, b and c.
-        hipMalloc(&d_a, sizeof(*d_a));
-        hipMalloc(&d_b, sizeof(*d_b));
-        hipMalloc(&d_c, sizeof(*d_c));
-
-        // Copy input values to device.
-        hipMemcpy(d_a, &a, sizeof(*d_a), hipMemcpyHostToDevice);
-        hipMemcpy(d_b, &b, sizeof(*d_b), hipMemcpyHostToDevice);
-
-        // Launch add() kernel on GPU.
-        hipLaunchKernelGGL(add, dim3(1), dim3(1), 0, 0, d_a, d_b, d_c);
-
-        // Copy the result back to the host.
-        hipMemcpy(&c, d_c, sizeof(*d_c), hipMemcpyDeviceToHost);
-                                                                                                                                                                                                         (continues on next page)
-
-
-    15.3. Unified memory programming models                                                                                                                                                                                                        103
-```
-**Following code does:** The code snippet `<_Bash_>` appears to be a placeholder or a tag indicating that a section of code written in the Bash scripting language should be inserted or is expected there. It does not perform any specific function or operation by itself. Instead, it likely serves as a marker within a larger document or system to denote where Bash code is relevant or should be included.
-
-
-```
-
-    // Cleanup allocated memory.
-    hipFree(d_a);
-    hipFree(d_b);
-    hipFree(d_c);
-
-    // Prints the result.
-    std::cout << a << " + " << b << " = " << c << std::endl;
-
-    return 0;
-}
-```
-
-## 15.4 Using unified memory management (UMM)
-
-Unified memory management (UMM) is a feature that can simplify the complexities of memory management in GPU computing. It is particularly useful in heterogeneous computing environments with heavy memory usage with both a CPU and a GPU, which would require large memory transfers. Here are some areas where UMM can be beneficial:
-
-- Simplification of Memory Management :
-
-UMMcan help to simplify the complexities of memory management. This can make it easier for developers to write code without worrying about memory allocation and deallocation details.
-
-- Data Migration :
-
-UMMallows for efficient data migration between the host (CPU) and the device (GPU). This can be particularly useful for applications that need to move data back and forth between the device and host.
-
-- Improved Programming Productivity :
-
-As a positive side effect, UMM can reduce the lines of code, thereby improving programming productivity.
-
-In HIP, pinned memory allocations are coherent by default. Pinned memory is host memory mapped into the address space of all GPUs, meaning that the pointer can be used on both host and device. Using pinned memory instead of pageable memory on the host can improve bandwidth.
-
-While UMMcanprovide numerous benefits, it's important to be aware of the potential performance overhead associated with UMM. You must thoroughly test and profile your code to ensure it's the most suitable choice for your use case.
-
-## 15.5 Unified memory HIP runtime hints for the better performance
-
-Unified memory HIP runtime hints can help improve the performance of your code if you know your code's ability and infrastructure. Some hint techniques are presented in this section.
-
-Thehint functions can set actions on a selected device, which can be identified by hipGetDeviceProperties(&amp;prop, device\_id) . There are two special device\_id values:
-
-- hipCpuDeviceId = -1 means that the advised device is the CPU.
-- hipInvalidDeviceId = -2 means that the device is invalid.
-
-For the best performance, profile your application to optimize the utilization of HIP runtime hints.
-
-(continued from previous page)
-
-## 15.5.1 Data prefetching
-
-Data prefetching is a technique used to improve the performance of your application by moving data closer to the processing unit before it's actually needed.
-**Following code does:** The code snippet appears to be a malformed attempt to clone specific branches of two Git repositories from GitHub using the `git clone` command. The intention is to clone the repositories `clr` and `hip` from the `ROCm` organization, checking out the branch specified by the environment variable `ROCM_BRANCH`. However, the command is incorrectly written with `:lone` instead of `git clone`, which would result in an error if executed as is.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        // All                                                                                                                                                                                                        }
-                                                                                                                                                                                                      
-//                                                                                                                                                                                                        #                                                                                                                                                                                                        */
-                                                                                                                                                                                                       //                                                                                                                                                                                                        *
-                                                                                                                                                                                                       */
-
-                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       *
-
-                                                                                                                                                                                                       *                                                                                                                                                                                                        /*
-                                                                                                                                                                                                       /*
-
-                                                                                                                                                                                                       */                                                                                                                                                                                                        /
-                                                                                                                                                                                                       }
-```
-
-Remember to check the return status of hipMemPrefetchAsync() to ensure that the prefetch operations are completed successfully.
-
-## 15.5.2 Memory advice
-
-The effectiveness of hipMemAdvise() comes from its ability to inform the runtime system of the developer's intentions regarding memory usage. When the runtime system has knowledge of the expected memory access patterns, it can make better decisions about data placement and caching, leading to more efficient execution of the application. However, the actual impact on performance can vary based on the specific use case and the hardware architecture.
-
-For the description of hipMemAdvise() and the detailed list of advice, visit the HIP managed memory allocation API .
-
-Here is the updated version of the example above with memory advice.
-**Following code does:** The code snippet `<_Bash_>` appears to be a placeholder or a tag indicating that a Bash script or command is expected to be inserted or referenced there. It does not contain any actual executable code or commands. Therefore, it does not perform any operations or have a specific functionality on its own.
-
-
-```
-
-    The effectiveness of nipMemAdvise() comes from its ability to inform the runtime system at the developer's intentions
-    regarding memory usage. When the runtime system has knowledge of the expected memory access patterns, it can make
-    better decisions about data placement and caching, leading to more efficient execution of the application. However, the
-    actual impact on performance can vary based on the specific use case and the hardware architecture.
-    For the description of hipMemAdvise() and the detailed list of advice, visit the HIP managed memory allocation API.
-    Here is the updated version of the example above with memory advice.
-    
-  #include <hip/hip_runtime.h>
-  #include <iostream>
-    
-  // Addition of two values.
-  __global__ void add(int *a, int *b, int *c) {
-      *c = *a + *b;
-  }
-  
-  int main() {
-      int *a, *b, *c;
-      
-      // Allocate memory for a, b, and c accessible to both device and host codes.
-      hipMallocManaged(&a, sizeof(*a));
-      hipMallocManaged(&b, sizeof(*b));
-      hipMallocManaged(&c, sizeof(*c));
-      
-      // Set memory advice for a, b, and c to be accessed by the CPU.
-      hipMemAdvise(a, sizeof(*a), hipMemAdviseSetPreferredLocation, hipCpuDeviceId);
-      hipMemAdvise(b, sizeof(*b), hipMemAdviseSetPreferredLocation, hipCpuDeviceId);
-      hipMemAdvise(c, sizeof(*c), hipMemAdviseSetPreferredLocation, hipCpuDeviceId);
-      
-      // Additionally, set memory advice for a, b, and c to be read mostly from the device.
-  __0.
-      constexpr int device = 0;
-      hipMemAdvise(a, sizeof(*a), hipMemAdviseSetReadMostly, device);
-      hipMemAdvise(b, sizeof(*b), hipMemAdviseSetReadMostly, device);
-      hipMemAdvise(c, sizeof(*c), hipMemAdviseSetReadMostly, device);
-      
-      // Setup input values.
-      *a = 1;
-      *b = 2;
-      
-      // Launch add() kernel on GPU.
-      hipLaunchKernelGGL(add, dim3(1), dim3(1), 0, 0, a, b, c);
-      
-      // Wait for GPU to finish before accessing on host.
-      hipDeviceSynchronize();
-      
-      // Prints the result.
-      std::cout << *a << " + " << *b << " = " << *c << std::endl;
-      
-      // Cleanup allocated memory.
-      hipFree(a);
-      
-                                                                                                                                                                                                         (continues on next page)
-      
-      
-      
-  106
-```
-
-(continues on next page)
-**Following code does:** This code snippet is a shell script that automates the process of building and installing a software project using CMake and Make. Here's a high-level summary of what it does:
-
-1. It changes the current directory to the one specified by the `CLR_DIR` environment variable.
-2. It creates a `build` directory if it doesn't already exist and then changes into that directory.
-3. It runs the `cmake` command to configure the build system. This command specifies various options, such as the HIP common directory, the HIP platform, and the CMake prefix path. It also sets certain build flags, like enabling HIP support and disabling OpenCL support.
-4. It compiles the project using `make`, utilizing all available CPU cores (`-j$(nproc)`).
-5. Finally, it installs the compiled software using `sudo make install`, which typically requires administrative privileges.
-
-
-```
-      hipFree(b);
-      hipFree(c);
-
-      return 0;
-}
-```
-
-## 15.5.3 Memory range attributes
-
-Memory Range attributes allow you to query attributes of a given memory range.
-
-The hipMemRangeGetAttribute() is added to the example to query the hipMemRangeAttributeReadMostly attribute of the memory range pointed to by a . The result is stored in attributeValue and then printed out.
-
-For more details, visit the HIP managed memory allocation API .
-**Following code does:** The code snippet you provided seems to be a placeholder or a tag indicating PHP code, but it does not contain any actual PHP code to analyze. If you have a specific PHP code snippet you'd like me to explain, please provide the actual code, and I'd be happy to help!
-
-
-```
-
-        Memory Range attributes allow you to query attributes of a given memory range.
-        The hipMemRangeGetAttribute() is added to the example to query the hipMemRangeAttributeReadMostly at-
-        title of the memory range pointed to by a. The result is stored in attributeValue and then printed out.
-        For more details, visit the HIP managed memory allocation API.
-        #include <hip/hip_runtime.h>
-        #include <iostream>
-        
-        // Addition of two values.
-        __global__ void add(int *a, int *b, int *c) {
-            *c = *a + *b;
-        }
-        
-        int main() {
-            int *a, *b, *c;
-            unsigned int attributeValue;
-            constexpr size_t attributeSize = sizeof(attributeValue);
-            
-            // Allocate memory for a, b and c that is accessible to both device and host codes.
-            hipMallocManaged(&a, sizeof(*a));
-            hipMallocManaged(&b, sizeof(*b));
-            hipMallocManaged(&c, sizeof(*c));
-            
-            // Setup input values.
-            *a = 1;
-            *b = 2;
-            
-            // Launch add() kernel on GPU.
-            hipLaunchKernelGGL(add, dim3(1), dim3(1), 0, 0, a, b, c);
-            
-            // Wait for GPU to finish before accessing on host.
-            hipDeviceSynchronize();
-            
-            // Query an attribute of the memory range.
-            hipMemRangeGetAttribute(&attributeValue,
-                                             attributeSize,
-                                              hipMemRangeAttributeReadMostly,
-                                              a,
-                                               sizeof(*a));
-             
-            // Prints the result.
-            std::cout << *a << " + " << *b << " = " << *c << std::endl;
-                                                                                                                                                                                                         (continues on next page)
-                                                                                                                                                                                                      
-                                                                                                                                                                                                       )
-                                                                                                                                                                                                       (Continues on next page)
-```
-
-(continues on next page)
-
-(continued from previous page)
-
-(continued from previous page)
-**Following code does:** The code snippet provided appears to be a malformed or corrupted text, possibly due to formatting issues or errors in copying. It includes a mix of symbols and text that do not form a valid or meaningful Python code. Therefore, it does not perform any specific function or task in its current state.
-
-
-```
-    std::cout << "The queried attribute value is: " << attributeValue << std::endl;
-
-    // Cleanup allocated memory.
-    hipFree(a);
-    hipFree(b);
-    hipFree(c);
-
-    return 0;
-}
-```
-
-## 15.5.4 Asynchronously attach memory to a stream
-
-The hipStreamAttachMemAsync function would be able to asynchronously attach memory to a stream, which can help concurrent execution when using streams.
-
-Currently, this function is a no-operation (NOP) function on AMD GPUs. It simply returns success after the runtime memory validation passed. This function is necessary on Microsoft Windows, and UMM is not supported on this operating system with AMD GPUs at the moment.
-
-CHAPTER
-
-## SIXTEEN
-
-## VIRTUAL MEMORY MANAGEMENT
-
-Memorymanagement is important when creating high-performance applications in the HIP ecosystem. Both allocating and copying memory can result in bottlenecks, which can significantly impact performance.
-
-Global memory allocation in HIP uses the C language style allocation function. This works fine for simple cases but can cause problems if your memory needs change. If you need to increase the size of your memory, you must allocate a second larger buffer and copy the data to it before you can free the original buffer. This increases overall memory usage and causes unnecessary memcpy calls. Another solution is to allocate a larger buffer than you initially need. However, this isn't an efficient way to handle resources and doesn't solve the issue of reallocation when the extra buffer runs out.
-
-Virtual memory management solves these memory management problems. It helps to reduce memory usage and unnecessary memcpy calls.
-
-## 16.1 Memory allocation
-
-Standard memory allocation uses the hipMalloc function to allocate a block of memory on the device. However, when using virtual memory, this process is separated into multiple steps using the hipMemCreate , hipMemAddressReserve , hipMemMap , and hipMemSetAccess functions. This guide explains what these functions do and how you can use them for virtual memory management.
-
-## 16.1.1 Allocate physical memory
-
-The first step is to allocate the physical memory itself with the hipMemCreate function. This function accepts the size of the buffer, an unsigned long long variable for the flags, and a hipMemAllocationProp variable. hipMemAllocationProp contains the properties of the memory to be allocated, such as where the memory is physically located and what kind of shareable handles are available. If the allocation is successful, the function returns a value of hipSuccess , with hipMemGenericAllocationHandle\_t representing a valid physical memory allocation. The allocated memory size must be aligned with the granularity appropriate for the properties of the allocation. You can use the hipMemGetAllocationGranularity function to determine the correct granularity.
-**Following code does:** The code snippet you provided seems to be a placeholder or an incomplete representation of a code block, as it only contains `<_Bash_>`. This suggests that it might be intended to indicate a section where Bash script or commands should be inserted. Without actual Bash code or commands, it's not possible to determine its purpose or functionality. If you have a specific Bash script or command in mind, please provide the complete code for a more detailed explanation.
-
-
-```
-<_C_>
-```
-
-## 16.1.2 Reserve virtual address range
-
-After you have acquired an allocation of physical memory, you must map it before you can use it. To do so, you need a virtual address to map it to. Mapping means the physical memory allocation is available from the virtual address range it is mapped to. To reserve a virtual memory range, use the hipMemAddressReserve function. The size of the virtual memory must match the amount of physical memory previously allocated. You can then map the physical memory allocation to the newly-acquired virtual memory address range using the hipMemMap function.
-**Following code does:** The code snippet appears to be a mix of Python and C/C++ style comments and directives. However, it is mostly composed of whitespace and does not contain any executable code. The only meaningful part is the `#pragma unroll 16`, which is a compiler directive typically used in C/C++ to suggest that the compiler should unroll the following loop 16 times to potentially optimize performance. However, without any actual loop or surrounding code, this directive has no effect. Overall, the snippet does not perform any operations or have a functional purpose.
-
-
-```
-0) ;
-```
-**Following code does:** The code snippet appears to be malformed and does not represent valid Python code. It seems to contain HTML-like tags (`<img>` and `</img>`) with the word "void" inside them, but these are not valid in Python. The snippet does not perform any meaningful operation or serve a functional purpose in a Python context.
-
-
-```
-<_C++_>
-```
-
-## 16.1.3 Set memory access
-
-Finally, use the hipMemSetAccess function to enable memory access. It accepts the pointer to the virtual memory, the size, and a hipMemAccessDesc descriptor as parameters. In a multi-GPU environment, you can map the device memory of one GPU to another. This feature also works with the traditional memory management system, but isn't as scalable as with virtual memory. When memory is allocated with hipMalloc , hipDeviceEnablePeerAccess is used to enable peer access. This function enables access between two devices, but it means that every call to hipMalloc takes more time to perform the checks and the mapping between the devices. When using virtual memory management, peer access is enabled by hipMemSetAccess , which provides a finer level of control over what is shared. This has no performance impact on memory allocation and gives you more control over what memory buffers are shared with which devices.
-**Following code does:** This code snippet is a command-line instruction using `hipcc`, which is a compiler for HIP (Heterogeneous-Compute Interface for Portability) programs. The command is used to generate a code object file for a specific GPU architecture. It takes an input file containing GPU kernels, compiles it for the specified target GPU architecture, and outputs the compiled code into a designated output file. The `--genco` flag indicates that the command is specifically for generating code objects, and `--offload-arch` specifies the target GPU architecture for which the code should be compiled.
-
-
-```
-hipMemAccessDesc accessDesc = {};
-accessDesc.location.type = HIP_MEM_LOCATION_TYPE_DEVICE;
-accessDesc.location.id = currentDev;
-accessDesc.flags = HIP_MEM_ACCESS_FLAGS_PROT_READWRITE;
-hipMemSetAccess(ptr, padded_size, &accessDesc, 1);
-```
-
-At this point the memory is allocated, mapped, and ready for use. You can read and write to it, just like you would a C style memory allocation.
-
-## 16.1.4 Free virtual memory
-
-To free the memory allocated in this manner, use the corresponding free functions. To unmap the memory, use hipMemUnmap . To release the virtual address range, use hipMemAddressFree . Finally, to release the physical memory, use hipMemRelease . A side effect of these functions is the lack of synchronization when memory is released. If you call hipFree when you have multiple streams running in parallel, it synchronizes the device. This causes worse resource usage and performance.
-**Following code does:** This code snippet is a series of shell commands that clone specific branches of three different repositories from GitHub. The repositories are related to the ROCm (Radeon Open Compute) platform, which is an open-source software platform for GPU computing. The branches being cloned are specified by the environment variable `ROCM_BRANCH`. The repositories being cloned are `clr`, `hip`, and `hipother`, all from the ROCm organization on GitHub. This setup is typically used to obtain specific versions of these projects for development or deployment purposes.
-
-
-```
-        |hipMemUnmap(ptr, size);
-        |hipMemRelease(allocHandle);
-```
-**Following code does:** The code snippet appears to be part of a script or instructions for setting up a development environment related to HIP (Heterogeneous-Compute Interface for Portability). It outlines two main steps: 
-
-1. Cloning the HIP source code from a repository using Git, specifically checking out a branch specified by the environment variable `$ROCM_BRANCH`. The repetition of the `git clone` command suggests either a mistake or an incomplete snippet where different repositories or directories might be intended.
-
-2. Setting environment variables, which is a common step in configuring a development environment to ensure that the necessary paths and settings are available for building or running the software.
-
-Overall, the snippet is part of a setup process for working with HIP, likely in the context of ROCm (Radeon Open Compute), a platform for GPU computing.
-
-
-```
-        |hipMemAddressFree(ptr,  size);
-```
-
-## 16.2 Memory usage
-
-## 16.2.1 Dynamically increase allocation size
-
-The hipMemAddressReserve function allows you to increase the amount of pre-allocated memory. This function accepts a parameter representing the requested starting address of the virtual memory. This allows you to have a continuous virtual address space without worrying about the underlying physical allocation.
-**Following code does:** This code snippet sets three environment variables (`CLR_DIR`, `HIP_DIR`, and `HIP_OTHER`) to the absolute paths of the directories named `clr`, `hip`, and `hipother`, respectively. The `readlink -f` command is used to resolve and return the full path of each directory, ensuring that any symbolic links are followed to their final target locations. This setup is typically used in shell scripts to configure paths for use in subsequent commands or scripts.
-
-
-```
-            hipMemAddressReserve(&new_ptr, (new_size - padded_size), 0, ptr + padded_size, 0);
-            hipMemMap(new_ptr, (new_size - padded_size), 0, newAllocHandle, 0);
-            hipMemSetAccess(new_ptr, (new_size - padded_size), &accessDesc, 1);
-```
-
-The code sample above assumes that hipMemAddressReserve was able to reserve the memory address at the specified location. However, this isn't guaranteed to be true, so you should validate that new\_ptr points to a specific virtual address before using it.
-
-## CHAPTER
-
-## SEVENTEEN
-
-## FREQUENTLY ASKED QUESTIONS
-
-## 17.1 What APIs and features does HIP support?
-
-HIP provides the following:
-
-- Devices ( hipSetDevice() , hipGetDeviceProperties() , etc.)
-- Memory management ( hipMalloc() , hipMemcpy() , hipFree() , etc.)
-- Streams ( hipStreamCreate() , hipStreamSynchronize() , hipStreamWaitEvent() , etc.)
-- Events ( hipEventRecord() , hipEventElapsedTime() , etc.)
-- Kernel launching ( hipLaunchKernel / hipLaunchKernelGGL is the preferred way of launching kernels. hipLaunchKernelGGL is a standard C/C++ macro that can serve as an alternative way to launch kernels, replacing the CUDA triple-chevron ( &lt;&lt;&lt; &gt;&gt;&gt; ) syntax).
-- HIP Module API to control when and how code is loaded.
-- CUDA-style kernel coordinate functions ( threadIdx , blockIdx , blockDim , gridDim )
-- Cross-lane instructions including shfl , ballot , any , all
-- Most device-side math built-ins
-- Error reporting ( hipGetLastError() , hipGetErrorString() )
-
-The HIP API documentation describes each API and its limitations, if any, compared with the equivalent CUDA API.
-
-## 17.2 What is not supported?
-
-## 17.2.1 Runtime/Driver API features
-
-At a high-level, the following features are not supported:
-
-- Textures (partial support available)
-- Dynamic parallelism (CUDA 5.0)
-- Graphics interoperability with OpenGL or Direct3D
-- CUDA IPC Functions (Under Development)
-- CUDA array, mipmappedArray and pitched memory
-- Queue priority controls
-
-See the API Support Table for more detailed information.
-
-## 17.2.2 Kernel language features
-
-- C+ ± style device-side dynamic memory allocations (free, new, delete) (CUDA 4.0)
-- Virtual functions, indirect functions and try/catch (CUDA 4.0)
-- \_\_prof\_trigger
-- PTX assembly (CUDA 4.0). HIP-Clang supports inline GCN assembly.
-- Several kernel features are under development. See the C++ language extensions for more information.
-
-## 17.3 Is HIP a drop-in replacement for CUDA?
-
-No. HIP provides porting tools which do most of the work to convert CUDA code into portable C++ code that uses the HIP APIs. Most developers will port their code from CUDA to HIP and then maintain the HIP version. HIP code provides the same performance as native CUDA code, plus the benefits of running on AMD platforms.
-
-## 17.4 What specific version of CUDA does HIP support?
-
-HIP APIs and features do not map to a specific CUDA version. HIP provides a strong subset of the functionality provided in CUDA, and the hipify tools can scan code to identify any unsupported CUDA functions - this is useful for identifying the specific features required by a given application.
-
-However, we can provide a rough summary of the features included in each CUDA SDK and the support level in HIP. Each bullet below lists the major new language features in each CUDA release and then indicate which are supported/not supported in HIP:
-
-- CUDA 4.0 and earlier :
-- -HIP supports CUDA 4.0 except for the limitations described above.
-- CUDA 5.0 :
-- -Dynamic Parallelism (not supported)
-- -cuIpc functions (under development).
-- CUDA 6.0 :
-- -Managed memory (under development)
-- CUDA 6.5 :
-- -\_\_shfl intrinsic (supported)
-- CUDA 7.0 :
-- -Per-thread default streams (supported)
-- -C++11 (Hip-Clang supports all of C++11, all of C++14 and some C++17 features)
-- CUDA 7.5 :
-- -float16 (supported)
-- CUDA 8.0 :
-- -Page Migration including cudaMemAdvise , cudaMemPrefetch , other cudaMem* APIs(not supported)
-- CUDA 9.0 :
-
-- -Cooperative Launch, Surface Object Management, Version Management
-
-## 17.5 What libraries does HIP support?
-
-HIP includes growing support for the four key math libraries using hipBLAS, hipFFT, hipRAND and hipSPARSE, as well as MIOpen for machine intelligence applications. These offer pointer-based memory interfaces (as opposed to opaque buffers) and can be easily interfaced with other HIP applications. The hip interfaces support both ROCm and CUDA paths, with familiar library interfaces.
-
-- hipBLAS, which utilizes rocBlas.
-- hipFFT
-- hipsSPARSE
-- hipRAND
-- MIOpen
-
-Additionally, some of the cuBLAS routines are automatically converted to hipblas equivalents by the HIPIFY tools. These APIs use cuBLAS or hcBLAS depending on the platform and replace the need to use conditional compilation.
-
-## 17.6 How does HIP compare with OpenCL?
-
-Both AMD and NVIDIA support OpenCL 1.2 on their devices so that developers can write portable code. HIP offers several benefits over OpenCL:
-
-- Developers can code in C++ as well as mix host and device C++ code in their source files. HIP C++ code can use templates, lambdas, classes and so on.
-- The HIP API is less verbose than OpenCL and is familiar to CUDA developers.
-- Because both CUDA and HIP are C++ languages, porting from CUDA to HIP is significantly easier than porting from CUDA to OpenCL.
-- HIP uses the best available development tools on each platform: on NVIDIA GPUs, HIP code compiles using NVCC and can employ the Nsight profiler and debugger (unlike OpenCL on NVIDIA GPUs).
-- HIP provides pointers and host-side pointer arithmetic.
-- HIP provides device-level control over memory allocation and placement.
-- HIP offers an offline compilation model.
-
-## 17.7 How does porting CUDA to HIP compare to porting CUDA to OpenCL?
-
-Both HIP and CUDA are dialects of C++, and thus porting between them is relatively straightforward. Both dialects support templates, classes, lambdas, and other C++ constructs. As one example, the hipify-perl tool was originally a Perl script that used simple text conversions from CUDA to HIP. HIP and CUDA provide similar math library calls as well. In summary, the HIP philosophy was to make the HIP language close enough to CUDA that the porting effort is relatively simple. This reduces the potential for error, and also makes it easy to automate the translation. HIP goal is to quickly get the ported program running on both platforms with little manual intervention, so that the programmer can focus on performance optimizations.
-
-There have been several tools that have attempted to convert CUDA into OpenCL, such as CU2CL. OpenCL is a C99based kernel language (rather than C++) and also does not support single-source compilation. As a result, the OpenCL syntax is different from CUDA, and the porting tools have to perform some heroic transformations to bridge this gap. The tools also struggle with more complex CUDA applications, in particular, those that use templates, classes, or other C++ features inside the kernel.
-
-## 17.8 What hardware does HIP support?
-
-- For AMD platforms, see the ROCm documentation for the list of supported platforms.
-- For NVIDIA platforms, HIP requires unified memory and should run on any device supporting CUDA SDK 6.0 or newer. We have tested the NVIDIA Titan and Tesla K40.
-
-## 17.9 Do HIPIFY tools automatically convert all source code?
-
-Typically, HIPIFY tools can automatically convert almost all run-time code. Most device code needs no additional conversion since HIP and CUDA have similar names for math and built-in functions. The hipify-clang tool will automatically modify the kernel signature as needed (automating a step that used to be done manually). Additional porting may be required to deal with architecture feature queries or with CUDA capabilities that HIP doesn't support. In general, developers should always expect to perform some platform-specific tuning and optimization.
-
-## 17.10 What is NVCC?
-
-NVCC is NVIDIA's compiler driver for compiling 'CUDA C++' code into PTX or device code for NVIDIA GPUs. It's a closed-source binary compiler that is provided by the CUDA SDK.
-
-## 17.11 What is HIP-Clang?
-
-HIP-Clang is a Clang/LLVM based compiler to compile HIP programs which can run on AMD platform.
-
-## 17.12 Why use HIP rather than supporting CUDA directly?
-
-While HIP is a strong subset of the CUDA, it is a subset. The HIP layer allows that subset to be clearly defined and documented. Developers who code to the HIP API can be assured their code will remain portable across NVIDIA and AMD platforms. In addition, HIP defines portable mechanisms to query architectural features and supports a larger 64-bit WaveSize which expands the return type for cross-lane functions like ballot and shuffle from 32-bit integers to 64-bit integers.
-
-## 17.13 Can I develop HIP code on an NVIDIA CUDA platform?
-
-Yes. HIP's CUDA path only exposes the APIs and functionality that work on both NVCC and AMDGPU back-ends. 'Extra' APIs, parameters, and features which exist in CUDA but not in HIP-Clang will typically result in compile-time or run-time errors. Developers need to use the HIP API for most accelerator code and bracket any CUDA-specific code with preprocessor conditionals. Developers concerned about portability should, of course, run on both platforms, and should expect to tune for performance. In some cases, CUDA has a richer set of modes for some APIs, and some C++ capabilities such as virtual functions - see the HIP @API documentation for more details.
-
-## 17.14 Can I develop HIP code on an AMD HIP-Clang platform?
-
-Yes. HIP's HIP-Clang path only exposes the APIs and functions that work on AMD runtime back ends. 'Extra' APIs, parameters and features that appear in HIP-Clang but not CUDA will typically cause compile- or run-time errors. Developers must use the HIP API for most accelerator code and bracket any HIP-Clang specific code with preprocessor conditionals. Those concerned about portability should, of course, test their code on both platforms and should tune it for performance. Typically, HIP-Clang supports a more modern set of C++11/C++14/C++17 features, so HIP developers who want portability should be careful when using advanced C++ features on the HIP-Clang path.
-
-## 17.15 How to use HIP-Clang to build HIP programs?
-
-The environment variable can be used to set compiler path:
-
-- HIP\_CLANG\_PATH: path to hip-clang. When set, this variable let hipcc to use hip-clang for compilation/linking.
-
-There is an alternative environment variable to set compiler path:
-
-- HIP\_ROCCLR\_HOME: path to root directory of the HIP-ROCclr runtime. When set, this variable let hipcc use hip-clang from the ROCclr distribution. NOTE: If HIP\_ROCCLR\_HOME is set, there is no need to set HIP\_CLANG\_PATH since hipcc will deduce them from HIP\_ROCCLR\_HOME.
-
-## 17.16 What is AMD clr?
-
-AMD Common Language Runtime (CLR) is a repository for the AMD platform, which contains source codes for AMD's compute languages runtimes as follows,
-
-- hipamd - contains implementation of HIP language for AMD GPU.
-- rocclr - contains virtual device interfaces that compute runtimes interact with backends, such as ROCr on Linux and PAL on Windows.
-- opencl - contains implementation of OpenCL™ on the AMD platform.
-
-## 17.17 What is hipother?
-
-A new repository 'hipother' is added in the ROCm 6.1 release, which is branched out from HIP. hipother supports the HIP back-end implementation on some non-AMD platforms, like NVIDIA.
-
-## 17.18 Can I get HIP open source repository for Windows?
-
-No, there is no HIP repository open publicly on Windows.
-
-## 17.19 Can a HIP binary run on both AMD and NVIDIA platforms?
-
-HIP is a source-portable language that can be compiled to run on either AMD or NVIDIA platform. HIP tools don't create a 'fat binary' that can run on either platform, however.
-
-## 17.20 On HIP-Clang, can I link HIP code with host code compiled with another compiler such as gcc, icc, or clang?
-
-Yes. HIP generates the object code which conforms to the GCC ABI, and also links with libstdc++. This means you can compile host code with the compiler of your choice and link the generated object code with GPU code compiled with HIP. Larger projects often contain a mixture of accelerator code (initially written in CUDA with NVCC) and host code (compiled with gcc, icc, or clang). These projects can convert the accelerator code to HIP, compile that code with hipcc, and link with object code from their preferred compiler.
-
-## 17.21 Can HIP API support C style application? What is the difference between C and C++?
-
-HIP is C++ runtime API that supports C style applications as well.
-
-Some C style applications (and interfaces to other languages (FORTRAN, Python)) would call certain HIP APIs but not use kernel programming. They can be compiled with a C compiler and run correctly, however, small details must be considered in the code. For example, initialization, as shown in the simple application below, uses HIP structs dim3 with the file name 'test.hip.cpp'
-**Following code does:** The code snippet provided is not a valid Python code. It appears to be a fragment of a list or a set of instructions, specifically the third step in a sequence, which is "Build HIP." Without additional context, it's unclear what "HIP" refers to, but it could be an acronym or a specific component in a larger process. The snippet suggests that this step involves constructing or assembling something referred to as HIP.
-
-
-```
-                                                                                                                                                                                                        //the file name `test.hip.cpp`
-                                                                                                                                                                                                       
-                                                                                                                                                                                                      
-#include "hip/hip_runtime_api.h"
-                                                                                                                                                                                                       //this file name `test.hip.cpp`
-                                                                                                                                                                                             
-          int main(int argc, char** argv) {
-            dim3 grid1;
-            printf("dim3 grid1; x=%d, y=%d, z=%d\n",grid1.x,grid1.y,grid1.z);
-            dim3 grid2 = {1,1,1};
-            printf("dim3 grid2 = {1,1,1}; x=%d, y=%d, z=%d\n",grid2.x,grid2.y,grid2.z);
-            return 0;
-            }
-```
-
-When using a C++ compiler,
-**Following code does:** This code snippet is a shell script that automates the process of building and installing a software project using CMake and Make, specifically targeting a HIP (Heterogeneous-Compute Interface for Portability) platform with NVIDIA support. Here's a high-level breakdown of its purpose:
-
-1. **Change Directory**: It navigates to a directory specified by the environment variable `CLR_DIR`.
-
-2. **Create and Navigate to Build Directory**: It creates a `build` directory if it doesn't exist and then changes into it.
-
-3. **Configure the Build with CMake**: It runs the `cmake` command to configure the build system. Various options are set, such as:
-   - `HIP_COMMON_DIR` and `HIPNV_DIR` for specifying directories related to HIP.
-   - `HIP_PLATFORM=nvidia` to target NVIDIA GPUs.
-   - `CMAKE_INSTALL_PREFIX` to set the installation directory to the current working directory.
-   - Disabling certain build options like `HIP_CATCH_TEST` and `CLR_BUILD_OCL`.
-
-4. **Compile the Project**: It uses `make` with parallel execution (`-j$(nproc)`) to compile the project, utilizing all available CPU cores.
-
-5. **Install the Compiled Software**: It runs `sudo make install` to install the compiled software, which typically requires superuser privileges.
-
-Overall, this script is used to build and install a HIP-based software project configured for NVIDIA GPUs.
-
-
-```
-$ gcc -x c++  $(hipconfig --cpp_config) test3.hip.cpp -o test
-$./test
-dim3 grid1; x=1, y=1, z=1
-dim3 grid2 = {1,1,1}; x=1, y=1, z=1
-```
-
-In which 'dim3 grid1;' will yield a dim3 grid with all dimensional members x,y,z initialized to 1, as the default constructor behaves that way. Further, if written: dim3 grid(2); // yields {2,1,1} dim3 grid(2,3); yields {2,3,1} In comparison, when using the C compiler, $ gcc -x c $( hipconfig --cpp\_config ) test.hip.cpp -o test $ ./test dim3 grid1; x=646881376, y=21975, z=1517277280 dim3 grid2 = {1,1,1}; x=1, y=1, z=1 In which 'dim3 grid;' does not imply any initialization, no constructor is called, and dimensional values x,y,z of grid are undefined. NOTE: To get the C++ default behavior, C programmers must additionally specify the right-hand side as shown below,
-**Following code does:** This code snippet is a shell command that uses `git` to clone a specific branch of a repository from GitHub. It clones the `hip-tests` repository from the ROCm (Radeon Open Compute) GitHub organization. The branch to be cloned is specified by the environment variable `ROCM_BRANCH`. This command is typically used to obtain a local copy of the code from a particular branch of the repository for development, testing, or deployment purposes.
-
-
-```
-        |dim3 grid = {1,1,1}; // initialized as in C++
-```
-**Following code does:** This code snippet appears to be a shell script intended for setting up and running tests for a project that uses HIP (Heterogeneous-Compute Interface for Portability), which is a C++ runtime API and kernel language that allows developers to create portable applications across different GPU platforms. Here's a high-level summary of what it does:
-
-1. **Set Environment Variable**: It sets the `HIPTESTS_DIR` environment variable to the absolute path of the `hip-tests` directory using `readlink -f`.
-
-2. **Navigate to Directory**: It changes the current directory to `HIPTESTS_DIR`.
-
-3. **Create and Navigate to Build Directory**: It creates a `build` directory if it doesn't exist and navigates into it.
-
-4. **Configure Build with CMake**: It runs `cmake` to configure the build system for the project, specifying the HIP platform as AMD and setting the HIP path to a specified directory.
-
-5. **Build Tests**: It compiles the test suite using `make build_tests`.
-
-6. **Run Tests**: It executes the tests using `ctest`.
-
-Overall, this script automates the process of setting up the environment, configuring, building, and running tests for a HIP-based project.
-
-
-```
-C++
-```
-
-## 17.22 Can I install both CUDA SDK and HIP-Clang on the same machine?
-
-Yes. You can use HIP\_PLATFORM to choose which path hipcc targets. This configuration can be useful when using HIP to develop an application which is portable to both AMD and NVIDIA.
-
-## 17.23 HIP detected my platform (HIP-Clang vs NVCC) incorrectly * what should I do?
-
-HIP will set the platform to AMD and use HIP-Clang as compiler if it sees that the AMD graphics driver is installed and has detected an AMD GPU. Sometimes this isn't what you want * you can force HIP to recognize the platform by setting the following,
-**Following code does:** The code snippet defines a function `ynf` that calculates and returns the value of the Bessel function of the second kind of order `n` for a given input `x`. Bessel functions are a family of solutions to Bessel's differential equation and are commonly used in various fields such as physics and engineering, particularly in problems involving cylindrical or spherical symmetry.
-
-
-```
-| export
-```
-**Following code does:** The code snippet appears to be a comment or documentation rather than executable code. It describes the process of building HIP (Heterogeneous-Compute Interface for Portability) tests using Catch2, a unit testing framework. Specifically, it mentions that these HIP tests are separate from the main HIP project and outlines a step to obtain the source code for these tests.
-
-
-```
-rt HIP_PLATFORM=amd
-```
-**Following code does:** This code snippet appears to be a part of a script or configuration file that compiles and runs a specific test for a HIP (Heterogeneous-Compute Interface for Portability) application. It navigates to a directory specified by the environment variable `HIPTESTS_DIR`, then uses the `hipcc` compiler to compile a C++ test file named `hipPointerGetAttributes.cc` along with some include directories. The compiled output is an executable named `hipPointerGetAttributes`, which is then executed. The purpose of this script is to test the functionality related to HIP pointer attributes, and it concludes with a message indicating that all tests have passed.
-
-
-```
-<_Python_>
-```
-**Following code does:** The code snippet `++i)` appears to be a syntax error in Python. In Python, the `++` operator does not exist as it does in languages like C++ or JavaScript. Instead, Python uses `i += 1` to increment a variable. The snippet seems to be an incomplete or incorrect attempt to increment a variable, possibly influenced by syntax from another programming language.
-
-
-```
-  | HIP_COMPILER=cuda
-```
-**Following code does:** The code snippet `<_SQL_>` appears to be a placeholder or a tag indicating that the actual SQL code is not provided. It suggests that the content is related to SQL, which is a language used for managing and manipulating relational databases. Without the actual SQL code, it's not possible to determine the specific operations or queries being performed. The placeholder might be used in documentation, templates, or code generation tools to signify where SQL code should be inserted or referenced.
-
-
-```
-  | HIP_RUNTIME=nvcc
-```
-
-One symptom of this problem is the message 'error: 'unknown error'(11) at square.hipref.cpp:56 . This can occur if you have a CUDA installation on an AMD platform, and HIP incorrectly detects the platform as NVCC. HIP may be able to compile the application using the NVCC tool-chain but will generate this error at runtime since the platform does not have a CUDA device.
-
-## 17.24 On CUDA, can I mix CUDA code with HIP code?
-
-Yes. Most HIP data structures ( hipStream\_t , hipEvent\_t ) are typedefs to CUDA equivalents and can be intermixed. Both CUDA and HIP use integer device ids. One notable exception is that hipError\_t is a new type, and cannot be used where a cudaError\_t is expected. In these cases, refactor the code to remove the expectation. Alternatively, hip\_runtime\_api.h defines functions which convert between the error code spaces:
-
-hipErrorToCudaError hipCUDAErrorTohipError hipCUResultTohipError
-
-If platform portability is important, use #ifdef \_\_HIP\_PLATFORM\_NVIDIA\_\_ to guard the CUDA-specific code.
-
-## 17.25 How do I trace HIP application flow?
-
-See Logging HIP activity for more information.
-
-## 17.26 What are the maximum limits of kernel launch parameters?
-
-Product of block.x, block.y, and block.z should be less than 1024. Please note, HIP does not support kernel launch with total work items defined in dimension with size gridDim x blockDim &gt;= 2^32 , so gridDim.x * blockDim.x, gridDim.y * blockDim.y and gridDim.z * blockDim.z are always less than 2^32.
-
-## 17.27 Are \_\_shfl\_*\_sync functions supported on HIP platform?
-
-\_\_shfl\_*\_sync is not supported on HIP but for NVCC path CUDA 9.0 and above all shuffle calls get redirected to it's sync version.
-
-## 17.28 How to create a guard for code that is specific to the host or the GPU?
-
-The compiler defines the \_\_HIP\_DEVICE\_COMPILE\_\_ macro only when compiling the code for the GPU. It could be used to guard code that is specific to the host or the GPU.
-
-## 17.29 Why \_OpenMP is undefined when compiling with -fopenmp ?
-
-When compiling an OpenMP source file with hipcc -fopenmp , the compiler may generate error if there is a reference to the \_OPENMP macro. This is due to a limitation in hipcc that treats any source file type (for example .cpp ) as an HIP translation unit leading to some conflicts with the OpenMP language switch. If the OpenMP source file doesn't contain any HIP language constructs you could work around this issue by adding the -x c++ switch to force the compiler to treat the file as regular C++. Another approach would be to guard the OpenMP code with #ifdef \_OPENMP so that the code block is disabled when compiling for the GPU. The \_\_HIP\_DEVICE\_COMPILE\_\_ macro defined by the HIP compiler when compiling GPU code could also be used for guarding code paths specific to the host or the GPU.
-
-## 17.30 Does the HIP-Clang compiler support extern shared declarations?
-
-Previously, it was essential to declare dynamic shared memory using the HIP\_DYNAMIC\_SHARED macro for accuracy, as using static shared memory in the same kernel could result in overlapping memory ranges and data-races.
-
-Now, the HIP-Clang compiler provides support for extern shared declarations, and the HIP\_DYNAMIC\_SHARED option is no longer required. You may use the standard extern definition: extern shared type var[];
-
-## 17.31 I have multiple HIP enabled devices and I am getting an error code hipErrorSharedObjectInitFailed with the message 'Error: shared object initialization failed'?
-
-This error message is seen due to the fact that you do not have valid code object for all of your devices.
-
-If you have compiled the application yourself, make sure you have given the correct device name(s) and its features via: --offload-arch . If you are not mentioning the --offload-arch , make sure that hipcc is using the correct offload arch by verifying the hipcc output generated by setting the environment variable HIPCC\_VERBOSE=1 .
-
-If you have a precompiled application/library (like rocblas, TensorFlow etc) which gives you such error, there are one of two possibilities.
-
-- The application/library does not ship code object bundles for all of your device(s): in this case you need to recompile the application/library yourself with correct --offload-arch .
-- The application/library does not ship code object bundles for some of your device(s), for example you have a system with an APU + GPU and the library does not ship code objects for your APU. For this you can set the environment variable HIP\_VISIBLE\_DEVICES or CUDA\_VISIBLE\_DEVICES on NVIDIA platform, to only enable GPUs for which code object is available. This will limit the GPUs visible to your application and allow it to run.
-
-Note: In previous releases, the error code is hipErrorNoBinaryForGpu with message 'Unable to find code object for all current devices'. The error code handling behavior is changed. HIP runtime shows the error code hipErrorSharedObjectInitFailed with message 'Error: shared object initialization failed' on unsupported GPU.
-
-## 17.32 How to use per-thread default stream in HIP?
-
-The per-thread default stream is an implicit stream local to both the thread and the current device. It does not do any implicit synchronization with other streams (like explicitly created streams), or default per-thread stream on other threads.
-
-The per-thread default stream is a blocking stream and will synchronize with the default null stream if both are used in a program.
-
-In ROCm, a compilation option should be added in order to compile the translation unit with per-thread default stream enabled. -fgpu-default-stream=per-thread . Once source is compiled with per-thread default stream enabled, all APIs will be executed on per thread default stream, hence there will not be any implicit synchronization with other streams.
-
-Besides, per-thread default stream be enabled per translation unit, users can compile some files with feature enabled and some with feature disabled. Feature enabled translation unit will have default stream as per thread and there will not be any implicit synchronization done but other modules will have legacy default stream which will do implicit synchronization.
-
-## 17.33 How to use complex multiplication and division operations?
-
-In HIP, hipFloatComplex and hipDoubleComplex are defined as complex data types,
-**Following code does:** This code is a command-line instruction that uses the `git` version control system to create a local copy (clone) of the repository located at the specified URL, `https://github.com/amd/rcm-examples.git`. This repository is hosted on GitHub and likely contains example code or resources related to AMD's RCM (Resource and Configuration Management) tools or projects. The cloned repository will be downloaded to the current directory where the command is executed.
-
-
-```
-<_C_>
-```
-
-Any application uses complex multiplication and division operations, need to replace '*' and '/' operators with the following,
-
-- hipCmulf() and hipCdivf() for hipFloatComplex
-- hipCmul() and hipCdiv() for hipDoubleComplex
-
-Note: These complex operations are equivalent to corresponding types/functions on the NVIDIA platform.
-
-## 17.34 Can I develop applications with HIP APIs on Windows the same on Linux?
-
-Yes, HIP APIs are available to use on both Linux and Windows. Due to different working mechanisms on operating systems like Windows vs Linux, HIP APIs call corresponding lower level backend runtime libraries and kernel drivers for the OS, in order to control the executions on GPU hardware accordingly. There might be a few differences on the related backend software and driver support, which might affect usage of HIP APIs. See OS support details in HIP API document.
-
-## 17.35 Does HIP support LUID?
-
-Starting ROCm 6.0, HIP runtime supports Locally Unique Identifier (LUID). This feature enables the local physical device(s) to interoperate with other devices. For example, DirectX 12.
-
-HIP runtime sets device LUID properties so the driver can query LUID to identify each device for interoperability.
-
-Note: HIP supports LUID only on Windows OS.
-
-## 17.36 How can I know the version of HIP?
-
-HIP version definition has been updated since ROCm 4.2 release as the following:
-**Following code does:** This code snippet is written in C++ using the HIP API, which is used for GPU programming. The code's high-level purpose is to allocate memory on a GPU device and copy data from the host (CPU) to the device (GPU). Specifically, it allocates memory for two float arrays (`d_x` and `d_y`) on the GPU, each with a size specified by `size_bytes`. It then copies data from two host arrays (`x` and `y`) to these newly allocated device arrays. The `HIP_CHECK` macro is likely used to handle errors that may occur during these operations.
-
-
-```
-<_SQL_>
-```
-
-HIP version can be queried from HIP API call, hipRuntimeGetVersion(&amp;runtimeVersion);
-
-The version returned will always be greater than the versions in previous ROCm releases.
-
-Note: The version definition of HIP runtime is different from CUDA. On AMD platform, the function returns HIP runtime version, while on NVIDIA platform, it returns CUDA runtime version. And there is no mapping/correlation between HIP version and CUDA version.
-
-## 18.1 Related Pages
-
-18.2 Topics
-
-## 18.3 Namespaces
-
-18.3.1 Namespace List
-
-18.3.2 Namespace Members
-
-18.3.2.1 Namespace Members
-
-18.3.2.2 Namespace Members
-
-## 18.4 Data Structures
-
-- 18.4.1 Data Structures
-- 18.4.2 Data Structure Index
-- 18.4.3 Class Hierarchy
-
-18.4.4 Data Fields
-
-18.4.4.1 All
-
-18.4.4.1.1 Data Fields
-
-18.4.4.1.2 Data Fields
-
-18.4.4.1.3 Data Fields
-
-18.4.4.1.4 Data Fields
-
-18.4.4.1.5 Data Fields
-
-18.4.4.1.6 Data Fields 26
-
-18.4.4.1.7 Data Fields
-
-CHAPTER
-
-## EIGHTEEN
-
-## HIP RUNTIME API REFERENCE
-
-## CHAPTER
-
-## NINETEEN
-
-## C++ LANGUAGE EXTENSIONS
-
-HIP provides a C++ syntax that is suitable for compiling most code that commonly appears in compute kernels (classes, namespaces, operator overloading, and templates). HIP also defines other language features that are designed to target accelerators, such as:
-
-- A kernel-launch syntax that uses standard C++ (this resembles a function call and is portable to all HIP targets)
-- Short-vector headers that can serve on a host or device
-- Math functions that resemble those in math.h , which is included with standard C++ compilers
-- Built-in functions for accessing specific GPU hardware capabilities
-
-Note: This chapter describes the built-in variables and functions that are accessible from the HIP kernel. It's intended for users who are familiar with CUDA kernel syntax and want to learn how HIP differs from CUDA.
-
-Features are labeled with one of the following keywords:
-
-- Supported : HIP supports the feature with a CUDA-equivalent function
-- Not supported : HIP does not support the feature
-- Under development : The feature is under development and not yet available
-
-## 19.1 Function-type qualifiers
-
-## 19.1.1 \_\_device\_\_
-
-Supported \_\_device\_\_ functions are:
-
-- Run on the device
-- Called from the device only
-
-You can combine \_\_device\_\_ with the host keyword ( \_\_host\_\_ ).
-
-## 19.1.2 \_\_global\_\_
-
-Supported \_\_global\_\_ functions are:
-
-- Run on the device
-- Called (launched) from the host
-
-HIP \_\_global\_\_ functions must have a void return type.
-
-HIP doesn't support dynamic-parallelism, which means that you can't call \_\_global\_\_ functions from the device.
-
-## 19.1.3 \_\_host\_\_
-
-Supported \_\_host\_\_ functions are:
-
-- Run on the host
-- Called from the host
-
-You can combine \_\_host\_\_ with \_\_device\_\_ ; in this case, the function compiles for the host and the device. Note that these functions can't use the HIP grid coordinate functions (e.g., threadIdx.x ). If you need to use HIP grid coordinate functions, you can pass the necessary coordinate information as an argument.
-
-You can't combine \_\_host\_\_ with \_\_global\_\_ .
-
-HIP parses the \_\_noinline\_\_ and \_\_forceinline\_\_ keywords and converts them into the appropriate Clang attributes.
-
-## 19.2 Calling \_\_global\_\_ functions
-
-\_\_global\_\_ functions are often referred to as kernels . When you call a global function, you're launching a kernel . When launching a kernel, you must specify an execution configuration that includes the grid and block dimensions. The execution configuration can also include other information for the launch, such as the amount of additional shared memory to allocate and the stream where you want to execute the kernel.
-
-HIP introduces a standard C++ calling convention ( hipLaunchKernelGGL ) to pass the run configuration to the kernel. However, you can also use the CUDA &lt;&lt;&lt; &gt;&gt;&gt; syntax.
-
-When using hipLaunchKernelGGL , your first five parameters must be:
-
-- symbol kernelName : The name of the kernel you want to launch. To support template kernels that contain "," , use the HIP\_KERNEL\_NAME macro (HIPIFY tools insert this automatically).
-- dim3 gridDim : 3D-grid dimensions that specify the number of blocks to launch.
-- dim3 blockDim : 3D-block dimensions that specify the number of threads in each block.
-- size\_t dynamicShared : The amount of additional shared memory that you want to allocate when launching the kernel (see \_\_shared\_\_ ).
-- hipStream\_t : The stream where you want to run the kernel. A value of 0 corresponds to the NULL stream (see Synchronization functions ).
-
-You can include your kernel arguments after these parameters.
-**Following code does:** This code snippet is part of a GPU programming context, likely using a framework like CUDA or HIP for parallel computing. The high-level purpose of the code is to perform a SAXPY operation (Single-Precision A·X Plus Y) on a GPU. The `saxpy_kernel` function is a kernel function that runs on the GPU and performs the SAXPY operation on arrays `d_x` and `d_y` with a scalar `a`. The `main` function sets up the execution environment and launches this kernel on the GPU using a specified grid and block size configuration. The kernel is executed on the default stream, which is a queue for managing the execution order of operations on the GPU.
-
-
-```
-                                                                                                                                                                                                        // Example hipLaunchKernelGGL pseudocode:
-```
-**Following code does:** The code snippet `<_Cuda_>` appears to be a placeholder or a symbolic representation rather than actual executable Python code. In a typical context, "Cuda" refers to NVIDIA's parallel computing platform and application programming interface (API) model, which allows developers to use a CUDA-enabled graphics processing unit (GPU) for general purpose processing. However, without additional context or surrounding code, it is not possible to determine the specific functionality or purpose of this snippet.
-
-
-```
-
-ize_t  N)
-```
-
-(continued from previous page)
-**Following code does:** This code snippet is part of a program that uses HIP, a C++ runtime API and kernel language that allows developers to write portable code to run on AMD and NVIDIA GPUs. The specific line of code is performing a memory copy operation from a GPU device to the host (CPU) memory. 
-
-Here's a high-level explanation of what it does:
-
-- `hipMemcpy` is a function that copies data between host and device memory.
-- `y.data()` is likely a pointer or an array on the host where the data will be copied to.
-- `d_y` is a pointer or an array on the device (GPU) from which the data will be copied.
-- `size_bytes` specifies the number of bytes to copy.
-- `hipMemcpyDeviceToHost` is an enumeration that indicates the direction of the copy, from device to host.
-
-The `HIP_CHECK` macro is likely used to check for errors in the `hipMemcpy` operation, ensuring that the memory copy was successful.
-
-
-```
-                                                                                                                                                                                                        (continued from previous page)
-                                                                                                                                                                                                       
-                                                                                                                                                                                                      
-}
-
-MyKernel<<<dim3(gridDim), dim3(groupDim), 0, 0>>> (a,b,c,n);
-
-// Alternatively, you can launch the kernel using:
-// hipLaunchKernelGGL(MyKernel, dim3(gridDim), dim3(groupDim), 0/*dynamicShared*/, 0/
-                                                                                                                                                                                                       :*stream), a, b, c, n);
-```
-
-You can use HIPIFY tools to convert CUDA launch syntax to hipLaunchKernelGGL . This includes the conversion of optional &lt;&lt;&lt; &gt;&gt;&gt; arguments into the five required hipLaunchKernelGGL parameters. Note: HIP doesn't support dimension sizes of 𝑔𝑟𝑖𝑑𝐷𝑖𝑚 * 𝑏𝑙𝑜𝑐𝑘𝐷𝑖𝑚 ≥ 2 32 when launching a kernel.
-
-## 19.3 Kernel launch example
-**Following code does:** This code snippet is a shell command that modifies the `PATH` environment variable. It prepends the directory `/opt/rcm/bin` to the existing `PATH`. This means that when the system searches for executable files, it will first look in `/opt/rcm/bin` before checking the other directories listed in the current `PATH`. This is typically done to prioritize custom or specific versions of executables located in `/opt/rcm/bin` over those in other directories.
-
-
-```
-
-// Example showing device function, __device__ __host__
-// <- compile for both device and host
-float PlusOne(float x)
-{
-  return x + 1.0;
-}
-
-__global__
-void
-MyKernel (hipLaunchParm lp, /*lp parm for execution configuration */
-          const float *a, const float *b, float *c, unsigned N)
-{
-  unsigned gid = threadIdx.x; // <- coordinate index function
-  if (gid < N) {
-    c[gid] = a[gid] + PlusOne(b[gid]);
-  }
-}
-void callMyKernel()
-{
-  float *a, *b, *c; // initialization not shown...
-  unsigned N = 1000000;
-  const unsigned blockSize = 256;
-
-  MyKernel<<<dim3(gridDim), dim3(groupDim), 0, 0>>> (a,b,c,n);
-  // Alternatively, kernel can be launched by
-  // hipLaunchKernelGGL(MyKernel, dim3(N/blockSize), dim3(blockSize), 0, 0, a,b,c,N);
-}
-```
-
-## 19.4 Variable type qualifiers
-
-## 19.4.1 \_\_constant\_\_
-
-The host writes constant memory before launching the kernel. This memory is read-only from the GPU while the kernel is running. The functions for accessing constant memory are:
-
-- hipGetSymbolAddress()
-- hipGetSymbolSize()
-- hipMemcpyToSymbol()
-- hipMemcpyToSymbolAsync()
-- hipMemcpyFromSymbol()
-- hipMemcpyFromSymbolAsync()
-
-## 19.4.2 \_\_shared\_\_
-
-To allow the host to dynamically allocate shared memory, you can specify extern \_\_shared\_\_ as a launch parameter.
-
-Note: Prior to the HIP-Clang compiler, dynamic shared memory had to be declared using the HIP\_DYNAMIC\_SHARED macro in order to ensure accuracy. This is because using static shared memory in the same kernel could've resulted in overlapping memory ranges and data-races. The HIP-Clang compiler provides support for extern \_\_shared\_ declarations, so HIP\_DYNAMIC\_SHARED is no longer required.
-
-## 19.4.3 \_\_managed\_\_
-
-Managed memory, including the \_\_managed\_\_ keyword, is supported in HIP combined host/device compilation.
-
-## 19.4.4 \_\_restrict\_\_
-
-\_\_restrict\_\_ tells the compiler that the associated memory pointer not to alias with any other pointer in the kernel or function. This can help the compiler generate better code. In most use cases, every pointer argument should use this keyword in order to achieve the benefit.
-
-## 19.5 Built-in variables
-
-## 19.5.1 Coordinate built-ins
-
-The kernel uses coordinate built-ins ( thread* , block* , grid* ) to determine the coordinate index and bounds for the active work item.
-
-Built-ins are defined in amd\_hip\_runtime.h , rather than being implicitly defined by the compiler.
-
-Coordinate variable definitions for built-ins are the same for HIP and CUDA. For example: threadIdx.x , blockIdx. y , and gridDim.y . The products gridDim.x * blockDim.x , gridDim.y * blockDim.y , and gridDim.z * blockDim.z are always less than 2^32 .
-
-Coordinate built-ins are implemented as structures for improved performance. When used with printf , they must be explicitly cast to integer types.
-
-## 19.5.2 warpSize
-
-The warpSize variable type is int . It contains the warp size (in threads) for the target device. warpSize should only be used in device functions that develop portable wave-aware code.
-
-Note: NVIDIA devices return 32 for this variable; AMD devices return 64 for gfx9 and 32 for gfx10 and above.
-
-## 19.6 Vector types
-
-The following vector types are defined in hip\_runtime.h . They are not automatically provided by the compiler.
-
-## 19.6.1 Short vector types
-
-Short vector types derive from basic integer and floating-point types. These structures are defined in hip\_vector\_types.h . The first, second, third, and fourth components of the vector are defined by the x , y , z , and w fields, respectively. All short vector types support a constructor function of the form make\_&lt;type\_name&gt;() . For example, float4 make\_float4(float x, float y, float z, float w) creates a vector with type float4 and value (x,y,z,w) .
-
-HIP supports the following short vector formats:
-
-- Signed Integers:
-- -char1 , char2 , char3 , char4
-- -short1 , short2 , short3 , short4
-- -int1 , int2 , int3 , int4
-- -long1 , long2 , long3 , long4
-- -longlong1 , longlong2 , longlong3 , longlong4
-- Unsigned Integers:
-- -uchar1 , uchar2 , uchar3 , uchar4
-- -ushort1 , ushort2 , ushort3 , ushort4
-- -uint1 , uint2 , uint3 , uint4
-- -ulong1 , ulong2 , ulong3 , ulong4
-- -ulonglong1 , ulonglong2 , ulonglong3 , ulonglong4
-- Floating Points:
-- -float1 , float2 , float3 , float4
-- -double1 , double2 , double3 , double4
-
-## 19.6.2 dim3
-
-dim3 is a three-dimensional integer vector type that is commonly used to specify grid and group dimensions.
-
-The dim3 constructor accepts between zero and three arguments. By default, it initializes unspecified dimensions to 1.
-**Following code does:** The code snippet provided is not valid Python code. It consists of a single closing curly brace `}`, which is not used in Python syntax. Curly braces are typically used in languages like C, C++, Java, and JavaScript to denote blocks of code, but in Python, indentation is used instead. Therefore, this snippet does not perform any function or operation in Python.
-
-
-```
-<_C_>
-```
-
-## 19.7 Memory fence instructions
-
-HIP supports \_\_threadfence() and \_\_threadfence\_block() . If you're using threadfence\_system() in the HIP-Clang path, you can use the following workaround:
-
-1. Build HIP with the HIP\_COHERENT\_HOST\_ALLOC environment variable enabled.
-2. Modify kernels that use \_\_threadfence\_system() as follows:
-- Ensure the kernel operates only on fine-grained system memory, which should be allocated with hipHostMalloc() .
-- Remove memcpy for all allocated fine-grained system memory regions.
-
-## 19.8 Synchronization functions
-
-Synchronization functions causes all threads in the group to wait at this synchronization point, and for all shared and global memory accesses by the threads to complete, before running synchronization. This guarantees the visibility of accessed data for all threads in the group.
-
-The \_\_syncthreads() built-in function is supported in HIP. The \_\_syncthreads\_count(int) , \_\_syncthreads\_and(int) , and \_\_syncthreads\_or(int) functions are under development.
-
-The Cooperative Groups API offer options to do synchronization on a developer defined set of thread groups. For further information, check Cooperative Groups API or Cooperative Groups how to .
-
-## 19.9 Math functions
-
-HIP-Clang supports a set of math operations that are callable from the device. HIP supports most of the device functions supported by CUDA. These are described on Math API page .
-
-## 19.10 Texture functions
-
-The supported texture functions are listed in texture\_fetch\_functions.h and texture\_indirect\_functions. h header files in the HIP-AMD backend repository.
-
-Texture functions are not supported on some devices. To determine if texture functions are supported on your device, use Macro \_\_HIP\_NO\_IMAGE\_SUPPORT == 1 . You can query the attribute hipDeviceAttributeImageSupport to check if texture functions are supported in the host runtime code.
-
-## 19.11 Surface functions
-
-The following surface functions are supported in HIP:
-
-hipError\_t hipCreateSurfaceObject ( hipSurfaceObject\_t *pSurfObject, const hipResourceDesc *pResDesc )
-
-Create a surface object.
-
-## Parameters
-
-- pSurfObject -[out] Pointer of surface object to be created.
-- pResDesc -[in] Pointer of suface object descriptor.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipDestroySurfaceObject ( hipSurfaceObject\_t surfaceObject )
-
-Destroy a surface object.
-
-## Parameters
-
-surfaceObject -[in] Surface object to be destroyed.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf1Dread ( T *data, hipSurfaceObject\_t surfObj, int x, int boundaryMode = hipBoundaryModeZero )
-
-Reads the value at coordinate x from the one-dimensional surface.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [out] The T type result is stored in this pointer.
-- surfObj - [in] The surface descriptor.
-- x - [in] The coordinate where the value will be read out.
-- boundaryMode - [in] The boundary mode is currently ignored.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf1Dwrite ( T data, hipSurfaceObject\_t surfObj, int x )
-
-Writes the value data to the one-dimensional surface at coordinate x.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [in] The T type value is written to surface.
-
-- surfObj - [in] The surface descriptor.
-- x - [in] The coordinate where the data will be written.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf2Dread ( T *data, hipSurfaceObject\_t surfObj, int x, int y )
-
-Reads the value from the two-dimensional surface at coordinate x, y.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [out] The T type result is stored in this pointer.
-- surfObj - [in] The surface descriptor.
-- x - [in] The x coordinate where the value will be read out.
-- y - [in] The y coordinate where the value will be read out.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf2Dwrite ( T data, hipSurfaceObject\_t surfObj, int x, int y )
-
-Writes the value data to the two-dimensional surface at coordinate x, y.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [in] The T type value is written to surface.
-- surfObj - [in] The surface descriptor.
-- x - [in] The x coordinate where the data will be written.
-- y - [in] The y coordinate where the data will be written.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf3Dread ( T *data, hipSurfaceObject\_t surfObj, int x, int y, int z )
-
-Reads the value from the three-dimensional surface at coordinate x, y, z.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [out] The T type result is stored in this pointer.
-- surfObj - [in] The surface descriptor.
-- x - [in] The x coordinate where the value will be read out.
-- y - [in] The y coordinate where the value will be read out.
-- z - [in] The z coordinate where the value will be read out.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf3Dwrite ( T data, hipSurfaceObject\_t surfObj, int x, int y, int z )
-
-Writes the value data to the three-dimensional surface at coordinate x, y, z.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [in] The T type value is written to surface.
-- surfObj - [in] The surface descriptor.
-- x - [in] The x coordinate where the data will be written.
-- y - [in] The y coordinate where the data will be written.
-- z - [in] The z coordinate where the data will be written.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf1DLayeredread ( T *data, hipSurfaceObject\_t surfObj, int x, int layer )
-
-Reads the value from the one-dimensional layered surface at coordinate x and layer index.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [out] The T type result is stored in this pointer.
-- surfObj - [in] The surface descriptor.
-- x - [in] The coordinate where the value will be read out.
-- layer - [in] The layer index where the value will be read out.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf1DLayeredwrite ( T data, hipSurfaceObject\_t surfObj, int x, int layer )
-
-Writes the value data to the one-dimensional layered surface at coordinate x and layer index.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [in] The T type value is written to surface.
-- surfObj - [in] The surface descriptor.
-- x - [in] The x coordinate where the data will be written.
-- layer - [in] The layer index where the data will be written.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf2DLayeredread ( T *data, hipSurfaceObject\_t surfObj, int x, int y, int layer )
-
-Reads the value from the two-dimensional layered surface at coordinate x, y and layer index.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [out] The T type result is stored in this pointer.
-- surfObj - [in] The surface descriptor.
-- x - [in] The x coordinate where the value will be read out.
-- y - [in] The y coordinate where the value will be read out.
-- layer - [in] The layer index where the value will be read out.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt;
-
-static void surf2DLayeredwrite ( T data, hipSurfaceObject\_t surfObj, int x, int y, int layer )
-
-Writes the value data to the two-dimensional layered surface at coordinate x, y and layer index.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [in] The T type value is written to surface.
-- surfObj - [in] The surface descriptor.
-- x - [in] The x coordinate where the data will be written.
-- y - [in] The y coordinate where the data will be written.
-- layer - [in] The layer index where the data will be written.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surfCubemapread ( T *data, hipSurfaceObject\_t surfObj, int x, int y, int face )
-
-Reads the value from the cubemap surface at coordinate x, y and face index.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [out] The T type result is stored in this pointer.
-- surfObj - [in] The surface descriptor.
-- x - [in] The x coordinate where the value will be read out.
-- y - [in] The y coordinate where the value will be read out.
-- face - [in] The face index where the value will be read out.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surfCubemapwrite ( T data, hipSurfaceObject\_t surfObj, int x, int y, int face )
-
-Writes the value data to the cubemap surface at coordinate x, y and face index.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [in] The T type value is written to surface.
-- surfObj - [in] The surface descriptor.
-- x - [in] The x coordinate where the data will be written.
-- y - [in] The y coordinate where the data will be written.
-- face - [in] The face index where the data will be written.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surfCubemapLayeredread ( T *data, hipSurfaceObject\_t surfObj, int x, int y, int face, int layer )
-
-Reads the value from the layered cubemap surface at coordinate x, y and face, layer index.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [out] The T type result is stored in this pointer.
-
-- surfObj - [in] The surface descriptor.
-- x - [in] The x coordinate where the value will be read out.
-- y - [in] The y coordinate where the value will be read out.
-- face - [in] The face index where the value will be read out.
-- layer - [in] The layer index where the data will be written.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surfCubemapLayeredwrite ( T *data, hipSurfaceObject\_t surfObj, int x, int y, int face, int layer )
-
-Writes the value data to the layered cubemap surface at coordinate x, y and face, layer index.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [in] The T type value to write to the surface.
-- surfObj - [in] The surface descriptor.
-- x - [in] The x coordinate where the data will be written.
-- y - [in] The y coordinate where the data will be written.
-- face - [in] The face index where the data will be written.
-- layer - [in] The layer index where the data will be written.
-
-## 19.12 Timer functions
-
-To read a high-resolution timer from the device, HIP provides the following built-in functions:
-
-- Returning the incremental counter value for every clock cycle on a device:
-**Following code does:** The code snippet is not actually a code but rather an instruction. It suggests that you should be able to execute a command in the command line to check the version of a compiler named `amdclang++`. This implies that `amdclang++` is a C++ compiler, likely provided by AMD, and the command `amdclang++ --version` is used to display the version information of this compiler.
-
-
-```
-<_SQL_>
-```
-**Following code does:** This code snippet is a shell command that checks the version of the NVIDIA CUDA Compiler (nvcc) installed on the system. By executing `nvcc --version`, it outputs the version information of the nvcc tool, which is part of the CUDA Toolkit used for compiling CUDA programs. This is useful for verifying the installation and version of CUDA on a machine.
-
-
-```
-    [clock_t clock()
-    long long int close
-```
-
-The difference between the values that are returned represents the cycles used.
-
-- Returning the wall clock count at a constant frequency on the device:
-**Following code does:** This PowerShell script is designed to set up a development environment for Visual Studio. Here's a high-level summary of what it does:
-
-1. **Locate Visual Studio Installation**: It retrieves a list of installed Visual Studio instances, sorts them by version in descending order, and selects the most recent one. It then extracts the installation path of this latest version.
-
-2. **Import Visual Studio Module**: It imports a specific Visual Studio module (`Microsoft.VisualStudio.DevShell.dll`) from the installation path. This module is likely used to facilitate the setup of a development shell environment.
-
-3. **Enter Visual Studio Developer Shell**: It enters the Visual Studio Developer Shell using the installation path determined earlier. It specifies the architecture as `amd64` for both the host and the development environment, and it suppresses the display of the logo with the `-no_logo` argument.
-
-4. **Modify Environment Path**: It updates the system's `PATH` environment variable by prepending a directory (`bin` subdirectory of `HIP_PATH`) to the existing `PATH`. This ensures that executables in this directory are prioritized when running commands.
-
-Overall, the script automates the process of setting up a Visual Studio development environment with specific configurations and updates the system path to include additional tools.
-
-
-```
-  | long long int w:
-```
-**Following code does:** This code snippet is a shell command that checks the version of the `clang++` compiler installed on the system. `clang++` is the C++ compiler that is part of the LLVM project. Running this command will output the version information of the `clang++` compiler, including details like the version number, target architecture, and possibly the build date.
-
-
-```
-    it will_clock64()
-```
-
-This can be queried using the HIP API with the hipDeviceAttributeWallClockRate attribute of the device in HIP application code. For example:
-**Following code does:** This PowerShell script is designed to set up a development environment for Visual Studio. It performs the following high-level tasks:
-
-1. **Retrieve Visual Studio Installation Path**: It queries the system for installed Visual Studio instances, sorts them by version in descending order, and selects the installation path of the latest version.
-
-2. **Import Visual Studio Development Shell Module**: It imports a specific module (`Microsoft.VisualStudio.DevShell.dll`) from the selected Visual Studio installation. This module is used to configure the development environment.
-
-3. **Enter Visual Studio Development Shell**: It initializes the Visual Studio Developer Command Prompt environment for the specified installation path, targeting the `amd64` architecture for both the host and the development environment, while suppressing the display of the logo. This sets up the necessary environment variables and paths for development tasks.
-
-
-```
-            int wallClkRate = 0; //in kilohertz
-            HIPCHECK(hipDeviceGetAttribute(&wallClkRate, hipDeviceAttributeWallClockRate, _
-            --deviceId));
-```
-
-Where hipDeviceAttributeWallClockRate is a device attribute. Note that wall clock frequency is a perdevice attribute.
-
-Note that clock() and clock64() do not work properly on AMD RDNA3 (GFX11) graphic processors.
-
-## 19.13 Atomic functions
-
-Atomic functions are run as read-modify-write (RMW) operations that reside in global or shared memory. No other device or thread can observe or modify the memory location during an atomic operation. If multiple instructions from different devices or threads target the same memory location, the instructions are serialized in an undefined order.
-
-To support system scope atomic operations, you can use the HIP APIs that contain the \_system suffix. For example:
-
-- atomicAnd : This function is atomic and coherent within the GPU device running the function
-- atomicAnd\_system : This function extends the atomic operation from the GPU device to other CPUs and GPU devices in the system.
-
-HIP supports the following atomic operations.
-
-Table 1: Atomic operations
-
-| Function int atomicAdd(int* address, int val) int atomicAdd_system(int* address, int val) unsigned int atomicAdd(unsigned int* address,unsigned unsigned int atomicAdd_system(unsigned int* address, unsigned long long atomicAdd(unsigned long long* unsigned long long atomicAdd_system(unsigned long long* float atomicAdd(float* address, float val) float atomicAdd_system(float* address, float val) double atomicAdd(double* address, double val) double atomicAdd_system(double* address, double val) float unsafeAtomicAdd(float* address, float val) float safeAtomicAdd(float* address, float val)   |
-|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| int val) unsigned int val) address,unsigned long long val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| address, unsigned long long val) double unsafeAtomicAdd(double* address, double val) double safeAtomicAdd(double* address, double val) int atomicSub(int* address, int val) int atomicSub_system(int* address, int val) unsigned int atomicSub(unsigned int* address,unsigned int val) unsigned int atomicSub_system(unsigned int* address, unsigned int val)                                                                                                                                                                                                                                                   |
-| int atomicExch(int* address, int val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
-| int atomicExch_system(int* address, int val) unsigned int atomicExch(unsigned int* address,unsigned int val) unsigned int atomicExch_system(unsigned int* address, unsigned int val)                                                                                                                                                                                                                                                                                                                                                                                                                            |
-| unsigned long long atomicExch(unsigned long long int* address,unsigned long val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-| long unsigned long long atomicExch_system(unsigned long long* address, unsigned long                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
-| int long val) unsigned long long atomicExch_system(unsigned long long* address, unsigned long long val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| float atomicExch(float* address, float val) int atomicMin(int* address, int val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-| int atomicMin_system(int* address, int val) unsigned int atomicMin(unsigned int* address,unsigned int                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
-| val) unsigned int atomicMin_system(unsigned int* address, unsigned int                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
-| val) unsigned long long atomicMin(unsigned long long* address,unsigned long long val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
-| atomicMax(int* address, int val) atomicMax_system(int* address, int val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
-| int unsigned int atomicMax(unsigned int* address,unsigned int val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
-| unsigned int atomicMax_system(unsigned int* address, unsigned int                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
-| int                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
-| val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
-| unsigned long long atomicMax(unsigned long long* address,unsigned long long val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-
-Table 1 - continued from previous page
-
-| unsigned int atomicDec(unsigned int* address)                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| int atomicCAS(int* address, int compare, int val)                                                                                                                                                                                                                                                                                                                                                                                                                              |
-| int atomicCAS_system(int* address, int compare, int val)                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| unsigned int atomicCAS(unsigned int* address,unsigned int compare,unsigned int val) unsigned int atomicCAS_system(unsigned int* address, unsigned int compare, unsigned int val) unsigned long long atomicCAS(unsigned long long* address,unsigned long long compare,unsigned long long unsigned long long atomicCAS_system(unsigned long long* address, unsigned long long compare, unsigned int atomicAnd(int* address, int val) int atomicAnd_system(int* address, int val) |
-| unsigned int atomicAnd(unsigned int* address,unsigned int val) unsigned int atomicAnd_system(unsigned int* address, unsigned int val)                                                                                                                                                                                                                                                                                                                                          |
-| unsigned long long atomicAnd(unsigned long long* address,unsigned long long val) unsigned long long atomicAnd_system(unsigned long long* address, unsigned long                                                                                                                                                                                                                                                                                                                |
-| long val) int atomicOr(int* address, int val)                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| int atomicOr_system(int* address, int val)                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| unsigned int atomicOr(unsigned int* address,unsigned int val) unsigned int atomicOr_system(unsigned int* address, unsigned                                                                                                                                                                                                                                                                                                                                                     |
-| int val) unsigned int atomicOr_system(unsigned int* address, unsigned int val)                                                                                                                                                                                                                                                                                                                                                                                                 |
-| unsigned long long atomicOr(unsigned long long int* address,unsigned long long val)                                                                                                                                                                                                                                                                                                                                                                                            |
-| unsigned long long atomicOr_system(unsigned long long* address, unsigned long long val)                                                                                                                                                                                                                                                                                                                                                                                        |
-| int atomicXor(int* address, int val)                                                                                                                                                                                                                                                                                                                                                                                                                                           |
-| int atomicXor_system(int* address, int val)                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| unsigned int atomicXor(unsigned int* address,unsigned int val)                                                                                                                                                                                                                                                                                                                                                                                                                 |
-| unsigned int atomicXor_system(unsigned int* address, unsigned int val)                                                                                                                                                                                                                                                                                                                                                                                                         |
-| unsigned long long atomicXor(unsigned long long* address,unsigned long long val)                                                                                                                                                                                                                                                                                                                                                                                               |
-| unsigned long long atomicXor_system(unsigned long long* address, unsigned long long                                                                                                                                                                                                                                                                                                                                                                                            |
-| val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
-
-## 19.13.1 Unsafe floating-point atomic RMW operations
-
-Some HIP devices support fast atomic RMW operations on floating-point values. For example, atomicAdd on singleor double-precision floating-point values may generate a hardware RMW instruction that is faster than emulating the atomic operation using an atomic compare-and-swap (CAS) loop.
-
-On some devices, fast atomic RMW instructions can produce results that differ from the same functions implemented with atomic CAS loops. For example, some devices will use different rounding or denormal modes, and some devices produce incorrect answers if fast floating-point atomic RMW instructions target fine-grained memory allocations.
-
-The HIP-Clang compiler offers a compile-time option, so you can choose fast-but potentially unsafe-atomic instructions for your code. On devices that support these instructions, you can include the -munsafe-fp-atomics option. This flag indicates to the compiler that all floating-point atomic function calls are allowed to use an unsafe version, if one exists. For example, on some devices, this flag indicates to the compiler that no floating-point atomicAdd function can target fine-grained memory.
-
-If you want to avoid using unsafe use a floating-point atomic RMW operations, you can use the -mno-unsafe-fp-atomics option. Note that the compiler default is to not produce unsafe floating-point atomic RMW instructions, so the -mno-unsafe-fp-atomics option is not necessarily required. However, passing this option to the compiler is good practice.
-
-When you pass -munsafe-fp-atomics or -mno-unsafe-fp-atomics to the compiler's command line, the option is applied globally for the entire compilation. Note that if some of the atomic RMW function calls cannot safely use the faster floating-point atomic RMW instructions, you must use -mno-unsafe-fp-atomics in order to ensure that your atomic RMW function calls produce correct results.
-
-HIP has four extra functions that you can use to more precisely control which floating-point atomic RMW functions produce unsafe atomic RMW instructions:
-
-- float unsafeAtomicAdd(float* address, float val)
-- double unsafeAtomicAdd(double* address, double val) (Always produces fast atomic RMW instructions on devices that have them, even when -mno-unsafe-fp-atomics is used)
-- float safeAtomicAdd(float* address, float val)
-- double safeAtomicAdd(double* address, double val) (Always produces safe atomic RMW operations, even when -munsafe-fp-atomics is used)
-
-## 19.14 Warp cross-lane functions
-
-Threads in a warp are referred to as lanes and are numbered from 0 to warpSize - 1 . Warp cross-lane functions operate across all lanes in a warp. The hardware guarantees that all warp lanes will execute in lockstep, so additional synchronization is unnecessary, and the instructions use no shared memory.
-
-Note that NVIDIA and AMD devices have different warp sizes. You can use warpSize built-ins in you portable code to query the warp size.
-
-Tip: Be sure to review HIP code generated from the CUDA path to ensure that it doesn't assume a waveSize of 32. 'Wave-aware' code that assumes a waveSize of 32 can run on a wave-64 machine, but it only utilizes half of the machine's resources.
-
-To get the default warp size of a GPU device, use hipGetDeviceProperties in you host functions.
-**Following code does:** This code snippet is a shell command that checks the version of the NVIDIA CUDA Compiler (nvcc) installed on the system. By executing `nvcc --version`, it outputs information about the installed version of nvcc, which is part of the CUDA toolkit used for compiling CUDA programs that run on NVIDIA GPUs.
-
-
-```
-    cudaDeviceProp props;
-    cudaGetDeviceProperties(&props, deviceID);
-    int w = props.warpSize;
-    // implement portable algorithm based on w (rather than assume 32 or 64)
-```
-
-Only use warpSize built-ins in device functions, and don't assume warpSize to be a compile-time constant.
-
-Note that assembly kernels may be built for a warp size that is different from the default. All mask values either returned or accepted by these builtins are 64-bit unsigned integer values, even when compiled for a wave-32 device, where all the higher bits are unused. CUDA code ported to HIP requires changes to ensure that the correct type is used.
-
-Note that the \_\_sync variants are made available in ROCm 6.2, but disabled by default to help with the transition to 64-bit masks. They can be enabled by setting the preprocessor macro HIP\_ENABLE\_WARP\_SYNC\_BUILTINS . These builtins will be enabled unconditionally in ROCm 6.3. Wherever possible, the implementation includes a static assert to check that the program source uses the correct type for the mask.
-
-## 19.14.1 Warp vote and ballot functions
-**Following code does:** The code snippet provided appears to be a series of ASCII art arrows and lines, rather than functional code. It does not perform any computational tasks or have any executable logic. Its high-level purpose seems to be purely decorative or illustrative, possibly intended to visually represent directional arrows or boundaries.
-
-
-```
-int __all(int predicate)
-int __any(int predicate)
-unsigned long long __ballot(int predicate)
-unsigned long long __activemask()
-
-int __all_sync(unsigned long long mask, int predicate)
-```
-
-(continued from previous page)
-**Following code does:** This code snippet is a command-line instruction for compiling a HIP (Heterogeneous-Compute Interface for Portability) program using the NVIDIA CUDA Compiler (`nvcc`). The command is set to compile a source file located at `./HIP-Basic/saxpy/main.hip` into an executable named `saxpy`. It includes additional header files from the directories `./Common` and `/opt/rocm/include`. The `-O2` flag is used to optimize the code for better performance. The `-x cu` flag specifies that the input file is a CUDA source file. This setup is typically used for compiling GPU-accelerated applications that can run on both NVIDIA and AMD hardware using HIP.
-
-
-```
-<_Python_>
-```
-
-You can use \_\_any and \_\_all to get a summary view of the predicates evaluated by the participating lanes.
-
-- \_\_any() : Returns 1 if the predicate is non-zero for any participating lane, otherwise it returns 0.
-- \_\_all() : Returns 1 if the predicate is non-zero for all participating lanes, otherwise it returns 0.
-
-To determine if the target platform supports the any/all instruction, you can use the hasWarpVote device property or the HIP\_ARCH\_HAS\_WARP\_VOTE compiler definition.
-
-\_\_ballot returns a bit mask containing the 1-bit predicate value from each lane. The nth bit of the result contains the 1 bit contributed by the nth warp lane.
-
-\_\_activemask() returns a bit mask of currently active warp lanes. The nth bit of the result is 1 if the nth warp lane is active.
-
-Note that the \_\_ballot and \_\_activemask builtins in HIP have a 64-bit return value (unlike the 32-bit value returned by the CUDA builtins). Code ported from CUDA should be adapted to support the larger warp sizes that the HIP version requires.
-
-Applications can test whether the target platform supports the \_\_ballot or \_\_activemask instructions using the hasWarpBallot device property in host code or the HIP\_ARCH\_HAS\_WARP\_BALLOT macro defined by the compiler for device code.
-
-The \_sync variants require a 64-bit unsigned integer mask argument that specifies the lanes in the warp that will participate in cross-lane communication with the calling lane. Each participating thread must have its own bit set in its mask argument, and all active threads specified in any mask argument must execute the same call with the same mask, otherwise the result is undefined.
-
-## 19.14.2 Warp match functions
-**Following code does:** This code snippet is a command to compile a C++ program using the `clang++` compiler. It specifically compiles a file named `main.hip` located in the `HIP-Basic\saxpy` directory into an executable named `saxpy.exe`. The command includes several options:
-
-- `-I.\Common`: Specifies an additional directory (`.\Common`) to search for header files.
-- `-lamdhip64`: Links against the `amdhip64` library, which is likely related to AMD's HIP (Heterogeneous-Compute Interface for Portability) framework.
-- `-L ${env:HIP_PATH}`: Adds the directory specified by the environment variable `HIP_PATH` to the library search path.
-- `-lib`: Indicates that the output should be a library (though this seems inconsistent with the `-o saxpy.exe` option for an executable).
-- `-02`: This appears to be a typo or misconfiguration; it might be intended to be `-O2`, which is an optimization flag for the compiler.
-
-Overall, the command is intended to compile a HIP-based C++ program, linking it with necessary libraries and including specific directories for headers and libraries.
-
-
-```
-    unsigned long long __match_any(T value)
-    unsigned long long __match_all(T value, int *pred)
-
-    unsigned long long __match_any_sync(unsigned long long mask, T value)
-    unsigned long long __match_all_sync(unsigned long long mask, T value, int *pred)
-```
-
-T can be a 32-bit integer type, 64-bit integer type or a single precision or double precision floating point type.
-
-\_\_match\_any returns a bit mask containing a 1-bit for every participating lane if and only if that lane has the same value in value as the current lane, and a 0-bit for all other lanes.
-
-\_\_match\_all returns a bit mask containing a 1-bit for every participating lane if and only if they all have the same value in value as the current lane, and a 0-bit for all other lanes. The predicate pred is set to true if and only if all participating threads have the same value in value .
-
-The \_sync variants require a 64-bit unsigned integer mask argument that specifies the lanes in the warp that will participate in cross-lane communication with the calling lane. Each participating thread must have its own bit set in its mask argument, and all active threads specified in any mask argument must execute the same call with the same mask, otherwise the result is undefined.
-
-## 19.14.3 Warp shuffle functions
-
-The default width is warpSize (see Warp cross-lane functions ). Half-float shuffles are not supported.
-**Following code does:** The code snippet appears to be a command for compiling a HIP (Heterogeneous-Compute Interface for Portability) program using the `nvcc` compiler. The command is intended to compile a source file named `main.hip` located in the `saxpy` directory under `HIP-Basic`, and produce an executable named `saxpy.exe`. The command includes options to specify include directories (`-I ${env:HIP_PATH}include` and `-I.\Common`) and an optimization level (`-O2`). However, the snippet seems to be corrupted or improperly formatted, as it contains extraneous characters and symbols that do not form a valid command.
-
-
-```
-            The default width is warpSize (see Warp cross-lane functions). Half-float shuffles are not supported.
-                                                                                                                                                                                                        
-                                                                                                                                                                                                      
-int       __shfl           (T var,     int srcLane,  int width=warpSize);
-```
-
-T can be a 32-bit integer type, 64-bit integer type or a single precision or double precision floating point type.
-
-The \_sync variants require a 64-bit unsigned integer mask argument that specifies the lanes in the warp that will participate in cross-lane communication with the calling lane. Each participating thread must have its own bit set in its mask argument, and all active threads specified in any mask argument must execute the same call with the same mask, otherwise the result is undefined.
-
-## 19.15 Cooperative groups functions
-
-You can use cooperative groups to synchronize groups of threads. Cooperative groups also provide a way of communicating between groups of threads at a granularity that is different from the block.
-
-HIP supports the following kernel language cooperative groups types and functions:
-
-Table 2: Cooperative groups functions
-
-| Function                                | Supported in HIP   | Supported in CUDA   |
-|-----------------------------------------|--------------------|---------------------|
-| void thread_group.sync();               | ✓                  | ✓                   |
-| unsigned thread_group.size();           | ✓                  | ✓                   |
-| unsigned thread_group.thread_rank()     | ✓                  | ✓                   |
-| bool thread_group.is_valid();           | ✓                  | ✓                   |
-| grid_group this_grid()                  | ✓                  | ✓                   |
-| void grid_group.sync()                  | ✓                  | ✓                   |
-| unsigned grid_group.size()              | ✓                  | ✓                   |
-| unsigned grid_group.thread_rank()       | ✓                  | ✓                   |
-| bool grid_group.is_valid()              | ✓                  | ✓                   |
-| multi_grid_group this_multi_grid()      | ✓                  | ✓                   |
-| void multi_grid_group.sync()            | ✓                  | ✓                   |
-| unsigned multi_grid_group.size()        | ✓                  | ✓                   |
-| unsigned multi_grid_group.thread_rank() | ✓                  | ✓                   |
-| bool multi_grid_group.is_valid()        | ✓                  | ✓                   |
-| unsigned multi_grid_group.num_grids()   | ✓                  | ✓                   |
-| unsigned multi_grid_group.grid_rank()   | ✓                  | ✓                   |
-| thread_block this_thread_block()        | ✓                  | ✓                   |
-| multi_grid_group this_multi_grid()      | ✓                  | ✓                   |
-| void multi_grid_group.sync()            | ✓                  | ✓                   |
-| void thread_block.sync()                | ✓                  | ✓                   |
-| unsigned thread_block.size()            | ✓                  | ✓                   |
-| unsigned thread_block.thread_rank()     | ✓                  | ✓                   |
-| bool thread_block.is_valid()            | ✓                  | ✓                   |
-| dim3 thread_block.group_index()         | ✓                  | ✓                   |
-| dim3 thread_block.thread_index()        | ✓                  | ✓                   |
-
-For further information, check Cooperative Groups API or Cooperative Groups how to .
-
-## 19.16 Warp matrix functions
-
-Warp matrix functions allow a warp to cooperatively operate on small matrices that have elements spread over lanes in an unspecified manner.
-
-HIP does not support kernel language warp matrix types or functions.
-
-Table 3: Warp matrix functions
-
-| Function                                                                                                     | Sup- ported in HIP   | Supported in CUDA   |
-|--------------------------------------------------------------------------------------------------------------|----------------------|---------------------|
-| void load_matrix_sync(fragment<...> &a, const T* mptr, unsigned lda)                                         |                      | ✓                   |
-| void load_matrix_sync(fragment<...> &a, const T* mptr, unsigned lda, layout_t layout)                        |                      | ✓                   |
-| void store_matrix_sync(T* mptr, fragment<...> &a, unsigned lda, layout_t layout)                             |                      | ✓                   |
-| void fill_fragment(fragment<...> &a, const T &value) void mma_sync(fragment<...> &d, const fragment<...> &a, |                      | ✓                   |
-| const fragment<...> &b, const fragment<...> &c , bool sat)                                                   |                      | ✓                   |
-
-## 19.17 Independent thread scheduling
-
-Certain architectures that support CUDA allow threads to progress independently of each other. This independent thread scheduling makes intra-warp synchronization possible.
-
-HIP does not support this type of scheduling.
-
-## 19.18 Profiler Counter Function
-
-The CUDA \_\_prof\_trigger() instruction is not supported.
-
-## 19.19 Assert
-
-The assert function is supported in HIP. Assert function is used for debugging purpose, when the input expression equals to zero, the execution will be stopped.
-**Following code does:** This code snippet appears to be a series of special characters and whitespace, but it does not represent any valid or meaningful Python code. It seems to be a random arrangement of symbols and spaces without any executable purpose or functionality in a programming context.
-
-
-```
-|void assert(int ir
-```
-**Following code does:** The code snippet `<_SQL_>` appears to be a placeholder or a tag indicating that the actual SQL code is not provided. Without the specific SQL code, it's not possible to determine its functionality. Typically, SQL code is used for interacting with databases, such as querying data, updating records, or managing database structures. If you have the actual SQL code, I can help explain its purpose.
-
-
-```
-    input()
-```
-
-There are two kinds of implementations for assert functions depending on the use sceneries, - One is for the host version of assert, which is defined in assert.h , - Another is the device version of assert, which is implemented in hip/hip\_runtime.h . Users need to include assert.h to use assert . For assert to work in both device and host functions, users need to include "hip/hip\_runtime.h" .
-
-HIP provides the function abort() which can be used to terminate the application when terminal failures are detected. It is implemented using the \_\_builtin\_trap() function.
-
-This function produces a similar effect of using asm("trap") in the CUDA code.
-
-Note: In HIP, the function terminates the entire application, while in CUDA, asm("trap") only terminates the dispatch and the application continues to run.
-
-## 19.20 printf
-
-printf function is supported in HIP. The following is a simple example to print information in the kernel.
-**Following code does:** The code snippet you've provided appears to be a command line instruction rather than a typical Python code snippet. It seems to be a command for a build or compilation tool, possibly related to a makefile or a build script. Here's a breakdown of its components:
-
-- `|` and `\` are shell operators. `|` is used for piping the output of one command into another, and `\` is used to escape characters or continue a command on the next line.
-- `roc-obj` could be a reference to a specific object file or a target within a build system.
-- `-t` and `-d` are likely flags or options for the command being executed.
-- `gfx803` might refer to a specific architecture or hardware target, possibly related to AMD's GCN (Graphics Core Next) architecture.
-- `./saxpy` suggests that the command is operating on or with a file or executable named `saxpy` in the current directory.
-
-Overall, this command seems to be part of a build process, possibly compiling or linking code for a specific hardware target.
-
-
-```
-                                                                                                                                                                                                       
-#include <hip/hip_runtime.h>
-
-    __global__ void run_printf() { printf("Hello World\n"); }
-
-    int main() {
-      run_printf<<<dim3(1), dim3(1), 0, 0>>>();
-    }
-```
-
-## 19.21 Device-Side Dynamic Global Memory Allocation
-
-Device-side dynamic global memory allocation is under development. HIP now includes a preliminary implementation of malloc and free that can be called from device functions.
-
-## 19.22 \_\_launch\_bounds\_\_
-
-GPU multiprocessors have a fixed pool of resources (primarily registers and shared memory) which are shared by the actively running warps. Using more resources can increase IPC of the kernel but reduces the resources available for other warps and limits the number of warps that can be simultaneously running. Thus GPUs have a complex relationship between resource usage and performance.
-
-\_\_launch\_bounds\_\_ allows the application to provide usage hints that influence the resources (primarily registers) used by the generated code. It is a function attribute that must be attached to a \_\_global\_\_ function:
-**Following code does:** The code snippet `<_XML_>` appears to be a placeholder or a tag, rather than actual executable Python code. It might be used in a larger context to denote a section where XML data or XML-related processing is expected. Without additional context or surrounding code, it does not perform any specific function or operation by itself.
-
-
-```
-<_Cython_>
-```
-
-\_\_launch\_bounds\_\_ supports two parameters: - MAX\_THREADS\_PER\_BLOCK - The programmers guarantees that kernel will be launched with threads less than MAX\_THREADS\_PER\_BLOCK. (On NVCC this maps to the . maxntid PTX directive). If no launch\_bounds is specified, MAX\_THREADS\_PER\_BLOCK is the maximum block size supported by the device (typically 1024 or larger). Specifying MAX\_THREADS\_PER\_BLOCK less than the maximum effectively allows the compiler to use more resources than a default unconstrained compilation that supports all possible block sizes at launch time. The threads-per-block is the product of ( blockDim.x * blockDim. y * blockDim.z ). - MIN\_WARPS\_PER\_EXECUTION\_UNIT - directs the compiler to minimize resource usage so that the requested number of warps can be simultaneously active on a multi-processor. Since active warps compete for the same fixed pool of resources, the compiler must reduce resources required by each warp(primarily registers). MIN\_WARPS\_PER\_EXECUTION\_UNIT is optional and defaults to 1 if not specified. Specifying a MIN\_WARPS\_PER\_EXECUTION\_UNIT greater than the default 1 effectively constrains the compiler's resource usage.
-
-When launch kernel with HIP APIs, for example, hipModuleLaunchKernel() , HIP will do validation to make sure input kernel dimension size is not larger than specified launch\_bounds. In case exceeded, HIP would return launch failure, if AMD\_LOG\_LEVEL is set with proper value (for details, please refer to docs/markdown/hip\_logging. md ), detail information will be shown in the error log message, including launch parameters of kernel dim size, launch bounds, and the name of the faulting kernel. It's helpful to figure out which is the faulting kernel, besides, the kernel dim size and launch bounds values will also assist in debugging such failures.
-
-## 19.22.1 Compiler Impact
-
-The compiler uses these parameters as follows: - The compiler uses the hints only to manage register usage, and does not automatically reduce shared memory or other resources. - Compilation fails if compiler cannot generate a kernel which meets the requirements of the specified launch bounds. - From MAX\_THREADS\_PER\_BLOCK, the compiler derives the maximum number of warps/block that can be used at launch time. Values of MAX\_THREADS\_PER\_BLOCK less than the default allows the compiler to use a larger pool of registers : each warp uses registers, and this hint constrains the launch to a warps/block size which is less than maximum. - From MIN\_WARPS\_PER\_EXECUTION\_UNIT, the compiler derives a maximum number of registers that can be used by the kernel (to meet the required #simultaneous active blocks). If MIN\_WARPS\_PER\_EXECUTION\_UNIT is 1, then the kernel can use all registers supported by the multiprocessor. - The compiler ensures that the registers used in the kernel is less than both allowed maximums, typically by spilling registers (to shared or global memory), or by using more instructions. - The compiler may use heuristics to increase register usage, or may simply be able to avoid spilling. The MAX\_THREADS\_PER\_BLOCK
-
-is particularly useful in this cases, since it allows the compiler to use more registers and avoid situations where the compiler constrains the register usage (potentially spilling) to meet the requirements of a large block size that is never used at launch time.
-
-## 19.22.2 CU and EU Definitions
-
-A compute unit (CU) is responsible for executing the waves of a work-group. It is composed of one or more execution units (EU) which are responsible for executing waves. An EU can have enough resources to maintain the state of more than one executing wave. This allows an EU to hide latency by switching between waves in a similar way to symmetric multithreading on a CPU. In order to allow the state for multiple waves to fit on an EU, the resources used by a single wave have to be limited. Limiting such resources can allow greater latency hiding, but can result in having to spill some register state to memory. This attribute allows an advanced developer to tune the number of waves that are capable of fitting within the resources of an EU. It can be used to ensure at least a certain number will fit to help hide latency, and can also be used to ensure no more than a certain number will fit to limit cache thrashing.
-
-## 19.22.3 Porting from CUDA \_\_launch\_bounds
-
-CUDA defines a \_\_launch\_bounds which is also designed to control occupancy:
-
-- \_\_launch\_bounds(MAX\_THREADS\_PER\_BLOCK, MIN\_BLOCKS\_PER\_MULTIPROCESSOR)
-- The second parameter \_\_launch\_bounds parameters must be converted to the format used \_\_hip\_launch\_bounds, which uses warps and execution-units rather than blocks and multi-processors (this conversion is performed automatically by HIPIFY tools).
-**Following code does:** This code snippet appears to be a collection of various symbols and characters arranged in a seemingly random manner. It does not form a valid or meaningful Python program. The arrangement of characters does not follow any recognizable syntax or structure that would perform a specific function or task in Python. Therefore, it does not have a high-level purpose or functionality.
-
-
-```
-                                                                                                                                                                                                        | MIN_WARPS_PER_EXECUTION_UNIT  =  (MIN_BLOCKS_PER_MULTIPROCESSOR  *  MAX_THREADS_PER_BLOCK)  /_\                                                                                                                                                                                                       
-                                                                                                                                                                                                        :                                                                                                                                                                                                        --                                                                                                                                                                                                        <                                                                                                                                                                                                        </                                                                                                                                                                                                        >                                                                                                                                                                                                        }
-```
-
-The key differences in the interface are: - Warps (rather than blocks): The developer is trying to tell the compiler to control resource utilization to guarantee some amount of active Warps/EU for latency hiding. Specifying active warps in terms of blocks appears to hide the micro-architectural details of the warp size, but makes the interface more confusing since the developer ultimately needs to compute the number of warps to obtain the desired level of control. - Execution Units (rather than multiprocessor): The use of execution units rather than multiprocessors provides support for architectures with multiple execution units/multi-processor. For example, the AMD GCN architecture has 4 execution units per multiprocessor. The hipDeviceProps has a field executionUnitsPerMultiprocessor . Platform-specific coding techniques such as #ifdef can be used to specify different launch\_bounds for NVCC and HIP-Clang platforms, if desired.
-
-## 19.22.4 maxregcount
-
-Unlike NVCC, HIP-Clang does not support the --maxregcount option. Instead, users are encouraged to use the hip\_launch\_bounds directive since the parameters are more intuitive and portable than micro-architecture details like registers, and also the directive allows per-kernel control rather than an entire file. hip\_launch\_bounds works on both HIP-Clang and NVCC targets.
-
-## 19.23 Asynchronous Functions
-
-## 19.23.1 Memory stream
-
-typedef void (* hipStreamCallback\_t )(hipStream\_t stream, hipError\_t status, void *userData)
-
-Stream CallBack struct hipError\_t hipStreamCreate ( hipStream\_t *stream )
-
-Create an asynchronous stream.
-
-Create a new asynchronous stream. stream returns an opaque handle that can be used to reference the newly created stream in subsequent hipStream* commands. The stream is allocated on the heap and will remain allocated even if the handle goes out-of-scope. To release the memory used by the stream, application must call hipStreamDestroy.
-
-## See also:
-
-hipStreamCreateWithFlags , hipStreamCreateWithPriority , hipStreamSynchronize , hipStreamWaitEvent , hipStreamDestroy
-
-## Parameters
-
-stream -[inout] Valid pointer to hipStream\_t. This function writes the memory with the newly created stream.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipStreamCreateWithFlags ( hipStream\_t *stream, unsigned int flags )
-
-Create an asynchronous stream.
-
-Create a new asynchronous stream. stream returns an opaque handle that can be used to reference the newly created stream in subsequent hipStream* commands. The stream is allocated on the heap and will remain allocated even if the handle goes out-of-scope. To release the memory used by the stream, application must call hipStreamDestroy. Flags controls behavior of the stream. See hipStreamDefault, hipStreamNonBlocking.
-
-## See also:
-
-hipStreamCreate , hipStreamCreateWithPriority , hipStreamSynchronize , hipStreamWaitEvent , hipStreamDestroy
-
-## Parameters
-
-- stream -[inout] Pointer to new stream
-- flags -[in] to control stream creation.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue
-
-hipError\_t hipStreamCreateWithPriority ( hipStream\_t *stream, unsigned int flags, int priority )
-
-Create an asynchronous stream with the specified priority.
-
-Create a new asynchronous stream with the specified priority. stream returns an opaque handle that can be used to reference the newly created stream in subsequent hipStream* commands. The stream is allocated on the heap and will remain allocated even if the handle goes out-of-scope. To release the memory used by the stream, application must call hipStreamDestroy. Flags controls behavior of the stream. See hipStreamDefault, hipStreamNonBlocking.
-
-## See also:
-
-hipStreamCreate , hipStreamSynchronize , hipStreamWaitEvent , hipStreamDestroy
-
-## Parameters
-
-- stream -[inout] Pointer to new stream
-- flags -[in] to control stream creation.
-- priority -[in] of the stream. Lower numbers represent higher priorities.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipDeviceGetStreamPriorityRange ( int *leastPriority, int *greatestPriority )
-
-Returns numerical values that correspond to the least and greatest stream priority.
-
-Returns in *leastPriority and *greatestPriority the numerical values that correspond to the least and greatest stream priority respectively. Stream priorities follow a convention where lower numbers imply greater priorities. The range of meaningful stream priorities is given by [*greatestPriority, *leastPriority]. If the user attempts to create a stream with a priority value that is outside the meaningful range as specified by this API, the priority is automatically clamped to within the valid range.
-
-## Parameters
-
-- leastPriority -[inout] pointer in which value corresponding to least priority is returned.
-- greatestPriority -[inout] pointer in which value corresponding to greatest priority is returned.
-
-## Returns
-
-hipSuccess hipError\_t hipStreamDestroy ( hipStream\_t stream )
-
-Destroys the specified stream.
-
-Destroys the specified stream.
-
-If commands are still executing on the specified stream, some may complete execution before the queue is deleted.
-
-The queue may be destroyed while some commands are still inflight, or may wait for all commands queued to the stream before destroying it.
-
-## See also:
-
-hipStreamCreate , hipStreamCreateWithFlags , hipStreamCreateWithPriority , hipStreamQuery , hipStreamWaitEvent , hipStreamSynchronize
-
-## Parameters
-
-stream -[in] stream identifier.
-
-## Returns
-
-hipSuccess hipErrorInvalidHandle
-
-## hipError\_t hipStreamQuery ( hipStream\_t stream )
-
-Return hipSuccess if all of the operations in the specified stream have completed, or hipErrorNotReady if not.
-
-This is thread-safe and returns a snapshot of the current state of the queue. However, if other host threads are sending work to the stream, the status may change immediately after the function is called. It is typically used for debug.
-
-## See also:
-
-hipStreamCreate , hipStreamCreateWithFlags , hipStreamCreateWithPriority , hipStreamWaitEvent , hipStreamSynchronize , hipStreamDestroy
-
-## Parameters
-
-stream -[in] stream to query
-
-## Returns
-
-hipSuccess, hipErrorNotReady, hipErrorInvalidHandle
-
-## hipError\_t hipStreamSynchronize ( hipStream\_t stream )
-
-Wait for all commands in stream to complete.
-
-This command is host-synchronous : the host will block until the specified stream is empty.
-
-This command follows standard null-stream semantics. Specifically, specifying the null stream will cause the command to wait for other streams on the same device to complete all pending operations.
-
-This command honors the hipDeviceLaunchBlocking flag, which controls whether the wait is active or blocking.
-
-## See also:
-
-hipStreamCreate , hipStreamCreateWithFlags , hipStreamCreateWithPriority , hipStreamWaitEvent , hipStreamDestroy
-
-## Parameters
-
-stream -[in] stream identifier.
-
-## Returns
-
-hipSuccess, hipErrorInvalidHandle
-
-hipError\_t hipStreamWaitEvent ( hipStream\_t stream, hipEvent\_t event, unsigned int flags )
-
-Make the specified compute stream wait for an event.
-
-This function inserts a wait operation into the specified stream. All future work submitted to stream will wait until event reports completion before beginning execution.
-
-This function only waits for commands in the current stream to complete. Notably, this function does not implicitly wait for commands in the default stream to complete, even if the specified stream is created with hipStreamNonBlocking = 0.
-
-## See also:
-
-hipStreamCreate , hipStreamCreateWithFlags , hipStreamCreateWithPriority , hipStreamSynchronize , hipStreamDestroy
-
-## Parameters
-
-- stream -[in] stream to make wait.
-- event -[in] event to wait on
-- flags -[in] control operation [must be 0]
-
-## Returns
-
-hipSuccess, hipErrorInvalidHandle hipError\_t hipStreamGetFlags ( hipStream\_t stream, unsigned int *flags )
-
-Return flags associated with this stream.
-
-Return flags associated with this stream in * flags .
-
-## See also:
-
-hipStreamCreateWithFlags
-
-## Parameters
-
-- stream -[in] stream to be queried
-- flags -[inout] Pointer to an unsigned integer in which the stream's flags are returned
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidHandle
-
-## Returns
-
-hipSuccess hipErrorInvalidValue hipErrorInvalidHandle hipError\_t hipStreamGetPriority ( hipStream\_t stream, int *priority )
-
-Query the priority of a stream.
-
-Query the priority of a stream. The priority is returned in in priority.
-
-## See also:
-
-hipStreamCreateWithFlags
-
-## Parameters
-
-- stream -[in] stream to be queried
-- priority -[inout] Pointer to an unsigned integer in which the stream's priority is returned
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidHandle
-
-## Returns
-
-hipSuccess hipErrorInvalidValue hipErrorInvalidHandle hipError\_t hipStreamGetDevice ( hipStream\_t stream, hipDevice\_t *device )
-
-Get the device assocaited with the stream.
-
-## See also:
-
-hipStreamCreate , hipStreamDestroy , hipDeviceGetStreamPriorityRange
-
-## Parameters
-
-- stream -[in] stream to be queried
-- device -[out] device associated with the stream
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorContextIsDestroyed, hipErrorInvalidHandle, hipErrorNotInitialized, hipErrorDeinitialized, hipErrorInvalidContext hipError\_t hipExtStreamCreateWithCUMask ( hipStream\_t *stream, uint32\_t cuMaskSize, const uint32\_t *cuMask )
-
-Create an asynchronous stream with the specified CU mask.
-
-Create a new asynchronous stream with the specified CU mask. stream returns an opaque handle that can be used to reference the newly created stream in subsequent hipStream* commands. The stream is allocated on the heap and will remain allocated even if the handle goes out-of-scope. To release the memory used by the stream, application must call hipStreamDestroy.
-
-## See also:
-
-hipStreamCreate , hipStreamSynchronize , hipStreamWaitEvent , hipStreamDestroy
-
-## Parameters
-
-- stream -[inout] Pointer to new stream
-- cuMaskSize -[in] Size of CU mask bit array passed in.
-- cuMask -[in] Bit-vector representing the CU mask. Each active bit represents using one CU. The first 32 bits represent the first 32 CUs, and so on. If its size is greater than physical CU number (i.e., multiProcessorCount member of hipDeviceProp\_t), the extra elements are ignored. It is user's responsibility to make sure the input is meaningful.
-
-## Returns
-
-hipSuccess, hipErrorInvalidHandle, hipErrorInvalidValue hipError\_t hipExtStreamGetCUMask ( hipStream\_t stream, uint32\_t cuMaskSize, uint32\_t *cuMask )
-
-Get CU mask associated with an asynchronous stream.
-
-## See also:
-
-hipStreamCreate , hipStreamSynchronize , hipStreamWaitEvent , hipStreamDestroy
-
-## Parameters
-
-- stream -[in] stream to be queried
-- cuMaskSize -[in] number of the block of memories (uint32\_t *) allocated by user
-- cuMask -[out] Pointer to a pre-allocated block of memories (uint32\_t *) in which the stream's CU mask is returned. The CU mask is returned in a chunck of 32 bits where each active bit represents one active CU
-
-## Returns
-
-hipSuccess, hipErrorInvalidHandle, hipErrorInvalidValue hipError\_t hipStreamAddCallback ( hipStream\_t stream, hipStreamCallback\_t callback, void *userData, unsigned int flags )
-
-Adds a callback to be called on the host after all currently enqueued items in the stream have completed. For each hipStreamAddCallback call, a callback will be executed exactly once. The callback will block later work in the stream until it is finished.
-
-## See also:
-
-hipStreamCreate , hipStreamCreateWithFlags , hipStreamQuery , hipStreamSynchronize , hipStreamWaitEvent , hipStreamDestroy , hipStreamCreateWithPriority
-
-## Parameters
-
-- stream -[in] - Stream to add callback to
-- callback -[in] - The function to call once preceding stream operations are complete
-- userData -[in] - User specified data to be passed to the callback function
-- flags -[in] - Reserved for future use, must be 0
-
-## Returns
-
-hipSuccess, hipErrorInvalidHandle, hipErrorNotSupported static inline hipError\_t hipMallocAsync ( void **dev\_ptr, size\_t size, hipMemPool\_t mem\_pool, hipStream\_t stream )
-
-C++ wrappers for allocations from a memory pool.
-
-This section describes wrappers for stream Ordered allocation from memory pool functions of HIP runtime API.
-
-This is an alternate C++ calls for hipMallocFromPoolAsync made available through function overloading.
-
-## See also:
-
-hipMallocFromPoolAsync
-
-Note: APIs in this section are implemented on Linux, under development on Windows.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-## template&lt;class T &gt;
-
-static inline hipError\_t hipMallocAsync ( T **dev\_ptr, size\_t size, hipMemPool\_t mem\_pool, hipStream\_t stream C++ wrappers for allocations from a memory pool on the stream.
-
-This is an alternate C++ calls for hipMallocFromPoolAsync made available through function overloading.
-
-## See also:
-
-hipMallocFromPoolAsync
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-## template&lt;class T &gt;
-
-static inline hipError\_t hipMallocAsync ( T **dev\_ptr, size\_t size, hipStream\_t stream )
-
-C++ wrappers for allocations from a memory pool.
-
-This is an alternate C++ calls for hipMallocFromPoolAsync made available through function overloading.
-
-## See also:
-
-hipMallocFromPoolAsync
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-## template&lt;class T &gt;
-
-static inline hipError\_t hipMallocFromPoolAsync ( T **dev\_ptr, size\_t size, hipMemPool\_t mem\_pool, hipStream\_t stream )
-
-C++ wrappers for allocations from a memory pool.
-
-This is an alternate C++ calls for hipMallocFromPoolAsync made available through function overloading.
-
-## See also:
-
-hipMallocFromPoolAsync
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-)
-
-hipError\_t hipMallocAsync ( void **dev\_ptr, size\_t size, hipStream\_t stream )
-
-Allocates memory with stream ordered semantics.
-
-Inserts a memory allocation operation into stream . A pointer to the allocated memory is returned immediately in *dptr. The allocation must not be accessed until the allocation operation completes. The allocation comes from the memory pool associated with the stream's device.
-
-## See also:
-
-hipMallocFromPoolAsync , hipFreeAsync , hipMemPoolTrimTo , hipMemPoolGetAttribute , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess , hipMemPoolGetAccess
-
-Note: The default memory pool of a device contains device memory from that device.
-
-Note: Basic stream ordering allows future work submitted into the same stream to use the allocation. Stream query, stream synchronize, and HIP events can be used to guarantee that the allocation operation completes before work submitted in a separate stream runs.
-
-Note: During stream capture, this function results in the creation of an allocation node. In this case, the allocation is owned by the graph instead of the memory pool. The memory pool's properties are used to set the node's creation parameters.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- dev\_ptr -[out] Returned device pointer of memory allocation
-- size -[in] Number of bytes to allocate
-- stream -[in] The stream establishing the stream ordering contract and the memory pool to allocate from
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported, hipErrorOutOfMemory hipError\_t hipFreeAsync ( void *dev\_ptr, hipStream\_t stream )
-
-Frees memory with stream ordered semantics.
-
-Inserts a free operation into stream . The allocation must not be used after stream execution reaches the free. After this API returns, accessing the memory from any subsequent work launched on the GPU or querying its pointer attributes results in undefined behavior.
-
-## See also:
-
-hipMallocFromPoolAsync , hipMallocAsync , hipMemPoolTrimTo , hipMemPoolGetAttribute , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess , hipMemPoolGetAccess
-
-Note: During stream capture, this function results in the creation of a free node and must therefore be passed the address of a graph allocation.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- dev\_ptr -[in] Pointer to device memory to free
-- stream -[in] The stream, where the destruciton will occur according to the execution order
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemPoolTrimTo ( hipMemPool\_t mem\_pool, size\_t min\_bytes\_to\_hold )
-
-Releases freed memory back to the OS.
-
-Releases memory back to the OS until the pool contains fewer than min\_bytes\_to\_keep reserved bytes, or there is no more memory that the allocator can safely release. The allocator cannot release OS allocations that back outstanding asynchronous allocations. The OS allocations may happen at different granularity from the user allocations.
-
-## See also:
-
-hipMallocFromPoolAsync , hipMallocAsync , hipFreeAsync , hipMemPoolGetAttribute , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess , hipMemPoolGetAccess
-
-Note: Allocations that have not been freed count as outstanding.
-
-Note: Allocations that have been asynchronously freed but whose completion has not been observed on the host (eg. by a synchronize) can count as outstanding.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- mem\_pool -[in] The memory pool to trim allocations
-- min\_bytes\_to\_hold -[in] If the pool has less than min\_bytes\_to\_hold reserved, then the TrimTo operation is a no-op. Otherwise the memory pool will contain at least min\_bytes\_to\_hold bytes reserved after the operation.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemPoolSetAttribute ( hipMemPool\_t mem\_pool, hipMemPoolAttr attr, void *value )
-
-Sets attributes of a memory pool.
-
-Supported attributes are:
-
-- hipMemPoolAttrReleaseThreshold: (value type = cuuint64\_t) Amount of reserved memory in bytes to hold onto before trying to release memory back to the OS. When more than the release threshold bytes of memory are held by the memory pool, the allocator will try to release memory back to the OS on the next call to stream, event or context synchronize. (default 0)
-- hipMemPoolReuseFollowEventDependencies: (value type = int) Allow hipMallocAsync to use memory asynchronously freed in another stream as long as a stream ordering dependency of the allocating stream on the free action exists. HIP events and null stream interactions can create the required stream ordered dependencies. (default enabled)
-- hipMemPoolReuseAllowOpportunistic: (value type = int) Allow reuse of already completed frees when there is no dependency between the free and allocation. (default enabled)
-- hipMemPoolReuseAllowInternalDependencies: (value type = int) Allow hipMallocAsync to insert new stream dependencies in order to establish the stream ordering required to reuse a piece of memory released by hipFreeAsync (default enabled).
-
-## See also:
-
-hipMallocFromPoolAsync , hipMallocAsync , hipFreeAsync , hipMemPoolGetAttribute , hipMemPoolTrimTo , hipDeviceSetMemPool, hipMemPoolSetAccess , hipMemPoolGetAccess
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- mem\_pool -[in] The memory pool to modify
-- attr -[in] The attribute to modify
-- value -[in] Pointer to the value to assign
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue
-
-hipError\_t hipMemPoolGetAttribute ( hipMemPool\_t mem\_pool, hipMemPoolAttr attr, void *value )
-
-Gets attributes of a memory pool.
-
-Supported attributes are:
-
-- hipMemPoolAttrReleaseThreshold: (value type = cuuint64\_t) Amount of reserved memory in bytes to hold onto before trying to release memory back to the OS. When more than the release threshold bytes of memory are held by the memory pool, the allocator will try to release memory back to the OS on the next call to stream, event or context synchronize. (default 0)
-- hipMemPoolReuseFollowEventDependencies: (value type = int) Allow hipMallocAsync to use memory asynchronously freed in another stream as long as a stream ordering dependency of the allocating stream on the free action exists. HIP events and null stream interactions can create the required stream ordered dependencies. (default enabled)
-- hipMemPoolReuseAllowOpportunistic: (value type = int) Allow reuse of already completed frees when there is no dependency between the free and allocation. (default enabled)
-- hipMemPoolReuseAllowInternalDependencies: (value type = int) Allow hipMallocAsync to insert new stream dependencies in order to establish the stream ordering required to reuse a piece of memory released by hipFreeAsync (default enabled).
-
-## See also:
-
-hipMallocFromPoolAsync , hipMallocAsync , hipFreeAsync , hipMemPoolTrimTo , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess , hipMemPoolGetAccess
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- mem\_pool -[in] The memory pool to get attributes of
-- attr -[in] The attribute to get
-- value -[in] Retrieved value
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemPoolSetAccess ( hipMemPool\_t mem\_pool, const hipMemAccessDesc *desc\_list, size\_t count ) Controls visibility of the specified pool between devices.
-
-## See also:
-
-hipMallocFromPoolAsync , hipMallocAsync , hipFreeAsync , hipMemPoolGetAttribute , hipMemPoolTrimTo , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolGetAccess
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- mem\_pool -[in] Memory pool for acccess change
-- desc\_list -[in] Array of access descriptors. Each descriptor instructs the access to enable for a single gpu
-- count -[in] Number of descriptors in the map array.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemPoolGetAccess ( hipMemAccessFlags *flags, hipMemPool\_t mem\_pool, hipMemLocation *location )
-
-Returns the accessibility of a pool from a device.
-
-Returns the accessibility of the pool's memory from the specified location.
-
-## See also:
-
-hipMallocFromPoolAsync , hipMallocAsync , hipFreeAsync , hipMemPoolGetAttribute , hipMemPoolTrimTo , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- flags -[out] Accessibility of the memory pool from the specified location/device
-- mem\_pool -[in] Memory pool being queried
-- location -[in] Location/device for memory pool access
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemPoolCreate ( hipMemPool\_t *mem\_pool, const hipMemPoolProps *pool\_props )
-
-Creates a memory pool.
-
-Creates a HIP memory pool and returns the handle in mem\_pool . The pool\_props determines the properties of the pool such as the backing device and IPC capabilities.
-
-By default, the memory pool will be accessible from the device it is allocated on.
-
-## See also:
-
-hipMallocFromPoolAsync , hipMallocAsync , hipFreeAsync , hipMemPoolGetAttribute , hipMemPoolDestroy , hipMemPoolTrimTo , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess , hipMemPoolGetAccess
-
-Note: Specifying hipMemHandleTypeNone creates a memory pool that will not support IPC.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- mem\_pool -[out] Contains createed memory pool
-- pool\_props -[in] Memory pool properties
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemPoolDestroy ( hipMemPool\_t mem\_pool )
-
-Destroys the specified memory pool.
-
-If any pointers obtained from this pool haven't been freed or the pool has free operations that haven't completed when hipMemPoolDestroy is invoked, the function will return immediately and the resources associated with the pool will be released automatically once there are no more outstanding allocations.
-
-Destroying the current mempool of a device sets the default mempool of that device as the current mempool for that device.
-
-## See also:
-
-hipMallocFromPoolAsync , hipMallocAsync , hipFreeAsync , hipMemPoolGetAttribute , hipMemPoolCreate hipMemPoolTrimTo , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess , hipMemPoolGetAccess
-
-Note: A device's default memory pool cannot be destroyed.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-mem\_pool -[in] Memory pool for destruction
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t void **dev\_ptr, size\_t size, hipMemPool\_t mem\_pool, hipStream\_t stream
-
-hipMallocFromPoolAsync ( ) Allocates memory from a specified pool with stream ordered semantics.
-
-Inserts an allocation operation into stream . A pointer to the allocated memory is returned immediately in dev\_ptr . The allocation must not be accessed until the allocation operation completes. The allocation comes from the specified memory pool.
-
-Basic stream ordering allows future work submitted into the same stream to use the allocation. Stream query, stream synchronize, and HIP events can be used to guarantee that the allocation operation completes before work submitted in a separate stream runs.
-
-## See also:
-
-hipMallocAsync , hipFreeAsync , hipMemPoolGetAttribute , hipMemPoolCreate hipMemPoolTrimTo , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess , hipMemPoolGetAccess ,
-
-Note: The specified memory pool may be from a device different than that of the specified stream .
-
-Note: During stream capture, this function results in the creation of an allocation node. In this case, the allocation is owned by the graph instead of the memory pool. The memory pool's properties are used to set the node's creation parameters.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- dev\_ptr -[out] Returned device pointer
-- size -[in] Number of bytes to allocate
-- mem\_pool -[in] The pool to allocate from
-- stream -[in] The stream establishing the stream ordering semantic
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported, hipErrorOutOfMemory hipError\_t hipMemPoolExportToShareableHandle ( void *shared\_handle, hipMemPool\_t mem\_pool, hipMemAllocationHandleType handle\_type, unsigned int flags )
-
-Exports a memory pool to the requested handle type.
-
-Given an IPC capable mempool, create an OS handle to share the pool with another process. A recipient process can convert the shareable handle into a mempool with hipMemPoolImportFromShareableHandle . Individual pointers can then be shared with the hipMemPoolExportPointer and hipMemPoolImportPointer APIs. The implementation of what the shareable handle is and how it can be transferred is defined by the requested handle type.
-
-## See also:
-
-hipMemPoolImportFromShareableHandle
-
-Note: To create an IPC capable mempool, create a mempool with a hipMemAllocationHandleType other than hipMemHandleTypeNone .
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- shared\_handle -[out] Pointer to the location in which to store the requested handle
-- mem\_pool -[in] Pool to export
-- handle\_type -[in] The type of handle to create
-- flags -[in] Must be 0
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorOutOfMemory hipError\_t hipMemPoolImportFromShareableHandle ( hipMemPool\_t *mem\_pool, void *shared\_handle, hipMemAllocationHandleType handle\_type, unsigned int flags )
-
-Imports a memory pool from a shared handle.
-
-Specific allocations can be imported from the imported pool with hipMemPoolImportPointer .
-
-## See also:
-
-hipMemPoolExportToShareableHandle
-
-Note: Imported memory pools do not support creating new allocations. As such imported memory pools may not be used in hipDeviceSetMemPool or hipMallocFromPoolAsync calls.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- mem\_pool -[out] Returned memory pool
-- shared\_handle -[in] OS handle of the pool to open
-- handle\_type -[in] The type of handle being imported
-- flags -[in] Must be 0
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorOutOfMemory hipError\_t hipMemPoolExportPointer ( hipMemPoolPtrExportData *export\_data, void *dev\_ptr )
-
-Export data to share a memory pool allocation between processes.
-
-Constructs export\_data for sharing a specific allocation from an already shared memory pool. The recipient process can import the allocation with the hipMemPoolImportPointer api. The data is not a handle and may be shared through any IPC mechanism.
-
-## See also:
-
-hipMemPoolImportPointer
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- export\_data -[out] Returned export data
-- dev\_ptr -[in] Pointer to memory being exported
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorOutOfMemory hipError\_t hipMemPoolImportPointer ( void **dev\_ptr, hipMemPool\_t mem\_pool, hipMemPoolPtrExportData *export\_data )
-
-Import a memory pool allocation from another process.
-
-Returns in dev\_ptr a pointer to the imported memory. The imported memory must not be accessed before the allocation operation completes in the exporting process. The imported memory must be freed from all importing processes before being freed in the exporting process. The pointer may be freed with hipFree or hipFreeAsync . If hipFreeAsync is used, the free must be completed on the importing process before the free operation on the exporting process.
-
-## See also:
-
-hipMemPoolExportPointer
-
-Note: The hipFreeAsync api may be used in the exporting process before the hipFreeAsync operation completes in its stream as long as the hipFreeAsync in the exporting process specifies a stream with a stream dependency on the importing process's hipFreeAsync .
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- dev\_ptr -[out] Pointer to imported memory
-- mem\_pool -[in] Memory pool from which to import a pointer
-- export\_data -[in] Data specifying the memory to import
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized, hipErrorOutOfMemory
-
-## 19.23.2 Peer to peer
-
-hipError\_t hipDeviceCanAccessPeer ( int *canAccessPeer, int deviceId, int peerDeviceId )
-
-Determine if a device can access a peer's memory.
-
-Returns '1' in canAccessPeer if the specified device is capable of directly accessing memory physically located on peerDevice , or '0' if not.
-
-Returns '0' in canAccessPeer if deviceId == peerDeviceId, and both are valid devices : a device is not a peer of itself.
-
-## Parameters
-
-- canAccessPeer -[out] Returns the peer access capability (0 or 1)
-- deviceId -[in] - device from where memory may be accessed.
-- peerDeviceId -[in] - device where memory is physically located
-
-## Returns
-
-hipSuccess,
-
-## Returns
-
-hipErrorInvalidDevice if deviceId or peerDeviceId are not valid devices hipError\_t hipDeviceEnablePeerAccess ( int peerDeviceId, unsigned int flags )
-
-Enable direct access from current device's virtual address space to memory allocations physically located on a peer device.
-
-Memory which already allocated on peer device will be mapped into the address space of the current device. In addition, all future memory allocations on peerDeviceId will be mapped into the address space of the current device when the memory is allocated. The peer memory remains accessible from the current device until a call to hipDeviceDisablePeerAccess or hipDeviceReset.
-
-Returns hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue,
-
-## Parameters
-
-- peerDeviceId -[in] Peer device to enable direct access to from the current device
-- flags -[in] Reserved for future use, must be zero
-
-## Returns
-
-hipErrorPeerAccessAlreadyEnabled if peer access is already enabled for this device.
-
-## hipError\_t hipDeviceDisablePeerAccess ( int peerDeviceId )
-
-Disable direct access from current device's virtual address space to memory allocations physically located on a peer device.
-
-Returns hipErrorPeerAccessNotEnabled if direct access to memory on peerDevice has not yet been enabled from the current device.
-
-## Parameters
-
-peerDeviceId -[in] Peer device to disable direct access to
-
-## Returns
-
-hipSuccess, hipErrorPeerAccessNotEnabled hipError\_t hipMemGetAddressRange ( hipDeviceptr\_t *pbase, size\_t *psize, hipDeviceptr\_t dptr )
-
-Get information on memory allocations.
-
-## See also:
-
-hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent, hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice
-
-## Parameters
-
-- pbase -[out] - BAse pointer address
-- psize -[out] - Size of allocation
-- dptr--[in] Device Pointer
-
-## Returns
-
-hipSuccess, hipErrorNotFound
-
-## USE\_PEER\_NON\_UNIFIED
-
-## 19.23.3 Memory management
-
-hipError\_t hipPointerSetAttribute ( const void *value, hipPointer\_attribute attribute, hipDeviceptr\_t ptr )
-
-Sets information on the specified pointer.[BETA].
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- value -[in] Sets pointer attribute value
-- attribute -[in] Attribute to set
-- ptr -[in] Pointer to set attributes for
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError\_t hipPointerGetAttributes ( hipPointerAttribute\_t *attributes, const void *ptr )
-
-Returns attributes for the specified pointer.
-
-The output parameter 'attributes' has a member named 'type' that describes what memory the pointer is associated with, such as device memory, host memory, managed memory, and others. Otherwise, the API cannot handle the pointer and returns hipErrorInvalidValue.
-
-## See also:
-
-hipPointerGetAttribute
-
-Note: The unrecognized memory type is unsupported to keep the HIP functionality backward compatibility due to hipMemoryType enum values.
-
-Note: The current behavior of this HIP API corresponds to the CUDA API before version 11.0.
-
-## Parameters
-
-- attributes -[out] attributes for the specified pointer
-- ptr -[in] pointer to get attributes for
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError\_t hipPointerGetAttribute ( void *data, hipPointer\_attribute attribute, hipDeviceptr\_t ptr ) Returns information about the specified pointer.[BETA].
-
-## See also:
-
-hipPointerGetAttributes
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- data -[inout] Returned pointer attribute value
-- attribute -[in] Attribute to query for
-- ptr -[in] Pointer to get attributes for
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError\_t hipDrvPointerGetAttributes ( unsigned int numAttributes, hipPointer\_attribute *attributes, void **data, hipDeviceptr\_t ptr )
-
-Returns information about the specified pointer.[BETA].
-
-## See also:
-
-hipPointerGetAttribute
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- numAttributes -[in] number of attributes to query for
-- attributes -[in] attributes to query for
-- data -[inout] a two-dimensional containing pointers to memory locations where the result of each attribute query will be written to
-- ptr -[in] pointer to get attributes for
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError\_t hipMalloc ( void **ptr, size\_t size )
-
-Allocate memory on the default accelerator.
-
-If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.
-
-## See also:
-
-hipMallocPitch , hipFree , hipMallocArray , hipFreeArray , hipMalloc3D , hipMalloc3DArray , hipHostFree , hipHostMalloc
-
-## Parameters
-
-- ptr -[out] Pointer to the allocated memory
-- size -[in] Requested memory size
-
-## Returns
-
-hipSuccess, hipErrorOutOfMemory, hipErrorInvalidValue (bad context, null *ptr)
-
-hipError\_t hipExtMallocWithFlags ( void **ptr, size\_t sizeBytes, unsigned int flags )
-
-Allocate memory on the default accelerator.
-
-If requested memory size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.
-
-The memory allocation flag should be either hipDeviceMallocDefault, hipDeviceMallocFinegrained, hipDeviceMallocUncached, or hipMallocSignalMemory. If the flag is any other value, the API returns hipErrorInvalidValue.
-
-## See also:
-
-hipMallocPitch , hipFree , hipMallocArray , hipFreeArray , hipMalloc3D , hipMalloc3DArray , hipHostFree , hipHostMalloc
-
-## Parameters
-
-- ptr -[out] Pointer to the allocated memory
-- sizeBytes -[in] Requested memory size
-- flags -[in] Type of memory allocation
-
-## Returns
-
-hipSuccess, hipErrorOutOfMemory, hipErrorInvalidValue (bad context, null *ptr)
-
-hipError\_t hipMallocHost ( void **ptr, size\_t size )
-
-Allocate pinned host memory [Deprecated].
-
-If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.
-
-Warning:
-**Following code does:** The code snippet is a shell command that lists files in the current directory with names starting with "main-hip-amdgcn-amd-amdhsa-" and ending with any extension. The output shows a list of files that match this pattern, indicating that these files are likely related to a project or build process involving AMD GPU architecture (specifically the GFX803 series) and the HIP (Heterogeneous-Compute Interface for Portability) platform. The files have various extensions, suggesting they are different types of build artifacts, such as bytecode (.bc), object files (.o), assembly (.s), and output files (.out).
-
-
-```
-
-
-arning:   This API is deprecated, use hipHostMalloc() instead
-```
-
-## Parameters
-
-- ptr -[out] Pointer to the allocated host pinned memory
-- size -[in] Requested memory size
-
-## Returns
-
-hipSuccess, hipErrorOutOfMemory
-
-## hipError\_t hipMemAllocHost ( void **ptr, size\_t size )
-
-Allocate pinned host memory [Deprecated].
-
-If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.
-
-Warning: This API is deprecated, use hipHostMalloc() instead
-
-## Parameters
-
-- ptr -[out] Pointer to the allocated host pinned memory
-- size -[in] Requested memory size
-
-## Returns
-
-hipSuccess, hipErrorOutOfMemory hipError\_t hipHostMalloc ( void **ptr, size\_t size, unsigned int flags )
-
-Allocates device accessible page locked (pinned) host memory.
-
-This API allocates pinned host memory which is mapped into the address space of all GPUs in the system, the memory can be accessed directly by the GPU device, and can be read or written with much higher bandwidth than pageable memory obtained with functions such as malloc().
-
-Using the pinned host memory, applications can implement faster data transfers for HostToDevice and DeviceToHost. The runtime tracks the hipHostMalloc allocations and can avoid some of the setup required for regular unpinned memory.
-
-When the memory accesses are infrequent, zero-copy memory can be a good choice, for coherent allocation. GPU can directly access the host memory over the CPU/GPU interconnect, without need to copy the data.
-
-Currently the allocation granularity is 4KB for the API.
-
-Developers need to choose proper allocation flag with consideration of synchronization.
-
-If no input for flags, it will be the default pinned memory allocation on the host.
-
-## See also:
-
-hipSetDeviceFlags, hipHostFree
-
-## Parameters
-
-- ptr -[out] Pointer to the allocated host pinned memory
-- size -[in] Requested memory size in bytes If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.
-- flags -[in] Type of host memory allocation. See the description of flags in hipSetDeviceFlags.
-
-## Returns
-
-hipSuccess, hipErrorOutOfMemory hipError\_t hipHostAlloc ( void **ptr, size\_t size, unsigned int flags )
-
-Allocate device accessible page locked host memory [Deprecated].
-
-If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.
-
-Warning: This API is deprecated, use hipHostMalloc() instead
-
-## Parameters
-
-- ptr -[out] Pointer to the allocated host pinned memory
-
-- size -[in] Requested memory size in bytes
-- flags -[in] Type of host memory allocation
-
-## Returns
-
-hipSuccess, hipErrorOutOfMemory hipError\_t hipHostGetDevicePointer ( void **devPtr, void *hstPtr, unsigned int flags )
-
-Get Device pointer from Host Pointer allocated through hipHostMalloc.
-
-## See also:
-
-hipSetDeviceFlags, hipHostMalloc
-
-## Parameters
-
-- devPtr -[out] Device Pointer mapped to passed host pointer
-- hstPtr -[in] Host Pointer allocated through hipHostMalloc
-- flags -[in] Flags to be passed for extension
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorOutOfMemory hipError\_t hipHostGetFlags ( unsigned int *flagsPtr, void *hostPtr )
-
-Return flags associated with host pointer.
-
-## See also:
-
-## hipHostMalloc
-
-## Parameters
-
-- flagsPtr -[out] Memory location to store flags
-- hostPtr -[in] Host Pointer allocated through hipHostMalloc
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipHostRegister ( void *hostPtr, size\_t sizeBytes, unsigned int flags )
-
-Register host memory so it can be accessed from the current device.
-
-## Flags:
-
-- hipHostRegisterDefault Memory is Mapped and Portable
-- hipHostRegisterPortable Memory is considered registered by all contexts. HIP only supports one context so this is always assumed true.
-- hipHostRegisterMapped Map the allocation into the address space for the current device. The device pointer can be obtained with hipHostGetDevicePointer .
-
-After registering the memory, use hipHostGetDevicePointer to obtain the mapped device pointer. On many systems, the mapped device pointer will have a different value than the mapped host pointer. Applications must use the device pointer in device code, and the host pointer in host code.
-
-On some systems, registered memory is pinned. On some systems, registered memory may not be actually be pinned but uses OS or hardware facilities to all GPU access to the host memory.
-
-Developers are strongly encouraged to register memory blocks which are aligned to the host cache-line size. (typically 64-bytes but can be obtains from the CPUID instruction).
-
-If registering non-aligned pointers, the application must take care when register pointers from the same cache line on different devices. HIP's coarse-grained synchronization model does not guarantee correct results if different devices write to different parts of the same cache block - typically one of the writes will 'win' and overwrite data from the other registered memory region.
-
-## See also:
-
-hipHostUnregister , hipHostGetFlags , hipHostGetDevicePointer
-
-## Parameters
-
-- hostPtr -[out] Pointer to host memory to be registered.
-- sizeBytes -[in] Size of the host memory
-- flags -[in] See below.
-
-## Returns
-
-hipSuccess, hipErrorOutOfMemory hipError\_t hipHostUnregister ( void *hostPtr )
-
-Un-register host pointer.
-
-## See also:
-
-hipHostRegister
-
-## Parameters
-
-hostPtr -[in] Host pointer previously registered with hipHostRegister
-
-## Returns
-
-Error code hipError\_t hipMallocPitch ( void **ptr, size\_t *pitch, size\_t width, size\_t height )
-
-Allocates at least width (in bytes) * height bytes of linear memory Padding may occur to ensure alighnment requirements are met for the given row The change in width size due to padding will be returned in *pitch. Currently the alignment is set to 128 bytes
-
-If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.
-
-## See also:
-
-hipMalloc , hipFree , hipMallocArray , hipFreeArray , hipHostFree , hipMalloc3D , hipMalloc3DArray , hipHostMalloc
-
-## Parameters
-
-- ptr -[out] Pointer to the allocated device memory
-
-- pitch -[out] Pitch for allocation (in bytes)
-- width -[in] Requested pitched allocation width (in bytes)
-- height -[in] Requested pitched allocation height
-
-## Returns
-
-Error code hipError\_t hipMemAllocPitch ( hipDeviceptr\_t *dptr, size\_t *pitch, size\_t widthInBytes, size\_t height, unsigned int elementSizeBytes )
-
-Allocates at least width (in bytes) * height bytes of linear memory Padding may occur to ensure alighnment requirements are met for the given row The change in width size due to padding will be returned in *pitch. Currently the alignment is set to 128 bytes
-
-If size is 0, no memory is allocated, ptr returns nullptr, and hipSuccess is returned. The intended usage of pitch is as a separate parameter of the allocation, used to compute addresses within the 2D array. Given the row and column of an array element of type T, the address is computed as: T pElement = (T*)((char*)BaseAddress + Row * Pitch) + Column;
-
-## See also:
-
-hipMalloc , hipFree , hipMallocArray , hipFreeArray , hipHostFree , hipMalloc3D , hipMalloc3DArray , hipHostMalloc
-
-## Parameters
-
-- dptr -[out] Pointer to the allocated device memory
-- pitch -[out] Pitch for allocation (in bytes)
-- widthInBytes -[in] Requested pitched allocation width (in bytes)
-- height -[in] Requested pitched allocation height
-- elementSizeBytes -[in] The size of element bytes, should be 4, 8 or 16
-
-## Returns
-
-Error code
-
-## hipError\_t hipFree ( void *ptr )
-
-Free memory allocated by the hcc hip memory allocation API. This API performs an implicit hipDeviceSynchronize() call. If pointer is NULL, the hip runtime is initialized and hipSuccess is returned.
-
-## See also:
-
-hipMalloc , hipMallocPitch , hipMallocArray , hipFreeArray , hipHostFree , hipMalloc3D , hipMalloc3DArray , hipHostMalloc
-
-## Parameters
-
-ptr -[in] Pointer to memory to be freed
-
-## Returns
-
-hipSuccess
-
-## Returns
-
-hipErrorInvalidDevicePointer (if pointer is invalid, including host pointers allocated with hipHostMalloc)
-
-## hipError\_t hipFreeHost ( void *ptr )
-
-Free memory allocated by the hcc hip host memory allocation API [Deprecated].
-
-Warning:
-**Following code does:** The code snippet appears to be a command intended to be run in a terminal or command line interface, rather than a Python script. The command `cuobjdump --list-ptx ./saxpy` is used to extract and list the PTX (Parallel Thread Execution) code from a compiled CUDA binary file, in this case, named `saxpy`. PTX is an intermediate representation of CUDA code that is closer to assembly language. This command is typically used by developers to inspect the PTX code generated by the CUDA compiler for debugging or optimization purposes. The output of this command would display the PTX code sections contained within the `saxpy` binary.
-
-
-```
-
-
-urning:   This API is deprecated, use hipHostFree() instead
-```
-
-## Parameters
-
-ptr -[in] Pointer to memory to be freed
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue (if pointer is invalid, including device pointers allocated with hipMalloc)
-
-## hipError\_t hipHostFree ( void *ptr )
-
-Free memory allocated by the hcc hip host memory allocation API This API performs an implicit hipDeviceSynchronize() call. If pointer is NULL, the hip runtime is initialized and hipSuccess is returned.
-
-## See also:
-
-hipMalloc , hipMallocPitch , hipFree , hipMallocArray , hipFreeArray , hipMalloc3D , hipMalloc3DArray , hipHostMalloc
-
-## Parameters
-
-ptr -[in] Pointer to memory to be freed
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue (if pointer is invalid, including device pointers allocated with hipMalloc)
-
-hipError\_t hipMemcpy ( void *dst, const void *src, size\_t sizeBytes, hipMemcpyKind kind )
-
-Copy data from src to dst.
-
-It supports memory from host to device, device to host, device to device and host to host The src and dst must not overlap.
-
-For hipMemcpy, the copy is always performed by the current device (set by hipSetDevice). For multi-gpu or peerto-peer configurations, it is recommended to set the current device to the device where the src data is physically located. For optimal peer-to-peer copies, the copy device must be able to access the src and dst pointers (by calling hipDeviceEnablePeerAccess with copy agent as the current device and src/dest as the peerDevice argument. if this is not done, the hipMemcpy will still work, but will perform the copy using a staging buffer on the host. Calling hipMemcpy with dst and src pointers that do not match the hipMemcpyKind results in undefined behavior.
-
-## See also:
-
-hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer
-
-## Parameters
-
-- dst -[out] Data being copy to
-- src -[in] Data being copy from
-- sizeBytes -[in] Data size in bytes
-- kind -[in] Kind of transfer
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorUnknown hipError\_t hipMemcpyWithStream ( void *dst, const void *src, size\_t sizeBytes, hipMemcpyKind kind, hipStream\_t stream )
-
-Memory copy on the stream. It allows single or multiple devices to do memory copy on single or multiple streams.
-
-## See also:
-
-hipMemcpy , hipStreamCreate , hipStreamSynchronize , hipStreamDestroy , hipSetDevice, hipLaunchKernelGGL
-
-## Parameters
-
-- dst -[out] Data being copy to
-- src -[in] Data being copy from
-- sizeBytes -[in] Data size in bytes
-- kind -[in] Kind of transfer
-- stream -[in] Valid stream
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorUnknown, hipErrorContextIsDestroyed hipError\_t hipMemcpyHtoD ( hipDeviceptr\_t dst, void *src, size\_t sizeBytes )
-
-Copy data from Host to Device.
-
-## See also:
-
-hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer
-
-## Parameters
-
-- dst -[out] Data being copy to
-- src -[in] Data being copy from
-- sizeBytes -[in] Data size in bytes
-
-## Returns
-
-hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue
-
-hipError\_t hipMemcpyDtoH ( void *dst, hipDeviceptr\_t src, size\_t sizeBytes )
-
-Copy data from Device to Host.
-
-## See also:
-
-hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer
-
-## Parameters
-
-- dst -[out] Data being copy to
-- src -[in] Data being copy from
-- sizeBytes -[in] Data size in bytes
-
-## Returns
-
-hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue hipError\_t hipMemcpyDtoD ( hipDeviceptr\_t dst, hipDeviceptr\_t src, size\_t sizeBytes )
-
-Copy data from Device to Device.
-
-## See also:
-
-hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer
-
-## Parameters
-
-- dst -[out] Data being copy to
-- src -[in] Data being copy from
-- sizeBytes -[in] Data size in bytes
-
-## Returns
-
-hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue hipError\_t hipMemcpyHtoDAsync ( hipDeviceptr\_t dst, void *src, size\_t sizeBytes, hipStream\_t stream )
-
-Copy data from Host to Device asynchronously.
-
-## See also:
-
-hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpyAtoA, hipMemcpyAtoD,
-
-hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer
-
-## Parameters
-
-- dst -[out] Data being copy to
-- src -[in] Data being copy from
-- sizeBytes -[in] Data size in bytes
-- stream -[in] Stream identifier
-
-## Returns
-
-hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue hipError\_t hipMemcpyDtoHAsync ( void *dst, hipDeviceptr\_t src, size\_t sizeBytes, hipStream\_t stream )
-
-Copy data from Device to Host asynchronously.
-
-## See also:
-
-hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer
-
-## Parameters
-
-- dst -[out] Data being copy to
-- src -[in] Data being copy from
-- sizeBytes -[in] Data size in bytes
-- stream -[in] Stream identifier
-
-## Returns
-
-hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue hipError\_t hipMemcpyDtoDAsync ( hipDeviceptr\_t dst, hipDeviceptr\_t src, size\_t sizeBytes, hipStream\_t stream )
-
-Copy data from Device to Device asynchronously.
-
-## See also:
-
-hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer
-
-## Parameters
-
-- dst -[out] Data being copy to
-- src -[in] Data being copy from
-- sizeBytes -[in] Data size in bytes
-- stream -[in] Stream identifier
-
-## Returns
-
-hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue hipError\_t hipModuleGetGlobal ( hipDeviceptr\_t *dptr, size\_t *bytes, hipModule\_t hmod, const char *name )
-
-Returns a global pointer from a module. Returns in *dptr and *bytes the pointer and size of the global of name name located in module hmod. If no variable of that name exists, it returns hipErrorNotFound. Both parameters dptr and bytes are optional. If one of them is NULL, it is ignored and hipSuccess is returned.
-
-## Parameters
-
-- dptr -[out] Returns global device pointer
-- bytes -[out] Returns global size in bytes
-- hmod -[in] Module to retrieve global from
-- name -[in] Name of global to retrieve
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotFound, hipErrorInvalidContext hipError\_t hipGetSymbolAddress ( void **devPtr, const void *symbol )
-
-Gets device pointer associated with symbol on the device.
-
-## Parameters
-
-- devPtr -[out] pointer to the device associated the symbole
-- symbol -[in] pointer to the symbole of the device
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipGetSymbolSize ( size\_t *size, const void *symbol )
-
-Gets the size of the given symbol on the device.
-
-## Parameters
-
-- symbol -[in] pointer to the device symbole
-- size -[out] pointer to the size
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipGetProcAddress ( const char *symbol, void **pfn, int hipVersion, uint64\_t flags, hipDriverProcAddressQueryResult *symbolStatus )
-
-Gets the pointer of requested HIP driver function.
-
-Returns hipSuccess if the returned pfn is addressed to the pointer of found driver function.
-
-## Parameters
-
-- symbol -[in] The Symbol name of the driver function to request.
-- pfn -[out] Output pointer to the requested driver function.
-- hipVersion -[in] The HIP version for the requested driver function symbol. HIP version is defined as 100*version\_major + version\_minor. For example, in HIP 6.1, the hipversion is 601, for the symbol function 'hipGetDeviceProperties', the specified hipVersion 601 is greater or equal to the version 600, the symbol function will be handle properly as backend compatible function.
-- flags -[in] Currently only default flag is suppported.
-- symbolStatus -[out] Optional enumeration for returned status of searching for symbol driver function based on the input hipVersion.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue.
-
-hipError\_t hipMemcpyToSymbol ( const void *symbol, const void *src, size\_t sizeBytes, size\_t offset, hipMemcpyKind kind )
-
-Copies data to the given symbol on the device. Symbol HIP APIs allow a kernel to define a device-side data symbol which can be accessed on the host side. The symbol can be in \_\_constant or device space. Note that the symbol name needs to be encased in the HIP\_SYMBOL macro. This also applies to hipMemcpyFromSymbol, hipGetSymbolAddress, and hipGetSymbolSize. For detailed usage, see the memcpyToSymbol example in the HIP Porting Guide.
-
-## Parameters
-
-- symbol -[out] pointer to the device symbole
-- src -[in] pointer to the source address
-- sizeBytes -[in] size in bytes to copy
-- offset -[in] offset in bytes from start of symbole
-- kind -[in] type of memory transfer
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemcpyToSymbolAsync ( const void *symbol, const void *src, size\_t sizeBytes, size\_t offset, hipMemcpyKind kind, hipStream\_t stream )
-
-Copies data to the given symbol on the device asynchronously.
-
-## Parameters
-
-- symbol -[out] pointer to the device symbole
-- src -[in] pointer to the source address
-- sizeBytes -[in] size in bytes to copy
-- offset -[in] offset in bytes from start of symbole
-- kind -[in] type of memory transfer
-- stream -[in] stream identifier
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue
-
-hipError\_t hipMemcpyFromSymbol ( void *dst, const void *symbol, size\_t sizeBytes, size\_t offset, hipMemcpyKind kind )
-
-Copies data from the given symbol on the device.
-
-## Parameters
-
-- dst -[out] Returns pointer to destinition memory address
-- symbol -[in] Pointer to the symbole address on the device
-- sizeBytes -[in] Size in bytes to copy
-- offset -[in] Offset in bytes from the start of symbole
-- kind -[in] Type of memory transfer
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemcpyFromSymbolAsync ( void *dst, const void *symbol, size\_t sizeBytes, size\_t offset, hipMemcpyKind kind, hipStream\_t stream )
-
-Copies data from the given symbol on the device asynchronously.
-
-## Parameters
-
-- dst -[out] Returns pointer to destinition memory address
-- symbol -[in] pointer to the symbole address on the device
-- sizeBytes -[in] size in bytes to copy
-- offset -[in] offset in bytes from the start of symbole
-- kind -[in] type of memory transfer
-- stream -[in] stream identifier
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemcpyAsync ( void *dst, const void *src, size\_t sizeBytes, hipMemcpyKind kind, hipStream\_t stream )
-
-Copy data from src to dst asynchronously.
-
-For multi-gpu or peer-to-peer configurations, it is recommended to use a stream which is a attached to the device where the src data is physically located. For optimal peer-to-peer copies, the copy device must be able to access the src and dst pointers (by calling hipDeviceEnablePeerAccess with copy agent as the current device and src/dest as the peerDevice argument. if this is not done, the hipMemcpy will still work, but will perform the copy using a staging buffer on the host.
-
-## See also:
-
-hipMemcpy , hipMemcpy2D , hipMemcpyToArray , hipMemcpy2DToArray , hipMemcpyFromArray , hipMemcpy2DFromArray , hipMemcpyArrayToArray, hipMemcpy2DArrayToArray, hipMemcpyToSymbol , hipMemcpyFromSymbol , hipMemcpy2DAsync , hipMemcpyToArrayAsync, hipMemcpy2DToArrayAsync , hipMemcpyFromArrayAsync, hipMemcpy2DFromArrayAsync , hipMemcpyToSymbolAsync , hipMemcpyFromSymbolAsync
-
-Warning: If host or dest are not pinned, the memory copy will be performed synchronously. For best performance, use hipHostMalloc to allocate host memory that is transferred asynchronously.
-
-Warning: on HCC hipMemcpyAsync does not support overlapped H2D and D2H copies. For hipMemcpy, the copy is always performed by the device associated with the specified stream.
-
-## Parameters
-
-- dst -[out] Data being copy to
-- src -[in] Data being copy from
-- sizeBytes -[in] Data size in bytes
-- kind -[in] Type of memory transfer
-- stream -[in] Stream identifier
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorUnknown hipError\_t hipMemset ( void *dst, int value, size\_t sizeBytes )
-
-Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant byte value value.
-
-## Parameters
-
-- dst -[out] Data being filled
-- value -[in] Value to be set
-- sizeBytes -[in] Data size in bytes
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized hipError\_t hipMemsetD8 ( hipDeviceptr\_t dest, unsigned char value, size\_t count )
-
-Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant byte value value.
-
-## Parameters
-
-- dest -[out] Data ptr to be filled
-- value -[in] Value to be set
-- count -[in] Number of values to be set
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized hipError\_t hipMemsetD8Async ( hipDeviceptr\_t dest, unsigned char value, size\_t count, hipStream\_t stream )
-
-Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant byte value value.
-
-hipMemsetD8Async() is asynchronous with respect to the host, so the call may return before the memset is complete. The operation can optionally be associated to a stream by passing a non-zero stream argument. If stream is non-zero, the operation may overlap with operations in other streams.
-
-## Parameters
-
-- dest -[out] Data ptr to be filled
-- value -[in] Constant value to be set
-
-- count -[in] Number of values to be set
-- stream -[in] Stream identifier
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized hipError\_t hipMemsetD16 ( hipDeviceptr\_t dest, unsigned short value, size\_t count )
-
-Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant short value value.
-
-## Parameters
-
-- dest -[out] Data ptr to be filled
-- value -[in] Constant value to be set
-- count -[in] Number of values to be set
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized hipError\_t hipMemsetD16Async ( hipDeviceptr\_t dest, unsigned short value, size\_t count, hipStream\_t stream )
-
-Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant short value value.
-
-hipMemsetD16Async() is asynchronous with respect to the host, so the call may return before the memset is complete. The operation can optionally be associated to a stream by passing a non-zero stream argument. If stream is non-zero, the operation may overlap with operations in other streams.
-
-## Parameters
-
-- dest -[out] Data ptr to be filled
-- value -[in] Constant value to be set
-- count -[in] Number of values to be set
-- stream -[in] Stream identifier
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized hipError\_t hipMemsetD32 ( hipDeviceptr\_t dest, int value, size\_t count )
-
-Fills the memory area pointed to by dest with the constant integer value for specified number of times.
-
-## Parameters
-
-- dest -[out] Data being filled
-- value -[in] Constant value to be set
-- count -[in] Number of values to be set
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized hipError\_t hipMemsetAsync ( void *dst, int value, size\_t sizeBytes, hipStream\_t stream )
-
-Fills the first sizeBytes bytes of the memory area pointed to by dev with the constant byte value value.
-
-hipMemsetAsync() is asynchronous with respect to the host, so the call may return before the memset is complete. The operation can optionally be associated to a stream by passing a non-zero stream argument. If stream is nonzero, the operation may overlap with operations in other streams.
-
-## Parameters
-
-- dst -[out] Pointer to device memory
-
-- value -[in] Value to set for each byte of specified memory
-- sizeBytes -[in] Size in bytes to set
-- stream -[in] Stream identifier
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemsetD32Async ( hipDeviceptr\_t dst, int value, size\_t count, hipStream\_t stream )
-
-Fills the memory area pointed to by dev with the constant integer value for specified number of times.
-
-hipMemsetD32Async() is asynchronous with respect to the host, so the call may return before the memset is complete. The operation can optionally be associated to a stream by passing a non-zero stream argument. If stream is non-zero, the operation may overlap with operations in other streams.
-
-## Parameters
-
-- dst -[out] Pointer to device memory
-- value -[in] Value to set for each byte of specified memory
-- count -[in] Number of values to be set
-- stream -[in] Stream identifier
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemset2D ( void *dst, size\_t pitch, int value, size\_t width, size\_t height )
-
-Fills the memory area pointed to by dst with the constant value.
-
-## Parameters
-
-- dst -[out] Pointer to device memory
-- pitch -[in] Data size in bytes
-- value -[in] Constant value to be set
-- width -[in]
-- height -[in]
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemset2DAsync ( void *dst, size\_t pitch, int value, size\_t width, size\_t height, hipStream\_t stream ) Fills asynchronously the memory area pointed to by dst with the constant value.
-
-## Parameters
-
-- dst -[in] Pointer to 2D device memory
-- pitch -[in] Pitch size in bytes
-- value -[in] Value to be set for each byte of specified memory
-- width -[in] Width of matrix set columns in bytes
-- height -[in] Height of matrix set rows in bytes
-- stream -[in] Stream identifier
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue
-
-hipError\_t hipMemset3D ( hipPitchedPtr pitchedDevPtr, int value, hipExtent extent )
-
-Fills synchronously the memory area pointed to by pitchedDevPtr with the constant value.
-
-## Parameters
-
-- pitchedDevPtr -[in] Pointer to pitched device memory
-- value -[in] Value to set for each byte of specified memory
-- extent -[in] Size parameters for width field in bytes in device memory
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemset3DAsync ( hipPitchedPtr pitchedDevPtr, int value, hipExtent extent, hipStream\_t stream )
-
-Fills asynchronously the memory area pointed to by pitchedDevPtr with the constant value.
-
-## Parameters
-
-- pitchedDevPtr -[in] Pointer to pitched device memory
-- value -[in] Value to set for each byte of specified memory
-- extent -[in] Size parameters for width field in bytes in device memory
-- stream -[in] Stream identifier
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemGetInfo ( size\_t *free, size\_t *total )
-
-Query memory info.
-
-On ROCM, this function gets the actual free memory left on the current device, so supports the cases while running multi-workload (such as multiple processes, multiple threads, and multiple GPUs).
-
-Warning: On Windows, the free memory only accounts for memory allocated by this process and may be optimistic.
-
-## Parameters
-
-- free -[out] Returns free memory on the current device in bytes
-- total -[out] Returns total allocatable memory on the current device in bytes
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError\_t hipMemPtrGetInfo ( void *ptr, size\_t *size )
-
-Get allocated memory size via memory pointer.
-
-This function gets the allocated shared virtual memory size from memory pointer.
-
-## Parameters
-
-- ptr -[in] Pointer to allocated memory
-- size -[out] Returns the allocated memory size in bytes
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue
-
-hipError\_t hipMallocArray ( hipArray\_t *array, const hipChannelFormatDesc *desc, size\_t width, size\_t height, unsigned int flags )
-
-Allocate an array on the device.
-
-## See also:
-
-hipMalloc , hipMallocPitch , hipFree , hipFreeArray , hipHostMalloc , hipHostFree
-
-## Parameters
-
-- array -[out] Pointer to allocated array in device memory
-- desc -[in] Requested channel format
-- width -[in] Requested array allocation width
-- height -[in] Requested array allocation height
-- flags -[in] Requested properties of allocated array
-
-## Returns
-
-hipSuccess, hipErrorOutOfMemory hipError\_t hipArrayCreate ( hipArray\_t *pHandle, const HIP\_ARRAY\_DESCRIPTOR *pAllocateArray )
-
-Create an array memory pointer on the device.
-
-## See also:
-
-hipMallocArray , hipArrayDestroy , hipFreeArray
-
-## Parameters
-
-- pHandle -[out] Pointer to the array memory
-- pAllocateArray -[in] Requested array desciptor
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipArrayDestroy ( hipArray\_t array )
-
-Destroy an array memory pointer on the device.
-
-## See also:
-
-hipArrayCreate , hipArrayDestroy , hipFreeArray
-
-## Parameters
-
-array -[in] Pointer to the array memory
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue
-
-hipError\_t hipArray3DCreate ( hipArray\_t *array, const HIP\_ARRAY3D\_DESCRIPTOR *pAllocateArray )
-
-Create a 3D array memory pointer on the device.
-
-## See also:
-
-hipMallocArray , hipArrayDestroy , hipFreeArray
-
-## Parameters
-
-- array -[out] Pointer to the 3D array memory
-- pAllocateArray -[in] Requested array desciptor
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMalloc3D ( hipPitchedPtr *pitchedDevPtr, hipExtent extent )
-
-Create a 3D memory pointer on the device.
-
-## See also:
-
-hipMallocPitch , hipMemGetInfo , hipFree
-
-## Parameters
-
-- pitchedDevPtr -[out] Pointer to the 3D memory
-- extent -[in] Requested extent
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipFreeArray ( hipArray\_t array )
-
-Frees an array on the device.
-
-## See also:
-
-hipMalloc , hipMallocPitch , hipFree , hipMallocArray , hipHostMalloc , hipHostFree
-
-## Parameters
-
-array -[in] Pointer to array to free
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized hipError\_t hipMalloc3DArray ( hipArray\_t *array, const struct hipChannelFormatDesc *desc, struct hipExtent extent, unsigned int flags )
-
-Allocate an array on the device.
-
-## See also:
-
-hipMalloc , hipMallocPitch , hipFree , hipFreeArray , hipHostMalloc , hipHostFree
-
-## Parameters
-
-- array -[out] Pointer to allocated array in device memory
-- desc -[in] Requested channel format
-- extent -[in] Requested array allocation width, height and depth
-- flags -[in] Requested properties of allocated array
-
-## Returns
-
-hipSuccess, hipErrorOutOfMemory hipError\_t hipArrayGetInfo ( hipChannelFormatDesc *desc, hipExtent *extent, unsigned int *flags, hipArray\_t array )
-
-Gets info about the specified array.
-
-## See also:
-
-hipArrayGetDescriptor , hipArray3DGetDescriptor
-
-## Parameters
-
-- desc -[out] - Returned array type
-- extent -[out] - Returned array shape. 2D arrays will have depth of zero
-- flags -[out] - Returned array flags
-- array -[in] - The HIP array to get info for
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipErrorInvalidHandle hipError\_t hipArrayGetDescriptor ( HIP\_ARRAY\_DESCRIPTOR *pArrayDescriptor, hipArray\_t array )
-
-Gets a 1D or 2D array descriptor.
-
-## See also:
-
-hipArray3DCreate , hipArray3DGetDescriptor , hipArrayCreate , hipArrayDestroy , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpy3D , hipMemcpy3DAsync , hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoD , hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer, hipMemsetD8 , hipMemsetD16 , hipMemsetD32 , hipArrayGetInfo
-
-## Parameters
-
-- pArrayDescriptor -[out] - Returned array descriptor
-- array -[in] - Array to get descriptor of
-
-## Returns
-
-hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue hipErrorInvalidHandle
-
-hipError\_t hipArray3DGetDescriptor ( HIP\_ARRAY3D\_DESCRIPTOR *pArrayDescriptor, hipArray\_t array )
-
-Gets a 3D array descriptor.
-
-## See also:
-
-hipArray3DCreate , hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpy3D , hipMemcpy3DAsync , hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoD , hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer, hipMemsetD8 , hipMemsetD16 , hipMemsetD32 , hipArrayGetInfo
-
-## Parameters
-
-- pArrayDescriptor -[out] - Returned 3D array descriptor
-- array -[in] - 3D array to get descriptor of
-
-## Returns
-
-hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue hipErrorInvalidHandle, hipErrorContextIsDestroyed hipError\_t hipMemcpy2D ( void *dst, size\_t dpitch, const void *src, size\_t spitch, size\_t width, size\_t height, hipMemcpyKind kind )
-
-Copies data between host and device.
-
-## See also:
-
-hipMemcpy , hipMemcpyToArray , hipMemcpy2DToArray , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-- dst -[in] Destination memory address
-- dpitch -[in] Pitch of destination memory
-- src -[in] Source memory address
-- spitch -[in] Pitch of source memory
-- width -[in] Width of matrix transfer (columns in bytes)
-- height -[in] Height of matrix transfer (rows)
-- kind -[in] Type of transfer
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpyParam2D ( const hip\_Memcpy2D *pCopy )
-
-Copies memory for 2D arrays.
-
-## See also:
-
-hipMemcpy , hipMemcpy2D , hipMemcpyToArray , hipMemcpy2DToArray , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-pCopy -[in] Parameters for the memory copy
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpyParam2DAsync ( const hip\_Memcpy2D *pCopy, hipStream\_t stream )
-
-Copies memory for 2D arrays.
-
-## See also:
-
-hipMemcpy , hipMemcpy2D , hipMemcpyToArray , hipMemcpy2DToArray , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-- pCopy -[in] Parameters for the memory copy
-- stream -[in] Stream to use
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpy2DAsync ( void *dst, size\_t dpitch, const void *src, size\_t spitch, size\_t width, size\_t height, hipMemcpyKind kind, hipStream\_t stream )
-
-Copies data between host and device.
-
-## See also:
-
-hipMemcpy , hipMemcpyToArray , hipMemcpy2DToArray , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-- dst -[in] Destination memory address
-- dpitch -[in] Pitch of destination memory
-- src -[in] Source memory address
-- spitch -[in] Pitch of source memory
-- width -[in] Width of matrix transfer (columns in bytes)
-- height -[in] Height of matrix transfer (rows)
-- kind -[in] Type of transfer
-- stream -[in] Stream to use
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpy2DToArray ( hipArray\_t dst, size\_t wOffset, size\_t hOffset, const void *src, size\_t spitch, size\_t width, size\_t height, hipMemcpyKind kind )
-
-Copies data between host and device.
-
-## See also:
-
-hipMemcpy , hipMemcpyToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-- dst -[in] Destination memory address
-- wOffset -[in] Destination starting X offset
-- hOffset -[in] Destination starting Y offset
-- src -[in] Source memory address
-- spitch -[in] Pitch of source memory
-- width -[in] Width of matrix transfer (columns in bytes)
-- height -[in] Height of matrix transfer (rows)
-- kind -[in] Type of transfer
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpy2DToArrayAsync ( hipArray\_t dst, size\_t wOffset, size\_t hOffset, const void *src, size\_t spitch, size\_t width, size\_t height, hipMemcpyKind kind, hipStream\_t stream )
-
-Copies data between host and device.
-
-## See also:
-
-hipMemcpy , hipMemcpyToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-- dst -[in] Destination memory address
-- wOffset -[in] Destination starting X offset
-- hOffset -[in] Destination starting Y offset
-- src -[in] Source memory address
-- spitch -[in] Pitch of source memory
-- width -[in] Width of matrix transfer (columns in bytes)
-- height -[in] Height of matrix transfer (rows)
-
-- kind -[in] Type of transfer
-- stream -[in] Accelerator view which the copy is being enqueued
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpyToArray ( hipArray\_t dst, size\_t wOffset, size\_t hOffset, const void *src, size\_t count, hipMemcpyKind kind )
-
-Copies data between host and device.
-
-## See also:
-
-hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-Warning: This API is deprecated.
-
-## Parameters
-
-- dst -[in] Destination memory address
-- wOffset -[in] Destination starting X offset
-- hOffset -[in] Destination starting Y offset
-- src -[in] Source memory address
-- count -[in] size in bytes to copy
-- kind -[in] Type of transfer
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpyFromArray ( void *dst, hipArray\_const\_t srcArray, size\_t wOffset, size\_t hOffset, size\_t count, hipMemcpyKind kind )
-
-Copies data between host and device.
-
-## See also:
-
-hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-Warning: This API is deprecated.
-
-## Parameters
-
-- dst -[in] Destination memory address
-- srcArray -[in] Source memory address
-- wOffset -[in] Source starting X offset
-
-- hOffset -[in] Source starting Y offset
-- count -[in] Size in bytes to copy
-- kind -[in] Type of transfer
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpy2DFromArray ( void *dst, size\_t dpitch, hipArray\_const\_t src, size\_t wOffset, size\_t hOffset, size\_t width, size\_t height, hipMemcpyKind kind )
-
-Copies data between host and device.
-
-## See also:
-
-hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-- dst -[in] Destination memory address
-- dpitch -[in] Pitch of destination memory
-- src -[in] Source memory address
-- wOffset -[in] Source starting X offset
-- hOffset -[in] Source starting Y offset
-- width -[in] Width of matrix transfer (columns in bytes)
-- height -[in] Height of matrix transfer (rows)
-- kind -[in] Type of transfer
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpy2DFromArrayAsync ( void *dst, size\_t dpitch, hipArray\_const\_t src, size\_t wOffset, size\_t hOffset, size\_t width, size\_t height, hipMemcpyKind kind, hipStream\_t stream )
-
-Copies data between host and device asynchronously.
-
-## See also:
-
-hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-- dst -[in] Destination memory address
-- dpitch -[in] Pitch of destination memory
-- src -[in] Source memory address
-- wOffset -[in] Source starting X offset
-
-- hOffset -[in] Source starting Y offset
-- width -[in] Width of matrix transfer (columns in bytes)
-- height -[in] Height of matrix transfer (rows)
-- kind -[in] Type of transfer
-- stream -[in] Accelerator view which the copy is being enqueued
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpyAtoH ( void *dst, hipArray\_t srcArray, size\_t srcOffset, size\_t count )
-
-Copies data between host and device.
-
-## See also:
-
-hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-- dst -[in] Destination memory address
-- srcArray -[in] Source array
-- srcOffset -[in] Offset in bytes of source array
-- count -[in] Size of memory copy in bytes
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpyHtoA ( hipArray\_t dstArray, size\_t dstOffset, const void *srcHost, size\_t count )
-
-Copies data between host and device.
-
-## See also:
-
-hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-- dstArray -[in] Destination memory address
-- dstOffset -[in] Offset in bytes of destination array
-- srcHost -[in] Source host pointer
-- count -[in] Size of memory copy in bytes
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection
-
-hipError\_t hipMemcpy3D ( const struct hipMemcpy3DParms *p )
-
-Copies data between host and device.
-
-## See also:
-
-hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-p -[in] 3D memory copy parameters
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpy3DAsync ( const struct hipMemcpy3DParms *p, hipStream\_t stream )
-
-Copies data between host and device asynchronously.
-
-## See also:
-
-hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-- p -[in] 3D memory copy parameters
-- stream -[in] Stream to use
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipDrvMemcpy3D ( const HIP\_MEMCPY3D *pCopy )
-
-Copies data between host and device.
-
-## See also:
-
-hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-pCopy -[in] 3D memory copy parameters
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipDrvMemcpy3DAsync ( const HIP\_MEMCPY3D *pCopy, hipStream\_t stream )
-
-Copies data between host and device asynchronously.
-
-## See also:
-
-hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-- pCopy -[in] 3D memory copy parameters
-- stream -[in] Stream to use
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection template&lt;typename T &gt; hipError\_t hipGetSymbolAddress ( void **devPtr, const T &amp;symbol ) Gets the address of a symbol.
-
-## Parameters
-
-- devPtr -[out] - Returns device pointer associated with symbol.
-- symbol -[in] - Device symbol.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue template&lt;typename T &gt; hipError\_t hipGetSymbolSize ( size\_t *size, const T &amp;symbol ) Gets the size of a symbol.
-
-## Parameters
-
-- size -[out] - Returns the size of a symbol.
-- symbol -[in] - Device symbol address.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue template&lt;typename T &gt;
-
-hipError\_t hipMemcpyToSymbol ( const T &amp;symbol, const void *src, size\_t sizeBytes, size\_t offset, hipMemcpyKind kind )
-
-Copies data to the given symbol on the device.
-
-## See also:
-
-hipMemcpyToSymbol
-
-## Returns
-
-hipSuccess, hipErrorInvalidMemcpyDirection, hipErrorInvalidValue template&lt;typename T &gt;
-
-hipError\_t hipMemcpyToSymbolAsync ( const T &amp;symbol, const void *src, size\_t sizeBytes, size\_t offset, hipMemcpyKind kind, hipStream\_t stream )
-
-Copies data to the given symbol on the device asynchronously on the stream.
-
-## See also:
-
-hipMemcpyToSymbolAsync
-
-## Returns
-
-hipSuccess, hipErrorInvalidMemcpyDirection, hipErrorInvalidValue template&lt;typename T &gt;
-
-hipError\_t hipMemcpyFromSymbol ( void *dst, const T &amp;symbol, size\_t sizeBytes, size\_t offset, hipMemcpyKind kind )
-
-Copies data from the given symbol on the device.
-
-## See also:
-
-hipMemcpyFromSymbol
-
-## Returns
-
-hipSuccess, hipErrorInvalidMemcpyDirection, hipErrorInvalidValue template&lt;typename T &gt;
-
-hipError\_t hipMemcpyFromSymbolAsync ( void *dst, const T &amp;symbol, size\_t sizeBytes, size\_t offset, hipMemcpyKind kind, hipStream\_t stream )
-
-Copies data from the given symbol on the device asynchronously on the stream.
-
-## See also:
-
-hipMemcpyFromSymbolAsync
-
-## Returns
-
-hipSuccess, hipErrorInvalidMemcpyDirection, hipErrorInvalidValue template&lt;class T &gt;
-
-static inline hipError\_t hipMalloc ( T **devPtr, size\_t size )
-
-- : C++ wrapper for hipMalloc
-
-Perform automatic type conversion to eliminate need for excessive typecasting (ie void**)
-
-HIP\_DISABLE\_CPP\_FUNCTIONS macro can be defined to suppress these wrappers. It is useful for applications which need to obtain decltypes of HIP runtime APIs.
-
-## See also:
-
-hipMalloc
-
-## template&lt;class T &gt;
-
-static inline hipError\_t hipHostMalloc ( T **ptr, size\_t size, unsigned int flags = hipHostMallocDefault )
-
-- : C++ wrapper for hipHostMalloc
-
-Provide an override to automatically typecast the pointer type from void**, and also provide a default for the flags.
-
-HIP\_DISABLE\_CPP\_FUNCTIONS macro can be defined to suppress these wrappers. It is useful for applications which need to obtain decltypes of HIP runtime APIs.
-
-## See also:
-
-hipHostMalloc
-
-## 19.23.4 External Resource Interoperability
-
-hipError\_t hipImportExternalSemaphore ( hipExternalSemaphore\_t *extSem\_out, const hipExternalSemaphoreHandleDesc *semHandleDesc )
-
-Imports an external semaphore.
-
-See also:
-
-## Parameters
-
-- extSem\_out -[out] External semaphores to be waited on
-- semHandleDesc -[in] Semaphore import handle descriptor
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError\_t hipSignalExternalSemaphoresAsync ( const hipExternalSemaphore\_t *extSemArray, const hipExternalSemaphoreSignalParams *paramsArray, unsigned int numExtSems, hipStream\_t stream )
-
-Signals a set of external semaphore objects.
-
-## See also:
-
-## Parameters
-
-- extSemArray -[in] External semaphores to be waited on
-- paramsArray -[in] Array of semaphore parameters
-- numExtSems -[in] Number of semaphores to wait on
-- stream -[in] Stream to enqueue the wait operations in
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError\_t hipWaitExternalSemaphoresAsync ( const hipExternalSemaphore\_t *extSemArray, const hipExternalSemaphoreWaitParams *paramsArray, unsigned int numExtSems, hipStream\_t stream )
-
-Waits on a set of external semaphore objects.
-
-See also:
-
-## Parameters
-
-- extSemArray -[in] External semaphores to be waited on
-- paramsArray -[in] Array of semaphore parameters
-- numExtSems -[in] Number of semaphores to wait on
-- stream -[in] Stream to enqueue the wait operations in
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue
-
-## hipError\_t hipDestroyExternalSemaphore ( hipExternalSemaphore\_t extSem )
-
-Destroys an external semaphore object and releases any references to the underlying resource. Any outstanding signals or waits must have completed before the semaphore is destroyed.
-
-## See also:
-
-## Parameters
-
-extSem -[in] handle to an external memory object
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError\_t hipImportExternalMemory ( hipExternalMemory\_t *extMem\_out, const hipExternalMemoryHandleDesc *memHandleDesc )
-
-Imports an external memory object.
-
-## See also:
-
-## Parameters
-
-- extMem\_out -[out] Returned handle to an external memory object
-- memHandleDesc -[in] Memory import handle descriptor
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError\_t hipExternalMemoryGetMappedBuffer ( void **devPtr, hipExternalMemory\_t extMem, const hipExternalMemoryBufferDesc *bufferDesc )
-
-Maps a buffer onto an imported memory object.
-
-## See also:
-
-## Parameters
-
-- devPtr -[out] Returned device pointer to buffer
-- extMem -[in] Handle to external memory object
-- bufferDesc -[in] Buffer descriptor
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue
-
-## hipError\_t hipDestroyExternalMemory ( hipExternalMemory\_t extMem )
-
-Destroys an external memory object.
-
-See also:
-
-## Parameters
-
-extMem -[in] External memory object to be destroyed
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError\_t hipExternalMemoryGetMappedMipmappedArray ( hipMipmappedArray\_t *mipmap,
-
-hipExternalMemory\_t extMem, const hipExternalMemoryMipmappedArrayDesc *mipmapDesc )
-
-Maps a mipmapped array onto an external memory object.
-
-Returned mipmapped array must be freed using hipFreeMipmappedArray.
-
-## See also:
-
-hipImportExternalMemory , hipFreeMipmappedArray
-
-hipDestroyExternalMemory ,
-
-## Parameters
-
-- mipmap -[out] mipmapped array to return
-- extMem -[in] external memory object handle
-- mipmapDesc -[in] external mipmapped array descriptor
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidResourceHandle
-
-## 19.24 Register Keyword
-
-The register keyword is deprecated in C++, and is silently ignored by both NVCC and HIP-Clang. You can pass the option -Wdeprecated-register the compiler warning message.
-
-hipExternalMemoryGetMappedBuffer ,
-
-## 19.25 Pragma Unroll
-
-Unroll with a bounds that is known at compile-time is supported. For example:
-**Following code does:** The code snippet appears to be a corrupted or incorrectly formatted text, possibly due to a copy-paste error or encoding issue. It does not represent valid Python code or any recognizable programming construct. Therefore, it does not perform any specific function or task in its current form.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        //                                                                                                                                                                                                        #pragma unroll 16 /* hint to compiler to unroll next loop by 16 */
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        }                                                                                                                                                                                                        /*                                                                                                                                                                                                        */
-                                                                                                                                                                                                     
-		                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       //
-                                                                                                                                                                                                       }
-                                                                                                                                                                                                       */
-```
-
-## 19.26 In-Line Assembly
-
-GCN ISA In-line assembly, is supported. For example:
-**Following code does:** The code snippet you provided appears to be a command or a reference to a file rather than a typical code snippet. It seems to be related to a SAXPY operation, which stands for "Single-Precision A·X Plus Y." SAXPY is a common operation in linear algebra used to perform a scaled vector addition. The rest of the line suggests it might be related to a specific implementation or version (possibly for a GPU architecture, given the "sm_5" which could refer to a specific compute capability of NVIDIA GPUs) and "ptx" which typically refers to Parallel Thread Execution, NVIDIA's intermediate representation for GPU code. Overall, this line likely refers to a file or command related to executing or compiling a SAXPY operation for a specific GPU architecture.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <img>void                                                                                                                                                                                                        </img>void
-```
-
-We insert the GCN isa into the kernel using asm() Assembler statement. volatile keyword is used so that the optimizers must not change the number of volatile operations or change their order of execution relative to other volatile operations. v\_mac\_f32\_e32 is the GCN instruction, for more information please refer - [AMD GCN3 ISA architecture manual](http://gpuopen.com/compute-product/amd-gcn3-isa-architecture-manual/) Index for the respective operand in the ordered fashion is provided by % followed by position in the list of operands 'v' is the constraint code (for target-specific AMDGPU) for 32-bit VGPR register, for more info please refer - [Supported Constraint Code List for AMDGPU](https://llvm.org/docs/LangRef.html#supported-constraint-code-list) Output Constraints are specified by an '=' prefix as shown above ('=v'). This indicate that assembly will write to this operand, and the operand will then be made available as a return value of the asm expression. Input constraints do not have a prefix - just the constraint code. The constraint string of '0' says to use the assigned register for output as an input as well (it being the 0'th constraint).
-
-## C++ Support The following C++ features are not supported: - Run-time-type information (RTTI) - Try/catch Virtual functions Virtual functions are not supported if objects containing virtual function tables are passed between GPU's of different offload arch's, e.g. between gfx906 and gfx1030. Otherwise virtual functions are supported.
-
-## 19.27 Kernel Compilation
-
-hipcc now supports compiling C++/HIP kernels to binary code objects. The file format for binary is .co which means Code Object. The following command builds the code object using hipcc .
-**Following code does:** The code snippet appears to be a command-line operation that uses `dumpbin.exe` to analyze a specific section of an executable file (`saxpy.exe`). It targets the `.hip_fat` section and extracts raw data with a specified format. The output is then piped into a `select` command, which skips the first 20 lines and selects the next 12 lines from the output. This operation is likely used for inspecting or debugging specific parts of the executable's binary data.
-
-
-```
-hipcc --genco --offload-arch=[TARGET GPU] [INPUT FILE] -o [OUTPUT FILE]
-
-[TARGET GPU] = GPU architecture
-[INPUT FILE] = Name of the file containing kernels
-[OUTPUT FILE] = Name of the generated code object file
-```
-
-Note: When using binary code objects is that the number of arguments to the kernel is different on HIP-Clang and NVCC path. Refer to the HIP module\_api sample for differences in the arguments to be passed to the kernel.
-
-## 19.28 gfx-arch-specific-kernel
-
-Clang defined '\_\_gfx*\_\_' macros can be used to execute gfx arch specific codes inside the kernel. Refer to the sample in HIP 14\_gpu\_arch sample.
-
-## CHAPTER
-
-## TWENTY
-
-## C++ LANGUAGE SUPPORT
-
-The ROCm platform enables the power of combined C++ and HIP (Heterogeneous-computing Interface for Portability) code. This code is compiled with a clang or clang++ compiler. The official compilers support the HIP platform, or you can use the amdclang or amdclang++ included in the ROCm installation, which are a wrapper for the official versions.
-
-The source code is compiled according to the C++03 , C++11 , C++14 , C++17 , and C++20 standards, along with HIPspecific extensions, but is subject to restrictions. The key restriction is the reduced support of standard library in device code. This is due to the fact that by default a function is considered to run on host, except for constexpr functions, which can run on host and device as well.
-
-## 20.1 Modern C++ support
-
-C++ is considered a modern programming language as of C++11. This section describes how HIP supports these new C++ features.
-
-## 20.1.1 C++11 support
-
-The C++11 standard introduced many new features. These features are supported in HIP host code, with some notable omissions on the device side. The rule of thumb here is that constexpr functions work on device, the rest doesn't. This means that some important functionality like std::function is missing on the device, but unfortunately the standard library wasn't designed with HIP in mind, which means that the support is in a state of 'works as-is'.
-
-Certain features have restrictions and clarifications. For example, any functions using the constexpr qualifier or the new initializer lists , std::move or std::forward features are implicitly considered to have the \_\_host\_\_ and \_\_device\_\_ execution space specifier. Also, constexpr variables that are static members or namespace scoped can be used from both host and device, but only for read access. Dereferencing a static constexpr outside its specified execution space causes an error.
-
-Lambdas are supported, but there are some extensions and restrictions on their usage. For more information, see the Extended lambdas section below.
-
-## 20.1.2 C++14 support
-
-The C++14 language features are supported.
-
-## 20.1.3 C++17 support
-
-All C++17 language features are supported.
-
-## 20.1.4 C++20 support
-
-All C++20 language features are supported, but extensions and restrictions apply. C++20 introduced coroutines and modules, which fundamentally changed how programs are written. HIP doesn't support these features. However, consteval functions can be called from host and device, even if specified for host use only.
-
-The three-way comparison operator (spaceship operator &lt;=&gt; ) works with host and device code.
-
-## 20.2 Extensions and restrictions
-
-In addition to the deviations from the standard, there are some general extensions and restrictions to consider.
-
-## 20.2.1 Global functions
-
-Functions that serve as an entry point for device execution are called kernels and are specified with the \_\_global\_\_ qualifier. To call a kernel function, use the triple chevron operator: &lt;&lt;&lt; &gt;&gt;&gt; . Kernel functions must have a void return type. These functions can't:
-
-- have a constexpr specifier
-- have a parameter of type std::initializer\_list or va\_list
-- use an rvalue reference as a parameter.
-- use parameters having different sizes in host and device code, e.g. long double arguments, or structs containing long double members.
-- use struct-type arguments which have different layout in host and device code.
-
-Kernels can have variadic template parameters, but only one parameter pack, which must be the last item in the template parameter list.
-
-## 20.2.2 Device space memory specifiers
-
-HIP includes device space memory specifiers to indicate whether a variable is allocated in host or device memory and howits memory should be allocated. HIP supports the \_\_device\_\_ , \_\_shared\_\_ , \_\_managed\_\_ , and \_\_constant\_\_ specifiers.
-
-The \_\_device\_\_ and \_\_constant\_\_ specifiers define global variables, which are allocated within global memory on the HIP devices. The only difference is that \_\_constant\_\_ variables can't be changed after allocation. The \_\_shared\_\_ specifier allocates the variable within shared memory, which is available for all threads in a block.
-
-The \_\_managed\_\_ variable specifier creates global variables that are initially undefined and unaddressed within the global symbol table. The HIP runtime allocates managed memory and defines the symbol when it loads the device binary. A managed variable can be accessed in both device and host code.
-
-It's important to know where a variable is stored because it is only available from certain locations. Generally, variables allocated in the host memory are not accessible from the device code, while variables allocated in the device memory are not directly accessible from the host code. Dereferencing a pointer to device memory on the host results in a segmentation fault. Accessing device variables in host code should be done through kernel execution or HIP functions like hipMemCpyToSymbol .
-
-## 20.2.3 Exception handling
-
-An important difference between the host and device code is exception handling. In device code, this control flow isn't available due to the hardware architecture. The device code must use return codes to handle errors.
-
-## 20.2.4 Kernel parameters
-
-There are some restrictions on kernel function parameters. They cannot be passed by reference, because these functions are called from the host but run on the device. Also, a variable number of arguments is not allowed.
-
-## 20.2.5 Classes
-
-Classes work on both the host and device side, but there are some constraints. The static member functions can't be \_\_global\_\_ . Virtual member functions work, but a virtual function must not be called from the host if the parent object was created on the device, or the other way around, because this behavior is undefined. Another minor restriction is that \_\_device\_\_ variables, that are global scoped must have trivial constructors.
-
-## 20.2.6 Polymorphic function wrappers
-
-HIP doesn't support the polymorphic function wrapper std::function , which was introduced in C++11.
-
-## 20.2.7 Extended lambdas
-
-HIP supports Lambdas, which by default work as expected.
-
-Lambdas have implicit host device attributes. This means that they can be executed by both host and device code, and works the way you would expect. To make a lambda callable only by host or device code, users can add \_\_host\_\_ or \_\_device\_\_ attribute. The only restriction is that host variables can only be accessed through copy on the device. Accessing through reference will cause undefined behavior.
-
-## 20.2.8 Inline namespaces
-
-Inline namespaces are supported, but with a few exceptions. The following entities can't be declared in namespace scope within an inline unnamed namespace:
-
-- \_\_managed\_\_ , \_\_device\_\_ , \_\_shared\_\_ and \_\_constant\_\_ variables
-- \_\_global\_\_ function and function templates
-- variables with surface or texture type
-
-## CHAPTER
-
-## TWENTYONE
-
-## HIP MATH API
-
-HIP-Clang supports a set of math operations that are callable from the device. HIP supports most of the device functions supported by NVIDIA CUDA. These are described in the following sections.
-
-## 21.1 Single precision mathematical functions
-
-Following is the list of supported single precision mathematical functions.
-
-Table 1: Single precision mathematical functions
-
-| Function                                                                   | Supported on Host   | Supported on Device   |
-|----------------------------------------------------------------------------|---------------------|-----------------------|
-| float abs(float x) Returns the absolute value of 𝑥                         | ✓                   | ✓                     |
-| float acosf(float x) Returns the arc cosine of 𝑥 .                         | ✓                   | ✓                     |
-| float acoshf(float x) Returns the nonnegative arc hyperbolic cosine of 𝑥 . | ✓                   | ✓                     |
-| float asinf(float x) Returns the arc sine of 𝑥 .                           | ✓                   | ✓                     |
-| float asinhf(float x) Returns the arc hyperbolic sine of 𝑥 .               | ✓                   | ✓                     |
-| float atanf(float x) Returns the arc tangent of 𝑥 .                        | ✓                   | ✓                     |
-
-continues on next page
-
-|                                                                                                                        | Table   | 1 - continued from previous page   |
-|------------------------------------------------------------------------------------------------------------------------|---------|------------------------------------|
-| float atan2f(float x, float y) Returns the arc tangent of the ratio of 𝑥 and 𝑦 .                                       | ✓       | ✓                                  |
-| float atanhf(float x) Returns the arc hyperbolic tangent of 𝑥 .                                                        | ✓       | ✓                                  |
-| float cbrtf(float x) Returns the cube root of 𝑥 .                                                                      | ✓       | ✓                                  |
-| float ceilf(float x) Returns ceiling of 𝑥 .                                                                            | ✓       | ✓                                  |
-| float copysignf(float x, float y) Create value with given magnitude, copying sign of second value.                     | ✓       | ✓                                  |
-| float cosf(float x) Returns the cosine of 𝑥 .                                                                          | ✓       | ✓                                  |
-| float coshf(float x) Returns the hyperbolic cosine of 𝑥 .                                                              | ✓       | ✓                                  |
-| float cospif(float x) Returns the cosine of 𝜋 · 𝑥 .                                                                    | ✓       | ✓                                  |
-| float cyl_bessel_i0f(float x) Returns the value of the regular modified cylindrical Bessel function of order 0 for 𝑥 . |         |                                    |
-
-continues on next page
-
-Table 1 - continued from previous page
-
-| float cyl_bessel_i1f(float x) Returns the value of the regular modified cylindrical Bessel function of order 1 for 𝑥 .   |    |    |
-|--------------------------------------------------------------------------------------------------------------------------|----|----|
-| float erff(float x) Returns the error function of 𝑥 .                                                                    | ✓  | ✓  |
-| float erfcf(float x) Returns the complementary error function of 𝑥 .                                                     | ✓  | ✓  |
-| float erfcinvf(float x) Returns the inverse complementary function of 𝑥 .                                                | ✓  | ✓  |
-| float erfcxf(float x) Returns the scaled complementary error function of 𝑥 .                                             | ✓  | ✓  |
-| float erfinvf(float x) Returns the inverse error function of 𝑥 .                                                         | ✓  | ✓  |
-| float expf(float x) Returns 𝑒 𝑥 .                                                                                        | ✓  | ✓  |
-| float exp10f(float x) Returns 10 𝑥 .                                                                                     | ✓  | ✓  |
-| float exp2f( float x) Returns 2 𝑥 .                                                                                      | ✓  | ✓  |
-| float expm1f(float x) Returns 𝑙𝑛 ( 𝑥 - 1)                                                                                | ✓  | ✓  |
-
-continues on next page
-
-Table
-
-1 - continued from previous page
-
-| float fabsf(float x) Returns the absolute value of x                               | ✓   | ✓   |
-|------------------------------------------------------------------------------------|-----|-----|
-| float fdimf(float x, float y) Returns the positive difference between 𝑥 and 𝑦 .    | ✓   | ✓   |
-| float fdividef(float x, float y) Divide two floating point values.                 | ✓   | ✓   |
-| float floorf(float x) Returns the largest integer less than or equal to 𝑥 .        | ✓   | ✓   |
-| float fmaf(float x, float y, float z) Returns 𝑥 · 𝑦 + 𝑧 as a single operation.     | ✓   | ✓   |
-| float fmaxf(float x, float y) Determine the maximum numeric value of 𝑥 and 𝑦 .     | ✓   | ✓   |
-| float fminf(float x, float y) Determine the minimum numeric value of 𝑥 and 𝑦 .     | ✓   | ✓   |
-| float fmodf(float x, float y) Returns the floating-point remainder of 𝑥/𝑦 .        | ✓   | ✓   |
-| float modff(float x, float* iptr) Break down 𝑥 into fractional and integral parts. | ✓   |     |
-
-continues on next page
-
-Table 1 - continued from previous page
-
-| float frexpf(float x, int* nptr) Extract mantissa and exponent of 𝑥 .                                   | ✓   |
-|---------------------------------------------------------------------------------------------------------|-----|
-| float hypotf(float x, float y) Returns the square root of the sum of squares of 𝑥 and 𝑦 .               | ✓   |
-| int ilogbf(float x) Returns the unbiased integer exponent of 𝑥 .                                        | ✓   |
-| bool isfinite(float x) Determine whether 𝑥 is finite.                                                   | ✓   |
-| bool isinf(float x) Determine whether 𝑥 is infinite.                                                    | ✓   |
-| bool isnan(float x) Determine whether 𝑥 is a NAN .                                                      | ✓   |
-| float j0f(float x) Returns the value of the Bessel function of the first kind of order 0 for 𝑥 .        | ✓   |
-| float j1f(float x) Returns the value of the Bessel function of the first kind of order 1 for 𝑥 .        | ✓   |
-| float jnf(int n, float x) Returns the value of the Bessel function of the first kind of order n for 𝑥 . | ✓   |
-
-continues on next page
-
-Table
-
-1 - continued from previous page
-
-| float ldexpf(float x, int exp) Returns the natural logarithm of the absolute value of the gamma function of 𝑥 .   | ✓   | ✓   |
-|-------------------------------------------------------------------------------------------------------------------|-----|-----|
-| float lgammaf(float x) Returns the natural logarithm of the absolute value of the gamma function of 𝑥 .           | ✓   |     |
-| long int lrintf(float x) Round 𝑥 to nearest integer value.                                                        | ✓   | ✓   |
-| long long int llrintf(float x) Round 𝑥 to nearest integer value.                                                  | ✓   | ✓   |
-| long int lroundf(float x) Round to nearest integer value.                                                         | ✓   | ✓   |
-| long long int llroundf(float x) Round to nearest integer value.                                                   | ✓   | ✓   |
-| float log10f(float x) Returns the base 10 logarithm of 𝑥 .                                                        | ✓   | ✓   |
-| float log1pf(float x) Returns the natural logarithm of 𝑥 +1 .                                                     | ✓   | ✓   |
-| float log2f(float x) Returns the base 2 logarithm of 𝑥 .                                                          | ✓   | ✓   |
-| float logf(float x) Returns the natural logarithm of 𝑥 .                                                          | ✓   | ✓   |
-
-continues on next page
-
-Table 1 - continued from previous page
-
-|                                                                                                                      |    | ✓   |
-|----------------------------------------------------------------------------------------------------------------------|----|-----|
-| float logbf(float x) Returns the floating point representation of the exponent of 𝑥 .                                | ✓  |     |
-| float nanf(const char* tagp) Returns 'Not a Number' value.                                                           |    | ✓   |
-| float nearbyintf(float x) Round 𝑥 to the nearest integer.                                                            | ✓  | ✓   |
-| float nextafterf(float x, float y) Returns next representable single-precision floating-point value after argument.  | ✓  |     |
-| float norm3df(float x, float y, float z) Returns the square root of the sum of squares of 𝑥 , 𝑦 and 𝑧 .              | ✓  | ✓   |
-| float norm4df(float x, float y, float z, float w) Returns the square root of the sum of squares of 𝑥 , 𝑦 , 𝑧 and 𝑤 . | ✓  | ✓   |
-| float normcdff(float y) Returns the standard normal cumulative distribution function.                                | ✓  | ✓   |
-| float normcdfinvf(float y) Returns the inverse of the standard normal cumulative distribution function.              | ✓  | ✓   |
-| float normf(int dim, const float *a) Returns the square root of the sum of squares of any number of coordinates.     | ✓  | ✓   |
-
-continues on next page
-
-|                                                                                                                   | Table   | 1 - continued from previous page   |
-|-------------------------------------------------------------------------------------------------------------------|---------|------------------------------------|
-| float powf(float x, float y) Returns 𝑥 𝑦 .                                                                        | ✓       | ✓                                  |
-| float powif(float base, int iexp) Returns the value of first argument to the power of second argument.            | ✓       | ✓                                  |
-| float remainderf(float x, float y) Returns single-precision floating-point remainder.                             | ✓       | ✓                                  |
-| float remquof(float x, float y, int* quo) Returns single-precision floating-point remainder and part of quotient. | ✓       | ✓                                  |
-| float roundf(float x) Round to nearest integer value in floating-point.                                           | ✓       | ✓                                  |
-| float rcbrtf(float x) Returns the reciprocal cube root function.                                                  | ✓       | ✓                                  |
-| float rhypotf(float x, float y) Returns one over the square root of the sum of squares of two arguments.          | ✓       | ✓                                  |
-| float rintf(float x) Round input to nearest integer value in floating-point.                                      | ✓       | ✓                                  |
-
-continues on next page
-
-Table
-
-1 - continued from previous page
-
-| float rnorm3df(float x, float y, float z) Returns one over the square root of the sum of squares of three coordinates of the argument.         | ✓   | ✓   |
-|------------------------------------------------------------------------------------------------------------------------------------------------|-----|-----|
-| float rnorm4df(float x, float y, float z, float w) Returns one over the square root of the sum of squares of four coordinates of the argument. | ✓   | ✓   |
-| float rnormf(int dim, const float *a) Returns the reciprocal of square root of the sum of squares of any number of coordinates.                | ✓   | ✓   |
-| float scalblnf(float x, long int n) Scale 𝑥 by 2 𝑛 .                                                                                           | ✓   | ✓   |
-| float scalbnf(float x, int n) Scale 𝑥 by 2 𝑛 .                                                                                                 | ✓   | ✓   |
-| bool signbit(float x) Return the sign bit of 𝑥 .                                                                                               | ✓   | ✓   |
-| float sinf(float x) Returns the sine of 𝑥 .                                                                                                    | ✓   | ✓   |
-| float sinhf(float x) Returns the hyperbolic sine of 𝑥 .                                                                                        | ✓   | ✓   |
-| float sinpif(float x) Returns the hyperbolic sine of 𝜋 · 𝑥 .                                                                                   | ✓   | ✓   |
-
-continues on next page
-
-Table
-
-1 - continued from previous page
-
-| void sincosf(float x, float *sptr, float *cptr) Returns the sine and cosine of 𝑥 .                | ✓   | ✓   |
-|---------------------------------------------------------------------------------------------------|-----|-----|
-| void sincospif(float x, float *sptr, float *cptr) Returns the sine and cosine of 𝜋 · 𝑥 .          | ✓   | ✓   |
-| float sqrtf(float x) Returns the square root of 𝑥 .                                               | ✓   | ✓   |
-| float rsqrtf(float x) Returns the reciprocal of the square root of 𝑥 .                            |     | ✓   |
-| float tanf(float x) Returns the tangent of 𝑥 .                                                    | ✓   | ✓   |
-| float tanhf(float x) Returns the hyperbolic tangent of 𝑥 .                                        | ✓   | ✓   |
-| float tgammaf(float x) Returns the gamma function of 𝑥 .                                          | ✓   | ✓   |
-| float truncf(float x) Truncate 𝑥 to the integral part.                                            | ✓   | ✓   |
-| float y0f(float x) Returns the value of the Bessel function of the second kind of order 0 for 𝑥 . | ✓   | ✓   |
-| float y1f(float x) Returns the value of the Bessel function of the second kind of order 1 for 𝑥 . | ✓   | ✓   |
-
-continues on next page
-**Following code does:** It seems like there is a placeholder or an error in your request, as the code snippet is missing. Please provide the actual code snippet you would like me to analyze, and I'll be happy to help!
-
-
-```
-                                                                                                                                                                                                        \
-    float  ynf(int  n,  float  x)
-    Returns the value of the Bessel
-    function of the second kind of order
-    n for x.
-```
-
-Table 1 - continued from previous page
-
-## 21.2 Double precision mathematical functions
-
-Following is the list of supported double precision mathematical functions.
-
-Table 2: Double precision mathematical functions
-
-| Function                                                                           | Supported on Host   | Supported on Device   |
-|------------------------------------------------------------------------------------|---------------------|-----------------------|
-| double abs(double x) Returns the absolute value of 𝑥                               | ✓                   | ✓                     |
-| double acos(double x) Returns the arc cosine of 𝑥 .                                | ✓                   | ✓                     |
-| double acosh(double x) Returns the nonnegative arc hyperbolic cosine of 𝑥 .        | ✓                   | ✓                     |
-| double asin(double x) Returns the arc sine of 𝑥 .                                  | ✓                   | ✓                     |
-| double asinh(double x) Returns the arc hyperbolic sine of 𝑥 .                      | ✓                   | ✓                     |
-| double atan(double x) Returns the arc tangent of 𝑥 .                               | ✓                   | ✓                     |
-| double atan2(double x, double y) Returns the arc tangent of the ratio of 𝑥 and 𝑦 . | ✓                   | ✓                     |
-
-continues on next page
-
-Table 2 - continued from previous page
-
-| double atanh(double x) Returns the arc hyperbolic tangent of 𝑥 .                                                        | ✓   | ✓   |
-|-------------------------------------------------------------------------------------------------------------------------|-----|-----|
-| double cbrt(double x) Returns the cube root of 𝑥 .                                                                      | ✓   | ✓   |
-| double ceil(double x) Returns ceiling of 𝑥 .                                                                            | ✓   | ✓   |
-| double copysign(double x, double y) Create value with given magnitude, copying sign of second value.                    | ✓   | ✓   |
-| double cos(double x) Returns the cosine of 𝑥 .                                                                          | ✓   | ✓   |
-| double cosh(double x) Returns the hyperbolic cosine of 𝑥 .                                                              | ✓   | ✓   |
-| double cospi(double x) Returns the cosine of 𝜋 · 𝑥 .                                                                    | ✓   | ✓   |
-| double cyl_bessel_i0(double x) Returns the value of the regular modified cylindrical Bessel function of order 0 for 𝑥 . |     |     |
-| double cyl_bessel_i1(double x) Returns the value of the regular modified cylindrical Bessel function of order 1 for     | 𝑥 . |     |
-| double erf(double x) Returns the error function of 𝑥 .                                                                  | ✓   | ✓   |
-
-continues on next page
-
-Table 2 - continued from previous page
-
-| double erfc(double x) Returns the complementary error function of 𝑥 .             | ✓   | ✓   |
-|-----------------------------------------------------------------------------------|-----|-----|
-| double erfcinv(double x) Returns the inverse complementary function of 𝑥 .        | ✓   | ✓   |
-| double erfcx(double x) Returns the scaled complementary error function of 𝑥 .     | ✓   | ✓   |
-| double erfinv(double x) Returns the inverse error function of 𝑥 .                 | ✓   | ✓   |
-| double exp(double x) Returns 𝑒 𝑥 .                                                | ✓   | ✓   |
-| double exp10(double x) Returns 10 𝑥 .                                             | ✓   | ✓   |
-| double exp2( double x) Returns 2 𝑥 .                                              | ✓   | ✓   |
-| double expm1(double x) Returns 𝑙𝑛 ( 𝑥 - 1)                                        | ✓   | ✓   |
-| double fabs(double x) Returns the absolute value of x                             | ✓   | ✓   |
-| double fdim(double x, double y) Returns the positive difference between 𝑥 and 𝑦 . | ✓   | ✓   |
-
-continues on next page
-
-Table 2 - continued from previous page
-
-| double floor(double x) Returns the largest integer less than or equal to 𝑥 .                | ✓   | ✓   |
-|---------------------------------------------------------------------------------------------|-----|-----|
-| double fma(double x, double y, double z) Returns 𝑥 · 𝑦 + 𝑧 as a single operation.           | ✓   | ✓   |
-| double fmax(double x, double y) Determine the maximum numeric value of 𝑥 and 𝑦 .            | ✓   | ✓   |
-| double fmin(double x, double y) Determine the minimum numeric value of 𝑥 and 𝑦 .            | ✓   | ✓   |
-| double fmod(double x, double y) Returns the floating-point remainder of 𝑥/𝑦 .               | ✓   | ✓   |
-| double modf(double x, double* iptr) Break down 𝑥 into fractional and integral parts.        | ✓   |     |
-| double frexp(double x, int* nptr) Extract mantissa and exponent of 𝑥 .                      | ✓   |     |
-| double hypot(double x, double y) Returns the square root of the sum of squares of 𝑥 and 𝑦 . | ✓   | ✓   |
-| int ilogb(double x) Returns the unbiased integer exponent of 𝑥 .                            | ✓   | ✓   |
-
-continues on next page
-
-Table 2 - continued from previous page
-
-| bool isfinite(double x) Determine whether 𝑥 is finite.                                                           | ✓   | ✓   |
-|------------------------------------------------------------------------------------------------------------------|-----|-----|
-| bool isin(double x) Determine whether 𝑥 is infinite.                                                             | ✓   | ✓   |
-| bool isnan(double x) Determine whether 𝑥 is a NAN .                                                              | ✓   | ✓   |
-| double j0(double x) Returns the value of the Bessel function of the first kind of order 0 for 𝑥 .                | ✓   | ✓   |
-| double j1(double x) Returns the value of the Bessel function of the first kind of order 1 for 𝑥 .                | ✓   | ✓   |
-| double jn(int n, double x) Returns the value of the Bessel function of the first kind of order n for 𝑥 .         | ✓   | ✓   |
-| double ldexp(double x, int exp) Returns the natural logarithm of the absolute value of the gamma function of 𝑥 . | ✓   | ✓   |
-| double lgamma(double x) Returns the natural logarithm of the absolute value of the gamma function of 𝑥 .         | ✓   |     |
-| long int lrint(double x) Round 𝑥 to nearest integer value.                                                       | ✓   | ✓   |
-
-continues on next page
-
-Table 2 - continued from previous page
-
-| long long int llrint(double x) Round 𝑥 to nearest integer value.                       | ✓   | ✓   |
-|----------------------------------------------------------------------------------------|-----|-----|
-| long int lround(double x) Round to nearest integer value.                              | ✓   | ✓   |
-| long long int llround(double x) Round to nearest integer value.                        | ✓   | ✓   |
-| double log10(double x) Returns the base 10 logarithm of 𝑥 .                            | ✓   | ✓   |
-| double log1p(double x) Returns the natural logarithm of 𝑥 +1 .                         | ✓   | ✓   |
-| double log2(double x) Returns the base 2 logarithm of 𝑥 .                              | ✓   | ✓   |
-| double log(double x) Returns the natural logarithm of 𝑥 .                              | ✓   | ✓   |
-| double logb(double x) Returns the floating point representation of the exponent of 𝑥 . | ✓   | ✓   |
-| double nan(const char* tagp) Returns 'Not a Number' value.                             |     | ✓   |
-| double nearbyint(double x) Round 𝑥 to the nearest integer.                             | ✓   | ✓   |
-
-continues on next page
-
-Table 2 - continued from previous page
-
-|                                                                                                                          |    | ✓   |
-|--------------------------------------------------------------------------------------------------------------------------|----|-----|
-| double nextafter(double x, double y) Returns next representable double-precision floating-point value after argument.    | ✓  |     |
-| double norm3d(double x, double y, double z) Returns the square root of the sum of squares of 𝑥 , 𝑦 and 𝑧 .               | ✓  | ✓   |
-| double norm4d(double x, double y, double z, double w) Returns the square root of the sum of squares of 𝑥 , 𝑦 , 𝑧 and 𝑤 . | ✓  | ✓   |
-| double normcdf(double y) Returns the standard normal cumulative distribution function.                                   | ✓  | ✓   |
-| double normcdfinv(double y) Returns the inverse of the standard normal cumulative distribution function.                 | ✓  | ✓   |
-| double norm(int dim, const double *a) Returns the square root of the sum of squares of any number of coordinates.        | ✓  | ✓   |
-| double pow(double x, double y) Returns 𝑥 𝑦 .                                                                             | ✓  | ✓   |
-| double powi(double base, int iexp) Returns the value of first argument to the power of second argument.                  | ✓  | ✓   |
-
-continues on next page
-
-|                                                                                                                                                    | Table   | 2 - continued from previous page   |
-|----------------------------------------------------------------------------------------------------------------------------------------------------|---------|------------------------------------|
-| double remainder(double x, double y) Returns double-precision floating-point remainder.                                                            | ✓       | ✓                                  |
-| double remquo(double x, double y, int* quo) Returns double-precision floating-point remainder and part quotient.                                   | ✓       | of                                 |
-| double round(double x) Round to nearest integer value in floating-point.                                                                           | ✓       | ✓                                  |
-| double rcbrt(double x) Returns the reciprocal cube root function.                                                                                  | ✓       | ✓                                  |
-| double rhypot(double x, double y) Returns one over the square root of the sum of squares of two arguments.                                         | ✓       | ✓                                  |
-| double rint(double x) Round input to nearest integer value in floating-point.                                                                      | ✓       | ✓                                  |
-| double rnorm3d(double x, double y, double z) Returns one over the square root of the sum of squares of three coordinates of the argument.          | ✓       | ✓                                  |
-| double rnorm4d(double x, double y, double z, double w) Returns one over the square root of the sum of squares of four coordinates of the argument. | ✓       | ✓                                  |
-
-continues on next page
-
-Table 2 - continued from previous page
-
-|                                                                                                                                  | ✓   |    |
-|----------------------------------------------------------------------------------------------------------------------------------|-----|----|
-| double rnorm(int dim, const double *a) Returns the reciprocal of square root of the sum of squares of any number of coordinates. |     | ✓  |
-| double scalbln(double x, long int n) Scale 𝑥 by 2 𝑛 .                                                                            | ✓   | ✓  |
-| double scalbn(double x, int n) Scale 𝑥 by 2 𝑛 .                                                                                  | ✓   | ✓  |
-| bool signbit(double x) Return the sign bit of 𝑥 .                                                                                | ✓   | ✓  |
-| double sin(double x) Returns the sine of 𝑥 .                                                                                     | ✓   | ✓  |
-| double sinh(double x) Returns the hyperbolic sine of 𝑥 .                                                                         | ✓   | ✓  |
-| double sinpi(double x) Returns the hyperbolic sine of 𝜋 · 𝑥 .                                                                    | ✓   | ✓  |
-| void sincos(double x, double *sptr, double *cptr) Returns the sine and cosine of 𝑥 .                                             | ✓   | ✓  |
-| void sincospi(double x, double *sptr, double *cptr) Returns the sine and cosine of 𝜋 · 𝑥 .                                       | ✓   | ✓  |
-| double sqrt(double x) Returns the square root of 𝑥 .                                                                             | ✓   | ✓  |
-
-continues on next page
-
-Table 2 - continued from previous page
-
-| double rsqrt(double x) Returns the reciprocal of the square root of 𝑥 .                                   | ✓   |
-|-----------------------------------------------------------------------------------------------------------|-----|
-| double tan(double x) Returns the tangent of 𝑥 .                                                           | ✓   |
-| double tanh(double x) Returns the hyperbolic tangent of 𝑥 .                                               | ✓   |
-| double tgamma(double x) Returns the gamma function of 𝑥 .                                                 | ✓   |
-| double trunc(double x) Truncate 𝑥 to the integral part.                                                   | ✓   |
-| double y0(double x) Returns the value of the Bessel function of the second kind of order 0 for 𝑥 .        | ✓   |
-| double y1(double x) Returns the value of the Bessel function of the second kind of order 1 for 𝑥 .        | ✓   |
-| double yn(int n, double x) Returns the value of the Bessel function of the second kind of order n for 𝑥 . | ✓   |
-
-## 21.3 Integer intrinsics
-
-Following is the list of supported integer intrinsics. Note that intrinsics are supported on device only.
-
-Table 3: Integer intrinsics mathematical functions
-
-## Function
-
-unsigned int \_\_brev(unsigned int x) Reverse the bit order of a 32 bit unsigned integer.
-
-unsigned long long int \_\_brevll(unsigned long long int x) Reverse the bit order of a 64 bit unsigned integer.
-
-unsigned int \_\_byte\_perm(unsigned int x, unsigned int y, unsigned int z) Return selected bytes from two 32-bit unsigned integers.
-
-unsigned int \_\_clz(int x) Return the number of consecutive high-order zero bits in 32 bit integer.
-
-unsigned int \_\_clzll(long long int x) Return the number of consecutive high-order zero bits in 64 bit integer.
-
-unsigned int \_\_ffs(int x) Find the position of least significant bit set to 1 in a 32 bit integer.
-
-unsigned int \_\_ffsll(long long int x) Find the position of least significant bit set to 1 in a 64 bit signed integer.
-
-unsigned int \_\_fns32(unsigned long long mask, unsigned int base, int offset) Find the position of the n-th set to 1 bit in a 32-bit integer.
-
-unsigned int \_\_fns64(unsigned long long int mask, unsigned int base, int offset) Find the position of the n-th set to 1 bit in a 64-bit integer.
-
-unsigned int \_\_funnelshift\_l(unsigned int lo, unsigned int hi, unsigned int shift) Concatenate ℎ𝑖 and 𝑙𝑜 , shift left by shift &amp; 31 bits, return the most significant 32 bits.
-
-unsigned int \_\_funnelshift\_lc(unsigned int lo, unsigned int hi, unsigned int shift) Concatenate ℎ𝑖 and 𝑙𝑜 , shift left by min(shift, 32) bits, return the most significant 32 bits.
-
-unsigned int \_\_funnelshift\_r(unsigned int lo, unsigned int hi, unsigned int shift) Concatenate ℎ𝑖 and 𝑙𝑜 , shift right by shift &amp; 31 bits, return the least significant 32 bits. 226 Chapter 21. HIP math API
-
-The HIP-Clang implementation of \_\_ffs() and \_\_ffsll() contains code to add a constant +1 to produce the ffs result format. For the cases where this overhead is not acceptable and programmer is willing to specialize for the platform, HIP-Clang provides \_\_lastbit\_u32\_u32(unsigned int input) and \_\_lastbit\_u32\_u64(unsigned long long int input) . The index returned by \_\_lastbit\_ instructions starts at -1, while for ffs the index starts at 0.
-
-## 21.4 Floating-point Intrinsics
-
-Following is the list of supported floating-point intrinsics. Note that intrinsics are supported on device only.
-
-Note: Only the nearest even rounding mode supported on AMD GPUs by defaults. The \_rz , \_ru and \_rd suffixed intrinsic functions are existing in HIP AMD backend, if the OCML\_BASIC\_ROUNDED\_OPERATIONS macro is defined.
-
-Table 4: Single precision intrinsics mathematical functions
-
-Function float \_\_cosf(float x) Returns the fast approximate cosine of 𝑥 . float \_\_exp10f(float x) Returns the fast approximate for 10 x . float \_\_expf(float x) Returns the fast approximate for e x . float \_\_fadd\_rn(float x, float y) Add two floating-point values in round-to-nearest-even mode. float \_\_fdiv\_rn(float x, float y) Divide two floating point values in round-to-nearest-even mode. float \_\_fmaf\_rn(float x, float y, float z) Returns x × y + z as a single operation in round-to-nearest-even mode. float \_\_fmul\_rn(float x, float y) Multiply two floating-point values in round-to-nearest-even mode. float \_\_frcp\_rn(float x, float y) Returns 1 / x in round-to-nearest-even mode. float \_\_frsqrt\_rn(float x) Returns 1 / x in round-to-nearest-even mode. float \_\_fsqrt\_rn(float x) Returns x in round-to-nearest-even mode. float \_\_fsub\_rn(float x, float y) Subtract two floating-point values in round-to-nearest-even mode. float \_\_log10f(float x) Returns the fast approximate for base 10 logarithm of 𝑥 . 228 Chapter 21. HIP math API
-
-Table 5: Double precision intrinsics mathematical functions
-
-Function double \_\_dadd\_rn(double x, double y) Add two floating-point values in round-to-nearest-even mode. double \_\_ddiv\_rn(double x, double y) Divide two floating-point values in round-to-nearest-even mode. double \_\_dmul\_rn(double x, double y) Multiply two floating-point values in round-to-nearest-even mode. double \_\_drcp\_rn(double x, double y) Returns 1 / x in round-to-nearest-even mode. double \_\_dsqrt\_rn(double x) Returns x in round-to-nearest-even mode. double \_\_dsub\_rn(double x, double y) Subtract two floating-point values in round-to-nearest-even mode. double \_\_fma\_rn(double x, double y, double z) Returns x × y + z as a single operation in round-to-nearest-even mode.
-
-## CHAPTER
-
-## TWENTYTWO
-
-## TABLE COMPARING SYNTAX FOR DIFFERENT COMPUTE APIS
-
-| Term                   | CUDA                | HIP                                        | OpenCL                 |
-|------------------------|---------------------|--------------------------------------------|------------------------|
-| Device                 | int deviceId        | int deviceId                               | cl_device              |
-| Queue                  | cudaStream_t        | hipStream_t                                | cl_command_queue       |
-| Event                  | cudaEvent_t         | hipEvent_t                                 | cl_event               |
-| Memory                 | void *              | void *                                     | cl_mem                 |
-|                        | grid                | grid                                       | NDRange                |
-|                        | block               | block                                      | work-group             |
-|                        | thread              | thread                                     | work-item              |
-|                        | warp                | warp                                       | sub-group              |
-| Thread-index           | threadIdx.x         | threadIdx.x                                | get_local_id(0)        |
-| Block-index            | blockIdx.x          | blockIdx.x                                 | get_group_id(0)        |
-| Block-dim              | blockDim.x          | blockDim.x                                 | get_local_size(0)      |
-| Grid-dim               | gridDim.x           | gridDim.x                                  | get_num_groups(0)      |
-| Device Kernel          | __global__          | __global__                                 | __kernel               |
-| Device Function        | __device__          | __device__                                 | Implied in device com  |
-| Host Function          | __host_ (default)   | __host_ (default)                          | Implied in host compil |
-| Host + Device Function | __host__ __device__ | __host__ __device__                        | No equivalent          |
-| Kernel Launch          | <<< >>>             | hipLaunchKernel / hipLaunchKernelGGL / <<< | clEnqueueNDRangeK      |
-| Global Memory          | __global__          | __global__                                 | __global               |
-| Group Memory           | __shared__          | __shared__                                 | __local                |
-| Constant               | __constant__        | __constant__                               | __constant             |
-|                        | __syncthreads       | __syncthreads                              | barrier(CLK_LOCAL      |
-| Atomic Builtins        | atomicAdd           | atomicAdd                                  | atomic_add             |
-| Precise Math           | cos(f)              | cos(f)                                     | cos(f)                 |
-| Fast Math              | __cos(f)            | __cos(f)                                   | native_cos(f)          |
-| Vector                 | float4              | float4                                     | float4                 |
-
-## 22.1 Notes
-
-The indexing functions (starting with thread-index ) show the terminology for a 1D grid. Some APIs use reverse order of xyz / 012 indexing for 3D grids.
-
-## CHAPTER
-
-## TWENTYTHREE
-
-## HIP COOPERATIVE GROUPS API
-
-## 23.1 Cooperative kernel launches
-
-The following host-side functions are used for cooperative kernel launches.
-
-| Warning:                                                                                    | Warning:                                                                                    | doxygenfunction:                                                                            | doxygenfunction:                                                                            | doxygenfunction:                                                                            | Cannot                                                                                      | find function                                                                               | 'hipLaunchCooperativeKernel' Documentation'                                                 | 'hipLaunchCooperativeKernel' Documentation'                                                 |                                                                                             |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
-| in                                                                                          | doxygen                                                                                     | xml                                                                                         | output                                                                                      | for project                                                                                 | 'HIP                                                                                        | 6.1.40092                                                                                   | from                                                                                        | directory:                                                                                  |                                                                                             |
-| /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- |
-| 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      |
-
-| Warning:                                                                                    | Warning:                                                                                    | doxygenfunction: project                                                                    | doxygenfunction: project                                                                    | doxygenfunction: project                                                                    | Cannot                                                                                      | Cannot                                                                                      | find function                                                                               | 'hipLaunchCooperativeKernel'                                                                | 'hipLaunchCooperativeKernel'                                                                |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
-| in                                                                                          | doxygen                                                                                     | xml                                                                                         | output                                                                                      | for                                                                                         |                                                                                             | 'HIP                                                                                        | 6.1.40092                                                                                   | Documentation'                                                                              | from                                                                                        |
-| /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- |
-| 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      |
-
-| Warning:                                                                                    | Warning:                                                                                    | doxygenfunction:                                                                            | doxygenfunction:                                                                            | doxygenfunction:                                                                            | Cannot                                                                                      | find                                                                                        | function                                                                                    | 'hipLaunchCooperativeKernelMultiDe-                                                         | 'hipLaunchCooperativeKernelMultiDe-                                                         | 'hipLaunchCooperativeKernelMultiDe-                                                         |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
-| vice'                                                                                       | in                                                                                          | doxygen                                                                                     | xml                                                                                         | output for                                                                                  | project                                                                                     | 'HIP                                                                                        | 6.1.40092                                                                                   | Documentation'                                                                              | from                                                                                        | directory:                                                                                  |
-| /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- |
-| 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      |
-
-| Warning: in                                                                                 | doxygenfunction: Cannot find xml output for project 'HIP                                    | doxygenfunction: Cannot find xml output for project 'HIP                                    |                                                                                             |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
-| nel'                                                                                        | function 6.1.40092                                                                          | 'hipModuleLaunchCooperativeKer- Documentation' from directory:                              |                                                                                             |
-| /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- |
-| 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      |
-
-Warning: doxygenfunction: Cannot find function 'hipModuleLaunchCooperativeKernelMultiDevice' in doxygen xml output for project 'HIP 6.1.40092 Documentation' from directory: /home/docs/checkouts/readthedocs.org/user\_builds/advanced-micro-devices-hip/checkouts/docs6.1.2/docs/doxygen/xml
-
-## 23.2 Cooperative groups classes
-
-The following cooperative groups classes can be used on the device side.
-
-## class thread\_group
-
-The base type of all cooperative group types.
-
-Holds the key properties of a constructed cooperative group types object, like the group type, its size, etc.
-
-Note: Cooperative groups feature is implemented on Linux, under development on Microsoft Windows.
-
-Subclassed by cooperative\_groups::coalesced\_group , cooperative\_groups::grid\_group , coopera-tive\_groups::multi\_grid\_group , cooperative\_groups::thread\_block , cooperative\_groups::tiled\_group class thread\_block : public cooperative\_groups:: thread\_group
-
-The workgroup (thread-block in CUDA terminology) cooperative group type.
-
-Represents an intra-workgroup cooperative group type, where the participating threads within the group are the same threads that participated in the currently executing workgroup .
-
-Note: This function is implemented on Linux and is under development on Microsoft Windows.
-
-class grid\_group : public cooperative\_groups:: thread\_group
-
-The grid cooperative group type.
-
-Represents an inter-workgroup cooperative group type, where the participating threads within the group spans across multiple workgroups running the (same) kernel on the same device.
-
-Note: This is implemented on Linux and is under development on Microsoft Windows.
-
-class multi\_grid\_group : public cooperative\_groups:: thread\_group
-
-The multi-grid cooperative group type.
-
-Represents an inter-device cooperative group type, where the participating threads within the group span across multiple devices, running the (same) kernel on these devices.
-
-Note: The multi-grid cooperative group type is implemented on Linux, under development on Microsoft Windows.
-
-## template&lt;unsigned int size , class ParentCGTy &gt;
-
-class thread\_block\_tile : public cooperative\_groups::impl::thread\_block\_tile\_internal&lt; size , ParentCGTy &gt; Group type -thread\_block\_tile .
-
-Represents one tiled thread group in a wavefront. This group type also supports sub-wave level intrinsics.
-
-Note: This type is implemented on Linux, under development on Microsoft Windows.
-
-## Public Functions
-
-unsigned int thread\_rank () const
-
-Rank of the calling thread within [0, size() ).
-
-## void sync ()
-
-Synchronizes the threads in the group.
-
-Causes all threads in the group to wait at this synchronization point, and for all shared and global memory accesses by the threads to complete, before running synchronization. This guarantees the visibility of accessed data for all threads in the group.
-
-Note: There are potential read-after-write (RAW), write-after-read (WAR), or write-after-write (WAW) hazards, when threads in the group access the same addresses in shared or global memory. The data hazards can be avoided with synchronization of the group.
-
-## unsigned int meta\_group\_rank () const
-
-Returns the linear rank of the group within the set of tiles partitioned from a parent group (bounded by meta\_group\_size)
-
-unsigned int meta\_group\_size () const
-
-Returns the number of groups created when the parent group was partitioned.
-
-## template&lt;class T &gt;
-
-T shfl ( T var, int srcRank ) const
-
-Shuffle operation on group level.
-
-Exchanging variables between threads without use of shared memory. Shuffle operation is a direct copy of var from srcRank thread ID of group.
-
-## Template Parameters
-
-T - The type can be a 32-bit integer or single-precision floating point.
-
-## Parameters
-
-- var - [in] The source variable to copy. Only the srcRank thread ID of group is copied to other threads.
-- srcRank - [in] The source thread ID of the group for copy.
-
-## template&lt;class T &gt;
-
-T shfl\_down ( T var, unsigned int lane\_delta ) const
-
-Shuffle down operation on group level.
-
-Exchanging variables between threads without use of shared memory. Shuffle down operation is copy of var from thread with thread ID of group relative higher with lane\_delta to caller thread ID.
-
-## Template Parameters
-
-T - The type can be a 32-bit integer or single-precision floating point.
-
-## Parameters
-
-- var - [in] The source variable to copy.
-- lane\_delta - [in] The lane\_delta is the relative thread ID difference between caller thread ID and source of copy thread ID. sourceID = (threadID + lane\_delta) % size()
-
-template&lt;class T &gt;
-
-## T shfl\_up ( T var, unsigned int lane\_delta ) const
-
-Shuffle up operation on group level.
-
-Exchanging variables between threads without use of shared memory. Shuffle up operation is copy of var from thread with thread ID of group relative lower with lane\_delta to caller thread ID.
-
-## Template Parameters
-
-T - The type can be a 32-bit integer or single-precision floating point.
-
-## Parameters
-
-- var - [in] The source variable to copy.
-- lane\_delta - [in] The lane\_delta is the relative thread ID difference between caller thread ID and source of copy thread ID. sourceID = (threadID - lane\_delta) % size()
-
-## template&lt;class T &gt;
-
-T shfl\_xor ( T var, unsigned int laneMask ) const
-
-Shuffle xor operation on group level.
-
-Exchanging variables between threads without use of shared memory. Shuffle xor operation is copy of var from thread with thread ID of group based on laneMask XOR of the caller thread ID.
-
-## Template Parameters
-
-- T - The type can be a 32-bit integer or single-precision floating point.
-
-## Parameters
-
-- var - [in] The source variable to copy.
-- laneMask - [in] The laneMask is the mask for XOR operation. sourceID = threadID ^ laneMask
-
-unsigned long long ballot ( int pred ) const
-
-Ballot function on group level.
-
-Returns a bit mask with the Nth bit set to one if the Nth thread predicate evaluates true.
-
-## Parameters
-
-pred - [in] The predicate to evaluate on group threads.
-
-int any ( int pred ) const
-
-Any function on group level.
-
-Returns non-zero if a predicate evaluates true for any threads.
-
-## Parameters
-
-pred - [in] The predicate to evaluate on group threads.
-
-int all ( int pred ) const
-
-All function on group level.
-
-Returns non-zero if a predicate evaluates true for all threads.
-
-## Parameters
-
-pred - [in] The predicate to evaluate on group threads.
-
-template&lt;typename T &gt;
-
-unsigned long long match\_any ( T value ) const
-
-Match any function on group level.
-
-Returns a bit mask containing a 1-bit for every participating thread if that thread has the same value in value as the caller thread.
-
-## Parameters
-
-value - [in] The value to examine on the current thread in group.
-
-template&lt;typename T &gt; unsigned long long match\_all ( T value, int &amp;pred ) const
-
-Match all function on group level.
-
-Returns a bit mask containing a 1-bit for every participating thread if they all have the same value in value as the caller thread. The predicate pred is set to true if all participating threads have the same value in value .
-
-## Parameters
-
-- value - [in] The value to examine on the current thread in group.
-- pred - [out] The predicate is set to true if all participating threads in the thread group have the same value.
-
-class coalesced\_group : public cooperative\_groups:: thread\_group
-
-The coalesced\_group cooperative group type.
-
-Represents an active thread group in a wavefront. This group type also supports sub-wave level intrinsics.
-
-Note: This is implemented on Linux and is under development on Microsoft Windows.
-
-## 23.3 Cooperative groups construct functions
-
-The following functions are used to construct different group-type instances on the device side.
-
-| Warning:                                                                                    | Warning:                                                                                    | doxygenfunction:                                                                            | doxygenfunction:                                                                            | doxygenfunction:                                                                            | Cannot find                                                                                 | Cannot find                                                                                 | function                                                                                    | 'cooperative_groups::this_multi_grid'                                                       | 'cooperative_groups::this_multi_grid'                                                       | 'cooperative_groups::this_multi_grid'                                                       |                                                                                             |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
-| in                                                                                          | doxygen                                                                                     | xml                                                                                         | output                                                                                      | for                                                                                         | project                                                                                     | 'HIP                                                                                        | 6.1.40092                                                                                   | Documentation'                                                                              | from                                                                                        | directory:                                                                                  |                                                                                             |
-| /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- |
-| 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      |
-
-Warning: doxygenfunction: Cannot find function 'cooperative\_groups::this\_grid' in doxygen xml output for project 'HIP 6.1.40092 Documentation' from directory: /home/docs/checkouts/readthedocs.org/user\_builds/advanced-micro-devices-hip/checkouts/docs6.1.2/docs/doxygen/xml
-
-Warning: doxygenfunction: Cannot find function 'cooperative\_groups::this\_thread\_block' in doxygen xml output for project 'HIP 6.1.40092 Documentation' from directory: /home/docs/checkouts/readthedocs.org/user\_builds/advanced-micro-devices-hip/checkouts/docs6.1.2/docs/doxygen/xml
-
-| Warning:   | Warning:   | doxygenfunction:   | doxygenfunction:   | doxygenfunction:   | Cannot   | find   | function   | 'cooperative_groups::coalesced_threads'   | 'cooperative_groups::coalesced_threads'   |            |
-|------------|------------|--------------------|--------------------|--------------------|----------|--------|------------|-------------------------------------------|-------------------------------------------|------------|
-| in         | doxygen    | xml                | output             | for                | project  | 'HIP   | 6.1.40092  | Documentation'                            | from                                      | directory: |
-
-/home/docs/checkouts/readthedocs.org/user\_builds/advanced-micro-devices-hip/checkouts/docs6.1.2/docs/doxygen/xml
-
-| Warning:                                                                                    | Warning:                                                                                    | doxygenfunction:                                                                            | doxygenfunction:                                                                            | doxygenfunction:                                                                            | Cannot find                                                                                 | Cannot find                                                                                 | function                                                                                    | 'cooperative_groups::tiled_partition'                                                       | 'cooperative_groups::tiled_partition'                                                       | 'cooperative_groups::tiled_partition'                                                       |                                                                                             |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
-| in                                                                                          | doxygen                                                                                     | xml                                                                                         | output                                                                                      | for                                                                                         | project                                                                                     | 'HIP                                                                                        | 6.1.40092                                                                                   | Documentation'                                                                              | from                                                                                        | directory:                                                                                  |                                                                                             |
-| /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- |
-| 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      |
-
-| Warning:                                                                                    | Warning:                                                                                    | doxygenfunction:                                                                            | doxygenfunction:                                                                            | doxygenfunction:                                                                            | Cannot                                                                                      | find                                                                                        | function 'cooperative_groups::tiled_partition' 6.1.40092                                    | function 'cooperative_groups::tiled_partition' 6.1.40092                                    | function 'cooperative_groups::tiled_partition' 6.1.40092                                    |                                                                                             |                                                                                             |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
-| in                                                                                          | doxygen                                                                                     | xml                                                                                         | output                                                                                      | for                                                                                         | project                                                                                     | 'HIP                                                                                        | Documentation'                                                                              | from                                                                                        | directory:                                                                                  |                                                                                             |                                                                                             |
-| /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- |
-| 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      |
-
-| Warning:                                                                                    | Warning:                                                                                    | doxygenfunction:                                                                            | doxygenfunction:                                                                            | doxygenfunction:                                                                            | Cannot find                                                                                 | Cannot find                                                                                 | function                                                                                    | function                                                                                    | 'cooperative_groups::binary_partition'                                                      | 'cooperative_groups::binary_partition'                                                      |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
-| in                                                                                          | doxygen                                                                                     | xml                                                                                         | output                                                                                      | for                                                                                         | project                                                                                     | 'HIP                                                                                        |                                                                                             | 6.1.40092                                                                                   | Documentation'                                                                              | from                                                                                        |
-| /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- |
-| 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      |
-
-| Warning:                                                                                    | Warning:                                                                                    | doxygenfunction:                                                                            | doxygenfunction:                                                                            | doxygenfunction:                                                                            | Cannot find                                                                                 | Cannot find                                                                                 | function 'cooperative_groups::binary_partition' 6.1.40092                                   | function 'cooperative_groups::binary_partition' 6.1.40092                                   | function 'cooperative_groups::binary_partition' 6.1.40092                                   |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
-| in                                                                                          | doxygen                                                                                     | xml                                                                                         | output                                                                                      | for                                                                                         | project                                                                                     | 'HIP                                                                                        | Documentation'                                                                              | from                                                                                        | directory:                                                                                  |
-| /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- |
-| 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      |
-
-## 23.4 Cooperative groups exposed API functions
-
-The following functions are the exposed API for different group-type instances on the device side.
-
-| Warning:                                                                                    | Warning:                                                                                    | doxygenfunction: project                                                                    | doxygenfunction: project                                                                    | doxygenfunction: project                                                                    | Cannot find                                                                                 | function                                                                                    | 'cooperative_groups::group_size'                                                            | 'cooperative_groups::group_size'                                                            | 'cooperative_groups::group_size'                                                            |                                                                                             |                                                                                             |                                                                                             |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
-| in                                                                                          | doxygen                                                                                     | xml                                                                                         | output                                                                                      | for                                                                                         | 'HIP                                                                                        | 6.1.40092                                                                                   | Documentation'                                                                              | from                                                                                        | directory:                                                                                  |                                                                                             |                                                                                             |                                                                                             |
-| /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- |
-| 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      |
-
-| Warning:                                                                                    | Warning:                                                                                    | doxygenfunction: Cannot                                                                     | doxygenfunction: Cannot                                                                     | doxygenfunction: Cannot                                                                     | doxygenfunction: Cannot                                                                     | find 'HIP                                                                                   | find 'HIP                                                                                   | function 'cooperative_groups::thread_rank'                                                  | function 'cooperative_groups::thread_rank'                                                  | function 'cooperative_groups::thread_rank'                                                  |                                                                                             |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
-| in                                                                                          | doxygen                                                                                     | xml                                                                                         | output                                                                                      | for                                                                                         | project                                                                                     |                                                                                             | 6.1.40092                                                                                   | Documentation'                                                                              | from                                                                                        | directory:                                                                                  |                                                                                             |
-| /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- |
-| 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      |
-
-Warning: doxygenfunction: Cannot find function 'cooperative\_groups::is\_valid' in doxygen xml output for project 'HIP 6.1.40092 Documentation' from directory: /home/docs/checkouts/readthedocs.org/user\_builds/advanced-micro-devices-hip/checkouts/docs6.1.2/docs/doxygen/xml
-
-Warning: doxygenfunction: Cannot find function 'cooperative\_groups::sync' in doxygen xml output for project 'HIP 6.1.40092 Documentation' from directory: /home/docs/checkouts/readthedocs.org/user\_builds/advancedmicro-devices-hip/checkouts/docs-6.1.2/docs/doxygen/xml
-
-## CHAPTER
-
-## TWENTYFOUR
-
-## HSA RUNTIME API FOR ROCM
-
-The following functions are located in the https://github.com/ROCm/ROCR-Runtime repository.
-
-hsa\_status\_t hsa\_amd\_vmem\_address\_reserve ( void **va, size\_t size, uint64\_t address, uint64\_t flags )
-
-Allocate a reserved address range.
-
-Reserve a virtual address range. The size must be a multiple of the system page size. If it is not possible to allocate the address specified by address , then va will be a different address range. Address range should be released by calling hsa\_amd\_vmem\_address\_free.
-
-Note that this API will be deprecated in a future release and replaced by hsa\_amd\_vmem\_address\_reserve\_align
-
-## Parameters
-
-- va -[out] virtual address allocated
-- size -[in] of address range requested
-- address -[in] requested
-- flags -[in] currently unsupported
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS - Address range allocated successfully
-- ::HSA\_STATUS\_ERROR\_NOT\_INITIALIZED - The HSA runtime has not been initialized.
-- ::HSA\_STATUS\_ERROR\_OUT\_OF\_RESOURCES - Insufficient resources to allocate an address range of this size.
-
-hsa\_status\_t hsa\_amd\_vmem\_address\_free ( void *va, size\_t size )
-
-Free a reserved address range.
-
-Free a previously allocated address range. The size must match the size of a previously allocated address range.
-
-## Parameters
-
-- va -[out] virtual address to be freed
-- size -[in] of address range
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS - Address range released successfully
-- ::HSA\_STATUS\_ERROR\_INVALID\_ALLOCATION - Invalid va specified
-- ::HSA\_STATUS\_ERROR\_INVALID\_ARGUMENT - Invalid size specified
-- ::HSA\_STATUS\_ERROR\_RESOURCE\_FREE - Address range is still in use
-
-· ::HSA\_STATUS\_ERROR - Internal unexpected error
-
-hsa\_status\_t hsa\_amd\_vmem\_handle\_create ( hsa\_amd\_memory\_pool\_t pool, size\_t size, hsa\_amd\_memory\_type\_t type, uint64\_t flags, hsa\_amd\_vmem\_alloc\_handle\_t *memory\_handle
-
-)
-
-Create a virtual memory handle.
-
-Create a virtual memory handle within this pool size must be a aligned to allocation granule size for this memory pool, see HSA\_AMD\_MEMORY\_POOL\_INFO\_RUNTIME\_ALLOC\_GRANULE To minimize internal memory fragmentation, align the size to the recommended allocation granule size, see HSA\_AMD\_MEMORY\_POOL\_INFO\_RUNTIME\_ALLOC\_REC\_GRANULE
-
-## Parameters
-
-- pool -[in] memory to use
-- size -[in] of the memory allocation
-- type -[in] of memory
-- flags -[in] - currently unsupported
-- memory\_handle -[out] - handle for the allocation
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS - memory allocated successfully
-- ::HSA\_STATUS\_ERROR\_NOT\_INITIALIZED - The HSA runtime has not been initialized.
-- ::HSA\_STATUS\_ERROR\_INVALID\_ARGUMENT - Invalid arguments
-- ::HSA\_STATUS\_ERROR\_INVALID\_ALLOCATION - This memory pool does not support allocations
-- ::HSA\_STATUS\_ERROR\_OUT\_OF\_RESOURCES - Insufficient resources to allocate this memory
-
-hsa\_status\_t hsa\_amd\_vmem\_handle\_release ( hsa\_amd\_vmem\_alloc\_handle\_t memory\_handle )
-
-Release a virtual memory handle.
-
-## Parameters
-
-memory -[in] handle that was previously allocated
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS - Address range allocated successfully
-- ::HSA\_STATUS\_ERROR\_INVALID\_ALLOCATION - Invalid memory handle
-
-hsa\_status\_t hsa\_amd\_vmem\_map ( void *va, size\_t size, size\_t in\_offset, hsa\_amd\_vmem\_alloc\_handle\_t memory\_handle, uint64\_t flags )
-
-Map a virtual memory handle.
-
-Map a virtual memory handle to a reserved address range. The virtual address requested must be within a previously reserved address range. va and ( va + size) must be must be within (va + size) of the previous allocated address range. size must be equal to size of the memory\_handle hsa\_amd\_vmem\_set\_access needs to be called to make the memory accessible to specific agents
-
-## Parameters
-
-- va -[in] virtual address range where memory will be mapped
-- size -[in] of memory mapping
-- in\_offset -[in] offset into memory. Currently unsupported
-
-- memory\_handle -[in] virtual memory handle to be mapped
-- flags. -[in] Currently unsupported
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS - Memory mapped successfully
-- ::HSA\_STATUS\_ERROR\_INVALID\_ARGUMENT - va, size or memory\_handle are invalid
-- ::HSA\_STATUS\_ERROR\_OUT\_OF\_RESOURCES - Insufficient resources
-- ::HSA\_STATUS\_ERROR - Unexpected internal error
-
-## hsa\_status\_t hsa\_amd\_vmem\_unmap ( void *va, size\_t size )
-
-Unmap a virtual memory handle.
-
-Unmap previously mapped virtual address range
-
-## Parameters
-
-- va -[in] virtual address range where memory will be mapped
-- size -[in] of memory mapping
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS - Memory backing unmapped successfully
-- ::HSA\_STATUS\_ERROR\_INVALID\_ALLOCATION - memory\_handle is invalid
-- ::HSA\_STATUS\_ERROR\_INVALID\_ARGUMENT - size is invalid
-- ::HSA\_STATUS\_ERROR - Unexpected internal error
-
-hsa\_status\_t hsa\_amd\_vmem\_set\_access ( void *va, size\_t size, const hsa\_amd\_memory\_access\_desc\_t *desc, size\_t desc\_cnt )
-
-Make a memory mapping accessible.
-
-Make previously mapped virtual address accessible to specific agents. size must be equal to size of previously mapped virtual memory handle. Calling hsa\_amd\_vmem\_set\_access multiple times on the same va will overwrite previous permissions for all agents
-
-## Parameters
-
-- va -[in] previously mapped virtual address
-- size -[in] of memory mapping
-- desc -[in] list of access permissions for each agent
-- desc\_cnt -[in] number of elements in desc
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS -
-- ::HSA\_STATUS\_ERROR\_INVALID\_ARGUMENT - va, size or memory\_handle are invalid
-- ::HSA\_STATUS\_ERROR\_INVALID\_ALLOCATION - memory\_handle is invalid
-- ::HSA\_STATUS\_ERROR\_OUT\_OF\_RESOURCES - Insufficient resources
-- ::HSA\_STATUS\_ERROR\_INVALID\_AGENT - Invalid agent in desc
-- ::HSA\_STATUS\_ERROR - Unexpected internal error
-
-hsa\_status\_t hsa\_amd\_vmem\_get\_access ( void *va, hsa\_access\_permission\_t *perms, hsa\_agent\_t agent\_handle )
-
-Get current access permissions for memory mapping.
-
-Get access permissions for memory mapping for specific agent.
-
-## Parameters
-
-- va -[in] previously mapped virtual address
-- perms -[in] current permissions
-- agent\_handle -[in] agent
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS -
-- ::HSA\_STATUS\_ERROR\_INVALID\_AGENT - Invalid agent
-- ::HSA\_STATUS\_ERROR\_INVALID\_ALLOCATION - va is not mapped or permissions never set for this agent
-- ::HSA\_STATUS\_ERROR - Unexpected internal error
-
-hsa\_status\_t hsa\_amd\_vmem\_export\_shareable\_handle ( int *dmabuf\_fd, hsa\_amd\_vmem\_alloc\_handle\_t handle, uint64\_t flags )
-
-Get an exportable shareable handle.
-
-Get an exportable shareable handle for a memory\_handle. This shareabl handle can then be used to re-create a virtual memory handle using hsa\_amd\_vmem\_import\_shareable\_handle. The shareable handle can be transferred using mechanisms that support posix file descriptors Once all shareable handles are closed, the memory\_handle is released.
-
-## Parameters
-
-- dmabuf\_fd -[out] shareable handle
-- handle -[in] previously allocated virtual memory handle
-- flags -[in] Currently unsupported
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS -
-- ::HSA\_STATUS\_ERROR\_INVALID\_ALLOCATION - Invalid memory handle
-- ::HSA\_STATUS\_ERROR\_OUT\_OF\_RESOURCES - Out of resources
-- ::HSA\_STATUS\_ERROR - Unexpected internal error
-
-## hsa\_status\_t hsa\_amd\_vmem\_import\_shareable\_handle ( int dmabuf\_fd, hsa\_amd\_vmem\_alloc\_handle\_t *handle )
-
-Import a shareable handle.
-
-Import a shareable handle for a memory handle. Importing a shareable handle that has been closed and released results in undefined behavior.
-
-## Parameters
-
-- dmabuf\_fd -[in] shareable handle exported with hsa\_amd\_vmem\_export\_shareable\_handle
-- handle -[out] virtual memory handle
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS -
-
-- ::HSA\_STATUS\_ERROR\_INVALID\_ALLOCATION - Invalid memory handle
-- ::HSA\_STATUS\_ERROR\_OUT\_OF\_RESOURCES - Out of resources
-- ::HSA\_STATUS\_ERROR - Unexpected internal error
-
-hsa\_status\_t hsa\_amd\_vmem\_retain\_alloc\_handle ( hsa\_amd\_vmem\_alloc\_handle\_t *memory\_handle, void *addr )
-
-Returns memory handle for mapped memory.
-
-Return a memory handle for previously mapped memory. The handle will be the same value of handle used to map the memory. The returned handle must be released with corresponding number of calls to hsa\_amd\_vmem\_handle\_release.
-
-## Parameters
-
-- memory\_handle -[out] memory handle for this mapped address
-- mapped -[in] address
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS -
-- ::HSA\_STATUS\_ERROR\_INVALID\_ALLOCATION - Invalid address
-
-hsa\_status\_t hsa\_amd\_vmem\_get\_alloc\_properties\_from\_handle ( hsa\_amd\_vmem\_alloc\_handle\_t memory\_handle, hsa\_amd\_memory\_pool\_t *pool, hsa\_amd\_memory\_type\_t *type )
-
-Returns the current allocation properties of a handle.
-
-Returns the allocation properties of an existing handle
-
-## Parameters
-
-- memory\_handle -[in] memory handle to be queried
-- pool -[out] memory pool that owns this handle
-- memory -[out] type
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS -
-- ::HSA\_STATUS\_ERROR\_INVALID\_ALLOCATION - Invalid memory\_handle
-
-## CHAPTER
-
-## TWENTYFIVE
-
-## HIP MANAGED MEMORY ALLOCATION API
-
-hipError\_t hipMallocManaged ( void **dev\_ptr, size\_t size, unsigned int flags )
-
-Allocates memory that will be automatically managed by HIP.
-
-This API is used for managed memory, allows data be shared and accessible to both CPU and GPU using a single pointer.
-
-The API returns the allocation pointer, managed by HMM, can be used further to execute kernels on device and fetch data between the host and device as needed.
-
-Note: It is recommend to do the capability check before call this API.
-
-## Parameters
-
-- dev\_ptr -[out] - pointer to allocated device memory
-- size -[in] - requested allocation size in bytes, it should be granularity of 4KB
-- flags -[in] - must be either hipMemAttachGlobal or hipMemAttachHost (defaults to hipMemAttachGlobal)
-
-## Returns
-
-hipSuccess, hipErrorMemoryAllocation, hipErrorNotSupported, hipErrorInvalidValue hipError\_t hipMemPrefetchAsync ( const void *dev\_ptr, size\_t count, int device, hipStream\_t stream
-
-) Prefetches memory to the specified destination device using HIP.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-## Parameters
-
-- dev\_ptr -[in] pointer to be prefetched
-- count -[in] size in bytes for prefetching
-- device -[in] destination device to prefetch to
-- stream -[in] stream to enqueue prefetch operation
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue
-
-hipError\_t hipMemAdvise ( const void *dev\_ptr, size\_t count, hipMemoryAdvise advice, int device )
-
-Advise about the usage of a given memory range to HIP.
-
-This HIP API advises about the usage to be applied on unified memory allocation in the range starting from the pointer address devPtr, with the size of count bytes. The memory range must refer to managed memory allocated via the API hipMallocManaged, and the range will be handled with proper round down and round up respectively in the driver to be aligned to CPU page size, the same way as corresponding CUDA API behaves in CUDA version 8.0 and afterwards.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-## Parameters
-
-- dev\_ptr -[in] pointer to memory to set the advice for
-- count -[in] size in bytes of the memory range, it should be CPU page size alligned.
-- advice -[in] advice to be applied for the specified memory range
-- device -[in] device to apply the advice for
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemRangeGetAttribute ( void *data, size\_t data\_size, hipMemRangeAttribute attribute, const void *dev\_ptr, size\_t count )
-
-Query an attribute of a given memory range in HIP.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-## Parameters
-
-- data -[inout] a pointer to a memory location where the result of each attribute query will be written to
-- data\_size -[in] the size of data
-- attribute -[in] the attribute to query
-- dev\_ptr -[in] start of the range to query
-- count -[in] size of the range to query
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemRangeGetAttributes ( void **data, size\_t *data\_sizes, hipMemRangeAttribute *attributes, size\_t num\_attributes, const void *dev\_ptr, size\_t count )
-
-Query attributes of a given memory range in HIP.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-## Parameters
-
-- data -[inout] a two-dimensional array containing pointers to memory locations where the result of each attribute query will be written to
-- data\_sizes -[in] an array, containing the sizes of each result
-- attributes -[in] the attribute to query
-- num\_attributes -[in] an array of attributes to query (numAttributes and the number of attributes in this array should match)
-- dev\_ptr -[in] start of the range to query
-- count -[in] size of the range to query
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipStreamAttachMemAsync ( hipStream\_t stream, void *dev\_ptr, size\_t length, unsigned int flags ) Attach memory to a stream asynchronously in HIP.
-
-Warning: This API is under development. Currently it is a no-operation (NOP) function on AMD GPUs and returns hipSuccess.
-
-## Parameters
-
-- stream -[in] - stream in which to enqueue the attach operation
-- dev\_ptr -[in] - pointer to memory (must be a pointer to managed memory or to a valid host-accessible region of system-allocated memory)
-- length -[in] - length of memory (defaults to zero)
-- flags -[in] - must be one of hipMemAttachGlobal, hipMemAttachHost or hipMemAttachSingle (defaults to hipMemAttachSingle)
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue
-
-## template&lt;class T &gt;
-
-static inline hipError\_t hipMallocManaged ( T **devPtr, size\_t size, unsigned int flags = hipMemAttachGlobal )
-
-- : C++ wrapper for hipMallocManaged
-
-Provide an override to automatically typecast the pointer type from void**, and also provide a default for the flags.
-
-HIP\_DISABLE\_CPP\_FUNCTIONS macro can be defined to suppress these wrappers. It is useful for applications which need to obtain decltypes of HIP runtime APIs.
-
-## See also:
-
-hipMallocManaged
-
-## CHAPTER
-
-## TWENTYSIX
-
-## HIP VIRTUAL MEMORY MANAGEMENT API
-
-hipError\_t hipMemAddressFree ( void *devPtr, size\_t size )
-
-Frees an address range reservation made via hipMemAddressReserve.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- devPtr -[in] - starting address of the range.
-- size -[in] - size of the range.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemAddressReserve ( void **ptr, size\_t size, size\_t alignment, void *addr, unsigned long long flags )
-
-Reserves an address range.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- ptr -[out] - starting address of the reserved range.
-- size -[in] - size of the reservation.
-- alignment -[in] - alignment of the address.
-- addr -[in] - requested starting address of the range.
-- flags -[in] - currently unused, must be zero.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported
-
-hipError\_t hipMemCreate ( hipMemGenericAllocationHandle\_t *handle, size\_t size, const hipMemAllocationProp *prop, unsigned long long flags )
-
-Creates a memory allocation described by the properties and size.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- handle -[out] - value of the returned handle.
-- size -[in] - size of the allocation.
-- prop -[in] - properties of the allocation.
-- flags -[in] - currently unused, must be zero.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemExportToShareableHandle ( void *shareableHandle, hipMemGenericAllocationHandle\_t handle, hipMemAllocationHandleType handleType, unsigned long long flags )
-
-Exports an allocation to a requested shareable handle type.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- shareableHandle -[out] - value of the returned handle.
-- handle -[in] - handle to share.
-- handleType -[in] - type of the shareable handle.
-- flags -[in] - currently unused, must be zero.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemGetAccess ( unsigned long long *flags, const hipMemLocation *location, void *ptr
-
-) Get the access flags set for the given location and ptr.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- flags -[out] - flags for this location.
-- location -[in] - target location.
-- ptr -[in] - address to check the access flags.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemGetAllocationGranularity ( size\_t *granularity, const hipMemAllocationProp *prop, hipMemAllocationGranularity\_flags option )
-
-Calculates either the minimal or recommended granularity.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- granularity -[out] - returned granularity.
-- prop -[in] - location properties.
-- option -[in] - determines which granularity to return.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemGetAllocationPropertiesFromHandle ( hipMemAllocationProp *prop,
-
-hipMemGenericAllocationHandle\_t handle )
-
-Retrieve the property structure of the given handle.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- prop -[out] - properties of the given handle.
-- handle -[in] - handle to perform the query on.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported
-
-hipError\_t hipMemImportFromShareableHandle ( hipMemGenericAllocationHandle\_t *handle, void *osHandle, hipMemAllocationHandleType shHandleType )
-
-Imports an allocation from a requested shareable handle type.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- handle -[out] - returned value.
-- osHandle -[in] - shareable handle representing the memory allocation.
-- shHandleType -[in] - handle type.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemMap ( void *ptr, size\_t size, size\_t offset, hipMemGenericAllocationHandle\_t handle, unsigned long long flags )
-
-Maps an allocation handle to a reserved virtual address range.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- ptr -[in] - address where the memory will be mapped.
-- size -[in] - size of the mapping.
-- offset -[in] - offset into the memory, currently must be zero.
-- handle -[in] - memory allocation to be mapped.
-- flags -[in] - currently unused, must be zero.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemMapArrayAsync ( hipArrayMapInfo *mapInfoList, unsigned int count, hipStream\_t stream )
-
-Maps or unmaps subregions of sparse HIP arrays and sparse HIP mipmapped arrays.
-
-Warning: This API is under development. Currently it is not supported on AMD GPUs and returns hipErrorNotSupported.
-
-## Parameters
-
-- mapInfoList -[in] - list of hipArrayMapInfo.
-- count -[in] - number of hipArrayMapInfo in mapInfoList.
-- stream -[in] - stream identifier for the stream to use for map or unmap operations.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemRelease ( hipMemGenericAllocationHandle\_t handle )
-
-Release a memory handle representing a memory allocation which was previously allocated through hipMemCreate.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-handle -[in] - handle of the memory allocation.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemRetainAllocationHandle ( hipMemGenericAllocationHandle\_t *handle, void *addr )
-
-Returns the allocation handle of the backing memory allocation given the address.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- handle -[out] - handle representing addr.
-- addr -[in] - address to look up.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemSetAccess ( void *ptr, size\_t size, const hipMemAccessDesc *desc, size\_t count )
-
-Set the access flags for each location specified in desc for the given virtual address range.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- ptr -[in] - starting address of the virtual address range.
-- size -[in] - size of the range.
-- desc -[in] - array of hipMemAccessDesc.
-- count -[in] - number of hipMemAccessDesc in desc.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported
-
-## hipError\_t hipMemUnmap ( void *ptr, size\_t size )
-
-Unmap memory allocation of a given address range.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- ptr -[in] - starting address of the range to unmap.
-- size -[in] - size of the virtual address range.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported
-
-## CHAPTER
-
-## TWENTYSEVEN
-
-## HIP DEPRECATED RUNTIME API FUNCTIONS
-
-Several of our API functions have been flagged for deprecation. Using the following functions results in errors and unexpected results, so we encourage you to update your code accordingly.
-
-## 27.1 Context management
-
-CUDAsupports cuCtx API, which is the driver API that defines 'Context' and 'Devices' as separate entities. Context contains a single device, and a device can theoretically have multiple contexts. HIP initially added limited support for these APIs in order to facilitate porting from existing driver codes. These APIs are now marked as deprecated because there are better alternate interfaces (such as hipSetDevice or the stream API) to achieve these functions.
-
-- hipCtxCreate
-- hipCtxDestroy
-- hipCtxPopCurrent
-- hipCtxPushCurrent
-- hipCtxSetCurrent
-- hipCtxGetCurrent
-- hipCtxGetDevice
-- hipCtxGetApiVersion
-- hipCtxGetCacheConfig
-- hipCtxSetCacheConfig
-- hipCtxSetSharedMemConfig
-- hipCtxGetSharedMemConfig
-- hipCtxSynchronize
-- hipCtxGetFlags
-- hipCtxEnablePeerAccess
-- hipCtxDisablePeerAccess
-- hipDevicePrimaryCtxGetState
-- hipDevicePrimaryCtxRelease
-- hipDevicePrimaryCtxRetain
-- hipDevicePrimaryCtxReset
-
-- hipDevicePrimaryCtxSetFlags
-
-## 27.2 Memory management
-
-- hipMallocHost (replaced with hipHostMalloc )
-- hipMemAllocHost (replaced with hipHostMalloc )
-- hipHostAlloc (replaced with hipHostMalloc )
-- hipFreeHost (replaced with hipHostFree )
-- hipMemcpyToArray
-- hipMemcpyFromArray
-
-## 27.3 Profiler control
-
-- hipProfilerStart (use roctracer/rocTX)
-- hipProfilerStop (use roctracer/rocTX)
-
-## 27.4 Texture management
-
-- hipGetTextureReference
-- hipTexRefSetAddressMode
-- hipTexRefSetArray
-- hipTexRefSetFilterMode
-- hipTexRefSetFlags
-- hipTexRefSetFormat
-- hipTexRefGetAddress
-- hipTexRefGetAddressMode
-- hipTexRefGetFilterMode
-- hipTexRefGetFlags
-- hipTexRefGetFormat
-- hipTexRefGetMaxAnisotropy
-- hipTexRefGetMipmapFilterMode
-- hipTexRefGetMipmapLevelBias
-- hipTexRefGetMipmapLevelClamp
-- hipTexRefGetMipMappedArray
-- hipTexRefSetAddress
-- hipTexRefSetAddress2D
-- hipTexRefSetMaxAnisotropy
-
-- hipTexRefSetBorderColor
-- hipTexRefSetMipmapFilterMode
-- hipTexRefSetMipmapLevelBias
-- hipTexRefSetMipmapLevelClamp
-- hipTexRefSetMipmappedArray
-- hipTexRefGetBorderColor
-- hipTexRefGetArray
-- hipBindTexture
-- hipBindTexture2D
-- hipBindTextureToArray
-- hipGetTextureAlignmentOffset
-- hipUnbindTexture
-- hipBindTextureToMipmappedArray
-
-## CHAPTER
-
-## TWENTYEIGHT
-
-## SAXPY - HELLO, HIP
-
-This tutorial explains the basic concepts of the single-source Heterogeneous-computing Interface for Portability (HIP) programming model and the essential tooling around it. It also reviews some commonalities of heterogenous APIs in general. This topic assumes basic familiarity with the C/C++ compilation model and language.
-
-## 28.1 Prerequisites
-
-To follow this tutorial, you'll need installed drivers and a HIP compiler toolchain to compile your code. Because HIP for ROCm supports compiling and running on Linux and Windows with AMD and NVIDIA GPUs, the combination of install instructions is more than worth covering as part of this tutorial. For more information about installing HIP development packages, see Install HIP .
-
-## 28.2 Heterogeneous programming
-
-Heterogeneous programming and offloading APIs are often mentioned together. Heterogeneous programming deals with devices of varying capabilities simultaneously. Offloading focuses on the 'remote' and asynchronous aspects of computation. HIP encompasses both. It exposes GPGPU (general-purpose GPU) programming much like ordinary host-side CPU programming and lets you move data across various devices.
-
-When programming in HIP (and other heterogenous APIs for that matter), remember that target devices are built for a specific purpose. They are designed with different tradeoffs than traditional CPUs and therefore have very different performance characteristics. Even subtle changes in code might adversely affect execution time.
-
-## 28.3 Your first lines of HIP code
-
-First, let's do the 'Hello, World!' of GPGPU: SAXPY. Single-precision A times X Plus Y ( SAXPY ) is a mathematical acronym; a vector equation 𝑎 · 𝑥 + 𝑦 = 𝑧 where 𝑎 ∈ R is a scalar and 𝑥, 𝑦, 𝑧 ∈ V are vector quantities of some large dimensionality. This vector space is defined over the set of reals. Practically speaking, you can compute this using a single for loop over three arrays.
-**Following code does:** This code snippet is a command to compile a C++ program using the `clang++` compiler. It is specifically compiling a HIP (Heterogeneous-Compute Interface for Portability) program, which is used for writing portable code that can run on both AMD and NVIDIA GPUs. The command compiles the source file `main.hip` located in the `HIP-Basic\saxpy` directory into an executable named `saxpy.exe`. It includes headers from the `.\Common` directory, links against the `amdhip64` library, and uses the library path specified by the `HIP_PATH` environment variable. The `-O2` flag is used for optimization, and `--save-temps` is used to save intermediate compilation files.
-
-
-```
-++i)
-```
-**Following code does:** This code snippet is a partial command written in PowerShell. It uses the `Get-ChildItem` cmdlet to list items (files and directories) in the current directory that match a specific pattern. The `-Filter main-hip-*` option specifies that only items with names starting with "main-hip-" should be included in the output. The command is incomplete, as it ends with `selec`, which is likely intended to be `Select-Object` to further process or filter the properties of the listed items.
-
-
-```
-<_SQL_>
-```
-
-In linear algebra libraries, such as BLAS (Basic Linear Algebra Subsystem) this operation is defined as AXPY 'A times X Plus Y'. The 'S' comes from single-precision , meaning that array element is float -s (IEEE 754 binary32 representation).
-
-To quickly get started, use the set of HIP samples from GitHub. With Git configured on your machine, open a commandline and navigate to your desired working directory, then run:
-**Following code does:** The code snippet appears to be incomplete and seems to be a mix of Python and PowerShell syntax. The part `n-hip-* | select -Property Name` resembles a PowerShell command rather than Python. In PowerShell, this command would filter objects whose names match the pattern `n-hip-*` and then select only the `Name` property of those objects. However, without additional context or a complete command, it's difficult to provide a precise explanation.
-
-
-```
-            |git clone https://github.com/amd/rcm-examples.git
-```
-
-A simple implementation of SAXPY resides in the HIP-Basic/saxpy/main.hip file in this repository. The HIP code here mostly deals with where data has to be and when, and how devices transform this data. The first HIP calls deal with allocating device-side memory and copying data from host-side memory to device side in a C runtime-like fashion.
-**Following code does:** The code snippet appears to be a list of filenames rather than executable code. These filenames suggest that they are related to a project or compilation process targeting the AMD GCN (Graphics Core Next) architecture, specifically the gfx906 variant, which is used in AMD GPUs. The files likely represent different stages or outputs of compiling a program using the HIP (Heterogeneous-Compute Interface for Portability) framework for AMD hardware. The extensions indicate various file types: 
-
-- `.bc` is likely a LLVM bitcode file.
-- `.hipi` could be an intermediate file specific to HIP.
-- `.o` is an object file.
-- `.out` is an executable or output file.
-- `.out.resolution.txt` might be a text file containing resolution or linking information.
-- `.s` is an assembly file.
-
-Overall, these files are part of the build process for a HIP application targeting AMD GPUs.
-
-
-```
-// Allocate and copy vectors to device memory.
-float* d_x{};
-float* d_y{};
-HIP_CHECK(hipMalloc(&d_x, size_bytes));
-HIP_CHECK(hipMalloc(&d_y, size_bytes));
-HIP_CHECK(hipMemcpy(d_x, x.data(), size_bytes, hipMemcpyHostToDevice));
-HIP_CHECK(hipMemcpy(d_y, y.data(), size_bytes, hipMemcpyHostToDevice));
-```
-
-HIP\_CHECK is a custom macro borrowed from the examples utilities which checks the error code returned by API functions for errors and reports them to the console. It is not essential to the API, but it is a good practice to check the error codes of the HIP APIs in case you pass on incorrect values to the API, or the API might be out of resources.
-
-The code selects the device to allocate to and to copy to. Commands are issued to the HIP runtime per thread, and every thread has a device set as the target of commands. The default device is 0 , which is equivalent to calling hipSetDevice(0) .
-
-Launch the calculation on the device after the input data has been prepared.
-**Following code does:** This code snippet appears to be a disassembled output of a compiled program targeting AMD's GCN (Graphics Core Next) architecture, specifically the gfx906 variant. The disassembly is likely generated from a HIP (Heterogeneous-Compute Interface for Portability) application, which is used for GPU programming on AMD hardware.
-
-The code includes assembly instructions for a function named `_Z12saxpy_kernelPKfPfj`, which suggests it is implementing a SAXPY (Single-Precision A·X Plus Y) operation, a common vector operation in linear algebra. The SAXPY operation computes the result of `Y = a * X + Y`, where `a` is a scalar and `X` and `Y` are vectors.
-
-The assembly instructions involve loading data, performing arithmetic operations, and storing results back to memory, which are typical steps in executing a SAXPY operation on a GPU. The use of specific instructions like `s_load_dword`, `v_add_u32_e32`, and `global_store_dword` indicates manipulation of scalar and vector registers, memory access, and arithmetic operations optimized for parallel execution on the GPU.
-
-
-```
-    Launch the calculation on the device after the input data has been prepared.
-    __global__ void saxpy_kernel(const float a, const float* d_x, float* d_y, const unsigned_
-    __int size)
-    {
-        //...
-    }
-
-    int main()
-    {
-        //...
-
-        // Launch the kernel on the default stream.
-        saxpy_kernel<<<dim3(grid_size), dim3(block_size), 0, hipStreamDefault>>>(a, d_x, d_y,
-    -- size);
-    }
-
-    Analyze at the signature of the offloaded function:
-```
-
-Analyze at the signature of the offloaded function:
-
-- \_\_global\_\_ instructs the compiler to generate code for this function as an entrypoint to a device program, such that it can be launched from the host.
-- The function does not return anything, because there is no trivial way to construct a return channel of a parallel invocation. Device-side entrypoints may not return a value, their results should be communicated using output parameters.
-- Device-side functions are typically called compute kernels, or just kernels for short. This is to distinguish them from non-graphics-related graphics shaders, or just shaders for short.
-- Arguments are taken by value and all arguments shall be TriviallyCopyable, meaning they should be memcpy -friendly. (Imagine if they had custom copy constructors. Where would that logic execute? On the host? On the device?) Pointer arguments are pointers to device memory, one typically backed by VRAM.
-
-- We said that we'll be computing 𝑎 · 𝑥 + 𝑦 = 𝑧 , however we only pass two pointers to the function. We'll be canonically reusing one of the inputs as outputs.
-
-This function is launched from the host using a language extension often called the triple chevron syntax. Inside the angle brackets, provide the following.
-
-- The number of blocks to launch (our grid size)
-- The number of threads in a block (our block size)
-- The amount of shared memory to allocate by the host
-- The device stream to enqueue the operation on
-
-The block size and shared memory become important later in Reduction . For now, a hardcoded 256 is a safe default for simple kernels such as this. Following the triple chevron is ordinary function argument passing.
-
-Look at how the kernel is implemented.
-**Following code does:** The code snippet you provided seems to be a placeholder or an incomplete representation of a Bash script. The `<_Bash_>` tag does not contain any actual Bash code or commands. Therefore, it does not perform any specific function or task. If you have a specific Bash script or code snippet you would like explained, please provide the actual code.
-
-
-```
-<_Cuda_>
-```
-
-- The unique linear index identifying the thread is computed from the block ID the thread is a member of, the block 's size and the ID of the thread within the block .
-- A check is made to avoid overindexing the input.
-- The useful part of the computation is carried out.
-
-Retrieval of the result from the device is done much like input data copy. In this current step the results copied from device to host. The opposite direction of the input data copy:
-**Following code does:** The code snippet you've provided appears to be a corrupted or improperly formatted text, possibly due to a copy-paste error or encoding issue. It does not represent valid Python code or any recognizable programming construct. If you intended to share a specific piece of code, please ensure it is correctly formatted and complete.
-
-
-```
-                |HIP_CHECK(hipMemcpy(y.data()),  d_y,  size_bytes,  hipMemcpyDeviceToHost));
-```
-
-## 28.4 Compiling on the command line
-
-## 28.4.1 Setting up the command line
-
-Strictly speaking there's no such thing as 'setting up the command-line for compilation' on Linux. To make invocations more terse, Linux and Windows example follow.
-
-## Linux and AMD
-
-While distro maintainers might package ROCm so that it installs to system-default locations, AMD's packages aren't installed that way. They need to be added to the PATH by the user.
-**Following code does:** The code snippet you provided appears to be a command or a reference to a file rather than a typical code snippet. It seems to be related to a SAXPY operation, which stands for "Single-Precision A·X Plus Y." SAXPY is a common operation in linear algebra used to scale a vector `X` by a scalar `A` and add it to another vector `Y`. The term "sm_5" likely refers to a specific compute capability or architecture version for NVIDIA GPUs, and "ptx" indicates that this is a PTX (Parallel Thread Execution) file, which is an intermediate representation used in CUDA programming for NVIDIA GPUs. Overall, this line likely refers to a compiled or source file related to performing a SAXPY operation on a GPU.
-
-
-```
-        | export PATH=/opt/rcm/bin:${PATH}
-```
-**Following code does:** The code snippet appears to be a mix of Python and PHP syntax, but it is not valid code in either language. It seems to be an attempt to execute a shell command using PHP tags, specifically running `rocminfo` and filtering the output with `grep gfx`. The intention might be to extract information about AMD GPU architectures (gfx) from the `rocminfo` command output. However, due to the incorrect syntax and formatting, this code will not execute as intended in any programming environment.
-
-
-```
-}
-```
-**Following code does:** This code snippet appears to be a series of special characters and symbols arranged in a specific pattern. However, it does not constitute valid or meaningful Python code. It seems to be more of an artistic or visual arrangement of characters rather than a functional code snippet with a high-level purpose.
-
-
-```
-    You should be able to call the compiler on the command line now:
-    
-    amdclang++  --version
-```
-
-Note: Docker images distributed by AMD, such as rocm-terminal already have /opt/rocm/bin on the Path for convenience. This subtly affects CMake package detection logic of ROCm libraries.
-
-## Linux and NVIDIA
-
-Both distro maintainers and NVIDIA package CUDA so that nvcc and related tools are available on the command line by default. You can call the compiler on the command line with:
-**Following code does:** The code snippet describes a SAXPY operation, which stands for "Single-Precision A·X Plus Y". It performs a linear algebra operation where each element of an array `y` is updated by multiplying a scalar `a` with the corresponding element of another array `x` and then adding the result to the original element in `y`. This operation is applied over 10,000,000 elements. The snippet also provides the first 10 elements of the resulting array `y` after the operation, which are `[3, 5, 7, 9, 11, 13, 15, 17, 19, 21]`.
-
-
-```
-| nvcc --version
-```
-
-## Windows and AMD
-
-Windows compilers and command line tooling have traditionally relied on extra environmental variables and PATH entries to function correctly. Visual Studio refers to command lines with this setup as 'Developer Command Prompt' or 'Developer PowerShell' for cmd.exe and PowerShell respectively.
-
-The HIP SDK on Windows doesn't include a complete toolchain. You will also need:
-
-- The Microsoft Windows SDK. It provides the import libs to crucial system libraries that all executables must link to and some auxiliary compiler tooling.
-- A Standard Template Library (STL). Installed as part of the Microsoft Visual C++ compiler (MSVC) or with Visual Studio.
-
-If you don't have a version of Visual Studio 2022 installed, for a minimal command line experience, install the Build Tools for Visual Studio 2022 with the Desktop Developemnt Workload. Under Individual Components select:
-
-- A version of the Windows SDK
-- 'MSVC v143 - VS 2022 C++ x64/x86 build tools (Latest)'
-- 'C++ CMake tools for Windows' (optional)
-
-Note: The 'C++ CMake tools for Windows' individual component is a convenience which puts both cmake.exe and ninja.exe onto the PATH inside developer command prompts. You can install these manually, but then you must manage them manually.
-
-Visual Studio 2017 and later are detectable as COM object instances via WMI. To setup a command line from any shell for the latest Visual Studio's default Visual C++ toolset issue:
-**Following code does:** It seems like there is a placeholder `<_Python_>` instead of actual code. Please provide the code snippet you would like me to explain.
-
-
-```
-$InstallationPath = Get-CimInstance MSFT_VSInstance | Sort-Object -Property Version -
- --Descending | Select-Object -First 1 -ExpandProperty InstallLocation
- Import-Module $InstallationPath\Common?\Tools\Microsoft.VisualStudio.DevShell.dll
-Enter-VsDevShell -InstallPath $InstallationPath -SkipAutomaticLocation -Arch amd64 -
- --HostArch amd64 -DevCmdArguments '-no_logo'
-$env:PATH = "${env:HIP_PATH}bin;${env:PATH}"
-```
-
-You should be able to call the compiler on the command line now:
-**Following code does:** This code snippet appears to be a series of symbols and numbers, but it does not represent valid or meaningful Python code. It seems to be a random arrangement of characters and does not perform any computational task or serve any high-level purpose in programming.
-
-
-```
-  | clang++ --version
-```
-
-## Windows and NVIDIA
-
-Windows compilers and command line tooling have traditionally relied on extra environmental variables and PATH entries to function correctly. Visual Studio refers to command lines with this setup as 'Developer Command Prompt' or 'Developer PowerShell' for cmd.exe and PowerShell respectively.
-
-The HIP and CUDA SDKs on Windows don't include complete toolchains. You will also need:
-
-- The Microsoft Windows SDK. It provides the import libs to crucial system libraries that all executables must link to and some auxiliary compiler tooling.
-- A Standard Template Library (STL). Installed as part of the Microsoft Visual C++ compiler (MSVC) or with Visual Studio.
-
-If you don't have a version of Visual Studio 2022 installed, for a minimal command line experience, install the Build Tools for Visual Studio 2022 with the Desktop Developemnt Workload. Under Individual Components select:
-
-- A version of the Windows SDK
-- 'MSVC v143 - VS 2022 C++ x64/x86 build tools (Latest)'
-- 'C++ CMake tools for Windows' (optional)
-
-Note: The 'C++ CMake tools for Windows' individual component is a convenience which puts both cmake.exe and ninja.exe onto the PATH inside developer command prompts. You can install these manually, but then you must manage them manually.
-
-Visual Studio 2017 and later are detectable as COM object instances via WMI. To setup a command line from any shell for the latest Visual Studio's default Visual C++ toolset issue:
-**Following code does:** The code snippet you provided seems to be a placeholder or a tag indicating a YAML (YAML Ain't Markup Language) document or section, rather than actual executable code. YAML is a human-readable data serialization standard often used for configuration files or data exchange between languages with different data structures. Without specific YAML content, it's not possible to determine what data or configuration it represents. If you have a YAML file or content, it would typically define structured data in a readable format, such as lists, dictionaries, or configuration settings.
-
-
-```
-$InstallationPath = Get-CimInstance MSFT_VSInstance | Sort-Object -Property Version -
---Descending | Select-Object -First 1 -ExpandProperty InstallLocation
-Import-Module $InstallationPath\Common7\Tools\Microsoft.VisualStudio.DevShell.dll
-Enter-VsDevShell -InstallPath $InstallationPath -SkipAutomaticLocation -Arch amd64 -
---HostArch amd64 -DevCmdArguments '-no_logo'
-```
-
-You should be able to call the compiler on the command line now:
-**Following code does:** The code snippet provided is not a valid or complete Python code. It appears to be a fragment with a lot of whitespace and a string that looks like a comment or a directive related to architecture specifications, possibly for CUDA (Compute Unified Device Architecture) which is used for programming NVIDIA GPUs. The `<_arch=sm_70,sm_86` part suggests specifying the compute capabilities (sm_70 and sm_86) for which the code might be intended to run. However, without additional context or surrounding code, it's not possible to determine its exact purpose or functionality.
-
-
-```
-| nvcc --version
-```
-
-## 28.4.2 Invoking the compiler manually
-
-To compile and link a single-file application, use the following commands:
-
-## Linux and AMD
-**Following code does:** The code snippet appears to be executing a program or script named `saxpy`, which performs the SAXPY operation (Single-Precision A·X Plus Y). This operation is a common vector operation in numerical computing, where each element of a vector `y` is updated by multiplying a scalar `a` with the corresponding element of another vector `x` and then adding the result to the original element of `y`. The operation is performed over 10,000,000 elements. After the computation, the first 10 elements of the resulting vector `y` are displayed, showing a sequence of odd numbers starting from 3.
-
-
-```
-                                                                                                                                                                                                        |                                                                                                                                                                                                       
-                                                                                                                                                                                                        <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        </----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                    <---------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        >----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                    |   
-                                                                                                                                                                                                    |   
-
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                   
-    </----------------------------------------------------------------------------------------------------------------------
-```
-
-## Linux and NVIDIA
-**Following code does:** This code snippet is a PowerShell command that executes the `hipInfo.exe` program located in the `bin` directory of the path specified by the `HIP_PATH` environment variable. The output of this program is then filtered using `Select-String` to search for lines containing the string "gfx". The purpose of this command is to extract and display information related to graphics architecture names (e.g., `gfx1032`, `gfx1035`) from the output of `hipInfo.exe`.
-
-
-```
-                                                                                                                                                                                                        | nvcc ./HIP-Basic/saxpy/main.hip  -o  saxpy  -I ./Common  -I  /opt/rocm/include  -02  -x  cu                                                                                                                                                                                                       
-                                                                                                                                                                                                        -x  cu                                                                                                                                                                                                  |                                                                                                                                                                                                        }
-```
-
-## Windows and AMD
-**Following code does:** This code snippet is a command line instruction for compiling a HIP (Heterogeneous-Compute Interface for Portability) program using the `clang++` compiler. The command is set up to compile a source file named `main.hip` located in the `HIP-Basic\saxpy` directory into an executable named `saxpy.exe`. It includes a directory `.\Common` for header files and links against the `amdhip64` library. The command also specifies the HIP installation path using the environment variable `${env:HIP_PATH}`. Additionally, it targets specific GPU architectures (`gfx1032` and `gfx1035`) for offloading, and uses optimization level `-O2` for the compilation process.
-
-
-```
-                                                                                                                                                                                                        |clang++.\HIP-Basic\saxpy\main.hip -o saxpy.exe -I.\Common -lamdhip64 -L ${env:HIP_PATH}                                                                                                                                                                                                       
-                                                                                                                                                                                                        -lib -02
-```
-
-## Windows and NVIDIA
-**Following code does:** This code snippet appears to be executing a compiled program named `saxpy.exe`, which performs the SAXPY operation (Single-Precision A·X Plus Y). The operation involves scaling a vector `x` by a scalar `a` and adding it to another vector `y`, element-wise. The program processes 10,000,000 elements and outputs the first 10 elements of the resulting vector `y` after the computation. The output suggests that the operation has been successfully completed, showing the first 10 elements of the updated vector `y`.
-
-
-```
-                                                                                                                                                                                                        | nvcc.\HIP-Basic\saxpy\main.hip -o saxpy.exe -I ${env:HIP_PATH}include -I.\Common -02 - -
-                                                                                                                                                                                                        -x                                                                                                                                                                                                       
-                                                                                                                                                                                                       |                                                                                                                                                                                                        +x                                                                                                                                                                                                       |
-```
-
-Depending on your computer, the resulting binary might or might not run. If not, it typically complains about 'Invalid device function'. That error (corresponding to the hipErrorInvalidDeviceFunction entry of hipError\_t ) means that the runtime could not find a device program binary of the appropriate flavor embedded into the executable.
-
-So far, the discussion has covered how data makes it from the host to the device and back. It has also discussed the device code as source, with the HIP runtime arguing that the correct binary to dispatch for execution. How can you find out what device binary flavors are embedded into the executable?
-
-## Linux and AMD
-
-The utilities included with ROCm help significantly to inspect binary artifacts on disk. Add the ROCmCC installation folder to your PATH if you want to use these utilities (the utilities expect them to be on the PATH).
-
-You can list embedded program binaries using roc-obj-ls .
-**Following code does:** The code snippet appears to be a command for compiling a C++ program using `nvcc`, which is the NVIDIA CUDA Compiler. The command is intended to compile a source file named `main.cpp` located in the `HIP-Basic/device_query` directory, and produce an executable named `device_query.exe`. It includes additional directories for header files specified by `-I.\Common` and `-I ${env:HIP_PATH}`. However, the command seems to be malformed or incomplete, as it includes unusual formatting and options like `-include -02` and `--include -0022`, which are not standard or correctly formatted compiler options. This suggests that the command might be incorrectly copied or formatted.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?>
-                                                                                                                                                                                                       <!>
-                                                                                                                                                                                                      <!>"
-```
-**Following code does:** This code snippet executes a command-line program called `device_query.exe` and pipes its output to the `Select-String` command, which searches for occurrences of the string "major.minor". The output shows that the program found two instances of "major.minor" with associated version numbers, 8.6 and 7.0. This suggests that the code is used to query and display the major and minor version numbers of certain devices or software components.
-
-
-```
-<_SQL_>
-```
-
-The compiler embeds a version 4 code object (more on code object versions) and used the LLVM target triple amdgcnamd-amdhsa-gfx803 (more on target triples). You can extract that program object in a disassembled fashion for human consumption via roc-obj .
-**Following code does:** The code snippet provided appears to be a series of whitespace characters followed by two lines with the decrement operation `--x` and `-x`. However, this is not valid Python code due to the excessive whitespace and lack of context or structure. In Python, `--x` is not a valid operation as it would be interpreted as two separate unary negations, effectively leaving `x` unchanged. Similarly, `-x` is a unary negation that simply returns the negative value of `x`. Without additional context or surrounding code, this snippet does not perform any meaningful operation.
-
-
-```
-        | r o c - o b j \ - t \ g f x 8 0 3 \ - d \. / s a x p y
-```
-
-This creates two files on disk and .s extension is of most interest. Opening this file or dumping it to the console using cat lets find the disassembled binary of the SAXPY compute kernel, something similar to:
-**Following code does:** This code snippet appears to be executing a compiled program named `saxpy.exe`, which performs the SAXPY operation (Single-Precision A·X Plus Y). The operation involves scaling a vector `x` by a scalar `a` and adding it to another vector `y`, element-wise, over 10,000,000 elements. The output shows the first 10 elements of the resulting vector `y` after the operation has been completed.
-
-
-```
-<_XML_>
-```
-
-Alternatively, call the compiler with --save-temps to dump all device binary to disk in separate files.
-**Following code does:** It seems like you've provided a placeholder or incomplete code snippet. Please provide the actual code so I can help explain its purpose.
-
-
-```
-                                                                                                                                                                                                        |                                                                                                                                                                                                       
-                                                                                                                                                                                                        -                                                                                                                                                                                                        --                                                                                                                                                                                                        \                                                                                                                                                                                                        +                                                                                                                                                                                                        <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        }                                                                                                                                                                                                        </----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                    |   
-                                                                                                                                                                                                    |    -                                                                                                                                                                                                    |    0                                                                                                                                                                                                        ]                                                                                                                                                                                                        )                                                                                                                                                                                                       .                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        :                                                                                                                                                                                                       '
-```
-
-List all the temporaries created while compiling main.hip with:
-**Following code does:** This code defines a CUDA kernel function named `k` that operates on arrays of `float4` structures. The kernel is intended to be executed on a GPU, where each thread in a block performs a computation on elements of the input arrays `a` and `b`. Specifically, for each thread, it calculates an index using the thread ID (`tid`), block ID (`bid`), and block dimension (`dim`). It then updates the element in array `a` at the current thread index by adding the product of the calculated index and the corresponding element in array `b`. This operation is performed in parallel across all threads in a block.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-    ls main-hip-amdgcn-amd-amdhsa-*
-    main-hip-amdgcn-amd-amdhsa-gfx803.bc
-    main-hip-amdgcn-amd-amdhsa-gfx803.cui
-    main-hip-amdgcn-amd-amdhsa-gfx803.o
-    main-hip-amdgcn-amd-amdhsa-gfx803.out
-    main-hip-amdgcn-amd-amdhsa-gfx803.out.resolution.txt
-    main-hip-amdgcn-amd-amdhsa-gfx803.s
-```
-
-Files with the .s extension hold the disassembled contents of the binary. The filename notes the graphics IPs used by the compiler. The contents of this file are similar to what roc-obj printed to the console.
-
-## Linux and NVIDIA
-
-Unlike HIP on AMD, when compiling using the NVIDIA support of HIP the resulting binary will be a valid CUDA executable as far as the binary goes. Therefor it'll incorporate PTX ISA (Parallel Thread eXecution Instruction Set Architecture) instead of AMDGPU binary. As s result, tooling shipping with the CUDA SDK can be used to inspect which device ISA got compiled into a specific executable. The tool most useful to us currently is cuobjdump .
-**Following code does:** The provided code snippet appears to be a mix of Python and C++ syntax, but it is largely nonsensical and does not perform any meaningful operation. It includes fragments of C++ code, such as `<std::size_t factor = block_size;` and `</std::endl;`, which are not valid in Python. Additionally, there are scattered mathematical operators and comments that do not form a coherent program. Overall, this snippet does not achieve any functional purpose and seems to be a collection of random code fragments.
-
-
-```
-  cuobjdump --list-ptx./saxpy
-
-  Which will print something like:
-```
-**Following code does:** The provided code snippet appears to be a series of `<void>` and `</void>` tags interspersed with whitespace. It does not contain any executable Python code or meaningful logic. It seems to be a nonsensical or malformed attempt at using XML-like tags, but without any context or structure that would give it a functional purpose. Therefore, the code does not perform any operations or have a high-level purpose.
-
-
-```
-| P T X \ f i l e
-```
-**Following code does:** This code snippet appears to be part of a loop that launches a GPU kernel using the HIP (Heterogeneous-Compute Interface for Portability) API. The loop iterates in reverse, starting from `input_count` and decrementing until it is greater than 1. Within the loop, the `hipLaunchKernelGGL` function is called to execute a kernel function named `kernel` on the GPU. The kernel is launched with a grid configuration determined by `dim3(new_size(curr))` and a block size of `dim3(block_size)`. The kernel is provided with shared memory of size `factor * sizeof(unsigned)` and is executed on the default HIP stream. The parameters `front`, `back`, and `kernel_op` are passed to the kernel, likely as arguments for processing data. The purpose of this code is to perform parallel computations on a GPU, potentially for tasks like data processing or transformation, by repeatedly launching a kernel with varying configurations.
-
-
-```
-1:  saxpy. 1. sm_5. ptx
-```
-
-From this we can see that the saxpy kernel is stored as sm\_52 , which shows that a compute capability 5.2 ISA got embedded into the executable, so devices which sport compute capability 5.2 or newer will be able to run this code.
-
-## Windows and AMD
-
-The HIP SDK for Windows don't yet sport the roc-* set of utilities to work with binary artifacts. To find out what binary formats are embedded into an executable, one may use dumpbin tool from the Windows SDK to obtain the raw data of the .hip\_fat section of an executable. (This binary payload is what gets parsed by the roc-* set of utilities on Linux.) Skipping over the reported header, the rendered raw data as ASCII has ~3 lines per entries. Depending on how many binaries are embedded, you may need to alter the number of rendered lines. An invocation such as:
-**Following code does:** The code snippet `1;)` is not valid Python code. It appears to be a syntax error, as Python does not allow a semicolon to follow a number without a preceding valid statement. This snippet will result in a syntax error if executed in a Python interpreter.
-
-
-```
-                                                                                                                                                                                                        | dumpbin.exe  /nologo  /section:.hip_fat  /rawdata:8 .\saxpy.exe  |  select  -Skip  20  -First  12                                                                                                                                                                                                       
-                                                                                                                                                                                                        -                                                                                                                                                                                                        --                                                                                                                                                                                                        +                                                                                                                                                                                                        <--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        </--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                   | dumpbin .exe  /nologo  /section:.hip_fat  /rawdata:8 .\saxpy.exe  |  select  -Skip  20  -First  12                                                                                                                                                             |                                                                                                                                                                                                        >--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                  
-     |  dumpbin.exe  /nologo  /section:.hip_fat  /rawdata:8 .\saxpy.exe  |  select  -Skip  20  -First  12                                                                                                                                                        |                                               
-     |                                                                                                                                                                                                   |                                          
-     |                                                                                                                                                       
-     |                                                                                                                                                   |                                                    
-     |                                                                                                                                             
-     |                                                    
-     |                                                                                                                                        
-     |                                                         
-     |
-```
-
-The output may look like:
-**Following code does:** This code snippet appears to be part of a larger function or program, likely written in C++ given the use of `std::swap`. The code performs the following high-level operations:
-
-1. It assigns a new value to the variable `curr` by calling a function `new_size(curr)`.
-2. It checks if the updated value of `curr` is greater than 1.
-3. If `curr` is greater than 1, it swaps the values of two variables, `front` and `back`, using the `std::swap` function.
-
-Overall, the code seems to be adjusting the size of something (possibly a container or data structure) and conditionally swapping two elements based on the new size.
-
-
-```
-<_Python_>
-```
-
-We can see that the compiler embedded a version 4 code object (more on code object versions) and used the LLVM target triple amdgcn-amd-amdhsa-gfx906 (more on target triples). Don't be alarmed about linux showing up as a binary format, AMDGPU binaries uploaded to the GPU for execution are proper linux ELF binaries in their format.
-
-Alternatively we can call the compiler with --save-temps to dump all device binary to disk in separate files.
-**Following code does:** The code snippet `<_Cuda_>` appears to be a placeholder or a symbolic representation rather than actual executable code. In the context of programming, particularly with Python, it might be intended to represent a CUDA-related object or module. CUDA (Compute Unified Device Architecture) is a parallel computing platform and application programming interface (API) model created by NVIDIA, which allows developers to use a GPU for general purpose processing. However, without additional context or actual code, it's not possible to determine the specific functionality or purpose of this placeholder.
-
-
-```
-                                                                                                                                                                                                        |clang++.\HIP-Basic\saxpy\main.hip -o saxpy.exe -I.\Common -lamdhip64 -L ${env:HIP_PATH}                                                                                                                                                                                                       
-                                                                                                                                                                                                        -lib -02 --save-temps                                                                                                                                                                                                        \
-```
-
-Now we can list all the temporaries created while compiling main.hip via
-**Following code does:** This code snippet is part of a parallel reduction algorithm typically used in GPU programming, such as with CUDA. The purpose of this code is to perform a reduction operation (e.g., summation, finding the maximum) on an array of data stored in shared memory (`shared`). The reduction is done in parallel by multiple threads within a block.
-
-The loop iteratively reduces the number of elements by combining pairs of elements using a binary operation `op`. The `for` loop iterates over increasing powers of two, effectively halving the number of active elements in each iteration. The `__syncthreads()` function is used to synchronize all threads in the block, ensuring that all threads have completed their operations before proceeding to the next iteration.
-
-The code has been modified to use a different indexing strategy, where the index `j` is calculated based on the thread ID (`tid`) and the current step size (`i`). This change aims to ensure that only valid indices within the bounds of the block are accessed, preventing out-of-bounds memory access.
-
-
-```
-        |Get-ChildItem -Filter main-hip-* | selec
-```
-**Following code does:** The provided code snippet appears to be a fragment of a larger codebase, possibly related to parallel computing or GPU programming, given the use of `blockDim.x` which is common in CUDA programming for defining the number of threads in a block. The snippet seems to be part of a loop intended for a shared reduction operation, which is a common parallel algorithm used to reduce an array of values to a single value (e.g., sum, max). However, the snippet is incomplete and contains some formatting artifacts (e.g., `-` and `+` symbols), which suggest it might be part of a diff or patch file showing changes to the code. The high-level purpose of this snippet is likely to perform a reduction operation across threads within a block.
-
-
-```
-n-hip-* | select -Property Name
-                                                                                                                                                                                                         (continues on next page)
-```
-
-(continued from previous page)
-**Following code does:** The code snippet `<_Cuda_>` appears to be a placeholder or a symbolic representation rather than actual executable Python code. In the context of programming, "Cuda" typically refers to NVIDIA's parallel computing platform and application programming interface (API) model, which allows developers to use a CUDA-enabled graphics processing unit (GPU) for general purpose processing. However, without additional context or actual code, it's not possible to determine the specific functionality or purpose of this placeholder.
-
-
-```
-Name
------
-main-hip-amdgcn-amd-amdhsa-gfx906.bc
-main-hip-amdgcn-amd-amdhsa-gfx906.hipi
-main-hip-amdgcn-amd-amdhsa-gfx906.o
-main-hip-amdgcn-amd-amdhsa-gfx906.out
-main-hip-amdgcn-amd-amdhsa-gfx906.out.resolution.txt
-main-hip-amdgcn-amd-amdhsa-gfx906.s
-```
-
-Files with the .s extension hold the disassembled contents of the binary and the filename directly informs us of the graphics IPs used by the compiler.
-**Following code does:** This code snippet is written in C++ and its purpose is to print the numbers from 0 to 3 sequentially. It uses a `for` loop to iterate over a range of integers starting from 0 up to, but not including, 4. During each iteration, it prints the current value of the loop variable `i` using the `printf` function.
-
-
-```
-main-hip-amdgcn-amd-amdsha-gfx906.out
-main-hip-amdgcn-amd-amdsha-gfx906.out.resolution.txt
-main-hip-amdgcn-amd-amdsha-gfx906.s
-
-Files with the.s extension hold the disassembled contents of the binary and the filename directly informs us of the
-graphics IPs used by the compiler.
-
-Get-ChildItem main-hip-*.s | Get-Content
-           .text
-           .amdgcn_target "amdgcn-amd-amdsha--gfx906"
-           .protected        _Z12saxpy_kernelPKfPfj ; -- Begin  function _Z12saxpy_
-  --kernelPKfPfj
-           .glob1   _Z12saxpy_kernelPKfPfj
-           .p2align           8
-           .type     _Z12saxpy_kernelPKfPfj,@function
-_Z12saxpy_kernelPKfPfj:                                                                                                                                                                                                        
-  ; %bb.0:
-            s_load_dword s0, s[4:5], 0x4
-            s_load_dword s1, s[6:7], 0x18
-            s_waitcnt lgkmcnt(0)
-            s_and_b32 s0, s0, 0xffff
-            s_mul_i32 s8, s8, s0
-            v_add_u32_e32 v0, s8, v0
-            v_cmp_gt_u32_e32 vcc,  s1, v0
-            s_and_saveexec_b64 s[0:1], vcc
-            s_cbranch_execz.LBB0_2
-  ; %bb.1:
-            s_load_dwordx4 s[0:3], s[6:7], 0x8
-            v_mov_b32_e32 v1, 0
-            v_lshlrev_b64 v[0:1], 2, v[0:1]
-            s_waitcnt lgkmcnt(0)
-            v_mov_b32_e32 v3, s1
-            v_add_co_u32_e32 v2, vcc, s0, v0
-            v_addc_co_u32_e32 v3, vcc, v3, v1, vcc
-            global_load_dword v2, v[2:3], off
-            v_mov_b32_e32 v3, s3
-            v_add_co_u32_e32 v0, vcc, s2, v0
-            v_addc_co_u32_e32 v1, vcc, v3, v1, vcc
-            global_load_dword v3, v[0:1], off
-            s_load_dword s0, s[6:7], 0x0
-            s_waitcnt vmcnt(0) lgkmcnt(0)
-            v_fmac_f32_e32 v3, s0, v2
-            global_store_dword v[0:1], v3, off
- .LBB0_2:
-            s_endpgm
-           ...
-```
-
-## Windows and NVIDIA
-
-Unlike HIP on AMD, when compiling using the NVIDIA support for HIP, the resulting binary will be a valid CUDA executable. Therefore, it'll incorporate PTX ISA (Parallel Thread eXecution Instruction Set Architecture) instead of AMDGPU binary. As a result, tooling included with the CUDA SDK can be used to inspect which device ISA was compiled into a specific executable. The most helpful to us currently is cuobjdump .
-**Following code does:** This code snippet is a portion of assembly code that is part of a function, likely the `main` function of a program. It primarily performs the following actions:
-
-1. It saves the `rbx` register onto the stack to preserve its value.
-2. It loads the address of a string (likely a format string) into the `rbx` register.
-3. It sets up arguments for the `printf` function call by moving the address of the string into the `rdi` register and zeroing out the `esi` and `eax` registers, which are used for additional arguments and return values, respectively.
-4. It calls the `printf` function twice, first with `esi` set to zero and then with `esi` set to one, likely printing the same string twice with different formatting or arguments.
-5. The code does not show the complete function, but it is likely part of a simple program that prints a string to the console using the `printf` function from the C standard library.
-
-Overall, the code is focused on printing a string to the console using the `printf` function.
-
-
-```
-<_Bash_>
-```
-**Following code does:** This code snippet is a fragment of assembly code, likely generated by the GCC compiler, that involves calling the `printf` function twice. The purpose of this code is to print two integers to the standard output using the format string "%d". 
-
-1. The first `printf` call prints the integer `2`.
-2. The second `printf` call prints the integer `3`.
-
-The code uses the `printf` function from the Procedure Linkage Table (PLT), which is a common technique in dynamically linked executables to resolve function addresses at runtime. The `xor eax, eax` instructions are used to set the `eax` register to zero, which is a common way to prepare for a function call in x86-64 assembly. The `pop rbx` and `ret` instructions are used to restore the base pointer and return from the function, respectively.
-
-
-```
-| P T X \ f i l e
-```
-**Following code does:** This code is a low-level assembly representation of a simple C program that prints the numbers 0 through 3, each on a new line. It uses a loop to increment a counter (`ebx`) from 0 to 3, and in each iteration, it calls the `printf` function to print the current value of the counter. The loop continues until the counter reaches 4, at which point the program exits. The `.string "%d"` is used as the format string for `printf` to print integers.
-
-
-```
-1:  saxpy. 1. sm_5. ptx
-```
-
-This example shows that the SAXPY kernel is stored as sm\_52 . It also shows that a compute capability 5.2 ISA was embedded into the executable, so devices that support compute capability 5.2 or newer will be able to run this code.
-
-Now that you've found what binary got embedded into the executable, find which format our available devices use.
-
-## Linux and AMD
-
-On Linux a utility called rocminfo helps us list all the properties of the devices available on the system, including which version of graphics IP ( gfxXYZ ) they employ. You can filter the output to have only these lines:
-**Following code does:** This code is an assembly routine for a function named `main`, likely compiled from a C/C++ program using the Microsoft Visual C++ (MSVC) compiler. The function's high-level purpose is to print a string (referred to as `'string'` in the code) four times using a loop. It uses the `printf` function to output the string. The loop is controlled by the `ebx` register, which is incremented each iteration until it reaches 4. The function sets up and cleans up the stack frame before and after the loop, respectively, and returns 0 upon completion.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?php?com/bin/rocminfo | grep gfx
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        </?php?com/bin/rocminfo | grep gfx
-                                                                                                                                                                                        
-	              Name:                                                                                                                                                                                                        &
-```
-
-Now that you know which graphics IPs our devices use, recompile your program with the appropriate parameters.
-**Following code does:** This code snippet sequentially prints the integers 0, 1, 2, and 3 to the standard output. Each `printf` function call outputs one integer, formatted as a decimal integer (`%d`).
-
-
-```
-                                                                                                                                                                                                        |                                                                                                                                                                                                       
-                                                                                                                                                                                                        -                                                                                                                                                                                                        --                                                                                                                                                                                                        \                                                                                                                                                                                                        +                                                                                                                                                                                                        <                                                                                                                                                                                                        </                                                                                                                                                                                                        }                                                                                                                                                                                                        >                                                                                                                                                                                                        &                                                                                                                                                                                                        )                                                                                                                                                                                                        ]                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        :                                                                                                                                                                                                        ;                                                                                                                                                                                                       .                                                                                                                                                                                                        "
-```
-
-Now the sample will run.
-**Following code does:** The code snippet appears to be an incorrectly formatted XML declaration. It contains two XML declaration lines, which are not valid in XML syntax. The first line is a correctly formatted XML declaration, while the second line is incorrectly closed with a question mark before the "xml" keyword. This snippet does not perform any functional operation and would likely result in a parsing error if used in an XML document.
-
-
-```
-        /saxpy
-        Calculating y[i] = a * x[i] + y[i] over 10000000 elements.
-        First 10 elements of the results: [ 3, 5, 7, 9, 11, 13, 15, 17, 19, 21 ]
-```
-**Following code does:** This code snippet is written in C++ and is used in a GPU programming context, likely with the HIP (Heterogeneous-Compute Interface for Portability) API, which is used for writing portable code across AMD and NVIDIA GPUs. The code retrieves the warp size from the device properties and uses a switch statement to launch a GPU kernel with a template parameter that matches the warp size. Specifically, if the warp size is 32, it launches a kernel with a template argument of 32; if the warp size is 64, it launches a kernel with a template argument of 64. This allows the kernel to be optimized based on the warp size of the GPU being used.
-
-
-```
-<_Python_>
-```
-
-## Linux and NVIDIA
-
-On Linux HIP with the NVIDIA back-end, the deviceQuery CUDA SDK sample can help us list all the properties of the devices available on the system, including which version of compute capability a device sports. &lt;major&gt;.&lt;minor&gt; compute capability is passed to nvcc on the command-line as sm\_&lt;major&gt;&lt;minor&gt; , for eg. 8.6 is sm\_86 .
-
-Because it's not included as a binary, compile the matching example from ROCm.
-**Following code does:** This code snippet is a template-based mechanism that uses a static switch to select between different compile-time options for a CUDA or HIP kernel launch. Specifically, it uses `tmp::static_switch` to choose between two possible values for `warp_size` (32 or 64). Depending on the selected value, it launches a GPU kernel (`kernel`) with the corresponding warp size as a template parameter. This allows the code to optimize the kernel execution for different warp sizes at compile time, potentially improving performance by tailoring the execution to the specific hardware configuration.
-
-
-```
-                                                                                                                                                                                                        |                                                                                                                                                                                                       
-                                                                                                                                                                                                        <.02                                                                                                                                                                                                        </.00                                                                                                                                                                                                        >.00                                                                                                                                                                                                      <.00                                                                                                                                                                                                      </.01                                                                                                                                                                                                        }
-```
-
-Filter the output to have only the lines of interest, for example:
-**Following code does:** The code snippet appears to be incomplete or malformed. It seems to be missing context or additional code that would clarify its purpose. The snippet includes a generic placeholder `t WarpSize>()`, which might suggest a template or a function call in a language like C++ rather than Python. However, without additional context or surrounding code, it's not possible to determine its high-level purpose or functionality.
-
-
-```
-<_YAML_>
-```
-
-Note: In addition to the nvcc executable is another tool called \_\_nvcc\_device\_query which prints the SM Architecture numbers to standard out as a comma separated list of numbers. The utility's name suggests it's not a user-facing executable but is used by nvcc to determine what devices are in the system at hand.
-
-Now that you know which graphics IPs our devices use, recompile your program with the appropriate parameters.
-**Following code does:** This code snippet is a modification of a GPU kernel function written in HIP (Heterogeneous-Compute Interface for Portability), which is used for parallel computing on AMD and NVIDIA GPUs. The changes introduce a template parameter `WarpSize` to the kernel, allowing it to handle different warp sizes (32 for NVIDIA and RDNA AMD GPUs, 64 for CDNA AMD GPUs) more flexibly. The shared memory reduction loop is adjusted to stop at the warp size, and a new warp-level reduction is added using a static loop unrolling technique (`tmp::static_for`). This ensures that the kernel can efficiently perform reductions across threads within a warp, adapting to the specific warp size of the target hardware.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <_arch=sm_70,sm_86
-```
-
-Note: If you want to portably target the development machine which is compiling, you may specify -arch=native instead.
-
-Now the sample will run.
-**Following code does:** It seems there is a formatting error in your request. The code snippet is labeled as C++ but is enclosed within Python code tags. Please provide the correct code snippet or clarify the language so I can assist you accurately.
-
-
-```
-           ./saxpy
-            Calculating y[i] = a * x[i] + y[i] over 10000000 elements.
-            First 10 elements of the results: [ 3, 5, 7, 9, 11, 13, 15, 17, 19, 21 ]
-```
-
-## Windows and AMD
-
-On Windows, a utility called hipInfo.exe helps us list all the properties of the devices available on the system, including which version of graphics IP ( gfxXYZ ) they employ. Filter the output to have only these lines:
-**Following code does:** The provided code snippet appears to be a collection of random characters and symbols, including some that resemble HTML/XML tags and others that are typical in programming syntax. However, it does not form any valid or meaningful code in Python or any other programming language. It seems to be a nonsensical or corrupted text rather than a functional code snippet.
-
-
-```
-& ${env:HIP_PATH}bin\hipInfo.exe | Select-String gfx
-
-gcnArchName:                    gfx1032
-gcnArchName:                    gfx1035
-```
-
-Now that you know which graphics IPs our devices use, recompile your program with the appropriate parameters.
-**Following code does:** The code snippet provided is incomplete and contains only a comment: `// Warp reduction`. This comment suggests that the code is likely part of a larger program, possibly written in a language like CUDA C/C++ for GPU programming, where "warp reduction" is a common technique. Warp reduction is used to efficiently perform parallel reduction operations (such as summing elements) within a warp, which is a group of threads that execute the same instruction simultaneously on a GPU. However, without additional context or code, it's not possible to describe the specific implementation or purpose beyond this general concept.
-
-
-```
-                                                                                                                                                                                                        |clang++.\HIP-Basic\saxpy\main.hip -o saxpy.exe -I.\Common -lamdhip64 -L ${env:HIP_PATH}                                                                                                                                                                                                       
-                                                                                                                                                                                                        -lib -02 --offload-arch=gfx1032 --offload-arch=gfx1035                                                                                                                                                                                                        --lib -02 --offload-arch=gfx1035
-```
-
-Now the sample will run.
-**Following code does:** The provided code snippet is a partial definition of a CUDA kernel function template in C++. This kernel is designed to be executed on a GPU. It uses template parameters to allow flexibility in specifying the block size, warp size, data type, and operation type. The kernel function, named `kernel`, takes several parameters: pointers to two arrays (`front` and `back`), an operation (`op`), a zero element (`zero_elem`), and the size of the `front` array (`front_size`). The `__launch_bounds__(BlockSize)` attribute is used to specify the maximum number of threads per block, optimizing the kernel's execution configuration. The actual implementation of the kernel is not provided in the snippet.
-
-
-```
-       .\saxpy.exe
-        Calculating y[i] = a * x[i] + y[i] over 10000000 elements.
-        First 10 elements of the results: [ 3, 5, 7, 9, 11, 13, 15, 17, 19, 21 ]
-```
-
-## Windows and NVIDIA
-
-On Windows HIP with the NVIDIA back-end, the deviceQuery CUDASDKsample can help us list all the properties of the devices available on the system, including which version of compute capability a device sports. &lt;major&gt;. &lt;minor&gt; compute capability is passed to nvcc on the command-line as sm\_&lt;major&gt;&lt;minor&gt; , for eg. 8.6 is sm\_86 .
-
-Because it's not included as a binary, compile the matching example from ROCm.
-**Following code does:** This code snippet is part of a CUDA kernel designed for parallel computation on a GPU. It involves reading data from a global memory buffer (`front`) and performing operations on it using shared memory to optimize performance. Here's a high-level summary of what the code does:
-
-1. **Warp and Block Configuration**: It calculates the number of warps (`WarpCount`) within a block based on the block size and warp size. Warps are groups of threads that execute instructions in lockstep.
-
-2. **Shared Memory Allocation**: It allocates shared memory (`shared`) for storing intermediate results. The size of this shared memory is determined by the number of warps in the block.
-
-3. **Safe Reading Functions**: It defines two lambda functions, `read_global_safe` and `read_shared_safe`, to safely read elements from global and shared memory, respectively. These functions ensure that reads do not exceed the bounds of the memory arrays.
-
-4. **Thread and Block Indexing**: It calculates various indices (`tid`, `bid`, `gid`, `wid`, `lid`) to identify the thread's position within the block and grid. These indices are used to determine which data elements each thread should process.
-
-5. **Data Processing**: Each thread reads two elements from the global memory (`front`) using the `read_global_safe` function and applies an operation (`op`) on them. The result is stored in a local variable (`res`).
-
-Overall, this code is part of a larger CUDA kernel that performs parallel data processing using shared memory to improve performance by reducing global memory accesses. The use of shared memory allows for efficient communication of results between threads within the same block.
-
-
-```
-                                                                                                                                                                                                        |nvcc.\HIP-Basic\device_query\main.cpp -o device_query.exe -I.\Common -I ${env:HIP_PATH}                                                                                                                                                                                                       
-                                                                                                                                                                                                        -include -02                                                                                                                                                                                                        --include -0022
-```
-
-Filter the output to have only the lines of interest, for example:
-**Following code does:** This code snippet appears to be part of a parallel computing or multi-threading context, likely using a GPU or a similar architecture where threads are organized into blocks. The code checks if the current thread's identifier (`tid`) is zero, which typically means it is the first thread in a block. If this condition is true, it writes a computed result (`res`) from local memory to a shared or global memory location (`back`) indexed by the block identifier (`bid`). This pattern is often used to consolidate results from multiple threads within a block into a single output.
-
-
-```
- .\device_query.exe | Select-String "major.minor"
-
-  major.minor:              8.6
-  major.minor:              7.0
-```
-
-Note: Next to the nvcc executable is another tool called \_\_nvcc\_device\_query.exe which simply prints the SM Architecture numbers to standard out as a comma separated list of numbers. The naming of this utility suggests it's not a user facing executable but is used by nvcc to determine what devices are in the system at hand.
-
-Now that you know which graphics IPs our devices use, recompile your program with the appropriate parameters.
-**Following code does:** The code snippet appears to be incomplete and contains a syntax error. It seems like it might be part of a larger piece of code, possibly involving threading or parallel processing, given the mention of "ItemsPerThread". However, without additional context or complete code, it's not possible to determine its high-level purpose.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        --x                                                                                                                                                                                                        -x
-```
-
-Note: If you want to portably target the development machine which is compiling, you may specify -arch=native instead.
-
-Now the sample will run.
-**Following code does:** The code snippet provided is a fragment of a CUDA kernel function declaration in C++. CUDA is a parallel computing platform and application programming interface model created by NVIDIA. The purpose of this code is to define a GPU kernel function that can be executed on an NVIDIA GPU.
-
-- `__global__`: This keyword indicates that the function is a CUDA kernel, which means it is executed on the GPU but can be called from the host (CPU) code.
-- `static`: This keyword suggests that the kernel function has internal linkage, meaning it is only visible within the translation unit it is defined in.
-- `__launch_bounds__(BlockSize)`: This is an optional CUDA attribute that specifies the maximum number of threads per block (`BlockSize`) that the kernel is optimized for. It helps the compiler optimize the kernel for specific execution configurations.
-
-The ellipsis (`...`) indicates that the function's parameters and body are not shown. Overall, this snippet is part of a larger CUDA program designed to perform parallel computations on a GPU.
-
-
-```
-       .\saxpy.exe
-        Calculating y[i] = a * x[i] + y[i] over 10000000 elements.
-        First 10 elements of the results: [ 3, 5, 7, 9, 11, 13, 15, 17, 19, 21 ]
-```
-**Following code does:** The code snippet `<_C_>` appears to be a placeholder or a symbolic representation rather than actual executable code. It does not perform any operations or have any functionality in Python as it stands. It might be used as a marker or a template in a larger context where specific code or content is meant to be inserted.
-
-
-```
-<_Python_>
-```
-
-## CHAPTER
-
-## TWENTYNINE
-
-## REDUCTION
-
-Reduction is a common algorithmic operation used in parallel programming to reduce an array of elements into a shorter array of elements or a single value. This document exploits reduction to introduce some key considerations while designing and optimizing GPU algorithms.
-
-This document is a rejuvenation and extension of the invaluable work of Mark Harris. While the author approaches the topic with a less naive approach, reviewing some original material is valuable to see how much the underlying hardware has changed. This document provides a greater insight to demonstrate progress.
-
-## 29.1 The algorithm
-
-Reduction has many names depending on the domain; in functional programming it's referred to as fold, in C++, it's called std::accumulate and in C++17, as std::reduce . A reduction takes a range of inputs and 'reduces' the given range with a binary operation to a singular or scalar output. Canonically, a reduction requires a 'zero' element that bootstraps the algorithm and serves as one of the initial operands to the binary operation. The 'zero' element is generally called identity or neutral element in the group theory, which implies that it is an operand that doesn't change the result. Some typical use cases are: calculating a sum or normalizing a dataset and finding the maximum value in the dataset. The latter use case is discussed further in this tutorial.
-
-There are multiple variations of reduction that allow parallel processing. The approach taken by std::reduce requires the user-provided binary operator to operate on any combination of identity and input range elements, or even exclusively on any of them. This allows you to insert any number of identities to facilitate parallel processing and then combine the partial results of parallel execution.
-
-## 29.2 Reduction on GPUs
-
-Implementing reductions on GPUs requires a basic understanding of the /understand/programming\_model\_reference. The document explores aspects of low-level optimization best discussed through the Inherent thread model , and refrains from using cooperative groups.
-
-Synchronizing parallel threads of execution across a GPU is crucial for correctness as the partial results can't be synchronized before they manifest. Synchronizing all the threads running on a GPU at any given time is possible, however, it is a costly and intricate operation. If synchronization is not absolutely necessary, map the parallel algorithm so that multiprocessors and blocks can make independent progress and need not sync frequently.
-
-There are ten reduction implementations in the rocm-examples, which are described in the following sections.
-
-## 29.2.1 Naive shared reduction
-
-The naive algorithm takes a tree-like shape, where the computational domain is purposefully distributed among blocks. In all blocks, all threads participate in loading data from persistent (from the kernel's perspective) global memory into the shared memory. This helps to perform tree-like reduction for a single thread by writing the partial result to global, in a location unique to the block, which allows the block to make independent progress. The partial results are combined in subsequent launches of the same kernel until a scalar result is reached.
-
-This approach requires temporary storage based on the number of blocks launched, as each block outputs a scalar partial result. Depending on the need to store or destroy the input, a second temporary storage might be needed, which could be large enough to store the results of the second kernel launch. Alternatively, you can reuse the storage of the larger than necessary original input. These implementations differ so slightly that the document only considers the use case where the input could be destroyed.
-**Following code does:** The code snippet defines a lambda function `read_global_safe` in C++ that reads a sequence of elements from an array `front` into a static array of a specified size `ItemsPerThread`. The lambda uses a template parameter pack and `std::integer_sequence` to iterate over indices. If the index plus the number of items per thread is within the bounds of `front_size`, it directly loads elements from `front`. Otherwise, it loads elements conditionally, substituting a `zero_elem` for out-of-bounds indices. This ensures safe reading from the array without exceeding its bounds.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <std::size_t factor = block_size; // block_size from hipGetDeviceProperties()
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        </std::endl;
-                                                                                                                                                                                                       <int>                                                                                                                                                                                                        //                                                                                                                                                                                                       	                                                                                                                                                                                                      
-//                                                                                                                                                                                                        +                                                                                                                                                                                                        -                                                                                                                                                                                                        *                                                                                                                                                                                                        /                                                                                                                                                                                                        */
-                                                                                                                                                                                                       +
-                                                                                                                                                                                                       *
-                                                                                                                                                                                                       -
-                                                                                                                                                                                                       */
-```
-
-For threads that don't have unique inputs, feed zero\_elem instances to threads. The backing of double-buffering is allocated as such:
-**Following code does:** This code snippet initializes an array `arr` of size 4 with elements from another array or list called `front`. The elements are selected based on an index `gid`, such that `arr` contains four consecutive elements starting from `front[gid]` to `front[gid + 3]`. The type of the elements in `arr` is denoted by `T`, which suggests that this code is likely written in a language that uses templates or generics, such as C++ or a similar language. The purpose of this code is to create a subarray or slice of four elements from the `front` array starting at a specific index `gid`.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <void>                                                                                                                                                                                                        </void>                                                                                                                                                                                                     
- 
-                                                                                                                                                                                                      <void><void>                                                                                                                                                                                                      <void></void>                                                                                                                                                                                                     
-
- 
-                                                                                                                                                                                                     
- 
-
-                                                                                                                                                                                                      <void>"                                                                                                                                                                                                        >void>                                                                                                                                                                                                      </void></void>                                                                                                                                                                                                    <void> 
-                                                                                                                                                                                                      </void><void>                                                                                                                                                                                                    <void></void></void>                                                                                                                                                                                                   
-   
-                                                                                                                                                                                                    <void>
-```
-
-Data is initialized on the host and dispatched to the device followed by the commencement of device-side reduction. The swapping of the double-buffer on the last iteration is omitted, therefore the result is in the back-buffer irrespective of the input size.
-**Following code does:** This code snippet initializes an array `arr` of size 4 with elements from another array `front`. It uses a conditional expression to fill each position in `arr`. For each index `i` from 0 to 3, it checks if `i` is within the bounds of `front` (i.e., `i < front_size`). If it is, the corresponding element from `front` is used; otherwise, a default value `zero_elem` is used. This effectively copies up to four elements from `front` into `arr`, filling any out-of-bounds positions with `zero_elem`.
-
-
-```
-of the input size.
-
-for (uint32_t curr = input_count; curr > 1;)
-{
-      hipLaunchKernelGGL(
-           kernel,
-           dim3(new_size(curr)),
-           dim3(block_size),
-           factor * sizeof(unsigned),
-           hipStreamDefault,
-           front,
-           back,
-           kernel_op,
-```
-**Following code does:** This code snippet appears to be a series of empty lines with a placeholder or invalid tag `<?>` in the middle. It doesn't perform any functional operation or have any meaningful purpose in its current form. It might be intended as a placeholder or a template for future code development.
-
-
-```
-1;)
-```
-
-(continues on next page)
-
-(continued from previous page)
-**Following code does:** This code snippet is a host-side reference implementation of a reduction operation typically executed on a GPU. It processes an input vector of unsigned integers by dividing it into partitions of a specified size (`partition_size`). For each partition, it calculates the sum of its elements and stores the result in a new vector (`result`). The size of the result vector is determined by dividing the total input size by the partition size, effectively reducing the input data by aggregating sums of each partition. This operation is useful for tasks like parallel processing where data needs to be reduced or aggregated efficiently.
-
-
-```
-        zero_elem,
-        curr);
-
-     curr = new_size(curr);
-     if (curr > 1)
-        std::swap(front, back);
-}
-```
-
-This structure persists in the kernel throughout all the variations of reduction with slight modifications to factor and shared memory allocation:
-**Following code does:** The code snippet appears to be part of a function in a programming language that uses semicolons to terminate statements, likely C, C++, or Java. It seems to be iterating over some collection or array, assigning a value `partition_result` to an element at index `i` in an array or list called `result`. After the loop completes, the function returns the `result` array or list. The high-level purpose of this code is to populate the `result` array with values computed or retrieved during the loop and then return this populated array.
-
-
-```
-<_Cuda_>
-```
-
-While the tid % (2 * i) == 0 indexing scheme yields correct results, it also leads to high thread divergence. Thread divergence indicates the event when the threads in a warp diverge, which implies that the threads have to execute different instructions in a given clock cycle. This is easily manifested using if-else statements as shown here, but can also be manifested as for loop dependent on thread ID lengths. Even though the number of active threads participating in the reduction reduces, warps remain active longer than necessary, as at least one lane in a warp hits the if statement.
-
-## 29.2.2 Reducing thread divergence
-
-You can reduce divergence by keeping dataflow between memory addresses identical but reassigning the thread ids.
-**Following code does:** The provided code snippet is a CUDA device function named `reduce_sum` that performs a parallel reduction to compute the sum of unsigned integer values within a thread group using shared memory. The function takes a `thread_group` object `g`, a shared memory pointer `x`, and an unsigned integer `val` as inputs. It uses a loop to iteratively halve the number of active threads, synchronizing them at each step, and accumulates the sum of values from different threads. The final result of the reduction is stored in the first thread of the group, while other threads return 0. This function is typically used in GPU programming to efficiently compute sums across threads in a block or custom partition.
-
-
-```
-// Shared reduction
-for (uint32_t i = 1; i < blockDim.x; i *= 2)
-{
--    if (tid % (2 * i) == 0)
--        shared[tid] = op(shared[tid], shared[tid + i]);
-+    if (uint32_t j = 2 * i * tid; j < blockDim.x)
-+        shared[j] = op(shared[j], shared[j + i]);
-    __syncthreads();
-}
-```
-
-This way inactive threads start accumulating uniformly towards the higher thread ID index range and might uniformly skip to \_\_syncthreads() . However, this introduces a bank conflicts issue.
-
-## 29.2.3 Resolving bank conflicts
-
-Both AMD and NVIDIA implement shared memory in the hardware by organizing storage into banks of various sizes. This hardware element is known as Local Data Share (LDS) on AMD hardware. On NVIDIA hardware, it's implemented using the same silicon as the L1 data cache. You can think of shared memory as a striped 2-dimensional range of memory. Shared memory bank's count, width, and depth depend on the architecture. A bank conflict occurs when different threads in a warp access the same bank during the same operation. In this case, the hardware prevents the attempted concurrent accesses to the same bank by converting them into serial accesses.
-
-- 'AMD Instinct MI200' Instruction Set Architecture, Chapter 11.1
-- 'RDNA 2' Instruction Set Architecture, Chapter 10.1
-
-A notable exception is when the shared read uniformly broadcasts to the same address across the entire warp. A better implementation of the naive algorithm is to form continuous ranges of the threads activities and their memory accesses.
-**Following code does:** This code snippet is part of a CUDA program, which is designed to run on NVIDIA GPUs. Its high-level purpose is to set up a parallel computation environment using CUDA's thread block and shared memory features. Specifically, it:
-
-1. Declares shared memory (`workspace`) to be used by threads within a block for operations like reduction, which is a common parallel algorithm for combining elements (e.g., summing an array).
-2. Defines a `thread_block` object (`thread_block_group`) that represents all threads within a CUDA block, allowing them to coordinate and share data.
-3. Loads an input value from global memory (`d_vector`) into a local variable (`input`) for each thread, based on the thread's rank within the block.
-4. Creates a `custom_partition` of threads within the block, where each partition consists of 16 threads. This partitioning allows for more fine-grained control over thread collaboration and data sharing within the block.
-
-Overall, the code sets up the necessary structures for performing parallel computations on a GPU, leveraging shared memory and thread coordination to optimize performance.
-
-
-```
-
-        implementation of the naive algorithm is to form continuous ranges of the threads activ
-        
-        // Shared reduction
-        -for (uint32_t i = 1; i < blockDim.x; i *= 2)
-        -{
-        -                                                                                                                                                                                                        
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        -f                                                                                                                                                                                                        +f
-```
-
-Note: To avoid bank conflicts, read shared memory in a coalesced manner, which implies that reads/writes of each lane in a warp evaluate to consecutive locations. Analyzing the read/write patterns could help you to understand the cause of bank conflicts. For more details, check CDNA3 ISA or RDNA3 ISA data share operations chapter.
-
-## 29.2.4 Utilize upper half of the block
-
-The preceding implementation is free of low-level GPU-specific anti-patterns. However, it still exhibits some common shortcomings. The loop performing the reduction in the shared memory starts from i = blockDim.x / 2 and the first predicate if (tid &lt; i) immediately disables half of the block, which only helps load the data into the shared memory. You can change the kernel along with the calculation of factor on the host, as shown here:
-**Following code does:** This code snippet performs a parallel reduction operation on a set of input data using a thread block group, which is a collection of threads that work together. The `reduce_sum` function aggregates the input data into a single sum, storing the result in the `output` variable. After the reduction, only the first thread in the thread block group (determined by checking if its rank is 0) writes the computed sum to the first element of the `d_block_reduced_vector` array. This ensures that only one thread outputs the final reduced value, preventing race conditions or redundant writes.
-
-
-```
-<_Cuda_>
-```
-
-By eliminating half of the threads and giving meaningful work to all the threads by unconditionally performing a binary op , you can prevent the wastage of half of the threads.
-
-Even though global memory is read in a coalesced fashion, as preferred by the memory controller, optimal performance is still limited by the instruction throughput. Omit superfluous synchronization -----------
-
-Warps are known to execute in a strict lockstep fashion. Therefore, once shared reduction reaches a point where only a single warp participates meaningfully, you can cut short the loop and let the rest of the warps terminate. Moreover, you can also unroll the loop without syncing the entire block.
-
-The tmp namespace used beyond this point in this document holds a handful of template meta-programmed utilities to facilitate writing flexible and optimal code.
-
-tmp::static\_for is not just a constant folding within the optimizer but a variation of the language for loop, where the running index is a compile-time constant and is eligible for use in compile-time evaluated contexts.
-
-Consider the following code:
-**Following code does:** This code snippet appears to be part of a parallel computing or GPU programming context, where it performs a reduction operation. The `reduce_sum` function is used to sum elements within a specified partition of data. The `custom_partition` likely defines how the data is divided, and `workspace[group_offset]` and `input` are the data sources involved in the reduction. The comment indicates that only the first thread in each partition will return a valid result, which is a common pattern in parallel reductions to ensure that only one thread writes the final result of the reduction for each partition.
-
-
-```
-constexpr int size = 4;
-for (int i = 0 ; i < size ; ++i)
-{
-    printf("%d", i);
-}
-```
-
-This compiles to the following binaries:
-
-## LLVM Block
-**Following code does:** This code snippet appears to be part of a parallel computing operation, likely using CUDA or a similar framework for GPU programming. The code calculates a `partition_id` for a thread within a block by dividing the thread's rank by a constant `PartitionSize`. It then assigns a value `output` to an element in the `d_partition_reduced_vector` array at the index corresponding to this `partition_id`. The purpose is to organize or reduce data into partitions based on thread ranks within a block.
-
-
-```
-LLVM Block
-main:
-    push    rbx
-    lea      rbx, [rip +.L.str]
-    mov     rdi, rbx
-    xor     esi, esi
-    xor     eax, eax
-    call    printf@PLT
-    mov     rdi, rbx
-    mov     esi, 1
-    xor     eax, eax
-    call    printf@PLT
-    mov     rdi, rbx
-```
-
-(continues on next page)
-**Following code does:** It seems there is a formatting error in your request. The code snippet is labeled as Python, but it contains a placeholder that suggests it might be C++ code. Please provide the actual code snippet you would like me to analyze, and I'll be happy to help!
-
-
-```
-      mov     esi, 2
-      xor     eax, eax
-      call    printf@PLT
-      mov     rdi, rbx
-      mov     esi, 3
-      xor     eax, eax
-      call    printf@PLT
-      xor     eax, eax
-      pop     rbx
-      ret
-.L.str:
-     .asciz  "%d"
-      
- GCC
-```
-
-## GCC
-**Following code does:** The code snippet `<_C_>` appears to be incomplete or not a valid Python code. It does not represent any known Python syntax or construct. It might be a placeholder or a typo. Without additional context or surrounding code, it's not possible to determine its purpose or functionality.
-
-
-```
-  GCC
- .LC0:
-     .string "%d"
-  main:
-      push    rbx
-      xor     ebx, ebx
- .L2:
-      mov     esi, ebx
-      mov     edi, 0FFSET FLAT:.LC0
-      xor     eax, eax
-      add     ebx, 1
-      call    printf
-      cmp     ebx, 4
-      jne    .L2
-      xor     eax, eax
-      pop     rbx
-      ret
-
-  MSVC
-```
-
-## MSVC
-**Following code does:** This code snippet is part of a program that uses the HIP (Heterogeneous-Compute Interface for Portability) API to launch a cooperative kernel on a GPU. The cooperative kernel is likely designed to perform a reduction operation on a vector, as suggested by the variable names. The `hipLaunchCooperativeKernel` function is used to initiate the execution of the `vector_reduce_kernel` on the GPU, with `params` being an array of pointers to the data structures (`d_vector`, `d_block_reduced`, and `d_partition_reduced`) that the kernel will operate on. The cooperative groups API allows for more efficient synchronization and communication between threads within a GPU kernel.
-
-
-```
-  MSVC
-
-main     PROC
-      $LN12:
-      push    rbx
-      sub     rsp, 32
-      xor     ebx, ebx
-      npad    8
-  $LL4@main:
-      mov     edx, ebx
-      lea     rcx, OFFSET FLAT:'string'
-      call    printf
-      inc     ebx
-      cmp     ebx, 4
-      jl      SHORT $LL4@main
-      xor     eax, eax
-      add     rsp, 32
-      pop     rbx
-      ret     0
-  main    ENDP
-```
-
-(continued from previous page)
-
-LLVM unrolls the loop and compiles to a flat series of printf invocations, while both GCC and MSVC keep the loop intact, as visible from the compare ( cmp ) and the jump ( jne , jl ) instructions. LLVM code generation is identical to manually writing the unrolled loop:
-**Following code does:** The provided snippet appears to be incomplete and lacks any functional code. It only contains a comment line that reads "* For HIP". This suggests that the code might be related to or intended for use with HIP, which is a C++ runtime API and kernel language that allows developers to create portable applications that can run on AMD and NVIDIA GPUs. However, without additional context or code, it's not possible to determine any specific functionality or purpose.
-
-
-```
-printf("%d", 0);
-printf("%d", 1);
-printf("%d", 2);
-printf("%d", 3);
-```
-
-While various non-standard pragmas are available to hint or force the compiler to unroll the loop, we instead use template meta-programming to force feed the compiler the unrolled loop.
-**Following code does:** The code snippet `<_Bash_>` appears to be a placeholder or a tag indicating that a section of code written in the Bash scripting language should be inserted or is expected in that location. It does not perform any operations or have any functionality on its own. Instead, it likely serves as a marker for where Bash code should be included or referenced in a larger context, such as in documentation, a template, or a code generation tool.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?xml version="1.0" encoding="UTF-8" />
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        </?xml version="1.0" encoding="UTF-8" />
-```
-
-The most notable structural difference is that in the language for loop, the loop variable is given a name in the beginning, while in the static\_for utility, the loop variable is given a name in the end. An important bonus is that in the loop's body, you can use the running index i in contexts requiring constant expressions such as template arguments or inside if constexpr .
-
-tmp::static\_switch takes runtime value and runtime dispatches to a range of set of tabulated functions, where said value is a compile-time constant and is eligible for use in compile-time evaluated contexts.
-
-Consider the following code:
-**Following code does:** It seems there is a misunderstanding in the code snippet provided. The snippet `<_Haskell_>` does not represent valid Python code or any executable code in any programming language. It appears to be a placeholder or a tag indicating that Haskell code might be expected or referenced. If you intended to provide a Haskell code snippet, please share the correct code so I can help explain its purpose.
-
-
-```
-        Consider the following code:
-
-        int  warp_size  = device_props.warpSize;
-
-        switch  (warp_size)
-
-        {
-
-        case  32:
-
-            hipLaunchKernelGGL(kernel<32>, ...);
-
-            break;
-
-        case  64:
-
-            hipLaunchKernelGGL(kernel<64>, ...);
-
-            break;
-
-        }
-```
-
-In the preceding code, note the code repetition for all possible values of warp\_size , the code is prepared to handle. To avoid this, use tmp::static\_switch , as shown:
-**Following code does:** This code snippet appears to be a series of empty lines with a placeholder or invalid tag `<?>` in the middle. It doesn't perform any functional operation or have any meaningful purpose in its current form. It might be intended as a placeholder or template for further development, but as it stands, it doesn't execute any logic or serve a specific function.
-
-
-```
-  tmp::static_switch<std::array{32, 64}>(warp_size, [&]<int WarpSize>
-  {
-      hipLaunchKernelGGL(kernel<WarpSize>,...);
-  });
-```
-**Following code does:** The code snippet `<_Bash_>` appears to be a placeholder or a formatting artifact rather than actual executable code. It does not perform any operations or have any functionality as it stands. If this is meant to indicate a section where Bash code should be inserted, it would typically be replaced with actual Bash script content to perform specific tasks in a Unix-like shell environment.
-
-
-```
-
-t WarpSize>()
-```
-**Following code does:** This code snippet is a sequence of shell commands used to compile and link a C++ program that utilizes GPU resources with the HIP (Heterogeneous-Compute Interface for Portability) compiler, `hipcc`. 
-
-1. The first command compiles `hipDevice.cpp` into an object file `hipDevice.o` with GPU relocatable device code enabled (`-fgpu-rdc`).
-2. The second command creates a static library `libHipDevice.a` from the object file `hipDevice.o` using the `ar` archiving tool.
-3. The third command links the static library `libHipDevice.a` with another source file `test.cpp`, again with GPU relocatable device code enabled, and produces an executable `test.out`.
-
-Overall, this process compiles and links a GPU-accelerated application using HIP, organizing the code into a static library before creating the final executable.
-
-
-```
-
-        HIP Documentation, Release 6.1.40092
-
-
-        
-        -template<typename T, typename F>
-        +template<uint32_t WarpSize, typename T, typename F>
-        __global__ void kernel(
-           ...
-        )
-        {
-           ...
-        // Shared reduction
-        -for (uint32_t i = blockDim.x / 2; i!= 0; i /= 2)
-        +for (uint32_t i = blockDim.x / 2; i > WarpSize; i /= 2)
-        {
-            if (tid < i)
-                shared[tid] = op(shared[tid], shared[tid + i]);
-            __syncthreads();
-        }
-        +// Warp reduction
-        +tmp::static_for<WarpSize, tmp::not_equal<0>, tmp::divide<2>>([&]<int I>()
-        +{
-        +     if (tid < I)
-        +          shared[tid] = op(shared[tid], shared[tid + I]);
-        +#ifdef __HIP_PLATFORM_NVIDIA__
-        +     __syncwarp(0xffffffff >> (WarpSize - I));
-        +#endif
-        +});
-
-        Because HIP typically targets hardware with warp sizes of 32(NVIDIA GPUs and RDNA AMD GPUs) and 64 (CD!
-        AMD GPUs), portable HIP code must handle both. That is why instead of assuming a warp size of 32, make the w:
-        size a template argument of the kernel. This allows you to unroll the final loop using tmp::static_for in a paramet
-```
-
-Because HIP typically targets hardware with warp sizes of 32 (NVIDIA GPUs and RDNA AMD GPUs) and 64 (CDNA AMDGPUs), portable HIP code must handle both. That is why instead of assuming a warp size of 32, make the warp size a template argument of the kernel. This allows you to unroll the final loop using tmp::static\_for in a parametric way but still having the code read much like an ordinary loop.
-
-Promoting the warp size to being a compile-time constant also requires you to handle it similarly on the host-side. You can sandwich the kernel launch with tmp::static\_switch , promoting the snake-case run-time warp\_size variable to a camel-case compile-time constant WarpSize .
-**Following code does:** The code snippet `<_Cuda_>` appears to be a placeholder or a symbolic representation rather than actual executable Python code. In the context of programming, "Cuda" typically refers to NVIDIA's parallel computing platform and application programming interface (API) model, which allows developers to use a CUDA-enabled graphics processing unit (GPU) for general purpose processing. However, without additional context or actual code, it's not possible to determine the specific functionality or purpose of this placeholder.
-
-
-```
-<_C++_>
-```
-
-Note: Neither RDNA- nor CDNA-based AMD hardware provides guaranteed independent progress to lanes of the same warp. When targeting NVIDIA hardware, lanes of a warp might execute somewhat independently as long as the programmer assists the compiler using dedicated built-in functions. This feature is called Independent Thread Scheduling. The HIP headers don't expose the necessary warp primitives and their overloads.
-
-Portable applications can still tap into this feature with carefully #ifdef -ed code, but at this particular optimization level, it's a requirement. The code implicitly relies on the lockstep behavior of an ROCm wavefront, but CUDA warps don't share this property. You must synchronize all the active lanes of a warp to avoid a data race with some lanes progressing faster than others in the same warp.
-
-## 29.2.5 Unroll all loops
-
-While the previous step primarily aims to remove unnecessary syncing, it also unrolls the end of the loop. However, you could also force unrolling the first part of the loop. This saves a few scalar registers (values the compiler can prove to be uniform across warps).
-**Following code does:** The provided text appears to be a continuation marker from a previous page, indicating that the code snippet is incomplete. Without the actual code, it's not possible to determine its purpose or functionality. If you can provide the complete code snippet, I would be happy to help explain what it does.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <Linear                                                                                                                                                                                                        </Linear                                                                                                                                                                                                      <Linar                                                                                                                                                                                                        >                                                                                                                                                                                                        &Linear                                                                                                                                                                                                     
- 
-                                                                                                                                                                                                      <Lin                                                                                                                                                                                                        +                                                                                                                                                                                                        -                                                                                                                                                                                                        |                                                                                                                                                                                                        }                                                                                                                                                                                                        \
-                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       <L                                                                                                                                                                                                        1                                                                                                                                                                                                        0
-```
-
-Introducing yet another template argument for the kernel and moving from for to tmp::static\_for leads to the following two notable improvements:
-
-- Introducing new attribute \_\_launch\_bounds\_\_(BlockSize) to the kernel instructs the compiler that the kernel will only be launched using the designated block size. This implies that the launches of differing block sizes will fail. This allows the optimizer to enroll the blockDim.x variable in constant folding as well as get information about register usage.
-- Turning the block size into a compile-time constant allows you to statically allocate the shared memory.
-
-## 29.2.6 Communicate using warp-collective functions
-
-Shared memory provides a fast communication path within a block, however when performing reduction within the last warp, you can use faster means of communication, which is warp-collective or cross-lane functions. Instead of using the hardware-backed shared memory, you can directly copy between the local memory (registers) of each lane in a warp. This can be achieve using the shuffle functions.
-
-See how to use \_\_shfl\_down() , which is one of the most restrictive but also the most structured communication schemes.
-**Following code does:** The placeholder `<_SQL_>` suggests that this is not actual code but rather a placeholder indicating where SQL code would be inserted. Without specific SQL statements, it's not possible to determine the exact functionality. However, generally, SQL code is used for interacting with databases, which can include operations such as querying data, updating records, inserting new data, or deleting existing records. The high-level purpose of SQL code is to manage and manipulate data stored in a relational database.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        // Warp reduction
-```
-
-Using warp-collective functions for communication requires the control flow to be uniform across warps, as the name warp-collective implies. Therefore, you can see that the thread ID is being checked outside the loop, but the result is written inside due to variable scoping.
-
-## 29.2.7 Prefer warp communication over shared
-
-As mentioned in the previous step, communication between local memory is faster than shared memory. Instead of relying on the local memory only at the end of the tree-like reduction, a better approach is to turn the tree reduction inside out and perform multiple warp reductions in parallel on all active threads, thus communicating only their partial results through the shared memory.
-
-The kernel versions differ significantly enough to be described using a diff; use afresh instead.
-**Following code does:** The provided code snippet appears to be malformed or incomplete. It consists of a series of spaces and dashes followed by the text `--event:0` and `-event:0`. This does not represent valid or executable Python code. It seems more like a formatting error or a placeholder rather than a functional script. Without additional context or correction, it is not possible to determine a high-level purpose for this snippet.
-
-
-```
-        The kernel versions differ significantly enough to be described using a diff; use afresh instead.
-
-        template<uint32_t BlockSize,  uint32_t WarpSize,  typename  T,  typename  F>
-        __global__ __launch_bounds__(BlockSize)  void kernel(
-            T*  front,
-            T*  back,
-            F  op,
-            T zero_elem,
-            uint32_t  front_size)
-        {
-            // ...
-        }
-
-        The kernel estimate and the reduction factor as the comma as in variance access only the imlamantation diffar.
-```
-
-The kernel signature and the reduction factor are the same as in previous cases; only the implementation differs.
-**Following code does:** It seems that you've provided a single character `>` instead of a code snippet. Could you please provide the complete code so I can help explain its purpose?
-
-
-```
-static constexpr uint32_t WarpCount = BlockSize / WarpSize;
-
-__shared__ T shared[WarpCount];
-
-auto read_global_safe =
-    [&](const uint32_t i) { return i < front_size? front[i] : zero_elem; };
-auto read_shared_safe =
-    [&](const uint32_t i) { return i < WarpCount? shared[i] : zero_elem; };
-
-const uint32_t tid = threadIdx.x,
-                     bid = blockIdx.x,
-                     gid = bid * (blockDim.x * 2) + tid,
-                     wid = tid / WarpSize,
-                     lid = tid % WarpSize;
-
-// Read input from front buffer to local
-T res = op(read_global_safe(gid), read_global_safe(gid + blockDim.x));
-
-As we communicate the results of warps through shared memory, the same number of elements are required in the
-shared memory as warps within the block. Similar to how you can only launch kernels at block granularity. you can
-```
-
-As we communicate the results of warps through shared memory, the same number of elements are required in the shared memory as warps within the block. Similar to how you can only launch kernels at block granularity, you can only warp reduce with WarpSize granularity due to the collective nature of the cross-lane builtins. To address this, you can use read\_shared\_safe to pad overindexing by reading zero\_elem . Reading from global remains unaffected. // Perform warp reductions and communicate results via shared // for (uint32\_t ActiveWarps = WarpCount; // ActiveWarps != 0; // ActiveWarps = ActiveWarps != 1 ? // divide\_ceil(ActiveWarps, WarpSize) : // ActiveWarps = 0) tmp::static\_for&lt; WarpCount, tmp::not\_equal&lt;0&gt;, tmp::select&lt; tmp::not\_equal&lt;1&gt;, tmp::divide\_ceil&lt;WarpSize&gt;, tmp::constant&lt;0&gt;&gt;&gt;([&amp;]&lt; uint32\_t ActiveWarps&gt;() { if (wid &lt; ActiveWarps) { // Warp reduction tmp::static\_for&lt;WarpSize / 2, tmp::not\_equal&lt;0&gt;, tmp::divide&lt;2&gt;&gt;([&amp;]&lt; int Delta&gt;() { res = op(res, \_\_shfl\_down(res, Delta)); }); // Write warp result from local to shared if (lid == 0) shared[wid] = res; } \_\_syncthreads(); // Read warp result from shared to local res = read\_shared\_safe(tid); (continues on next page)
-
-(continued from previous page)
-**Following code does:** The code snippet is a command-line instruction that uses the `hipify-perl` tool to convert CUDA code into HIP (Heterogeneous-Compute Interface for Portability) code. The `--inplace` option indicates that the conversion should be done directly in the original files, modifying them in place rather than creating new output files. This is typically used to facilitate the migration of CUDA applications to run on AMD GPUs by translating CUDA-specific syntax and API calls to their HIP equivalents.
-
-
-```
-});
-
-// Write result from local to back buffer
-if(tid == 0)
-    back[bid] = res;
-```
-
-ActiveWarps iterates from WarpCount until it reaches 0 . Every iteration of ActiveWarps reduces the WarpSize . In cases where the partial result count isn't a divisor of ActiveWarps and you need to launch an extra warp, use tmp::divide\_ceil , which always rounds to positive infinity. The tertiary tmp::select is required because such division never reaches 0 , so you must terminate the loop after the last warp concludes.
-
-In each iteration, if the warp is active, which means it has at least a single valid input, it carries out a pass of warp reduction and writes output based on warp ID. Reading is carried out based on thread ID. Global output continues to be based on block ID.
-
-## 29.2.8 Amortize bookkeeping variable overhead
-
-The previous sections explained how to reduce register usage to improve occupancy. This allows more blocks to execute in parallel on all multiprocessors, leading to more global store/load latency to be hidden. Reducing the number of kernels in flight while still carrying out the same workload reduces the wastage of registers while loading and maintaining bookkeeping variables such as kernel indices.
-
-An example of this optimization is performing one binary op while loading input from global. Even though the operation is said to be carried out 'in flight', the two values are loaded into local memory (registers) before op is called.
-
-Amore general form of this optimization is wrapping most kernel logic in loops that carry out the workload of multiple kernel instances but require storing only a single instance of most of the bookkeeping logic. In code, this multiplicity factor is referred to via the ItemsPerThread compile-time constant, which is supplied by a template argument to allow for loop unrolling.
-
-This kernel variant utilizes another generally applicable utility known as hip::static\_array , which is a more restrictive wrapper over the builtin array than std::array , as it allows indexing only compile-time constants using the usual tuple-like template &lt;size\_t I&gt; auto get&lt;I&gt;(...) interface.
-
-Note: On a GPU, there is no stack, and the local memory is provisioned from the register file. This provisioning takes place statically. To paraphrase, the address range of a thread's local memory is determined at compile-time. When an array is defined and used in the local storage, the compiler can only maintain its storage in the register file as long as all accesses to the array are computable by the compiler at compile-time. It doesn't need to be a compile-time constant as long as the compiler can resolve the addresses of the accesses through constant folding or some other means. If the compiler fails to do so, the array will be backed by global memory, which is indicated by allocating a non-zero number of spill registers observable using static analysis tools. However, this is slower by the magnitude of multiple order. hip::static\_array via its hip::get&lt;&gt; interface ensures that no such spills occur.
-**Following code does:** This code snippet is a preprocessor directive used in C/C++ programming, specifically when working with the HIP (Heterogeneous-Compute Interface for Portability) framework. The `#ifdef __HIP_PLATFORM_AMD__` checks if the macro `__HIP_PLATFORM_AMD__` is defined, which indicates that the code is being compiled for AMD platforms using HIP-Clang. If this condition is true, the comment `// Compiled with HIP-Clang` is included in the code. This is typically used to conditionally compile code specific to AMD hardware when using the HIP framework.
-
-
-```
-_t  ItemsPerThread>
-```
-**Following code does:** This code snippet is a preprocessor directive used in a C/C++ program to conditionally compile code based on the target platform. Specifically, it checks if the code is being compiled for an NVIDIA platform using the HIP (Heterogeneous-Compute Interface for Portability) API. If the `__HIP_PLATFORM_NVIDIA__` macro is defined, it indicates that the code is being compiled with NVIDIA's CUDA compiler (`nvcc`). The comments suggest that the code could be using CUDA language extensions or be in a pass-through mode to an underlying host compiler, depending on the file type or compilation settings.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        --global__ static __launch_bounds__(BlockSize) void kernel(...)
-```
-
-The kernel now has three compile-time configurable parameters. The only part of the kernel that changes depends on how you load data from global and perform the binary operation on those loaded values. So, the following step to read input from front buffer to global is now split into two steps: reading ``ItemsPerThread` &lt;reading-items&gt;`and processing ``ItemsPerThread` &lt;processing-items&gt;`.
-**Following code does:** This code snippet is a preprocessor directive used in C/C++ programming to check if the code is being compiled with NVIDIA's CUDA Compiler (nvcc). The `#ifdef __CUDACC__` checks if the `__CUDACC__` macro is defined, which indicates that the CUDA language extensions are enabled. This is typically used to conditionally include or exclude code that is specific to CUDA, allowing the same source file to be compiled with or without CUDA support.
-
-
-```
-<_C_>
-```
-
-## 29.2.8.1 Reading ItemsPerThread
-
-The change to reading happens inside read\_global\_safe :
-**Following code does:** The code snippet you provided appears to be incomplete or malformed. It does not represent valid Python code, as it contains a semicolon at the beginning and a misspelled or incorrectly formatted word "enab1ed" (with a numeral '1' instead of the letter 'l'). Without additional context or correction, it's not possible to determine its high-level purpose.
-
-
-```
-        The change to reading happens inside read_global_safe:
-        auto  read_global_safe = [&](const  int32_t  i)  -> hip::static_array<T,  ItemsPerThread>
-        {
-            return  [&]<int32_t...  I>(std::integer_sequence<int32_t,  I...>)
-            {
-                if(i + ItemsPerThread < front_size)
-                        return hip::static_array<T,  ItemsPerThread>{
-                              front[i + I]...
-                        };
-                else
-                        return hip::static_array<T,  ItemsPerThread>{
-                              (i + I < front_size? front[i + I] : zero_elem)...
-                        };
-            }(std::make_integer_sequence<int32_t,  ItemsPerThread>());
-        };
-
-        Note that each array element is being loaded consecutively without the flexibility of a configurable ItemsPerThread
-```
-
-Note that each array element is being loaded consecutively without the flexibility of a configurable ItemsPerThread property. This is morally equivalent to:
-**Following code does:** This code snippet is a preprocessor directive used in the context of HIP (Heterogeneous-Compute Interface for Portability), which is a C++ runtime API that allows developers to write portable code to run on AMD and NVIDIA GPUs. The line `#if __HIP__DEVICE__COMPILE__` is a conditional compilation directive that checks if the code is being compiled for a GPU device. If the condition is true, the code following this directive will be included in the compilation process for the device. This is typically used to separate code that should only be executed on the GPU from code that runs on the host (CPU).
-
-
-```
-T arr[4] = {
-    front[gid + 0],
-    front[gid + 1],
-    front[gid + 2],
-    front[gid + 3]
-}
-```
-
-This is exactly what's happening in the front[i + I]... fold-expression. However, this can only be issued if the entire read operates on real input without padding using zero\_elem . If some reads over-index the input, the read turns into:
-**Following code does:** This code snippet is a preprocessor directive used in CUDA programming, which is a parallel computing platform and application programming interface model created by NVIDIA. The directive `#if (__CUDA_ARCH__ >= 130)` checks if the code is being compiled for a CUDA architecture version that is 1.3 or higher. If the condition is true, the code following this directive will be included in the compilation process. This is typically used to ensure that certain code segments are only compiled for specific GPU architectures that support the required features or capabilities.
-
-
-```
-T arr[4] = {
-    i + 0 < front_size? front[i + 0] : zero_elem,
-    i + 1 < front_size? front[i + 1] : zero_elem,
-    i + 2 < front_size? front[i + 2] : zero_elem,
-    i + 3 < front_size? front[i + 3] : zero_elem
-}
-```
-
-This makes it easier for the compiler to recognize vector loads from global. As the performance at large is dominated by how you move the data, it's only natural to utilize dedicated instructions to move more data with less binary. This is evident by the huge performance improvement when loading two values per thread. For more information, see the compiler explorer to learn how loading for AMD (both RDNA and CDNA) compiles to global\_load\_dwordx4 , where x4 denotes the 4-vector variant of the instruction.
-
-Note: Note that read\_global\_safe , which used to take an uint32\_t as the index type, now takes a signed integer. When indexing an array with unsigned integers, the compiler has to handle integer overflows, as the C/C++ standards defined them. It might happen that some part of the vector load indices overflow, thus resulting in a non-contiguous
-
-read. If you change the previously linked code to use an unsigned integer as the thread ID, the compiler won't emit a vector load. Signed integer overflow is an undefined behavior, and hence, unknown to the optimizer. To convey the absence of overflow to the compiler with unsigned indices, add \_\_builtin\_assume(gid + 4 &gt; gid) , or the more portable [[assume]](gid + 4 &gt; gid) , once amdclang++ supports it.
-
-read\_global\_safe implementation is an Immediately Invoked Lambda Expression (IILE), because ItemsPerThread is an integer value, while you need a compile-time iota -like sequence of integers as a pack for the fold-expressions to expand on. This can only occur as part of template argument deduction on the IILE.
-
-## 29.2.8.2 Processing ItemsPerThread
-
-Once the kernel reads ItemsPerThread number of inputs to local, it immediately reduces them to a scalar. There is no reason to propagate the input element multiplicity to the warp reduction phase.
-**Following code does:** This code snippet appears to be a comment rather than executable code. It suggests that the programming environment or language being used supports the use of "doubles," which typically refers to double-precision floating-point numbers. This comment might be indicating that the code or system can handle numerical data types that require more precision than single-precision floating-point numbers.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?>                                                                                                                                                                                                        </?>
-```
-
-## 29.2.9 Two-pass reduction
-
-Alter kernel launch and input fetching such that no more blocks are launched than what a subsequent kernel launch's single block can conveniently reduce, while performing multiple passes of input reading from global and combining their results before engaging in the end game tree-like reduction.
-
-With this method, you can save at least one to two kernel launches for large inputs.
-
-## 29.2.10 Global data share
-
-Warning: This modification can only be executed on AMD hardware.
-
-Perform the first step of the two-pass reduction, but in the end, instead of writing to global and reading it back in a subsequent kernel, write the partial results to the Global Data Share (GDS). This is an N+1 th shared memory that is accessed by all multiprocessors and is also on-chip memory.
-
-Note: The API doesn't guarantee the order in which blocks are scheduled even though all GPUs schedule them in the same monotonically increasing order of block ids. Relying on this implicitly, the last block of a grid is in the optimal position to observe the side effects of all other blocks (using spinlocks or other methods) without occupying a multiprocessor for longer than necessary.
-
-Without launching a second kernel, you can make the last block collect the results of all other blocks from GDS by implicitly exploiting the scheduling behavior or relying on another AMD-specific feature called Global Wave Sync (GWS) to merge them for a final tree-like reduction.
-
-Note: GDS and GWS are reserved runtime features that the HIP API doesn't cover. Invoking these functionalities requires inline AMDGCN assembly. Moreover, the fact that the runtime doesn't virtualize the GDS, imposes further restrictions on concurrent scheduling of other kernels.
-
-## 29.3 Conclusion
-
-Optimizing code on GPUs, like on any other architecture, requires careful consideration and balancing of resources and costs of various operations to obtain optimal performance. This document explored optimizing reductions much beyond the territory of diminishing returns. This approach introduced multiple optimization techniques and discussed opportunities.
-
-The document focused on reductions when an entire device participates in it. Still, the choice of optimal compile-time constants or even the algorithm itself might not be optimal when its multiple blocks participate in multiple parallel reductions or when each thread performs its reduction. However, when multiple devices participate in the same reduction, other aspects must be considered.
-
-Most solutions, including the ones covered in this document, are given to the end users in a turnkey fashion via algorithm primitive libraries. These solutions might not be the fastest in all cases, but they are close to being the gold standard for carrying out certain operations as reasonably as possible.
-
-CHAPTER
-
-## THIRTY
-
-## COOPERATIVE GROUPS
-
-This tutorial demonstrates the basic concepts of cooperative groups in the HIP (Heterogeneous-computing Interface for Portability) programming model and the most essential tooling supporting it. This topic also reviews the commonalities of heterogeneous APIs. Familiarity with the C/C++ compilation model and the language is assumed.
-
-## 30.1 Prerequisites
-
-To follow this tutorial, you'll need properly installed drivers and a HIP compiler toolchain to compile your code. Because ROCm HIP supports compiling and running on Linux and Microsoft Windows with AMD and NVIDIA GPUs, review the HIP development package installation before starting this tutorial. For more information, see Install HIP .
-
-## 30.2 Simple HIP Code
-
-To become familiar with heterogeneous programming, review the SAXPY tutorial and the first HIP code subsection. Compiling is also described in that tutorial.
-
-## 30.3 Tiled partition
-
-You can use tiled partition to calculate the sum of partition\_size length sequences and the sum of result\_size / BlockSize length sequences. The host-side reference implementation is the following:
-**Following code does:** This code snippet is a conditional check to determine if the hardware architecture supports double-precision floating-point operations. The commented-out line `//#if (__CUDA_ARCH__ >= 130)` is a non-portable way to check for this support in CUDA, which is specific to NVIDIA GPUs. The active line `if __HIP_ARCH_HAS_DOUBLES__` is a portable way to perform a similar check in HIP, which is a framework designed to run on both NVIDIA and AMD GPUs. If the condition is true, it indicates that the architecture supports double-precision operations, and the code within the block can safely use double-precision data types.
-
-
-```
-    You can use ued partition to calculate the sum or partition_size length sequences and the sum or result_size/
-    BlockSize length sequences. The host-side reference implementation is the following:
-    
-    // Host-side function to perform the same reductions as executed on the GPU
-    std::vector<unsigned int> ref_reduced(const unsigned int          partition_size,
-                                                   std::vector<unsigned int> input)
-    {
-        const unsigned int          input_size  = input.size();
-        const unsigned int          result_size = input_size / partition_size;
-        std::vector<unsigned int> result(result_size);
-
-        for(unsigned int i = 0; i < result_size; i++)
-        {
-            unsigned int partition_result = 0;
-            for(unsigned int j = 0; j < partition_size; j++)
-            {
-                partition_result += input[partition_size * i + j];
-            }
-                                                                                                                                                                                                         (continues on next page)
-```
-
-(continues on next page)
-**Following code does:** This code snippet is querying the properties of a GPU device using the HIP (Heterogeneous-Compute Interface for Portability) API. It retrieves the properties of a specified device and checks if the device supports shared 32-bit integer atomic operations. The commented-out line suggests an alternative, non-portable way of checking device capabilities based on major and minor version numbers, but the actual code uses a more portable method by directly querying the `hasSharedInt32Atomics` feature of the device architecture. If the device supports this feature, the code within the conditional block (not shown) would execute.
-
-
-```
-            result[i] = partition_result;
-        }
-
-        return result;
-    }
-```
-
-## 30.3.1 Device-side code
-
-To calculate the sum of the sets of numbers, the tutorial uses the shared memory-based reduction on the device side. The warp level intrinsics usage is not covered in this tutorial, unlike in the reduction tutorial. x input variable is a shared pointer, which needs to be synchronized after every value change. The thread\_group input parameter can be thread\_block\_tile or thread\_block because the thread\_group is the parent class of these types. The val are the numbers to calculate the sum of. The returned results of this function return the final results of the reduction on thread ID 0 of the thread\_group , and for every other thread, the function results are 0.
-**Following code does:** The code snippet is a command-line instruction that uses the `hipconfig` tool with the `--cxx_config` option. `hipconfig` is a utility associated with the HIP (Heterogeneous-Compute Interface for Portability) framework, which is used for developing applications that can run on both AMD and NVIDIA GPUs. The `--cxx_config` option specifically retrieves and displays the C++ compiler configuration settings used by HIP. This information is useful for developers to understand or verify the compiler settings being applied in their HIP-based projects.
-
-
-```
-        The warp level intrinsics usage is not covered in this tutorial, unlike in the reduction tutorial. x input variable is a
-        shared pointer, which needs to be synchronized after every value change. The thread_group input parameter can be
-        thread_block_tile or thread_block because the thread_group is the parent class of these types. The val are
-        the numbers to calculate the sum of. The returned results of this function return the final results of the reduction on
-        thread ID 0 of the thread_group, and for every other thread, the function results are 0.
-
-        /// \brief Summation of `unsigned int val`s in `thread_group g` using shared memory `x`
-        __device__ unsigned int reduce_sum(thread_group g, unsigned int* x, unsigned int val)
-    {
-            // Rank of this thread in the group
-            const unsigned int group_thread_id = g.thread_rank();
-
-            // We start with half the group size as active threads
-            // Every iteration the number of active threads halves, until we processed all values
-            for(unsigned int i = g.size() / 2; i > 0; i /= 2)
-            {
-                // Store value for this thread in a shared, temporary array
-                x[group_thread_id] = val;
-
-                // Synchronize all threads in the group
-                g.sync();
-
-                // If our thread is still active, sum with its counterpart in the other half
-                if(group_thread_id < i)
-                {
-                    val += x[group_thread_id + i];
-                }
-
-                // Synchronize all threads in the group
-                g.sync();
-            }
-
-            // Only the first thread returns a valid value
-            if(g.thread_rank() == 0)
-                return val;
-            else
-                return 0;
-    }
-
-        The reduce_sum device function is reused to calculate the block and custom partition sum of the input numbers. The
-        kernel has three sections:
-
-        1. Initialization of the reduction function variables.
-```
-
-The reduce\_sum device function is reused to calculate the block and custom partition sum of the input numbers. The kernel has three sections:
-
-1. Initialization of the reduction function variables.
-
-(continued from previous page)
-
-2. The reduction of thread block and store the results in global memory.
-3. The reduction of custom partition and store the results in global memory.
-
-## 30.3.1.1 1. Initialization of the reduction function variables
-
-In this code section, the shared memory is declared, the thread\_block\_group and custom\_partition are defined, and the input variables are loaded from global memory.
-**Following code does:** The code snippet appears to be a fragment of a command or configuration related to compiling or building software that uses the HIP (Heterogeneous-Compute Interface for Portability) platform. Specifically, it includes a compiler definition `-D___HIP_PLATFORM_AMD___`, which indicates that the target platform is AMD, and an include path `-I/home/user1/hip/include`, which specifies where to find the HIP header files during compilation. This setup is typically used in environments where code is being prepared to run on AMD GPUs using HIP.
-
-
-```
-
-
-in this code section, the shared memory is declared, the thread_block_group and custom_partition are define
-input variables are loaded from global memory.
-
-// threadBlockGroup consists of all threads in the block
-thread_block thread_block_group = this_thread_block();
-
-// Workspace array in shared memory required for reduction
-__shared__ unsigned int workspace[2048];
-
-unsigned int output;
-
-// Input to reduce
-const unsigned int input = d_vector[thread_block_group.thread_rank()];
-
-//...
-
-// Every custom_partition group consists of 16 threads
-thread_block_tile<PartitionSize> custom_partition
-           = tiled_partition<PartitionSize>(thread_block_group);
-
-
-
-as a 2 - 2 The read-line of thread block
-```
-
-## 30.3.1.2 2. The reduction of thread block
-
-In this code section, the sum is calculated on thread\_block\_group level, then the results are stored in global memory.
-**Following code does:** This code snippet is a Makefile command that appends additional preprocessor flags to the `CPPFLAGS` variable. It uses the `hipconfig` tool, which is part of the HIP (Heterogeneous-Compute Interface for Portability) framework, to generate the necessary preprocessor configuration flags for compiling HIP code. The `$(shell ...)` function executes the `hipconfig --cpp_config` command and captures its output, which is then added to `CPPFLAGS`. This setup is typically used to ensure that the correct compiler flags are used when building applications that utilize HIP for GPU programming.
-
-
-```
-// Perform reduction
-output = reduce_sum(thread_block_group, workspace, input);
-
-// Only the first thread returns a valid value
-if(thread_block_group.thread_rank() == 0)
-{
-    d_block_reduced_vector[0] = output;
-}
-```
-
-## 30.3.1.3 3. The reduction of custom partition
-
-In this code section, the sum is calculated on the custom partition level, then the results are stored in global memory. The custom partition is a partial block of the thread block, it means the reduction calculates on a shorter sequence of input numbers than at the thread\_block\_group case.
-**Following code does:** The code snippet you provided appears to be incomplete or malformed, as it only contains a closing parenthesis `)`. Without additional context or surrounding code, it is not possible to determine its purpose or functionality.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        // Perform reduction                                                                                                                                                                                                        }
-                                                                                                                                                                                                      
-output = reduce_sum(custom_partition, &workspace[group_offset], input);
-
-                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       // Only the first thread in each partition returns a valid value                                                                                                                                                                                                        \
-                                                                                                                                                                                                       \
-
-                                                                                                                                                                                                       \
-```
-
-(continued from previous page)
-**Following code does:** The code snippet `<_SQL_>` appears to be a placeholder or a tag indicating that the actual SQL code is not provided. In this context, it suggests that the code is related to SQL (Structured Query Language), which is used for managing and manipulating relational databases. Without the actual SQL code, it's not possible to determine the specific operations or queries being performed. The placeholder might be used in documentation, templates, or code generation tools to signify where SQL code should be inserted or processed.
-
-
-```
-        const unsigned int partition_id           = thread_block_group.thread_rank() /\__
-        ~PartitionSize;
-        d_partition_reduced_vector[partition_id] = output;
-    }
-```
-
-## 30.3.2 Host-side code
-
-On the host-side, the following steps are done in the example:
-
-1. Confirm the cooperative group support on AMD GPUs.
-2. Initialize the cooperative group configuration.
-3. Allocate and copy input to global memory.
-4. Launch the cooperative kernel.
-5. Save the results from global memory.
-6. Free the global memory.
-
-Only the first, second and fourth steps are important from the cooperative groups aspect, that's why those steps are detailed further.
-
-## 30.3.2.1 1. Confirm the cooperative group support on AMD GPUs
-
-Not all AMD GPUs support cooperative groups. You can confirm support with the following code:
-**Following code does:** It seems there is a formatting error in your request. The code snippet is labeled as Python, but it contains a placeholder that suggests it should be C++ code. Please provide the correct code snippet or clarify the language so I can assist you accurately.
-
-
-```
-<_C++_>
-```
-
-## 30.3.2.2 2. Initialize the cooperative group configuration
-
-In the example, there is only one block in the grid, and the threads\_per\_block must be dividable with partition\_size .
-**Following code does:** This code snippet is part of a GPU programming workflow using HIP, a C++ runtime API and kernel language that allows developers to write portable code for AMD and NVIDIA GPUs. The code performs the following high-level tasks:
-
-1. **Initialization**: It initializes two arrays, `A` and `B`, where `A` is filled with negative indices and `B` is initialized to zero.
-
-2. **Memory Allocation**: It allocates memory on the GPU for the array `Ad` using `hipMalloc`.
-
-3. **Data Transfer to GPU**: It copies the contents of array `A` from the host (CPU) to a symbol on the device (GPU) using `hipMemcpyToSymbol`.
-
-4. **Kernel Launch**: It launches a GPU kernel named `Get` with a specific grid and block configuration to perform operations on the data stored in `Ad`.
-
-5. **Data Transfer to Host**: It copies the results from the device array `Ad` back to the host array `B` using `hipMemcpy`.
-
-6. **Validation**: It checks if the contents of arrays `A` and `B` are equal, asserting that the GPU computation was performed correctly.
-
-7. **Output**: If the assertion passes, it prints "Passed" to indicate successful execution and validation of the GPU operations.
-
-Overall, this code tests the correctness of a GPU computation by comparing the results with expected values.
-
-
-```
-<_C_>
-```
-
-## 30.3.2.3 4. Launch the kernel
-
-The kernel launch is done with the hipLaunchCooperativeKernel of the cooperative groups API.
-**Following code does:** This code snippet demonstrates the allocation of memory on both the device (GPU) and the host (CPU) using HIP, a C++ runtime API for GPU programming. It first allocates memory on the device for a double pointer using `hipMalloc` and retrieves its attributes with `hipPointerGetAttributes`, which would indicate that the memory type is `hipMemoryTypeDevice`. Then, it allocates memory on the host using `hipHostMalloc` for another double pointer and again retrieves its attributes, which would indicate that the memory type is `hipMemoryTypeHost`. The comments suggest that the code is checking the type of memory allocated (device vs. host). The last line seems to be incomplete and unrelated to the memory operations shown.
-
-
-```
-        The kernel launch is done with the hipLaunchCooperativeKernel of the cooperative groups API.
-        void* params[] = {&d_vector,  &d_block_reduced,  &d_partition_reduced};
-        // Launching kernel from host.
-        HIP_CHECK(hipLaunchCooperativeKernel(vector_reduce_kernel<partition_size>,
-```
-
-## 30.4 Conclusion
-
-With cooperative groups, you can easily use custom partitions to create custom tiles for custom solutions. You can find the complete code at cooperative groups ROCm example.
-
-## CHAPTER
-
-## THIRTYONE
-
-## LICENSE
-
-Copyright © 2008 - 2024 Advanced Micro Devices, Inc.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-## INDEX
-
-| C                                                                                                           | hipArrayCreate ( C++ function ), 183                                                                        |    |     |      |     |          |
-|-------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------|----|-----|------|-----|----------|
-| cooperative_groups::coalesced_group class ), 237                                                            | C++ hipArrayDestroy ( C++ function ), 183 hipArrayGetDescriptor ( C++ function ), 185 ( C++ function ), 185 | (  |     |      |     |          |
-| cooperative_groups::grid_group ( C++ class ), 234                                                           | hipArrayGetInfo hipCreateSurfaceObject ( C++ function ), 133                                                |    |     |      |     |          |
-| cooperative_groups::multi_grid_group ( C++                                                                  | ( C++ function ), 197                                                                                       |    |     |      |     |          |
-| class ), 234 cooperative_groups::thread_block ( C++                                                         | ), hipDestroyExternalMemory ( C++ function ), 196                                                           |    |     |      |     |          |
-| class 234                                                                                                   | hipDestroyExternalSemaphore hipDestroySurfaceObject ( C++ function ), 133 C++ function                      |    |     |      |     |          |
-| cooperative_groups::thread_block_tile ( C++ class ), 234                                                    | hipDeviceCanAccessPeer ( ), 163 hipDeviceDisablePeerAccess ( C++ function ), 164 ( C++ function ), 163      |    |     |      |     |          |
-| cooperative_groups::thread_block_tile::all ( C++ function ), 236 cooperative_groups::thread_block_tile::any | hipDeviceEnablePeerAccess hipDeviceGetStreamPriorityRange ( C++ function ), 148                             |    |     |      |     |          |
-| ( C++ function ), 236                                                                                       | hipDrvMemcpy3D ( C++ function ), 192                                                                        |    |     |      |     |          |
-| cooperative_groups::thread_block_tile::ballot                                                               | hipDrvMemcpy3DAsync ( C++ function ), 192                                                                   |    |     |      |     |          |
-|                                                                                                             | hipDrvPointerGetAttributes ( C++ function ), 166                                                            |    |     |      |     |          |
-| ( C++ function ), 236                                                                                       |                                                                                                             |    |     |      |     |          |
-| cooperative_groups::thread_block_tile::match_all                                                            | hipExternalMemoryGetMappedBuffer ( C++ func- tion ), 196                                                    |    |     |      |     |          |
-| ( C++ function ), 237 cooperative_groups::thread_block_tile::match_any                                      | hipExternalMemoryGetMappedMipmappedArray ( C++ function ), 197 hipExtMallocWithFlags ( C++ function ), 167  |    | 236 | ( ), | C++ | function |
-| cooperative_groups::thread_block_tile::meta_group_rank ( C++ function ), 235                                | hipExtStreamCreateWithCUMask ( C++function ), 151 hipExtStreamGetCUMask ( C++ function ), 152               |    |     |      |     |          |
-|                                                                                                             | hipFree ( C++ function ), 171 hipFreeArray ( C++ function ), 184                                            |    |     |      |     |          |
-| cooperative_groups::thread_block_tile::meta_group_size ( C++ function ), 235                                | hipFreeAsync                                                                                                |    |     |      |     |          |
-| cooperative_groups::thread_block_tile::shfl ( C++ function ), 235                                           |                                                                                                             |    |     |      |     |          |
-|                                                                                                             | ( C++ function ), 154                                                                                       |    |     |      |     |          |
-| cooperative_groups::thread_block_tile::shfl_down                                                            |                                                                                                             |    |     |      |     |          |
-| ( C++ function ), 235                                                                                       | hipFreeHost ( C++ function ), 172 hipGetProcAddress ( C++ function ), 176                                   |    |     |      |     |          |
-| cooperative_groups::thread_block_tile::shfl_up                                                              | hipGetSymbolAddress ( C++ function ), 176, 193 ( C++ function ), 176, 193                                   |    |     |      |     |          |
-| ( C++ function ), 235                                                                                       | hipHostAlloc ( C++ function ), 168 hipHostFree ( C++ function ), 172                                        |    |     |      |     |          |
-| ( C++ function ), 236                                                                                       | ( C++ function ),                                                                                           |    |     |      |     |          |
-| cooperative_groups::thread_block_tile::sync ( C++ function ), 235                                           | 169 ( C++ function ), 169                                                                                   |    |     |      |     |          |
-| cooperative_groups::thread_block_tile::thread_rank ( C++ function ), 235 ),                                 | ( C++ function ), 169                                                                                       |    |     |      |     |          |
-| cooperative_groups::thread_group ( C++ class                                                                | ( C++ function ), 170 ( C++ function ),                                                                     |    |     |      |     |          |
-| 234                                                                                                         | 196 ( C++ function ),                                                                                       |    |     |      |     |          |
-|                                                                                                             | ( C++ function ), 166, 194                                                                                  |    |     |      |     |          |
-| H                                                                                                           | hipMalloc hipMalloc3D                                                                                       |    |     |      |     |          |
-|                                                                                                             | ( C++ function ), 184                                                                                       |    |     |      |     |          |
-| hipArray3DCreate ( C++ function ), 183                                                                      |                                                                                                             |    |     |      |     |          |
-| 185                                                                                                         | hipMalloc3DArray ( C++ function ),                                                                          |    |     |      |     |          |
-| hipArray3DGetDescriptor ( C++ function ),                                                                   |                                                                                                             |    |     |      |     |          |
-|                                                                                                             | 195                                                                                                         |    |     |      |     |          |
-|                                                                                                             | 184                                                                                                         |    |     |      |     |          |
-|                                                                                                             | hipImportExternalSemaphore                                                                                  |    |     |      |     |          |
-|                                                                                                             | hipImportExternalMemory                                                                                     |    |     |      |     |          |
-|                                                                                                             | hipHostMalloc ( C++ function ), 168, 194 hipHostRegister hipHostUnregister                                  |    |     |      |     |          |
-|                                                                                                             | hipHostGetDevicePointer hipHostGetFlags                                                                     |    |     |      |     |          |
-|                                                                                                             | hipGetSymbolSize                                                                                            |    |     |      |     |          |
-|                                                                                                             | cooperative_groups::thread_block_tile::shfl_xor                                                             |    |     |      |     |          |
-
-| hipMallocArray ( C++ function ), 182 ( C++ function ), 152,                                |
-|--------------------------------------------------------------------------------------------|
-| 153 hipMallocFromPoolAsync ( C++ function ), 153, 160                                      |
-| hipMallocHost ( C++ function ), 167                                                        |
-| hipMallocManaged ( C++ function ), 247, 249                                                |
-| hipMallocPitch ( C++ function ), 170                                                       |
-| hipMemAddressFree ( C++ function ), 251                                                    |
-| hipMemAddressReserve ( C++ function ), 251                                                 |
-| hipMemAdvise ( C++ function ), 247                                                         |
-| hipMemAllocHost ( C++ function ), 167                                                      |
-| hipMemAllocPitch ( C++ function ), 171                                                     |
-| hipMemcpy ( C++ function ), 172                                                            |
-| hipMemcpy2D ( C++ function ), 186                                                          |
-| hipMemcpy2DAsync ( C++ function ), 187                                                     |
-| hipMemcpy2DFromArray ( C++ function ), 190                                                 |
-| hipMemcpy2DFromArrayAsync ( C++ function ), 190                                            |
-| hipMemcpy2DToArray ( C++ function ), 188                                                   |
-| hipMemcpy2DToArrayAsync ( C++ function ), 188                                              |
-| hipMemcpy3D ( C++ function ), 191                                                          |
-| hipMemcpy3DAsync ( C++ function ), 192                                                     |
-| hipMemcpyAsync ( C++ function ), 178                                                       |
-| hipMemcpyAtoH ( C++ function ), 191                                                        |
-| hipMemcpyDtoD ( C++ function ), 174                                                        |
-| hipMemcpyDtoDAsync ( C++ function ), 175 hipMemcpyDtoH ( C++ function ), 174               |
-| hipMemcpyDtoHAsync ( C++ function ), 175                                                   |
-| hipMemcpyFromArray ( C++ function ), 189                                                   |
-| hipMemcpyFromSymbol ( C++ function ),                                                      |
-| 177,                                                                                       |
-| 194 hipMemcpyFromSymbolAsync ( C++ function ), 178, 194                                    |
-| hipMemcpyHtoA ( C++ function ), 191                                                        |
-| hipMemcpyHtoD ( C++ function ), 173 hipMemcpyHtoDAsync ( C++ function ),                   |
-| hipMemcpyParam2D ( C++ function ),                                                         |
-| 174 186                                                                                    |
-| hipMemcpyParam2DAsync ( C++ function ),                                                    |
-| 187 hipMemcpyToArray ( C++ function ), 189 ( C++ function ), 177,                          |
-| hipMemcpyToSymbol 193 hipMemcpyToSymbolAsync ( C++ function ), 193                         |
-| 177, ( C++ function ), 173                                                                 |
-| hipMemcpyWithStream hipMemCreate ( C++ function ), 252                                     |
-| hipMemExportToShareableHandle (                                                            |
-| C++ function 252 ( C++ function ), 252                                                     |
-| hipMemGetAddressRange ( C++ function ), 164 hipMemGetAllocationGranularity ( C++           |
-| function 253 hipMemGetAllocationPropertiesFromHandle                                       |
-| ( C++ function ), 253                                                                      |
-| hipMemGetInfo ( C++ function ), 182 hipMemImportFromShareableHandle ( C++ function         |
-| 253 hipMemMap ( C++ function ), 254 hipMemMapArrayAsync ( C++ function ), hipMemPoolCreate |
-| 254 ( C++ function ), 158                                                                  |
-| hipMemPoolDestroy 159                                                                      |
-| ( C++ function ),                                                                          |
-
-C++ function
-
-(
-
-), 162
-
-| hipMemPoolExportPointer hipMemPoolExportToShareableHandle ( C++                          | func-                                                                                    |
-|------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------|
-| tion ), 160                                                                              | tion ), 160                                                                              |
-| hipMemPoolGetAccess ( C++ function ), 158 hipMemPoolGetAttribute ( C++ function ), 156   | hipMemPoolGetAccess ( C++ function ), 158 hipMemPoolGetAttribute ( C++ function ), 156   |
-| hipMemPoolImportFromShareableHandle function ), 161                                      | ( C++                                                                                    |
-| hipMemPoolImportPointer ( C++ function ), 162 hipMemPoolSetAccess ( C++ function ), 157  | hipMemPoolImportPointer ( C++ function ), 162 hipMemPoolSetAccess ( C++ function ), 157  |
-| hipMemPoolSetAttribute ( C++ function ), 156                                             | hipMemPoolSetAttribute ( C++ function ), 156                                             |
-| hipMemPoolTrimTo ( C++ function ), 155                                                   | hipMemPoolTrimTo ( C++ function ), 155                                                   |
-| hipMemPrefetchAsync ( C++ function ), 247                                                | hipMemPrefetchAsync ( C++ function ), 247                                                |
-| hipMemPtrGetInfo ( C++ function ), 182                                                   | hipMemPtrGetInfo ( C++ function ), 182                                                   |
-| hipMemRangeGetAttribute ( C++ function ), 248                                            | hipMemRangeGetAttribute ( C++ function ), 248                                            |
-| hipMemRangeGetAttributes ( C++ function ), 248                                           | hipMemRangeGetAttributes ( C++ function ), 248                                           |
-| hipMemRelease ( C++ function ), 255                                                      | hipMemRelease ( C++ function ), 255                                                      |
-| hipMemRetainAllocationHandle ( C++function ), 255                                        | hipMemRetainAllocationHandle ( C++function ), 255                                        |
-| hipMemset ( C++ function ), 179                                                          | hipMemset ( C++ function ), 179                                                          |
-| hipMemset2D ( C++ function ), 181                                                        | hipMemset2D ( C++ function ), 181                                                        |
-| hipMemset2DAsync ( C++ function ), 181                                                   | hipMemset2DAsync ( C++ function ), 181                                                   |
-| hipMemset3D ( C++ function ), 181                                                        | hipMemset3D ( C++ function ), 181                                                        |
-| hipMemset3DAsync ( C++ function ), 182                                                   | hipMemset3DAsync ( C++ function ), 182                                                   |
-| hipMemSetAccess ( C++ function ), 255                                                    | hipMemSetAccess ( C++ function ), 255                                                    |
-| hipMemsetAsync ( C++ function ), 180                                                     | hipMemsetAsync ( C++ function ), 180                                                     |
-| hipMemsetD16 ( C++ function ), 180 hipMemsetD16Async ( C++ function ), 180               | hipMemsetD16 ( C++ function ), 180 hipMemsetD16Async ( C++ function ), 180               |
-| hipMemsetD32 ( C++ function ), 180                                                       | hipMemsetD32 ( C++ function ), 180                                                       |
-| hipMemsetD32Async ( C++ function ), 181                                                  | hipMemsetD32Async ( C++ function ), 181                                                  |
-| hipMemsetD8 ( C++ function ), 179                                                        | hipMemsetD8 ( C++ function ), 179                                                        |
-| hipMemsetD8Async ( C++ function ), 179                                                   | hipMemsetD8Async ( C++ function ), 179                                                   |
-| hipMemUnmap ( C++ function ), 256                                                        | hipMemUnmap ( C++ function ), 256                                                        |
-| hipModuleGetGlobal ( C++ function ), 176                                                 | hipModuleGetGlobal ( C++ function ), 176                                                 |
-| ( C++ function ), 165                                                                    | ( C++ function ), 165                                                                    |
-| hipPointerGetAttribute hipPointerGetAttributes ( C++ function ), 165                     | hipPointerGetAttribute hipPointerGetAttributes ( C++ function ), 165                     |
-| hipPointerSetAttribute ( C++ function ), 165                                             | hipPointerSetAttribute ( C++ function ), 165                                             |
-| hipSignalExternalSemaphoresAsync ( C++ func- tion ), 195                                 | hipSignalExternalSemaphoresAsync ( C++ func- tion ), 195                                 |
-| hipStreamAddCallback ( C++ function ), 152 hipStreamAttachMemAsync ( C++ function ), 249 | hipStreamAddCallback ( C++ function ), 152 hipStreamAttachMemAsync ( C++ function ), 249 |
-| hipStreamCallback_t ( C++ type ), 147 ( C++ function ), 147                              | hipStreamCallback_t ( C++ type ), 147 ( C++ function ), 147                              |
-| hipStreamCreate hipStreamCreateWithFlags ( C++ function ), 147                           | hipStreamCreate hipStreamCreateWithFlags ( C++ function ), 147                           |
-| hipStreamCreateWithPriority ( C++ function ), 147 hipStreamDestroy ( C++ function ), 148 | hipStreamCreateWithPriority ( C++ function ), 147 hipStreamDestroy ( C++ function ), 148 |
-| hipStreamGetDevice ( C++ function ), 151                                                 | hipStreamGetDevice ( C++ function ), 151                                                 |
-| hipStreamGetFlags ( C++ function ), 150                                                  | hipStreamGetFlags ( C++ function ), 150                                                  |
-| hipStreamGetPriority ( C++ function ), 150 hipStreamQuery ( C++ function ), 149          | hipStreamGetPriority ( C++ function ), 150 hipStreamQuery ( C++ function ), 149          |
-| hipStreamSynchronize ( C++ function ), 149                                               | hipStreamSynchronize ( C++ function ), 149                                               |
-| hipStreamWaitEvent                                                                       | hipStreamWaitEvent                                                                       |
-| ( C++ function ), 149                                                                    | ( C++ function ), 149                                                                    |
-| hipWaitExternalSemaphoresAsync ( C++ function ), 195                                     | hipWaitExternalSemaphoresAsync ( C++ function ), 195                                     |
-| hsa_amd_vmem_address_free ( C++ function ), 241                                          | hsa_amd_vmem_address_free ( C++ function ), 241                                          |
-| hsa_amd_vmem_address_reserve ( C++function ),                                            |                                                                                          |
-| 241                                                                                      | 241                                                                                      |
-
-| hsa_amd_vmem_export_shareable_handle function ), 244                |                                                                     |
-|---------------------------------------------------------------------|---------------------------------------------------------------------|
-| hsa_amd_vmem_get_access ( C++ function ), 243                       | hsa_amd_vmem_get_access ( C++ function ), 243                       |
-| hsa_amd_vmem_get_alloc_properties_from_handle ( C++ function ), 245 | hsa_amd_vmem_get_alloc_properties_from_handle ( C++ function ), 245 |
-| hsa_amd_vmem_handle_create ( C++ function ), 242                    | hsa_amd_vmem_handle_create ( C++ function ), 242                    |
-| hsa_amd_vmem_handle_release ( C++ function ), 242                   | hsa_amd_vmem_handle_release ( C++ function ), 242                   |
-| hsa_amd_vmem_import_shareable_handle function ), 244                | ( C++                                                               |
-| hsa_amd_vmem_map ( C++ function ), 242                              | hsa_amd_vmem_map ( C++ function ), 242                              |
-| hsa_amd_vmem_retain_alloc_handle ( C++ tion ), 245                  | func-                                                               |
-| hsa_amd_vmem_set_access ( C++ function ), 243                       | hsa_amd_vmem_set_access ( C++ function ), 243                       |
-| hsa_amd_vmem_unmap ( C++ function ), 243                            | hsa_amd_vmem_unmap ( C++ function ), 243                            |
-
-## S
-
-| surf1DLayeredread                             |
-|-----------------------------------------------|
-| surf1DLayeredwrite ( C++ function ), 135      |
-| surf1Dread ( C++ function ), 133              |
-| surf1Dwrite ( C++ function ), 133             |
-| surf2DLayeredread ( C++ function ), 135       |
-| surf2DLayeredwrite ( C++ function ), 135      |
-| surf2Dread ( C++ function ), 134              |
-| surf2Dwrite ( C++ function ), 134             |
-| surf3Dread ( C++ function ), 134              |
-| surf3Dwrite ( C++ function ), 134             |
-| surfCubemapLayeredread ( C++ function ), 136  |
-| surfCubemapLayeredwrite ( C++ function ), 137 |
-| surfCubemapread ( C++ function ), 136         |
-| surfCubemapwrite ( C++ function ), 136        |
-
-## U
-
-USE\_PEER\_NON\_UNIFIED ( C macro ), 164
\ No newline at end of file
diff --git a/kernel-agentic/docs/hip/hip_spec_mm/hip_spec-with-image-refs.html b/kernel-agentic/docs/hip/hip_spec_mm/hip_spec-with-image-refs.html
deleted file mode 100644
index 9c41bee..0000000
--- a/kernel-agentic/docs/hip/hip_spec_mm/hip_spec-with-image-refs.html
+++ /dev/null
@@ -1,6706 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-<meta charset="UTF-8">
-<title>hip_spec</title>
-<meta name="generator" content="Docling HTML Serializer">
-<style>
-    html {
-        background-color: #f5f5f5;
-        font-family: Arial, sans-serif;
-        line-height: 1.6;
-    }
-    body {
-        max-width: 800px;
-        margin: 0 auto;
-        padding: 2rem;
-        background-color: white;
-        box-shadow: 0 0 10px rgba(0,0,0,0.1);
-    }
-    h1, h2, h3, h4, h5, h6 {
-        color: #333;
-        margin-top: 1.5em;
-        margin-bottom: 0.5em;
-    }
-    h1 {
-        font-size: 2em;
-        border-bottom: 1px solid #eee;
-        padding-bottom: 0.3em;
-    }
-    table {
-        border-collapse: collapse;
-        margin: 1em 0;
-        width: 100%;
-    }
-    th, td {
-        border: 1px solid #ddd;
-        padding: 8px;
-        text-align: left;
-    }
-    th {
-        background-color: #f2f2f2;
-        font-weight: bold;
-    }
-    figure {
-        margin: 1.5em 0;
-        text-align: center;
-    }
-    figcaption {
-        color: #666;
-        font-style: italic;
-        margin-top: 0.5em;
-    }
-    img {
-        max-width: 100%;
-        height: auto;
-    }
-    pre {
-        background-color: #f6f8fa;
-        border-radius: 3px;
-        padding: 1em;
-        overflow: auto;
-    }
-    code {
-        font-family: monospace;
-        background-color: #f6f8fa;
-        padding: 0.2em 0.4em;
-        border-radius: 3px;
-    }
-    pre code {
-        background-color: transparent;
-        padding: 0;
-    }
-    .formula {
-        text-align: center;
-        padding: 0.5em;
-        margin: 1em 0;
-        background-color: #f9f9f9;
-    }
-    .formula-not-decoded {
-        text-align: center;
-        padding: 0.5em;
-        margin: 1em 0;
-        background: repeating-linear-gradient(
-            45deg,
-            #f0f0f0,
-            #f0f0f0 10px,
-            #f9f9f9 10px,
-            #f9f9f9 20px
-        );
-    }
-    .page-break {
-        page-break-after: always;
-        border-top: 1px dashed #ccc;
-        margin: 2em 0;
-    }
-    .key-value-region {
-        background-color: #f9f9f9;
-        padding: 1em;
-        border-radius: 4px;
-        margin: 1em 0;
-    }
-    .key-value-region dt {
-        font-weight: bold;
-    }
-    .key-value-region dd {
-        margin-left: 1em;
-        margin-bottom: 0.5em;
-    }
-    .form-container {
-        border: 1px solid #ddd;
-        padding: 1em;
-        border-radius: 4px;
-        margin: 1em 0;
-    }
-    .form-item {
-        margin-bottom: 0.5em;
-    }
-    .image-classification {
-        font-size: 0.9em;
-        color: #666;
-        margin-top: 0.5em;
-    }
-</style>
-</head>
-<body>
-<div class='page'>
-<h2>HIP Documentation Release 6.1.40092</h2>
-<p>Advanced Micro Devices, Inc.</p>
-<p>Sep 13, 2024</p>
-<h2>INSTALL</h2>
-<table><tbody><tr><td colspan="3">1 Overview</td><th>3</th></tr><tr><td></td><th colspan="2">Install HIP</th><td></td></tr><tr><th>2</th><td></td><td></td><td>5</td></tr><tr><td></td><th>2.1</th><th>Prerequisites . . . . . . . . .</th><td>5</td></tr><tr><td></td><th>2.2</th><th>Installation . . .</th><td>5</td></tr><tr><td></td><th>2.3</th><th>. . . . . Verify your installation . . .</th><td>6</td></tr><tr><th>3</th><th colspan="2">Build HIP from source</th><th>7</th></tr><tr><td></td><th colspan="2">3.1 Prerequisites</th><td>. . . . . .</td><td></td></tr><tr><td></td><td></td><th>. .</th><td>7</td></tr><tr><td></td><th colspan="2">3.2 Building the HIP runtime 3.3 . .</th><td>.</td><td>7</td></tr><tr><td></td><th colspan="2">Build HIP tests . . .</th><td>10</td></tr><tr><td></td><th colspan="2">. . . 3.4 Run HIP . . . . . . . . . . .</th><td>11</td></tr><tr><th>4</th><th colspan="2">HIP programming model</th><th>13</th></tr><tr><td></td><th colspan="2">4.1</th><td>13</td></tr><tr><th>4.2</th><th colspan="2">RDNA &amp;CDNAarchitecture summary Heterogeneous Programming . .</th><td>14</td></tr><tr><td></td><th colspan="2">Single instruction multiple threads (SIMT) . . .</th><td>14</td></tr><tr><th>4.3 4.4</th><th colspan="2">Inherent thread model . .</th><td>15</td></tr><tr><th>4.5</th><th colspan="2">. . . . 4.4.1 Cooperative groups thread</th><td>16</td></tr><tr><td></td><th colspan="2">Memory model . . . . . . . . .</th><td>16</td></tr><tr><td></td><th colspan="2">4.6 Execution model .</th><td>. . . . .</td><td>17</td></tr><tr><td></td><th colspan="2">4.6.1 Host-side</th><td></td></tr><tr><td></td><td></td><th>execution</th><td>17 17</td></tr><tr><td></td><th>4.6.2</th><th>Device-side execution . .</th><td></td></tr><tr><td></td><th>4.6.3</th><th>Kernel launch .</th><td>18</td></tr><tr><th>5</th><th colspan="2">Hardware implementation</th><th>19</th></tr><tr><td></td><th colspan="2">Compute units</th><td>. . . . . . .</td><td>19</td></tr><tr><td></td><td></td><td>. . . . .</td><td>20</td></tr><tr><th>5.1</th><th>5.1.1 5.1.2</th><th>SIMD . . Vector cache . .</th><td>20</td></tr><tr><td></td><th>5.1.3</th><th>. . Local data share . .</th><td>20</td></tr><tr><td></td><th>5.1.4</th><th>Scalar Unit . . . .</th><td>20</td></tr><tr><td></td><th colspan="2">5.2 CDNA architecture .</th><td>. . . .</td><td>20</td></tr><tr><td></td><th colspan="2">5.3 RDNA architecture . .</th><td>. . . .</td><td>21</td></tr><tr><td></td><th colspan="2">5.4 Shader engines . .</th><td>. . . .</td><td>21</td></tr><tr><td></td><th colspan="2">(CLR)</th><td></td></tr><tr><th>6</th><th colspan="2">AMDcommon language runtimes</th><td>23</td></tr><tr><td></td><th colspan="2">6.1 Project organization</th><td>. . . .</td><td>23</td></tr><tr><td></td><th colspan="2">How to build/install .</th><td>. . .</td><td>23</td></tr><tr><th>6.2</th><th>6.2.1</th><th>Prerequisites . . .</th><td>23</td></tr><tr><td></td><th>6.2.2</th><th>Linux . . . . . . .</th><td>23</td></tr><tr><td></td><th>6.2.3</th><th>Test . . . . . . . .</th><td>24</td></tr></tbody></table>
-<table><tbody><tr><td></td><td>6.2.4</td><td>Release notes . . . . . . . . . . . . . . . . . . . . .</td><td>24</td></tr><tr><th colspan="3">HIP programming manual</th><td>25</td></tr><tr><th>7 7.1</th><th colspan="2">Host Memory . . . . .</th><td>. . . . . . . . . . . . . . . . . . . . .</td><td>25</td></tr><tr><td></td><th>7.1.1</th><th>Introduction . . . . . . . . . . . . . . .</th><td>25</td></tr><tr><td></td><th>7.1.2</th><th>. . . . . . . Memory allocation flags . . . . . . . . .</th><td>25</td></tr><tr><td></td><th>7.1.3</th><th>. . . . . . Numa-aware host memory allocation . . . . . . . . .</th><td>26</td></tr><tr><td></td><th>7.1.4</th><th>Coherency Controls . . . . . . . . .</th><td>26</td></tr><tr><td></td><th>7.1.5</th><th>. . . . . . . . . Visibility of Zero-Copy Host Memory . . . . . . . .</th><td>27</td></tr><tr><td></td><th>7.1.6</th><th>hipEventSynchronize . . . . . . . . . . .</th><td>27</td></tr><tr><td></td><th>7.1.7</th><th>. . . . Summary and Recommendations . . . . . . . . . . .</th><td>27</td></tr><tr><td></td><th>7.1.8</th><th>Managed memory allocation . . . . . . . . . . . . .</th><td>28</td></tr><tr><td></td><th>7.1.9</th><th>HIP Stream Memory Operations . . . . . . . . . . .</th><td>28</td></tr><tr><th>7.2</th><th colspan="2">Direct Dispatch . . . . . .</th><td>. . . . . . . . . . . . . . . . . . .</td><td>28</td></tr><tr><th>7.3</th><th colspan="2">HIP Runtime Compilation</th><td>. . . . . . . . . .</td><td>29</td></tr><tr><th>7.4</th><th colspan="2">. . . . . . . . . HIP Graph . . . . . . . . . . . . . . . . .</th><td>. . . . . . . . . .</td><td>29</td></tr><tr><th>7.5</th><th colspan="2">Device-Side Malloc . . . . . .</th><td>. . . . . . . . . . . . .</td><td>29</td></tr><tr><th>7.6</th><th colspan="2">. . . Use of Per-thread default stream . . .</th><td>. . . . . . . . . . . . .</td><td>29</td></tr><tr><th>7.7</th><th colspan="2">Use of Long Double Type . . . . .</th><td>. . . . . . . . . . . . . .</td><td>30</td></tr><tr><th>7.8</th><th colspan="2">Use of _Float16 Type . . . . . . .</th><td>30</td></tr><tr><th>7.9</th><th colspan="2">. . . . . . . . . . . . . . FMA and contractions . . . . . . . . . . . . . . . . . . . . .</th><td>30</td></tr><tr><th>7.10</th><th colspan="2">Math functions with special rounding modes . . . . . . . . . . . . . . . .</th><td>. . . . .</td><td>30</td></tr><tr><th>7.11</th><th colspan="2">Creating Static Libraries . . .</th><td>. . . . .</td><td>30</td></tr><tr><th colspan="3">8 HIP porting guide . . . . . . . . . . .</th><th>33</th></tr><tr><th>8.1</th><th colspan="2">Porting a New CUDA Project .</th><td>. . . . .</td><td>33</td></tr><tr><td></td><td></td><th>General Tips . .</th><td></td></tr><tr><td></td><th>8.1.1</th><th>. . . . . . . . . . . . . . . . . . .</th><td>33</td></tr><tr><td></td><th>8.1.2</th><th>Scanning existing CUDA code to scope the porting effort &#x27;in-place&#x27; . . . . . . . . . .</th><td>33 34</td></tr><tr><td></td><th>8.1.3</th><th>Converting a project . .</th><td></td></tr><tr><td></td><th>8.1.4</th><th>Library Equivalents . . . . . . . . . . . . . . . . . .</th><td>35 35</td></tr><tr><th>8.2</th><th>Distinguishing 8.2.1</th><th>Compiler Modes . . . . . . . . . . . . . . . . Identifying HIP Target Platform . . .</th><td>35</td></tr><tr><td></td><th>8.2.2</th><th>. . . . . . . . Identifying the Compiler: hip-clang or NVCC . . .</th><td>36</td></tr><tr><td></td><th>8.2.3</th><th>. Identifying Current Compilation Pass: Host or Device</th><td>36</td></tr><tr><td></td><th>8.2.4</th><th>Compiler Defines: Summary . . . . . . . . . . . . . . .</th><td>37</td></tr><tr><th>8.3</th><th colspan="2">Identifying Architecture Features . .</th><td>. . . . . . . . . . . . .</td><td>37</td></tr><tr><td></td><th>8.3.1</th><th>HIP_ARCH Defines . . . . . . . . . . . . . . .</th><td>37</td></tr><tr><td></td><th>8.3.2</th><th>Device-Architecture Properties . . . . . . . . . . . .</th><td>38</td></tr><tr><td></td><th>8.3.3</th><th>Table of Architecture Properties . . . . . . . . . . . . . . . . . .</th><td>38</td></tr><tr><th>8.4</th><th colspan="2">Finding HIP . . . . . . .</th><td>. . . . . . . . . . . .</td><td>39 40</td></tr><tr><th>8.5 8.6</th><th colspan="2">Identifying HIP Runtime . . . . . hipLaunchKernelGGL . . . . .</th><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>40</td></tr><tr><th>8.7</th><th colspan="2">Compiler Options . . . . . . . 8.7.1 Compiler options supported</th><td>. . . . . . . . . . . . . . . .</td><td>40</td></tr><tr><td></td><td></td><td>on AMDplatforms . . .</td><td>40</td></tr><tr><th>8.8</th><th colspan="2">Linking Issues . . .</th><td>. . . . . . . . . . . . . . . . . . . .</td><td>41</td></tr><tr><td></td><th colspan="2">. . 8.8.1 Linking With hipcc</th><td>. . . . . . . . . . . . . . . . . .</td><td>41</td></tr><tr><td></td><th>8.8.2</th><th>-lm Option . . . . . . . . . . . . . . . . .</th><td>41</td></tr><tr><th>8.9</th><th colspan="2">. . . . . Linking Code With Other Compilers</th><td>. . . . . . . . . . . . .</td><td>41</td></tr><tr><td></td><th colspan="2">8.9.1 libc++ and libstdc++</th><td></td></tr><tr><td></td><td></td><td>. . . . . . . . . . . . . . . . .</td><td>41</td></tr><tr><td></td><th>8.9.2</th><th>HIP Headers ( hip_runtime.h , hip_runtime_api.h Compiler . . . . . . . . . . .</th><td>42 42</td></tr><tr><td></td><th colspan="2">8.9.3 Using a Standard C++ 8.9.3.1 . .</th><td>. . . . . . . . . . . .</td><td>42</td></tr><tr><td></td><th colspan="2">cuda.h . . . . . 8.9.4 Choosing HIP File Extensions . .</th><td>. . . . . . . . . . . .</td><td>42</td></tr><tr><th>8.10</th><th colspan="2">Workarounds . . . . . . . . . . . .</th><td>. . . . . . . . . . . .</td><td>43</td></tr></tbody></table>
-<p>8.10.1</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>43</p>
-<table><tbody><tr><td></td><td></td><td></td><th>warpSize</th><td></td></tr><tr><td></td><td></td><td colspan="2">8.10.2 Kernel launch with group size &gt; 256 . . . . . . . . . . . . . . . . . . . . .</td><td>43</td></tr><tr><td></td><th>8.11</th><td colspan="2">memcpyToSymbol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>43</td></tr><tr><td></td><th>8.12</th><td colspan="2">CU_POINTER_ATTRIBUTE_MEMORY_TYPE</td><td>. . .</td><td>44</td></tr><tr><td></td><th>8.13</th><td colspan="2">threadfence_system . . .</td><td>. . . . . . . .</td><td>45</td></tr><tr><td></td><td></td><td colspan="2">. . . . . . 8.13.1 Textures and Cache Control . . .</td><td>. . . . . . . .</td><td>45</td></tr><tr><td></td><th>8.14</th><td colspan="2">More Tips . . . .</td><td>. . . . . . . . .</td><td>46</td></tr><tr><td></td><th>8.14.1</th><td colspan="2">. . . . . . . . . . . HIP Logging . . . . . . . . .</td><td>. . . . . . . . .</td><td>46</td></tr><tr><td></td><th>8.14.2</th><td colspan="2">Debugging hipcc</td><td>. . . . . . . . . . . . . . . .</td><td>47</td></tr><tr><td></td><th>8.14.3</th><td colspan="2">Editor Highlighting . .</td><td>. . . . . . . . . . . . .</td><td>47</td></tr><tr><td>9</td><th colspan="3">Porting CUDA driver API</th><td>49</td></tr><tr><td>9.1</td><th colspan="3">Introduction to the CUDA Driver and Runtime APIs . . . . . . . .</th><td>49</td></tr><tr><td></td><th>9.1.1</th><td colspan="2">cuModule API . . . . . . . . . . . . . .</td><td>49</td></tr><tr><td></td><th>9.1.2</th><td colspan="2">. . . . . . . . . cuCtx API . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>50</td></tr><tr><td>9.2</td><th>HIP</th><td colspan="2">Module and Ctx APIs . . . . . . . . . . . . .</td><td>. . .</td><td>50</td></tr><tr><td></td><th>9.2.1</th><td colspan="2">hipModule API . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>50</td></tr><tr><td></td><th>9.2.2</th><td colspan="2">. hipCtx API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>51</td></tr><tr><td></td><th>9.2.3</th><td colspan="2">hipify translation of CUDA Driver API . . . . . .</td><td>51</td></tr><tr><td></td><td></td><td>9.2.3.1</td><td>Address Spaces . . . . . .</td><td>51</td></tr><tr><td></td><td></td><td>9.2.3.2</td><td>. . . . . . Using hipModuleLaunchKernel . .</td><td>51</td></tr><tr><td></td><td></td><td>9.2.3.3</td><td>Additional Information</td><td>51</td></tr><tr><td></td><th>9.2.4</th><td colspan="2">. . . . . . . . . . . hip-clang Implementation Notes . . . . . . . . . .</td><td>51</td></tr><tr><td></td><td></td><td>9.2.4.1</td><td>.hip_fatbin . . . . . . . . . . . . .</td><td>51</td></tr><tr><td></td><td></td><td>9.2.4.2</td><td>Initialization and Termination Functions</td><td>52</td></tr><tr><td></td><td></td><td>9.2.4.3</td><td>Kernel Launching</td><td>52</td></tr><tr><td></td><th>9.2.5</th><td colspan="2">. . . . . . . . . . . . . . . . . . NVCC Implementation Notes . . . . . . . . . . . . . . . . .</td><td>52</td></tr><tr><td></td><td></td><td colspan="2">. . . . 9.2.5.1 Interoperation between HIP and CUDA Driver . . . . . . .</td><td>52</td></tr><tr><td></td><td></td><td colspan="2">9.2.5.2 Compilation Options . . .</td><td>. . . . . .</td><td>53</td></tr><tr><td>9.3</td><th>HIP</th><td colspan="2">Module and Texture Driver API . . . .</td><td>. . . . . . .</td><td>55</td></tr><tr><td>10</td><th colspan="3">Programming for HIP runtime compiler (RTC)</th><td>57</td></tr><tr><td>10.1</td><th colspan="3">Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</th><td>57</td></tr><tr><td>10.2</td><th>HIPRTC</th><td colspan="2">specific options . . . . . . . .</td><td>. . . . . . . . .</td><td>61</td></tr><tr><td></td><th>10.2.1</th><td colspan="2">Bitcode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>62</td></tr><tr><td></td><th>10.2.2</th><td colspan="2">CU Mode vs WGP mode . . . . . .</td><td>62</td></tr><tr><td>10.3</td><th>Linker</th><td colspan="2">APIs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>62</td></tr><tr><td></td><th>10.3.1</th><td colspan="2">Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>63 63</td></tr><tr><td></td><th>10.3.2</th><td colspan="2">10.3.1.1 Note . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Input Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>64</td></tr><tr><td></td><th>10.3.3</th><td colspan="2">. Backward Compatibility of LLVM Bitcode/IR . . . . . . . . . . . . . .</td><td>64</td></tr><tr><td></td><th>10.3.4</th><td colspan="2">Link Options . . . . . . . . . .</td><td>. . . . . . . .</td><td>64</td></tr><tr><td>10.4</td><th colspan="3">Error Handling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</th><td>65</td></tr><tr><td>10.5</td><th colspan="3">HIPRTC General APIs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</th><td>65</td></tr><tr><td>10.6</td><th colspan="3">Lowered Names (Mangled Names) . . . . . . . . . . .</th><td>66</td></tr><tr><td></td><th>10.6.1 10.6.2</th><td colspan="2">Note . . . . . . . . . . . . . . . . . . . . . . . . . . . Example . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>66 66</td></tr><tr><td>10.7</td><th colspan="3">. . . . . . . . . . .</th><td>67</td></tr><tr><td>10.8</td><th colspan="3">Versioning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . HIP header support . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</th><td>68</td></tr><tr><td>10.9</td><th colspan="3">Deprecation notice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</th><td>68</td></tr><tr><td>11</td><td></td><td></td><td></td><td>69</td></tr><tr><td>11.1</td><th colspan="3">Performance guidelines Parallel</th><td>execution</td><td>. . . . . . . . . . . . . . . . . . . . .</td><td>69</td></tr></tbody></table>
-<p>11.1.2</p>
-<p>Device level</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>69</p>
-<table><tbody><tr><td></td><td>11.1.3</td><td>Multiprocessor level . . . . . . . . . . . . . .</td><td>70</td></tr><tr><td>11.2</td><td>Memory</td><td>optimization . . . . . . . . . . . .</td><td>70</td></tr><tr><td></td><td>11.2.1</td><td>Data Transfer . . . . . . . . . . . . .</td><td>70</td></tr><tr><td></td><td>11.2.2</td><td>. . Device Memory Access . . . . . . . . . .</td><td>71</td></tr><tr><td>11.3</td><td colspan="2">Optimization for maximum instruction throughput</td><td>71</td></tr><tr><td></td><td>11.3.1</td><td>Arithmetic instructions . . . . . . . . .</td><td>72</td></tr><tr><td></td><td>11.3.2</td><td>. Control flow instructions . . . . . . . . .</td><td>72</td></tr><tr><td></td><td>11.3.3</td><td>Synchronization . . . . . . . . . .</td><td>72</td></tr><tr><td>11.4</td><td colspan="2">. . . . Minimizing memory thrashing .</td><td>. . . . . . . . . .</td><td>73</td></tr><tr><td colspan="3">12 Debugging with HIP</td><td>75</td></tr><tr><td>12.1</td><td colspan="2">Tracing . .</td><td>. . . . . . . . . . . . . . . . . . . . .</td><td>75</td></tr><tr><td>12.2</td><td colspan="2">Debugging . . . . . .</td><td>. . . . . . . .</td><td>77</td></tr><tr><td></td><td colspan="2">. . . . . . . 12.2.1 Debugging HIP applications</td><td>. . . . . . .</td><td>77</td></tr><tr><td>12.3</td><td colspan="2">Useful environment variables</td><td>. . . . . . .</td><td>79</td></tr><tr><td></td><td>12.3.1</td><td>. . . . Kernel enqueue serialization . . . . . . .</td><td>79</td></tr><tr><td></td><td>12.3.2</td><td>Making device visible . . . . . . . . . . .</td><td>79</td></tr><tr><td></td><td>12.3.3</td><td>Dump code object . .</td><td>79</td></tr><tr><td></td><td>12.3.4</td><td>. . . . . . . . . . . HSA-related environment variables (Linux)</td><td>80</td></tr><tr><td></td><td colspan="2">12.3.5 HIP environment variable summary . .</td><td>.</td><td>80</td></tr><tr><td>12.4</td><td colspan="2">General debugging tips . . .</td><td>. . . . . . . . . . . .</td><td>82</td></tr><tr><td colspan="3">13 Logging HIP activity</td><td>83</td></tr><tr><td>13.1</td><td colspan="2">Logging level . . . . . . . .</td><td>. . . . . . . . . . . .</td><td>83</td></tr><tr><td>13.2</td><td colspan="2">Logging mask . . . . .</td><td>. . .</td><td>84</td></tr><tr><td>13.3</td><td colspan="2">. . . . . . . . . . . Logging command . . . . . . . . . . . . . .</td><td>. . .</td><td>84</td></tr><tr><td>13.4</td><td colspan="2">Logging examples . . . . . .</td><td>. . . . . . . . . . .</td><td>85</td></tr><tr><td colspan="3">14 Cooperative groups . . . . . . . . . . . .</td><td>89</td></tr><tr><td>14.1</td><td colspan="2">Cooperative groups thread model . . .</td><td>89</td></tr><tr><td>14.2</td><td colspan="2">Group types . . . . . . . . group</td><td>. . . . . . . . .</td><td>90</td></tr><tr><td></td><td>14.2.1</td><td>Thread-block . . . . . . . . . . . . .</td><td>90</td></tr><tr><td></td><td>14.2.2</td><td>Grid group . . . . . . . . . . . . . .</td><td>90</td></tr><tr><td></td><td>14.2.3</td><td>. Multi-grid group . . . . . . . . . . . . .</td><td>90</td></tr><tr><td></td><td>14.2.4 14.2.5</td><td>Thread-block tile . . . . . . . . . . . . . Coalesced groups . . . . . . . . . . . . .</td><td>91 91</td></tr><tr><td>14.3</td><td colspan="2">Cooperative groups simple example . .</td><td>. . . . . .</td><td>92</td></tr><tr><td>14.4</td><td colspan="2">Synchronization . . . . . .</td><td>. . . . . . . .</td><td>94</td></tr><tr><td>14.5</td><td colspan="2">. . . .</td><td>. . . .</td><td>97</td></tr><tr><td></td><td colspan="2">Unsupported NVIDIA CUDA features . . .</td><td></td></tr><tr><td colspan="3">15 Unified memory</td><td>99</td></tr><tr><td>15.1</td><td colspan="2">Unified memory . . .</td><td>. . . . . . . . . . . . . . .</td><td>99 99</td></tr><tr><td>15.2</td><td colspan="2">System requirements . . . . .</td><td>. . . . . . . . . . .</td><td>100</td></tr><tr><td>15.3</td><td colspan="2">Unified memory programming models</td><td>. . . . . .</td><td></td></tr><tr><td></td><td>15.3.1</td><td>Checking unified memory management support</td><td>100</td></tr><tr><td></td><td colspan="2">15.3.2 Example for unified memory management</td><td>101</td></tr><tr><td>15.4</td><td colspan="2">Using unified memory management (UMM)</td><td>. . .</td><td>104</td></tr><tr><td>15.5</td><td colspan="2">Unified memory HIP runtime hints . . . . .</td><td>for the better performance</td><td>104</td></tr><tr><td></td><td>15.5.1</td><td>Data prefetching . . . . . . . . .</td><td>105</td></tr><tr><td></td><td>15.5.2</td><td>Memory advice . . . . . . . . . . . . . .</td><td>106 107</td></tr><tr><td></td><td>15.5.3 15.5.4</td><td>Memory range attributes . . . . . . . . . Asynchronously attach memory to a stream</td><td>108</td></tr><tr><td colspan="3">16 Virtual memory management</td><td>109</td></tr></tbody></table>
-<table><tbody><tr><td>16.1</td><td>Memory allocation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16.1.1</td><td>. . . 109 . . .</td></tr><tr><td></td><td>Allocate physical memory . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>109</td></tr><tr><td>16.1.2</td><td>Reserve virtual address range . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . 110</td></tr><tr><td>16.1.3</td><td>Set memory access . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . 110</td></tr><tr><td></td><td>Free virtual memory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . 110</td></tr><tr><td>16.2</td><td>16.1.4 Memory usage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . 111</td></tr><tr><td></td><td>16.2.1 Dynamically increase allocation size . . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . 111</td></tr><tr><td colspan="2">17 Frequently asked questions</td><td>113</td></tr><tr><td>17.1</td><td>What APIs and features does HIP support? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . 113</td></tr><tr><td>17.2</td><td>What is not supported? . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . 113</td></tr><tr><td></td><td>17.2.1 Runtime/Driver API features . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . 113</td></tr><tr><td></td><td>17.2.2 Kernel language features . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . 114</td></tr><tr><td>17.3 Is</td><td>HIP a drop-in replacement for CUDA? . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . 114</td></tr><tr><td>17.4</td><td>What specific version of CUDA does HIP support? . . . . . . . . . . . . . . . . . . . .</td><td>. . . 114</td></tr><tr><td>17.5</td><td>What libraries does HIP support? . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . 115</td></tr><tr><td>17.6</td><td>How does HIP compare with OpenCL? . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . 115</td></tr><tr><td>17.7</td><td>How does porting CUDA to HIP compare to porting CUDA to OpenCL? . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . 115</td></tr><tr><td>17.8</td><td>What hardware does HIP support? . . . . . . . .</td><td>. . . 116</td></tr><tr><td>17.9</td><td>Do HIPIFY tools automatically convert all source code? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . 116</td></tr><tr><td>17.10</td><td>What is NVCC? . . . . . . . . . . . . . . . .</td><td>. . . 116</td></tr><tr><td>17.11</td><td>. . What is HIP-Clang? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . 116</td></tr><tr><td>17.12</td><td>Why use HIP rather than supporting CUDA directly? . . . . . . . . . . . . . . . . . . .</td><td>. . . 116 117</td></tr><tr><td>17.13</td><td>Can I develop HIP code on an NVIDIA CUDA platform? . . . . . . . . . . . . . . . . Can I develop HIP code on an AMDHIP-Clang platform? . . . . . . . . . . . . . . . .</td><td>. . . . . . 117</td></tr><tr><td>17.14</td><td>How to use HIP-Clang to build HIP programs? . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . 117</td></tr><tr><td>17.15</td><td>. . . . . . . . . . . . . .</td><td></td></tr><tr><td>17.16 17.17</td><td>What is AMDclr? . . . . . . . . . . . . . . . . . . . What is hipother? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . 117 . . . 118</td></tr><tr><td>17.18</td><td>Can I get HIP open source repository . . . . . . . . . . . . . . . .</td><td>. . . 118</td></tr><tr><td>17.19</td><td>for Windows? . . . Can a HIP binary run on both AMDand NVIDIA platforms? .</td><td>. . . 118</td></tr><tr><td>17.20 or</td><td>. . . . . . . . . . . . . On HIP-Clang, can I link HIP code with host code compiled with another compiler such clang? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>icc, . . . 118</td></tr><tr><td>17.21</td><td>Can HIP API support C style application? What is the difference between C and C++? . .</td><td>. . . 118</td></tr><tr><td>17.22</td><td>Can I install both CUDA SDK and HIP-Clang on the same machine? . . . . . . . . .</td><td>. . . 119</td></tr><tr><td>17.23</td><td>HIP detected my platform (HIP-Clang vs NVCC) incorrectly * what should I do? . . . . . . . . . . . . . . .</td><td>. . . 119</td></tr><tr><td>17.24</td><td>On CUDA, can I mix CUDA code with HIP code? . . . . . . . . . . . . . .</td><td>. . . 120</td></tr><tr><td>17.25</td><td>How do I trace HIP application flow? . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . 120</td></tr><tr><td>17.26</td><td>What are the maximum limits of kernel launch parameters? . . . . . . . . . . . . . . .</td><td>. . . 120</td></tr><tr><td>17.27</td><td>Are __shfl_*_sync functions supported on HIP platform? . . . . . . . . . . . . . . .</td><td>. . . 120</td></tr><tr><td>17.28</td><td>How to create a guard for code that is specific to the host or the GPU? . . . . . . . . . .</td><td>. . . 120</td></tr><tr><td>17.29</td><td>Why _OpenMP is undefined when compiling with -fopenmp ? . . . . . . . . . . . . . .</td><td>. . . 121</td></tr><tr><td>17.30</td><td>Does the HIP-Clang compiler support extern shared declarations? . . . . . . . . . . . .</td><td>. . . 121 code</td></tr><tr><td>17.31</td><td>I have multiple HIP enabled devices and I am getting an error hipErrorSharedObjectInitFailed with the message &#x27;Error: shared object initialization failed&#x27;? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . 121</td></tr><tr><td>17.32</td><td>How to use per-thread default stream in HIP? . . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . 122</td></tr><tr><td>17.33</td><td>How to use complex multiplication and division operations? . . . . . . . . .</td><td>. . . 122</td></tr><tr><td>17.34</td><td>. . . . . . Can I develop applications with HIP APIs on Windows the same on Linux? . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . 122</td></tr><tr><td>17.35</td><td>Does HIP support LUID? . . . . . . . . . . .</td><td>. . . 123</td></tr><tr><td>17.36</td><td>How can I know the version of HIP? . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . 123</td></tr><tr><td>18 HIP Runtime 18.1 Related</td><td>API Reference Pages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>125 . . . 126</td></tr></tbody></table>
-<p>18.3</p>
-<p>Namespaces</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>126</p>
-<table><tbody><tr><td></td><td>18.3.1</td><td colspan="2">Namespace List . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td>18.3.2</td><td colspan="2">Namespace Members . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td colspan="2">18.3.2.1 Namespace Members . . . . .</td><td>126</td></tr><tr><td></td><td></td><td colspan="2">18.3.2.2 Namespace Members .</td><td>126</td></tr><tr><td>18.4</td><td colspan="3">. . . . . Data Structures . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td>18.4.1 Data</td><td colspan="2">Structures . . . . . . . .</td><td>. .</td><td>126</td></tr><tr><td></td><td>18.4.2</td><td colspan="2">. . . Data Structure Index . . . . . . . .</td><td>126</td></tr><tr><td></td><td>18.4.3</td><td colspan="2">. . . Class Hierarchy . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td>18.4.4</td><td colspan="2">. . Data Fields . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td colspan="2">18.4.4.1 All . . . . . . . . . . . . . .</td><td>.</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.1</td><td>Data Fields . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.2</td><td>Data Fields . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.3</td><td>Data Fields . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.4</td><td>Data Fields . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.5</td><td>Data Fields . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.6</td><td>Data Fields . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.7</td><td>. Data Fields . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.8</td><td>Data Fields . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.9</td><td>Data Fields . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.10</td><td>Data Fields . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.11</td><td>Data Fields . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.12</td><td>Data Fields . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.13</td><td>Data Fields . . . . . Data Fields .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.14</td><td>. . . . Data Fields</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.15</td><td>. . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.16</td><td>Data Fields . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.17</td><td>Data Fields . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.18</td><td>Data Fields . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.19</td><td>Data Fields . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.20</td><td>Data Fields . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.21</td><td>Data Fields . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.22</td><td>Data Fields . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.23</td><td>Data Fields . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.24</td><td>Data Fields . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.1.25</td><td>. Data Fields . . . . .</td><td>126 126</td></tr><tr><td></td><td colspan="3">18.4.4.2 Data Fields - Functions . . . . . . . . . . . . . 18.4.4.3 Variables . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.3.1</td><td>Data Fields - Variables</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.3.2</td><td>Data Fields - Variables</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.3.3</td><td>Data Fields - Variables</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.3.4</td><td>Data Fields - Variables</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.3.5</td><td>Data Fields - Variables</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.3.6</td><td>Data Fields - Variables</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.3.7</td><td>Data Fields - Variables</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.3.8</td><td>Data Fields - Variables</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.3.9</td><td>Data Fields - Variables</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.3.10</td><td>Data Fields - Variables</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.3.11</td><td>Data Fields - Variables</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.3.12</td><td>Data Fields - Variables</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.3.13</td><td>Data Fields - Variables</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.3.14 18.4.4.3.15</td><td>Data Fields - Variables Data Fields - Variables</td><td>126 126</td></tr><tr><td></td><td></td><td>18.4.4.3.16</td><td>Data Fields - Variables</td><td>126</td></tr></tbody></table>
-<p>18.4.4.3.17</p>
-<p>Data Fields - Variables</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>126</p>
-<table><tbody><tr><td></td><td></td><td>18.4.4.3.18</td><td>Data Fields - Variables</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.3.19</td><td>Data Fields - Variables</td><td>. . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.3.20</td><td>Data Fields -</td><td>Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.3.21</td><td>Data Fields - Variables</td><td>. . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.3.22</td><td>Data</td><td>Fields - Variables . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.3.23</td><td>Data Fields -</td><td>. . . . . . Variables . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.3.24</td><td>Data</td><td>Fields - Variables . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.4.4.3.25</td><td>Data</td><td>Fields - Variables . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td>18.5</td><td colspan="3">18.4.4.4 Data Fields - Related Symbols . .</td><td>. . . . . . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . 126 . . . . . . . . .</td><td>126</td></tr><tr><td></td><td>Files 18.5.1</td><td>File List . . . . .</td><td>. . . . . . . . . . . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td>18.5.2</td><td>Globals . . .</td><td>. . . . . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.5.2.1 All . .</td><td>. . . . . . . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.5.2.1.1</td><td>Globals . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.5.2.1.2</td><td>Globals . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.5.2.1.3</td><td>Globals . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.5.2.1.4</td><td>Globals . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.5.2.1.5</td><td>Globals . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.5.2.1.6</td><td>Globals . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.5.2.1.7</td><td>Globals . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.5.2.1.8</td><td>Globals . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.5.2.1.9</td><td>Globals</td><td></td><td>126</td></tr><tr><td></td><td></td><td></td><td>. .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.5.2.2 Functions 18.5.2.2.1</td><td>. . . . . . . Globals . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.5.2.2.2</td><td>Globals . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.5.2.2.3</td><td>Globals . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.5.2.3 Globals</td><td>. . . . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.5.2.4 Globals</td><td>. . . . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td></td><td>. . . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.5.2.5 Globals</td><td>Enumerator . . . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.5.2.6 18.5.2.6.1</td><td>Globals . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>18.5.2.6.2</td><td>Globals .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td></td><td>Globals</td><td>.</td><td>. . . .</td><td></td></tr><tr><td></td><td>18.5.2.7</td><td></td><td>. . . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>126</td></tr><tr><td></td><td colspan="3">C++ language extensions</td><td></td><td>127</td></tr><tr><td>19.1</td><td>Function-type</td><td>qualifiers</td><td>. . . . . . . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>127 127</td></tr><tr><td></td><td>19.1.1</td><td>__device__ . .</td><td>. . . . . . . . . . . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>128</td></tr><tr><td></td><td>19.1.2</td><td>__global__</td><td>. . . . . .</td><td></td><td></td></tr><tr><td></td><td>19.1.3</td><td>__host__ . . .</td><td>. . . . . . . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>128</td></tr><tr><td>19.2 19.3</td><td colspan="3">Calling __global__ functions . . . . .</td><td>. . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>128 129</td></tr><tr><td>19.4</td><td colspan="3">Kernel launch example . . . . . . . . Variable type qualifiers . . . . . . . .</td><td>. .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>130</td></tr><tr><td></td><td colspan="3">.</td><td></td><td>130</td></tr><tr><td></td><td>19.4.1</td><td>__constant__</td><td>. . . . . . . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td></td></tr><tr><td></td><td>19.4.2</td><td>__shared__ .</td><td>. . . . . . . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>130</td></tr><tr><td></td><td>19.4.3</td><td>__managed__ .</td><td>. . . . . . . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>130</td></tr><tr><td></td><td>19.4.4</td><td>__restrict__</td><td>. . . . . . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>130</td></tr><tr><td>19.5</td><td colspan="3">. Built-in variables . . . . . . . . . . .</td><td>. .</td><td>. . . . . . . . .</td><td>130</td></tr><tr><td></td><td>19.5.1</td><td>Coordinate built-ins</td><td>. . . . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>130</td></tr><tr><td></td><td>19.5.2</td><td>warpSize . . .</td><td>. . . . . . . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>131</td></tr><tr><td>19.6</td><td colspan="3">Vector types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>. . . . . . . . .</td><td>131</td></tr><tr><td></td><td>19.6.1</td><td>Short vector types</td><td>. . . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>131</td></tr><tr><td>19.7</td><td colspan="3">19.6.2 dim3 . . . . . . . . . . . . . . . . . . Memory fence instructions . . . . . . . . . . .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132</td><td>132</td></tr></tbody></table>
-<p>19.8</p>
-<p>Synchronization functions</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>.</p>
-<p>132</p>
-<table><tbody><tr><td></td><th>.</th><td>. .</td><td></td></tr><tr><th>19.9</th><th>Math</th><td>functions . . . . . . . . . . .</td><td>132</td></tr><tr><th>19.10</th><th>Texture</th><td>functions . . . . . . . . . . . . .</td><td>133</td></tr><tr><th>19.11</th><th>Surface</th><td>functions . . . . . . . . . . . . .</td><td>133</td></tr><tr><th>19.12</th><th>Timer</th><td>functions . . . . . . . . . . . . . .</td><td>137</td></tr><tr><th>19.13</th><th>Atomic</th><td>functions</td><td>138</td></tr><tr><td></td><th>19.13.1</th><td>. . . . . . . . . . . . . Unsafe floating-point atomic RMWoperations</td><td>139</td></tr><tr><th>19.14</th><th>Warp cross-lane</th><td>functions . .</td><td>140</td></tr><tr><td></td><th>19.14.1</th><td>. . . . . . Warp vote and ballot functions .</td><td>140</td></tr><tr><td></td><th>19.14.2 Warp</th><td>match functions . . . . .</td><td>141</td></tr><tr><td></td><th>19.14.3</th><td>. Warp shuffle functions . . . . .</td><td>142</td></tr><tr><th>19.15</th><th>Cooperative groups</th><td>functions . . . . . .</td><td>142</td></tr><tr><th>19.16</th><th>Warp matrix</th><td>functions . . . . . . .</td><td>143</td></tr><tr><th>19.17</th><th>Independent</th><td>. . . thread scheduling . . . . . .</td><td>144</td></tr><tr><th>19.18</th><th>Profiler</th><td>Counter Function . . . . . . . .</td><td>144</td></tr><tr><th>19.19</th><th>Assert . . . . .</th><td>. . . . . . . . . . . . . .</td><td>144</td></tr><tr><th>19.20</th><th>. . . .</th><td>printf . . . . . . . . . . . . . .</td><td>144</td></tr><tr><th>19.21</th><td></td><td>Device-Side Dynamic Global Memory Allocation . . . . . . . .</td><td>145</td></tr><tr><th>19.22</th><td></td><td>__launch_bounds__ . .</td><td>145</td></tr><tr><td></td><th>19.22.1</th><td>Compiler Impact . . . . . . . .</td><td>145</td></tr><tr><td></td><th>19.22.2</th><td>CU and EU Definitions . . . . .</td><td>146 146</td></tr><tr><td></td><th>19.22.3 19.22.4 maxregcount</th><td>Porting from CUDA __launch_bounds . . . . . . . . . .</td><td>146</td></tr><tr><th>19.23</th><td></td><td>Asynchronous Functions . . . . . . . . .</td><td>147</td></tr><tr><td></td><th>19.23.1</th><td>Memory stream . . . . . . . . .</td><td>147</td></tr><tr><td></td><th>19.23.2</th><td>Peer to peer . . . . . .</td><td>163</td></tr><tr><td></td><th>19.23.3</th><td>. . . . . Memory management . . .</td><td>165</td></tr><tr><td></td><th>19.23.4</th><td>. . . External Resource Interoperability</td><td>195</td></tr><tr><td></td><th>Register</th><td>Keyword . . . . . . . . . . . . .</td><td>197</td></tr><tr><th>19.24</th><th>19.25 Pragma</th><td>Unroll . . . . . . . . . . . . .</td><td>198</td></tr><tr><th>19.26</th><th>In-Line</th><td>Assembly . . . . . . . . . . . .</td><td>198</td></tr><tr><th>19.27</th><th>Kernel</th><td>Compilation . . . . . . . . . . .</td><td>198</td></tr><tr><th>19.28</th><td></td><td></td><td></td></tr><tr><td></td><td></td><td>gfx-arch-specific-kernel . . . . . . . . .</td><td>199</td></tr><tr><th>C++ language 20.1</th><th>20.1.1</th><td>Modern C++ support . . . . . . . . . . . C++11 support . . . . . . . . .</td><td>201 201</td></tr><tr><td></td><th>20.1.2</th><td>C++14 support . . . . . . . . .</td><td>202</td></tr><tr><td></td><th>20.1.3</th><td>C++17 support . . . . . . . . .</td><td>202</td></tr><tr><td></td><th>20.1.4</th><td>C++20 support . . . . . . . . .</td><td>202</td></tr><tr><th>20.2</th><th>Extensions</th><td>and restrictions . . . . . . . .</td><td>202</td></tr><tr><td></td><th>20.2.1</th><td>Global functions . .</td><td>202</td></tr><tr><td></td><th>20.2.2</th><td>. . . . . . Device space memory specifiers . . . .</td><td>202</td></tr><tr><td></td><th>20.2.3</th><td>Exception handling . . . . .</td><td>203</td></tr><tr><td></td><th>20.2.4</th><td>Kernel parameters . . . . . .</td><td>203</td></tr><tr><td></td><th>20.2.5</th><td>Classes . . . .</td><td>203</td></tr><tr><td></td><th>20.2.6</th><td>. . . . . . . . . Polymorphic function wrappers .</td><td>203</td></tr><tr><td></td><th>20.2.7</th><td>Extended lambdas . . . . . . . .</td><td>203</td></tr><tr><td></td><td></td><td>Inline namespaces</td><td></td></tr><tr><td></td><th>20.2.8</th><td>. . . . . . .</td><td>203</td></tr><tr><td></td><td></td><td>.</td><td>205</td></tr><tr><th>21 HIP math</th><th colspan="2">API</th><td>205</td></tr><tr><th>21.1</th><th colspan="2">Single precision mathematical functions . . . . Double precision mathematical functions . . . Integer . . . .</th><td>215</td></tr><tr><th>21.2</th><th colspan="2">intrinsics . . . . . . . . . . . .</th><td></td></tr><tr><th>21.3</th><td></td><td></td><td>225</td></tr></tbody></table>
-<table><tbody><tr><td></td><td>21.4</td><td>Floating-point Intrinsics . . . . . . . . . . . . . .</td><td>227</td></tr><tr><td>22</td><td>Table</td><td>comparing syntax for different compute APIs</td><td>231</td></tr><tr><td></td><td>22.1</td><td>Notes . . . . . . . . . . . . . . . . . . . . . . . .</td><td>232</td></tr><tr><td>23</td><td>HIP</td><td>Cooperative groups API</td><td>233</td></tr><tr><td></td><td>23.1</td><td>Cooperative kernel launches . . . . . . . . . . . .</td><td>233</td></tr><tr><td></td><td>23.2</td><td>Cooperative groups classes . . . . . . . . . . . . .</td><td>234</td></tr><tr><td></td><td>23.3</td><td>Cooperative groups construct functions . . . .</td><td>237</td></tr><tr><td></td><td>23.4</td><td>. . Cooperative groups exposed API functions . . . .</td><td>238</td></tr><tr><td>24</td><td colspan="2">HSA runtime API for ROCm</td><td>241</td></tr><tr><td>25</td><td colspan="2">HIP managed memory allocation API</td><td>247</td></tr><tr><td>26</td><td colspan="2">HIP virtual memory management API</td><td>251</td></tr><tr><th>27</th><th>HIP deprecated</th><th>runtime API functions</th><td></td></tr><tr><td></td><td></td><td></td><td>257</td></tr><tr><td></td><td>27.1</td><td>Context management . . . . . . . . . . . . . . . .</td><td>257</td></tr><tr><td></td><td>27.2</td><td>Memory management . . . . . . . . . . . . . . . . . .</td><td>258</td></tr><tr><td></td><td>27.3</td><td>Profiler control . . . . . . . . . . . . . . . .</td><td>258</td></tr><tr><td></td><td>27.4</td><td>Texture management . . . . . . . . . . . . . . . .</td><td>258</td></tr><tr><td>28</td><td colspan="2">SAXPY - Hello, HIP</td><td>261</td></tr><tr><td></td><td colspan="2">28.1 Prerequisites . . . . . .</td><td>. . . . . . . . . . .</td><td>261</td></tr><tr><td></td><td colspan="2">. . . 28.2 Heterogeneous programming</td><td>. . . . . . . . .</td><td>261</td></tr><tr><td></td><td colspan="2">. . 28.3 Your first lines of HIP code . . .</td><td>. . . . . .</td><td>261</td></tr><tr><td></td><td colspan="2">. . . 28.4 Compiling on the command line . . . .</td><td>. . . . . .</td><td>263</td></tr><tr><td></td><td colspan="2">28.4.1 Setting up the command line</td><td>. . . . . . .</td><td>263</td></tr><tr><td></td><td>28.4.2</td><td>Invoking the compiler manually . . . . .</td><td>266</td></tr><tr><td>29</td><td colspan="2">Reduction</td><td>273</td></tr><tr><td></td><td colspan="2">29.1 The algorithm . . . 29.2</td><td>. . . . . . . . . . . . . . . .</td><td>273</td></tr><tr><td></td><td colspan="2">Reduction on GPUs</td><td>. . . . . . . . . . . . . . . .</td><td>273</td></tr><tr><td></td><td colspan="2">29.2.1 Naive shared reduction</td><td>. . . . . . . . . .</td><td>274</td></tr><tr><td></td><td>29.2.2</td><td>Reducing thread divergence . . . . . . . .</td><td>276</td></tr><tr><td></td><td>29.2.3</td><td>Resolving bank conflicts . . . . . . . . .</td><td>276</td></tr><tr><td></td><td>29.2.4</td><td>Utilize upper half of the block . . . . . . . . . . . . .</td><td>277</td></tr><tr><td></td><td>29.2.5</td><td>Unroll all loops . . . . . . .</td><td>281</td></tr><tr><td></td><td>29.2.6</td><td>Communicate using warp-collective functions</td><td>282</td></tr><tr><td></td><td>29.2.7</td><td>Prefer warp communication over shared</td><td>282</td></tr><tr><td></td><td>29.2.8</td><td>. Amortize bookkeeping variable overhead</td><td>284</td></tr><tr><td></td><td colspan="2">29.2.8.1 Reading ItemsPerThread</td><td>. . .</td><td>285</td></tr><tr><td></td><td colspan="2">29.2.8.2 Processing ItemsPerThread</td><td>. .</td><td>286</td></tr><tr><td></td><td colspan="2">29.2.9 Two-pass reduction</td><td>. . . . . . . . . . . .</td><td>286</td></tr><tr><td></td><td colspan="2">29.2.10 Global data share</td><td>. . . . . . . . . . . . .</td><td>286</td></tr><tr><td></td><td colspan="2">29.3 Conclusion . . . . .</td><td>. . . . . . . . . . . . . . . .</td><td>287</td></tr><tr><td>30</td><td colspan="2">Cooperative groups .</td><td>289</td></tr><tr><td></td><td colspan="2">30.1 Prerequisites</td><td>. . . . . . . . . . . . . . . . . . .</td><td>289</td></tr><tr><td></td><td colspan="2">30.2 Simple HIP Code</td><td>. . . . . . . . . . . . . . . . . .</td><td>289</td></tr><tr><td></td><td colspan="2">Tiled partition</td><td>. . . . . . .</td><td>289</td></tr><tr><td></td><td colspan="2">30.3 . . . . . . . . . . . . 30.3.1 Device-side code . . . . . .</td><td>. . .</td><td>290</td></tr><tr><td></td><td colspan="2">. . . . 30.3.1.1 1. Initialization of the reduction</td><td>291</td></tr><tr><td></td><td colspan="2">function variables . . . 30.3.1.2 2. The reduction of thread block . . . . . . . . . . . .</td><td>291</td></tr></tbody></table>
-<table><tbody><tr><td></td><td>30.3.1.3 3. The reduction of custom partition . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>291</td></tr><tr><td>30.3.2</td><td>Host-side code . . . . . . . . . . . .</td><td>292</td></tr><tr><td></td><td>30.3.2.1 1. Confirm the cooperative group support on AMDGPUs 30.3.2.2 . . . . .</td><td>292</td></tr><tr><td></td><td>2. Initialize the cooperative group configuration . . . . . . . . . . . . . . . . . . .</td><td>293</td></tr><tr><td>30.3.2.3 Conclusion</td><td>4. Launch the kernel . . . . .</td><td>293</td></tr><tr><td>30.4 .</td><td>. . . . . . . . . . . . . . . . . . . . . . . . . . . . .</td><td>293</td></tr><tr><td>31 License</td><td></td><td>295</td></tr></tbody></table>
-<p>Index</p>
-<p>297</p>
-<p>The Heterogeneous-computing Interface for Portability (HIP) API is a C++ runtime API and kernel language that lets developers create portable applications for AMD and NVIDIA GPUs from single source code.</p>
-<p>For HIP supported AMD GPUs on multiple operating systems, see:</p>
-<ul>
-<li style="list-style-type: '· ';">Linux system requirements</li>
-<li style="list-style-type: '· ';">Microsoft Windows system requirements</li>
-</ul>
-<p>The CUDA enabled NVIDIA GPUs are supported by HIP. For more information, see GPU Compute Capability.</p>
-<p>On the AMD ROCm platform, HIP provides header files and runtime library built on top of HIP-Clang compiler in the repository Common Language Runtimes (CLR) , which contains source codes for AMD's compute languages runtimes as follows,</p>
-<p>On non-AMD platforms, like NVIDIA, HIP provides header files required to support non-AMD specific back-end implementation in the repository 'hipother', which translates from the HIP runtime APIs to CUDA runtime APIs.</p>
-<h2>Install</h2>
-<ul>
-<li style="list-style-type: '· ';">Installing HIP</li>
-<li style="list-style-type: '· ';">Building HIP from source</li>
-</ul>
-<h2>Conceptual</h2>
-<ul>
-<li style="list-style-type: '· ';">HIP programming model</li>
-<li style="list-style-type: '· ';">Hardware implementation</li>
-<li style="list-style-type: '· ';">AMD common language runtimes (CLR)</li>
-</ul>
-<h2>How to</h2>
-<ul>
-<li style="list-style-type: '· ';">Programming manual</li>
-<li style="list-style-type: '· ';">HIP porting guide</li>
-<li style="list-style-type: '· ';">HIP porting: driver API guide</li>
-<li style="list-style-type: '· ';">Programming for HIP runtime compiler (RTC)</li>
-<li style="list-style-type: '· ';">Performance guidelines</li>
-<li style="list-style-type: '· ';">Debugging with HIP</li>
-<li style="list-style-type: '· ';">Logging HIP activity</li>
-<li style="list-style-type: '· ';">Unified memory</li>
-<li style="list-style-type: '· ';">Virtual memory</li>
-<li style="list-style-type: '· ';">Cooperative groups</li>
-<li style="list-style-type: '· ';">Frequently asked questions</li>
-</ul>
-<h2>Reference</h2>
-<ul>
-<li style="list-style-type: '· ';">HIP Runtime API Reference</li>
-<li style="list-style-type: '· ';">C++ language extensions</li>
-<li style="list-style-type: '· ';">C++ language support</li>
-<li style="list-style-type: '· ';">HIP math API</li>
-<li style="list-style-type: '· ';">Comparing syntax for different APIs</li>
-<li style="list-style-type: '· ';">HSA runtime API for ROCm</li>
-<li style="list-style-type: '· ';">HIP managed memory allocation API</li>
-</ul>
-<h2>CHAPTER ONE</h2>
-<h2>OVERVIEW</h2>
-<ul>
-<li style="list-style-type: '· ';">HIP virtual memory management API</li>
-<li style="list-style-type: '· ';">HIP Cooperative groups API</li>
-<li style="list-style-type: '· ';">List of deprecated APIs</li>
-</ul>
-<h2>Tutorial</h2>
-<ul>
-<li style="list-style-type: '· ';">HIP basic examples</li>
-<li style="list-style-type: '· ';">HIP examples</li>
-<li style="list-style-type: '· ';">HIP test samples</li>
-<li style="list-style-type: '· ';">SAXPY tutorial</li>
-<li style="list-style-type: '· ';">Reduction tutorial</li>
-<li style="list-style-type: '· ';">Cooperative groups tutorial</li>
-</ul>
-<p>Known issues are listed on the HIP GitHub repository.</p>
-<p>To contribute features or functions to the HIP project, refer to Contributing to HIP. To contribute to the documentation, refer to Contributing to ROCm docs page.</p>
-<p>You can find licensing information on the Licensing page.</p>
-<h2>CHAPTER</h2>
-<h2>TWO</h2>
-<h2>INSTALL HIP</h2>
-<p>HIP can be installed on AMD (ROCm with HIP-Clang) and NVIDIA (CUDA with NVCC) platforms.</p>
-<p>Note: The version definition for the HIP runtime is different from CUDA. On an AMD platform, the hipRuntimeGerVersion function returns the HIP runtime version; on an NVIDIA platform, this function returns the CUDA runtime version.</p>
-<h2>2.1 Prerequisites</h2>
-<h2>AMD</h2>
-<p>Refer to the Prerequisites section in the ROCm install guides:</p>
-<ul>
-<li style="list-style-type: '· ';">System requirements (Linux)</li>
-<li style="list-style-type: '· ';">System requirements (Windows)</li>
-</ul>
-<h2>NVIDIA</h2>
-<p>Check the system requirements in the NVIDIA CUDA Installation Guide.</p>
-<h2>2.2 Installation</h2>
-<h2>AMD</h2>
-<p>HIP is automatically installed during the ROCm installation. If you haven't yet installed ROCm, you can find installation instructions here:</p>
-<ul>
-<li style="list-style-type: '· ';">ROCm installation for Linux</li>
-<li style="list-style-type: '· ';">HIP SDK installation for Windows</li>
-</ul>
-<p>By default, HIP is installed into /opt/rocm/hip .</p>
-<p>Note: There is no autodetection for the HIP installation. If you choose to install it somewhere other than the default location, you must set the HIP_PATH environment variable as explained in Build HIP from source.</p>
-<h2>NVIDIA</h2>
-<ol>
-<li style="list-style-type: '1. ';">Install the NVIDIA driver.</li>
-</ol>
-<p>sudo apt-get install ubuntu-drivers-common &amp;&amp; sudo ubuntu-drivers autoinstall sudo reboot</p>
-<p>Alternatively, you can download the latest CUDA Toolkit.</p>
-<ol>
-<li style="list-style-type: '2. ';">Install the hip-runtime-nvidia and hip-dev packages. This installs the CUDA SDK and HIP porting layer.</li>
-</ol>
-<pre><code>  | apt-get install hi</code></pre>
-<pre><code>tall hip-runtime-nvidia hip-dev</code></pre>
-<h2>The default paths are:</h2>
-<ul>
-<li style="list-style-type: '· ';">CUDA SDK: /usr/local/cuda</li>
-<li style="list-style-type: '· ';">HIP: /opt/rocm/hip</li>
-</ul>
-<p>You can optionally add /opt/rocm/bin to your path, which can make it easier to use the tools.</p>
-<h2>2.3 Verify your installation</h2>
-<p>Run hipconfig in your installation path.</p>
-<p>/opt/rocm/bin/hipconfig --full</p>
-<p>CHAPTER</p>
-<h2>THREE</h2>
-<h2>BUILD HIP FROM SOURCE</h2>
-<h2>3.1 Prerequisites</h2>
-<p>HIP code can be developed either on AMD ROCm platform using HIP-Clang compiler, or a CUDA platform with nvcc installed. Before building and running HIP, make sure drivers and prebuilt packages are installed properly on the platform.</p>
-<p>You also need to install Python 3, which includes the CppHeaderParser package. Install Python 3 using the following command:</p>
-<pre><code>    | apt-get install python3</code></pre>
-<p>Check and install CppHeaderParser package using the command:</p>
-<pre><code>      | pip3 install CppHeaderParser</code></pre>
-<h2>3.2 Building the HIP runtime</h2>
-<p>Set the repository branch using the variable: ROCM_BRANCH . For example, for ROCm 6.1, use:</p>
-<pre><code>| export</code></pre>
-<pre><code><_Bash_></code></pre>
-<h2>AMD</h2>
-<ol>
-<li style="list-style-type: '1. ';">Get HIP source code.</li>
-</ol>
-<p>Note: Starting in ROCM 5.6, CLR is a new repository that includes the former ROCclr, HIPAMD and OpenCl repositories. OpenCL provides headers that ROCclr runtime depends on.</p>
-<p>Note: Starting in ROCM 6.1, a new repository hipother is added to ROCm, which is branched out from HIP. hipother provides files required to support the HIP back-end implementation on some non-AMD platforms, like NVIDIA.</p>
-<pre><code><_Bash_></code></pre>
-<pre><code>:lone -b "$ROCM_BRANCH" https://github.com/ROCm/clr.git
-:lone -b "$ROCM_BRANCH" https://github.com/ROCm/hip.git</code></pre>
-<p>CLR (Common Language Runtime) repository includes ROCclr, HIPAMD and OpenCL.</p>
-<p>ROCclr (Radeon Open Compute Common Language Runtime) is a virtual device interface which is defined on the AMD platform. HIP runtime uses ROCclr to interact with different backends.</p>
-<p>HIPAMD provides implementation specifically for HIP on the AMD platform.</p>
-<p>OpenCL provides headers that ROCclr runtime currently depends on. hipother provides headers and implementation specifically for non-AMD HIP platforms, like NVIDIA.</p>
-<ol>
-<li style="list-style-type: '2. ';">Set the environment variables.</li>
-<li style="list-style-type: '3. ';">Build HIP.</li>
-</ol>
-<pre><code><_Bash_></code></pre>
-<pre><code>        cd "$CLR_DIR"
-        mkdir -p build; cd build
-        cmake -DHIP_COMMON_DIR=$HIP_DIR -DHIP_PLATFORM=amd -DCMAKE_PREFIX_PATH="/opt/rocm/"_
-        ---DCMAKE_INSTALL_PREFIX=$PWD/install -DHIP_CATCH_TEST=0 -DCLR_BUILD_HIP=ON -DCLR_
-        --BUILD_OCL=OFF..
-        
-        make -j$(nproc)
-        sudo make install</code></pre>
-<p>Note: Note, if you don't specify CMAKE_INSTALL_PREFIX , the HIP runtime is installed at &lt;ROCM_PATH&gt;/hip .</p>
-<p>By default, release version of HIP is built. If need debug version, you can put the option CMAKE_BUILD_TYPE=Debug in the command line.</p>
-<p>Default paths and environment variables:</p>
-<ul>
-<li style="list-style-type: '· ';">HIP is installed into &lt;ROCM_PATH&gt;/hip . This can be overridden by setting the HIP_PATH environment variable.</li>
-</ul>
-<p>•</p>
-<p>HSA is in</p>
-<p>&lt;ROCM_PATH&gt;/hsa</p>
-<p>. This can be overridden by setting the</p>
-<p>HSA_PATH</p>
-<p>environment variable.</p>
-<ul>
-<li style="list-style-type: '· ';">Clang is in &lt;ROCM_PATH&gt;/llvm/bin . This can be overridden by setting the HIP_CLANG_PATH environment variable.</li>
-<li style="list-style-type: '· ';">The device library is in &lt;ROCM_PATH&gt;/lib . This can be overridden by setting the DEVICE_LIB_PATH environment variable.</li>
-<li style="list-style-type: '· ';">Optionally, you can add &lt;ROCM_PATH&gt;/bin to your PATH , which can make it easier to use the tools.</li>
-<li style="list-style-type: '· ';">Optionally, you can set HIPCC_VERBOSE=7 to output the command line for compilation.</li>
-</ul>
-<p>After you run the make install command, make sure HIP_PATH points to $PWD/install/hip .</p>
-<ol>
-<li style="list-style-type: '1. ';">Generate a profiling header after adding/changing a HIP API.</li>
-</ol>
-<p>Whenyouadd or change a HIP API, you may need to generate a new hip_prof_str.h header. This header is used by ROCm tools to track HIP APIs, such as rocprofiler and roctracer .</p>
-<p>To generate the header after your change, use the hip_prof_gen.py tool located in hipamd/src .</p>
-<p>Usage:</p>
-<pre><code><_PHP_></code></pre>
-<pre><code>                                                                                                                                                                                                        |                                                                                                                                                                                                       
-                                                                                                                                                                                                        <! hip_prof_gen.py                                                                                                                                                                                                        </!                                                                                                                                                                                                        >
-                                                                                                                                                                                                       <?php                                                                                                                                                                                                        +</code></pre>
-<h2>Flags:</h2>
-<ul>
-<li style="list-style-type: '· ';">-v : Verbose messages</li>
-<li style="list-style-type: '· ';">-r : Process source directory recursively</li>
-<li style="list-style-type: '· ';">-t : API types matching check</li>
-<li style="list-style-type: '· ';">--priv : Private API check</li>
-<li style="list-style-type: '· ';">-e : On error exit mode</li>
-<li style="list-style-type: '· ';">-p : HIP_INIT_API macro patching mode</li>
-</ul>
-<p>Example usage:</p>
-<pre><code><_Bash_></code></pre>
-<h2>NVIDIA</h2>
-<pre><code>git clone -b "$ROCM_BRANCH" https://github.com/ROCm/clr.git
-git clone -b "$ROCM_BRANCH" https://github.com/ROCm/hip.git
-git clone -b "$ROCM_BRANCH" https://github.com/ROCm/hipother.git</code></pre>
-<pre><code>--- ---
-
-    1. Get the HIP source code.
-        git clone -b "$ROCM_BRANCH"
-        git clone -b "$ROCM_BRANCH"
-        git clone -b "$ROCM_BRANCH"
-
-    2. Set the environment variables.</code></pre>
-<pre><code>export CLR_DIR="$(readlink -f clr)"
-export HIP_DIR="$(readlink -f hip)"
-export HIP_OTHER="$(readlink -f hipother)"</code></pre>
-<pre><code>3.  Build HIP.</code></pre>
-<pre><code>cd "$CLR_DIR"
-mkdir -p build; cd build
-cmake -DHIP_COMMON_DIR=$HIP_DIR -DHIP_PLATFORM=nvidia -DCMAKE_INSTALL_PREFIX=$PWD/
- --install -DHIP_CATCH_TEST=0 -DCLR_BUILD_HIP=ON -DCLR_BUILD_OCL=OFF -DHIPNV_DIR=
- --$HIP_OTHER/hipnv..
-make -j$(nproc)
-sudo make install</code></pre>
-<h2>3.3 Build HIP tests</h2>
-<h2>AMD</h2>
-<ul>
-<li style="list-style-type: '· ';">Build HIP catch tests.</li>
-</ul>
-<pre><code>git clone -b "$ROCM_BRANCH" https://github.com/ROCm/hip-tests.git  |</code></pre>
-<pre><code>        - npm -m -cos no-source.
-
-            export HIPTESTS_DIR="$(readlink -f hip-tests)"
-            cd "$HIPTESTS_DIR"
-            mkdir -p build; cd build
-            cmake../catch -DHIP_PLATFORM=amd -DHIP_PATH=$CLR_DIR/build/
-            --install  # or any path where HIP is installed; for example: ``/
-            --opt/rocm``
-            make build_tests
-            ctest # run tests</code></pre>
-<pre><code>AMD
-
-     *  Build HIP catch tests.
-
-                HIP catch tests are separate from the HIP project and use Catch2.
-
-                    - Get HIP tests source code.</code></pre>
-<pre><code>      - command: command.json.
-        
-          cd "$HIPTESTS_DIR"
-          hipcc $HIPTESTS_DIR/catch/unit/memory/hipPointerGetAttributes.cc \
-          -I./catch/include./catch/hipTestMain/standalone_main.cc \
-          -I./catch/external/Catch2 -o hipPointerGetAttributes
-         ./hipPointerGetAttributes
-         ...
-
-          All tests passed</code></pre>
-<h2>NVIDIA</h2>
-<p>The commands to build HIP tests on an NVIDIA platform are the same as on an AMD platform. However, you must first set -DHIP_PLATFORM=nvidia .</p>
-<h2>3.4 Run HIP</h2>
-<p>After installation and building HIP, you can compile your application and run. A simple example is square sample.</p>
-<h2>FOUR</h2>
-<h2>HIP PROGRAMMING MODEL</h2>
-<p>The HIP programming model makes it easy to map data-parallel C/C++ algorithms to massively parallel, wide single instruction, multiple data (SIMD) architectures, such as GPUs.</p>
-<p>While the model may be expressed in most imperative languages, (for example Python via PyHIP) this document will focus on the original C/C++ API of HIP.</p>
-<p>A basic understanding of the underlying device architecture helps you make efficient use of HIP and general purpose graphics processing unit (GPGPU) programming in general.</p>
-<h2>4.1 RDNA &amp; CDNA architecture summary</h2>
-<p>GPUs in general are made up of basic building blocks called compute units (CUs), that execute the threads of a kernel. These CUs provide the necessary resources for the threads: the Arithmetic Logical Units (ALUs), register files, caches and shared memory for efficient communication between the threads.</p>
-<p>This design allows for efficient execution of kernels while also being able to scale from small GPUs embedded in APUs with few CUs up to GPUs designed for data centers with hundreds of CUs. Figure Block Diagram of an RDNA3 Compute Unit. and Block Diagram of a CDNA3 Compute Unit. show examples of such compute units.</p>
-<p>For architecture details, check Hardware implementation .</p>
-<figure><figcaption><div class="caption">Fig. 1: Block Diagram of an RDNA3 Compute Unit.</div> <div data-annotation-kind="description">Schedule.</div></figcaption><img src="hip_spec-with-image-refs_artifacts/image_000000_5208c655dc4611802372524b387216259e5e5c3c192ee9dd1c1c8e76383cd3f6.png"></figure>
-<figure><figcaption><div class="caption">Fig. 2: Block Diagram of a CDNA3 Compute Unit.</div> <div data-annotation-kind="description">The image depicts a horizontal bar chart titled &quot;Local Data Share.&quot; The chart is divided into two main sections: the left section and the right section.
-
-### Left Section:
-- **Title:** &quot;Local Data Share&quot;
-- **X-axis:** Labeled &quot;Schedule&quot;
-- **Y-axis:** Labeled &quot;Matrix Core Unit&quot;
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
--</div></figcaption><img src="hip_spec-with-image-refs_artifacts/image_000001_bfcf0651eef1f236f619420b33a1d732aeb71e35bd879a965fdc6375d5204886.png"></figure>
-<h2>4.2 Heterogeneous Programming</h2>
-<p>The HIP programming model assumes two execution contexts. One is referred to as host while compute kernels execute on a device . These contexts have different capabilities, therefor slightly different rules apply. The host execution is defined by the C++ abstract machine, while device execution follows the SIMT model of HIP. These execution contexts in code are signified by the __host__ and __device__ decorators. There are a few key differences between the two:</p>
-<ul>
-<li style="list-style-type: '· ';">The C++ abstract machine assumes a unified memory address space, meaning that one can always access any given address in memory (assuming the absence of data races). HIP however introduces several memory namespaces, an address from one means nothing in another. Moreover, not all address spaces are accessible from all contexts.</li>
-<li>Looking at Block Diagram of an RDNA3 Compute Unit. and Block Diagram of a CDNA3 Compute Unit. , you can see that every CU has an instance of storage backing the namespace __shared__ . Even if the host were to have access to these regions of memory, the performance benefits of the segmented memory subsystem are supported by the inability of asynchronous access from the host.</li>
-<li style="list-style-type: '· ';">Not all C++ language features map cleanly to typical device architectures, some are very expensive (meaning slow) to implement on GPU devices, therefor they are forbidden in device contexts to avoid users tapping into features that unexpectedly decimate their program's performance. Offload devices targeted by HIP aren't general purpose devices, at least not in the sense that a CPU is. HIP focuses on data parallel computations and as such caters to throughput optimized architectures, such as GPUs or accelerators derived from GPU architectures.</li>
-<li style="list-style-type: '· ';">Asynchrony is at the forefront of the HIP API. Computations launched on the device execute asynchronously with respect to the host, and it is the user's responsibility to synchronize their data dispatch/fetch with computations on the device.</li>
-</ul>
-<p>Note: HIP does perform implicit synchronization on occasions, more advanced than other APIs such as OpenCL or SYCL, in which the responsibility of synchronization mostly depends on the user.</p>
-<h2>4.3 Single instruction multiple threads (SIMT)</h2>
-<p>The SIMT programming model behind the HIP device-side execution is a middle-ground between SMT (Simultaneous Multi-Threading) programming known from multicore CPUs, and SIMD (Single Instruction, Multiple Data) programming mostly known from exploiting relevant instruction sets on CPUs (for example SSE/AVX/Neon).</p>
-<p>A HIP device compiler maps SIMT code written in HIP C++ to an inherently SIMD architecture (like GPUs). This is done by scalarizing the entire kernel and issuing the scalar instructions of multiple kernel instances (called threads) to each of the SIMD engine lanes, rather than exploiting data parallelism within a single instance of a kernel and spreading identical instructions over the available SIMD engines.</p>
-<p>Consider the following kernel:</p>
-<pre><code>__global__ void k(float4* a, const float4* b)
-{
-  int tid = threadIdx.x;
-  int bid = blockIdx.x;
-  int dim = blockDim.x;
-
-  a[tid] += (tid + bid - dim) * b[tid];
-}</code></pre>
-<p>The incoming four-vector of floating-point values b is multiplied by a scalar and then added element-wise to the fourvector floating-point values of a . On modern SIMD-capable architectures, the four-vector ops are expected to compile to a single SIMD instruction. However, GPU execution of this kernel will typically break down the vector elements into 4 separate threads for parallel execution, as seen in the following figure:</p>
-<p>Fig. 3: Instruction flow of the sample SIMT program.</p>
-<p>In HIP, lanes of the SIMD architecture are fed by mapping threads of a SIMT execution, one thread down each lane of an SIMD engine. Execution parallelism usually isn't exploited from the width of the built-in vector types, but across multiple threads via the thread ID constants threadIdx.x , blockIdx.x , etc.</p>
-<h2>4.4 Inherent thread model</h2>
-<p>The SIMT nature of HIP is captured by the ability to execute user-provided device programs, expressed as single-source C/C++ functions or sources compiled online/offline to binaries, in bulk.</p>
-<p>All threads of a kernel are uniquely identified by a set of integral values, called thread IDs. The set of integers identifying a thread relate to the hierarchy in which the threads execute.</p>
-<p>The thread hierarchy inherent to how AMD GPUs operate is depicted in the following figure.</p>
-<p>Fig. 4: Hierarchy of thread groups.</p>
-<h2>Warp (or Wavefront)</h2>
-<p>The innermost grouping of threads is called a warp, or a wavefront in ISA terms. A warp is the most tightly coupled groups of threads, both physically and logically. Threads inside a warp are also called lanes, and the integral value identifying them is the lane ID.</p>
-<p>Tip: Lane IDs aren't queried like other thread IDs, but are user-calculated. As a consequence, they are only as multidimensional as the user interprets the calculated values to be.</p>
-<p>The size of a warp is architecture dependent and always fixed. For AMD GPUs the wavefront is typically 64 threads, though sometimes 32 threads. Warps are signified by the set of communication primitives at their disposal, as discussed in Warp cross-lane functions .</p>
-<p>The middle grouping is called a block or thread block. The defining feature of a block is that all threads in a block will share an instance of memory which they may use to share data or synchronize with one another.</p>
-<p>The size of a block is user-configurable but is limited by the queryable capabilities of the executing hardware. The unique ID of the thread within a block is 3-dimensional as provided by the API. When linearizing thread IDs within a block, assume the 'fast index' being dimension x , followed by the y and z dimensions.</p>
-<h2>Block</h2>
-<h2>Grid</h2>
-<p>The outermost grouping is called a grid. A grid manifests as a single dispatch of kernels for execution. The unique ID of each block within a grid is 3-dimensional, as provided by the API and is queryable by every thread within the block.</p>
-<h2>4.4.1 Cooperative groups thread model</h2>
-<p>The Cooperative groups API introduces new APIs to launch, group, subdivide, synchronize and identify threads, as well as some predefined group-collective algorithms, but most importantly a matching threading model to think in terms of. It relaxes some restrictions of the Inherent thread model imposed by the strict 1:1 mapping of architectural details to the programming model. Cooperative groups let you define your own set of thread groups which may fit your user-cases better than the defaults defined by the hardware.</p>
-<p>Note: The implicit groups defined by kernel launch parameters are still available when working with cooperative groups.</p>
-<p>For further information, see Cooperative groups.</p>
-<h2>4.5 Memory model</h2>
-<p>The hierarchy of threads introduced by the Inherent thread model is induced by the memory subsystem of GPUs. The following figure summarizes the memory namespaces and how they relate to the various levels of the threading model.</p>
-<p>Fig. 5: Memory hierarchy.</p>
-<h2>Local or per-thread memory</h2>
-<p>Read-write storage only visible to the threads defining the given variables, also called per-thread memory. The size of a block for a given kernel, and thereby the number of concurrent warps, are limited by local memory usage. This relates to an important aspect: occupancy. This is the default memory namespace.</p>
-<h2>Shared memory</h2>
-<p>Read-write storage visible to all the threads in a given block.</p>
-<h2>Global</h2>
-<p>Read-write storage visible to all threads in a given grid. There are specialized versions of global memory with different usage semantics which are typically backed by the same hardware storing global.</p>
-<h2>Constant</h2>
-<p>Read-only storage visible to all threads in a given grid. It is a limited segment of global with queryable size.</p>
-<h2>Texture</h2>
-<p>Read-only storage visible to all threads in a given grid and accessible through additional APIs.</p>
-<h2>Surface</h2>
-<p>A read-write version of texture memory.</p>
-<h2>4.6 Execution model</h2>
-<p>HIP programs consist of two distinct scopes:</p>
-<ul>
-<li style="list-style-type: '· ';">The host-side API running on the host processor. There are two APIs available:</li>
-<li>-The HIP runtime API which enables use of the single-source programming model.</li>
-<li>-The HIP driver API which sits at a lower level and most importantly differs by removing some facilities provided by the runtime API, most importantly around kernel launching and argument setting. It is geared towards implementing abstractions atop, such as the runtime API itself. Offers two additional pieces of functionality not provided by the Runtime API: hipModule and hipCtx APIs. For further details, check HIP driver API.</li>
-<li style="list-style-type: '· ';">The device-side kernels running on GPUs. Both the host and the device-side APIs have synchronous and asynchronous functions in them.</li>
-</ul>
-<p>Note: The HIP does not present two separate APIs link NVIDIA CUDA. HIP only extends the HIP runtime API with new APIs for hipModule and hipCtx .</p>
-<h2>4.6.1 Host-side execution</h2>
-<p>The part of the host-side API which deals with device management and their queries are synchronous. All asynchronous APIs, such as kernel execution, data movement and potentially data allocation/freeing all happen in the context of device streams.</p>
-<p>Streams are FIFO buffers of commands to execute relating to a given device. Commands which enqueue tasks on a stream all return promptly and the command is executed asynchronously. All side effects of a command on a stream are visible to all subsequent commands on the same stream. Multiple streams may point to the same device and those streams may be fed from multiple concurrent host-side threads. Execution on multiple streams may be concurrent but isn't required to be.</p>
-<p>Asynchronous APIs involving a stream all return a stream event which may be used to synchronize the execution of multiple streams. A user may enqueue a barrier onto a stream referencing an event. The barrier will block until the command related to the event does not complete, at which point all side effects of the command shall be visible to commands following the barrier, even if those side effects manifest on different devices.</p>
-<p>Streams also support executing user-defined functions as callbacks on the host. The stream will not launch subsequent commands until the callback completes.</p>
-<h2>4.6.2 Device-side execution</h2>
-<p>The SIMT programming model behind the HIP device-side execution is a middle-ground between SMT (Simultaneous Multi-Threading) programming known from multicore CPUs, and SIMD (Single Instruction, Multiple Data) programming mostly known from exploiting relevant instruction sets on CPUs (for example SSE/AVX/Neon).</p>
-<h2>4.6.3 Kernel launch</h2>
-<p>Kernels may be launched in multiple ways all with different syntaxes and intended use-cases.</p>
-<ul>
-<li style="list-style-type: '· ';">Using the triple-chevron &lt;&lt;&lt;...&gt;&gt;&gt; operator on a __global__ annotated function.</li>
-<li style="list-style-type: '· ';">Using hipLaunchKernelGGL() on a __global__ annotated function.</li>
-</ul>
-<p>Tip: This name by default is a macro expanding to triple-chevron. In cases where language syntax extensions are undesirable, or where launching templated and/or overloaded kernel functions define the HIP_TEMPLATE_KERNEL_LAUNCH preprocessor macro before including the HIP headers to turn it into a templated function.</p>
-<ul>
-<li style="list-style-type: '· ';">Using the launch APIs supporting the triple-chevron syntax directly.</li>
-</ul>
-<p>Caution: These APIs are intended to be used/generated by tools such as the HIP compiler itself and not intended towards end-user code. Should you be writing a tool having to launch device code using HIP, consider using these over the alternatives.</p>
-<h2>HARDWARE IMPLEMENTATION</h2>
-<p>This chapter describes the typical hardware implementation of GPUs supported by HIP, and how the Inherent thread model maps to the hardware.</p>
-<h2>5.1 Compute units</h2>
-<p>The basic building block of a GPU is a compute unit (CU), also known as streaming multiprocessor (SM) on NVIDIA GPUs. The thread blocks making up a grid are scheduled for execution on CUs. Each block is assigned to an individual CU, and a CU can accommodate several blocks. Depending on their resource usage up to thousands of threads can reside on a CU.</p>
-<p>CUs contain an array of processing elements, referred to as vector ALU (VALU), that execute the actual instructions of the threads according to the SIMT model , together with the necessary registers and caches.</p>
-<p>The threads are executed in groupings called warps. The amount of threads making up a warp is architecture dependent. On AMD GPUs the warp size is commonly 64 threads, except in RDNA architectures which can utilize a warp size of 32 or 64 respectively. The warp size of supported AMD GPUs is listed in the Accelerator and GPU hardware specifications. NVIDIA GPUs have a warp size of 32.</p>
-<p>In contrast to CPUs, GPUs generally do not employ complex cache structures or control logic, like branch prediction or out-of-order execution, but instead rely on massive hardware multithreading to hide latency.</p>
-<p>Context switching between warps residing on a CU incurs no overhead, as the context for the warps is stored on the CU and does not need to be fetched from memory. If there are not enough free registers to accommodate all warps of a block, the block can not be scheduled to that CU and it has to wait until other blocks finish execution.</p>
-<p>The amount of warps that can reside concurrently on a CU, known as occupancy, is determined by the warp's resource usage of registers and shared memory.</p>
-<p>Fig. 1: An AMD Graphics Core Next (GCN) CU. The CDNA and RDNA CUs are based on variations of the GCN CU.</p>
-<p>On AMD GCN GPUs the basic structure of a CU is:</p>
-<ul>
-<li style="list-style-type: '· ';">four Single Instruction Multiple Data units (SIMDs)</li>
-<li style="list-style-type: '· ';">a vector cache</li>
-<li style="list-style-type: '· ';">a local data share</li>
-<li style="list-style-type: '· ';">and a scalar unit</li>
-</ul>
-<h2>5.1.1 SIMD</h2>
-<p>A SIMD consists of a VALU, that executes the instruction of a warp, together with a register file, that provides the registers warps.</p>
-<p>The size of the warp is inherently related to the width of the vector ALU of the SIMD. On GCN compute units the width of the VALU is 16, so a warp can be issued to a SIMD every 4 cycles. Since a CU has 4 SIMDs it issues one warp per cycle. The instructions of a warp are effectively executed in lock-step.</p>
-<p>A SIMD always executes the same instruction for the whole VALU. If the control flow of a warp diverges, the performance is decreased, as the results for the threads that do not participate in that branch have to be masked out, and the instructions of the other branch have to be executed in the same way. The best performance can therefore be achieved when thread divergence is kept to a warp level, i.e. when all threads in a warp take the same execution path.</p>
-<h2>5.1.2 Vector cache</h2>
-<p>The usage of cache on a GPU differs from that on a CPU, as there is less cache available per thread. Its main purpose is to coalesce memory accesses of the warps in order to reduce the amount of accesses to device memory, and make that memory available for other warps that currently reside on the compute unit, that also need to load those values.</p>
-<h2>5.1.3 Local data share</h2>
-<p>The local data share is memory that is accessible to all threads within a block. Its latency and bandwidth is comparable to that of the vector cache. It can be used to share memory between the threads in a block, or as a software managed cache.</p>
-<h2>5.1.4 Scalar Unit</h2>
-<p>The scalar unit performs instructions that are uniform within a warp. It thereby improves efficiency and reduces the pressure on the vector ALUs and the vector register file.</p>
-<h2>5.2 CDNA architecture</h2>
-<p>The general structure of CUs stays mostly as it is in GCN architectures. The most prominent change is the addition of matrix ALUs, which can greatly improve the performance of algorithms involving matrix multiply-accumulate operations for int8, float16, bfloat16 or float32.</p>
-<figure><figcaption><div class="caption">Fig. 2: Block Diagram of a CDNA3 Compute Unit.</div> <div data-annotation-kind="description">The image depicts a horizontal bar chart titled &quot;Local Data Share.&quot; The chart is divided into two main sections: the left section and the right section.
-
-### Left Section:
-- **Title:** Local Data Share
-- **X-Axis:** Labeled as &quot;Scheduler&quot; and &quot;Matrix Core Unit&quot;
-- **Y-Axis:** Labeled as &quot;Local Data Share&quot;
-- **Data Points:**
-  - **Leftmost Data Point:** 100
-  - **Rightmost Data Point:** 100
-  - **Leftmost Data Point:** 100
-  - **Rightmost Data Point:** 100
-
-### Right Section:
-- **Title:** Shader Core
-- **X-Axis:** Labeled as &quot;L1 Cache&quot;
-- **Y-Axis:** Labeled as &quot;Shader Core&quot;
-- **Data Points:**
-  - **Leftmost Data Point:** 100
-  - **Rightmost</div></figcaption><img src="hip_spec-with-image-refs_artifacts/image_000002_cfbddcc77ec59fe03ed26460c2aa6a54c9646387476d59ddc5eaabf5c6641187.png"></figure>
-<h2>5.3 RDNA architecture</h2>
-<p>RDNA makes a fundamental change to CU design, by changing the size of a warp to 32 threads. This is done by effectively combining two GCN5 SIMDs, creating a VALU of width 32, so that a whole warp can be issued in one cycle. The CU is also replaced by the work group processor (WGP), which encompasses two CUs. For backwards compatibility the WGP can also run in wave64 mode, in which it issues a warp of size 64 in two cycles.</p>
-<p>It also adds an extra layer of cache to the WGP, shared by the CUs within it. This cache is referred to as L1 cache, promoting the per-CU cache to an L0 cache.</p>
-<figure><figcaption><div class="caption">Fig. 3: Block Diagram of an RDNA3 work group processor.</div> <div data-annotation-kind="description">Scheduler Vector GPR.</div></figcaption><img src="hip_spec-with-image-refs_artifacts/image_000003_8ba501e7c1e4fd45f649ac07d48e9985a382fa290507dbd9ebd5ecafa7f23bd2.png"></figure>
-<h2>5.4 Shader engines</h2>
-<p>For hardware implementation's sake, multiple CUs are grouped together into a Shader Engine or Compute Engine, typically sharing some fixed function units or memory subsystem resources.</p>
-<figure><figcaption><div class="caption">Fig. 4: Block Diagram of a CDNA2 Graphics Compute Die.</div> <div data-annotation-kind="description">The image is a table that contains data about different types of fabric. The table is divided into rows and columns, with each row representing a different type of fabric. The columns are labeled as follows:
-
-- Memory
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller</div></figcaption><img src="hip_spec-with-image-refs_artifacts/image_000004_b494ff70840b694ceb0cb8c49613faf77041d4148e4ceb04903608a8022e3cbd.png"></figure>
-<h2>CHAPTER</h2>
-<h2>SIX</h2>
-<h2>AMD COMMON LANGUAGE RUNTIMES (CLR)</h2>
-<p>CLRcontains source codes for AMD's compute languages runtimes: HIP and OpenCL ™ . CLR is the part of HIP runtime which is supported on the AMD ROCm platform, it provides a header and runtime library built on top of HIP-Clang compiler. For developers and users, CLR implements HIP runtime APIs including streams, events, and memory APIs, which is a object library that is linked with the application. The source codes for all headers and the library implementation are available on GitHub in the CLR repository.</p>
-<h2>6.1 Project organization</h2>
-<p>CLR includes the following source code,</p>
-<ul>
-<li style="list-style-type: '· ';">hipamd - contains implementation of HIP language on the AMD platform. It is hosted at clr/hipamd.</li>
-<li style="list-style-type: '· ';">opencl - contains implementation of OpenCL™ on AMD platform. It is hosted at clr/opencl.</li>
-<li style="list-style-type: '· ';">rocclr - contains common runtime used in HIP and OpenCL™ . This is hosted at clr/rocclr.</li>
-</ul>
-<h2>6.2 How to build/install</h2>
-<h2>6.2.1 Prerequisites</h2>
-<p>Please refer to Quick Start Guide in ROCm Docs.</p>
-<p>Building CLR requires rocm-hip-libraries meta package, which provides the pre-requisites for CLR.</p>
-<h2>6.2.2 Linux</h2>
-<ul>
-<li style="list-style-type: '· ';">Clone this repository</li>
-<li style="list-style-type: '· ';">For OpenCL ™</li>
-</ul>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        * For HIP</code></pre>
-<pre><code><_Bash_></code></pre>
-<pre><code><_Haskell_></code></pre>
-<p>Users can also build OCL and HIP at the same time by passing -DCLR_BUILD_HIP=ON -DCLR_BUILD_OCL=ON to configure command.</p>
-<p>For detail instructions, please refer to build HIP.</p>
-<h2>6.2.3 Test</h2>
-<p>hip-tests is a separate repository hosted at hip-tests.</p>
-<p>To run hip-tests please go to the repository and follow the steps.</p>
-<h2>6.2.4 Release notes</h2>
-<p>HIP provides release notes in CLR change log, which has records of changes in each release.</p>
-<h2>7.1 Host Memory</h2>
-<h2>7.1.1 Introduction</h2>
-<p>hipHostMalloc allocates pinned host memory which is mapped into the address space of all GPUs in the system, the memory can be accessed directly by the GPU device, and can be read or written with much higher bandwidth than pageable memory obtained with functions such as malloc() . There are two use cases for this host memory:</p>
-<ul>
-<li style="list-style-type: '· ';">Faster HostToDevice and DeviceToHost Data Transfers: The runtime tracks the hipHostMalloc allocations and can avoid some of the setup required for regular unpinned memory. For exact measurements on a specific system, experiment with --unpinned and --pinned switches for the hipBusBandwidth tool.</li>
-<li style="list-style-type: '· ';">Zero-Copy GPU Access: GPU can directly access the host memory over the CPU/GPU interconnect, without need to copy the data. This avoids the need for the copy, but during the kernel access each memory access must traverse the interconnect, which can be tens of times slower than accessing the GPU's local device memory. Zerocopy memory can be a good choice when the memory accesses are infrequent (perhaps only once). Zero-copy memory is typically 'Coherent' and thus not cached by the GPU but this can be overridden if desired.</li>
-</ul>
-<h2>7.1.2 Memory allocation flags</h2>
-<p>There are flags parameter which can specify options how to allocate the memory, for example, hipHostMallocPortable , the memory is considered allocated by all contexts, not just the one on which the allocation is made. hipHostMallocMapped , will map the allocation into the address space for the current device, and the device pointer can be obtained with the API hipHostGetDevicePointer() . hipHostMallocNumaUser is the flag to allow host memory allocation to follow Numa policy by user. Please note this flag is currently only applicable on Linux, under development on Windows.</p>
-<p>All allocation flags are independent, and can be used in any combination without restriction, for instance, hipHostMalloc can be called with both hipHostMallocPortable and hipHostMallocMapped flags set. Both usage models described above use the same allocation flags, and the difference is in how the surrounding code uses the host memory.</p>
-<h2>HIP PROGRAMMING MANUAL</h2>
-<h2>7.1.3 Numa-aware host memory allocation</h2>
-<p>Numa policy determines how memory is allocated. Target of Numa policy is to select a CPU that is closest to each GPU. Numa distance is the measurement of how far between GPU and CPU devices.</p>
-<p>By default, each GPU selects a Numa CPU node that has the least Numa distance between them, that is, host memory will be automatically allocated closest on the memory pool of Numa node of the current GPU device. Using hipSetDevice API to a different GPU will still be able to access the host allocation, but can have longer Numa distance. Note, Numa policy is so far implemented on Linux, and under development on Windows.</p>
-<h2>7.1.4 Coherency Controls</h2>
-<p>ROCm defines two coherency options for host memory:</p>
-<ul>
-<li style="list-style-type: '· ';">Coherent memory : Supports fine-grain synchronization while the kernel is running. For example, a kernel can perform atomic operations that are visible to the host CPU or to other (peer) GPUs. Synchronization instructions include threadfence_system and C++11-style atomic operations. In order to achieve this fine-grained coherence, many AMD GPUs use a limited cache policy, such as leaving these allocations uncached by the GPU, or making them read-only.</li>
-<li style="list-style-type: '· ';">Non-coherent memory : Can be cached by GPU, but cannot support synchronization while the kernel is running. Non-coherent memory can be optionally synchronized only at command (end-of-kernel or copy command) boundaries. This memory is appropriate for high-performance access when fine-grain synchronization is not required.</li>
-</ul>
-<p>HIP provides the developer with controls to select which type of memory is used via allocation flags passed to hipHostMalloc and the HIP_HOST_COHERENT environment variable. By default, the environment variable HIP_HOST_COHERENT is set to 0 in HIP. The control logic in the current version of HIP is as follows:</p>
-<ul>
-<li style="list-style-type: '· ';">No flags are passed in: the host memory allocation is coherent, the HIP_HOST_COHERENT environment variable is ignored.</li>
-<li style="list-style-type: '· ';">hipHostMallocCoherent=1 : The host memory allocation will be coherent, the HIP_HOST_COHERENT environment variable is ignored.</li>
-<li style="list-style-type: '· ';">hipHostMallocMapped=1 : The host memory allocation will be coherent, the HIP_HOST_COHERENT environment variable is ignored.</li>
-<li style="list-style-type: '· ';">hipHostMallocNonCoherent=1 , hipHostMallocCoherent=0 , and hipHostMallocMapped=0 : The host memory will be non-coherent, the HIP_HOST_COHERENT environment variable is ignored.</li>
-<li style="list-style-type: '· ';">hipHostMallocCoherent=0 , hipHostMallocNonCoherent=0 , hipHostMallocMapped=0 , but one of the other HostMalloc flags is set:</li>
-<li>-If HIP_HOST_COHERENT is defined as 1, the host memory allocation is coherent.</li>
-<li>-If HIP_HOST_COHERENT is not defined, or defined as 0, the host memory allocation is non-coherent.</li>
-<li style="list-style-type: '· ';">hipHostMallocCoherent=1 , hipHostMallocNonCoherent=1 : Illegal.</li>
-</ul>
-<h2>7.1.5 Visibility of Zero-Copy Host Memory</h2>
-<p>Coherent host memory is automatically visible at synchronization points. Non-coherent</p>
-<table><tbody><tr><th>HIP API Synchronization Effect</th><th>Fence</th><th>Coherent Memory ity</th><th>Host Visibil-</th><th>Non-Coherent Host Memory Visi- bility</th></tr><tr><td>hipStreamSynchronize host waits for all commands in the spec- ified stream to complete</td><td>system- scope release</td><td>yes</td><td></td><td>yes</td></tr><tr><td>hipDeviceSynchronize host waits for all commands in all streams on the specified device to com- plete</td><td>system- scope release</td><td>yes</td><td></td><td>yes</td></tr><tr><td>hipEventSynchronize host waits for the specified event to com- plete</td><td>device- scope release</td><td>yes</td><td></td><td>depends - see below</td></tr><tr><td>hipStreamWaitEvent stream waits for the specified event to complete</td><td>none</td><td>yes</td><td></td><td>no</td></tr></tbody></table>
-<h2>7.1.6 hipEventSynchronize</h2>
-<p>Developers can control the release scope for hipEvents :</p>
-<ul>
-<li style="list-style-type: '· ';">By default, the GPU performs a device-scope acquire and release operation with each recorded event. This will make host and device memory visible to other commands executing on the same device.</li>
-</ul>
-<p>A stronger system-level fence can be specified when the event is created with hipEventCreateWithFlags :</p>
-<ul>
-<li style="list-style-type: '· ';">hipEventReleaseToSystem : Perform a system-scope release operation when the event is recorded. This will make both Coherent and Non-Coherent host memory visible to other agents in the system, but may involve heavyweight operations such as cache flushing. Coherent memory will typically use lighter-weight in-kernel synchronization mechanisms such as an atomic operation and thus does not need to use hipEventReleaseToSystem .</li>
-<li style="list-style-type: '· ';">hipEventDisableTiming : Events created with this flag will not record profiling data and provide the best performance if used for synchronization.</li>
-</ul>
-<h2>7.1.7 Summary and Recommendations</h2>
-<ul>
-<li style="list-style-type: '· ';">Coherent host memory is the default and is the easiest to use since the memory is visible to the CPU at typical synchronization points. This memory allows in-kernel synchronization commands such as threadfence_system to work transparently.</li>
-<li style="list-style-type: '· ';">HIP/ROCm also supports the ability to cache host memory in the GPU using the 'Non-Coherent' host memory allocations. This can provide performance benefit, but care must be taken to use the correct synchronization.</li>
-</ul>
-<h2>7.1.8 Managed memory allocation</h2>
-<p>Managed memory, including the __managed__ keyword, is supported in HIP combined host/device compilation, on Linux, not on Windows (under development).</p>
-<p>Managed memory, via unified memory allocation, allows data be shared and accessible to both the CPU and GPU using a single pointer. The allocation will be managed by AMD GPU driver using the Linux HMM (Heterogeneous Memory Management) mechanism, the user can call managed memory API hipMallocManaged to allocate a large chunk of HMMmemory, execute kernels on device and fetch data between the host and device as needed.</p>
-<p>In HIP application, it is recommended to do the capability check before calling the managed memory APIs. For example:</p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?>                                                                                                                                                                                                        </?></code></pre>
-<p>Please note, the managed memory capability check may not be necessary, but if HMM is not supported, then managed malloc will fall back to using system memory and other managed memory API calls will have undefined behavior.</p>
-<p>Note, managed memory management is implemented on Linux, not supported on Windows yet.</p>
-<h2>7.1.9 HIP Stream Memory Operations</h2>
-<p>HIP supports Stream Memory Operations to enable direct synchronization between Network Nodes and GPU. Following new APIs are added, hipStreamWaitValue32 hipStreamWaitValue64 hipStreamWriteValue32 hipStreamWriteValue64</p>
-<p>Note, CPU access to the semaphore's memory requires volatile keyword to disable CPU compiler's optimizations on memory access. For more details, please check the documentation HIP-API.pdf .</p>
-<p>Please note, HIP stream does not guarantee concurrency on AMD hardware for the case of multiple (at least 6) longrunning streams executing concurrently, using hipStreamSynchronize(nullptr) for synchronization.</p>
-<h2>7.2 Direct Dispatch</h2>
-<p>HIP runtime has Direct Dispatch enabled by default in ROCM 4.4 on Linux. With this feature we move away from our conventional producer-consumer model where the runtime creates a worker thread(consumer) for each HIP Stream, and the host thread(producer) enqueues commands to a command queue(per stream).</p>
-<p>For Direct Dispatch, HIP runtime would directly enqueue a packet to the AQL queue (user mode queue on GPU) on the Dispatch API call from the application. That has shown to reduce the latency to launch the first wave on the idle GPU and total time of tiny dispatches synchronized with the host.</p>
-<p>In addition, eliminating the threads in runtime has reduced the variance in the dispatch numbers as the thread scheduling delays and atomics/locks synchronization latencies are reduced.</p>
-<p>This feature can be disabled via setting the following environment variable, AMD_DIRECT_DISPATCH=0</p>
-<p>Note, Direct Dispatch is implemented on Linux. It is currently not supported on Windows.</p>
-<h2>7.3 HIP Runtime Compilation</h2>
-<p>HIP now supports runtime compilation (HIP RTC), the usage of which will provide the possibility of optimizations and performance improvement compared with other APIs via regular offline static compilation.</p>
-<p>HIP RTC APIs accept HIP source files in character string format as input parameters and create handles of programs by compiling the HIP source files without spawning separate processes.</p>
-<p>For more details on HIP RTC APIs, refer to HIP Runtime API Reference .</p>
-<p>For Linux developers, the link here shows an example how to program HIP application using runtime compilation mechanism, and a detailed HIP RTC programming guide is also available.</p>
-<h2>7.4 HIP Graph</h2>
-<p>HIP graph is supported. For more details, refer to the HIP API Guide.</p>
-<h2>7.5 Device-Side Malloc</h2>
-<p>HIP-Clang now supports device-side malloc and free. This implementation does not require the use of hipDeviceSetLimit(hipLimitMallocHeapSize,value) nor respects any setting. The heap is fully dynamic and can grow until the available free memory on the device is consumed.</p>
-<h2>7.6 Use of Per-thread default stream</h2>
-<p>The per-thread default stream is supported in HIP. It is an implicit stream local to both the thread and the current device. This means that the command issued to the per-thread default stream by the thread does not implicitly synchronize with other streams (like explicitly created streams), or default per-thread stream on other threads. The per-thread default stream is a blocking stream and will synchronize with the default null stream if both are used in a program. The per-thread default stream can be enabled via adding a compilation option, -fgpu-default-stream=per-thread .</p>
-<p>And users can explicitly use hipStreamPerThread as per-thread default stream handle as input in API commands. There are test codes as examples in the link.</p>
-<h2>7.7 Use of Long Double Type</h2>
-<p>In HIP-Clang, long double type is 80-bit extended precision format for x86_64, which is not supported by AMDGPU. HIP-Clang treats long double type as IEEE double type for AMDGPU. Using long double type in HIP source code will not cause issue as long as data of long double type is not transferred between host and device. However, long double type should not be used as kernel argument type.</p>
-<h2>7.8 Use of _Float16 Type</h2>
-<p>If a host function is to be used between clang (or hipcc) and gcc for x86_64, i.e. its definition is compiled by one compiler but the caller is compiled by a different compiler, _Float16 or aggregates containing _Float16 should not be used as function argument or return type. This is due to lack of stable ABI for _Float16 on x86_64. Passing _Float16 or aggregates containing _Float16 between clang and gcc could cause undefined behavior.</p>
-<h2>7.9 FMA and contractions</h2>
-<p>By default HIP-Clang assumes -ffp-contract=fast-honor-pragmas . Users can use #pragma clang fp contract(on|off|fast) to control fp contraction of a block of code. For x86_64, FMA is off by default since the generic x86_64 target does not support FMA by default. To turn on FMA on x86_64, either use -mfma or -march=native on CPU's supporting FMA.</p>
-<p>When contractions are enabled and the CPU has not enabled FMA instructions, the GPU can produce different numerical results than the CPU for expressions that can be contracted. Tolerance should be used for floating point comparisons.</p>
-<h2>7.10 Math functions with special rounding modes</h2>
-<p>Note: Currently, HIP only supports basic math functions with rounding modern (round to nearest). HIP does not support basic math functions with rounding modes ru (round up), rd (round down), and rz (round towards zero).</p>
-<h2>7.11 Creating Static Libraries</h2>
-<p>HIP-Clang supports generating two types of static libraries. The first type of static library does not export device functions, and only exports and launches host functions within the same library. The advantage of this type is the ability to link with a non-hipcc compiler such as gcc. The second type exports device functions to be linked by other code objects. However, this requires using hipcc as the linker.</p>
-<p>In addition, the first type of library contains host objects with device code embedded as fat binaries. It is generated using the flag -emit-static-lib. The second type of library contains relocatable device objects and is generated using ar .</p>
-<p>Here is an example to create and use static libraries:</p>
-<ul>
-<li style="list-style-type: '· ';">Type 1 using --emit-static-lib :</li>
-<li style="list-style-type: '· ';">Type 2 using system ar :</li>
-</ul>
-<pre><code><_Bash_></code></pre>
-<pre><code>hipcc hipDevice.cpp -c -fgpu-rdc -o hipDevice.o
-ar rcsD libHipDevice.a hipDevice.o
-hipcc libHipDevice.a test.cpp -fgpu-rdc -o test.out</code></pre>
-<p>For more information, please see HIP samples host functions and device_functions.</p>
-<p>CHAPTER</p>
-<h2>EIGHT</h2>
-<h2>HIP PORTING GUIDE</h2>
-<p>In addition to providing a portable C++ programming environment for GPUs, HIP is designed to ease the porting of existing CUDA code into the HIP environment. This section describes the available tools and provides practical suggestions on how to port CUDA code and work through common issues.</p>
-<h2>8.1 Porting a New CUDA Project</h2>
-<h2>8.1.1 General Tips</h2>
-<ul>
-<li style="list-style-type: '· ';">Starting the port on a CUDA machine is often the easiest approach, since you can incrementally port pieces of the code to HIP while leaving the rest in CUDA. (Recall that on CUDA machines HIP is just a thin layer over CUDA, so the two code types can interoperate on NVCC platforms.) Also, the HIP port can be compared with the original CUDA code for function and performance.</li>
-<li style="list-style-type: '· ';">Once the CUDA code is ported to HIP and is running on the CUDA machine, compile the HIP code using the HIP compiler on an AMD machine.</li>
-<li style="list-style-type: '· ';">HIP ports can replace CUDA versions: HIP can deliver the same performance as a native CUDA implementation, with the benefit of portability to both NVIDIA and AMD architectures as well as a path to future C++ standard support. You can handle platform-specific features through conditional compilation or by adding them to the open-source HIP infrastructure.</li>
-<li style="list-style-type: '· ';">Use hipconvertinplace-perl.sh to hipify all code files in the CUDA source directory.</li>
-</ul>
-<h2>8.1.2 Scanning existing CUDA code to scope the porting effort</h2>
-<p>The hipexamine-perl.sh tool will scan a source directory to determine which files contain CUDA code and how much of that code can be automatically hipified.</p>
-<pre><code><_Cuda_></code></pre>
-<p>(continued from previous page)</p>
-<pre><code>                                                                                                                                                                                                        (continued from previous page)</code></pre>
-<p>hipexamine-perl scans each code file (cpp, c, h, hpp, etc.) found in the specified directory:</p>
-<ul>
-<li style="list-style-type: '· ';">Files with no CUDA code ( kmeans.h ) print one line summary just listing the source file name.</li>
-<li style="list-style-type: '· ';">Files with CUDA code print a summary of what was found - for example the kmeans_cuda_kernel.cu file:</li>
-<li style="list-style-type: '· ';">Interesting information in kmeans_cuda_kernel.cu :</li>
-<li>-How many CUDA calls were converted to HIP (40)</li>
-<li>-Breakdown of the CUDA functionality used ( dev:0 mem:0 etc). This file uses many CUDA builtins (37) and texture functions (3).</li>
-<li>-Warning for code that looks like CUDA API but was not converted (0 in this file).</li>
-<li>-Count Lines-of-Code (LOC) - 185 for this file.</li>
-<li style="list-style-type: '· ';">hipexamine-perl also presents a summary at the end of the process for the statistics collected across all files. This has similar format to the per-file reporting, and also includes a list of all kernels which have been called. An example from above:</li>
-</ul>
-<pre><code><_SQL_></code></pre>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        --event:0                                                                                                                                                                                                        -event:0</code></pre>
-<h2>8.1.3 Converting a project 'in-place'</h2>
-<pre><code>></code></pre>
-<pre><code>| > hipify-perl --inplace</code></pre>
-<p>For each input file FILE, this script will:</p>
-<ul>
-<li style="list-style-type: '· ';">If FILE.prehip file does not exist, copy the original code to a new file with extension .prehip . Then hipify the code file.</li>
-<li style="list-style-type: '· ';">If FILE.prehip file exists, hipify FILE.prehip and save to FILE.</li>
-</ul>
-<p>This is useful for testing improvements to the hipify toolset.</p>
-<p>The hipconvertinplace-perl.sh script will perform inplace conversion for all code files in the specified directory. This can be quite handy when dealing with an existing CUDA code base since the script preserves the existing directory structure and filenames - and includes work. After converting in-place, you can review the code to add additional parameters to directory names.</p>
-<ul>
-<li>&gt; hipconvertinplace-perl.sh MY_SRC_DIR</li>
-</ul>
-<h2>8.1.4 Library Equivalents</h2>
-<p>Most CUDA libraries have a corresponding ROCm library with similar functionality and APIs. However, ROCm also provides HIP marshalling libraries that greatly simplify the porting process because they more precisely reflect their CUDAcounterparts and can be used with either the AMD or NVIDIA platforms (see 'Identifying HIP Target Platform' below). There are a few notable exceptions:</p>
-<ul>
-<li style="list-style-type: '· ';">MIOpen does not have a marshalling library interface to ease porting from cuDNN.</li>
-<li style="list-style-type: '· ';">RCCL is a drop-in replacement for NCCL and implements the NCCL APIs.</li>
-<li style="list-style-type: '· ';">hipBLASLt does not have a ROCm library but can still target the NVIDIA platform, as needed.</li>
-<li style="list-style-type: '· ';">EIGEN's HIP support is part of the library.</li>
-</ul>
-<table><tbody><tr><th>CUDA brary</th><th>Li-</th><th>HIP Li- brary</th><th>ROCm Li- brary</th><th>Comment</th></tr><tr><td>cuBLAS</td><td></td><td>hipBLAS</td><td>rocBLAS</td><td>Basic Linear Algebra Subroutines</td></tr><tr><td>cuBLASLt</td><td></td><td>hip- BLASLt</td><td>N/A</td><td>Basic Linear Algebra Subroutines, lightweight and new flexible API</td></tr><tr><td>cuFFT</td><td></td><td>hipFFT</td><td>rocFFT</td><td>Fast Fourier Transfer Library</td></tr><tr><td>cuSPARSE</td><td></td><td>hipSPARSE</td><td>rocSPARSE</td><td>Sparse BLAS + SPMV</td></tr><tr><td>cuSOLVER</td><td></td><td>hip- SOLVER</td><td>rocSOLVER</td><td>Lapack library</td></tr><tr><td>AmgX</td><td></td><td>N/A</td><td>rocALU- TION</td><td>Sparse iterative solvers and preconditioners with algebraic multigrid</td></tr><tr><td>Thrust</td><td></td><td>N/A</td><td>rocThrust</td><td>C++ parallel algorithms library</td></tr><tr><td>CUB</td><td></td><td>hipCUB</td><td>rocPRIM</td><td>Low Level Optimized Parallel Primitives</td></tr><tr><td>cuDNN</td><td></td><td>N/A</td><td>MIOpen</td><td>Deep learning Solver Library</td></tr><tr><td>cuRAND</td><td></td><td>hipRAND</td><td>rocRAND</td><td>Random Number Generator Library</td></tr><tr><td>EIGEN</td><td></td><td>EIGEN</td><td>N/A</td><td>C++ template library for linear algebra: matrices, vectors, numeri- cal solvers,</td></tr><tr><td>NCCL</td><td></td><td>N/A</td><td>RCCL</td><td>Communications Primitives Library based on the MPI equivalents</td></tr></tbody></table>
-<h2>8.2 Distinguishing Compiler Modes</h2>
-<h2>8.2.1 Identifying HIP Target Platform</h2>
-<p>All HIP projects target either AMD or NVIDIA platform. The platform affects which headers are included and which libraries are used for linking.</p>
-<ul>
-<li style="list-style-type: '· ';">HIP_PLATFORM_AMD is defined if the HIP platform targets AMD. Note, HIP_PLATFORM_HCC was previously defined if the HIP platform targeted AMD, it is deprecated.</li>
-<li style="list-style-type: '· ';">HIP_PLATFORM_NVDIA is defined if the HIP platform targets NVIDIA. Note, HIP_PLATFORM_NVCC was previously defined if the HIP platform targeted NVIDIA, it is deprecated.</li>
-</ul>
-<h2>8.2.2 Identifying the Compiler: hip-clang or NVCC</h2>
-<p>Often, it's useful to know whether the underlying compiler is HIP-Clang or NVCC. This knowledge can guard platformspecific code or aid in platform-specific performance tuning.</p>
-<pre><code>    #ifdef __HIP_PLATFORM_AMD__
-    // Compiled with HIP-Clang
-    #endif</code></pre>
-<pre><code>#ifdef __HIP_PLATFORM_NVIDIA__
-// Compiled with nvcc
-//  Could be compiling with CUDA language extensions enabled (for example, a ".cu file)
-//  Could be in pass-through mode to an underlying host compile OR (for example, a.cpp_
---file)</code></pre>
-<pre><code>        #ifdef __CUDACC__
-        // Compiled with nvcc (CUDA language extensions enabled)</code></pre>
-<pre><code>; enab1ed)</code></pre>
-<p>Compiler directly generates the host code (using the Clang x86 target) and passes the code to another host compiler. Thus, they have no equivalent of the __CUDACC__ define.</p>
-<h2>8.2.3 Identifying Current Compilation Pass: Host or Device</h2>
-<p>NVCCmakestwo passes over the code: one for host code and one for device code. HIP-Clang will have multiple passes over the code: one for the host code, and one for each architecture on the device code. __HIP_DEVICE_COMPILE__ is set to a nonzero value when the compiler (HIP-Clang or NVCC) is compiling code for a device inside a __global__ kernel or for a device function. __HIP_DEVICE_COMPILE__ can replace #ifdef checks on the __CUDA_ARCH__ define.</p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                        #if __HIP__DEVICE__COMPILE__</code></pre>
-<p>Unlike __CUDA_ARCH__ , the __HIP_DEVICE_COMPILE__ value is 1 or undefined, and it doesn't represent the feature capability of the target device.</p>
-<h2>8.2.4 Compiler Defines: Summary</h2>
-<table><tbody><tr><th>Define</th><th>HIP-Clang</th><th>NVCC</th><th>Other (GCC, ICC, Clang, etc.)</th></tr><tr><th>HIP-related defines:</th><td></td><td></td><td></td></tr><tr><td>__HIP_PLATFORM_AMD__</td><td>Defined</td><td>Undefined</td><td>Defined if targetingAMD platform; undefined oth- erwise</td></tr><tr><td>__HIP_PLATFORM_NVIDIA__</td><td>Undefined</td><td>Defined</td><td>Defined if targeting NVIDIA platform; unde- fined otherwise</td></tr><tr><td>__HIP_DEVICE_COMPILE__</td><td>1 if compiling for device; un- defined if compiling for host</td><td>1 if compiling for device; undefined if compiling for host</td><td>Undefined</td></tr><tr><td>__HIPCC__</td><td>Defined</td><td>Defined</td><td>Undefined</td></tr><tr><td>__HIP_ARCH_*</td><td>0 or 1 depending on feature support (see below)</td><td>0 or 1 depending on feature support (see below)</td><td>0</td></tr><tr><th>NVCC- related defines:</th><td></td><td></td><td></td></tr><tr><td>__CUDACC__</td><td>Defined if source code is compiled by NVCC; unde- fined otherwise</td><td>Undefined</td><td></td></tr><tr><td>__NVCC__ Undefined</td><td>Defined</td><td>Undefined</td><td></td></tr><tr><td>__CUDA_ARCH__</td><td>Undefined</td><td>Unsigned representing compute capa- bility (e.g., &#x27;130&#x27;) if in device code; 0 if in host code</td><td>Undefined</td></tr><tr><th>hip-clang- related defines:</th><td></td><td></td><td></td></tr><tr><td>__HIP__ HIP-Clang common</td><td>Defined</td><td>Undefined</td><td>Undefined</td></tr><tr><td>defines: __clang__</td><td>Defined</td><td>Defined</td><td>Undefined</td></tr></tbody></table>
-<h2>8.3 Identifying Architecture Features</h2>
-<h2>8.3.1 HIP_ARCH Defines</h2>
-<p>Some CUDA code tests __CUDA_ARCH__ for a specific value to determine whether the machine supports a certain architectural feature. For instance,</p>
-<pre><code>        | #if (__CUDA_ARCH__ >= 13 0)</code></pre>
-<pre><code>    |// doubles are supported</code></pre>
-<p>This type of code requires special attention, since AMD and CUDA devices have different architectural capabilities. Moreover, you can't determine the presence of a feature using a simple comparison against an architecture's version</p>
-<p>number. HIP provides a set of defines and device properties to query whether a specific architectural feature is supported.</p>
-<p>The __HIP_ARCH_* defines can replace comparisons of __CUDA_ARCH__ values:</p>
-<pre><code>//#if (__CUDA_ARCH__ >= 130)   // non-portable
-if __HIP_ARCH_HAS_DOUBLES__ {  // portable HIP feature query
-    // doubles are supported
-}</code></pre>
-<p>For host code, the __HIP_ARCH__* defines are set to 0. You should only use the __HIP_ARCH__ fields in device code.</p>
-<h2>8.3.2 Device-Architecture Properties</h2>
-<p>Host code should query the architecture feature flags in the device properties that hipGetDeviceProperties returns, rather than testing the 'major' and 'minor' fields directly:</p>
-<pre><code>hipGetDeviceProperties(&deviceProp, device);
-//if ((deviceProp.major == 1 && deviceProp.minor < 2))  // non-portable
-if (deviceProp.arch.hasSharedInt32Atomics) {            // portable HIP feature query
-    // has shared int32 atomic operations...
-}</code></pre>
-<h2>8.3.3 Table of Architecture Properties</h2>
-<p>The table below shows the full set of architectural properties that HIP supports.</p>
-<table><tbody><tr><th>Define (use only in device code)</th><th>Device Property (run- time query)</th><th>Comment</th></tr><tr><th>32-bit atomics:</th><td></td><td></td></tr><tr><td>__HIP_ARCH_HAS_GLOBAL_INT32_ATOMICS__ __HIP_ARCH_HAS_GLOBAL_FLOAT_ATOMIC_EXCH__</td><td>hasGlobalInt32Atomics hasGlobalFloatAtomicExch</td><td>32-bit integer atomics for global memory 32-bit float atomic exchange for global mem- ory</td></tr><tr><td>__HIP_ARCH_HAS_SHARED_INT32_ATOMICS__ __HIP_ARCH_HAS_SHARED_FLOAT_ATOMIC_EXCH__</td><td>hasSharedInt32Atomics hasSharedFloatAtomicExch</td><td>32-bit integer atomics for shared memory 32-bit float atomic exchange for shared mem- ory</td></tr><tr><td>__HIP_ARCH_HAS_FLOAT_ATOMIC_ADD__</td><td>hasFloatAtomicAdd</td><td>32-bit float atomic add in global and shared memory</td></tr><tr><th>64-bit atomics:</th><td></td><td></td></tr><tr><td>__HIP_ARCH_HAS_GLOBAL_INT64_ATOMICS__ __HIP_ARCH_HAS_SHARED_INT64_ATOMICS__ Doubles:</td><td>hasGlobalInt64Atomics hasSharedInt64Atomics</td><td>64-bit integer atomics for global memory 64-bit integer atomics for shared memory</td></tr><tr><td>__HIP_ARCH_HAS_DOUBLES__ Warp cross-lane operations:</td><td>hasDoubles</td><td>Double-precision floating point</td></tr><tr><td>__HIP_ARCH_HAS_WARP_VOTE__ __HIP_ARCH_HAS_WARP_BALLOT__ __HIP_ARCH_HAS_WARP_SHUFFLE__ __HIP_ARCH_HAS_WARP_FUNNEL_SHIFT__ Sync:</td><td>hasWarpVote hasWarpBallot hasWarpShuffle hasFunnelShift</td><td>Warp vote instructions ( any , all ) Warp ballot instructions Warp shuffle operations ( shfl_* ) Funnel shift two input words into one</td></tr><tr><td></td><td>hasThreadFenceSystem hasSyncThreadsExt</td><td>threadfence_system syncthreads_count , syncthreads_and</td></tr><tr><td>__HIP_ARCH_HAS_THREAD_FENCE_SYSTEM__</td><td></td><td></td></tr><tr><td>__HIP_ARCH_HAS_SYNC_THREAD_EXT__</td><td></td><td>, syncthreads_or</td></tr><tr><th>Miscellaneous:</th><td></td><td></td></tr><tr><td>__HIP_ARCH_HAS_SURFACE_FUNCS__</td><td>hasSurfaceFuncs</td><td></td></tr><tr><td>__HIP_ARCH_HAS_3DGRID__</td><td>has3dGrid</td><td>Grids and groups are 3D</td></tr><tr><td>__HIP_ARCH_HAS_DYNAMIC_PARALLEL__</td><td>hasDynamicParallelism</td><td></td></tr></tbody></table>
-<h2>8.4 Finding HIP</h2>
-<p>Makefiles can use the following syntax to conditionally provide a default HIP_PATH if one does not exist:</p>
-<p>HIP_PATH ?= $( shell hipconfig --path )</p>
-<h2>8.5 Identifying HIP Runtime</h2>
-<p>HIP can depend on rocclr, or CUDA as runtime</p>
-<ul>
-<li style="list-style-type: '· ';">AMDplatform On AMD platform, HIP uses Radeon Open Compute Common Language Runtime, called ROCclr. ROCclr is a virtual device interface that HIP runtimes interact with different backends which allows runtimes to work on Linux , as well as Windows without much efforts.</li>
-<li style="list-style-type: '· ';">NVIDIA platform On NVIDIA platform, HIP is just a thin layer on top of CUDA. On non-AMD platform, HIP runtime determines if CUDA is available and can be used. If available, HIP_PLATFORM is set to nvidia and underneath CUDA path is used.</li>
-</ul>
-<h2>8.6 hipLaunchKernelGGL</h2>
-<p>hipLaunchKernelGGL is a macro that can serve as an alternative way to launch kernel, which accepts parameters of launch configurations (grid dims, group dims, stream, dynamic shared size) followed by a variable number of kernel arguments. It can replace &lt;&lt;&lt; &gt;&gt;&gt;, if the user so desires.</p>
-<h2>8.7 Compiler Options</h2>
-<p>hipcc is a portable compiler driver that will call NVCC or HIP-Clang (depending on the target system) and attach all required include and library options. It passes options through to the target compiler. Tools that call hipcc must ensure the compiler options are appropriate for the target compiler. The hipconfig script may helpful in identifying the target platform, compiler and runtime. It can also help set options appropriately.</p>
-<h2>8.7.1 Compiler options supported on AMD platforms</h2>
-<p>Here are the main compiler options supported on AMD platforms by HIP-Clang.</p>
-<table><tbody><tr><th>Option</th><th>Description</th></tr><tr><td></td><td>--amdgpu-target=&lt;gpu_arch&gt; [DEPRECATED] This option is being replaced by --offload-arch=&lt;target&gt; . Generate code for the given GPU target. Supported targets are gfx701, gfx801, gfx802, gfx803, gfx900, gfx906, gfx908, gfx1010, gfx1011, gfx1012, gfx1030, gfx1031. This option could appear multiple times on the same command line to generate a fat binary for multiple targets.</td></tr><tr><td>--fgpu-rdc</td><td>Generate relocatable device code, which allows kernels or device functions calling device functions in different translation units.</td></tr><tr><td>-ggdb</td><td>Equivalent to -g plus tuning for GDB. This is recommended when using ROCm&#x27;s GDB to debug GPU code.</td></tr><tr><td></td><td>--gpu-max-threads-per-block=&lt;num&gt; Generate code to support up to the specified number of threads per block.</td></tr><tr><td>-O&lt;n&gt;</td><td>Specify the optimization level.</td></tr><tr><td></td><td>-offload-arch=&lt;target&gt; Specify the AMDGPUtarget ID.</td></tr><tr><td>-save-temps</td><td>Save the compiler generated intermediate files.</td></tr><tr><td>-v</td><td>Show the compilation steps.</td></tr></tbody></table>
-<h2>8.8 Linking Issues</h2>
-<h2>8.8.1 Linking With hipcc</h2>
-<p>hipcc adds the necessary libraries for HIP as well as for the accelerator compiler (NVCC or AMD compiler). We recommend linking with hipcc since it automatically links the binary to the necessary HIP runtime libraries. It also has knowledge on how to link and to manage the GPU objects.</p>
-<h2>8.8.2 -lm Option</h2>
-<p>hipcc adds -lm by default to the link command.</p>
-<h2>8.9 Linking Code With Other Compilers</h2>
-<p>CUDA code often uses NVCC for accelerator code (defining and launching kernels, typically defined in .cu or .cuh files). It also uses a standard compiler (g++) for the rest of the application. NVCC is a preprocessor that employs a standard host compiler (gcc) to generate the host code. Code compiled using this tool can employ only the intersection of language features supported by both NVCC and the host compiler. In some cases, you must take care to ensure the data types and alignment of the host compiler are identical to those of the device compiler. Only some host compilers are supported-for example, recent NVCC versions lack Clang host-compiler capability.</p>
-<p>HIP-Clang generates both device and host code using the same Clang-based compiler. The code uses the same API as gcc, which allows code generated by different gcc-compatible compilers to be linked together. For example, code compiled using HIP-Clang can link with code compiled using 'standard' compilers (such as gcc, ICC and Clang). Take care to ensure all compilers use the same standard C++ header and library formats.</p>
-<h2>8.9.1 libc++ and libstdc++</h2>
-<p>hipcc links to libstdc++ by default. This provides better compatibility between g++ and HIP.</p>
-<p>If you pass --stdlib=libc++ to hipcc, hipcc will use the libc++ library. Generally, libc++ provides a broader set of C++ features while libstdc++ is the standard for more compilers (notably including g++).</p>
-<p>When cross-linking C++ code, any C++ functions that use types from the C++ standard library (including std::string, std::vector and other containers) must use the same standard-library implementation. They include the following:</p>
-<ul>
-<li style="list-style-type: '· ';">Functions or kernels defined in HIP-Clang that are called from a standard compiler</li>
-<li style="list-style-type: '· ';">Functions defined in a standard compiler that are called from HIP-Clang.</li>
-</ul>
-<p>Applications with these interfaces should use the default libstdc++ linking.</p>
-<p>Applications which are compiled entirely with hipcc, and which benefit from advanced C++ features not supported in libstdc++, and which do not require portability to NVCC, may choose to use libc++.</p>
-<h2>8.9.2 HIP Headers ( hip_runtime.h , hip_runtime_api.h )</h2>
-<p>The hip_runtime.h and hip_runtime_api.h files define the types, functions and enumerations needed to compile a HIP program:</p>
-<ul>
-<li style="list-style-type: '· ';">hip_runtime_api.h : defines all the HIP runtime APIs (e.g., hipMalloc ) and the types required to call them. A source file that is only calling HIP APIs but neither defines nor launches any kernels can include hip_runtime_api.h . hip_runtime_api.h uses no custom Heterogeneous Compute (HC) language features and can be compiled using a standard C++ compiler.</li>
-<li style="list-style-type: '· ';">hip_runtime.h : included in hip_runtime_api.h . It additionally provides the types and defines required to create and launch kernels. hip_runtime.h can be compiled using a standard C++ compiler but will expose a subset of the available functions.</li>
-</ul>
-<p>CUDAhasslightly different contents for these two files. In some cases you may need to convert hipified code to include the richer hip_runtime.h instead of hip_runtime_api.h .</p>
-<h2>8.9.3 Using a Standard C++ Compiler</h2>
-<p>You can compile hip_runtime_api.h using a standard C or C++ compiler (e.g., gcc or ICC). The HIP include paths and defines ( __HIP_PLATFORM_AMD__ or __HIP_PLATFORM_NVIDIA__ ) must pass to the standard compiler; hipconfig then returns the necessary options:</p>
-<ul>
-<li>&gt;</li>
-</ul>
-<pre><code>|> hipconfig --cxx_config</code></pre>
-<pre><code>                                                                                                                                                                                                        |  -D___HIP_PLATFORM_AMD___ -I/home/user1/hip/include</code></pre>
-<p>You can capture the hipconfig output and passed it to the standard compiler; below is a sample makefile syntax:</p>
-<pre><code>            |CPPFLAGS += $(shell $(HIP_PATH)/bin/hipconfig --cpp_config)</code></pre>
-<pre><code>
-)</code></pre>
-<p>NVCC includes some headers by default. However, HIP does not include default headers, and instead all required files must be explicitly included. Specifically, files that call HIP run-time APIs or define HIP kernels must explicitly include the appropriate HIP headers. If the compilation process reports that it cannot find necessary APIs (for example, error: identifier hipSetDevice is undefined ), ensure that the file includes hip_runtime.h (or hip_runtime_api.h, if appropriate). The hipify-perl script automatically converts cuda_runtime.h to hip_runtime.h , and it converts cuda_runtime_api.h to hip_runtime_api.h , but it may miss nested headers or macros.</p>
-<h2>8.9.3.1 cuda.h</h2>
-<p>The HIP-Clang path provides an empty cuda.h file. Some existing CUDA programs include this file but don't require any of the functions.</p>
-<h2>8.9.4 Choosing HIP File Extensions</h2>
-<p>Many existing CUDA projects use the .cu and .cuh file extensions to indicate code that should be run through the NVCC compiler. For quick HIP ports, leaving these file extensions unchanged is often easier, as it minimizes the work required to change file names in the directory and #include statements in the files.</p>
-<p>For new projects or ports which can be re-factored, we recommend the use of the extension .hip.cpp for source files, and .hip.h or .hip.hpp for header files. This indicates that the code is standard C++ code, but also provides a unique indication for make tools to run hipcc when appropriate.</p>
-<h2>8.10 Workarounds</h2>
-<h2>8.10.1 warpSize</h2>
-<p>Code should not assume a warp size of 32 or 64. See Warp Cross-Lane Functions for information on how to write portable wave-aware code.</p>
-<h2>8.10.2 Kernel launch with group size &gt; 256</h2>
-<p>Kernel code should use __attribute__((amdgpu_flat_work_group_size(&lt;min&gt;,&lt;max&gt;))) . For example:</p>
-<pre><code><_SQL_></code></pre>
-<h2>8.11 memcpyToSymbol</h2>
-<p>HIP support for hipMemcpyToSymbol is complete. This feature allows a kernel to define a device-side data symbol which can be accessed on the host side. The symbol can be in __constant or device space.</p>
-<p>Note that the symbol name needs to be encased in the HIP_SYMBOL macro, as shown in the code example below. This also applies to hipMemcpyFromSymbol , hipGetSymbolAddress , and hipGetSymbolSize .</p>
-<p>For example:</p>
-<p>Device Code:</p>
-<pre><code><_C++_></code></pre>
-<p>(continued from previous page)</p>
-<pre><code>        {
-            A[i] = -1*i;
-            B[i] = 0;
-        }
-
-        HIP_ASSERT(hipMalloc((void**)&Ad, SIZE));
-
-        HIP_ASSERT(hipMemcpyToSymbol(HIP_SYMBOL(Value), A, SIZE, 0, hipMemcpyHostToDevice));
-        hipLaunchKernelGGL(Get, dim3(1,1,1), dim3(LEN,1,1), 0, 0, Ad);
-        HIP_ASSERT(hipMemcpy(B, Ad, SIZE, hipMemcpyDeviceToHost));
-
-        for(unsigned i=0;i<LEN;i++)
-        {
-            assert(A[i] == B[i]);
-        }
-        std::cout<<"Passed"<<std::endl;
-    }
-    
-    
-    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -</code></pre>
-<h2>8.12 CU_POINTER_ATTRIBUTE_MEMORY_TYPE</h2>
-<p>To get pointer's memory type in HIP/HIP-Clang, developers should use hipPointerGetAttributes API. First parameter of the API is hipPointerAttribute_t which has 'type' as member variable. 'type' indicates input pointer is allocated on device or host.</p>
-<p>For example:</p>
-<pre><code>            For example:
-            double * ptr;
-            hipMalloc(reinterpret_cast<void**>(&ptr), sizeof(double));
-            hipPointerAttribute_t attr;
-            hipPointerGetAttributes(&attr, ptr); /*attr.type will have value as hipMemoryTypeDevice*/
-
-            double* ptrHost;
-            hipHostMalloc(&ptrHost, sizeof(double));
-            hipPointerAttribute_t attr;
-            hipPointerGetAttributes(&attr, ptrHost); /*attr.type will have value as _
-           ...hipMemoryTypeHost*/
-
-            Data data file.MaximumTime amount value as different from end.MaximumTime amount value</code></pre>
-<p>Please note, hipMemoryType enum values are different from cudaMemoryType enum values.</p>
-<p>For example, on AMD platform, hipMemoryType is defined in hip_runtime_api.h ,</p>
-<pre><code>            For example, on AMD platform, hipMemoryType is defined in hip_runtime_api.h,
-            
-        typedef enum hipMemoryType {
-            hipMemoryTypeHost = 0,     ///< Memory is physically located on host
-            hipMemoryTypeDevice = 1,  ///< Memory is physically located on device. (see deviceId,
-        --for specific device)
-            hipMemoryTypeArray = 2,   ///< Array memory, physically located on device. (see_,
-        --deviceId for specific device)
-            hipMemoryTypeUnified = 3, ///< Not used currently
-            hipMemoryTypeManaged = 4  ///< Managed memory, automatically managed by the unified.
-        --memory system
-        } hipMemoryType;</code></pre>
-<p>Looking into CUDA toolkit, it defines cudaMemoryType as following,</p>
-<pre><code><_Cuda_></code></pre>
-<p>In this case, memory type translation for hipPointerGetAttributes needs to be handled properly on NVIDIA platform to get the correct memory type in CUDA, which is done in the file nvidia_hip_runtime_api.h .</p>
-<p>So in any HIP applications which use HIP APIs involving memory types, developers should use #ifdef in order to assign the correct enum values depending on NVIDIA or AMD platform.</p>
-<p>As an example, please see the code from the link.</p>
-<p>With the #ifdef condition, HIP APIs work as expected on both AMD and NVIDIA platforms.</p>
-<p>Note, cudaMemoryTypeUnregstered is currently not supported in hipMemoryType enum, due to HIP functionality backward compatibility.</p>
-<h2>8.13 threadfence_system</h2>
-<p>threadfence_system makes all device memory writes, all writes to mapped host memory, and all writes to peer memory visible to CPU and other GPU devices. Some implementations can provide this behavior by flushing the GPU L2 cache. HIP/HIP-Clang does not provide this functionality. As a workaround, users can set the environment variable HSA_DISABLE_CACHE=1 to disable the GPU L2 cache. This will affect all accesses and for all kernels and so may have a performance impact.</p>
-<h2>8.13.1 Textures and Cache Control</h2>
-<p>Compute programs sometimes use textures either to access dedicated texture caches or to use the texture-sampling hardware for interpolation and clamping. The former approach uses simple point samplers with linear interpolation, essentially only reading a single point. The latter approach uses the sampler hardware to interpolate and combine multiple samples. AMD hardware, as well as recent competing hardware, has a unified texture/L1 cache, so it no longer has a dedicated texture cache. But the NVCC path often caches global loads in the L2 cache, and some programs may benefit from explicit control of the L1 cache contents. We recommend the __ldg instruction for this purpose.</p>
-<p>AMDcompilers currently load all data into both the L1 and L2 caches, so __ldg is treated as a no-op.</p>
-<p>We recommend the following for functional portability:</p>
-<ul>
-<li style="list-style-type: '· ';">For programs that use textures only to benefit from improved caching, use the __ldg instruction</li>
-<li style="list-style-type: '· ';">Programs that use texture object and reference APIs, work well on HIP</li>
-</ul>
-<h2>8.14 More Tips</h2>
-<h2>8.14.1 HIP Logging</h2>
-<p>Onan AMDplatform, set the AMD_LOG_LEVEL environment variable to log HIP application execution information.</p>
-<p>The value of the setting controls different logging level,</p>
-<pre><code><_C++_></code></pre>
-<p>Logging mask is used to print types of functionalities during the execution of HIP application. It can be set as one of the following values,</p>
-<pre><code><_C++_></code></pre>
-<h2>8.14.2 Debugging hipcc</h2>
-<p>To see the detailed commands that hipcc issues, set the environment variable HIPCC_VERBOSE to 1. Doing so will print to stderr the HIP-clang (or NVCC) commands that hipcc generates.</p>
-<pre><code>export HIPCC_VERBOSE=1
-make
-
-...
-hipcc-cmd: /opt/rcm/bin/hipcc --offload-arch=native -x hip backprop_cuda.cu</code></pre>
-<h2>8.14.3 Editor Highlighting</h2>
-<p>See the utils/vim or utils/gedit directories to add handy highlighting to hip files.</p>
-<h2>PORTING CUDA DRIVER API</h2>
-<h2>9.1 Introduction to the CUDA Driver and Runtime APIs</h2>
-<p>CUDA provides a separate CUDA Driver and Runtime APIs. The two APIs have significant overlap in functionality:</p>
-<ul>
-<li style="list-style-type: '· ';">Both APIs support events, streams, memory management, memory copy, and error handling.</li>
-<li style="list-style-type: '· ';">Both APIs deliver similar performance.</li>
-<li style="list-style-type: '· ';">Driver APIs calls begin with the prefix cu while Runtime APIs begin with the prefix cuda . For example, the Driver API API contains cuEventCreate while the Runtime API contains cudaEventCreate , with similar functionality.</li>
-<li style="list-style-type: '· ';">The Driver API defines a different but largely overlapping error code space than the Runtime API, and uses a different coding convention. For example, Driver API defines CUDA_ERROR_INVALID_VALUE while the Runtime API defines cudaErrorInvalidValue</li>
-</ul>
-<p>The Driver API offers two additional pieces of functionality not provided by the Runtime API: cuModule and cuCtx APIs.</p>
-<h2>9.1.1 cuModule API</h2>
-<p>The Module section of the Driver API provides additional control over how and when accelerator code objects are loaded. For example, the driver API allows code objects to be loaded from files or memory pointers. Symbols for kernels or global data can be extracted from the loaded code objects. In contrast, the Runtime API automatically loads and (if necessary) compiles all of the kernels from an executable binary when run. In this mode, NVCC must be used to compile kernel code so the automatic loading can function correctly.</p>
-<p>Both Driver and Runtime APIs define a function for launching kernels (called cuLaunchKernel or cudaLaunchKernel . The kernel arguments and the execution configuration (grid dimensions, group dimensions, dynamic shared memory, and stream) are passed as arguments to the launch function. The Runtime additionally provides the &lt;&lt;&lt; &gt;&gt;&gt; syntax for launching kernels, which resembles a special function call and is easier to use than explicit launch API (in particular with respect to handling of kernel arguments). However, this syntax is not standard C++ and is available only when NVCC is used to compile the host code.</p>
-<p>The Module features are useful in an environment which generates the code objects directly, such as a new accelerator language front-end. Here, NVCC is not used. Instead, the environment may have a different kernel language or different compilation flow. Other environments have many kernels and do not want them to be all loaded automatically. The Module functions can be used to load the generated code objects and launch kernels. As we will see below, HIP defines a Module API which provides similar explicit control over code object management.</p>
-<h2>9.1.2 cuCtx API</h2>
-<p>The Driver API defines 'Context' and 'Devices' as separate entities. Contexts contain a single device, and a device can theoretically have multiple contexts. Each context contains a set of streams and events specific to the context. Historically contexts also defined a unique address space for the GPU, though this may no longer be the case in Unified Memory platforms (since the CPU and all the devices in the same process share a single unified address space). The Context APIs also provide a mechanism to switch between devices, which allowed a single CPU thread to send commands to different GPUs. HIP as well as a recent versions of CUDA Runtime provide other mechanisms to accomplish this feat - for example using streams or cudaSetDevice .</p>
-<p>The CUDA Runtime API unifies the Context API with the Device API. This simplifies the APIs and has little loss of functionality since each Context can contain a single device, and the benefits of multiple contexts has been replaced with other interfaces. HIP provides a context API to facilitate easy porting from existing Driver codes. In HIP, the Ctx functions largely provide an alternate syntax for changing the active device.</p>
-<p>Most new applications will prefer to use hipSetDevice or the stream APIs, therefore HIP has marked hipCtx APIs as deprecated . Support for these APIs may not be available in future releases. For more details on deprecated APIs please refer HIP deprecated APIs .</p>
-<h2>9.2 HIP Module and Ctx APIs</h2>
-<p>Rather than present two separate APIs, HIP extends the HIP API with new APIs for Modules and Ctx control.</p>
-<h2>9.2.1 hipModule API</h2>
-<p>Like the CUDA Driver API, the Module API provides additional control over how code is loaded, including options to load code from files or from in-memory pointers. NVCC and HIP-Clang target different architectures and use different code object formats: NVCC is cubin or ptx files, while the HIP-Clang path is the hsaco format. The external compilers which generate these code objects are responsible for generating and loading the correct code object for each platform. Notably, there is not a fat binary format that can contain code for both NVCC and HIP-Clang platforms. The following table summarizes the formats used on each platform:</p>
-<table><tbody><tr><th>Format</th><th>APIs</th><th>NVCC</th><th>HIP-CLANG</th></tr><tr><td>Code Object Fat Binary</td><td>hipModuleLoad , hipModuleLoadData hipModuleLoadFatBin</td><td>.cubin or PTX text .fatbin</td><td>.hsaco .hip_fatbin</td></tr></tbody></table>
-<p>hipcc uses HIP-Clang or NVCC to compile host codes. Both of these may embed code objects into the final executable, and these code objects will be automatically loaded when the application starts. The hipModule API can be used to load additional code objects, and in this way provides an extended capability to the automatically loaded code objects. HIP-Clang allows both of these capabilities to be used together, if desired. Of course it is possible to create a program with no kernels and thus no automatic loading.</p>
-<h2>9.2.2 hipCtx API</h2>
-<p>HIP provides a Ctx API as a thin layer over the existing Device functions. This Ctx API can be used to set the current context, or to query properties of the device associated with the context. The current context is implicitly used by other APIs such as hipStreamCreate .</p>
-<h2>9.2.3 hipify translation of CUDA Driver API</h2>
-<p>The HIPIFY tools convert CUDA Driver APIs for streams, events, modules, devices, memory management, context, profiler to the equivalent HIP driver calls. For example, cuEventCreate will be translated to hipEventCreate . HIPIFY tools also convert error codes from the Driver namespace and coding convention to the equivalent HIP error code. Thus, HIP unifies the APIs for these common functions.</p>
-<p>The memory copy API requires additional explanation. The CUDA driver includes the memory direction in the name of the API ( cuMemcpyH2D ) while the CUDA driver API provides a single memory copy API with a parameter that specifies the direction and additionally supports a 'default' direction where the runtime determines the direction automatically. HIP provides APIs with both styles: for example, hipMemcpyH2D as well as hipMemcpy . The first flavor may be faster in some cases since they avoid host overhead to detect the different memory directions.</p>
-<p>HIP defines a single error space, and uses camel-case for all errors (i.e. hipErrorInvalidValue ).</p>
-<h2>9.2.3.1 Address Spaces</h2>
-<p>HIP-Clang defines a process-wide address space where the CPU and all devices allocate addresses from a single unified pool. Thus addresses may be shared between contexts, and unlike the original CUDA definition a new context does not create a new address space for the device.</p>
-<h2>9.2.3.2 Using hipModuleLaunchKernel</h2>
-<p>hipModuleLaunchKernel is cuLaunchKernel in HIP world. It takes the same arguments as cuLaunchKernel .</p>
-<h2>9.2.3.3 Additional Information</h2>
-<ul>
-<li style="list-style-type: '· ';">HIP-Clang creates a primary context when the HIP API is called. So in a pure driver API code, HIP-Clang will create a primary context while HIP/NVCC will have empty context stack. HIP-Clang will push primary context to context stack when it is empty. This can have subtle differences on applications which mix the runtime and driver APIs.</li>
-</ul>
-<h2>9.2.4 hip-clang Implementation Notes</h2>
-<h2>9.2.4.1 .hip_fatbin</h2>
-<p>hip-clang links device code from different translation units together. For each device target, a code object is generated. Code objects for different device targets are bundled by clang-offload-bundler as one fatbinary, which is embeded as a global symbol __hip_fatbin in the .hip_fatbin section of the ELF file of the executable or shared object.</p>
-<h2>9.2.4.2 Initialization and Termination Functions</h2>
-<p>hip-clang generates initialization and termination functions for each translation unit for host code compilation. The initialization functions call __hipRegisterFatBinary to register the fatbinary embeded in the ELF file. They also call __hipRegisterFunction and __hipRegisterVar to register kernel functions and device side global variables. The termination functions call __hipUnregisterFatBinary . hip-clang emits a global variable __hip_gpubin_handle of void** type with linkonce linkage and inital value 0 for each host translation unit. Each initialization function checks __hip_gpubin_handle and register the fatbinary only if __hip_gpubin_handle is 0 and saves the return value of __hip_gpubin_handle to __hip_gpubin_handle . This is to guarantee that the fatbinary is only registered once. Similar check is done in the termination functions.</p>
-<h2>9.2.4.3 Kernel Launching</h2>
-<p>hip-clang supports kernel launching by CUDA &lt;&lt;&lt;&gt;&gt;&gt; syntax, hipLaunchKernelGGL. The latter one is macro which expand to CUDA &lt;&lt;&lt;&gt;&gt;&gt; syntax.</p>
-<p>When the executable or shared library is loaded by the dynamic linker, the initialization functions are called. In the initialization functions, when __hipRegisterFatBinary is called, the code objects containing all kernels are loaded; when __hipRegisterFunction is called, the stub functions are associated with the corresponding kernels in code objects.</p>
-<p>hip-clang implements two sets of kernel launching APIs.</p>
-<p>By default, in the host code, for the &lt;&lt;&lt;&gt;&gt;&gt; statement, hip-clang first emits call of hipConfigureCall to set up the threads and grids, then emits call of the stub function with the given arguments. In the stub function, hipSetupArgument is called for each kernel argument, then hipLaunchByPtr is called with a function pointer to the stub function. In hipLaunchByPtr , the real kernel associated with the stub function is launched.</p>
-<h2>9.2.5 NVCC Implementation Notes</h2>
-<h2>9.2.5.1 Interoperation between HIP and CUDA Driver</h2>
-<p>CUDA applications may want to mix CUDA driver code with HIP code (see example below). This table shows the type equivalence to enable this interaction.</p>
-<table><tbody><tr><th>HIP Type</th><th>CU Driver Type</th><th>CUDA Runtime Type</th></tr><tr><td>hipModule_t</td><td>CUmodule</td><td></td></tr><tr><td>hipFunction_t</td><td>CUfunction</td><td></td></tr><tr><td>hipCtx_t</td><td>CUcontext</td><td></td></tr><tr><td>hipDevice_t</td><td>CUdevice</td><td></td></tr><tr><td>hipStream_t</td><td>CUstream</td><td>cudaStream_t</td></tr><tr><td>hipEvent_t</td><td>CUevent</td><td>cudaEvent_t</td></tr><tr><td>hipArray</td><td>CUarray</td><td>cudaArray</td></tr></tbody></table>
-<h2>9.2.5.2 Compilation Options</h2>
-<p>The hipModule_t interface does not support cuModuleLoadDataEx function, which is used to control PTX compilation options. HIP-Clang does not use PTX and does not support these compilation options. In fact, HIP-Clang code objects always contain fully compiled ISA and do not require additional compilation as a part of the load step. The corresponding HIP function hipModuleLoadDataEx behaves as hipModuleLoadData on HIP-Clang path (compilation options are not used) and as cuModuleLoadDataEx on NVCC path. For example (CUDA):</p>
-<pre><code><_Cuda_></code></pre>
-<p>HIP:</p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?xml version="1.0" encoding="UTF-8" />
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        </?xml version="2.0" encoding="UTF-8" />
-                                                                                                                                                                                             <?xml version="3.0" encoding="UTF-8" />
-                                                                                                                                                                                            
-	         
-                                                                                                                                                                                             
-         
-                                                                                                                                                                                              <?xml version="4.0" encoding="UTF-8" />
-                                                                                                                                                                                             </?xml version="5.0" encoding="UTF-8" />
-                                                                                                                                                                                            
-
-          
-                                                                                                                                                                                             <?xml version="6.0" encoding="UTF-8" />
-                                                                                                                                                                                             >
-                                                                                                                                                                                                       <!xml version="7.0" encoding="UTF-8" />
-                                                                                                                                                                                             //
-                                                                                                                                                                                                       </!xml version="8.0" encoding="UTF-8" />
-                                                                                                                                                                                             }</code></pre>
-<p>The below sample shows how to use hipModuleGetFunction .</p>
-<pre><code>#include<hip_runtime.h>
-#include<hip_runtime_api.h>
-#include<iostream>
-#include<fstream>
-#include<vector></code></pre>
-<pre><code>#include<hip_runtime.h>
-#include<hip_runtime_api.h>
-#include<iostream>
-#include<fstream>
-#include<vector></code></pre>
-<pre><code>HIP Documentation, Release 6.1.40092
-
-
-
-
-#define LEN 64
-#define SIZE LEN<<2
-
-#ifdef __HIP_PLATFORM_AMD__
-#define fileName "vcpy_isa.co"
-#endif
-
-#ifdef __HIP_PLATFORM_NVIDIA__
-#define fileName "vcpy_isa.ptx"
-#endif
-
-#define kernel_name "hello_world"
-
-int main(){
-	float *A, *B;
-	hipDeviceptr_t Ad, Bd;
-	A = new float[LEN];
-	B = new float[LEN];
-
-	for(uint32_t i=0;i<LEN;i++){
-		A[i] = i*1.0f;
-		B[i] = 0.0f;
-		std::cout<<A[i] << " "<<B[i]<<std::endl;
-	}
-
-
-#ifdef __HIP_PLATFORM_NVIDIA__
-		hipInit(0);
-		hipDevice_t device;
-		hipCtx_t context;
-		hipDeviceGet(&device, 0);
-		hipCtxCreate(&context, 0, device);
-#endif
-
-	hipMalloc((void**)&Ad, SIZE);
-	hipMalloc((void**)&Bd, SIZE);
-
-	hipMemcpyHtoD(Ad, A, SIZE);
-	hipMemcpyHtoD(Bd, B, SIZE);
-	hipModule_t Module;
-	hipFunction_t Function;
-	hipModuleLoad(&Module, fileName);
-	hipModuleGetFunction(&Function, Module, kernel_name);
-
-	std::vector<void*>argBuffer(2);
-	memcpy(&argBuffer[0], &Ad, sizeof(void*));
-	memcpy(&argBuffer[1], &Bd, sizeof(void*));
-
-	size_t size = argBuffer.size()*sizeof(void*);
-
-	void *config[] = {
-		HIP_LAUNCH_PARAM_BUFFER_POINTER, &argBuffer[0],
-
-
-
-54</code></pre>
-<p>(continued from previous page)</p>
-<p>(continues on next page)</p>
-<p>(continued from previous page)</p>
-<pre><code>        HIP_LAUNCH_PARAM_BUFFER_SIZE, &size,
-        HIP_LAUNCH_PARAM_END
-    };
-
-    hipModuleLaunchKernel(Function, 1, 1, 1, LEN, 1, 1, 0, 0, NULL, (void**)&config);
-
-    hipMemcpyDtoH(B, Bd, SIZE);
-    for(uint32_t i=0;i<LEN;i++){
-        std::cout<<A[i]<<" - "<<B[i]<<std::endl;
-    }
-
-#ifdef __HIP_PLATFORM_NVIDIA__
-          hipCtxDetach(context);
-#endif
-
-    return 0;
-}
-
-__A__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ ======"__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__= "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "_ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = '__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ from "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "___ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "'</code></pre>
-<h2>9.3 HIP Module and Texture Driver API</h2>
-<p>HIP supports texture driver APIs however texture reference should be declared in host scope. Following code explains the use of texture reference for __HIP_PLATFORM_AMD__ platform.</p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        // Code to generate code object
-
-                                                                                                                                                                                                      
-#include "hip/hip_runtime.h"
-                                                                                                                                                                                                      
-extern texture<float, 2, hipReadModeElementType> tex;
-
-        __global__ void tex2dKernel(hipLaunchParm lp, float* outputData,
-                                                                                                                                                                                                       //</code></pre>
-<pre><code>  }
-
-  // Host code:
-
-  texture<float, 2, hipReadModeElementType> tex;
-
-  void myFunc ()
-  {
-
-      //...
-
-      textureReference* texref;
-      hipModuleGetTexRef(&texref, Module1, "tex");
-      hipTexRefSetAddressMode(texref, 0, hipAddressModeWrap);
-      hipTexRefSetAddressMode(texref, 1, hipAddressModeWrap);
-      hipTexRefSetFilterMode(texref, hipFilterModePoint);</code></pre>
-<p>(continues on next page)</p>
-<pre><code>    hipTexRefSetFlags(texref, 0);
-    hipTexRefSetFormat(texref, HIP_AD_FORMAT_FLOAT, 1);
-    hipTexRefSetArray(texref, array, HIP_TRSA_OVERRIDE_FORMAT);
-
-    //...
-}</code></pre>
-<p>(continued from previous page)</p>
-<h2>TEN</h2>
-<h2>PROGRAMMING FOR HIP RUNTIME COMPILER (RTC)</h2>
-<p>HIP lets you compile kernels at runtime with the hiprtc* APIs. Kernels can be stored as a text string and can be passed to HIPRTC APIs alongside options to guide the compilation.</p>
-<p>NOTE:</p>
-<ul>
-<li style="list-style-type: '· ';">This library can be used on systems without HIP installed nor AMD GPU driver installed at all (offline compilation). Therefore, it does not depend on any HIP runtime library.</li>
-<li style="list-style-type: '· ';">But it does depend on comgr. You may try to statically link comgr into HIPRTC to avoid any ambiguity.</li>
-<li style="list-style-type: '· ';">Developers can decide to bundle this library with their application.</li>
-</ul>
-<h2>10.1 Example</h2>
-<p>To use HIPRTC functionality, HIPRTC header needs to be included first. #include &lt;hip/hiprtc.h&gt;</p>
-<p>Kernels can be stored in a string:</p>
-<pre><code><_C_></code></pre>
-<p>Now to compile this kernel, it needs to be associated with hiprtcProgram type, which is done by declaring hiprtcProgram prog; and associating the string of kernel with this program:</p>
-<pre><code>hiprtcCreateProgram(&prog,                    // HIPRTC program
-                       kernel,                // kernel string
-                       "gpu_kernel.cu",       // Name of the file
-                       num_headers,            // Number of headers
-                       &header_sources[0],     // Header sources
-                       &header_names[0]);      // Name of header files</code></pre>
-<p>hiprtcCreateProgram API also allows you to add headers which can be included in your RTC program. For online compilation, the compiler pre-defines HIP device API functions, HIP specific types and macros for device compilation, but does not include standard C/C++ headers by default. Users can only include header files provided to hiprtcCreateProgram .</p>
-<p>After associating the kernel string with hiprtcProgram , you can now compile this program using:</p>
-<pre><code>
-
-hiprtcCompileProgram(prog,     // hiprtcProgram
-                         0,          // Number of options
-                          options);  // Clang Options [Supported Clang Options](clang_options.
-
---md)</code></pre>
-<p>hiprtcCompileProgram returns a status value which can be converted to string via hiprtcGetErrorString . If compilation is successful, hiprtcCompileProgram will return HIPRTC_SUCCESS .</p>
-<p>If the compilation fails, you can look up the logs via:</p>
-<pre><code><_C++_></code></pre>
-<p>If the compilation is successful, you can load the compiled binary in a local variable.</p>
-<pre><code>  size_t codeSize;
-  hiprtcGetCodeSize(prog, &codeSize);
-
-  vector<char> kernel_binary(codeSize);
-  hiprtcGetCode(prog, kernel_binary.data());</code></pre>
-<p>After loading the binary, hiprtcProgram can be destroyed. hiprtcDestroyProgram(&amp;prog);</p>
-<p>The binary present in kernel_binary can now be loaded via hipModuleLoadData API.</p>
-<pre><code>hipModule_t module;
-hipFunction_t kernel;
-
-hipModuleLoadData(&module, kernel_binary.data());
-hipModuleGetFunction(&kernel, module, "vector_add");</code></pre>
-<p>And now this kernel can be launched via hipModule APIs.</p>
-<p>The full example is below:</p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        //</code></pre>
-<p>(continued from previous page)</p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        </----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                    <-----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        >----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                   
-    <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                <----------------------------------------------------------------------------------------------------------------------    <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                               
-        <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                            <----------------------------------------------------------------------------------------------------------------------        <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                           
-            <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                        <----------------------------------------------------------------------------------------------------------------------            <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                       
-                <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                    <----------------------------------------------------------------------------------------------------------------------                <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                   
-                    <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                <----------------------------------------------------------------------------------------------------------------------                    <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                               
-                        <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                            <----------------------------------------------------------------------------------------------------------------------                        <----------------------------------------------------------------------------------------------------------------------</code></pre>
-<pre><code>HIP Documentation,Release 6.1.40092</code></pre>
-<p>(continued from previous page)</p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        }
-                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       }
-
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                       	                                                                                                                                                                                                      
-
-                                                                                                                                                                                                      
-                                                                                                                                                                                                     
-
-                                                                                                                                                                                                    
- 
-                                                                                                                                                                                                    
-
-                                                                                                                                                                                                      
-
- 
-                                                                                                                                                                                                     }
- 
-                                                                                                                                                                                                    }
-  
-                                                                                                                                                                                                    }
-
-  
-                                                                                                                                                                                                   
-  
-                                                                                                                                                                                                   }</code></pre>
-<h2>10.2 HIPRTC specific options</h2>
-<p>HIPRTC provides a few HIPRTC specific flags</p>
-<ul>
-<li style="list-style-type: '· ';">--gpu-architecture : This flag can guide the code object generation for a specific gpu arch. Example: --gpu-architecture=gfx906:sramecc+:xnack, its equivalent to --offload-arch .</li>
-<li>-This option is compulsory if compilation is done on a system without AMD GPUs supported by HIP runtime.</li>
-<li>-Otherwise, HIPRTC will load the hip runtime and gather the current device and its architecture info and use it as option.</li>
-<li style="list-style-type: '· ';">-fgpu-rdc : This flag when provided during the hiprtcCompileProgram generates the bitcode (HIPRTC doesn't convert this bitcode into ISA and binary). This bitcode can later be fetched using hiprtcGetBitcode and hiprtcGetBitcodeSize APIs.</li>
-</ul>
-<h2>10.2.1 Bitcode</h2>
-<p>In the usual scenario, the kernel associated with hiprtcProgram is compiled into the binary which can be loaded and run. However, if -fpu-rdc option is provided in the compile options, HIPRTC calls comgr and generates only the LLVM bitcode. It doesn't convert this bitcode to ISA and generate the final binary.</p>
-<pre><code>  std::string sarg = std::string("-fgpu-rdc");
-  const char* options[] = {
-      sarg.c_str() };
-  hiprtcCompileProgram(prog, // hiprtcProgram
-                        1,     // Number of options
-                        options);</code></pre>
-<p>If the compilation is successful, one can load the bitcode in a local variable using the bitcode APIs provided by HIPRTC.</p>
-<pre><code>size_t bitCodeSize;
-hiprtcGetBitcodeSize(prog, &bitCodeSize);
-
-vector<char> kernel_bitcode(bitCodeSize);
-hiprtcGetBitcode(prog, kernel_bitcode.data());</code></pre>
-<h2>10.2.2 CU Mode vs WGP mode</h2>
-<p>AMDGPUs consist of an array of workgroup processors, each built with 2 compute units (CUs) capable of executing SIMD32. All the CUs inside a workgroup processor use local data share (LDS).</p>
-<p>gfx10+ support execution of wavefront in CU mode and work-group processor mode (WGP). Please refer to section 2.3 of RDNA3 ISA reference.</p>
-<p>gfx9 and below only supports CU mode.</p>
-<p>In WGP mode, 4 warps of a block can simultaneously be executed on the workgroup processor, where as in CU mode only 2 warps of a block can simultaneously execute on a CU. In theory, WGP mode might help with occupancy and increase the performance of certain HIP programs (if not bound to inter warp communication), but might incur performance penalty on other HIP programs which rely on atomics and inter warp communication. This also has effect of how the LDS is split between warps, please refer to RDNA3 ISA reference for more information.</p>
-<p>HIPRTCassumes WGPmodebydefault for gfx10+. This can be overridden by passing -mcumode to HIPRTC compile options in hiprtcCompileProgram .</p>
-<h2>10.3 Linker APIs</h2>
-<p>The bitcode generated using the HIPRTC Bitcode APIs can be loaded using hipModule APIs and also can be linked with other generated bitcodes with appropriate linker flags using the HIPRTC linker APIs. This also provides more flexibility and optimizations to the applications who want to generate the binary dynamically according to their needs. The input bitcodes can be generated only for a specific architecture or it can be a bundled bitcode which is generated for multiple architectures.</p>
-<h2>10.3.1 Example</h2>
-<p>Firstly, HIPRTC link instance or a pending linker invocation must be created using hiprtcLinkCreate , with the appropriate linker options provided.</p>
-<pre><code><_C++_></code></pre>
-<p>Following which, the bitcode data can be added to this link instance via hiprtcLinkAddData (if the data is present as a string) or hiprtcLinkAddFile (if the data is present as a file) with the appropriate input type according to the data or the bitcode used.</p>
-<pre><code>
-hiprtcLinkAddData(rtc_link_state,        // HIPRTC link state
-                         input_type,            // type of the input data or bitcode
-                         bit_code_ptr,           // input data which is null terminated
-                         bit_code_size,          // size of the input data
-                          "a",                   // optional name for this input
-                          0,                     // size of the options
-                          0,                     // Array of options applied to this input
-                          0);                      // Array of option values cast to void*</code></pre>
-<pre><code>hiprtcLinkAddFile(rtc_link_state,        // HIPRTC link state
-                         input_type,            // type of the input data or bitcode
-                         bc_file_path.c_str(),  // path to the input file where bitcode is_
---present
-                         0,                   // size of the options
-                          0,                    // Array of options applied to this input
-                          0);                    // Array of option values cast to void*</code></pre>
-<p>Once the bitcodes for multiple architectures are added to the link instance, the linking of the device code must be completed using hiprtcLinkComplete which generates the final binary.</p>
-<pre><code><_C_></code></pre>
-<p>If the hiprtcLinkComplete returns successfully, the generated binary can be loaded and run using the hipModule* APIs.</p>
-<pre><code>      |hipModuleLoadData(&module, bina</code></pre>
-<pre><code>binary);</code></pre>
-<h2>10.3.1.1 Note</h2>
-<ul>
-<li style="list-style-type: '· ';">The compiled binary must be loaded before HIPRTC link instance is destroyed using the hiprtcLinkDestroy API.</li>
-</ul>
-<h2>hiprtcLinkDestroy(rtc_link_state);</h2>
-<ul>
-<li style="list-style-type: '· ';">The correct sequence of calls is : hiprtcLinkCreate , hiprtcLinkAddData or hiprtcLinkAddFile , hiprtcLinkComplete , hiprtcModuleLoadData , hiprtcLinkDestroy .</li>
-</ul>
-<h2>10.3.2 Input Types</h2>
-<p>HIPRTC provides hiprtcJITInputType enumeration type which defines the input types accepted by the Linker APIs. Here are the enum values of hiprtcJITInputType . However only the input types HIPRTC_JIT_INPUT_LLVM_BITCODE , HIPRTC_JIT_INPUT_LLVM_BUNDLED_BITCODE and HIPRTC_JIT_INPUT_LLVM_ARCHIVES_OF_BUNDLED_BITCODE are supported currently.</p>
-<p>HIPRTC_JIT_INPUT_LLVM_BITCODE can be used to load both LLVM bitcode or LLVM IR assembly code. However, HIPRTC_JIT_INPUT_LLVM_BUNDLED_BITCODE and HIPRTC_JIT_INPUT_LLVM_ARCHIVES_OF_BUNDLED_BITCODE are only for bundled bitcode and archive of bundled bitcode.</p>
-<pre><code><_Cuda_></code></pre>
-<h2>10.3.3 Backward Compatibility of LLVM Bitcode/IR</h2>
-<p>For HIP applications utilizing HIPRTC to compile LLVM bitcode/IR, compatibility is assured only when the ROCm or HIP SDK version used for generating the LLVM bitcode/IR matches the version used during the runtime compilation. When an application requires the ingestion of bitcode/IR not derived from the currently installed AMD compiler, it must run with HIPRTC and comgr dynamic libraries that are compatible with the version of the bitcode/IR.</p>
-<p>comgr, a shared library, incorporates the LLVM/Clang compiler that HIPRTC relies on. To identify the bitcode/IR version that comgr is compatible with, one can execute 'clang -v' using the clang binary from the same ROCm or HIP SDK package. For instance, if compiling bitcode/IR version 14, the HIPRTC and comgr libraries released by AMD around mid 2022 would be the best choice, assuming the LLVM/Clang version included in the package is also version 14.</p>
-<p>To ensure smooth operation and compatibility, an application may choose to ship the specific versions of HIPRTC and comgr dynamic libraries, or it may opt to clearly specify the version requirements and dependencies. This approach guarantees that the application can correctly compile the specified version of bitcode/IR.</p>
-<h2>10.3.4 Link Options</h2>
-<ul>
-<li style="list-style-type: '· ';">HIPRTC_JIT_IR_TO_ISA_OPT_EXT - AMD Only. Options to be passed on to link step of compiler by hiprtcLinkCreate .</li>
-<li style="list-style-type: '· ';">HIPRTC_JIT_IR_TO_ISA_OPT_COUNT_EXT - AMD Only. Count of options passed on to link step of compiler.</li>
-</ul>
-<p>Example:</p>
-<pre><code>const char* isaopts[] = {"-mllvm", "-inline-threshold=1", "-mllvm", "-inlinehint-
---threshold=1"};
-std::vector<hiprtcJIT_option> jit_options = {HIPRTC_JIT_IR_TO_ISA_OPT_EXT,
-                                                                                                                                                                                                         HIPRTC_JIT_IR_TO_ISA_OPT_COUNT_EXT};
-size_t isaoptssize = 4;
-                                                                                                                                                                                                       (continues on next page)</code></pre>
-<pre><code>        const void* lopts[] = {(void*)isaopts, (void*)(isaoptssize)};
-        hiprtcLinkState linkstate;
-        hiprtcLinkCreate(2, jit_options.data(), (void**)lopts, &linkstate);</code></pre>
-<h2>10.4 Error Handling</h2>
-<p>HIPRTC defines the hiprtcResult enumeration type and a function hiprtcGetErrorString for API call error handling. hiprtcResult enum defines the API result codes. HIPRTC APIs return hiprtcResult to indicate the call result. hiprtcGetErrorString function returns a string describing the given hiprtcResult code, e.g., HIPRTC_SUCCESS to 'HIPRTC_SUCCESS'. For unrecognized enumeration values, it returns 'Invalid HIPRTC error code'.</p>
-<p>hiprtcResult enum supported values and the hiprtcGetErrorString usage are mentioned below.</p>
-<pre><code><_Python_></code></pre>
-<pre><code>hiprtcResult result;
-result = hiprtcCompileProgram(prog, 1, opts);
-if (result!= HIPRTC_SUCCESS) {
-std::cout << "hiprtcCompileProgram fails with error " << hiprtcGetErrorString(result);
-}</code></pre>
-<h2>10.5 HIPRTC General APIs</h2>
-<p>HIPRTC provides the following API for querying the version.</p>
-<p>hiprtcVersion(int* major, int* minor) - This sets the output parameters major and minor with the HIP Runtime compilation major version and minor version number respectively.</p>
-<p>Currently, it returns hardcoded value. This should be implemented to return HIP runtime major and minor version in the future releases.</p>
-<p>(continued from previous page)</p>
-<h2>10.6 Lowered Names (Mangled Names)</h2>
-<p>HIPRTC mangles the __global__ function names and names of __device__ and __constant__ variables. If the generated binary is being loaded using the HIP Runtime API, the kernel function or __device__/__constant__ variable must be looked up by name, but this is very hard when the name has been mangled. To overcome this, HIPRTC provides API functions that map __global__ function or __device__/__constant__ variable names in the source to the mangled names present in the generated binary.</p>
-<p>The two APIs hiprtcAddNameExpression and hiprtcGetLoweredName provide this functionality. First, a 'name expression' string denoting the address for the __global__ function or __device__/__constant__ variable is provided to hiprtcAddNameExpression . Then, the program is compiled with hiprtcCompileProgram . During compilation, HIPRTC will parse the name expression string as a C++ constant expression at the end of the user program. Finally, the function hiprtcGetLoweredName is called with the original name expression and it returns a pointer to the lowered name. The lowered name can be used to refer to the kernel or variable in the HIP Runtime API.</p>
-<h2>10.6.1 Note</h2>
-<ul>
-<li style="list-style-type: '· ';">The identical name expression string must be provided on a subsequent call to hiprtcGetLoweredName to extract the lowered name.</li>
-<li style="list-style-type: '· ';">The correct sequence of calls is : hiprtcAddNameExpression , hiprtcCompileProgram , hiprtcGetLoweredName , hiprtcDestroyProgram .</li>
-<li style="list-style-type: '· ';">The lowered names must be fetched using hiprtcGetLoweredName only after the HIPRTC program has been compiled, and before it has been destroyed.</li>
-</ul>
-<h2>10.6.2 Example</h2>
-<p>kernel containing various definitions __global__ functions/function templates and __device__/__constant__ variables can be stored in a string.</p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-        static constexpr const char gpu_program[] {</code></pre>
-<p>hiprtcAddNameExpression is called with various name expressions referring to the address of __global__ functions and __device__/__constant__ variables.</p>
-<pre><code>kernel_name_vec.push_back("&f1");
-kernel_name_vec.push_back("N1::N2::f2");
-kernel_name_vec.push_back("f3<int>");
-for (auto&& x : kernel_name_vec) hiprtcAddNameExpression(prog, x.c_str());
-variable_name_vec.push_back("&V1");</code></pre>
-<p>(continues on next page)</p>
-<p>(continued from previous page)</p>
-<pre><code>auto&& x : variable_name_vec) hiprtcAddNameExpression(prog, x.c_str());</code></pre>
-<pre><code>        | variable_name_vec.push_back("&N1::N2::V2");
-        for (auto&& x : variable_name_vec) hiprtcAddNameExp</code></pre>
-<p>After which, the program is compiled using hiprtcCompileProgram and the generated binary is loaded using hipModuleLoadData . And the mangled names can be fetched using hirtcGetLoweredName .</p>
-<pre><code>for (decltype(variable_name_vec.size()) i = 0; i!= variable_name_vec.size(); ++i) {
-  const char* name;
-  hiprtcGetLoweredName(prog, variable_name_vec[i].c_str(), &name);
-}</code></pre>
-<pre><code>    for (decltype(kernel_name_vec.size()) i = 0; i!= kernel_name_vec.size(); ++i) {
-      const char* name;
-      hiprtcGetLoweredName(prog, kernel_name_vec[i].c_str(), &name);
-    }</code></pre>
-<p>The mangled name of the variables are used to look up the variable in the module and update its value.</p>
-<pre><code>        hipDeviceptr_t variable_addr;
-        size_t bytes{};
-        hipModuleGetGlobal(&variable_addr, &bytes, module, name);
-        hipMemcpyHtoD(variable_addr, &initial_value, sizeof(initial_value));</code></pre>
-<p>Finally, the mangled name of the kernel is used to launch it using the hipModule APIs.</p>
-<pre><code>        hipFunction_t kernel;
-        hipModuleGetFunction(&kernel, module, name);
-        hipModuleLaunchKernel(kernel, 1, 1, 1, 1, 1, 0, nullptr, nullptr, config);</code></pre>
-<p>Please have a look at hiprtcGetLoweredName.cpp for the detailed example.</p>
-<h2>10.7 Versioning</h2>
-<p>HIPRTC follows the below versioning.</p>
-<ul>
-<li style="list-style-type: '· ';">Linux</li>
-<li>-HIPRTC follows the same versioning as HIP runtime library.</li>
-<li>-The so name field for the shared library is set to MAJOR version. For example, for HIP 5.3 the so name is set to 5 ( hiprtc.so.5 ).</li>
-<li style="list-style-type: '• ';">Windows</li>
-<li>-HIPRTC dll is named as hiprtcXXYY.dll where XX is MAJOR version and YY is MINOR version. For example, for HIP 5.3 the name is hiprtc0503.dll .</li>
-</ul>
-<h2>10.8 HIP header support</h2>
-<ul>
-<li style="list-style-type: '· ';">Added HIPRTC support for all the hip common header files such as library_types.h, hip_math_constants.h, hip_complex.h, math_functions.h, surface_types.h etc. from 6.1. HIPRTC users need not include any HIP macros or constants explicitly in their header files. All of these should get included via HIPRTC builtins when the app links to HIPRTC library.</li>
-</ul>
-<h2>10.9 Deprecation notice</h2>
-<ul>
-<li style="list-style-type: '· ';">Currently HIPRTC APIs are separated from HIP APIs and HIPRTC is available as a separate library libhiprtc. so / libhiprtc.dll . But on Linux, HIPRTC symbols are also present in libamdhip64.so in order to support the existing applications. Gradually, these symbols will be removed from HIP library and applications using HIPRTC will be required to explicitly link to HIPRTC library. However, on Windows hiprtc.dll must be used as the amdhip64.dll doesn't contain the HIPRTC symbols.</li>
-<li style="list-style-type: '· ';">Data types such as uint32_t , uint64_t , int32_t , int64_t defined in std namespace in HIPRTC are deprecated earlier and are being removed from ROCm release 6.1 since these can conflict with the standard C++ data types. These data types are now prefixed with __hip__ , e.g. __hip_uint32_t . Applications previously using std::uint32_t or similar types can use __hip_ prefixed types to avoid conflicts with standard std namespace or application can have their own definitions for these types. Also, type_traits templates previously defined in std namespace are moved to __hip_internal namespace as implementation details.</li>
-</ul>
-<h2>CHAPTER</h2>
-<h2>ELEVEN</h2>
-<h2>PERFORMANCE GUIDELINES</h2>
-<p>The AMDHIPPerformance Guidelines are a set of best practices designed to help developers optimize the performance of AMD GPUs. They cover established parallelization and optimization techniques, coding metaphors, and idioms that can greatly simplify programming for HIP-capable GPU architectures.</p>
-<p>By following four main cornerstones, we can exploit the performance optimization potential of HIP.</p>
-<ul>
-<li style="list-style-type: '· ';">parallel execution</li>
-<li style="list-style-type: '· ';">memory usage optimization</li>
-<li style="list-style-type: '· ';">optimization for maximum throughput</li>
-<li style="list-style-type: '· ';">minimizing memory thrashing</li>
-</ul>
-<p>In the following chapters, we will show you their benefits and how to use them effectively.</p>
-<h2>11.1 Parallel execution</h2>
-<p>For optimal use, the application should reveal and efficiently imply as much parallelism as possible to keep all system components active.</p>
-<h2>11.1.1 Application level</h2>
-<p>The application should optimize parallel execution across the host and devices using asynchronous calls and streams. Workloads should be assigned based on efficiency: serial to the host, parallel to the devices.</p>
-<p>For parallel workloads, when threads need to synchronize to share data, if they belong to the same block, they should use __syncthreads() (see: Synchronization functions ) within the same kernel invocation. If they belong to different blocks, they must use global memory with two separate kernel invocations. The latter should be minimized as it adds overhead.</p>
-<h2>11.1.2 Device level</h2>
-<p>Device-level optimization primarily involves maximizing parallel execution across the multiprocessors of the device. This can be achieved by executing multiple kernels concurrently on a device. The management of these kernels is facilitated by streams, which allow for the overlapping of computation and data transfers, enhancing performance. The aim is to keep all multiprocessors busy by executing enough kernels concurrently. However, launching too many kernels can lead to resource contention, so a balance must be found for optimal performance. This approach helps in achieving maximum utilization of the resources of the device.</p>
-<h2>11.1.3 Multiprocessor level</h2>
-<p>Multiprocessor-level optimization involves maximizing parallel execution within each multiprocessor on a device. Each multiprocessor can execute a number of threads concurrently, and the total number of threads that can run in parallel is determined by the number of concurrent threads each multiprocessor can handle.</p>
-<p>The key to multiprocessor-level optimization is to efficiently utilize the various functional units within a multiprocessor. This can be achieved by ensuring a sufficient number of resident warps, as at every instruction issue time, a warp scheduler selects an instruction that is ready to execute. This instruction can be another independent instruction of the same warp, exploiting Optimization for maximum instruction throughput , or more commonly an instruction of another warp, exploiting thread-level parallelism.</p>
-<p>In comparison, device-level optimization focuses on the device as a whole, aiming to keep all multiprocessors busy by executing enough kernels concurrently. Both levels of optimization are crucial for achieving maximum performance. They work together to ensure efficient utilization of the resources of the GPU, from the individual multiprocessors to the device as a whole.</p>
-<h2>11.2 Memory optimization</h2>
-<p>The first step in maximizing memory throughput is to minimize low-bandwidth data transfers. This involves reducing data transfers between the host and the device, as these have lower bandwidth than transfers between global memory and the device.</p>
-<p>Additionally, data transfers between global memory and the device should be minimized by maximizing the use of on-chip memory: shared memory and caches. Shared memory acts as a user-managed cache, where the application explicitly allocates and accesses it. A common programming pattern is to stage data from device memory into shared memory. This involves each thread of a block loading data from device memory to shared memory, synchronizing with all other threads of the block, processing the data in shared memory, synchronizing again if necessary, and writing the results back to device global memory.</p>
-<p>For some applications, a traditional hardware-managed cache is more appropriate to exploit data locality. On devices of certain compute capabilities, the same on-chip memory is used for both L1 and shared memory, and the amount dedicated to each is configurable for each kernel call.</p>
-<p>Finally, the throughput of memory accesses by a kernel can vary significantly depending on the access pattern for each type of memory. Therefore, the next step in maximizing memory throughput is to organize memory accesses as optimally as possible. This is especially important for global memory accesses, as global memory bandwidth is low compared to available on-chip bandwidths and arithmetic instruction throughput. Thus, non-optimal global memory accesses generally have a high impact on performance.</p>
-<h2>11.2.1 Data Transfer</h2>
-<p>Applications should aim to minimize data transfers between the host and the device. This can be achieved by moving more computations from the host to the device, even if it means running kernels that do not fully utilize the parallelism for device. Intermediate data structures can be created, used, and discarded in device memory without being mapped or copied to host memory.</p>
-<p>Batching small transfers into a single large transfer can improve performance due to the overhead associated with each transfer. On systems with a front-side bus, using page-locked host memory can enhance data transfer performance.</p>
-<p>When using mapped page-locked memory, there is no need to allocate device memory or explicitly copy data between device and host memory. Data transfers occur implicitly each time the kernel accesses the mapped memory. For optimal performance, these memory accesses should be coalesced, similar to global memory accesses.</p>
-<p>On integrated systems where device and host memory are physically the same, any copy operation between host and device memory is unnecessary, and mapped page-locked memory should be used instead. Applications can check if a device is integrated by querying the integrated device property.</p>
-<h2>11.2.2 Device Memory Access</h2>
-<p>Memory access instructions may be repeated due to the spread of memory addresses across warp threads. The impact on throughput varies with memory type and is generally reduced when addresses are more scattered, especially in global memory.</p>
-<p>Device memory is accessed via 32-, 64-, or 128-byte transactions that must be naturally aligned. Maximizing memory throughput involves coalescing memory accesses of threads within a warp into minimal transactions, following optimal access patterns, using properly sized and aligned data types, and padding data when necessary.</p>
-<p>Global memory instructions support reading or writing data of specific sizes (1, 2, 4, 8, or 16 bytes) that are naturally aligned. If the size and alignment requirements are not met, it leads to multiple instructions, reducing performance. Therefore, using data types that meet these requirements, ensuring alignment for structures, and maintaining alignment for all values or arrays is crucial for correct results and optimal performance.</p>
-<p>Threads often access 2D arrays at an address calculated as BaseAddress + xIndex + width * yIndex . For efficient memory access, the array and thread block widths should be multiples of the warp size. If the array width is not a multiple of the warp size, it is usually more efficient to allocate it with a width rounded up to the nearest multiple and pad the rows accordingly.</p>
-<p>Local memory is used for certain automatic variables, such as arrays with non-constant indices, large structures or arrays, and any variable when the kernel uses more registers than available. Local memory resides in device memory, leading to high latency and low bandwidth similar to global memory accesses. However, it is organized for consecutive 32-bit words to be accessed by consecutive thread IDs, allowing full coalescing when all threads in a warp access the same relative address.</p>
-<p>Shared memory, located on-chip, provides higher bandwidth and lower latency than local or global memory. It is divided into banks that can be simultaneously accessed, boosting bandwidth. However, bank conflicts, where two addresses fall in the same bank, lead to serialized access and decreased throughput. Therefore, understanding how memory addresses map to banks and scheduling requests to minimize conflicts is crucial for optimal performance.</p>
-<p>Constant memory is in device memory and cached in the constant cache. Requests are split based on different memory addresses, affecting throughput, and are serviced at the throughput of the constant cache for cache hits, or the throughput of the device memory otherwise.</p>
-<p>Texture and surface memory are stored in device memory and cached in texture cache. This setup optimizes 2D spatial locality, leading to better performance for threads reading close 2D addresses. Reading device memory through texture or surface fetching can be advantageous, offering higher bandwidth for local texture fetches or surface reads, offloading addressing calculations, allowing data broadcasting, and optional conversion of 8-bit and 16-bit integer input data to 32-bit floating-point values on-the-fly.</p>
-<h2>11.3 Optimization for maximum instruction throughput</h2>
-<p>To maximize instruction throughput:</p>
-<ul>
-<li style="list-style-type: '· ';">minimize low throughput arithmetic instructions</li>
-<li style="list-style-type: '· ';">minimize divergent warps inflicted by control flow instructions</li>
-<li style="list-style-type: '· ';">minimize the number of instruction as possible</li>
-<li style="list-style-type: '· ';">maximize instruction parallelism</li>
-</ul>
-<h2>11.3.1 Arithmetic instructions</h2>
-<p>The type and complexity of arithmetic operations can significantly impact the performance of your application. We are highlighting some hints how to maximize it.</p>
-<p>Using efficient operations: Some arithmetic operations are more costly than others. For example, multiplication is typically faster than division, and integer operations are usually faster than floating-point operations, especially with double-precision.</p>
-<p>Minimizing low-throughput instructions: This might involve trading precision for speed when it does not affect the final result. For instance, consider using single-precision arithmetic instead of double-precision.</p>
-<p>Leverage intrinsic functions: Intrinsic functions are pre-defined functions available in HIP that can often be executed faster than equivalent arithmetic operations (subject to some input or accuracy restrictions). They can help optimize performance by replacing more complex arithmetic operations.</p>
-<p>Avoiding divergent warps: Divergent warps occur when threads within the same warp follow different execution paths. This can happen due to conditional statements that lead to different arithmetic operations being performed by different threads. Divergent warps can significantly reduce instruction throughput, so try to structure your code to minimize divergence.</p>
-<p>Optimizing memory access: The efficiency of memory access can impact the speed of arithmetic operations. Coalesced memory access, where threads in a warp access consecutive memory locations, can improve memory throughput and thus the speed of arithmetic operations.</p>
-<p>Maximizing instruction parallelism: Some GPU architectures could issue parallel independent instructions simultaneously, for example integer and floating point, or two operations with independent inputs and outputs. Mostly this is a work for compiler, but expressing parallelism in the code explicitly can improve instructions throughput.</p>
-<h2>11.3.2 Control flow instructions</h2>
-<p>Flow control instructions ( if , else , for , do , while , break , continue , switch ) can impact instruction throughput by causing threads within a warp to diverge and follow different execution paths. To optimize performance, control conditions should be written to minimize divergent warps. For example, when the control condition depends on ( threadIdx / warpSize ), no warp diverges. The compiler may optimize loops or short if or switch blocks using branch predication, preventing warp divergence. With branch predication, instructions associated with a false predicate are scheduled but not executed, avoiding unnecessary operations.</p>
-<h2>11.3.3 Synchronization</h2>
-<p>Synchronization ensures that all threads within a block have completed their computations and memory accesses before moving forward, which is critical when threads are dependent on the results of other threads. However, synchronization can also lead to performance overhead, as it requires threads to wait, potentially leading to idle GPU resources.</p>
-<p>__syncthreads() is used to synchronize all threads in a block, ensuring that all threads have reached the same point in the code and that shared memory is visible to all threads after the point of synchronization.</p>
-<p>An alternative way to synchronize is using streams. Different streams can execute commands out of order with respect to one another or concurrently. This allows for more fine-grained control over the execution order of commands, which can be beneficial in certain scenarios.</p>
-<h2>11.4 Minimizing memory thrashing</h2>
-<p>Applications frequently allocating and freeing memory may experience slower allocation calls over time. This is expected as memory is released back to the operating system. To optimize performance in such scenarios, consider some recommendations:</p>
-<ul>
-<li style="list-style-type: '· ';">avoid allocating all available memory with hipMalloc / hipHostMalloc , as this immediately reserves memory and can block other applications from using it. This could strain the operating system schedulers or even prevent other applications from running on the same GPU.</li>
-<li style="list-style-type: '· ';">aim to allocate memory in suitably sized blocks early in the lifecycle of the application and deallocate only when the application no longer needs it. Minimize the number of hipMalloc and hipFree calls in your application, particularly in areas critical to performance.</li>
-<li style="list-style-type: '· ';">if an application is unable to allocate sufficient device memory, consider resorting to other memory types such as hipHostMalloc or hipMallocManaged . While these may not offer the same performance, they can allow the application to continue running.</li>
-<li style="list-style-type: '· ';">For supported platforms, hipMallocManaged allows for oversubscription. With the right memory advise policies, it can maintain most, if not all, of the performance of hipMalloc . hipMallocManaged does not require an allocation to be resident until it is needed or prefetched, easing the load on the operating system schedulers and facilitating multi-tenant scenarios.</li>
-</ul>
-<p>CHAPTER</p>
-<h2>TWELVE</h2>
-<h2>DEBUGGING WITH HIP</h2>
-<p>AMDdebugging tools include ltrace and ROCgdb . External tools are available and can be found online. For example, if you're using Windows, you can use Microsoft Visual Studio and WinGDB .</p>
-<p>You can trace and debug your code using the following tools and techniques.</p>
-<h2>12.1 Tracing</h2>
-<p>You can use tracing to quickly observe the flow of an application before reviewing the detailed information provided by a command-line debugger. Tracing can be used to identify issues ranging from accidental API calls to calls made on a critical path.</p>
-<p>ltrace is a standard Linux tool that provides a message to stderr on every dynamic library call. You can use ltrace to visualize the runtime behavior of the entire ROCm software stack.</p>
-<p>Here's a simple command-line example that uses ltrace to trace HIP APIs and output:</p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?php?^"./hipGetChanDesc
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        </?php?^"
-	                                                                                                                                                                                                     
-		                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       <!
-                                                                                                                                                                                                      
-
-	                                                                                                                                                                                                       <%
-                                                                                                                                                                                                       </%
-                                                                                                                                                                                                      <?>
-                                                                                                                                                                                                       ></code></pre>
-<p>Here's another example that uses ltrace to trace hsa APIs and output:</p>
-<pre><code>        Here's another example that uses ltrace to trace hsa APIs and output:
-        $ ltrace  -C -e "hsa*"./hipGetChanDesc
-        libamdhip64.so.4->hsa_init(0, 0x7fff325a69d0, 0x9c80e0, 0 <unfinished...>
-        libhsa-runtime64.so.1->hsaKmtOpenKFD(0x7fff325a6590, 0x9c38c0, 0, 1) = 0
-        libhsa-runtime64.so.1->hsaKmtGetVersion(0x7fff325a6608, 0, 0, 0) = 0
-        libhsa-runtime64.so.1->hsaKmtReleaseSystemProperties(3, 0x80084b01, 0, 0) = 0
-        libhsa-runtime64.so.1->hsaKmtAcquireSystemProperties(0x7fff325a6610, 0, 0, 1) = 0
-        libhsa-runtime64.so.1->hsaKmtGetNodeProperties(0, 0x7fff325a66a0, 0, 0) = 0
-        libhsa-runtime64.so.1->hsaKmtGetNodeMemoryProperties(0, 1, 0x9c42b0, 0x936012) = 0
-       ...
-        <... hsaKmtCreateEvent  resumed> )                                                                                                                                                                                                        
-        libhsa-runtime64.so.1->hsaKmtAllocMemory(0, 4096, 64, 0x7fff325a6690) = 0
-        libhsa-runtime64.so.1->hsaKmtMapMemoryToGPUNodes(0x7f1202749000, 4096, 0x7fff325a6690,,...
-        --0) = 0
-        libhsa-runtime64.so.1->hsaKmtCreateEvent(0x7fff325a6700, 0, 0, 0x7fff325a66f0) = 0
-                                                                                                                                                                                                        (continues on next page)</code></pre>
-<p>(continues on next page)</p>
-<p>(continued from previous page)</p>
-<pre><code>HIP Documentation, Release 6.1.40092</code></pre>
-<h2>12.2 Debugging</h2>
-<p>You can use ROCgdb for debugging and profiling.</p>
-<p>ROCgdbis the ROCm source-level debugger for Linux and is based on GNU Project debugger (GDB). the GNU sourcelevel debugger, equivalent of CUDA-GDB, can be used with debugger frontends, such as Eclipse, Visual Studio Code, or GDB dashboard. For details, see (https://github.com/ROCm/ROCgdb).</p>
-<p>Below is a sample how to use ROCgdb run and debug HIP application, ROCgdb is installed with ROCM package in the folder /opt/rocm/bin.</p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <p>
-                                                                                                                                                                                                       <h1>
-                                                                                                                                                                                                      <p/>
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        </p>
-                                                                                                                                                                                                     <p>
-
-                                                                                                                                                                                                       <a>
-                                                                                                                                                                                                     
- 	                                                                                                                                                                                                       <b>
-                                                                                                                                                                                                      </a>
-                                                                                                                                                                                                     <a>
-
-                                                                                                                                                                                                      <b/>
-                                                                                                                                                                                                      <a/>
-                                                                                                                                                                                                     
-		                                                                                                                                                                                                      
-
-	                                                                                                                                                                                                      <a></b></code></pre>
-<h2>12.2.1 Debugging HIP applications</h2>
-<p>The following Linux example shows how to get useful information from the debugger while running a simple memory copy test, which caused a segmentation fault issue.</p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <p>test, which caused a segmentation fault issue.                                                                                                                                                                                                        </p>                                                                                                                                                                                                        >
-                                                                                                                                                                                                       <a>http://tests/src/runtimeApi/memory/hipMemcpy_simple.cpp:147</code></pre>
-<p>(continues on next page)</p>
-<p>(continued from previous page)</p>
-<pre><code>HIP Documentation, Release 6.1.40092
-
-
-                                                                                                                                                                                                         (continued from previous page)                                                                                                                                                                                                       
-                                                                                                                                                                                                      
-1                                                                                                                                                                                                        "                                                                                                                                                                                                        <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        </----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                    <-----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        >----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                   
-1   //                                                                                                                                                                                                        :                                                                                                                                                                                                        |                                                                                                                                                                                                        -                                                                                                                                                                                                        +                                                                                                                                                                                                        \
-                                                                                                                                                                                                       |
-                                                                                                                                                                                                       <============================================================================================                                                                                                                                                                                                        }                                                                                                                                                                                                        )</code></pre>
-<p>Debugging HIP applications using Windows tools can be more informative than on Linux. Windows tools provides more visibility into debug codes, which makes it easier to inspect variables, watch multiple details, and examine call stacks.</p>
-<h2>12.3 Useful environment variables</h2>
-<p>HIP provides environment variables that allow HIP, hip-clang, or HSA drivers to prevent certain features and optimizations. These are not intended for production, but can be useful to diagnose synchronization problems in the application (or driver).</p>
-<p>Some of the more widely used environment variables are described in this section. These are supported on the Linux ROCm path and Windows.</p>
-<h2>12.3.1 Kernel enqueue serialization</h2>
-<p>You can control kernel command serialization from the host:</p>
-<h2>AMD_SERIALIZE_KERNEL , for serializing kernel enqueue</h2>
-<p>AMD_SERIALIZE_KERNEL = 1 , Wait for completion before enqueue AMD_SERIALIZE_KERNEL = 2 , Wait for completion after enqueue AMD_SERIALIZE_KERNEL = 3 , Both</p>
-<p>Or</p>
-<h2>AMD_SERIALIZE_COPY , for serializing copies</h2>
-<p>AMD_SERIALIZE_COPY = 1 , Wait for completion before enqueue AMD_SERIALIZE_COPY = 2 , Wait for completion after enqueue AMD_SERIALIZE_COPY = 3 , Both</p>
-<p>So HIP runtime can wait for GPU idle before/after any GPU command depending on the environment setting.</p>
-<h2>12.3.2 Making device visible</h2>
-<p>For systems with multiple devices, you can choose to make only certain device(s) visible to HIP using HIP_VISIBLE_DEVICES (or CUDA_VISIBLE_DEVICES on an NVIDIA platform). Once enabled, HIP can only view devices that have indices present in the sequence. For example:</p>
-<pre><code>    | $ HIP_VISIBLE_DEVICES=0,1</code></pre>
-<pre><code><_Python_></code></pre>
-<pre><code>if (totalDeviceNum > 2) {
-setenv("HIP_VISIBLE_DEVICES", "0,1,2", 1);
-assert(getDeviceNumber(false) == 3);
-
-.......
-}</code></pre>
-<h2>12.3.3 Dump code object</h2>
-<p>To analyze compiler-related issues, you can use the dump code object: GPU_DUMP_CODE_OBJECT .</p>
-<h2>12.3.4 HSA-related environment variables (Linux)</h2>
-<p>HSA provides environment variables that help analyze issues in drivers or hardware.</p>
-<ul>
-<li style="list-style-type: '· ';">To isolate issues with hardware copy engines, you can use HSA_ENABLE_SDMA .</li>
-<li>HSA_ENABLE_SDMA=0 causes host-to-device and device-to-host copies to use compute shader blit kernels, rather than the dedicated DMA copy engines. Compute shader copies have low latency (typically &lt; 5 us) and can achieve approximately 80% of the bandwidth of the DMA copy engine.</li>
-<li style="list-style-type: '· ';">To diagnose interrupt storm issues in the driver, you can use HSA_ENABLE_INTERRUPT .</li>
-</ul>
-<p>HSA_ENABLE_INTERRUPT=0 causes completion signals to be detected with memory-based polling, rather than interrupts.</p>
-<h2>12.3.5 HIP environment variable summary</h2>
-<p>Here are some of the more commonly used environment variables:</p>
-<table><tbody><tr><th>Environment variable</th><th>De- fault value</th><th>Usage</th></tr><tr><td>AMD_LOG_LEVEL Enable HIP log on different Level</td><td>0</td><td>0: Disable log. 1: Enable log on error level 2: Enable log on warning and below levels 0x3: Enable log on information and below levels 0x4: Decode and display AQL packets</td></tr><tr><td>AMD_LOG_MASK Enable HIP log on different Level</td><td></td><td>0x7FFFFFFF 0x1: Log API calls 0x02: Kernel and Copy Commands and Barriers 0x4: Synchroniza- tion and waiting for commands to finish 0x8: Enable log on information and below levels 0x20: Queue commands and queue contents 0x40: Signal creation, allocation, pool 0x80: Locks and thread-safety code 0x100: Copy debug 0x200: Detailed copy debug 0x400: Resource allocation, performance-impacting events 0x800: Initialization and shutdown 0x1000: Misc debug, not yet classified 0x2000: Show raw bytes of AQL packet 0x4000: Show code creation debug 0x8000: More detailed command info, including barrier com- mands 0x10000: Log message location 0xFFFFFFFF: Log always even mask flag is zero</td></tr><tr><td>HIP_LAUNCH_BLOCKING Used for serial- ization on kernel execution.</td><td>0</td><td>0: Disable. Kernel executes normally. 1: Enable. Serializes kernel enqueue, behaves the same as AMD_SERIALIZE_KERNEL.</td></tr><tr><td>HIP_VISIBLE_DEVICES (or CUDA_VISIBLE_DEVICES) Only devices whose index is present in the sequence are visible to HIP</td><td></td><td>0,1,2: Depending on the number of devices on the system</td></tr><tr><td>GPU_DUMP_CODE_OBJECT Dump code ob- ject</td><td>0</td><td>0: Disable 1: Enable</td></tr><tr><td>AMD_SERIALIZE_KERNEL Serialize kernel enqueue</td><td>0</td><td>1: Wait for completion before enqueue 2: Wait for completion after enqueue 3: Both</td></tr><tr><td>AMD_SERIALIZE_COPY Serialize copies</td><td>0</td><td>1: Wait for completion before enqueue 2: Wait for completion after enqueue 3: Both</td></tr><tr><td>HIP_HOST_COHERENT Coherent mem-</td><td>0</td><td>0: memory is not coherent between host and GPU 1: memory is coherent with host</td></tr><tr><td>ory in hipHost- Malloc AMD_DIRECT_DISPATCH Enable direct kernel dispatch (Currently for Linux; under development for Windows)</td><td>1</td><td>0: Disable 1: Enable</td></tr><tr><td>GPU_MAX_HW_QUEUES The maximum number of hard- ware queues allocated per device</td><td>4</td><td>The variable controls how many independent hardware queues HIP runtime can create per process, per device. If an application allocates more HIP streams than this number, then HIP runtime reuses the same hardware queues for the new streams in a round-robin manner. Note that this maximum number does not apply to hardware queues that are created for CU-masked HIP streams, or cooperative queues for HIP Cooperative Groups (single queue per device).</td></tr></tbody></table>
-<h2>12.4 General debugging tips</h2>
-<ul>
-<li style="list-style-type: '· ';">gdb --args can be used to pass the executable and arguments to gdb .</li>
-<li style="list-style-type: '· ';">You can set environment variables ( set env ) from within GDB on Linux:</li>
-</ul>
-<pre><code>        | (gdb)  set env  AND_SERIALIZE_KERNEL  3</code></pre>
-<p>Note: This gdb command does not use an equal (=) sign.</p>
-<ul>
-<li style="list-style-type: '· ';">The GDB backtrace shows a path in the runtime. This is because a fault is caught by the runtime, but it is generated by an asynchronous command running on the GPU.</li>
-<li style="list-style-type: '· ';">To determine the true location of a fault, you can force the kernels to run synchronously by setting the environment variables AMD_SERIALIZE_KERNEL=3 and AMD_SERIALIZE_COPY=3 . This forces HIP runtime to wait for the kernel to finish running before returning. If the fault occurs when a kernel is running, you can see the code that launched the kernel inside the backtrace. The thread that's causing the issue is typically the one inside libhsa-runtime64.so .</li>
-<li style="list-style-type: '· ';">VMfaults inside kernels can be caused by:</li>
-<li>-Incorrect code (e.g., a for loop that extends past array boundaries)</li>
-<li>-Memory issues, such as invalid kernel arguments (null pointers, unregistered host pointers, bad pointers)</li>
-<li>-Synchronization issues</li>
-<li>-Compiler issues (incorrect code generation from the compiler)</li>
-<li>-Runtime issues</li>
-</ul>
-<h2>CHAPTER</h2>
-<h2>THIRTEEN</h2>
-<h2>LOGGING HIP ACTIVITY</h2>
-<p>HIP provides a logging mechanism that allows you to trace HIP API and runtime codes when running a HIP application. In addition to being useful to our users/developers, the HIP development team uses these logs to improve the HIP runtime.</p>
-<p>By adjusting the logging settings and logging mask, you can get different types of information for different functionalities, such as HIP APIs, executed kernels, queue commands, and queue contents. Refer to the following sections for examples.</p>
-<p>Tip: Logging works for the release and debug versions of HIP. If you want to save logging output in a file, define the file when running the application via command line. For example:</p>
-<pre><code>            |user@user-test:~/hip/bin$./hipinfo > ~/hipinfo > ~/hip_log.txt</code></pre>
-<h2>13.1 Logging level</h2>
-<p>HIP logging is disabled by default. You can enable it via the AMD_LOG_LEVEL environment variable. The value of this variable controls your logging level. Levels are defined as follows:</p>
-<pre><code>                                                                                                                                                                                                       
-  enum LogLevel {
-      LOG_NONE       = 0,
-      LOG_ERROR     = 1,
-      LOG_WARNING = 2,
-      LOG_INFO       = 3,
-      LOG_DEBUG     = 4
-  };</code></pre>
-<p>Tip: You can call a logging function with different logging levels. All information under the value set for AMD_LOG_LEVEL is printed.</p>
-<h2>13.2 Logging mask</h2>
-<p>The logging mask is designed to print functionality types when you're running a HIP application. Once you set AMD_LOG_LEVEL , the logging mask is set as the default value ( 0x7FFFFFFF ). You can change this to any of the valid values:</p>
-<pre><code>        The logging mask is designed to print functionality types when you're running a HIP application.  Once you set
-        AMD_LOG_LEVEL, the logging mask is set as the default value (0x7FFFFFFF). You can change this to any of the valid
-        values:
-
-        enum LogMask {
-          LOG_API         = 0x000000001,  //!< API call
-          LOG_CMD         = 0x000000002,  //!< Kernel and Copy Commands and Barriers
-          LOG_WAIT        = 0x000000004,  //!< Synchronization and waiting for commands to finish
-          LOG_AQL         = 0x000000008,  //!< Decode and display AQL packets
-          LOG_QUEUE      = 0x00000010,  //!< Queue commands and queue contents
-          LOG_SIG         = 0x00000020,  //!< Signal creation, allocation, pool
-          LOG_LOCK        = 0x00000040,  //!< Locks and thread-safety code.
-          LOG_KERN        = 0x00000080,  //!< kernel creations and arguments, etc.
-          LOG_COPY        = 0x000000100,  //!< Copy debug
-          LOG_COPY2       = 0x000000200,  //!< Detailed copy debug
-          LOG_RESOURCE   = 0x000000400,  //!< Resource allocation, performance-impacting events.
-          LOG_INIT        = 0x00000080,  //!< Initialization and shutdown
-          LOG_MISC        = 0x00001000,  //!< misc debug, not yet classified
-          LOG_AQL2        = 0x00002000,  //!< Show raw bytes of AQL packet
-          LOG_CODE        = 0x00004000,  //!< Show code creation debug
-          LOG_CMD2        = 0x00008000,  //!< More detailed command info, including barrier commands
-          LOG_LOCATION   = 0x00010000,  //!< Log message location
-          LOG_MEM         = 0x0000200000,  //!< Memory allocation
-          LOG_MEM_POOL   = 0x00040000,  //!< Memory pool allocation, including memory in graphs
-          LOG_ALWAYS     = 0xFFFFFFFF,  //!< Log always even mask flag is zero
-        };
-
-        You can also define the logging mask via the AMD_LOG_MASK environment variable.</code></pre>
-<p>You can also define the logging mask via the AMD_LOG_MASK environment variable.</p>
-<h2>13.3 Logging command</h2>
-<p>You can use the following code to print HIP logging information:</p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?                                                                                                                                                                                                        </?                                                                                                                                                                                                       <!                                                                                                                                                                                                        >
-                                                                                                                                                                                                       <&                                                                                                                                                                                                        &
-                                                                                                                                                                                                      
-																																																																																																																																																																																																								                                                                                                                                                                                                       																																																																																																																																																																																																							<?                                                                                                                                                                                                      	                                                                                                                                                                                                      	
-																																																																																																																																																																																																						 																																																																																																																																																																																																						  <?</code></pre>
-<p>Using HIP code, call the ClPrint() function with the desired input variables. For example:</p>
-<pre><code>            |ClPrint(amd::LOG_INFO, amd::LOG_INIT, "Initializing HSA stack.");</code></pre>
-<h2>13.4 Logging examples</h2>
-<p>On Linux , you can enable HIP logging and retrieve logging information when you run hipinfo .</p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <HR>
-                                                                                                                                                                                                       <HIP Documentation, Release 6.1.40092                                                                                                                                                                                                        </HIP Documentation, Release 6.1.40092                                                                                                                                                                                             <HR>
-        Loggging examples                                                                                                                                                                                                        >
-                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       >
-
-                                                                                                                                                                                                       <BR>
-                                                                                                                                                                                                      <BR><BR>
-                                                                                                                                                                                                     <BR>
-
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                       	                                                                                                                                                                                                       <B>
-                                                                                                                                                                                                     
-  <B>
-                                                                                                                                                                                                   <BR>
-  <B>
-                                                                                                                                                                                                  <BR></code></pre>
-<p>(continues on next page)</p>
-<p>(continued from previous page)</p>
-<pre><code>HIP Documentation, Release 6.1.40092</code></pre>
-<p>On Windows , you can set AMD_LOG_LEVEL via environment variable from the advanced system settings or the command prompt (when run as administrator). The following example shows debug log information when calling the backend runtime.</p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <kendo runume.                                                                                                                                                                                                        </kendo>runume.</code></pre>
-<p>(continues on next page)</p>
-<p>(continued from previous page)</p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <![
-                                                                                                                                                                                                       <?xml:%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/.%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/)
-                                                                                                                                                                                                      
-
-                                                                                                                                                                                                      
-
-
-                                                                                                                                                                                                       </?xml:%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazon AWS.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazon AWS.com/.%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazon AWS.com%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/"
-                                                                                                                                                                                                       :
-                                                                                                                                                                                                       >
-                                                                                                                                                                                                      ?xml:%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws,com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws,com%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.</code></pre>
-<p>(continues on next page)</p>
-<p>(continued from previous page)</p>
-<pre><code>  --copyBuffer
-...
-:4:C:\constructicon\builds\gfx\two\22.40\drivers\compute\vdi\device\pal\palmemory.
-  --cpp:206 : 605414523422 us: 29864: [tid:0x9298] Alloc: 100000 bytes,_,
-  --ptr[0000003008D0000-0000003009D0000], obj[0000003007D0000-0000003047D0000]
-:4:C:\constructicon\builds\gfx\two\22.40\drivers\compute\vdi\device\pal\palmemory.
-  --cpp:206 : 605414523767 us: 29864: [tid:0x9298] Alloc: 100000 bytes,_,
-  --ptr[0000003009D0000-000000300AD0000], obj[0000003007D0000-0000003047D0000]
-:3:C:\constructicon\builds\gfx\two\22.40\drivers\compute\hipamd\src\hip_memory.cpp:681 :_,
-  --605414524092 us: 29864: [tid:0x9298] hipMemGetInfo: Returned hipSuccess :
-memInfo.total:                     12.06 GB
-memInfo.free:                     11.93 GB (99%)</code></pre>
-<h2>CHAPTER</h2>
-<h2>FOURTEEN</h2>
-<h2>COOPERATIVE GROUPS</h2>
-<p>Cooperative groups API is an extension to the HIP programming model, which provides developers with a flexible, dynamic grouping mechanism for the communicating threads. Cooperative groups let you define your own set of thread groups which may fit your user-cases better than those defined by the hardware. This lets you specify the level of granularity for thread communication which can lead to more efficient parallel decompositions.</p>
-<p>The API is accessible in the cooperative_groups namespace after the hip_cooperative_groups.h is included. The header contains the following elements:</p>
-<ul>
-<li style="list-style-type: '· ';">Static functions to create groups and subgroups.</li>
-<li style="list-style-type: '· ';">Hardware-accelerated operations over the whole group, like shuffles.</li>
-<li style="list-style-type: '· ';">Data types of cooperative groups.</li>
-<li style="list-style-type: '· ';">Synchronize member function of the groups.</li>
-<li style="list-style-type: '· ';">Get group properties member functions.</li>
-</ul>
-<h2>14.1 Cooperative groups thread model</h2>
-<p>The thread hierarchy abstraction of cooperative groups are in grid hierarchy and block hierarchy .</p>
-<p>Fig. 1: Cooperative group thread hierarchy in grids.</p>
-<p>The multi grid is an abstraction of potentially multiple simultaneous launches of the same kernel over multiple devices (Deprecated since 5.0). The grid in cooperative groups is a single dispatch of kernels for execution like the original grid.</p>
-<p>Note: The ability to synchronize over a grid or multi grid requires the kernel to be launched using the specific cooperative groups API.</p>
-<p>The block is the same as the Inherent thread model block entity.</p>
-<p>Note: Explicit warp-level thread handling is absent from the Cooperative groups API. In order to exploit the known hardware SIMD width on which built-in functionality translates to simpler logic, you can use the group partitioning part of the API, such as tiled_partition .</p>
-<p>Fig. 2: Cooperative group thread hierarchy in blocks.</p>
-<p>The cooperative groups API introduce a new level between block thread and threads. The thread-block tile give the opportunity to have tiles in the thread block, while the coalesced group holds the active threads of the parent group. These groups further discussed in the groups types section.</p>
-<p>For details on memory model, check the memory model description .</p>
-<h2>14.2 Group types</h2>
-<p>Group types are based on the levels of synchronization and data sharing among threads.</p>
-<h2>14.2.1 Thread-block group</h2>
-<p>Represents an intra-block cooperative groups type where the participating threads within the group are the same threads that participated in the currently executing block .</p>
-<pre><code>    class thread_block;
-
-    Constructed via:
-
-    thread_block g = this_thread_block();</code></pre>
-<p>The group_index() , thread_index() , thread_rank() , size() , cg_type() , is_valid() , sync() and group_dim() member functions are public of the thread_block class. For further details, check the thread_block references .</p>
-<h2>14.2.2 Grid group</h2>
-<p>Represents an inter-block cooperative groups type where the group's participating threads span multiple blocks running the same kernel on the same device. Use the cooperative launch API to enable synchronization across the grid group.</p>
-<pre><code>class grid_group;
-
- Constructed via:
-
-grid_group g = this_grid();</code></pre>
-<p>The thread_rank() , size() , cg_type() , is_valid() and sync() member functions are public of the grid_group class. For further details, check the grid_group references .</p>
-<h2>14.2.3 Multi-grid group</h2>
-<p>Represents an inter-device cooperative groups type where the participating threads within the group span multiple devices that run the same kernel on the devices. Use the cooperative launch API to enable synchronization across the multi-grid group.</p>
-<pre><code>    |class multi_grid_group;</code></pre>
-<pre><code>;</code></pre>
-<p>Constructed via:</p>
-<pre><code><_C_></code></pre>
-<pre><code><_YAML_></code></pre>
-<p>The num_grids() , grid_rank() , thread_rank() , size() , cg_type() , is_valid() , and sync() member functions are public of the multi_grid_group class. For further details check the multi_grid_group references .</p>
-<h2>14.2.4 Thread-block tile</h2>
-<p>This constructs a templated class derived from thread_group . The template defines the tile size of the new thread group at compile time. This group type also supports sub-wave level intrinsics.</p>
-<pre><code><_C++_></code></pre>
-<p>Constructed via:</p>
-<pre><code><_SQL_></code></pre>
-<h2>Note:</h2>
-<ul>
-<li style="list-style-type: '· ';">Size must be a power of 2 and not larger than warp (wavefront) size.</li>
-<li style="list-style-type: '· ';">shfl() functions support integer or float type.</li>
-</ul>
-<p>The thread_rank() , size() , cg_type() , is_valid() , sync() , meta_group_rank() , meta_group_size() , shfl() , shfl_down() , shfl_up() , shfl_xor() , ballot() , any() , all() , match_any() and match_all() member functions are public of the thread_block_tile class. For further details, check the thread_block_tile references .</p>
-<h2>14.2.5 Coalesced groups</h2>
-<p>Threads (64 threads on CDNA and 32 threads on RDNA) in a warp cannot execute different instructions simultaneously, so conditional branches are executed serially within the warp. When threads encounter a conditional branch, they can diverge, resulting in some threads being disabled, if they do not meet the condition to execute that branch. The active threads referred as coalesced, and coalesced group represents an active thread group within a warp.</p>
-<p>Note: The NVIDIA GPU's independent thread scheduling presents the appearance that threads on different branches execute concurrently.</p>
-<p>Warning: AMD GPUs do not support independent thread scheduling. Some CUDA application can rely on this feature and the ported HIP version on AMD GPUs can deadlock, when they try to make use of independent thread scheduling.</p>
-<p>This group type also supports sub-wave level intrinsics.</p>
-<pre><code>    | class coalesced_group;</code></pre>
-<p>Constructed via:</p>
-<p>coalesced_group</p>
-<pre><code>    |roup active  = coalesced_threads() ;</code></pre>
-<p>Note: shfl() functions support integer or float type.</p>
-<p>The thread_rank() , size() , cg_type() , is_valid() , sync() , meta_group_rank() , meta_group_size() , shfl() , shfl_down() , shfl_up() , ballot() , any() , all() , match_any() and match_all() member functions are public of the coalesced_group class. For more information, see coalesced_group references .</p>
-<h2>14.3 Cooperative groups simple example</h2>
-<p>The difference to the original block model in the reduce_sum device function is the following.</p>
-<h2>Original Block</h2>
-<pre><code><_Cuda_></code></pre>
-<h2>Cooperative groups</h2>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        // Thread ID
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        /                                                                                                                                                                                                        *                                                                                                                                                                                                        /*                                                                                                                                                                                                        */
-                                                                                                                                                                                                       */</code></pre>
-<p>(continues on next page)</p>
-<p>(continued from previous page)</p>
-<pre><code>      for(unsigned int i = g.size() / 2; i > 0; i /= 2) {
-          // Store value in shared memory with thread ID
-          shared[group_thread_id] = val;
-
-          // Synchronize all threads in the group
-          g.sync();
-
-          // Active thread sum up
-          if(group_thread_id < i)
-               val += shared[group_thread_id + i];
-
-          // Synchronize all threads in the group
-          g.sync();
-      }
-
-      //...
-}
-
-The reduce_sum() function call and input data initialization difference to the origin.</code></pre>
-<p>The reduce_sum() function call and input data initialization difference to the original block model is the following.</p>
-<h2>Original Block</h2>
-<pre><code>Original Block
-
-__global__ void sum_kernel(...) {
-
-    //...
-
-    // Workspace array in shared memory
-    __shared__ unsigned int workspace[2048];
-
-    //...
-
-    // Perform reduction
-    output = reduce_sum(workspace, input);
-
-    //...
-}</code></pre>
-<h2>Cooperative groups</h2>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        //                                                                                                                                                                                                        const auto                                                                                                                                                                                                        }                                                                                                                                                                                                        /*                                                                                                                                                                                                        */                                                                                                                                                                                                        *</code></pre>
-<p>(continued from previous page)</p>
-<pre><code>    thread_block thread_block_group = this_thread_block();
-    // Perform reduction
-    output = reduce_sum(thread_block_group, workspace, input);
-
-    //...
-}</code></pre>
-<p>At the device function, the input group type is the thread_group , which is the parent class of all the cooperative groups type. With this, you can write generic functions, which can work with any type of cooperative groups.</p>
-<h2>14.4 Synchronization</h2>
-<p>With each group type, the synchronization requires using the correct cooperative groups launch API.</p>
-<h2>Check the kernel launch capability</h2>
-<h2>Thread-block</h2>
-<p>Do not need kernel launch validation.</p>
-<h2>Grid</h2>
-<p>Confirm the cooperative launch capability on the single AMD GPU:</p>
-<pre><code>    Confirm the cooperative launch capability on the single AMD GPU:
-
-    int device                       = 0;
-    int supports_coop_launch = 0;
-    // Check support
-    // Use hipDeviceAttributeCooperativeMultiDeviceLaunch when launching across multiple_
-    --devices
-    HIP_CHECK(hipGetDevice(&device));
-    HIP_CHECK(
-        hipDeviceGetAttribute(&supports_coop_launch, hipDeviceAttributeCooperativeLaunch,\
-    --device));
-    if(!supports_coop_launch)
-    {
-        std::cout << "Skipping, device " << device << " does not support cooperative groups"
-                       << std::endl;
-        return 0;
-    }</code></pre>
-<h2>Multi-grid</h2>
-<p>Confirm the cooperative launch capability over multiple GPUs:</p>
-<pre><code>    Multi-grid
-
-    Confirm the cooperative launch capability over multiple GPUs:
-
-    // Check support of cooperative groups
-    std::vector<int> deviceIDs;
-    for(int deviceID = 0; deviceID < device_count; deviceID++) {
-    #ifdef __HIP_PLATFORM_AMD__
-        int supports_coop_launch = 0;
-        HIP_CHECK(
-            hipDeviceGetAttribute(
-                &supports_coop_launch,
-                hipDeviceAttributeCooperativeMultiDeviceLaunch,
-                deviceID));
-        if(!supports_coop_launch) {
-            std::cout << "Skipping, device " << deviceID << " does not support cooperative_
-    --groups"
-                        << std::endl;
-        }
-        else
-    #endif
-        {
-            std::cout << deviceID << std::endl;
-            // Collect valid deviceIDs.
-            deviceIDs.push_back(deviceID);
-        }
-    }
-
-    Kernel launch
-
-    __   ...  .</code></pre>
-<h2>Kernel launch</h2>
-<h2>Thread-block</h2>
-<p>You can access the new block representation using the original kernel launch methods.</p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        // Launching kernel  from host.</code></pre>
-<h2>Grid</h2>
-<p>Launch the cooperative kernel on a single GPU:</p>
-<pre><code><_C_></code></pre>
-<h2>Multi-grid</h2>
-<p>Launch the cooperative kernel over multiple GPUs:</p>
-<pre><code>    Multi-grid
-
-    Launch the cooperative kernel over multiple GPUs:
-
-    hipLaunchParams *launchParamsList = (hipLaunchParams*)malloc(sizeof(hipLaunchParams) *_
-    --deviceIDs.size());
-    for(int deviceID : deviceIDs) {
-
-        // Set device
-        HIP_CHECK(hipSetDevice(deviceID));
-
-        // Create stream
-        hipStream_t stream;
-        HIP_CHECK(hipStreamCreate(&stream));
-
-        // Parameters
-        void* params[] = {&(d_vector[deviceID]), &(d_block_reduced[deviceID]), &(d_partition_
-    --reduced[deviceID])};
-
-        // Set launchParams
-        launchParamsList[deviceID].func = (void*)vector_reduce_kernel<partition_size>;
-        launchParamsList[deviceID].gridDim = dim3(1);
-        launchParamsList[deviceID].blockDim = dim3(threads_per_block);
-        launchParamsList[deviceID].sharedMem = 0;
-        launchParamsList[deviceID].stream = stream;
-        launchParamsList[deviceID].args = params;
-    }
-
-    HIP_CHECK(hipLaunchCooperativeKernelMultiDevice(launchParamsList,
-                                                                                                                                                                                                         (int)deviceIDs.size(),
-                                                                                                                                                                                                       )
-    --hipCooperativeLaunchMultiDeviceNoPreSync));
-
-    Device side synchronization</code></pre>
-<p>Device side synchronization</p>
-<h2>Thread-block</h2>
-<p>The device side code of the thread_block synchronization over single GPUs:</p>
-<pre><code><_C_></code></pre>
-<h2>Grid</h2>
-<p>The device side code of the grid synchronization over single GPUs:</p>
-<pre><code><_Cython_></code></pre>
-<pre><code>  =  this._grid() ;</code></pre>
-<h2>Multi-grid</h2>
-<p>The device side code of the multi-grid synchronization over multiple GPUs:</p>
-<pre><code>            |multi_grid_group multi_grid = this_multi_grid();</code></pre>
-<pre><code>|multi_grid.sync();</code></pre>
-<h2>14.5 Unsupported NVIDIA CUDA features</h2>
-<p>HIP doesn't support the following NVIDIA CUDA optional headers:</p>
-<ul>
-<li style="list-style-type: '· ';">cooperative_groups/memcpy_async.h</li>
-<li style="list-style-type: '· ';">cooperative_groups/reduce.h</li>
-<li style="list-style-type: '· ';">cooperative_groups/scan.h</li>
-</ul>
-<p>HIP doesn't support the following CUDA class in cooperative_groups namespace:</p>
-<ul>
-<li style="list-style-type: '· ';">cluster_group</li>
-</ul>
-<p>HIP doesn't support the following CUDA functions/operators in cooperative_groups namespace:</p>
-<ul>
-<li style="list-style-type: '· ';">synchronize</li>
-<li style="list-style-type: '· ';">memcpy_async</li>
-<li style="list-style-type: '· ';">wait and wait_prior</li>
-<li style="list-style-type: '· ';">barrier_arrive and barrier_wait</li>
-<li style="list-style-type: '· ';">invoke_one and invoke_one_broadcast</li>
-<li style="list-style-type: '· ';">reduce</li>
-<li style="list-style-type: '· ';">reduce_update_async and reduce_store_async</li>
-<li style="list-style-type: '· ';">Reduce operators plus , less , greater , bit_and , bit_xor and bit_or</li>
-<li style="list-style-type: '· ';">inclusive_scan and exclusive_scan</li>
-</ul>
-<h2>CHAPTER</h2>
-<h2>FIFTEEN</h2>
-<h2>UNIFIED MEMORY</h2>
-<p>In conventional architectures, CPUs and GPUs have dedicated memory like Random Access Memory (RAM) and Video Random Access Memory (VRAM). This architectural design, while effective, can be limiting in terms of memory capacity and bandwidth, as continuous memory copying is required to allow the processors to access the appropriate data. New architectural features like Heterogeneous System Architectures (HSA) and Unified Memory (UM) help avoid these limitations and promise increased efficiency and innovation.</p>
-<h2>15.1 Unified memory</h2>
-<p>Unified Memory is a single memory address space accessible from any processor within a system. This setup simplifies memory management processes and enables applications to allocate data that can be read or written by code running on either CPUs or GPUs. The Unified memory model is shown in the following figure.</p>
-<p>AMD Accelerated Processing Unit (APU) is a typical example of a Unified Memory Architecture. On a single die, a central processing unit (CPU) is combined with an integrated graphics processing unit (iGPU), and both have access to a high-bandwidth memory (HBM) module named Unified Memory. The CPU enables high-performance, low-latency operations, while the GPU is optimized for high throughput (data processed by unit time).</p>
-<h2>15.2 System requirements</h2>
-<p>Unified memory is supported on Linux by all modern AMD GPUs from the Vega series onward. Unified memory management can be achieved with managed memory allocation and, for the latest GPUs, with a system allocator.</p>
-<p>The table below lists the supported allocators. The allocators are described in the next section.</p>
-<table><caption><div class="caption">Table 1: Supported Unified Memory Allocators</div></caption><tbody><tr><th>Architecture</th><th>hipMallocManaged()</th><th>__managed__</th><th>malloc()</th></tr><tr><td>MI200, MI300 Series</td><td></td><td></td><td>1</td></tr><tr><td>MI100</td><td></td><td></td><td></td></tr><tr><td>RDNA (Navi) Series</td><td></td><td></td><td></td></tr><tr><td>GCN5 (Vega) Series</td><td></td><td></td><td></td></tr></tbody></table>
-<h2>: Supported</h2>
-<ul>
-<li>: Unsupported</li>
-</ul>
-<p>1 Works only with XNACK=1 . First GPU access causes recoverable page-fault. For more details, visit GPU memory.</p>
-<h2>15.3 Unified memory programming models</h2>
-<p>Showcasing various unified memory programming models, the model availability depends on your architecture. For more information, see System requirements and Checking unified memory management support .</p>
-<ul>
-<li style="list-style-type: '· ';">HIP managed memory allocation API :</li>
-</ul>
-<p>The hipMallocManaged() is a dynamic memory allocator available on all GPUs with unified memory support. For more details, visit HIP managed memory allocation API .</p>
-<ul>
-<li style="list-style-type: '· ';">HIP managed variables :</li>
-</ul>
-<p>The __managed__ declaration specifier, which serves as its counterpart, is supported on all modern AMD cards and can be utilized for static allocation.</p>
-<ul>
-<li style="list-style-type: '· ';">System allocation API :</li>
-</ul>
-<p>Starting with the AMD MI300 series, the malloc() system allocator allows you to reserve unified memory. The system allocator is more versatile and offers an easy transition from a CPU written C++ code to a HIP code as the same system allocation API is used.</p>
-<h2>15.3.1 Checking unified memory management support</h2>
-<p>Some device attributes can offer information about which Unified memory programming models are supported. The attribute value is 1 if the functionality is supported, and 0 if it is not supported.</p>
-<table><caption><div class="caption">Table 2: Device attributes for unified memory management</div></caption><tbody><tr><th>attribute description</th></tr><tr><td>hipDeviceAttributeManagedMemory unified addressing is supported</td></tr><tr><td>hipDeviceAttributeConcurrentManagedAccess full managed memory support, concurrent access is supported</td></tr><tr><td>hipDeviceAttributePageableMemoryAccess both managed and system memory allocation API is supported</td></tr></tbody></table>
-<p>The following examples show how to use device attributes:</p>
-<pre><code>
-
-#include <hip/hip_runtime.h>
-#include <iostream>
-
-int main()  {
-        int d;
-        hipGetDevice(&d);
-
-        int  is_cma = 0;
-        hipDeviceGetAttribute(&is_cma, hipDeviceAttributeConcurrentManagedAccess, d);
-        std::cout << "HIP Managed Memory: "
-                       << (is_cma == 1? "is" : "NOT")
-                        << " " supported" << std::endl;
-        return 0;
-}</code></pre>
-<h2>15.3.2 Example for unified memory management</h2>
-<p>The following example shows how to use unified memory management with hipMallocManaged() , function, with __managed__ attribute for static allocation and standard malloc() allocation. For comparison, the Explicit Memory Management example is presented in the last tab.</p>
-<h2>hipMallocManaged()</h2>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        //                                                                                                                                                                                                        }                                                                                                                                                                                                        */
-                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       //
-                                                                                                                                                                                                      
-
-
-                                                                                                                                                                                                       }
-                                                                                                                                                                                                       */</code></pre>
-<p>__managed__</p>
-<pre><code>__managed__
-
-#include <hip/hip_runtime.h>
-#include <iostream>
-
-// Addition of two values.
-__global__ void add(int *a, int *b, int *c) {
-    *c = *a + *b;
-}
-
-// Declare a, b and c as static variables.
-__managed__ int a, b, c;
-
-int main() {
-    // Setup input values.
-    a = 1;
-    b = 2;
-
-    // Launch add() kernel on GPU.
-    hipLaunchKernelGGL(add, dim3(1), dim3(1), 0, 0, &a, &b, &c);
-
-    // Wait for GPU to finish before accessing on host.
-    hipDeviceSynchronize();
-
-    // Prints the result.
-    std::cout << a << " + " << b << " = " << c << std::endl;
-
-    return 0;
-}
-
-
-malloc()</code></pre>
-<h2>malloc()</h2>
-<pre><code>malloc()
-
-#include <hip/hip_runtime.h>
-#include <iostream>
-
-// Addition of two values.
-__global__ void add(int* a, int* b, int* c) {
-    *c = *a + *b;
-}
-
-int main() {
-    int* a, * b, * c;
-
-    // Allocate memory for a, b, and c.
-    a = (int*)malloc(sizeof(*a));
-    b = (int*)malloc(sizeof(*b));
-    c = (int*)malloc(sizeof(*c));
-
-    // Setup input values.
-    *a = 1;
-    *b = 2;</code></pre>
-<p>(continues on next page)</p>
-<p>(continued from previous page)</p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-        // Launch add() kernel on GPU.
-        hipLaunchKernelGGL(add, dim3(1), dim3(1), 0, 0, a, b, c);
-
-        // Wait for GPU to finish before accessing on host.
-        hipDeviceSynchronize();
-
-        // Prints the result.
-        std::cout << *a << " + " << *b << " = " << *c << std::endl;
-
-        // Cleanup allocated memory.
-        free(a);
-        free(b);
-        free(c);
-
-        return 0;
-    }</code></pre>
-<pre><code>        tree<J;
-
-        return 0;
-    }
-
-
-    Explicit Memory Management
-
-    #include <hip/hip_runtime.h>
-    #include <iostream>
-
-    // Addition of two values.
-    __global__ void add(int *a, int *b, int *c) {
-        *c = *a + *b;
-    }
-
-    int main() {
-        int a, b, c;
-        int *d_a, *d_b, *d_c;
-
-        // Setup input values.
-        a = 1;
-        b = 2;
-
-        // Allocate device copies of a, b and c.
-        hipMalloc(&d_a, sizeof(*d_a));
-        hipMalloc(&d_b, sizeof(*d_b));
-        hipMalloc(&d_c, sizeof(*d_c));
-
-        // Copy input values to device.
-        hipMemcpy(d_a, &a, sizeof(*d_a), hipMemcpyHostToDevice);
-        hipMemcpy(d_b, &b, sizeof(*d_b), hipMemcpyHostToDevice);
-
-        // Launch add() kernel on GPU.
-        hipLaunchKernelGGL(add, dim3(1), dim3(1), 0, 0, d_a, d_b, d_c);
-
-        // Copy the result back to the host.
-        hipMemcpy(&c, d_c, sizeof(*d_c), hipMemcpyDeviceToHost);
-                                                                                                                                                                                                         (continues on next page)
-
-
-    15.3. Unified memory programming models                                                                                                                                                                                                        103</code></pre>
-<pre><code>
-    // Cleanup allocated memory.
-    hipFree(d_a);
-    hipFree(d_b);
-    hipFree(d_c);
-
-    // Prints the result.
-    std::cout << a << " + " << b << " = " << c << std::endl;
-
-    return 0;
-}</code></pre>
-<h2>15.4 Using unified memory management (UMM)</h2>
-<p>Unified memory management (UMM) is a feature that can simplify the complexities of memory management in GPU computing. It is particularly useful in heterogeneous computing environments with heavy memory usage with both a CPU and a GPU, which would require large memory transfers. Here are some areas where UMM can be beneficial:</p>
-<ul>
-<li style="list-style-type: '· ';">Simplification of Memory Management :</li>
-</ul>
-<p>UMMcan help to simplify the complexities of memory management. This can make it easier for developers to write code without worrying about memory allocation and deallocation details.</p>
-<ul>
-<li style="list-style-type: '· ';">Data Migration :</li>
-</ul>
-<p>UMMallows for efficient data migration between the host (CPU) and the device (GPU). This can be particularly useful for applications that need to move data back and forth between the device and host.</p>
-<ul>
-<li style="list-style-type: '· ';">Improved Programming Productivity :</li>
-</ul>
-<p>As a positive side effect, UMM can reduce the lines of code, thereby improving programming productivity.</p>
-<p>In HIP, pinned memory allocations are coherent by default. Pinned memory is host memory mapped into the address space of all GPUs, meaning that the pointer can be used on both host and device. Using pinned memory instead of pageable memory on the host can improve bandwidth.</p>
-<p>While UMMcanprovide numerous benefits, it's important to be aware of the potential performance overhead associated with UMM. You must thoroughly test and profile your code to ensure it's the most suitable choice for your use case.</p>
-<h2>15.5 Unified memory HIP runtime hints for the better performance</h2>
-<p>Unified memory HIP runtime hints can help improve the performance of your code if you know your code's ability and infrastructure. Some hint techniques are presented in this section.</p>
-<p>Thehint functions can set actions on a selected device, which can be identified by hipGetDeviceProperties(&amp;prop, device_id) . There are two special device_id values:</p>
-<ul>
-<li style="list-style-type: '· ';">hipCpuDeviceId = -1 means that the advised device is the CPU.</li>
-<li style="list-style-type: '· ';">hipInvalidDeviceId = -2 means that the device is invalid.</li>
-</ul>
-<p>For the best performance, profile your application to optimize the utilization of HIP runtime hints.</p>
-<p>(continued from previous page)</p>
-<h2>15.5.1 Data prefetching</h2>
-<p>Data prefetching is a technique used to improve the performance of your application by moving data closer to the processing unit before it's actually needed.</p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        // All                                                                                                                                                                                                        }
-                                                                                                                                                                                                      
-//                                                                                                                                                                                                        #                                                                                                                                                                                                        */
-                                                                                                                                                                                                       //                                                                                                                                                                                                        *
-                                                                                                                                                                                                       */
-
-                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       *
-
-                                                                                                                                                                                                       *                                                                                                                                                                                                        /*
-                                                                                                                                                                                                       /*
-
-                                                                                                                                                                                                       */                                                                                                                                                                                                        /
-                                                                                                                                                                                                       }</code></pre>
-<p>Remember to check the return status of hipMemPrefetchAsync() to ensure that the prefetch operations are completed successfully.</p>
-<h2>15.5.2 Memory advice</h2>
-<p>The effectiveness of hipMemAdvise() comes from its ability to inform the runtime system of the developer's intentions regarding memory usage. When the runtime system has knowledge of the expected memory access patterns, it can make better decisions about data placement and caching, leading to more efficient execution of the application. However, the actual impact on performance can vary based on the specific use case and the hardware architecture.</p>
-<p>For the description of hipMemAdvise() and the detailed list of advice, visit the HIP managed memory allocation API .</p>
-<p>Here is the updated version of the example above with memory advice.</p>
-<pre><code>
-    The effectiveness of nipMemAdvise() comes from its ability to inform the runtime system at the developer's intentions
-    regarding memory usage. When the runtime system has knowledge of the expected memory access patterns, it can make
-    better decisions about data placement and caching, leading to more efficient execution of the application. However, the
-    actual impact on performance can vary based on the specific use case and the hardware architecture.
-    For the description of hipMemAdvise() and the detailed list of advice, visit the HIP managed memory allocation API.
-    Here is the updated version of the example above with memory advice.
-    
-  #include <hip/hip_runtime.h>
-  #include <iostream>
-    
-  // Addition of two values.
-  __global__ void add(int *a, int *b, int *c) {
-      *c = *a + *b;
-  }
-  
-  int main() {
-      int *a, *b, *c;
-      
-      // Allocate memory for a, b, and c accessible to both device and host codes.
-      hipMallocManaged(&a, sizeof(*a));
-      hipMallocManaged(&b, sizeof(*b));
-      hipMallocManaged(&c, sizeof(*c));
-      
-      // Set memory advice for a, b, and c to be accessed by the CPU.
-      hipMemAdvise(a, sizeof(*a), hipMemAdviseSetPreferredLocation, hipCpuDeviceId);
-      hipMemAdvise(b, sizeof(*b), hipMemAdviseSetPreferredLocation, hipCpuDeviceId);
-      hipMemAdvise(c, sizeof(*c), hipMemAdviseSetPreferredLocation, hipCpuDeviceId);
-      
-      // Additionally, set memory advice for a, b, and c to be read mostly from the device.
-  __0.
-      constexpr int device = 0;
-      hipMemAdvise(a, sizeof(*a), hipMemAdviseSetReadMostly, device);
-      hipMemAdvise(b, sizeof(*b), hipMemAdviseSetReadMostly, device);
-      hipMemAdvise(c, sizeof(*c), hipMemAdviseSetReadMostly, device);
-      
-      // Setup input values.
-      *a = 1;
-      *b = 2;
-      
-      // Launch add() kernel on GPU.
-      hipLaunchKernelGGL(add, dim3(1), dim3(1), 0, 0, a, b, c);
-      
-      // Wait for GPU to finish before accessing on host.
-      hipDeviceSynchronize();
-      
-      // Prints the result.
-      std::cout << *a << " + " << *b << " = " << *c << std::endl;
-      
-      // Cleanup allocated memory.
-      hipFree(a);
-      
-                                                                                                                                                                                                         (continues on next page)
-      
-      
-      
-  106</code></pre>
-<p>(continues on next page)</p>
-<pre><code>      hipFree(b);
-      hipFree(c);
-
-      return 0;
-}</code></pre>
-<h2>15.5.3 Memory range attributes</h2>
-<p>Memory Range attributes allow you to query attributes of a given memory range.</p>
-<p>The hipMemRangeGetAttribute() is added to the example to query the hipMemRangeAttributeReadMostly attribute of the memory range pointed to by a . The result is stored in attributeValue and then printed out.</p>
-<p>For more details, visit the HIP managed memory allocation API .</p>
-<pre><code>
-        Memory Range attributes allow you to query attributes of a given memory range.
-        The hipMemRangeGetAttribute() is added to the example to query the hipMemRangeAttributeReadMostly at-
-        title of the memory range pointed to by a. The result is stored in attributeValue and then printed out.
-        For more details, visit the HIP managed memory allocation API.
-        #include <hip/hip_runtime.h>
-        #include <iostream>
-        
-        // Addition of two values.
-        __global__ void add(int *a, int *b, int *c) {
-            *c = *a + *b;
-        }
-        
-        int main() {
-            int *a, *b, *c;
-            unsigned int attributeValue;
-            constexpr size_t attributeSize = sizeof(attributeValue);
-            
-            // Allocate memory for a, b and c that is accessible to both device and host codes.
-            hipMallocManaged(&a, sizeof(*a));
-            hipMallocManaged(&b, sizeof(*b));
-            hipMallocManaged(&c, sizeof(*c));
-            
-            // Setup input values.
-            *a = 1;
-            *b = 2;
-            
-            // Launch add() kernel on GPU.
-            hipLaunchKernelGGL(add, dim3(1), dim3(1), 0, 0, a, b, c);
-            
-            // Wait for GPU to finish before accessing on host.
-            hipDeviceSynchronize();
-            
-            // Query an attribute of the memory range.
-            hipMemRangeGetAttribute(&attributeValue,
-                                             attributeSize,
-                                              hipMemRangeAttributeReadMostly,
-                                              a,
-                                               sizeof(*a));
-             
-            // Prints the result.
-            std::cout << *a << " + " << *b << " = " << *c << std::endl;
-                                                                                                                                                                                                         (continues on next page)
-                                                                                                                                                                                                      
-                                                                                                                                                                                                       )
-                                                                                                                                                                                                       (Continues on next page)</code></pre>
-<p>(continues on next page)</p>
-<p>(continued from previous page)</p>
-<p>(continued from previous page)</p>
-<pre><code>    std::cout << "The queried attribute value is: " << attributeValue << std::endl;
-
-    // Cleanup allocated memory.
-    hipFree(a);
-    hipFree(b);
-    hipFree(c);
-
-    return 0;
-}</code></pre>
-<h2>15.5.4 Asynchronously attach memory to a stream</h2>
-<p>The hipStreamAttachMemAsync function would be able to asynchronously attach memory to a stream, which can help concurrent execution when using streams.</p>
-<p>Currently, this function is a no-operation (NOP) function on AMD GPUs. It simply returns success after the runtime memory validation passed. This function is necessary on Microsoft Windows, and UMM is not supported on this operating system with AMD GPUs at the moment.</p>
-<p>CHAPTER</p>
-<h2>SIXTEEN</h2>
-<h2>VIRTUAL MEMORY MANAGEMENT</h2>
-<p>Memorymanagement is important when creating high-performance applications in the HIP ecosystem. Both allocating and copying memory can result in bottlenecks, which can significantly impact performance.</p>
-<p>Global memory allocation in HIP uses the C language style allocation function. This works fine for simple cases but can cause problems if your memory needs change. If you need to increase the size of your memory, you must allocate a second larger buffer and copy the data to it before you can free the original buffer. This increases overall memory usage and causes unnecessary memcpy calls. Another solution is to allocate a larger buffer than you initially need. However, this isn't an efficient way to handle resources and doesn't solve the issue of reallocation when the extra buffer runs out.</p>
-<p>Virtual memory management solves these memory management problems. It helps to reduce memory usage and unnecessary memcpy calls.</p>
-<h2>16.1 Memory allocation</h2>
-<p>Standard memory allocation uses the hipMalloc function to allocate a block of memory on the device. However, when using virtual memory, this process is separated into multiple steps using the hipMemCreate , hipMemAddressReserve , hipMemMap , and hipMemSetAccess functions. This guide explains what these functions do and how you can use them for virtual memory management.</p>
-<h2>16.1.1 Allocate physical memory</h2>
-<p>The first step is to allocate the physical memory itself with the hipMemCreate function. This function accepts the size of the buffer, an unsigned long long variable for the flags, and a hipMemAllocationProp variable. hipMemAllocationProp contains the properties of the memory to be allocated, such as where the memory is physically located and what kind of shareable handles are available. If the allocation is successful, the function returns a value of hipSuccess , with hipMemGenericAllocationHandle_t representing a valid physical memory allocation. The allocated memory size must be aligned with the granularity appropriate for the properties of the allocation. You can use the hipMemGetAllocationGranularity function to determine the correct granularity.</p>
-<pre><code><_C_></code></pre>
-<h2>16.1.2 Reserve virtual address range</h2>
-<p>After you have acquired an allocation of physical memory, you must map it before you can use it. To do so, you need a virtual address to map it to. Mapping means the physical memory allocation is available from the virtual address range it is mapped to. To reserve a virtual memory range, use the hipMemAddressReserve function. The size of the virtual memory must match the amount of physical memory previously allocated. You can then map the physical memory allocation to the newly-acquired virtual memory address range using the hipMemMap function.</p>
-<pre><code>0) ;</code></pre>
-<pre><code><_C++_></code></pre>
-<h2>16.1.3 Set memory access</h2>
-<p>Finally, use the hipMemSetAccess function to enable memory access. It accepts the pointer to the virtual memory, the size, and a hipMemAccessDesc descriptor as parameters. In a multi-GPU environment, you can map the device memory of one GPU to another. This feature also works with the traditional memory management system, but isn't as scalable as with virtual memory. When memory is allocated with hipMalloc , hipDeviceEnablePeerAccess is used to enable peer access. This function enables access between two devices, but it means that every call to hipMalloc takes more time to perform the checks and the mapping between the devices. When using virtual memory management, peer access is enabled by hipMemSetAccess , which provides a finer level of control over what is shared. This has no performance impact on memory allocation and gives you more control over what memory buffers are shared with which devices.</p>
-<pre><code>hipMemAccessDesc accessDesc = {};
-accessDesc.location.type = HIP_MEM_LOCATION_TYPE_DEVICE;
-accessDesc.location.id = currentDev;
-accessDesc.flags = HIP_MEM_ACCESS_FLAGS_PROT_READWRITE;
-hipMemSetAccess(ptr, padded_size, &accessDesc, 1);</code></pre>
-<p>At this point the memory is allocated, mapped, and ready for use. You can read and write to it, just like you would a C style memory allocation.</p>
-<h2>16.1.4 Free virtual memory</h2>
-<p>To free the memory allocated in this manner, use the corresponding free functions. To unmap the memory, use hipMemUnmap . To release the virtual address range, use hipMemAddressFree . Finally, to release the physical memory, use hipMemRelease . A side effect of these functions is the lack of synchronization when memory is released. If you call hipFree when you have multiple streams running in parallel, it synchronizes the device. This causes worse resource usage and performance.</p>
-<pre><code>        |hipMemUnmap(ptr, size);
-        |hipMemRelease(allocHandle);</code></pre>
-<pre><code>        |hipMemAddressFree(ptr,  size);</code></pre>
-<h2>16.2 Memory usage</h2>
-<h2>16.2.1 Dynamically increase allocation size</h2>
-<p>The hipMemAddressReserve function allows you to increase the amount of pre-allocated memory. This function accepts a parameter representing the requested starting address of the virtual memory. This allows you to have a continuous virtual address space without worrying about the underlying physical allocation.</p>
-<pre><code>            hipMemAddressReserve(&new_ptr, (new_size - padded_size), 0, ptr + padded_size, 0);
-            hipMemMap(new_ptr, (new_size - padded_size), 0, newAllocHandle, 0);
-            hipMemSetAccess(new_ptr, (new_size - padded_size), &accessDesc, 1);</code></pre>
-<p>The code sample above assumes that hipMemAddressReserve was able to reserve the memory address at the specified location. However, this isn't guaranteed to be true, so you should validate that new_ptr points to a specific virtual address before using it.</p>
-<h2>CHAPTER</h2>
-<h2>SEVENTEEN</h2>
-<h2>FREQUENTLY ASKED QUESTIONS</h2>
-<h2>17.1 What APIs and features does HIP support?</h2>
-<p>HIP provides the following:</p>
-<ul>
-<li style="list-style-type: '· ';">Devices ( hipSetDevice() , hipGetDeviceProperties() , etc.)</li>
-<li style="list-style-type: '· ';">Memory management ( hipMalloc() , hipMemcpy() , hipFree() , etc.)</li>
-<li style="list-style-type: '· ';">Streams ( hipStreamCreate() , hipStreamSynchronize() , hipStreamWaitEvent() , etc.)</li>
-<li style="list-style-type: '· ';">Events ( hipEventRecord() , hipEventElapsedTime() , etc.)</li>
-<li style="list-style-type: '· ';">Kernel launching ( hipLaunchKernel / hipLaunchKernelGGL is the preferred way of launching kernels. hipLaunchKernelGGL is a standard C/C++ macro that can serve as an alternative way to launch kernels, replacing the CUDA triple-chevron ( &lt;&lt;&lt; &gt;&gt;&gt; ) syntax).</li>
-<li style="list-style-type: '· ';">HIP Module API to control when and how code is loaded.</li>
-<li style="list-style-type: '· ';">CUDA-style kernel coordinate functions ( threadIdx , blockIdx , blockDim , gridDim )</li>
-<li style="list-style-type: '· ';">Cross-lane instructions including shfl , ballot , any , all</li>
-<li style="list-style-type: '· ';">Most device-side math built-ins</li>
-<li style="list-style-type: '· ';">Error reporting ( hipGetLastError() , hipGetErrorString() )</li>
-</ul>
-<p>The HIP API documentation describes each API and its limitations, if any, compared with the equivalent CUDA API.</p>
-<h2>17.2 What is not supported?</h2>
-<h2>17.2.1 Runtime/Driver API features</h2>
-<p>At a high-level, the following features are not supported:</p>
-<ul>
-<li style="list-style-type: '· ';">Textures (partial support available)</li>
-<li style="list-style-type: '· ';">Dynamic parallelism (CUDA 5.0)</li>
-<li style="list-style-type: '· ';">Graphics interoperability with OpenGL or Direct3D</li>
-<li style="list-style-type: '· ';">CUDA IPC Functions (Under Development)</li>
-<li style="list-style-type: '· ';">CUDA array, mipmappedArray and pitched memory</li>
-<li style="list-style-type: '· ';">Queue priority controls</li>
-</ul>
-<p>See the API Support Table for more detailed information.</p>
-<h2>17.2.2 Kernel language features</h2>
-<ul>
-<li style="list-style-type: '· ';">C+ ± style device-side dynamic memory allocations (free, new, delete) (CUDA 4.0)</li>
-<li style="list-style-type: '· ';">Virtual functions, indirect functions and try/catch (CUDA 4.0)</li>
-<li style="list-style-type: '· ';">__prof_trigger</li>
-<li style="list-style-type: '· ';">PTX assembly (CUDA 4.0). HIP-Clang supports inline GCN assembly.</li>
-<li style="list-style-type: '· ';">Several kernel features are under development. See the C++ language extensions for more information.</li>
-</ul>
-<h2>17.3 Is HIP a drop-in replacement for CUDA?</h2>
-<p>No. HIP provides porting tools which do most of the work to convert CUDA code into portable C++ code that uses the HIP APIs. Most developers will port their code from CUDA to HIP and then maintain the HIP version. HIP code provides the same performance as native CUDA code, plus the benefits of running on AMD platforms.</p>
-<h2>17.4 What specific version of CUDA does HIP support?</h2>
-<p>HIP APIs and features do not map to a specific CUDA version. HIP provides a strong subset of the functionality provided in CUDA, and the hipify tools can scan code to identify any unsupported CUDA functions - this is useful for identifying the specific features required by a given application.</p>
-<p>However, we can provide a rough summary of the features included in each CUDA SDK and the support level in HIP. Each bullet below lists the major new language features in each CUDA release and then indicate which are supported/not supported in HIP:</p>
-<ul>
-<li style="list-style-type: '· ';">CUDA 4.0 and earlier :</li>
-<li>-HIP supports CUDA 4.0 except for the limitations described above.</li>
-<li style="list-style-type: '· ';">CUDA 5.0 :</li>
-<li>-Dynamic Parallelism (not supported)</li>
-<li>-cuIpc functions (under development).</li>
-<li style="list-style-type: '· ';">CUDA 6.0 :</li>
-<li>-Managed memory (under development)</li>
-<li style="list-style-type: '· ';">CUDA 6.5 :</li>
-<li>-__shfl intrinsic (supported)</li>
-<li style="list-style-type: '· ';">CUDA 7.0 :</li>
-<li>-Per-thread default streams (supported)</li>
-<li>-C++11 (Hip-Clang supports all of C++11, all of C++14 and some C++17 features)</li>
-<li style="list-style-type: '· ';">CUDA 7.5 :</li>
-<li>-float16 (supported)</li>
-<li style="list-style-type: '· ';">CUDA 8.0 :</li>
-<li>-Page Migration including cudaMemAdvise , cudaMemPrefetch , other cudaMem* APIs(not supported)</li>
-<li style="list-style-type: '· ';">CUDA 9.0 :</li>
-</ul>
-<ul>
-<li>-Cooperative Launch, Surface Object Management, Version Management</li>
-</ul>
-<h2>17.5 What libraries does HIP support?</h2>
-<p>HIP includes growing support for the four key math libraries using hipBLAS, hipFFT, hipRAND and hipSPARSE, as well as MIOpen for machine intelligence applications. These offer pointer-based memory interfaces (as opposed to opaque buffers) and can be easily interfaced with other HIP applications. The hip interfaces support both ROCm and CUDA paths, with familiar library interfaces.</p>
-<ul>
-<li style="list-style-type: '· ';">hipBLAS, which utilizes rocBlas.</li>
-<li style="list-style-type: '• ';">hipFFT</li>
-<li style="list-style-type: '• ';">hipsSPARSE</li>
-<li style="list-style-type: '• ';">hipRAND</li>
-<li style="list-style-type: '• ';">MIOpen</li>
-</ul>
-<p>Additionally, some of the cuBLAS routines are automatically converted to hipblas equivalents by the HIPIFY tools. These APIs use cuBLAS or hcBLAS depending on the platform and replace the need to use conditional compilation.</p>
-<h2>17.6 How does HIP compare with OpenCL?</h2>
-<p>Both AMD and NVIDIA support OpenCL 1.2 on their devices so that developers can write portable code. HIP offers several benefits over OpenCL:</p>
-<ul>
-<li style="list-style-type: '· ';">Developers can code in C++ as well as mix host and device C++ code in their source files. HIP C++ code can use templates, lambdas, classes and so on.</li>
-<li style="list-style-type: '· ';">The HIP API is less verbose than OpenCL and is familiar to CUDA developers.</li>
-<li style="list-style-type: '· ';">Because both CUDA and HIP are C++ languages, porting from CUDA to HIP is significantly easier than porting from CUDA to OpenCL.</li>
-<li style="list-style-type: '· ';">HIP uses the best available development tools on each platform: on NVIDIA GPUs, HIP code compiles using NVCC and can employ the Nsight profiler and debugger (unlike OpenCL on NVIDIA GPUs).</li>
-<li style="list-style-type: '· ';">HIP provides pointers and host-side pointer arithmetic.</li>
-<li style="list-style-type: '· ';">HIP provides device-level control over memory allocation and placement.</li>
-<li style="list-style-type: '· ';">HIP offers an offline compilation model.</li>
-</ul>
-<h2>17.7 How does porting CUDA to HIP compare to porting CUDA to OpenCL?</h2>
-<p>Both HIP and CUDA are dialects of C++, and thus porting between them is relatively straightforward. Both dialects support templates, classes, lambdas, and other C++ constructs. As one example, the hipify-perl tool was originally a Perl script that used simple text conversions from CUDA to HIP. HIP and CUDA provide similar math library calls as well. In summary, the HIP philosophy was to make the HIP language close enough to CUDA that the porting effort is relatively simple. This reduces the potential for error, and also makes it easy to automate the translation. HIP goal is to quickly get the ported program running on both platforms with little manual intervention, so that the programmer can focus on performance optimizations.</p>
-<p>There have been several tools that have attempted to convert CUDA into OpenCL, such as CU2CL. OpenCL is a C99based kernel language (rather than C++) and also does not support single-source compilation. As a result, the OpenCL syntax is different from CUDA, and the porting tools have to perform some heroic transformations to bridge this gap. The tools also struggle with more complex CUDA applications, in particular, those that use templates, classes, or other C++ features inside the kernel.</p>
-<h2>17.8 What hardware does HIP support?</h2>
-<ul>
-<li style="list-style-type: '· ';">For AMD platforms, see the ROCm documentation for the list of supported platforms.</li>
-<li style="list-style-type: '· ';">For NVIDIA platforms, HIP requires unified memory and should run on any device supporting CUDA SDK 6.0 or newer. We have tested the NVIDIA Titan and Tesla K40.</li>
-</ul>
-<h2>17.9 Do HIPIFY tools automatically convert all source code?</h2>
-<p>Typically, HIPIFY tools can automatically convert almost all run-time code. Most device code needs no additional conversion since HIP and CUDA have similar names for math and built-in functions. The hipify-clang tool will automatically modify the kernel signature as needed (automating a step that used to be done manually). Additional porting may be required to deal with architecture feature queries or with CUDA capabilities that HIP doesn't support. In general, developers should always expect to perform some platform-specific tuning and optimization.</p>
-<h2>17.10 What is NVCC?</h2>
-<p>NVCC is NVIDIA's compiler driver for compiling 'CUDA C++' code into PTX or device code for NVIDIA GPUs. It's a closed-source binary compiler that is provided by the CUDA SDK.</p>
-<h2>17.11 What is HIP-Clang?</h2>
-<p>HIP-Clang is a Clang/LLVM based compiler to compile HIP programs which can run on AMD platform.</p>
-<h2>17.12 Why use HIP rather than supporting CUDA directly?</h2>
-<p>While HIP is a strong subset of the CUDA, it is a subset. The HIP layer allows that subset to be clearly defined and documented. Developers who code to the HIP API can be assured their code will remain portable across NVIDIA and AMD platforms. In addition, HIP defines portable mechanisms to query architectural features and supports a larger 64-bit WaveSize which expands the return type for cross-lane functions like ballot and shuffle from 32-bit integers to 64-bit integers.</p>
-<h2>17.13 Can I develop HIP code on an NVIDIA CUDA platform?</h2>
-<p>Yes. HIP's CUDA path only exposes the APIs and functionality that work on both NVCC and AMDGPU back-ends. 'Extra' APIs, parameters, and features which exist in CUDA but not in HIP-Clang will typically result in compile-time or run-time errors. Developers need to use the HIP API for most accelerator code and bracket any CUDA-specific code with preprocessor conditionals. Developers concerned about portability should, of course, run on both platforms, and should expect to tune for performance. In some cases, CUDA has a richer set of modes for some APIs, and some C++ capabilities such as virtual functions - see the HIP @API documentation for more details.</p>
-<h2>17.14 Can I develop HIP code on an AMD HIP-Clang platform?</h2>
-<p>Yes. HIP's HIP-Clang path only exposes the APIs and functions that work on AMD runtime back ends. 'Extra' APIs, parameters and features that appear in HIP-Clang but not CUDA will typically cause compile- or run-time errors. Developers must use the HIP API for most accelerator code and bracket any HIP-Clang specific code with preprocessor conditionals. Those concerned about portability should, of course, test their code on both platforms and should tune it for performance. Typically, HIP-Clang supports a more modern set of C++11/C++14/C++17 features, so HIP developers who want portability should be careful when using advanced C++ features on the HIP-Clang path.</p>
-<h2>17.15 How to use HIP-Clang to build HIP programs?</h2>
-<p>The environment variable can be used to set compiler path:</p>
-<ul>
-<li style="list-style-type: '· ';">HIP_CLANG_PATH: path to hip-clang. When set, this variable let hipcc to use hip-clang for compilation/linking.</li>
-</ul>
-<p>There is an alternative environment variable to set compiler path:</p>
-<ul>
-<li style="list-style-type: '· ';">HIP_ROCCLR_HOME: path to root directory of the HIP-ROCclr runtime. When set, this variable let hipcc use hip-clang from the ROCclr distribution. NOTE: If HIP_ROCCLR_HOME is set, there is no need to set HIP_CLANG_PATH since hipcc will deduce them from HIP_ROCCLR_HOME.</li>
-</ul>
-<h2>17.16 What is AMD clr?</h2>
-<p>AMD Common Language Runtime (CLR) is a repository for the AMD platform, which contains source codes for AMD's compute languages runtimes as follows,</p>
-<ul>
-<li style="list-style-type: '· ';">hipamd - contains implementation of HIP language for AMD GPU.</li>
-<li style="list-style-type: '· ';">rocclr - contains virtual device interfaces that compute runtimes interact with backends, such as ROCr on Linux and PAL on Windows.</li>
-<li style="list-style-type: '· ';">opencl - contains implementation of OpenCL™ on the AMD platform.</li>
-</ul>
-<h2>17.17 What is hipother?</h2>
-<p>A new repository 'hipother' is added in the ROCm 6.1 release, which is branched out from HIP. hipother supports the HIP back-end implementation on some non-AMD platforms, like NVIDIA.</p>
-<h2>17.18 Can I get HIP open source repository for Windows?</h2>
-<p>No, there is no HIP repository open publicly on Windows.</p>
-<h2>17.19 Can a HIP binary run on both AMD and NVIDIA platforms?</h2>
-<p>HIP is a source-portable language that can be compiled to run on either AMD or NVIDIA platform. HIP tools don't create a 'fat binary' that can run on either platform, however.</p>
-<h2>17.20 On HIP-Clang, can I link HIP code with host code compiled with another compiler such as gcc, icc, or clang?</h2>
-<p>Yes. HIP generates the object code which conforms to the GCC ABI, and also links with libstdc++. This means you can compile host code with the compiler of your choice and link the generated object code with GPU code compiled with HIP. Larger projects often contain a mixture of accelerator code (initially written in CUDA with NVCC) and host code (compiled with gcc, icc, or clang). These projects can convert the accelerator code to HIP, compile that code with hipcc, and link with object code from their preferred compiler.</p>
-<h2>17.21 Can HIP API support C style application? What is the difference between C and C++?</h2>
-<p>HIP is C++ runtime API that supports C style applications as well.</p>
-<p>Some C style applications (and interfaces to other languages (FORTRAN, Python)) would call certain HIP APIs but not use kernel programming. They can be compiled with a C compiler and run correctly, however, small details must be considered in the code. For example, initialization, as shown in the simple application below, uses HIP structs dim3 with the file name 'test.hip.cpp'</p>
-<pre><code>                                                                                                                                                                                                        //the file name `test.hip.cpp`
-                                                                                                                                                                                                       
-                                                                                                                                                                                                      
-#include "hip/hip_runtime_api.h"
-                                                                                                                                                                                                       //this file name `test.hip.cpp`
-                                                                                                                                                                                             
-          int main(int argc, char** argv) {
-            dim3 grid1;
-            printf("dim3 grid1; x=%d, y=%d, z=%d\n",grid1.x,grid1.y,grid1.z);
-            dim3 grid2 = {1,1,1};
-            printf("dim3 grid2 = {1,1,1}; x=%d, y=%d, z=%d\n",grid2.x,grid2.y,grid2.z);
-            return 0;
-            }</code></pre>
-<p>When using a C++ compiler,</p>
-<pre><code>$ gcc -x c++  $(hipconfig --cpp_config) test3.hip.cpp -o test
-$./test
-dim3 grid1; x=1, y=1, z=1
-dim3 grid2 = {1,1,1}; x=1, y=1, z=1</code></pre>
-<p>In which 'dim3 grid1;' will yield a dim3 grid with all dimensional members x,y,z initialized to 1, as the default constructor behaves that way. Further, if written: dim3 grid(2); // yields {2,1,1} dim3 grid(2,3); yields {2,3,1} In comparison, when using the C compiler, $ gcc -x c $( hipconfig --cpp_config ) test.hip.cpp -o test $ ./test dim3 grid1; x=646881376, y=21975, z=1517277280 dim3 grid2 = {1,1,1}; x=1, y=1, z=1 In which 'dim3 grid;' does not imply any initialization, no constructor is called, and dimensional values x,y,z of grid are undefined. NOTE: To get the C++ default behavior, C programmers must additionally specify the right-hand side as shown below,</p>
-<pre><code>        |dim3 grid = {1,1,1}; // initialized as in C++</code></pre>
-<pre><code>C++</code></pre>
-<h2>17.22 Can I install both CUDA SDK and HIP-Clang on the same machine?</h2>
-<p>Yes. You can use HIP_PLATFORM to choose which path hipcc targets. This configuration can be useful when using HIP to develop an application which is portable to both AMD and NVIDIA.</p>
-<h2>17.23 HIP detected my platform (HIP-Clang vs NVCC) incorrectly * what should I do?</h2>
-<p>HIP will set the platform to AMD and use HIP-Clang as compiler if it sees that the AMD graphics driver is installed and has detected an AMD GPU. Sometimes this isn't what you want * you can force HIP to recognize the platform by setting the following,</p>
-<pre><code>| export</code></pre>
-<pre><code>rt HIP_PLATFORM=amd</code></pre>
-<pre><code><_Python_></code></pre>
-<pre><code>  | HIP_COMPILER=cuda</code></pre>
-<pre><code>  | HIP_RUNTIME=nvcc</code></pre>
-<p>One symptom of this problem is the message 'error: 'unknown error'(11) at square.hipref.cpp:56 . This can occur if you have a CUDA installation on an AMD platform, and HIP incorrectly detects the platform as NVCC. HIP may be able to compile the application using the NVCC tool-chain but will generate this error at runtime since the platform does not have a CUDA device.</p>
-<h2>17.24 On CUDA, can I mix CUDA code with HIP code?</h2>
-<p>Yes. Most HIP data structures ( hipStream_t , hipEvent_t ) are typedefs to CUDA equivalents and can be intermixed. Both CUDA and HIP use integer device ids. One notable exception is that hipError_t is a new type, and cannot be used where a cudaError_t is expected. In these cases, refactor the code to remove the expectation. Alternatively, hip_runtime_api.h defines functions which convert between the error code spaces:</p>
-<p>hipErrorToCudaError hipCUDAErrorTohipError hipCUResultTohipError</p>
-<p>If platform portability is important, use #ifdef __HIP_PLATFORM_NVIDIA__ to guard the CUDA-specific code.</p>
-<h2>17.25 How do I trace HIP application flow?</h2>
-<p>See Logging HIP activity for more information.</p>
-<h2>17.26 What are the maximum limits of kernel launch parameters?</h2>
-<p>Product of block.x, block.y, and block.z should be less than 1024. Please note, HIP does not support kernel launch with total work items defined in dimension with size gridDim x blockDim &gt;= 2^32 , so gridDim.x * blockDim.x, gridDim.y * blockDim.y and gridDim.z * blockDim.z are always less than 2^32.</p>
-<h2>17.27 Are __shfl_*_sync functions supported on HIP platform?</h2>
-<p>__shfl_*_sync is not supported on HIP but for NVCC path CUDA 9.0 and above all shuffle calls get redirected to it's sync version.</p>
-<h2>17.28 How to create a guard for code that is specific to the host or the GPU?</h2>
-<p>The compiler defines the __HIP_DEVICE_COMPILE__ macro only when compiling the code for the GPU. It could be used to guard code that is specific to the host or the GPU.</p>
-<h2>17.29 Why _OpenMP is undefined when compiling with -fopenmp ?</h2>
-<p>When compiling an OpenMP source file with hipcc -fopenmp , the compiler may generate error if there is a reference to the _OPENMP macro. This is due to a limitation in hipcc that treats any source file type (for example .cpp ) as an HIP translation unit leading to some conflicts with the OpenMP language switch. If the OpenMP source file doesn't contain any HIP language constructs you could work around this issue by adding the -x c++ switch to force the compiler to treat the file as regular C++. Another approach would be to guard the OpenMP code with #ifdef _OPENMP so that the code block is disabled when compiling for the GPU. The __HIP_DEVICE_COMPILE__ macro defined by the HIP compiler when compiling GPU code could also be used for guarding code paths specific to the host or the GPU.</p>
-<h2>17.30 Does the HIP-Clang compiler support extern shared declarations?</h2>
-<p>Previously, it was essential to declare dynamic shared memory using the HIP_DYNAMIC_SHARED macro for accuracy, as using static shared memory in the same kernel could result in overlapping memory ranges and data-races.</p>
-<p>Now, the HIP-Clang compiler provides support for extern shared declarations, and the HIP_DYNAMIC_SHARED option is no longer required. You may use the standard extern definition: extern shared type var[];</p>
-<h2>17.31 I have multiple HIP enabled devices and I am getting an error code hipErrorSharedObjectInitFailed with the message 'Error: shared object initialization failed'?</h2>
-<p>This error message is seen due to the fact that you do not have valid code object for all of your devices.</p>
-<p>If you have compiled the application yourself, make sure you have given the correct device name(s) and its features via: --offload-arch . If you are not mentioning the --offload-arch , make sure that hipcc is using the correct offload arch by verifying the hipcc output generated by setting the environment variable HIPCC_VERBOSE=1 .</p>
-<p>If you have a precompiled application/library (like rocblas, TensorFlow etc) which gives you such error, there are one of two possibilities.</p>
-<ul>
-<li style="list-style-type: '· ';">The application/library does not ship code object bundles for all of your device(s): in this case you need to recompile the application/library yourself with correct --offload-arch .</li>
-<li style="list-style-type: '· ';">The application/library does not ship code object bundles for some of your device(s), for example you have a system with an APU + GPU and the library does not ship code objects for your APU. For this you can set the environment variable HIP_VISIBLE_DEVICES or CUDA_VISIBLE_DEVICES on NVIDIA platform, to only enable GPUs for which code object is available. This will limit the GPUs visible to your application and allow it to run.</li>
-</ul>
-<p>Note: In previous releases, the error code is hipErrorNoBinaryForGpu with message 'Unable to find code object for all current devices'. The error code handling behavior is changed. HIP runtime shows the error code hipErrorSharedObjectInitFailed with message 'Error: shared object initialization failed' on unsupported GPU.</p>
-<h2>17.32 How to use per-thread default stream in HIP?</h2>
-<p>The per-thread default stream is an implicit stream local to both the thread and the current device. It does not do any implicit synchronization with other streams (like explicitly created streams), or default per-thread stream on other threads.</p>
-<p>The per-thread default stream is a blocking stream and will synchronize with the default null stream if both are used in a program.</p>
-<p>In ROCm, a compilation option should be added in order to compile the translation unit with per-thread default stream enabled. -fgpu-default-stream=per-thread . Once source is compiled with per-thread default stream enabled, all APIs will be executed on per thread default stream, hence there will not be any implicit synchronization with other streams.</p>
-<p>Besides, per-thread default stream be enabled per translation unit, users can compile some files with feature enabled and some with feature disabled. Feature enabled translation unit will have default stream as per thread and there will not be any implicit synchronization done but other modules will have legacy default stream which will do implicit synchronization.</p>
-<h2>17.33 How to use complex multiplication and division operations?</h2>
-<p>In HIP, hipFloatComplex and hipDoubleComplex are defined as complex data types,</p>
-<pre><code><_C_></code></pre>
-<p>Any application uses complex multiplication and division operations, need to replace '*' and '/' operators with the following,</p>
-<ul>
-<li style="list-style-type: '· ';">hipCmulf() and hipCdivf() for hipFloatComplex</li>
-<li style="list-style-type: '· ';">hipCmul() and hipCdiv() for hipDoubleComplex</li>
-</ul>
-<p>Note: These complex operations are equivalent to corresponding types/functions on the NVIDIA platform.</p>
-<h2>17.34 Can I develop applications with HIP APIs on Windows the same on Linux?</h2>
-<p>Yes, HIP APIs are available to use on both Linux and Windows. Due to different working mechanisms on operating systems like Windows vs Linux, HIP APIs call corresponding lower level backend runtime libraries and kernel drivers for the OS, in order to control the executions on GPU hardware accordingly. There might be a few differences on the related backend software and driver support, which might affect usage of HIP APIs. See OS support details in HIP API document.</p>
-<h2>17.35 Does HIP support LUID?</h2>
-<p>Starting ROCm 6.0, HIP runtime supports Locally Unique Identifier (LUID). This feature enables the local physical device(s) to interoperate with other devices. For example, DirectX 12.</p>
-<p>HIP runtime sets device LUID properties so the driver can query LUID to identify each device for interoperability.</p>
-<p>Note: HIP supports LUID only on Windows OS.</p>
-<h2>17.36 How can I know the version of HIP?</h2>
-<p>HIP version definition has been updated since ROCm 4.2 release as the following:</p>
-<pre><code><_SQL_></code></pre>
-<p>HIP version can be queried from HIP API call, hipRuntimeGetVersion(&amp;runtimeVersion);</p>
-<p>The version returned will always be greater than the versions in previous ROCm releases.</p>
-<p>Note: The version definition of HIP runtime is different from CUDA. On AMD platform, the function returns HIP runtime version, while on NVIDIA platform, it returns CUDA runtime version. And there is no mapping/correlation between HIP version and CUDA version.</p>
-<h2>18.1 Related Pages</h2>
-<p>18.2 Topics</p>
-<h2>18.3 Namespaces</h2>
-<p>18.3.1 Namespace List</p>
-<p>18.3.2 Namespace Members</p>
-<p>18.3.2.1 Namespace Members</p>
-<p>18.3.2.2 Namespace Members</p>
-<h2>18.4 Data Structures</h2>
-<ul>
-<li>18.4.1 Data Structures</li>
-<li>18.4.2 Data Structure Index</li>
-<li>18.4.3 Class Hierarchy</li>
-</ul>
-<p>18.4.4 Data Fields</p>
-<p>18.4.4.1 All</p>
-<p>18.4.4.1.1 Data Fields</p>
-<p>18.4.4.1.2 Data Fields</p>
-<p>18.4.4.1.3 Data Fields</p>
-<p>18.4.4.1.4 Data Fields</p>
-<p>18.4.4.1.5 Data Fields</p>
-<p>18.4.4.1.6 Data Fields 26</p>
-<p>18.4.4.1.7 Data Fields</p>
-<p>CHAPTER</p>
-<h2>EIGHTEEN</h2>
-<h2>HIP RUNTIME API REFERENCE</h2>
-<h2>CHAPTER</h2>
-<h2>NINETEEN</h2>
-<h2>C++ LANGUAGE EXTENSIONS</h2>
-<p>HIP provides a C++ syntax that is suitable for compiling most code that commonly appears in compute kernels (classes, namespaces, operator overloading, and templates). HIP also defines other language features that are designed to target accelerators, such as:</p>
-<ul>
-<li style="list-style-type: '· ';">A kernel-launch syntax that uses standard C++ (this resembles a function call and is portable to all HIP targets)</li>
-<li style="list-style-type: '· ';">Short-vector headers that can serve on a host or device</li>
-<li style="list-style-type: '· ';">Math functions that resemble those in math.h , which is included with standard C++ compilers</li>
-<li style="list-style-type: '· ';">Built-in functions for accessing specific GPU hardware capabilities</li>
-</ul>
-<p>Note: This chapter describes the built-in variables and functions that are accessible from the HIP kernel. It's intended for users who are familiar with CUDA kernel syntax and want to learn how HIP differs from CUDA.</p>
-<p>Features are labeled with one of the following keywords:</p>
-<ul>
-<li style="list-style-type: '· ';">Supported : HIP supports the feature with a CUDA-equivalent function</li>
-<li style="list-style-type: '· ';">Not supported : HIP does not support the feature</li>
-<li style="list-style-type: '· ';">Under development : The feature is under development and not yet available</li>
-</ul>
-<h2>19.1 Function-type qualifiers</h2>
-<h2>19.1.1 __device__</h2>
-<p>Supported __device__ functions are:</p>
-<ul>
-<li style="list-style-type: '· ';">Run on the device</li>
-<li style="list-style-type: '· ';">Called from the device only</li>
-</ul>
-<p>You can combine __device__ with the host keyword ( __host__ ).</p>
-<h2>19.1.2 __global__</h2>
-<p>Supported __global__ functions are:</p>
-<ul>
-<li style="list-style-type: '· ';">Run on the device</li>
-<li style="list-style-type: '· ';">Called (launched) from the host</li>
-</ul>
-<p>HIP __global__ functions must have a void return type.</p>
-<p>HIP doesn't support dynamic-parallelism, which means that you can't call __global__ functions from the device.</p>
-<h2>19.1.3 __host__</h2>
-<p>Supported __host__ functions are:</p>
-<ul>
-<li style="list-style-type: '· ';">Run on the host</li>
-<li style="list-style-type: '· ';">Called from the host</li>
-</ul>
-<p>You can combine __host__ with __device__ ; in this case, the function compiles for the host and the device. Note that these functions can't use the HIP grid coordinate functions (e.g., threadIdx.x ). If you need to use HIP grid coordinate functions, you can pass the necessary coordinate information as an argument.</p>
-<p>You can't combine __host__ with __global__ .</p>
-<p>HIP parses the __noinline__ and __forceinline__ keywords and converts them into the appropriate Clang attributes.</p>
-<h2>19.2 Calling __global__ functions</h2>
-<p>__global__ functions are often referred to as kernels . When you call a global function, you're launching a kernel . When launching a kernel, you must specify an execution configuration that includes the grid and block dimensions. The execution configuration can also include other information for the launch, such as the amount of additional shared memory to allocate and the stream where you want to execute the kernel.</p>
-<p>HIP introduces a standard C++ calling convention ( hipLaunchKernelGGL ) to pass the run configuration to the kernel. However, you can also use the CUDA &lt;&lt;&lt; &gt;&gt;&gt; syntax.</p>
-<p>When using hipLaunchKernelGGL , your first five parameters must be:</p>
-<ul>
-<li style="list-style-type: '· ';">symbol kernelName : The name of the kernel you want to launch. To support template kernels that contain "," , use the HIP_KERNEL_NAME macro (HIPIFY tools insert this automatically).</li>
-<li style="list-style-type: '· ';">dim3 gridDim : 3D-grid dimensions that specify the number of blocks to launch.</li>
-<li style="list-style-type: '· ';">dim3 blockDim : 3D-block dimensions that specify the number of threads in each block.</li>
-<li style="list-style-type: '· ';">size_t dynamicShared : The amount of additional shared memory that you want to allocate when launching the kernel (see __shared__ ).</li>
-<li style="list-style-type: '· ';">hipStream_t : The stream where you want to run the kernel. A value of 0 corresponds to the NULL stream (see Synchronization functions ).</li>
-</ul>
-<p>You can include your kernel arguments after these parameters.</p>
-<pre><code>                                                                                                                                                                                                        // Example hipLaunchKernelGGL pseudocode:</code></pre>
-<pre><code>
-ize_t  N)</code></pre>
-<p>(continued from previous page)</p>
-<pre><code>                                                                                                                                                                                                        (continued from previous page)
-                                                                                                                                                                                                       
-                                                                                                                                                                                                      
-}
-
-MyKernel<<<dim3(gridDim), dim3(groupDim), 0, 0>>> (a,b,c,n);
-
-// Alternatively, you can launch the kernel using:
-// hipLaunchKernelGGL(MyKernel, dim3(gridDim), dim3(groupDim), 0/*dynamicShared*/, 0/
-                                                                                                                                                                                                       :*stream), a, b, c, n);</code></pre>
-<p>You can use HIPIFY tools to convert CUDA launch syntax to hipLaunchKernelGGL . This includes the conversion of optional &lt;&lt;&lt; &gt;&gt;&gt; arguments into the five required hipLaunchKernelGGL parameters. Note: HIP doesn't support dimension sizes of 𝑔𝑟𝑖𝑑𝐷𝑖𝑚 * 𝑏𝑙𝑜𝑐𝑘𝐷𝑖𝑚 ≥ 2 32 when launching a kernel.</p>
-<h2>19.3 Kernel launch example</h2>
-<pre><code>
-// Example showing device function, __device__ __host__
-// <- compile for both device and host
-float PlusOne(float x)
-{
-  return x + 1.0;
-}
-
-__global__
-void
-MyKernel (hipLaunchParm lp, /*lp parm for execution configuration */
-          const float *a, const float *b, float *c, unsigned N)
-{
-  unsigned gid = threadIdx.x; // <- coordinate index function
-  if (gid < N) {
-    c[gid] = a[gid] + PlusOne(b[gid]);
-  }
-}
-void callMyKernel()
-{
-  float *a, *b, *c; // initialization not shown...
-  unsigned N = 1000000;
-  const unsigned blockSize = 256;
-
-  MyKernel<<<dim3(gridDim), dim3(groupDim), 0, 0>>> (a,b,c,n);
-  // Alternatively, kernel can be launched by
-  // hipLaunchKernelGGL(MyKernel, dim3(N/blockSize), dim3(blockSize), 0, 0, a,b,c,N);
-}</code></pre>
-<h2>19.4 Variable type qualifiers</h2>
-<h2>19.4.1 __constant__</h2>
-<p>The host writes constant memory before launching the kernel. This memory is read-only from the GPU while the kernel is running. The functions for accessing constant memory are:</p>
-<ul>
-<li style="list-style-type: '· ';">hipGetSymbolAddress()</li>
-<li style="list-style-type: '· ';">hipGetSymbolSize()</li>
-<li style="list-style-type: '· ';">hipMemcpyToSymbol()</li>
-<li style="list-style-type: '· ';">hipMemcpyToSymbolAsync()</li>
-<li style="list-style-type: '· ';">hipMemcpyFromSymbol()</li>
-<li style="list-style-type: '· ';">hipMemcpyFromSymbolAsync()</li>
-</ul>
-<h2>19.4.2 __shared__</h2>
-<p>To allow the host to dynamically allocate shared memory, you can specify extern __shared__ as a launch parameter.</p>
-<p>Note: Prior to the HIP-Clang compiler, dynamic shared memory had to be declared using the HIP_DYNAMIC_SHARED macro in order to ensure accuracy. This is because using static shared memory in the same kernel could've resulted in overlapping memory ranges and data-races. The HIP-Clang compiler provides support for extern __shared_ declarations, so HIP_DYNAMIC_SHARED is no longer required.</p>
-<h2>19.4.3 __managed__</h2>
-<p>Managed memory, including the __managed__ keyword, is supported in HIP combined host/device compilation.</p>
-<h2>19.4.4 __restrict__</h2>
-<p>__restrict__ tells the compiler that the associated memory pointer not to alias with any other pointer in the kernel or function. This can help the compiler generate better code. In most use cases, every pointer argument should use this keyword in order to achieve the benefit.</p>
-<h2>19.5 Built-in variables</h2>
-<h2>19.5.1 Coordinate built-ins</h2>
-<p>The kernel uses coordinate built-ins ( thread* , block* , grid* ) to determine the coordinate index and bounds for the active work item.</p>
-<p>Built-ins are defined in amd_hip_runtime.h , rather than being implicitly defined by the compiler.</p>
-<p>Coordinate variable definitions for built-ins are the same for HIP and CUDA. For example: threadIdx.x , blockIdx. y , and gridDim.y . The products gridDim.x * blockDim.x , gridDim.y * blockDim.y , and gridDim.z * blockDim.z are always less than 2^32 .</p>
-<p>Coordinate built-ins are implemented as structures for improved performance. When used with printf , they must be explicitly cast to integer types.</p>
-<h2>19.5.2 warpSize</h2>
-<p>The warpSize variable type is int . It contains the warp size (in threads) for the target device. warpSize should only be used in device functions that develop portable wave-aware code.</p>
-<p>Note: NVIDIA devices return 32 for this variable; AMD devices return 64 for gfx9 and 32 for gfx10 and above.</p>
-<h2>19.6 Vector types</h2>
-<p>The following vector types are defined in hip_runtime.h . They are not automatically provided by the compiler.</p>
-<h2>19.6.1 Short vector types</h2>
-<p>Short vector types derive from basic integer and floating-point types. These structures are defined in hip_vector_types.h . The first, second, third, and fourth components of the vector are defined by the x , y , z , and w fields, respectively. All short vector types support a constructor function of the form make_&lt;type_name&gt;() . For example, float4 make_float4(float x, float y, float z, float w) creates a vector with type float4 and value (x,y,z,w) .</p>
-<p>HIP supports the following short vector formats:</p>
-<ul>
-<li style="list-style-type: '· ';">Signed Integers:</li>
-<li>-char1 , char2 , char3 , char4</li>
-<li>-short1 , short2 , short3 , short4</li>
-<li>-int1 , int2 , int3 , int4</li>
-<li>-long1 , long2 , long3 , long4</li>
-<li>-longlong1 , longlong2 , longlong3 , longlong4</li>
-<li style="list-style-type: '· ';">Unsigned Integers:</li>
-<li>-uchar1 , uchar2 , uchar3 , uchar4</li>
-<li>-ushort1 , ushort2 , ushort3 , ushort4</li>
-<li>-uint1 , uint2 , uint3 , uint4</li>
-<li>-ulong1 , ulong2 , ulong3 , ulong4</li>
-<li>-ulonglong1 , ulonglong2 , ulonglong3 , ulonglong4</li>
-<li style="list-style-type: '· ';">Floating Points:</li>
-<li>-float1 , float2 , float3 , float4</li>
-<li>-double1 , double2 , double3 , double4</li>
-</ul>
-<h2>19.6.2 dim3</h2>
-<p>dim3 is a three-dimensional integer vector type that is commonly used to specify grid and group dimensions.</p>
-<p>The dim3 constructor accepts between zero and three arguments. By default, it initializes unspecified dimensions to 1.</p>
-<pre><code><_C_></code></pre>
-<h2>19.7 Memory fence instructions</h2>
-<p>HIP supports __threadfence() and __threadfence_block() . If you're using threadfence_system() in the HIP-Clang path, you can use the following workaround:</p>
-<ol>
-<li style="list-style-type: '1. ';">Build HIP with the HIP_COHERENT_HOST_ALLOC environment variable enabled.</li>
-<li style="list-style-type: '2. ';">Modify kernels that use __threadfence_system() as follows:</li>
-<li style="list-style-type: '· ';">Ensure the kernel operates only on fine-grained system memory, which should be allocated with hipHostMalloc() .</li>
-<li style="list-style-type: '· ';">Remove memcpy for all allocated fine-grained system memory regions.</li>
-</ol>
-<h2>19.8 Synchronization functions</h2>
-<p>Synchronization functions causes all threads in the group to wait at this synchronization point, and for all shared and global memory accesses by the threads to complete, before running synchronization. This guarantees the visibility of accessed data for all threads in the group.</p>
-<p>The __syncthreads() built-in function is supported in HIP. The __syncthreads_count(int) , __syncthreads_and(int) , and __syncthreads_or(int) functions are under development.</p>
-<p>The Cooperative Groups API offer options to do synchronization on a developer defined set of thread groups. For further information, check Cooperative Groups API or Cooperative Groups how to .</p>
-<h2>19.9 Math functions</h2>
-<p>HIP-Clang supports a set of math operations that are callable from the device. HIP supports most of the device functions supported by CUDA. These are described on Math API page .</p>
-<h2>19.10 Texture functions</h2>
-<p>The supported texture functions are listed in texture_fetch_functions.h and texture_indirect_functions. h header files in the HIP-AMD backend repository.</p>
-<p>Texture functions are not supported on some devices. To determine if texture functions are supported on your device, use Macro __HIP_NO_IMAGE_SUPPORT == 1 . You can query the attribute hipDeviceAttributeImageSupport to check if texture functions are supported in the host runtime code.</p>
-<h2>19.11 Surface functions</h2>
-<p>The following surface functions are supported in HIP:</p>
-<p>hipError_t hipCreateSurfaceObject ( hipSurfaceObject_t *pSurfObject, const hipResourceDesc *pResDesc )</p>
-<p>Create a surface object.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">pSurfObject -[out] Pointer of surface object to be created.</li>
-<li style="list-style-type: '· ';">pResDesc -[in] Pointer of suface object descriptor.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipError_t hipDestroySurfaceObject ( hipSurfaceObject_t surfaceObject )</p>
-<p>Destroy a surface object.</p>
-<h2>Parameters</h2>
-<p>surfaceObject -[in] Surface object to be destroyed.</p>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue template&lt;typename T , typename std::enable_if&lt;__hip_is_tex_surf_channel_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf1Dread ( T *data, hipSurfaceObject_t surfObj, int x, int boundaryMode = hipBoundaryModeZero )</p>
-<p>Reads the value at coordinate x from the one-dimensional surface.</p>
-<h2>Template Parameters</h2>
-<p>T - The data type of the surface.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">data - [out] The T type result is stored in this pointer.</li>
-<li style="list-style-type: '· ';">surfObj - [in] The surface descriptor.</li>
-<li style="list-style-type: '· ';">x - [in] The coordinate where the value will be read out.</li>
-<li style="list-style-type: '· ';">boundaryMode - [in] The boundary mode is currently ignored.</li>
-</ul>
-<p>template&lt;typename T , typename std::enable_if&lt;__hip_is_tex_surf_channel_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf1Dwrite ( T data, hipSurfaceObject_t surfObj, int x )</p>
-<p>Writes the value data to the one-dimensional surface at coordinate x.</p>
-<h2>Template Parameters</h2>
-<p>T - The data type of the surface.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">data - [in] The T type value is written to surface.</li>
-</ul>
-<ul>
-<li style="list-style-type: '· ';">surfObj - [in] The surface descriptor.</li>
-<li style="list-style-type: '· ';">x - [in] The coordinate where the data will be written.</li>
-</ul>
-<p>template&lt;typename T , typename std::enable_if&lt;__hip_is_tex_surf_channel_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf2Dread ( T *data, hipSurfaceObject_t surfObj, int x, int y )</p>
-<p>Reads the value from the two-dimensional surface at coordinate x, y.</p>
-<h2>Template Parameters</h2>
-<p>T - The data type of the surface.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">data - [out] The T type result is stored in this pointer.</li>
-<li style="list-style-type: '· ';">surfObj - [in] The surface descriptor.</li>
-<li style="list-style-type: '· ';">x - [in] The x coordinate where the value will be read out.</li>
-<li style="list-style-type: '· ';">y - [in] The y coordinate where the value will be read out.</li>
-</ul>
-<p>template&lt;typename T , typename std::enable_if&lt;__hip_is_tex_surf_channel_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf2Dwrite ( T data, hipSurfaceObject_t surfObj, int x, int y )</p>
-<p>Writes the value data to the two-dimensional surface at coordinate x, y.</p>
-<h2>Template Parameters</h2>
-<p>T - The data type of the surface.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">data - [in] The T type value is written to surface.</li>
-<li style="list-style-type: '· ';">surfObj - [in] The surface descriptor.</li>
-<li style="list-style-type: '· ';">x - [in] The x coordinate where the data will be written.</li>
-<li style="list-style-type: '· ';">y - [in] The y coordinate where the data will be written.</li>
-</ul>
-<p>template&lt;typename T , typename std::enable_if&lt;__hip_is_tex_surf_channel_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf3Dread ( T *data, hipSurfaceObject_t surfObj, int x, int y, int z )</p>
-<p>Reads the value from the three-dimensional surface at coordinate x, y, z.</p>
-<h2>Template Parameters</h2>
-<p>T - The data type of the surface.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">data - [out] The T type result is stored in this pointer.</li>
-<li style="list-style-type: '· ';">surfObj - [in] The surface descriptor.</li>
-<li style="list-style-type: '· ';">x - [in] The x coordinate where the value will be read out.</li>
-<li style="list-style-type: '· ';">y - [in] The y coordinate where the value will be read out.</li>
-<li style="list-style-type: '· ';">z - [in] The z coordinate where the value will be read out.</li>
-</ul>
-<p>template&lt;typename T , typename std::enable_if&lt;__hip_is_tex_surf_channel_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf3Dwrite ( T data, hipSurfaceObject_t surfObj, int x, int y, int z )</p>
-<p>Writes the value data to the three-dimensional surface at coordinate x, y, z.</p>
-<h2>Template Parameters</h2>
-<p>T - The data type of the surface.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">data - [in] The T type value is written to surface.</li>
-<li style="list-style-type: '· ';">surfObj - [in] The surface descriptor.</li>
-<li style="list-style-type: '· ';">x - [in] The x coordinate where the data will be written.</li>
-<li style="list-style-type: '· ';">y - [in] The y coordinate where the data will be written.</li>
-<li style="list-style-type: '· ';">z - [in] The z coordinate where the data will be written.</li>
-</ul>
-<p>template&lt;typename T , typename std::enable_if&lt;__hip_is_tex_surf_channel_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf1DLayeredread ( T *data, hipSurfaceObject_t surfObj, int x, int layer )</p>
-<p>Reads the value from the one-dimensional layered surface at coordinate x and layer index.</p>
-<h2>Template Parameters</h2>
-<p>T - The data type of the surface.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">data - [out] The T type result is stored in this pointer.</li>
-<li style="list-style-type: '· ';">surfObj - [in] The surface descriptor.</li>
-<li style="list-style-type: '· ';">x - [in] The coordinate where the value will be read out.</li>
-<li style="list-style-type: '· ';">layer - [in] The layer index where the value will be read out.</li>
-</ul>
-<p>template&lt;typename T , typename std::enable_if&lt;__hip_is_tex_surf_channel_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf1DLayeredwrite ( T data, hipSurfaceObject_t surfObj, int x, int layer )</p>
-<p>Writes the value data to the one-dimensional layered surface at coordinate x and layer index.</p>
-<h2>Template Parameters</h2>
-<p>T - The data type of the surface.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">data - [in] The T type value is written to surface.</li>
-<li style="list-style-type: '· ';">surfObj - [in] The surface descriptor.</li>
-<li style="list-style-type: '· ';">x - [in] The x coordinate where the data will be written.</li>
-<li style="list-style-type: '· ';">layer - [in] The layer index where the data will be written.</li>
-</ul>
-<p>template&lt;typename T , typename std::enable_if&lt;__hip_is_tex_surf_channel_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf2DLayeredread ( T *data, hipSurfaceObject_t surfObj, int x, int y, int layer )</p>
-<p>Reads the value from the two-dimensional layered surface at coordinate x, y and layer index.</p>
-<h2>Template Parameters</h2>
-<p>T - The data type of the surface.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">data - [out] The T type result is stored in this pointer.</li>
-<li style="list-style-type: '· ';">surfObj - [in] The surface descriptor.</li>
-<li style="list-style-type: '· ';">x - [in] The x coordinate where the value will be read out.</li>
-<li style="list-style-type: '· ';">y - [in] The y coordinate where the value will be read out.</li>
-<li style="list-style-type: '· ';">layer - [in] The layer index where the value will be read out.</li>
-</ul>
-<p>template&lt;typename T , typename std::enable_if&lt;__hip_is_tex_surf_channel_type&lt; T &gt;::value&gt;::type* = nullptr&gt;</p>
-<p>static void surf2DLayeredwrite ( T data, hipSurfaceObject_t surfObj, int x, int y, int layer )</p>
-<p>Writes the value data to the two-dimensional layered surface at coordinate x, y and layer index.</p>
-<h2>Template Parameters</h2>
-<p>T - The data type of the surface.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">data - [in] The T type value is written to surface.</li>
-<li style="list-style-type: '· ';">surfObj - [in] The surface descriptor.</li>
-<li style="list-style-type: '· ';">x - [in] The x coordinate where the data will be written.</li>
-<li style="list-style-type: '· ';">y - [in] The y coordinate where the data will be written.</li>
-<li style="list-style-type: '· ';">layer - [in] The layer index where the data will be written.</li>
-</ul>
-<p>template&lt;typename T , typename std::enable_if&lt;__hip_is_tex_surf_channel_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surfCubemapread ( T *data, hipSurfaceObject_t surfObj, int x, int y, int face )</p>
-<p>Reads the value from the cubemap surface at coordinate x, y and face index.</p>
-<h2>Template Parameters</h2>
-<p>T - The data type of the surface.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">data - [out] The T type result is stored in this pointer.</li>
-<li style="list-style-type: '· ';">surfObj - [in] The surface descriptor.</li>
-<li style="list-style-type: '· ';">x - [in] The x coordinate where the value will be read out.</li>
-<li style="list-style-type: '· ';">y - [in] The y coordinate where the value will be read out.</li>
-<li style="list-style-type: '· ';">face - [in] The face index where the value will be read out.</li>
-</ul>
-<p>template&lt;typename T , typename std::enable_if&lt;__hip_is_tex_surf_channel_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surfCubemapwrite ( T data, hipSurfaceObject_t surfObj, int x, int y, int face )</p>
-<p>Writes the value data to the cubemap surface at coordinate x, y and face index.</p>
-<h2>Template Parameters</h2>
-<p>T - The data type of the surface.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">data - [in] The T type value is written to surface.</li>
-<li style="list-style-type: '· ';">surfObj - [in] The surface descriptor.</li>
-<li style="list-style-type: '· ';">x - [in] The x coordinate where the data will be written.</li>
-<li style="list-style-type: '· ';">y - [in] The y coordinate where the data will be written.</li>
-<li style="list-style-type: '· ';">face - [in] The face index where the data will be written.</li>
-</ul>
-<p>template&lt;typename T , typename std::enable_if&lt;__hip_is_tex_surf_channel_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surfCubemapLayeredread ( T *data, hipSurfaceObject_t surfObj, int x, int y, int face, int layer )</p>
-<p>Reads the value from the layered cubemap surface at coordinate x, y and face, layer index.</p>
-<h2>Template Parameters</h2>
-<p>T - The data type of the surface.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">data - [out] The T type result is stored in this pointer.</li>
-</ul>
-<ul>
-<li style="list-style-type: '· ';">surfObj - [in] The surface descriptor.</li>
-<li style="list-style-type: '· ';">x - [in] The x coordinate where the value will be read out.</li>
-<li style="list-style-type: '· ';">y - [in] The y coordinate where the value will be read out.</li>
-<li style="list-style-type: '· ';">face - [in] The face index where the value will be read out.</li>
-<li style="list-style-type: '· ';">layer - [in] The layer index where the data will be written.</li>
-</ul>
-<p>template&lt;typename T , typename std::enable_if&lt;__hip_is_tex_surf_channel_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surfCubemapLayeredwrite ( T *data, hipSurfaceObject_t surfObj, int x, int y, int face, int layer )</p>
-<p>Writes the value data to the layered cubemap surface at coordinate x, y and face, layer index.</p>
-<h2>Template Parameters</h2>
-<p>T - The data type of the surface.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">data - [in] The T type value to write to the surface.</li>
-<li style="list-style-type: '· ';">surfObj - [in] The surface descriptor.</li>
-<li style="list-style-type: '· ';">x - [in] The x coordinate where the data will be written.</li>
-<li style="list-style-type: '· ';">y - [in] The y coordinate where the data will be written.</li>
-<li style="list-style-type: '· ';">face - [in] The face index where the data will be written.</li>
-<li style="list-style-type: '· ';">layer - [in] The layer index where the data will be written.</li>
-</ul>
-<h2>19.12 Timer functions</h2>
-<p>To read a high-resolution timer from the device, HIP provides the following built-in functions:</p>
-<ul>
-<li style="list-style-type: '· ';">Returning the incremental counter value for every clock cycle on a device:</li>
-</ul>
-<pre><code><_SQL_></code></pre>
-<pre><code>    [clock_t clock()
-    long long int close</code></pre>
-<p>The difference between the values that are returned represents the cycles used.</p>
-<ul>
-<li style="list-style-type: '· ';">Returning the wall clock count at a constant frequency on the device:</li>
-</ul>
-<pre><code>  | long long int w:</code></pre>
-<pre><code>    it will_clock64()</code></pre>
-<p>This can be queried using the HIP API with the hipDeviceAttributeWallClockRate attribute of the device in HIP application code. For example:</p>
-<pre><code>            int wallClkRate = 0; //in kilohertz
-            HIPCHECK(hipDeviceGetAttribute(&wallClkRate, hipDeviceAttributeWallClockRate, _
-            --deviceId));</code></pre>
-<p>Where hipDeviceAttributeWallClockRate is a device attribute. Note that wall clock frequency is a perdevice attribute.</p>
-<p>Note that clock() and clock64() do not work properly on AMD RDNA3 (GFX11) graphic processors.</p>
-<h2>19.13 Atomic functions</h2>
-<p>Atomic functions are run as read-modify-write (RMW) operations that reside in global or shared memory. No other device or thread can observe or modify the memory location during an atomic operation. If multiple instructions from different devices or threads target the same memory location, the instructions are serialized in an undefined order.</p>
-<p>To support system scope atomic operations, you can use the HIP APIs that contain the _system suffix. For example:</p>
-<ul>
-<li style="list-style-type: '· ';">atomicAnd : This function is atomic and coherent within the GPU device running the function</li>
-<li style="list-style-type: '· ';">atomicAnd_system : This function extends the atomic operation from the GPU device to other CPUs and GPU devices in the system.</li>
-</ul>
-<p>HIP supports the following atomic operations.</p>
-<p>Table 1: Atomic operations</p>
-<table><tbody><tr><td>Function int atomicAdd(int* address, int val) int atomicAdd_system(int* address, int val) unsigned int atomicAdd(unsigned int* address,unsigned unsigned int atomicAdd_system(unsigned int* address, unsigned long long atomicAdd(unsigned long long* unsigned long long atomicAdd_system(unsigned long long* float atomicAdd(float* address, float val) float atomicAdd_system(float* address, float val) double atomicAdd(double* address, double val) double atomicAdd_system(double* address, double val) float unsafeAtomicAdd(float* address, float val) float safeAtomicAdd(float* address, float val)</td></tr><tr><td>int val) unsigned int val) address,unsigned long long val)</td></tr><tr><td>address, unsigned long long val) double unsafeAtomicAdd(double* address, double val) double safeAtomicAdd(double* address, double val) int atomicSub(int* address, int val) int atomicSub_system(int* address, int val) unsigned int atomicSub(unsigned int* address,unsigned int val) unsigned int atomicSub_system(unsigned int* address, unsigned int val)</td></tr><tr><td>int atomicExch(int* address, int val)</td></tr><tr><td>int atomicExch_system(int* address, int val) unsigned int atomicExch(unsigned int* address,unsigned int val) unsigned int atomicExch_system(unsigned int* address, unsigned int val)</td></tr><tr><td>unsigned long long atomicExch(unsigned long long int* address,unsigned long val)</td></tr><tr><td>long unsigned long long atomicExch_system(unsigned long long* address, unsigned long</td></tr><tr><td>int long val) unsigned long long atomicExch_system(unsigned long long* address, unsigned long long val)</td></tr><tr><td>float atomicExch(float* address, float val) int atomicMin(int* address, int val)</td></tr><tr><td>int atomicMin_system(int* address, int val) unsigned int atomicMin(unsigned int* address,unsigned int</td></tr><tr><td>val) unsigned int atomicMin_system(unsigned int* address, unsigned int</td></tr><tr><td>val) unsigned long long atomicMin(unsigned long long* address,unsigned long long val)</td></tr><tr><td>atomicMax(int* address, int val) atomicMax_system(int* address, int val)</td></tr><tr><td>int unsigned int atomicMax(unsigned int* address,unsigned int val)</td></tr><tr><td>unsigned int atomicMax_system(unsigned int* address, unsigned int</td></tr><tr><td>int</td></tr><tr><td>val)</td></tr><tr><td>unsigned long long atomicMax(unsigned long long* address,unsigned long long val)</td></tr></tbody></table>
-<table><caption><div class="caption">Table 1 - continued from previous page</div></caption><tbody><tr><td>unsigned int atomicDec(unsigned int* address)</td></tr><tr><td>int atomicCAS(int* address, int compare, int val)</td></tr><tr><td>int atomicCAS_system(int* address, int compare, int val)</td></tr><tr><td>unsigned int atomicCAS(unsigned int* address,unsigned int compare,unsigned int val) unsigned int atomicCAS_system(unsigned int* address, unsigned int compare, unsigned int val) unsigned long long atomicCAS(unsigned long long* address,unsigned long long compare,unsigned long long unsigned long long atomicCAS_system(unsigned long long* address, unsigned long long compare, unsigned int atomicAnd(int* address, int val) int atomicAnd_system(int* address, int val)</td></tr><tr><td>unsigned int atomicAnd(unsigned int* address,unsigned int val) unsigned int atomicAnd_system(unsigned int* address, unsigned int val)</td></tr><tr><td>unsigned long long atomicAnd(unsigned long long* address,unsigned long long val) unsigned long long atomicAnd_system(unsigned long long* address, unsigned long</td></tr><tr><td>long val) int atomicOr(int* address, int val)</td></tr><tr><td>int atomicOr_system(int* address, int val)</td></tr><tr><td>unsigned int atomicOr(unsigned int* address,unsigned int val) unsigned int atomicOr_system(unsigned int* address, unsigned</td></tr><tr><td>int val) unsigned int atomicOr_system(unsigned int* address, unsigned int val)</td></tr><tr><td>unsigned long long atomicOr(unsigned long long int* address,unsigned long long val)</td></tr><tr><td>unsigned long long atomicOr_system(unsigned long long* address, unsigned long long val)</td></tr><tr><td>int atomicXor(int* address, int val)</td></tr><tr><td>int atomicXor_system(int* address, int val)</td></tr><tr><td>unsigned int atomicXor(unsigned int* address,unsigned int val)</td></tr><tr><td>unsigned int atomicXor_system(unsigned int* address, unsigned int val)</td></tr><tr><td>unsigned long long atomicXor(unsigned long long* address,unsigned long long val)</td></tr><tr><td>unsigned long long atomicXor_system(unsigned long long* address, unsigned long long</td></tr><tr><td>val)</td></tr></tbody></table>
-<h2>19.13.1 Unsafe floating-point atomic RMW operations</h2>
-<p>Some HIP devices support fast atomic RMW operations on floating-point values. For example, atomicAdd on singleor double-precision floating-point values may generate a hardware RMW instruction that is faster than emulating the atomic operation using an atomic compare-and-swap (CAS) loop.</p>
-<p>On some devices, fast atomic RMW instructions can produce results that differ from the same functions implemented with atomic CAS loops. For example, some devices will use different rounding or denormal modes, and some devices produce incorrect answers if fast floating-point atomic RMW instructions target fine-grained memory allocations.</p>
-<p>The HIP-Clang compiler offers a compile-time option, so you can choose fast-but potentially unsafe-atomic instructions for your code. On devices that support these instructions, you can include the -munsafe-fp-atomics option. This flag indicates to the compiler that all floating-point atomic function calls are allowed to use an unsafe version, if one exists. For example, on some devices, this flag indicates to the compiler that no floating-point atomicAdd function can target fine-grained memory.</p>
-<p>If you want to avoid using unsafe use a floating-point atomic RMW operations, you can use the -mno-unsafe-fp-atomics option. Note that the compiler default is to not produce unsafe floating-point atomic RMW instructions, so the -mno-unsafe-fp-atomics option is not necessarily required. However, passing this option to the compiler is good practice.</p>
-<p>When you pass -munsafe-fp-atomics or -mno-unsafe-fp-atomics to the compiler's command line, the option is applied globally for the entire compilation. Note that if some of the atomic RMW function calls cannot safely use the faster floating-point atomic RMW instructions, you must use -mno-unsafe-fp-atomics in order to ensure that your atomic RMW function calls produce correct results.</p>
-<p>HIP has four extra functions that you can use to more precisely control which floating-point atomic RMW functions produce unsafe atomic RMW instructions:</p>
-<ul>
-<li style="list-style-type: '· ';">float unsafeAtomicAdd(float* address, float val)</li>
-<li style="list-style-type: '· ';">double unsafeAtomicAdd(double* address, double val) (Always produces fast atomic RMW instructions on devices that have them, even when -mno-unsafe-fp-atomics is used)</li>
-<li style="list-style-type: '· ';">float safeAtomicAdd(float* address, float val)</li>
-<li style="list-style-type: '· ';">double safeAtomicAdd(double* address, double val) (Always produces safe atomic RMW operations, even when -munsafe-fp-atomics is used)</li>
-</ul>
-<h2>19.14 Warp cross-lane functions</h2>
-<p>Threads in a warp are referred to as lanes and are numbered from 0 to warpSize - 1 . Warp cross-lane functions operate across all lanes in a warp. The hardware guarantees that all warp lanes will execute in lockstep, so additional synchronization is unnecessary, and the instructions use no shared memory.</p>
-<p>Note that NVIDIA and AMD devices have different warp sizes. You can use warpSize built-ins in you portable code to query the warp size.</p>
-<p>Tip: Be sure to review HIP code generated from the CUDA path to ensure that it doesn't assume a waveSize of 32. 'Wave-aware' code that assumes a waveSize of 32 can run on a wave-64 machine, but it only utilizes half of the machine's resources.</p>
-<p>To get the default warp size of a GPU device, use hipGetDeviceProperties in you host functions.</p>
-<pre><code>    cudaDeviceProp props;
-    cudaGetDeviceProperties(&props, deviceID);
-    int w = props.warpSize;
-    // implement portable algorithm based on w (rather than assume 32 or 64)</code></pre>
-<p>Only use warpSize built-ins in device functions, and don't assume warpSize to be a compile-time constant.</p>
-<p>Note that assembly kernels may be built for a warp size that is different from the default. All mask values either returned or accepted by these builtins are 64-bit unsigned integer values, even when compiled for a wave-32 device, where all the higher bits are unused. CUDA code ported to HIP requires changes to ensure that the correct type is used.</p>
-<p>Note that the __sync variants are made available in ROCm 6.2, but disabled by default to help with the transition to 64-bit masks. They can be enabled by setting the preprocessor macro HIP_ENABLE_WARP_SYNC_BUILTINS . These builtins will be enabled unconditionally in ROCm 6.3. Wherever possible, the implementation includes a static assert to check that the program source uses the correct type for the mask.</p>
-<h2>19.14.1 Warp vote and ballot functions</h2>
-<pre><code>int __all(int predicate)
-int __any(int predicate)
-unsigned long long __ballot(int predicate)
-unsigned long long __activemask()
-
-int __all_sync(unsigned long long mask, int predicate)</code></pre>
-<p>(continued from previous page)</p>
-<pre><code><_Python_></code></pre>
-<p>You can use __any and __all to get a summary view of the predicates evaluated by the participating lanes.</p>
-<ul>
-<li style="list-style-type: '· ';">__any() : Returns 1 if the predicate is non-zero for any participating lane, otherwise it returns 0.</li>
-<li style="list-style-type: '· ';">__all() : Returns 1 if the predicate is non-zero for all participating lanes, otherwise it returns 0.</li>
-</ul>
-<p>To determine if the target platform supports the any/all instruction, you can use the hasWarpVote device property or the HIP_ARCH_HAS_WARP_VOTE compiler definition.</p>
-<p>__ballot returns a bit mask containing the 1-bit predicate value from each lane. The nth bit of the result contains the 1 bit contributed by the nth warp lane.</p>
-<p>__activemask() returns a bit mask of currently active warp lanes. The nth bit of the result is 1 if the nth warp lane is active.</p>
-<p>Note that the __ballot and __activemask builtins in HIP have a 64-bit return value (unlike the 32-bit value returned by the CUDA builtins). Code ported from CUDA should be adapted to support the larger warp sizes that the HIP version requires.</p>
-<p>Applications can test whether the target platform supports the __ballot or __activemask instructions using the hasWarpBallot device property in host code or the HIP_ARCH_HAS_WARP_BALLOT macro defined by the compiler for device code.</p>
-<p>The _sync variants require a 64-bit unsigned integer mask argument that specifies the lanes in the warp that will participate in cross-lane communication with the calling lane. Each participating thread must have its own bit set in its mask argument, and all active threads specified in any mask argument must execute the same call with the same mask, otherwise the result is undefined.</p>
-<h2>19.14.2 Warp match functions</h2>
-<pre><code>    unsigned long long __match_any(T value)
-    unsigned long long __match_all(T value, int *pred)
-
-    unsigned long long __match_any_sync(unsigned long long mask, T value)
-    unsigned long long __match_all_sync(unsigned long long mask, T value, int *pred)</code></pre>
-<p>T can be a 32-bit integer type, 64-bit integer type or a single precision or double precision floating point type.</p>
-<p>__match_any returns a bit mask containing a 1-bit for every participating lane if and only if that lane has the same value in value as the current lane, and a 0-bit for all other lanes.</p>
-<p>__match_all returns a bit mask containing a 1-bit for every participating lane if and only if they all have the same value in value as the current lane, and a 0-bit for all other lanes. The predicate pred is set to true if and only if all participating threads have the same value in value .</p>
-<p>The _sync variants require a 64-bit unsigned integer mask argument that specifies the lanes in the warp that will participate in cross-lane communication with the calling lane. Each participating thread must have its own bit set in its mask argument, and all active threads specified in any mask argument must execute the same call with the same mask, otherwise the result is undefined.</p>
-<h2>19.14.3 Warp shuffle functions</h2>
-<p>The default width is warpSize (see Warp cross-lane functions ). Half-float shuffles are not supported.</p>
-<pre><code>            The default width is warpSize (see Warp cross-lane functions). Half-float shuffles are not supported.
-                                                                                                                                                                                                        
-                                                                                                                                                                                                      
-int       __shfl           (T var,     int srcLane,  int width=warpSize);</code></pre>
-<p>T can be a 32-bit integer type, 64-bit integer type or a single precision or double precision floating point type.</p>
-<p>The _sync variants require a 64-bit unsigned integer mask argument that specifies the lanes in the warp that will participate in cross-lane communication with the calling lane. Each participating thread must have its own bit set in its mask argument, and all active threads specified in any mask argument must execute the same call with the same mask, otherwise the result is undefined.</p>
-<h2>19.15 Cooperative groups functions</h2>
-<p>You can use cooperative groups to synchronize groups of threads. Cooperative groups also provide a way of communicating between groups of threads at a granularity that is different from the block.</p>
-<p>HIP supports the following kernel language cooperative groups types and functions:</p>
-<table><caption><div class="caption">Table 2: Cooperative groups functions</div></caption><tbody><tr><th>Function</th><th>Supported in HIP</th><th>Supported in CUDA</th></tr><tr><th>void thread_group.sync();</th><td>✓</td><td>✓</td></tr><tr><th>unsigned thread_group.size();</th><td>✓</td><td>✓</td></tr><tr><th>unsigned thread_group.thread_rank()</th><td>✓</td><td>✓</td></tr><tr><th>bool thread_group.is_valid();</th><td>✓</td><td>✓</td></tr><tr><th>grid_group this_grid()</th><td>✓</td><td>✓</td></tr><tr><th>void grid_group.sync()</th><td>✓</td><td>✓</td></tr><tr><th>unsigned grid_group.size()</th><td>✓</td><td>✓</td></tr><tr><th>unsigned grid_group.thread_rank()</th><td>✓</td><td>✓</td></tr><tr><th>bool grid_group.is_valid()</th><td>✓</td><td>✓</td></tr><tr><th>multi_grid_group this_multi_grid()</th><td>✓</td><td>✓</td></tr><tr><th>void multi_grid_group.sync()</th><td>✓</td><td>✓</td></tr><tr><th>unsigned multi_grid_group.size()</th><td>✓</td><td>✓</td></tr><tr><th>unsigned multi_grid_group.thread_rank()</th><td>✓</td><td>✓</td></tr><tr><th>bool multi_grid_group.is_valid()</th><td>✓</td><td>✓</td></tr><tr><th>unsigned multi_grid_group.num_grids()</th><td>✓</td><td>✓</td></tr><tr><th>unsigned multi_grid_group.grid_rank()</th><td>✓</td><td>✓</td></tr><tr><th>thread_block this_thread_block()</th><td>✓</td><td>✓</td></tr><tr><th>multi_grid_group this_multi_grid()</th><td>✓</td><td>✓</td></tr><tr><th>void multi_grid_group.sync()</th><td>✓</td><td>✓</td></tr><tr><th>void thread_block.sync()</th><td>✓</td><td>✓</td></tr><tr><th>unsigned thread_block.size()</th><td>✓</td><td>✓</td></tr><tr><th>unsigned thread_block.thread_rank()</th><td>✓</td><td>✓</td></tr><tr><th>bool thread_block.is_valid()</th><td>✓</td><td>✓</td></tr><tr><th>dim3 thread_block.group_index()</th><td>✓</td><td>✓</td></tr><tr><th>dim3 thread_block.thread_index()</th><td>✓</td><td>✓</td></tr></tbody></table>
-<p>For further information, check Cooperative Groups API or Cooperative Groups how to .</p>
-<h2>19.16 Warp matrix functions</h2>
-<p>Warp matrix functions allow a warp to cooperatively operate on small matrices that have elements spread over lanes in an unspecified manner.</p>
-<p>HIP does not support kernel language warp matrix types or functions.</p>
-<table><caption><div class="caption">Table 3: Warp matrix functions</div></caption><tbody><tr><th>Function</th><th>Sup- ported in HIP</th><th>Supported in CUDA</th></tr><tr><td>void load_matrix_sync(fragment&lt;...&gt; &amp;a, const T* mptr, unsigned lda)</td><td></td><td>✓</td></tr><tr><td>void load_matrix_sync(fragment&lt;...&gt; &amp;a, const T* mptr, unsigned lda, layout_t layout)</td><td></td><td>✓</td></tr><tr><td>void store_matrix_sync(T* mptr, fragment&lt;...&gt; &amp;a, unsigned lda, layout_t layout)</td><td></td><td>✓</td></tr><tr><td>void fill_fragment(fragment&lt;...&gt; &amp;a, const T &amp;value) void mma_sync(fragment&lt;...&gt; &amp;d, const fragment&lt;...&gt; &amp;a,</td><td></td><td>✓</td></tr><tr><td>const fragment&lt;...&gt; &amp;b, const fragment&lt;...&gt; &amp;c , bool sat)</td><td></td><td>✓</td></tr></tbody></table>
-<h2>19.17 Independent thread scheduling</h2>
-<p>Certain architectures that support CUDA allow threads to progress independently of each other. This independent thread scheduling makes intra-warp synchronization possible.</p>
-<p>HIP does not support this type of scheduling.</p>
-<h2>19.18 Profiler Counter Function</h2>
-<p>The CUDA __prof_trigger() instruction is not supported.</p>
-<h2>19.19 Assert</h2>
-<p>The assert function is supported in HIP. Assert function is used for debugging purpose, when the input expression equals to zero, the execution will be stopped.</p>
-<pre><code>|void assert(int ir</code></pre>
-<pre><code>    input()</code></pre>
-<p>There are two kinds of implementations for assert functions depending on the use sceneries, - One is for the host version of assert, which is defined in assert.h , - Another is the device version of assert, which is implemented in hip/hip_runtime.h . Users need to include assert.h to use assert . For assert to work in both device and host functions, users need to include "hip/hip_runtime.h" .</p>
-<p>HIP provides the function abort() which can be used to terminate the application when terminal failures are detected. It is implemented using the __builtin_trap() function.</p>
-<p>This function produces a similar effect of using asm("trap") in the CUDA code.</p>
-<p>Note: In HIP, the function terminates the entire application, while in CUDA, asm("trap") only terminates the dispatch and the application continues to run.</p>
-<h2>19.20 printf</h2>
-<p>printf function is supported in HIP. The following is a simple example to print information in the kernel.</p>
-<pre><code>                                                                                                                                                                                                       
-#include <hip/hip_runtime.h>
-
-    __global__ void run_printf() { printf("Hello World\n"); }
-
-    int main() {
-      run_printf<<<dim3(1), dim3(1), 0, 0>>>();
-    }</code></pre>
-<h2>19.21 Device-Side Dynamic Global Memory Allocation</h2>
-<p>Device-side dynamic global memory allocation is under development. HIP now includes a preliminary implementation of malloc and free that can be called from device functions.</p>
-<h2>19.22 __launch_bounds__</h2>
-<p>GPU multiprocessors have a fixed pool of resources (primarily registers and shared memory) which are shared by the actively running warps. Using more resources can increase IPC of the kernel but reduces the resources available for other warps and limits the number of warps that can be simultaneously running. Thus GPUs have a complex relationship between resource usage and performance.</p>
-<p>__launch_bounds__ allows the application to provide usage hints that influence the resources (primarily registers) used by the generated code. It is a function attribute that must be attached to a __global__ function:</p>
-<pre><code><_Cython_></code></pre>
-<p>__launch_bounds__ supports two parameters: - MAX_THREADS_PER_BLOCK - The programmers guarantees that kernel will be launched with threads less than MAX_THREADS_PER_BLOCK. (On NVCC this maps to the . maxntid PTX directive). If no launch_bounds is specified, MAX_THREADS_PER_BLOCK is the maximum block size supported by the device (typically 1024 or larger). Specifying MAX_THREADS_PER_BLOCK less than the maximum effectively allows the compiler to use more resources than a default unconstrained compilation that supports all possible block sizes at launch time. The threads-per-block is the product of ( blockDim.x * blockDim. y * blockDim.z ). - MIN_WARPS_PER_EXECUTION_UNIT - directs the compiler to minimize resource usage so that the requested number of warps can be simultaneously active on a multi-processor. Since active warps compete for the same fixed pool of resources, the compiler must reduce resources required by each warp(primarily registers). MIN_WARPS_PER_EXECUTION_UNIT is optional and defaults to 1 if not specified. Specifying a MIN_WARPS_PER_EXECUTION_UNIT greater than the default 1 effectively constrains the compiler's resource usage.</p>
-<p>When launch kernel with HIP APIs, for example, hipModuleLaunchKernel() , HIP will do validation to make sure input kernel dimension size is not larger than specified launch_bounds. In case exceeded, HIP would return launch failure, if AMD_LOG_LEVEL is set with proper value (for details, please refer to docs/markdown/hip_logging. md ), detail information will be shown in the error log message, including launch parameters of kernel dim size, launch bounds, and the name of the faulting kernel. It's helpful to figure out which is the faulting kernel, besides, the kernel dim size and launch bounds values will also assist in debugging such failures.</p>
-<h2>19.22.1 Compiler Impact</h2>
-<p>The compiler uses these parameters as follows: - The compiler uses the hints only to manage register usage, and does not automatically reduce shared memory or other resources. - Compilation fails if compiler cannot generate a kernel which meets the requirements of the specified launch bounds. - From MAX_THREADS_PER_BLOCK, the compiler derives the maximum number of warps/block that can be used at launch time. Values of MAX_THREADS_PER_BLOCK less than the default allows the compiler to use a larger pool of registers : each warp uses registers, and this hint constrains the launch to a warps/block size which is less than maximum. - From MIN_WARPS_PER_EXECUTION_UNIT, the compiler derives a maximum number of registers that can be used by the kernel (to meet the required #simultaneous active blocks). If MIN_WARPS_PER_EXECUTION_UNIT is 1, then the kernel can use all registers supported by the multiprocessor. - The compiler ensures that the registers used in the kernel is less than both allowed maximums, typically by spilling registers (to shared or global memory), or by using more instructions. - The compiler may use heuristics to increase register usage, or may simply be able to avoid spilling. The MAX_THREADS_PER_BLOCK</p>
-<p>is particularly useful in this cases, since it allows the compiler to use more registers and avoid situations where the compiler constrains the register usage (potentially spilling) to meet the requirements of a large block size that is never used at launch time.</p>
-<h2>19.22.2 CU and EU Definitions</h2>
-<p>A compute unit (CU) is responsible for executing the waves of a work-group. It is composed of one or more execution units (EU) which are responsible for executing waves. An EU can have enough resources to maintain the state of more than one executing wave. This allows an EU to hide latency by switching between waves in a similar way to symmetric multithreading on a CPU. In order to allow the state for multiple waves to fit on an EU, the resources used by a single wave have to be limited. Limiting such resources can allow greater latency hiding, but can result in having to spill some register state to memory. This attribute allows an advanced developer to tune the number of waves that are capable of fitting within the resources of an EU. It can be used to ensure at least a certain number will fit to help hide latency, and can also be used to ensure no more than a certain number will fit to limit cache thrashing.</p>
-<h2>19.22.3 Porting from CUDA __launch_bounds</h2>
-<p>CUDA defines a __launch_bounds which is also designed to control occupancy:</p>
-<ul>
-<li>__launch_bounds(MAX_THREADS_PER_BLOCK, MIN_BLOCKS_PER_MULTIPROCESSOR)</li>
-<li style="list-style-type: '· ';">The second parameter __launch_bounds parameters must be converted to the format used __hip_launch_bounds, which uses warps and execution-units rather than blocks and multi-processors (this conversion is performed automatically by HIPIFY tools).</li>
-</ul>
-<pre><code>                                                                                                                                                                                                        | MIN_WARPS_PER_EXECUTION_UNIT  =  (MIN_BLOCKS_PER_MULTIPROCESSOR  *  MAX_THREADS_PER_BLOCK)  /_\                                                                                                                                                                                                       
-                                                                                                                                                                                                        :                                                                                                                                                                                                        --                                                                                                                                                                                                        <                                                                                                                                                                                                        </                                                                                                                                                                                                        >                                                                                                                                                                                                        }</code></pre>
-<p>The key differences in the interface are: - Warps (rather than blocks): The developer is trying to tell the compiler to control resource utilization to guarantee some amount of active Warps/EU for latency hiding. Specifying active warps in terms of blocks appears to hide the micro-architectural details of the warp size, but makes the interface more confusing since the developer ultimately needs to compute the number of warps to obtain the desired level of control. - Execution Units (rather than multiprocessor): The use of execution units rather than multiprocessors provides support for architectures with multiple execution units/multi-processor. For example, the AMD GCN architecture has 4 execution units per multiprocessor. The hipDeviceProps has a field executionUnitsPerMultiprocessor . Platform-specific coding techniques such as #ifdef can be used to specify different launch_bounds for NVCC and HIP-Clang platforms, if desired.</p>
-<h2>19.22.4 maxregcount</h2>
-<p>Unlike NVCC, HIP-Clang does not support the --maxregcount option. Instead, users are encouraged to use the hip_launch_bounds directive since the parameters are more intuitive and portable than micro-architecture details like registers, and also the directive allows per-kernel control rather than an entire file. hip_launch_bounds works on both HIP-Clang and NVCC targets.</p>
-<h2>19.23 Asynchronous Functions</h2>
-<h2>19.23.1 Memory stream</h2>
-<p>typedef void (* hipStreamCallback_t )(hipStream_t stream, hipError_t status, void *userData)</p>
-<p>Stream CallBack struct hipError_t hipStreamCreate ( hipStream_t *stream )</p>
-<p>Create an asynchronous stream.</p>
-<p>Create a new asynchronous stream. stream returns an opaque handle that can be used to reference the newly created stream in subsequent hipStream* commands. The stream is allocated on the heap and will remain allocated even if the handle goes out-of-scope. To release the memory used by the stream, application must call hipStreamDestroy.</p>
-<h2>See also:</h2>
-<p>hipStreamCreateWithFlags , hipStreamCreateWithPriority , hipStreamSynchronize , hipStreamWaitEvent , hipStreamDestroy</p>
-<h2>Parameters</h2>
-<p>stream -[inout] Valid pointer to hipStream_t. This function writes the memory with the newly created stream.</p>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue</p>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipError_t hipStreamCreateWithFlags ( hipStream_t *stream, unsigned int flags )</p>
-<p>Create an asynchronous stream.</p>
-<p>Create a new asynchronous stream. stream returns an opaque handle that can be used to reference the newly created stream in subsequent hipStream* commands. The stream is allocated on the heap and will remain allocated even if the handle goes out-of-scope. To release the memory used by the stream, application must call hipStreamDestroy. Flags controls behavior of the stream. See hipStreamDefault, hipStreamNonBlocking.</p>
-<h2>See also:</h2>
-<p>hipStreamCreate , hipStreamCreateWithPriority , hipStreamSynchronize , hipStreamWaitEvent , hipStreamDestroy</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">stream -[inout] Pointer to new stream</li>
-<li style="list-style-type: '· ';">flags -[in] to control stream creation.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue</p>
-<p>hipError_t hipStreamCreateWithPriority ( hipStream_t *stream, unsigned int flags, int priority )</p>
-<p>Create an asynchronous stream with the specified priority.</p>
-<p>Create a new asynchronous stream with the specified priority. stream returns an opaque handle that can be used to reference the newly created stream in subsequent hipStream* commands. The stream is allocated on the heap and will remain allocated even if the handle goes out-of-scope. To release the memory used by the stream, application must call hipStreamDestroy. Flags controls behavior of the stream. See hipStreamDefault, hipStreamNonBlocking.</p>
-<h2>See also:</h2>
-<p>hipStreamCreate , hipStreamSynchronize , hipStreamWaitEvent , hipStreamDestroy</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">stream -[inout] Pointer to new stream</li>
-<li style="list-style-type: '· ';">flags -[in] to control stream creation.</li>
-<li style="list-style-type: '· ';">priority -[in] of the stream. Lower numbers represent higher priorities.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipError_t hipDeviceGetStreamPriorityRange ( int *leastPriority, int *greatestPriority )</p>
-<p>Returns numerical values that correspond to the least and greatest stream priority.</p>
-<p>Returns in *leastPriority and *greatestPriority the numerical values that correspond to the least and greatest stream priority respectively. Stream priorities follow a convention where lower numbers imply greater priorities. The range of meaningful stream priorities is given by [*greatestPriority, *leastPriority]. If the user attempts to create a stream with a priority value that is outside the meaningful range as specified by this API, the priority is automatically clamped to within the valid range.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">leastPriority -[inout] pointer in which value corresponding to least priority is returned.</li>
-<li style="list-style-type: '· ';">greatestPriority -[inout] pointer in which value corresponding to greatest priority is returned.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess hipError_t hipStreamDestroy ( hipStream_t stream )</p>
-<p>Destroys the specified stream.</p>
-<p>Destroys the specified stream.</p>
-<p>If commands are still executing on the specified stream, some may complete execution before the queue is deleted.</p>
-<p>The queue may be destroyed while some commands are still inflight, or may wait for all commands queued to the stream before destroying it.</p>
-<h2>See also:</h2>
-<p>hipStreamCreate , hipStreamCreateWithFlags , hipStreamCreateWithPriority , hipStreamQuery , hipStreamWaitEvent , hipStreamSynchronize</p>
-<h2>Parameters</h2>
-<p>stream -[in] stream identifier.</p>
-<h2>Returns</h2>
-<p>hipSuccess hipErrorInvalidHandle</p>
-<h2>hipError_t hipStreamQuery ( hipStream_t stream )</h2>
-<p>Return hipSuccess if all of the operations in the specified stream have completed, or hipErrorNotReady if not.</p>
-<p>This is thread-safe and returns a snapshot of the current state of the queue. However, if other host threads are sending work to the stream, the status may change immediately after the function is called. It is typically used for debug.</p>
-<h2>See also:</h2>
-<p>hipStreamCreate , hipStreamCreateWithFlags , hipStreamCreateWithPriority , hipStreamWaitEvent , hipStreamSynchronize , hipStreamDestroy</p>
-<h2>Parameters</h2>
-<p>stream -[in] stream to query</p>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorNotReady, hipErrorInvalidHandle</p>
-<h2>hipError_t hipStreamSynchronize ( hipStream_t stream )</h2>
-<p>Wait for all commands in stream to complete.</p>
-<p>This command is host-synchronous : the host will block until the specified stream is empty.</p>
-<p>This command follows standard null-stream semantics. Specifically, specifying the null stream will cause the command to wait for other streams on the same device to complete all pending operations.</p>
-<p>This command honors the hipDeviceLaunchBlocking flag, which controls whether the wait is active or blocking.</p>
-<h2>See also:</h2>
-<p>hipStreamCreate , hipStreamCreateWithFlags , hipStreamCreateWithPriority , hipStreamWaitEvent , hipStreamDestroy</p>
-<h2>Parameters</h2>
-<p>stream -[in] stream identifier.</p>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidHandle</p>
-<p>hipError_t hipStreamWaitEvent ( hipStream_t stream, hipEvent_t event, unsigned int flags )</p>
-<p>Make the specified compute stream wait for an event.</p>
-<p>This function inserts a wait operation into the specified stream. All future work submitted to stream will wait until event reports completion before beginning execution.</p>
-<p>This function only waits for commands in the current stream to complete. Notably, this function does not implicitly wait for commands in the default stream to complete, even if the specified stream is created with hipStreamNonBlocking = 0.</p>
-<h2>See also:</h2>
-<p>hipStreamCreate , hipStreamCreateWithFlags , hipStreamCreateWithPriority , hipStreamSynchronize , hipStreamDestroy</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">stream -[in] stream to make wait.</li>
-<li style="list-style-type: '· ';">event -[in] event to wait on</li>
-<li style="list-style-type: '· ';">flags -[in] control operation [must be 0]</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidHandle hipError_t hipStreamGetFlags ( hipStream_t stream, unsigned int *flags )</p>
-<p>Return flags associated with this stream.</p>
-<p>Return flags associated with this stream in * flags .</p>
-<h2>See also:</h2>
-<p>hipStreamCreateWithFlags</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">stream -[in] stream to be queried</li>
-<li style="list-style-type: '· ';">flags -[inout] Pointer to an unsigned integer in which the stream's flags are returned</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorInvalidHandle</p>
-<h2>Returns</h2>
-<p>hipSuccess hipErrorInvalidValue hipErrorInvalidHandle hipError_t hipStreamGetPriority ( hipStream_t stream, int *priority )</p>
-<p>Query the priority of a stream.</p>
-<p>Query the priority of a stream. The priority is returned in in priority.</p>
-<h2>See also:</h2>
-<p>hipStreamCreateWithFlags</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">stream -[in] stream to be queried</li>
-<li style="list-style-type: '· ';">priority -[inout] Pointer to an unsigned integer in which the stream's priority is returned</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorInvalidHandle</p>
-<h2>Returns</h2>
-<p>hipSuccess hipErrorInvalidValue hipErrorInvalidHandle hipError_t hipStreamGetDevice ( hipStream_t stream, hipDevice_t *device )</p>
-<p>Get the device assocaited with the stream.</p>
-<h2>See also:</h2>
-<p>hipStreamCreate , hipStreamDestroy , hipDeviceGetStreamPriorityRange</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">stream -[in] stream to be queried</li>
-<li style="list-style-type: '· ';">device -[out] device associated with the stream</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorContextIsDestroyed, hipErrorInvalidHandle, hipErrorNotInitialized, hipErrorDeinitialized, hipErrorInvalidContext hipError_t hipExtStreamCreateWithCUMask ( hipStream_t *stream, uint32_t cuMaskSize, const uint32_t *cuMask )</p>
-<p>Create an asynchronous stream with the specified CU mask.</p>
-<p>Create a new asynchronous stream with the specified CU mask. stream returns an opaque handle that can be used to reference the newly created stream in subsequent hipStream* commands. The stream is allocated on the heap and will remain allocated even if the handle goes out-of-scope. To release the memory used by the stream, application must call hipStreamDestroy.</p>
-<h2>See also:</h2>
-<p>hipStreamCreate , hipStreamSynchronize , hipStreamWaitEvent , hipStreamDestroy</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">stream -[inout] Pointer to new stream</li>
-<li style="list-style-type: '· ';">cuMaskSize -[in] Size of CU mask bit array passed in.</li>
-<li style="list-style-type: '· ';">cuMask -[in] Bit-vector representing the CU mask. Each active bit represents using one CU. The first 32 bits represent the first 32 CUs, and so on. If its size is greater than physical CU number (i.e., multiProcessorCount member of hipDeviceProp_t), the extra elements are ignored. It is user's responsibility to make sure the input is meaningful.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidHandle, hipErrorInvalidValue hipError_t hipExtStreamGetCUMask ( hipStream_t stream, uint32_t cuMaskSize, uint32_t *cuMask )</p>
-<p>Get CU mask associated with an asynchronous stream.</p>
-<h2>See also:</h2>
-<p>hipStreamCreate , hipStreamSynchronize , hipStreamWaitEvent , hipStreamDestroy</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">stream -[in] stream to be queried</li>
-<li style="list-style-type: '· ';">cuMaskSize -[in] number of the block of memories (uint32_t *) allocated by user</li>
-<li style="list-style-type: '· ';">cuMask -[out] Pointer to a pre-allocated block of memories (uint32_t *) in which the stream's CU mask is returned. The CU mask is returned in a chunck of 32 bits where each active bit represents one active CU</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidHandle, hipErrorInvalidValue hipError_t hipStreamAddCallback ( hipStream_t stream, hipStreamCallback_t callback, void *userData, unsigned int flags )</p>
-<p>Adds a callback to be called on the host after all currently enqueued items in the stream have completed. For each hipStreamAddCallback call, a callback will be executed exactly once. The callback will block later work in the stream until it is finished.</p>
-<h2>See also:</h2>
-<p>hipStreamCreate , hipStreamCreateWithFlags , hipStreamQuery , hipStreamSynchronize , hipStreamWaitEvent , hipStreamDestroy , hipStreamCreateWithPriority</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">stream -[in] - Stream to add callback to</li>
-<li style="list-style-type: '· ';">callback -[in] - The function to call once preceding stream operations are complete</li>
-<li style="list-style-type: '· ';">userData -[in] - User specified data to be passed to the callback function</li>
-<li style="list-style-type: '· ';">flags -[in] - Reserved for future use, must be 0</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidHandle, hipErrorNotSupported static inline hipError_t hipMallocAsync ( void **dev_ptr, size_t size, hipMemPool_t mem_pool, hipStream_t stream )</p>
-<p>C++ wrappers for allocations from a memory pool.</p>
-<p>This section describes wrappers for stream Ordered allocation from memory pool functions of HIP runtime API.</p>
-<p>This is an alternate C++ calls for hipMallocFromPoolAsync made available through function overloading.</p>
-<h2>See also:</h2>
-<p>hipMallocFromPoolAsync</p>
-<p>Note: APIs in this section are implemented on Linux, under development on Windows.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<h2>template&lt;class T &gt;</h2>
-<p>static inline hipError_t hipMallocAsync ( T **dev_ptr, size_t size, hipMemPool_t mem_pool, hipStream_t stream C++ wrappers for allocations from a memory pool on the stream.</p>
-<p>This is an alternate C++ calls for hipMallocFromPoolAsync made available through function overloading.</p>
-<h2>See also:</h2>
-<p>hipMallocFromPoolAsync</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<h2>template&lt;class T &gt;</h2>
-<p>static inline hipError_t hipMallocAsync ( T **dev_ptr, size_t size, hipStream_t stream )</p>
-<p>C++ wrappers for allocations from a memory pool.</p>
-<p>This is an alternate C++ calls for hipMallocFromPoolAsync made available through function overloading.</p>
-<h2>See also:</h2>
-<p>hipMallocFromPoolAsync</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<h2>template&lt;class T &gt;</h2>
-<p>static inline hipError_t hipMallocFromPoolAsync ( T **dev_ptr, size_t size, hipMemPool_t mem_pool, hipStream_t stream )</p>
-<p>C++ wrappers for allocations from a memory pool.</p>
-<p>This is an alternate C++ calls for hipMallocFromPoolAsync made available through function overloading.</p>
-<h2>See also:</h2>
-<p>hipMallocFromPoolAsync</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>)</p>
-<p>hipError_t hipMallocAsync ( void **dev_ptr, size_t size, hipStream_t stream )</p>
-<p>Allocates memory with stream ordered semantics.</p>
-<p>Inserts a memory allocation operation into stream . A pointer to the allocated memory is returned immediately in *dptr. The allocation must not be accessed until the allocation operation completes. The allocation comes from the memory pool associated with the stream's device.</p>
-<h2>See also:</h2>
-<p>hipMallocFromPoolAsync , hipFreeAsync , hipMemPoolTrimTo , hipMemPoolGetAttribute , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess , hipMemPoolGetAccess</p>
-<p>Note: The default memory pool of a device contains device memory from that device.</p>
-<p>Note: Basic stream ordering allows future work submitted into the same stream to use the allocation. Stream query, stream synchronize, and HIP events can be used to guarantee that the allocation operation completes before work submitted in a separate stream runs.</p>
-<p>Note: During stream capture, this function results in the creation of an allocation node. In this case, the allocation is owned by the graph instead of the memory pool. The memory pool's properties are used to set the node's creation parameters.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dev_ptr -[out] Returned device pointer of memory allocation</li>
-<li style="list-style-type: '· ';">size -[in] Number of bytes to allocate</li>
-<li style="list-style-type: '· ';">stream -[in] The stream establishing the stream ordering contract and the memory pool to allocate from</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotSupported, hipErrorOutOfMemory hipError_t hipFreeAsync ( void *dev_ptr, hipStream_t stream )</p>
-<p>Frees memory with stream ordered semantics.</p>
-<p>Inserts a free operation into stream . The allocation must not be used after stream execution reaches the free. After this API returns, accessing the memory from any subsequent work launched on the GPU or querying its pointer attributes results in undefined behavior.</p>
-<h2>See also:</h2>
-<p>hipMallocFromPoolAsync , hipMallocAsync , hipMemPoolTrimTo , hipMemPoolGetAttribute , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess , hipMemPoolGetAccess</p>
-<p>Note: During stream capture, this function results in the creation of a free node and must therefore be passed the address of a graph allocation.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dev_ptr -[in] Pointer to device memory to free</li>
-<li style="list-style-type: '· ';">stream -[in] The stream, where the destruciton will occur according to the execution order</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError_t hipMemPoolTrimTo ( hipMemPool_t mem_pool, size_t min_bytes_to_hold )</p>
-<p>Releases freed memory back to the OS.</p>
-<p>Releases memory back to the OS until the pool contains fewer than min_bytes_to_keep reserved bytes, or there is no more memory that the allocator can safely release. The allocator cannot release OS allocations that back outstanding asynchronous allocations. The OS allocations may happen at different granularity from the user allocations.</p>
-<h2>See also:</h2>
-<p>hipMallocFromPoolAsync , hipMallocAsync , hipFreeAsync , hipMemPoolGetAttribute , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess , hipMemPoolGetAccess</p>
-<p>Note: Allocations that have not been freed count as outstanding.</p>
-<p>Note: Allocations that have been asynchronously freed but whose completion has not been observed on the host (eg. by a synchronize) can count as outstanding.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">mem_pool -[in] The memory pool to trim allocations</li>
-<li style="list-style-type: '· ';">min_bytes_to_hold -[in] If the pool has less than min_bytes_to_hold reserved, then the TrimTo operation is a no-op. Otherwise the memory pool will contain at least min_bytes_to_hold bytes reserved after the operation.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipError_t hipMemPoolSetAttribute ( hipMemPool_t mem_pool, hipMemPoolAttr attr, void *value )</p>
-<p>Sets attributes of a memory pool.</p>
-<p>Supported attributes are:</p>
-<ul>
-<li style="list-style-type: '· ';">hipMemPoolAttrReleaseThreshold: (value type = cuuint64_t) Amount of reserved memory in bytes to hold onto before trying to release memory back to the OS. When more than the release threshold bytes of memory are held by the memory pool, the allocator will try to release memory back to the OS on the next call to stream, event or context synchronize. (default 0)</li>
-<li style="list-style-type: '· ';">hipMemPoolReuseFollowEventDependencies: (value type = int) Allow hipMallocAsync to use memory asynchronously freed in another stream as long as a stream ordering dependency of the allocating stream on the free action exists. HIP events and null stream interactions can create the required stream ordered dependencies. (default enabled)</li>
-<li style="list-style-type: '· ';">hipMemPoolReuseAllowOpportunistic: (value type = int) Allow reuse of already completed frees when there is no dependency between the free and allocation. (default enabled)</li>
-<li style="list-style-type: '· ';">hipMemPoolReuseAllowInternalDependencies: (value type = int) Allow hipMallocAsync to insert new stream dependencies in order to establish the stream ordering required to reuse a piece of memory released by hipFreeAsync (default enabled).</li>
-</ul>
-<h2>See also:</h2>
-<p>hipMallocFromPoolAsync , hipMallocAsync , hipFreeAsync , hipMemPoolGetAttribute , hipMemPoolTrimTo , hipDeviceSetMemPool, hipMemPoolSetAccess , hipMemPoolGetAccess</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">mem_pool -[in] The memory pool to modify</li>
-<li style="list-style-type: '· ';">attr -[in] The attribute to modify</li>
-<li style="list-style-type: '· ';">value -[in] Pointer to the value to assign</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue</p>
-<p>hipError_t hipMemPoolGetAttribute ( hipMemPool_t mem_pool, hipMemPoolAttr attr, void *value )</p>
-<p>Gets attributes of a memory pool.</p>
-<p>Supported attributes are:</p>
-<ul>
-<li style="list-style-type: '· ';">hipMemPoolAttrReleaseThreshold: (value type = cuuint64_t) Amount of reserved memory in bytes to hold onto before trying to release memory back to the OS. When more than the release threshold bytes of memory are held by the memory pool, the allocator will try to release memory back to the OS on the next call to stream, event or context synchronize. (default 0)</li>
-<li style="list-style-type: '· ';">hipMemPoolReuseFollowEventDependencies: (value type = int) Allow hipMallocAsync to use memory asynchronously freed in another stream as long as a stream ordering dependency of the allocating stream on the free action exists. HIP events and null stream interactions can create the required stream ordered dependencies. (default enabled)</li>
-<li style="list-style-type: '· ';">hipMemPoolReuseAllowOpportunistic: (value type = int) Allow reuse of already completed frees when there is no dependency between the free and allocation. (default enabled)</li>
-<li style="list-style-type: '· ';">hipMemPoolReuseAllowInternalDependencies: (value type = int) Allow hipMallocAsync to insert new stream dependencies in order to establish the stream ordering required to reuse a piece of memory released by hipFreeAsync (default enabled).</li>
-</ul>
-<h2>See also:</h2>
-<p>hipMallocFromPoolAsync , hipMallocAsync , hipFreeAsync , hipMemPoolTrimTo , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess , hipMemPoolGetAccess</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">mem_pool -[in] The memory pool to get attributes of</li>
-<li style="list-style-type: '· ';">attr -[in] The attribute to get</li>
-<li style="list-style-type: '· ';">value -[in] Retrieved value</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipError_t hipMemPoolSetAccess ( hipMemPool_t mem_pool, const hipMemAccessDesc *desc_list, size_t count ) Controls visibility of the specified pool between devices.</p>
-<h2>See also:</h2>
-<p>hipMallocFromPoolAsync , hipMallocAsync , hipFreeAsync , hipMemPoolGetAttribute , hipMemPoolTrimTo , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolGetAccess</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">mem_pool -[in] Memory pool for acccess change</li>
-<li style="list-style-type: '· ';">desc_list -[in] Array of access descriptors. Each descriptor instructs the access to enable for a single gpu</li>
-<li style="list-style-type: '· ';">count -[in] Number of descriptors in the map array.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipError_t hipMemPoolGetAccess ( hipMemAccessFlags *flags, hipMemPool_t mem_pool, hipMemLocation *location )</p>
-<p>Returns the accessibility of a pool from a device.</p>
-<p>Returns the accessibility of the pool's memory from the specified location.</p>
-<h2>See also:</h2>
-<p>hipMallocFromPoolAsync , hipMallocAsync , hipFreeAsync , hipMemPoolGetAttribute , hipMemPoolTrimTo , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">flags -[out] Accessibility of the memory pool from the specified location/device</li>
-<li style="list-style-type: '· ';">mem_pool -[in] Memory pool being queried</li>
-<li style="list-style-type: '· ';">location -[in] Location/device for memory pool access</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipError_t hipMemPoolCreate ( hipMemPool_t *mem_pool, const hipMemPoolProps *pool_props )</p>
-<p>Creates a memory pool.</p>
-<p>Creates a HIP memory pool and returns the handle in mem_pool . The pool_props determines the properties of the pool such as the backing device and IPC capabilities.</p>
-<p>By default, the memory pool will be accessible from the device it is allocated on.</p>
-<h2>See also:</h2>
-<p>hipMallocFromPoolAsync , hipMallocAsync , hipFreeAsync , hipMemPoolGetAttribute , hipMemPoolDestroy , hipMemPoolTrimTo , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess , hipMemPoolGetAccess</p>
-<p>Note: Specifying hipMemHandleTypeNone creates a memory pool that will not support IPC.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">mem_pool -[out] Contains createed memory pool</li>
-<li style="list-style-type: '· ';">pool_props -[in] Memory pool properties</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError_t hipMemPoolDestroy ( hipMemPool_t mem_pool )</p>
-<p>Destroys the specified memory pool.</p>
-<p>If any pointers obtained from this pool haven't been freed or the pool has free operations that haven't completed when hipMemPoolDestroy is invoked, the function will return immediately and the resources associated with the pool will be released automatically once there are no more outstanding allocations.</p>
-<p>Destroying the current mempool of a device sets the default mempool of that device as the current mempool for that device.</p>
-<h2>See also:</h2>
-<p>hipMallocFromPoolAsync , hipMallocAsync , hipFreeAsync , hipMemPoolGetAttribute , hipMemPoolCreate hipMemPoolTrimTo , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess , hipMemPoolGetAccess</p>
-<p>Note: A device's default memory pool cannot be destroyed.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<p>mem_pool -[in] Memory pool for destruction</p>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipError_t void **dev_ptr, size_t size, hipMemPool_t mem_pool, hipStream_t stream</p>
-<p>hipMallocFromPoolAsync ( ) Allocates memory from a specified pool with stream ordered semantics.</p>
-<p>Inserts an allocation operation into stream . A pointer to the allocated memory is returned immediately in dev_ptr . The allocation must not be accessed until the allocation operation completes. The allocation comes from the specified memory pool.</p>
-<p>Basic stream ordering allows future work submitted into the same stream to use the allocation. Stream query, stream synchronize, and HIP events can be used to guarantee that the allocation operation completes before work submitted in a separate stream runs.</p>
-<h2>See also:</h2>
-<p>hipMallocAsync , hipFreeAsync , hipMemPoolGetAttribute , hipMemPoolCreate hipMemPoolTrimTo , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess , hipMemPoolGetAccess ,</p>
-<p>Note: The specified memory pool may be from a device different than that of the specified stream .</p>
-<p>Note: During stream capture, this function results in the creation of an allocation node. In this case, the allocation is owned by the graph instead of the memory pool. The memory pool's properties are used to set the node's creation parameters.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dev_ptr -[out] Returned device pointer</li>
-<li style="list-style-type: '· ';">size -[in] Number of bytes to allocate</li>
-<li style="list-style-type: '· ';">mem_pool -[in] The pool to allocate from</li>
-<li style="list-style-type: '· ';">stream -[in] The stream establishing the stream ordering semantic</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotSupported, hipErrorOutOfMemory hipError_t hipMemPoolExportToShareableHandle ( void *shared_handle, hipMemPool_t mem_pool, hipMemAllocationHandleType handle_type, unsigned int flags )</p>
-<p>Exports a memory pool to the requested handle type.</p>
-<p>Given an IPC capable mempool, create an OS handle to share the pool with another process. A recipient process can convert the shareable handle into a mempool with hipMemPoolImportFromShareableHandle . Individual pointers can then be shared with the hipMemPoolExportPointer and hipMemPoolImportPointer APIs. The implementation of what the shareable handle is and how it can be transferred is defined by the requested handle type.</p>
-<h2>See also:</h2>
-<p>hipMemPoolImportFromShareableHandle</p>
-<p>Note: To create an IPC capable mempool, create a mempool with a hipMemAllocationHandleType other than hipMemHandleTypeNone .</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">shared_handle -[out] Pointer to the location in which to store the requested handle</li>
-<li style="list-style-type: '· ';">mem_pool -[in] Pool to export</li>
-<li style="list-style-type: '· ';">handle_type -[in] The type of handle to create</li>
-<li style="list-style-type: '· ';">flags -[in] Must be 0</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorOutOfMemory hipError_t hipMemPoolImportFromShareableHandle ( hipMemPool_t *mem_pool, void *shared_handle, hipMemAllocationHandleType handle_type, unsigned int flags )</p>
-<p>Imports a memory pool from a shared handle.</p>
-<p>Specific allocations can be imported from the imported pool with hipMemPoolImportPointer .</p>
-<h2>See also:</h2>
-<p>hipMemPoolExportToShareableHandle</p>
-<p>Note: Imported memory pools do not support creating new allocations. As such imported memory pools may not be used in hipDeviceSetMemPool or hipMallocFromPoolAsync calls.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">mem_pool -[out] Returned memory pool</li>
-<li style="list-style-type: '· ';">shared_handle -[in] OS handle of the pool to open</li>
-<li style="list-style-type: '· ';">handle_type -[in] The type of handle being imported</li>
-<li style="list-style-type: '· ';">flags -[in] Must be 0</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorOutOfMemory hipError_t hipMemPoolExportPointer ( hipMemPoolPtrExportData *export_data, void *dev_ptr )</p>
-<p>Export data to share a memory pool allocation between processes.</p>
-<p>Constructs export_data for sharing a specific allocation from an already shared memory pool. The recipient process can import the allocation with the hipMemPoolImportPointer api. The data is not a handle and may be shared through any IPC mechanism.</p>
-<h2>See also:</h2>
-<p>hipMemPoolImportPointer</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">export_data -[out] Returned export data</li>
-<li style="list-style-type: '· ';">dev_ptr -[in] Pointer to memory being exported</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorOutOfMemory hipError_t hipMemPoolImportPointer ( void **dev_ptr, hipMemPool_t mem_pool, hipMemPoolPtrExportData *export_data )</p>
-<p>Import a memory pool allocation from another process.</p>
-<p>Returns in dev_ptr a pointer to the imported memory. The imported memory must not be accessed before the allocation operation completes in the exporting process. The imported memory must be freed from all importing processes before being freed in the exporting process. The pointer may be freed with hipFree or hipFreeAsync . If hipFreeAsync is used, the free must be completed on the importing process before the free operation on the exporting process.</p>
-<h2>See also:</h2>
-<p>hipMemPoolExportPointer</p>
-<p>Note: The hipFreeAsync api may be used in the exporting process before the hipFreeAsync operation completes in its stream as long as the hipFreeAsync in the exporting process specifies a stream with a stream dependency on the importing process's hipFreeAsync .</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dev_ptr -[out] Pointer to imported memory</li>
-<li style="list-style-type: '· ';">mem_pool -[in] Memory pool from which to import a pointer</li>
-<li style="list-style-type: '· ';">export_data -[in] Data specifying the memory to import</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized, hipErrorOutOfMemory</p>
-<h2>19.23.2 Peer to peer</h2>
-<p>hipError_t hipDeviceCanAccessPeer ( int *canAccessPeer, int deviceId, int peerDeviceId )</p>
-<p>Determine if a device can access a peer's memory.</p>
-<p>Returns '1' in canAccessPeer if the specified device is capable of directly accessing memory physically located on peerDevice , or '0' if not.</p>
-<p>Returns '0' in canAccessPeer if deviceId == peerDeviceId, and both are valid devices : a device is not a peer of itself.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">canAccessPeer -[out] Returns the peer access capability (0 or 1)</li>
-<li style="list-style-type: '· ';">deviceId -[in] - device from where memory may be accessed.</li>
-<li style="list-style-type: '· ';">peerDeviceId -[in] - device where memory is physically located</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess,</p>
-<h2>Returns</h2>
-<p>hipErrorInvalidDevice if deviceId or peerDeviceId are not valid devices hipError_t hipDeviceEnablePeerAccess ( int peerDeviceId, unsigned int flags )</p>
-<p>Enable direct access from current device's virtual address space to memory allocations physically located on a peer device.</p>
-<p>Memory which already allocated on peer device will be mapped into the address space of the current device. In addition, all future memory allocations on peerDeviceId will be mapped into the address space of the current device when the memory is allocated. The peer memory remains accessible from the current device until a call to hipDeviceDisablePeerAccess or hipDeviceReset.</p>
-<p>Returns hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue,</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">peerDeviceId -[in] Peer device to enable direct access to from the current device</li>
-<li style="list-style-type: '· ';">flags -[in] Reserved for future use, must be zero</li>
-</ul>
-<h2>Returns</h2>
-<p>hipErrorPeerAccessAlreadyEnabled if peer access is already enabled for this device.</p>
-<h2>hipError_t hipDeviceDisablePeerAccess ( int peerDeviceId )</h2>
-<p>Disable direct access from current device's virtual address space to memory allocations physically located on a peer device.</p>
-<p>Returns hipErrorPeerAccessNotEnabled if direct access to memory on peerDevice has not yet been enabled from the current device.</p>
-<h2>Parameters</h2>
-<p>peerDeviceId -[in] Peer device to disable direct access to</p>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorPeerAccessNotEnabled hipError_t hipMemGetAddressRange ( hipDeviceptr_t *pbase, size_t *psize, hipDeviceptr_t dptr )</p>
-<p>Get information on memory allocations.</p>
-<h2>See also:</h2>
-<p>hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent, hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">pbase -[out] - BAse pointer address</li>
-<li style="list-style-type: '· ';">psize -[out] - Size of allocation</li>
-<li style="list-style-type: '· ';">dptr--[in] Device Pointer</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorNotFound</p>
-<h2>USE_PEER_NON_UNIFIED</h2>
-<h2>19.23.3 Memory management</h2>
-<p>hipError_t hipPointerSetAttribute ( const void *value, hipPointer_attribute attribute, hipDeviceptr_t ptr )</p>
-<p>Sets information on the specified pointer.[BETA].</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">value -[in] Sets pointer attribute value</li>
-<li style="list-style-type: '· ';">attribute -[in] Attribute to set</li>
-<li style="list-style-type: '· ';">ptr -[in] Pointer to set attributes for</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError_t hipPointerGetAttributes ( hipPointerAttribute_t *attributes, const void *ptr )</p>
-<p>Returns attributes for the specified pointer.</p>
-<p>The output parameter 'attributes' has a member named 'type' that describes what memory the pointer is associated with, such as device memory, host memory, managed memory, and others. Otherwise, the API cannot handle the pointer and returns hipErrorInvalidValue.</p>
-<h2>See also:</h2>
-<p>hipPointerGetAttribute</p>
-<p>Note: The unrecognized memory type is unsupported to keep the HIP functionality backward compatibility due to hipMemoryType enum values.</p>
-<p>Note: The current behavior of this HIP API corresponds to the CUDA API before version 11.0.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">attributes -[out] attributes for the specified pointer</li>
-<li style="list-style-type: '· ';">ptr -[in] pointer to get attributes for</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError_t hipPointerGetAttribute ( void *data, hipPointer_attribute attribute, hipDeviceptr_t ptr ) Returns information about the specified pointer.[BETA].</p>
-<h2>See also:</h2>
-<p>hipPointerGetAttributes</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">data -[inout] Returned pointer attribute value</li>
-<li style="list-style-type: '· ';">attribute -[in] Attribute to query for</li>
-<li style="list-style-type: '· ';">ptr -[in] Pointer to get attributes for</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError_t hipDrvPointerGetAttributes ( unsigned int numAttributes, hipPointer_attribute *attributes, void **data, hipDeviceptr_t ptr )</p>
-<p>Returns information about the specified pointer.[BETA].</p>
-<h2>See also:</h2>
-<p>hipPointerGetAttribute</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">numAttributes -[in] number of attributes to query for</li>
-<li style="list-style-type: '· ';">attributes -[in] attributes to query for</li>
-<li style="list-style-type: '· ';">data -[inout] a two-dimensional containing pointers to memory locations where the result of each attribute query will be written to</li>
-<li style="list-style-type: '· ';">ptr -[in] pointer to get attributes for</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError_t hipMalloc ( void **ptr, size_t size )</p>
-<p>Allocate memory on the default accelerator.</p>
-<p>If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.</p>
-<h2>See also:</h2>
-<p>hipMallocPitch , hipFree , hipMallocArray , hipFreeArray , hipMalloc3D , hipMalloc3DArray , hipHostFree , hipHostMalloc</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">ptr -[out] Pointer to the allocated memory</li>
-<li style="list-style-type: '· ';">size -[in] Requested memory size</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorOutOfMemory, hipErrorInvalidValue (bad context, null *ptr)</p>
-<p>hipError_t hipExtMallocWithFlags ( void **ptr, size_t sizeBytes, unsigned int flags )</p>
-<p>Allocate memory on the default accelerator.</p>
-<p>If requested memory size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.</p>
-<p>The memory allocation flag should be either hipDeviceMallocDefault, hipDeviceMallocFinegrained, hipDeviceMallocUncached, or hipMallocSignalMemory. If the flag is any other value, the API returns hipErrorInvalidValue.</p>
-<h2>See also:</h2>
-<p>hipMallocPitch , hipFree , hipMallocArray , hipFreeArray , hipMalloc3D , hipMalloc3DArray , hipHostFree , hipHostMalloc</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">ptr -[out] Pointer to the allocated memory</li>
-<li style="list-style-type: '· ';">sizeBytes -[in] Requested memory size</li>
-<li style="list-style-type: '· ';">flags -[in] Type of memory allocation</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorOutOfMemory, hipErrorInvalidValue (bad context, null *ptr)</p>
-<p>hipError_t hipMallocHost ( void **ptr, size_t size )</p>
-<p>Allocate pinned host memory [Deprecated].</p>
-<p>If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.</p>
-<p>Warning:</p>
-<pre><code>
-
-arning:   This API is deprecated, use hipHostMalloc() instead</code></pre>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">ptr -[out] Pointer to the allocated host pinned memory</li>
-<li style="list-style-type: '· ';">size -[in] Requested memory size</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorOutOfMemory</p>
-<h2>hipError_t hipMemAllocHost ( void **ptr, size_t size )</h2>
-<p>Allocate pinned host memory [Deprecated].</p>
-<p>If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.</p>
-<p>Warning: This API is deprecated, use hipHostMalloc() instead</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">ptr -[out] Pointer to the allocated host pinned memory</li>
-<li style="list-style-type: '· ';">size -[in] Requested memory size</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorOutOfMemory hipError_t hipHostMalloc ( void **ptr, size_t size, unsigned int flags )</p>
-<p>Allocates device accessible page locked (pinned) host memory.</p>
-<p>This API allocates pinned host memory which is mapped into the address space of all GPUs in the system, the memory can be accessed directly by the GPU device, and can be read or written with much higher bandwidth than pageable memory obtained with functions such as malloc().</p>
-<p>Using the pinned host memory, applications can implement faster data transfers for HostToDevice and DeviceToHost. The runtime tracks the hipHostMalloc allocations and can avoid some of the setup required for regular unpinned memory.</p>
-<p>When the memory accesses are infrequent, zero-copy memory can be a good choice, for coherent allocation. GPU can directly access the host memory over the CPU/GPU interconnect, without need to copy the data.</p>
-<p>Currently the allocation granularity is 4KB for the API.</p>
-<p>Developers need to choose proper allocation flag with consideration of synchronization.</p>
-<p>If no input for flags, it will be the default pinned memory allocation on the host.</p>
-<h2>See also:</h2>
-<p>hipSetDeviceFlags, hipHostFree</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">ptr -[out] Pointer to the allocated host pinned memory</li>
-<li style="list-style-type: '· ';">size -[in] Requested memory size in bytes If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.</li>
-<li style="list-style-type: '· ';">flags -[in] Type of host memory allocation. See the description of flags in hipSetDeviceFlags.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorOutOfMemory hipError_t hipHostAlloc ( void **ptr, size_t size, unsigned int flags )</p>
-<p>Allocate device accessible page locked host memory [Deprecated].</p>
-<p>If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.</p>
-<p>Warning: This API is deprecated, use hipHostMalloc() instead</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">ptr -[out] Pointer to the allocated host pinned memory</li>
-</ul>
-<ul>
-<li style="list-style-type: '· ';">size -[in] Requested memory size in bytes</li>
-<li style="list-style-type: '· ';">flags -[in] Type of host memory allocation</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorOutOfMemory hipError_t hipHostGetDevicePointer ( void **devPtr, void *hstPtr, unsigned int flags )</p>
-<p>Get Device pointer from Host Pointer allocated through hipHostMalloc.</p>
-<h2>See also:</h2>
-<p>hipSetDeviceFlags, hipHostMalloc</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">devPtr -[out] Device Pointer mapped to passed host pointer</li>
-<li style="list-style-type: '· ';">hstPtr -[in] Host Pointer allocated through hipHostMalloc</li>
-<li style="list-style-type: '· ';">flags -[in] Flags to be passed for extension</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorOutOfMemory hipError_t hipHostGetFlags ( unsigned int *flagsPtr, void *hostPtr )</p>
-<p>Return flags associated with host pointer.</p>
-<h2>See also:</h2>
-<h2>hipHostMalloc</h2>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">flagsPtr -[out] Memory location to store flags</li>
-<li style="list-style-type: '· ';">hostPtr -[in] Host Pointer allocated through hipHostMalloc</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipError_t hipHostRegister ( void *hostPtr, size_t sizeBytes, unsigned int flags )</p>
-<p>Register host memory so it can be accessed from the current device.</p>
-<h2>Flags:</h2>
-<ul>
-<li style="list-style-type: '· ';">hipHostRegisterDefault Memory is Mapped and Portable</li>
-<li style="list-style-type: '· ';">hipHostRegisterPortable Memory is considered registered by all contexts. HIP only supports one context so this is always assumed true.</li>
-<li style="list-style-type: '· ';">hipHostRegisterMapped Map the allocation into the address space for the current device. The device pointer can be obtained with hipHostGetDevicePointer .</li>
-</ul>
-<p>After registering the memory, use hipHostGetDevicePointer to obtain the mapped device pointer. On many systems, the mapped device pointer will have a different value than the mapped host pointer. Applications must use the device pointer in device code, and the host pointer in host code.</p>
-<p>On some systems, registered memory is pinned. On some systems, registered memory may not be actually be pinned but uses OS or hardware facilities to all GPU access to the host memory.</p>
-<p>Developers are strongly encouraged to register memory blocks which are aligned to the host cache-line size. (typically 64-bytes but can be obtains from the CPUID instruction).</p>
-<p>If registering non-aligned pointers, the application must take care when register pointers from the same cache line on different devices. HIP's coarse-grained synchronization model does not guarantee correct results if different devices write to different parts of the same cache block - typically one of the writes will 'win' and overwrite data from the other registered memory region.</p>
-<h2>See also:</h2>
-<p>hipHostUnregister , hipHostGetFlags , hipHostGetDevicePointer</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">hostPtr -[out] Pointer to host memory to be registered.</li>
-<li style="list-style-type: '· ';">sizeBytes -[in] Size of the host memory</li>
-<li style="list-style-type: '· ';">flags -[in] See below.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorOutOfMemory hipError_t hipHostUnregister ( void *hostPtr )</p>
-<p>Un-register host pointer.</p>
-<h2>See also:</h2>
-<p>hipHostRegister</p>
-<h2>Parameters</h2>
-<p>hostPtr -[in] Host pointer previously registered with hipHostRegister</p>
-<h2>Returns</h2>
-<p>Error code hipError_t hipMallocPitch ( void **ptr, size_t *pitch, size_t width, size_t height )</p>
-<p>Allocates at least width (in bytes) * height bytes of linear memory Padding may occur to ensure alighnment requirements are met for the given row The change in width size due to padding will be returned in *pitch. Currently the alignment is set to 128 bytes</p>
-<p>If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.</p>
-<h2>See also:</h2>
-<p>hipMalloc , hipFree , hipMallocArray , hipFreeArray , hipHostFree , hipMalloc3D , hipMalloc3DArray , hipHostMalloc</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">ptr -[out] Pointer to the allocated device memory</li>
-</ul>
-<ul>
-<li style="list-style-type: '· ';">pitch -[out] Pitch for allocation (in bytes)</li>
-<li style="list-style-type: '· ';">width -[in] Requested pitched allocation width (in bytes)</li>
-<li style="list-style-type: '· ';">height -[in] Requested pitched allocation height</li>
-</ul>
-<h2>Returns</h2>
-<p>Error code hipError_t hipMemAllocPitch ( hipDeviceptr_t *dptr, size_t *pitch, size_t widthInBytes, size_t height, unsigned int elementSizeBytes )</p>
-<p>Allocates at least width (in bytes) * height bytes of linear memory Padding may occur to ensure alighnment requirements are met for the given row The change in width size due to padding will be returned in *pitch. Currently the alignment is set to 128 bytes</p>
-<p>If size is 0, no memory is allocated, ptr returns nullptr, and hipSuccess is returned. The intended usage of pitch is as a separate parameter of the allocation, used to compute addresses within the 2D array. Given the row and column of an array element of type T, the address is computed as: T pElement = (T*)((char*)BaseAddress + Row * Pitch) + Column;</p>
-<h2>See also:</h2>
-<p>hipMalloc , hipFree , hipMallocArray , hipFreeArray , hipHostFree , hipMalloc3D , hipMalloc3DArray , hipHostMalloc</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dptr -[out] Pointer to the allocated device memory</li>
-<li style="list-style-type: '· ';">pitch -[out] Pitch for allocation (in bytes)</li>
-<li style="list-style-type: '· ';">widthInBytes -[in] Requested pitched allocation width (in bytes)</li>
-<li style="list-style-type: '· ';">height -[in] Requested pitched allocation height</li>
-<li style="list-style-type: '· ';">elementSizeBytes -[in] The size of element bytes, should be 4, 8 or 16</li>
-</ul>
-<h2>Returns</h2>
-<p>Error code</p>
-<h2>hipError_t hipFree ( void *ptr )</h2>
-<p>Free memory allocated by the hcc hip memory allocation API. This API performs an implicit hipDeviceSynchronize() call. If pointer is NULL, the hip runtime is initialized and hipSuccess is returned.</p>
-<h2>See also:</h2>
-<p>hipMalloc , hipMallocPitch , hipMallocArray , hipFreeArray , hipHostFree , hipMalloc3D , hipMalloc3DArray , hipHostMalloc</p>
-<h2>Parameters</h2>
-<p>ptr -[in] Pointer to memory to be freed</p>
-<h2>Returns</h2>
-<p>hipSuccess</p>
-<h2>Returns</h2>
-<p>hipErrorInvalidDevicePointer (if pointer is invalid, including host pointers allocated with hipHostMalloc)</p>
-<h2>hipError_t hipFreeHost ( void *ptr )</h2>
-<p>Free memory allocated by the hcc hip host memory allocation API [Deprecated].</p>
-<p>Warning:</p>
-<pre><code>
-
-urning:   This API is deprecated, use hipHostFree() instead</code></pre>
-<h2>Parameters</h2>
-<p>ptr -[in] Pointer to memory to be freed</p>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue (if pointer is invalid, including device pointers allocated with hipMalloc)</p>
-<h2>hipError_t hipHostFree ( void *ptr )</h2>
-<p>Free memory allocated by the hcc hip host memory allocation API This API performs an implicit hipDeviceSynchronize() call. If pointer is NULL, the hip runtime is initialized and hipSuccess is returned.</p>
-<h2>See also:</h2>
-<p>hipMalloc , hipMallocPitch , hipFree , hipMallocArray , hipFreeArray , hipMalloc3D , hipMalloc3DArray , hipHostMalloc</p>
-<h2>Parameters</h2>
-<p>ptr -[in] Pointer to memory to be freed</p>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue (if pointer is invalid, including device pointers allocated with hipMalloc)</p>
-<p>hipError_t hipMemcpy ( void *dst, const void *src, size_t sizeBytes, hipMemcpyKind kind )</p>
-<p>Copy data from src to dst.</p>
-<p>It supports memory from host to device, device to host, device to device and host to host The src and dst must not overlap.</p>
-<p>For hipMemcpy, the copy is always performed by the current device (set by hipSetDevice). For multi-gpu or peerto-peer configurations, it is recommended to set the current device to the device where the src data is physically located. For optimal peer-to-peer copies, the copy device must be able to access the src and dst pointers (by calling hipDeviceEnablePeerAccess with copy agent as the current device and src/dest as the peerDevice argument. if this is not done, the hipMemcpy will still work, but will perform the copy using a staging buffer on the host. Calling hipMemcpy with dst and src pointers that do not match the hipMemcpyKind results in undefined behavior.</p>
-<h2>See also:</h2>
-<p>hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[out] Data being copy to</li>
-<li style="list-style-type: '· ';">src -[in] Data being copy from</li>
-<li style="list-style-type: '· ';">sizeBytes -[in] Data size in bytes</li>
-<li style="list-style-type: '· ';">kind -[in] Kind of transfer</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorUnknown hipError_t hipMemcpyWithStream ( void *dst, const void *src, size_t sizeBytes, hipMemcpyKind kind, hipStream_t stream )</p>
-<p>Memory copy on the stream. It allows single or multiple devices to do memory copy on single or multiple streams.</p>
-<h2>See also:</h2>
-<p>hipMemcpy , hipStreamCreate , hipStreamSynchronize , hipStreamDestroy , hipSetDevice, hipLaunchKernelGGL</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[out] Data being copy to</li>
-<li style="list-style-type: '· ';">src -[in] Data being copy from</li>
-<li style="list-style-type: '· ';">sizeBytes -[in] Data size in bytes</li>
-<li style="list-style-type: '· ';">kind -[in] Kind of transfer</li>
-<li style="list-style-type: '· ';">stream -[in] Valid stream</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorUnknown, hipErrorContextIsDestroyed hipError_t hipMemcpyHtoD ( hipDeviceptr_t dst, void *src, size_t sizeBytes )</p>
-<p>Copy data from Host to Device.</p>
-<h2>See also:</h2>
-<p>hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[out] Data being copy to</li>
-<li style="list-style-type: '· ';">src -[in] Data being copy from</li>
-<li style="list-style-type: '· ';">sizeBytes -[in] Data size in bytes</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue</p>
-<p>hipError_t hipMemcpyDtoH ( void *dst, hipDeviceptr_t src, size_t sizeBytes )</p>
-<p>Copy data from Device to Host.</p>
-<h2>See also:</h2>
-<p>hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[out] Data being copy to</li>
-<li style="list-style-type: '· ';">src -[in] Data being copy from</li>
-<li style="list-style-type: '· ';">sizeBytes -[in] Data size in bytes</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue hipError_t hipMemcpyDtoD ( hipDeviceptr_t dst, hipDeviceptr_t src, size_t sizeBytes )</p>
-<p>Copy data from Device to Device.</p>
-<h2>See also:</h2>
-<p>hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[out] Data being copy to</li>
-<li style="list-style-type: '· ';">src -[in] Data being copy from</li>
-<li style="list-style-type: '· ';">sizeBytes -[in] Data size in bytes</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue hipError_t hipMemcpyHtoDAsync ( hipDeviceptr_t dst, void *src, size_t sizeBytes, hipStream_t stream )</p>
-<p>Copy data from Host to Device asynchronously.</p>
-<h2>See also:</h2>
-<p>hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpyAtoA, hipMemcpyAtoD,</p>
-<p>hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[out] Data being copy to</li>
-<li style="list-style-type: '· ';">src -[in] Data being copy from</li>
-<li style="list-style-type: '· ';">sizeBytes -[in] Data size in bytes</li>
-<li style="list-style-type: '· ';">stream -[in] Stream identifier</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue hipError_t hipMemcpyDtoHAsync ( void *dst, hipDeviceptr_t src, size_t sizeBytes, hipStream_t stream )</p>
-<p>Copy data from Device to Host asynchronously.</p>
-<h2>See also:</h2>
-<p>hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[out] Data being copy to</li>
-<li style="list-style-type: '· ';">src -[in] Data being copy from</li>
-<li style="list-style-type: '· ';">sizeBytes -[in] Data size in bytes</li>
-<li style="list-style-type: '· ';">stream -[in] Stream identifier</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue hipError_t hipMemcpyDtoDAsync ( hipDeviceptr_t dst, hipDeviceptr_t src, size_t sizeBytes, hipStream_t stream )</p>
-<p>Copy data from Device to Device asynchronously.</p>
-<h2>See also:</h2>
-<p>hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[out] Data being copy to</li>
-<li style="list-style-type: '· ';">src -[in] Data being copy from</li>
-<li style="list-style-type: '· ';">sizeBytes -[in] Data size in bytes</li>
-<li style="list-style-type: '· ';">stream -[in] Stream identifier</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue hipError_t hipModuleGetGlobal ( hipDeviceptr_t *dptr, size_t *bytes, hipModule_t hmod, const char *name )</p>
-<p>Returns a global pointer from a module. Returns in *dptr and *bytes the pointer and size of the global of name name located in module hmod. If no variable of that name exists, it returns hipErrorNotFound. Both parameters dptr and bytes are optional. If one of them is NULL, it is ignored and hipSuccess is returned.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dptr -[out] Returns global device pointer</li>
-<li style="list-style-type: '· ';">bytes -[out] Returns global size in bytes</li>
-<li style="list-style-type: '· ';">hmod -[in] Module to retrieve global from</li>
-<li style="list-style-type: '· ';">name -[in] Name of global to retrieve</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotFound, hipErrorInvalidContext hipError_t hipGetSymbolAddress ( void **devPtr, const void *symbol )</p>
-<p>Gets device pointer associated with symbol on the device.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">devPtr -[out] pointer to the device associated the symbole</li>
-<li style="list-style-type: '· ';">symbol -[in] pointer to the symbole of the device</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipError_t hipGetSymbolSize ( size_t *size, const void *symbol )</p>
-<p>Gets the size of the given symbol on the device.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">symbol -[in] pointer to the device symbole</li>
-<li style="list-style-type: '· ';">size -[out] pointer to the size</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipError_t hipGetProcAddress ( const char *symbol, void **pfn, int hipVersion, uint64_t flags, hipDriverProcAddressQueryResult *symbolStatus )</p>
-<p>Gets the pointer of requested HIP driver function.</p>
-<p>Returns hipSuccess if the returned pfn is addressed to the pointer of found driver function.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">symbol -[in] The Symbol name of the driver function to request.</li>
-<li style="list-style-type: '· ';">pfn -[out] Output pointer to the requested driver function.</li>
-<li style="list-style-type: '· ';">hipVersion -[in] The HIP version for the requested driver function symbol. HIP version is defined as 100*version_major + version_minor. For example, in HIP 6.1, the hipversion is 601, for the symbol function 'hipGetDeviceProperties', the specified hipVersion 601 is greater or equal to the version 600, the symbol function will be handle properly as backend compatible function.</li>
-<li style="list-style-type: '· ';">flags -[in] Currently only default flag is suppported.</li>
-<li style="list-style-type: '· ';">symbolStatus -[out] Optional enumeration for returned status of searching for symbol driver function based on the input hipVersion.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue.</p>
-<p>hipError_t hipMemcpyToSymbol ( const void *symbol, const void *src, size_t sizeBytes, size_t offset, hipMemcpyKind kind )</p>
-<p>Copies data to the given symbol on the device. Symbol HIP APIs allow a kernel to define a device-side data symbol which can be accessed on the host side. The symbol can be in __constant or device space. Note that the symbol name needs to be encased in the HIP_SYMBOL macro. This also applies to hipMemcpyFromSymbol, hipGetSymbolAddress, and hipGetSymbolSize. For detailed usage, see the memcpyToSymbol example in the HIP Porting Guide.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">symbol -[out] pointer to the device symbole</li>
-<li style="list-style-type: '· ';">src -[in] pointer to the source address</li>
-<li style="list-style-type: '· ';">sizeBytes -[in] size in bytes to copy</li>
-<li style="list-style-type: '· ';">offset -[in] offset in bytes from start of symbole</li>
-<li style="list-style-type: '· ';">kind -[in] type of memory transfer</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipError_t hipMemcpyToSymbolAsync ( const void *symbol, const void *src, size_t sizeBytes, size_t offset, hipMemcpyKind kind, hipStream_t stream )</p>
-<p>Copies data to the given symbol on the device asynchronously.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">symbol -[out] pointer to the device symbole</li>
-<li style="list-style-type: '· ';">src -[in] pointer to the source address</li>
-<li style="list-style-type: '· ';">sizeBytes -[in] size in bytes to copy</li>
-<li style="list-style-type: '· ';">offset -[in] offset in bytes from start of symbole</li>
-<li style="list-style-type: '· ';">kind -[in] type of memory transfer</li>
-<li style="list-style-type: '· ';">stream -[in] stream identifier</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue</p>
-<p>hipError_t hipMemcpyFromSymbol ( void *dst, const void *symbol, size_t sizeBytes, size_t offset, hipMemcpyKind kind )</p>
-<p>Copies data from the given symbol on the device.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[out] Returns pointer to destinition memory address</li>
-<li style="list-style-type: '· ';">symbol -[in] Pointer to the symbole address on the device</li>
-<li style="list-style-type: '· ';">sizeBytes -[in] Size in bytes to copy</li>
-<li style="list-style-type: '· ';">offset -[in] Offset in bytes from the start of symbole</li>
-<li style="list-style-type: '· ';">kind -[in] Type of memory transfer</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipError_t hipMemcpyFromSymbolAsync ( void *dst, const void *symbol, size_t sizeBytes, size_t offset, hipMemcpyKind kind, hipStream_t stream )</p>
-<p>Copies data from the given symbol on the device asynchronously.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[out] Returns pointer to destinition memory address</li>
-<li style="list-style-type: '· ';">symbol -[in] pointer to the symbole address on the device</li>
-<li style="list-style-type: '· ';">sizeBytes -[in] size in bytes to copy</li>
-<li style="list-style-type: '· ';">offset -[in] offset in bytes from the start of symbole</li>
-<li style="list-style-type: '· ';">kind -[in] type of memory transfer</li>
-<li style="list-style-type: '· ';">stream -[in] stream identifier</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipError_t hipMemcpyAsync ( void *dst, const void *src, size_t sizeBytes, hipMemcpyKind kind, hipStream_t stream )</p>
-<p>Copy data from src to dst asynchronously.</p>
-<p>For multi-gpu or peer-to-peer configurations, it is recommended to use a stream which is a attached to the device where the src data is physically located. For optimal peer-to-peer copies, the copy device must be able to access the src and dst pointers (by calling hipDeviceEnablePeerAccess with copy agent as the current device and src/dest as the peerDevice argument. if this is not done, the hipMemcpy will still work, but will perform the copy using a staging buffer on the host.</p>
-<h2>See also:</h2>
-<p>hipMemcpy , hipMemcpy2D , hipMemcpyToArray , hipMemcpy2DToArray , hipMemcpyFromArray , hipMemcpy2DFromArray , hipMemcpyArrayToArray, hipMemcpy2DArrayToArray, hipMemcpyToSymbol , hipMemcpyFromSymbol , hipMemcpy2DAsync , hipMemcpyToArrayAsync, hipMemcpy2DToArrayAsync , hipMemcpyFromArrayAsync, hipMemcpy2DFromArrayAsync , hipMemcpyToSymbolAsync , hipMemcpyFromSymbolAsync</p>
-<p>Warning: If host or dest are not pinned, the memory copy will be performed synchronously. For best performance, use hipHostMalloc to allocate host memory that is transferred asynchronously.</p>
-<p>Warning: on HCC hipMemcpyAsync does not support overlapped H2D and D2H copies. For hipMemcpy, the copy is always performed by the device associated with the specified stream.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[out] Data being copy to</li>
-<li style="list-style-type: '· ';">src -[in] Data being copy from</li>
-<li style="list-style-type: '· ';">sizeBytes -[in] Data size in bytes</li>
-<li style="list-style-type: '· ';">kind -[in] Type of memory transfer</li>
-<li style="list-style-type: '· ';">stream -[in] Stream identifier</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorUnknown hipError_t hipMemset ( void *dst, int value, size_t sizeBytes )</p>
-<p>Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant byte value value.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[out] Data being filled</li>
-<li style="list-style-type: '· ';">value -[in] Value to be set</li>
-<li style="list-style-type: '· ';">sizeBytes -[in] Data size in bytes</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized hipError_t hipMemsetD8 ( hipDeviceptr_t dest, unsigned char value, size_t count )</p>
-<p>Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant byte value value.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dest -[out] Data ptr to be filled</li>
-<li style="list-style-type: '· ';">value -[in] Value to be set</li>
-<li style="list-style-type: '· ';">count -[in] Number of values to be set</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized hipError_t hipMemsetD8Async ( hipDeviceptr_t dest, unsigned char value, size_t count, hipStream_t stream )</p>
-<p>Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant byte value value.</p>
-<p>hipMemsetD8Async() is asynchronous with respect to the host, so the call may return before the memset is complete. The operation can optionally be associated to a stream by passing a non-zero stream argument. If stream is non-zero, the operation may overlap with operations in other streams.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dest -[out] Data ptr to be filled</li>
-<li style="list-style-type: '· ';">value -[in] Constant value to be set</li>
-</ul>
-<ul>
-<li style="list-style-type: '· ';">count -[in] Number of values to be set</li>
-<li style="list-style-type: '· ';">stream -[in] Stream identifier</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized hipError_t hipMemsetD16 ( hipDeviceptr_t dest, unsigned short value, size_t count )</p>
-<p>Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant short value value.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dest -[out] Data ptr to be filled</li>
-<li style="list-style-type: '· ';">value -[in] Constant value to be set</li>
-<li style="list-style-type: '· ';">count -[in] Number of values to be set</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized hipError_t hipMemsetD16Async ( hipDeviceptr_t dest, unsigned short value, size_t count, hipStream_t stream )</p>
-<p>Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant short value value.</p>
-<p>hipMemsetD16Async() is asynchronous with respect to the host, so the call may return before the memset is complete. The operation can optionally be associated to a stream by passing a non-zero stream argument. If stream is non-zero, the operation may overlap with operations in other streams.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dest -[out] Data ptr to be filled</li>
-<li style="list-style-type: '· ';">value -[in] Constant value to be set</li>
-<li style="list-style-type: '· ';">count -[in] Number of values to be set</li>
-<li style="list-style-type: '· ';">stream -[in] Stream identifier</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized hipError_t hipMemsetD32 ( hipDeviceptr_t dest, int value, size_t count )</p>
-<p>Fills the memory area pointed to by dest with the constant integer value for specified number of times.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dest -[out] Data being filled</li>
-<li style="list-style-type: '· ';">value -[in] Constant value to be set</li>
-<li style="list-style-type: '· ';">count -[in] Number of values to be set</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized hipError_t hipMemsetAsync ( void *dst, int value, size_t sizeBytes, hipStream_t stream )</p>
-<p>Fills the first sizeBytes bytes of the memory area pointed to by dev with the constant byte value value.</p>
-<p>hipMemsetAsync() is asynchronous with respect to the host, so the call may return before the memset is complete. The operation can optionally be associated to a stream by passing a non-zero stream argument. If stream is nonzero, the operation may overlap with operations in other streams.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[out] Pointer to device memory</li>
-</ul>
-<ul>
-<li style="list-style-type: '· ';">value -[in] Value to set for each byte of specified memory</li>
-<li style="list-style-type: '· ';">sizeBytes -[in] Size in bytes to set</li>
-<li style="list-style-type: '· ';">stream -[in] Stream identifier</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipError_t hipMemsetD32Async ( hipDeviceptr_t dst, int value, size_t count, hipStream_t stream )</p>
-<p>Fills the memory area pointed to by dev with the constant integer value for specified number of times.</p>
-<p>hipMemsetD32Async() is asynchronous with respect to the host, so the call may return before the memset is complete. The operation can optionally be associated to a stream by passing a non-zero stream argument. If stream is non-zero, the operation may overlap with operations in other streams.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[out] Pointer to device memory</li>
-<li style="list-style-type: '· ';">value -[in] Value to set for each byte of specified memory</li>
-<li style="list-style-type: '· ';">count -[in] Number of values to be set</li>
-<li style="list-style-type: '· ';">stream -[in] Stream identifier</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipError_t hipMemset2D ( void *dst, size_t pitch, int value, size_t width, size_t height )</p>
-<p>Fills the memory area pointed to by dst with the constant value.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[out] Pointer to device memory</li>
-<li style="list-style-type: '· ';">pitch -[in] Data size in bytes</li>
-<li style="list-style-type: '· ';">value -[in] Constant value to be set</li>
-<li style="list-style-type: '· ';">width -[in]</li>
-<li style="list-style-type: '· ';">height -[in]</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipError_t hipMemset2DAsync ( void *dst, size_t pitch, int value, size_t width, size_t height, hipStream_t stream ) Fills asynchronously the memory area pointed to by dst with the constant value.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[in] Pointer to 2D device memory</li>
-<li style="list-style-type: '· ';">pitch -[in] Pitch size in bytes</li>
-<li style="list-style-type: '· ';">value -[in] Value to be set for each byte of specified memory</li>
-<li style="list-style-type: '· ';">width -[in] Width of matrix set columns in bytes</li>
-<li style="list-style-type: '· ';">height -[in] Height of matrix set rows in bytes</li>
-<li style="list-style-type: '· ';">stream -[in] Stream identifier</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue</p>
-<p>hipError_t hipMemset3D ( hipPitchedPtr pitchedDevPtr, int value, hipExtent extent )</p>
-<p>Fills synchronously the memory area pointed to by pitchedDevPtr with the constant value.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">pitchedDevPtr -[in] Pointer to pitched device memory</li>
-<li style="list-style-type: '· ';">value -[in] Value to set for each byte of specified memory</li>
-<li style="list-style-type: '· ';">extent -[in] Size parameters for width field in bytes in device memory</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipError_t hipMemset3DAsync ( hipPitchedPtr pitchedDevPtr, int value, hipExtent extent, hipStream_t stream )</p>
-<p>Fills asynchronously the memory area pointed to by pitchedDevPtr with the constant value.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">pitchedDevPtr -[in] Pointer to pitched device memory</li>
-<li style="list-style-type: '· ';">value -[in] Value to set for each byte of specified memory</li>
-<li style="list-style-type: '· ';">extent -[in] Size parameters for width field in bytes in device memory</li>
-<li style="list-style-type: '· ';">stream -[in] Stream identifier</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipError_t hipMemGetInfo ( size_t *free, size_t *total )</p>
-<p>Query memory info.</p>
-<p>On ROCM, this function gets the actual free memory left on the current device, so supports the cases while running multi-workload (such as multiple processes, multiple threads, and multiple GPUs).</p>
-<p>Warning: On Windows, the free memory only accounts for memory allocated by this process and may be optimistic.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">free -[out] Returns free memory on the current device in bytes</li>
-<li style="list-style-type: '· ';">total -[out] Returns total allocatable memory on the current device in bytes</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError_t hipMemPtrGetInfo ( void *ptr, size_t *size )</p>
-<p>Get allocated memory size via memory pointer.</p>
-<p>This function gets the allocated shared virtual memory size from memory pointer.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">ptr -[in] Pointer to allocated memory</li>
-<li style="list-style-type: '· ';">size -[out] Returns the allocated memory size in bytes</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue</p>
-<p>hipError_t hipMallocArray ( hipArray_t *array, const hipChannelFormatDesc *desc, size_t width, size_t height, unsigned int flags )</p>
-<p>Allocate an array on the device.</p>
-<h2>See also:</h2>
-<p>hipMalloc , hipMallocPitch , hipFree , hipFreeArray , hipHostMalloc , hipHostFree</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">array -[out] Pointer to allocated array in device memory</li>
-<li style="list-style-type: '· ';">desc -[in] Requested channel format</li>
-<li style="list-style-type: '· ';">width -[in] Requested array allocation width</li>
-<li style="list-style-type: '· ';">height -[in] Requested array allocation height</li>
-<li style="list-style-type: '· ';">flags -[in] Requested properties of allocated array</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorOutOfMemory hipError_t hipArrayCreate ( hipArray_t *pHandle, const HIP_ARRAY_DESCRIPTOR *pAllocateArray )</p>
-<p>Create an array memory pointer on the device.</p>
-<h2>See also:</h2>
-<p>hipMallocArray , hipArrayDestroy , hipFreeArray</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">pHandle -[out] Pointer to the array memory</li>
-<li style="list-style-type: '· ';">pAllocateArray -[in] Requested array desciptor</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError_t hipArrayDestroy ( hipArray_t array )</p>
-<p>Destroy an array memory pointer on the device.</p>
-<h2>See also:</h2>
-<p>hipArrayCreate , hipArrayDestroy , hipFreeArray</p>
-<h2>Parameters</h2>
-<p>array -[in] Pointer to the array memory</p>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue</p>
-<p>hipError_t hipArray3DCreate ( hipArray_t *array, const HIP_ARRAY3D_DESCRIPTOR *pAllocateArray )</p>
-<p>Create a 3D array memory pointer on the device.</p>
-<h2>See also:</h2>
-<p>hipMallocArray , hipArrayDestroy , hipFreeArray</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">array -[out] Pointer to the 3D array memory</li>
-<li style="list-style-type: '· ';">pAllocateArray -[in] Requested array desciptor</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError_t hipMalloc3D ( hipPitchedPtr *pitchedDevPtr, hipExtent extent )</p>
-<p>Create a 3D memory pointer on the device.</p>
-<h2>See also:</h2>
-<p>hipMallocPitch , hipMemGetInfo , hipFree</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">pitchedDevPtr -[out] Pointer to the 3D memory</li>
-<li style="list-style-type: '· ';">extent -[in] Requested extent</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError_t hipFreeArray ( hipArray_t array )</p>
-<p>Frees an array on the device.</p>
-<h2>See also:</h2>
-<p>hipMalloc , hipMallocPitch , hipFree , hipMallocArray , hipHostMalloc , hipHostFree</p>
-<h2>Parameters</h2>
-<p>array -[in] Pointer to array to free</p>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized hipError_t hipMalloc3DArray ( hipArray_t *array, const struct hipChannelFormatDesc *desc, struct hipExtent extent, unsigned int flags )</p>
-<p>Allocate an array on the device.</p>
-<h2>See also:</h2>
-<p>hipMalloc , hipMallocPitch , hipFree , hipFreeArray , hipHostMalloc , hipHostFree</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">array -[out] Pointer to allocated array in device memory</li>
-<li style="list-style-type: '· ';">desc -[in] Requested channel format</li>
-<li style="list-style-type: '· ';">extent -[in] Requested array allocation width, height and depth</li>
-<li style="list-style-type: '· ';">flags -[in] Requested properties of allocated array</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorOutOfMemory hipError_t hipArrayGetInfo ( hipChannelFormatDesc *desc, hipExtent *extent, unsigned int *flags, hipArray_t array )</p>
-<p>Gets info about the specified array.</p>
-<h2>See also:</h2>
-<p>hipArrayGetDescriptor , hipArray3DGetDescriptor</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">desc -[out] - Returned array type</li>
-<li style="list-style-type: '· ';">extent -[out] - Returned array shape. 2D arrays will have depth of zero</li>
-<li style="list-style-type: '· ';">flags -[out] - Returned array flags</li>
-<li style="list-style-type: '· ';">array -[in] - The HIP array to get info for</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipErrorInvalidHandle hipError_t hipArrayGetDescriptor ( HIP_ARRAY_DESCRIPTOR *pArrayDescriptor, hipArray_t array )</p>
-<p>Gets a 1D or 2D array descriptor.</p>
-<h2>See also:</h2>
-<p>hipArray3DCreate , hipArray3DGetDescriptor , hipArrayCreate , hipArrayDestroy , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpy3D , hipMemcpy3DAsync , hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoD , hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer, hipMemsetD8 , hipMemsetD16 , hipMemsetD32 , hipArrayGetInfo</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">pArrayDescriptor -[out] - Returned array descriptor</li>
-<li style="list-style-type: '· ';">array -[in] - Array to get descriptor of</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue hipErrorInvalidHandle</p>
-<p>hipError_t hipArray3DGetDescriptor ( HIP_ARRAY3D_DESCRIPTOR *pArrayDescriptor, hipArray_t array )</p>
-<p>Gets a 3D array descriptor.</p>
-<h2>See also:</h2>
-<p>hipArray3DCreate , hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpy3D , hipMemcpy3DAsync , hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoD , hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer, hipMemsetD8 , hipMemsetD16 , hipMemsetD32 , hipArrayGetInfo</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">pArrayDescriptor -[out] - Returned 3D array descriptor</li>
-<li style="list-style-type: '· ';">array -[in] - 3D array to get descriptor of</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue hipErrorInvalidHandle, hipErrorContextIsDestroyed hipError_t hipMemcpy2D ( void *dst, size_t dpitch, const void *src, size_t spitch, size_t width, size_t height, hipMemcpyKind kind )</p>
-<p>Copies data between host and device.</p>
-<h2>See also:</h2>
-<p>hipMemcpy , hipMemcpyToArray , hipMemcpy2DToArray , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[in] Destination memory address</li>
-<li style="list-style-type: '· ';">dpitch -[in] Pitch of destination memory</li>
-<li style="list-style-type: '· ';">src -[in] Source memory address</li>
-<li style="list-style-type: '· ';">spitch -[in] Pitch of source memory</li>
-<li style="list-style-type: '· ';">width -[in] Width of matrix transfer (columns in bytes)</li>
-<li style="list-style-type: '· ';">height -[in] Height of matrix transfer (rows)</li>
-<li style="list-style-type: '· ';">kind -[in] Type of transfer</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError_t hipMemcpyParam2D ( const hip_Memcpy2D *pCopy )</p>
-<p>Copies memory for 2D arrays.</p>
-<h2>See also:</h2>
-<p>hipMemcpy , hipMemcpy2D , hipMemcpyToArray , hipMemcpy2DToArray , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync</p>
-<h2>Parameters</h2>
-<p>pCopy -[in] Parameters for the memory copy</p>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError_t hipMemcpyParam2DAsync ( const hip_Memcpy2D *pCopy, hipStream_t stream )</p>
-<p>Copies memory for 2D arrays.</p>
-<h2>See also:</h2>
-<p>hipMemcpy , hipMemcpy2D , hipMemcpyToArray , hipMemcpy2DToArray , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">pCopy -[in] Parameters for the memory copy</li>
-<li style="list-style-type: '· ';">stream -[in] Stream to use</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError_t hipMemcpy2DAsync ( void *dst, size_t dpitch, const void *src, size_t spitch, size_t width, size_t height, hipMemcpyKind kind, hipStream_t stream )</p>
-<p>Copies data between host and device.</p>
-<h2>See also:</h2>
-<p>hipMemcpy , hipMemcpyToArray , hipMemcpy2DToArray , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[in] Destination memory address</li>
-<li style="list-style-type: '· ';">dpitch -[in] Pitch of destination memory</li>
-<li style="list-style-type: '· ';">src -[in] Source memory address</li>
-<li style="list-style-type: '· ';">spitch -[in] Pitch of source memory</li>
-<li style="list-style-type: '· ';">width -[in] Width of matrix transfer (columns in bytes)</li>
-<li style="list-style-type: '· ';">height -[in] Height of matrix transfer (rows)</li>
-<li style="list-style-type: '· ';">kind -[in] Type of transfer</li>
-<li style="list-style-type: '· ';">stream -[in] Stream to use</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError_t hipMemcpy2DToArray ( hipArray_t dst, size_t wOffset, size_t hOffset, const void *src, size_t spitch, size_t width, size_t height, hipMemcpyKind kind )</p>
-<p>Copies data between host and device.</p>
-<h2>See also:</h2>
-<p>hipMemcpy , hipMemcpyToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[in] Destination memory address</li>
-<li style="list-style-type: '· ';">wOffset -[in] Destination starting X offset</li>
-<li style="list-style-type: '· ';">hOffset -[in] Destination starting Y offset</li>
-<li style="list-style-type: '· ';">src -[in] Source memory address</li>
-<li style="list-style-type: '· ';">spitch -[in] Pitch of source memory</li>
-<li style="list-style-type: '· ';">width -[in] Width of matrix transfer (columns in bytes)</li>
-<li style="list-style-type: '· ';">height -[in] Height of matrix transfer (rows)</li>
-<li style="list-style-type: '· ';">kind -[in] Type of transfer</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError_t hipMemcpy2DToArrayAsync ( hipArray_t dst, size_t wOffset, size_t hOffset, const void *src, size_t spitch, size_t width, size_t height, hipMemcpyKind kind, hipStream_t stream )</p>
-<p>Copies data between host and device.</p>
-<h2>See also:</h2>
-<p>hipMemcpy , hipMemcpyToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[in] Destination memory address</li>
-<li style="list-style-type: '· ';">wOffset -[in] Destination starting X offset</li>
-<li style="list-style-type: '· ';">hOffset -[in] Destination starting Y offset</li>
-<li style="list-style-type: '· ';">src -[in] Source memory address</li>
-<li style="list-style-type: '· ';">spitch -[in] Pitch of source memory</li>
-<li style="list-style-type: '· ';">width -[in] Width of matrix transfer (columns in bytes)</li>
-<li style="list-style-type: '· ';">height -[in] Height of matrix transfer (rows)</li>
-</ul>
-<ul>
-<li style="list-style-type: '· ';">kind -[in] Type of transfer</li>
-<li style="list-style-type: '· ';">stream -[in] Accelerator view which the copy is being enqueued</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError_t hipMemcpyToArray ( hipArray_t dst, size_t wOffset, size_t hOffset, const void *src, size_t count, hipMemcpyKind kind )</p>
-<p>Copies data between host and device.</p>
-<h2>See also:</h2>
-<p>hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync</p>
-<p>Warning: This API is deprecated.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[in] Destination memory address</li>
-<li style="list-style-type: '· ';">wOffset -[in] Destination starting X offset</li>
-<li style="list-style-type: '· ';">hOffset -[in] Destination starting Y offset</li>
-<li style="list-style-type: '· ';">src -[in] Source memory address</li>
-<li style="list-style-type: '· ';">count -[in] size in bytes to copy</li>
-<li style="list-style-type: '· ';">kind -[in] Type of transfer</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError_t hipMemcpyFromArray ( void *dst, hipArray_const_t srcArray, size_t wOffset, size_t hOffset, size_t count, hipMemcpyKind kind )</p>
-<p>Copies data between host and device.</p>
-<h2>See also:</h2>
-<p>hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync</p>
-<p>Warning: This API is deprecated.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[in] Destination memory address</li>
-<li style="list-style-type: '· ';">srcArray -[in] Source memory address</li>
-<li style="list-style-type: '· ';">wOffset -[in] Source starting X offset</li>
-</ul>
-<ul>
-<li style="list-style-type: '· ';">hOffset -[in] Source starting Y offset</li>
-<li style="list-style-type: '· ';">count -[in] Size in bytes to copy</li>
-<li style="list-style-type: '· ';">kind -[in] Type of transfer</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError_t hipMemcpy2DFromArray ( void *dst, size_t dpitch, hipArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, hipMemcpyKind kind )</p>
-<p>Copies data between host and device.</p>
-<h2>See also:</h2>
-<p>hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[in] Destination memory address</li>
-<li style="list-style-type: '· ';">dpitch -[in] Pitch of destination memory</li>
-<li style="list-style-type: '· ';">src -[in] Source memory address</li>
-<li style="list-style-type: '· ';">wOffset -[in] Source starting X offset</li>
-<li style="list-style-type: '· ';">hOffset -[in] Source starting Y offset</li>
-<li style="list-style-type: '· ';">width -[in] Width of matrix transfer (columns in bytes)</li>
-<li style="list-style-type: '· ';">height -[in] Height of matrix transfer (rows)</li>
-<li style="list-style-type: '· ';">kind -[in] Type of transfer</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError_t hipMemcpy2DFromArrayAsync ( void *dst, size_t dpitch, hipArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, hipMemcpyKind kind, hipStream_t stream )</p>
-<p>Copies data between host and device asynchronously.</p>
-<h2>See also:</h2>
-<p>hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[in] Destination memory address</li>
-<li style="list-style-type: '· ';">dpitch -[in] Pitch of destination memory</li>
-<li style="list-style-type: '· ';">src -[in] Source memory address</li>
-<li style="list-style-type: '· ';">wOffset -[in] Source starting X offset</li>
-</ul>
-<ul>
-<li style="list-style-type: '· ';">hOffset -[in] Source starting Y offset</li>
-<li style="list-style-type: '· ';">width -[in] Width of matrix transfer (columns in bytes)</li>
-<li style="list-style-type: '· ';">height -[in] Height of matrix transfer (rows)</li>
-<li style="list-style-type: '· ';">kind -[in] Type of transfer</li>
-<li style="list-style-type: '· ';">stream -[in] Accelerator view which the copy is being enqueued</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError_t hipMemcpyAtoH ( void *dst, hipArray_t srcArray, size_t srcOffset, size_t count )</p>
-<p>Copies data between host and device.</p>
-<h2>See also:</h2>
-<p>hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dst -[in] Destination memory address</li>
-<li style="list-style-type: '· ';">srcArray -[in] Source array</li>
-<li style="list-style-type: '· ';">srcOffset -[in] Offset in bytes of source array</li>
-<li style="list-style-type: '· ';">count -[in] Size of memory copy in bytes</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError_t hipMemcpyHtoA ( hipArray_t dstArray, size_t dstOffset, const void *srcHost, size_t count )</p>
-<p>Copies data between host and device.</p>
-<h2>See also:</h2>
-<p>hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dstArray -[in] Destination memory address</li>
-<li style="list-style-type: '· ';">dstOffset -[in] Offset in bytes of destination array</li>
-<li style="list-style-type: '· ';">srcHost -[in] Source host pointer</li>
-<li style="list-style-type: '· ';">count -[in] Size of memory copy in bytes</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection</p>
-<p>hipError_t hipMemcpy3D ( const struct hipMemcpy3DParms *p )</p>
-<p>Copies data between host and device.</p>
-<h2>See also:</h2>
-<p>hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync</p>
-<h2>Parameters</h2>
-<p>p -[in] 3D memory copy parameters</p>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError_t hipMemcpy3DAsync ( const struct hipMemcpy3DParms *p, hipStream_t stream )</p>
-<p>Copies data between host and device asynchronously.</p>
-<h2>See also:</h2>
-<p>hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">p -[in] 3D memory copy parameters</li>
-<li style="list-style-type: '· ';">stream -[in] Stream to use</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError_t hipDrvMemcpy3D ( const HIP_MEMCPY3D *pCopy )</p>
-<p>Copies data between host and device.</p>
-<h2>See also:</h2>
-<p>hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync</p>
-<h2>Parameters</h2>
-<p>pCopy -[in] 3D memory copy parameters</p>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError_t hipDrvMemcpy3DAsync ( const HIP_MEMCPY3D *pCopy, hipStream_t stream )</p>
-<p>Copies data between host and device asynchronously.</p>
-<h2>See also:</h2>
-<p>hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">pCopy -[in] 3D memory copy parameters</li>
-<li style="list-style-type: '· ';">stream -[in] Stream to use</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection template&lt;typename T &gt; hipError_t hipGetSymbolAddress ( void **devPtr, const T &amp;symbol ) Gets the address of a symbol.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">devPtr -[out] - Returns device pointer associated with symbol.</li>
-<li style="list-style-type: '· ';">symbol -[in] - Device symbol.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue template&lt;typename T &gt; hipError_t hipGetSymbolSize ( size_t *size, const T &amp;symbol ) Gets the size of a symbol.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">size -[out] - Returns the size of a symbol.</li>
-<li style="list-style-type: '· ';">symbol -[in] - Device symbol address.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue template&lt;typename T &gt;</p>
-<p>hipError_t hipMemcpyToSymbol ( const T &amp;symbol, const void *src, size_t sizeBytes, size_t offset, hipMemcpyKind kind )</p>
-<p>Copies data to the given symbol on the device.</p>
-<h2>See also:</h2>
-<p>hipMemcpyToSymbol</p>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidMemcpyDirection, hipErrorInvalidValue template&lt;typename T &gt;</p>
-<p>hipError_t hipMemcpyToSymbolAsync ( const T &amp;symbol, const void *src, size_t sizeBytes, size_t offset, hipMemcpyKind kind, hipStream_t stream )</p>
-<p>Copies data to the given symbol on the device asynchronously on the stream.</p>
-<h2>See also:</h2>
-<p>hipMemcpyToSymbolAsync</p>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidMemcpyDirection, hipErrorInvalidValue template&lt;typename T &gt;</p>
-<p>hipError_t hipMemcpyFromSymbol ( void *dst, const T &amp;symbol, size_t sizeBytes, size_t offset, hipMemcpyKind kind )</p>
-<p>Copies data from the given symbol on the device.</p>
-<h2>See also:</h2>
-<p>hipMemcpyFromSymbol</p>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidMemcpyDirection, hipErrorInvalidValue template&lt;typename T &gt;</p>
-<p>hipError_t hipMemcpyFromSymbolAsync ( void *dst, const T &amp;symbol, size_t sizeBytes, size_t offset, hipMemcpyKind kind, hipStream_t stream )</p>
-<p>Copies data from the given symbol on the device asynchronously on the stream.</p>
-<h2>See also:</h2>
-<p>hipMemcpyFromSymbolAsync</p>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidMemcpyDirection, hipErrorInvalidValue template&lt;class T &gt;</p>
-<p>static inline hipError_t hipMalloc ( T **devPtr, size_t size )</p>
-<ul>
-<li>: C++ wrapper for hipMalloc</li>
-</ul>
-<p>Perform automatic type conversion to eliminate need for excessive typecasting (ie void**)</p>
-<p>HIP_DISABLE_CPP_FUNCTIONS macro can be defined to suppress these wrappers. It is useful for applications which need to obtain decltypes of HIP runtime APIs.</p>
-<h2>See also:</h2>
-<p>hipMalloc</p>
-<h2>template&lt;class T &gt;</h2>
-<p>static inline hipError_t hipHostMalloc ( T **ptr, size_t size, unsigned int flags = hipHostMallocDefault )</p>
-<ul>
-<li>: C++ wrapper for hipHostMalloc</li>
-</ul>
-<p>Provide an override to automatically typecast the pointer type from void**, and also provide a default for the flags.</p>
-<p>HIP_DISABLE_CPP_FUNCTIONS macro can be defined to suppress these wrappers. It is useful for applications which need to obtain decltypes of HIP runtime APIs.</p>
-<h2>See also:</h2>
-<p>hipHostMalloc</p>
-<h2>19.23.4 External Resource Interoperability</h2>
-<p>hipError_t hipImportExternalSemaphore ( hipExternalSemaphore_t *extSem_out, const hipExternalSemaphoreHandleDesc *semHandleDesc )</p>
-<p>Imports an external semaphore.</p>
-<p>See also:</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">extSem_out -[out] External semaphores to be waited on</li>
-<li style="list-style-type: '· ';">semHandleDesc -[in] Semaphore import handle descriptor</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError_t hipSignalExternalSemaphoresAsync ( const hipExternalSemaphore_t *extSemArray, const hipExternalSemaphoreSignalParams *paramsArray, unsigned int numExtSems, hipStream_t stream )</p>
-<p>Signals a set of external semaphore objects.</p>
-<h2>See also:</h2>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">extSemArray -[in] External semaphores to be waited on</li>
-<li style="list-style-type: '· ';">paramsArray -[in] Array of semaphore parameters</li>
-<li style="list-style-type: '· ';">numExtSems -[in] Number of semaphores to wait on</li>
-<li style="list-style-type: '· ';">stream -[in] Stream to enqueue the wait operations in</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError_t hipWaitExternalSemaphoresAsync ( const hipExternalSemaphore_t *extSemArray, const hipExternalSemaphoreWaitParams *paramsArray, unsigned int numExtSems, hipStream_t stream )</p>
-<p>Waits on a set of external semaphore objects.</p>
-<p>See also:</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">extSemArray -[in] External semaphores to be waited on</li>
-<li style="list-style-type: '· ';">paramsArray -[in] Array of semaphore parameters</li>
-<li style="list-style-type: '· ';">numExtSems -[in] Number of semaphores to wait on</li>
-<li style="list-style-type: '· ';">stream -[in] Stream to enqueue the wait operations in</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue</p>
-<h2>hipError_t hipDestroyExternalSemaphore ( hipExternalSemaphore_t extSem )</h2>
-<p>Destroys an external semaphore object and releases any references to the underlying resource. Any outstanding signals or waits must have completed before the semaphore is destroyed.</p>
-<h2>See also:</h2>
-<h2>Parameters</h2>
-<p>extSem -[in] handle to an external memory object</p>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError_t hipImportExternalMemory ( hipExternalMemory_t *extMem_out, const hipExternalMemoryHandleDesc *memHandleDesc )</p>
-<p>Imports an external memory object.</p>
-<h2>See also:</h2>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">extMem_out -[out] Returned handle to an external memory object</li>
-<li style="list-style-type: '· ';">memHandleDesc -[in] Memory import handle descriptor</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError_t hipExternalMemoryGetMappedBuffer ( void **devPtr, hipExternalMemory_t extMem, const hipExternalMemoryBufferDesc *bufferDesc )</p>
-<p>Maps a buffer onto an imported memory object.</p>
-<h2>See also:</h2>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">devPtr -[out] Returned device pointer to buffer</li>
-<li style="list-style-type: '· ';">extMem -[in] Handle to external memory object</li>
-<li style="list-style-type: '· ';">bufferDesc -[in] Buffer descriptor</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue</p>
-<h2>hipError_t hipDestroyExternalMemory ( hipExternalMemory_t extMem )</h2>
-<p>Destroys an external memory object.</p>
-<p>See also:</p>
-<h2>Parameters</h2>
-<p>extMem -[in] External memory object to be destroyed</p>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError_t hipExternalMemoryGetMappedMipmappedArray ( hipMipmappedArray_t *mipmap,</p>
-<p>hipExternalMemory_t extMem, const hipExternalMemoryMipmappedArrayDesc *mipmapDesc )</p>
-<p>Maps a mipmapped array onto an external memory object.</p>
-<p>Returned mipmapped array must be freed using hipFreeMipmappedArray.</p>
-<h2>See also:</h2>
-<p>hipImportExternalMemory , hipFreeMipmappedArray</p>
-<p>hipDestroyExternalMemory ,</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">mipmap -[out] mipmapped array to return</li>
-<li style="list-style-type: '· ';">extMem -[in] external memory object handle</li>
-<li style="list-style-type: '· ';">mipmapDesc -[in] external mipmapped array descriptor</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorInvalidResourceHandle</p>
-<h2>19.24 Register Keyword</h2>
-<p>The register keyword is deprecated in C++, and is silently ignored by both NVCC and HIP-Clang. You can pass the option -Wdeprecated-register the compiler warning message.</p>
-<p>hipExternalMemoryGetMappedBuffer ,</p>
-<h2>19.25 Pragma Unroll</h2>
-<p>Unroll with a bounds that is known at compile-time is supported. For example:</p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        //                                                                                                                                                                                                        #pragma unroll 16 /* hint to compiler to unroll next loop by 16 */
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        }                                                                                                                                                                                                        /*                                                                                                                                                                                                        */
-                                                                                                                                                                                                     
-		                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       //
-                                                                                                                                                                                                       }
-                                                                                                                                                                                                       */</code></pre>
-<h2>19.26 In-Line Assembly</h2>
-<p>GCN ISA In-line assembly, is supported. For example:</p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <img>void                                                                                                                                                                                                        </img>void</code></pre>
-<p>We insert the GCN isa into the kernel using asm() Assembler statement. volatile keyword is used so that the optimizers must not change the number of volatile operations or change their order of execution relative to other volatile operations. v_mac_f32_e32 is the GCN instruction, for more information please refer - [AMD GCN3 ISA architecture manual](http://gpuopen.com/compute-product/amd-gcn3-isa-architecture-manual/) Index for the respective operand in the ordered fashion is provided by % followed by position in the list of operands 'v' is the constraint code (for target-specific AMDGPU) for 32-bit VGPR register, for more info please refer - [Supported Constraint Code List for AMDGPU](https://llvm.org/docs/LangRef.html#supported-constraint-code-list) Output Constraints are specified by an '=' prefix as shown above ('=v'). This indicate that assembly will write to this operand, and the operand will then be made available as a return value of the asm expression. Input constraints do not have a prefix - just the constraint code. The constraint string of '0' says to use the assigned register for output as an input as well (it being the 0'th constraint).</p>
-<p>## C++ Support The following C++ features are not supported: - Run-time-type information (RTTI) - Try/catch Virtual functions Virtual functions are not supported if objects containing virtual function tables are passed between GPU's of different offload arch's, e.g. between gfx906 and gfx1030. Otherwise virtual functions are supported.</p>
-<h2>19.27 Kernel Compilation</h2>
-<p>hipcc now supports compiling C++/HIP kernels to binary code objects. The file format for binary is .co which means Code Object. The following command builds the code object using hipcc .</p>
-<pre><code>hipcc --genco --offload-arch=[TARGET GPU] [INPUT FILE] -o [OUTPUT FILE]
-
-[TARGET GPU] = GPU architecture
-[INPUT FILE] = Name of the file containing kernels
-[OUTPUT FILE] = Name of the generated code object file</code></pre>
-<p>Note: When using binary code objects is that the number of arguments to the kernel is different on HIP-Clang and NVCC path. Refer to the HIP module_api sample for differences in the arguments to be passed to the kernel.</p>
-<h2>19.28 gfx-arch-specific-kernel</h2>
-<p>Clang defined '__gfx*__' macros can be used to execute gfx arch specific codes inside the kernel. Refer to the sample in HIP 14_gpu_arch sample.</p>
-<h2>CHAPTER</h2>
-<h2>TWENTY</h2>
-<h2>C++ LANGUAGE SUPPORT</h2>
-<p>The ROCm platform enables the power of combined C++ and HIP (Heterogeneous-computing Interface for Portability) code. This code is compiled with a clang or clang++ compiler. The official compilers support the HIP platform, or you can use the amdclang or amdclang++ included in the ROCm installation, which are a wrapper for the official versions.</p>
-<p>The source code is compiled according to the C++03 , C++11 , C++14 , C++17 , and C++20 standards, along with HIPspecific extensions, but is subject to restrictions. The key restriction is the reduced support of standard library in device code. This is due to the fact that by default a function is considered to run on host, except for constexpr functions, which can run on host and device as well.</p>
-<h2>20.1 Modern C++ support</h2>
-<p>C++ is considered a modern programming language as of C++11. This section describes how HIP supports these new C++ features.</p>
-<h2>20.1.1 C++11 support</h2>
-<p>The C++11 standard introduced many new features. These features are supported in HIP host code, with some notable omissions on the device side. The rule of thumb here is that constexpr functions work on device, the rest doesn't. This means that some important functionality like std::function is missing on the device, but unfortunately the standard library wasn't designed with HIP in mind, which means that the support is in a state of 'works as-is'.</p>
-<p>Certain features have restrictions and clarifications. For example, any functions using the constexpr qualifier or the new initializer lists , std::move or std::forward features are implicitly considered to have the __host__ and __device__ execution space specifier. Also, constexpr variables that are static members or namespace scoped can be used from both host and device, but only for read access. Dereferencing a static constexpr outside its specified execution space causes an error.</p>
-<p>Lambdas are supported, but there are some extensions and restrictions on their usage. For more information, see the Extended lambdas section below.</p>
-<h2>20.1.2 C++14 support</h2>
-<p>The C++14 language features are supported.</p>
-<h2>20.1.3 C++17 support</h2>
-<p>All C++17 language features are supported.</p>
-<h2>20.1.4 C++20 support</h2>
-<p>All C++20 language features are supported, but extensions and restrictions apply. C++20 introduced coroutines and modules, which fundamentally changed how programs are written. HIP doesn't support these features. However, consteval functions can be called from host and device, even if specified for host use only.</p>
-<p>The three-way comparison operator (spaceship operator &lt;=&gt; ) works with host and device code.</p>
-<h2>20.2 Extensions and restrictions</h2>
-<p>In addition to the deviations from the standard, there are some general extensions and restrictions to consider.</p>
-<h2>20.2.1 Global functions</h2>
-<p>Functions that serve as an entry point for device execution are called kernels and are specified with the __global__ qualifier. To call a kernel function, use the triple chevron operator: &lt;&lt;&lt; &gt;&gt;&gt; . Kernel functions must have a void return type. These functions can't:</p>
-<ul>
-<li style="list-style-type: '· ';">have a constexpr specifier</li>
-<li style="list-style-type: '· ';">have a parameter of type std::initializer_list or va_list</li>
-<li style="list-style-type: '· ';">use an rvalue reference as a parameter.</li>
-<li style="list-style-type: '· ';">use parameters having different sizes in host and device code, e.g. long double arguments, or structs containing long double members.</li>
-<li style="list-style-type: '· ';">use struct-type arguments which have different layout in host and device code.</li>
-</ul>
-<p>Kernels can have variadic template parameters, but only one parameter pack, which must be the last item in the template parameter list.</p>
-<h2>20.2.2 Device space memory specifiers</h2>
-<p>HIP includes device space memory specifiers to indicate whether a variable is allocated in host or device memory and howits memory should be allocated. HIP supports the __device__ , __shared__ , __managed__ , and __constant__ specifiers.</p>
-<p>The __device__ and __constant__ specifiers define global variables, which are allocated within global memory on the HIP devices. The only difference is that __constant__ variables can't be changed after allocation. The __shared__ specifier allocates the variable within shared memory, which is available for all threads in a block.</p>
-<p>The __managed__ variable specifier creates global variables that are initially undefined and unaddressed within the global symbol table. The HIP runtime allocates managed memory and defines the symbol when it loads the device binary. A managed variable can be accessed in both device and host code.</p>
-<p>It's important to know where a variable is stored because it is only available from certain locations. Generally, variables allocated in the host memory are not accessible from the device code, while variables allocated in the device memory are not directly accessible from the host code. Dereferencing a pointer to device memory on the host results in a segmentation fault. Accessing device variables in host code should be done through kernel execution or HIP functions like hipMemCpyToSymbol .</p>
-<h2>20.2.3 Exception handling</h2>
-<p>An important difference between the host and device code is exception handling. In device code, this control flow isn't available due to the hardware architecture. The device code must use return codes to handle errors.</p>
-<h2>20.2.4 Kernel parameters</h2>
-<p>There are some restrictions on kernel function parameters. They cannot be passed by reference, because these functions are called from the host but run on the device. Also, a variable number of arguments is not allowed.</p>
-<h2>20.2.5 Classes</h2>
-<p>Classes work on both the host and device side, but there are some constraints. The static member functions can't be __global__ . Virtual member functions work, but a virtual function must not be called from the host if the parent object was created on the device, or the other way around, because this behavior is undefined. Another minor restriction is that __device__ variables, that are global scoped must have trivial constructors.</p>
-<h2>20.2.6 Polymorphic function wrappers</h2>
-<p>HIP doesn't support the polymorphic function wrapper std::function , which was introduced in C++11.</p>
-<h2>20.2.7 Extended lambdas</h2>
-<p>HIP supports Lambdas, which by default work as expected.</p>
-<p>Lambdas have implicit host device attributes. This means that they can be executed by both host and device code, and works the way you would expect. To make a lambda callable only by host or device code, users can add __host__ or __device__ attribute. The only restriction is that host variables can only be accessed through copy on the device. Accessing through reference will cause undefined behavior.</p>
-<h2>20.2.8 Inline namespaces</h2>
-<p>Inline namespaces are supported, but with a few exceptions. The following entities can't be declared in namespace scope within an inline unnamed namespace:</p>
-<ul>
-<li style="list-style-type: '· ';">__managed__ , __device__ , __shared__ and __constant__ variables</li>
-<li style="list-style-type: '· ';">__global__ function and function templates</li>
-<li style="list-style-type: '· ';">variables with surface or texture type</li>
-</ul>
-<h2>CHAPTER</h2>
-<h2>TWENTYONE</h2>
-<h2>HIP MATH API</h2>
-<p>HIP-Clang supports a set of math operations that are callable from the device. HIP supports most of the device functions supported by NVIDIA CUDA. These are described in the following sections.</p>
-<h2>21.1 Single precision mathematical functions</h2>
-<p>Following is the list of supported single precision mathematical functions.</p>
-<table><caption><div class="caption">Table 1: Single precision mathematical functions</div></caption><tbody><tr><th>Function</th><th>Supported on Host</th><th>Supported on Device</th></tr><tr><td>float abs(float x) Returns the absolute value of 𝑥</td><td>✓</td><td>✓</td></tr><tr><td>float acosf(float x) Returns the arc cosine of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float acoshf(float x) Returns the nonnegative arc hyperbolic cosine of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float asinf(float x) Returns the arc sine of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float asinhf(float x) Returns the arc hyperbolic sine of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float atanf(float x) Returns the arc tangent of 𝑥 .</td><td>✓</td><td>✓</td></tr></tbody></table>
-<p>continues on next page</p>
-<table><tbody><tr><td></td><th>Table</th><th>1 - continued from previous page</th></tr><tr><td>float atan2f(float x, float y) Returns the arc tangent of the ratio of 𝑥 and 𝑦 .</td><td>✓</td><td>✓</td></tr><tr><td>float atanhf(float x) Returns the arc hyperbolic tangent of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float cbrtf(float x) Returns the cube root of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float ceilf(float x) Returns ceiling of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float copysignf(float x, float y) Create value with given magnitude, copying sign of second value.</td><td>✓</td><td>✓</td></tr><tr><td>float cosf(float x) Returns the cosine of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float coshf(float x) Returns the hyperbolic cosine of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float cospif(float x) Returns the cosine of 𝜋 · 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float cyl_bessel_i0f(float x) Returns the value of the regular modified cylindrical Bessel function of order 0 for 𝑥 .</td><td></td><td></td></tr></tbody></table>
-<p>continues on next page</p>
-<table><caption><div class="caption">Table 1 - continued from previous page</div></caption><tbody><tr><td>float cyl_bessel_i1f(float x) Returns the value of the regular modified cylindrical Bessel function of order 1 for 𝑥 .</td><td></td><td></td></tr><tr><td>float erff(float x) Returns the error function of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float erfcf(float x) Returns the complementary error function of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float erfcinvf(float x) Returns the inverse complementary function of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float erfcxf(float x) Returns the scaled complementary error function of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float erfinvf(float x) Returns the inverse error function of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float expf(float x) Returns 𝑒 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float exp10f(float x) Returns 10 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float exp2f( float x) Returns 2 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float expm1f(float x) Returns 𝑙𝑛 ( 𝑥 - 1)</td><td>✓</td><td>✓</td></tr></tbody></table>
-<p>continues on next page</p>
-<p>Table</p>
-<p>1 - continued from previous page</p>
-<table><tbody><tr><td>float fabsf(float x) Returns the absolute value of x</td><td>✓</td><td>✓</td></tr><tr><td>float fdimf(float x, float y) Returns the positive difference between 𝑥 and 𝑦 .</td><td>✓</td><td>✓</td></tr><tr><td>float fdividef(float x, float y) Divide two floating point values.</td><td>✓</td><td>✓</td></tr><tr><td>float floorf(float x) Returns the largest integer less than or equal to 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float fmaf(float x, float y, float z) Returns 𝑥 · 𝑦 + 𝑧 as a single operation.</td><td>✓</td><td>✓</td></tr><tr><td>float fmaxf(float x, float y) Determine the maximum numeric value of 𝑥 and 𝑦 .</td><td>✓</td><td>✓</td></tr><tr><td>float fminf(float x, float y) Determine the minimum numeric value of 𝑥 and 𝑦 .</td><td>✓</td><td>✓</td></tr><tr><td>float fmodf(float x, float y) Returns the floating-point remainder of 𝑥/𝑦 .</td><td>✓</td><td>✓</td></tr><tr><td>float modff(float x, float* iptr) Break down 𝑥 into fractional and integral parts.</td><td>✓</td><td></td></tr></tbody></table>
-<p>continues on next page</p>
-<table><caption><div class="caption">Table 1 - continued from previous page</div></caption><tbody><tr><td>float frexpf(float x, int* nptr) Extract mantissa and exponent of 𝑥 .</td><td>✓</td></tr><tr><td>float hypotf(float x, float y) Returns the square root of the sum of squares of 𝑥 and 𝑦 .</td><td>✓</td></tr><tr><td>int ilogbf(float x) Returns the unbiased integer exponent of 𝑥 .</td><td>✓</td></tr><tr><td>bool isfinite(float x) Determine whether 𝑥 is finite.</td><td>✓</td></tr><tr><td>bool isinf(float x) Determine whether 𝑥 is infinite.</td><td>✓</td></tr><tr><td>bool isnan(float x) Determine whether 𝑥 is a NAN .</td><td>✓</td></tr><tr><td>float j0f(float x) Returns the value of the Bessel function of the first kind of order 0 for 𝑥 .</td><td>✓</td></tr><tr><td>float j1f(float x) Returns the value of the Bessel function of the first kind of order 1 for 𝑥 .</td><td>✓</td></tr><tr><td>float jnf(int n, float x) Returns the value of the Bessel function of the first kind of order n for 𝑥 .</td><td>✓</td></tr></tbody></table>
-<p>continues on next page</p>
-<p>Table</p>
-<p>1 - continued from previous page</p>
-<table><tbody><tr><td>float ldexpf(float x, int exp) Returns the natural logarithm of the absolute value of the gamma function of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float lgammaf(float x) Returns the natural logarithm of the absolute value of the gamma function of 𝑥 .</td><td>✓</td><td></td></tr><tr><td>long int lrintf(float x) Round 𝑥 to nearest integer value.</td><td>✓</td><td>✓</td></tr><tr><td>long long int llrintf(float x) Round 𝑥 to nearest integer value.</td><td>✓</td><td>✓</td></tr><tr><td>long int lroundf(float x) Round to nearest integer value.</td><td>✓</td><td>✓</td></tr><tr><td>long long int llroundf(float x) Round to nearest integer value.</td><td>✓</td><td>✓</td></tr><tr><td>float log10f(float x) Returns the base 10 logarithm of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float log1pf(float x) Returns the natural logarithm of 𝑥 +1 .</td><td>✓</td><td>✓</td></tr><tr><td>float log2f(float x) Returns the base 2 logarithm of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float logf(float x) Returns the natural logarithm of 𝑥 .</td><td>✓</td><td>✓</td></tr></tbody></table>
-<p>continues on next page</p>
-<table><caption><div class="caption">Table 1 - continued from previous page</div></caption><tbody><tr><td></td><td></td><th>✓</th></tr><tr><td>float logbf(float x) Returns the floating point representation of the exponent of 𝑥 .</td><td>✓</td><td></td></tr><tr><td>float nanf(const char* tagp) Returns &#x27;Not a Number&#x27; value.</td><td></td><td>✓</td></tr><tr><td>float nearbyintf(float x) Round 𝑥 to the nearest integer.</td><td>✓</td><td>✓</td></tr><tr><td>float nextafterf(float x, float y) Returns next representable single-precision floating-point value after argument.</td><td>✓</td><td></td></tr><tr><td>float norm3df(float x, float y, float z) Returns the square root of the sum of squares of 𝑥 , 𝑦 and 𝑧 .</td><td>✓</td><td>✓</td></tr><tr><td>float norm4df(float x, float y, float z, float w) Returns the square root of the sum of squares of 𝑥 , 𝑦 , 𝑧 and 𝑤 .</td><td>✓</td><td>✓</td></tr><tr><td>float normcdff(float y) Returns the standard normal cumulative distribution function.</td><td>✓</td><td>✓</td></tr><tr><td>float normcdfinvf(float y) Returns the inverse of the standard normal cumulative distribution function.</td><td>✓</td><td>✓</td></tr><tr><td>float normf(int dim, const float *a) Returns the square root of the sum of squares of any number of coordinates.</td><td>✓</td><td>✓</td></tr></tbody></table>
-<p>continues on next page</p>
-<table><tbody><tr><td></td><th>Table</th><th>1 - continued from previous page</th></tr><tr><td>float powf(float x, float y) Returns 𝑥 𝑦 .</td><td>✓</td><td>✓</td></tr><tr><td>float powif(float base, int iexp) Returns the value of first argument to the power of second argument.</td><td>✓</td><td>✓</td></tr><tr><td>float remainderf(float x, float y) Returns single-precision floating-point remainder.</td><td>✓</td><td>✓</td></tr><tr><td>float remquof(float x, float y, int* quo) Returns single-precision floating-point remainder and part of quotient.</td><td>✓</td><td>✓</td></tr><tr><td>float roundf(float x) Round to nearest integer value in floating-point.</td><td>✓</td><td>✓</td></tr><tr><td>float rcbrtf(float x) Returns the reciprocal cube root function.</td><td>✓</td><td>✓</td></tr><tr><td>float rhypotf(float x, float y) Returns one over the square root of the sum of squares of two arguments.</td><td>✓</td><td>✓</td></tr><tr><td>float rintf(float x) Round input to nearest integer value in floating-point.</td><td>✓</td><td>✓</td></tr></tbody></table>
-<p>continues on next page</p>
-<p>Table</p>
-<p>1 - continued from previous page</p>
-<table><tbody><tr><td>float rnorm3df(float x, float y, float z) Returns one over the square root of the sum of squares of three coordinates of the argument.</td><td>✓</td><td>✓</td></tr><tr><th>float rnorm4df(float x, float y, float z, float w) Returns one over the square root of the sum of squares of four coordinates of the argument.</th><td>✓</td><td>✓</td></tr><tr><th>float rnormf(int dim, const float *a) Returns the reciprocal of square root of the sum of squares of any number of coordinates.</th><td>✓</td><td>✓</td></tr><tr><th>float scalblnf(float x, long int n) Scale 𝑥 by 2 𝑛 .</th><td>✓</td><td>✓</td></tr><tr><th>float scalbnf(float x, int n) Scale 𝑥 by 2 𝑛 .</th><td>✓</td><td>✓</td></tr><tr><th>bool signbit(float x) Return the sign bit of 𝑥 .</th><td>✓</td><td>✓</td></tr><tr><th>float sinf(float x) Returns the sine of 𝑥 .</th><td>✓</td><td>✓</td></tr><tr><th>float sinhf(float x) Returns the hyperbolic sine of 𝑥 .</th><td>✓</td><td>✓</td></tr><tr><th>float sinpif(float x) Returns the hyperbolic sine of 𝜋 · 𝑥 .</th><td>✓</td><td>✓</td></tr></tbody></table>
-<p>continues on next page</p>
-<p>Table</p>
-<p>1 - continued from previous page</p>
-<table><tbody><tr><td>void sincosf(float x, float *sptr, float *cptr) Returns the sine and cosine of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>void sincospif(float x, float *sptr, float *cptr) Returns the sine and cosine of 𝜋 · 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float sqrtf(float x) Returns the square root of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float rsqrtf(float x) Returns the reciprocal of the square root of 𝑥 .</td><td></td><td>✓</td></tr><tr><td>float tanf(float x) Returns the tangent of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float tanhf(float x) Returns the hyperbolic tangent of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float tgammaf(float x) Returns the gamma function of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float truncf(float x) Truncate 𝑥 to the integral part.</td><td>✓</td><td>✓</td></tr><tr><td>float y0f(float x) Returns the value of the Bessel function of the second kind of order 0 for 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>float y1f(float x) Returns the value of the Bessel function of the second kind of order 1 for 𝑥 .</td><td>✓</td><td>✓</td></tr></tbody></table>
-<p>continues on next page</p>
-<pre><code>                                                                                                                                                                                                        \
-    float  ynf(int  n,  float  x)
-    Returns the value of the Bessel
-    function of the second kind of order
-    n for x.</code></pre>
-<h2>21.2 Double precision mathematical functions</h2>
-<p>Following is the list of supported double precision mathematical functions.</p>
-<table><caption><div class="caption">Table 2: Double precision mathematical functions</div></caption><tbody><tr><th>Function</th><th>Supported on Host</th><th>Supported on Device</th></tr><tr><td>double abs(double x) Returns the absolute value of 𝑥</td><td>✓</td><td>✓</td></tr><tr><td>double acos(double x) Returns the arc cosine of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>double acosh(double x) Returns the nonnegative arc hyperbolic cosine of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>double asin(double x) Returns the arc sine of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>double asinh(double x) Returns the arc hyperbolic sine of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>double atan(double x) Returns the arc tangent of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>double atan2(double x, double y) Returns the arc tangent of the ratio of 𝑥 and 𝑦 .</td><td>✓</td><td>✓</td></tr></tbody></table>
-<p>continues on next page</p>
-<table><caption><div class="caption">Table 2 - continued from previous page</div></caption><tbody><tr><td>double atanh(double x) Returns the arc hyperbolic tangent of 𝑥 .</td><th>✓</th><th>✓</th></tr><tr><th>double cbrt(double x) Returns the cube root of 𝑥 .</th><td>✓</td><td>✓</td></tr><tr><th>double ceil(double x) Returns ceiling of 𝑥 .</th><td>✓</td><td>✓</td></tr><tr><th>double copysign(double x, double y) Create value with given magnitude, copying sign of second value.</th><td>✓</td><td>✓</td></tr><tr><th>double cos(double x) Returns the cosine of 𝑥 .</th><td>✓</td><td>✓</td></tr><tr><th>double cosh(double x) Returns the hyperbolic cosine of 𝑥 .</th><td>✓</td><td>✓</td></tr><tr><th>double cospi(double x) Returns the cosine of 𝜋 · 𝑥 .</th><td>✓</td><td>✓</td></tr><tr><th>double cyl_bessel_i0(double x) Returns the value of the regular modified cylindrical Bessel function of order 0 for 𝑥 .</th><td></td><td></td></tr><tr><th>double cyl_bessel_i1(double x) Returns the value of the regular modified cylindrical Bessel function of order 1 for</th><td>𝑥 .</td><td></td></tr><tr><th>double erf(double x) Returns the error function of 𝑥 .</th><td>✓</td><td>✓</td></tr></tbody></table>
-<p>continues on next page</p>
-<table><caption><div class="caption">Table 2 - continued from previous page</div></caption><tbody><tr><td>double erfc(double x) Returns the complementary error function of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><th>double erfcinv(double x) Returns the inverse complementary function of 𝑥 .</th><td>✓</td><td>✓</td></tr><tr><th>double erfcx(double x) Returns the scaled complementary error function of 𝑥 .</th><td>✓</td><td>✓</td></tr><tr><th>double erfinv(double x) Returns the inverse error function of 𝑥 .</th><td>✓</td><td>✓</td></tr><tr><th>double exp(double x) Returns 𝑒 𝑥 .</th><td>✓</td><td>✓</td></tr><tr><th>double exp10(double x) Returns 10 𝑥 .</th><td>✓</td><td>✓</td></tr><tr><th>double exp2( double x) Returns 2 𝑥 .</th><td>✓</td><td>✓</td></tr><tr><th>double expm1(double x) Returns 𝑙𝑛 ( 𝑥 - 1)</th><td>✓</td><td>✓</td></tr><tr><th>double fabs(double x) Returns the absolute value of x</th><td>✓</td><td>✓</td></tr><tr><th>double fdim(double x, double y) Returns the positive difference between 𝑥 and 𝑦 .</th><td>✓</td><td>✓</td></tr></tbody></table>
-<p>continues on next page</p>
-<table><caption><div class="caption">Table 2 - continued from previous page</div></caption><tbody><tr><td>double floor(double x) Returns the largest integer less than or equal to 𝑥 .</td><th>✓</th><th>✓</th></tr><tr><th>double fma(double x, double y, double z) Returns 𝑥 · 𝑦 + 𝑧 as a single operation.</th><td>✓</td><td>✓</td></tr><tr><th>double fmax(double x, double y) Determine the maximum numeric value of 𝑥 and 𝑦 .</th><td>✓</td><td>✓</td></tr><tr><th>double fmin(double x, double y) Determine the minimum numeric value of 𝑥 and 𝑦 .</th><td>✓</td><td>✓</td></tr><tr><th>double fmod(double x, double y) Returns the floating-point remainder of 𝑥/𝑦 .</th><td>✓</td><td>✓</td></tr><tr><th>double modf(double x, double* iptr) Break down 𝑥 into fractional and integral parts.</th><td>✓</td><td></td></tr><tr><th>double frexp(double x, int* nptr) Extract mantissa and exponent of 𝑥 .</th><td>✓</td><td></td></tr><tr><th>double hypot(double x, double y) Returns the square root of the sum of squares of 𝑥 and 𝑦 .</th><td>✓</td><td>✓</td></tr><tr><th>int ilogb(double x) Returns the unbiased integer exponent of 𝑥 .</th><td>✓</td><td>✓</td></tr></tbody></table>
-<p>continues on next page</p>
-<table><caption><div class="caption">Table 2 - continued from previous page</div></caption><tbody><tr><th>bool isfinite(double x) Determine whether 𝑥 is finite.</th><td>✓</td><td>✓</td></tr><tr><th>bool isin(double x) Determine whether 𝑥 is infinite.</th><td>✓</td><td>✓</td></tr><tr><th>bool isnan(double x) Determine whether 𝑥 is a NAN .</th><td>✓</td><td>✓</td></tr><tr><th>double j0(double x) Returns the value of the Bessel function of the first kind of order 0 for 𝑥 .</th><td>✓</td><td>✓</td></tr><tr><th>double j1(double x) Returns the value of the Bessel function of the first kind of order 1 for 𝑥 .</th><td>✓</td><td>✓</td></tr><tr><th>double jn(int n, double x) Returns the value of the Bessel function of the first kind of order n for 𝑥 .</th><td>✓</td><td>✓</td></tr><tr><th>double ldexp(double x, int exp) Returns the natural logarithm of the absolute value of the gamma function of 𝑥 .</th><td>✓</td><td>✓</td></tr><tr><th>double lgamma(double x) Returns the natural logarithm of the absolute value of the gamma function of 𝑥 .</th><td>✓</td><td></td></tr><tr><th>long int lrint(double x) Round 𝑥 to nearest integer value.</th><td>✓</td><td>✓</td></tr></tbody></table>
-<p>continues on next page</p>
-<table><caption><div class="caption">Table 2 - continued from previous page</div></caption><tbody><tr><td>long long int llrint(double x) Round 𝑥 to nearest integer value.</td><td>✓</td><td>✓</td></tr><tr><td>long int lround(double x) Round to nearest integer value.</td><td>✓</td><td>✓</td></tr><tr><td>long long int llround(double x) Round to nearest integer value.</td><td>✓</td><td>✓</td></tr><tr><td>double log10(double x) Returns the base 10 logarithm of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>double log1p(double x) Returns the natural logarithm of 𝑥 +1 .</td><td>✓</td><td>✓</td></tr><tr><td>double log2(double x) Returns the base 2 logarithm of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>double log(double x) Returns the natural logarithm of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>double logb(double x) Returns the floating point representation of the exponent of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>double nan(const char* tagp) Returns &#x27;Not a Number&#x27; value.</td><td></td><td>✓</td></tr><tr><td>double nearbyint(double x) Round 𝑥 to the nearest integer.</td><td>✓</td><td>✓</td></tr></tbody></table>
-<p>continues on next page</p>
-<table><caption><div class="caption">Table 2 - continued from previous page</div></caption><tbody><tr><td></td><td></td><th>✓</th></tr><tr><td>double nextafter(double x, double y) Returns next representable double-precision floating-point value after argument.</td><td>✓</td><td></td></tr><tr><th>double norm3d(double x, double y, double z) Returns the square root of the sum of squares of 𝑥 , 𝑦 and 𝑧 .</th><td>✓</td><td>✓</td></tr><tr><th>double norm4d(double x, double y, double z, double w) Returns the square root of the sum of squares of 𝑥 , 𝑦 , 𝑧 and 𝑤 .</th><td>✓</td><td>✓</td></tr><tr><th>double normcdf(double y) Returns the standard normal cumulative distribution function.</th><td>✓</td><td>✓</td></tr><tr><th>double normcdfinv(double y) Returns the inverse of the standard normal cumulative distribution function.</th><td>✓</td><td>✓</td></tr><tr><th>double norm(int dim, const double *a) Returns the square root of the sum of squares of any number of coordinates.</th><td>✓</td><td>✓</td></tr><tr><th>double pow(double x, double y) Returns 𝑥 𝑦 .</th><td>✓</td><td>✓</td></tr><tr><th>double powi(double base, int iexp) Returns the value of first argument to the power of second argument.</th><td>✓</td><td>✓</td></tr></tbody></table>
-<p>continues on next page</p>
-<table><tbody><tr><td></td><th>Table</th><th>2 - continued from previous page</th></tr><tr><td>double remainder(double x, double y) Returns double-precision floating-point remainder.</td><td>✓</td><td>✓</td></tr><tr><td>double remquo(double x, double y, int* quo) Returns double-precision floating-point remainder and part quotient.</td><td>✓</td><td>of</td></tr><tr><td>double round(double x) Round to nearest integer value in floating-point.</td><td>✓</td><td>✓</td></tr><tr><td>double rcbrt(double x) Returns the reciprocal cube root function.</td><td>✓</td><td>✓</td></tr><tr><td>double rhypot(double x, double y) Returns one over the square root of the sum of squares of two arguments.</td><td>✓</td><td>✓</td></tr><tr><td>double rint(double x) Round input to nearest integer value in floating-point.</td><td>✓</td><td>✓</td></tr><tr><td>double rnorm3d(double x, double y, double z) Returns one over the square root of the sum of squares of three coordinates of the argument.</td><td>✓</td><td>✓</td></tr><tr><td>double rnorm4d(double x, double y, double z, double w) Returns one over the square root of the sum of squares of four coordinates of the argument.</td><td>✓</td><td>✓</td></tr></tbody></table>
-<p>continues on next page</p>
-<table><caption><div class="caption">Table 2 - continued from previous page</div></caption><tbody><tr><td></td><td>✓</td><td></td></tr><tr><td>double rnorm(int dim, const double *a) Returns the reciprocal of square root of the sum of squares of any number of coordinates.</td><td></td><td>✓</td></tr><tr><td>double scalbln(double x, long int n) Scale 𝑥 by 2 𝑛 .</td><td>✓</td><td>✓</td></tr><tr><td>double scalbn(double x, int n) Scale 𝑥 by 2 𝑛 .</td><td>✓</td><td>✓</td></tr><tr><td>bool signbit(double x) Return the sign bit of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>double sin(double x) Returns the sine of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>double sinh(double x) Returns the hyperbolic sine of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>double sinpi(double x) Returns the hyperbolic sine of 𝜋 · 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>void sincos(double x, double *sptr, double *cptr) Returns the sine and cosine of 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>void sincospi(double x, double *sptr, double *cptr) Returns the sine and cosine of 𝜋 · 𝑥 .</td><td>✓</td><td>✓</td></tr><tr><td>double sqrt(double x) Returns the square root of 𝑥 .</td><td>✓</td><td>✓</td></tr></tbody></table>
-<p>continues on next page</p>
-<table><caption><div class="caption">Table 2 - continued from previous page</div></caption><tbody><tr><td>double rsqrt(double x) Returns the reciprocal of the square root of 𝑥 .</td><th>✓</th></tr><tr><td>double tan(double x) Returns the tangent of 𝑥 .</td><td>✓</td></tr><tr><td>double tanh(double x) Returns the hyperbolic tangent of 𝑥 .</td><td>✓</td></tr><tr><td>double tgamma(double x) Returns the gamma function of 𝑥 .</td><td>✓</td></tr><tr><td>double trunc(double x) Truncate 𝑥 to the integral part.</td><td>✓</td></tr><tr><td>double y0(double x) Returns the value of the Bessel function of the second kind of order 0 for 𝑥 .</td><td>✓</td></tr><tr><td>double y1(double x) Returns the value of the Bessel function of the second kind of order 1 for 𝑥 .</td><td>✓</td></tr><tr><td>double yn(int n, double x) Returns the value of the Bessel function of the second kind of order n for 𝑥 .</td><td>✓</td></tr></tbody></table>
-<h2>21.3 Integer intrinsics</h2>
-<p>Following is the list of supported integer intrinsics. Note that intrinsics are supported on device only.</p>
-<p>Table 3: Integer intrinsics mathematical functions</p>
-<h2>Function</h2>
-<p>unsigned int __brev(unsigned int x) Reverse the bit order of a 32 bit unsigned integer.</p>
-<p>unsigned long long int __brevll(unsigned long long int x) Reverse the bit order of a 64 bit unsigned integer.</p>
-<p>unsigned int __byte_perm(unsigned int x, unsigned int y, unsigned int z) Return selected bytes from two 32-bit unsigned integers.</p>
-<p>unsigned int __clz(int x) Return the number of consecutive high-order zero bits in 32 bit integer.</p>
-<p>unsigned int __clzll(long long int x) Return the number of consecutive high-order zero bits in 64 bit integer.</p>
-<p>unsigned int __ffs(int x) Find the position of least significant bit set to 1 in a 32 bit integer.</p>
-<p>unsigned int __ffsll(long long int x) Find the position of least significant bit set to 1 in a 64 bit signed integer.</p>
-<p>unsigned int __fns32(unsigned long long mask, unsigned int base, int offset) Find the position of the n-th set to 1 bit in a 32-bit integer.</p>
-<p>unsigned int __fns64(unsigned long long int mask, unsigned int base, int offset) Find the position of the n-th set to 1 bit in a 64-bit integer.</p>
-<p>unsigned int __funnelshift_l(unsigned int lo, unsigned int hi, unsigned int shift) Concatenate ℎ𝑖 and 𝑙𝑜 , shift left by shift &amp; 31 bits, return the most significant 32 bits.</p>
-<p>unsigned int __funnelshift_lc(unsigned int lo, unsigned int hi, unsigned int shift) Concatenate ℎ𝑖 and 𝑙𝑜 , shift left by min(shift, 32) bits, return the most significant 32 bits.</p>
-<p>unsigned int __funnelshift_r(unsigned int lo, unsigned int hi, unsigned int shift) Concatenate ℎ𝑖 and 𝑙𝑜 , shift right by shift &amp; 31 bits, return the least significant 32 bits. 226 Chapter 21. HIP math API</p>
-<p>The HIP-Clang implementation of __ffs() and __ffsll() contains code to add a constant +1 to produce the ffs result format. For the cases where this overhead is not acceptable and programmer is willing to specialize for the platform, HIP-Clang provides __lastbit_u32_u32(unsigned int input) and __lastbit_u32_u64(unsigned long long int input) . The index returned by __lastbit_ instructions starts at -1, while for ffs the index starts at 0.</p>
-<h2>21.4 Floating-point Intrinsics</h2>
-<p>Following is the list of supported floating-point intrinsics. Note that intrinsics are supported on device only.</p>
-<p>Note: Only the nearest even rounding mode supported on AMD GPUs by defaults. The _rz , _ru and _rd suffixed intrinsic functions are existing in HIP AMD backend, if the OCML_BASIC_ROUNDED_OPERATIONS macro is defined.</p>
-<p>Table 4: Single precision intrinsics mathematical functions</p>
-<p>Function float __cosf(float x) Returns the fast approximate cosine of 𝑥 . float __exp10f(float x) Returns the fast approximate for 10 x . float __expf(float x) Returns the fast approximate for e x . float __fadd_rn(float x, float y) Add two floating-point values in round-to-nearest-even mode. float __fdiv_rn(float x, float y) Divide two floating point values in round-to-nearest-even mode. float __fmaf_rn(float x, float y, float z) Returns x × y + z as a single operation in round-to-nearest-even mode. float __fmul_rn(float x, float y) Multiply two floating-point values in round-to-nearest-even mode. float __frcp_rn(float x, float y) Returns 1 / x in round-to-nearest-even mode. float __frsqrt_rn(float x) Returns 1 / x in round-to-nearest-even mode. float __fsqrt_rn(float x) Returns x in round-to-nearest-even mode. float __fsub_rn(float x, float y) Subtract two floating-point values in round-to-nearest-even mode. float __log10f(float x) Returns the fast approximate for base 10 logarithm of 𝑥 . 228 Chapter 21. HIP math API</p>
-<p>Table 5: Double precision intrinsics mathematical functions</p>
-<p>Function double __dadd_rn(double x, double y) Add two floating-point values in round-to-nearest-even mode. double __ddiv_rn(double x, double y) Divide two floating-point values in round-to-nearest-even mode. double __dmul_rn(double x, double y) Multiply two floating-point values in round-to-nearest-even mode. double __drcp_rn(double x, double y) Returns 1 / x in round-to-nearest-even mode. double __dsqrt_rn(double x) Returns x in round-to-nearest-even mode. double __dsub_rn(double x, double y) Subtract two floating-point values in round-to-nearest-even mode. double __fma_rn(double x, double y, double z) Returns x × y + z as a single operation in round-to-nearest-even mode.</p>
-<h2>CHAPTER</h2>
-<h2>TWENTYTWO</h2>
-<h2>TABLE COMPARING SYNTAX FOR DIFFERENT COMPUTE APIS</h2>
-<table><tbody><tr><th>Term</th><th>CUDA</th><th>HIP</th><th>OpenCL</th></tr><tr><td>Device</td><td>int deviceId</td><td>int deviceId</td><td>cl_device</td></tr><tr><td>Queue</td><td>cudaStream_t</td><td>hipStream_t</td><td>cl_command_queue</td></tr><tr><td>Event</td><td>cudaEvent_t</td><td>hipEvent_t</td><td>cl_event</td></tr><tr><td>Memory</td><td>void *</td><td>void *</td><td>cl_mem</td></tr><tr><td></td><td>grid</td><td>grid</td><td>NDRange</td></tr><tr><td></td><td>block</td><td>block</td><td>work-group</td></tr><tr><td></td><td>thread</td><td>thread</td><td>work-item</td></tr><tr><td></td><td>warp</td><td>warp</td><td>sub-group</td></tr><tr><td>Thread-index</td><td>threadIdx.x</td><td>threadIdx.x</td><td>get_local_id(0)</td></tr><tr><td>Block-index</td><td>blockIdx.x</td><td>blockIdx.x</td><td>get_group_id(0)</td></tr><tr><td>Block-dim</td><td>blockDim.x</td><td>blockDim.x</td><td>get_local_size(0)</td></tr><tr><td>Grid-dim</td><td>gridDim.x</td><td>gridDim.x</td><td>get_num_groups(0)</td></tr><tr><td>Device Kernel</td><td>__global__</td><td>__global__</td><td>__kernel</td></tr><tr><td>Device Function</td><td>__device__</td><td>__device__</td><td>Implied in device com</td></tr><tr><td>Host Function</td><td>__host_ (default)</td><td>__host_ (default)</td><td>Implied in host compil</td></tr><tr><td>Host + Device Function</td><td>__host__ __device__</td><td>__host__ __device__</td><td>No equivalent</td></tr><tr><td>Kernel Launch</td><td>&lt;&lt;&lt; &gt;&gt;&gt;</td><td>hipLaunchKernel / hipLaunchKernelGGL / &lt;&lt;&lt;</td><td>clEnqueueNDRangeK</td></tr><tr><td>Global Memory</td><td>__global__</td><td>__global__</td><td>__global</td></tr><tr><td>Group Memory</td><td>__shared__</td><td>__shared__</td><td>__local</td></tr><tr><td>Constant</td><td>__constant__</td><td>__constant__</td><td>__constant</td></tr><tr><td></td><td>__syncthreads</td><td>__syncthreads</td><td>barrier(CLK_LOCAL</td></tr><tr><td>Atomic Builtins</td><td>atomicAdd</td><td>atomicAdd</td><td>atomic_add</td></tr><tr><td>Precise Math</td><td>cos(f)</td><td>cos(f)</td><td>cos(f)</td></tr><tr><td>Fast Math</td><td>__cos(f)</td><td>__cos(f)</td><td>native_cos(f)</td></tr><tr><td>Vector</td><td>float4</td><td>float4</td><td>float4</td></tr></tbody></table>
-<h2>22.1 Notes</h2>
-<p>The indexing functions (starting with thread-index ) show the terminology for a 1D grid. Some APIs use reverse order of xyz / 012 indexing for 3D grids.</p>
-<h2>CHAPTER</h2>
-<h2>TWENTYTHREE</h2>
-<h2>HIP COOPERATIVE GROUPS API</h2>
-<h2>23.1 Cooperative kernel launches</h2>
-<p>The following host-side functions are used for cooperative kernel launches.</p>
-<table><tbody><tr><th colspan="2">Warning:</th><th colspan="3">doxygenfunction:</th><th>Cannot</th><th colspan="2">find function</th><th colspan="2">&#x27;hipLaunchCooperativeKernel&#x27; Documentation&#x27;</th><td></td></tr><tr><td>in</td><td>doxygen</td><td>xml</td><td>output</td><td>for project</td><td>&#x27;HIP</td><td>6.1.40092</td><td>from</td><td>directory:</td><td></td></tr><tr><td colspan="11">/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-</td></tr><tr><td colspan="11">6.1.2/docs/doxygen/xml</td></tr></tbody></table>
-<table><tbody><tr><th colspan="2">Warning:</th><th colspan="3">doxygenfunction: project</th><th colspan="2">Cannot</th><th colspan="2">find function</th><th colspan="3">&#x27;hipLaunchCooperativeKernel&#x27;</th></tr><tr><td>in</td><td>doxygen</td><td>xml</td><td>output</td><td>for</td><td></td><td>&#x27;HIP</td><td colspan="2">6.1.40092</td><td>Documentation&#x27;</td><td>from</td></tr><tr><td colspan="12">/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-</td></tr><tr><td colspan="12">6.1.2/docs/doxygen/xml</td></tr></tbody></table>
-<table><tbody><tr><th colspan="2">Warning:</th><th colspan="3">doxygenfunction:</th><th>Cannot</th><th>find</th><th>function</th><th colspan="3">&#x27;hipLaunchCooperativeKernelMultiDe-</th></tr><tr><td>vice&#x27;</td><td>in</td><td>doxygen</td><td>xml</td><td>output for</td><td>project</td><td>&#x27;HIP</td><td>6.1.40092</td><td>Documentation&#x27;</td><td>from</td><td>directory:</td></tr><tr><td colspan="11">/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-</td></tr><tr><td colspan="11">6.1.2/docs/doxygen/xml</td></tr></tbody></table>
-<table><tbody><tr><th colspan="2">Warning: in</th><th colspan="2">doxygenfunction: Cannot find xml output for project &#x27;HIP</th><td></td></tr><tr><td>nel&#x27;</td><td>function 6.1.40092</td><td>&#x27;hipModuleLaunchCooperativeKer- Documentation&#x27; from directory:</td><td></td></tr><tr><td colspan="4">/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-</td></tr><tr><td colspan="4">6.1.2/docs/doxygen/xml</td></tr></tbody></table>
-<p>Warning: doxygenfunction: Cannot find function 'hipModuleLaunchCooperativeKernelMultiDevice' in doxygen xml output for project 'HIP 6.1.40092 Documentation' from directory: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs6.1.2/docs/doxygen/xml</p>
-<h2>23.2 Cooperative groups classes</h2>
-<p>The following cooperative groups classes can be used on the device side.</p>
-<h2>class thread_group</h2>
-<p>The base type of all cooperative group types.</p>
-<p>Holds the key properties of a constructed cooperative group types object, like the group type, its size, etc.</p>
-<p>Note: Cooperative groups feature is implemented on Linux, under development on Microsoft Windows.</p>
-<p>Subclassed by cooperative_groups::coalesced_group , cooperative_groups::grid_group , coopera-tive_groups::multi_grid_group , cooperative_groups::thread_block , cooperative_groups::tiled_group class thread_block : public cooperative_groups:: thread_group</p>
-<p>The workgroup (thread-block in CUDA terminology) cooperative group type.</p>
-<p>Represents an intra-workgroup cooperative group type, where the participating threads within the group are the same threads that participated in the currently executing workgroup .</p>
-<p>Note: This function is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>class grid_group : public cooperative_groups:: thread_group</p>
-<p>The grid cooperative group type.</p>
-<p>Represents an inter-workgroup cooperative group type, where the participating threads within the group spans across multiple workgroups running the (same) kernel on the same device.</p>
-<p>Note: This is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>class multi_grid_group : public cooperative_groups:: thread_group</p>
-<p>The multi-grid cooperative group type.</p>
-<p>Represents an inter-device cooperative group type, where the participating threads within the group span across multiple devices, running the (same) kernel on these devices.</p>
-<p>Note: The multi-grid cooperative group type is implemented on Linux, under development on Microsoft Windows.</p>
-<h2>template&lt;unsigned int size , class ParentCGTy &gt;</h2>
-<p>class thread_block_tile : public cooperative_groups::impl::thread_block_tile_internal&lt; size , ParentCGTy &gt; Group type -thread_block_tile .</p>
-<p>Represents one tiled thread group in a wavefront. This group type also supports sub-wave level intrinsics.</p>
-<p>Note: This type is implemented on Linux, under development on Microsoft Windows.</p>
-<h2>Public Functions</h2>
-<p>unsigned int thread_rank () const</p>
-<p>Rank of the calling thread within [0, size() ).</p>
-<h2>void sync ()</h2>
-<p>Synchronizes the threads in the group.</p>
-<p>Causes all threads in the group to wait at this synchronization point, and for all shared and global memory accesses by the threads to complete, before running synchronization. This guarantees the visibility of accessed data for all threads in the group.</p>
-<p>Note: There are potential read-after-write (RAW), write-after-read (WAR), or write-after-write (WAW) hazards, when threads in the group access the same addresses in shared or global memory. The data hazards can be avoided with synchronization of the group.</p>
-<h2>unsigned int meta_group_rank () const</h2>
-<p>Returns the linear rank of the group within the set of tiles partitioned from a parent group (bounded by meta_group_size)</p>
-<p>unsigned int meta_group_size () const</p>
-<p>Returns the number of groups created when the parent group was partitioned.</p>
-<h2>template&lt;class T &gt;</h2>
-<p>T shfl ( T var, int srcRank ) const</p>
-<p>Shuffle operation on group level.</p>
-<p>Exchanging variables between threads without use of shared memory. Shuffle operation is a direct copy of var from srcRank thread ID of group.</p>
-<h2>Template Parameters</h2>
-<p>T - The type can be a 32-bit integer or single-precision floating point.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">var - [in] The source variable to copy. Only the srcRank thread ID of group is copied to other threads.</li>
-<li style="list-style-type: '· ';">srcRank - [in] The source thread ID of the group for copy.</li>
-</ul>
-<h2>template&lt;class T &gt;</h2>
-<p>T shfl_down ( T var, unsigned int lane_delta ) const</p>
-<p>Shuffle down operation on group level.</p>
-<p>Exchanging variables between threads without use of shared memory. Shuffle down operation is copy of var from thread with thread ID of group relative higher with lane_delta to caller thread ID.</p>
-<h2>Template Parameters</h2>
-<p>T - The type can be a 32-bit integer or single-precision floating point.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">var - [in] The source variable to copy.</li>
-<li style="list-style-type: '· ';">lane_delta - [in] The lane_delta is the relative thread ID difference between caller thread ID and source of copy thread ID. sourceID = (threadID + lane_delta) % size()</li>
-</ul>
-<p>template&lt;class T &gt;</p>
-<h2>T shfl_up ( T var, unsigned int lane_delta ) const</h2>
-<p>Shuffle up operation on group level.</p>
-<p>Exchanging variables between threads without use of shared memory. Shuffle up operation is copy of var from thread with thread ID of group relative lower with lane_delta to caller thread ID.</p>
-<h2>Template Parameters</h2>
-<p>T - The type can be a 32-bit integer or single-precision floating point.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">var - [in] The source variable to copy.</li>
-<li style="list-style-type: '· ';">lane_delta - [in] The lane_delta is the relative thread ID difference between caller thread ID and source of copy thread ID. sourceID = (threadID - lane_delta) % size()</li>
-</ul>
-<h2>template&lt;class T &gt;</h2>
-<p>T shfl_xor ( T var, unsigned int laneMask ) const</p>
-<p>Shuffle xor operation on group level.</p>
-<p>Exchanging variables between threads without use of shared memory. Shuffle xor operation is copy of var from thread with thread ID of group based on laneMask XOR of the caller thread ID.</p>
-<h2>Template Parameters</h2>
-<ul>
-<li>T - The type can be a 32-bit integer or single-precision floating point.</li>
-</ul>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">var - [in] The source variable to copy.</li>
-<li style="list-style-type: '· ';">laneMask - [in] The laneMask is the mask for XOR operation. sourceID = threadID ^ laneMask</li>
-</ul>
-<p>unsigned long long ballot ( int pred ) const</p>
-<p>Ballot function on group level.</p>
-<p>Returns a bit mask with the Nth bit set to one if the Nth thread predicate evaluates true.</p>
-<h2>Parameters</h2>
-<p>pred - [in] The predicate to evaluate on group threads.</p>
-<p>int any ( int pred ) const</p>
-<p>Any function on group level.</p>
-<p>Returns non-zero if a predicate evaluates true for any threads.</p>
-<h2>Parameters</h2>
-<p>pred - [in] The predicate to evaluate on group threads.</p>
-<p>int all ( int pred ) const</p>
-<p>All function on group level.</p>
-<p>Returns non-zero if a predicate evaluates true for all threads.</p>
-<h2>Parameters</h2>
-<p>pred - [in] The predicate to evaluate on group threads.</p>
-<p>template&lt;typename T &gt;</p>
-<p>unsigned long long match_any ( T value ) const</p>
-<p>Match any function on group level.</p>
-<p>Returns a bit mask containing a 1-bit for every participating thread if that thread has the same value in value as the caller thread.</p>
-<h2>Parameters</h2>
-<p>value - [in] The value to examine on the current thread in group.</p>
-<p>template&lt;typename T &gt; unsigned long long match_all ( T value, int &amp;pred ) const</p>
-<p>Match all function on group level.</p>
-<p>Returns a bit mask containing a 1-bit for every participating thread if they all have the same value in value as the caller thread. The predicate pred is set to true if all participating threads have the same value in value .</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">value - [in] The value to examine on the current thread in group.</li>
-<li style="list-style-type: '· ';">pred - [out] The predicate is set to true if all participating threads in the thread group have the same value.</li>
-</ul>
-<p>class coalesced_group : public cooperative_groups:: thread_group</p>
-<p>The coalesced_group cooperative group type.</p>
-<p>Represents an active thread group in a wavefront. This group type also supports sub-wave level intrinsics.</p>
-<p>Note: This is implemented on Linux and is under development on Microsoft Windows.</p>
-<h2>23.3 Cooperative groups construct functions</h2>
-<p>The following functions are used to construct different group-type instances on the device side.</p>
-<table><tbody><tr><td colspan="2">Warning:</td><td colspan="3">doxygenfunction:</td><td colspan="2">Cannot find</td><td colspan="2">function</td><td colspan="3">&#x27;cooperative_groups::this_multi_grid&#x27;</td><td></td></tr><tr><td>in</td><td>doxygen</td><td>xml</td><td>output</td><td>for</td><td>project</td><td>&#x27;HIP</td><td>6.1.40092</td><td>Documentation&#x27;</td><td>from</td><td>directory:</td><td></td></tr><tr><td colspan="12">/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-</td></tr><tr><td colspan="12">6.1.2/docs/doxygen/xml</td></tr></tbody></table>
-<p>Warning: doxygenfunction: Cannot find function 'cooperative_groups::this_grid' in doxygen xml output for project 'HIP 6.1.40092 Documentation' from directory: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs6.1.2/docs/doxygen/xml</p>
-<p>Warning: doxygenfunction: Cannot find function 'cooperative_groups::this_thread_block' in doxygen xml output for project 'HIP 6.1.40092 Documentation' from directory: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs6.1.2/docs/doxygen/xml</p>
-<table><tbody><tr><th colspan="2">Warning:</th><th colspan="3">doxygenfunction:</th><th>Cannot</th><th>find</th><th>function</th><th colspan="2">&#x27;cooperative_groups::coalesced_threads&#x27;</th><td></td></tr><tr><td>in</td><td>doxygen</td><td>xml</td><td>output</td><td>for</td><td>project</td><td>&#x27;HIP</td><td>6.1.40092</td><td>Documentation&#x27;</td><td>from</td><td>directory:</td></tr></tbody></table>
-<p>/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs6.1.2/docs/doxygen/xml</p>
-<table><tbody><tr><th colspan="2">Warning:</th><th colspan="3">doxygenfunction:</th><th colspan="2">Cannot find</th><th colspan="2">function</th><th colspan="3">&#x27;cooperative_groups::tiled_partition&#x27;</th><td></td></tr><tr><td>in</td><td>doxygen</td><td>xml</td><td>output</td><td>for</td><td>project</td><td>&#x27;HIP</td><td>6.1.40092</td><td>Documentation&#x27;</td><td>from</td><td>directory:</td><td></td></tr><tr><td colspan="12">/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-</td></tr><tr><td colspan="12">6.1.2/docs/doxygen/xml</td></tr></tbody></table>
-<table><tbody><tr><td colspan="2">Warning:</td><th colspan="3">doxygenfunction:</th><th colspan="2">Cannot</th><th colspan="2">find</th><th colspan="3">function &#x27;cooperative_groups::tiled_partition&#x27; 6.1.40092</th><td></td><td></td></tr><tr><td>in</td><td>doxygen</td><td>xml</td><td>output</td><td>for</td><td>project</td><td>&#x27;HIP</td><td>Documentation&#x27;</td><td>from</td><td>directory:</td><td></td><td></td></tr><tr><td colspan="12">/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-</td></tr><tr><td colspan="12">6.1.2/docs/doxygen/xml</td></tr></tbody></table>
-<table><tbody><tr><th colspan="2">Warning:</th><th colspan="3">doxygenfunction:</th><th colspan="2">Cannot find</th><th colspan="2">function</th><th colspan="3">&#x27;cooperative_groups::binary_partition&#x27;</th></tr><tr><td>in</td><td>doxygen</td><td>xml</td><td>output</td><td>for</td><td>project</td><td>&#x27;HIP</td><td></td><td>6.1.40092</td><td>Documentation&#x27;</td><td>from</td></tr><tr><td colspan="12">/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-</td></tr><tr><td colspan="12">6.1.2/docs/doxygen/xml</td></tr></tbody></table>
-<table><tbody><tr><td colspan="2">Warning:</td><th colspan="3">doxygenfunction:</th><th colspan="2">Cannot find</th><th colspan="3">function &#x27;cooperative_groups::binary_partition&#x27; 6.1.40092</th></tr><tr><td>in</td><td>doxygen</td><td>xml</td><td>output</td><td>for</td><td>project</td><td>&#x27;HIP</td><td>Documentation&#x27;</td><td>from</td><td>directory:</td></tr><tr><td colspan="11">/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-</td></tr><tr><td colspan="11">6.1.2/docs/doxygen/xml</td></tr></tbody></table>
-<h2>23.4 Cooperative groups exposed API functions</h2>
-<p>The following functions are the exposed API for different group-type instances on the device side.</p>
-<table><tbody><tr><th colspan="2">Warning:</th><th colspan="4">doxygenfunction: project</th><th colspan="2">Cannot find</th><th colspan="2">function</th><th colspan="3">&#x27;cooperative_groups::group_size&#x27;</th><td></td><td></td><td></td></tr><tr><td>in</td><td>doxygen</td><td>xml</td><td>output</td><td>for</td><td>&#x27;HIP</td><td>6.1.40092</td><td>Documentation&#x27;</td><td>from</td><td>directory:</td><td></td><td></td><td></td></tr><tr><td colspan="13">/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-</td></tr><tr><td colspan="13">6.1.2/docs/doxygen/xml</td></tr></tbody></table>
-<table><tbody><tr><th colspan="2">Warning:</th><th colspan="5">doxygenfunction: Cannot</th><th colspan="3">find &#x27;HIP</th><th colspan="3">function &#x27;cooperative_groups::thread_rank&#x27;</th><td></td></tr><tr><td>in</td><td>doxygen</td><td>xml</td><td>output</td><td>for</td><td>project</td><td></td><td>6.1.40092</td><td>Documentation&#x27;</td><td>from</td><td>directory:</td><td></td></tr><tr><td colspan="13">/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-</td></tr><tr><td colspan="13">6.1.2/docs/doxygen/xml</td></tr></tbody></table>
-<p>Warning: doxygenfunction: Cannot find function 'cooperative_groups::is_valid' in doxygen xml output for project 'HIP 6.1.40092 Documentation' from directory: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs6.1.2/docs/doxygen/xml</p>
-<p>Warning: doxygenfunction: Cannot find function 'cooperative_groups::sync' in doxygen xml output for project 'HIP 6.1.40092 Documentation' from directory: /home/docs/checkouts/readthedocs.org/user_builds/advancedmicro-devices-hip/checkouts/docs-6.1.2/docs/doxygen/xml</p>
-<h2>CHAPTER</h2>
-<h2>TWENTYFOUR</h2>
-<h2>HSA RUNTIME API FOR ROCM</h2>
-<p>The following functions are located in the https://github.com/ROCm/ROCR-Runtime repository.</p>
-<p>hsa_status_t hsa_amd_vmem_address_reserve ( void **va, size_t size, uint64_t address, uint64_t flags )</p>
-<p>Allocate a reserved address range.</p>
-<p>Reserve a virtual address range. The size must be a multiple of the system page size. If it is not possible to allocate the address specified by address , then va will be a different address range. Address range should be released by calling hsa_amd_vmem_address_free.</p>
-<p>Note that this API will be deprecated in a future release and replaced by hsa_amd_vmem_address_reserve_align</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">va -[out] virtual address allocated</li>
-<li style="list-style-type: '· ';">size -[in] of address range requested</li>
-<li style="list-style-type: '· ';">address -[in] requested</li>
-<li style="list-style-type: '· ';">flags -[in] currently unsupported</li>
-</ul>
-<h2>Return values</h2>
-<ul>
-<li style="list-style-type: '· ';">::HSA_STATUS_SUCCESS - Address range allocated successfully</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_NOT_INITIALIZED - The HSA runtime has not been initialized.</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_OUT_OF_RESOURCES - Insufficient resources to allocate an address range of this size.</li>
-</ul>
-<p>hsa_status_t hsa_amd_vmem_address_free ( void *va, size_t size )</p>
-<p>Free a reserved address range.</p>
-<p>Free a previously allocated address range. The size must match the size of a previously allocated address range.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">va -[out] virtual address to be freed</li>
-<li style="list-style-type: '· ';">size -[in] of address range</li>
-</ul>
-<h2>Return values</h2>
-<ul>
-<li style="list-style-type: '· ';">::HSA_STATUS_SUCCESS - Address range released successfully</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_INVALID_ALLOCATION - Invalid va specified</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_INVALID_ARGUMENT - Invalid size specified</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_RESOURCE_FREE - Address range is still in use</li>
-</ul>
-<p>· ::HSA_STATUS_ERROR - Internal unexpected error</p>
-<p>hsa_status_t hsa_amd_vmem_handle_create ( hsa_amd_memory_pool_t pool, size_t size, hsa_amd_memory_type_t type, uint64_t flags, hsa_amd_vmem_alloc_handle_t *memory_handle</p>
-<p>)</p>
-<p>Create a virtual memory handle.</p>
-<p>Create a virtual memory handle within this pool size must be a aligned to allocation granule size for this memory pool, see HSA_AMD_MEMORY_POOL_INFO_RUNTIME_ALLOC_GRANULE To minimize internal memory fragmentation, align the size to the recommended allocation granule size, see HSA_AMD_MEMORY_POOL_INFO_RUNTIME_ALLOC_REC_GRANULE</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">pool -[in] memory to use</li>
-<li style="list-style-type: '· ';">size -[in] of the memory allocation</li>
-<li style="list-style-type: '· ';">type -[in] of memory</li>
-<li style="list-style-type: '· ';">flags -[in] - currently unsupported</li>
-<li style="list-style-type: '· ';">memory_handle -[out] - handle for the allocation</li>
-</ul>
-<h2>Return values</h2>
-<ul>
-<li style="list-style-type: '· ';">::HSA_STATUS_SUCCESS - memory allocated successfully</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_NOT_INITIALIZED - The HSA runtime has not been initialized.</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_INVALID_ARGUMENT - Invalid arguments</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_INVALID_ALLOCATION - This memory pool does not support allocations</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_OUT_OF_RESOURCES - Insufficient resources to allocate this memory</li>
-</ul>
-<p>hsa_status_t hsa_amd_vmem_handle_release ( hsa_amd_vmem_alloc_handle_t memory_handle )</p>
-<p>Release a virtual memory handle.</p>
-<h2>Parameters</h2>
-<p>memory -[in] handle that was previously allocated</p>
-<h2>Return values</h2>
-<ul>
-<li style="list-style-type: '· ';">::HSA_STATUS_SUCCESS - Address range allocated successfully</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_INVALID_ALLOCATION - Invalid memory handle</li>
-</ul>
-<p>hsa_status_t hsa_amd_vmem_map ( void *va, size_t size, size_t in_offset, hsa_amd_vmem_alloc_handle_t memory_handle, uint64_t flags )</p>
-<p>Map a virtual memory handle.</p>
-<p>Map a virtual memory handle to a reserved address range. The virtual address requested must be within a previously reserved address range. va and ( va + size) must be must be within (va + size) of the previous allocated address range. size must be equal to size of the memory_handle hsa_amd_vmem_set_access needs to be called to make the memory accessible to specific agents</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">va -[in] virtual address range where memory will be mapped</li>
-<li style="list-style-type: '· ';">size -[in] of memory mapping</li>
-<li style="list-style-type: '· ';">in_offset -[in] offset into memory. Currently unsupported</li>
-</ul>
-<ul>
-<li style="list-style-type: '· ';">memory_handle -[in] virtual memory handle to be mapped</li>
-<li style="list-style-type: '· ';">flags. -[in] Currently unsupported</li>
-</ul>
-<h2>Return values</h2>
-<ul>
-<li style="list-style-type: '· ';">::HSA_STATUS_SUCCESS - Memory mapped successfully</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_INVALID_ARGUMENT - va, size or memory_handle are invalid</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_OUT_OF_RESOURCES - Insufficient resources</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR - Unexpected internal error</li>
-</ul>
-<h2>hsa_status_t hsa_amd_vmem_unmap ( void *va, size_t size )</h2>
-<p>Unmap a virtual memory handle.</p>
-<p>Unmap previously mapped virtual address range</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">va -[in] virtual address range where memory will be mapped</li>
-<li style="list-style-type: '· ';">size -[in] of memory mapping</li>
-</ul>
-<h2>Return values</h2>
-<ul>
-<li style="list-style-type: '· ';">::HSA_STATUS_SUCCESS - Memory backing unmapped successfully</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_INVALID_ALLOCATION - memory_handle is invalid</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_INVALID_ARGUMENT - size is invalid</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR - Unexpected internal error</li>
-</ul>
-<p>hsa_status_t hsa_amd_vmem_set_access ( void *va, size_t size, const hsa_amd_memory_access_desc_t *desc, size_t desc_cnt )</p>
-<p>Make a memory mapping accessible.</p>
-<p>Make previously mapped virtual address accessible to specific agents. size must be equal to size of previously mapped virtual memory handle. Calling hsa_amd_vmem_set_access multiple times on the same va will overwrite previous permissions for all agents</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">va -[in] previously mapped virtual address</li>
-<li style="list-style-type: '· ';">size -[in] of memory mapping</li>
-<li style="list-style-type: '· ';">desc -[in] list of access permissions for each agent</li>
-<li style="list-style-type: '· ';">desc_cnt -[in] number of elements in desc</li>
-</ul>
-<h2>Return values</h2>
-<ul>
-<li style="list-style-type: '· ';">::HSA_STATUS_SUCCESS -</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_INVALID_ARGUMENT - va, size or memory_handle are invalid</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_INVALID_ALLOCATION - memory_handle is invalid</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_OUT_OF_RESOURCES - Insufficient resources</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_INVALID_AGENT - Invalid agent in desc</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR - Unexpected internal error</li>
-</ul>
-<p>hsa_status_t hsa_amd_vmem_get_access ( void *va, hsa_access_permission_t *perms, hsa_agent_t agent_handle )</p>
-<p>Get current access permissions for memory mapping.</p>
-<p>Get access permissions for memory mapping for specific agent.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">va -[in] previously mapped virtual address</li>
-<li style="list-style-type: '· ';">perms -[in] current permissions</li>
-<li style="list-style-type: '· ';">agent_handle -[in] agent</li>
-</ul>
-<h2>Return values</h2>
-<ul>
-<li style="list-style-type: '· ';">::HSA_STATUS_SUCCESS -</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_INVALID_AGENT - Invalid agent</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_INVALID_ALLOCATION - va is not mapped or permissions never set for this agent</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR - Unexpected internal error</li>
-</ul>
-<p>hsa_status_t hsa_amd_vmem_export_shareable_handle ( int *dmabuf_fd, hsa_amd_vmem_alloc_handle_t handle, uint64_t flags )</p>
-<p>Get an exportable shareable handle.</p>
-<p>Get an exportable shareable handle for a memory_handle. This shareabl handle can then be used to re-create a virtual memory handle using hsa_amd_vmem_import_shareable_handle. The shareable handle can be transferred using mechanisms that support posix file descriptors Once all shareable handles are closed, the memory_handle is released.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dmabuf_fd -[out] shareable handle</li>
-<li style="list-style-type: '· ';">handle -[in] previously allocated virtual memory handle</li>
-<li style="list-style-type: '· ';">flags -[in] Currently unsupported</li>
-</ul>
-<h2>Return values</h2>
-<ul>
-<li style="list-style-type: '· ';">::HSA_STATUS_SUCCESS -</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_INVALID_ALLOCATION - Invalid memory handle</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_OUT_OF_RESOURCES - Out of resources</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR - Unexpected internal error</li>
-</ul>
-<h2>hsa_status_t hsa_amd_vmem_import_shareable_handle ( int dmabuf_fd, hsa_amd_vmem_alloc_handle_t *handle )</h2>
-<p>Import a shareable handle.</p>
-<p>Import a shareable handle for a memory handle. Importing a shareable handle that has been closed and released results in undefined behavior.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dmabuf_fd -[in] shareable handle exported with hsa_amd_vmem_export_shareable_handle</li>
-<li style="list-style-type: '· ';">handle -[out] virtual memory handle</li>
-</ul>
-<h2>Return values</h2>
-<ul>
-<li style="list-style-type: '· ';">::HSA_STATUS_SUCCESS -</li>
-</ul>
-<ul>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_INVALID_ALLOCATION - Invalid memory handle</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_OUT_OF_RESOURCES - Out of resources</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR - Unexpected internal error</li>
-</ul>
-<p>hsa_status_t hsa_amd_vmem_retain_alloc_handle ( hsa_amd_vmem_alloc_handle_t *memory_handle, void *addr )</p>
-<p>Returns memory handle for mapped memory.</p>
-<p>Return a memory handle for previously mapped memory. The handle will be the same value of handle used to map the memory. The returned handle must be released with corresponding number of calls to hsa_amd_vmem_handle_release.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">memory_handle -[out] memory handle for this mapped address</li>
-<li style="list-style-type: '· ';">mapped -[in] address</li>
-</ul>
-<h2>Return values</h2>
-<ul>
-<li style="list-style-type: '· ';">::HSA_STATUS_SUCCESS -</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_INVALID_ALLOCATION - Invalid address</li>
-</ul>
-<p>hsa_status_t hsa_amd_vmem_get_alloc_properties_from_handle ( hsa_amd_vmem_alloc_handle_t memory_handle, hsa_amd_memory_pool_t *pool, hsa_amd_memory_type_t *type )</p>
-<p>Returns the current allocation properties of a handle.</p>
-<p>Returns the allocation properties of an existing handle</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">memory_handle -[in] memory handle to be queried</li>
-<li style="list-style-type: '· ';">pool -[out] memory pool that owns this handle</li>
-<li style="list-style-type: '· ';">memory -[out] type</li>
-</ul>
-<h2>Return values</h2>
-<ul>
-<li style="list-style-type: '· ';">::HSA_STATUS_SUCCESS -</li>
-<li style="list-style-type: '· ';">::HSA_STATUS_ERROR_INVALID_ALLOCATION - Invalid memory_handle</li>
-</ul>
-<h2>CHAPTER</h2>
-<h2>TWENTYFIVE</h2>
-<h2>HIP MANAGED MEMORY ALLOCATION API</h2>
-<p>hipError_t hipMallocManaged ( void **dev_ptr, size_t size, unsigned int flags )</p>
-<p>Allocates memory that will be automatically managed by HIP.</p>
-<p>This API is used for managed memory, allows data be shared and accessible to both CPU and GPU using a single pointer.</p>
-<p>The API returns the allocation pointer, managed by HMM, can be used further to execute kernels on device and fetch data between the host and device as needed.</p>
-<p>Note: It is recommend to do the capability check before call this API.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dev_ptr -[out] - pointer to allocated device memory</li>
-<li style="list-style-type: '· ';">size -[in] - requested allocation size in bytes, it should be granularity of 4KB</li>
-<li style="list-style-type: '· ';">flags -[in] - must be either hipMemAttachGlobal or hipMemAttachHost (defaults to hipMemAttachGlobal)</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorMemoryAllocation, hipErrorNotSupported, hipErrorInvalidValue hipError_t hipMemPrefetchAsync ( const void *dev_ptr, size_t count, int device, hipStream_t stream</p>
-<p>) Prefetches memory to the specified destination device using HIP.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dev_ptr -[in] pointer to be prefetched</li>
-<li style="list-style-type: '· ';">count -[in] size in bytes for prefetching</li>
-<li style="list-style-type: '· ';">device -[in] destination device to prefetch to</li>
-<li style="list-style-type: '· ';">stream -[in] stream to enqueue prefetch operation</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue</p>
-<p>hipError_t hipMemAdvise ( const void *dev_ptr, size_t count, hipMemoryAdvise advice, int device )</p>
-<p>Advise about the usage of a given memory range to HIP.</p>
-<p>This HIP API advises about the usage to be applied on unified memory allocation in the range starting from the pointer address devPtr, with the size of count bytes. The memory range must refer to managed memory allocated via the API hipMallocManaged, and the range will be handled with proper round down and round up respectively in the driver to be aligned to CPU page size, the same way as corresponding CUDA API behaves in CUDA version 8.0 and afterwards.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">dev_ptr -[in] pointer to memory to set the advice for</li>
-<li style="list-style-type: '· ';">count -[in] size in bytes of the memory range, it should be CPU page size alligned.</li>
-<li style="list-style-type: '· ';">advice -[in] advice to be applied for the specified memory range</li>
-<li style="list-style-type: '· ';">device -[in] device to apply the advice for</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipError_t hipMemRangeGetAttribute ( void *data, size_t data_size, hipMemRangeAttribute attribute, const void *dev_ptr, size_t count )</p>
-<p>Query an attribute of a given memory range in HIP.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">data -[inout] a pointer to a memory location where the result of each attribute query will be written to</li>
-<li style="list-style-type: '· ';">data_size -[in] the size of data</li>
-<li style="list-style-type: '· ';">attribute -[in] the attribute to query</li>
-<li style="list-style-type: '· ';">dev_ptr -[in] start of the range to query</li>
-<li style="list-style-type: '· ';">count -[in] size of the range to query</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipError_t hipMemRangeGetAttributes ( void **data, size_t *data_sizes, hipMemRangeAttribute *attributes, size_t num_attributes, const void *dev_ptr, size_t count )</p>
-<p>Query attributes of a given memory range in HIP.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">data -[inout] a two-dimensional array containing pointers to memory locations where the result of each attribute query will be written to</li>
-<li style="list-style-type: '· ';">data_sizes -[in] an array, containing the sizes of each result</li>
-<li style="list-style-type: '· ';">attributes -[in] the attribute to query</li>
-<li style="list-style-type: '· ';">num_attributes -[in] an array of attributes to query (numAttributes and the number of attributes in this array should match)</li>
-<li style="list-style-type: '· ';">dev_ptr -[in] start of the range to query</li>
-<li style="list-style-type: '· ';">count -[in] size of the range to query</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue hipError_t hipStreamAttachMemAsync ( hipStream_t stream, void *dev_ptr, size_t length, unsigned int flags ) Attach memory to a stream asynchronously in HIP.</p>
-<p>Warning: This API is under development. Currently it is a no-operation (NOP) function on AMD GPUs and returns hipSuccess.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">stream -[in] - stream in which to enqueue the attach operation</li>
-<li style="list-style-type: '· ';">dev_ptr -[in] - pointer to memory (must be a pointer to managed memory or to a valid host-accessible region of system-allocated memory)</li>
-<li style="list-style-type: '· ';">length -[in] - length of memory (defaults to zero)</li>
-<li style="list-style-type: '· ';">flags -[in] - must be one of hipMemAttachGlobal, hipMemAttachHost or hipMemAttachSingle (defaults to hipMemAttachSingle)</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue</p>
-<h2>template&lt;class T &gt;</h2>
-<p>static inline hipError_t hipMallocManaged ( T **devPtr, size_t size, unsigned int flags = hipMemAttachGlobal )</p>
-<ul>
-<li>: C++ wrapper for hipMallocManaged</li>
-</ul>
-<p>Provide an override to automatically typecast the pointer type from void**, and also provide a default for the flags.</p>
-<p>HIP_DISABLE_CPP_FUNCTIONS macro can be defined to suppress these wrappers. It is useful for applications which need to obtain decltypes of HIP runtime APIs.</p>
-<h2>See also:</h2>
-<p>hipMallocManaged</p>
-<h2>CHAPTER</h2>
-<h2>TWENTYSIX</h2>
-<h2>HIP VIRTUAL MEMORY MANAGEMENT API</h2>
-<p>hipError_t hipMemAddressFree ( void *devPtr, size_t size )</p>
-<p>Frees an address range reservation made via hipMemAddressReserve.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">devPtr -[in] - starting address of the range.</li>
-<li style="list-style-type: '· ';">size -[in] - size of the range.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError_t hipMemAddressReserve ( void **ptr, size_t size, size_t alignment, void *addr, unsigned long long flags )</p>
-<p>Reserves an address range.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">ptr -[out] - starting address of the reserved range.</li>
-<li style="list-style-type: '· ';">size -[in] - size of the reservation.</li>
-<li style="list-style-type: '· ';">alignment -[in] - alignment of the address.</li>
-<li style="list-style-type: '· ';">addr -[in] - requested starting address of the range.</li>
-<li style="list-style-type: '· ';">flags -[in] - currently unused, must be zero.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotSupported</p>
-<p>hipError_t hipMemCreate ( hipMemGenericAllocationHandle_t *handle, size_t size, const hipMemAllocationProp *prop, unsigned long long flags )</p>
-<p>Creates a memory allocation described by the properties and size.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">handle -[out] - value of the returned handle.</li>
-<li style="list-style-type: '· ';">size -[in] - size of the allocation.</li>
-<li style="list-style-type: '· ';">prop -[in] - properties of the allocation.</li>
-<li style="list-style-type: '· ';">flags -[in] - currently unused, must be zero.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError_t hipMemExportToShareableHandle ( void *shareableHandle, hipMemGenericAllocationHandle_t handle, hipMemAllocationHandleType handleType, unsigned long long flags )</p>
-<p>Exports an allocation to a requested shareable handle type.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">shareableHandle -[out] - value of the returned handle.</li>
-<li style="list-style-type: '· ';">handle -[in] - handle to share.</li>
-<li style="list-style-type: '· ';">handleType -[in] - type of the shareable handle.</li>
-<li style="list-style-type: '· ';">flags -[in] - currently unused, must be zero.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError_t hipMemGetAccess ( unsigned long long *flags, const hipMemLocation *location, void *ptr</p>
-<p>) Get the access flags set for the given location and ptr.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">flags -[out] - flags for this location.</li>
-<li style="list-style-type: '· ';">location -[in] - target location.</li>
-<li style="list-style-type: '· ';">ptr -[in] - address to check the access flags.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError_t hipMemGetAllocationGranularity ( size_t *granularity, const hipMemAllocationProp *prop, hipMemAllocationGranularity_flags option )</p>
-<p>Calculates either the minimal or recommended granularity.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">granularity -[out] - returned granularity.</li>
-<li style="list-style-type: '· ';">prop -[in] - location properties.</li>
-<li style="list-style-type: '· ';">option -[in] - determines which granularity to return.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError_t hipMemGetAllocationPropertiesFromHandle ( hipMemAllocationProp *prop,</p>
-<p>hipMemGenericAllocationHandle_t handle )</p>
-<p>Retrieve the property structure of the given handle.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">prop -[out] - properties of the given handle.</li>
-<li style="list-style-type: '· ';">handle -[in] - handle to perform the query on.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotSupported</p>
-<p>hipError_t hipMemImportFromShareableHandle ( hipMemGenericAllocationHandle_t *handle, void *osHandle, hipMemAllocationHandleType shHandleType )</p>
-<p>Imports an allocation from a requested shareable handle type.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">handle -[out] - returned value.</li>
-<li style="list-style-type: '· ';">osHandle -[in] - shareable handle representing the memory allocation.</li>
-<li style="list-style-type: '· ';">shHandleType -[in] - handle type.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError_t hipMemMap ( void *ptr, size_t size, size_t offset, hipMemGenericAllocationHandle_t handle, unsigned long long flags )</p>
-<p>Maps an allocation handle to a reserved virtual address range.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">ptr -[in] - address where the memory will be mapped.</li>
-<li style="list-style-type: '· ';">size -[in] - size of the mapping.</li>
-<li style="list-style-type: '· ';">offset -[in] - offset into the memory, currently must be zero.</li>
-<li style="list-style-type: '· ';">handle -[in] - memory allocation to be mapped.</li>
-<li style="list-style-type: '· ';">flags -[in] - currently unused, must be zero.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError_t hipMemMapArrayAsync ( hipArrayMapInfo *mapInfoList, unsigned int count, hipStream_t stream )</p>
-<p>Maps or unmaps subregions of sparse HIP arrays and sparse HIP mipmapped arrays.</p>
-<p>Warning: This API is under development. Currently it is not supported on AMD GPUs and returns hipErrorNotSupported.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">mapInfoList -[in] - list of hipArrayMapInfo.</li>
-<li style="list-style-type: '· ';">count -[in] - number of hipArrayMapInfo in mapInfoList.</li>
-<li style="list-style-type: '· ';">stream -[in] - stream identifier for the stream to use for map or unmap operations.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError_t hipMemRelease ( hipMemGenericAllocationHandle_t handle )</p>
-<p>Release a memory handle representing a memory allocation which was previously allocated through hipMemCreate.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<p>handle -[in] - handle of the memory allocation.</p>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError_t hipMemRetainAllocationHandle ( hipMemGenericAllocationHandle_t *handle, void *addr )</p>
-<p>Returns the allocation handle of the backing memory allocation given the address.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">handle -[out] - handle representing addr.</li>
-<li style="list-style-type: '· ';">addr -[in] - address to look up.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError_t hipMemSetAccess ( void *ptr, size_t size, const hipMemAccessDesc *desc, size_t count )</p>
-<p>Set the access flags for each location specified in desc for the given virtual address range.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">ptr -[in] - starting address of the virtual address range.</li>
-<li style="list-style-type: '· ';">size -[in] - size of the range.</li>
-<li style="list-style-type: '· ';">desc -[in] - array of hipMemAccessDesc.</li>
-<li style="list-style-type: '· ';">count -[in] - number of hipMemAccessDesc in desc.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotSupported</p>
-<h2>hipError_t hipMemUnmap ( void *ptr, size_t size )</h2>
-<p>Unmap memory allocation of a given address range.</p>
-<p>Note: This API is implemented on Linux and is under development on Microsoft Windows.</p>
-<p>Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.</p>
-<h2>Parameters</h2>
-<ul>
-<li style="list-style-type: '· ';">ptr -[in] - starting address of the range to unmap.</li>
-<li style="list-style-type: '· ';">size -[in] - size of the virtual address range.</li>
-</ul>
-<h2>Returns</h2>
-<p>hipSuccess, hipErrorInvalidValue, hipErrorNotSupported</p>
-<h2>CHAPTER</h2>
-<h2>TWENTYSEVEN</h2>
-<h2>HIP DEPRECATED RUNTIME API FUNCTIONS</h2>
-<p>Several of our API functions have been flagged for deprecation. Using the following functions results in errors and unexpected results, so we encourage you to update your code accordingly.</p>
-<h2>27.1 Context management</h2>
-<p>CUDAsupports cuCtx API, which is the driver API that defines 'Context' and 'Devices' as separate entities. Context contains a single device, and a device can theoretically have multiple contexts. HIP initially added limited support for these APIs in order to facilitate porting from existing driver codes. These APIs are now marked as deprecated because there are better alternate interfaces (such as hipSetDevice or the stream API) to achieve these functions.</p>
-<ul>
-<li style="list-style-type: '· ';">hipCtxCreate</li>
-<li style="list-style-type: '· ';">hipCtxDestroy</li>
-<li style="list-style-type: '· ';">hipCtxPopCurrent</li>
-<li style="list-style-type: '· ';">hipCtxPushCurrent</li>
-<li style="list-style-type: '· ';">hipCtxSetCurrent</li>
-<li style="list-style-type: '· ';">hipCtxGetCurrent</li>
-<li style="list-style-type: '· ';">hipCtxGetDevice</li>
-<li style="list-style-type: '· ';">hipCtxGetApiVersion</li>
-<li style="list-style-type: '· ';">hipCtxGetCacheConfig</li>
-<li style="list-style-type: '· ';">hipCtxSetCacheConfig</li>
-<li style="list-style-type: '· ';">hipCtxSetSharedMemConfig</li>
-<li style="list-style-type: '· ';">hipCtxGetSharedMemConfig</li>
-<li style="list-style-type: '· ';">hipCtxSynchronize</li>
-<li style="list-style-type: '· ';">hipCtxGetFlags</li>
-<li style="list-style-type: '· ';">hipCtxEnablePeerAccess</li>
-<li style="list-style-type: '· ';">hipCtxDisablePeerAccess</li>
-<li style="list-style-type: '· ';">hipDevicePrimaryCtxGetState</li>
-<li style="list-style-type: '· ';">hipDevicePrimaryCtxRelease</li>
-<li style="list-style-type: '· ';">hipDevicePrimaryCtxRetain</li>
-<li style="list-style-type: '· ';">hipDevicePrimaryCtxReset</li>
-</ul>
-<ul>
-<li style="list-style-type: '· ';">hipDevicePrimaryCtxSetFlags</li>
-</ul>
-<h2>27.2 Memory management</h2>
-<ul>
-<li style="list-style-type: '· ';">hipMallocHost (replaced with hipHostMalloc )</li>
-<li style="list-style-type: '· ';">hipMemAllocHost (replaced with hipHostMalloc )</li>
-<li style="list-style-type: '· ';">hipHostAlloc (replaced with hipHostMalloc )</li>
-<li style="list-style-type: '· ';">hipFreeHost (replaced with hipHostFree )</li>
-<li style="list-style-type: '· ';">hipMemcpyToArray</li>
-<li style="list-style-type: '· ';">hipMemcpyFromArray</li>
-</ul>
-<h2>27.3 Profiler control</h2>
-<ul>
-<li style="list-style-type: '· ';">hipProfilerStart (use roctracer/rocTX)</li>
-<li style="list-style-type: '· ';">hipProfilerStop (use roctracer/rocTX)</li>
-</ul>
-<h2>27.4 Texture management</h2>
-<ul>
-<li style="list-style-type: '· ';">hipGetTextureReference</li>
-<li style="list-style-type: '· ';">hipTexRefSetAddressMode</li>
-<li style="list-style-type: '· ';">hipTexRefSetArray</li>
-<li style="list-style-type: '· ';">hipTexRefSetFilterMode</li>
-<li style="list-style-type: '· ';">hipTexRefSetFlags</li>
-<li style="list-style-type: '· ';">hipTexRefSetFormat</li>
-<li style="list-style-type: '· ';">hipTexRefGetAddress</li>
-<li style="list-style-type: '· ';">hipTexRefGetAddressMode</li>
-<li style="list-style-type: '· ';">hipTexRefGetFilterMode</li>
-<li style="list-style-type: '· ';">hipTexRefGetFlags</li>
-<li style="list-style-type: '· ';">hipTexRefGetFormat</li>
-<li style="list-style-type: '· ';">hipTexRefGetMaxAnisotropy</li>
-<li style="list-style-type: '· ';">hipTexRefGetMipmapFilterMode</li>
-<li style="list-style-type: '· ';">hipTexRefGetMipmapLevelBias</li>
-<li style="list-style-type: '· ';">hipTexRefGetMipmapLevelClamp</li>
-<li style="list-style-type: '· ';">hipTexRefGetMipMappedArray</li>
-<li style="list-style-type: '· ';">hipTexRefSetAddress</li>
-<li style="list-style-type: '· ';">hipTexRefSetAddress2D</li>
-<li style="list-style-type: '· ';">hipTexRefSetMaxAnisotropy</li>
-</ul>
-<ul>
-<li style="list-style-type: '· ';">hipTexRefSetBorderColor</li>
-<li style="list-style-type: '· ';">hipTexRefSetMipmapFilterMode</li>
-<li style="list-style-type: '· ';">hipTexRefSetMipmapLevelBias</li>
-<li style="list-style-type: '· ';">hipTexRefSetMipmapLevelClamp</li>
-<li style="list-style-type: '· ';">hipTexRefSetMipmappedArray</li>
-<li style="list-style-type: '· ';">hipTexRefGetBorderColor</li>
-<li style="list-style-type: '· ';">hipTexRefGetArray</li>
-<li style="list-style-type: '· ';">hipBindTexture</li>
-<li style="list-style-type: '· ';">hipBindTexture2D</li>
-<li style="list-style-type: '· ';">hipBindTextureToArray</li>
-<li style="list-style-type: '· ';">hipGetTextureAlignmentOffset</li>
-<li style="list-style-type: '· ';">hipUnbindTexture</li>
-<li style="list-style-type: '· ';">hipBindTextureToMipmappedArray</li>
-</ul>
-<h2>CHAPTER</h2>
-<h2>TWENTYEIGHT</h2>
-<h2>SAXPY - HELLO, HIP</h2>
-<p>This tutorial explains the basic concepts of the single-source Heterogeneous-computing Interface for Portability (HIP) programming model and the essential tooling around it. It also reviews some commonalities of heterogenous APIs in general. This topic assumes basic familiarity with the C/C++ compilation model and language.</p>
-<h2>28.1 Prerequisites</h2>
-<p>To follow this tutorial, you'll need installed drivers and a HIP compiler toolchain to compile your code. Because HIP for ROCm supports compiling and running on Linux and Windows with AMD and NVIDIA GPUs, the combination of install instructions is more than worth covering as part of this tutorial. For more information about installing HIP development packages, see Install HIP .</p>
-<h2>28.2 Heterogeneous programming</h2>
-<p>Heterogeneous programming and offloading APIs are often mentioned together. Heterogeneous programming deals with devices of varying capabilities simultaneously. Offloading focuses on the 'remote' and asynchronous aspects of computation. HIP encompasses both. It exposes GPGPU (general-purpose GPU) programming much like ordinary host-side CPU programming and lets you move data across various devices.</p>
-<p>When programming in HIP (and other heterogenous APIs for that matter), remember that target devices are built for a specific purpose. They are designed with different tradeoffs than traditional CPUs and therefore have very different performance characteristics. Even subtle changes in code might adversely affect execution time.</p>
-<h2>28.3 Your first lines of HIP code</h2>
-<p>First, let's do the 'Hello, World!' of GPGPU: SAXPY. Single-precision A times X Plus Y ( SAXPY ) is a mathematical acronym; a vector equation 𝑎 · 𝑥 + 𝑦 = 𝑧 where 𝑎 ∈ R is a scalar and 𝑥, 𝑦, 𝑧 ∈ V are vector quantities of some large dimensionality. This vector space is defined over the set of reals. Practically speaking, you can compute this using a single for loop over three arrays.</p>
-<pre><code>++i)</code></pre>
-<pre><code><_SQL_></code></pre>
-<p>In linear algebra libraries, such as BLAS (Basic Linear Algebra Subsystem) this operation is defined as AXPY 'A times X Plus Y'. The 'S' comes from single-precision , meaning that array element is float -s (IEEE 754 binary32 representation).</p>
-<p>To quickly get started, use the set of HIP samples from GitHub. With Git configured on your machine, open a commandline and navigate to your desired working directory, then run:</p>
-<pre><code>            |git clone https://github.com/amd/rcm-examples.git</code></pre>
-<p>A simple implementation of SAXPY resides in the HIP-Basic/saxpy/main.hip file in this repository. The HIP code here mostly deals with where data has to be and when, and how devices transform this data. The first HIP calls deal with allocating device-side memory and copying data from host-side memory to device side in a C runtime-like fashion.</p>
-<pre><code>// Allocate and copy vectors to device memory.
-float* d_x{};
-float* d_y{};
-HIP_CHECK(hipMalloc(&d_x, size_bytes));
-HIP_CHECK(hipMalloc(&d_y, size_bytes));
-HIP_CHECK(hipMemcpy(d_x, x.data(), size_bytes, hipMemcpyHostToDevice));
-HIP_CHECK(hipMemcpy(d_y, y.data(), size_bytes, hipMemcpyHostToDevice));</code></pre>
-<p>HIP_CHECK is a custom macro borrowed from the examples utilities which checks the error code returned by API functions for errors and reports them to the console. It is not essential to the API, but it is a good practice to check the error codes of the HIP APIs in case you pass on incorrect values to the API, or the API might be out of resources.</p>
-<p>The code selects the device to allocate to and to copy to. Commands are issued to the HIP runtime per thread, and every thread has a device set as the target of commands. The default device is 0 , which is equivalent to calling hipSetDevice(0) .</p>
-<p>Launch the calculation on the device after the input data has been prepared.</p>
-<pre><code>    Launch the calculation on the device after the input data has been prepared.
-    __global__ void saxpy_kernel(const float a, const float* d_x, float* d_y, const unsigned_
-    __int size)
-    {
-        //...
-    }
-
-    int main()
-    {
-        //...
-
-        // Launch the kernel on the default stream.
-        saxpy_kernel<<<dim3(grid_size), dim3(block_size), 0, hipStreamDefault>>>(a, d_x, d_y,
-    -- size);
-    }
-
-    Analyze at the signature of the offloaded function:</code></pre>
-<p>Analyze at the signature of the offloaded function:</p>
-<ul>
-<li style="list-style-type: '· ';">__global__ instructs the compiler to generate code for this function as an entrypoint to a device program, such that it can be launched from the host.</li>
-<li style="list-style-type: '· ';">The function does not return anything, because there is no trivial way to construct a return channel of a parallel invocation. Device-side entrypoints may not return a value, their results should be communicated using output parameters.</li>
-<li style="list-style-type: '· ';">Device-side functions are typically called compute kernels, or just kernels for short. This is to distinguish them from non-graphics-related graphics shaders, or just shaders for short.</li>
-<li style="list-style-type: '· ';">Arguments are taken by value and all arguments shall be TriviallyCopyable, meaning they should be memcpy -friendly. (Imagine if they had custom copy constructors. Where would that logic execute? On the host? On the device?) Pointer arguments are pointers to device memory, one typically backed by VRAM.</li>
-</ul>
-<ul>
-<li style="list-style-type: '· ';">We said that we'll be computing 𝑎 · 𝑥 + 𝑦 = 𝑧 , however we only pass two pointers to the function. We'll be canonically reusing one of the inputs as outputs.</li>
-</ul>
-<p>This function is launched from the host using a language extension often called the triple chevron syntax. Inside the angle brackets, provide the following.</p>
-<ul>
-<li style="list-style-type: '· ';">The number of blocks to launch (our grid size)</li>
-<li style="list-style-type: '· ';">The number of threads in a block (our block size)</li>
-<li style="list-style-type: '· ';">The amount of shared memory to allocate by the host</li>
-<li style="list-style-type: '· ';">The device stream to enqueue the operation on</li>
-</ul>
-<p>The block size and shared memory become important later in Reduction . For now, a hardcoded 256 is a safe default for simple kernels such as this. Following the triple chevron is ordinary function argument passing.</p>
-<p>Look at how the kernel is implemented.</p>
-<pre><code><_Cuda_></code></pre>
-<ul>
-<li style="list-style-type: '· ';">The unique linear index identifying the thread is computed from the block ID the thread is a member of, the block 's size and the ID of the thread within the block .</li>
-<li style="list-style-type: '· ';">A check is made to avoid overindexing the input.</li>
-<li style="list-style-type: '· ';">The useful part of the computation is carried out.</li>
-</ul>
-<p>Retrieval of the result from the device is done much like input data copy. In this current step the results copied from device to host. The opposite direction of the input data copy:</p>
-<pre><code>                |HIP_CHECK(hipMemcpy(y.data()),  d_y,  size_bytes,  hipMemcpyDeviceToHost));</code></pre>
-<h2>28.4 Compiling on the command line</h2>
-<h2>28.4.1 Setting up the command line</h2>
-<p>Strictly speaking there's no such thing as 'setting up the command-line for compilation' on Linux. To make invocations more terse, Linux and Windows example follow.</p>
-<h2>Linux and AMD</h2>
-<p>While distro maintainers might package ROCm so that it installs to system-default locations, AMD's packages aren't installed that way. They need to be added to the PATH by the user.</p>
-<pre><code>        | export PATH=/opt/rcm/bin:${PATH}</code></pre>
-<pre><code>}</code></pre>
-<pre><code>    You should be able to call the compiler on the command line now:
-    
-    amdclang++  --version</code></pre>
-<p>Note: Docker images distributed by AMD, such as rocm-terminal already have /opt/rocm/bin on the Path for convenience. This subtly affects CMake package detection logic of ROCm libraries.</p>
-<h2>Linux and NVIDIA</h2>
-<p>Both distro maintainers and NVIDIA package CUDA so that nvcc and related tools are available on the command line by default. You can call the compiler on the command line with:</p>
-<pre><code>| nvcc --version</code></pre>
-<h2>Windows and AMD</h2>
-<p>Windows compilers and command line tooling have traditionally relied on extra environmental variables and PATH entries to function correctly. Visual Studio refers to command lines with this setup as 'Developer Command Prompt' or 'Developer PowerShell' for cmd.exe and PowerShell respectively.</p>
-<p>The HIP SDK on Windows doesn't include a complete toolchain. You will also need:</p>
-<ul>
-<li style="list-style-type: '· ';">The Microsoft Windows SDK. It provides the import libs to crucial system libraries that all executables must link to and some auxiliary compiler tooling.</li>
-<li style="list-style-type: '· ';">A Standard Template Library (STL). Installed as part of the Microsoft Visual C++ compiler (MSVC) or with Visual Studio.</li>
-</ul>
-<p>If you don't have a version of Visual Studio 2022 installed, for a minimal command line experience, install the Build Tools for Visual Studio 2022 with the Desktop Developemnt Workload. Under Individual Components select:</p>
-<ul>
-<li style="list-style-type: '· ';">A version of the Windows SDK</li>
-<li style="list-style-type: '· ';">'MSVC v143 - VS 2022 C++ x64/x86 build tools (Latest)'</li>
-<li style="list-style-type: '· ';">'C++ CMake tools for Windows' (optional)</li>
-</ul>
-<p>Note: The 'C++ CMake tools for Windows' individual component is a convenience which puts both cmake.exe and ninja.exe onto the PATH inside developer command prompts. You can install these manually, but then you must manage them manually.</p>
-<p>Visual Studio 2017 and later are detectable as COM object instances via WMI. To setup a command line from any shell for the latest Visual Studio's default Visual C++ toolset issue:</p>
-<pre><code>$InstallationPath = Get-CimInstance MSFT_VSInstance | Sort-Object -Property Version -
- --Descending | Select-Object -First 1 -ExpandProperty InstallLocation
- Import-Module $InstallationPath\Common?\Tools\Microsoft.VisualStudio.DevShell.dll
-Enter-VsDevShell -InstallPath $InstallationPath -SkipAutomaticLocation -Arch amd64 -
- --HostArch amd64 -DevCmdArguments '-no_logo'
-$env:PATH = "${env:HIP_PATH}bin;${env:PATH}"</code></pre>
-<p>You should be able to call the compiler on the command line now:</p>
-<pre><code>  | clang++ --version</code></pre>
-<h2>Windows and NVIDIA</h2>
-<p>Windows compilers and command line tooling have traditionally relied on extra environmental variables and PATH entries to function correctly. Visual Studio refers to command lines with this setup as 'Developer Command Prompt' or 'Developer PowerShell' for cmd.exe and PowerShell respectively.</p>
-<p>The HIP and CUDA SDKs on Windows don't include complete toolchains. You will also need:</p>
-<ul>
-<li style="list-style-type: '· ';">The Microsoft Windows SDK. It provides the import libs to crucial system libraries that all executables must link to and some auxiliary compiler tooling.</li>
-<li style="list-style-type: '· ';">A Standard Template Library (STL). Installed as part of the Microsoft Visual C++ compiler (MSVC) or with Visual Studio.</li>
-</ul>
-<p>If you don't have a version of Visual Studio 2022 installed, for a minimal command line experience, install the Build Tools for Visual Studio 2022 with the Desktop Developemnt Workload. Under Individual Components select:</p>
-<ul>
-<li style="list-style-type: '· ';">A version of the Windows SDK</li>
-<li style="list-style-type: '· ';">'MSVC v143 - VS 2022 C++ x64/x86 build tools (Latest)'</li>
-<li style="list-style-type: '· ';">'C++ CMake tools for Windows' (optional)</li>
-</ul>
-<p>Note: The 'C++ CMake tools for Windows' individual component is a convenience which puts both cmake.exe and ninja.exe onto the PATH inside developer command prompts. You can install these manually, but then you must manage them manually.</p>
-<p>Visual Studio 2017 and later are detectable as COM object instances via WMI. To setup a command line from any shell for the latest Visual Studio's default Visual C++ toolset issue:</p>
-<pre><code>$InstallationPath = Get-CimInstance MSFT_VSInstance | Sort-Object -Property Version -
---Descending | Select-Object -First 1 -ExpandProperty InstallLocation
-Import-Module $InstallationPath\Common7\Tools\Microsoft.VisualStudio.DevShell.dll
-Enter-VsDevShell -InstallPath $InstallationPath -SkipAutomaticLocation -Arch amd64 -
---HostArch amd64 -DevCmdArguments '-no_logo'</code></pre>
-<p>You should be able to call the compiler on the command line now:</p>
-<pre><code>| nvcc --version</code></pre>
-<h2>28.4.2 Invoking the compiler manually</h2>
-<p>To compile and link a single-file application, use the following commands:</p>
-<h2>Linux and AMD</h2>
-<pre><code>                                                                                                                                                                                                        |                                                                                                                                                                                                       
-                                                                                                                                                                                                        <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        </----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                    <---------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        >----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                    |   
-                                                                                                                                                                                                    |   
-
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                   
-    </----------------------------------------------------------------------------------------------------------------------</code></pre>
-<h2>Linux and NVIDIA</h2>
-<pre><code>                                                                                                                                                                                                        | nvcc ./HIP-Basic/saxpy/main.hip  -o  saxpy  -I ./Common  -I  /opt/rocm/include  -02  -x  cu                                                                                                                                                                                                       
-                                                                                                                                                                                                        -x  cu                                                                                                                                                                                                  |                                                                                                                                                                                                        }</code></pre>
-<h2>Windows and AMD</h2>
-<pre><code>                                                                                                                                                                                                        |clang++.\HIP-Basic\saxpy\main.hip -o saxpy.exe -I.\Common -lamdhip64 -L ${env:HIP_PATH}                                                                                                                                                                                                       
-                                                                                                                                                                                                        -lib -02</code></pre>
-<h2>Windows and NVIDIA</h2>
-<pre><code>                                                                                                                                                                                                        | nvcc.\HIP-Basic\saxpy\main.hip -o saxpy.exe -I ${env:HIP_PATH}include -I.\Common -02 - -
-                                                                                                                                                                                                        -x                                                                                                                                                                                                       
-                                                                                                                                                                                                       |                                                                                                                                                                                                        +x                                                                                                                                                                                                       |</code></pre>
-<p>Depending on your computer, the resulting binary might or might not run. If not, it typically complains about 'Invalid device function'. That error (corresponding to the hipErrorInvalidDeviceFunction entry of hipError_t ) means that the runtime could not find a device program binary of the appropriate flavor embedded into the executable.</p>
-<p>So far, the discussion has covered how data makes it from the host to the device and back. It has also discussed the device code as source, with the HIP runtime arguing that the correct binary to dispatch for execution. How can you find out what device binary flavors are embedded into the executable?</p>
-<h2>Linux and AMD</h2>
-<p>The utilities included with ROCm help significantly to inspect binary artifacts on disk. Add the ROCmCC installation folder to your PATH if you want to use these utilities (the utilities expect them to be on the PATH).</p>
-<p>You can list embedded program binaries using roc-obj-ls .</p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?>
-                                                                                                                                                                                                       <!>
-                                                                                                                                                                                                      <!>"</code></pre>
-<pre><code><_SQL_></code></pre>
-<p>The compiler embeds a version 4 code object (more on code object versions) and used the LLVM target triple amdgcnamd-amdhsa-gfx803 (more on target triples). You can extract that program object in a disassembled fashion for human consumption via roc-obj .</p>
-<pre><code>        | r o c - o b j \ - t \ g f x 8 0 3 \ - d \. / s a x p y</code></pre>
-<p>This creates two files on disk and .s extension is of most interest. Opening this file or dumping it to the console using cat lets find the disassembled binary of the SAXPY compute kernel, something similar to:</p>
-<pre><code><_XML_></code></pre>
-<p>Alternatively, call the compiler with --save-temps to dump all device binary to disk in separate files.</p>
-<pre><code>                                                                                                                                                                                                        |                                                                                                                                                                                                       
-                                                                                                                                                                                                        -                                                                                                                                                                                                        --                                                                                                                                                                                                        \                                                                                                                                                                                                        +                                                                                                                                                                                                        <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        }                                                                                                                                                                                                        </----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                    |   
-                                                                                                                                                                                                    |    -                                                                                                                                                                                                    |    0                                                                                                                                                                                                        ]                                                                                                                                                                                                        )                                                                                                                                                                                                       .                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        :                                                                                                                                                                                                       '</code></pre>
-<p>List all the temporaries created while compiling main.hip with:</p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-    ls main-hip-amdgcn-amd-amdhsa-*
-    main-hip-amdgcn-amd-amdhsa-gfx803.bc
-    main-hip-amdgcn-amd-amdhsa-gfx803.cui
-    main-hip-amdgcn-amd-amdhsa-gfx803.o
-    main-hip-amdgcn-amd-amdhsa-gfx803.out
-    main-hip-amdgcn-amd-amdhsa-gfx803.out.resolution.txt
-    main-hip-amdgcn-amd-amdhsa-gfx803.s</code></pre>
-<p>Files with the .s extension hold the disassembled contents of the binary. The filename notes the graphics IPs used by the compiler. The contents of this file are similar to what roc-obj printed to the console.</p>
-<h2>Linux and NVIDIA</h2>
-<p>Unlike HIP on AMD, when compiling using the NVIDIA support of HIP the resulting binary will be a valid CUDA executable as far as the binary goes. Therefor it'll incorporate PTX ISA (Parallel Thread eXecution Instruction Set Architecture) instead of AMDGPU binary. As s result, tooling shipping with the CUDA SDK can be used to inspect which device ISA got compiled into a specific executable. The tool most useful to us currently is cuobjdump .</p>
-<pre><code>  cuobjdump --list-ptx./saxpy
-
-  Which will print something like:</code></pre>
-<pre><code>| P T X \ f i l e</code></pre>
-<pre><code>1:  saxpy. 1. sm_5. ptx</code></pre>
-<p>From this we can see that the saxpy kernel is stored as sm_52 , which shows that a compute capability 5.2 ISA got embedded into the executable, so devices which sport compute capability 5.2 or newer will be able to run this code.</p>
-<h2>Windows and AMD</h2>
-<p>The HIP SDK for Windows don't yet sport the roc-* set of utilities to work with binary artifacts. To find out what binary formats are embedded into an executable, one may use dumpbin tool from the Windows SDK to obtain the raw data of the .hip_fat section of an executable. (This binary payload is what gets parsed by the roc-* set of utilities on Linux.) Skipping over the reported header, the rendered raw data as ASCII has ~3 lines per entries. Depending on how many binaries are embedded, you may need to alter the number of rendered lines. An invocation such as:</p>
-<pre><code>                                                                                                                                                                                                        | dumpbin.exe  /nologo  /section:.hip_fat  /rawdata:8 .\saxpy.exe  |  select  -Skip  20  -First  12                                                                                                                                                                                                       
-                                                                                                                                                                                                        -                                                                                                                                                                                                        --                                                                                                                                                                                                        +                                                                                                                                                                                                        <--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        </--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                   | dumpbin .exe  /nologo  /section:.hip_fat  /rawdata:8 .\saxpy.exe  |  select  -Skip  20  -First  12                                                                                                                                                             |                                                                                                                                                                                                        >--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                  
-     |  dumpbin.exe  /nologo  /section:.hip_fat  /rawdata:8 .\saxpy.exe  |  select  -Skip  20  -First  12                                                                                                                                                        |                                               
-     |                                                                                                                                                                                                   |                                          
-     |                                                                                                                                                       
-     |                                                                                                                                                   |                                                    
-     |                                                                                                                                             
-     |                                                    
-     |                                                                                                                                        
-     |                                                         
-     |</code></pre>
-<p>The output may look like:</p>
-<pre><code><_Python_></code></pre>
-<p>We can see that the compiler embedded a version 4 code object (more on code object versions) and used the LLVM target triple amdgcn-amd-amdhsa-gfx906 (more on target triples). Don't be alarmed about linux showing up as a binary format, AMDGPU binaries uploaded to the GPU for execution are proper linux ELF binaries in their format.</p>
-<p>Alternatively we can call the compiler with --save-temps to dump all device binary to disk in separate files.</p>
-<pre><code>                                                                                                                                                                                                        |clang++.\HIP-Basic\saxpy\main.hip -o saxpy.exe -I.\Common -lamdhip64 -L ${env:HIP_PATH}                                                                                                                                                                                                       
-                                                                                                                                                                                                        -lib -02 --save-temps                                                                                                                                                                                                        \</code></pre>
-<p>Now we can list all the temporaries created while compiling main.hip via</p>
-<pre><code>        |Get-ChildItem -Filter main-hip-* | selec</code></pre>
-<pre><code>n-hip-* | select -Property Name
-                                                                                                                                                                                                         (continues on next page)</code></pre>
-<p>(continued from previous page)</p>
-<pre><code>Name
------
-main-hip-amdgcn-amd-amdhsa-gfx906.bc
-main-hip-amdgcn-amd-amdhsa-gfx906.hipi
-main-hip-amdgcn-amd-amdhsa-gfx906.o
-main-hip-amdgcn-amd-amdhsa-gfx906.out
-main-hip-amdgcn-amd-amdhsa-gfx906.out.resolution.txt
-main-hip-amdgcn-amd-amdhsa-gfx906.s</code></pre>
-<p>Files with the .s extension hold the disassembled contents of the binary and the filename directly informs us of the graphics IPs used by the compiler.</p>
-<pre><code>main-hip-amdgcn-amd-amdsha-gfx906.out
-main-hip-amdgcn-amd-amdsha-gfx906.out.resolution.txt
-main-hip-amdgcn-amd-amdsha-gfx906.s
-
-Files with the.s extension hold the disassembled contents of the binary and the filename directly informs us of the
-graphics IPs used by the compiler.
-
-Get-ChildItem main-hip-*.s | Get-Content
-           .text
-           .amdgcn_target "amdgcn-amd-amdsha--gfx906"
-           .protected        _Z12saxpy_kernelPKfPfj ; -- Begin  function _Z12saxpy_
-  --kernelPKfPfj
-           .glob1   _Z12saxpy_kernelPKfPfj
-           .p2align           8
-           .type     _Z12saxpy_kernelPKfPfj,@function
-_Z12saxpy_kernelPKfPfj:                                                                                                                                                                                                        
-  ; %bb.0:
-            s_load_dword s0, s[4:5], 0x4
-            s_load_dword s1, s[6:7], 0x18
-            s_waitcnt lgkmcnt(0)
-            s_and_b32 s0, s0, 0xffff
-            s_mul_i32 s8, s8, s0
-            v_add_u32_e32 v0, s8, v0
-            v_cmp_gt_u32_e32 vcc,  s1, v0
-            s_and_saveexec_b64 s[0:1], vcc
-            s_cbranch_execz.LBB0_2
-  ; %bb.1:
-            s_load_dwordx4 s[0:3], s[6:7], 0x8
-            v_mov_b32_e32 v1, 0
-            v_lshlrev_b64 v[0:1], 2, v[0:1]
-            s_waitcnt lgkmcnt(0)
-            v_mov_b32_e32 v3, s1
-            v_add_co_u32_e32 v2, vcc, s0, v0
-            v_addc_co_u32_e32 v3, vcc, v3, v1, vcc
-            global_load_dword v2, v[2:3], off
-            v_mov_b32_e32 v3, s3
-            v_add_co_u32_e32 v0, vcc, s2, v0
-            v_addc_co_u32_e32 v1, vcc, v3, v1, vcc
-            global_load_dword v3, v[0:1], off
-            s_load_dword s0, s[6:7], 0x0
-            s_waitcnt vmcnt(0) lgkmcnt(0)
-            v_fmac_f32_e32 v3, s0, v2
-            global_store_dword v[0:1], v3, off
- .LBB0_2:
-            s_endpgm
-           ...</code></pre>
-<h2>Windows and NVIDIA</h2>
-<p>Unlike HIP on AMD, when compiling using the NVIDIA support for HIP, the resulting binary will be a valid CUDA executable. Therefore, it'll incorporate PTX ISA (Parallel Thread eXecution Instruction Set Architecture) instead of AMDGPU binary. As a result, tooling included with the CUDA SDK can be used to inspect which device ISA was compiled into a specific executable. The most helpful to us currently is cuobjdump .</p>
-<pre><code><_Bash_></code></pre>
-<pre><code>| P T X \ f i l e</code></pre>
-<pre><code>1:  saxpy. 1. sm_5. ptx</code></pre>
-<p>This example shows that the SAXPY kernel is stored as sm_52 . It also shows that a compute capability 5.2 ISA was embedded into the executable, so devices that support compute capability 5.2 or newer will be able to run this code.</p>
-<p>Now that you've found what binary got embedded into the executable, find which format our available devices use.</p>
-<h2>Linux and AMD</h2>
-<p>On Linux a utility called rocminfo helps us list all the properties of the devices available on the system, including which version of graphics IP ( gfxXYZ ) they employ. You can filter the output to have only these lines:</p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?php?com/bin/rocminfo | grep gfx
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        </?php?com/bin/rocminfo | grep gfx
-                                                                                                                                                                                        
-	              Name:                                                                                                                                                                                                        &</code></pre>
-<p>Now that you know which graphics IPs our devices use, recompile your program with the appropriate parameters.</p>
-<pre><code>                                                                                                                                                                                                        |                                                                                                                                                                                                       
-                                                                                                                                                                                                        -                                                                                                                                                                                                        --                                                                                                                                                                                                        \                                                                                                                                                                                                        +                                                                                                                                                                                                        <                                                                                                                                                                                                        </                                                                                                                                                                                                        }                                                                                                                                                                                                        >                                                                                                                                                                                                        &                                                                                                                                                                                                        )                                                                                                                                                                                                        ]                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        :                                                                                                                                                                                                        ;                                                                                                                                                                                                       .                                                                                                                                                                                                        "</code></pre>
-<p>Now the sample will run.</p>
-<pre><code>        /saxpy
-        Calculating y[i] = a * x[i] + y[i] over 10000000 elements.
-        First 10 elements of the results: [ 3, 5, 7, 9, 11, 13, 15, 17, 19, 21 ]</code></pre>
-<pre><code><_Python_></code></pre>
-<h2>Linux and NVIDIA</h2>
-<p>On Linux HIP with the NVIDIA back-end, the deviceQuery CUDA SDK sample can help us list all the properties of the devices available on the system, including which version of compute capability a device sports. &lt;major&gt;.&lt;minor&gt; compute capability is passed to nvcc on the command-line as sm_&lt;major&gt;&lt;minor&gt; , for eg. 8.6 is sm_86 .</p>
-<p>Because it's not included as a binary, compile the matching example from ROCm.</p>
-<pre><code>                                                                                                                                                                                                        |                                                                                                                                                                                                       
-                                                                                                                                                                                                        <.02                                                                                                                                                                                                        </.00                                                                                                                                                                                                        >.00                                                                                                                                                                                                      <.00                                                                                                                                                                                                      </.01                                                                                                                                                                                                        }</code></pre>
-<p>Filter the output to have only the lines of interest, for example:</p>
-<pre><code><_YAML_></code></pre>
-<p>Note: In addition to the nvcc executable is another tool called __nvcc_device_query which prints the SM Architecture numbers to standard out as a comma separated list of numbers. The utility's name suggests it's not a user-facing executable but is used by nvcc to determine what devices are in the system at hand.</p>
-<p>Now that you know which graphics IPs our devices use, recompile your program with the appropriate parameters.</p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <_arch=sm_70,sm_86</code></pre>
-<p>Note: If you want to portably target the development machine which is compiling, you may specify -arch=native instead.</p>
-<p>Now the sample will run.</p>
-<pre><code>           ./saxpy
-            Calculating y[i] = a * x[i] + y[i] over 10000000 elements.
-            First 10 elements of the results: [ 3, 5, 7, 9, 11, 13, 15, 17, 19, 21 ]</code></pre>
-<h2>Windows and AMD</h2>
-<p>On Windows, a utility called hipInfo.exe helps us list all the properties of the devices available on the system, including which version of graphics IP ( gfxXYZ ) they employ. Filter the output to have only these lines:</p>
-<pre><code>& ${env:HIP_PATH}bin\hipInfo.exe | Select-String gfx
-
-gcnArchName:                    gfx1032
-gcnArchName:                    gfx1035</code></pre>
-<p>Now that you know which graphics IPs our devices use, recompile your program with the appropriate parameters.</p>
-<pre><code>                                                                                                                                                                                                        |clang++.\HIP-Basic\saxpy\main.hip -o saxpy.exe -I.\Common -lamdhip64 -L ${env:HIP_PATH}                                                                                                                                                                                                       
-                                                                                                                                                                                                        -lib -02 --offload-arch=gfx1032 --offload-arch=gfx1035                                                                                                                                                                                                        --lib -02 --offload-arch=gfx1035</code></pre>
-<p>Now the sample will run.</p>
-<pre><code>       .\saxpy.exe
-        Calculating y[i] = a * x[i] + y[i] over 10000000 elements.
-        First 10 elements of the results: [ 3, 5, 7, 9, 11, 13, 15, 17, 19, 21 ]</code></pre>
-<h2>Windows and NVIDIA</h2>
-<p>On Windows HIP with the NVIDIA back-end, the deviceQuery CUDASDKsample can help us list all the properties of the devices available on the system, including which version of compute capability a device sports. &lt;major&gt;. &lt;minor&gt; compute capability is passed to nvcc on the command-line as sm_&lt;major&gt;&lt;minor&gt; , for eg. 8.6 is sm_86 .</p>
-<p>Because it's not included as a binary, compile the matching example from ROCm.</p>
-<pre><code>                                                                                                                                                                                                        |nvcc.\HIP-Basic\device_query\main.cpp -o device_query.exe -I.\Common -I ${env:HIP_PATH}                                                                                                                                                                                                       
-                                                                                                                                                                                                        -include -02                                                                                                                                                                                                        --include -0022</code></pre>
-<p>Filter the output to have only the lines of interest, for example:</p>
-<pre><code> .\device_query.exe | Select-String "major.minor"
-
-  major.minor:              8.6
-  major.minor:              7.0</code></pre>
-<p>Note: Next to the nvcc executable is another tool called __nvcc_device_query.exe which simply prints the SM Architecture numbers to standard out as a comma separated list of numbers. The naming of this utility suggests it's not a user facing executable but is used by nvcc to determine what devices are in the system at hand.</p>
-<p>Now that you know which graphics IPs our devices use, recompile your program with the appropriate parameters.</p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        --x                                                                                                                                                                                                        -x</code></pre>
-<p>Note: If you want to portably target the development machine which is compiling, you may specify -arch=native instead.</p>
-<p>Now the sample will run.</p>
-<pre><code>       .\saxpy.exe
-        Calculating y[i] = a * x[i] + y[i] over 10000000 elements.
-        First 10 elements of the results: [ 3, 5, 7, 9, 11, 13, 15, 17, 19, 21 ]</code></pre>
-<pre><code><_Python_></code></pre>
-<h2>CHAPTER</h2>
-<h2>TWENTYNINE</h2>
-<h2>REDUCTION</h2>
-<p>Reduction is a common algorithmic operation used in parallel programming to reduce an array of elements into a shorter array of elements or a single value. This document exploits reduction to introduce some key considerations while designing and optimizing GPU algorithms.</p>
-<p>This document is a rejuvenation and extension of the invaluable work of Mark Harris. While the author approaches the topic with a less naive approach, reviewing some original material is valuable to see how much the underlying hardware has changed. This document provides a greater insight to demonstrate progress.</p>
-<h2>29.1 The algorithm</h2>
-<p>Reduction has many names depending on the domain; in functional programming it's referred to as fold, in C++, it's called std::accumulate and in C++17, as std::reduce . A reduction takes a range of inputs and 'reduces' the given range with a binary operation to a singular or scalar output. Canonically, a reduction requires a 'zero' element that bootstraps the algorithm and serves as one of the initial operands to the binary operation. The 'zero' element is generally called identity or neutral element in the group theory, which implies that it is an operand that doesn't change the result. Some typical use cases are: calculating a sum or normalizing a dataset and finding the maximum value in the dataset. The latter use case is discussed further in this tutorial.</p>
-<p>There are multiple variations of reduction that allow parallel processing. The approach taken by std::reduce requires the user-provided binary operator to operate on any combination of identity and input range elements, or even exclusively on any of them. This allows you to insert any number of identities to facilitate parallel processing and then combine the partial results of parallel execution.</p>
-<h2>29.2 Reduction on GPUs</h2>
-<p>Implementing reductions on GPUs requires a basic understanding of the /understand/programming_model_reference. The document explores aspects of low-level optimization best discussed through the Inherent thread model , and refrains from using cooperative groups.</p>
-<p>Synchronizing parallel threads of execution across a GPU is crucial for correctness as the partial results can't be synchronized before they manifest. Synchronizing all the threads running on a GPU at any given time is possible, however, it is a costly and intricate operation. If synchronization is not absolutely necessary, map the parallel algorithm so that multiprocessors and blocks can make independent progress and need not sync frequently.</p>
-<p>There are ten reduction implementations in the rocm-examples, which are described in the following sections.</p>
-<h2>29.2.1 Naive shared reduction</h2>
-<p>The naive algorithm takes a tree-like shape, where the computational domain is purposefully distributed among blocks. In all blocks, all threads participate in loading data from persistent (from the kernel's perspective) global memory into the shared memory. This helps to perform tree-like reduction for a single thread by writing the partial result to global, in a location unique to the block, which allows the block to make independent progress. The partial results are combined in subsequent launches of the same kernel until a scalar result is reached.</p>
-<p>This approach requires temporary storage based on the number of blocks launched, as each block outputs a scalar partial result. Depending on the need to store or destroy the input, a second temporary storage might be needed, which could be large enough to store the results of the second kernel launch. Alternatively, you can reuse the storage of the larger than necessary original input. These implementations differ so slightly that the document only considers the use case where the input could be destroyed.</p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <std::size_t factor = block_size; // block_size from hipGetDeviceProperties()
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        </std::endl;
-                                                                                                                                                                                                       <int>                                                                                                                                                                                                        //                                                                                                                                                                                                       	                                                                                                                                                                                                      
-//                                                                                                                                                                                                        +                                                                                                                                                                                                        -                                                                                                                                                                                                        *                                                                                                                                                                                                        /                                                                                                                                                                                                        */
-                                                                                                                                                                                                       +
-                                                                                                                                                                                                       *
-                                                                                                                                                                                                       -
-                                                                                                                                                                                                       */</code></pre>
-<p>For threads that don't have unique inputs, feed zero_elem instances to threads. The backing of double-buffering is allocated as such:</p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <void>                                                                                                                                                                                                        </void>                                                                                                                                                                                                     
- 
-                                                                                                                                                                                                      <void><void>                                                                                                                                                                                                      <void></void>                                                                                                                                                                                                     
-
- 
-                                                                                                                                                                                                     
- 
-
-                                                                                                                                                                                                      <void>"                                                                                                                                                                                                        >void>                                                                                                                                                                                                      </void></void>                                                                                                                                                                                                    <void> 
-                                                                                                                                                                                                      </void><void>                                                                                                                                                                                                    <void></void></void>                                                                                                                                                                                                   
-   
-                                                                                                                                                                                                    <void></code></pre>
-<p>Data is initialized on the host and dispatched to the device followed by the commencement of device-side reduction. The swapping of the double-buffer on the last iteration is omitted, therefore the result is in the back-buffer irrespective of the input size.</p>
-<pre><code>of the input size.
-
-for (uint32_t curr = input_count; curr > 1;)
-{
-      hipLaunchKernelGGL(
-           kernel,
-           dim3(new_size(curr)),
-           dim3(block_size),
-           factor * sizeof(unsigned),
-           hipStreamDefault,
-           front,
-           back,
-           kernel_op,</code></pre>
-<pre><code>1;)</code></pre>
-<p>(continues on next page)</p>
-<p>(continued from previous page)</p>
-<pre><code>        zero_elem,
-        curr);
-
-     curr = new_size(curr);
-     if (curr > 1)
-        std::swap(front, back);
-}</code></pre>
-<p>This structure persists in the kernel throughout all the variations of reduction with slight modifications to factor and shared memory allocation:</p>
-<pre><code><_Cuda_></code></pre>
-<p>While the tid % (2 * i) == 0 indexing scheme yields correct results, it also leads to high thread divergence. Thread divergence indicates the event when the threads in a warp diverge, which implies that the threads have to execute different instructions in a given clock cycle. This is easily manifested using if-else statements as shown here, but can also be manifested as for loop dependent on thread ID lengths. Even though the number of active threads participating in the reduction reduces, warps remain active longer than necessary, as at least one lane in a warp hits the if statement.</p>
-<h2>29.2.2 Reducing thread divergence</h2>
-<p>You can reduce divergence by keeping dataflow between memory addresses identical but reassigning the thread ids.</p>
-<pre><code>// Shared reduction
-for (uint32_t i = 1; i < blockDim.x; i *= 2)
-{
--    if (tid % (2 * i) == 0)
--        shared[tid] = op(shared[tid], shared[tid + i]);
-+    if (uint32_t j = 2 * i * tid; j < blockDim.x)
-+        shared[j] = op(shared[j], shared[j + i]);
-    __syncthreads();
-}</code></pre>
-<p>This way inactive threads start accumulating uniformly towards the higher thread ID index range and might uniformly skip to __syncthreads() . However, this introduces a bank conflicts issue.</p>
-<h2>29.2.3 Resolving bank conflicts</h2>
-<p>Both AMD and NVIDIA implement shared memory in the hardware by organizing storage into banks of various sizes. This hardware element is known as Local Data Share (LDS) on AMD hardware. On NVIDIA hardware, it's implemented using the same silicon as the L1 data cache. You can think of shared memory as a striped 2-dimensional range of memory. Shared memory bank's count, width, and depth depend on the architecture. A bank conflict occurs when different threads in a warp access the same bank during the same operation. In this case, the hardware prevents the attempted concurrent accesses to the same bank by converting them into serial accesses.</p>
-<ul>
-<li style="list-style-type: '· ';">'AMD Instinct MI200' Instruction Set Architecture, Chapter 11.1</li>
-<li style="list-style-type: '· ';">'RDNA 2' Instruction Set Architecture, Chapter 10.1</li>
-</ul>
-<p>A notable exception is when the shared read uniformly broadcasts to the same address across the entire warp. A better implementation of the naive algorithm is to form continuous ranges of the threads activities and their memory accesses.</p>
-<pre><code>
-        implementation of the naive algorithm is to form continuous ranges of the threads activ
-        
-        // Shared reduction
-        -for (uint32_t i = 1; i < blockDim.x; i *= 2)
-        -{
-        -                                                                                                                                                                                                        
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        -f                                                                                                                                                                                                        +f</code></pre>
-<p>Note: To avoid bank conflicts, read shared memory in a coalesced manner, which implies that reads/writes of each lane in a warp evaluate to consecutive locations. Analyzing the read/write patterns could help you to understand the cause of bank conflicts. For more details, check CDNA3 ISA or RDNA3 ISA data share operations chapter.</p>
-<h2>29.2.4 Utilize upper half of the block</h2>
-<p>The preceding implementation is free of low-level GPU-specific anti-patterns. However, it still exhibits some common shortcomings. The loop performing the reduction in the shared memory starts from i = blockDim.x / 2 and the first predicate if (tid &lt; i) immediately disables half of the block, which only helps load the data into the shared memory. You can change the kernel along with the calculation of factor on the host, as shown here:</p>
-<pre><code><_Cuda_></code></pre>
-<p>By eliminating half of the threads and giving meaningful work to all the threads by unconditionally performing a binary op , you can prevent the wastage of half of the threads.</p>
-<p>Even though global memory is read in a coalesced fashion, as preferred by the memory controller, optimal performance is still limited by the instruction throughput. Omit superfluous synchronization -----------</p>
-<p>Warps are known to execute in a strict lockstep fashion. Therefore, once shared reduction reaches a point where only a single warp participates meaningfully, you can cut short the loop and let the rest of the warps terminate. Moreover, you can also unroll the loop without syncing the entire block.</p>
-<p>The tmp namespace used beyond this point in this document holds a handful of template meta-programmed utilities to facilitate writing flexible and optimal code.</p>
-<p>tmp::static_for is not just a constant folding within the optimizer but a variation of the language for loop, where the running index is a compile-time constant and is eligible for use in compile-time evaluated contexts.</p>
-<p>Consider the following code:</p>
-<pre><code>constexpr int size = 4;
-for (int i = 0 ; i < size ; ++i)
-{
-    printf("%d", i);
-}</code></pre>
-<p>This compiles to the following binaries:</p>
-<h2>LLVM Block</h2>
-<pre><code>LLVM Block
-main:
-    push    rbx
-    lea      rbx, [rip +.L.str]
-    mov     rdi, rbx
-    xor     esi, esi
-    xor     eax, eax
-    call    printf@PLT
-    mov     rdi, rbx
-    mov     esi, 1
-    xor     eax, eax
-    call    printf@PLT
-    mov     rdi, rbx</code></pre>
-<p>(continues on next page)</p>
-<pre><code>      mov     esi, 2
-      xor     eax, eax
-      call    printf@PLT
-      mov     rdi, rbx
-      mov     esi, 3
-      xor     eax, eax
-      call    printf@PLT
-      xor     eax, eax
-      pop     rbx
-      ret
-.L.str:
-     .asciz  "%d"
-      
- GCC</code></pre>
-<h2>GCC</h2>
-<pre><code>  GCC
- .LC0:
-     .string "%d"
-  main:
-      push    rbx
-      xor     ebx, ebx
- .L2:
-      mov     esi, ebx
-      mov     edi, 0FFSET FLAT:.LC0
-      xor     eax, eax
-      add     ebx, 1
-      call    printf
-      cmp     ebx, 4
-      jne    .L2
-      xor     eax, eax
-      pop     rbx
-      ret
-
-  MSVC</code></pre>
-<h2>MSVC</h2>
-<pre><code>  MSVC
-
-main     PROC
-      $LN12:
-      push    rbx
-      sub     rsp, 32
-      xor     ebx, ebx
-      npad    8
-  $LL4@main:
-      mov     edx, ebx
-      lea     rcx, OFFSET FLAT:'string'
-      call    printf
-      inc     ebx
-      cmp     ebx, 4
-      jl      SHORT $LL4@main
-      xor     eax, eax
-      add     rsp, 32
-      pop     rbx
-      ret     0
-  main    ENDP</code></pre>
-<p>(continued from previous page)</p>
-<p>LLVM unrolls the loop and compiles to a flat series of printf invocations, while both GCC and MSVC keep the loop intact, as visible from the compare ( cmp ) and the jump ( jne , jl ) instructions. LLVM code generation is identical to manually writing the unrolled loop:</p>
-<pre><code>printf("%d", 0);
-printf("%d", 1);
-printf("%d", 2);
-printf("%d", 3);</code></pre>
-<p>While various non-standard pragmas are available to hint or force the compiler to unroll the loop, we instead use template meta-programming to force feed the compiler the unrolled loop.</p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?xml version="1.0" encoding="UTF-8" />
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        </?xml version="1.0" encoding="UTF-8" /></code></pre>
-<p>The most notable structural difference is that in the language for loop, the loop variable is given a name in the beginning, while in the static_for utility, the loop variable is given a name in the end. An important bonus is that in the loop's body, you can use the running index i in contexts requiring constant expressions such as template arguments or inside if constexpr .</p>
-<p>tmp::static_switch takes runtime value and runtime dispatches to a range of set of tabulated functions, where said value is a compile-time constant and is eligible for use in compile-time evaluated contexts.</p>
-<p>Consider the following code:</p>
-<pre><code>        Consider the following code:
-
-        int  warp_size  = device_props.warpSize;
-
-        switch  (warp_size)
-
-        {
-
-        case  32:
-
-            hipLaunchKernelGGL(kernel<32>, ...);
-
-            break;
-
-        case  64:
-
-            hipLaunchKernelGGL(kernel<64>, ...);
-
-            break;
-
-        }</code></pre>
-<p>In the preceding code, note the code repetition for all possible values of warp_size , the code is prepared to handle. To avoid this, use tmp::static_switch , as shown:</p>
-<pre><code>  tmp::static_switch<std::array{32, 64}>(warp_size, [&]<int WarpSize>
-  {
-      hipLaunchKernelGGL(kernel<WarpSize>,...);
-  });</code></pre>
-<pre><code>
-t WarpSize>()</code></pre>
-<pre><code>
-        HIP Documentation, Release 6.1.40092
-
-
-        
-        -template<typename T, typename F>
-        +template<uint32_t WarpSize, typename T, typename F>
-        __global__ void kernel(
-           ...
-        )
-        {
-           ...
-        // Shared reduction
-        -for (uint32_t i = blockDim.x / 2; i!= 0; i /= 2)
-        +for (uint32_t i = blockDim.x / 2; i > WarpSize; i /= 2)
-        {
-            if (tid < i)
-                shared[tid] = op(shared[tid], shared[tid + i]);
-            __syncthreads();
-        }
-        +// Warp reduction
-        +tmp::static_for<WarpSize, tmp::not_equal<0>, tmp::divide<2>>([&]<int I>()
-        +{
-        +     if (tid < I)
-        +          shared[tid] = op(shared[tid], shared[tid + I]);
-        +#ifdef __HIP_PLATFORM_NVIDIA__
-        +     __syncwarp(0xffffffff >> (WarpSize - I));
-        +#endif
-        +});
-
-        Because HIP typically targets hardware with warp sizes of 32(NVIDIA GPUs and RDNA AMD GPUs) and 64 (CD!
-        AMD GPUs), portable HIP code must handle both. That is why instead of assuming a warp size of 32, make the w:
-        size a template argument of the kernel. This allows you to unroll the final loop using tmp::static_for in a paramet</code></pre>
-<p>Because HIP typically targets hardware with warp sizes of 32 (NVIDIA GPUs and RDNA AMD GPUs) and 64 (CDNA AMDGPUs), portable HIP code must handle both. That is why instead of assuming a warp size of 32, make the warp size a template argument of the kernel. This allows you to unroll the final loop using tmp::static_for in a parametric way but still having the code read much like an ordinary loop.</p>
-<p>Promoting the warp size to being a compile-time constant also requires you to handle it similarly on the host-side. You can sandwich the kernel launch with tmp::static_switch , promoting the snake-case run-time warp_size variable to a camel-case compile-time constant WarpSize .</p>
-<pre><code><_C++_></code></pre>
-<p>Note: Neither RDNA- nor CDNA-based AMD hardware provides guaranteed independent progress to lanes of the same warp. When targeting NVIDIA hardware, lanes of a warp might execute somewhat independently as long as the programmer assists the compiler using dedicated built-in functions. This feature is called Independent Thread Scheduling. The HIP headers don't expose the necessary warp primitives and their overloads.</p>
-<p>Portable applications can still tap into this feature with carefully #ifdef -ed code, but at this particular optimization level, it's a requirement. The code implicitly relies on the lockstep behavior of an ROCm wavefront, but CUDA warps don't share this property. You must synchronize all the active lanes of a warp to avoid a data race with some lanes progressing faster than others in the same warp.</p>
-<h2>29.2.5 Unroll all loops</h2>
-<p>While the previous step primarily aims to remove unnecessary syncing, it also unrolls the end of the loop. However, you could also force unrolling the first part of the loop. This saves a few scalar registers (values the compiler can prove to be uniform across warps).</p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <Linear                                                                                                                                                                                                        </Linear                                                                                                                                                                                                      <Linar                                                                                                                                                                                                        >                                                                                                                                                                                                        &Linear                                                                                                                                                                                                     
- 
-                                                                                                                                                                                                      <Lin                                                                                                                                                                                                        +                                                                                                                                                                                                        -                                                                                                                                                                                                        |                                                                                                                                                                                                        }                                                                                                                                                                                                        \
-                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       <L                                                                                                                                                                                                        1                                                                                                                                                                                                        0</code></pre>
-<p>Introducing yet another template argument for the kernel and moving from for to tmp::static_for leads to the following two notable improvements:</p>
-<ul>
-<li style="list-style-type: '· ';">Introducing new attribute __launch_bounds__(BlockSize) to the kernel instructs the compiler that the kernel will only be launched using the designated block size. This implies that the launches of differing block sizes will fail. This allows the optimizer to enroll the blockDim.x variable in constant folding as well as get information about register usage.</li>
-<li style="list-style-type: '· ';">Turning the block size into a compile-time constant allows you to statically allocate the shared memory.</li>
-</ul>
-<h2>29.2.6 Communicate using warp-collective functions</h2>
-<p>Shared memory provides a fast communication path within a block, however when performing reduction within the last warp, you can use faster means of communication, which is warp-collective or cross-lane functions. Instead of using the hardware-backed shared memory, you can directly copy between the local memory (registers) of each lane in a warp. This can be achieve using the shuffle functions.</p>
-<p>See how to use __shfl_down() , which is one of the most restrictive but also the most structured communication schemes.</p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        // Warp reduction</code></pre>
-<p>Using warp-collective functions for communication requires the control flow to be uniform across warps, as the name warp-collective implies. Therefore, you can see that the thread ID is being checked outside the loop, but the result is written inside due to variable scoping.</p>
-<h2>29.2.7 Prefer warp communication over shared</h2>
-<p>As mentioned in the previous step, communication between local memory is faster than shared memory. Instead of relying on the local memory only at the end of the tree-like reduction, a better approach is to turn the tree reduction inside out and perform multiple warp reductions in parallel on all active threads, thus communicating only their partial results through the shared memory.</p>
-<p>The kernel versions differ significantly enough to be described using a diff; use afresh instead.</p>
-<pre><code>        The kernel versions differ significantly enough to be described using a diff; use afresh instead.
-
-        template<uint32_t BlockSize,  uint32_t WarpSize,  typename  T,  typename  F>
-        __global__ __launch_bounds__(BlockSize)  void kernel(
-            T*  front,
-            T*  back,
-            F  op,
-            T zero_elem,
-            uint32_t  front_size)
-        {
-            // ...
-        }
-
-        The kernel estimate and the reduction factor as the comma as in variance access only the imlamantation diffar.</code></pre>
-<p>The kernel signature and the reduction factor are the same as in previous cases; only the implementation differs.</p>
-<pre><code>static constexpr uint32_t WarpCount = BlockSize / WarpSize;
-
-__shared__ T shared[WarpCount];
-
-auto read_global_safe =
-    [&](const uint32_t i) { return i < front_size? front[i] : zero_elem; };
-auto read_shared_safe =
-    [&](const uint32_t i) { return i < WarpCount? shared[i] : zero_elem; };
-
-const uint32_t tid = threadIdx.x,
-                     bid = blockIdx.x,
-                     gid = bid * (blockDim.x * 2) + tid,
-                     wid = tid / WarpSize,
-                     lid = tid % WarpSize;
-
-// Read input from front buffer to local
-T res = op(read_global_safe(gid), read_global_safe(gid + blockDim.x));
-
-As we communicate the results of warps through shared memory, the same number of elements are required in the
-shared memory as warps within the block. Similar to how you can only launch kernels at block granularity. you can</code></pre>
-<p>As we communicate the results of warps through shared memory, the same number of elements are required in the shared memory as warps within the block. Similar to how you can only launch kernels at block granularity, you can only warp reduce with WarpSize granularity due to the collective nature of the cross-lane builtins. To address this, you can use read_shared_safe to pad overindexing by reading zero_elem . Reading from global remains unaffected. // Perform warp reductions and communicate results via shared // for (uint32_t ActiveWarps = WarpCount; // ActiveWarps != 0; // ActiveWarps = ActiveWarps != 1 ? // divide_ceil(ActiveWarps, WarpSize) : // ActiveWarps = 0) tmp::static_for&lt; WarpCount, tmp::not_equal&lt;0&gt;, tmp::select&lt; tmp::not_equal&lt;1&gt;, tmp::divide_ceil&lt;WarpSize&gt;, tmp::constant&lt;0&gt;&gt;&gt;([&amp;]&lt; uint32_t ActiveWarps&gt;() { if (wid &lt; ActiveWarps) { // Warp reduction tmp::static_for&lt;WarpSize / 2, tmp::not_equal&lt;0&gt;, tmp::divide&lt;2&gt;&gt;([&amp;]&lt; int Delta&gt;() { res = op(res, __shfl_down(res, Delta)); }); // Write warp result from local to shared if (lid == 0) shared[wid] = res; } __syncthreads(); // Read warp result from shared to local res = read_shared_safe(tid); (continues on next page)</p>
-<p>(continued from previous page)</p>
-<pre><code>});
-
-// Write result from local to back buffer
-if(tid == 0)
-    back[bid] = res;</code></pre>
-<p>ActiveWarps iterates from WarpCount until it reaches 0 . Every iteration of ActiveWarps reduces the WarpSize . In cases where the partial result count isn't a divisor of ActiveWarps and you need to launch an extra warp, use tmp::divide_ceil , which always rounds to positive infinity. The tertiary tmp::select is required because such division never reaches 0 , so you must terminate the loop after the last warp concludes.</p>
-<p>In each iteration, if the warp is active, which means it has at least a single valid input, it carries out a pass of warp reduction and writes output based on warp ID. Reading is carried out based on thread ID. Global output continues to be based on block ID.</p>
-<h2>29.2.8 Amortize bookkeeping variable overhead</h2>
-<p>The previous sections explained how to reduce register usage to improve occupancy. This allows more blocks to execute in parallel on all multiprocessors, leading to more global store/load latency to be hidden. Reducing the number of kernels in flight while still carrying out the same workload reduces the wastage of registers while loading and maintaining bookkeeping variables such as kernel indices.</p>
-<p>An example of this optimization is performing one binary op while loading input from global. Even though the operation is said to be carried out 'in flight', the two values are loaded into local memory (registers) before op is called.</p>
-<p>Amore general form of this optimization is wrapping most kernel logic in loops that carry out the workload of multiple kernel instances but require storing only a single instance of most of the bookkeeping logic. In code, this multiplicity factor is referred to via the ItemsPerThread compile-time constant, which is supplied by a template argument to allow for loop unrolling.</p>
-<p>This kernel variant utilizes another generally applicable utility known as hip::static_array , which is a more restrictive wrapper over the builtin array than std::array , as it allows indexing only compile-time constants using the usual tuple-like template &lt;size_t I&gt; auto get&lt;I&gt;(...) interface.</p>
-<p>Note: On a GPU, there is no stack, and the local memory is provisioned from the register file. This provisioning takes place statically. To paraphrase, the address range of a thread's local memory is determined at compile-time. When an array is defined and used in the local storage, the compiler can only maintain its storage in the register file as long as all accesses to the array are computable by the compiler at compile-time. It doesn't need to be a compile-time constant as long as the compiler can resolve the addresses of the accesses through constant folding or some other means. If the compiler fails to do so, the array will be backed by global memory, which is indicated by allocating a non-zero number of spill registers observable using static analysis tools. However, this is slower by the magnitude of multiple order. hip::static_array via its hip::get&lt;&gt; interface ensures that no such spills occur.</p>
-<pre><code>_t  ItemsPerThread></code></pre>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        --global__ static __launch_bounds__(BlockSize) void kernel(...)</code></pre>
-<p>The kernel now has three compile-time configurable parameters. The only part of the kernel that changes depends on how you load data from global and perform the binary operation on those loaded values. So, the following step to read input from front buffer to global is now split into two steps: reading ``ItemsPerThread` &lt;reading-items&gt;`and processing ``ItemsPerThread` &lt;processing-items&gt;`.</p>
-<pre><code><_C_></code></pre>
-<h2>29.2.8.1 Reading ItemsPerThread</h2>
-<p>The change to reading happens inside read_global_safe :</p>
-<pre><code>        The change to reading happens inside read_global_safe:
-        auto  read_global_safe = [&](const  int32_t  i)  -> hip::static_array<T,  ItemsPerThread>
-        {
-            return  [&]<int32_t...  I>(std::integer_sequence<int32_t,  I...>)
-            {
-                if(i + ItemsPerThread < front_size)
-                        return hip::static_array<T,  ItemsPerThread>{
-                              front[i + I]...
-                        };
-                else
-                        return hip::static_array<T,  ItemsPerThread>{
-                              (i + I < front_size? front[i + I] : zero_elem)...
-                        };
-            }(std::make_integer_sequence<int32_t,  ItemsPerThread>());
-        };
-
-        Note that each array element is being loaded consecutively without the flexibility of a configurable ItemsPerThread</code></pre>
-<p>Note that each array element is being loaded consecutively without the flexibility of a configurable ItemsPerThread property. This is morally equivalent to:</p>
-<pre><code>T arr[4] = {
-    front[gid + 0],
-    front[gid + 1],
-    front[gid + 2],
-    front[gid + 3]
-}</code></pre>
-<p>This is exactly what's happening in the front[i + I]... fold-expression. However, this can only be issued if the entire read operates on real input without padding using zero_elem . If some reads over-index the input, the read turns into:</p>
-<pre><code>T arr[4] = {
-    i + 0 < front_size? front[i + 0] : zero_elem,
-    i + 1 < front_size? front[i + 1] : zero_elem,
-    i + 2 < front_size? front[i + 2] : zero_elem,
-    i + 3 < front_size? front[i + 3] : zero_elem
-}</code></pre>
-<p>This makes it easier for the compiler to recognize vector loads from global. As the performance at large is dominated by how you move the data, it's only natural to utilize dedicated instructions to move more data with less binary. This is evident by the huge performance improvement when loading two values per thread. For more information, see the compiler explorer to learn how loading for AMD (both RDNA and CDNA) compiles to global_load_dwordx4 , where x4 denotes the 4-vector variant of the instruction.</p>
-<p>Note: Note that read_global_safe , which used to take an uint32_t as the index type, now takes a signed integer. When indexing an array with unsigned integers, the compiler has to handle integer overflows, as the C/C++ standards defined them. It might happen that some part of the vector load indices overflow, thus resulting in a non-contiguous</p>
-<p>read. If you change the previously linked code to use an unsigned integer as the thread ID, the compiler won't emit a vector load. Signed integer overflow is an undefined behavior, and hence, unknown to the optimizer. To convey the absence of overflow to the compiler with unsigned indices, add __builtin_assume(gid + 4 &gt; gid) , or the more portable [[assume]](gid + 4 &gt; gid) , once amdclang++ supports it.</p>
-<p>read_global_safe implementation is an Immediately Invoked Lambda Expression (IILE), because ItemsPerThread is an integer value, while you need a compile-time iota -like sequence of integers as a pack for the fold-expressions to expand on. This can only occur as part of template argument deduction on the IILE.</p>
-<h2>29.2.8.2 Processing ItemsPerThread</h2>
-<p>Once the kernel reads ItemsPerThread number of inputs to local, it immediately reduces them to a scalar. There is no reason to propagate the input element multiplicity to the warp reduction phase.</p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?>                                                                                                                                                                                                        </?></code></pre>
-<h2>29.2.9 Two-pass reduction</h2>
-<p>Alter kernel launch and input fetching such that no more blocks are launched than what a subsequent kernel launch's single block can conveniently reduce, while performing multiple passes of input reading from global and combining their results before engaging in the end game tree-like reduction.</p>
-<p>With this method, you can save at least one to two kernel launches for large inputs.</p>
-<h2>29.2.10 Global data share</h2>
-<p>Warning: This modification can only be executed on AMD hardware.</p>
-<p>Perform the first step of the two-pass reduction, but in the end, instead of writing to global and reading it back in a subsequent kernel, write the partial results to the Global Data Share (GDS). This is an N+1 th shared memory that is accessed by all multiprocessors and is also on-chip memory.</p>
-<p>Note: The API doesn't guarantee the order in which blocks are scheduled even though all GPUs schedule them in the same monotonically increasing order of block ids. Relying on this implicitly, the last block of a grid is in the optimal position to observe the side effects of all other blocks (using spinlocks or other methods) without occupying a multiprocessor for longer than necessary.</p>
-<p>Without launching a second kernel, you can make the last block collect the results of all other blocks from GDS by implicitly exploiting the scheduling behavior or relying on another AMD-specific feature called Global Wave Sync (GWS) to merge them for a final tree-like reduction.</p>
-<p>Note: GDS and GWS are reserved runtime features that the HIP API doesn't cover. Invoking these functionalities requires inline AMDGCN assembly. Moreover, the fact that the runtime doesn't virtualize the GDS, imposes further restrictions on concurrent scheduling of other kernels.</p>
-<h2>29.3 Conclusion</h2>
-<p>Optimizing code on GPUs, like on any other architecture, requires careful consideration and balancing of resources and costs of various operations to obtain optimal performance. This document explored optimizing reductions much beyond the territory of diminishing returns. This approach introduced multiple optimization techniques and discussed opportunities.</p>
-<p>The document focused on reductions when an entire device participates in it. Still, the choice of optimal compile-time constants or even the algorithm itself might not be optimal when its multiple blocks participate in multiple parallel reductions or when each thread performs its reduction. However, when multiple devices participate in the same reduction, other aspects must be considered.</p>
-<p>Most solutions, including the ones covered in this document, are given to the end users in a turnkey fashion via algorithm primitive libraries. These solutions might not be the fastest in all cases, but they are close to being the gold standard for carrying out certain operations as reasonably as possible.</p>
-<p>CHAPTER</p>
-<h2>THIRTY</h2>
-<h2>COOPERATIVE GROUPS</h2>
-<p>This tutorial demonstrates the basic concepts of cooperative groups in the HIP (Heterogeneous-computing Interface for Portability) programming model and the most essential tooling supporting it. This topic also reviews the commonalities of heterogeneous APIs. Familiarity with the C/C++ compilation model and the language is assumed.</p>
-<h2>30.1 Prerequisites</h2>
-<p>To follow this tutorial, you'll need properly installed drivers and a HIP compiler toolchain to compile your code. Because ROCm HIP supports compiling and running on Linux and Microsoft Windows with AMD and NVIDIA GPUs, review the HIP development package installation before starting this tutorial. For more information, see Install HIP .</p>
-<h2>30.2 Simple HIP Code</h2>
-<p>To become familiar with heterogeneous programming, review the SAXPY tutorial and the first HIP code subsection. Compiling is also described in that tutorial.</p>
-<h2>30.3 Tiled partition</h2>
-<p>You can use tiled partition to calculate the sum of partition_size length sequences and the sum of result_size / BlockSize length sequences. The host-side reference implementation is the following:</p>
-<pre><code>    You can use ued partition to calculate the sum or partition_size length sequences and the sum or result_size/
-    BlockSize length sequences. The host-side reference implementation is the following:
-    
-    // Host-side function to perform the same reductions as executed on the GPU
-    std::vector<unsigned int> ref_reduced(const unsigned int          partition_size,
-                                                   std::vector<unsigned int> input)
-    {
-        const unsigned int          input_size  = input.size();
-        const unsigned int          result_size = input_size / partition_size;
-        std::vector<unsigned int> result(result_size);
-
-        for(unsigned int i = 0; i < result_size; i++)
-        {
-            unsigned int partition_result = 0;
-            for(unsigned int j = 0; j < partition_size; j++)
-            {
-                partition_result += input[partition_size * i + j];
-            }
-                                                                                                                                                                                                         (continues on next page)</code></pre>
-<p>(continues on next page)</p>
-<pre><code>            result[i] = partition_result;
-        }
-
-        return result;
-    }</code></pre>
-<h2>30.3.1 Device-side code</h2>
-<p>To calculate the sum of the sets of numbers, the tutorial uses the shared memory-based reduction on the device side. The warp level intrinsics usage is not covered in this tutorial, unlike in the reduction tutorial. x input variable is a shared pointer, which needs to be synchronized after every value change. The thread_group input parameter can be thread_block_tile or thread_block because the thread_group is the parent class of these types. The val are the numbers to calculate the sum of. The returned results of this function return the final results of the reduction on thread ID 0 of the thread_group , and for every other thread, the function results are 0.</p>
-<pre><code>        The warp level intrinsics usage is not covered in this tutorial, unlike in the reduction tutorial. x input variable is a
-        shared pointer, which needs to be synchronized after every value change. The thread_group input parameter can be
-        thread_block_tile or thread_block because the thread_group is the parent class of these types. The val are
-        the numbers to calculate the sum of. The returned results of this function return the final results of the reduction on
-        thread ID 0 of the thread_group, and for every other thread, the function results are 0.
-
-        /// \brief Summation of `unsigned int val`s in `thread_group g` using shared memory `x`
-        __device__ unsigned int reduce_sum(thread_group g, unsigned int* x, unsigned int val)
-    {
-            // Rank of this thread in the group
-            const unsigned int group_thread_id = g.thread_rank();
-
-            // We start with half the group size as active threads
-            // Every iteration the number of active threads halves, until we processed all values
-            for(unsigned int i = g.size() / 2; i > 0; i /= 2)
-            {
-                // Store value for this thread in a shared, temporary array
-                x[group_thread_id] = val;
-
-                // Synchronize all threads in the group
-                g.sync();
-
-                // If our thread is still active, sum with its counterpart in the other half
-                if(group_thread_id < i)
-                {
-                    val += x[group_thread_id + i];
-                }
-
-                // Synchronize all threads in the group
-                g.sync();
-            }
-
-            // Only the first thread returns a valid value
-            if(g.thread_rank() == 0)
-                return val;
-            else
-                return 0;
-    }
-
-        The reduce_sum device function is reused to calculate the block and custom partition sum of the input numbers. The
-        kernel has three sections:
-
-        1. Initialization of the reduction function variables.</code></pre>
-<p>The reduce_sum device function is reused to calculate the block and custom partition sum of the input numbers. The kernel has three sections:</p>
-<ol>
-<li style="list-style-type: '1. ';">Initialization of the reduction function variables.</li>
-</ol>
-<p>(continued from previous page)</p>
-<ol>
-<li style="list-style-type: '2. ';">The reduction of thread block and store the results in global memory.</li>
-<li style="list-style-type: '3. ';">The reduction of custom partition and store the results in global memory.</li>
-</ol>
-<h2>30.3.1.1 1. Initialization of the reduction function variables</h2>
-<p>In this code section, the shared memory is declared, the thread_block_group and custom_partition are defined, and the input variables are loaded from global memory.</p>
-<pre><code>
-
-in this code section, the shared memory is declared, the thread_block_group and custom_partition are define
-input variables are loaded from global memory.
-
-// threadBlockGroup consists of all threads in the block
-thread_block thread_block_group = this_thread_block();
-
-// Workspace array in shared memory required for reduction
-__shared__ unsigned int workspace[2048];
-
-unsigned int output;
-
-// Input to reduce
-const unsigned int input = d_vector[thread_block_group.thread_rank()];
-
-//...
-
-// Every custom_partition group consists of 16 threads
-thread_block_tile<PartitionSize> custom_partition
-           = tiled_partition<PartitionSize>(thread_block_group);
-
-
-
-as a 2 - 2 The read-line of thread block</code></pre>
-<h2>30.3.1.2 2. The reduction of thread block</h2>
-<p>In this code section, the sum is calculated on thread_block_group level, then the results are stored in global memory.</p>
-<pre><code>// Perform reduction
-output = reduce_sum(thread_block_group, workspace, input);
-
-// Only the first thread returns a valid value
-if(thread_block_group.thread_rank() == 0)
-{
-    d_block_reduced_vector[0] = output;
-}</code></pre>
-<h2>30.3.1.3 3. The reduction of custom partition</h2>
-<p>In this code section, the sum is calculated on the custom partition level, then the results are stored in global memory. The custom partition is a partial block of the thread block, it means the reduction calculates on a shorter sequence of input numbers than at the thread_block_group case.</p>
-<pre><code>                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        // Perform reduction                                                                                                                                                                                                        }
-                                                                                                                                                                                                      
-output = reduce_sum(custom_partition, &workspace[group_offset], input);
-
-                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       // Only the first thread in each partition returns a valid value                                                                                                                                                                                                        \
-                                                                                                                                                                                                       \
-
-                                                                                                                                                                                                       \</code></pre>
-<p>(continued from previous page)</p>
-<pre><code>        const unsigned int partition_id           = thread_block_group.thread_rank() /\__
-        ~PartitionSize;
-        d_partition_reduced_vector[partition_id] = output;
-    }</code></pre>
-<h2>30.3.2 Host-side code</h2>
-<p>On the host-side, the following steps are done in the example:</p>
-<ol>
-<li style="list-style-type: '1. ';">Confirm the cooperative group support on AMD GPUs.</li>
-<li style="list-style-type: '2. ';">Initialize the cooperative group configuration.</li>
-<li style="list-style-type: '3. ';">Allocate and copy input to global memory.</li>
-<li style="list-style-type: '4. ';">Launch the cooperative kernel.</li>
-<li style="list-style-type: '5. ';">Save the results from global memory.</li>
-<li style="list-style-type: '6. ';">Free the global memory.</li>
-</ol>
-<p>Only the first, second and fourth steps are important from the cooperative groups aspect, that's why those steps are detailed further.</p>
-<h2>30.3.2.1 1. Confirm the cooperative group support on AMD GPUs</h2>
-<p>Not all AMD GPUs support cooperative groups. You can confirm support with the following code:</p>
-<pre><code><_C++_></code></pre>
-<h2>30.3.2.2 2. Initialize the cooperative group configuration</h2>
-<p>In the example, there is only one block in the grid, and the threads_per_block must be dividable with partition_size .</p>
-<pre><code><_C_></code></pre>
-<h2>30.3.2.3 4. Launch the kernel</h2>
-<p>The kernel launch is done with the hipLaunchCooperativeKernel of the cooperative groups API.</p>
-<pre><code>        The kernel launch is done with the hipLaunchCooperativeKernel of the cooperative groups API.
-        void* params[] = {&d_vector,  &d_block_reduced,  &d_partition_reduced};
-        // Launching kernel from host.
-        HIP_CHECK(hipLaunchCooperativeKernel(vector_reduce_kernel<partition_size>,</code></pre>
-<h2>30.4 Conclusion</h2>
-<p>With cooperative groups, you can easily use custom partitions to create custom tiles for custom solutions. You can find the complete code at cooperative groups ROCm example.</p>
-<h2>CHAPTER</h2>
-<h2>THIRTYONE</h2>
-<h2>LICENSE</h2>
-<p>Copyright © 2008 - 2024 Advanced Micro Devices, Inc.</p>
-<p>Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:</p>
-<p>The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.</p>
-<p>THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.</p>
-<h2>INDEX</h2>
-<table><tbody><tr><td>C</td><td>hipArrayCreate ( C++ function ), 183</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>cooperative_groups::coalesced_group class ), 237</td><td>C++ hipArrayDestroy ( C++ function ), 183 hipArrayGetDescriptor ( C++ function ), 185 ( C++ function ), 185</td><td>(</td><td></td><td></td><td></td><td></td></tr><tr><td>cooperative_groups::grid_group ( C++ class ), 234</td><td>hipArrayGetInfo hipCreateSurfaceObject ( C++ function ), 133</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>cooperative_groups::multi_grid_group ( C++</td><td>( C++ function ), 197</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>class ), 234 cooperative_groups::thread_block ( C++</td><td>), hipDestroyExternalMemory ( C++ function ), 196</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>class 234</td><td>hipDestroyExternalSemaphore hipDestroySurfaceObject ( C++ function ), 133 C++ function</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>cooperative_groups::thread_block_tile ( C++ class ), 234</td><td>hipDeviceCanAccessPeer ( ), 163 hipDeviceDisablePeerAccess ( C++ function ), 164 ( C++ function ), 163</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>cooperative_groups::thread_block_tile::all ( C++ function ), 236 cooperative_groups::thread_block_tile::any</td><td>hipDeviceEnablePeerAccess hipDeviceGetStreamPriorityRange ( C++ function ), 148</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>( C++ function ), 236</td><td>hipDrvMemcpy3D ( C++ function ), 192</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>cooperative_groups::thread_block_tile::ballot</td><td>hipDrvMemcpy3DAsync ( C++ function ), 192</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>hipDrvPointerGetAttributes ( C++ function ), 166</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>( C++ function ), 236</td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>cooperative_groups::thread_block_tile::match_all</td><td>hipExternalMemoryGetMappedBuffer ( C++ func- tion ), 196</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>( C++ function ), 237 cooperative_groups::thread_block_tile::match_any</td><td>hipExternalMemoryGetMappedMipmappedArray ( C++ function ), 197 hipExtMallocWithFlags ( C++ function ), 167</td><td></td><td>236</td><td>( ),</td><td>C++</td><td>function</td></tr><tr><td>cooperative_groups::thread_block_tile::meta_group_rank ( C++ function ), 235</td><td>hipExtStreamCreateWithCUMask ( C++function ), 151 hipExtStreamGetCUMask ( C++ function ), 152</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>hipFree ( C++ function ), 171 hipFreeArray ( C++ function ), 184</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>cooperative_groups::thread_block_tile::meta_group_size ( C++ function ), 235</td><td>hipFreeAsync</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>cooperative_groups::thread_block_tile::shfl ( C++ function ), 235</td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>( C++ function ), 154</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>cooperative_groups::thread_block_tile::shfl_down</td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>( C++ function ), 235</td><td>hipFreeHost ( C++ function ), 172 hipGetProcAddress ( C++ function ), 176</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>cooperative_groups::thread_block_tile::shfl_up</td><td>hipGetSymbolAddress ( C++ function ), 176, 193 ( C++ function ), 176, 193</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>( C++ function ), 235</td><td>hipHostAlloc ( C++ function ), 168 hipHostFree ( C++ function ), 172</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>( C++ function ), 236</td><td>( C++ function ),</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>cooperative_groups::thread_block_tile::sync ( C++ function ), 235</td><td>169 ( C++ function ), 169</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>cooperative_groups::thread_block_tile::thread_rank ( C++ function ), 235 ),</td><td>( C++ function ), 169</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>cooperative_groups::thread_group ( C++ class</td><td>( C++ function ), 170 ( C++ function ),</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>234</td><td>196 ( C++ function ),</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>( C++ function ), 166, 194</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>H</td><td>hipMalloc hipMalloc3D</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>( C++ function ), 184</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>hipArray3DCreate ( C++ function ), 183</td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>185</td><td>hipMalloc3DArray ( C++ function ),</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>hipArray3DGetDescriptor ( C++ function ),</td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>195</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>184</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>hipImportExternalSemaphore</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>hipImportExternalMemory</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>hipHostMalloc ( C++ function ), 168, 194 hipHostRegister hipHostUnregister</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>hipHostGetDevicePointer hipHostGetFlags</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>hipGetSymbolSize</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>cooperative_groups::thread_block_tile::shfl_xor</td><td></td><td></td><td></td><td></td><td></td></tr></tbody></table>
-<table><tbody><tr><td>hipMallocArray ( C++ function ), 182 ( C++ function ), 152,</td></tr><tr><td>153 hipMallocFromPoolAsync ( C++ function ), 153, 160</td></tr><tr><td>hipMallocHost ( C++ function ), 167</td></tr><tr><td>hipMallocManaged ( C++ function ), 247, 249</td></tr><tr><td>hipMallocPitch ( C++ function ), 170</td></tr><tr><td>hipMemAddressFree ( C++ function ), 251</td></tr><tr><td>hipMemAddressReserve ( C++ function ), 251</td></tr><tr><td>hipMemAdvise ( C++ function ), 247</td></tr><tr><td>hipMemAllocHost ( C++ function ), 167</td></tr><tr><td>hipMemAllocPitch ( C++ function ), 171</td></tr><tr><td>hipMemcpy ( C++ function ), 172</td></tr><tr><td>hipMemcpy2D ( C++ function ), 186</td></tr><tr><td>hipMemcpy2DAsync ( C++ function ), 187</td></tr><tr><td>hipMemcpy2DFromArray ( C++ function ), 190</td></tr><tr><td>hipMemcpy2DFromArrayAsync ( C++ function ), 190</td></tr><tr><td>hipMemcpy2DToArray ( C++ function ), 188</td></tr><tr><td>hipMemcpy2DToArrayAsync ( C++ function ), 188</td></tr><tr><td>hipMemcpy3D ( C++ function ), 191</td></tr><tr><td>hipMemcpy3DAsync ( C++ function ), 192</td></tr><tr><td>hipMemcpyAsync ( C++ function ), 178</td></tr><tr><td>hipMemcpyAtoH ( C++ function ), 191</td></tr><tr><td>hipMemcpyDtoD ( C++ function ), 174</td></tr><tr><td>hipMemcpyDtoDAsync ( C++ function ), 175 hipMemcpyDtoH ( C++ function ), 174</td></tr><tr><td>hipMemcpyDtoHAsync ( C++ function ), 175</td></tr><tr><td>hipMemcpyFromArray ( C++ function ), 189</td></tr><tr><td>hipMemcpyFromSymbol ( C++ function ),</td></tr><tr><td>177,</td></tr><tr><td>194 hipMemcpyFromSymbolAsync ( C++ function ), 178, 194</td></tr><tr><td>hipMemcpyHtoA ( C++ function ), 191</td></tr><tr><td>hipMemcpyHtoD ( C++ function ), 173 hipMemcpyHtoDAsync ( C++ function ),</td></tr><tr><td>hipMemcpyParam2D ( C++ function ),</td></tr><tr><td>174 186</td></tr><tr><td>hipMemcpyParam2DAsync ( C++ function ),</td></tr><tr><td>187 hipMemcpyToArray ( C++ function ), 189 ( C++ function ), 177,</td></tr><tr><td>hipMemcpyToSymbol 193 hipMemcpyToSymbolAsync ( C++ function ), 193</td></tr><tr><td>177, ( C++ function ), 173</td></tr><tr><td>hipMemcpyWithStream hipMemCreate ( C++ function ), 252</td></tr><tr><td>hipMemExportToShareableHandle (</td></tr><tr><td>C++ function 252 ( C++ function ), 252</td></tr><tr><td>hipMemGetAddressRange ( C++ function ), 164 hipMemGetAllocationGranularity ( C++</td></tr><tr><td>function 253 hipMemGetAllocationPropertiesFromHandle</td></tr><tr><td>( C++ function ), 253</td></tr><tr><td>hipMemGetInfo ( C++ function ), 182 hipMemImportFromShareableHandle ( C++ function</td></tr><tr><td>253 hipMemMap ( C++ function ), 254 hipMemMapArrayAsync ( C++ function ), hipMemPoolCreate</td></tr><tr><td>254 ( C++ function ), 158</td></tr><tr><td>hipMemPoolDestroy 159</td></tr><tr><td>( C++ function ),</td></tr></tbody></table>
-<p>C++ function</p>
-<p>(</p>
-<p>), 162</p>
-<table><tbody><tr><td>hipMemPoolExportPointer hipMemPoolExportToShareableHandle ( C++</td><td>func-</td></tr><tr><td colspan="2">tion ), 160</td></tr><tr><td colspan="2">hipMemPoolGetAccess ( C++ function ), 158 hipMemPoolGetAttribute ( C++ function ), 156</td></tr><tr><td>hipMemPoolImportFromShareableHandle function ), 161</td><td>( C++</td></tr><tr><td colspan="2">hipMemPoolImportPointer ( C++ function ), 162 hipMemPoolSetAccess ( C++ function ), 157</td></tr><tr><td colspan="2">hipMemPoolSetAttribute ( C++ function ), 156</td></tr><tr><td colspan="2">hipMemPoolTrimTo ( C++ function ), 155</td></tr><tr><td colspan="2">hipMemPrefetchAsync ( C++ function ), 247</td></tr><tr><td colspan="2">hipMemPtrGetInfo ( C++ function ), 182</td></tr><tr><td colspan="2">hipMemRangeGetAttribute ( C++ function ), 248</td></tr><tr><td colspan="2">hipMemRangeGetAttributes ( C++ function ), 248</td></tr><tr><td colspan="2">hipMemRelease ( C++ function ), 255</td></tr><tr><td colspan="2">hipMemRetainAllocationHandle ( C++function ), 255</td></tr><tr><td colspan="2">hipMemset ( C++ function ), 179</td></tr><tr><td colspan="2">hipMemset2D ( C++ function ), 181</td></tr><tr><td colspan="2">hipMemset2DAsync ( C++ function ), 181</td></tr><tr><td colspan="2">hipMemset3D ( C++ function ), 181</td></tr><tr><td colspan="2">hipMemset3DAsync ( C++ function ), 182</td></tr><tr><td colspan="2">hipMemSetAccess ( C++ function ), 255</td></tr><tr><td colspan="2">hipMemsetAsync ( C++ function ), 180</td></tr><tr><td colspan="2">hipMemsetD16 ( C++ function ), 180 hipMemsetD16Async ( C++ function ), 180</td></tr><tr><td colspan="2">hipMemsetD32 ( C++ function ), 180</td></tr><tr><td colspan="2">hipMemsetD32Async ( C++ function ), 181</td></tr><tr><td colspan="2">hipMemsetD8 ( C++ function ), 179</td></tr><tr><td colspan="2">hipMemsetD8Async ( C++ function ), 179</td></tr><tr><td colspan="2">hipMemUnmap ( C++ function ), 256</td></tr><tr><td colspan="2">hipModuleGetGlobal ( C++ function ), 176</td></tr><tr><td colspan="2">( C++ function ), 165</td></tr><tr><td colspan="2">hipPointerGetAttribute hipPointerGetAttributes ( C++ function ), 165</td></tr><tr><td colspan="2">hipPointerSetAttribute ( C++ function ), 165</td></tr><tr><td colspan="2">hipSignalExternalSemaphoresAsync ( C++ func- tion ), 195</td></tr><tr><td colspan="2">hipStreamAddCallback ( C++ function ), 152 hipStreamAttachMemAsync ( C++ function ), 249</td></tr><tr><td colspan="2">hipStreamCallback_t ( C++ type ), 147 ( C++ function ), 147</td></tr><tr><td colspan="2">hipStreamCreate hipStreamCreateWithFlags ( C++ function ), 147</td></tr><tr><td colspan="2">hipStreamCreateWithPriority ( C++ function ), 147 hipStreamDestroy ( C++ function ), 148</td></tr><tr><td colspan="2">hipStreamGetDevice ( C++ function ), 151</td></tr><tr><td colspan="2">hipStreamGetFlags ( C++ function ), 150</td></tr><tr><td colspan="2">hipStreamGetPriority ( C++ function ), 150 hipStreamQuery ( C++ function ), 149</td></tr><tr><td colspan="2">hipStreamSynchronize ( C++ function ), 149</td></tr><tr><td colspan="2">hipStreamWaitEvent</td></tr><tr><td colspan="2">( C++ function ), 149</td></tr><tr><td colspan="2">hipWaitExternalSemaphoresAsync ( C++ function ), 195</td></tr><tr><td colspan="2">hsa_amd_vmem_address_free ( C++ function ), 241</td></tr><tr><td>hsa_amd_vmem_address_reserve ( C++function ),</td><td></td></tr><tr><td colspan="2">241</td></tr></tbody></table>
-<table><tbody><tr><td>hsa_amd_vmem_export_shareable_handle function ), 244</td><td></td></tr><tr><td colspan="2">hsa_amd_vmem_get_access ( C++ function ), 243</td></tr><tr><td colspan="2">hsa_amd_vmem_get_alloc_properties_from_handle ( C++ function ), 245</td></tr><tr><td colspan="2">hsa_amd_vmem_handle_create ( C++ function ), 242</td></tr><tr><td colspan="2">hsa_amd_vmem_handle_release ( C++ function ), 242</td></tr><tr><td>hsa_amd_vmem_import_shareable_handle function ), 244</td><td>( C++</td></tr><tr><td colspan="2">hsa_amd_vmem_map ( C++ function ), 242</td></tr><tr><td>hsa_amd_vmem_retain_alloc_handle ( C++ tion ), 245</td><td>func-</td></tr><tr><td colspan="2">hsa_amd_vmem_set_access ( C++ function ), 243</td></tr><tr><td colspan="2">hsa_amd_vmem_unmap ( C++ function ), 243</td></tr></tbody></table>
-<h2>S</h2>
-<table><tbody><tr><td>surf1DLayeredread</td></tr><tr><td>surf1DLayeredwrite ( C++ function ), 135</td></tr><tr><td>surf1Dread ( C++ function ), 133</td></tr><tr><td>surf1Dwrite ( C++ function ), 133</td></tr><tr><td>surf2DLayeredread ( C++ function ), 135</td></tr><tr><td>surf2DLayeredwrite ( C++ function ), 135</td></tr><tr><td>surf2Dread ( C++ function ), 134</td></tr><tr><td>surf2Dwrite ( C++ function ), 134</td></tr><tr><td>surf3Dread ( C++ function ), 134</td></tr><tr><td>surf3Dwrite ( C++ function ), 134</td></tr><tr><td>surfCubemapLayeredread ( C++ function ), 136</td></tr><tr><td>surfCubemapLayeredwrite ( C++ function ), 137</td></tr><tr><td>surfCubemapread ( C++ function ), 136</td></tr><tr><td>surfCubemapwrite ( C++ function ), 136</td></tr></tbody></table>
-<h2>U</h2>
-<p>USE_PEER_NON_UNIFIED ( C macro ), 164</p>
-</div>
-</body>
-</html>
\ No newline at end of file
diff --git a/kernel-agentic/docs/hip/hip_spec_mm/hip_spec-with-image-refs.md b/kernel-agentic/docs/hip/hip_spec_mm/hip_spec-with-image-refs.md
deleted file mode 100644
index 9ae98e2..0000000
--- a/kernel-agentic/docs/hip/hip_spec_mm/hip_spec-with-image-refs.md
+++ /dev/null
@@ -1,11189 +0,0 @@
-## HIP Documentation Release 6.1.40092
-
-Advanced Micro Devices, Inc.
-
-Sep 13, 2024
-
-## INSTALL
-
-| 1 Overview   | 1 Overview                                                   | 1 Overview                                                   | 3     |
-|--------------|--------------------------------------------------------------|--------------------------------------------------------------|-------|
-|              | Install HIP                                                  | Install HIP                                                  |       |
-| 2            |                                                              |                                                              | 5     |
-|              | 2.1                                                          | Prerequisites . . . . . . . . .                              | 5     |
-|              | 2.2                                                          | Installation . . .                                           | 5     |
-|              | 2.3                                                          | . . . . . Verify your installation . . .                     | 6     |
-| 3            | Build HIP from source                                        | Build HIP from source                                        | 7     |
-|              | 3.1 Prerequisites                                            | . . . . . .                                                  |       |
-|              |                                                              | . .                                                          | 7     |
-|              | 3.2 Building the HIP runtime 3.3 . .                         | .                                                            | 7     |
-|              | Build HIP tests . . .                                        | Build HIP tests . . .                                        | 10    |
-|              | . . . 3.4 Run HIP . . . . . . . . . . .                      | . . . 3.4 Run HIP . . . . . . . . . . .                      | 11    |
-| 4            | HIP programming model                                        | HIP programming model                                        | 13    |
-|              | 4.1                                                          | 4.1                                                          | 13    |
-| 4.2          | RDNA &CDNAarchitecture summary Heterogeneous Programming . . | RDNA &CDNAarchitecture summary Heterogeneous Programming . . | 14    |
-|              | Single instruction multiple threads (SIMT) . . .             | Single instruction multiple threads (SIMT) . . .             | 14    |
-| 4.3 4.4      | Inherent thread model . .                                    | Inherent thread model . .                                    | 15    |
-| 4.5          | . . . . 4.4.1 Cooperative groups thread                      | . . . . 4.4.1 Cooperative groups thread                      | 16    |
-|              | Memory model . . . . . . . . .                               | Memory model . . . . . . . . .                               | 16    |
-|              | 4.6 Execution model .                                        | . . . . .                                                    | 17    |
-|              | 4.6.1 Host-side                                              | 4.6.1 Host-side                                              |       |
-|              |                                                              | execution                                                    | 17 17 |
-|              | 4.6.2                                                        | Device-side execution . .                                    |       |
-|              | 4.6.3                                                        | Kernel launch .                                              | 18    |
-| 5            | Hardware implementation                                      | Hardware implementation                                      | 19    |
-|              | Compute units                                                | . . . . . . .                                                | 19    |
-|              |                                                              | . . . . .                                                    | 20    |
-| 5.1          | 5.1.1 5.1.2                                                  | SIMD . . Vector cache . .                                    | 20    |
-|              | 5.1.3                                                        | . . Local data share . .                                     | 20    |
-|              | 5.1.4                                                        | Scalar Unit . . . .                                          | 20    |
-|              | 5.2 CDNA architecture .                                      | . . . .                                                      | 20    |
-|              | 5.3 RDNA architecture . .                                    | . . . .                                                      | 21    |
-|              | 5.4 Shader engines . .                                       | . . . .                                                      | 21    |
-|              | (CLR)                                                        | (CLR)                                                        |       |
-| 6            | AMDcommon language runtimes                                  | AMDcommon language runtimes                                  | 23    |
-|              | 6.1 Project organization                                     | . . . .                                                      | 23    |
-|              | How to build/install .                                       | . . .                                                        | 23    |
-| 6.2          | 6.2.1                                                        | Prerequisites . . .                                          | 23    |
-|              | 6.2.2                                                        | Linux . . . . . . .                                          | 23    |
-|              | 6.2.3                                                        | Test . . . . . . . .                                         | 24    |
-
-|                                           | 6.2.4                                                                                      | Release notes . . . . . . . . . . . . . . . . . . . . .                                    | 24    |
-|-------------------------------------------|--------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------|-------|
-| HIP programming manual                    | HIP programming manual                                                                     | HIP programming manual                                                                     | 25    |
-| 7 7.1                                     | Host Memory . . . . .                                                                      | . . . . . . . . . . . . . . . . . . . . .                                                  | 25    |
-|                                           | 7.1.1                                                                                      | Introduction . . . . . . . . . . . . . . .                                                 | 25    |
-|                                           | 7.1.2                                                                                      | . . . . . . . Memory allocation flags . . . . . . . . .                                    | 25    |
-|                                           | 7.1.3                                                                                      | . . . . . . Numa-aware host memory allocation . . . . . . . . .                            | 26    |
-|                                           | 7.1.4                                                                                      | Coherency Controls . . . . . . . . .                                                       | 26    |
-|                                           | 7.1.5                                                                                      | . . . . . . . . . Visibility of Zero-Copy Host Memory . . . . . . . .                      | 27    |
-|                                           | 7.1.6                                                                                      | hipEventSynchronize . . . . . . . . . . .                                                  | 27    |
-|                                           | 7.1.7                                                                                      | . . . . Summary and Recommendations . . . . . . . . . . .                                  | 27    |
-|                                           | 7.1.8                                                                                      | Managed memory allocation . . . . . . . . . . . . .                                        | 28    |
-|                                           | 7.1.9                                                                                      | HIP Stream Memory Operations . . . . . . . . . . .                                         | 28    |
-| 7.2                                       | Direct Dispatch . . . . . .                                                                | . . . . . . . . . . . . . . . . . . .                                                      | 28    |
-| 7.3                                       | HIP Runtime Compilation                                                                    | . . . . . . . . . .                                                                        | 29    |
-| 7.4                                       | . . . . . . . . . HIP Graph . . . . . . . . . . . . . . . . .                              | . . . . . . . . . .                                                                        | 29    |
-| 7.5                                       | Device-Side Malloc . . . . . .                                                             | . . . . . . . . . . . . .                                                                  | 29    |
-| 7.6                                       | . . . Use of Per-thread default stream . . .                                               | . . . . . . . . . . . . .                                                                  | 29    |
-| 7.7                                       | Use of Long Double Type . . . . .                                                          | . . . . . . . . . . . . . .                                                                | 30    |
-| 7.8                                       | Use of _Float16 Type . . . . . . .                                                         | Use of _Float16 Type . . . . . . .                                                         | 30    |
-| 7.9                                       | . . . . . . . . . . . . . . FMA and contractions . . . . . . . . . . . . . . . . . . . . . | . . . . . . . . . . . . . . FMA and contractions . . . . . . . . . . . . . . . . . . . . . | 30    |
-| 7.10                                      | Math functions with special rounding modes . . . . . . . . . . . . . . . .                 | . . . . .                                                                                  | 30    |
-| 7.11                                      | Creating Static Libraries . . .                                                            | . . . . .                                                                                  | 30    |
-| 8 HIP porting guide . . . . . . . . . . . | 8 HIP porting guide . . . . . . . . . . .                                                  | 8 HIP porting guide . . . . . . . . . . .                                                  | 33    |
-| 8.1                                       | Porting a New CUDA Project .                                                               | . . . . .                                                                                  | 33    |
-|                                           |                                                                                            | General Tips . .                                                                           |       |
-|                                           | 8.1.1                                                                                      | . . . . . . . . . . . . . . . . . . .                                                      | 33    |
-|                                           | 8.1.2                                                                                      | Scanning existing CUDA code to scope the porting effort 'in-place' . . . . . . . . . .     | 33 34 |
-|                                           | 8.1.3                                                                                      | Converting a project . .                                                                   |       |
-|                                           | 8.1.4                                                                                      | Library Equivalents . . . . . . . . . . . . . . . . . .                                    | 35 35 |
-| 8.2                                       | Distinguishing 8.2.1                                                                       | Compiler Modes . . . . . . . . . . . . . . . . Identifying HIP Target Platform . . .       | 35    |
-|                                           | 8.2.2                                                                                      | . . . . . . . . Identifying the Compiler: hip-clang or NVCC . . .                          | 36    |
-|                                           | 8.2.3                                                                                      | . Identifying Current Compilation Pass: Host or Device                                     | 36    |
-|                                           | 8.2.4                                                                                      | Compiler Defines: Summary . . . . . . . . . . . . . . .                                    | 37    |
-| 8.3                                       | Identifying Architecture Features . .                                                      | . . . . . . . . . . . . .                                                                  | 37    |
-|                                           | 8.3.1                                                                                      | HIP_ARCH Defines . . . . . . . . . . . . . . .                                             | 37    |
-|                                           | 8.3.2                                                                                      | Device-Architecture Properties . . . . . . . . . . . .                                     | 38    |
-|                                           | 8.3.3                                                                                      | Table of Architecture Properties . . . . . . . . . . . . . . . . . .                       | 38    |
-| 8.4                                       | Finding HIP . . . . . . .                                                                  | . . . . . . . . . . . .                                                                    | 39 40 |
-| 8.5 8.6                                   | Identifying HIP Runtime . . . . . hipLaunchKernelGGL . . . . .                             | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                | 40    |
-| 8.7                                       | Compiler Options . . . . . . . 8.7.1 Compiler options supported                            | . . . . . . . . . . . . . . . .                                                            | 40    |
-|                                           |                                                                                            | on AMDplatforms . . .                                                                      | 40    |
-| 8.8                                       | Linking Issues . . .                                                                       | . . . . . . . . . . . . . . . . . . . .                                                    | 41    |
-|                                           | . . 8.8.1 Linking With hipcc                                                               | . . . . . . . . . . . . . . . . . .                                                        | 41    |
-|                                           | 8.8.2                                                                                      | -lm Option . . . . . . . . . . . . . . . . .                                               | 41    |
-| 8.9                                       | . . . . . Linking Code With Other Compilers                                                | . . . . . . . . . . . . .                                                                  | 41    |
-|                                           | 8.9.1 libc++ and libstdc++                                                                 | 8.9.1 libc++ and libstdc++                                                                 |       |
-|                                           |                                                                                            | . . . . . . . . . . . . . . . . .                                                          | 41    |
-|                                           | 8.9.2                                                                                      | HIP Headers ( hip_runtime.h , hip_runtime_api.h Compiler . . . . . . . . . . .             | 42 42 |
-|                                           | 8.9.3 Using a Standard C++ 8.9.3.1 . .                                                     | . . . . . . . . . . . .                                                                    | 42    |
-|                                           | cuda.h . . . . . 8.9.4 Choosing HIP File Extensions . .                                    | . . . . . . . . . . . .                                                                    | 42    |
-| 8.10                                      | Workarounds . . . . . . . . . . . .                                                        | . . . . . . . . . . . .                                                                    | 43    |
-
-8.10.1
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-43
-
-|      |                                                                                                                                                                           |                                                                                                                                                                           | warpSize                                                                                                                                                                  |       |
-|------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------|
-|      |                                                                                                                                                                           | 8.10.2 Kernel launch with group size > 256 . . . . . . . . . . . . . . . . . . . . .                                                                                      | 8.10.2 Kernel launch with group size > 256 . . . . . . . . . . . . . . . . . . . . .                                                                                      | 43    |
-|      | 8.11                                                                                                                                                                      | memcpyToSymbol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                            | memcpyToSymbol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                            | 43    |
-|      | 8.12                                                                                                                                                                      | CU_POINTER_ATTRIBUTE_MEMORY_TYPE                                                                                                                                          | . . .                                                                                                                                                                     | 44    |
-|      | 8.13                                                                                                                                                                      | threadfence_system . . .                                                                                                                                                  | . . . . . . . .                                                                                                                                                           | 45    |
-|      |                                                                                                                                                                           | . . . . . . 8.13.1 Textures and Cache Control . . .                                                                                                                       | . . . . . . . .                                                                                                                                                           | 45    |
-|      | 8.14                                                                                                                                                                      | More Tips . . . .                                                                                                                                                         | . . . . . . . . .                                                                                                                                                         | 46    |
-|      | 8.14.1                                                                                                                                                                    | . . . . . . . . . . . HIP Logging . . . . . . . . .                                                                                                                       | . . . . . . . . .                                                                                                                                                         | 46    |
-|      | 8.14.2                                                                                                                                                                    | Debugging hipcc                                                                                                                                                           | . . . . . . . . . . . . . . . .                                                                                                                                           | 47    |
-|      | 8.14.3                                                                                                                                                                    | Editor Highlighting . .                                                                                                                                                   | . . . . . . . . . . . . .                                                                                                                                                 | 47    |
-| 9    | Porting CUDA driver API                                                                                                                                                   | Porting CUDA driver API                                                                                                                                                   | Porting CUDA driver API                                                                                                                                                   | 49    |
-| 9.1  | Introduction to the CUDA Driver and Runtime APIs . . . . . . . .                                                                                                          | Introduction to the CUDA Driver and Runtime APIs . . . . . . . .                                                                                                          | Introduction to the CUDA Driver and Runtime APIs . . . . . . . .                                                                                                          | 49    |
-|      | 9.1.1                                                                                                                                                                     | cuModule API . . . . . . . . . . . . . .                                                                                                                                  | cuModule API . . . . . . . . . . . . . .                                                                                                                                  | 49    |
-|      | 9.1.2                                                                                                                                                                     | . . . . . . . . . cuCtx API . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                             | . . . . . . . . . cuCtx API . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                             | 50    |
-| 9.2  | HIP                                                                                                                                                                       | Module and Ctx APIs . . . . . . . . . . . . .                                                                                                                             | . . .                                                                                                                                                                     | 50    |
-|      | 9.2.1                                                                                                                                                                     | hipModule API . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                       | hipModule API . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                       | 50    |
-|      | 9.2.2                                                                                                                                                                     | . hipCtx API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                  | . hipCtx API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                  | 51    |
-|      | 9.2.3                                                                                                                                                                     | hipify translation of CUDA Driver API . . . . . .                                                                                                                         | hipify translation of CUDA Driver API . . . . . .                                                                                                                         | 51    |
-|      |                                                                                                                                                                           | 9.2.3.1                                                                                                                                                                   | Address Spaces . . . . . .                                                                                                                                                | 51    |
-|      |                                                                                                                                                                           | 9.2.3.2                                                                                                                                                                   | . . . . . . Using hipModuleLaunchKernel . .                                                                                                                               | 51    |
-|      |                                                                                                                                                                           | 9.2.3.3                                                                                                                                                                   | Additional Information                                                                                                                                                    | 51    |
-|      | 9.2.4                                                                                                                                                                     | . . . . . . . . . . . hip-clang Implementation Notes . . . . . . . . . .                                                                                                  | . . . . . . . . . . . hip-clang Implementation Notes . . . . . . . . . .                                                                                                  | 51    |
-|      |                                                                                                                                                                           | 9.2.4.1                                                                                                                                                                   | .hip_fatbin . . . . . . . . . . . . .                                                                                                                                     | 51    |
-|      |                                                                                                                                                                           | 9.2.4.2                                                                                                                                                                   | Initialization and Termination Functions                                                                                                                                  | 52    |
-|      |                                                                                                                                                                           | 9.2.4.3                                                                                                                                                                   | Kernel Launching                                                                                                                                                          | 52    |
-|      | 9.2.5                                                                                                                                                                     | . . . . . . . . . . . . . . . . . . NVCC Implementation Notes . . . . . . . . . . . . . . . . .                                                                           | . . . . . . . . . . . . . . . . . . NVCC Implementation Notes . . . . . . . . . . . . . . . . .                                                                           | 52    |
-|      |                                                                                                                                                                           | . . . . 9.2.5.1 Interoperation between HIP and CUDA Driver . . . . . . .                                                                                                  | . . . . 9.2.5.1 Interoperation between HIP and CUDA Driver . . . . . . .                                                                                                  | 52    |
-|      |                                                                                                                                                                           | 9.2.5.2 Compilation Options . . .                                                                                                                                         | . . . . . .                                                                                                                                                               | 53    |
-| 9.3  | HIP                                                                                                                                                                       | Module and Texture Driver API . . . .                                                                                                                                     | . . . . . . .                                                                                                                                                             | 55    |
-| 10   | Programming for HIP runtime compiler (RTC)                                                                                                                                | Programming for HIP runtime compiler (RTC)                                                                                                                                | Programming for HIP runtime compiler (RTC)                                                                                                                                | 57    |
-| 10.1 | Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                       | Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                       | Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                       | 57    |
-| 10.2 | HIPRTC                                                                                                                                                                    | specific options . . . . . . . .                                                                                                                                          | . . . . . . . . .                                                                                                                                                         | 61    |
-|      | 10.2.1                                                                                                                                                                    | Bitcode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                             | Bitcode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                             | 62    |
-|      | 10.2.2                                                                                                                                                                    | CU Mode vs WGP mode . . . . . .                                                                                                                                           | CU Mode vs WGP mode . . . . . .                                                                                                                                           | 62    |
-| 10.3 | Linker                                                                                                                                                                    | APIs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                        | APIs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                        | 62    |
-|      | 10.3.1                                                                                                                                                                    | Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                 | Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                 | 63 63 |
-|      | 10.3.2                                                                                                                                                                    | 10.3.1.1 Note . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Input Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                     | 10.3.1.1 Note . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Input Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                     | 64    |
-|      | 10.3.3                                                                                                                                                                    | . Backward Compatibility of LLVM Bitcode/IR . . . . . . . . . . . . . .                                                                                                   | . Backward Compatibility of LLVM Bitcode/IR . . . . . . . . . . . . . .                                                                                                   | 64    |
-|      | 10.3.4                                                                                                                                                                    | Link Options . . . . . . . . . .                                                                                                                                          | . . . . . . . .                                                                                                                                                           | 64    |
-| 10.4 | Error Handling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                | Error Handling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                | Error Handling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                | 65    |
-| 10.5 | HIPRTC General APIs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                   | HIPRTC General APIs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                   | HIPRTC General APIs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                   | 65    |
-| 10.6 | Lowered Names (Mangled Names) . . . . . . . . . . .                                                                                                                       | Lowered Names (Mangled Names) . . . . . . . . . . .                                                                                                                       | Lowered Names (Mangled Names) . . . . . . . . . . .                                                                                                                       | 66    |
-|      | 10.6.1 10.6.2                                                                                                                                                             | Note . . . . . . . . . . . . . . . . . . . . . . . . . . . Example . . . . . . . . . . . . . . . . . . . . . . . . .                                                      | Note . . . . . . . . . . . . . . . . . . . . . . . . . . . Example . . . . . . . . . . . . . . . . . . . . . . . . .                                                      | 66 66 |
-| 10.7 | . . . . . . . . . . .                                                                                                                                                     | . . . . . . . . . . .                                                                                                                                                     | . . . . . . . . . . .                                                                                                                                                     | 67    |
-| 10.8 | Versioning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . HIP header support . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . | Versioning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . HIP header support . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . | Versioning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . HIP header support . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . | 68    |
-| 10.9 | Deprecation notice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                      | Deprecation notice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                      | Deprecation notice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                      | 68    |
-| 11   |                                                                                                                                                                           |                                                                                                                                                                           |                                                                                                                                                                           | 69    |
-| 11.1 | Performance guidelines Parallel                                                                                                                                           | execution                                                                                                                                                                 | . . . . . . . . . . . . . . . . . . . . .                                                                                                                                 | 69    |
-
-11.1.2
-
-Device level
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-69
-
-|                                               | 11.1.3                                                            | Multiprocessor level . . . . . . . . . . . . . .                                       | 70      |
-|-----------------------------------------------|-------------------------------------------------------------------|----------------------------------------------------------------------------------------|---------|
-| 11.2                                          | Memory                                                            | optimization . . . . . . . . . . . .                                                   | 70      |
-|                                               | 11.2.1                                                            | Data Transfer . . . . . . . . . . . . .                                                | 70      |
-|                                               | 11.2.2                                                            | . . Device Memory Access . . . . . . . . . .                                           | 71      |
-| 11.3                                          | Optimization for maximum instruction throughput                   | Optimization for maximum instruction throughput                                        | 71      |
-|                                               | 11.3.1                                                            | Arithmetic instructions . . . . . . . . .                                              | 72      |
-|                                               | 11.3.2                                                            | . Control flow instructions . . . . . . . . .                                          | 72      |
-|                                               | 11.3.3                                                            | Synchronization . . . . . . . . . .                                                    | 72      |
-| 11.4                                          | . . . . Minimizing memory thrashing .                             | . . . . . . . . . .                                                                    | 73      |
-| 12 Debugging with HIP                         | 12 Debugging with HIP                                             | 12 Debugging with HIP                                                                  | 75      |
-| 12.1                                          | Tracing . .                                                       | . . . . . . . . . . . . . . . . . . . . .                                              | 75      |
-| 12.2                                          | Debugging . . . . . .                                             | . . . . . . . .                                                                        | 77      |
-|                                               | . . . . . . . 12.2.1 Debugging HIP applications                   | . . . . . . .                                                                          | 77      |
-| 12.3                                          | Useful environment variables                                      | . . . . . . .                                                                          | 79      |
-|                                               | 12.3.1                                                            | . . . . Kernel enqueue serialization . . . . . . .                                     | 79      |
-|                                               | 12.3.2                                                            | Making device visible . . . . . . . . . . .                                            | 79      |
-|                                               | 12.3.3                                                            | Dump code object . .                                                                   | 79      |
-|                                               | 12.3.4                                                            | . . . . . . . . . . . HSA-related environment variables (Linux)                        | 80      |
-|                                               | 12.3.5 HIP environment variable summary . .                       | .                                                                                      | 80      |
-| 12.4                                          | General debugging tips . . .                                      | . . . . . . . . . . . .                                                                | 82      |
-| 13 Logging HIP activity                       | 13 Logging HIP activity                                           | 13 Logging HIP activity                                                                | 83      |
-| 13.1                                          | Logging level . . . . . . . .                                     | . . . . . . . . . . . .                                                                | 83      |
-| 13.2                                          | Logging mask . . . . .                                            | . . .                                                                                  | 84      |
-| 13.3                                          | . . . . . . . . . . . Logging command . . . . . . . . . . . . . . | . . .                                                                                  | 84      |
-| 13.4                                          | Logging examples . . . . . .                                      | . . . . . . . . . . .                                                                  | 85      |
-| 14 Cooperative groups . . . . . . . . . . . . | 14 Cooperative groups . . . . . . . . . . . .                     | 14 Cooperative groups . . . . . . . . . . . .                                          | 89      |
-| 14.1                                          | Cooperative groups thread model . . .                             | Cooperative groups thread model . . .                                                  | 89      |
-| 14.2                                          | Group types . . . . . . . . group                                 | . . . . . . . . .                                                                      | 90      |
-|                                               | 14.2.1                                                            | Thread-block . . . . . . . . . . . . .                                                 | 90      |
-|                                               | 14.2.2                                                            | Grid group . . . . . . . . . . . . . .                                                 | 90      |
-|                                               | 14.2.3                                                            | . Multi-grid group . . . . . . . . . . . . .                                           | 90      |
-|                                               | 14.2.4 14.2.5                                                     | Thread-block tile . . . . . . . . . . . . . Coalesced groups . . . . . . . . . . . . . | 91 91   |
-| 14.3                                          | Cooperative groups simple example . .                             | . . . . . .                                                                            | 92      |
-| 14.4                                          | Synchronization . . . . . .                                       | . . . . . . . .                                                                        | 94      |
-| 14.5                                          | . . . .                                                           | . . . .                                                                                | 97      |
-|                                               | Unsupported NVIDIA CUDA features . . .                            | Unsupported NVIDIA CUDA features . . .                                                 |         |
-| 15 Unified memory                             | 15 Unified memory                                                 | 15 Unified memory                                                                      | 99      |
-| 15.1                                          | Unified memory . . .                                              | . . . . . . . . . . . . . . .                                                          | 99 99   |
-| 15.2                                          | System requirements . . . . .                                     | . . . . . . . . . . .                                                                  | 100     |
-| 15.3                                          | Unified memory programming models                                 | . . . . . .                                                                            |         |
-|                                               | 15.3.1                                                            | Checking unified memory management support                                             | 100     |
-|                                               | 15.3.2 Example for unified memory management                      | 15.3.2 Example for unified memory management                                           | 101     |
-| 15.4                                          | Using unified memory management (UMM)                             | . . .                                                                                  | 104     |
-| 15.5                                          | Unified memory HIP runtime hints . . . . .                        | for the better performance                                                             | 104     |
-|                                               | 15.5.1                                                            | Data prefetching . . . . . . . . .                                                     | 105     |
-|                                               | 15.5.2                                                            | Memory advice . . . . . . . . . . . . . .                                              | 106 107 |
-|                                               | 15.5.3 15.5.4                                                     | Memory range attributes . . . . . . . . . Asynchronously attach memory to a stream     | 108     |
-| 16 Virtual memory management                  | 16 Virtual memory management                                      | 16 Virtual memory management                                                           | 109     |
-
-| 16.1                          | Memory allocation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16.1.1                                                                                                                                                | . . . 109 . . .     |
-|-------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------|
-|                               | Allocate physical memory . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                                  | 109                 |
-| 16.1.2                        | Reserve virtual address range . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                               | . . . 110           |
-| 16.1.3                        | Set memory access . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                                 | . . . 110           |
-|                               | Free virtual memory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                                 | . . . 110           |
-| 16.2                          | 16.1.4 Memory usage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                 | . . . 111           |
-|                               | 16.2.1 Dynamically increase allocation size . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                         | . . . 111           |
-| 17 Frequently asked questions | 17 Frequently asked questions                                                                                                                                                                                                                     | 113                 |
-| 17.1                          | What APIs and features does HIP support? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                      | . . . 113           |
-| 17.2                          | What is not supported? . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                                          | . . . 113           |
-|                               | 17.2.1 Runtime/Driver API features . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                          | . . . 113           |
-|                               | 17.2.2 Kernel language features . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                         | . . . 114           |
-| 17.3 Is                       | HIP a drop-in replacement for CUDA? . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                             | . . . 114           |
-| 17.4                          | What specific version of CUDA does HIP support? . . . . . . . . . . . . . . . . . . . .                                                                                                                                                           | . . . 114           |
-| 17.5                          | What libraries does HIP support? . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                        | . . . 115           |
-| 17.6                          | How does HIP compare with OpenCL? . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                             | . . . 115           |
-| 17.7                          | How does porting CUDA to HIP compare to porting CUDA to OpenCL? . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                         | . . . 115           |
-| 17.8                          | What hardware does HIP support? . . . . . . . .                                                                                                                                                                                                   | . . . 116           |
-| 17.9                          | Do HIPIFY tools automatically convert all source code? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                  | . . . 116           |
-| 17.10                         | What is NVCC? . . . . . . . . . . . . . . . .                                                                                                                                                                                                     | . . . 116           |
-| 17.11                         | . . What is HIP-Clang? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                    | . . . 116           |
-| 17.12                         | Why use HIP rather than supporting CUDA directly? . . . . . . . . . . . . . . . . . . .                                                                                                                                                           | . . . 116 117       |
-| 17.13                         | Can I develop HIP code on an NVIDIA CUDA platform? . . . . . . . . . . . . . . . . Can I develop HIP code on an AMDHIP-Clang platform? . . . . . . . . . . . . . . . .                                                                            | . . . . . . 117     |
-| 17.14                         | How to use HIP-Clang to build HIP programs? . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                   | . . . 117           |
-| 17.15                         | . . . . . . . . . . . . . .                                                                                                                                                                                                                       |                     |
-| 17.16 17.17                   | What is AMDclr? . . . . . . . . . . . . . . . . . . . What is hipother? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                               | . . . 117 . . . 118 |
-| 17.18                         | Can I get HIP open source repository . . . . . . . . . . . . . . . .                                                                                                                                                                              | . . . 118           |
-| 17.19                         | for Windows? . . . Can a HIP binary run on both AMDand NVIDIA platforms? .                                                                                                                                                                        | . . . 118           |
-| 17.20 or                      | . . . . . . . . . . . . . On HIP-Clang, can I link HIP code with host code compiled with another compiler such clang? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                         | icc, . . . 118      |
-| 17.21                         | Can HIP API support C style application? What is the difference between C and C++? . .                                                                                                                                                            | . . . 118           |
-| 17.22                         | Can I install both CUDA SDK and HIP-Clang on the same machine? . . . . . . . . .                                                                                                                                                                  | . . . 119           |
-| 17.23                         | HIP detected my platform (HIP-Clang vs NVCC) incorrectly * what should I do? . . . . . . . . . . . . . . .                                                                                                                                        | . . . 119           |
-| 17.24                         | On CUDA, can I mix CUDA code with HIP code? . . . . . . . . . . . . . .                                                                                                                                                                           | . . . 120           |
-| 17.25                         | How do I trace HIP application flow? . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                                  | . . . 120           |
-| 17.26                         | What are the maximum limits of kernel launch parameters? . . . . . . . . . . . . . . .                                                                                                                                                            | . . . 120           |
-| 17.27                         | Are __shfl_*_sync functions supported on HIP platform? . . . . . . . . . . . . . . .                                                                                                                                                              | . . . 120           |
-| 17.28                         | How to create a guard for code that is specific to the host or the GPU? . . . . . . . . . .                                                                                                                                                       | . . . 120           |
-| 17.29                         | Why _OpenMP is undefined when compiling with -fopenmp ? . . . . . . . . . . . . . .                                                                                                                                                               | . . . 121           |
-| 17.30                         | Does the HIP-Clang compiler support extern shared declarations? . . . . . . . . . . . .                                                                                                                                                           | . . . 121 code      |
-| 17.31                         | I have multiple HIP enabled devices and I am getting an error hipErrorSharedObjectInitFailed with the message 'Error: shared object initialization failed'? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . | . . . 121           |
-| 17.32                         | How to use per-thread default stream in HIP? . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                        | . . . 122           |
-| 17.33                         | How to use complex multiplication and division operations? . . . . . . . . .                                                                                                                                                                      | . . . 122           |
-| 17.34                         | . . . . . . Can I develop applications with HIP APIs on Windows the same on Linux? . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                      | . . . 122           |
-| 17.35                         | Does HIP support LUID? . . . . . . . . . . .                                                                                                                                                                                                      | . . . 123           |
-| 17.36                         | How can I know the version of HIP? . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                        | . . . 123           |
-| 18 HIP Runtime 18.1 Related   | API Reference Pages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                               | 125 . . . 126       |
-
-18.3
-
-Namespaces
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-126
-
-|      | 18.3.1                                                                                                                  | Namespace List . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                        | Namespace List . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                        | 126     |
-|------|-------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------|---------|
-|      | 18.3.2                                                                                                                  | Namespace Members . . . . . . . . . . . . . .                                                                           | Namespace Members . . . . . . . . . . . . . .                                                                           | 126     |
-|      |                                                                                                                         | 18.3.2.1 Namespace Members . . . . .                                                                                    | 18.3.2.1 Namespace Members . . . . .                                                                                    | 126     |
-|      |                                                                                                                         | 18.3.2.2 Namespace Members .                                                                                            | 18.3.2.2 Namespace Members .                                                                                            | 126     |
-| 18.4 | . . . . . Data Structures . . . . . . . . . . . . . . . . . . .                                                         | . . . . . Data Structures . . . . . . . . . . . . . . . . . . .                                                         | . . . . . Data Structures . . . . . . . . . . . . . . . . . . .                                                         | 126     |
-|      | 18.4.1 Data                                                                                                             | Structures . . . . . . . .                                                                                              | . .                                                                                                                     | 126     |
-|      | 18.4.2                                                                                                                  | . . . Data Structure Index . . . . . . . .                                                                              | . . . Data Structure Index . . . . . . . .                                                                              | 126     |
-|      | 18.4.3                                                                                                                  | . . . Class Hierarchy . . . . . . . . . . . . . .                                                                       | . . . Class Hierarchy . . . . . . . . . . . . . .                                                                       | 126     |
-|      | 18.4.4                                                                                                                  | . . Data Fields . . . . . . . . . . . . . . . . . .                                                                     | . . Data Fields . . . . . . . . . . . . . . . . . .                                                                     | 126     |
-|      |                                                                                                                         | 18.4.4.1 All . . . . . . . . . . . . . .                                                                                | .                                                                                                                       | 126     |
-|      |                                                                                                                         | 18.4.4.1.1                                                                                                              | Data Fields . . . . .                                                                                                   | 126     |
-|      |                                                                                                                         | 18.4.4.1.2                                                                                                              | Data Fields . . . . .                                                                                                   | 126     |
-|      |                                                                                                                         | 18.4.4.1.3                                                                                                              | Data Fields . . . . .                                                                                                   | 126     |
-|      |                                                                                                                         | 18.4.4.1.4                                                                                                              | Data Fields . . . . .                                                                                                   | 126     |
-|      |                                                                                                                         | 18.4.4.1.5                                                                                                              | Data Fields . . . . .                                                                                                   | 126     |
-|      |                                                                                                                         | 18.4.4.1.6                                                                                                              | Data Fields . . . .                                                                                                     | 126     |
-|      |                                                                                                                         | 18.4.4.1.7                                                                                                              | . Data Fields . . . . . .                                                                                               | 126     |
-|      |                                                                                                                         | 18.4.4.1.8                                                                                                              | Data Fields . . . .                                                                                                     | 126     |
-|      |                                                                                                                         | 18.4.4.1.9                                                                                                              | Data Fields . . . . . . .                                                                                               | 126     |
-|      |                                                                                                                         | 18.4.4.1.10                                                                                                             | Data Fields . . .                                                                                                       | 126     |
-|      |                                                                                                                         | 18.4.4.1.11                                                                                                             | Data Fields . . . . . . .                                                                                               | 126     |
-|      |                                                                                                                         | 18.4.4.1.12                                                                                                             | Data Fields . . .                                                                                                       | 126     |
-|      |                                                                                                                         | 18.4.4.1.13                                                                                                             | Data Fields . . . . . Data Fields .                                                                                     | 126     |
-|      |                                                                                                                         | 18.4.4.1.14                                                                                                             | . . . . Data Fields                                                                                                     | 126     |
-|      |                                                                                                                         | 18.4.4.1.15                                                                                                             | . . . . . .                                                                                                             | 126     |
-|      |                                                                                                                         | 18.4.4.1.16                                                                                                             | Data Fields . . . .                                                                                                     | 126     |
-|      |                                                                                                                         | 18.4.4.1.17                                                                                                             | Data Fields . . . . .                                                                                                   | 126     |
-|      |                                                                                                                         | 18.4.4.1.18                                                                                                             | Data Fields . . . . .                                                                                                   | 126     |
-|      |                                                                                                                         | 18.4.4.1.19                                                                                                             | Data Fields . . . . .                                                                                                   | 126     |
-|      |                                                                                                                         | 18.4.4.1.20                                                                                                             | Data Fields . . . . . .                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.1.21                                                                                                             | Data Fields . . . .                                                                                                     | 126     |
-|      |                                                                                                                         | 18.4.4.1.22                                                                                                             | Data Fields . . . . .                                                                                                   | 126     |
-|      |                                                                                                                         | 18.4.4.1.23                                                                                                             | Data Fields . . . . .                                                                                                   | 126     |
-|      |                                                                                                                         | 18.4.4.1.24                                                                                                             | Data Fields . . . .                                                                                                     | 126     |
-|      |                                                                                                                         | 18.4.4.1.25                                                                                                             | . Data Fields . . . . .                                                                                                 | 126 126 |
-|      | 18.4.4.2 Data Fields - Functions . . . . . . . . . . . . . 18.4.4.3 Variables . . . . . . . . . . . . . . . . . . . . . | 18.4.4.2 Data Fields - Functions . . . . . . . . . . . . . 18.4.4.3 Variables . . . . . . . . . . . . . . . . . . . . . | 18.4.4.2 Data Fields - Functions . . . . . . . . . . . . . 18.4.4.3 Variables . . . . . . . . . . . . . . . . . . . . . | 126     |
-|      |                                                                                                                         | 18.4.4.3.1                                                                                                              | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.2                                                                                                              | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.3                                                                                                              | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.4                                                                                                              | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.5                                                                                                              | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.6                                                                                                              | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.7                                                                                                              | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.8                                                                                                              | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.9                                                                                                              | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.10                                                                                                             | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.11                                                                                                             | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.12                                                                                                             | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.13                                                                                                             | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.14 18.4.4.3.15                                                                                                 | Data Fields - Variables Data Fields - Variables                                                                         | 126 126 |
-|      |                                                                                                                         | 18.4.4.3.16                                                                                                             | Data Fields - Variables                                                                                                 | 126     |
-
-18.4.4.3.17
-
-Data Fields - Variables
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-126
-
-|           |                                                                                                 | 18.4.4.3.18                                                                                     | Data Fields - Variables                                                                         | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                               | 126     |
-|-----------|-------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------|---------|
-|           |                                                                                                 | 18.4.4.3.19                                                                                     | Data Fields - Variables                                                                         | . . . . . . . . . . . . . . . . . . . . .                                                                                       | 126     |
-|           |                                                                                                 | 18.4.4.3.20                                                                                     | Data Fields -                                                                                   | Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                       | 126     |
-|           |                                                                                                 | 18.4.4.3.21                                                                                     | Data Fields - Variables                                                                         | . . . . . . . . . . . . . . . . . . . . . .                                                                                     | 126     |
-|           |                                                                                                 | 18.4.4.3.22                                                                                     | Data                                                                                            | Fields - Variables . . . . . . . . . . . . . . . . . . . . .                                                                    | 126     |
-|           |                                                                                                 | 18.4.4.3.23                                                                                     | Data Fields -                                                                                   | . . . . . . Variables . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                     | 126     |
-|           |                                                                                                 | 18.4.4.3.24                                                                                     | Data                                                                                            | Fields - Variables . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                        | 126     |
-|           |                                                                                                 | 18.4.4.3.25                                                                                     | Data                                                                                            | Fields - Variables . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                        | 126     |
-| 18.5      | 18.4.4.4 Data Fields - Related Symbols . .                                                      | . . . . . . . . .                                                                               | 18.4.4.4 Data Fields - Related Symbols . .                                                      | . . . . . . . . . . . . . . . . . . . . . . . . . . 126 . . . . . . . . .                                                       | 126     |
-|           | Files 18.5.1                                                                                    | File List . . . . .                                                                             | . . . . . . . . . . . . . .                                                                     | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .           | 126     |
-|           | 18.5.2                                                                                          | Globals . . .                                                                                   | . . . . . . . .                                                                                 | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                               | 126     |
-|           |                                                                                                 | 18.5.2.1 All . .                                                                                | . . . . . . . . . .                                                                             | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 126     |
-|           |                                                                                                 | 18.5.2.1.1                                                                                      | Globals . . . .                                                                                 | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 126     |
-|           |                                                                                                 | 18.5.2.1.2                                                                                      | Globals . . . .                                                                                 | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 126     |
-|           |                                                                                                 | 18.5.2.1.3                                                                                      | Globals . . . .                                                                                 | . . . . . . . . . . . . . . . . . . . . . . . . .                                                                               | 126     |
-|           |                                                                                                 | 18.5.2.1.4                                                                                      | Globals . . . .                                                                                 | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                       | 126     |
-|           |                                                                                                 | 18.5.2.1.5                                                                                      | Globals . . . .                                                                                 | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 126     |
-|           |                                                                                                 | 18.5.2.1.6                                                                                      | Globals . . . .                                                                                 | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 126     |
-|           |                                                                                                 | 18.5.2.1.7                                                                                      | Globals . . . .                                                                                 | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                     | 126     |
-|           |                                                                                                 | 18.5.2.1.8                                                                                      | Globals . .                                                                                     | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 126     |
-|           |                                                                                                 | 18.5.2.1.9                                                                                      | Globals                                                                                         |                                                                                                                                 | 126     |
-|           |                                                                                                 |                                                                                                 | . .                                                                                             | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                         | 126     |
-|           |                                                                                                 | 18.5.2.2 Functions 18.5.2.2.1                                                                   | . . . . . . . Globals . . .                                                                     | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . | 126     |
-|           |                                                                                                 | 18.5.2.2.2                                                                                      | Globals . .                                                                                     | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 126     |
-|           |                                                                                                 | 18.5.2.2.3                                                                                      | Globals . .                                                                                     | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                             | 126     |
-|           |                                                                                                 | 18.5.2.3 Globals                                                                                | . . . . . . .                                                                                   | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                             | 126     |
-|           |                                                                                                 | 18.5.2.4 Globals                                                                                | . . . . . . .                                                                                   | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                               | 126     |
-|           |                                                                                                 |                                                                                                 | . . . . . .                                                                                     | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                       | 126     |
-|           |                                                                                                 | 18.5.2.5 Globals                                                                                | Enumerator . . . . . .                                                                          | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                 | 126     |
-|           |                                                                                                 | 18.5.2.6 18.5.2.6.1                                                                             | Globals . . . .                                                                                 | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 126     |
-|           |                                                                                                 | 18.5.2.6.2                                                                                      | Globals .                                                                                       | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                     | 126     |
-|           |                                                                                                 | Globals                                                                                         | .                                                                                               | . . . .                                                                                                                         |         |
-|           | 18.5.2.7                                                                                        |                                                                                                 | . . . . . .                                                                                     | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                             | 126     |
-|           | C++ language extensions                                                                         | C++ language extensions                                                                         | C++ language extensions                                                                         |                                                                                                                                 | 127     |
-| 19.1      | Function-type                                                                                   | qualifiers                                                                                      | . . . . . . . . . .                                                                             | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 127 127 |
-|           | 19.1.1                                                                                          | __device__ . .                                                                                  | . . . . . . . . . . . . . .                                                                     | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .     | 128     |
-|           | 19.1.2                                                                                          | __global__                                                                                      | . . . . . .                                                                                     |                                                                                                                                 |         |
-|           | 19.1.3                                                                                          | __host__ . . .                                                                                  | . . . . . . . . . .                                                                             | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 128     |
-| 19.2 19.3 | Calling __global__ functions . . . . .                                                          | Calling __global__ functions . . . . .                                                          | . . . .                                                                                         | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .     | 128 129 |
-| 19.4      | Kernel launch example . . . . . . . . Variable type qualifiers . . . . . . . .                  | Kernel launch example . . . . . . . . Variable type qualifiers . . . . . . . .                  | . .                                                                                             | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 130     |
-|           | .                                                                                               | .                                                                                               | .                                                                                               |                                                                                                                                 | 130     |
-|           | 19.4.1                                                                                          | __constant__                                                                                    | . . . . . . . . . .                                                                             | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                 |         |
-|           | 19.4.2                                                                                          | __shared__ .                                                                                    | . . . . . . . . . .                                                                             | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                     | 130     |
-|           | 19.4.3                                                                                          | __managed__ .                                                                                   | . . . . . . . . . .                                                                             | . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                             | 130     |
-|           | 19.4.4                                                                                          | __restrict__                                                                                    | . . . . . . . . .                                                                               | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                         | 130     |
-| 19.5      | . Built-in variables . . . . . . . . . . .                                                      | . Built-in variables . . . . . . . . . . .                                                      | . .                                                                                             | . . . . . . . . .                                                                                                               | 130     |
-|           | 19.5.1                                                                                          | Coordinate built-ins                                                                            | . . . . . . .                                                                                   | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                   | 130     |
-|           | 19.5.2                                                                                          | warpSize . . .                                                                                  | . . . . . . . . . .                                                                             | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 131     |
-| 19.6      | Vector types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                    | Vector types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                    | Vector types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                    | . . . . . . . . .                                                                                                               | 131     |
-|           | 19.6.1                                                                                          | Short vector types                                                                              | . . . . . .                                                                                     | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                 | 131     |
-| 19.7      | 19.6.2 dim3 . . . . . . . . . . . . . . . . . . Memory fence instructions . . . . . . . . . . . | 19.6.2 dim3 . . . . . . . . . . . . . . . . . . Memory fence instructions . . . . . . . . . . . | 19.6.2 dim3 . . . . . . . . . . . . . . . . . . Memory fence instructions . . . . . . . . . . . | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132         | 132     |
-
-19.8
-
-Synchronization functions
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-132
-
-|                   | .                                                                                                             | . .                                                                                                           |         |
-|-------------------|---------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------|---------|
-| 19.9              | Math                                                                                                          | functions . . . . . . . . . . .                                                                               | 132     |
-| 19.10             | Texture                                                                                                       | functions . . . . . . . . . . . . .                                                                           | 133     |
-| 19.11             | Surface                                                                                                       | functions . . . . . . . . . . . . .                                                                           | 133     |
-| 19.12             | Timer                                                                                                         | functions . . . . . . . . . . . . . .                                                                         | 137     |
-| 19.13             | Atomic                                                                                                        | functions                                                                                                     | 138     |
-|                   | 19.13.1                                                                                                       | . . . . . . . . . . . . . Unsafe floating-point atomic RMWoperations                                          | 139     |
-| 19.14             | Warp cross-lane                                                                                               | functions . .                                                                                                 | 140     |
-|                   | 19.14.1                                                                                                       | . . . . . . Warp vote and ballot functions .                                                                  | 140     |
-|                   | 19.14.2 Warp                                                                                                  | match functions . . . . .                                                                                     | 141     |
-|                   | 19.14.3                                                                                                       | . Warp shuffle functions . . . . .                                                                            | 142     |
-| 19.15             | Cooperative groups                                                                                            | functions . . . . . .                                                                                         | 142     |
-| 19.16             | Warp matrix                                                                                                   | functions . . . . . . .                                                                                       | 143     |
-| 19.17             | Independent                                                                                                   | . . . thread scheduling . . . . . .                                                                           | 144     |
-| 19.18             | Profiler                                                                                                      | Counter Function . . . . . . . .                                                                              | 144     |
-| 19.19             | Assert . . . . .                                                                                              | . . . . . . . . . . . . . .                                                                                   | 144     |
-| 19.20             | . . . .                                                                                                       | printf . . . . . . . . . . . . . .                                                                            | 144     |
-| 19.21             |                                                                                                               | Device-Side Dynamic Global Memory Allocation . . . . . . . .                                                  | 145     |
-| 19.22             |                                                                                                               | __launch_bounds__ . .                                                                                         | 145     |
-|                   | 19.22.1                                                                                                       | Compiler Impact . . . . . . . .                                                                               | 145     |
-|                   | 19.22.2                                                                                                       | CU and EU Definitions . . . . .                                                                               | 146 146 |
-|                   | 19.22.3 19.22.4 maxregcount                                                                                   | Porting from CUDA __launch_bounds . . . . . . . . . .                                                         | 146     |
-| 19.23             |                                                                                                               | Asynchronous Functions . . . . . . . . .                                                                      | 147     |
-|                   | 19.23.1                                                                                                       | Memory stream . . . . . . . . .                                                                               | 147     |
-|                   | 19.23.2                                                                                                       | Peer to peer . . . . . .                                                                                      | 163     |
-|                   | 19.23.3                                                                                                       | . . . . . Memory management . . .                                                                             | 165     |
-|                   | 19.23.4                                                                                                       | . . . External Resource Interoperability                                                                      | 195     |
-|                   | Register                                                                                                      | Keyword . . . . . . . . . . . . .                                                                             | 197     |
-| 19.24             | 19.25 Pragma                                                                                                  | Unroll . . . . . . . . . . . . .                                                                              | 198     |
-| 19.26             | In-Line                                                                                                       | Assembly . . . . . . . . . . . .                                                                              | 198     |
-| 19.27             | Kernel                                                                                                        | Compilation . . . . . . . . . . .                                                                             | 198     |
-| 19.28             |                                                                                                               |                                                                                                               |         |
-|                   |                                                                                                               | gfx-arch-specific-kernel . . . . . . . . .                                                                    | 199     |
-| C++ language 20.1 | 20.1.1                                                                                                        | Modern C++ support . . . . . . . . . . . C++11 support . . . . . . . . .                                      | 201 201 |
-|                   | 20.1.2                                                                                                        | C++14 support . . . . . . . . .                                                                               | 202     |
-|                   | 20.1.3                                                                                                        | C++17 support . . . . . . . . .                                                                               | 202     |
-|                   | 20.1.4                                                                                                        | C++20 support . . . . . . . . .                                                                               | 202     |
-| 20.2              | Extensions                                                                                                    | and restrictions . . . . . . . .                                                                              | 202     |
-|                   | 20.2.1                                                                                                        | Global functions . .                                                                                          | 202     |
-|                   | 20.2.2                                                                                                        | . . . . . . Device space memory specifiers . . . .                                                            | 202     |
-|                   | 20.2.3                                                                                                        | Exception handling . . . . .                                                                                  | 203     |
-|                   | 20.2.4                                                                                                        | Kernel parameters . . . . . .                                                                                 | 203     |
-|                   | 20.2.5                                                                                                        | Classes . . . .                                                                                               | 203     |
-|                   | 20.2.6                                                                                                        | . . . . . . . . . Polymorphic function wrappers .                                                             | 203     |
-|                   | 20.2.7                                                                                                        | Extended lambdas . . . . . . . .                                                                              | 203     |
-|                   |                                                                                                               | Inline namespaces                                                                                             |         |
-|                   | 20.2.8                                                                                                        | . . . . . . .                                                                                                 | 203     |
-|                   |                                                                                                               | .                                                                                                             | 205     |
-| 21 HIP math       | API                                                                                                           | API                                                                                                           | 205     |
-| 21.1              | Single precision mathematical functions . . . . Double precision mathematical functions . . . Integer . . . . | Single precision mathematical functions . . . . Double precision mathematical functions . . . Integer . . . . | 215     |
-| 21.2              | intrinsics . . . . . . . . . . . .                                                                            | intrinsics . . . . . . . . . . . .                                                                            |         |
-| 21.3              |                                                                                                               |                                                                                                               | 225     |
-
-|    | 21.4                                                                                       | Floating-point Intrinsics . . . . . . . . . . . . . .                                      | 227   |
-|----|--------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------|-------|
-| 22 | Table                                                                                      | comparing syntax for different compute APIs                                                | 231   |
-|    | 22.1                                                                                       | Notes . . . . . . . . . . . . . . . . . . . . . . . .                                      | 232   |
-| 23 | HIP                                                                                        | Cooperative groups API                                                                     | 233   |
-|    | 23.1                                                                                       | Cooperative kernel launches . . . . . . . . . . . .                                        | 233   |
-|    | 23.2                                                                                       | Cooperative groups classes . . . . . . . . . . . . .                                       | 234   |
-|    | 23.3                                                                                       | Cooperative groups construct functions . . . .                                             | 237   |
-|    | 23.4                                                                                       | . . Cooperative groups exposed API functions . . . .                                       | 238   |
-| 24 | HSA runtime API for ROCm                                                                   | HSA runtime API for ROCm                                                                   | 241   |
-| 25 | HIP managed memory allocation API                                                          | HIP managed memory allocation API                                                          | 247   |
-| 26 | HIP virtual memory management API                                                          | HIP virtual memory management API                                                          | 251   |
-| 27 | HIP deprecated                                                                             | runtime API functions                                                                      |       |
-|    |                                                                                            |                                                                                            | 257   |
-|    | 27.1                                                                                       | Context management . . . . . . . . . . . . . . . .                                         | 257   |
-|    | 27.2                                                                                       | Memory management . . . . . . . . . . . . . . . . . .                                      | 258   |
-|    | 27.3                                                                                       | Profiler control . . . . . . . . . . . . . . . .                                           | 258   |
-|    | 27.4                                                                                       | Texture management . . . . . . . . . . . . . . . .                                         | 258   |
-| 28 | SAXPY - Hello, HIP                                                                         | SAXPY - Hello, HIP                                                                         | 261   |
-|    | 28.1 Prerequisites . . . . . .                                                             | . . . . . . . . . . .                                                                      | 261   |
-|    | . . . 28.2 Heterogeneous programming                                                       | . . . . . . . . .                                                                          | 261   |
-|    | . . 28.3 Your first lines of HIP code . . .                                                | . . . . . .                                                                                | 261   |
-|    | . . . 28.4 Compiling on the command line . . . .                                           | . . . . . .                                                                                | 263   |
-|    | 28.4.1 Setting up the command line                                                         | . . . . . . .                                                                              | 263   |
-|    | 28.4.2                                                                                     | Invoking the compiler manually . . . . .                                                   | 266   |
-| 29 | Reduction                                                                                  | Reduction                                                                                  | 273   |
-|    | 29.1 The algorithm . . . 29.2                                                              | . . . . . . . . . . . . . . . .                                                            | 273   |
-|    | Reduction on GPUs                                                                          | . . . . . . . . . . . . . . . .                                                            | 273   |
-|    | 29.2.1 Naive shared reduction                                                              | . . . . . . . . . .                                                                        | 274   |
-|    | 29.2.2                                                                                     | Reducing thread divergence . . . . . . . .                                                 | 276   |
-|    | 29.2.3                                                                                     | Resolving bank conflicts . . . . . . . . .                                                 | 276   |
-|    | 29.2.4                                                                                     | Utilize upper half of the block . . . . . . . . . . . . .                                  | 277   |
-|    | 29.2.5                                                                                     | Unroll all loops . . . . . . .                                                             | 281   |
-|    | 29.2.6                                                                                     | Communicate using warp-collective functions                                                | 282   |
-|    | 29.2.7                                                                                     | Prefer warp communication over shared                                                      | 282   |
-|    | 29.2.8                                                                                     | . Amortize bookkeeping variable overhead                                                   | 284   |
-|    | 29.2.8.1 Reading ItemsPerThread                                                            | . . .                                                                                      | 285   |
-|    | 29.2.8.2 Processing ItemsPerThread                                                         | . .                                                                                        | 286   |
-|    | 29.2.9 Two-pass reduction                                                                  | . . . . . . . . . . . .                                                                    | 286   |
-|    | 29.2.10 Global data share                                                                  | . . . . . . . . . . . . .                                                                  | 286   |
-|    | 29.3 Conclusion . . . . .                                                                  | . . . . . . . . . . . . . . . .                                                            | 287   |
-| 30 | Cooperative groups .                                                                       | Cooperative groups .                                                                       | 289   |
-|    | 30.1 Prerequisites                                                                         | . . . . . . . . . . . . . . . . . . .                                                      | 289   |
-|    | 30.2 Simple HIP Code                                                                       | . . . . . . . . . . . . . . . . . .                                                        | 289   |
-|    | Tiled partition                                                                            | . . . . . . .                                                                              | 289   |
-|    | 30.3 . . . . . . . . . . . . 30.3.1 Device-side code . . . . . .                           | . . .                                                                                      | 290   |
-|    | . . . . 30.3.1.1 1. Initialization of the reduction                                        | . . . . 30.3.1.1 1. Initialization of the reduction                                        | 291   |
-|    | function variables . . . 30.3.1.2 2. The reduction of thread block . . . . . . . . . . . . | function variables . . . 30.3.1.2 2. The reduction of thread block . . . . . . . . . . . . | 291   |
-
-|                     | 30.3.1.3 3. The reduction of custom partition . . . . . . . . . . . . . . . . . . . . . . . . . .   |   291 |
-|---------------------|-----------------------------------------------------------------------------------------------------|-------|
-| 30.3.2              | Host-side code . . . . . . . . . . . .                                                              |   292 |
-|                     | 30.3.2.1 1. Confirm the cooperative group support on AMDGPUs 30.3.2.2 . . . . .                     |   292 |
-|                     | 2. Initialize the cooperative group configuration . . . . . . . . . . . . . . . . . . .             |   293 |
-| 30.3.2.3 Conclusion | 4. Launch the kernel . . . . .                                                                      |   293 |
-| 30.4 .              | . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                           |   293 |
-| 31 License          |                                                                                                     |   295 |
-
-Index
-
-297
-
-The Heterogeneous-computing Interface for Portability (HIP) API is a C++ runtime API and kernel language that lets developers create portable applications for AMD and NVIDIA GPUs from single source code.
-
-For HIP supported AMD GPUs on multiple operating systems, see:
-
-- Linux system requirements
-- Microsoft Windows system requirements
-
-The CUDA enabled NVIDIA GPUs are supported by HIP. For more information, see GPU Compute Capability.
-
-On the AMD ROCm platform, HIP provides header files and runtime library built on top of HIP-Clang compiler in the repository Common Language Runtimes (CLR) , which contains source codes for AMD's compute languages runtimes as follows,
-
-On non-AMD platforms, like NVIDIA, HIP provides header files required to support non-AMD specific back-end implementation in the repository 'hipother', which translates from the HIP runtime APIs to CUDA runtime APIs.
-
-## Install
-
-- Installing HIP
-- Building HIP from source
-
-## Conceptual
-
-- HIP programming model
-- Hardware implementation
-- AMD common language runtimes (CLR)
-
-## How to
-
-- Programming manual
-- HIP porting guide
-- HIP porting: driver API guide
-- Programming for HIP runtime compiler (RTC)
-- Performance guidelines
-- Debugging with HIP
-- Logging HIP activity
-- Unified memory
-- Virtual memory
-- Cooperative groups
-- Frequently asked questions
-
-## Reference
-
-- HIP Runtime API Reference
-- C++ language extensions
-- C++ language support
-- HIP math API
-- Comparing syntax for different APIs
-- HSA runtime API for ROCm
-- HIP managed memory allocation API
-
-## CHAPTER ONE
-
-## OVERVIEW
-
-- HIP virtual memory management API
-- HIP Cooperative groups API
-- List of deprecated APIs
-
-## Tutorial
-
-- HIP basic examples
-- HIP examples
-- HIP test samples
-- SAXPY tutorial
-- Reduction tutorial
-- Cooperative groups tutorial
-
-Known issues are listed on the HIP GitHub repository.
-
-To contribute features or functions to the HIP project, refer to Contributing to HIP. To contribute to the documentation, refer to Contributing to ROCm docs page.
-
-You can find licensing information on the Licensing page.
-
-## CHAPTER
-
-## TWO
-
-## INSTALL HIP
-
-HIP can be installed on AMD (ROCm with HIP-Clang) and NVIDIA (CUDA with NVCC) platforms.
-
-Note: The version definition for the HIP runtime is different from CUDA. On an AMD platform, the hipRuntimeGerVersion function returns the HIP runtime version; on an NVIDIA platform, this function returns the CUDA runtime version.
-
-## 2.1 Prerequisites
-
-## AMD
-
-Refer to the Prerequisites section in the ROCm install guides:
-
-- System requirements (Linux)
-- System requirements (Windows)
-
-## NVIDIA
-
-Check the system requirements in the NVIDIA CUDA Installation Guide.
-
-## 2.2 Installation
-
-## AMD
-
-HIP is automatically installed during the ROCm installation. If you haven't yet installed ROCm, you can find installation instructions here:
-
-- ROCm installation for Linux
-- HIP SDK installation for Windows
-
-By default, HIP is installed into /opt/rocm/hip .
-
-Note: There is no autodetection for the HIP installation. If you choose to install it somewhere other than the default location, you must set the HIP\_PATH environment variable as explained in Build HIP from source.
-
-## NVIDIA
-
-1. Install the NVIDIA driver.
-
-sudo apt-get install ubuntu-drivers-common &amp;&amp; sudo ubuntu-drivers autoinstall sudo reboot
-
-Alternatively, you can download the latest CUDA Toolkit.
-
-2. Install the hip-runtime-nvidia and hip-dev packages. This installs the CUDA SDK and HIP porting layer.
-
-```
-  | apt-get install hi
-```
-
-```
-tall hip-runtime-nvidia hip-dev
-```
-
-## The default paths are:
-
-- CUDA SDK: /usr/local/cuda
-- HIP: /opt/rocm/hip
-
-You can optionally add /opt/rocm/bin to your path, which can make it easier to use the tools.
-
-## 2.3 Verify your installation
-
-Run hipconfig in your installation path.
-
-/opt/rocm/bin/hipconfig --full
-
-CHAPTER
-
-## THREE
-
-## BUILD HIP FROM SOURCE
-
-## 3.1 Prerequisites
-
-HIP code can be developed either on AMD ROCm platform using HIP-Clang compiler, or a CUDA platform with nvcc installed. Before building and running HIP, make sure drivers and prebuilt packages are installed properly on the platform.
-
-You also need to install Python 3, which includes the CppHeaderParser package. Install Python 3 using the following command:
-
-```
-    | apt-get install python3
-```
-
-Check and install CppHeaderParser package using the command:
-
-```
-      | pip3 install CppHeaderParser
-```
-
-## 3.2 Building the HIP runtime
-
-Set the repository branch using the variable: ROCM\_BRANCH . For example, for ROCm 6.1, use:
-
-```
-| export
-```
-
-```
-<_Bash_>
-```
-
-## AMD
-
-1. Get HIP source code.
-
-Note: Starting in ROCM 5.6, CLR is a new repository that includes the former ROCclr, HIPAMD and OpenCl repositories. OpenCL provides headers that ROCclr runtime depends on.
-
-Note: Starting in ROCM 6.1, a new repository hipother is added to ROCm, which is branched out from HIP. hipother provides files required to support the HIP back-end implementation on some non-AMD platforms, like NVIDIA.
-
-```
-<_Bash_>
-```
-
-```
-:lone -b "$ROCM_BRANCH" https://github.com/ROCm/clr.git
-:lone -b "$ROCM_BRANCH" https://github.com/ROCm/hip.git
-```
-
-CLR (Common Language Runtime) repository includes ROCclr, HIPAMD and OpenCL.
-
-ROCclr (Radeon Open Compute Common Language Runtime) is a virtual device interface which is defined on the AMD platform. HIP runtime uses ROCclr to interact with different backends.
-
-HIPAMD provides implementation specifically for HIP on the AMD platform.
-
-OpenCL provides headers that ROCclr runtime currently depends on. hipother provides headers and implementation specifically for non-AMD HIP platforms, like NVIDIA.
-
-2. Set the environment variables.
-3. Build HIP.
-
-```
-<_Bash_>
-```
-
-```
-        cd "$CLR_DIR"
-        mkdir -p build; cd build
-        cmake -DHIP_COMMON_DIR=$HIP_DIR -DHIP_PLATFORM=amd -DCMAKE_PREFIX_PATH="/opt/rocm/"_
-        ---DCMAKE_INSTALL_PREFIX=$PWD/install -DHIP_CATCH_TEST=0 -DCLR_BUILD_HIP=ON -DCLR_
-        --BUILD_OCL=OFF..
-        
-        make -j$(nproc)
-        sudo make install
-```
-
-Note: Note, if you don't specify CMAKE\_INSTALL\_PREFIX , the HIP runtime is installed at &lt;ROCM\_PATH&gt;/hip .
-
-By default, release version of HIP is built. If need debug version, you can put the option CMAKE\_BUILD\_TYPE=Debug in the command line.
-
-Default paths and environment variables:
-
-- HIP is installed into &lt;ROCM\_PATH&gt;/hip . This can be overridden by setting the HIP\_PATH environment variable.
-
-•
-
-HSA is in
-
-&lt;ROCM\_PATH&gt;/hsa
-
-. This can be overridden by setting the
-
-HSA\_PATH
-
-environment variable.
-
-- Clang is in &lt;ROCM\_PATH&gt;/llvm/bin . This can be overridden by setting the HIP\_CLANG\_PATH environment variable.
-- The device library is in &lt;ROCM\_PATH&gt;/lib . This can be overridden by setting the DEVICE\_LIB\_PATH environment variable.
-- Optionally, you can add &lt;ROCM\_PATH&gt;/bin to your PATH , which can make it easier to use the tools.
-- Optionally, you can set HIPCC\_VERBOSE=7 to output the command line for compilation.
-
-After you run the make install command, make sure HIP\_PATH points to $PWD/install/hip .
-
-1. Generate a profiling header after adding/changing a HIP API.
-
-Whenyouadd or change a HIP API, you may need to generate a new hip\_prof\_str.h header. This header is used by ROCm tools to track HIP APIs, such as rocprofiler and roctracer .
-
-To generate the header after your change, use the hip\_prof\_gen.py tool located in hipamd/src .
-
-Usage:
-
-```
-<_PHP_>
-```
-
-```
-                                                                                                                                                                                                        |                                                                                                                                                                                                       
-                                                                                                                                                                                                        <! hip_prof_gen.py                                                                                                                                                                                                        </!                                                                                                                                                                                                        >
-                                                                                                                                                                                                       <?php                                                                                                                                                                                                        +
-```
-
-## Flags:
-
-- -v : Verbose messages
-- -r : Process source directory recursively
-- -t : API types matching check
-- --priv : Private API check
-- -e : On error exit mode
-- -p : HIP\_INIT\_API macro patching mode
-
-Example usage:
-
-```
-<_Bash_>
-```
-
-## NVIDIA
-
-```
-git clone -b "$ROCM_BRANCH" https://github.com/ROCm/clr.git
-git clone -b "$ROCM_BRANCH" https://github.com/ROCm/hip.git
-git clone -b "$ROCM_BRANCH" https://github.com/ROCm/hipother.git
-```
-
-```
---- ---
-
-    1. Get the HIP source code.
-        git clone -b "$ROCM_BRANCH"
-        git clone -b "$ROCM_BRANCH"
-        git clone -b "$ROCM_BRANCH"
-
-    2. Set the environment variables.
-```
-
-```
-export CLR_DIR="$(readlink -f clr)"
-export HIP_DIR="$(readlink -f hip)"
-export HIP_OTHER="$(readlink -f hipother)"
-```
-
-```
-3.  Build HIP.
-```
-
-```
-cd "$CLR_DIR"
-mkdir -p build; cd build
-cmake -DHIP_COMMON_DIR=$HIP_DIR -DHIP_PLATFORM=nvidia -DCMAKE_INSTALL_PREFIX=$PWD/
- --install -DHIP_CATCH_TEST=0 -DCLR_BUILD_HIP=ON -DCLR_BUILD_OCL=OFF -DHIPNV_DIR=
- --$HIP_OTHER/hipnv..
-make -j$(nproc)
-sudo make install
-```
-
-## 3.3 Build HIP tests
-
-## AMD
-
-- Build HIP catch tests.
-
-```
-git clone -b "$ROCM_BRANCH" https://github.com/ROCm/hip-tests.git  |
-```
-
-```
-        - npm -m -cos no-source.
-
-            export HIPTESTS_DIR="$(readlink -f hip-tests)"
-            cd "$HIPTESTS_DIR"
-            mkdir -p build; cd build
-            cmake../catch -DHIP_PLATFORM=amd -DHIP_PATH=$CLR_DIR/build/
-            --install  # or any path where HIP is installed; for example: ``/
-            --opt/rocm``
-            make build_tests
-            ctest # run tests
-```
-
-```
-AMD
-
-     *  Build HIP catch tests.
-
-                HIP catch tests are separate from the HIP project and use Catch2.
-
-                    - Get HIP tests source code.
-```
-
-```
-      - command: command.json.
-        
-          cd "$HIPTESTS_DIR"
-          hipcc $HIPTESTS_DIR/catch/unit/memory/hipPointerGetAttributes.cc \
-          -I./catch/include./catch/hipTestMain/standalone_main.cc \
-          -I./catch/external/Catch2 -o hipPointerGetAttributes
-         ./hipPointerGetAttributes
-         ...
-
-          All tests passed
-```
-
-## NVIDIA
-
-The commands to build HIP tests on an NVIDIA platform are the same as on an AMD platform. However, you must first set -DHIP\_PLATFORM=nvidia .
-
-## 3.4 Run HIP
-
-After installation and building HIP, you can compile your application and run. A simple example is square sample.
-
-## FOUR
-
-## HIP PROGRAMMING MODEL
-
-The HIP programming model makes it easy to map data-parallel C/C++ algorithms to massively parallel, wide single instruction, multiple data (SIMD) architectures, such as GPUs.
-
-While the model may be expressed in most imperative languages, (for example Python via PyHIP) this document will focus on the original C/C++ API of HIP.
-
-A basic understanding of the underlying device architecture helps you make efficient use of HIP and general purpose graphics processing unit (GPGPU) programming in general.
-
-## 4.1 RDNA &amp; CDNA architecture summary
-
-GPUs in general are made up of basic building blocks called compute units (CUs), that execute the threads of a kernel. These CUs provide the necessary resources for the threads: the Arithmetic Logical Units (ALUs), register files, caches and shared memory for efficient communication between the threads.
-
-This design allows for efficient execution of kernels while also being able to scale from small GPUs embedded in APUs with few CUs up to GPUs designed for data centers with hundreds of CUs. Figure Block Diagram of an RDNA3 Compute Unit. and Block Diagram of a CDNA3 Compute Unit. show examples of such compute units.
-
-For architecture details, check Hardware implementation .
-
-Fig. 1: Block Diagram of an RDNA3 Compute Unit.
-
-Schedule.
-
-![Image](hip_spec-with-image-refs_artifacts/image_000000_5208c655dc4611802372524b387216259e5e5c3c192ee9dd1c1c8e76383cd3f6.png)
-
-Fig. 2: Block Diagram of a CDNA3 Compute Unit.
-
-The image depicts a horizontal bar chart titled "Local Data Share." The chart is divided into two main sections: the left section and the right section.
-
-### Left Section:
-- **Title:** "Local Data Share"
-- **X-axis:** Labeled "Schedule"
-- **Y-axis:** Labeled "Matrix Core Unit"
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
--
-
-![Image](hip_spec-with-image-refs_artifacts/image_000001_bfcf0651eef1f236f619420b33a1d732aeb71e35bd879a965fdc6375d5204886.png)
-
-## 4.2 Heterogeneous Programming
-
-The HIP programming model assumes two execution contexts. One is referred to as host while compute kernels execute on a device . These contexts have different capabilities, therefor slightly different rules apply. The host execution is defined by the C++ abstract machine, while device execution follows the SIMT model of HIP. These execution contexts in code are signified by the \_\_host\_\_ and \_\_device\_\_ decorators. There are a few key differences between the two:
-
-- The C++ abstract machine assumes a unified memory address space, meaning that one can always access any given address in memory (assuming the absence of data races). HIP however introduces several memory namespaces, an address from one means nothing in another. Moreover, not all address spaces are accessible from all contexts.
-- Looking at Block Diagram of an RDNA3 Compute Unit. and Block Diagram of a CDNA3 Compute Unit. , you can see that every CU has an instance of storage backing the namespace \_\_shared\_\_ . Even if the host were to have access to these regions of memory, the performance benefits of the segmented memory subsystem are supported by the inability of asynchronous access from the host.
-- Not all C++ language features map cleanly to typical device architectures, some are very expensive (meaning slow) to implement on GPU devices, therefor they are forbidden in device contexts to avoid users tapping into features that unexpectedly decimate their program's performance. Offload devices targeted by HIP aren't general purpose devices, at least not in the sense that a CPU is. HIP focuses on data parallel computations and as such caters to throughput optimized architectures, such as GPUs or accelerators derived from GPU architectures.
-- Asynchrony is at the forefront of the HIP API. Computations launched on the device execute asynchronously with respect to the host, and it is the user's responsibility to synchronize their data dispatch/fetch with computations on the device.
-
-Note: HIP does perform implicit synchronization on occasions, more advanced than other APIs such as OpenCL or SYCL, in which the responsibility of synchronization mostly depends on the user.
-
-## 4.3 Single instruction multiple threads (SIMT)
-
-The SIMT programming model behind the HIP device-side execution is a middle-ground between SMT (Simultaneous Multi-Threading) programming known from multicore CPUs, and SIMD (Single Instruction, Multiple Data) programming mostly known from exploiting relevant instruction sets on CPUs (for example SSE/AVX/Neon).
-
-A HIP device compiler maps SIMT code written in HIP C++ to an inherently SIMD architecture (like GPUs). This is done by scalarizing the entire kernel and issuing the scalar instructions of multiple kernel instances (called threads) to each of the SIMD engine lanes, rather than exploiting data parallelism within a single instance of a kernel and spreading identical instructions over the available SIMD engines.
-
-Consider the following kernel:
-
-```
-__global__ void k(float4* a, const float4* b)
-{
-  int tid = threadIdx.x;
-  int bid = blockIdx.x;
-  int dim = blockDim.x;
-
-  a[tid] += (tid + bid - dim) * b[tid];
-}
-```
-
-The incoming four-vector of floating-point values b is multiplied by a scalar and then added element-wise to the fourvector floating-point values of a . On modern SIMD-capable architectures, the four-vector ops are expected to compile to a single SIMD instruction. However, GPU execution of this kernel will typically break down the vector elements into 4 separate threads for parallel execution, as seen in the following figure:
-
-Fig. 3: Instruction flow of the sample SIMT program.
-
-In HIP, lanes of the SIMD architecture are fed by mapping threads of a SIMT execution, one thread down each lane of an SIMD engine. Execution parallelism usually isn't exploited from the width of the built-in vector types, but across multiple threads via the thread ID constants threadIdx.x , blockIdx.x , etc.
-
-## 4.4 Inherent thread model
-
-The SIMT nature of HIP is captured by the ability to execute user-provided device programs, expressed as single-source C/C++ functions or sources compiled online/offline to binaries, in bulk.
-
-All threads of a kernel are uniquely identified by a set of integral values, called thread IDs. The set of integers identifying a thread relate to the hierarchy in which the threads execute.
-
-The thread hierarchy inherent to how AMD GPUs operate is depicted in the following figure.
-
-Fig. 4: Hierarchy of thread groups.
-
-## Warp (or Wavefront)
-
-The innermost grouping of threads is called a warp, or a wavefront in ISA terms. A warp is the most tightly coupled groups of threads, both physically and logically. Threads inside a warp are also called lanes, and the integral value identifying them is the lane ID.
-
-Tip: Lane IDs aren't queried like other thread IDs, but are user-calculated. As a consequence, they are only as multidimensional as the user interprets the calculated values to be.
-
-The size of a warp is architecture dependent and always fixed. For AMD GPUs the wavefront is typically 64 threads, though sometimes 32 threads. Warps are signified by the set of communication primitives at their disposal, as discussed in Warp cross-lane functions .
-
-The middle grouping is called a block or thread block. The defining feature of a block is that all threads in a block will share an instance of memory which they may use to share data or synchronize with one another.
-
-The size of a block is user-configurable but is limited by the queryable capabilities of the executing hardware. The unique ID of the thread within a block is 3-dimensional as provided by the API. When linearizing thread IDs within a block, assume the 'fast index' being dimension x , followed by the y and z dimensions.
-
-## Block
-
-## Grid
-
-The outermost grouping is called a grid. A grid manifests as a single dispatch of kernels for execution. The unique ID of each block within a grid is 3-dimensional, as provided by the API and is queryable by every thread within the block.
-
-## 4.4.1 Cooperative groups thread model
-
-The Cooperative groups API introduces new APIs to launch, group, subdivide, synchronize and identify threads, as well as some predefined group-collective algorithms, but most importantly a matching threading model to think in terms of. It relaxes some restrictions of the Inherent thread model imposed by the strict 1:1 mapping of architectural details to the programming model. Cooperative groups let you define your own set of thread groups which may fit your user-cases better than the defaults defined by the hardware.
-
-Note: The implicit groups defined by kernel launch parameters are still available when working with cooperative groups.
-
-For further information, see Cooperative groups.
-
-## 4.5 Memory model
-
-The hierarchy of threads introduced by the Inherent thread model is induced by the memory subsystem of GPUs. The following figure summarizes the memory namespaces and how they relate to the various levels of the threading model.
-
-Fig. 5: Memory hierarchy.
-
-## Local or per-thread memory
-
-Read-write storage only visible to the threads defining the given variables, also called per-thread memory. The size of a block for a given kernel, and thereby the number of concurrent warps, are limited by local memory usage. This relates to an important aspect: occupancy. This is the default memory namespace.
-
-## Shared memory
-
-Read-write storage visible to all the threads in a given block.
-
-## Global
-
-Read-write storage visible to all threads in a given grid. There are specialized versions of global memory with different usage semantics which are typically backed by the same hardware storing global.
-
-## Constant
-
-Read-only storage visible to all threads in a given grid. It is a limited segment of global with queryable size.
-
-## Texture
-
-Read-only storage visible to all threads in a given grid and accessible through additional APIs.
-
-## Surface
-
-A read-write version of texture memory.
-
-## 4.6 Execution model
-
-HIP programs consist of two distinct scopes:
-
-- The host-side API running on the host processor. There are two APIs available:
-- -The HIP runtime API which enables use of the single-source programming model.
-- -The HIP driver API which sits at a lower level and most importantly differs by removing some facilities provided by the runtime API, most importantly around kernel launching and argument setting. It is geared towards implementing abstractions atop, such as the runtime API itself. Offers two additional pieces of functionality not provided by the Runtime API: hipModule and hipCtx APIs. For further details, check HIP driver API.
-- The device-side kernels running on GPUs. Both the host and the device-side APIs have synchronous and asynchronous functions in them.
-
-Note: The HIP does not present two separate APIs link NVIDIA CUDA. HIP only extends the HIP runtime API with new APIs for hipModule and hipCtx .
-
-## 4.6.1 Host-side execution
-
-The part of the host-side API which deals with device management and their queries are synchronous. All asynchronous APIs, such as kernel execution, data movement and potentially data allocation/freeing all happen in the context of device streams.
-
-Streams are FIFO buffers of commands to execute relating to a given device. Commands which enqueue tasks on a stream all return promptly and the command is executed asynchronously. All side effects of a command on a stream are visible to all subsequent commands on the same stream. Multiple streams may point to the same device and those streams may be fed from multiple concurrent host-side threads. Execution on multiple streams may be concurrent but isn't required to be.
-
-Asynchronous APIs involving a stream all return a stream event which may be used to synchronize the execution of multiple streams. A user may enqueue a barrier onto a stream referencing an event. The barrier will block until the command related to the event does not complete, at which point all side effects of the command shall be visible to commands following the barrier, even if those side effects manifest on different devices.
-
-Streams also support executing user-defined functions as callbacks on the host. The stream will not launch subsequent commands until the callback completes.
-
-## 4.6.2 Device-side execution
-
-The SIMT programming model behind the HIP device-side execution is a middle-ground between SMT (Simultaneous Multi-Threading) programming known from multicore CPUs, and SIMD (Single Instruction, Multiple Data) programming mostly known from exploiting relevant instruction sets on CPUs (for example SSE/AVX/Neon).
-
-## 4.6.3 Kernel launch
-
-Kernels may be launched in multiple ways all with different syntaxes and intended use-cases.
-
-- Using the triple-chevron &lt;&lt;&lt;...&gt;&gt;&gt; operator on a \_\_global\_\_ annotated function.
-- Using hipLaunchKernelGGL() on a \_\_global\_\_ annotated function.
-
-Tip: This name by default is a macro expanding to triple-chevron. In cases where language syntax extensions are undesirable, or where launching templated and/or overloaded kernel functions define the HIP\_TEMPLATE\_KERNEL\_LAUNCH preprocessor macro before including the HIP headers to turn it into a templated function.
-
-- Using the launch APIs supporting the triple-chevron syntax directly.
-
-Caution: These APIs are intended to be used/generated by tools such as the HIP compiler itself and not intended towards end-user code. Should you be writing a tool having to launch device code using HIP, consider using these over the alternatives.
-
-## HARDWARE IMPLEMENTATION
-
-This chapter describes the typical hardware implementation of GPUs supported by HIP, and how the Inherent thread model maps to the hardware.
-
-## 5.1 Compute units
-
-The basic building block of a GPU is a compute unit (CU), also known as streaming multiprocessor (SM) on NVIDIA GPUs. The thread blocks making up a grid are scheduled for execution on CUs. Each block is assigned to an individual CU, and a CU can accommodate several blocks. Depending on their resource usage up to thousands of threads can reside on a CU.
-
-CUs contain an array of processing elements, referred to as vector ALU (VALU), that execute the actual instructions of the threads according to the SIMT model , together with the necessary registers and caches.
-
-The threads are executed in groupings called warps. The amount of threads making up a warp is architecture dependent. On AMD GPUs the warp size is commonly 64 threads, except in RDNA architectures which can utilize a warp size of 32 or 64 respectively. The warp size of supported AMD GPUs is listed in the Accelerator and GPU hardware specifications. NVIDIA GPUs have a warp size of 32.
-
-In contrast to CPUs, GPUs generally do not employ complex cache structures or control logic, like branch prediction or out-of-order execution, but instead rely on massive hardware multithreading to hide latency.
-
-Context switching between warps residing on a CU incurs no overhead, as the context for the warps is stored on the CU and does not need to be fetched from memory. If there are not enough free registers to accommodate all warps of a block, the block can not be scheduled to that CU and it has to wait until other blocks finish execution.
-
-The amount of warps that can reside concurrently on a CU, known as occupancy, is determined by the warp's resource usage of registers and shared memory.
-
-Fig. 1: An AMD Graphics Core Next (GCN) CU. The CDNA and RDNA CUs are based on variations of the GCN CU.
-
-On AMD GCN GPUs the basic structure of a CU is:
-
-- four Single Instruction Multiple Data units (SIMDs)
-- a vector cache
-- a local data share
-- and a scalar unit
-
-## 5.1.1 SIMD
-
-A SIMD consists of a VALU, that executes the instruction of a warp, together with a register file, that provides the registers warps.
-
-The size of the warp is inherently related to the width of the vector ALU of the SIMD. On GCN compute units the width of the VALU is 16, so a warp can be issued to a SIMD every 4 cycles. Since a CU has 4 SIMDs it issues one warp per cycle. The instructions of a warp are effectively executed in lock-step.
-
-A SIMD always executes the same instruction for the whole VALU. If the control flow of a warp diverges, the performance is decreased, as the results for the threads that do not participate in that branch have to be masked out, and the instructions of the other branch have to be executed in the same way. The best performance can therefore be achieved when thread divergence is kept to a warp level, i.e. when all threads in a warp take the same execution path.
-
-## 5.1.2 Vector cache
-
-The usage of cache on a GPU differs from that on a CPU, as there is less cache available per thread. Its main purpose is to coalesce memory accesses of the warps in order to reduce the amount of accesses to device memory, and make that memory available for other warps that currently reside on the compute unit, that also need to load those values.
-
-## 5.1.3 Local data share
-
-The local data share is memory that is accessible to all threads within a block. Its latency and bandwidth is comparable to that of the vector cache. It can be used to share memory between the threads in a block, or as a software managed cache.
-
-## 5.1.4 Scalar Unit
-
-The scalar unit performs instructions that are uniform within a warp. It thereby improves efficiency and reduces the pressure on the vector ALUs and the vector register file.
-
-## 5.2 CDNA architecture
-
-The general structure of CUs stays mostly as it is in GCN architectures. The most prominent change is the addition of matrix ALUs, which can greatly improve the performance of algorithms involving matrix multiply-accumulate operations for int8, float16, bfloat16 or float32.
-
-Fig. 2: Block Diagram of a CDNA3 Compute Unit.
-
-The image depicts a horizontal bar chart titled "Local Data Share." The chart is divided into two main sections: the left section and the right section.
-
-### Left Section:
-- **Title:** Local Data Share
-- **X-Axis:** Labeled as "Scheduler" and "Matrix Core Unit"
-- **Y-Axis:** Labeled as "Local Data Share"
-- **Data Points:**
-  - **Leftmost Data Point:** 100
-  - **Rightmost Data Point:** 100
-  - **Leftmost Data Point:** 100
-  - **Rightmost Data Point:** 100
-
-### Right Section:
-- **Title:** Shader Core
-- **X-Axis:** Labeled as "L1 Cache"
-- **Y-Axis:** Labeled as "Shader Core"
-- **Data Points:**
-  - **Leftmost Data Point:** 100
-  - **Rightmost
-
-![Image](hip_spec-with-image-refs_artifacts/image_000002_cfbddcc77ec59fe03ed26460c2aa6a54c9646387476d59ddc5eaabf5c6641187.png)
-
-## 5.3 RDNA architecture
-
-RDNA makes a fundamental change to CU design, by changing the size of a warp to 32 threads. This is done by effectively combining two GCN5 SIMDs, creating a VALU of width 32, so that a whole warp can be issued in one cycle. The CU is also replaced by the work group processor (WGP), which encompasses two CUs. For backwards compatibility the WGP can also run in wave64 mode, in which it issues a warp of size 64 in two cycles.
-
-It also adds an extra layer of cache to the WGP, shared by the CUs within it. This cache is referred to as L1 cache, promoting the per-CU cache to an L0 cache.
-
-Fig. 3: Block Diagram of an RDNA3 work group processor.
-
-Scheduler Vector GPR.
-
-![Image](hip_spec-with-image-refs_artifacts/image_000003_8ba501e7c1e4fd45f649ac07d48e9985a382fa290507dbd9ebd5ecafa7f23bd2.png)
-
-## 5.4 Shader engines
-
-For hardware implementation's sake, multiple CUs are grouped together into a Shader Engine or Compute Engine, typically sharing some fixed function units or memory subsystem resources.
-
-Fig. 4: Block Diagram of a CDNA2 Graphics Compute Die.
-
-The image is a table that contains data about different types of fabric. The table is divided into rows and columns, with each row representing a different type of fabric. The columns are labeled as follows:
-
-- Memory
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-
-![Image](hip_spec-with-image-refs_artifacts/image_000004_b494ff70840b694ceb0cb8c49613faf77041d4148e4ceb04903608a8022e3cbd.png)
-
-## CHAPTER
-
-## SIX
-
-## AMD COMMON LANGUAGE RUNTIMES (CLR)
-
-CLRcontains source codes for AMD's compute languages runtimes: HIP and OpenCL ™ . CLR is the part of HIP runtime which is supported on the AMD ROCm platform, it provides a header and runtime library built on top of HIP-Clang compiler. For developers and users, CLR implements HIP runtime APIs including streams, events, and memory APIs, which is a object library that is linked with the application. The source codes for all headers and the library implementation are available on GitHub in the CLR repository.
-
-## 6.1 Project organization
-
-CLR includes the following source code,
-
-- hipamd - contains implementation of HIP language on the AMD platform. It is hosted at clr/hipamd.
-- opencl - contains implementation of OpenCL™ on AMD platform. It is hosted at clr/opencl.
-- rocclr - contains common runtime used in HIP and OpenCL™ . This is hosted at clr/rocclr.
-
-## 6.2 How to build/install
-
-## 6.2.1 Prerequisites
-
-Please refer to Quick Start Guide in ROCm Docs.
-
-Building CLR requires rocm-hip-libraries meta package, which provides the pre-requisites for CLR.
-
-## 6.2.2 Linux
-
-- Clone this repository
-- For OpenCL ™
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        * For HIP
-```
-
-```
-<_Bash_>
-```
-
-```
-<_Haskell_>
-```
-
-Users can also build OCL and HIP at the same time by passing -DCLR\_BUILD\_HIP=ON -DCLR\_BUILD\_OCL=ON to configure command.
-
-For detail instructions, please refer to build HIP.
-
-## 6.2.3 Test
-
-hip-tests is a separate repository hosted at hip-tests.
-
-To run hip-tests please go to the repository and follow the steps.
-
-## 6.2.4 Release notes
-
-HIP provides release notes in CLR change log, which has records of changes in each release.
-
-## 7.1 Host Memory
-
-## 7.1.1 Introduction
-
-hipHostMalloc allocates pinned host memory which is mapped into the address space of all GPUs in the system, the memory can be accessed directly by the GPU device, and can be read or written with much higher bandwidth than pageable memory obtained with functions such as malloc() . There are two use cases for this host memory:
-
-- Faster HostToDevice and DeviceToHost Data Transfers: The runtime tracks the hipHostMalloc allocations and can avoid some of the setup required for regular unpinned memory. For exact measurements on a specific system, experiment with --unpinned and --pinned switches for the hipBusBandwidth tool.
-- Zero-Copy GPU Access: GPU can directly access the host memory over the CPU/GPU interconnect, without need to copy the data. This avoids the need for the copy, but during the kernel access each memory access must traverse the interconnect, which can be tens of times slower than accessing the GPU's local device memory. Zerocopy memory can be a good choice when the memory accesses are infrequent (perhaps only once). Zero-copy memory is typically 'Coherent' and thus not cached by the GPU but this can be overridden if desired.
-
-## 7.1.2 Memory allocation flags
-
-There are flags parameter which can specify options how to allocate the memory, for example, hipHostMallocPortable , the memory is considered allocated by all contexts, not just the one on which the allocation is made. hipHostMallocMapped , will map the allocation into the address space for the current device, and the device pointer can be obtained with the API hipHostGetDevicePointer() . hipHostMallocNumaUser is the flag to allow host memory allocation to follow Numa policy by user. Please note this flag is currently only applicable on Linux, under development on Windows.
-
-All allocation flags are independent, and can be used in any combination without restriction, for instance, hipHostMalloc can be called with both hipHostMallocPortable and hipHostMallocMapped flags set. Both usage models described above use the same allocation flags, and the difference is in how the surrounding code uses the host memory.
-
-## HIP PROGRAMMING MANUAL
-
-## 7.1.3 Numa-aware host memory allocation
-
-Numa policy determines how memory is allocated. Target of Numa policy is to select a CPU that is closest to each GPU. Numa distance is the measurement of how far between GPU and CPU devices.
-
-By default, each GPU selects a Numa CPU node that has the least Numa distance between them, that is, host memory will be automatically allocated closest on the memory pool of Numa node of the current GPU device. Using hipSetDevice API to a different GPU will still be able to access the host allocation, but can have longer Numa distance. Note, Numa policy is so far implemented on Linux, and under development on Windows.
-
-## 7.1.4 Coherency Controls
-
-ROCm defines two coherency options for host memory:
-
-- Coherent memory : Supports fine-grain synchronization while the kernel is running. For example, a kernel can perform atomic operations that are visible to the host CPU or to other (peer) GPUs. Synchronization instructions include threadfence\_system and C++11-style atomic operations. In order to achieve this fine-grained coherence, many AMD GPUs use a limited cache policy, such as leaving these allocations uncached by the GPU, or making them read-only.
-- Non-coherent memory : Can be cached by GPU, but cannot support synchronization while the kernel is running. Non-coherent memory can be optionally synchronized only at command (end-of-kernel or copy command) boundaries. This memory is appropriate for high-performance access when fine-grain synchronization is not required.
-
-HIP provides the developer with controls to select which type of memory is used via allocation flags passed to hipHostMalloc and the HIP\_HOST\_COHERENT environment variable. By default, the environment variable HIP\_HOST\_COHERENT is set to 0 in HIP. The control logic in the current version of HIP is as follows:
-
-- No flags are passed in: the host memory allocation is coherent, the HIP\_HOST\_COHERENT environment variable is ignored.
-- hipHostMallocCoherent=1 : The host memory allocation will be coherent, the HIP\_HOST\_COHERENT environment variable is ignored.
-- hipHostMallocMapped=1 : The host memory allocation will be coherent, the HIP\_HOST\_COHERENT environment variable is ignored.
-- hipHostMallocNonCoherent=1 , hipHostMallocCoherent=0 , and hipHostMallocMapped=0 : The host memory will be non-coherent, the HIP\_HOST\_COHERENT environment variable is ignored.
-- hipHostMallocCoherent=0 , hipHostMallocNonCoherent=0 , hipHostMallocMapped=0 , but one of the other HostMalloc flags is set:
-- -If HIP\_HOST\_COHERENT is defined as 1, the host memory allocation is coherent.
-- -If HIP\_HOST\_COHERENT is not defined, or defined as 0, the host memory allocation is non-coherent.
-- hipHostMallocCoherent=1 , hipHostMallocNonCoherent=1 : Illegal.
-
-## 7.1.5 Visibility of Zero-Copy Host Memory
-
-Coherent host memory is automatically visible at synchronization points. Non-coherent
-
-| HIP API Synchronization Effect                                                                        | Fence                 | Coherent Memory ity   | Host Visibil-   | Non-Coherent Host Memory Visi- bility   |
-|-------------------------------------------------------------------------------------------------------|-----------------------|-----------------------|-----------------|-----------------------------------------|
-| hipStreamSynchronize host waits for all commands in the spec- ified stream to complete                | system- scope release | yes                   |                 | yes                                     |
-| hipDeviceSynchronize host waits for all commands in all streams on the specified device to com- plete | system- scope release | yes                   |                 | yes                                     |
-| hipEventSynchronize host waits for the specified event to com- plete                                  | device- scope release | yes                   |                 | depends - see below                     |
-| hipStreamWaitEvent stream waits for the specified event to complete                                   | none                  | yes                   |                 | no                                      |
-
-## 7.1.6 hipEventSynchronize
-
-Developers can control the release scope for hipEvents :
-
-- By default, the GPU performs a device-scope acquire and release operation with each recorded event. This will make host and device memory visible to other commands executing on the same device.
-
-A stronger system-level fence can be specified when the event is created with hipEventCreateWithFlags :
-
-- hipEventReleaseToSystem : Perform a system-scope release operation when the event is recorded. This will make both Coherent and Non-Coherent host memory visible to other agents in the system, but may involve heavyweight operations such as cache flushing. Coherent memory will typically use lighter-weight in-kernel synchronization mechanisms such as an atomic operation and thus does not need to use hipEventReleaseToSystem .
-- hipEventDisableTiming : Events created with this flag will not record profiling data and provide the best performance if used for synchronization.
-
-## 7.1.7 Summary and Recommendations
-
-- Coherent host memory is the default and is the easiest to use since the memory is visible to the CPU at typical synchronization points. This memory allows in-kernel synchronization commands such as threadfence\_system to work transparently.
-- HIP/ROCm also supports the ability to cache host memory in the GPU using the 'Non-Coherent' host memory allocations. This can provide performance benefit, but care must be taken to use the correct synchronization.
-
-## 7.1.8 Managed memory allocation
-
-Managed memory, including the \_\_managed\_\_ keyword, is supported in HIP combined host/device compilation, on Linux, not on Windows (under development).
-
-Managed memory, via unified memory allocation, allows data be shared and accessible to both the CPU and GPU using a single pointer. The allocation will be managed by AMD GPU driver using the Linux HMM (Heterogeneous Memory Management) mechanism, the user can call managed memory API hipMallocManaged to allocate a large chunk of HMMmemory, execute kernels on device and fetch data between the host and device as needed.
-
-In HIP application, it is recommended to do the capability check before calling the managed memory APIs. For example:
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?>                                                                                                                                                                                                        </?>
-```
-
-Please note, the managed memory capability check may not be necessary, but if HMM is not supported, then managed malloc will fall back to using system memory and other managed memory API calls will have undefined behavior.
-
-Note, managed memory management is implemented on Linux, not supported on Windows yet.
-
-## 7.1.9 HIP Stream Memory Operations
-
-HIP supports Stream Memory Operations to enable direct synchronization between Network Nodes and GPU. Following new APIs are added, hipStreamWaitValue32 hipStreamWaitValue64 hipStreamWriteValue32 hipStreamWriteValue64
-
-Note, CPU access to the semaphore's memory requires volatile keyword to disable CPU compiler's optimizations on memory access. For more details, please check the documentation HIP-API.pdf .
-
-Please note, HIP stream does not guarantee concurrency on AMD hardware for the case of multiple (at least 6) longrunning streams executing concurrently, using hipStreamSynchronize(nullptr) for synchronization.
-
-## 7.2 Direct Dispatch
-
-HIP runtime has Direct Dispatch enabled by default in ROCM 4.4 on Linux. With this feature we move away from our conventional producer-consumer model where the runtime creates a worker thread(consumer) for each HIP Stream, and the host thread(producer) enqueues commands to a command queue(per stream).
-
-For Direct Dispatch, HIP runtime would directly enqueue a packet to the AQL queue (user mode queue on GPU) on the Dispatch API call from the application. That has shown to reduce the latency to launch the first wave on the idle GPU and total time of tiny dispatches synchronized with the host.
-
-In addition, eliminating the threads in runtime has reduced the variance in the dispatch numbers as the thread scheduling delays and atomics/locks synchronization latencies are reduced.
-
-This feature can be disabled via setting the following environment variable, AMD\_DIRECT\_DISPATCH=0
-
-Note, Direct Dispatch is implemented on Linux. It is currently not supported on Windows.
-
-## 7.3 HIP Runtime Compilation
-
-HIP now supports runtime compilation (HIP RTC), the usage of which will provide the possibility of optimizations and performance improvement compared with other APIs via regular offline static compilation.
-
-HIP RTC APIs accept HIP source files in character string format as input parameters and create handles of programs by compiling the HIP source files without spawning separate processes.
-
-For more details on HIP RTC APIs, refer to HIP Runtime API Reference .
-
-For Linux developers, the link here shows an example how to program HIP application using runtime compilation mechanism, and a detailed HIP RTC programming guide is also available.
-
-## 7.4 HIP Graph
-
-HIP graph is supported. For more details, refer to the HIP API Guide.
-
-## 7.5 Device-Side Malloc
-
-HIP-Clang now supports device-side malloc and free. This implementation does not require the use of hipDeviceSetLimit(hipLimitMallocHeapSize,value) nor respects any setting. The heap is fully dynamic and can grow until the available free memory on the device is consumed.
-
-## 7.6 Use of Per-thread default stream
-
-The per-thread default stream is supported in HIP. It is an implicit stream local to both the thread and the current device. This means that the command issued to the per-thread default stream by the thread does not implicitly synchronize with other streams (like explicitly created streams), or default per-thread stream on other threads. The per-thread default stream is a blocking stream and will synchronize with the default null stream if both are used in a program. The per-thread default stream can be enabled via adding a compilation option, -fgpu-default-stream=per-thread .
-
-And users can explicitly use hipStreamPerThread as per-thread default stream handle as input in API commands. There are test codes as examples in the link.
-
-## 7.7 Use of Long Double Type
-
-In HIP-Clang, long double type is 80-bit extended precision format for x86\_64, which is not supported by AMDGPU. HIP-Clang treats long double type as IEEE double type for AMDGPU. Using long double type in HIP source code will not cause issue as long as data of long double type is not transferred between host and device. However, long double type should not be used as kernel argument type.
-
-## 7.8 Use of \_Float16 Type
-
-If a host function is to be used between clang (or hipcc) and gcc for x86\_64, i.e. its definition is compiled by one compiler but the caller is compiled by a different compiler, \_Float16 or aggregates containing \_Float16 should not be used as function argument or return type. This is due to lack of stable ABI for \_Float16 on x86\_64. Passing \_Float16 or aggregates containing \_Float16 between clang and gcc could cause undefined behavior.
-
-## 7.9 FMA and contractions
-
-By default HIP-Clang assumes -ffp-contract=fast-honor-pragmas . Users can use #pragma clang fp contract(on|off|fast) to control fp contraction of a block of code. For x86\_64, FMA is off by default since the generic x86\_64 target does not support FMA by default. To turn on FMA on x86\_64, either use -mfma or -march=native on CPU's supporting FMA.
-
-When contractions are enabled and the CPU has not enabled FMA instructions, the GPU can produce different numerical results than the CPU for expressions that can be contracted. Tolerance should be used for floating point comparisons.
-
-## 7.10 Math functions with special rounding modes
-
-Note: Currently, HIP only supports basic math functions with rounding modern (round to nearest). HIP does not support basic math functions with rounding modes ru (round up), rd (round down), and rz (round towards zero).
-
-## 7.11 Creating Static Libraries
-
-HIP-Clang supports generating two types of static libraries. The first type of static library does not export device functions, and only exports and launches host functions within the same library. The advantage of this type is the ability to link with a non-hipcc compiler such as gcc. The second type exports device functions to be linked by other code objects. However, this requires using hipcc as the linker.
-
-In addition, the first type of library contains host objects with device code embedded as fat binaries. It is generated using the flag -emit-static-lib. The second type of library contains relocatable device objects and is generated using ar .
-
-Here is an example to create and use static libraries:
-
-- Type 1 using --emit-static-lib :
-- Type 2 using system ar :
-
-```
-<_Bash_>
-```
-
-```
-hipcc hipDevice.cpp -c -fgpu-rdc -o hipDevice.o
-ar rcsD libHipDevice.a hipDevice.o
-hipcc libHipDevice.a test.cpp -fgpu-rdc -o test.out
-```
-
-For more information, please see HIP samples host functions and device\_functions.
-
-CHAPTER
-
-## EIGHT
-
-## HIP PORTING GUIDE
-
-In addition to providing a portable C++ programming environment for GPUs, HIP is designed to ease the porting of existing CUDA code into the HIP environment. This section describes the available tools and provides practical suggestions on how to port CUDA code and work through common issues.
-
-## 8.1 Porting a New CUDA Project
-
-## 8.1.1 General Tips
-
-- Starting the port on a CUDA machine is often the easiest approach, since you can incrementally port pieces of the code to HIP while leaving the rest in CUDA. (Recall that on CUDA machines HIP is just a thin layer over CUDA, so the two code types can interoperate on NVCC platforms.) Also, the HIP port can be compared with the original CUDA code for function and performance.
-- Once the CUDA code is ported to HIP and is running on the CUDA machine, compile the HIP code using the HIP compiler on an AMD machine.
-- HIP ports can replace CUDA versions: HIP can deliver the same performance as a native CUDA implementation, with the benefit of portability to both NVIDIA and AMD architectures as well as a path to future C++ standard support. You can handle platform-specific features through conditional compilation or by adding them to the open-source HIP infrastructure.
-- Use hipconvertinplace-perl.sh to hipify all code files in the CUDA source directory.
-
-## 8.1.2 Scanning existing CUDA code to scope the porting effort
-
-The hipexamine-perl.sh tool will scan a source directory to determine which files contain CUDA code and how much of that code can be automatically hipified.
-
-```
-<_Cuda_>
-```
-
-(continued from previous page)
-
-```
-                                                                                                                                                                                                        (continued from previous page)
-```
-
-hipexamine-perl scans each code file (cpp, c, h, hpp, etc.) found in the specified directory:
-
-- Files with no CUDA code ( kmeans.h ) print one line summary just listing the source file name.
-- Files with CUDA code print a summary of what was found - for example the kmeans\_cuda\_kernel.cu file:
-- Interesting information in kmeans\_cuda\_kernel.cu :
-- -How many CUDA calls were converted to HIP (40)
-- -Breakdown of the CUDA functionality used ( dev:0 mem:0 etc). This file uses many CUDA builtins (37) and texture functions (3).
-- -Warning for code that looks like CUDA API but was not converted (0 in this file).
-- -Count Lines-of-Code (LOC) - 185 for this file.
-- hipexamine-perl also presents a summary at the end of the process for the statistics collected across all files. This has similar format to the per-file reporting, and also includes a list of all kernels which have been called. An example from above:
-
-```
-<_SQL_>
-```
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        --event:0                                                                                                                                                                                                        -event:0
-```
-
-## 8.1.3 Converting a project 'in-place'
-
-```
->
-```
-
-```
-| > hipify-perl --inplace
-```
-
-For each input file FILE, this script will:
-
-- If FILE.prehip file does not exist, copy the original code to a new file with extension .prehip . Then hipify the code file.
-- If FILE.prehip file exists, hipify FILE.prehip and save to FILE.
-
-This is useful for testing improvements to the hipify toolset.
-
-The hipconvertinplace-perl.sh script will perform inplace conversion for all code files in the specified directory. This can be quite handy when dealing with an existing CUDA code base since the script preserves the existing directory structure and filenames - and includes work. After converting in-place, you can review the code to add additional parameters to directory names.
-
-- &gt; hipconvertinplace-perl.sh MY\_SRC\_DIR
-
-## 8.1.4 Library Equivalents
-
-Most CUDA libraries have a corresponding ROCm library with similar functionality and APIs. However, ROCm also provides HIP marshalling libraries that greatly simplify the porting process because they more precisely reflect their CUDAcounterparts and can be used with either the AMD or NVIDIA platforms (see 'Identifying HIP Target Platform' below). There are a few notable exceptions:
-
-- MIOpen does not have a marshalling library interface to ease porting from cuDNN.
-- RCCL is a drop-in replacement for NCCL and implements the NCCL APIs.
-- hipBLASLt does not have a ROCm library but can still target the NVIDIA platform, as needed.
-- EIGEN's HIP support is part of the library.
-
-| CUDA brary   | Li-   | HIP Li- brary   | ROCm Li- brary   | Comment                                                                          |
-|--------------|-------|-----------------|------------------|----------------------------------------------------------------------------------|
-| cuBLAS       |       | hipBLAS         | rocBLAS          | Basic Linear Algebra Subroutines                                                 |
-| cuBLASLt     |       | hip- BLASLt     | N/A              | Basic Linear Algebra Subroutines, lightweight and new flexible API               |
-| cuFFT        |       | hipFFT          | rocFFT           | Fast Fourier Transfer Library                                                    |
-| cuSPARSE     |       | hipSPARSE       | rocSPARSE        | Sparse BLAS + SPMV                                                               |
-| cuSOLVER     |       | hip- SOLVER     | rocSOLVER        | Lapack library                                                                   |
-| AmgX         |       | N/A             | rocALU- TION     | Sparse iterative solvers and preconditioners with algebraic multigrid            |
-| Thrust       |       | N/A             | rocThrust        | C++ parallel algorithms library                                                  |
-| CUB          |       | hipCUB          | rocPRIM          | Low Level Optimized Parallel Primitives                                          |
-| cuDNN        |       | N/A             | MIOpen           | Deep learning Solver Library                                                     |
-| cuRAND       |       | hipRAND         | rocRAND          | Random Number Generator Library                                                  |
-| EIGEN        |       | EIGEN           | N/A              | C++ template library for linear algebra: matrices, vectors, numeri- cal solvers, |
-| NCCL         |       | N/A             | RCCL             | Communications Primitives Library based on the MPI equivalents                   |
-
-## 8.2 Distinguishing Compiler Modes
-
-## 8.2.1 Identifying HIP Target Platform
-
-All HIP projects target either AMD or NVIDIA platform. The platform affects which headers are included and which libraries are used for linking.
-
-- HIP\_PLATFORM\_AMD is defined if the HIP platform targets AMD. Note, HIP\_PLATFORM\_HCC was previously defined if the HIP platform targeted AMD, it is deprecated.
-- HIP\_PLATFORM\_NVDIA is defined if the HIP platform targets NVIDIA. Note, HIP\_PLATFORM\_NVCC was previously defined if the HIP platform targeted NVIDIA, it is deprecated.
-
-## 8.2.2 Identifying the Compiler: hip-clang or NVCC
-
-Often, it's useful to know whether the underlying compiler is HIP-Clang or NVCC. This knowledge can guard platformspecific code or aid in platform-specific performance tuning.
-
-```
-    #ifdef __HIP_PLATFORM_AMD__
-    // Compiled with HIP-Clang
-    #endif
-```
-
-```
-#ifdef __HIP_PLATFORM_NVIDIA__
-// Compiled with nvcc
-//  Could be compiling with CUDA language extensions enabled (for example, a ".cu file)
-//  Could be in pass-through mode to an underlying host compile OR (for example, a.cpp_
---file)
-```
-
-```
-        #ifdef __CUDACC__
-        // Compiled with nvcc (CUDA language extensions enabled)
-```
-
-```
-; enab1ed)
-```
-
-Compiler directly generates the host code (using the Clang x86 target) and passes the code to another host compiler. Thus, they have no equivalent of the \_\_CUDACC\_\_ define.
-
-## 8.2.3 Identifying Current Compilation Pass: Host or Device
-
-NVCCmakestwo passes over the code: one for host code and one for device code. HIP-Clang will have multiple passes over the code: one for the host code, and one for each architecture on the device code. \_\_HIP\_DEVICE\_COMPILE\_\_ is set to a nonzero value when the compiler (HIP-Clang or NVCC) is compiling code for a device inside a \_\_global\_\_ kernel or for a device function. \_\_HIP\_DEVICE\_COMPILE\_\_ can replace #ifdef checks on the \_\_CUDA\_ARCH\_\_ define.
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                        #if __HIP__DEVICE__COMPILE__
-```
-
-Unlike \_\_CUDA\_ARCH\_\_ , the \_\_HIP\_DEVICE\_COMPILE\_\_ value is 1 or undefined, and it doesn't represent the feature capability of the target device.
-
-## 8.2.4 Compiler Defines: Summary
-
-| Define                      | HIP-Clang                                                         | NVCC                                                                                          | Other (GCC, ICC, Clang, etc.)                               |
-|-----------------------------|-------------------------------------------------------------------|-----------------------------------------------------------------------------------------------|-------------------------------------------------------------|
-| HIP-related defines:        |                                                                   |                                                                                               |                                                             |
-| __HIP_PLATFORM_AMD__        | Defined                                                           | Undefined                                                                                     | Defined if targetingAMD platform; undefined oth- erwise     |
-| __HIP_PLATFORM_NVIDIA__     | Undefined                                                         | Defined                                                                                       | Defined if targeting NVIDIA platform; unde- fined otherwise |
-| __HIP_DEVICE_COMPILE__      | 1 if compiling for device; un- defined if compiling for host      | 1 if compiling for device; undefined if compiling for host                                    | Undefined                                                   |
-| __HIPCC__                   | Defined                                                           | Defined                                                                                       | Undefined                                                   |
-| __HIP_ARCH_*                | 0 or 1 depending on feature support (see below)                   | 0 or 1 depending on feature support (see below)                                               | 0                                                           |
-| NVCC- related defines:      |                                                                   |                                                                                               |                                                             |
-| __CUDACC__                  | Defined if source code is compiled by NVCC; unde- fined otherwise | Undefined                                                                                     |                                                             |
-| __NVCC__ Undefined          | Defined                                                           | Undefined                                                                                     |                                                             |
-| __CUDA_ARCH__               | Undefined                                                         | Unsigned representing compute capa- bility (e.g., '130') if in device code; 0 if in host code | Undefined                                                   |
-| hip-clang- related defines: |                                                                   |                                                                                               |                                                             |
-| __HIP__ HIP-Clang common    | Defined                                                           | Undefined                                                                                     | Undefined                                                   |
-| defines: __clang__          | Defined                                                           | Defined                                                                                       | Undefined                                                   |
-
-## 8.3 Identifying Architecture Features
-
-## 8.3.1 HIP\_ARCH Defines
-
-Some CUDA code tests \_\_CUDA\_ARCH\_\_ for a specific value to determine whether the machine supports a certain architectural feature. For instance,
-
-```
-        | #if (__CUDA_ARCH__ >= 13 0)
-```
-
-```
-    |// doubles are supported
-```
-
-This type of code requires special attention, since AMD and CUDA devices have different architectural capabilities. Moreover, you can't determine the presence of a feature using a simple comparison against an architecture's version
-
-number. HIP provides a set of defines and device properties to query whether a specific architectural feature is supported.
-
-The \_\_HIP\_ARCH\_* defines can replace comparisons of \_\_CUDA\_ARCH\_\_ values:
-
-```
-//#if (__CUDA_ARCH__ >= 130)   // non-portable
-if __HIP_ARCH_HAS_DOUBLES__ {  // portable HIP feature query
-    // doubles are supported
-}
-```
-
-For host code, the \_\_HIP\_ARCH\_\_* defines are set to 0. You should only use the \_\_HIP\_ARCH\_\_ fields in device code.
-
-## 8.3.2 Device-Architecture Properties
-
-Host code should query the architecture feature flags in the device properties that hipGetDeviceProperties returns, rather than testing the 'major' and 'minor' fields directly:
-
-```
-hipGetDeviceProperties(&deviceProp, device);
-//if ((deviceProp.major == 1 && deviceProp.minor < 2))  // non-portable
-if (deviceProp.arch.hasSharedInt32Atomics) {            // portable HIP feature query
-    // has shared int32 atomic operations...
-}
-```
-
-## 8.3.3 Table of Architecture Properties
-
-The table below shows the full set of architectural properties that HIP supports.
-
-| Define (use only in device code)                                                                                               | Device Property (run- time query)                       | Comment                                                                                                                                |
-|--------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------|
-| 32-bit atomics:                                                                                                                |                                                         |                                                                                                                                        |
-| __HIP_ARCH_HAS_GLOBAL_INT32_ATOMICS__ __HIP_ARCH_HAS_GLOBAL_FLOAT_ATOMIC_EXCH__                                                | hasGlobalInt32Atomics hasGlobalFloatAtomicExch          | 32-bit integer atomics for global memory 32-bit float atomic exchange for global mem- ory                                              |
-| __HIP_ARCH_HAS_SHARED_INT32_ATOMICS__ __HIP_ARCH_HAS_SHARED_FLOAT_ATOMIC_EXCH__                                                | hasSharedInt32Atomics hasSharedFloatAtomicExch          | 32-bit integer atomics for shared memory 32-bit float atomic exchange for shared mem- ory                                              |
-| __HIP_ARCH_HAS_FLOAT_ATOMIC_ADD__                                                                                              | hasFloatAtomicAdd                                       | 32-bit float atomic add in global and shared memory                                                                                    |
-| 64-bit atomics:                                                                                                                |                                                         |                                                                                                                                        |
-| __HIP_ARCH_HAS_GLOBAL_INT64_ATOMICS__ __HIP_ARCH_HAS_SHARED_INT64_ATOMICS__ Doubles:                                           | hasGlobalInt64Atomics hasSharedInt64Atomics             | 64-bit integer atomics for global memory 64-bit integer atomics for shared memory                                                      |
-| __HIP_ARCH_HAS_DOUBLES__ Warp cross-lane operations:                                                                           | hasDoubles                                              | Double-precision floating point                                                                                                        |
-| __HIP_ARCH_HAS_WARP_VOTE__ __HIP_ARCH_HAS_WARP_BALLOT__ __HIP_ARCH_HAS_WARP_SHUFFLE__ __HIP_ARCH_HAS_WARP_FUNNEL_SHIFT__ Sync: | hasWarpVote hasWarpBallot hasWarpShuffle hasFunnelShift | Warp vote instructions ( any , all ) Warp ballot instructions Warp shuffle operations ( shfl_* ) Funnel shift two input words into one |
-|                                                                                                                                | hasThreadFenceSystem hasSyncThreadsExt                  | threadfence_system syncthreads_count , syncthreads_and                                                                                 |
-| __HIP_ARCH_HAS_THREAD_FENCE_SYSTEM__                                                                                           |                                                         |                                                                                                                                        |
-| __HIP_ARCH_HAS_SYNC_THREAD_EXT__                                                                                               |                                                         | , syncthreads_or                                                                                                                       |
-| Miscellaneous:                                                                                                                 |                                                         |                                                                                                                                        |
-| __HIP_ARCH_HAS_SURFACE_FUNCS__                                                                                                 | hasSurfaceFuncs                                         |                                                                                                                                        |
-| __HIP_ARCH_HAS_3DGRID__                                                                                                        | has3dGrid                                               | Grids and groups are 3D                                                                                                                |
-| __HIP_ARCH_HAS_DYNAMIC_PARALLEL__                                                                                              | hasDynamicParallelism                                   |                                                                                                                                        |
-
-## 8.4 Finding HIP
-
-Makefiles can use the following syntax to conditionally provide a default HIP\_PATH if one does not exist:
-
-HIP\_PATH ?= $( shell hipconfig --path )
-
-## 8.5 Identifying HIP Runtime
-
-HIP can depend on rocclr, or CUDA as runtime
-
-- AMDplatform On AMD platform, HIP uses Radeon Open Compute Common Language Runtime, called ROCclr. ROCclr is a virtual device interface that HIP runtimes interact with different backends which allows runtimes to work on Linux , as well as Windows without much efforts.
-- NVIDIA platform On NVIDIA platform, HIP is just a thin layer on top of CUDA. On non-AMD platform, HIP runtime determines if CUDA is available and can be used. If available, HIP\_PLATFORM is set to nvidia and underneath CUDA path is used.
-
-## 8.6 hipLaunchKernelGGL
-
-hipLaunchKernelGGL is a macro that can serve as an alternative way to launch kernel, which accepts parameters of launch configurations (grid dims, group dims, stream, dynamic shared size) followed by a variable number of kernel arguments. It can replace &lt;&lt;&lt; &gt;&gt;&gt;, if the user so desires.
-
-## 8.7 Compiler Options
-
-hipcc is a portable compiler driver that will call NVCC or HIP-Clang (depending on the target system) and attach all required include and library options. It passes options through to the target compiler. Tools that call hipcc must ensure the compiler options are appropriate for the target compiler. The hipconfig script may helpful in identifying the target platform, compiler and runtime. It can also help set options appropriately.
-
-## 8.7.1 Compiler options supported on AMD platforms
-
-Here are the main compiler options supported on AMD platforms by HIP-Clang.
-
-| Option      | Description                                                                                                                                                                                                                                                                                                                                                                           |
-|-------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-|             | --amdgpu-target=<gpu_arch> [DEPRECATED] This option is being replaced by --offload-arch=<target> . Generate code for the given GPU target. Supported targets are gfx701, gfx801, gfx802, gfx803, gfx900, gfx906, gfx908, gfx1010, gfx1011, gfx1012, gfx1030, gfx1031. This option could appear multiple times on the same command line to generate a fat binary for multiple targets. |
-| --fgpu-rdc  | Generate relocatable device code, which allows kernels or device functions calling device functions in different translation units.                                                                                                                                                                                                                                                   |
-| -ggdb       | Equivalent to -g plus tuning for GDB. This is recommended when using ROCm's GDB to debug GPU code.                                                                                                                                                                                                                                                                                    |
-|             | --gpu-max-threads-per-block=<num> Generate code to support up to the specified number of threads per block.                                                                                                                                                                                                                                                                           |
-| -O<n>       | Specify the optimization level.                                                                                                                                                                                                                                                                                                                                                       |
-|             | -offload-arch=<target> Specify the AMDGPUtarget ID.                                                                                                                                                                                                                                                                                                                                   |
-| -save-temps | Save the compiler generated intermediate files.                                                                                                                                                                                                                                                                                                                                       |
-| -v          | Show the compilation steps.                                                                                                                                                                                                                                                                                                                                                           |
-
-## 8.8 Linking Issues
-
-## 8.8.1 Linking With hipcc
-
-hipcc adds the necessary libraries for HIP as well as for the accelerator compiler (NVCC or AMD compiler). We recommend linking with hipcc since it automatically links the binary to the necessary HIP runtime libraries. It also has knowledge on how to link and to manage the GPU objects.
-
-## 8.8.2 -lm Option
-
-hipcc adds -lm by default to the link command.
-
-## 8.9 Linking Code With Other Compilers
-
-CUDA code often uses NVCC for accelerator code (defining and launching kernels, typically defined in .cu or .cuh files). It also uses a standard compiler (g++) for the rest of the application. NVCC is a preprocessor that employs a standard host compiler (gcc) to generate the host code. Code compiled using this tool can employ only the intersection of language features supported by both NVCC and the host compiler. In some cases, you must take care to ensure the data types and alignment of the host compiler are identical to those of the device compiler. Only some host compilers are supported-for example, recent NVCC versions lack Clang host-compiler capability.
-
-HIP-Clang generates both device and host code using the same Clang-based compiler. The code uses the same API as gcc, which allows code generated by different gcc-compatible compilers to be linked together. For example, code compiled using HIP-Clang can link with code compiled using 'standard' compilers (such as gcc, ICC and Clang). Take care to ensure all compilers use the same standard C++ header and library formats.
-
-## 8.9.1 libc++ and libstdc++
-
-hipcc links to libstdc++ by default. This provides better compatibility between g++ and HIP.
-
-If you pass --stdlib=libc++ to hipcc, hipcc will use the libc++ library. Generally, libc++ provides a broader set of C++ features while libstdc++ is the standard for more compilers (notably including g++).
-
-When cross-linking C++ code, any C++ functions that use types from the C++ standard library (including std::string, std::vector and other containers) must use the same standard-library implementation. They include the following:
-
-- Functions or kernels defined in HIP-Clang that are called from a standard compiler
-- Functions defined in a standard compiler that are called from HIP-Clang.
-
-Applications with these interfaces should use the default libstdc++ linking.
-
-Applications which are compiled entirely with hipcc, and which benefit from advanced C++ features not supported in libstdc++, and which do not require portability to NVCC, may choose to use libc++.
-
-## 8.9.2 HIP Headers ( hip\_runtime.h , hip\_runtime\_api.h )
-
-The hip\_runtime.h and hip\_runtime\_api.h files define the types, functions and enumerations needed to compile a HIP program:
-
-- hip\_runtime\_api.h : defines all the HIP runtime APIs (e.g., hipMalloc ) and the types required to call them. A source file that is only calling HIP APIs but neither defines nor launches any kernels can include hip\_runtime\_api.h . hip\_runtime\_api.h uses no custom Heterogeneous Compute (HC) language features and can be compiled using a standard C++ compiler.
-- hip\_runtime.h : included in hip\_runtime\_api.h . It additionally provides the types and defines required to create and launch kernels. hip\_runtime.h can be compiled using a standard C++ compiler but will expose a subset of the available functions.
-
-CUDAhasslightly different contents for these two files. In some cases you may need to convert hipified code to include the richer hip\_runtime.h instead of hip\_runtime\_api.h .
-
-## 8.9.3 Using a Standard C++ Compiler
-
-You can compile hip\_runtime\_api.h using a standard C or C++ compiler (e.g., gcc or ICC). The HIP include paths and defines ( \_\_HIP\_PLATFORM\_AMD\_\_ or \_\_HIP\_PLATFORM\_NVIDIA\_\_ ) must pass to the standard compiler; hipconfig then returns the necessary options:
-
-- &gt;
-
-```
-|> hipconfig --cxx_config
-```
-
-```
-                                                                                                                                                                                                        |  -D___HIP_PLATFORM_AMD___ -I/home/user1/hip/include
-```
-
-You can capture the hipconfig output and passed it to the standard compiler; below is a sample makefile syntax:
-
-```
-            |CPPFLAGS += $(shell $(HIP_PATH)/bin/hipconfig --cpp_config)
-```
-
-```
-
-)
-```
-
-NVCC includes some headers by default. However, HIP does not include default headers, and instead all required files must be explicitly included. Specifically, files that call HIP run-time APIs or define HIP kernels must explicitly include the appropriate HIP headers. If the compilation process reports that it cannot find necessary APIs (for example, error: identifier hipSetDevice is undefined ), ensure that the file includes hip\_runtime.h (or hip\_runtime\_api.h, if appropriate). The hipify-perl script automatically converts cuda\_runtime.h to hip\_runtime.h , and it converts cuda\_runtime\_api.h to hip\_runtime\_api.h , but it may miss nested headers or macros.
-
-## 8.9.3.1 cuda.h
-
-The HIP-Clang path provides an empty cuda.h file. Some existing CUDA programs include this file but don't require any of the functions.
-
-## 8.9.4 Choosing HIP File Extensions
-
-Many existing CUDA projects use the .cu and .cuh file extensions to indicate code that should be run through the NVCC compiler. For quick HIP ports, leaving these file extensions unchanged is often easier, as it minimizes the work required to change file names in the directory and #include statements in the files.
-
-For new projects or ports which can be re-factored, we recommend the use of the extension .hip.cpp for source files, and .hip.h or .hip.hpp for header files. This indicates that the code is standard C++ code, but also provides a unique indication for make tools to run hipcc when appropriate.
-
-## 8.10 Workarounds
-
-## 8.10.1 warpSize
-
-Code should not assume a warp size of 32 or 64. See Warp Cross-Lane Functions for information on how to write portable wave-aware code.
-
-## 8.10.2 Kernel launch with group size &gt; 256
-
-Kernel code should use \_\_attribute\_\_((amdgpu\_flat\_work\_group\_size(&lt;min&gt;,&lt;max&gt;))) . For example:
-
-```
-<_SQL_>
-```
-
-## 8.11 memcpyToSymbol
-
-HIP support for hipMemcpyToSymbol is complete. This feature allows a kernel to define a device-side data symbol which can be accessed on the host side. The symbol can be in \_\_constant or device space.
-
-Note that the symbol name needs to be encased in the HIP\_SYMBOL macro, as shown in the code example below. This also applies to hipMemcpyFromSymbol , hipGetSymbolAddress , and hipGetSymbolSize .
-
-For example:
-
-Device Code:
-
-```
-<_C++_>
-```
-
-(continued from previous page)
-
-```
-        {
-            A[i] = -1*i;
-            B[i] = 0;
-        }
-
-        HIP_ASSERT(hipMalloc((void**)&Ad, SIZE));
-
-        HIP_ASSERT(hipMemcpyToSymbol(HIP_SYMBOL(Value), A, SIZE, 0, hipMemcpyHostToDevice));
-        hipLaunchKernelGGL(Get, dim3(1,1,1), dim3(LEN,1,1), 0, 0, Ad);
-        HIP_ASSERT(hipMemcpy(B, Ad, SIZE, hipMemcpyDeviceToHost));
-
-        for(unsigned i=0;i<LEN;i++)
-        {
-            assert(A[i] == B[i]);
-        }
-        std::cout<<"Passed"<<std::endl;
-    }
-    
-    
-    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-```
-
-## 8.12 CU\_POINTER\_ATTRIBUTE\_MEMORY\_TYPE
-
-To get pointer's memory type in HIP/HIP-Clang, developers should use hipPointerGetAttributes API. First parameter of the API is hipPointerAttribute\_t which has 'type' as member variable. 'type' indicates input pointer is allocated on device or host.
-
-For example:
-
-```
-            For example:
-            double * ptr;
-            hipMalloc(reinterpret_cast<void**>(&ptr), sizeof(double));
-            hipPointerAttribute_t attr;
-            hipPointerGetAttributes(&attr, ptr); /*attr.type will have value as hipMemoryTypeDevice*/
-
-            double* ptrHost;
-            hipHostMalloc(&ptrHost, sizeof(double));
-            hipPointerAttribute_t attr;
-            hipPointerGetAttributes(&attr, ptrHost); /*attr.type will have value as _
-           ...hipMemoryTypeHost*/
-
-            Data data file.MaximumTime amount value as different from end.MaximumTime amount value
-```
-
-Please note, hipMemoryType enum values are different from cudaMemoryType enum values.
-
-For example, on AMD platform, hipMemoryType is defined in hip\_runtime\_api.h ,
-
-```
-            For example, on AMD platform, hipMemoryType is defined in hip_runtime_api.h,
-            
-        typedef enum hipMemoryType {
-            hipMemoryTypeHost = 0,     ///< Memory is physically located on host
-            hipMemoryTypeDevice = 1,  ///< Memory is physically located on device. (see deviceId,
-        --for specific device)
-            hipMemoryTypeArray = 2,   ///< Array memory, physically located on device. (see_,
-        --deviceId for specific device)
-            hipMemoryTypeUnified = 3, ///< Not used currently
-            hipMemoryTypeManaged = 4  ///< Managed memory, automatically managed by the unified.
-        --memory system
-        } hipMemoryType;
-```
-
-Looking into CUDA toolkit, it defines cudaMemoryType as following,
-
-```
-<_Cuda_>
-```
-
-In this case, memory type translation for hipPointerGetAttributes needs to be handled properly on NVIDIA platform to get the correct memory type in CUDA, which is done in the file nvidia\_hip\_runtime\_api.h .
-
-So in any HIP applications which use HIP APIs involving memory types, developers should use #ifdef in order to assign the correct enum values depending on NVIDIA or AMD platform.
-
-As an example, please see the code from the link.
-
-With the #ifdef condition, HIP APIs work as expected on both AMD and NVIDIA platforms.
-
-Note, cudaMemoryTypeUnregstered is currently not supported in hipMemoryType enum, due to HIP functionality backward compatibility.
-
-## 8.13 threadfence\_system
-
-threadfence\_system makes all device memory writes, all writes to mapped host memory, and all writes to peer memory visible to CPU and other GPU devices. Some implementations can provide this behavior by flushing the GPU L2 cache. HIP/HIP-Clang does not provide this functionality. As a workaround, users can set the environment variable HSA\_DISABLE\_CACHE=1 to disable the GPU L2 cache. This will affect all accesses and for all kernels and so may have a performance impact.
-
-## 8.13.1 Textures and Cache Control
-
-Compute programs sometimes use textures either to access dedicated texture caches or to use the texture-sampling hardware for interpolation and clamping. The former approach uses simple point samplers with linear interpolation, essentially only reading a single point. The latter approach uses the sampler hardware to interpolate and combine multiple samples. AMD hardware, as well as recent competing hardware, has a unified texture/L1 cache, so it no longer has a dedicated texture cache. But the NVCC path often caches global loads in the L2 cache, and some programs may benefit from explicit control of the L1 cache contents. We recommend the \_\_ldg instruction for this purpose.
-
-AMDcompilers currently load all data into both the L1 and L2 caches, so \_\_ldg is treated as a no-op.
-
-We recommend the following for functional portability:
-
-- For programs that use textures only to benefit from improved caching, use the \_\_ldg instruction
-- Programs that use texture object and reference APIs, work well on HIP
-
-## 8.14 More Tips
-
-## 8.14.1 HIP Logging
-
-Onan AMDplatform, set the AMD\_LOG\_LEVEL environment variable to log HIP application execution information.
-
-The value of the setting controls different logging level,
-
-```
-<_C++_>
-```
-
-Logging mask is used to print types of functionalities during the execution of HIP application. It can be set as one of the following values,
-
-```
-<_C++_>
-```
-
-## 8.14.2 Debugging hipcc
-
-To see the detailed commands that hipcc issues, set the environment variable HIPCC\_VERBOSE to 1. Doing so will print to stderr the HIP-clang (or NVCC) commands that hipcc generates.
-
-```
-export HIPCC_VERBOSE=1
-make
-
-...
-hipcc-cmd: /opt/rcm/bin/hipcc --offload-arch=native -x hip backprop_cuda.cu
-```
-
-## 8.14.3 Editor Highlighting
-
-See the utils/vim or utils/gedit directories to add handy highlighting to hip files.
-
-## PORTING CUDA DRIVER API
-
-## 9.1 Introduction to the CUDA Driver and Runtime APIs
-
-CUDA provides a separate CUDA Driver and Runtime APIs. The two APIs have significant overlap in functionality:
-
-- Both APIs support events, streams, memory management, memory copy, and error handling.
-- Both APIs deliver similar performance.
-- Driver APIs calls begin with the prefix cu while Runtime APIs begin with the prefix cuda . For example, the Driver API API contains cuEventCreate while the Runtime API contains cudaEventCreate , with similar functionality.
-- The Driver API defines a different but largely overlapping error code space than the Runtime API, and uses a different coding convention. For example, Driver API defines CUDA\_ERROR\_INVALID\_VALUE while the Runtime API defines cudaErrorInvalidValue
-
-The Driver API offers two additional pieces of functionality not provided by the Runtime API: cuModule and cuCtx APIs.
-
-## 9.1.1 cuModule API
-
-The Module section of the Driver API provides additional control over how and when accelerator code objects are loaded. For example, the driver API allows code objects to be loaded from files or memory pointers. Symbols for kernels or global data can be extracted from the loaded code objects. In contrast, the Runtime API automatically loads and (if necessary) compiles all of the kernels from an executable binary when run. In this mode, NVCC must be used to compile kernel code so the automatic loading can function correctly.
-
-Both Driver and Runtime APIs define a function for launching kernels (called cuLaunchKernel or cudaLaunchKernel . The kernel arguments and the execution configuration (grid dimensions, group dimensions, dynamic shared memory, and stream) are passed as arguments to the launch function. The Runtime additionally provides the &lt;&lt;&lt; &gt;&gt;&gt; syntax for launching kernels, which resembles a special function call and is easier to use than explicit launch API (in particular with respect to handling of kernel arguments). However, this syntax is not standard C++ and is available only when NVCC is used to compile the host code.
-
-The Module features are useful in an environment which generates the code objects directly, such as a new accelerator language front-end. Here, NVCC is not used. Instead, the environment may have a different kernel language or different compilation flow. Other environments have many kernels and do not want them to be all loaded automatically. The Module functions can be used to load the generated code objects and launch kernels. As we will see below, HIP defines a Module API which provides similar explicit control over code object management.
-
-## 9.1.2 cuCtx API
-
-The Driver API defines 'Context' and 'Devices' as separate entities. Contexts contain a single device, and a device can theoretically have multiple contexts. Each context contains a set of streams and events specific to the context. Historically contexts also defined a unique address space for the GPU, though this may no longer be the case in Unified Memory platforms (since the CPU and all the devices in the same process share a single unified address space). The Context APIs also provide a mechanism to switch between devices, which allowed a single CPU thread to send commands to different GPUs. HIP as well as a recent versions of CUDA Runtime provide other mechanisms to accomplish this feat - for example using streams or cudaSetDevice .
-
-The CUDA Runtime API unifies the Context API with the Device API. This simplifies the APIs and has little loss of functionality since each Context can contain a single device, and the benefits of multiple contexts has been replaced with other interfaces. HIP provides a context API to facilitate easy porting from existing Driver codes. In HIP, the Ctx functions largely provide an alternate syntax for changing the active device.
-
-Most new applications will prefer to use hipSetDevice or the stream APIs, therefore HIP has marked hipCtx APIs as deprecated . Support for these APIs may not be available in future releases. For more details on deprecated APIs please refer HIP deprecated APIs .
-
-## 9.2 HIP Module and Ctx APIs
-
-Rather than present two separate APIs, HIP extends the HIP API with new APIs for Modules and Ctx control.
-
-## 9.2.1 hipModule API
-
-Like the CUDA Driver API, the Module API provides additional control over how code is loaded, including options to load code from files or from in-memory pointers. NVCC and HIP-Clang target different architectures and use different code object formats: NVCC is cubin or ptx files, while the HIP-Clang path is the hsaco format. The external compilers which generate these code objects are responsible for generating and loading the correct code object for each platform. Notably, there is not a fat binary format that can contain code for both NVCC and HIP-Clang platforms. The following table summarizes the formats used on each platform:
-
-| Format                 | APIs                                                  | NVCC                       | HIP-CLANG          |
-|------------------------|-------------------------------------------------------|----------------------------|--------------------|
-| Code Object Fat Binary | hipModuleLoad , hipModuleLoadData hipModuleLoadFatBin | .cubin or PTX text .fatbin | .hsaco .hip_fatbin |
-
-hipcc uses HIP-Clang or NVCC to compile host codes. Both of these may embed code objects into the final executable, and these code objects will be automatically loaded when the application starts. The hipModule API can be used to load additional code objects, and in this way provides an extended capability to the automatically loaded code objects. HIP-Clang allows both of these capabilities to be used together, if desired. Of course it is possible to create a program with no kernels and thus no automatic loading.
-
-## 9.2.2 hipCtx API
-
-HIP provides a Ctx API as a thin layer over the existing Device functions. This Ctx API can be used to set the current context, or to query properties of the device associated with the context. The current context is implicitly used by other APIs such as hipStreamCreate .
-
-## 9.2.3 hipify translation of CUDA Driver API
-
-The HIPIFY tools convert CUDA Driver APIs for streams, events, modules, devices, memory management, context, profiler to the equivalent HIP driver calls. For example, cuEventCreate will be translated to hipEventCreate . HIPIFY tools also convert error codes from the Driver namespace and coding convention to the equivalent HIP error code. Thus, HIP unifies the APIs for these common functions.
-
-The memory copy API requires additional explanation. The CUDA driver includes the memory direction in the name of the API ( cuMemcpyH2D ) while the CUDA driver API provides a single memory copy API with a parameter that specifies the direction and additionally supports a 'default' direction where the runtime determines the direction automatically. HIP provides APIs with both styles: for example, hipMemcpyH2D as well as hipMemcpy . The first flavor may be faster in some cases since they avoid host overhead to detect the different memory directions.
-
-HIP defines a single error space, and uses camel-case for all errors (i.e. hipErrorInvalidValue ).
-
-## 9.2.3.1 Address Spaces
-
-HIP-Clang defines a process-wide address space where the CPU and all devices allocate addresses from a single unified pool. Thus addresses may be shared between contexts, and unlike the original CUDA definition a new context does not create a new address space for the device.
-
-## 9.2.3.2 Using hipModuleLaunchKernel
-
-hipModuleLaunchKernel is cuLaunchKernel in HIP world. It takes the same arguments as cuLaunchKernel .
-
-## 9.2.3.3 Additional Information
-
-- HIP-Clang creates a primary context when the HIP API is called. So in a pure driver API code, HIP-Clang will create a primary context while HIP/NVCC will have empty context stack. HIP-Clang will push primary context to context stack when it is empty. This can have subtle differences on applications which mix the runtime and driver APIs.
-
-## 9.2.4 hip-clang Implementation Notes
-
-## 9.2.4.1 .hip\_fatbin
-
-hip-clang links device code from different translation units together. For each device target, a code object is generated. Code objects for different device targets are bundled by clang-offload-bundler as one fatbinary, which is embeded as a global symbol \_\_hip\_fatbin in the .hip\_fatbin section of the ELF file of the executable or shared object.
-
-## 9.2.4.2 Initialization and Termination Functions
-
-hip-clang generates initialization and termination functions for each translation unit for host code compilation. The initialization functions call \_\_hipRegisterFatBinary to register the fatbinary embeded in the ELF file. They also call \_\_hipRegisterFunction and \_\_hipRegisterVar to register kernel functions and device side global variables. The termination functions call \_\_hipUnregisterFatBinary . hip-clang emits a global variable \_\_hip\_gpubin\_handle of void** type with linkonce linkage and inital value 0 for each host translation unit. Each initialization function checks \_\_hip\_gpubin\_handle and register the fatbinary only if \_\_hip\_gpubin\_handle is 0 and saves the return value of \_\_hip\_gpubin\_handle to \_\_hip\_gpubin\_handle . This is to guarantee that the fatbinary is only registered once. Similar check is done in the termination functions.
-
-## 9.2.4.3 Kernel Launching
-
-hip-clang supports kernel launching by CUDA &lt;&lt;&lt;&gt;&gt;&gt; syntax, hipLaunchKernelGGL. The latter one is macro which expand to CUDA &lt;&lt;&lt;&gt;&gt;&gt; syntax.
-
-When the executable or shared library is loaded by the dynamic linker, the initialization functions are called. In the initialization functions, when \_\_hipRegisterFatBinary is called, the code objects containing all kernels are loaded; when \_\_hipRegisterFunction is called, the stub functions are associated with the corresponding kernels in code objects.
-
-hip-clang implements two sets of kernel launching APIs.
-
-By default, in the host code, for the &lt;&lt;&lt;&gt;&gt;&gt; statement, hip-clang first emits call of hipConfigureCall to set up the threads and grids, then emits call of the stub function with the given arguments. In the stub function, hipSetupArgument is called for each kernel argument, then hipLaunchByPtr is called with a function pointer to the stub function. In hipLaunchByPtr , the real kernel associated with the stub function is launched.
-
-## 9.2.5 NVCC Implementation Notes
-
-## 9.2.5.1 Interoperation between HIP and CUDA Driver
-
-CUDA applications may want to mix CUDA driver code with HIP code (see example below). This table shows the type equivalence to enable this interaction.
-
-| HIP Type      | CU Driver Type   | CUDA Runtime Type   |
-|---------------|------------------|---------------------|
-| hipModule_t   | CUmodule         |                     |
-| hipFunction_t | CUfunction       |                     |
-| hipCtx_t      | CUcontext        |                     |
-| hipDevice_t   | CUdevice         |                     |
-| hipStream_t   | CUstream         | cudaStream_t        |
-| hipEvent_t    | CUevent          | cudaEvent_t         |
-| hipArray      | CUarray          | cudaArray           |
-
-## 9.2.5.2 Compilation Options
-
-The hipModule\_t interface does not support cuModuleLoadDataEx function, which is used to control PTX compilation options. HIP-Clang does not use PTX and does not support these compilation options. In fact, HIP-Clang code objects always contain fully compiled ISA and do not require additional compilation as a part of the load step. The corresponding HIP function hipModuleLoadDataEx behaves as hipModuleLoadData on HIP-Clang path (compilation options are not used) and as cuModuleLoadDataEx on NVCC path. For example (CUDA):
-
-```
-<_Cuda_>
-```
-
-HIP:
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?xml version="1.0" encoding="UTF-8" />
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        </?xml version="2.0" encoding="UTF-8" />
-                                                                                                                                                                                             <?xml version="3.0" encoding="UTF-8" />
-                                                                                                                                                                                            
-	         
-                                                                                                                                                                                             
-         
-                                                                                                                                                                                              <?xml version="4.0" encoding="UTF-8" />
-                                                                                                                                                                                             </?xml version="5.0" encoding="UTF-8" />
-                                                                                                                                                                                            
-
-          
-                                                                                                                                                                                             <?xml version="6.0" encoding="UTF-8" />
-                                                                                                                                                                                             >
-                                                                                                                                                                                                       <!xml version="7.0" encoding="UTF-8" />
-                                                                                                                                                                                             //
-                                                                                                                                                                                                       </!xml version="8.0" encoding="UTF-8" />
-                                                                                                                                                                                             }
-```
-
-The below sample shows how to use hipModuleGetFunction .
-
-```
-#include<hip_runtime.h>
-#include<hip_runtime_api.h>
-#include<iostream>
-#include<fstream>
-#include<vector>
-```
-
-```
-#include<hip_runtime.h>
-#include<hip_runtime_api.h>
-#include<iostream>
-#include<fstream>
-#include<vector>
-```
-
-```
-HIP Documentation, Release 6.1.40092
-
-
-
-
-#define LEN 64
-#define SIZE LEN<<2
-
-#ifdef __HIP_PLATFORM_AMD__
-#define fileName "vcpy_isa.co"
-#endif
-
-#ifdef __HIP_PLATFORM_NVIDIA__
-#define fileName "vcpy_isa.ptx"
-#endif
-
-#define kernel_name "hello_world"
-
-int main(){
-	float *A, *B;
-	hipDeviceptr_t Ad, Bd;
-	A = new float[LEN];
-	B = new float[LEN];
-
-	for(uint32_t i=0;i<LEN;i++){
-		A[i] = i*1.0f;
-		B[i] = 0.0f;
-		std::cout<<A[i] << " "<<B[i]<<std::endl;
-	}
-
-
-#ifdef __HIP_PLATFORM_NVIDIA__
-		hipInit(0);
-		hipDevice_t device;
-		hipCtx_t context;
-		hipDeviceGet(&device, 0);
-		hipCtxCreate(&context, 0, device);
-#endif
-
-	hipMalloc((void**)&Ad, SIZE);
-	hipMalloc((void**)&Bd, SIZE);
-
-	hipMemcpyHtoD(Ad, A, SIZE);
-	hipMemcpyHtoD(Bd, B, SIZE);
-	hipModule_t Module;
-	hipFunction_t Function;
-	hipModuleLoad(&Module, fileName);
-	hipModuleGetFunction(&Function, Module, kernel_name);
-
-	std::vector<void*>argBuffer(2);
-	memcpy(&argBuffer[0], &Ad, sizeof(void*));
-	memcpy(&argBuffer[1], &Bd, sizeof(void*));
-
-	size_t size = argBuffer.size()*sizeof(void*);
-
-	void *config[] = {
-		HIP_LAUNCH_PARAM_BUFFER_POINTER, &argBuffer[0],
-
-
-
-54
-```
-
-(continued from previous page)
-
-(continues on next page)
-
-(continued from previous page)
-
-```
-        HIP_LAUNCH_PARAM_BUFFER_SIZE, &size,
-        HIP_LAUNCH_PARAM_END
-    };
-
-    hipModuleLaunchKernel(Function, 1, 1, 1, LEN, 1, 1, 0, 0, NULL, (void**)&config);
-
-    hipMemcpyDtoH(B, Bd, SIZE);
-    for(uint32_t i=0;i<LEN;i++){
-        std::cout<<A[i]<<" - "<<B[i]<<std::endl;
-    }
-
-#ifdef __HIP_PLATFORM_NVIDIA__
-          hipCtxDetach(context);
-#endif
-
-    return 0;
-}
-
-__A__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ ======"__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__= "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "_ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = '__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ from "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "___ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "'
-```
-
-## 9.3 HIP Module and Texture Driver API
-
-HIP supports texture driver APIs however texture reference should be declared in host scope. Following code explains the use of texture reference for \_\_HIP\_PLATFORM\_AMD\_\_ platform.
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        // Code to generate code object
-
-                                                                                                                                                                                                      
-#include "hip/hip_runtime.h"
-                                                                                                                                                                                                      
-extern texture<float, 2, hipReadModeElementType> tex;
-
-        __global__ void tex2dKernel(hipLaunchParm lp, float* outputData,
-                                                                                                                                                                                                       //
-```
-
-```
-  }
-
-  // Host code:
-
-  texture<float, 2, hipReadModeElementType> tex;
-
-  void myFunc ()
-  {
-
-      //...
-
-      textureReference* texref;
-      hipModuleGetTexRef(&texref, Module1, "tex");
-      hipTexRefSetAddressMode(texref, 0, hipAddressModeWrap);
-      hipTexRefSetAddressMode(texref, 1, hipAddressModeWrap);
-      hipTexRefSetFilterMode(texref, hipFilterModePoint);
-```
-
-(continues on next page)
-
-```
-    hipTexRefSetFlags(texref, 0);
-    hipTexRefSetFormat(texref, HIP_AD_FORMAT_FLOAT, 1);
-    hipTexRefSetArray(texref, array, HIP_TRSA_OVERRIDE_FORMAT);
-
-    //...
-}
-```
-
-(continued from previous page)
-
-## TEN
-
-## PROGRAMMING FOR HIP RUNTIME COMPILER (RTC)
-
-HIP lets you compile kernels at runtime with the hiprtc* APIs. Kernels can be stored as a text string and can be passed to HIPRTC APIs alongside options to guide the compilation.
-
-NOTE:
-
-- This library can be used on systems without HIP installed nor AMD GPU driver installed at all (offline compilation). Therefore, it does not depend on any HIP runtime library.
-- But it does depend on comgr. You may try to statically link comgr into HIPRTC to avoid any ambiguity.
-- Developers can decide to bundle this library with their application.
-
-## 10.1 Example
-
-To use HIPRTC functionality, HIPRTC header needs to be included first. #include &lt;hip/hiprtc.h&gt;
-
-Kernels can be stored in a string:
-
-```
-<_C_>
-```
-
-Now to compile this kernel, it needs to be associated with hiprtcProgram type, which is done by declaring hiprtcProgram prog; and associating the string of kernel with this program:
-
-```
-hiprtcCreateProgram(&prog,                    // HIPRTC program
-                       kernel,                // kernel string
-                       "gpu_kernel.cu",       // Name of the file
-                       num_headers,            // Number of headers
-                       &header_sources[0],     // Header sources
-                       &header_names[0]);      // Name of header files
-```
-
-hiprtcCreateProgram API also allows you to add headers which can be included in your RTC program. For online compilation, the compiler pre-defines HIP device API functions, HIP specific types and macros for device compilation, but does not include standard C/C++ headers by default. Users can only include header files provided to hiprtcCreateProgram .
-
-After associating the kernel string with hiprtcProgram , you can now compile this program using:
-
-```
-
-
-hiprtcCompileProgram(prog,     // hiprtcProgram
-                         0,          // Number of options
-                          options);  // Clang Options [Supported Clang Options](clang_options.
-
---md)
-```
-
-hiprtcCompileProgram returns a status value which can be converted to string via hiprtcGetErrorString . If compilation is successful, hiprtcCompileProgram will return HIPRTC\_SUCCESS .
-
-If the compilation fails, you can look up the logs via:
-
-```
-<_C++_>
-```
-
-If the compilation is successful, you can load the compiled binary in a local variable.
-
-```
-  size_t codeSize;
-  hiprtcGetCodeSize(prog, &codeSize);
-
-  vector<char> kernel_binary(codeSize);
-  hiprtcGetCode(prog, kernel_binary.data());
-```
-
-After loading the binary, hiprtcProgram can be destroyed. hiprtcDestroyProgram(&amp;prog);
-
-The binary present in kernel\_binary can now be loaded via hipModuleLoadData API.
-
-```
-hipModule_t module;
-hipFunction_t kernel;
-
-hipModuleLoadData(&module, kernel_binary.data());
-hipModuleGetFunction(&kernel, module, "vector_add");
-```
-
-And now this kernel can be launched via hipModule APIs.
-
-The full example is below:
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        //
-```
-
-(continued from previous page)
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        </----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                    <-----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        >----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                   
-    <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                <----------------------------------------------------------------------------------------------------------------------    <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                               
-        <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                            <----------------------------------------------------------------------------------------------------------------------        <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                           
-            <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                        <----------------------------------------------------------------------------------------------------------------------            <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                       
-                <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                    <----------------------------------------------------------------------------------------------------------------------                <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                   
-                    <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                <----------------------------------------------------------------------------------------------------------------------                    <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                               
-                        <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                            <----------------------------------------------------------------------------------------------------------------------                        <----------------------------------------------------------------------------------------------------------------------
-```
-
-```
-HIP Documentation,Release 6.1.40092
-```
-
-(continued from previous page)
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        }
-                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       }
-
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                       	                                                                                                                                                                                                      
-
-                                                                                                                                                                                                      
-                                                                                                                                                                                                     
-
-                                                                                                                                                                                                    
- 
-                                                                                                                                                                                                    
-
-                                                                                                                                                                                                      
-
- 
-                                                                                                                                                                                                     }
- 
-                                                                                                                                                                                                    }
-  
-                                                                                                                                                                                                    }
-
-  
-                                                                                                                                                                                                   
-  
-                                                                                                                                                                                                   }
-```
-
-## 10.2 HIPRTC specific options
-
-HIPRTC provides a few HIPRTC specific flags
-
-- --gpu-architecture : This flag can guide the code object generation for a specific gpu arch. Example: --gpu-architecture=gfx906:sramecc+:xnack, its equivalent to --offload-arch .
-- -This option is compulsory if compilation is done on a system without AMD GPUs supported by HIP runtime.
-- -Otherwise, HIPRTC will load the hip runtime and gather the current device and its architecture info and use it as option.
-- -fgpu-rdc : This flag when provided during the hiprtcCompileProgram generates the bitcode (HIPRTC doesn't convert this bitcode into ISA and binary). This bitcode can later be fetched using hiprtcGetBitcode and hiprtcGetBitcodeSize APIs.
-
-## 10.2.1 Bitcode
-
-In the usual scenario, the kernel associated with hiprtcProgram is compiled into the binary which can be loaded and run. However, if -fpu-rdc option is provided in the compile options, HIPRTC calls comgr and generates only the LLVM bitcode. It doesn't convert this bitcode to ISA and generate the final binary.
-
-```
-  std::string sarg = std::string("-fgpu-rdc");
-  const char* options[] = {
-      sarg.c_str() };
-  hiprtcCompileProgram(prog, // hiprtcProgram
-                        1,     // Number of options
-                        options);
-```
-
-If the compilation is successful, one can load the bitcode in a local variable using the bitcode APIs provided by HIPRTC.
-
-```
-size_t bitCodeSize;
-hiprtcGetBitcodeSize(prog, &bitCodeSize);
-
-vector<char> kernel_bitcode(bitCodeSize);
-hiprtcGetBitcode(prog, kernel_bitcode.data());
-```
-
-## 10.2.2 CU Mode vs WGP mode
-
-AMDGPUs consist of an array of workgroup processors, each built with 2 compute units (CUs) capable of executing SIMD32. All the CUs inside a workgroup processor use local data share (LDS).
-
-gfx10+ support execution of wavefront in CU mode and work-group processor mode (WGP). Please refer to section 2.3 of RDNA3 ISA reference.
-
-gfx9 and below only supports CU mode.
-
-In WGP mode, 4 warps of a block can simultaneously be executed on the workgroup processor, where as in CU mode only 2 warps of a block can simultaneously execute on a CU. In theory, WGP mode might help with occupancy and increase the performance of certain HIP programs (if not bound to inter warp communication), but might incur performance penalty on other HIP programs which rely on atomics and inter warp communication. This also has effect of how the LDS is split between warps, please refer to RDNA3 ISA reference for more information.
-
-HIPRTCassumes WGPmodebydefault for gfx10+. This can be overridden by passing -mcumode to HIPRTC compile options in hiprtcCompileProgram .
-
-## 10.3 Linker APIs
-
-The bitcode generated using the HIPRTC Bitcode APIs can be loaded using hipModule APIs and also can be linked with other generated bitcodes with appropriate linker flags using the HIPRTC linker APIs. This also provides more flexibility and optimizations to the applications who want to generate the binary dynamically according to their needs. The input bitcodes can be generated only for a specific architecture or it can be a bundled bitcode which is generated for multiple architectures.
-
-## 10.3.1 Example
-
-Firstly, HIPRTC link instance or a pending linker invocation must be created using hiprtcLinkCreate , with the appropriate linker options provided.
-
-```
-<_C++_>
-```
-
-Following which, the bitcode data can be added to this link instance via hiprtcLinkAddData (if the data is present as a string) or hiprtcLinkAddFile (if the data is present as a file) with the appropriate input type according to the data or the bitcode used.
-
-```
-
-hiprtcLinkAddData(rtc_link_state,        // HIPRTC link state
-                         input_type,            // type of the input data or bitcode
-                         bit_code_ptr,           // input data which is null terminated
-                         bit_code_size,          // size of the input data
-                          "a",                   // optional name for this input
-                          0,                     // size of the options
-                          0,                     // Array of options applied to this input
-                          0);                      // Array of option values cast to void*
-```
-
-```
-hiprtcLinkAddFile(rtc_link_state,        // HIPRTC link state
-                         input_type,            // type of the input data or bitcode
-                         bc_file_path.c_str(),  // path to the input file where bitcode is_
---present
-                         0,                   // size of the options
-                          0,                    // Array of options applied to this input
-                          0);                    // Array of option values cast to void*
-```
-
-Once the bitcodes for multiple architectures are added to the link instance, the linking of the device code must be completed using hiprtcLinkComplete which generates the final binary.
-
-```
-<_C_>
-```
-
-If the hiprtcLinkComplete returns successfully, the generated binary can be loaded and run using the hipModule* APIs.
-
-```
-      |hipModuleLoadData(&module, bina
-```
-
-```
-binary);
-```
-
-## 10.3.1.1 Note
-
-- The compiled binary must be loaded before HIPRTC link instance is destroyed using the hiprtcLinkDestroy API.
-
-## hiprtcLinkDestroy(rtc\_link\_state);
-
-- The correct sequence of calls is : hiprtcLinkCreate , hiprtcLinkAddData or hiprtcLinkAddFile , hiprtcLinkComplete , hiprtcModuleLoadData , hiprtcLinkDestroy .
-
-## 10.3.2 Input Types
-
-HIPRTC provides hiprtcJITInputType enumeration type which defines the input types accepted by the Linker APIs. Here are the enum values of hiprtcJITInputType . However only the input types HIPRTC\_JIT\_INPUT\_LLVM\_BITCODE , HIPRTC\_JIT\_INPUT\_LLVM\_BUNDLED\_BITCODE and HIPRTC\_JIT\_INPUT\_LLVM\_ARCHIVES\_OF\_BUNDLED\_BITCODE are supported currently.
-
-HIPRTC\_JIT\_INPUT\_LLVM\_BITCODE can be used to load both LLVM bitcode or LLVM IR assembly code. However, HIPRTC\_JIT\_INPUT\_LLVM\_BUNDLED\_BITCODE and HIPRTC\_JIT\_INPUT\_LLVM\_ARCHIVES\_OF\_BUNDLED\_BITCODE are only for bundled bitcode and archive of bundled bitcode.
-
-```
-<_Cuda_>
-```
-
-## 10.3.3 Backward Compatibility of LLVM Bitcode/IR
-
-For HIP applications utilizing HIPRTC to compile LLVM bitcode/IR, compatibility is assured only when the ROCm or HIP SDK version used for generating the LLVM bitcode/IR matches the version used during the runtime compilation. When an application requires the ingestion of bitcode/IR not derived from the currently installed AMD compiler, it must run with HIPRTC and comgr dynamic libraries that are compatible with the version of the bitcode/IR.
-
-comgr, a shared library, incorporates the LLVM/Clang compiler that HIPRTC relies on. To identify the bitcode/IR version that comgr is compatible with, one can execute 'clang -v' using the clang binary from the same ROCm or HIP SDK package. For instance, if compiling bitcode/IR version 14, the HIPRTC and comgr libraries released by AMD around mid 2022 would be the best choice, assuming the LLVM/Clang version included in the package is also version 14.
-
-To ensure smooth operation and compatibility, an application may choose to ship the specific versions of HIPRTC and comgr dynamic libraries, or it may opt to clearly specify the version requirements and dependencies. This approach guarantees that the application can correctly compile the specified version of bitcode/IR.
-
-## 10.3.4 Link Options
-
-- HIPRTC\_JIT\_IR\_TO\_ISA\_OPT\_EXT - AMD Only. Options to be passed on to link step of compiler by hiprtcLinkCreate .
-- HIPRTC\_JIT\_IR\_TO\_ISA\_OPT\_COUNT\_EXT - AMD Only. Count of options passed on to link step of compiler.
-
-Example:
-
-```
-const char* isaopts[] = {"-mllvm", "-inline-threshold=1", "-mllvm", "-inlinehint-
---threshold=1"};
-std::vector<hiprtcJIT_option> jit_options = {HIPRTC_JIT_IR_TO_ISA_OPT_EXT,
-                                                                                                                                                                                                         HIPRTC_JIT_IR_TO_ISA_OPT_COUNT_EXT};
-size_t isaoptssize = 4;
-                                                                                                                                                                                                       (continues on next page)
-```
-
-```
-        const void* lopts[] = {(void*)isaopts, (void*)(isaoptssize)};
-        hiprtcLinkState linkstate;
-        hiprtcLinkCreate(2, jit_options.data(), (void**)lopts, &linkstate);
-```
-
-## 10.4 Error Handling
-
-HIPRTC defines the hiprtcResult enumeration type and a function hiprtcGetErrorString for API call error handling. hiprtcResult enum defines the API result codes. HIPRTC APIs return hiprtcResult to indicate the call result. hiprtcGetErrorString function returns a string describing the given hiprtcResult code, e.g., HIPRTC\_SUCCESS to 'HIPRTC\_SUCCESS'. For unrecognized enumeration values, it returns 'Invalid HIPRTC error code'.
-
-hiprtcResult enum supported values and the hiprtcGetErrorString usage are mentioned below.
-
-```
-<_Python_>
-```
-
-```
-hiprtcResult result;
-result = hiprtcCompileProgram(prog, 1, opts);
-if (result!= HIPRTC_SUCCESS) {
-std::cout << "hiprtcCompileProgram fails with error " << hiprtcGetErrorString(result);
-}
-```
-
-## 10.5 HIPRTC General APIs
-
-HIPRTC provides the following API for querying the version.
-
-hiprtcVersion(int* major, int* minor) - This sets the output parameters major and minor with the HIP Runtime compilation major version and minor version number respectively.
-
-Currently, it returns hardcoded value. This should be implemented to return HIP runtime major and minor version in the future releases.
-
-(continued from previous page)
-
-## 10.6 Lowered Names (Mangled Names)
-
-HIPRTC mangles the \_\_global\_\_ function names and names of \_\_device\_\_ and \_\_constant\_\_ variables. If the generated binary is being loaded using the HIP Runtime API, the kernel function or \_\_device\_\_/\_\_constant\_\_ variable must be looked up by name, but this is very hard when the name has been mangled. To overcome this, HIPRTC provides API functions that map \_\_global\_\_ function or \_\_device\_\_/\_\_constant\_\_ variable names in the source to the mangled names present in the generated binary.
-
-The two APIs hiprtcAddNameExpression and hiprtcGetLoweredName provide this functionality. First, a 'name expression' string denoting the address for the \_\_global\_\_ function or \_\_device\_\_/\_\_constant\_\_ variable is provided to hiprtcAddNameExpression . Then, the program is compiled with hiprtcCompileProgram . During compilation, HIPRTC will parse the name expression string as a C++ constant expression at the end of the user program. Finally, the function hiprtcGetLoweredName is called with the original name expression and it returns a pointer to the lowered name. The lowered name can be used to refer to the kernel or variable in the HIP Runtime API.
-
-## 10.6.1 Note
-
-- The identical name expression string must be provided on a subsequent call to hiprtcGetLoweredName to extract the lowered name.
-- The correct sequence of calls is : hiprtcAddNameExpression , hiprtcCompileProgram , hiprtcGetLoweredName , hiprtcDestroyProgram .
-- The lowered names must be fetched using hiprtcGetLoweredName only after the HIPRTC program has been compiled, and before it has been destroyed.
-
-## 10.6.2 Example
-
-kernel containing various definitions \_\_global\_\_ functions/function templates and \_\_device\_\_/\_\_constant\_\_ variables can be stored in a string.
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-        static constexpr const char gpu_program[] {
-```
-
-hiprtcAddNameExpression is called with various name expressions referring to the address of \_\_global\_\_ functions and \_\_device\_\_/\_\_constant\_\_ variables.
-
-```
-kernel_name_vec.push_back("&f1");
-kernel_name_vec.push_back("N1::N2::f2");
-kernel_name_vec.push_back("f3<int>");
-for (auto&& x : kernel_name_vec) hiprtcAddNameExpression(prog, x.c_str());
-variable_name_vec.push_back("&V1");
-```
-
-(continues on next page)
-
-(continued from previous page)
-
-```
-auto&& x : variable_name_vec) hiprtcAddNameExpression(prog, x.c_str());
-```
-
-```
-        | variable_name_vec.push_back("&N1::N2::V2");
-        for (auto&& x : variable_name_vec) hiprtcAddNameExp
-```
-
-After which, the program is compiled using hiprtcCompileProgram and the generated binary is loaded using hipModuleLoadData . And the mangled names can be fetched using hirtcGetLoweredName .
-
-```
-for (decltype(variable_name_vec.size()) i = 0; i!= variable_name_vec.size(); ++i) {
-  const char* name;
-  hiprtcGetLoweredName(prog, variable_name_vec[i].c_str(), &name);
-}
-```
-
-```
-    for (decltype(kernel_name_vec.size()) i = 0; i!= kernel_name_vec.size(); ++i) {
-      const char* name;
-      hiprtcGetLoweredName(prog, kernel_name_vec[i].c_str(), &name);
-    }
-```
-
-The mangled name of the variables are used to look up the variable in the module and update its value.
-
-```
-        hipDeviceptr_t variable_addr;
-        size_t bytes{};
-        hipModuleGetGlobal(&variable_addr, &bytes, module, name);
-        hipMemcpyHtoD(variable_addr, &initial_value, sizeof(initial_value));
-```
-
-Finally, the mangled name of the kernel is used to launch it using the hipModule APIs.
-
-```
-        hipFunction_t kernel;
-        hipModuleGetFunction(&kernel, module, name);
-        hipModuleLaunchKernel(kernel, 1, 1, 1, 1, 1, 0, nullptr, nullptr, config);
-```
-
-Please have a look at hiprtcGetLoweredName.cpp for the detailed example.
-
-## 10.7 Versioning
-
-HIPRTC follows the below versioning.
-
-- Linux
-- -HIPRTC follows the same versioning as HIP runtime library.
-- -The so name field for the shared library is set to MAJOR version. For example, for HIP 5.3 the so name is set to 5 ( hiprtc.so.5 ).
-- Windows
-- -HIPRTC dll is named as hiprtcXXYY.dll where XX is MAJOR version and YY is MINOR version. For example, for HIP 5.3 the name is hiprtc0503.dll .
-
-## 10.8 HIP header support
-
-- Added HIPRTC support for all the hip common header files such as library\_types.h, hip\_math\_constants.h, hip\_complex.h, math\_functions.h, surface\_types.h etc. from 6.1. HIPRTC users need not include any HIP macros or constants explicitly in their header files. All of these should get included via HIPRTC builtins when the app links to HIPRTC library.
-
-## 10.9 Deprecation notice
-
-- Currently HIPRTC APIs are separated from HIP APIs and HIPRTC is available as a separate library libhiprtc. so / libhiprtc.dll . But on Linux, HIPRTC symbols are also present in libamdhip64.so in order to support the existing applications. Gradually, these symbols will be removed from HIP library and applications using HIPRTC will be required to explicitly link to HIPRTC library. However, on Windows hiprtc.dll must be used as the amdhip64.dll doesn't contain the HIPRTC symbols.
-- Data types such as uint32\_t , uint64\_t , int32\_t , int64\_t defined in std namespace in HIPRTC are deprecated earlier and are being removed from ROCm release 6.1 since these can conflict with the standard C++ data types. These data types are now prefixed with \_\_hip\_\_ , e.g. \_\_hip\_uint32\_t . Applications previously using std::uint32\_t or similar types can use \_\_hip\_ prefixed types to avoid conflicts with standard std namespace or application can have their own definitions for these types. Also, type\_traits templates previously defined in std namespace are moved to \_\_hip\_internal namespace as implementation details.
-
-## CHAPTER
-
-## ELEVEN
-
-## PERFORMANCE GUIDELINES
-
-The AMDHIPPerformance Guidelines are a set of best practices designed to help developers optimize the performance of AMD GPUs. They cover established parallelization and optimization techniques, coding metaphors, and idioms that can greatly simplify programming for HIP-capable GPU architectures.
-
-By following four main cornerstones, we can exploit the performance optimization potential of HIP.
-
-- parallel execution
-- memory usage optimization
-- optimization for maximum throughput
-- minimizing memory thrashing
-
-In the following chapters, we will show you their benefits and how to use them effectively.
-
-## 11.1 Parallel execution
-
-For optimal use, the application should reveal and efficiently imply as much parallelism as possible to keep all system components active.
-
-## 11.1.1 Application level
-
-The application should optimize parallel execution across the host and devices using asynchronous calls and streams. Workloads should be assigned based on efficiency: serial to the host, parallel to the devices.
-
-For parallel workloads, when threads need to synchronize to share data, if they belong to the same block, they should use \_\_syncthreads() (see: Synchronization functions ) within the same kernel invocation. If they belong to different blocks, they must use global memory with two separate kernel invocations. The latter should be minimized as it adds overhead.
-
-## 11.1.2 Device level
-
-Device-level optimization primarily involves maximizing parallel execution across the multiprocessors of the device. This can be achieved by executing multiple kernels concurrently on a device. The management of these kernels is facilitated by streams, which allow for the overlapping of computation and data transfers, enhancing performance. The aim is to keep all multiprocessors busy by executing enough kernels concurrently. However, launching too many kernels can lead to resource contention, so a balance must be found for optimal performance. This approach helps in achieving maximum utilization of the resources of the device.
-
-## 11.1.3 Multiprocessor level
-
-Multiprocessor-level optimization involves maximizing parallel execution within each multiprocessor on a device. Each multiprocessor can execute a number of threads concurrently, and the total number of threads that can run in parallel is determined by the number of concurrent threads each multiprocessor can handle.
-
-The key to multiprocessor-level optimization is to efficiently utilize the various functional units within a multiprocessor. This can be achieved by ensuring a sufficient number of resident warps, as at every instruction issue time, a warp scheduler selects an instruction that is ready to execute. This instruction can be another independent instruction of the same warp, exploiting Optimization for maximum instruction throughput , or more commonly an instruction of another warp, exploiting thread-level parallelism.
-
-In comparison, device-level optimization focuses on the device as a whole, aiming to keep all multiprocessors busy by executing enough kernels concurrently. Both levels of optimization are crucial for achieving maximum performance. They work together to ensure efficient utilization of the resources of the GPU, from the individual multiprocessors to the device as a whole.
-
-## 11.2 Memory optimization
-
-The first step in maximizing memory throughput is to minimize low-bandwidth data transfers. This involves reducing data transfers between the host and the device, as these have lower bandwidth than transfers between global memory and the device.
-
-Additionally, data transfers between global memory and the device should be minimized by maximizing the use of on-chip memory: shared memory and caches. Shared memory acts as a user-managed cache, where the application explicitly allocates and accesses it. A common programming pattern is to stage data from device memory into shared memory. This involves each thread of a block loading data from device memory to shared memory, synchronizing with all other threads of the block, processing the data in shared memory, synchronizing again if necessary, and writing the results back to device global memory.
-
-For some applications, a traditional hardware-managed cache is more appropriate to exploit data locality. On devices of certain compute capabilities, the same on-chip memory is used for both L1 and shared memory, and the amount dedicated to each is configurable for each kernel call.
-
-Finally, the throughput of memory accesses by a kernel can vary significantly depending on the access pattern for each type of memory. Therefore, the next step in maximizing memory throughput is to organize memory accesses as optimally as possible. This is especially important for global memory accesses, as global memory bandwidth is low compared to available on-chip bandwidths and arithmetic instruction throughput. Thus, non-optimal global memory accesses generally have a high impact on performance.
-
-## 11.2.1 Data Transfer
-
-Applications should aim to minimize data transfers between the host and the device. This can be achieved by moving more computations from the host to the device, even if it means running kernels that do not fully utilize the parallelism for device. Intermediate data structures can be created, used, and discarded in device memory without being mapped or copied to host memory.
-
-Batching small transfers into a single large transfer can improve performance due to the overhead associated with each transfer. On systems with a front-side bus, using page-locked host memory can enhance data transfer performance.
-
-When using mapped page-locked memory, there is no need to allocate device memory or explicitly copy data between device and host memory. Data transfers occur implicitly each time the kernel accesses the mapped memory. For optimal performance, these memory accesses should be coalesced, similar to global memory accesses.
-
-On integrated systems where device and host memory are physically the same, any copy operation between host and device memory is unnecessary, and mapped page-locked memory should be used instead. Applications can check if a device is integrated by querying the integrated device property.
-
-## 11.2.2 Device Memory Access
-
-Memory access instructions may be repeated due to the spread of memory addresses across warp threads. The impact on throughput varies with memory type and is generally reduced when addresses are more scattered, especially in global memory.
-
-Device memory is accessed via 32-, 64-, or 128-byte transactions that must be naturally aligned. Maximizing memory throughput involves coalescing memory accesses of threads within a warp into minimal transactions, following optimal access patterns, using properly sized and aligned data types, and padding data when necessary.
-
-Global memory instructions support reading or writing data of specific sizes (1, 2, 4, 8, or 16 bytes) that are naturally aligned. If the size and alignment requirements are not met, it leads to multiple instructions, reducing performance. Therefore, using data types that meet these requirements, ensuring alignment for structures, and maintaining alignment for all values or arrays is crucial for correct results and optimal performance.
-
-Threads often access 2D arrays at an address calculated as BaseAddress + xIndex + width * yIndex . For efficient memory access, the array and thread block widths should be multiples of the warp size. If the array width is not a multiple of the warp size, it is usually more efficient to allocate it with a width rounded up to the nearest multiple and pad the rows accordingly.
-
-Local memory is used for certain automatic variables, such as arrays with non-constant indices, large structures or arrays, and any variable when the kernel uses more registers than available. Local memory resides in device memory, leading to high latency and low bandwidth similar to global memory accesses. However, it is organized for consecutive 32-bit words to be accessed by consecutive thread IDs, allowing full coalescing when all threads in a warp access the same relative address.
-
-Shared memory, located on-chip, provides higher bandwidth and lower latency than local or global memory. It is divided into banks that can be simultaneously accessed, boosting bandwidth. However, bank conflicts, where two addresses fall in the same bank, lead to serialized access and decreased throughput. Therefore, understanding how memory addresses map to banks and scheduling requests to minimize conflicts is crucial for optimal performance.
-
-Constant memory is in device memory and cached in the constant cache. Requests are split based on different memory addresses, affecting throughput, and are serviced at the throughput of the constant cache for cache hits, or the throughput of the device memory otherwise.
-
-Texture and surface memory are stored in device memory and cached in texture cache. This setup optimizes 2D spatial locality, leading to better performance for threads reading close 2D addresses. Reading device memory through texture or surface fetching can be advantageous, offering higher bandwidth for local texture fetches or surface reads, offloading addressing calculations, allowing data broadcasting, and optional conversion of 8-bit and 16-bit integer input data to 32-bit floating-point values on-the-fly.
-
-## 11.3 Optimization for maximum instruction throughput
-
-To maximize instruction throughput:
-
-- minimize low throughput arithmetic instructions
-- minimize divergent warps inflicted by control flow instructions
-- minimize the number of instruction as possible
-- maximize instruction parallelism
-
-## 11.3.1 Arithmetic instructions
-
-The type and complexity of arithmetic operations can significantly impact the performance of your application. We are highlighting some hints how to maximize it.
-
-Using efficient operations: Some arithmetic operations are more costly than others. For example, multiplication is typically faster than division, and integer operations are usually faster than floating-point operations, especially with double-precision.
-
-Minimizing low-throughput instructions: This might involve trading precision for speed when it does not affect the final result. For instance, consider using single-precision arithmetic instead of double-precision.
-
-Leverage intrinsic functions: Intrinsic functions are pre-defined functions available in HIP that can often be executed faster than equivalent arithmetic operations (subject to some input or accuracy restrictions). They can help optimize performance by replacing more complex arithmetic operations.
-
-Avoiding divergent warps: Divergent warps occur when threads within the same warp follow different execution paths. This can happen due to conditional statements that lead to different arithmetic operations being performed by different threads. Divergent warps can significantly reduce instruction throughput, so try to structure your code to minimize divergence.
-
-Optimizing memory access: The efficiency of memory access can impact the speed of arithmetic operations. Coalesced memory access, where threads in a warp access consecutive memory locations, can improve memory throughput and thus the speed of arithmetic operations.
-
-Maximizing instruction parallelism: Some GPU architectures could issue parallel independent instructions simultaneously, for example integer and floating point, or two operations with independent inputs and outputs. Mostly this is a work for compiler, but expressing parallelism in the code explicitly can improve instructions throughput.
-
-## 11.3.2 Control flow instructions
-
-Flow control instructions ( if , else , for , do , while , break , continue , switch ) can impact instruction throughput by causing threads within a warp to diverge and follow different execution paths. To optimize performance, control conditions should be written to minimize divergent warps. For example, when the control condition depends on ( threadIdx / warpSize ), no warp diverges. The compiler may optimize loops or short if or switch blocks using branch predication, preventing warp divergence. With branch predication, instructions associated with a false predicate are scheduled but not executed, avoiding unnecessary operations.
-
-## 11.3.3 Synchronization
-
-Synchronization ensures that all threads within a block have completed their computations and memory accesses before moving forward, which is critical when threads are dependent on the results of other threads. However, synchronization can also lead to performance overhead, as it requires threads to wait, potentially leading to idle GPU resources.
-
-\_\_syncthreads() is used to synchronize all threads in a block, ensuring that all threads have reached the same point in the code and that shared memory is visible to all threads after the point of synchronization.
-
-An alternative way to synchronize is using streams. Different streams can execute commands out of order with respect to one another or concurrently. This allows for more fine-grained control over the execution order of commands, which can be beneficial in certain scenarios.
-
-## 11.4 Minimizing memory thrashing
-
-Applications frequently allocating and freeing memory may experience slower allocation calls over time. This is expected as memory is released back to the operating system. To optimize performance in such scenarios, consider some recommendations:
-
-- avoid allocating all available memory with hipMalloc / hipHostMalloc , as this immediately reserves memory and can block other applications from using it. This could strain the operating system schedulers or even prevent other applications from running on the same GPU.
-- aim to allocate memory in suitably sized blocks early in the lifecycle of the application and deallocate only when the application no longer needs it. Minimize the number of hipMalloc and hipFree calls in your application, particularly in areas critical to performance.
-- if an application is unable to allocate sufficient device memory, consider resorting to other memory types such as hipHostMalloc or hipMallocManaged . While these may not offer the same performance, they can allow the application to continue running.
-- For supported platforms, hipMallocManaged allows for oversubscription. With the right memory advise policies, it can maintain most, if not all, of the performance of hipMalloc . hipMallocManaged does not require an allocation to be resident until it is needed or prefetched, easing the load on the operating system schedulers and facilitating multi-tenant scenarios.
-
-CHAPTER
-
-## TWELVE
-
-## DEBUGGING WITH HIP
-
-AMDdebugging tools include ltrace and ROCgdb . External tools are available and can be found online. For example, if you're using Windows, you can use Microsoft Visual Studio and WinGDB .
-
-You can trace and debug your code using the following tools and techniques.
-
-## 12.1 Tracing
-
-You can use tracing to quickly observe the flow of an application before reviewing the detailed information provided by a command-line debugger. Tracing can be used to identify issues ranging from accidental API calls to calls made on a critical path.
-
-ltrace is a standard Linux tool that provides a message to stderr on every dynamic library call. You can use ltrace to visualize the runtime behavior of the entire ROCm software stack.
-
-Here's a simple command-line example that uses ltrace to trace HIP APIs and output:
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?php?^"./hipGetChanDesc
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        </?php?^"
-	                                                                                                                                                                                                     
-		                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       <!
-                                                                                                                                                                                                      
-
-	                                                                                                                                                                                                       <%
-                                                                                                                                                                                                       </%
-                                                                                                                                                                                                      <?>
-                                                                                                                                                                                                       >
-```
-
-Here's another example that uses ltrace to trace hsa APIs and output:
-
-```
-        Here's another example that uses ltrace to trace hsa APIs and output:
-        $ ltrace  -C -e "hsa*"./hipGetChanDesc
-        libamdhip64.so.4->hsa_init(0, 0x7fff325a69d0, 0x9c80e0, 0 <unfinished...>
-        libhsa-runtime64.so.1->hsaKmtOpenKFD(0x7fff325a6590, 0x9c38c0, 0, 1) = 0
-        libhsa-runtime64.so.1->hsaKmtGetVersion(0x7fff325a6608, 0, 0, 0) = 0
-        libhsa-runtime64.so.1->hsaKmtReleaseSystemProperties(3, 0x80084b01, 0, 0) = 0
-        libhsa-runtime64.so.1->hsaKmtAcquireSystemProperties(0x7fff325a6610, 0, 0, 1) = 0
-        libhsa-runtime64.so.1->hsaKmtGetNodeProperties(0, 0x7fff325a66a0, 0, 0) = 0
-        libhsa-runtime64.so.1->hsaKmtGetNodeMemoryProperties(0, 1, 0x9c42b0, 0x936012) = 0
-       ...
-        <... hsaKmtCreateEvent  resumed> )                                                                                                                                                                                                        
-        libhsa-runtime64.so.1->hsaKmtAllocMemory(0, 4096, 64, 0x7fff325a6690) = 0
-        libhsa-runtime64.so.1->hsaKmtMapMemoryToGPUNodes(0x7f1202749000, 4096, 0x7fff325a6690,,...
-        --0) = 0
-        libhsa-runtime64.so.1->hsaKmtCreateEvent(0x7fff325a6700, 0, 0, 0x7fff325a66f0) = 0
-                                                                                                                                                                                                        (continues on next page)
-```
-
-(continues on next page)
-
-(continued from previous page)
-
-```
-HIP Documentation, Release 6.1.40092
-```
-
-## 12.2 Debugging
-
-You can use ROCgdb for debugging and profiling.
-
-ROCgdbis the ROCm source-level debugger for Linux and is based on GNU Project debugger (GDB). the GNU sourcelevel debugger, equivalent of CUDA-GDB, can be used with debugger frontends, such as Eclipse, Visual Studio Code, or GDB dashboard. For details, see (https://github.com/ROCm/ROCgdb).
-
-Below is a sample how to use ROCgdb run and debug HIP application, ROCgdb is installed with ROCM package in the folder /opt/rocm/bin.
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <p>
-                                                                                                                                                                                                       <h1>
-                                                                                                                                                                                                      <p/>
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        </p>
-                                                                                                                                                                                                     <p>
-
-                                                                                                                                                                                                       <a>
-                                                                                                                                                                                                     
- 	                                                                                                                                                                                                       <b>
-                                                                                                                                                                                                      </a>
-                                                                                                                                                                                                     <a>
-
-                                                                                                                                                                                                      <b/>
-                                                                                                                                                                                                      <a/>
-                                                                                                                                                                                                     
-		                                                                                                                                                                                                      
-
-	                                                                                                                                                                                                      <a></b>
-```
-
-## 12.2.1 Debugging HIP applications
-
-The following Linux example shows how to get useful information from the debugger while running a simple memory copy test, which caused a segmentation fault issue.
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <p>test, which caused a segmentation fault issue.                                                                                                                                                                                                        </p>                                                                                                                                                                                                        >
-                                                                                                                                                                                                       <a>http://tests/src/runtimeApi/memory/hipMemcpy_simple.cpp:147
-```
-
-(continues on next page)
-
-(continued from previous page)
-
-```
-HIP Documentation, Release 6.1.40092
-
-
-                                                                                                                                                                                                         (continued from previous page)                                                                                                                                                                                                       
-                                                                                                                                                                                                      
-1                                                                                                                                                                                                        "                                                                                                                                                                                                        <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        </----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                    <-----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        >----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                   
-1   //                                                                                                                                                                                                        :                                                                                                                                                                                                        |                                                                                                                                                                                                        -                                                                                                                                                                                                        +                                                                                                                                                                                                        \
-                                                                                                                                                                                                       |
-                                                                                                                                                                                                       <============================================================================================                                                                                                                                                                                                        }                                                                                                                                                                                                        )
-```
-
-Debugging HIP applications using Windows tools can be more informative than on Linux. Windows tools provides more visibility into debug codes, which makes it easier to inspect variables, watch multiple details, and examine call stacks.
-
-## 12.3 Useful environment variables
-
-HIP provides environment variables that allow HIP, hip-clang, or HSA drivers to prevent certain features and optimizations. These are not intended for production, but can be useful to diagnose synchronization problems in the application (or driver).
-
-Some of the more widely used environment variables are described in this section. These are supported on the Linux ROCm path and Windows.
-
-## 12.3.1 Kernel enqueue serialization
-
-You can control kernel command serialization from the host:
-
-## AMD\_SERIALIZE\_KERNEL , for serializing kernel enqueue
-
-AMD\_SERIALIZE\_KERNEL = 1 , Wait for completion before enqueue AMD\_SERIALIZE\_KERNEL = 2 , Wait for completion after enqueue AMD\_SERIALIZE\_KERNEL = 3 , Both
-
-Or
-
-## AMD\_SERIALIZE\_COPY , for serializing copies
-
-AMD\_SERIALIZE\_COPY = 1 , Wait for completion before enqueue AMD\_SERIALIZE\_COPY = 2 , Wait for completion after enqueue AMD\_SERIALIZE\_COPY = 3 , Both
-
-So HIP runtime can wait for GPU idle before/after any GPU command depending on the environment setting.
-
-## 12.3.2 Making device visible
-
-For systems with multiple devices, you can choose to make only certain device(s) visible to HIP using HIP\_VISIBLE\_DEVICES (or CUDA\_VISIBLE\_DEVICES on an NVIDIA platform). Once enabled, HIP can only view devices that have indices present in the sequence. For example:
-
-```
-    | $ HIP_VISIBLE_DEVICES=0,1
-```
-
-```
-<_Python_>
-```
-
-```
-if (totalDeviceNum > 2) {
-setenv("HIP_VISIBLE_DEVICES", "0,1,2", 1);
-assert(getDeviceNumber(false) == 3);
-
-.......
-}
-```
-
-## 12.3.3 Dump code object
-
-To analyze compiler-related issues, you can use the dump code object: GPU\_DUMP\_CODE\_OBJECT .
-
-## 12.3.4 HSA-related environment variables (Linux)
-
-HSA provides environment variables that help analyze issues in drivers or hardware.
-
-- To isolate issues with hardware copy engines, you can use HSA\_ENABLE\_SDMA .
-- HSA\_ENABLE\_SDMA=0 causes host-to-device and device-to-host copies to use compute shader blit kernels, rather than the dedicated DMA copy engines. Compute shader copies have low latency (typically &lt; 5 us) and can achieve approximately 80% of the bandwidth of the DMA copy engine.
-- To diagnose interrupt storm issues in the driver, you can use HSA\_ENABLE\_INTERRUPT .
-
-HSA\_ENABLE\_INTERRUPT=0 causes completion signals to be detected with memory-based polling, rather than interrupts.
-
-## 12.3.5 HIP environment variable summary
-
-Here are some of the more commonly used environment variables:
-
-| Environment variable                                                                                                          | De- fault value   | Usage                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-|-------------------------------------------------------------------------------------------------------------------------------|-------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| AMD_LOG_LEVEL Enable HIP log on different Level                                                                               | 0                 | 0: Disable log. 1: Enable log on error level 2: Enable log on warning and below levels 0x3: Enable log on information and below levels 0x4: Decode and display AQL packets                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-| AMD_LOG_MASK Enable HIP log on different Level                                                                                |                   | 0x7FFFFFFF 0x1: Log API calls 0x02: Kernel and Copy Commands and Barriers 0x4: Synchroniza- tion and waiting for commands to finish 0x8: Enable log on information and below levels 0x20: Queue commands and queue contents 0x40: Signal creation, allocation, pool 0x80: Locks and thread-safety code 0x100: Copy debug 0x200: Detailed copy debug 0x400: Resource allocation, performance-impacting events 0x800: Initialization and shutdown 0x1000: Misc debug, not yet classified 0x2000: Show raw bytes of AQL packet 0x4000: Show code creation debug 0x8000: More detailed command info, including barrier com- mands 0x10000: Log message location 0xFFFFFFFF: Log always even mask flag is zero |
-| HIP_LAUNCH_BLOCKING Used for serial- ization on kernel execution.                                                             | 0                 | 0: Disable. Kernel executes normally. 1: Enable. Serializes kernel enqueue, behaves the same as AMD_SERIALIZE_KERNEL.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| HIP_VISIBLE_DEVICES (or CUDA_VISIBLE_DEVICES) Only devices whose index is present in the sequence are visible to HIP          |                   | 0,1,2: Depending on the number of devices on the system                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| GPU_DUMP_CODE_OBJECT Dump code ob- ject                                                                                       | 0                 | 0: Disable 1: Enable                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| AMD_SERIALIZE_KERNEL Serialize kernel enqueue                                                                                 | 0                 | 1: Wait for completion before enqueue 2: Wait for completion after enqueue 3: Both                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
-| AMD_SERIALIZE_COPY Serialize copies                                                                                           | 0                 | 1: Wait for completion before enqueue 2: Wait for completion after enqueue 3: Both                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
-| HIP_HOST_COHERENT Coherent mem-                                                                                               | 0                 | 0: memory is not coherent between host and GPU 1: memory is coherent with host                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
-| ory in hipHost- Malloc AMD_DIRECT_DISPATCH Enable direct kernel dispatch (Currently for Linux; under development for Windows) | 1                 | 0: Disable 1: Enable                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| GPU_MAX_HW_QUEUES The maximum number of hard- ware queues allocated per device                                                | 4                 | The variable controls how many independent hardware queues HIP runtime can create per process, per device. If an application allocates more HIP streams than this number, then HIP runtime reuses the same hardware queues for the new streams in a round-robin manner. Note that this maximum number does not apply to hardware queues that are created for CU-masked HIP streams, or cooperative queues for HIP Cooperative Groups (single queue per device).                                                                                                                                                                                                                                           |
-
-## 12.4 General debugging tips
-
-- gdb --args can be used to pass the executable and arguments to gdb .
-- You can set environment variables ( set env ) from within GDB on Linux:
-
-```
-        | (gdb)  set env  AND_SERIALIZE_KERNEL  3
-```
-
-Note: This gdb command does not use an equal (=) sign.
-
-- The GDB backtrace shows a path in the runtime. This is because a fault is caught by the runtime, but it is generated by an asynchronous command running on the GPU.
-- To determine the true location of a fault, you can force the kernels to run synchronously by setting the environment variables AMD\_SERIALIZE\_KERNEL=3 and AMD\_SERIALIZE\_COPY=3 . This forces HIP runtime to wait for the kernel to finish running before returning. If the fault occurs when a kernel is running, you can see the code that launched the kernel inside the backtrace. The thread that's causing the issue is typically the one inside libhsa-runtime64.so .
-- VMfaults inside kernels can be caused by:
-- -Incorrect code (e.g., a for loop that extends past array boundaries)
-- -Memory issues, such as invalid kernel arguments (null pointers, unregistered host pointers, bad pointers)
-- -Synchronization issues
-- -Compiler issues (incorrect code generation from the compiler)
-- -Runtime issues
-
-## CHAPTER
-
-## THIRTEEN
-
-## LOGGING HIP ACTIVITY
-
-HIP provides a logging mechanism that allows you to trace HIP API and runtime codes when running a HIP application. In addition to being useful to our users/developers, the HIP development team uses these logs to improve the HIP runtime.
-
-By adjusting the logging settings and logging mask, you can get different types of information for different functionalities, such as HIP APIs, executed kernels, queue commands, and queue contents. Refer to the following sections for examples.
-
-Tip: Logging works for the release and debug versions of HIP. If you want to save logging output in a file, define the file when running the application via command line. For example:
-
-```
-            |user@user-test:~/hip/bin$./hipinfo > ~/hipinfo > ~/hip_log.txt
-```
-
-## 13.1 Logging level
-
-HIP logging is disabled by default. You can enable it via the AMD\_LOG\_LEVEL environment variable. The value of this variable controls your logging level. Levels are defined as follows:
-
-```
-                                                                                                                                                                                                       
-  enum LogLevel {
-      LOG_NONE       = 0,
-      LOG_ERROR     = 1,
-      LOG_WARNING = 2,
-      LOG_INFO       = 3,
-      LOG_DEBUG     = 4
-  };
-```
-
-Tip: You can call a logging function with different logging levels. All information under the value set for AMD\_LOG\_LEVEL is printed.
-
-## 13.2 Logging mask
-
-The logging mask is designed to print functionality types when you're running a HIP application. Once you set AMD\_LOG\_LEVEL , the logging mask is set as the default value ( 0x7FFFFFFF ). You can change this to any of the valid values:
-
-```
-        The logging mask is designed to print functionality types when you're running a HIP application.  Once you set
-        AMD_LOG_LEVEL, the logging mask is set as the default value (0x7FFFFFFF). You can change this to any of the valid
-        values:
-
-        enum LogMask {
-          LOG_API         = 0x000000001,  //!< API call
-          LOG_CMD         = 0x000000002,  //!< Kernel and Copy Commands and Barriers
-          LOG_WAIT        = 0x000000004,  //!< Synchronization and waiting for commands to finish
-          LOG_AQL         = 0x000000008,  //!< Decode and display AQL packets
-          LOG_QUEUE      = 0x00000010,  //!< Queue commands and queue contents
-          LOG_SIG         = 0x00000020,  //!< Signal creation, allocation, pool
-          LOG_LOCK        = 0x00000040,  //!< Locks and thread-safety code.
-          LOG_KERN        = 0x00000080,  //!< kernel creations and arguments, etc.
-          LOG_COPY        = 0x000000100,  //!< Copy debug
-          LOG_COPY2       = 0x000000200,  //!< Detailed copy debug
-          LOG_RESOURCE   = 0x000000400,  //!< Resource allocation, performance-impacting events.
-          LOG_INIT        = 0x00000080,  //!< Initialization and shutdown
-          LOG_MISC        = 0x00001000,  //!< misc debug, not yet classified
-          LOG_AQL2        = 0x00002000,  //!< Show raw bytes of AQL packet
-          LOG_CODE        = 0x00004000,  //!< Show code creation debug
-          LOG_CMD2        = 0x00008000,  //!< More detailed command info, including barrier commands
-          LOG_LOCATION   = 0x00010000,  //!< Log message location
-          LOG_MEM         = 0x0000200000,  //!< Memory allocation
-          LOG_MEM_POOL   = 0x00040000,  //!< Memory pool allocation, including memory in graphs
-          LOG_ALWAYS     = 0xFFFFFFFF,  //!< Log always even mask flag is zero
-        };
-
-        You can also define the logging mask via the AMD_LOG_MASK environment variable.
-```
-
-You can also define the logging mask via the AMD\_LOG\_MASK environment variable.
-
-## 13.3 Logging command
-
-You can use the following code to print HIP logging information:
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?                                                                                                                                                                                                        </?                                                                                                                                                                                                       <!                                                                                                                                                                                                        >
-                                                                                                                                                                                                       <&                                                                                                                                                                                                        &
-                                                                                                                                                                                                      
-																																																																																																																																																																																																								                                                                                                                                                                                                       																																																																																																																																																																																																							<?                                                                                                                                                                                                      	                                                                                                                                                                                                      	
-																																																																																																																																																																																																						 																																																																																																																																																																																																						  <?
-```
-
-Using HIP code, call the ClPrint() function with the desired input variables. For example:
-
-```
-            |ClPrint(amd::LOG_INFO, amd::LOG_INIT, "Initializing HSA stack.");
-```
-
-## 13.4 Logging examples
-
-On Linux , you can enable HIP logging and retrieve logging information when you run hipinfo .
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <HR>
-                                                                                                                                                                                                       <HIP Documentation, Release 6.1.40092                                                                                                                                                                                                        </HIP Documentation, Release 6.1.40092                                                                                                                                                                                             <HR>
-        Loggging examples                                                                                                                                                                                                        >
-                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       >
-
-                                                                                                                                                                                                       <BR>
-                                                                                                                                                                                                      <BR><BR>
-                                                                                                                                                                                                     <BR>
-
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                       	                                                                                                                                                                                                       <B>
-                                                                                                                                                                                                     
-  <B>
-                                                                                                                                                                                                   <BR>
-  <B>
-                                                                                                                                                                                                  <BR>
-```
-
-(continues on next page)
-
-(continued from previous page)
-
-```
-HIP Documentation, Release 6.1.40092
-```
-
-On Windows , you can set AMD\_LOG\_LEVEL via environment variable from the advanced system settings or the command prompt (when run as administrator). The following example shows debug log information when calling the backend runtime.
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <kendo runume.                                                                                                                                                                                                        </kendo>runume.
-```
-
-(continues on next page)
-
-(continued from previous page)
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <![
-                                                                                                                                                                                                       <?xml:%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/.%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/)
-                                                                                                                                                                                                      
-
-                                                                                                                                                                                                      
-
-
-                                                                                                                                                                                                       </?xml:%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazon AWS.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazon AWS.com/.%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazon AWS.com%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/"
-                                                                                                                                                                                                       :
-                                                                                                                                                                                                       >
-                                                                                                                                                                                                      ?xml:%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws,com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws,com%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.
-```
-
-(continues on next page)
-
-(continued from previous page)
-
-```
-  --copyBuffer
-...
-:4:C:\constructicon\builds\gfx\two\22.40\drivers\compute\vdi\device\pal\palmemory.
-  --cpp:206 : 605414523422 us: 29864: [tid:0x9298] Alloc: 100000 bytes,_,
-  --ptr[0000003008D0000-0000003009D0000], obj[0000003007D0000-0000003047D0000]
-:4:C:\constructicon\builds\gfx\two\22.40\drivers\compute\vdi\device\pal\palmemory.
-  --cpp:206 : 605414523767 us: 29864: [tid:0x9298] Alloc: 100000 bytes,_,
-  --ptr[0000003009D0000-000000300AD0000], obj[0000003007D0000-0000003047D0000]
-:3:C:\constructicon\builds\gfx\two\22.40\drivers\compute\hipamd\src\hip_memory.cpp:681 :_,
-  --605414524092 us: 29864: [tid:0x9298] hipMemGetInfo: Returned hipSuccess :
-memInfo.total:                     12.06 GB
-memInfo.free:                     11.93 GB (99%)
-```
-
-## CHAPTER
-
-## FOURTEEN
-
-## COOPERATIVE GROUPS
-
-Cooperative groups API is an extension to the HIP programming model, which provides developers with a flexible, dynamic grouping mechanism for the communicating threads. Cooperative groups let you define your own set of thread groups which may fit your user-cases better than those defined by the hardware. This lets you specify the level of granularity for thread communication which can lead to more efficient parallel decompositions.
-
-The API is accessible in the cooperative\_groups namespace after the hip\_cooperative\_groups.h is included. The header contains the following elements:
-
-- Static functions to create groups and subgroups.
-- Hardware-accelerated operations over the whole group, like shuffles.
-- Data types of cooperative groups.
-- Synchronize member function of the groups.
-- Get group properties member functions.
-
-## 14.1 Cooperative groups thread model
-
-The thread hierarchy abstraction of cooperative groups are in grid hierarchy and block hierarchy .
-
-Fig. 1: Cooperative group thread hierarchy in grids.
-
-The multi grid is an abstraction of potentially multiple simultaneous launches of the same kernel over multiple devices (Deprecated since 5.0). The grid in cooperative groups is a single dispatch of kernels for execution like the original grid.
-
-Note: The ability to synchronize over a grid or multi grid requires the kernel to be launched using the specific cooperative groups API.
-
-The block is the same as the Inherent thread model block entity.
-
-Note: Explicit warp-level thread handling is absent from the Cooperative groups API. In order to exploit the known hardware SIMD width on which built-in functionality translates to simpler logic, you can use the group partitioning part of the API, such as tiled\_partition .
-
-Fig. 2: Cooperative group thread hierarchy in blocks.
-
-The cooperative groups API introduce a new level between block thread and threads. The thread-block tile give the opportunity to have tiles in the thread block, while the coalesced group holds the active threads of the parent group. These groups further discussed in the groups types section.
-
-For details on memory model, check the memory model description .
-
-## 14.2 Group types
-
-Group types are based on the levels of synchronization and data sharing among threads.
-
-## 14.2.1 Thread-block group
-
-Represents an intra-block cooperative groups type where the participating threads within the group are the same threads that participated in the currently executing block .
-
-```
-    class thread_block;
-
-    Constructed via:
-
-    thread_block g = this_thread_block();
-```
-
-The group\_index() , thread\_index() , thread\_rank() , size() , cg\_type() , is\_valid() , sync() and group\_dim() member functions are public of the thread\_block class. For further details, check the thread\_block references .
-
-## 14.2.2 Grid group
-
-Represents an inter-block cooperative groups type where the group's participating threads span multiple blocks running the same kernel on the same device. Use the cooperative launch API to enable synchronization across the grid group.
-
-```
-class grid_group;
-
- Constructed via:
-
-grid_group g = this_grid();
-```
-
-The thread\_rank() , size() , cg\_type() , is\_valid() and sync() member functions are public of the grid\_group class. For further details, check the grid\_group references .
-
-## 14.2.3 Multi-grid group
-
-Represents an inter-device cooperative groups type where the participating threads within the group span multiple devices that run the same kernel on the devices. Use the cooperative launch API to enable synchronization across the multi-grid group.
-
-```
-    |class multi_grid_group;
-```
-
-```
-;
-```
-
-Constructed via:
-
-```
-<_C_>
-```
-
-```
-<_YAML_>
-```
-
-The num\_grids() , grid\_rank() , thread\_rank() , size() , cg\_type() , is\_valid() , and sync() member functions are public of the multi\_grid\_group class. For further details check the multi\_grid\_group references .
-
-## 14.2.4 Thread-block tile
-
-This constructs a templated class derived from thread\_group . The template defines the tile size of the new thread group at compile time. This group type also supports sub-wave level intrinsics.
-
-```
-<_C++_>
-```
-
-Constructed via:
-
-```
-<_SQL_>
-```
-
-## Note:
-
-- Size must be a power of 2 and not larger than warp (wavefront) size.
-- shfl() functions support integer or float type.
-
-The thread\_rank() , size() , cg\_type() , is\_valid() , sync() , meta\_group\_rank() , meta\_group\_size() , shfl() , shfl\_down() , shfl\_up() , shfl\_xor() , ballot() , any() , all() , match\_any() and match\_all() member functions are public of the thread\_block\_tile class. For further details, check the thread\_block\_tile references .
-
-## 14.2.5 Coalesced groups
-
-Threads (64 threads on CDNA and 32 threads on RDNA) in a warp cannot execute different instructions simultaneously, so conditional branches are executed serially within the warp. When threads encounter a conditional branch, they can diverge, resulting in some threads being disabled, if they do not meet the condition to execute that branch. The active threads referred as coalesced, and coalesced group represents an active thread group within a warp.
-
-Note: The NVIDIA GPU's independent thread scheduling presents the appearance that threads on different branches execute concurrently.
-
-Warning: AMD GPUs do not support independent thread scheduling. Some CUDA application can rely on this feature and the ported HIP version on AMD GPUs can deadlock, when they try to make use of independent thread scheduling.
-
-This group type also supports sub-wave level intrinsics.
-
-```
-    | class coalesced_group;
-```
-
-Constructed via:
-
-coalesced\_group
-
-```
-    |roup active  = coalesced_threads() ;
-```
-
-Note: shfl() functions support integer or float type.
-
-The thread\_rank() , size() , cg\_type() , is\_valid() , sync() , meta\_group\_rank() , meta\_group\_size() , shfl() , shfl\_down() , shfl\_up() , ballot() , any() , all() , match\_any() and match\_all() member functions are public of the coalesced\_group class. For more information, see coalesced\_group references .
-
-## 14.3 Cooperative groups simple example
-
-The difference to the original block model in the reduce\_sum device function is the following.
-
-## Original Block
-
-```
-<_Cuda_>
-```
-
-## Cooperative groups
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        // Thread ID
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        /                                                                                                                                                                                                        *                                                                                                                                                                                                        /*                                                                                                                                                                                                        */
-                                                                                                                                                                                                       */
-```
-
-(continues on next page)
-
-(continued from previous page)
-
-```
-      for(unsigned int i = g.size() / 2; i > 0; i /= 2) {
-          // Store value in shared memory with thread ID
-          shared[group_thread_id] = val;
-
-          // Synchronize all threads in the group
-          g.sync();
-
-          // Active thread sum up
-          if(group_thread_id < i)
-               val += shared[group_thread_id + i];
-
-          // Synchronize all threads in the group
-          g.sync();
-      }
-
-      //...
-}
-
-The reduce_sum() function call and input data initialization difference to the origin.
-```
-
-The reduce\_sum() function call and input data initialization difference to the original block model is the following.
-
-## Original Block
-
-```
-Original Block
-
-__global__ void sum_kernel(...) {
-
-    //...
-
-    // Workspace array in shared memory
-    __shared__ unsigned int workspace[2048];
-
-    //...
-
-    // Perform reduction
-    output = reduce_sum(workspace, input);
-
-    //...
-}
-```
-
-## Cooperative groups
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        //                                                                                                                                                                                                        const auto                                                                                                                                                                                                        }                                                                                                                                                                                                        /*                                                                                                                                                                                                        */                                                                                                                                                                                                        *
-```
-
-(continued from previous page)
-
-```
-    thread_block thread_block_group = this_thread_block();
-    // Perform reduction
-    output = reduce_sum(thread_block_group, workspace, input);
-
-    //...
-}
-```
-
-At the device function, the input group type is the thread\_group , which is the parent class of all the cooperative groups type. With this, you can write generic functions, which can work with any type of cooperative groups.
-
-## 14.4 Synchronization
-
-With each group type, the synchronization requires using the correct cooperative groups launch API.
-
-## Check the kernel launch capability
-
-## Thread-block
-
-Do not need kernel launch validation.
-
-## Grid
-
-Confirm the cooperative launch capability on the single AMD GPU:
-
-```
-    Confirm the cooperative launch capability on the single AMD GPU:
-
-    int device                       = 0;
-    int supports_coop_launch = 0;
-    // Check support
-    // Use hipDeviceAttributeCooperativeMultiDeviceLaunch when launching across multiple_
-    --devices
-    HIP_CHECK(hipGetDevice(&device));
-    HIP_CHECK(
-        hipDeviceGetAttribute(&supports_coop_launch, hipDeviceAttributeCooperativeLaunch,\
-    --device));
-    if(!supports_coop_launch)
-    {
-        std::cout << "Skipping, device " << device << " does not support cooperative groups"
-                       << std::endl;
-        return 0;
-    }
-```
-
-## Multi-grid
-
-Confirm the cooperative launch capability over multiple GPUs:
-
-```
-    Multi-grid
-
-    Confirm the cooperative launch capability over multiple GPUs:
-
-    // Check support of cooperative groups
-    std::vector<int> deviceIDs;
-    for(int deviceID = 0; deviceID < device_count; deviceID++) {
-    #ifdef __HIP_PLATFORM_AMD__
-        int supports_coop_launch = 0;
-        HIP_CHECK(
-            hipDeviceGetAttribute(
-                &supports_coop_launch,
-                hipDeviceAttributeCooperativeMultiDeviceLaunch,
-                deviceID));
-        if(!supports_coop_launch) {
-            std::cout << "Skipping, device " << deviceID << " does not support cooperative_
-    --groups"
-                        << std::endl;
-        }
-        else
-    #endif
-        {
-            std::cout << deviceID << std::endl;
-            // Collect valid deviceIDs.
-            deviceIDs.push_back(deviceID);
-        }
-    }
-
-    Kernel launch
-
-    __   ...  .
-```
-
-## Kernel launch
-
-## Thread-block
-
-You can access the new block representation using the original kernel launch methods.
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        // Launching kernel  from host.
-```
-
-## Grid
-
-Launch the cooperative kernel on a single GPU:
-
-```
-<_C_>
-```
-
-## Multi-grid
-
-Launch the cooperative kernel over multiple GPUs:
-
-```
-    Multi-grid
-
-    Launch the cooperative kernel over multiple GPUs:
-
-    hipLaunchParams *launchParamsList = (hipLaunchParams*)malloc(sizeof(hipLaunchParams) *_
-    --deviceIDs.size());
-    for(int deviceID : deviceIDs) {
-
-        // Set device
-        HIP_CHECK(hipSetDevice(deviceID));
-
-        // Create stream
-        hipStream_t stream;
-        HIP_CHECK(hipStreamCreate(&stream));
-
-        // Parameters
-        void* params[] = {&(d_vector[deviceID]), &(d_block_reduced[deviceID]), &(d_partition_
-    --reduced[deviceID])};
-
-        // Set launchParams
-        launchParamsList[deviceID].func = (void*)vector_reduce_kernel<partition_size>;
-        launchParamsList[deviceID].gridDim = dim3(1);
-        launchParamsList[deviceID].blockDim = dim3(threads_per_block);
-        launchParamsList[deviceID].sharedMem = 0;
-        launchParamsList[deviceID].stream = stream;
-        launchParamsList[deviceID].args = params;
-    }
-
-    HIP_CHECK(hipLaunchCooperativeKernelMultiDevice(launchParamsList,
-                                                                                                                                                                                                         (int)deviceIDs.size(),
-                                                                                                                                                                                                       )
-    --hipCooperativeLaunchMultiDeviceNoPreSync));
-
-    Device side synchronization
-```
-
-Device side synchronization
-
-## Thread-block
-
-The device side code of the thread\_block synchronization over single GPUs:
-
-```
-<_C_>
-```
-
-## Grid
-
-The device side code of the grid synchronization over single GPUs:
-
-```
-<_Cython_>
-```
-
-```
-  =  this._grid() ;
-```
-
-## Multi-grid
-
-The device side code of the multi-grid synchronization over multiple GPUs:
-
-```
-            |multi_grid_group multi_grid = this_multi_grid();
-```
-
-```
-|multi_grid.sync();
-```
-
-## 14.5 Unsupported NVIDIA CUDA features
-
-HIP doesn't support the following NVIDIA CUDA optional headers:
-
-- cooperative\_groups/memcpy\_async.h
-- cooperative\_groups/reduce.h
-- cooperative\_groups/scan.h
-
-HIP doesn't support the following CUDA class in cooperative\_groups namespace:
-
-- cluster\_group
-
-HIP doesn't support the following CUDA functions/operators in cooperative\_groups namespace:
-
-- synchronize
-- memcpy\_async
-- wait and wait\_prior
-- barrier\_arrive and barrier\_wait
-- invoke\_one and invoke\_one\_broadcast
-- reduce
-- reduce\_update\_async and reduce\_store\_async
-- Reduce operators plus , less , greater , bit\_and , bit\_xor and bit\_or
-- inclusive\_scan and exclusive\_scan
-
-## CHAPTER
-
-## FIFTEEN
-
-## UNIFIED MEMORY
-
-In conventional architectures, CPUs and GPUs have dedicated memory like Random Access Memory (RAM) and Video Random Access Memory (VRAM). This architectural design, while effective, can be limiting in terms of memory capacity and bandwidth, as continuous memory copying is required to allow the processors to access the appropriate data. New architectural features like Heterogeneous System Architectures (HSA) and Unified Memory (UM) help avoid these limitations and promise increased efficiency and innovation.
-
-## 15.1 Unified memory
-
-Unified Memory is a single memory address space accessible from any processor within a system. This setup simplifies memory management processes and enables applications to allocate data that can be read or written by code running on either CPUs or GPUs. The Unified memory model is shown in the following figure.
-
-AMD Accelerated Processing Unit (APU) is a typical example of a Unified Memory Architecture. On a single die, a central processing unit (CPU) is combined with an integrated graphics processing unit (iGPU), and both have access to a high-bandwidth memory (HBM) module named Unified Memory. The CPU enables high-performance, low-latency operations, while the GPU is optimized for high throughput (data processed by unit time).
-
-## 15.2 System requirements
-
-Unified memory is supported on Linux by all modern AMD GPUs from the Vega series onward. Unified memory management can be achieved with managed memory allocation and, for the latest GPUs, with a system allocator.
-
-The table below lists the supported allocators. The allocators are described in the next section.
-
-Table 1: Supported Unified Memory Allocators
-
-| Architecture        | hipMallocManaged()   | __managed__   | malloc()   |
-|---------------------|----------------------|---------------|------------|
-| MI200, MI300 Series |                      |               | 1          |
-| MI100               |                      |               |            |
-| RDNA (Navi) Series  |                      |               |            |
-| GCN5 (Vega) Series  |                      |               |            |
-
-## : Supported
-
-- : Unsupported
-
-1 Works only with XNACK=1 . First GPU access causes recoverable page-fault. For more details, visit GPU memory.
-
-## 15.3 Unified memory programming models
-
-Showcasing various unified memory programming models, the model availability depends on your architecture. For more information, see System requirements and Checking unified memory management support .
-
-- HIP managed memory allocation API :
-
-The hipMallocManaged() is a dynamic memory allocator available on all GPUs with unified memory support. For more details, visit HIP managed memory allocation API .
-
-- HIP managed variables :
-
-The \_\_managed\_\_ declaration specifier, which serves as its counterpart, is supported on all modern AMD cards and can be utilized for static allocation.
-
-- System allocation API :
-
-Starting with the AMD MI300 series, the malloc() system allocator allows you to reserve unified memory. The system allocator is more versatile and offers an easy transition from a CPU written C++ code to a HIP code as the same system allocation API is used.
-
-## 15.3.1 Checking unified memory management support
-
-Some device attributes can offer information about which Unified memory programming models are supported. The attribute value is 1 if the functionality is supported, and 0 if it is not supported.
-
-Table 2: Device attributes for unified memory management
-
-| attribute description                                                                                 |
-|-------------------------------------------------------------------------------------------------------|
-| hipDeviceAttributeManagedMemory unified addressing is supported                                       |
-| hipDeviceAttributeConcurrentManagedAccess full managed memory support, concurrent access is supported |
-| hipDeviceAttributePageableMemoryAccess both managed and system memory allocation API is supported     |
-
-The following examples show how to use device attributes:
-
-```
-
-
-#include <hip/hip_runtime.h>
-#include <iostream>
-
-int main()  {
-        int d;
-        hipGetDevice(&d);
-
-        int  is_cma = 0;
-        hipDeviceGetAttribute(&is_cma, hipDeviceAttributeConcurrentManagedAccess, d);
-        std::cout << "HIP Managed Memory: "
-                       << (is_cma == 1? "is" : "NOT")
-                        << " " supported" << std::endl;
-        return 0;
-}
-```
-
-## 15.3.2 Example for unified memory management
-
-The following example shows how to use unified memory management with hipMallocManaged() , function, with \_\_managed\_\_ attribute for static allocation and standard malloc() allocation. For comparison, the Explicit Memory Management example is presented in the last tab.
-
-## hipMallocManaged()
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        //                                                                                                                                                                                                        }                                                                                                                                                                                                        */
-                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       //
-                                                                                                                                                                                                      
-
-
-                                                                                                                                                                                                       }
-                                                                                                                                                                                                       */
-```
-
-\_\_managed\_\_
-
-```
-__managed__
-
-#include <hip/hip_runtime.h>
-#include <iostream>
-
-// Addition of two values.
-__global__ void add(int *a, int *b, int *c) {
-    *c = *a + *b;
-}
-
-// Declare a, b and c as static variables.
-__managed__ int a, b, c;
-
-int main() {
-    // Setup input values.
-    a = 1;
-    b = 2;
-
-    // Launch add() kernel on GPU.
-    hipLaunchKernelGGL(add, dim3(1), dim3(1), 0, 0, &a, &b, &c);
-
-    // Wait for GPU to finish before accessing on host.
-    hipDeviceSynchronize();
-
-    // Prints the result.
-    std::cout << a << " + " << b << " = " << c << std::endl;
-
-    return 0;
-}
-
-
-malloc()
-```
-
-## malloc()
-
-```
-malloc()
-
-#include <hip/hip_runtime.h>
-#include <iostream>
-
-// Addition of two values.
-__global__ void add(int* a, int* b, int* c) {
-    *c = *a + *b;
-}
-
-int main() {
-    int* a, * b, * c;
-
-    // Allocate memory for a, b, and c.
-    a = (int*)malloc(sizeof(*a));
-    b = (int*)malloc(sizeof(*b));
-    c = (int*)malloc(sizeof(*c));
-
-    // Setup input values.
-    *a = 1;
-    *b = 2;
-```
-
-(continues on next page)
-
-(continued from previous page)
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-        // Launch add() kernel on GPU.
-        hipLaunchKernelGGL(add, dim3(1), dim3(1), 0, 0, a, b, c);
-
-        // Wait for GPU to finish before accessing on host.
-        hipDeviceSynchronize();
-
-        // Prints the result.
-        std::cout << *a << " + " << *b << " = " << *c << std::endl;
-
-        // Cleanup allocated memory.
-        free(a);
-        free(b);
-        free(c);
-
-        return 0;
-    }
-```
-
-```
-        tree<J;
-
-        return 0;
-    }
-
-
-    Explicit Memory Management
-
-    #include <hip/hip_runtime.h>
-    #include <iostream>
-
-    // Addition of two values.
-    __global__ void add(int *a, int *b, int *c) {
-        *c = *a + *b;
-    }
-
-    int main() {
-        int a, b, c;
-        int *d_a, *d_b, *d_c;
-
-        // Setup input values.
-        a = 1;
-        b = 2;
-
-        // Allocate device copies of a, b and c.
-        hipMalloc(&d_a, sizeof(*d_a));
-        hipMalloc(&d_b, sizeof(*d_b));
-        hipMalloc(&d_c, sizeof(*d_c));
-
-        // Copy input values to device.
-        hipMemcpy(d_a, &a, sizeof(*d_a), hipMemcpyHostToDevice);
-        hipMemcpy(d_b, &b, sizeof(*d_b), hipMemcpyHostToDevice);
-
-        // Launch add() kernel on GPU.
-        hipLaunchKernelGGL(add, dim3(1), dim3(1), 0, 0, d_a, d_b, d_c);
-
-        // Copy the result back to the host.
-        hipMemcpy(&c, d_c, sizeof(*d_c), hipMemcpyDeviceToHost);
-                                                                                                                                                                                                         (continues on next page)
-
-
-    15.3. Unified memory programming models                                                                                                                                                                                                        103
-```
-
-```
-
-    // Cleanup allocated memory.
-    hipFree(d_a);
-    hipFree(d_b);
-    hipFree(d_c);
-
-    // Prints the result.
-    std::cout << a << " + " << b << " = " << c << std::endl;
-
-    return 0;
-}
-```
-
-## 15.4 Using unified memory management (UMM)
-
-Unified memory management (UMM) is a feature that can simplify the complexities of memory management in GPU computing. It is particularly useful in heterogeneous computing environments with heavy memory usage with both a CPU and a GPU, which would require large memory transfers. Here are some areas where UMM can be beneficial:
-
-- Simplification of Memory Management :
-
-UMMcan help to simplify the complexities of memory management. This can make it easier for developers to write code without worrying about memory allocation and deallocation details.
-
-- Data Migration :
-
-UMMallows for efficient data migration between the host (CPU) and the device (GPU). This can be particularly useful for applications that need to move data back and forth between the device and host.
-
-- Improved Programming Productivity :
-
-As a positive side effect, UMM can reduce the lines of code, thereby improving programming productivity.
-
-In HIP, pinned memory allocations are coherent by default. Pinned memory is host memory mapped into the address space of all GPUs, meaning that the pointer can be used on both host and device. Using pinned memory instead of pageable memory on the host can improve bandwidth.
-
-While UMMcanprovide numerous benefits, it's important to be aware of the potential performance overhead associated with UMM. You must thoroughly test and profile your code to ensure it's the most suitable choice for your use case.
-
-## 15.5 Unified memory HIP runtime hints for the better performance
-
-Unified memory HIP runtime hints can help improve the performance of your code if you know your code's ability and infrastructure. Some hint techniques are presented in this section.
-
-Thehint functions can set actions on a selected device, which can be identified by hipGetDeviceProperties(&amp;prop, device\_id) . There are two special device\_id values:
-
-- hipCpuDeviceId = -1 means that the advised device is the CPU.
-- hipInvalidDeviceId = -2 means that the device is invalid.
-
-For the best performance, profile your application to optimize the utilization of HIP runtime hints.
-
-(continued from previous page)
-
-## 15.5.1 Data prefetching
-
-Data prefetching is a technique used to improve the performance of your application by moving data closer to the processing unit before it's actually needed.
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        // All                                                                                                                                                                                                        }
-                                                                                                                                                                                                      
-//                                                                                                                                                                                                        #                                                                                                                                                                                                        */
-                                                                                                                                                                                                       //                                                                                                                                                                                                        *
-                                                                                                                                                                                                       */
-
-                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       *
-
-                                                                                                                                                                                                       *                                                                                                                                                                                                        /*
-                                                                                                                                                                                                       /*
-
-                                                                                                                                                                                                       */                                                                                                                                                                                                        /
-                                                                                                                                                                                                       }
-```
-
-Remember to check the return status of hipMemPrefetchAsync() to ensure that the prefetch operations are completed successfully.
-
-## 15.5.2 Memory advice
-
-The effectiveness of hipMemAdvise() comes from its ability to inform the runtime system of the developer's intentions regarding memory usage. When the runtime system has knowledge of the expected memory access patterns, it can make better decisions about data placement and caching, leading to more efficient execution of the application. However, the actual impact on performance can vary based on the specific use case and the hardware architecture.
-
-For the description of hipMemAdvise() and the detailed list of advice, visit the HIP managed memory allocation API .
-
-Here is the updated version of the example above with memory advice.
-
-```
-
-    The effectiveness of nipMemAdvise() comes from its ability to inform the runtime system at the developer's intentions
-    regarding memory usage. When the runtime system has knowledge of the expected memory access patterns, it can make
-    better decisions about data placement and caching, leading to more efficient execution of the application. However, the
-    actual impact on performance can vary based on the specific use case and the hardware architecture.
-    For the description of hipMemAdvise() and the detailed list of advice, visit the HIP managed memory allocation API.
-    Here is the updated version of the example above with memory advice.
-    
-  #include <hip/hip_runtime.h>
-  #include <iostream>
-    
-  // Addition of two values.
-  __global__ void add(int *a, int *b, int *c) {
-      *c = *a + *b;
-  }
-  
-  int main() {
-      int *a, *b, *c;
-      
-      // Allocate memory for a, b, and c accessible to both device and host codes.
-      hipMallocManaged(&a, sizeof(*a));
-      hipMallocManaged(&b, sizeof(*b));
-      hipMallocManaged(&c, sizeof(*c));
-      
-      // Set memory advice for a, b, and c to be accessed by the CPU.
-      hipMemAdvise(a, sizeof(*a), hipMemAdviseSetPreferredLocation, hipCpuDeviceId);
-      hipMemAdvise(b, sizeof(*b), hipMemAdviseSetPreferredLocation, hipCpuDeviceId);
-      hipMemAdvise(c, sizeof(*c), hipMemAdviseSetPreferredLocation, hipCpuDeviceId);
-      
-      // Additionally, set memory advice for a, b, and c to be read mostly from the device.
-  __0.
-      constexpr int device = 0;
-      hipMemAdvise(a, sizeof(*a), hipMemAdviseSetReadMostly, device);
-      hipMemAdvise(b, sizeof(*b), hipMemAdviseSetReadMostly, device);
-      hipMemAdvise(c, sizeof(*c), hipMemAdviseSetReadMostly, device);
-      
-      // Setup input values.
-      *a = 1;
-      *b = 2;
-      
-      // Launch add() kernel on GPU.
-      hipLaunchKernelGGL(add, dim3(1), dim3(1), 0, 0, a, b, c);
-      
-      // Wait for GPU to finish before accessing on host.
-      hipDeviceSynchronize();
-      
-      // Prints the result.
-      std::cout << *a << " + " << *b << " = " << *c << std::endl;
-      
-      // Cleanup allocated memory.
-      hipFree(a);
-      
-                                                                                                                                                                                                         (continues on next page)
-      
-      
-      
-  106
-```
-
-(continues on next page)
-
-```
-      hipFree(b);
-      hipFree(c);
-
-      return 0;
-}
-```
-
-## 15.5.3 Memory range attributes
-
-Memory Range attributes allow you to query attributes of a given memory range.
-
-The hipMemRangeGetAttribute() is added to the example to query the hipMemRangeAttributeReadMostly attribute of the memory range pointed to by a . The result is stored in attributeValue and then printed out.
-
-For more details, visit the HIP managed memory allocation API .
-
-```
-
-        Memory Range attributes allow you to query attributes of a given memory range.
-        The hipMemRangeGetAttribute() is added to the example to query the hipMemRangeAttributeReadMostly at-
-        title of the memory range pointed to by a. The result is stored in attributeValue and then printed out.
-        For more details, visit the HIP managed memory allocation API.
-        #include <hip/hip_runtime.h>
-        #include <iostream>
-        
-        // Addition of two values.
-        __global__ void add(int *a, int *b, int *c) {
-            *c = *a + *b;
-        }
-        
-        int main() {
-            int *a, *b, *c;
-            unsigned int attributeValue;
-            constexpr size_t attributeSize = sizeof(attributeValue);
-            
-            // Allocate memory for a, b and c that is accessible to both device and host codes.
-            hipMallocManaged(&a, sizeof(*a));
-            hipMallocManaged(&b, sizeof(*b));
-            hipMallocManaged(&c, sizeof(*c));
-            
-            // Setup input values.
-            *a = 1;
-            *b = 2;
-            
-            // Launch add() kernel on GPU.
-            hipLaunchKernelGGL(add, dim3(1), dim3(1), 0, 0, a, b, c);
-            
-            // Wait for GPU to finish before accessing on host.
-            hipDeviceSynchronize();
-            
-            // Query an attribute of the memory range.
-            hipMemRangeGetAttribute(&attributeValue,
-                                             attributeSize,
-                                              hipMemRangeAttributeReadMostly,
-                                              a,
-                                               sizeof(*a));
-             
-            // Prints the result.
-            std::cout << *a << " + " << *b << " = " << *c << std::endl;
-                                                                                                                                                                                                         (continues on next page)
-                                                                                                                                                                                                      
-                                                                                                                                                                                                       )
-                                                                                                                                                                                                       (Continues on next page)
-```
-
-(continues on next page)
-
-(continued from previous page)
-
-(continued from previous page)
-
-```
-    std::cout << "The queried attribute value is: " << attributeValue << std::endl;
-
-    // Cleanup allocated memory.
-    hipFree(a);
-    hipFree(b);
-    hipFree(c);
-
-    return 0;
-}
-```
-
-## 15.5.4 Asynchronously attach memory to a stream
-
-The hipStreamAttachMemAsync function would be able to asynchronously attach memory to a stream, which can help concurrent execution when using streams.
-
-Currently, this function is a no-operation (NOP) function on AMD GPUs. It simply returns success after the runtime memory validation passed. This function is necessary on Microsoft Windows, and UMM is not supported on this operating system with AMD GPUs at the moment.
-
-CHAPTER
-
-## SIXTEEN
-
-## VIRTUAL MEMORY MANAGEMENT
-
-Memorymanagement is important when creating high-performance applications in the HIP ecosystem. Both allocating and copying memory can result in bottlenecks, which can significantly impact performance.
-
-Global memory allocation in HIP uses the C language style allocation function. This works fine for simple cases but can cause problems if your memory needs change. If you need to increase the size of your memory, you must allocate a second larger buffer and copy the data to it before you can free the original buffer. This increases overall memory usage and causes unnecessary memcpy calls. Another solution is to allocate a larger buffer than you initially need. However, this isn't an efficient way to handle resources and doesn't solve the issue of reallocation when the extra buffer runs out.
-
-Virtual memory management solves these memory management problems. It helps to reduce memory usage and unnecessary memcpy calls.
-
-## 16.1 Memory allocation
-
-Standard memory allocation uses the hipMalloc function to allocate a block of memory on the device. However, when using virtual memory, this process is separated into multiple steps using the hipMemCreate , hipMemAddressReserve , hipMemMap , and hipMemSetAccess functions. This guide explains what these functions do and how you can use them for virtual memory management.
-
-## 16.1.1 Allocate physical memory
-
-The first step is to allocate the physical memory itself with the hipMemCreate function. This function accepts the size of the buffer, an unsigned long long variable for the flags, and a hipMemAllocationProp variable. hipMemAllocationProp contains the properties of the memory to be allocated, such as where the memory is physically located and what kind of shareable handles are available. If the allocation is successful, the function returns a value of hipSuccess , with hipMemGenericAllocationHandle\_t representing a valid physical memory allocation. The allocated memory size must be aligned with the granularity appropriate for the properties of the allocation. You can use the hipMemGetAllocationGranularity function to determine the correct granularity.
-
-```
-<_C_>
-```
-
-## 16.1.2 Reserve virtual address range
-
-After you have acquired an allocation of physical memory, you must map it before you can use it. To do so, you need a virtual address to map it to. Mapping means the physical memory allocation is available from the virtual address range it is mapped to. To reserve a virtual memory range, use the hipMemAddressReserve function. The size of the virtual memory must match the amount of physical memory previously allocated. You can then map the physical memory allocation to the newly-acquired virtual memory address range using the hipMemMap function.
-
-```
-0) ;
-```
-
-```
-<_C++_>
-```
-
-## 16.1.3 Set memory access
-
-Finally, use the hipMemSetAccess function to enable memory access. It accepts the pointer to the virtual memory, the size, and a hipMemAccessDesc descriptor as parameters. In a multi-GPU environment, you can map the device memory of one GPU to another. This feature also works with the traditional memory management system, but isn't as scalable as with virtual memory. When memory is allocated with hipMalloc , hipDeviceEnablePeerAccess is used to enable peer access. This function enables access between two devices, but it means that every call to hipMalloc takes more time to perform the checks and the mapping between the devices. When using virtual memory management, peer access is enabled by hipMemSetAccess , which provides a finer level of control over what is shared. This has no performance impact on memory allocation and gives you more control over what memory buffers are shared with which devices.
-
-```
-hipMemAccessDesc accessDesc = {};
-accessDesc.location.type = HIP_MEM_LOCATION_TYPE_DEVICE;
-accessDesc.location.id = currentDev;
-accessDesc.flags = HIP_MEM_ACCESS_FLAGS_PROT_READWRITE;
-hipMemSetAccess(ptr, padded_size, &accessDesc, 1);
-```
-
-At this point the memory is allocated, mapped, and ready for use. You can read and write to it, just like you would a C style memory allocation.
-
-## 16.1.4 Free virtual memory
-
-To free the memory allocated in this manner, use the corresponding free functions. To unmap the memory, use hipMemUnmap . To release the virtual address range, use hipMemAddressFree . Finally, to release the physical memory, use hipMemRelease . A side effect of these functions is the lack of synchronization when memory is released. If you call hipFree when you have multiple streams running in parallel, it synchronizes the device. This causes worse resource usage and performance.
-
-```
-        |hipMemUnmap(ptr, size);
-        |hipMemRelease(allocHandle);
-```
-
-```
-        |hipMemAddressFree(ptr,  size);
-```
-
-## 16.2 Memory usage
-
-## 16.2.1 Dynamically increase allocation size
-
-The hipMemAddressReserve function allows you to increase the amount of pre-allocated memory. This function accepts a parameter representing the requested starting address of the virtual memory. This allows you to have a continuous virtual address space without worrying about the underlying physical allocation.
-
-```
-            hipMemAddressReserve(&new_ptr, (new_size - padded_size), 0, ptr + padded_size, 0);
-            hipMemMap(new_ptr, (new_size - padded_size), 0, newAllocHandle, 0);
-            hipMemSetAccess(new_ptr, (new_size - padded_size), &accessDesc, 1);
-```
-
-The code sample above assumes that hipMemAddressReserve was able to reserve the memory address at the specified location. However, this isn't guaranteed to be true, so you should validate that new\_ptr points to a specific virtual address before using it.
-
-## CHAPTER
-
-## SEVENTEEN
-
-## FREQUENTLY ASKED QUESTIONS
-
-## 17.1 What APIs and features does HIP support?
-
-HIP provides the following:
-
-- Devices ( hipSetDevice() , hipGetDeviceProperties() , etc.)
-- Memory management ( hipMalloc() , hipMemcpy() , hipFree() , etc.)
-- Streams ( hipStreamCreate() , hipStreamSynchronize() , hipStreamWaitEvent() , etc.)
-- Events ( hipEventRecord() , hipEventElapsedTime() , etc.)
-- Kernel launching ( hipLaunchKernel / hipLaunchKernelGGL is the preferred way of launching kernels. hipLaunchKernelGGL is a standard C/C++ macro that can serve as an alternative way to launch kernels, replacing the CUDA triple-chevron ( &lt;&lt;&lt; &gt;&gt;&gt; ) syntax).
-- HIP Module API to control when and how code is loaded.
-- CUDA-style kernel coordinate functions ( threadIdx , blockIdx , blockDim , gridDim )
-- Cross-lane instructions including shfl , ballot , any , all
-- Most device-side math built-ins
-- Error reporting ( hipGetLastError() , hipGetErrorString() )
-
-The HIP API documentation describes each API and its limitations, if any, compared with the equivalent CUDA API.
-
-## 17.2 What is not supported?
-
-## 17.2.1 Runtime/Driver API features
-
-At a high-level, the following features are not supported:
-
-- Textures (partial support available)
-- Dynamic parallelism (CUDA 5.0)
-- Graphics interoperability with OpenGL or Direct3D
-- CUDA IPC Functions (Under Development)
-- CUDA array, mipmappedArray and pitched memory
-- Queue priority controls
-
-See the API Support Table for more detailed information.
-
-## 17.2.2 Kernel language features
-
-- C+ ± style device-side dynamic memory allocations (free, new, delete) (CUDA 4.0)
-- Virtual functions, indirect functions and try/catch (CUDA 4.0)
-- \_\_prof\_trigger
-- PTX assembly (CUDA 4.0). HIP-Clang supports inline GCN assembly.
-- Several kernel features are under development. See the C++ language extensions for more information.
-
-## 17.3 Is HIP a drop-in replacement for CUDA?
-
-No. HIP provides porting tools which do most of the work to convert CUDA code into portable C++ code that uses the HIP APIs. Most developers will port their code from CUDA to HIP and then maintain the HIP version. HIP code provides the same performance as native CUDA code, plus the benefits of running on AMD platforms.
-
-## 17.4 What specific version of CUDA does HIP support?
-
-HIP APIs and features do not map to a specific CUDA version. HIP provides a strong subset of the functionality provided in CUDA, and the hipify tools can scan code to identify any unsupported CUDA functions - this is useful for identifying the specific features required by a given application.
-
-However, we can provide a rough summary of the features included in each CUDA SDK and the support level in HIP. Each bullet below lists the major new language features in each CUDA release and then indicate which are supported/not supported in HIP:
-
-- CUDA 4.0 and earlier :
-- -HIP supports CUDA 4.0 except for the limitations described above.
-- CUDA 5.0 :
-- -Dynamic Parallelism (not supported)
-- -cuIpc functions (under development).
-- CUDA 6.0 :
-- -Managed memory (under development)
-- CUDA 6.5 :
-- -\_\_shfl intrinsic (supported)
-- CUDA 7.0 :
-- -Per-thread default streams (supported)
-- -C++11 (Hip-Clang supports all of C++11, all of C++14 and some C++17 features)
-- CUDA 7.5 :
-- -float16 (supported)
-- CUDA 8.0 :
-- -Page Migration including cudaMemAdvise , cudaMemPrefetch , other cudaMem* APIs(not supported)
-- CUDA 9.0 :
-
-- -Cooperative Launch, Surface Object Management, Version Management
-
-## 17.5 What libraries does HIP support?
-
-HIP includes growing support for the four key math libraries using hipBLAS, hipFFT, hipRAND and hipSPARSE, as well as MIOpen for machine intelligence applications. These offer pointer-based memory interfaces (as opposed to opaque buffers) and can be easily interfaced with other HIP applications. The hip interfaces support both ROCm and CUDA paths, with familiar library interfaces.
-
-- hipBLAS, which utilizes rocBlas.
-- hipFFT
-- hipsSPARSE
-- hipRAND
-- MIOpen
-
-Additionally, some of the cuBLAS routines are automatically converted to hipblas equivalents by the HIPIFY tools. These APIs use cuBLAS or hcBLAS depending on the platform and replace the need to use conditional compilation.
-
-## 17.6 How does HIP compare with OpenCL?
-
-Both AMD and NVIDIA support OpenCL 1.2 on their devices so that developers can write portable code. HIP offers several benefits over OpenCL:
-
-- Developers can code in C++ as well as mix host and device C++ code in their source files. HIP C++ code can use templates, lambdas, classes and so on.
-- The HIP API is less verbose than OpenCL and is familiar to CUDA developers.
-- Because both CUDA and HIP are C++ languages, porting from CUDA to HIP is significantly easier than porting from CUDA to OpenCL.
-- HIP uses the best available development tools on each platform: on NVIDIA GPUs, HIP code compiles using NVCC and can employ the Nsight profiler and debugger (unlike OpenCL on NVIDIA GPUs).
-- HIP provides pointers and host-side pointer arithmetic.
-- HIP provides device-level control over memory allocation and placement.
-- HIP offers an offline compilation model.
-
-## 17.7 How does porting CUDA to HIP compare to porting CUDA to OpenCL?
-
-Both HIP and CUDA are dialects of C++, and thus porting between them is relatively straightforward. Both dialects support templates, classes, lambdas, and other C++ constructs. As one example, the hipify-perl tool was originally a Perl script that used simple text conversions from CUDA to HIP. HIP and CUDA provide similar math library calls as well. In summary, the HIP philosophy was to make the HIP language close enough to CUDA that the porting effort is relatively simple. This reduces the potential for error, and also makes it easy to automate the translation. HIP goal is to quickly get the ported program running on both platforms with little manual intervention, so that the programmer can focus on performance optimizations.
-
-There have been several tools that have attempted to convert CUDA into OpenCL, such as CU2CL. OpenCL is a C99based kernel language (rather than C++) and also does not support single-source compilation. As a result, the OpenCL syntax is different from CUDA, and the porting tools have to perform some heroic transformations to bridge this gap. The tools also struggle with more complex CUDA applications, in particular, those that use templates, classes, or other C++ features inside the kernel.
-
-## 17.8 What hardware does HIP support?
-
-- For AMD platforms, see the ROCm documentation for the list of supported platforms.
-- For NVIDIA platforms, HIP requires unified memory and should run on any device supporting CUDA SDK 6.0 or newer. We have tested the NVIDIA Titan and Tesla K40.
-
-## 17.9 Do HIPIFY tools automatically convert all source code?
-
-Typically, HIPIFY tools can automatically convert almost all run-time code. Most device code needs no additional conversion since HIP and CUDA have similar names for math and built-in functions. The hipify-clang tool will automatically modify the kernel signature as needed (automating a step that used to be done manually). Additional porting may be required to deal with architecture feature queries or with CUDA capabilities that HIP doesn't support. In general, developers should always expect to perform some platform-specific tuning and optimization.
-
-## 17.10 What is NVCC?
-
-NVCC is NVIDIA's compiler driver for compiling 'CUDA C++' code into PTX or device code for NVIDIA GPUs. It's a closed-source binary compiler that is provided by the CUDA SDK.
-
-## 17.11 What is HIP-Clang?
-
-HIP-Clang is a Clang/LLVM based compiler to compile HIP programs which can run on AMD platform.
-
-## 17.12 Why use HIP rather than supporting CUDA directly?
-
-While HIP is a strong subset of the CUDA, it is a subset. The HIP layer allows that subset to be clearly defined and documented. Developers who code to the HIP API can be assured their code will remain portable across NVIDIA and AMD platforms. In addition, HIP defines portable mechanisms to query architectural features and supports a larger 64-bit WaveSize which expands the return type for cross-lane functions like ballot and shuffle from 32-bit integers to 64-bit integers.
-
-## 17.13 Can I develop HIP code on an NVIDIA CUDA platform?
-
-Yes. HIP's CUDA path only exposes the APIs and functionality that work on both NVCC and AMDGPU back-ends. 'Extra' APIs, parameters, and features which exist in CUDA but not in HIP-Clang will typically result in compile-time or run-time errors. Developers need to use the HIP API for most accelerator code and bracket any CUDA-specific code with preprocessor conditionals. Developers concerned about portability should, of course, run on both platforms, and should expect to tune for performance. In some cases, CUDA has a richer set of modes for some APIs, and some C++ capabilities such as virtual functions - see the HIP @API documentation for more details.
-
-## 17.14 Can I develop HIP code on an AMD HIP-Clang platform?
-
-Yes. HIP's HIP-Clang path only exposes the APIs and functions that work on AMD runtime back ends. 'Extra' APIs, parameters and features that appear in HIP-Clang but not CUDA will typically cause compile- or run-time errors. Developers must use the HIP API for most accelerator code and bracket any HIP-Clang specific code with preprocessor conditionals. Those concerned about portability should, of course, test their code on both platforms and should tune it for performance. Typically, HIP-Clang supports a more modern set of C++11/C++14/C++17 features, so HIP developers who want portability should be careful when using advanced C++ features on the HIP-Clang path.
-
-## 17.15 How to use HIP-Clang to build HIP programs?
-
-The environment variable can be used to set compiler path:
-
-- HIP\_CLANG\_PATH: path to hip-clang. When set, this variable let hipcc to use hip-clang for compilation/linking.
-
-There is an alternative environment variable to set compiler path:
-
-- HIP\_ROCCLR\_HOME: path to root directory of the HIP-ROCclr runtime. When set, this variable let hipcc use hip-clang from the ROCclr distribution. NOTE: If HIP\_ROCCLR\_HOME is set, there is no need to set HIP\_CLANG\_PATH since hipcc will deduce them from HIP\_ROCCLR\_HOME.
-
-## 17.16 What is AMD clr?
-
-AMD Common Language Runtime (CLR) is a repository for the AMD platform, which contains source codes for AMD's compute languages runtimes as follows,
-
-- hipamd - contains implementation of HIP language for AMD GPU.
-- rocclr - contains virtual device interfaces that compute runtimes interact with backends, such as ROCr on Linux and PAL on Windows.
-- opencl - contains implementation of OpenCL™ on the AMD platform.
-
-## 17.17 What is hipother?
-
-A new repository 'hipother' is added in the ROCm 6.1 release, which is branched out from HIP. hipother supports the HIP back-end implementation on some non-AMD platforms, like NVIDIA.
-
-## 17.18 Can I get HIP open source repository for Windows?
-
-No, there is no HIP repository open publicly on Windows.
-
-## 17.19 Can a HIP binary run on both AMD and NVIDIA platforms?
-
-HIP is a source-portable language that can be compiled to run on either AMD or NVIDIA platform. HIP tools don't create a 'fat binary' that can run on either platform, however.
-
-## 17.20 On HIP-Clang, can I link HIP code with host code compiled with another compiler such as gcc, icc, or clang?
-
-Yes. HIP generates the object code which conforms to the GCC ABI, and also links with libstdc++. This means you can compile host code with the compiler of your choice and link the generated object code with GPU code compiled with HIP. Larger projects often contain a mixture of accelerator code (initially written in CUDA with NVCC) and host code (compiled with gcc, icc, or clang). These projects can convert the accelerator code to HIP, compile that code with hipcc, and link with object code from their preferred compiler.
-
-## 17.21 Can HIP API support C style application? What is the difference between C and C++?
-
-HIP is C++ runtime API that supports C style applications as well.
-
-Some C style applications (and interfaces to other languages (FORTRAN, Python)) would call certain HIP APIs but not use kernel programming. They can be compiled with a C compiler and run correctly, however, small details must be considered in the code. For example, initialization, as shown in the simple application below, uses HIP structs dim3 with the file name 'test.hip.cpp'
-
-```
-                                                                                                                                                                                                        //the file name `test.hip.cpp`
-                                                                                                                                                                                                       
-                                                                                                                                                                                                      
-#include "hip/hip_runtime_api.h"
-                                                                                                                                                                                                       //this file name `test.hip.cpp`
-                                                                                                                                                                                             
-          int main(int argc, char** argv) {
-            dim3 grid1;
-            printf("dim3 grid1; x=%d, y=%d, z=%d\n",grid1.x,grid1.y,grid1.z);
-            dim3 grid2 = {1,1,1};
-            printf("dim3 grid2 = {1,1,1}; x=%d, y=%d, z=%d\n",grid2.x,grid2.y,grid2.z);
-            return 0;
-            }
-```
-
-When using a C++ compiler,
-
-```
-$ gcc -x c++  $(hipconfig --cpp_config) test3.hip.cpp -o test
-$./test
-dim3 grid1; x=1, y=1, z=1
-dim3 grid2 = {1,1,1}; x=1, y=1, z=1
-```
-
-In which 'dim3 grid1;' will yield a dim3 grid with all dimensional members x,y,z initialized to 1, as the default constructor behaves that way. Further, if written: dim3 grid(2); // yields {2,1,1} dim3 grid(2,3); yields {2,3,1} In comparison, when using the C compiler, $ gcc -x c $( hipconfig --cpp\_config ) test.hip.cpp -o test $ ./test dim3 grid1; x=646881376, y=21975, z=1517277280 dim3 grid2 = {1,1,1}; x=1, y=1, z=1 In which 'dim3 grid;' does not imply any initialization, no constructor is called, and dimensional values x,y,z of grid are undefined. NOTE: To get the C++ default behavior, C programmers must additionally specify the right-hand side as shown below,
-
-```
-        |dim3 grid = {1,1,1}; // initialized as in C++
-```
-
-```
-C++
-```
-
-## 17.22 Can I install both CUDA SDK and HIP-Clang on the same machine?
-
-Yes. You can use HIP\_PLATFORM to choose which path hipcc targets. This configuration can be useful when using HIP to develop an application which is portable to both AMD and NVIDIA.
-
-## 17.23 HIP detected my platform (HIP-Clang vs NVCC) incorrectly * what should I do?
-
-HIP will set the platform to AMD and use HIP-Clang as compiler if it sees that the AMD graphics driver is installed and has detected an AMD GPU. Sometimes this isn't what you want * you can force HIP to recognize the platform by setting the following,
-
-```
-| export
-```
-
-```
-rt HIP_PLATFORM=amd
-```
-
-```
-<_Python_>
-```
-
-```
-  | HIP_COMPILER=cuda
-```
-
-```
-  | HIP_RUNTIME=nvcc
-```
-
-One symptom of this problem is the message 'error: 'unknown error'(11) at square.hipref.cpp:56 . This can occur if you have a CUDA installation on an AMD platform, and HIP incorrectly detects the platform as NVCC. HIP may be able to compile the application using the NVCC tool-chain but will generate this error at runtime since the platform does not have a CUDA device.
-
-## 17.24 On CUDA, can I mix CUDA code with HIP code?
-
-Yes. Most HIP data structures ( hipStream\_t , hipEvent\_t ) are typedefs to CUDA equivalents and can be intermixed. Both CUDA and HIP use integer device ids. One notable exception is that hipError\_t is a new type, and cannot be used where a cudaError\_t is expected. In these cases, refactor the code to remove the expectation. Alternatively, hip\_runtime\_api.h defines functions which convert between the error code spaces:
-
-hipErrorToCudaError hipCUDAErrorTohipError hipCUResultTohipError
-
-If platform portability is important, use #ifdef \_\_HIP\_PLATFORM\_NVIDIA\_\_ to guard the CUDA-specific code.
-
-## 17.25 How do I trace HIP application flow?
-
-See Logging HIP activity for more information.
-
-## 17.26 What are the maximum limits of kernel launch parameters?
-
-Product of block.x, block.y, and block.z should be less than 1024. Please note, HIP does not support kernel launch with total work items defined in dimension with size gridDim x blockDim &gt;= 2^32 , so gridDim.x * blockDim.x, gridDim.y * blockDim.y and gridDim.z * blockDim.z are always less than 2^32.
-
-## 17.27 Are \_\_shfl\_*\_sync functions supported on HIP platform?
-
-\_\_shfl\_*\_sync is not supported on HIP but for NVCC path CUDA 9.0 and above all shuffle calls get redirected to it's sync version.
-
-## 17.28 How to create a guard for code that is specific to the host or the GPU?
-
-The compiler defines the \_\_HIP\_DEVICE\_COMPILE\_\_ macro only when compiling the code for the GPU. It could be used to guard code that is specific to the host or the GPU.
-
-## 17.29 Why \_OpenMP is undefined when compiling with -fopenmp ?
-
-When compiling an OpenMP source file with hipcc -fopenmp , the compiler may generate error if there is a reference to the \_OPENMP macro. This is due to a limitation in hipcc that treats any source file type (for example .cpp ) as an HIP translation unit leading to some conflicts with the OpenMP language switch. If the OpenMP source file doesn't contain any HIP language constructs you could work around this issue by adding the -x c++ switch to force the compiler to treat the file as regular C++. Another approach would be to guard the OpenMP code with #ifdef \_OPENMP so that the code block is disabled when compiling for the GPU. The \_\_HIP\_DEVICE\_COMPILE\_\_ macro defined by the HIP compiler when compiling GPU code could also be used for guarding code paths specific to the host or the GPU.
-
-## 17.30 Does the HIP-Clang compiler support extern shared declarations?
-
-Previously, it was essential to declare dynamic shared memory using the HIP\_DYNAMIC\_SHARED macro for accuracy, as using static shared memory in the same kernel could result in overlapping memory ranges and data-races.
-
-Now, the HIP-Clang compiler provides support for extern shared declarations, and the HIP\_DYNAMIC\_SHARED option is no longer required. You may use the standard extern definition: extern shared type var[];
-
-## 17.31 I have multiple HIP enabled devices and I am getting an error code hipErrorSharedObjectInitFailed with the message 'Error: shared object initialization failed'?
-
-This error message is seen due to the fact that you do not have valid code object for all of your devices.
-
-If you have compiled the application yourself, make sure you have given the correct device name(s) and its features via: --offload-arch . If you are not mentioning the --offload-arch , make sure that hipcc is using the correct offload arch by verifying the hipcc output generated by setting the environment variable HIPCC\_VERBOSE=1 .
-
-If you have a precompiled application/library (like rocblas, TensorFlow etc) which gives you such error, there are one of two possibilities.
-
-- The application/library does not ship code object bundles for all of your device(s): in this case you need to recompile the application/library yourself with correct --offload-arch .
-- The application/library does not ship code object bundles for some of your device(s), for example you have a system with an APU + GPU and the library does not ship code objects for your APU. For this you can set the environment variable HIP\_VISIBLE\_DEVICES or CUDA\_VISIBLE\_DEVICES on NVIDIA platform, to only enable GPUs for which code object is available. This will limit the GPUs visible to your application and allow it to run.
-
-Note: In previous releases, the error code is hipErrorNoBinaryForGpu with message 'Unable to find code object for all current devices'. The error code handling behavior is changed. HIP runtime shows the error code hipErrorSharedObjectInitFailed with message 'Error: shared object initialization failed' on unsupported GPU.
-
-## 17.32 How to use per-thread default stream in HIP?
-
-The per-thread default stream is an implicit stream local to both the thread and the current device. It does not do any implicit synchronization with other streams (like explicitly created streams), or default per-thread stream on other threads.
-
-The per-thread default stream is a blocking stream and will synchronize with the default null stream if both are used in a program.
-
-In ROCm, a compilation option should be added in order to compile the translation unit with per-thread default stream enabled. -fgpu-default-stream=per-thread . Once source is compiled with per-thread default stream enabled, all APIs will be executed on per thread default stream, hence there will not be any implicit synchronization with other streams.
-
-Besides, per-thread default stream be enabled per translation unit, users can compile some files with feature enabled and some with feature disabled. Feature enabled translation unit will have default stream as per thread and there will not be any implicit synchronization done but other modules will have legacy default stream which will do implicit synchronization.
-
-## 17.33 How to use complex multiplication and division operations?
-
-In HIP, hipFloatComplex and hipDoubleComplex are defined as complex data types,
-
-```
-<_C_>
-```
-
-Any application uses complex multiplication and division operations, need to replace '*' and '/' operators with the following,
-
-- hipCmulf() and hipCdivf() for hipFloatComplex
-- hipCmul() and hipCdiv() for hipDoubleComplex
-
-Note: These complex operations are equivalent to corresponding types/functions on the NVIDIA platform.
-
-## 17.34 Can I develop applications with HIP APIs on Windows the same on Linux?
-
-Yes, HIP APIs are available to use on both Linux and Windows. Due to different working mechanisms on operating systems like Windows vs Linux, HIP APIs call corresponding lower level backend runtime libraries and kernel drivers for the OS, in order to control the executions on GPU hardware accordingly. There might be a few differences on the related backend software and driver support, which might affect usage of HIP APIs. See OS support details in HIP API document.
-
-## 17.35 Does HIP support LUID?
-
-Starting ROCm 6.0, HIP runtime supports Locally Unique Identifier (LUID). This feature enables the local physical device(s) to interoperate with other devices. For example, DirectX 12.
-
-HIP runtime sets device LUID properties so the driver can query LUID to identify each device for interoperability.
-
-Note: HIP supports LUID only on Windows OS.
-
-## 17.36 How can I know the version of HIP?
-
-HIP version definition has been updated since ROCm 4.2 release as the following:
-
-```
-<_SQL_>
-```
-
-HIP version can be queried from HIP API call, hipRuntimeGetVersion(&amp;runtimeVersion);
-
-The version returned will always be greater than the versions in previous ROCm releases.
-
-Note: The version definition of HIP runtime is different from CUDA. On AMD platform, the function returns HIP runtime version, while on NVIDIA platform, it returns CUDA runtime version. And there is no mapping/correlation between HIP version and CUDA version.
-
-## 18.1 Related Pages
-
-18.2 Topics
-
-## 18.3 Namespaces
-
-18.3.1 Namespace List
-
-18.3.2 Namespace Members
-
-18.3.2.1 Namespace Members
-
-18.3.2.2 Namespace Members
-
-## 18.4 Data Structures
-
-- 18.4.1 Data Structures
-- 18.4.2 Data Structure Index
-- 18.4.3 Class Hierarchy
-
-18.4.4 Data Fields
-
-18.4.4.1 All
-
-18.4.4.1.1 Data Fields
-
-18.4.4.1.2 Data Fields
-
-18.4.4.1.3 Data Fields
-
-18.4.4.1.4 Data Fields
-
-18.4.4.1.5 Data Fields
-
-18.4.4.1.6 Data Fields 26
-
-18.4.4.1.7 Data Fields
-
-CHAPTER
-
-## EIGHTEEN
-
-## HIP RUNTIME API REFERENCE
-
-## CHAPTER
-
-## NINETEEN
-
-## C++ LANGUAGE EXTENSIONS
-
-HIP provides a C++ syntax that is suitable for compiling most code that commonly appears in compute kernels (classes, namespaces, operator overloading, and templates). HIP also defines other language features that are designed to target accelerators, such as:
-
-- A kernel-launch syntax that uses standard C++ (this resembles a function call and is portable to all HIP targets)
-- Short-vector headers that can serve on a host or device
-- Math functions that resemble those in math.h , which is included with standard C++ compilers
-- Built-in functions for accessing specific GPU hardware capabilities
-
-Note: This chapter describes the built-in variables and functions that are accessible from the HIP kernel. It's intended for users who are familiar with CUDA kernel syntax and want to learn how HIP differs from CUDA.
-
-Features are labeled with one of the following keywords:
-
-- Supported : HIP supports the feature with a CUDA-equivalent function
-- Not supported : HIP does not support the feature
-- Under development : The feature is under development and not yet available
-
-## 19.1 Function-type qualifiers
-
-## 19.1.1 \_\_device\_\_
-
-Supported \_\_device\_\_ functions are:
-
-- Run on the device
-- Called from the device only
-
-You can combine \_\_device\_\_ with the host keyword ( \_\_host\_\_ ).
-
-## 19.1.2 \_\_global\_\_
-
-Supported \_\_global\_\_ functions are:
-
-- Run on the device
-- Called (launched) from the host
-
-HIP \_\_global\_\_ functions must have a void return type.
-
-HIP doesn't support dynamic-parallelism, which means that you can't call \_\_global\_\_ functions from the device.
-
-## 19.1.3 \_\_host\_\_
-
-Supported \_\_host\_\_ functions are:
-
-- Run on the host
-- Called from the host
-
-You can combine \_\_host\_\_ with \_\_device\_\_ ; in this case, the function compiles for the host and the device. Note that these functions can't use the HIP grid coordinate functions (e.g., threadIdx.x ). If you need to use HIP grid coordinate functions, you can pass the necessary coordinate information as an argument.
-
-You can't combine \_\_host\_\_ with \_\_global\_\_ .
-
-HIP parses the \_\_noinline\_\_ and \_\_forceinline\_\_ keywords and converts them into the appropriate Clang attributes.
-
-## 19.2 Calling \_\_global\_\_ functions
-
-\_\_global\_\_ functions are often referred to as kernels . When you call a global function, you're launching a kernel . When launching a kernel, you must specify an execution configuration that includes the grid and block dimensions. The execution configuration can also include other information for the launch, such as the amount of additional shared memory to allocate and the stream where you want to execute the kernel.
-
-HIP introduces a standard C++ calling convention ( hipLaunchKernelGGL ) to pass the run configuration to the kernel. However, you can also use the CUDA &lt;&lt;&lt; &gt;&gt;&gt; syntax.
-
-When using hipLaunchKernelGGL , your first five parameters must be:
-
-- symbol kernelName : The name of the kernel you want to launch. To support template kernels that contain "," , use the HIP\_KERNEL\_NAME macro (HIPIFY tools insert this automatically).
-- dim3 gridDim : 3D-grid dimensions that specify the number of blocks to launch.
-- dim3 blockDim : 3D-block dimensions that specify the number of threads in each block.
-- size\_t dynamicShared : The amount of additional shared memory that you want to allocate when launching the kernel (see \_\_shared\_\_ ).
-- hipStream\_t : The stream where you want to run the kernel. A value of 0 corresponds to the NULL stream (see Synchronization functions ).
-
-You can include your kernel arguments after these parameters.
-
-```
-                                                                                                                                                                                                        // Example hipLaunchKernelGGL pseudocode:
-```
-
-```
-
-ize_t  N)
-```
-
-(continued from previous page)
-
-```
-                                                                                                                                                                                                        (continued from previous page)
-                                                                                                                                                                                                       
-                                                                                                                                                                                                      
-}
-
-MyKernel<<<dim3(gridDim), dim3(groupDim), 0, 0>>> (a,b,c,n);
-
-// Alternatively, you can launch the kernel using:
-// hipLaunchKernelGGL(MyKernel, dim3(gridDim), dim3(groupDim), 0/*dynamicShared*/, 0/
-                                                                                                                                                                                                       :*stream), a, b, c, n);
-```
-
-You can use HIPIFY tools to convert CUDA launch syntax to hipLaunchKernelGGL . This includes the conversion of optional &lt;&lt;&lt; &gt;&gt;&gt; arguments into the five required hipLaunchKernelGGL parameters. Note: HIP doesn't support dimension sizes of 𝑔𝑟𝑖𝑑𝐷𝑖𝑚 * 𝑏𝑙𝑜𝑐𝑘𝐷𝑖𝑚 ≥ 2 32 when launching a kernel.
-
-## 19.3 Kernel launch example
-
-```
-
-// Example showing device function, __device__ __host__
-// <- compile for both device and host
-float PlusOne(float x)
-{
-  return x + 1.0;
-}
-
-__global__
-void
-MyKernel (hipLaunchParm lp, /*lp parm for execution configuration */
-          const float *a, const float *b, float *c, unsigned N)
-{
-  unsigned gid = threadIdx.x; // <- coordinate index function
-  if (gid < N) {
-    c[gid] = a[gid] + PlusOne(b[gid]);
-  }
-}
-void callMyKernel()
-{
-  float *a, *b, *c; // initialization not shown...
-  unsigned N = 1000000;
-  const unsigned blockSize = 256;
-
-  MyKernel<<<dim3(gridDim), dim3(groupDim), 0, 0>>> (a,b,c,n);
-  // Alternatively, kernel can be launched by
-  // hipLaunchKernelGGL(MyKernel, dim3(N/blockSize), dim3(blockSize), 0, 0, a,b,c,N);
-}
-```
-
-## 19.4 Variable type qualifiers
-
-## 19.4.1 \_\_constant\_\_
-
-The host writes constant memory before launching the kernel. This memory is read-only from the GPU while the kernel is running. The functions for accessing constant memory are:
-
-- hipGetSymbolAddress()
-- hipGetSymbolSize()
-- hipMemcpyToSymbol()
-- hipMemcpyToSymbolAsync()
-- hipMemcpyFromSymbol()
-- hipMemcpyFromSymbolAsync()
-
-## 19.4.2 \_\_shared\_\_
-
-To allow the host to dynamically allocate shared memory, you can specify extern \_\_shared\_\_ as a launch parameter.
-
-Note: Prior to the HIP-Clang compiler, dynamic shared memory had to be declared using the HIP\_DYNAMIC\_SHARED macro in order to ensure accuracy. This is because using static shared memory in the same kernel could've resulted in overlapping memory ranges and data-races. The HIP-Clang compiler provides support for extern \_\_shared\_ declarations, so HIP\_DYNAMIC\_SHARED is no longer required.
-
-## 19.4.3 \_\_managed\_\_
-
-Managed memory, including the \_\_managed\_\_ keyword, is supported in HIP combined host/device compilation.
-
-## 19.4.4 \_\_restrict\_\_
-
-\_\_restrict\_\_ tells the compiler that the associated memory pointer not to alias with any other pointer in the kernel or function. This can help the compiler generate better code. In most use cases, every pointer argument should use this keyword in order to achieve the benefit.
-
-## 19.5 Built-in variables
-
-## 19.5.1 Coordinate built-ins
-
-The kernel uses coordinate built-ins ( thread* , block* , grid* ) to determine the coordinate index and bounds for the active work item.
-
-Built-ins are defined in amd\_hip\_runtime.h , rather than being implicitly defined by the compiler.
-
-Coordinate variable definitions for built-ins are the same for HIP and CUDA. For example: threadIdx.x , blockIdx. y , and gridDim.y . The products gridDim.x * blockDim.x , gridDim.y * blockDim.y , and gridDim.z * blockDim.z are always less than 2^32 .
-
-Coordinate built-ins are implemented as structures for improved performance. When used with printf , they must be explicitly cast to integer types.
-
-## 19.5.2 warpSize
-
-The warpSize variable type is int . It contains the warp size (in threads) for the target device. warpSize should only be used in device functions that develop portable wave-aware code.
-
-Note: NVIDIA devices return 32 for this variable; AMD devices return 64 for gfx9 and 32 for gfx10 and above.
-
-## 19.6 Vector types
-
-The following vector types are defined in hip\_runtime.h . They are not automatically provided by the compiler.
-
-## 19.6.1 Short vector types
-
-Short vector types derive from basic integer and floating-point types. These structures are defined in hip\_vector\_types.h . The first, second, third, and fourth components of the vector are defined by the x , y , z , and w fields, respectively. All short vector types support a constructor function of the form make\_&lt;type\_name&gt;() . For example, float4 make\_float4(float x, float y, float z, float w) creates a vector with type float4 and value (x,y,z,w) .
-
-HIP supports the following short vector formats:
-
-- Signed Integers:
-- -char1 , char2 , char3 , char4
-- -short1 , short2 , short3 , short4
-- -int1 , int2 , int3 , int4
-- -long1 , long2 , long3 , long4
-- -longlong1 , longlong2 , longlong3 , longlong4
-- Unsigned Integers:
-- -uchar1 , uchar2 , uchar3 , uchar4
-- -ushort1 , ushort2 , ushort3 , ushort4
-- -uint1 , uint2 , uint3 , uint4
-- -ulong1 , ulong2 , ulong3 , ulong4
-- -ulonglong1 , ulonglong2 , ulonglong3 , ulonglong4
-- Floating Points:
-- -float1 , float2 , float3 , float4
-- -double1 , double2 , double3 , double4
-
-## 19.6.2 dim3
-
-dim3 is a three-dimensional integer vector type that is commonly used to specify grid and group dimensions.
-
-The dim3 constructor accepts between zero and three arguments. By default, it initializes unspecified dimensions to 1.
-
-```
-<_C_>
-```
-
-## 19.7 Memory fence instructions
-
-HIP supports \_\_threadfence() and \_\_threadfence\_block() . If you're using threadfence\_system() in the HIP-Clang path, you can use the following workaround:
-
-1. Build HIP with the HIP\_COHERENT\_HOST\_ALLOC environment variable enabled.
-2. Modify kernels that use \_\_threadfence\_system() as follows:
-- Ensure the kernel operates only on fine-grained system memory, which should be allocated with hipHostMalloc() .
-- Remove memcpy for all allocated fine-grained system memory regions.
-
-## 19.8 Synchronization functions
-
-Synchronization functions causes all threads in the group to wait at this synchronization point, and for all shared and global memory accesses by the threads to complete, before running synchronization. This guarantees the visibility of accessed data for all threads in the group.
-
-The \_\_syncthreads() built-in function is supported in HIP. The \_\_syncthreads\_count(int) , \_\_syncthreads\_and(int) , and \_\_syncthreads\_or(int) functions are under development.
-
-The Cooperative Groups API offer options to do synchronization on a developer defined set of thread groups. For further information, check Cooperative Groups API or Cooperative Groups how to .
-
-## 19.9 Math functions
-
-HIP-Clang supports a set of math operations that are callable from the device. HIP supports most of the device functions supported by CUDA. These are described on Math API page .
-
-## 19.10 Texture functions
-
-The supported texture functions are listed in texture\_fetch\_functions.h and texture\_indirect\_functions. h header files in the HIP-AMD backend repository.
-
-Texture functions are not supported on some devices. To determine if texture functions are supported on your device, use Macro \_\_HIP\_NO\_IMAGE\_SUPPORT == 1 . You can query the attribute hipDeviceAttributeImageSupport to check if texture functions are supported in the host runtime code.
-
-## 19.11 Surface functions
-
-The following surface functions are supported in HIP:
-
-hipError\_t hipCreateSurfaceObject ( hipSurfaceObject\_t *pSurfObject, const hipResourceDesc *pResDesc )
-
-Create a surface object.
-
-## Parameters
-
-- pSurfObject -[out] Pointer of surface object to be created.
-- pResDesc -[in] Pointer of suface object descriptor.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipDestroySurfaceObject ( hipSurfaceObject\_t surfaceObject )
-
-Destroy a surface object.
-
-## Parameters
-
-surfaceObject -[in] Surface object to be destroyed.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf1Dread ( T *data, hipSurfaceObject\_t surfObj, int x, int boundaryMode = hipBoundaryModeZero )
-
-Reads the value at coordinate x from the one-dimensional surface.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [out] The T type result is stored in this pointer.
-- surfObj - [in] The surface descriptor.
-- x - [in] The coordinate where the value will be read out.
-- boundaryMode - [in] The boundary mode is currently ignored.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf1Dwrite ( T data, hipSurfaceObject\_t surfObj, int x )
-
-Writes the value data to the one-dimensional surface at coordinate x.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [in] The T type value is written to surface.
-
-- surfObj - [in] The surface descriptor.
-- x - [in] The coordinate where the data will be written.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf2Dread ( T *data, hipSurfaceObject\_t surfObj, int x, int y )
-
-Reads the value from the two-dimensional surface at coordinate x, y.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [out] The T type result is stored in this pointer.
-- surfObj - [in] The surface descriptor.
-- x - [in] The x coordinate where the value will be read out.
-- y - [in] The y coordinate where the value will be read out.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf2Dwrite ( T data, hipSurfaceObject\_t surfObj, int x, int y )
-
-Writes the value data to the two-dimensional surface at coordinate x, y.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [in] The T type value is written to surface.
-- surfObj - [in] The surface descriptor.
-- x - [in] The x coordinate where the data will be written.
-- y - [in] The y coordinate where the data will be written.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf3Dread ( T *data, hipSurfaceObject\_t surfObj, int x, int y, int z )
-
-Reads the value from the three-dimensional surface at coordinate x, y, z.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [out] The T type result is stored in this pointer.
-- surfObj - [in] The surface descriptor.
-- x - [in] The x coordinate where the value will be read out.
-- y - [in] The y coordinate where the value will be read out.
-- z - [in] The z coordinate where the value will be read out.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf3Dwrite ( T data, hipSurfaceObject\_t surfObj, int x, int y, int z )
-
-Writes the value data to the three-dimensional surface at coordinate x, y, z.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [in] The T type value is written to surface.
-- surfObj - [in] The surface descriptor.
-- x - [in] The x coordinate where the data will be written.
-- y - [in] The y coordinate where the data will be written.
-- z - [in] The z coordinate where the data will be written.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf1DLayeredread ( T *data, hipSurfaceObject\_t surfObj, int x, int layer )
-
-Reads the value from the one-dimensional layered surface at coordinate x and layer index.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [out] The T type result is stored in this pointer.
-- surfObj - [in] The surface descriptor.
-- x - [in] The coordinate where the value will be read out.
-- layer - [in] The layer index where the value will be read out.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf1DLayeredwrite ( T data, hipSurfaceObject\_t surfObj, int x, int layer )
-
-Writes the value data to the one-dimensional layered surface at coordinate x and layer index.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [in] The T type value is written to surface.
-- surfObj - [in] The surface descriptor.
-- x - [in] The x coordinate where the data will be written.
-- layer - [in] The layer index where the data will be written.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf2DLayeredread ( T *data, hipSurfaceObject\_t surfObj, int x, int y, int layer )
-
-Reads the value from the two-dimensional layered surface at coordinate x, y and layer index.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [out] The T type result is stored in this pointer.
-- surfObj - [in] The surface descriptor.
-- x - [in] The x coordinate where the value will be read out.
-- y - [in] The y coordinate where the value will be read out.
-- layer - [in] The layer index where the value will be read out.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt;
-
-static void surf2DLayeredwrite ( T data, hipSurfaceObject\_t surfObj, int x, int y, int layer )
-
-Writes the value data to the two-dimensional layered surface at coordinate x, y and layer index.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [in] The T type value is written to surface.
-- surfObj - [in] The surface descriptor.
-- x - [in] The x coordinate where the data will be written.
-- y - [in] The y coordinate where the data will be written.
-- layer - [in] The layer index where the data will be written.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surfCubemapread ( T *data, hipSurfaceObject\_t surfObj, int x, int y, int face )
-
-Reads the value from the cubemap surface at coordinate x, y and face index.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [out] The T type result is stored in this pointer.
-- surfObj - [in] The surface descriptor.
-- x - [in] The x coordinate where the value will be read out.
-- y - [in] The y coordinate where the value will be read out.
-- face - [in] The face index where the value will be read out.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surfCubemapwrite ( T data, hipSurfaceObject\_t surfObj, int x, int y, int face )
-
-Writes the value data to the cubemap surface at coordinate x, y and face index.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [in] The T type value is written to surface.
-- surfObj - [in] The surface descriptor.
-- x - [in] The x coordinate where the data will be written.
-- y - [in] The y coordinate where the data will be written.
-- face - [in] The face index where the data will be written.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surfCubemapLayeredread ( T *data, hipSurfaceObject\_t surfObj, int x, int y, int face, int layer )
-
-Reads the value from the layered cubemap surface at coordinate x, y and face, layer index.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [out] The T type result is stored in this pointer.
-
-- surfObj - [in] The surface descriptor.
-- x - [in] The x coordinate where the value will be read out.
-- y - [in] The y coordinate where the value will be read out.
-- face - [in] The face index where the value will be read out.
-- layer - [in] The layer index where the data will be written.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surfCubemapLayeredwrite ( T *data, hipSurfaceObject\_t surfObj, int x, int y, int face, int layer )
-
-Writes the value data to the layered cubemap surface at coordinate x, y and face, layer index.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [in] The T type value to write to the surface.
-- surfObj - [in] The surface descriptor.
-- x - [in] The x coordinate where the data will be written.
-- y - [in] The y coordinate where the data will be written.
-- face - [in] The face index where the data will be written.
-- layer - [in] The layer index where the data will be written.
-
-## 19.12 Timer functions
-
-To read a high-resolution timer from the device, HIP provides the following built-in functions:
-
-- Returning the incremental counter value for every clock cycle on a device:
-
-```
-<_SQL_>
-```
-
-```
-    [clock_t clock()
-    long long int close
-```
-
-The difference between the values that are returned represents the cycles used.
-
-- Returning the wall clock count at a constant frequency on the device:
-
-```
-  | long long int w:
-```
-
-```
-    it will_clock64()
-```
-
-This can be queried using the HIP API with the hipDeviceAttributeWallClockRate attribute of the device in HIP application code. For example:
-
-```
-            int wallClkRate = 0; //in kilohertz
-            HIPCHECK(hipDeviceGetAttribute(&wallClkRate, hipDeviceAttributeWallClockRate, _
-            --deviceId));
-```
-
-Where hipDeviceAttributeWallClockRate is a device attribute. Note that wall clock frequency is a perdevice attribute.
-
-Note that clock() and clock64() do not work properly on AMD RDNA3 (GFX11) graphic processors.
-
-## 19.13 Atomic functions
-
-Atomic functions are run as read-modify-write (RMW) operations that reside in global or shared memory. No other device or thread can observe or modify the memory location during an atomic operation. If multiple instructions from different devices or threads target the same memory location, the instructions are serialized in an undefined order.
-
-To support system scope atomic operations, you can use the HIP APIs that contain the \_system suffix. For example:
-
-- atomicAnd : This function is atomic and coherent within the GPU device running the function
-- atomicAnd\_system : This function extends the atomic operation from the GPU device to other CPUs and GPU devices in the system.
-
-HIP supports the following atomic operations.
-
-Table 1: Atomic operations
-
-| Function int atomicAdd(int* address, int val) int atomicAdd_system(int* address, int val) unsigned int atomicAdd(unsigned int* address,unsigned unsigned int atomicAdd_system(unsigned int* address, unsigned long long atomicAdd(unsigned long long* unsigned long long atomicAdd_system(unsigned long long* float atomicAdd(float* address, float val) float atomicAdd_system(float* address, float val) double atomicAdd(double* address, double val) double atomicAdd_system(double* address, double val) float unsafeAtomicAdd(float* address, float val) float safeAtomicAdd(float* address, float val)   |
-|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| int val) unsigned int val) address,unsigned long long val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| address, unsigned long long val) double unsafeAtomicAdd(double* address, double val) double safeAtomicAdd(double* address, double val) int atomicSub(int* address, int val) int atomicSub_system(int* address, int val) unsigned int atomicSub(unsigned int* address,unsigned int val) unsigned int atomicSub_system(unsigned int* address, unsigned int val)                                                                                                                                                                                                                                                   |
-| int atomicExch(int* address, int val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
-| int atomicExch_system(int* address, int val) unsigned int atomicExch(unsigned int* address,unsigned int val) unsigned int atomicExch_system(unsigned int* address, unsigned int val)                                                                                                                                                                                                                                                                                                                                                                                                                            |
-| unsigned long long atomicExch(unsigned long long int* address,unsigned long val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-| long unsigned long long atomicExch_system(unsigned long long* address, unsigned long                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
-| int long val) unsigned long long atomicExch_system(unsigned long long* address, unsigned long long val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| float atomicExch(float* address, float val) int atomicMin(int* address, int val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-| int atomicMin_system(int* address, int val) unsigned int atomicMin(unsigned int* address,unsigned int                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
-| val) unsigned int atomicMin_system(unsigned int* address, unsigned int                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
-| val) unsigned long long atomicMin(unsigned long long* address,unsigned long long val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
-| atomicMax(int* address, int val) atomicMax_system(int* address, int val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
-| int unsigned int atomicMax(unsigned int* address,unsigned int val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
-| unsigned int atomicMax_system(unsigned int* address, unsigned int                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
-| int                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
-| val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
-| unsigned long long atomicMax(unsigned long long* address,unsigned long long val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-
-Table 1 - continued from previous page
-
-| unsigned int atomicDec(unsigned int* address)                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| int atomicCAS(int* address, int compare, int val)                                                                                                                                                                                                                                                                                                                                                                                                                              |
-| int atomicCAS_system(int* address, int compare, int val)                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| unsigned int atomicCAS(unsigned int* address,unsigned int compare,unsigned int val) unsigned int atomicCAS_system(unsigned int* address, unsigned int compare, unsigned int val) unsigned long long atomicCAS(unsigned long long* address,unsigned long long compare,unsigned long long unsigned long long atomicCAS_system(unsigned long long* address, unsigned long long compare, unsigned int atomicAnd(int* address, int val) int atomicAnd_system(int* address, int val) |
-| unsigned int atomicAnd(unsigned int* address,unsigned int val) unsigned int atomicAnd_system(unsigned int* address, unsigned int val)                                                                                                                                                                                                                                                                                                                                          |
-| unsigned long long atomicAnd(unsigned long long* address,unsigned long long val) unsigned long long atomicAnd_system(unsigned long long* address, unsigned long                                                                                                                                                                                                                                                                                                                |
-| long val) int atomicOr(int* address, int val)                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| int atomicOr_system(int* address, int val)                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| unsigned int atomicOr(unsigned int* address,unsigned int val) unsigned int atomicOr_system(unsigned int* address, unsigned                                                                                                                                                                                                                                                                                                                                                     |
-| int val) unsigned int atomicOr_system(unsigned int* address, unsigned int val)                                                                                                                                                                                                                                                                                                                                                                                                 |
-| unsigned long long atomicOr(unsigned long long int* address,unsigned long long val)                                                                                                                                                                                                                                                                                                                                                                                            |
-| unsigned long long atomicOr_system(unsigned long long* address, unsigned long long val)                                                                                                                                                                                                                                                                                                                                                                                        |
-| int atomicXor(int* address, int val)                                                                                                                                                                                                                                                                                                                                                                                                                                           |
-| int atomicXor_system(int* address, int val)                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| unsigned int atomicXor(unsigned int* address,unsigned int val)                                                                                                                                                                                                                                                                                                                                                                                                                 |
-| unsigned int atomicXor_system(unsigned int* address, unsigned int val)                                                                                                                                                                                                                                                                                                                                                                                                         |
-| unsigned long long atomicXor(unsigned long long* address,unsigned long long val)                                                                                                                                                                                                                                                                                                                                                                                               |
-| unsigned long long atomicXor_system(unsigned long long* address, unsigned long long                                                                                                                                                                                                                                                                                                                                                                                            |
-| val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
-
-## 19.13.1 Unsafe floating-point atomic RMW operations
-
-Some HIP devices support fast atomic RMW operations on floating-point values. For example, atomicAdd on singleor double-precision floating-point values may generate a hardware RMW instruction that is faster than emulating the atomic operation using an atomic compare-and-swap (CAS) loop.
-
-On some devices, fast atomic RMW instructions can produce results that differ from the same functions implemented with atomic CAS loops. For example, some devices will use different rounding or denormal modes, and some devices produce incorrect answers if fast floating-point atomic RMW instructions target fine-grained memory allocations.
-
-The HIP-Clang compiler offers a compile-time option, so you can choose fast-but potentially unsafe-atomic instructions for your code. On devices that support these instructions, you can include the -munsafe-fp-atomics option. This flag indicates to the compiler that all floating-point atomic function calls are allowed to use an unsafe version, if one exists. For example, on some devices, this flag indicates to the compiler that no floating-point atomicAdd function can target fine-grained memory.
-
-If you want to avoid using unsafe use a floating-point atomic RMW operations, you can use the -mno-unsafe-fp-atomics option. Note that the compiler default is to not produce unsafe floating-point atomic RMW instructions, so the -mno-unsafe-fp-atomics option is not necessarily required. However, passing this option to the compiler is good practice.
-
-When you pass -munsafe-fp-atomics or -mno-unsafe-fp-atomics to the compiler's command line, the option is applied globally for the entire compilation. Note that if some of the atomic RMW function calls cannot safely use the faster floating-point atomic RMW instructions, you must use -mno-unsafe-fp-atomics in order to ensure that your atomic RMW function calls produce correct results.
-
-HIP has four extra functions that you can use to more precisely control which floating-point atomic RMW functions produce unsafe atomic RMW instructions:
-
-- float unsafeAtomicAdd(float* address, float val)
-- double unsafeAtomicAdd(double* address, double val) (Always produces fast atomic RMW instructions on devices that have them, even when -mno-unsafe-fp-atomics is used)
-- float safeAtomicAdd(float* address, float val)
-- double safeAtomicAdd(double* address, double val) (Always produces safe atomic RMW operations, even when -munsafe-fp-atomics is used)
-
-## 19.14 Warp cross-lane functions
-
-Threads in a warp are referred to as lanes and are numbered from 0 to warpSize - 1 . Warp cross-lane functions operate across all lanes in a warp. The hardware guarantees that all warp lanes will execute in lockstep, so additional synchronization is unnecessary, and the instructions use no shared memory.
-
-Note that NVIDIA and AMD devices have different warp sizes. You can use warpSize built-ins in you portable code to query the warp size.
-
-Tip: Be sure to review HIP code generated from the CUDA path to ensure that it doesn't assume a waveSize of 32. 'Wave-aware' code that assumes a waveSize of 32 can run on a wave-64 machine, but it only utilizes half of the machine's resources.
-
-To get the default warp size of a GPU device, use hipGetDeviceProperties in you host functions.
-
-```
-    cudaDeviceProp props;
-    cudaGetDeviceProperties(&props, deviceID);
-    int w = props.warpSize;
-    // implement portable algorithm based on w (rather than assume 32 or 64)
-```
-
-Only use warpSize built-ins in device functions, and don't assume warpSize to be a compile-time constant.
-
-Note that assembly kernels may be built for a warp size that is different from the default. All mask values either returned or accepted by these builtins are 64-bit unsigned integer values, even when compiled for a wave-32 device, where all the higher bits are unused. CUDA code ported to HIP requires changes to ensure that the correct type is used.
-
-Note that the \_\_sync variants are made available in ROCm 6.2, but disabled by default to help with the transition to 64-bit masks. They can be enabled by setting the preprocessor macro HIP\_ENABLE\_WARP\_SYNC\_BUILTINS . These builtins will be enabled unconditionally in ROCm 6.3. Wherever possible, the implementation includes a static assert to check that the program source uses the correct type for the mask.
-
-## 19.14.1 Warp vote and ballot functions
-
-```
-int __all(int predicate)
-int __any(int predicate)
-unsigned long long __ballot(int predicate)
-unsigned long long __activemask()
-
-int __all_sync(unsigned long long mask, int predicate)
-```
-
-(continued from previous page)
-
-```
-<_Python_>
-```
-
-You can use \_\_any and \_\_all to get a summary view of the predicates evaluated by the participating lanes.
-
-- \_\_any() : Returns 1 if the predicate is non-zero for any participating lane, otherwise it returns 0.
-- \_\_all() : Returns 1 if the predicate is non-zero for all participating lanes, otherwise it returns 0.
-
-To determine if the target platform supports the any/all instruction, you can use the hasWarpVote device property or the HIP\_ARCH\_HAS\_WARP\_VOTE compiler definition.
-
-\_\_ballot returns a bit mask containing the 1-bit predicate value from each lane. The nth bit of the result contains the 1 bit contributed by the nth warp lane.
-
-\_\_activemask() returns a bit mask of currently active warp lanes. The nth bit of the result is 1 if the nth warp lane is active.
-
-Note that the \_\_ballot and \_\_activemask builtins in HIP have a 64-bit return value (unlike the 32-bit value returned by the CUDA builtins). Code ported from CUDA should be adapted to support the larger warp sizes that the HIP version requires.
-
-Applications can test whether the target platform supports the \_\_ballot or \_\_activemask instructions using the hasWarpBallot device property in host code or the HIP\_ARCH\_HAS\_WARP\_BALLOT macro defined by the compiler for device code.
-
-The \_sync variants require a 64-bit unsigned integer mask argument that specifies the lanes in the warp that will participate in cross-lane communication with the calling lane. Each participating thread must have its own bit set in its mask argument, and all active threads specified in any mask argument must execute the same call with the same mask, otherwise the result is undefined.
-
-## 19.14.2 Warp match functions
-
-```
-    unsigned long long __match_any(T value)
-    unsigned long long __match_all(T value, int *pred)
-
-    unsigned long long __match_any_sync(unsigned long long mask, T value)
-    unsigned long long __match_all_sync(unsigned long long mask, T value, int *pred)
-```
-
-T can be a 32-bit integer type, 64-bit integer type or a single precision or double precision floating point type.
-
-\_\_match\_any returns a bit mask containing a 1-bit for every participating lane if and only if that lane has the same value in value as the current lane, and a 0-bit for all other lanes.
-
-\_\_match\_all returns a bit mask containing a 1-bit for every participating lane if and only if they all have the same value in value as the current lane, and a 0-bit for all other lanes. The predicate pred is set to true if and only if all participating threads have the same value in value .
-
-The \_sync variants require a 64-bit unsigned integer mask argument that specifies the lanes in the warp that will participate in cross-lane communication with the calling lane. Each participating thread must have its own bit set in its mask argument, and all active threads specified in any mask argument must execute the same call with the same mask, otherwise the result is undefined.
-
-## 19.14.3 Warp shuffle functions
-
-The default width is warpSize (see Warp cross-lane functions ). Half-float shuffles are not supported.
-
-```
-            The default width is warpSize (see Warp cross-lane functions). Half-float shuffles are not supported.
-                                                                                                                                                                                                        
-                                                                                                                                                                                                      
-int       __shfl           (T var,     int srcLane,  int width=warpSize);
-```
-
-T can be a 32-bit integer type, 64-bit integer type or a single precision or double precision floating point type.
-
-The \_sync variants require a 64-bit unsigned integer mask argument that specifies the lanes in the warp that will participate in cross-lane communication with the calling lane. Each participating thread must have its own bit set in its mask argument, and all active threads specified in any mask argument must execute the same call with the same mask, otherwise the result is undefined.
-
-## 19.15 Cooperative groups functions
-
-You can use cooperative groups to synchronize groups of threads. Cooperative groups also provide a way of communicating between groups of threads at a granularity that is different from the block.
-
-HIP supports the following kernel language cooperative groups types and functions:
-
-Table 2: Cooperative groups functions
-
-| Function                                | Supported in HIP   | Supported in CUDA   |
-|-----------------------------------------|--------------------|---------------------|
-| void thread_group.sync();               | ✓                  | ✓                   |
-| unsigned thread_group.size();           | ✓                  | ✓                   |
-| unsigned thread_group.thread_rank()     | ✓                  | ✓                   |
-| bool thread_group.is_valid();           | ✓                  | ✓                   |
-| grid_group this_grid()                  | ✓                  | ✓                   |
-| void grid_group.sync()                  | ✓                  | ✓                   |
-| unsigned grid_group.size()              | ✓                  | ✓                   |
-| unsigned grid_group.thread_rank()       | ✓                  | ✓                   |
-| bool grid_group.is_valid()              | ✓                  | ✓                   |
-| multi_grid_group this_multi_grid()      | ✓                  | ✓                   |
-| void multi_grid_group.sync()            | ✓                  | ✓                   |
-| unsigned multi_grid_group.size()        | ✓                  | ✓                   |
-| unsigned multi_grid_group.thread_rank() | ✓                  | ✓                   |
-| bool multi_grid_group.is_valid()        | ✓                  | ✓                   |
-| unsigned multi_grid_group.num_grids()   | ✓                  | ✓                   |
-| unsigned multi_grid_group.grid_rank()   | ✓                  | ✓                   |
-| thread_block this_thread_block()        | ✓                  | ✓                   |
-| multi_grid_group this_multi_grid()      | ✓                  | ✓                   |
-| void multi_grid_group.sync()            | ✓                  | ✓                   |
-| void thread_block.sync()                | ✓                  | ✓                   |
-| unsigned thread_block.size()            | ✓                  | ✓                   |
-| unsigned thread_block.thread_rank()     | ✓                  | ✓                   |
-| bool thread_block.is_valid()            | ✓                  | ✓                   |
-| dim3 thread_block.group_index()         | ✓                  | ✓                   |
-| dim3 thread_block.thread_index()        | ✓                  | ✓                   |
-
-For further information, check Cooperative Groups API or Cooperative Groups how to .
-
-## 19.16 Warp matrix functions
-
-Warp matrix functions allow a warp to cooperatively operate on small matrices that have elements spread over lanes in an unspecified manner.
-
-HIP does not support kernel language warp matrix types or functions.
-
-Table 3: Warp matrix functions
-
-| Function                                                                                                     | Sup- ported in HIP   | Supported in CUDA   |
-|--------------------------------------------------------------------------------------------------------------|----------------------|---------------------|
-| void load_matrix_sync(fragment<...> &a, const T* mptr, unsigned lda)                                         |                      | ✓                   |
-| void load_matrix_sync(fragment<...> &a, const T* mptr, unsigned lda, layout_t layout)                        |                      | ✓                   |
-| void store_matrix_sync(T* mptr, fragment<...> &a, unsigned lda, layout_t layout)                             |                      | ✓                   |
-| void fill_fragment(fragment<...> &a, const T &value) void mma_sync(fragment<...> &d, const fragment<...> &a, |                      | ✓                   |
-| const fragment<...> &b, const fragment<...> &c , bool sat)                                                   |                      | ✓                   |
-
-## 19.17 Independent thread scheduling
-
-Certain architectures that support CUDA allow threads to progress independently of each other. This independent thread scheduling makes intra-warp synchronization possible.
-
-HIP does not support this type of scheduling.
-
-## 19.18 Profiler Counter Function
-
-The CUDA \_\_prof\_trigger() instruction is not supported.
-
-## 19.19 Assert
-
-The assert function is supported in HIP. Assert function is used for debugging purpose, when the input expression equals to zero, the execution will be stopped.
-
-```
-|void assert(int ir
-```
-
-```
-    input()
-```
-
-There are two kinds of implementations for assert functions depending on the use sceneries, - One is for the host version of assert, which is defined in assert.h , - Another is the device version of assert, which is implemented in hip/hip\_runtime.h . Users need to include assert.h to use assert . For assert to work in both device and host functions, users need to include "hip/hip\_runtime.h" .
-
-HIP provides the function abort() which can be used to terminate the application when terminal failures are detected. It is implemented using the \_\_builtin\_trap() function.
-
-This function produces a similar effect of using asm("trap") in the CUDA code.
-
-Note: In HIP, the function terminates the entire application, while in CUDA, asm("trap") only terminates the dispatch and the application continues to run.
-
-## 19.20 printf
-
-printf function is supported in HIP. The following is a simple example to print information in the kernel.
-
-```
-                                                                                                                                                                                                       
-#include <hip/hip_runtime.h>
-
-    __global__ void run_printf() { printf("Hello World\n"); }
-
-    int main() {
-      run_printf<<<dim3(1), dim3(1), 0, 0>>>();
-    }
-```
-
-## 19.21 Device-Side Dynamic Global Memory Allocation
-
-Device-side dynamic global memory allocation is under development. HIP now includes a preliminary implementation of malloc and free that can be called from device functions.
-
-## 19.22 \_\_launch\_bounds\_\_
-
-GPU multiprocessors have a fixed pool of resources (primarily registers and shared memory) which are shared by the actively running warps. Using more resources can increase IPC of the kernel but reduces the resources available for other warps and limits the number of warps that can be simultaneously running. Thus GPUs have a complex relationship between resource usage and performance.
-
-\_\_launch\_bounds\_\_ allows the application to provide usage hints that influence the resources (primarily registers) used by the generated code. It is a function attribute that must be attached to a \_\_global\_\_ function:
-
-```
-<_Cython_>
-```
-
-\_\_launch\_bounds\_\_ supports two parameters: - MAX\_THREADS\_PER\_BLOCK - The programmers guarantees that kernel will be launched with threads less than MAX\_THREADS\_PER\_BLOCK. (On NVCC this maps to the . maxntid PTX directive). If no launch\_bounds is specified, MAX\_THREADS\_PER\_BLOCK is the maximum block size supported by the device (typically 1024 or larger). Specifying MAX\_THREADS\_PER\_BLOCK less than the maximum effectively allows the compiler to use more resources than a default unconstrained compilation that supports all possible block sizes at launch time. The threads-per-block is the product of ( blockDim.x * blockDim. y * blockDim.z ). - MIN\_WARPS\_PER\_EXECUTION\_UNIT - directs the compiler to minimize resource usage so that the requested number of warps can be simultaneously active on a multi-processor. Since active warps compete for the same fixed pool of resources, the compiler must reduce resources required by each warp(primarily registers). MIN\_WARPS\_PER\_EXECUTION\_UNIT is optional and defaults to 1 if not specified. Specifying a MIN\_WARPS\_PER\_EXECUTION\_UNIT greater than the default 1 effectively constrains the compiler's resource usage.
-
-When launch kernel with HIP APIs, for example, hipModuleLaunchKernel() , HIP will do validation to make sure input kernel dimension size is not larger than specified launch\_bounds. In case exceeded, HIP would return launch failure, if AMD\_LOG\_LEVEL is set with proper value (for details, please refer to docs/markdown/hip\_logging. md ), detail information will be shown in the error log message, including launch parameters of kernel dim size, launch bounds, and the name of the faulting kernel. It's helpful to figure out which is the faulting kernel, besides, the kernel dim size and launch bounds values will also assist in debugging such failures.
-
-## 19.22.1 Compiler Impact
-
-The compiler uses these parameters as follows: - The compiler uses the hints only to manage register usage, and does not automatically reduce shared memory or other resources. - Compilation fails if compiler cannot generate a kernel which meets the requirements of the specified launch bounds. - From MAX\_THREADS\_PER\_BLOCK, the compiler derives the maximum number of warps/block that can be used at launch time. Values of MAX\_THREADS\_PER\_BLOCK less than the default allows the compiler to use a larger pool of registers : each warp uses registers, and this hint constrains the launch to a warps/block size which is less than maximum. - From MIN\_WARPS\_PER\_EXECUTION\_UNIT, the compiler derives a maximum number of registers that can be used by the kernel (to meet the required #simultaneous active blocks). If MIN\_WARPS\_PER\_EXECUTION\_UNIT is 1, then the kernel can use all registers supported by the multiprocessor. - The compiler ensures that the registers used in the kernel is less than both allowed maximums, typically by spilling registers (to shared or global memory), or by using more instructions. - The compiler may use heuristics to increase register usage, or may simply be able to avoid spilling. The MAX\_THREADS\_PER\_BLOCK
-
-is particularly useful in this cases, since it allows the compiler to use more registers and avoid situations where the compiler constrains the register usage (potentially spilling) to meet the requirements of a large block size that is never used at launch time.
-
-## 19.22.2 CU and EU Definitions
-
-A compute unit (CU) is responsible for executing the waves of a work-group. It is composed of one or more execution units (EU) which are responsible for executing waves. An EU can have enough resources to maintain the state of more than one executing wave. This allows an EU to hide latency by switching between waves in a similar way to symmetric multithreading on a CPU. In order to allow the state for multiple waves to fit on an EU, the resources used by a single wave have to be limited. Limiting such resources can allow greater latency hiding, but can result in having to spill some register state to memory. This attribute allows an advanced developer to tune the number of waves that are capable of fitting within the resources of an EU. It can be used to ensure at least a certain number will fit to help hide latency, and can also be used to ensure no more than a certain number will fit to limit cache thrashing.
-
-## 19.22.3 Porting from CUDA \_\_launch\_bounds
-
-CUDA defines a \_\_launch\_bounds which is also designed to control occupancy:
-
-- \_\_launch\_bounds(MAX\_THREADS\_PER\_BLOCK, MIN\_BLOCKS\_PER\_MULTIPROCESSOR)
-- The second parameter \_\_launch\_bounds parameters must be converted to the format used \_\_hip\_launch\_bounds, which uses warps and execution-units rather than blocks and multi-processors (this conversion is performed automatically by HIPIFY tools).
-
-```
-                                                                                                                                                                                                        | MIN_WARPS_PER_EXECUTION_UNIT  =  (MIN_BLOCKS_PER_MULTIPROCESSOR  *  MAX_THREADS_PER_BLOCK)  /_\                                                                                                                                                                                                       
-                                                                                                                                                                                                        :                                                                                                                                                                                                        --                                                                                                                                                                                                        <                                                                                                                                                                                                        </                                                                                                                                                                                                        >                                                                                                                                                                                                        }
-```
-
-The key differences in the interface are: - Warps (rather than blocks): The developer is trying to tell the compiler to control resource utilization to guarantee some amount of active Warps/EU for latency hiding. Specifying active warps in terms of blocks appears to hide the micro-architectural details of the warp size, but makes the interface more confusing since the developer ultimately needs to compute the number of warps to obtain the desired level of control. - Execution Units (rather than multiprocessor): The use of execution units rather than multiprocessors provides support for architectures with multiple execution units/multi-processor. For example, the AMD GCN architecture has 4 execution units per multiprocessor. The hipDeviceProps has a field executionUnitsPerMultiprocessor . Platform-specific coding techniques such as #ifdef can be used to specify different launch\_bounds for NVCC and HIP-Clang platforms, if desired.
-
-## 19.22.4 maxregcount
-
-Unlike NVCC, HIP-Clang does not support the --maxregcount option. Instead, users are encouraged to use the hip\_launch\_bounds directive since the parameters are more intuitive and portable than micro-architecture details like registers, and also the directive allows per-kernel control rather than an entire file. hip\_launch\_bounds works on both HIP-Clang and NVCC targets.
-
-## 19.23 Asynchronous Functions
-
-## 19.23.1 Memory stream
-
-typedef void (* hipStreamCallback\_t )(hipStream\_t stream, hipError\_t status, void *userData)
-
-Stream CallBack struct hipError\_t hipStreamCreate ( hipStream\_t *stream )
-
-Create an asynchronous stream.
-
-Create a new asynchronous stream. stream returns an opaque handle that can be used to reference the newly created stream in subsequent hipStream* commands. The stream is allocated on the heap and will remain allocated even if the handle goes out-of-scope. To release the memory used by the stream, application must call hipStreamDestroy.
-
-## See also:
-
-hipStreamCreateWithFlags , hipStreamCreateWithPriority , hipStreamSynchronize , hipStreamWaitEvent , hipStreamDestroy
-
-## Parameters
-
-stream -[inout] Valid pointer to hipStream\_t. This function writes the memory with the newly created stream.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipStreamCreateWithFlags ( hipStream\_t *stream, unsigned int flags )
-
-Create an asynchronous stream.
-
-Create a new asynchronous stream. stream returns an opaque handle that can be used to reference the newly created stream in subsequent hipStream* commands. The stream is allocated on the heap and will remain allocated even if the handle goes out-of-scope. To release the memory used by the stream, application must call hipStreamDestroy. Flags controls behavior of the stream. See hipStreamDefault, hipStreamNonBlocking.
-
-## See also:
-
-hipStreamCreate , hipStreamCreateWithPriority , hipStreamSynchronize , hipStreamWaitEvent , hipStreamDestroy
-
-## Parameters
-
-- stream -[inout] Pointer to new stream
-- flags -[in] to control stream creation.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue
-
-hipError\_t hipStreamCreateWithPriority ( hipStream\_t *stream, unsigned int flags, int priority )
-
-Create an asynchronous stream with the specified priority.
-
-Create a new asynchronous stream with the specified priority. stream returns an opaque handle that can be used to reference the newly created stream in subsequent hipStream* commands. The stream is allocated on the heap and will remain allocated even if the handle goes out-of-scope. To release the memory used by the stream, application must call hipStreamDestroy. Flags controls behavior of the stream. See hipStreamDefault, hipStreamNonBlocking.
-
-## See also:
-
-hipStreamCreate , hipStreamSynchronize , hipStreamWaitEvent , hipStreamDestroy
-
-## Parameters
-
-- stream -[inout] Pointer to new stream
-- flags -[in] to control stream creation.
-- priority -[in] of the stream. Lower numbers represent higher priorities.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipDeviceGetStreamPriorityRange ( int *leastPriority, int *greatestPriority )
-
-Returns numerical values that correspond to the least and greatest stream priority.
-
-Returns in *leastPriority and *greatestPriority the numerical values that correspond to the least and greatest stream priority respectively. Stream priorities follow a convention where lower numbers imply greater priorities. The range of meaningful stream priorities is given by [*greatestPriority, *leastPriority]. If the user attempts to create a stream with a priority value that is outside the meaningful range as specified by this API, the priority is automatically clamped to within the valid range.
-
-## Parameters
-
-- leastPriority -[inout] pointer in which value corresponding to least priority is returned.
-- greatestPriority -[inout] pointer in which value corresponding to greatest priority is returned.
-
-## Returns
-
-hipSuccess hipError\_t hipStreamDestroy ( hipStream\_t stream )
-
-Destroys the specified stream.
-
-Destroys the specified stream.
-
-If commands are still executing on the specified stream, some may complete execution before the queue is deleted.
-
-The queue may be destroyed while some commands are still inflight, or may wait for all commands queued to the stream before destroying it.
-
-## See also:
-
-hipStreamCreate , hipStreamCreateWithFlags , hipStreamCreateWithPriority , hipStreamQuery , hipStreamWaitEvent , hipStreamSynchronize
-
-## Parameters
-
-stream -[in] stream identifier.
-
-## Returns
-
-hipSuccess hipErrorInvalidHandle
-
-## hipError\_t hipStreamQuery ( hipStream\_t stream )
-
-Return hipSuccess if all of the operations in the specified stream have completed, or hipErrorNotReady if not.
-
-This is thread-safe and returns a snapshot of the current state of the queue. However, if other host threads are sending work to the stream, the status may change immediately after the function is called. It is typically used for debug.
-
-## See also:
-
-hipStreamCreate , hipStreamCreateWithFlags , hipStreamCreateWithPriority , hipStreamWaitEvent , hipStreamSynchronize , hipStreamDestroy
-
-## Parameters
-
-stream -[in] stream to query
-
-## Returns
-
-hipSuccess, hipErrorNotReady, hipErrorInvalidHandle
-
-## hipError\_t hipStreamSynchronize ( hipStream\_t stream )
-
-Wait for all commands in stream to complete.
-
-This command is host-synchronous : the host will block until the specified stream is empty.
-
-This command follows standard null-stream semantics. Specifically, specifying the null stream will cause the command to wait for other streams on the same device to complete all pending operations.
-
-This command honors the hipDeviceLaunchBlocking flag, which controls whether the wait is active or blocking.
-
-## See also:
-
-hipStreamCreate , hipStreamCreateWithFlags , hipStreamCreateWithPriority , hipStreamWaitEvent , hipStreamDestroy
-
-## Parameters
-
-stream -[in] stream identifier.
-
-## Returns
-
-hipSuccess, hipErrorInvalidHandle
-
-hipError\_t hipStreamWaitEvent ( hipStream\_t stream, hipEvent\_t event, unsigned int flags )
-
-Make the specified compute stream wait for an event.
-
-This function inserts a wait operation into the specified stream. All future work submitted to stream will wait until event reports completion before beginning execution.
-
-This function only waits for commands in the current stream to complete. Notably, this function does not implicitly wait for commands in the default stream to complete, even if the specified stream is created with hipStreamNonBlocking = 0.
-
-## See also:
-
-hipStreamCreate , hipStreamCreateWithFlags , hipStreamCreateWithPriority , hipStreamSynchronize , hipStreamDestroy
-
-## Parameters
-
-- stream -[in] stream to make wait.
-- event -[in] event to wait on
-- flags -[in] control operation [must be 0]
-
-## Returns
-
-hipSuccess, hipErrorInvalidHandle hipError\_t hipStreamGetFlags ( hipStream\_t stream, unsigned int *flags )
-
-Return flags associated with this stream.
-
-Return flags associated with this stream in * flags .
-
-## See also:
-
-hipStreamCreateWithFlags
-
-## Parameters
-
-- stream -[in] stream to be queried
-- flags -[inout] Pointer to an unsigned integer in which the stream's flags are returned
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidHandle
-
-## Returns
-
-hipSuccess hipErrorInvalidValue hipErrorInvalidHandle hipError\_t hipStreamGetPriority ( hipStream\_t stream, int *priority )
-
-Query the priority of a stream.
-
-Query the priority of a stream. The priority is returned in in priority.
-
-## See also:
-
-hipStreamCreateWithFlags
-
-## Parameters
-
-- stream -[in] stream to be queried
-- priority -[inout] Pointer to an unsigned integer in which the stream's priority is returned
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidHandle
-
-## Returns
-
-hipSuccess hipErrorInvalidValue hipErrorInvalidHandle hipError\_t hipStreamGetDevice ( hipStream\_t stream, hipDevice\_t *device )
-
-Get the device assocaited with the stream.
-
-## See also:
-
-hipStreamCreate , hipStreamDestroy , hipDeviceGetStreamPriorityRange
-
-## Parameters
-
-- stream -[in] stream to be queried
-- device -[out] device associated with the stream
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorContextIsDestroyed, hipErrorInvalidHandle, hipErrorNotInitialized, hipErrorDeinitialized, hipErrorInvalidContext hipError\_t hipExtStreamCreateWithCUMask ( hipStream\_t *stream, uint32\_t cuMaskSize, const uint32\_t *cuMask )
-
-Create an asynchronous stream with the specified CU mask.
-
-Create a new asynchronous stream with the specified CU mask. stream returns an opaque handle that can be used to reference the newly created stream in subsequent hipStream* commands. The stream is allocated on the heap and will remain allocated even if the handle goes out-of-scope. To release the memory used by the stream, application must call hipStreamDestroy.
-
-## See also:
-
-hipStreamCreate , hipStreamSynchronize , hipStreamWaitEvent , hipStreamDestroy
-
-## Parameters
-
-- stream -[inout] Pointer to new stream
-- cuMaskSize -[in] Size of CU mask bit array passed in.
-- cuMask -[in] Bit-vector representing the CU mask. Each active bit represents using one CU. The first 32 bits represent the first 32 CUs, and so on. If its size is greater than physical CU number (i.e., multiProcessorCount member of hipDeviceProp\_t), the extra elements are ignored. It is user's responsibility to make sure the input is meaningful.
-
-## Returns
-
-hipSuccess, hipErrorInvalidHandle, hipErrorInvalidValue hipError\_t hipExtStreamGetCUMask ( hipStream\_t stream, uint32\_t cuMaskSize, uint32\_t *cuMask )
-
-Get CU mask associated with an asynchronous stream.
-
-## See also:
-
-hipStreamCreate , hipStreamSynchronize , hipStreamWaitEvent , hipStreamDestroy
-
-## Parameters
-
-- stream -[in] stream to be queried
-- cuMaskSize -[in] number of the block of memories (uint32\_t *) allocated by user
-- cuMask -[out] Pointer to a pre-allocated block of memories (uint32\_t *) in which the stream's CU mask is returned. The CU mask is returned in a chunck of 32 bits where each active bit represents one active CU
-
-## Returns
-
-hipSuccess, hipErrorInvalidHandle, hipErrorInvalidValue hipError\_t hipStreamAddCallback ( hipStream\_t stream, hipStreamCallback\_t callback, void *userData, unsigned int flags )
-
-Adds a callback to be called on the host after all currently enqueued items in the stream have completed. For each hipStreamAddCallback call, a callback will be executed exactly once. The callback will block later work in the stream until it is finished.
-
-## See also:
-
-hipStreamCreate , hipStreamCreateWithFlags , hipStreamQuery , hipStreamSynchronize , hipStreamWaitEvent , hipStreamDestroy , hipStreamCreateWithPriority
-
-## Parameters
-
-- stream -[in] - Stream to add callback to
-- callback -[in] - The function to call once preceding stream operations are complete
-- userData -[in] - User specified data to be passed to the callback function
-- flags -[in] - Reserved for future use, must be 0
-
-## Returns
-
-hipSuccess, hipErrorInvalidHandle, hipErrorNotSupported static inline hipError\_t hipMallocAsync ( void **dev\_ptr, size\_t size, hipMemPool\_t mem\_pool, hipStream\_t stream )
-
-C++ wrappers for allocations from a memory pool.
-
-This section describes wrappers for stream Ordered allocation from memory pool functions of HIP runtime API.
-
-This is an alternate C++ calls for hipMallocFromPoolAsync made available through function overloading.
-
-## See also:
-
-hipMallocFromPoolAsync
-
-Note: APIs in this section are implemented on Linux, under development on Windows.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-## template&lt;class T &gt;
-
-static inline hipError\_t hipMallocAsync ( T **dev\_ptr, size\_t size, hipMemPool\_t mem\_pool, hipStream\_t stream C++ wrappers for allocations from a memory pool on the stream.
-
-This is an alternate C++ calls for hipMallocFromPoolAsync made available through function overloading.
-
-## See also:
-
-hipMallocFromPoolAsync
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-## template&lt;class T &gt;
-
-static inline hipError\_t hipMallocAsync ( T **dev\_ptr, size\_t size, hipStream\_t stream )
-
-C++ wrappers for allocations from a memory pool.
-
-This is an alternate C++ calls for hipMallocFromPoolAsync made available through function overloading.
-
-## See also:
-
-hipMallocFromPoolAsync
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-## template&lt;class T &gt;
-
-static inline hipError\_t hipMallocFromPoolAsync ( T **dev\_ptr, size\_t size, hipMemPool\_t mem\_pool, hipStream\_t stream )
-
-C++ wrappers for allocations from a memory pool.
-
-This is an alternate C++ calls for hipMallocFromPoolAsync made available through function overloading.
-
-## See also:
-
-hipMallocFromPoolAsync
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-)
-
-hipError\_t hipMallocAsync ( void **dev\_ptr, size\_t size, hipStream\_t stream )
-
-Allocates memory with stream ordered semantics.
-
-Inserts a memory allocation operation into stream . A pointer to the allocated memory is returned immediately in *dptr. The allocation must not be accessed until the allocation operation completes. The allocation comes from the memory pool associated with the stream's device.
-
-## See also:
-
-hipMallocFromPoolAsync , hipFreeAsync , hipMemPoolTrimTo , hipMemPoolGetAttribute , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess , hipMemPoolGetAccess
-
-Note: The default memory pool of a device contains device memory from that device.
-
-Note: Basic stream ordering allows future work submitted into the same stream to use the allocation. Stream query, stream synchronize, and HIP events can be used to guarantee that the allocation operation completes before work submitted in a separate stream runs.
-
-Note: During stream capture, this function results in the creation of an allocation node. In this case, the allocation is owned by the graph instead of the memory pool. The memory pool's properties are used to set the node's creation parameters.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- dev\_ptr -[out] Returned device pointer of memory allocation
-- size -[in] Number of bytes to allocate
-- stream -[in] The stream establishing the stream ordering contract and the memory pool to allocate from
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported, hipErrorOutOfMemory hipError\_t hipFreeAsync ( void *dev\_ptr, hipStream\_t stream )
-
-Frees memory with stream ordered semantics.
-
-Inserts a free operation into stream . The allocation must not be used after stream execution reaches the free. After this API returns, accessing the memory from any subsequent work launched on the GPU or querying its pointer attributes results in undefined behavior.
-
-## See also:
-
-hipMallocFromPoolAsync , hipMallocAsync , hipMemPoolTrimTo , hipMemPoolGetAttribute , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess , hipMemPoolGetAccess
-
-Note: During stream capture, this function results in the creation of a free node and must therefore be passed the address of a graph allocation.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- dev\_ptr -[in] Pointer to device memory to free
-- stream -[in] The stream, where the destruciton will occur according to the execution order
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemPoolTrimTo ( hipMemPool\_t mem\_pool, size\_t min\_bytes\_to\_hold )
-
-Releases freed memory back to the OS.
-
-Releases memory back to the OS until the pool contains fewer than min\_bytes\_to\_keep reserved bytes, or there is no more memory that the allocator can safely release. The allocator cannot release OS allocations that back outstanding asynchronous allocations. The OS allocations may happen at different granularity from the user allocations.
-
-## See also:
-
-hipMallocFromPoolAsync , hipMallocAsync , hipFreeAsync , hipMemPoolGetAttribute , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess , hipMemPoolGetAccess
-
-Note: Allocations that have not been freed count as outstanding.
-
-Note: Allocations that have been asynchronously freed but whose completion has not been observed on the host (eg. by a synchronize) can count as outstanding.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- mem\_pool -[in] The memory pool to trim allocations
-- min\_bytes\_to\_hold -[in] If the pool has less than min\_bytes\_to\_hold reserved, then the TrimTo operation is a no-op. Otherwise the memory pool will contain at least min\_bytes\_to\_hold bytes reserved after the operation.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemPoolSetAttribute ( hipMemPool\_t mem\_pool, hipMemPoolAttr attr, void *value )
-
-Sets attributes of a memory pool.
-
-Supported attributes are:
-
-- hipMemPoolAttrReleaseThreshold: (value type = cuuint64\_t) Amount of reserved memory in bytes to hold onto before trying to release memory back to the OS. When more than the release threshold bytes of memory are held by the memory pool, the allocator will try to release memory back to the OS on the next call to stream, event or context synchronize. (default 0)
-- hipMemPoolReuseFollowEventDependencies: (value type = int) Allow hipMallocAsync to use memory asynchronously freed in another stream as long as a stream ordering dependency of the allocating stream on the free action exists. HIP events and null stream interactions can create the required stream ordered dependencies. (default enabled)
-- hipMemPoolReuseAllowOpportunistic: (value type = int) Allow reuse of already completed frees when there is no dependency between the free and allocation. (default enabled)
-- hipMemPoolReuseAllowInternalDependencies: (value type = int) Allow hipMallocAsync to insert new stream dependencies in order to establish the stream ordering required to reuse a piece of memory released by hipFreeAsync (default enabled).
-
-## See also:
-
-hipMallocFromPoolAsync , hipMallocAsync , hipFreeAsync , hipMemPoolGetAttribute , hipMemPoolTrimTo , hipDeviceSetMemPool, hipMemPoolSetAccess , hipMemPoolGetAccess
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- mem\_pool -[in] The memory pool to modify
-- attr -[in] The attribute to modify
-- value -[in] Pointer to the value to assign
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue
-
-hipError\_t hipMemPoolGetAttribute ( hipMemPool\_t mem\_pool, hipMemPoolAttr attr, void *value )
-
-Gets attributes of a memory pool.
-
-Supported attributes are:
-
-- hipMemPoolAttrReleaseThreshold: (value type = cuuint64\_t) Amount of reserved memory in bytes to hold onto before trying to release memory back to the OS. When more than the release threshold bytes of memory are held by the memory pool, the allocator will try to release memory back to the OS on the next call to stream, event or context synchronize. (default 0)
-- hipMemPoolReuseFollowEventDependencies: (value type = int) Allow hipMallocAsync to use memory asynchronously freed in another stream as long as a stream ordering dependency of the allocating stream on the free action exists. HIP events and null stream interactions can create the required stream ordered dependencies. (default enabled)
-- hipMemPoolReuseAllowOpportunistic: (value type = int) Allow reuse of already completed frees when there is no dependency between the free and allocation. (default enabled)
-- hipMemPoolReuseAllowInternalDependencies: (value type = int) Allow hipMallocAsync to insert new stream dependencies in order to establish the stream ordering required to reuse a piece of memory released by hipFreeAsync (default enabled).
-
-## See also:
-
-hipMallocFromPoolAsync , hipMallocAsync , hipFreeAsync , hipMemPoolTrimTo , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess , hipMemPoolGetAccess
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- mem\_pool -[in] The memory pool to get attributes of
-- attr -[in] The attribute to get
-- value -[in] Retrieved value
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemPoolSetAccess ( hipMemPool\_t mem\_pool, const hipMemAccessDesc *desc\_list, size\_t count ) Controls visibility of the specified pool between devices.
-
-## See also:
-
-hipMallocFromPoolAsync , hipMallocAsync , hipFreeAsync , hipMemPoolGetAttribute , hipMemPoolTrimTo , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolGetAccess
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- mem\_pool -[in] Memory pool for acccess change
-- desc\_list -[in] Array of access descriptors. Each descriptor instructs the access to enable for a single gpu
-- count -[in] Number of descriptors in the map array.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemPoolGetAccess ( hipMemAccessFlags *flags, hipMemPool\_t mem\_pool, hipMemLocation *location )
-
-Returns the accessibility of a pool from a device.
-
-Returns the accessibility of the pool's memory from the specified location.
-
-## See also:
-
-hipMallocFromPoolAsync , hipMallocAsync , hipFreeAsync , hipMemPoolGetAttribute , hipMemPoolTrimTo , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- flags -[out] Accessibility of the memory pool from the specified location/device
-- mem\_pool -[in] Memory pool being queried
-- location -[in] Location/device for memory pool access
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemPoolCreate ( hipMemPool\_t *mem\_pool, const hipMemPoolProps *pool\_props )
-
-Creates a memory pool.
-
-Creates a HIP memory pool and returns the handle in mem\_pool . The pool\_props determines the properties of the pool such as the backing device and IPC capabilities.
-
-By default, the memory pool will be accessible from the device it is allocated on.
-
-## See also:
-
-hipMallocFromPoolAsync , hipMallocAsync , hipFreeAsync , hipMemPoolGetAttribute , hipMemPoolDestroy , hipMemPoolTrimTo , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess , hipMemPoolGetAccess
-
-Note: Specifying hipMemHandleTypeNone creates a memory pool that will not support IPC.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- mem\_pool -[out] Contains createed memory pool
-- pool\_props -[in] Memory pool properties
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemPoolDestroy ( hipMemPool\_t mem\_pool )
-
-Destroys the specified memory pool.
-
-If any pointers obtained from this pool haven't been freed or the pool has free operations that haven't completed when hipMemPoolDestroy is invoked, the function will return immediately and the resources associated with the pool will be released automatically once there are no more outstanding allocations.
-
-Destroying the current mempool of a device sets the default mempool of that device as the current mempool for that device.
-
-## See also:
-
-hipMallocFromPoolAsync , hipMallocAsync , hipFreeAsync , hipMemPoolGetAttribute , hipMemPoolCreate hipMemPoolTrimTo , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess , hipMemPoolGetAccess
-
-Note: A device's default memory pool cannot be destroyed.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-mem\_pool -[in] Memory pool for destruction
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t void **dev\_ptr, size\_t size, hipMemPool\_t mem\_pool, hipStream\_t stream
-
-hipMallocFromPoolAsync ( ) Allocates memory from a specified pool with stream ordered semantics.
-
-Inserts an allocation operation into stream . A pointer to the allocated memory is returned immediately in dev\_ptr . The allocation must not be accessed until the allocation operation completes. The allocation comes from the specified memory pool.
-
-Basic stream ordering allows future work submitted into the same stream to use the allocation. Stream query, stream synchronize, and HIP events can be used to guarantee that the allocation operation completes before work submitted in a separate stream runs.
-
-## See also:
-
-hipMallocAsync , hipFreeAsync , hipMemPoolGetAttribute , hipMemPoolCreate hipMemPoolTrimTo , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess , hipMemPoolGetAccess ,
-
-Note: The specified memory pool may be from a device different than that of the specified stream .
-
-Note: During stream capture, this function results in the creation of an allocation node. In this case, the allocation is owned by the graph instead of the memory pool. The memory pool's properties are used to set the node's creation parameters.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- dev\_ptr -[out] Returned device pointer
-- size -[in] Number of bytes to allocate
-- mem\_pool -[in] The pool to allocate from
-- stream -[in] The stream establishing the stream ordering semantic
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported, hipErrorOutOfMemory hipError\_t hipMemPoolExportToShareableHandle ( void *shared\_handle, hipMemPool\_t mem\_pool, hipMemAllocationHandleType handle\_type, unsigned int flags )
-
-Exports a memory pool to the requested handle type.
-
-Given an IPC capable mempool, create an OS handle to share the pool with another process. A recipient process can convert the shareable handle into a mempool with hipMemPoolImportFromShareableHandle . Individual pointers can then be shared with the hipMemPoolExportPointer and hipMemPoolImportPointer APIs. The implementation of what the shareable handle is and how it can be transferred is defined by the requested handle type.
-
-## See also:
-
-hipMemPoolImportFromShareableHandle
-
-Note: To create an IPC capable mempool, create a mempool with a hipMemAllocationHandleType other than hipMemHandleTypeNone .
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- shared\_handle -[out] Pointer to the location in which to store the requested handle
-- mem\_pool -[in] Pool to export
-- handle\_type -[in] The type of handle to create
-- flags -[in] Must be 0
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorOutOfMemory hipError\_t hipMemPoolImportFromShareableHandle ( hipMemPool\_t *mem\_pool, void *shared\_handle, hipMemAllocationHandleType handle\_type, unsigned int flags )
-
-Imports a memory pool from a shared handle.
-
-Specific allocations can be imported from the imported pool with hipMemPoolImportPointer .
-
-## See also:
-
-hipMemPoolExportToShareableHandle
-
-Note: Imported memory pools do not support creating new allocations. As such imported memory pools may not be used in hipDeviceSetMemPool or hipMallocFromPoolAsync calls.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- mem\_pool -[out] Returned memory pool
-- shared\_handle -[in] OS handle of the pool to open
-- handle\_type -[in] The type of handle being imported
-- flags -[in] Must be 0
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorOutOfMemory hipError\_t hipMemPoolExportPointer ( hipMemPoolPtrExportData *export\_data, void *dev\_ptr )
-
-Export data to share a memory pool allocation between processes.
-
-Constructs export\_data for sharing a specific allocation from an already shared memory pool. The recipient process can import the allocation with the hipMemPoolImportPointer api. The data is not a handle and may be shared through any IPC mechanism.
-
-## See also:
-
-hipMemPoolImportPointer
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- export\_data -[out] Returned export data
-- dev\_ptr -[in] Pointer to memory being exported
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorOutOfMemory hipError\_t hipMemPoolImportPointer ( void **dev\_ptr, hipMemPool\_t mem\_pool, hipMemPoolPtrExportData *export\_data )
-
-Import a memory pool allocation from another process.
-
-Returns in dev\_ptr a pointer to the imported memory. The imported memory must not be accessed before the allocation operation completes in the exporting process. The imported memory must be freed from all importing processes before being freed in the exporting process. The pointer may be freed with hipFree or hipFreeAsync . If hipFreeAsync is used, the free must be completed on the importing process before the free operation on the exporting process.
-
-## See also:
-
-hipMemPoolExportPointer
-
-Note: The hipFreeAsync api may be used in the exporting process before the hipFreeAsync operation completes in its stream as long as the hipFreeAsync in the exporting process specifies a stream with a stream dependency on the importing process's hipFreeAsync .
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- dev\_ptr -[out] Pointer to imported memory
-- mem\_pool -[in] Memory pool from which to import a pointer
-- export\_data -[in] Data specifying the memory to import
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized, hipErrorOutOfMemory
-
-## 19.23.2 Peer to peer
-
-hipError\_t hipDeviceCanAccessPeer ( int *canAccessPeer, int deviceId, int peerDeviceId )
-
-Determine if a device can access a peer's memory.
-
-Returns '1' in canAccessPeer if the specified device is capable of directly accessing memory physically located on peerDevice , or '0' if not.
-
-Returns '0' in canAccessPeer if deviceId == peerDeviceId, and both are valid devices : a device is not a peer of itself.
-
-## Parameters
-
-- canAccessPeer -[out] Returns the peer access capability (0 or 1)
-- deviceId -[in] - device from where memory may be accessed.
-- peerDeviceId -[in] - device where memory is physically located
-
-## Returns
-
-hipSuccess,
-
-## Returns
-
-hipErrorInvalidDevice if deviceId or peerDeviceId are not valid devices hipError\_t hipDeviceEnablePeerAccess ( int peerDeviceId, unsigned int flags )
-
-Enable direct access from current device's virtual address space to memory allocations physically located on a peer device.
-
-Memory which already allocated on peer device will be mapped into the address space of the current device. In addition, all future memory allocations on peerDeviceId will be mapped into the address space of the current device when the memory is allocated. The peer memory remains accessible from the current device until a call to hipDeviceDisablePeerAccess or hipDeviceReset.
-
-Returns hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue,
-
-## Parameters
-
-- peerDeviceId -[in] Peer device to enable direct access to from the current device
-- flags -[in] Reserved for future use, must be zero
-
-## Returns
-
-hipErrorPeerAccessAlreadyEnabled if peer access is already enabled for this device.
-
-## hipError\_t hipDeviceDisablePeerAccess ( int peerDeviceId )
-
-Disable direct access from current device's virtual address space to memory allocations physically located on a peer device.
-
-Returns hipErrorPeerAccessNotEnabled if direct access to memory on peerDevice has not yet been enabled from the current device.
-
-## Parameters
-
-peerDeviceId -[in] Peer device to disable direct access to
-
-## Returns
-
-hipSuccess, hipErrorPeerAccessNotEnabled hipError\_t hipMemGetAddressRange ( hipDeviceptr\_t *pbase, size\_t *psize, hipDeviceptr\_t dptr )
-
-Get information on memory allocations.
-
-## See also:
-
-hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent, hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice
-
-## Parameters
-
-- pbase -[out] - BAse pointer address
-- psize -[out] - Size of allocation
-- dptr--[in] Device Pointer
-
-## Returns
-
-hipSuccess, hipErrorNotFound
-
-## USE\_PEER\_NON\_UNIFIED
-
-## 19.23.3 Memory management
-
-hipError\_t hipPointerSetAttribute ( const void *value, hipPointer\_attribute attribute, hipDeviceptr\_t ptr )
-
-Sets information on the specified pointer.[BETA].
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- value -[in] Sets pointer attribute value
-- attribute -[in] Attribute to set
-- ptr -[in] Pointer to set attributes for
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError\_t hipPointerGetAttributes ( hipPointerAttribute\_t *attributes, const void *ptr )
-
-Returns attributes for the specified pointer.
-
-The output parameter 'attributes' has a member named 'type' that describes what memory the pointer is associated with, such as device memory, host memory, managed memory, and others. Otherwise, the API cannot handle the pointer and returns hipErrorInvalidValue.
-
-## See also:
-
-hipPointerGetAttribute
-
-Note: The unrecognized memory type is unsupported to keep the HIP functionality backward compatibility due to hipMemoryType enum values.
-
-Note: The current behavior of this HIP API corresponds to the CUDA API before version 11.0.
-
-## Parameters
-
-- attributes -[out] attributes for the specified pointer
-- ptr -[in] pointer to get attributes for
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError\_t hipPointerGetAttribute ( void *data, hipPointer\_attribute attribute, hipDeviceptr\_t ptr ) Returns information about the specified pointer.[BETA].
-
-## See also:
-
-hipPointerGetAttributes
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- data -[inout] Returned pointer attribute value
-- attribute -[in] Attribute to query for
-- ptr -[in] Pointer to get attributes for
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError\_t hipDrvPointerGetAttributes ( unsigned int numAttributes, hipPointer\_attribute *attributes, void **data, hipDeviceptr\_t ptr )
-
-Returns information about the specified pointer.[BETA].
-
-## See also:
-
-hipPointerGetAttribute
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- numAttributes -[in] number of attributes to query for
-- attributes -[in] attributes to query for
-- data -[inout] a two-dimensional containing pointers to memory locations where the result of each attribute query will be written to
-- ptr -[in] pointer to get attributes for
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError\_t hipMalloc ( void **ptr, size\_t size )
-
-Allocate memory on the default accelerator.
-
-If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.
-
-## See also:
-
-hipMallocPitch , hipFree , hipMallocArray , hipFreeArray , hipMalloc3D , hipMalloc3DArray , hipHostFree , hipHostMalloc
-
-## Parameters
-
-- ptr -[out] Pointer to the allocated memory
-- size -[in] Requested memory size
-
-## Returns
-
-hipSuccess, hipErrorOutOfMemory, hipErrorInvalidValue (bad context, null *ptr)
-
-hipError\_t hipExtMallocWithFlags ( void **ptr, size\_t sizeBytes, unsigned int flags )
-
-Allocate memory on the default accelerator.
-
-If requested memory size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.
-
-The memory allocation flag should be either hipDeviceMallocDefault, hipDeviceMallocFinegrained, hipDeviceMallocUncached, or hipMallocSignalMemory. If the flag is any other value, the API returns hipErrorInvalidValue.
-
-## See also:
-
-hipMallocPitch , hipFree , hipMallocArray , hipFreeArray , hipMalloc3D , hipMalloc3DArray , hipHostFree , hipHostMalloc
-
-## Parameters
-
-- ptr -[out] Pointer to the allocated memory
-- sizeBytes -[in] Requested memory size
-- flags -[in] Type of memory allocation
-
-## Returns
-
-hipSuccess, hipErrorOutOfMemory, hipErrorInvalidValue (bad context, null *ptr)
-
-hipError\_t hipMallocHost ( void **ptr, size\_t size )
-
-Allocate pinned host memory [Deprecated].
-
-If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.
-
-Warning:
-
-```
-
-
-arning:   This API is deprecated, use hipHostMalloc() instead
-```
-
-## Parameters
-
-- ptr -[out] Pointer to the allocated host pinned memory
-- size -[in] Requested memory size
-
-## Returns
-
-hipSuccess, hipErrorOutOfMemory
-
-## hipError\_t hipMemAllocHost ( void **ptr, size\_t size )
-
-Allocate pinned host memory [Deprecated].
-
-If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.
-
-Warning: This API is deprecated, use hipHostMalloc() instead
-
-## Parameters
-
-- ptr -[out] Pointer to the allocated host pinned memory
-- size -[in] Requested memory size
-
-## Returns
-
-hipSuccess, hipErrorOutOfMemory hipError\_t hipHostMalloc ( void **ptr, size\_t size, unsigned int flags )
-
-Allocates device accessible page locked (pinned) host memory.
-
-This API allocates pinned host memory which is mapped into the address space of all GPUs in the system, the memory can be accessed directly by the GPU device, and can be read or written with much higher bandwidth than pageable memory obtained with functions such as malloc().
-
-Using the pinned host memory, applications can implement faster data transfers for HostToDevice and DeviceToHost. The runtime tracks the hipHostMalloc allocations and can avoid some of the setup required for regular unpinned memory.
-
-When the memory accesses are infrequent, zero-copy memory can be a good choice, for coherent allocation. GPU can directly access the host memory over the CPU/GPU interconnect, without need to copy the data.
-
-Currently the allocation granularity is 4KB for the API.
-
-Developers need to choose proper allocation flag with consideration of synchronization.
-
-If no input for flags, it will be the default pinned memory allocation on the host.
-
-## See also:
-
-hipSetDeviceFlags, hipHostFree
-
-## Parameters
-
-- ptr -[out] Pointer to the allocated host pinned memory
-- size -[in] Requested memory size in bytes If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.
-- flags -[in] Type of host memory allocation. See the description of flags in hipSetDeviceFlags.
-
-## Returns
-
-hipSuccess, hipErrorOutOfMemory hipError\_t hipHostAlloc ( void **ptr, size\_t size, unsigned int flags )
-
-Allocate device accessible page locked host memory [Deprecated].
-
-If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.
-
-Warning: This API is deprecated, use hipHostMalloc() instead
-
-## Parameters
-
-- ptr -[out] Pointer to the allocated host pinned memory
-
-- size -[in] Requested memory size in bytes
-- flags -[in] Type of host memory allocation
-
-## Returns
-
-hipSuccess, hipErrorOutOfMemory hipError\_t hipHostGetDevicePointer ( void **devPtr, void *hstPtr, unsigned int flags )
-
-Get Device pointer from Host Pointer allocated through hipHostMalloc.
-
-## See also:
-
-hipSetDeviceFlags, hipHostMalloc
-
-## Parameters
-
-- devPtr -[out] Device Pointer mapped to passed host pointer
-- hstPtr -[in] Host Pointer allocated through hipHostMalloc
-- flags -[in] Flags to be passed for extension
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorOutOfMemory hipError\_t hipHostGetFlags ( unsigned int *flagsPtr, void *hostPtr )
-
-Return flags associated with host pointer.
-
-## See also:
-
-## hipHostMalloc
-
-## Parameters
-
-- flagsPtr -[out] Memory location to store flags
-- hostPtr -[in] Host Pointer allocated through hipHostMalloc
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipHostRegister ( void *hostPtr, size\_t sizeBytes, unsigned int flags )
-
-Register host memory so it can be accessed from the current device.
-
-## Flags:
-
-- hipHostRegisterDefault Memory is Mapped and Portable
-- hipHostRegisterPortable Memory is considered registered by all contexts. HIP only supports one context so this is always assumed true.
-- hipHostRegisterMapped Map the allocation into the address space for the current device. The device pointer can be obtained with hipHostGetDevicePointer .
-
-After registering the memory, use hipHostGetDevicePointer to obtain the mapped device pointer. On many systems, the mapped device pointer will have a different value than the mapped host pointer. Applications must use the device pointer in device code, and the host pointer in host code.
-
-On some systems, registered memory is pinned. On some systems, registered memory may not be actually be pinned but uses OS or hardware facilities to all GPU access to the host memory.
-
-Developers are strongly encouraged to register memory blocks which are aligned to the host cache-line size. (typically 64-bytes but can be obtains from the CPUID instruction).
-
-If registering non-aligned pointers, the application must take care when register pointers from the same cache line on different devices. HIP's coarse-grained synchronization model does not guarantee correct results if different devices write to different parts of the same cache block - typically one of the writes will 'win' and overwrite data from the other registered memory region.
-
-## See also:
-
-hipHostUnregister , hipHostGetFlags , hipHostGetDevicePointer
-
-## Parameters
-
-- hostPtr -[out] Pointer to host memory to be registered.
-- sizeBytes -[in] Size of the host memory
-- flags -[in] See below.
-
-## Returns
-
-hipSuccess, hipErrorOutOfMemory hipError\_t hipHostUnregister ( void *hostPtr )
-
-Un-register host pointer.
-
-## See also:
-
-hipHostRegister
-
-## Parameters
-
-hostPtr -[in] Host pointer previously registered with hipHostRegister
-
-## Returns
-
-Error code hipError\_t hipMallocPitch ( void **ptr, size\_t *pitch, size\_t width, size\_t height )
-
-Allocates at least width (in bytes) * height bytes of linear memory Padding may occur to ensure alighnment requirements are met for the given row The change in width size due to padding will be returned in *pitch. Currently the alignment is set to 128 bytes
-
-If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.
-
-## See also:
-
-hipMalloc , hipFree , hipMallocArray , hipFreeArray , hipHostFree , hipMalloc3D , hipMalloc3DArray , hipHostMalloc
-
-## Parameters
-
-- ptr -[out] Pointer to the allocated device memory
-
-- pitch -[out] Pitch for allocation (in bytes)
-- width -[in] Requested pitched allocation width (in bytes)
-- height -[in] Requested pitched allocation height
-
-## Returns
-
-Error code hipError\_t hipMemAllocPitch ( hipDeviceptr\_t *dptr, size\_t *pitch, size\_t widthInBytes, size\_t height, unsigned int elementSizeBytes )
-
-Allocates at least width (in bytes) * height bytes of linear memory Padding may occur to ensure alighnment requirements are met for the given row The change in width size due to padding will be returned in *pitch. Currently the alignment is set to 128 bytes
-
-If size is 0, no memory is allocated, ptr returns nullptr, and hipSuccess is returned. The intended usage of pitch is as a separate parameter of the allocation, used to compute addresses within the 2D array. Given the row and column of an array element of type T, the address is computed as: T pElement = (T*)((char*)BaseAddress + Row * Pitch) + Column;
-
-## See also:
-
-hipMalloc , hipFree , hipMallocArray , hipFreeArray , hipHostFree , hipMalloc3D , hipMalloc3DArray , hipHostMalloc
-
-## Parameters
-
-- dptr -[out] Pointer to the allocated device memory
-- pitch -[out] Pitch for allocation (in bytes)
-- widthInBytes -[in] Requested pitched allocation width (in bytes)
-- height -[in] Requested pitched allocation height
-- elementSizeBytes -[in] The size of element bytes, should be 4, 8 or 16
-
-## Returns
-
-Error code
-
-## hipError\_t hipFree ( void *ptr )
-
-Free memory allocated by the hcc hip memory allocation API. This API performs an implicit hipDeviceSynchronize() call. If pointer is NULL, the hip runtime is initialized and hipSuccess is returned.
-
-## See also:
-
-hipMalloc , hipMallocPitch , hipMallocArray , hipFreeArray , hipHostFree , hipMalloc3D , hipMalloc3DArray , hipHostMalloc
-
-## Parameters
-
-ptr -[in] Pointer to memory to be freed
-
-## Returns
-
-hipSuccess
-
-## Returns
-
-hipErrorInvalidDevicePointer (if pointer is invalid, including host pointers allocated with hipHostMalloc)
-
-## hipError\_t hipFreeHost ( void *ptr )
-
-Free memory allocated by the hcc hip host memory allocation API [Deprecated].
-
-Warning:
-
-```
-
-
-urning:   This API is deprecated, use hipHostFree() instead
-```
-
-## Parameters
-
-ptr -[in] Pointer to memory to be freed
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue (if pointer is invalid, including device pointers allocated with hipMalloc)
-
-## hipError\_t hipHostFree ( void *ptr )
-
-Free memory allocated by the hcc hip host memory allocation API This API performs an implicit hipDeviceSynchronize() call. If pointer is NULL, the hip runtime is initialized and hipSuccess is returned.
-
-## See also:
-
-hipMalloc , hipMallocPitch , hipFree , hipMallocArray , hipFreeArray , hipMalloc3D , hipMalloc3DArray , hipHostMalloc
-
-## Parameters
-
-ptr -[in] Pointer to memory to be freed
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue (if pointer is invalid, including device pointers allocated with hipMalloc)
-
-hipError\_t hipMemcpy ( void *dst, const void *src, size\_t sizeBytes, hipMemcpyKind kind )
-
-Copy data from src to dst.
-
-It supports memory from host to device, device to host, device to device and host to host The src and dst must not overlap.
-
-For hipMemcpy, the copy is always performed by the current device (set by hipSetDevice). For multi-gpu or peerto-peer configurations, it is recommended to set the current device to the device where the src data is physically located. For optimal peer-to-peer copies, the copy device must be able to access the src and dst pointers (by calling hipDeviceEnablePeerAccess with copy agent as the current device and src/dest as the peerDevice argument. if this is not done, the hipMemcpy will still work, but will perform the copy using a staging buffer on the host. Calling hipMemcpy with dst and src pointers that do not match the hipMemcpyKind results in undefined behavior.
-
-## See also:
-
-hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer
-
-## Parameters
-
-- dst -[out] Data being copy to
-- src -[in] Data being copy from
-- sizeBytes -[in] Data size in bytes
-- kind -[in] Kind of transfer
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorUnknown hipError\_t hipMemcpyWithStream ( void *dst, const void *src, size\_t sizeBytes, hipMemcpyKind kind, hipStream\_t stream )
-
-Memory copy on the stream. It allows single or multiple devices to do memory copy on single or multiple streams.
-
-## See also:
-
-hipMemcpy , hipStreamCreate , hipStreamSynchronize , hipStreamDestroy , hipSetDevice, hipLaunchKernelGGL
-
-## Parameters
-
-- dst -[out] Data being copy to
-- src -[in] Data being copy from
-- sizeBytes -[in] Data size in bytes
-- kind -[in] Kind of transfer
-- stream -[in] Valid stream
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorUnknown, hipErrorContextIsDestroyed hipError\_t hipMemcpyHtoD ( hipDeviceptr\_t dst, void *src, size\_t sizeBytes )
-
-Copy data from Host to Device.
-
-## See also:
-
-hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer
-
-## Parameters
-
-- dst -[out] Data being copy to
-- src -[in] Data being copy from
-- sizeBytes -[in] Data size in bytes
-
-## Returns
-
-hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue
-
-hipError\_t hipMemcpyDtoH ( void *dst, hipDeviceptr\_t src, size\_t sizeBytes )
-
-Copy data from Device to Host.
-
-## See also:
-
-hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer
-
-## Parameters
-
-- dst -[out] Data being copy to
-- src -[in] Data being copy from
-- sizeBytes -[in] Data size in bytes
-
-## Returns
-
-hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue hipError\_t hipMemcpyDtoD ( hipDeviceptr\_t dst, hipDeviceptr\_t src, size\_t sizeBytes )
-
-Copy data from Device to Device.
-
-## See also:
-
-hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer
-
-## Parameters
-
-- dst -[out] Data being copy to
-- src -[in] Data being copy from
-- sizeBytes -[in] Data size in bytes
-
-## Returns
-
-hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue hipError\_t hipMemcpyHtoDAsync ( hipDeviceptr\_t dst, void *src, size\_t sizeBytes, hipStream\_t stream )
-
-Copy data from Host to Device asynchronously.
-
-## See also:
-
-hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpyAtoA, hipMemcpyAtoD,
-
-hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer
-
-## Parameters
-
-- dst -[out] Data being copy to
-- src -[in] Data being copy from
-- sizeBytes -[in] Data size in bytes
-- stream -[in] Stream identifier
-
-## Returns
-
-hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue hipError\_t hipMemcpyDtoHAsync ( void *dst, hipDeviceptr\_t src, size\_t sizeBytes, hipStream\_t stream )
-
-Copy data from Device to Host asynchronously.
-
-## See also:
-
-hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer
-
-## Parameters
-
-- dst -[out] Data being copy to
-- src -[in] Data being copy from
-- sizeBytes -[in] Data size in bytes
-- stream -[in] Stream identifier
-
-## Returns
-
-hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue hipError\_t hipMemcpyDtoDAsync ( hipDeviceptr\_t dst, hipDeviceptr\_t src, size\_t sizeBytes, hipStream\_t stream )
-
-Copy data from Device to Device asynchronously.
-
-## See also:
-
-hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer
-
-## Parameters
-
-- dst -[out] Data being copy to
-- src -[in] Data being copy from
-- sizeBytes -[in] Data size in bytes
-- stream -[in] Stream identifier
-
-## Returns
-
-hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue hipError\_t hipModuleGetGlobal ( hipDeviceptr\_t *dptr, size\_t *bytes, hipModule\_t hmod, const char *name )
-
-Returns a global pointer from a module. Returns in *dptr and *bytes the pointer and size of the global of name name located in module hmod. If no variable of that name exists, it returns hipErrorNotFound. Both parameters dptr and bytes are optional. If one of them is NULL, it is ignored and hipSuccess is returned.
-
-## Parameters
-
-- dptr -[out] Returns global device pointer
-- bytes -[out] Returns global size in bytes
-- hmod -[in] Module to retrieve global from
-- name -[in] Name of global to retrieve
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotFound, hipErrorInvalidContext hipError\_t hipGetSymbolAddress ( void **devPtr, const void *symbol )
-
-Gets device pointer associated with symbol on the device.
-
-## Parameters
-
-- devPtr -[out] pointer to the device associated the symbole
-- symbol -[in] pointer to the symbole of the device
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipGetSymbolSize ( size\_t *size, const void *symbol )
-
-Gets the size of the given symbol on the device.
-
-## Parameters
-
-- symbol -[in] pointer to the device symbole
-- size -[out] pointer to the size
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipGetProcAddress ( const char *symbol, void **pfn, int hipVersion, uint64\_t flags, hipDriverProcAddressQueryResult *symbolStatus )
-
-Gets the pointer of requested HIP driver function.
-
-Returns hipSuccess if the returned pfn is addressed to the pointer of found driver function.
-
-## Parameters
-
-- symbol -[in] The Symbol name of the driver function to request.
-- pfn -[out] Output pointer to the requested driver function.
-- hipVersion -[in] The HIP version for the requested driver function symbol. HIP version is defined as 100*version\_major + version\_minor. For example, in HIP 6.1, the hipversion is 601, for the symbol function 'hipGetDeviceProperties', the specified hipVersion 601 is greater or equal to the version 600, the symbol function will be handle properly as backend compatible function.
-- flags -[in] Currently only default flag is suppported.
-- symbolStatus -[out] Optional enumeration for returned status of searching for symbol driver function based on the input hipVersion.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue.
-
-hipError\_t hipMemcpyToSymbol ( const void *symbol, const void *src, size\_t sizeBytes, size\_t offset, hipMemcpyKind kind )
-
-Copies data to the given symbol on the device. Symbol HIP APIs allow a kernel to define a device-side data symbol which can be accessed on the host side. The symbol can be in \_\_constant or device space. Note that the symbol name needs to be encased in the HIP\_SYMBOL macro. This also applies to hipMemcpyFromSymbol, hipGetSymbolAddress, and hipGetSymbolSize. For detailed usage, see the memcpyToSymbol example in the HIP Porting Guide.
-
-## Parameters
-
-- symbol -[out] pointer to the device symbole
-- src -[in] pointer to the source address
-- sizeBytes -[in] size in bytes to copy
-- offset -[in] offset in bytes from start of symbole
-- kind -[in] type of memory transfer
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemcpyToSymbolAsync ( const void *symbol, const void *src, size\_t sizeBytes, size\_t offset, hipMemcpyKind kind, hipStream\_t stream )
-
-Copies data to the given symbol on the device asynchronously.
-
-## Parameters
-
-- symbol -[out] pointer to the device symbole
-- src -[in] pointer to the source address
-- sizeBytes -[in] size in bytes to copy
-- offset -[in] offset in bytes from start of symbole
-- kind -[in] type of memory transfer
-- stream -[in] stream identifier
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue
-
-hipError\_t hipMemcpyFromSymbol ( void *dst, const void *symbol, size\_t sizeBytes, size\_t offset, hipMemcpyKind kind )
-
-Copies data from the given symbol on the device.
-
-## Parameters
-
-- dst -[out] Returns pointer to destinition memory address
-- symbol -[in] Pointer to the symbole address on the device
-- sizeBytes -[in] Size in bytes to copy
-- offset -[in] Offset in bytes from the start of symbole
-- kind -[in] Type of memory transfer
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemcpyFromSymbolAsync ( void *dst, const void *symbol, size\_t sizeBytes, size\_t offset, hipMemcpyKind kind, hipStream\_t stream )
-
-Copies data from the given symbol on the device asynchronously.
-
-## Parameters
-
-- dst -[out] Returns pointer to destinition memory address
-- symbol -[in] pointer to the symbole address on the device
-- sizeBytes -[in] size in bytes to copy
-- offset -[in] offset in bytes from the start of symbole
-- kind -[in] type of memory transfer
-- stream -[in] stream identifier
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemcpyAsync ( void *dst, const void *src, size\_t sizeBytes, hipMemcpyKind kind, hipStream\_t stream )
-
-Copy data from src to dst asynchronously.
-
-For multi-gpu or peer-to-peer configurations, it is recommended to use a stream which is a attached to the device where the src data is physically located. For optimal peer-to-peer copies, the copy device must be able to access the src and dst pointers (by calling hipDeviceEnablePeerAccess with copy agent as the current device and src/dest as the peerDevice argument. if this is not done, the hipMemcpy will still work, but will perform the copy using a staging buffer on the host.
-
-## See also:
-
-hipMemcpy , hipMemcpy2D , hipMemcpyToArray , hipMemcpy2DToArray , hipMemcpyFromArray , hipMemcpy2DFromArray , hipMemcpyArrayToArray, hipMemcpy2DArrayToArray, hipMemcpyToSymbol , hipMemcpyFromSymbol , hipMemcpy2DAsync , hipMemcpyToArrayAsync, hipMemcpy2DToArrayAsync , hipMemcpyFromArrayAsync, hipMemcpy2DFromArrayAsync , hipMemcpyToSymbolAsync , hipMemcpyFromSymbolAsync
-
-Warning: If host or dest are not pinned, the memory copy will be performed synchronously. For best performance, use hipHostMalloc to allocate host memory that is transferred asynchronously.
-
-Warning: on HCC hipMemcpyAsync does not support overlapped H2D and D2H copies. For hipMemcpy, the copy is always performed by the device associated with the specified stream.
-
-## Parameters
-
-- dst -[out] Data being copy to
-- src -[in] Data being copy from
-- sizeBytes -[in] Data size in bytes
-- kind -[in] Type of memory transfer
-- stream -[in] Stream identifier
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorUnknown hipError\_t hipMemset ( void *dst, int value, size\_t sizeBytes )
-
-Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant byte value value.
-
-## Parameters
-
-- dst -[out] Data being filled
-- value -[in] Value to be set
-- sizeBytes -[in] Data size in bytes
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized hipError\_t hipMemsetD8 ( hipDeviceptr\_t dest, unsigned char value, size\_t count )
-
-Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant byte value value.
-
-## Parameters
-
-- dest -[out] Data ptr to be filled
-- value -[in] Value to be set
-- count -[in] Number of values to be set
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized hipError\_t hipMemsetD8Async ( hipDeviceptr\_t dest, unsigned char value, size\_t count, hipStream\_t stream )
-
-Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant byte value value.
-
-hipMemsetD8Async() is asynchronous with respect to the host, so the call may return before the memset is complete. The operation can optionally be associated to a stream by passing a non-zero stream argument. If stream is non-zero, the operation may overlap with operations in other streams.
-
-## Parameters
-
-- dest -[out] Data ptr to be filled
-- value -[in] Constant value to be set
-
-- count -[in] Number of values to be set
-- stream -[in] Stream identifier
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized hipError\_t hipMemsetD16 ( hipDeviceptr\_t dest, unsigned short value, size\_t count )
-
-Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant short value value.
-
-## Parameters
-
-- dest -[out] Data ptr to be filled
-- value -[in] Constant value to be set
-- count -[in] Number of values to be set
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized hipError\_t hipMemsetD16Async ( hipDeviceptr\_t dest, unsigned short value, size\_t count, hipStream\_t stream )
-
-Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant short value value.
-
-hipMemsetD16Async() is asynchronous with respect to the host, so the call may return before the memset is complete. The operation can optionally be associated to a stream by passing a non-zero stream argument. If stream is non-zero, the operation may overlap with operations in other streams.
-
-## Parameters
-
-- dest -[out] Data ptr to be filled
-- value -[in] Constant value to be set
-- count -[in] Number of values to be set
-- stream -[in] Stream identifier
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized hipError\_t hipMemsetD32 ( hipDeviceptr\_t dest, int value, size\_t count )
-
-Fills the memory area pointed to by dest with the constant integer value for specified number of times.
-
-## Parameters
-
-- dest -[out] Data being filled
-- value -[in] Constant value to be set
-- count -[in] Number of values to be set
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized hipError\_t hipMemsetAsync ( void *dst, int value, size\_t sizeBytes, hipStream\_t stream )
-
-Fills the first sizeBytes bytes of the memory area pointed to by dev with the constant byte value value.
-
-hipMemsetAsync() is asynchronous with respect to the host, so the call may return before the memset is complete. The operation can optionally be associated to a stream by passing a non-zero stream argument. If stream is nonzero, the operation may overlap with operations in other streams.
-
-## Parameters
-
-- dst -[out] Pointer to device memory
-
-- value -[in] Value to set for each byte of specified memory
-- sizeBytes -[in] Size in bytes to set
-- stream -[in] Stream identifier
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemsetD32Async ( hipDeviceptr\_t dst, int value, size\_t count, hipStream\_t stream )
-
-Fills the memory area pointed to by dev with the constant integer value for specified number of times.
-
-hipMemsetD32Async() is asynchronous with respect to the host, so the call may return before the memset is complete. The operation can optionally be associated to a stream by passing a non-zero stream argument. If stream is non-zero, the operation may overlap with operations in other streams.
-
-## Parameters
-
-- dst -[out] Pointer to device memory
-- value -[in] Value to set for each byte of specified memory
-- count -[in] Number of values to be set
-- stream -[in] Stream identifier
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemset2D ( void *dst, size\_t pitch, int value, size\_t width, size\_t height )
-
-Fills the memory area pointed to by dst with the constant value.
-
-## Parameters
-
-- dst -[out] Pointer to device memory
-- pitch -[in] Data size in bytes
-- value -[in] Constant value to be set
-- width -[in]
-- height -[in]
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemset2DAsync ( void *dst, size\_t pitch, int value, size\_t width, size\_t height, hipStream\_t stream ) Fills asynchronously the memory area pointed to by dst with the constant value.
-
-## Parameters
-
-- dst -[in] Pointer to 2D device memory
-- pitch -[in] Pitch size in bytes
-- value -[in] Value to be set for each byte of specified memory
-- width -[in] Width of matrix set columns in bytes
-- height -[in] Height of matrix set rows in bytes
-- stream -[in] Stream identifier
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue
-
-hipError\_t hipMemset3D ( hipPitchedPtr pitchedDevPtr, int value, hipExtent extent )
-
-Fills synchronously the memory area pointed to by pitchedDevPtr with the constant value.
-
-## Parameters
-
-- pitchedDevPtr -[in] Pointer to pitched device memory
-- value -[in] Value to set for each byte of specified memory
-- extent -[in] Size parameters for width field in bytes in device memory
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemset3DAsync ( hipPitchedPtr pitchedDevPtr, int value, hipExtent extent, hipStream\_t stream )
-
-Fills asynchronously the memory area pointed to by pitchedDevPtr with the constant value.
-
-## Parameters
-
-- pitchedDevPtr -[in] Pointer to pitched device memory
-- value -[in] Value to set for each byte of specified memory
-- extent -[in] Size parameters for width field in bytes in device memory
-- stream -[in] Stream identifier
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemGetInfo ( size\_t *free, size\_t *total )
-
-Query memory info.
-
-On ROCM, this function gets the actual free memory left on the current device, so supports the cases while running multi-workload (such as multiple processes, multiple threads, and multiple GPUs).
-
-Warning: On Windows, the free memory only accounts for memory allocated by this process and may be optimistic.
-
-## Parameters
-
-- free -[out] Returns free memory on the current device in bytes
-- total -[out] Returns total allocatable memory on the current device in bytes
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError\_t hipMemPtrGetInfo ( void *ptr, size\_t *size )
-
-Get allocated memory size via memory pointer.
-
-This function gets the allocated shared virtual memory size from memory pointer.
-
-## Parameters
-
-- ptr -[in] Pointer to allocated memory
-- size -[out] Returns the allocated memory size in bytes
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue
-
-hipError\_t hipMallocArray ( hipArray\_t *array, const hipChannelFormatDesc *desc, size\_t width, size\_t height, unsigned int flags )
-
-Allocate an array on the device.
-
-## See also:
-
-hipMalloc , hipMallocPitch , hipFree , hipFreeArray , hipHostMalloc , hipHostFree
-
-## Parameters
-
-- array -[out] Pointer to allocated array in device memory
-- desc -[in] Requested channel format
-- width -[in] Requested array allocation width
-- height -[in] Requested array allocation height
-- flags -[in] Requested properties of allocated array
-
-## Returns
-
-hipSuccess, hipErrorOutOfMemory hipError\_t hipArrayCreate ( hipArray\_t *pHandle, const HIP\_ARRAY\_DESCRIPTOR *pAllocateArray )
-
-Create an array memory pointer on the device.
-
-## See also:
-
-hipMallocArray , hipArrayDestroy , hipFreeArray
-
-## Parameters
-
-- pHandle -[out] Pointer to the array memory
-- pAllocateArray -[in] Requested array desciptor
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipArrayDestroy ( hipArray\_t array )
-
-Destroy an array memory pointer on the device.
-
-## See also:
-
-hipArrayCreate , hipArrayDestroy , hipFreeArray
-
-## Parameters
-
-array -[in] Pointer to the array memory
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue
-
-hipError\_t hipArray3DCreate ( hipArray\_t *array, const HIP\_ARRAY3D\_DESCRIPTOR *pAllocateArray )
-
-Create a 3D array memory pointer on the device.
-
-## See also:
-
-hipMallocArray , hipArrayDestroy , hipFreeArray
-
-## Parameters
-
-- array -[out] Pointer to the 3D array memory
-- pAllocateArray -[in] Requested array desciptor
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMalloc3D ( hipPitchedPtr *pitchedDevPtr, hipExtent extent )
-
-Create a 3D memory pointer on the device.
-
-## See also:
-
-hipMallocPitch , hipMemGetInfo , hipFree
-
-## Parameters
-
-- pitchedDevPtr -[out] Pointer to the 3D memory
-- extent -[in] Requested extent
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipFreeArray ( hipArray\_t array )
-
-Frees an array on the device.
-
-## See also:
-
-hipMalloc , hipMallocPitch , hipFree , hipMallocArray , hipHostMalloc , hipHostFree
-
-## Parameters
-
-array -[in] Pointer to array to free
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized hipError\_t hipMalloc3DArray ( hipArray\_t *array, const struct hipChannelFormatDesc *desc, struct hipExtent extent, unsigned int flags )
-
-Allocate an array on the device.
-
-## See also:
-
-hipMalloc , hipMallocPitch , hipFree , hipFreeArray , hipHostMalloc , hipHostFree
-
-## Parameters
-
-- array -[out] Pointer to allocated array in device memory
-- desc -[in] Requested channel format
-- extent -[in] Requested array allocation width, height and depth
-- flags -[in] Requested properties of allocated array
-
-## Returns
-
-hipSuccess, hipErrorOutOfMemory hipError\_t hipArrayGetInfo ( hipChannelFormatDesc *desc, hipExtent *extent, unsigned int *flags, hipArray\_t array )
-
-Gets info about the specified array.
-
-## See also:
-
-hipArrayGetDescriptor , hipArray3DGetDescriptor
-
-## Parameters
-
-- desc -[out] - Returned array type
-- extent -[out] - Returned array shape. 2D arrays will have depth of zero
-- flags -[out] - Returned array flags
-- array -[in] - The HIP array to get info for
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipErrorInvalidHandle hipError\_t hipArrayGetDescriptor ( HIP\_ARRAY\_DESCRIPTOR *pArrayDescriptor, hipArray\_t array )
-
-Gets a 1D or 2D array descriptor.
-
-## See also:
-
-hipArray3DCreate , hipArray3DGetDescriptor , hipArrayCreate , hipArrayDestroy , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpy3D , hipMemcpy3DAsync , hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoD , hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer, hipMemsetD8 , hipMemsetD16 , hipMemsetD32 , hipArrayGetInfo
-
-## Parameters
-
-- pArrayDescriptor -[out] - Returned array descriptor
-- array -[in] - Array to get descriptor of
-
-## Returns
-
-hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue hipErrorInvalidHandle
-
-hipError\_t hipArray3DGetDescriptor ( HIP\_ARRAY3D\_DESCRIPTOR *pArrayDescriptor, hipArray\_t array )
-
-Gets a 3D array descriptor.
-
-## See also:
-
-hipArray3DCreate , hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpy3D , hipMemcpy3DAsync , hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoD , hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer, hipMemsetD8 , hipMemsetD16 , hipMemsetD32 , hipArrayGetInfo
-
-## Parameters
-
-- pArrayDescriptor -[out] - Returned 3D array descriptor
-- array -[in] - 3D array to get descriptor of
-
-## Returns
-
-hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue hipErrorInvalidHandle, hipErrorContextIsDestroyed hipError\_t hipMemcpy2D ( void *dst, size\_t dpitch, const void *src, size\_t spitch, size\_t width, size\_t height, hipMemcpyKind kind )
-
-Copies data between host and device.
-
-## See also:
-
-hipMemcpy , hipMemcpyToArray , hipMemcpy2DToArray , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-- dst -[in] Destination memory address
-- dpitch -[in] Pitch of destination memory
-- src -[in] Source memory address
-- spitch -[in] Pitch of source memory
-- width -[in] Width of matrix transfer (columns in bytes)
-- height -[in] Height of matrix transfer (rows)
-- kind -[in] Type of transfer
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpyParam2D ( const hip\_Memcpy2D *pCopy )
-
-Copies memory for 2D arrays.
-
-## See also:
-
-hipMemcpy , hipMemcpy2D , hipMemcpyToArray , hipMemcpy2DToArray , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-pCopy -[in] Parameters for the memory copy
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpyParam2DAsync ( const hip\_Memcpy2D *pCopy, hipStream\_t stream )
-
-Copies memory for 2D arrays.
-
-## See also:
-
-hipMemcpy , hipMemcpy2D , hipMemcpyToArray , hipMemcpy2DToArray , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-- pCopy -[in] Parameters for the memory copy
-- stream -[in] Stream to use
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpy2DAsync ( void *dst, size\_t dpitch, const void *src, size\_t spitch, size\_t width, size\_t height, hipMemcpyKind kind, hipStream\_t stream )
-
-Copies data between host and device.
-
-## See also:
-
-hipMemcpy , hipMemcpyToArray , hipMemcpy2DToArray , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-- dst -[in] Destination memory address
-- dpitch -[in] Pitch of destination memory
-- src -[in] Source memory address
-- spitch -[in] Pitch of source memory
-- width -[in] Width of matrix transfer (columns in bytes)
-- height -[in] Height of matrix transfer (rows)
-- kind -[in] Type of transfer
-- stream -[in] Stream to use
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpy2DToArray ( hipArray\_t dst, size\_t wOffset, size\_t hOffset, const void *src, size\_t spitch, size\_t width, size\_t height, hipMemcpyKind kind )
-
-Copies data between host and device.
-
-## See also:
-
-hipMemcpy , hipMemcpyToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-- dst -[in] Destination memory address
-- wOffset -[in] Destination starting X offset
-- hOffset -[in] Destination starting Y offset
-- src -[in] Source memory address
-- spitch -[in] Pitch of source memory
-- width -[in] Width of matrix transfer (columns in bytes)
-- height -[in] Height of matrix transfer (rows)
-- kind -[in] Type of transfer
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpy2DToArrayAsync ( hipArray\_t dst, size\_t wOffset, size\_t hOffset, const void *src, size\_t spitch, size\_t width, size\_t height, hipMemcpyKind kind, hipStream\_t stream )
-
-Copies data between host and device.
-
-## See also:
-
-hipMemcpy , hipMemcpyToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-- dst -[in] Destination memory address
-- wOffset -[in] Destination starting X offset
-- hOffset -[in] Destination starting Y offset
-- src -[in] Source memory address
-- spitch -[in] Pitch of source memory
-- width -[in] Width of matrix transfer (columns in bytes)
-- height -[in] Height of matrix transfer (rows)
-
-- kind -[in] Type of transfer
-- stream -[in] Accelerator view which the copy is being enqueued
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpyToArray ( hipArray\_t dst, size\_t wOffset, size\_t hOffset, const void *src, size\_t count, hipMemcpyKind kind )
-
-Copies data between host and device.
-
-## See also:
-
-hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-Warning: This API is deprecated.
-
-## Parameters
-
-- dst -[in] Destination memory address
-- wOffset -[in] Destination starting X offset
-- hOffset -[in] Destination starting Y offset
-- src -[in] Source memory address
-- count -[in] size in bytes to copy
-- kind -[in] Type of transfer
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpyFromArray ( void *dst, hipArray\_const\_t srcArray, size\_t wOffset, size\_t hOffset, size\_t count, hipMemcpyKind kind )
-
-Copies data between host and device.
-
-## See also:
-
-hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-Warning: This API is deprecated.
-
-## Parameters
-
-- dst -[in] Destination memory address
-- srcArray -[in] Source memory address
-- wOffset -[in] Source starting X offset
-
-- hOffset -[in] Source starting Y offset
-- count -[in] Size in bytes to copy
-- kind -[in] Type of transfer
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpy2DFromArray ( void *dst, size\_t dpitch, hipArray\_const\_t src, size\_t wOffset, size\_t hOffset, size\_t width, size\_t height, hipMemcpyKind kind )
-
-Copies data between host and device.
-
-## See also:
-
-hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-- dst -[in] Destination memory address
-- dpitch -[in] Pitch of destination memory
-- src -[in] Source memory address
-- wOffset -[in] Source starting X offset
-- hOffset -[in] Source starting Y offset
-- width -[in] Width of matrix transfer (columns in bytes)
-- height -[in] Height of matrix transfer (rows)
-- kind -[in] Type of transfer
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpy2DFromArrayAsync ( void *dst, size\_t dpitch, hipArray\_const\_t src, size\_t wOffset, size\_t hOffset, size\_t width, size\_t height, hipMemcpyKind kind, hipStream\_t stream )
-
-Copies data between host and device asynchronously.
-
-## See also:
-
-hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-- dst -[in] Destination memory address
-- dpitch -[in] Pitch of destination memory
-- src -[in] Source memory address
-- wOffset -[in] Source starting X offset
-
-- hOffset -[in] Source starting Y offset
-- width -[in] Width of matrix transfer (columns in bytes)
-- height -[in] Height of matrix transfer (rows)
-- kind -[in] Type of transfer
-- stream -[in] Accelerator view which the copy is being enqueued
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpyAtoH ( void *dst, hipArray\_t srcArray, size\_t srcOffset, size\_t count )
-
-Copies data between host and device.
-
-## See also:
-
-hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-- dst -[in] Destination memory address
-- srcArray -[in] Source array
-- srcOffset -[in] Offset in bytes of source array
-- count -[in] Size of memory copy in bytes
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpyHtoA ( hipArray\_t dstArray, size\_t dstOffset, const void *srcHost, size\_t count )
-
-Copies data between host and device.
-
-## See also:
-
-hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-- dstArray -[in] Destination memory address
-- dstOffset -[in] Offset in bytes of destination array
-- srcHost -[in] Source host pointer
-- count -[in] Size of memory copy in bytes
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection
-
-hipError\_t hipMemcpy3D ( const struct hipMemcpy3DParms *p )
-
-Copies data between host and device.
-
-## See also:
-
-hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-p -[in] 3D memory copy parameters
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpy3DAsync ( const struct hipMemcpy3DParms *p, hipStream\_t stream )
-
-Copies data between host and device asynchronously.
-
-## See also:
-
-hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-- p -[in] 3D memory copy parameters
-- stream -[in] Stream to use
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipDrvMemcpy3D ( const HIP\_MEMCPY3D *pCopy )
-
-Copies data between host and device.
-
-## See also:
-
-hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-pCopy -[in] 3D memory copy parameters
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipDrvMemcpy3DAsync ( const HIP\_MEMCPY3D *pCopy, hipStream\_t stream )
-
-Copies data between host and device asynchronously.
-
-## See also:
-
-hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-- pCopy -[in] 3D memory copy parameters
-- stream -[in] Stream to use
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection template&lt;typename T &gt; hipError\_t hipGetSymbolAddress ( void **devPtr, const T &amp;symbol ) Gets the address of a symbol.
-
-## Parameters
-
-- devPtr -[out] - Returns device pointer associated with symbol.
-- symbol -[in] - Device symbol.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue template&lt;typename T &gt; hipError\_t hipGetSymbolSize ( size\_t *size, const T &amp;symbol ) Gets the size of a symbol.
-
-## Parameters
-
-- size -[out] - Returns the size of a symbol.
-- symbol -[in] - Device symbol address.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue template&lt;typename T &gt;
-
-hipError\_t hipMemcpyToSymbol ( const T &amp;symbol, const void *src, size\_t sizeBytes, size\_t offset, hipMemcpyKind kind )
-
-Copies data to the given symbol on the device.
-
-## See also:
-
-hipMemcpyToSymbol
-
-## Returns
-
-hipSuccess, hipErrorInvalidMemcpyDirection, hipErrorInvalidValue template&lt;typename T &gt;
-
-hipError\_t hipMemcpyToSymbolAsync ( const T &amp;symbol, const void *src, size\_t sizeBytes, size\_t offset, hipMemcpyKind kind, hipStream\_t stream )
-
-Copies data to the given symbol on the device asynchronously on the stream.
-
-## See also:
-
-hipMemcpyToSymbolAsync
-
-## Returns
-
-hipSuccess, hipErrorInvalidMemcpyDirection, hipErrorInvalidValue template&lt;typename T &gt;
-
-hipError\_t hipMemcpyFromSymbol ( void *dst, const T &amp;symbol, size\_t sizeBytes, size\_t offset, hipMemcpyKind kind )
-
-Copies data from the given symbol on the device.
-
-## See also:
-
-hipMemcpyFromSymbol
-
-## Returns
-
-hipSuccess, hipErrorInvalidMemcpyDirection, hipErrorInvalidValue template&lt;typename T &gt;
-
-hipError\_t hipMemcpyFromSymbolAsync ( void *dst, const T &amp;symbol, size\_t sizeBytes, size\_t offset, hipMemcpyKind kind, hipStream\_t stream )
-
-Copies data from the given symbol on the device asynchronously on the stream.
-
-## See also:
-
-hipMemcpyFromSymbolAsync
-
-## Returns
-
-hipSuccess, hipErrorInvalidMemcpyDirection, hipErrorInvalidValue template&lt;class T &gt;
-
-static inline hipError\_t hipMalloc ( T **devPtr, size\_t size )
-
-- : C++ wrapper for hipMalloc
-
-Perform automatic type conversion to eliminate need for excessive typecasting (ie void**)
-
-HIP\_DISABLE\_CPP\_FUNCTIONS macro can be defined to suppress these wrappers. It is useful for applications which need to obtain decltypes of HIP runtime APIs.
-
-## See also:
-
-hipMalloc
-
-## template&lt;class T &gt;
-
-static inline hipError\_t hipHostMalloc ( T **ptr, size\_t size, unsigned int flags = hipHostMallocDefault )
-
-- : C++ wrapper for hipHostMalloc
-
-Provide an override to automatically typecast the pointer type from void**, and also provide a default for the flags.
-
-HIP\_DISABLE\_CPP\_FUNCTIONS macro can be defined to suppress these wrappers. It is useful for applications which need to obtain decltypes of HIP runtime APIs.
-
-## See also:
-
-hipHostMalloc
-
-## 19.23.4 External Resource Interoperability
-
-hipError\_t hipImportExternalSemaphore ( hipExternalSemaphore\_t *extSem\_out, const hipExternalSemaphoreHandleDesc *semHandleDesc )
-
-Imports an external semaphore.
-
-See also:
-
-## Parameters
-
-- extSem\_out -[out] External semaphores to be waited on
-- semHandleDesc -[in] Semaphore import handle descriptor
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError\_t hipSignalExternalSemaphoresAsync ( const hipExternalSemaphore\_t *extSemArray, const hipExternalSemaphoreSignalParams *paramsArray, unsigned int numExtSems, hipStream\_t stream )
-
-Signals a set of external semaphore objects.
-
-## See also:
-
-## Parameters
-
-- extSemArray -[in] External semaphores to be waited on
-- paramsArray -[in] Array of semaphore parameters
-- numExtSems -[in] Number of semaphores to wait on
-- stream -[in] Stream to enqueue the wait operations in
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError\_t hipWaitExternalSemaphoresAsync ( const hipExternalSemaphore\_t *extSemArray, const hipExternalSemaphoreWaitParams *paramsArray, unsigned int numExtSems, hipStream\_t stream )
-
-Waits on a set of external semaphore objects.
-
-See also:
-
-## Parameters
-
-- extSemArray -[in] External semaphores to be waited on
-- paramsArray -[in] Array of semaphore parameters
-- numExtSems -[in] Number of semaphores to wait on
-- stream -[in] Stream to enqueue the wait operations in
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue
-
-## hipError\_t hipDestroyExternalSemaphore ( hipExternalSemaphore\_t extSem )
-
-Destroys an external semaphore object and releases any references to the underlying resource. Any outstanding signals or waits must have completed before the semaphore is destroyed.
-
-## See also:
-
-## Parameters
-
-extSem -[in] handle to an external memory object
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError\_t hipImportExternalMemory ( hipExternalMemory\_t *extMem\_out, const hipExternalMemoryHandleDesc *memHandleDesc )
-
-Imports an external memory object.
-
-## See also:
-
-## Parameters
-
-- extMem\_out -[out] Returned handle to an external memory object
-- memHandleDesc -[in] Memory import handle descriptor
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError\_t hipExternalMemoryGetMappedBuffer ( void **devPtr, hipExternalMemory\_t extMem, const hipExternalMemoryBufferDesc *bufferDesc )
-
-Maps a buffer onto an imported memory object.
-
-## See also:
-
-## Parameters
-
-- devPtr -[out] Returned device pointer to buffer
-- extMem -[in] Handle to external memory object
-- bufferDesc -[in] Buffer descriptor
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue
-
-## hipError\_t hipDestroyExternalMemory ( hipExternalMemory\_t extMem )
-
-Destroys an external memory object.
-
-See also:
-
-## Parameters
-
-extMem -[in] External memory object to be destroyed
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError\_t hipExternalMemoryGetMappedMipmappedArray ( hipMipmappedArray\_t *mipmap,
-
-hipExternalMemory\_t extMem, const hipExternalMemoryMipmappedArrayDesc *mipmapDesc )
-
-Maps a mipmapped array onto an external memory object.
-
-Returned mipmapped array must be freed using hipFreeMipmappedArray.
-
-## See also:
-
-hipImportExternalMemory , hipFreeMipmappedArray
-
-hipDestroyExternalMemory ,
-
-## Parameters
-
-- mipmap -[out] mipmapped array to return
-- extMem -[in] external memory object handle
-- mipmapDesc -[in] external mipmapped array descriptor
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidResourceHandle
-
-## 19.24 Register Keyword
-
-The register keyword is deprecated in C++, and is silently ignored by both NVCC and HIP-Clang. You can pass the option -Wdeprecated-register the compiler warning message.
-
-hipExternalMemoryGetMappedBuffer ,
-
-## 19.25 Pragma Unroll
-
-Unroll with a bounds that is known at compile-time is supported. For example:
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        //                                                                                                                                                                                                        #pragma unroll 16 /* hint to compiler to unroll next loop by 16 */
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        }                                                                                                                                                                                                        /*                                                                                                                                                                                                        */
-                                                                                                                                                                                                     
-		                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       //
-                                                                                                                                                                                                       }
-                                                                                                                                                                                                       */
-```
-
-## 19.26 In-Line Assembly
-
-GCN ISA In-line assembly, is supported. For example:
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <img>void                                                                                                                                                                                                        </img>void
-```
-
-We insert the GCN isa into the kernel using asm() Assembler statement. volatile keyword is used so that the optimizers must not change the number of volatile operations or change their order of execution relative to other volatile operations. v\_mac\_f32\_e32 is the GCN instruction, for more information please refer - [AMD GCN3 ISA architecture manual](http://gpuopen.com/compute-product/amd-gcn3-isa-architecture-manual/) Index for the respective operand in the ordered fashion is provided by % followed by position in the list of operands 'v' is the constraint code (for target-specific AMDGPU) for 32-bit VGPR register, for more info please refer - [Supported Constraint Code List for AMDGPU](https://llvm.org/docs/LangRef.html#supported-constraint-code-list) Output Constraints are specified by an '=' prefix as shown above ('=v'). This indicate that assembly will write to this operand, and the operand will then be made available as a return value of the asm expression. Input constraints do not have a prefix - just the constraint code. The constraint string of '0' says to use the assigned register for output as an input as well (it being the 0'th constraint).
-
-## C++ Support The following C++ features are not supported: - Run-time-type information (RTTI) - Try/catch Virtual functions Virtual functions are not supported if objects containing virtual function tables are passed between GPU's of different offload arch's, e.g. between gfx906 and gfx1030. Otherwise virtual functions are supported.
-
-## 19.27 Kernel Compilation
-
-hipcc now supports compiling C++/HIP kernels to binary code objects. The file format for binary is .co which means Code Object. The following command builds the code object using hipcc .
-
-```
-hipcc --genco --offload-arch=[TARGET GPU] [INPUT FILE] -o [OUTPUT FILE]
-
-[TARGET GPU] = GPU architecture
-[INPUT FILE] = Name of the file containing kernels
-[OUTPUT FILE] = Name of the generated code object file
-```
-
-Note: When using binary code objects is that the number of arguments to the kernel is different on HIP-Clang and NVCC path. Refer to the HIP module\_api sample for differences in the arguments to be passed to the kernel.
-
-## 19.28 gfx-arch-specific-kernel
-
-Clang defined '\_\_gfx*\_\_' macros can be used to execute gfx arch specific codes inside the kernel. Refer to the sample in HIP 14\_gpu\_arch sample.
-
-## CHAPTER
-
-## TWENTY
-
-## C++ LANGUAGE SUPPORT
-
-The ROCm platform enables the power of combined C++ and HIP (Heterogeneous-computing Interface for Portability) code. This code is compiled with a clang or clang++ compiler. The official compilers support the HIP platform, or you can use the amdclang or amdclang++ included in the ROCm installation, which are a wrapper for the official versions.
-
-The source code is compiled according to the C++03 , C++11 , C++14 , C++17 , and C++20 standards, along with HIPspecific extensions, but is subject to restrictions. The key restriction is the reduced support of standard library in device code. This is due to the fact that by default a function is considered to run on host, except for constexpr functions, which can run on host and device as well.
-
-## 20.1 Modern C++ support
-
-C++ is considered a modern programming language as of C++11. This section describes how HIP supports these new C++ features.
-
-## 20.1.1 C++11 support
-
-The C++11 standard introduced many new features. These features are supported in HIP host code, with some notable omissions on the device side. The rule of thumb here is that constexpr functions work on device, the rest doesn't. This means that some important functionality like std::function is missing on the device, but unfortunately the standard library wasn't designed with HIP in mind, which means that the support is in a state of 'works as-is'.
-
-Certain features have restrictions and clarifications. For example, any functions using the constexpr qualifier or the new initializer lists , std::move or std::forward features are implicitly considered to have the \_\_host\_\_ and \_\_device\_\_ execution space specifier. Also, constexpr variables that are static members or namespace scoped can be used from both host and device, but only for read access. Dereferencing a static constexpr outside its specified execution space causes an error.
-
-Lambdas are supported, but there are some extensions and restrictions on their usage. For more information, see the Extended lambdas section below.
-
-## 20.1.2 C++14 support
-
-The C++14 language features are supported.
-
-## 20.1.3 C++17 support
-
-All C++17 language features are supported.
-
-## 20.1.4 C++20 support
-
-All C++20 language features are supported, but extensions and restrictions apply. C++20 introduced coroutines and modules, which fundamentally changed how programs are written. HIP doesn't support these features. However, consteval functions can be called from host and device, even if specified for host use only.
-
-The three-way comparison operator (spaceship operator &lt;=&gt; ) works with host and device code.
-
-## 20.2 Extensions and restrictions
-
-In addition to the deviations from the standard, there are some general extensions and restrictions to consider.
-
-## 20.2.1 Global functions
-
-Functions that serve as an entry point for device execution are called kernels and are specified with the \_\_global\_\_ qualifier. To call a kernel function, use the triple chevron operator: &lt;&lt;&lt; &gt;&gt;&gt; . Kernel functions must have a void return type. These functions can't:
-
-- have a constexpr specifier
-- have a parameter of type std::initializer\_list or va\_list
-- use an rvalue reference as a parameter.
-- use parameters having different sizes in host and device code, e.g. long double arguments, or structs containing long double members.
-- use struct-type arguments which have different layout in host and device code.
-
-Kernels can have variadic template parameters, but only one parameter pack, which must be the last item in the template parameter list.
-
-## 20.2.2 Device space memory specifiers
-
-HIP includes device space memory specifiers to indicate whether a variable is allocated in host or device memory and howits memory should be allocated. HIP supports the \_\_device\_\_ , \_\_shared\_\_ , \_\_managed\_\_ , and \_\_constant\_\_ specifiers.
-
-The \_\_device\_\_ and \_\_constant\_\_ specifiers define global variables, which are allocated within global memory on the HIP devices. The only difference is that \_\_constant\_\_ variables can't be changed after allocation. The \_\_shared\_\_ specifier allocates the variable within shared memory, which is available for all threads in a block.
-
-The \_\_managed\_\_ variable specifier creates global variables that are initially undefined and unaddressed within the global symbol table. The HIP runtime allocates managed memory and defines the symbol when it loads the device binary. A managed variable can be accessed in both device and host code.
-
-It's important to know where a variable is stored because it is only available from certain locations. Generally, variables allocated in the host memory are not accessible from the device code, while variables allocated in the device memory are not directly accessible from the host code. Dereferencing a pointer to device memory on the host results in a segmentation fault. Accessing device variables in host code should be done through kernel execution or HIP functions like hipMemCpyToSymbol .
-
-## 20.2.3 Exception handling
-
-An important difference between the host and device code is exception handling. In device code, this control flow isn't available due to the hardware architecture. The device code must use return codes to handle errors.
-
-## 20.2.4 Kernel parameters
-
-There are some restrictions on kernel function parameters. They cannot be passed by reference, because these functions are called from the host but run on the device. Also, a variable number of arguments is not allowed.
-
-## 20.2.5 Classes
-
-Classes work on both the host and device side, but there are some constraints. The static member functions can't be \_\_global\_\_ . Virtual member functions work, but a virtual function must not be called from the host if the parent object was created on the device, or the other way around, because this behavior is undefined. Another minor restriction is that \_\_device\_\_ variables, that are global scoped must have trivial constructors.
-
-## 20.2.6 Polymorphic function wrappers
-
-HIP doesn't support the polymorphic function wrapper std::function , which was introduced in C++11.
-
-## 20.2.7 Extended lambdas
-
-HIP supports Lambdas, which by default work as expected.
-
-Lambdas have implicit host device attributes. This means that they can be executed by both host and device code, and works the way you would expect. To make a lambda callable only by host or device code, users can add \_\_host\_\_ or \_\_device\_\_ attribute. The only restriction is that host variables can only be accessed through copy on the device. Accessing through reference will cause undefined behavior.
-
-## 20.2.8 Inline namespaces
-
-Inline namespaces are supported, but with a few exceptions. The following entities can't be declared in namespace scope within an inline unnamed namespace:
-
-- \_\_managed\_\_ , \_\_device\_\_ , \_\_shared\_\_ and \_\_constant\_\_ variables
-- \_\_global\_\_ function and function templates
-- variables with surface or texture type
-
-## CHAPTER
-
-## TWENTYONE
-
-## HIP MATH API
-
-HIP-Clang supports a set of math operations that are callable from the device. HIP supports most of the device functions supported by NVIDIA CUDA. These are described in the following sections.
-
-## 21.1 Single precision mathematical functions
-
-Following is the list of supported single precision mathematical functions.
-
-Table 1: Single precision mathematical functions
-
-| Function                                                                   | Supported on Host   | Supported on Device   |
-|----------------------------------------------------------------------------|---------------------|-----------------------|
-| float abs(float x) Returns the absolute value of 𝑥                         | ✓                   | ✓                     |
-| float acosf(float x) Returns the arc cosine of 𝑥 .                         | ✓                   | ✓                     |
-| float acoshf(float x) Returns the nonnegative arc hyperbolic cosine of 𝑥 . | ✓                   | ✓                     |
-| float asinf(float x) Returns the arc sine of 𝑥 .                           | ✓                   | ✓                     |
-| float asinhf(float x) Returns the arc hyperbolic sine of 𝑥 .               | ✓                   | ✓                     |
-| float atanf(float x) Returns the arc tangent of 𝑥 .                        | ✓                   | ✓                     |
-
-continues on next page
-
-|                                                                                                                        | Table   | 1 - continued from previous page   |
-|------------------------------------------------------------------------------------------------------------------------|---------|------------------------------------|
-| float atan2f(float x, float y) Returns the arc tangent of the ratio of 𝑥 and 𝑦 .                                       | ✓       | ✓                                  |
-| float atanhf(float x) Returns the arc hyperbolic tangent of 𝑥 .                                                        | ✓       | ✓                                  |
-| float cbrtf(float x) Returns the cube root of 𝑥 .                                                                      | ✓       | ✓                                  |
-| float ceilf(float x) Returns ceiling of 𝑥 .                                                                            | ✓       | ✓                                  |
-| float copysignf(float x, float y) Create value with given magnitude, copying sign of second value.                     | ✓       | ✓                                  |
-| float cosf(float x) Returns the cosine of 𝑥 .                                                                          | ✓       | ✓                                  |
-| float coshf(float x) Returns the hyperbolic cosine of 𝑥 .                                                              | ✓       | ✓                                  |
-| float cospif(float x) Returns the cosine of 𝜋 · 𝑥 .                                                                    | ✓       | ✓                                  |
-| float cyl_bessel_i0f(float x) Returns the value of the regular modified cylindrical Bessel function of order 0 for 𝑥 . |         |                                    |
-
-continues on next page
-
-Table 1 - continued from previous page
-
-| float cyl_bessel_i1f(float x) Returns the value of the regular modified cylindrical Bessel function of order 1 for 𝑥 .   |    |    |
-|--------------------------------------------------------------------------------------------------------------------------|----|----|
-| float erff(float x) Returns the error function of 𝑥 .                                                                    | ✓  | ✓  |
-| float erfcf(float x) Returns the complementary error function of 𝑥 .                                                     | ✓  | ✓  |
-| float erfcinvf(float x) Returns the inverse complementary function of 𝑥 .                                                | ✓  | ✓  |
-| float erfcxf(float x) Returns the scaled complementary error function of 𝑥 .                                             | ✓  | ✓  |
-| float erfinvf(float x) Returns the inverse error function of 𝑥 .                                                         | ✓  | ✓  |
-| float expf(float x) Returns 𝑒 𝑥 .                                                                                        | ✓  | ✓  |
-| float exp10f(float x) Returns 10 𝑥 .                                                                                     | ✓  | ✓  |
-| float exp2f( float x) Returns 2 𝑥 .                                                                                      | ✓  | ✓  |
-| float expm1f(float x) Returns 𝑙𝑛 ( 𝑥 - 1)                                                                                | ✓  | ✓  |
-
-continues on next page
-
-Table
-
-1 - continued from previous page
-
-| float fabsf(float x) Returns the absolute value of x                               | ✓   | ✓   |
-|------------------------------------------------------------------------------------|-----|-----|
-| float fdimf(float x, float y) Returns the positive difference between 𝑥 and 𝑦 .    | ✓   | ✓   |
-| float fdividef(float x, float y) Divide two floating point values.                 | ✓   | ✓   |
-| float floorf(float x) Returns the largest integer less than or equal to 𝑥 .        | ✓   | ✓   |
-| float fmaf(float x, float y, float z) Returns 𝑥 · 𝑦 + 𝑧 as a single operation.     | ✓   | ✓   |
-| float fmaxf(float x, float y) Determine the maximum numeric value of 𝑥 and 𝑦 .     | ✓   | ✓   |
-| float fminf(float x, float y) Determine the minimum numeric value of 𝑥 and 𝑦 .     | ✓   | ✓   |
-| float fmodf(float x, float y) Returns the floating-point remainder of 𝑥/𝑦 .        | ✓   | ✓   |
-| float modff(float x, float* iptr) Break down 𝑥 into fractional and integral parts. | ✓   |     |
-
-continues on next page
-
-Table 1 - continued from previous page
-
-| float frexpf(float x, int* nptr) Extract mantissa and exponent of 𝑥 .                                   | ✓   |
-|---------------------------------------------------------------------------------------------------------|-----|
-| float hypotf(float x, float y) Returns the square root of the sum of squares of 𝑥 and 𝑦 .               | ✓   |
-| int ilogbf(float x) Returns the unbiased integer exponent of 𝑥 .                                        | ✓   |
-| bool isfinite(float x) Determine whether 𝑥 is finite.                                                   | ✓   |
-| bool isinf(float x) Determine whether 𝑥 is infinite.                                                    | ✓   |
-| bool isnan(float x) Determine whether 𝑥 is a NAN .                                                      | ✓   |
-| float j0f(float x) Returns the value of the Bessel function of the first kind of order 0 for 𝑥 .        | ✓   |
-| float j1f(float x) Returns the value of the Bessel function of the first kind of order 1 for 𝑥 .        | ✓   |
-| float jnf(int n, float x) Returns the value of the Bessel function of the first kind of order n for 𝑥 . | ✓   |
-
-continues on next page
-
-Table
-
-1 - continued from previous page
-
-| float ldexpf(float x, int exp) Returns the natural logarithm of the absolute value of the gamma function of 𝑥 .   | ✓   | ✓   |
-|-------------------------------------------------------------------------------------------------------------------|-----|-----|
-| float lgammaf(float x) Returns the natural logarithm of the absolute value of the gamma function of 𝑥 .           | ✓   |     |
-| long int lrintf(float x) Round 𝑥 to nearest integer value.                                                        | ✓   | ✓   |
-| long long int llrintf(float x) Round 𝑥 to nearest integer value.                                                  | ✓   | ✓   |
-| long int lroundf(float x) Round to nearest integer value.                                                         | ✓   | ✓   |
-| long long int llroundf(float x) Round to nearest integer value.                                                   | ✓   | ✓   |
-| float log10f(float x) Returns the base 10 logarithm of 𝑥 .                                                        | ✓   | ✓   |
-| float log1pf(float x) Returns the natural logarithm of 𝑥 +1 .                                                     | ✓   | ✓   |
-| float log2f(float x) Returns the base 2 logarithm of 𝑥 .                                                          | ✓   | ✓   |
-| float logf(float x) Returns the natural logarithm of 𝑥 .                                                          | ✓   | ✓   |
-
-continues on next page
-
-Table 1 - continued from previous page
-
-|                                                                                                                      |    | ✓   |
-|----------------------------------------------------------------------------------------------------------------------|----|-----|
-| float logbf(float x) Returns the floating point representation of the exponent of 𝑥 .                                | ✓  |     |
-| float nanf(const char* tagp) Returns 'Not a Number' value.                                                           |    | ✓   |
-| float nearbyintf(float x) Round 𝑥 to the nearest integer.                                                            | ✓  | ✓   |
-| float nextafterf(float x, float y) Returns next representable single-precision floating-point value after argument.  | ✓  |     |
-| float norm3df(float x, float y, float z) Returns the square root of the sum of squares of 𝑥 , 𝑦 and 𝑧 .              | ✓  | ✓   |
-| float norm4df(float x, float y, float z, float w) Returns the square root of the sum of squares of 𝑥 , 𝑦 , 𝑧 and 𝑤 . | ✓  | ✓   |
-| float normcdff(float y) Returns the standard normal cumulative distribution function.                                | ✓  | ✓   |
-| float normcdfinvf(float y) Returns the inverse of the standard normal cumulative distribution function.              | ✓  | ✓   |
-| float normf(int dim, const float *a) Returns the square root of the sum of squares of any number of coordinates.     | ✓  | ✓   |
-
-continues on next page
-
-|                                                                                                                   | Table   | 1 - continued from previous page   |
-|-------------------------------------------------------------------------------------------------------------------|---------|------------------------------------|
-| float powf(float x, float y) Returns 𝑥 𝑦 .                                                                        | ✓       | ✓                                  |
-| float powif(float base, int iexp) Returns the value of first argument to the power of second argument.            | ✓       | ✓                                  |
-| float remainderf(float x, float y) Returns single-precision floating-point remainder.                             | ✓       | ✓                                  |
-| float remquof(float x, float y, int* quo) Returns single-precision floating-point remainder and part of quotient. | ✓       | ✓                                  |
-| float roundf(float x) Round to nearest integer value in floating-point.                                           | ✓       | ✓                                  |
-| float rcbrtf(float x) Returns the reciprocal cube root function.                                                  | ✓       | ✓                                  |
-| float rhypotf(float x, float y) Returns one over the square root of the sum of squares of two arguments.          | ✓       | ✓                                  |
-| float rintf(float x) Round input to nearest integer value in floating-point.                                      | ✓       | ✓                                  |
-
-continues on next page
-
-Table
-
-1 - continued from previous page
-
-| float rnorm3df(float x, float y, float z) Returns one over the square root of the sum of squares of three coordinates of the argument.         | ✓   | ✓   |
-|------------------------------------------------------------------------------------------------------------------------------------------------|-----|-----|
-| float rnorm4df(float x, float y, float z, float w) Returns one over the square root of the sum of squares of four coordinates of the argument. | ✓   | ✓   |
-| float rnormf(int dim, const float *a) Returns the reciprocal of square root of the sum of squares of any number of coordinates.                | ✓   | ✓   |
-| float scalblnf(float x, long int n) Scale 𝑥 by 2 𝑛 .                                                                                           | ✓   | ✓   |
-| float scalbnf(float x, int n) Scale 𝑥 by 2 𝑛 .                                                                                                 | ✓   | ✓   |
-| bool signbit(float x) Return the sign bit of 𝑥 .                                                                                               | ✓   | ✓   |
-| float sinf(float x) Returns the sine of 𝑥 .                                                                                                    | ✓   | ✓   |
-| float sinhf(float x) Returns the hyperbolic sine of 𝑥 .                                                                                        | ✓   | ✓   |
-| float sinpif(float x) Returns the hyperbolic sine of 𝜋 · 𝑥 .                                                                                   | ✓   | ✓   |
-
-continues on next page
-
-Table
-
-1 - continued from previous page
-
-| void sincosf(float x, float *sptr, float *cptr) Returns the sine and cosine of 𝑥 .                | ✓   | ✓   |
-|---------------------------------------------------------------------------------------------------|-----|-----|
-| void sincospif(float x, float *sptr, float *cptr) Returns the sine and cosine of 𝜋 · 𝑥 .          | ✓   | ✓   |
-| float sqrtf(float x) Returns the square root of 𝑥 .                                               | ✓   | ✓   |
-| float rsqrtf(float x) Returns the reciprocal of the square root of 𝑥 .                            |     | ✓   |
-| float tanf(float x) Returns the tangent of 𝑥 .                                                    | ✓   | ✓   |
-| float tanhf(float x) Returns the hyperbolic tangent of 𝑥 .                                        | ✓   | ✓   |
-| float tgammaf(float x) Returns the gamma function of 𝑥 .                                          | ✓   | ✓   |
-| float truncf(float x) Truncate 𝑥 to the integral part.                                            | ✓   | ✓   |
-| float y0f(float x) Returns the value of the Bessel function of the second kind of order 0 for 𝑥 . | ✓   | ✓   |
-| float y1f(float x) Returns the value of the Bessel function of the second kind of order 1 for 𝑥 . | ✓   | ✓   |
-
-continues on next page
-
-```
-                                                                                                                                                                                                        \
-    float  ynf(int  n,  float  x)
-    Returns the value of the Bessel
-    function of the second kind of order
-    n for x.
-```
-
-Table 1 - continued from previous page
-
-## 21.2 Double precision mathematical functions
-
-Following is the list of supported double precision mathematical functions.
-
-Table 2: Double precision mathematical functions
-
-| Function                                                                           | Supported on Host   | Supported on Device   |
-|------------------------------------------------------------------------------------|---------------------|-----------------------|
-| double abs(double x) Returns the absolute value of 𝑥                               | ✓                   | ✓                     |
-| double acos(double x) Returns the arc cosine of 𝑥 .                                | ✓                   | ✓                     |
-| double acosh(double x) Returns the nonnegative arc hyperbolic cosine of 𝑥 .        | ✓                   | ✓                     |
-| double asin(double x) Returns the arc sine of 𝑥 .                                  | ✓                   | ✓                     |
-| double asinh(double x) Returns the arc hyperbolic sine of 𝑥 .                      | ✓                   | ✓                     |
-| double atan(double x) Returns the arc tangent of 𝑥 .                               | ✓                   | ✓                     |
-| double atan2(double x, double y) Returns the arc tangent of the ratio of 𝑥 and 𝑦 . | ✓                   | ✓                     |
-
-continues on next page
-
-Table 2 - continued from previous page
-
-| double atanh(double x) Returns the arc hyperbolic tangent of 𝑥 .                                                        | ✓   | ✓   |
-|-------------------------------------------------------------------------------------------------------------------------|-----|-----|
-| double cbrt(double x) Returns the cube root of 𝑥 .                                                                      | ✓   | ✓   |
-| double ceil(double x) Returns ceiling of 𝑥 .                                                                            | ✓   | ✓   |
-| double copysign(double x, double y) Create value with given magnitude, copying sign of second value.                    | ✓   | ✓   |
-| double cos(double x) Returns the cosine of 𝑥 .                                                                          | ✓   | ✓   |
-| double cosh(double x) Returns the hyperbolic cosine of 𝑥 .                                                              | ✓   | ✓   |
-| double cospi(double x) Returns the cosine of 𝜋 · 𝑥 .                                                                    | ✓   | ✓   |
-| double cyl_bessel_i0(double x) Returns the value of the regular modified cylindrical Bessel function of order 0 for 𝑥 . |     |     |
-| double cyl_bessel_i1(double x) Returns the value of the regular modified cylindrical Bessel function of order 1 for     | 𝑥 . |     |
-| double erf(double x) Returns the error function of 𝑥 .                                                                  | ✓   | ✓   |
-
-continues on next page
-
-Table 2 - continued from previous page
-
-| double erfc(double x) Returns the complementary error function of 𝑥 .             | ✓   | ✓   |
-|-----------------------------------------------------------------------------------|-----|-----|
-| double erfcinv(double x) Returns the inverse complementary function of 𝑥 .        | ✓   | ✓   |
-| double erfcx(double x) Returns the scaled complementary error function of 𝑥 .     | ✓   | ✓   |
-| double erfinv(double x) Returns the inverse error function of 𝑥 .                 | ✓   | ✓   |
-| double exp(double x) Returns 𝑒 𝑥 .                                                | ✓   | ✓   |
-| double exp10(double x) Returns 10 𝑥 .                                             | ✓   | ✓   |
-| double exp2( double x) Returns 2 𝑥 .                                              | ✓   | ✓   |
-| double expm1(double x) Returns 𝑙𝑛 ( 𝑥 - 1)                                        | ✓   | ✓   |
-| double fabs(double x) Returns the absolute value of x                             | ✓   | ✓   |
-| double fdim(double x, double y) Returns the positive difference between 𝑥 and 𝑦 . | ✓   | ✓   |
-
-continues on next page
-
-Table 2 - continued from previous page
-
-| double floor(double x) Returns the largest integer less than or equal to 𝑥 .                | ✓   | ✓   |
-|---------------------------------------------------------------------------------------------|-----|-----|
-| double fma(double x, double y, double z) Returns 𝑥 · 𝑦 + 𝑧 as a single operation.           | ✓   | ✓   |
-| double fmax(double x, double y) Determine the maximum numeric value of 𝑥 and 𝑦 .            | ✓   | ✓   |
-| double fmin(double x, double y) Determine the minimum numeric value of 𝑥 and 𝑦 .            | ✓   | ✓   |
-| double fmod(double x, double y) Returns the floating-point remainder of 𝑥/𝑦 .               | ✓   | ✓   |
-| double modf(double x, double* iptr) Break down 𝑥 into fractional and integral parts.        | ✓   |     |
-| double frexp(double x, int* nptr) Extract mantissa and exponent of 𝑥 .                      | ✓   |     |
-| double hypot(double x, double y) Returns the square root of the sum of squares of 𝑥 and 𝑦 . | ✓   | ✓   |
-| int ilogb(double x) Returns the unbiased integer exponent of 𝑥 .                            | ✓   | ✓   |
-
-continues on next page
-
-Table 2 - continued from previous page
-
-| bool isfinite(double x) Determine whether 𝑥 is finite.                                                           | ✓   | ✓   |
-|------------------------------------------------------------------------------------------------------------------|-----|-----|
-| bool isin(double x) Determine whether 𝑥 is infinite.                                                             | ✓   | ✓   |
-| bool isnan(double x) Determine whether 𝑥 is a NAN .                                                              | ✓   | ✓   |
-| double j0(double x) Returns the value of the Bessel function of the first kind of order 0 for 𝑥 .                | ✓   | ✓   |
-| double j1(double x) Returns the value of the Bessel function of the first kind of order 1 for 𝑥 .                | ✓   | ✓   |
-| double jn(int n, double x) Returns the value of the Bessel function of the first kind of order n for 𝑥 .         | ✓   | ✓   |
-| double ldexp(double x, int exp) Returns the natural logarithm of the absolute value of the gamma function of 𝑥 . | ✓   | ✓   |
-| double lgamma(double x) Returns the natural logarithm of the absolute value of the gamma function of 𝑥 .         | ✓   |     |
-| long int lrint(double x) Round 𝑥 to nearest integer value.                                                       | ✓   | ✓   |
-
-continues on next page
-
-Table 2 - continued from previous page
-
-| long long int llrint(double x) Round 𝑥 to nearest integer value.                       | ✓   | ✓   |
-|----------------------------------------------------------------------------------------|-----|-----|
-| long int lround(double x) Round to nearest integer value.                              | ✓   | ✓   |
-| long long int llround(double x) Round to nearest integer value.                        | ✓   | ✓   |
-| double log10(double x) Returns the base 10 logarithm of 𝑥 .                            | ✓   | ✓   |
-| double log1p(double x) Returns the natural logarithm of 𝑥 +1 .                         | ✓   | ✓   |
-| double log2(double x) Returns the base 2 logarithm of 𝑥 .                              | ✓   | ✓   |
-| double log(double x) Returns the natural logarithm of 𝑥 .                              | ✓   | ✓   |
-| double logb(double x) Returns the floating point representation of the exponent of 𝑥 . | ✓   | ✓   |
-| double nan(const char* tagp) Returns 'Not a Number' value.                             |     | ✓   |
-| double nearbyint(double x) Round 𝑥 to the nearest integer.                             | ✓   | ✓   |
-
-continues on next page
-
-Table 2 - continued from previous page
-
-|                                                                                                                          |    | ✓   |
-|--------------------------------------------------------------------------------------------------------------------------|----|-----|
-| double nextafter(double x, double y) Returns next representable double-precision floating-point value after argument.    | ✓  |     |
-| double norm3d(double x, double y, double z) Returns the square root of the sum of squares of 𝑥 , 𝑦 and 𝑧 .               | ✓  | ✓   |
-| double norm4d(double x, double y, double z, double w) Returns the square root of the sum of squares of 𝑥 , 𝑦 , 𝑧 and 𝑤 . | ✓  | ✓   |
-| double normcdf(double y) Returns the standard normal cumulative distribution function.                                   | ✓  | ✓   |
-| double normcdfinv(double y) Returns the inverse of the standard normal cumulative distribution function.                 | ✓  | ✓   |
-| double norm(int dim, const double *a) Returns the square root of the sum of squares of any number of coordinates.        | ✓  | ✓   |
-| double pow(double x, double y) Returns 𝑥 𝑦 .                                                                             | ✓  | ✓   |
-| double powi(double base, int iexp) Returns the value of first argument to the power of second argument.                  | ✓  | ✓   |
-
-continues on next page
-
-|                                                                                                                                                    | Table   | 2 - continued from previous page   |
-|----------------------------------------------------------------------------------------------------------------------------------------------------|---------|------------------------------------|
-| double remainder(double x, double y) Returns double-precision floating-point remainder.                                                            | ✓       | ✓                                  |
-| double remquo(double x, double y, int* quo) Returns double-precision floating-point remainder and part quotient.                                   | ✓       | of                                 |
-| double round(double x) Round to nearest integer value in floating-point.                                                                           | ✓       | ✓                                  |
-| double rcbrt(double x) Returns the reciprocal cube root function.                                                                                  | ✓       | ✓                                  |
-| double rhypot(double x, double y) Returns one over the square root of the sum of squares of two arguments.                                         | ✓       | ✓                                  |
-| double rint(double x) Round input to nearest integer value in floating-point.                                                                      | ✓       | ✓                                  |
-| double rnorm3d(double x, double y, double z) Returns one over the square root of the sum of squares of three coordinates of the argument.          | ✓       | ✓                                  |
-| double rnorm4d(double x, double y, double z, double w) Returns one over the square root of the sum of squares of four coordinates of the argument. | ✓       | ✓                                  |
-
-continues on next page
-
-Table 2 - continued from previous page
-
-|                                                                                                                                  | ✓   |    |
-|----------------------------------------------------------------------------------------------------------------------------------|-----|----|
-| double rnorm(int dim, const double *a) Returns the reciprocal of square root of the sum of squares of any number of coordinates. |     | ✓  |
-| double scalbln(double x, long int n) Scale 𝑥 by 2 𝑛 .                                                                            | ✓   | ✓  |
-| double scalbn(double x, int n) Scale 𝑥 by 2 𝑛 .                                                                                  | ✓   | ✓  |
-| bool signbit(double x) Return the sign bit of 𝑥 .                                                                                | ✓   | ✓  |
-| double sin(double x) Returns the sine of 𝑥 .                                                                                     | ✓   | ✓  |
-| double sinh(double x) Returns the hyperbolic sine of 𝑥 .                                                                         | ✓   | ✓  |
-| double sinpi(double x) Returns the hyperbolic sine of 𝜋 · 𝑥 .                                                                    | ✓   | ✓  |
-| void sincos(double x, double *sptr, double *cptr) Returns the sine and cosine of 𝑥 .                                             | ✓   | ✓  |
-| void sincospi(double x, double *sptr, double *cptr) Returns the sine and cosine of 𝜋 · 𝑥 .                                       | ✓   | ✓  |
-| double sqrt(double x) Returns the square root of 𝑥 .                                                                             | ✓   | ✓  |
-
-continues on next page
-
-Table 2 - continued from previous page
-
-| double rsqrt(double x) Returns the reciprocal of the square root of 𝑥 .                                   | ✓   |
-|-----------------------------------------------------------------------------------------------------------|-----|
-| double tan(double x) Returns the tangent of 𝑥 .                                                           | ✓   |
-| double tanh(double x) Returns the hyperbolic tangent of 𝑥 .                                               | ✓   |
-| double tgamma(double x) Returns the gamma function of 𝑥 .                                                 | ✓   |
-| double trunc(double x) Truncate 𝑥 to the integral part.                                                   | ✓   |
-| double y0(double x) Returns the value of the Bessel function of the second kind of order 0 for 𝑥 .        | ✓   |
-| double y1(double x) Returns the value of the Bessel function of the second kind of order 1 for 𝑥 .        | ✓   |
-| double yn(int n, double x) Returns the value of the Bessel function of the second kind of order n for 𝑥 . | ✓   |
-
-## 21.3 Integer intrinsics
-
-Following is the list of supported integer intrinsics. Note that intrinsics are supported on device only.
-
-Table 3: Integer intrinsics mathematical functions
-
-## Function
-
-unsigned int \_\_brev(unsigned int x) Reverse the bit order of a 32 bit unsigned integer.
-
-unsigned long long int \_\_brevll(unsigned long long int x) Reverse the bit order of a 64 bit unsigned integer.
-
-unsigned int \_\_byte\_perm(unsigned int x, unsigned int y, unsigned int z) Return selected bytes from two 32-bit unsigned integers.
-
-unsigned int \_\_clz(int x) Return the number of consecutive high-order zero bits in 32 bit integer.
-
-unsigned int \_\_clzll(long long int x) Return the number of consecutive high-order zero bits in 64 bit integer.
-
-unsigned int \_\_ffs(int x) Find the position of least significant bit set to 1 in a 32 bit integer.
-
-unsigned int \_\_ffsll(long long int x) Find the position of least significant bit set to 1 in a 64 bit signed integer.
-
-unsigned int \_\_fns32(unsigned long long mask, unsigned int base, int offset) Find the position of the n-th set to 1 bit in a 32-bit integer.
-
-unsigned int \_\_fns64(unsigned long long int mask, unsigned int base, int offset) Find the position of the n-th set to 1 bit in a 64-bit integer.
-
-unsigned int \_\_funnelshift\_l(unsigned int lo, unsigned int hi, unsigned int shift) Concatenate ℎ𝑖 and 𝑙𝑜 , shift left by shift &amp; 31 bits, return the most significant 32 bits.
-
-unsigned int \_\_funnelshift\_lc(unsigned int lo, unsigned int hi, unsigned int shift) Concatenate ℎ𝑖 and 𝑙𝑜 , shift left by min(shift, 32) bits, return the most significant 32 bits.
-
-unsigned int \_\_funnelshift\_r(unsigned int lo, unsigned int hi, unsigned int shift) Concatenate ℎ𝑖 and 𝑙𝑜 , shift right by shift &amp; 31 bits, return the least significant 32 bits. 226 Chapter 21. HIP math API
-
-The HIP-Clang implementation of \_\_ffs() and \_\_ffsll() contains code to add a constant +1 to produce the ffs result format. For the cases where this overhead is not acceptable and programmer is willing to specialize for the platform, HIP-Clang provides \_\_lastbit\_u32\_u32(unsigned int input) and \_\_lastbit\_u32\_u64(unsigned long long int input) . The index returned by \_\_lastbit\_ instructions starts at -1, while for ffs the index starts at 0.
-
-## 21.4 Floating-point Intrinsics
-
-Following is the list of supported floating-point intrinsics. Note that intrinsics are supported on device only.
-
-Note: Only the nearest even rounding mode supported on AMD GPUs by defaults. The \_rz , \_ru and \_rd suffixed intrinsic functions are existing in HIP AMD backend, if the OCML\_BASIC\_ROUNDED\_OPERATIONS macro is defined.
-
-Table 4: Single precision intrinsics mathematical functions
-
-Function float \_\_cosf(float x) Returns the fast approximate cosine of 𝑥 . float \_\_exp10f(float x) Returns the fast approximate for 10 x . float \_\_expf(float x) Returns the fast approximate for e x . float \_\_fadd\_rn(float x, float y) Add two floating-point values in round-to-nearest-even mode. float \_\_fdiv\_rn(float x, float y) Divide two floating point values in round-to-nearest-even mode. float \_\_fmaf\_rn(float x, float y, float z) Returns x × y + z as a single operation in round-to-nearest-even mode. float \_\_fmul\_rn(float x, float y) Multiply two floating-point values in round-to-nearest-even mode. float \_\_frcp\_rn(float x, float y) Returns 1 / x in round-to-nearest-even mode. float \_\_frsqrt\_rn(float x) Returns 1 / x in round-to-nearest-even mode. float \_\_fsqrt\_rn(float x) Returns x in round-to-nearest-even mode. float \_\_fsub\_rn(float x, float y) Subtract two floating-point values in round-to-nearest-even mode. float \_\_log10f(float x) Returns the fast approximate for base 10 logarithm of 𝑥 . 228 Chapter 21. HIP math API
-
-Table 5: Double precision intrinsics mathematical functions
-
-Function double \_\_dadd\_rn(double x, double y) Add two floating-point values in round-to-nearest-even mode. double \_\_ddiv\_rn(double x, double y) Divide two floating-point values in round-to-nearest-even mode. double \_\_dmul\_rn(double x, double y) Multiply two floating-point values in round-to-nearest-even mode. double \_\_drcp\_rn(double x, double y) Returns 1 / x in round-to-nearest-even mode. double \_\_dsqrt\_rn(double x) Returns x in round-to-nearest-even mode. double \_\_dsub\_rn(double x, double y) Subtract two floating-point values in round-to-nearest-even mode. double \_\_fma\_rn(double x, double y, double z) Returns x × y + z as a single operation in round-to-nearest-even mode.
-
-## CHAPTER
-
-## TWENTYTWO
-
-## TABLE COMPARING SYNTAX FOR DIFFERENT COMPUTE APIS
-
-| Term                   | CUDA                | HIP                                        | OpenCL                 |
-|------------------------|---------------------|--------------------------------------------|------------------------|
-| Device                 | int deviceId        | int deviceId                               | cl_device              |
-| Queue                  | cudaStream_t        | hipStream_t                                | cl_command_queue       |
-| Event                  | cudaEvent_t         | hipEvent_t                                 | cl_event               |
-| Memory                 | void *              | void *                                     | cl_mem                 |
-|                        | grid                | grid                                       | NDRange                |
-|                        | block               | block                                      | work-group             |
-|                        | thread              | thread                                     | work-item              |
-|                        | warp                | warp                                       | sub-group              |
-| Thread-index           | threadIdx.x         | threadIdx.x                                | get_local_id(0)        |
-| Block-index            | blockIdx.x          | blockIdx.x                                 | get_group_id(0)        |
-| Block-dim              | blockDim.x          | blockDim.x                                 | get_local_size(0)      |
-| Grid-dim               | gridDim.x           | gridDim.x                                  | get_num_groups(0)      |
-| Device Kernel          | __global__          | __global__                                 | __kernel               |
-| Device Function        | __device__          | __device__                                 | Implied in device com  |
-| Host Function          | __host_ (default)   | __host_ (default)                          | Implied in host compil |
-| Host + Device Function | __host__ __device__ | __host__ __device__                        | No equivalent          |
-| Kernel Launch          | <<< >>>             | hipLaunchKernel / hipLaunchKernelGGL / <<< | clEnqueueNDRangeK      |
-| Global Memory          | __global__          | __global__                                 | __global               |
-| Group Memory           | __shared__          | __shared__                                 | __local                |
-| Constant               | __constant__        | __constant__                               | __constant             |
-|                        | __syncthreads       | __syncthreads                              | barrier(CLK_LOCAL      |
-| Atomic Builtins        | atomicAdd           | atomicAdd                                  | atomic_add             |
-| Precise Math           | cos(f)              | cos(f)                                     | cos(f)                 |
-| Fast Math              | __cos(f)            | __cos(f)                                   | native_cos(f)          |
-| Vector                 | float4              | float4                                     | float4                 |
-
-## 22.1 Notes
-
-The indexing functions (starting with thread-index ) show the terminology for a 1D grid. Some APIs use reverse order of xyz / 012 indexing for 3D grids.
-
-## CHAPTER
-
-## TWENTYTHREE
-
-## HIP COOPERATIVE GROUPS API
-
-## 23.1 Cooperative kernel launches
-
-The following host-side functions are used for cooperative kernel launches.
-
-| Warning:                                                                                    | Warning:                                                                                    | doxygenfunction:                                                                            | doxygenfunction:                                                                            | doxygenfunction:                                                                            | Cannot                                                                                      | find function                                                                               | 'hipLaunchCooperativeKernel' Documentation'                                                 | 'hipLaunchCooperativeKernel' Documentation'                                                 |                                                                                             |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
-| in                                                                                          | doxygen                                                                                     | xml                                                                                         | output                                                                                      | for project                                                                                 | 'HIP                                                                                        | 6.1.40092                                                                                   | from                                                                                        | directory:                                                                                  |                                                                                             |
-| /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- |
-| 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      |
-
-| Warning:                                                                                    | Warning:                                                                                    | doxygenfunction: project                                                                    | doxygenfunction: project                                                                    | doxygenfunction: project                                                                    | Cannot                                                                                      | Cannot                                                                                      | find function                                                                               | 'hipLaunchCooperativeKernel'                                                                | 'hipLaunchCooperativeKernel'                                                                |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
-| in                                                                                          | doxygen                                                                                     | xml                                                                                         | output                                                                                      | for                                                                                         |                                                                                             | 'HIP                                                                                        | 6.1.40092                                                                                   | Documentation'                                                                              | from                                                                                        |
-| /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- |
-| 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      |
-
-| Warning:                                                                                    | Warning:                                                                                    | doxygenfunction:                                                                            | doxygenfunction:                                                                            | doxygenfunction:                                                                            | Cannot                                                                                      | find                                                                                        | function                                                                                    | 'hipLaunchCooperativeKernelMultiDe-                                                         | 'hipLaunchCooperativeKernelMultiDe-                                                         | 'hipLaunchCooperativeKernelMultiDe-                                                         |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
-| vice'                                                                                       | in                                                                                          | doxygen                                                                                     | xml                                                                                         | output for                                                                                  | project                                                                                     | 'HIP                                                                                        | 6.1.40092                                                                                   | Documentation'                                                                              | from                                                                                        | directory:                                                                                  |
-| /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- |
-| 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      |
-
-| Warning: in                                                                                 | doxygenfunction: Cannot find xml output for project 'HIP                                    | doxygenfunction: Cannot find xml output for project 'HIP                                    |                                                                                             |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
-| nel'                                                                                        | function 6.1.40092                                                                          | 'hipModuleLaunchCooperativeKer- Documentation' from directory:                              |                                                                                             |
-| /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- |
-| 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      |
-
-Warning: doxygenfunction: Cannot find function 'hipModuleLaunchCooperativeKernelMultiDevice' in doxygen xml output for project 'HIP 6.1.40092 Documentation' from directory: /home/docs/checkouts/readthedocs.org/user\_builds/advanced-micro-devices-hip/checkouts/docs6.1.2/docs/doxygen/xml
-
-## 23.2 Cooperative groups classes
-
-The following cooperative groups classes can be used on the device side.
-
-## class thread\_group
-
-The base type of all cooperative group types.
-
-Holds the key properties of a constructed cooperative group types object, like the group type, its size, etc.
-
-Note: Cooperative groups feature is implemented on Linux, under development on Microsoft Windows.
-
-Subclassed by cooperative\_groups::coalesced\_group , cooperative\_groups::grid\_group , coopera-tive\_groups::multi\_grid\_group , cooperative\_groups::thread\_block , cooperative\_groups::tiled\_group class thread\_block : public cooperative\_groups:: thread\_group
-
-The workgroup (thread-block in CUDA terminology) cooperative group type.
-
-Represents an intra-workgroup cooperative group type, where the participating threads within the group are the same threads that participated in the currently executing workgroup .
-
-Note: This function is implemented on Linux and is under development on Microsoft Windows.
-
-class grid\_group : public cooperative\_groups:: thread\_group
-
-The grid cooperative group type.
-
-Represents an inter-workgroup cooperative group type, where the participating threads within the group spans across multiple workgroups running the (same) kernel on the same device.
-
-Note: This is implemented on Linux and is under development on Microsoft Windows.
-
-class multi\_grid\_group : public cooperative\_groups:: thread\_group
-
-The multi-grid cooperative group type.
-
-Represents an inter-device cooperative group type, where the participating threads within the group span across multiple devices, running the (same) kernel on these devices.
-
-Note: The multi-grid cooperative group type is implemented on Linux, under development on Microsoft Windows.
-
-## template&lt;unsigned int size , class ParentCGTy &gt;
-
-class thread\_block\_tile : public cooperative\_groups::impl::thread\_block\_tile\_internal&lt; size , ParentCGTy &gt; Group type -thread\_block\_tile .
-
-Represents one tiled thread group in a wavefront. This group type also supports sub-wave level intrinsics.
-
-Note: This type is implemented on Linux, under development on Microsoft Windows.
-
-## Public Functions
-
-unsigned int thread\_rank () const
-
-Rank of the calling thread within [0, size() ).
-
-## void sync ()
-
-Synchronizes the threads in the group.
-
-Causes all threads in the group to wait at this synchronization point, and for all shared and global memory accesses by the threads to complete, before running synchronization. This guarantees the visibility of accessed data for all threads in the group.
-
-Note: There are potential read-after-write (RAW), write-after-read (WAR), or write-after-write (WAW) hazards, when threads in the group access the same addresses in shared or global memory. The data hazards can be avoided with synchronization of the group.
-
-## unsigned int meta\_group\_rank () const
-
-Returns the linear rank of the group within the set of tiles partitioned from a parent group (bounded by meta\_group\_size)
-
-unsigned int meta\_group\_size () const
-
-Returns the number of groups created when the parent group was partitioned.
-
-## template&lt;class T &gt;
-
-T shfl ( T var, int srcRank ) const
-
-Shuffle operation on group level.
-
-Exchanging variables between threads without use of shared memory. Shuffle operation is a direct copy of var from srcRank thread ID of group.
-
-## Template Parameters
-
-T - The type can be a 32-bit integer or single-precision floating point.
-
-## Parameters
-
-- var - [in] The source variable to copy. Only the srcRank thread ID of group is copied to other threads.
-- srcRank - [in] The source thread ID of the group for copy.
-
-## template&lt;class T &gt;
-
-T shfl\_down ( T var, unsigned int lane\_delta ) const
-
-Shuffle down operation on group level.
-
-Exchanging variables between threads without use of shared memory. Shuffle down operation is copy of var from thread with thread ID of group relative higher with lane\_delta to caller thread ID.
-
-## Template Parameters
-
-T - The type can be a 32-bit integer or single-precision floating point.
-
-## Parameters
-
-- var - [in] The source variable to copy.
-- lane\_delta - [in] The lane\_delta is the relative thread ID difference between caller thread ID and source of copy thread ID. sourceID = (threadID + lane\_delta) % size()
-
-template&lt;class T &gt;
-
-## T shfl\_up ( T var, unsigned int lane\_delta ) const
-
-Shuffle up operation on group level.
-
-Exchanging variables between threads without use of shared memory. Shuffle up operation is copy of var from thread with thread ID of group relative lower with lane\_delta to caller thread ID.
-
-## Template Parameters
-
-T - The type can be a 32-bit integer or single-precision floating point.
-
-## Parameters
-
-- var - [in] The source variable to copy.
-- lane\_delta - [in] The lane\_delta is the relative thread ID difference between caller thread ID and source of copy thread ID. sourceID = (threadID - lane\_delta) % size()
-
-## template&lt;class T &gt;
-
-T shfl\_xor ( T var, unsigned int laneMask ) const
-
-Shuffle xor operation on group level.
-
-Exchanging variables between threads without use of shared memory. Shuffle xor operation is copy of var from thread with thread ID of group based on laneMask XOR of the caller thread ID.
-
-## Template Parameters
-
-- T - The type can be a 32-bit integer or single-precision floating point.
-
-## Parameters
-
-- var - [in] The source variable to copy.
-- laneMask - [in] The laneMask is the mask for XOR operation. sourceID = threadID ^ laneMask
-
-unsigned long long ballot ( int pred ) const
-
-Ballot function on group level.
-
-Returns a bit mask with the Nth bit set to one if the Nth thread predicate evaluates true.
-
-## Parameters
-
-pred - [in] The predicate to evaluate on group threads.
-
-int any ( int pred ) const
-
-Any function on group level.
-
-Returns non-zero if a predicate evaluates true for any threads.
-
-## Parameters
-
-pred - [in] The predicate to evaluate on group threads.
-
-int all ( int pred ) const
-
-All function on group level.
-
-Returns non-zero if a predicate evaluates true for all threads.
-
-## Parameters
-
-pred - [in] The predicate to evaluate on group threads.
-
-template&lt;typename T &gt;
-
-unsigned long long match\_any ( T value ) const
-
-Match any function on group level.
-
-Returns a bit mask containing a 1-bit for every participating thread if that thread has the same value in value as the caller thread.
-
-## Parameters
-
-value - [in] The value to examine on the current thread in group.
-
-template&lt;typename T &gt; unsigned long long match\_all ( T value, int &amp;pred ) const
-
-Match all function on group level.
-
-Returns a bit mask containing a 1-bit for every participating thread if they all have the same value in value as the caller thread. The predicate pred is set to true if all participating threads have the same value in value .
-
-## Parameters
-
-- value - [in] The value to examine on the current thread in group.
-- pred - [out] The predicate is set to true if all participating threads in the thread group have the same value.
-
-class coalesced\_group : public cooperative\_groups:: thread\_group
-
-The coalesced\_group cooperative group type.
-
-Represents an active thread group in a wavefront. This group type also supports sub-wave level intrinsics.
-
-Note: This is implemented on Linux and is under development on Microsoft Windows.
-
-## 23.3 Cooperative groups construct functions
-
-The following functions are used to construct different group-type instances on the device side.
-
-| Warning:                                                                                    | Warning:                                                                                    | doxygenfunction:                                                                            | doxygenfunction:                                                                            | doxygenfunction:                                                                            | Cannot find                                                                                 | Cannot find                                                                                 | function                                                                                    | 'cooperative_groups::this_multi_grid'                                                       | 'cooperative_groups::this_multi_grid'                                                       | 'cooperative_groups::this_multi_grid'                                                       |                                                                                             |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
-| in                                                                                          | doxygen                                                                                     | xml                                                                                         | output                                                                                      | for                                                                                         | project                                                                                     | 'HIP                                                                                        | 6.1.40092                                                                                   | Documentation'                                                                              | from                                                                                        | directory:                                                                                  |                                                                                             |
-| /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- |
-| 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      |
-
-Warning: doxygenfunction: Cannot find function 'cooperative\_groups::this\_grid' in doxygen xml output for project 'HIP 6.1.40092 Documentation' from directory: /home/docs/checkouts/readthedocs.org/user\_builds/advanced-micro-devices-hip/checkouts/docs6.1.2/docs/doxygen/xml
-
-Warning: doxygenfunction: Cannot find function 'cooperative\_groups::this\_thread\_block' in doxygen xml output for project 'HIP 6.1.40092 Documentation' from directory: /home/docs/checkouts/readthedocs.org/user\_builds/advanced-micro-devices-hip/checkouts/docs6.1.2/docs/doxygen/xml
-
-| Warning:   | Warning:   | doxygenfunction:   | doxygenfunction:   | doxygenfunction:   | Cannot   | find   | function   | 'cooperative_groups::coalesced_threads'   | 'cooperative_groups::coalesced_threads'   |            |
-|------------|------------|--------------------|--------------------|--------------------|----------|--------|------------|-------------------------------------------|-------------------------------------------|------------|
-| in         | doxygen    | xml                | output             | for                | project  | 'HIP   | 6.1.40092  | Documentation'                            | from                                      | directory: |
-
-/home/docs/checkouts/readthedocs.org/user\_builds/advanced-micro-devices-hip/checkouts/docs6.1.2/docs/doxygen/xml
-
-| Warning:                                                                                    | Warning:                                                                                    | doxygenfunction:                                                                            | doxygenfunction:                                                                            | doxygenfunction:                                                                            | Cannot find                                                                                 | Cannot find                                                                                 | function                                                                                    | 'cooperative_groups::tiled_partition'                                                       | 'cooperative_groups::tiled_partition'                                                       | 'cooperative_groups::tiled_partition'                                                       |                                                                                             |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
-| in                                                                                          | doxygen                                                                                     | xml                                                                                         | output                                                                                      | for                                                                                         | project                                                                                     | 'HIP                                                                                        | 6.1.40092                                                                                   | Documentation'                                                                              | from                                                                                        | directory:                                                                                  |                                                                                             |
-| /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- |
-| 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      |
-
-| Warning:                                                                                    | Warning:                                                                                    | doxygenfunction:                                                                            | doxygenfunction:                                                                            | doxygenfunction:                                                                            | Cannot                                                                                      | find                                                                                        | function 'cooperative_groups::tiled_partition' 6.1.40092                                    | function 'cooperative_groups::tiled_partition' 6.1.40092                                    | function 'cooperative_groups::tiled_partition' 6.1.40092                                    |                                                                                             |                                                                                             |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
-| in                                                                                          | doxygen                                                                                     | xml                                                                                         | output                                                                                      | for                                                                                         | project                                                                                     | 'HIP                                                                                        | Documentation'                                                                              | from                                                                                        | directory:                                                                                  |                                                                                             |                                                                                             |
-| /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- |
-| 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      |
-
-| Warning:                                                                                    | Warning:                                                                                    | doxygenfunction:                                                                            | doxygenfunction:                                                                            | doxygenfunction:                                                                            | Cannot find                                                                                 | Cannot find                                                                                 | function                                                                                    | function                                                                                    | 'cooperative_groups::binary_partition'                                                      | 'cooperative_groups::binary_partition'                                                      |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
-| in                                                                                          | doxygen                                                                                     | xml                                                                                         | output                                                                                      | for                                                                                         | project                                                                                     | 'HIP                                                                                        |                                                                                             | 6.1.40092                                                                                   | Documentation'                                                                              | from                                                                                        |
-| /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- |
-| 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      |
-
-| Warning:                                                                                    | Warning:                                                                                    | doxygenfunction:                                                                            | doxygenfunction:                                                                            | doxygenfunction:                                                                            | Cannot find                                                                                 | Cannot find                                                                                 | function 'cooperative_groups::binary_partition' 6.1.40092                                   | function 'cooperative_groups::binary_partition' 6.1.40092                                   | function 'cooperative_groups::binary_partition' 6.1.40092                                   |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
-| in                                                                                          | doxygen                                                                                     | xml                                                                                         | output                                                                                      | for                                                                                         | project                                                                                     | 'HIP                                                                                        | Documentation'                                                                              | from                                                                                        | directory:                                                                                  |
-| /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- |
-| 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      |
-
-## 23.4 Cooperative groups exposed API functions
-
-The following functions are the exposed API for different group-type instances on the device side.
-
-| Warning:                                                                                    | Warning:                                                                                    | doxygenfunction: project                                                                    | doxygenfunction: project                                                                    | doxygenfunction: project                                                                    | Cannot find                                                                                 | function                                                                                    | 'cooperative_groups::group_size'                                                            | 'cooperative_groups::group_size'                                                            | 'cooperative_groups::group_size'                                                            |                                                                                             |                                                                                             |                                                                                             |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
-| in                                                                                          | doxygen                                                                                     | xml                                                                                         | output                                                                                      | for                                                                                         | 'HIP                                                                                        | 6.1.40092                                                                                   | Documentation'                                                                              | from                                                                                        | directory:                                                                                  |                                                                                             |                                                                                             |                                                                                             |
-| /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- |
-| 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      |
-
-| Warning:                                                                                    | Warning:                                                                                    | doxygenfunction: Cannot                                                                     | doxygenfunction: Cannot                                                                     | doxygenfunction: Cannot                                                                     | doxygenfunction: Cannot                                                                     | find 'HIP                                                                                   | find 'HIP                                                                                   | function 'cooperative_groups::thread_rank'                                                  | function 'cooperative_groups::thread_rank'                                                  | function 'cooperative_groups::thread_rank'                                                  |                                                                                             |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
-| in                                                                                          | doxygen                                                                                     | xml                                                                                         | output                                                                                      | for                                                                                         | project                                                                                     |                                                                                             | 6.1.40092                                                                                   | Documentation'                                                                              | from                                                                                        | directory:                                                                                  |                                                                                             |
-| /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- |
-| 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      |
-
-Warning: doxygenfunction: Cannot find function 'cooperative\_groups::is\_valid' in doxygen xml output for project 'HIP 6.1.40092 Documentation' from directory: /home/docs/checkouts/readthedocs.org/user\_builds/advanced-micro-devices-hip/checkouts/docs6.1.2/docs/doxygen/xml
-
-Warning: doxygenfunction: Cannot find function 'cooperative\_groups::sync' in doxygen xml output for project 'HIP 6.1.40092 Documentation' from directory: /home/docs/checkouts/readthedocs.org/user\_builds/advancedmicro-devices-hip/checkouts/docs-6.1.2/docs/doxygen/xml
-
-## CHAPTER
-
-## TWENTYFOUR
-
-## HSA RUNTIME API FOR ROCM
-
-The following functions are located in the https://github.com/ROCm/ROCR-Runtime repository.
-
-hsa\_status\_t hsa\_amd\_vmem\_address\_reserve ( void **va, size\_t size, uint64\_t address, uint64\_t flags )
-
-Allocate a reserved address range.
-
-Reserve a virtual address range. The size must be a multiple of the system page size. If it is not possible to allocate the address specified by address , then va will be a different address range. Address range should be released by calling hsa\_amd\_vmem\_address\_free.
-
-Note that this API will be deprecated in a future release and replaced by hsa\_amd\_vmem\_address\_reserve\_align
-
-## Parameters
-
-- va -[out] virtual address allocated
-- size -[in] of address range requested
-- address -[in] requested
-- flags -[in] currently unsupported
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS - Address range allocated successfully
-- ::HSA\_STATUS\_ERROR\_NOT\_INITIALIZED - The HSA runtime has not been initialized.
-- ::HSA\_STATUS\_ERROR\_OUT\_OF\_RESOURCES - Insufficient resources to allocate an address range of this size.
-
-hsa\_status\_t hsa\_amd\_vmem\_address\_free ( void *va, size\_t size )
-
-Free a reserved address range.
-
-Free a previously allocated address range. The size must match the size of a previously allocated address range.
-
-## Parameters
-
-- va -[out] virtual address to be freed
-- size -[in] of address range
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS - Address range released successfully
-- ::HSA\_STATUS\_ERROR\_INVALID\_ALLOCATION - Invalid va specified
-- ::HSA\_STATUS\_ERROR\_INVALID\_ARGUMENT - Invalid size specified
-- ::HSA\_STATUS\_ERROR\_RESOURCE\_FREE - Address range is still in use
-
-· ::HSA\_STATUS\_ERROR - Internal unexpected error
-
-hsa\_status\_t hsa\_amd\_vmem\_handle\_create ( hsa\_amd\_memory\_pool\_t pool, size\_t size, hsa\_amd\_memory\_type\_t type, uint64\_t flags, hsa\_amd\_vmem\_alloc\_handle\_t *memory\_handle
-
-)
-
-Create a virtual memory handle.
-
-Create a virtual memory handle within this pool size must be a aligned to allocation granule size for this memory pool, see HSA\_AMD\_MEMORY\_POOL\_INFO\_RUNTIME\_ALLOC\_GRANULE To minimize internal memory fragmentation, align the size to the recommended allocation granule size, see HSA\_AMD\_MEMORY\_POOL\_INFO\_RUNTIME\_ALLOC\_REC\_GRANULE
-
-## Parameters
-
-- pool -[in] memory to use
-- size -[in] of the memory allocation
-- type -[in] of memory
-- flags -[in] - currently unsupported
-- memory\_handle -[out] - handle for the allocation
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS - memory allocated successfully
-- ::HSA\_STATUS\_ERROR\_NOT\_INITIALIZED - The HSA runtime has not been initialized.
-- ::HSA\_STATUS\_ERROR\_INVALID\_ARGUMENT - Invalid arguments
-- ::HSA\_STATUS\_ERROR\_INVALID\_ALLOCATION - This memory pool does not support allocations
-- ::HSA\_STATUS\_ERROR\_OUT\_OF\_RESOURCES - Insufficient resources to allocate this memory
-
-hsa\_status\_t hsa\_amd\_vmem\_handle\_release ( hsa\_amd\_vmem\_alloc\_handle\_t memory\_handle )
-
-Release a virtual memory handle.
-
-## Parameters
-
-memory -[in] handle that was previously allocated
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS - Address range allocated successfully
-- ::HSA\_STATUS\_ERROR\_INVALID\_ALLOCATION - Invalid memory handle
-
-hsa\_status\_t hsa\_amd\_vmem\_map ( void *va, size\_t size, size\_t in\_offset, hsa\_amd\_vmem\_alloc\_handle\_t memory\_handle, uint64\_t flags )
-
-Map a virtual memory handle.
-
-Map a virtual memory handle to a reserved address range. The virtual address requested must be within a previously reserved address range. va and ( va + size) must be must be within (va + size) of the previous allocated address range. size must be equal to size of the memory\_handle hsa\_amd\_vmem\_set\_access needs to be called to make the memory accessible to specific agents
-
-## Parameters
-
-- va -[in] virtual address range where memory will be mapped
-- size -[in] of memory mapping
-- in\_offset -[in] offset into memory. Currently unsupported
-
-- memory\_handle -[in] virtual memory handle to be mapped
-- flags. -[in] Currently unsupported
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS - Memory mapped successfully
-- ::HSA\_STATUS\_ERROR\_INVALID\_ARGUMENT - va, size or memory\_handle are invalid
-- ::HSA\_STATUS\_ERROR\_OUT\_OF\_RESOURCES - Insufficient resources
-- ::HSA\_STATUS\_ERROR - Unexpected internal error
-
-## hsa\_status\_t hsa\_amd\_vmem\_unmap ( void *va, size\_t size )
-
-Unmap a virtual memory handle.
-
-Unmap previously mapped virtual address range
-
-## Parameters
-
-- va -[in] virtual address range where memory will be mapped
-- size -[in] of memory mapping
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS - Memory backing unmapped successfully
-- ::HSA\_STATUS\_ERROR\_INVALID\_ALLOCATION - memory\_handle is invalid
-- ::HSA\_STATUS\_ERROR\_INVALID\_ARGUMENT - size is invalid
-- ::HSA\_STATUS\_ERROR - Unexpected internal error
-
-hsa\_status\_t hsa\_amd\_vmem\_set\_access ( void *va, size\_t size, const hsa\_amd\_memory\_access\_desc\_t *desc, size\_t desc\_cnt )
-
-Make a memory mapping accessible.
-
-Make previously mapped virtual address accessible to specific agents. size must be equal to size of previously mapped virtual memory handle. Calling hsa\_amd\_vmem\_set\_access multiple times on the same va will overwrite previous permissions for all agents
-
-## Parameters
-
-- va -[in] previously mapped virtual address
-- size -[in] of memory mapping
-- desc -[in] list of access permissions for each agent
-- desc\_cnt -[in] number of elements in desc
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS -
-- ::HSA\_STATUS\_ERROR\_INVALID\_ARGUMENT - va, size or memory\_handle are invalid
-- ::HSA\_STATUS\_ERROR\_INVALID\_ALLOCATION - memory\_handle is invalid
-- ::HSA\_STATUS\_ERROR\_OUT\_OF\_RESOURCES - Insufficient resources
-- ::HSA\_STATUS\_ERROR\_INVALID\_AGENT - Invalid agent in desc
-- ::HSA\_STATUS\_ERROR - Unexpected internal error
-
-hsa\_status\_t hsa\_amd\_vmem\_get\_access ( void *va, hsa\_access\_permission\_t *perms, hsa\_agent\_t agent\_handle )
-
-Get current access permissions for memory mapping.
-
-Get access permissions for memory mapping for specific agent.
-
-## Parameters
-
-- va -[in] previously mapped virtual address
-- perms -[in] current permissions
-- agent\_handle -[in] agent
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS -
-- ::HSA\_STATUS\_ERROR\_INVALID\_AGENT - Invalid agent
-- ::HSA\_STATUS\_ERROR\_INVALID\_ALLOCATION - va is not mapped or permissions never set for this agent
-- ::HSA\_STATUS\_ERROR - Unexpected internal error
-
-hsa\_status\_t hsa\_amd\_vmem\_export\_shareable\_handle ( int *dmabuf\_fd, hsa\_amd\_vmem\_alloc\_handle\_t handle, uint64\_t flags )
-
-Get an exportable shareable handle.
-
-Get an exportable shareable handle for a memory\_handle. This shareabl handle can then be used to re-create a virtual memory handle using hsa\_amd\_vmem\_import\_shareable\_handle. The shareable handle can be transferred using mechanisms that support posix file descriptors Once all shareable handles are closed, the memory\_handle is released.
-
-## Parameters
-
-- dmabuf\_fd -[out] shareable handle
-- handle -[in] previously allocated virtual memory handle
-- flags -[in] Currently unsupported
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS -
-- ::HSA\_STATUS\_ERROR\_INVALID\_ALLOCATION - Invalid memory handle
-- ::HSA\_STATUS\_ERROR\_OUT\_OF\_RESOURCES - Out of resources
-- ::HSA\_STATUS\_ERROR - Unexpected internal error
-
-## hsa\_status\_t hsa\_amd\_vmem\_import\_shareable\_handle ( int dmabuf\_fd, hsa\_amd\_vmem\_alloc\_handle\_t *handle )
-
-Import a shareable handle.
-
-Import a shareable handle for a memory handle. Importing a shareable handle that has been closed and released results in undefined behavior.
-
-## Parameters
-
-- dmabuf\_fd -[in] shareable handle exported with hsa\_amd\_vmem\_export\_shareable\_handle
-- handle -[out] virtual memory handle
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS -
-
-- ::HSA\_STATUS\_ERROR\_INVALID\_ALLOCATION - Invalid memory handle
-- ::HSA\_STATUS\_ERROR\_OUT\_OF\_RESOURCES - Out of resources
-- ::HSA\_STATUS\_ERROR - Unexpected internal error
-
-hsa\_status\_t hsa\_amd\_vmem\_retain\_alloc\_handle ( hsa\_amd\_vmem\_alloc\_handle\_t *memory\_handle, void *addr )
-
-Returns memory handle for mapped memory.
-
-Return a memory handle for previously mapped memory. The handle will be the same value of handle used to map the memory. The returned handle must be released with corresponding number of calls to hsa\_amd\_vmem\_handle\_release.
-
-## Parameters
-
-- memory\_handle -[out] memory handle for this mapped address
-- mapped -[in] address
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS -
-- ::HSA\_STATUS\_ERROR\_INVALID\_ALLOCATION - Invalid address
-
-hsa\_status\_t hsa\_amd\_vmem\_get\_alloc\_properties\_from\_handle ( hsa\_amd\_vmem\_alloc\_handle\_t memory\_handle, hsa\_amd\_memory\_pool\_t *pool, hsa\_amd\_memory\_type\_t *type )
-
-Returns the current allocation properties of a handle.
-
-Returns the allocation properties of an existing handle
-
-## Parameters
-
-- memory\_handle -[in] memory handle to be queried
-- pool -[out] memory pool that owns this handle
-- memory -[out] type
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS -
-- ::HSA\_STATUS\_ERROR\_INVALID\_ALLOCATION - Invalid memory\_handle
-
-## CHAPTER
-
-## TWENTYFIVE
-
-## HIP MANAGED MEMORY ALLOCATION API
-
-hipError\_t hipMallocManaged ( void **dev\_ptr, size\_t size, unsigned int flags )
-
-Allocates memory that will be automatically managed by HIP.
-
-This API is used for managed memory, allows data be shared and accessible to both CPU and GPU using a single pointer.
-
-The API returns the allocation pointer, managed by HMM, can be used further to execute kernels on device and fetch data between the host and device as needed.
-
-Note: It is recommend to do the capability check before call this API.
-
-## Parameters
-
-- dev\_ptr -[out] - pointer to allocated device memory
-- size -[in] - requested allocation size in bytes, it should be granularity of 4KB
-- flags -[in] - must be either hipMemAttachGlobal or hipMemAttachHost (defaults to hipMemAttachGlobal)
-
-## Returns
-
-hipSuccess, hipErrorMemoryAllocation, hipErrorNotSupported, hipErrorInvalidValue hipError\_t hipMemPrefetchAsync ( const void *dev\_ptr, size\_t count, int device, hipStream\_t stream
-
-) Prefetches memory to the specified destination device using HIP.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-## Parameters
-
-- dev\_ptr -[in] pointer to be prefetched
-- count -[in] size in bytes for prefetching
-- device -[in] destination device to prefetch to
-- stream -[in] stream to enqueue prefetch operation
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue
-
-hipError\_t hipMemAdvise ( const void *dev\_ptr, size\_t count, hipMemoryAdvise advice, int device )
-
-Advise about the usage of a given memory range to HIP.
-
-This HIP API advises about the usage to be applied on unified memory allocation in the range starting from the pointer address devPtr, with the size of count bytes. The memory range must refer to managed memory allocated via the API hipMallocManaged, and the range will be handled with proper round down and round up respectively in the driver to be aligned to CPU page size, the same way as corresponding CUDA API behaves in CUDA version 8.0 and afterwards.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-## Parameters
-
-- dev\_ptr -[in] pointer to memory to set the advice for
-- count -[in] size in bytes of the memory range, it should be CPU page size alligned.
-- advice -[in] advice to be applied for the specified memory range
-- device -[in] device to apply the advice for
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemRangeGetAttribute ( void *data, size\_t data\_size, hipMemRangeAttribute attribute, const void *dev\_ptr, size\_t count )
-
-Query an attribute of a given memory range in HIP.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-## Parameters
-
-- data -[inout] a pointer to a memory location where the result of each attribute query will be written to
-- data\_size -[in] the size of data
-- attribute -[in] the attribute to query
-- dev\_ptr -[in] start of the range to query
-- count -[in] size of the range to query
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemRangeGetAttributes ( void **data, size\_t *data\_sizes, hipMemRangeAttribute *attributes, size\_t num\_attributes, const void *dev\_ptr, size\_t count )
-
-Query attributes of a given memory range in HIP.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-## Parameters
-
-- data -[inout] a two-dimensional array containing pointers to memory locations where the result of each attribute query will be written to
-- data\_sizes -[in] an array, containing the sizes of each result
-- attributes -[in] the attribute to query
-- num\_attributes -[in] an array of attributes to query (numAttributes and the number of attributes in this array should match)
-- dev\_ptr -[in] start of the range to query
-- count -[in] size of the range to query
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipStreamAttachMemAsync ( hipStream\_t stream, void *dev\_ptr, size\_t length, unsigned int flags ) Attach memory to a stream asynchronously in HIP.
-
-Warning: This API is under development. Currently it is a no-operation (NOP) function on AMD GPUs and returns hipSuccess.
-
-## Parameters
-
-- stream -[in] - stream in which to enqueue the attach operation
-- dev\_ptr -[in] - pointer to memory (must be a pointer to managed memory or to a valid host-accessible region of system-allocated memory)
-- length -[in] - length of memory (defaults to zero)
-- flags -[in] - must be one of hipMemAttachGlobal, hipMemAttachHost or hipMemAttachSingle (defaults to hipMemAttachSingle)
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue
-
-## template&lt;class T &gt;
-
-static inline hipError\_t hipMallocManaged ( T **devPtr, size\_t size, unsigned int flags = hipMemAttachGlobal )
-
-- : C++ wrapper for hipMallocManaged
-
-Provide an override to automatically typecast the pointer type from void**, and also provide a default for the flags.
-
-HIP\_DISABLE\_CPP\_FUNCTIONS macro can be defined to suppress these wrappers. It is useful for applications which need to obtain decltypes of HIP runtime APIs.
-
-## See also:
-
-hipMallocManaged
-
-## CHAPTER
-
-## TWENTYSIX
-
-## HIP VIRTUAL MEMORY MANAGEMENT API
-
-hipError\_t hipMemAddressFree ( void *devPtr, size\_t size )
-
-Frees an address range reservation made via hipMemAddressReserve.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- devPtr -[in] - starting address of the range.
-- size -[in] - size of the range.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemAddressReserve ( void **ptr, size\_t size, size\_t alignment, void *addr, unsigned long long flags )
-
-Reserves an address range.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- ptr -[out] - starting address of the reserved range.
-- size -[in] - size of the reservation.
-- alignment -[in] - alignment of the address.
-- addr -[in] - requested starting address of the range.
-- flags -[in] - currently unused, must be zero.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported
-
-hipError\_t hipMemCreate ( hipMemGenericAllocationHandle\_t *handle, size\_t size, const hipMemAllocationProp *prop, unsigned long long flags )
-
-Creates a memory allocation described by the properties and size.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- handle -[out] - value of the returned handle.
-- size -[in] - size of the allocation.
-- prop -[in] - properties of the allocation.
-- flags -[in] - currently unused, must be zero.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemExportToShareableHandle ( void *shareableHandle, hipMemGenericAllocationHandle\_t handle, hipMemAllocationHandleType handleType, unsigned long long flags )
-
-Exports an allocation to a requested shareable handle type.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- shareableHandle -[out] - value of the returned handle.
-- handle -[in] - handle to share.
-- handleType -[in] - type of the shareable handle.
-- flags -[in] - currently unused, must be zero.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemGetAccess ( unsigned long long *flags, const hipMemLocation *location, void *ptr
-
-) Get the access flags set for the given location and ptr.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- flags -[out] - flags for this location.
-- location -[in] - target location.
-- ptr -[in] - address to check the access flags.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemGetAllocationGranularity ( size\_t *granularity, const hipMemAllocationProp *prop, hipMemAllocationGranularity\_flags option )
-
-Calculates either the minimal or recommended granularity.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- granularity -[out] - returned granularity.
-- prop -[in] - location properties.
-- option -[in] - determines which granularity to return.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemGetAllocationPropertiesFromHandle ( hipMemAllocationProp *prop,
-
-hipMemGenericAllocationHandle\_t handle )
-
-Retrieve the property structure of the given handle.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- prop -[out] - properties of the given handle.
-- handle -[in] - handle to perform the query on.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported
-
-hipError\_t hipMemImportFromShareableHandle ( hipMemGenericAllocationHandle\_t *handle, void *osHandle, hipMemAllocationHandleType shHandleType )
-
-Imports an allocation from a requested shareable handle type.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- handle -[out] - returned value.
-- osHandle -[in] - shareable handle representing the memory allocation.
-- shHandleType -[in] - handle type.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemMap ( void *ptr, size\_t size, size\_t offset, hipMemGenericAllocationHandle\_t handle, unsigned long long flags )
-
-Maps an allocation handle to a reserved virtual address range.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- ptr -[in] - address where the memory will be mapped.
-- size -[in] - size of the mapping.
-- offset -[in] - offset into the memory, currently must be zero.
-- handle -[in] - memory allocation to be mapped.
-- flags -[in] - currently unused, must be zero.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemMapArrayAsync ( hipArrayMapInfo *mapInfoList, unsigned int count, hipStream\_t stream )
-
-Maps or unmaps subregions of sparse HIP arrays and sparse HIP mipmapped arrays.
-
-Warning: This API is under development. Currently it is not supported on AMD GPUs and returns hipErrorNotSupported.
-
-## Parameters
-
-- mapInfoList -[in] - list of hipArrayMapInfo.
-- count -[in] - number of hipArrayMapInfo in mapInfoList.
-- stream -[in] - stream identifier for the stream to use for map or unmap operations.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemRelease ( hipMemGenericAllocationHandle\_t handle )
-
-Release a memory handle representing a memory allocation which was previously allocated through hipMemCreate.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-handle -[in] - handle of the memory allocation.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemRetainAllocationHandle ( hipMemGenericAllocationHandle\_t *handle, void *addr )
-
-Returns the allocation handle of the backing memory allocation given the address.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- handle -[out] - handle representing addr.
-- addr -[in] - address to look up.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemSetAccess ( void *ptr, size\_t size, const hipMemAccessDesc *desc, size\_t count )
-
-Set the access flags for each location specified in desc for the given virtual address range.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- ptr -[in] - starting address of the virtual address range.
-- size -[in] - size of the range.
-- desc -[in] - array of hipMemAccessDesc.
-- count -[in] - number of hipMemAccessDesc in desc.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported
-
-## hipError\_t hipMemUnmap ( void *ptr, size\_t size )
-
-Unmap memory allocation of a given address range.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- ptr -[in] - starting address of the range to unmap.
-- size -[in] - size of the virtual address range.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported
-
-## CHAPTER
-
-## TWENTYSEVEN
-
-## HIP DEPRECATED RUNTIME API FUNCTIONS
-
-Several of our API functions have been flagged for deprecation. Using the following functions results in errors and unexpected results, so we encourage you to update your code accordingly.
-
-## 27.1 Context management
-
-CUDAsupports cuCtx API, which is the driver API that defines 'Context' and 'Devices' as separate entities. Context contains a single device, and a device can theoretically have multiple contexts. HIP initially added limited support for these APIs in order to facilitate porting from existing driver codes. These APIs are now marked as deprecated because there are better alternate interfaces (such as hipSetDevice or the stream API) to achieve these functions.
-
-- hipCtxCreate
-- hipCtxDestroy
-- hipCtxPopCurrent
-- hipCtxPushCurrent
-- hipCtxSetCurrent
-- hipCtxGetCurrent
-- hipCtxGetDevice
-- hipCtxGetApiVersion
-- hipCtxGetCacheConfig
-- hipCtxSetCacheConfig
-- hipCtxSetSharedMemConfig
-- hipCtxGetSharedMemConfig
-- hipCtxSynchronize
-- hipCtxGetFlags
-- hipCtxEnablePeerAccess
-- hipCtxDisablePeerAccess
-- hipDevicePrimaryCtxGetState
-- hipDevicePrimaryCtxRelease
-- hipDevicePrimaryCtxRetain
-- hipDevicePrimaryCtxReset
-
-- hipDevicePrimaryCtxSetFlags
-
-## 27.2 Memory management
-
-- hipMallocHost (replaced with hipHostMalloc )
-- hipMemAllocHost (replaced with hipHostMalloc )
-- hipHostAlloc (replaced with hipHostMalloc )
-- hipFreeHost (replaced with hipHostFree )
-- hipMemcpyToArray
-- hipMemcpyFromArray
-
-## 27.3 Profiler control
-
-- hipProfilerStart (use roctracer/rocTX)
-- hipProfilerStop (use roctracer/rocTX)
-
-## 27.4 Texture management
-
-- hipGetTextureReference
-- hipTexRefSetAddressMode
-- hipTexRefSetArray
-- hipTexRefSetFilterMode
-- hipTexRefSetFlags
-- hipTexRefSetFormat
-- hipTexRefGetAddress
-- hipTexRefGetAddressMode
-- hipTexRefGetFilterMode
-- hipTexRefGetFlags
-- hipTexRefGetFormat
-- hipTexRefGetMaxAnisotropy
-- hipTexRefGetMipmapFilterMode
-- hipTexRefGetMipmapLevelBias
-- hipTexRefGetMipmapLevelClamp
-- hipTexRefGetMipMappedArray
-- hipTexRefSetAddress
-- hipTexRefSetAddress2D
-- hipTexRefSetMaxAnisotropy
-
-- hipTexRefSetBorderColor
-- hipTexRefSetMipmapFilterMode
-- hipTexRefSetMipmapLevelBias
-- hipTexRefSetMipmapLevelClamp
-- hipTexRefSetMipmappedArray
-- hipTexRefGetBorderColor
-- hipTexRefGetArray
-- hipBindTexture
-- hipBindTexture2D
-- hipBindTextureToArray
-- hipGetTextureAlignmentOffset
-- hipUnbindTexture
-- hipBindTextureToMipmappedArray
-
-## CHAPTER
-
-## TWENTYEIGHT
-
-## SAXPY - HELLO, HIP
-
-This tutorial explains the basic concepts of the single-source Heterogeneous-computing Interface for Portability (HIP) programming model and the essential tooling around it. It also reviews some commonalities of heterogenous APIs in general. This topic assumes basic familiarity with the C/C++ compilation model and language.
-
-## 28.1 Prerequisites
-
-To follow this tutorial, you'll need installed drivers and a HIP compiler toolchain to compile your code. Because HIP for ROCm supports compiling and running on Linux and Windows with AMD and NVIDIA GPUs, the combination of install instructions is more than worth covering as part of this tutorial. For more information about installing HIP development packages, see Install HIP .
-
-## 28.2 Heterogeneous programming
-
-Heterogeneous programming and offloading APIs are often mentioned together. Heterogeneous programming deals with devices of varying capabilities simultaneously. Offloading focuses on the 'remote' and asynchronous aspects of computation. HIP encompasses both. It exposes GPGPU (general-purpose GPU) programming much like ordinary host-side CPU programming and lets you move data across various devices.
-
-When programming in HIP (and other heterogenous APIs for that matter), remember that target devices are built for a specific purpose. They are designed with different tradeoffs than traditional CPUs and therefore have very different performance characteristics. Even subtle changes in code might adversely affect execution time.
-
-## 28.3 Your first lines of HIP code
-
-First, let's do the 'Hello, World!' of GPGPU: SAXPY. Single-precision A times X Plus Y ( SAXPY ) is a mathematical acronym; a vector equation 𝑎 · 𝑥 + 𝑦 = 𝑧 where 𝑎 ∈ R is a scalar and 𝑥, 𝑦, 𝑧 ∈ V are vector quantities of some large dimensionality. This vector space is defined over the set of reals. Practically speaking, you can compute this using a single for loop over three arrays.
-
-```
-++i)
-```
-
-```
-<_SQL_>
-```
-
-In linear algebra libraries, such as BLAS (Basic Linear Algebra Subsystem) this operation is defined as AXPY 'A times X Plus Y'. The 'S' comes from single-precision , meaning that array element is float -s (IEEE 754 binary32 representation).
-
-To quickly get started, use the set of HIP samples from GitHub. With Git configured on your machine, open a commandline and navigate to your desired working directory, then run:
-
-```
-            |git clone https://github.com/amd/rcm-examples.git
-```
-
-A simple implementation of SAXPY resides in the HIP-Basic/saxpy/main.hip file in this repository. The HIP code here mostly deals with where data has to be and when, and how devices transform this data. The first HIP calls deal with allocating device-side memory and copying data from host-side memory to device side in a C runtime-like fashion.
-
-```
-// Allocate and copy vectors to device memory.
-float* d_x{};
-float* d_y{};
-HIP_CHECK(hipMalloc(&d_x, size_bytes));
-HIP_CHECK(hipMalloc(&d_y, size_bytes));
-HIP_CHECK(hipMemcpy(d_x, x.data(), size_bytes, hipMemcpyHostToDevice));
-HIP_CHECK(hipMemcpy(d_y, y.data(), size_bytes, hipMemcpyHostToDevice));
-```
-
-HIP\_CHECK is a custom macro borrowed from the examples utilities which checks the error code returned by API functions for errors and reports them to the console. It is not essential to the API, but it is a good practice to check the error codes of the HIP APIs in case you pass on incorrect values to the API, or the API might be out of resources.
-
-The code selects the device to allocate to and to copy to. Commands are issued to the HIP runtime per thread, and every thread has a device set as the target of commands. The default device is 0 , which is equivalent to calling hipSetDevice(0) .
-
-Launch the calculation on the device after the input data has been prepared.
-
-```
-    Launch the calculation on the device after the input data has been prepared.
-    __global__ void saxpy_kernel(const float a, const float* d_x, float* d_y, const unsigned_
-    __int size)
-    {
-        //...
-    }
-
-    int main()
-    {
-        //...
-
-        // Launch the kernel on the default stream.
-        saxpy_kernel<<<dim3(grid_size), dim3(block_size), 0, hipStreamDefault>>>(a, d_x, d_y,
-    -- size);
-    }
-
-    Analyze at the signature of the offloaded function:
-```
-
-Analyze at the signature of the offloaded function:
-
-- \_\_global\_\_ instructs the compiler to generate code for this function as an entrypoint to a device program, such that it can be launched from the host.
-- The function does not return anything, because there is no trivial way to construct a return channel of a parallel invocation. Device-side entrypoints may not return a value, their results should be communicated using output parameters.
-- Device-side functions are typically called compute kernels, or just kernels for short. This is to distinguish them from non-graphics-related graphics shaders, or just shaders for short.
-- Arguments are taken by value and all arguments shall be TriviallyCopyable, meaning they should be memcpy -friendly. (Imagine if they had custom copy constructors. Where would that logic execute? On the host? On the device?) Pointer arguments are pointers to device memory, one typically backed by VRAM.
-
-- We said that we'll be computing 𝑎 · 𝑥 + 𝑦 = 𝑧 , however we only pass two pointers to the function. We'll be canonically reusing one of the inputs as outputs.
-
-This function is launched from the host using a language extension often called the triple chevron syntax. Inside the angle brackets, provide the following.
-
-- The number of blocks to launch (our grid size)
-- The number of threads in a block (our block size)
-- The amount of shared memory to allocate by the host
-- The device stream to enqueue the operation on
-
-The block size and shared memory become important later in Reduction . For now, a hardcoded 256 is a safe default for simple kernels such as this. Following the triple chevron is ordinary function argument passing.
-
-Look at how the kernel is implemented.
-
-```
-<_Cuda_>
-```
-
-- The unique linear index identifying the thread is computed from the block ID the thread is a member of, the block 's size and the ID of the thread within the block .
-- A check is made to avoid overindexing the input.
-- The useful part of the computation is carried out.
-
-Retrieval of the result from the device is done much like input data copy. In this current step the results copied from device to host. The opposite direction of the input data copy:
-
-```
-                |HIP_CHECK(hipMemcpy(y.data()),  d_y,  size_bytes,  hipMemcpyDeviceToHost));
-```
-
-## 28.4 Compiling on the command line
-
-## 28.4.1 Setting up the command line
-
-Strictly speaking there's no such thing as 'setting up the command-line for compilation' on Linux. To make invocations more terse, Linux and Windows example follow.
-
-## Linux and AMD
-
-While distro maintainers might package ROCm so that it installs to system-default locations, AMD's packages aren't installed that way. They need to be added to the PATH by the user.
-
-```
-        | export PATH=/opt/rcm/bin:${PATH}
-```
-
-```
-}
-```
-
-```
-    You should be able to call the compiler on the command line now:
-    
-    amdclang++  --version
-```
-
-Note: Docker images distributed by AMD, such as rocm-terminal already have /opt/rocm/bin on the Path for convenience. This subtly affects CMake package detection logic of ROCm libraries.
-
-## Linux and NVIDIA
-
-Both distro maintainers and NVIDIA package CUDA so that nvcc and related tools are available on the command line by default. You can call the compiler on the command line with:
-
-```
-| nvcc --version
-```
-
-## Windows and AMD
-
-Windows compilers and command line tooling have traditionally relied on extra environmental variables and PATH entries to function correctly. Visual Studio refers to command lines with this setup as 'Developer Command Prompt' or 'Developer PowerShell' for cmd.exe and PowerShell respectively.
-
-The HIP SDK on Windows doesn't include a complete toolchain. You will also need:
-
-- The Microsoft Windows SDK. It provides the import libs to crucial system libraries that all executables must link to and some auxiliary compiler tooling.
-- A Standard Template Library (STL). Installed as part of the Microsoft Visual C++ compiler (MSVC) or with Visual Studio.
-
-If you don't have a version of Visual Studio 2022 installed, for a minimal command line experience, install the Build Tools for Visual Studio 2022 with the Desktop Developemnt Workload. Under Individual Components select:
-
-- A version of the Windows SDK
-- 'MSVC v143 - VS 2022 C++ x64/x86 build tools (Latest)'
-- 'C++ CMake tools for Windows' (optional)
-
-Note: The 'C++ CMake tools for Windows' individual component is a convenience which puts both cmake.exe and ninja.exe onto the PATH inside developer command prompts. You can install these manually, but then you must manage them manually.
-
-Visual Studio 2017 and later are detectable as COM object instances via WMI. To setup a command line from any shell for the latest Visual Studio's default Visual C++ toolset issue:
-
-```
-$InstallationPath = Get-CimInstance MSFT_VSInstance | Sort-Object -Property Version -
- --Descending | Select-Object -First 1 -ExpandProperty InstallLocation
- Import-Module $InstallationPath\Common?\Tools\Microsoft.VisualStudio.DevShell.dll
-Enter-VsDevShell -InstallPath $InstallationPath -SkipAutomaticLocation -Arch amd64 -
- --HostArch amd64 -DevCmdArguments '-no_logo'
-$env:PATH = "${env:HIP_PATH}bin;${env:PATH}"
-```
-
-You should be able to call the compiler on the command line now:
-
-```
-  | clang++ --version
-```
-
-## Windows and NVIDIA
-
-Windows compilers and command line tooling have traditionally relied on extra environmental variables and PATH entries to function correctly. Visual Studio refers to command lines with this setup as 'Developer Command Prompt' or 'Developer PowerShell' for cmd.exe and PowerShell respectively.
-
-The HIP and CUDA SDKs on Windows don't include complete toolchains. You will also need:
-
-- The Microsoft Windows SDK. It provides the import libs to crucial system libraries that all executables must link to and some auxiliary compiler tooling.
-- A Standard Template Library (STL). Installed as part of the Microsoft Visual C++ compiler (MSVC) or with Visual Studio.
-
-If you don't have a version of Visual Studio 2022 installed, for a minimal command line experience, install the Build Tools for Visual Studio 2022 with the Desktop Developemnt Workload. Under Individual Components select:
-
-- A version of the Windows SDK
-- 'MSVC v143 - VS 2022 C++ x64/x86 build tools (Latest)'
-- 'C++ CMake tools for Windows' (optional)
-
-Note: The 'C++ CMake tools for Windows' individual component is a convenience which puts both cmake.exe and ninja.exe onto the PATH inside developer command prompts. You can install these manually, but then you must manage them manually.
-
-Visual Studio 2017 and later are detectable as COM object instances via WMI. To setup a command line from any shell for the latest Visual Studio's default Visual C++ toolset issue:
-
-```
-$InstallationPath = Get-CimInstance MSFT_VSInstance | Sort-Object -Property Version -
---Descending | Select-Object -First 1 -ExpandProperty InstallLocation
-Import-Module $InstallationPath\Common7\Tools\Microsoft.VisualStudio.DevShell.dll
-Enter-VsDevShell -InstallPath $InstallationPath -SkipAutomaticLocation -Arch amd64 -
---HostArch amd64 -DevCmdArguments '-no_logo'
-```
-
-You should be able to call the compiler on the command line now:
-
-```
-| nvcc --version
-```
-
-## 28.4.2 Invoking the compiler manually
-
-To compile and link a single-file application, use the following commands:
-
-## Linux and AMD
-
-```
-                                                                                                                                                                                                        |                                                                                                                                                                                                       
-                                                                                                                                                                                                        <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        </----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                    <---------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        >----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                    |   
-                                                                                                                                                                                                    |   
-
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                   
-    </----------------------------------------------------------------------------------------------------------------------
-```
-
-## Linux and NVIDIA
-
-```
-                                                                                                                                                                                                        | nvcc ./HIP-Basic/saxpy/main.hip  -o  saxpy  -I ./Common  -I  /opt/rocm/include  -02  -x  cu                                                                                                                                                                                                       
-                                                                                                                                                                                                        -x  cu                                                                                                                                                                                                  |                                                                                                                                                                                                        }
-```
-
-## Windows and AMD
-
-```
-                                                                                                                                                                                                        |clang++.\HIP-Basic\saxpy\main.hip -o saxpy.exe -I.\Common -lamdhip64 -L ${env:HIP_PATH}                                                                                                                                                                                                       
-                                                                                                                                                                                                        -lib -02
-```
-
-## Windows and NVIDIA
-
-```
-                                                                                                                                                                                                        | nvcc.\HIP-Basic\saxpy\main.hip -o saxpy.exe -I ${env:HIP_PATH}include -I.\Common -02 - -
-                                                                                                                                                                                                        -x                                                                                                                                                                                                       
-                                                                                                                                                                                                       |                                                                                                                                                                                                        +x                                                                                                                                                                                                       |
-```
-
-Depending on your computer, the resulting binary might or might not run. If not, it typically complains about 'Invalid device function'. That error (corresponding to the hipErrorInvalidDeviceFunction entry of hipError\_t ) means that the runtime could not find a device program binary of the appropriate flavor embedded into the executable.
-
-So far, the discussion has covered how data makes it from the host to the device and back. It has also discussed the device code as source, with the HIP runtime arguing that the correct binary to dispatch for execution. How can you find out what device binary flavors are embedded into the executable?
-
-## Linux and AMD
-
-The utilities included with ROCm help significantly to inspect binary artifacts on disk. Add the ROCmCC installation folder to your PATH if you want to use these utilities (the utilities expect them to be on the PATH).
-
-You can list embedded program binaries using roc-obj-ls .
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?>
-                                                                                                                                                                                                       <!>
-                                                                                                                                                                                                      <!>"
-```
-
-```
-<_SQL_>
-```
-
-The compiler embeds a version 4 code object (more on code object versions) and used the LLVM target triple amdgcnamd-amdhsa-gfx803 (more on target triples). You can extract that program object in a disassembled fashion for human consumption via roc-obj .
-
-```
-        | r o c - o b j \ - t \ g f x 8 0 3 \ - d \. / s a x p y
-```
-
-This creates two files on disk and .s extension is of most interest. Opening this file or dumping it to the console using cat lets find the disassembled binary of the SAXPY compute kernel, something similar to:
-
-```
-<_XML_>
-```
-
-Alternatively, call the compiler with --save-temps to dump all device binary to disk in separate files.
-
-```
-                                                                                                                                                                                                        |                                                                                                                                                                                                       
-                                                                                                                                                                                                        -                                                                                                                                                                                                        --                                                                                                                                                                                                        \                                                                                                                                                                                                        +                                                                                                                                                                                                        <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        }                                                                                                                                                                                                        </----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                    |   
-                                                                                                                                                                                                    |    -                                                                                                                                                                                                    |    0                                                                                                                                                                                                        ]                                                                                                                                                                                                        )                                                                                                                                                                                                       .                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        :                                                                                                                                                                                                       '
-```
-
-List all the temporaries created while compiling main.hip with:
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-    ls main-hip-amdgcn-amd-amdhsa-*
-    main-hip-amdgcn-amd-amdhsa-gfx803.bc
-    main-hip-amdgcn-amd-amdhsa-gfx803.cui
-    main-hip-amdgcn-amd-amdhsa-gfx803.o
-    main-hip-amdgcn-amd-amdhsa-gfx803.out
-    main-hip-amdgcn-amd-amdhsa-gfx803.out.resolution.txt
-    main-hip-amdgcn-amd-amdhsa-gfx803.s
-```
-
-Files with the .s extension hold the disassembled contents of the binary. The filename notes the graphics IPs used by the compiler. The contents of this file are similar to what roc-obj printed to the console.
-
-## Linux and NVIDIA
-
-Unlike HIP on AMD, when compiling using the NVIDIA support of HIP the resulting binary will be a valid CUDA executable as far as the binary goes. Therefor it'll incorporate PTX ISA (Parallel Thread eXecution Instruction Set Architecture) instead of AMDGPU binary. As s result, tooling shipping with the CUDA SDK can be used to inspect which device ISA got compiled into a specific executable. The tool most useful to us currently is cuobjdump .
-
-```
-  cuobjdump --list-ptx./saxpy
-
-  Which will print something like:
-```
-
-```
-| P T X \ f i l e
-```
-
-```
-1:  saxpy. 1. sm_5. ptx
-```
-
-From this we can see that the saxpy kernel is stored as sm\_52 , which shows that a compute capability 5.2 ISA got embedded into the executable, so devices which sport compute capability 5.2 or newer will be able to run this code.
-
-## Windows and AMD
-
-The HIP SDK for Windows don't yet sport the roc-* set of utilities to work with binary artifacts. To find out what binary formats are embedded into an executable, one may use dumpbin tool from the Windows SDK to obtain the raw data of the .hip\_fat section of an executable. (This binary payload is what gets parsed by the roc-* set of utilities on Linux.) Skipping over the reported header, the rendered raw data as ASCII has ~3 lines per entries. Depending on how many binaries are embedded, you may need to alter the number of rendered lines. An invocation such as:
-
-```
-                                                                                                                                                                                                        | dumpbin.exe  /nologo  /section:.hip_fat  /rawdata:8 .\saxpy.exe  |  select  -Skip  20  -First  12                                                                                                                                                                                                       
-                                                                                                                                                                                                        -                                                                                                                                                                                                        --                                                                                                                                                                                                        +                                                                                                                                                                                                        <--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        </--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                   | dumpbin .exe  /nologo  /section:.hip_fat  /rawdata:8 .\saxpy.exe  |  select  -Skip  20  -First  12                                                                                                                                                             |                                                                                                                                                                                                        >--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                  
-     |  dumpbin.exe  /nologo  /section:.hip_fat  /rawdata:8 .\saxpy.exe  |  select  -Skip  20  -First  12                                                                                                                                                        |                                               
-     |                                                                                                                                                                                                   |                                          
-     |                                                                                                                                                       
-     |                                                                                                                                                   |                                                    
-     |                                                                                                                                             
-     |                                                    
-     |                                                                                                                                        
-     |                                                         
-     |
-```
-
-The output may look like:
-
-```
-<_Python_>
-```
-
-We can see that the compiler embedded a version 4 code object (more on code object versions) and used the LLVM target triple amdgcn-amd-amdhsa-gfx906 (more on target triples). Don't be alarmed about linux showing up as a binary format, AMDGPU binaries uploaded to the GPU for execution are proper linux ELF binaries in their format.
-
-Alternatively we can call the compiler with --save-temps to dump all device binary to disk in separate files.
-
-```
-                                                                                                                                                                                                        |clang++.\HIP-Basic\saxpy\main.hip -o saxpy.exe -I.\Common -lamdhip64 -L ${env:HIP_PATH}                                                                                                                                                                                                       
-                                                                                                                                                                                                        -lib -02 --save-temps                                                                                                                                                                                                        \
-```
-
-Now we can list all the temporaries created while compiling main.hip via
-
-```
-        |Get-ChildItem -Filter main-hip-* | selec
-```
-
-```
-n-hip-* | select -Property Name
-                                                                                                                                                                                                         (continues on next page)
-```
-
-(continued from previous page)
-
-```
-Name
------
-main-hip-amdgcn-amd-amdhsa-gfx906.bc
-main-hip-amdgcn-amd-amdhsa-gfx906.hipi
-main-hip-amdgcn-amd-amdhsa-gfx906.o
-main-hip-amdgcn-amd-amdhsa-gfx906.out
-main-hip-amdgcn-amd-amdhsa-gfx906.out.resolution.txt
-main-hip-amdgcn-amd-amdhsa-gfx906.s
-```
-
-Files with the .s extension hold the disassembled contents of the binary and the filename directly informs us of the graphics IPs used by the compiler.
-
-```
-main-hip-amdgcn-amd-amdsha-gfx906.out
-main-hip-amdgcn-amd-amdsha-gfx906.out.resolution.txt
-main-hip-amdgcn-amd-amdsha-gfx906.s
-
-Files with the.s extension hold the disassembled contents of the binary and the filename directly informs us of the
-graphics IPs used by the compiler.
-
-Get-ChildItem main-hip-*.s | Get-Content
-           .text
-           .amdgcn_target "amdgcn-amd-amdsha--gfx906"
-           .protected        _Z12saxpy_kernelPKfPfj ; -- Begin  function _Z12saxpy_
-  --kernelPKfPfj
-           .glob1   _Z12saxpy_kernelPKfPfj
-           .p2align           8
-           .type     _Z12saxpy_kernelPKfPfj,@function
-_Z12saxpy_kernelPKfPfj:                                                                                                                                                                                                        
-  ; %bb.0:
-            s_load_dword s0, s[4:5], 0x4
-            s_load_dword s1, s[6:7], 0x18
-            s_waitcnt lgkmcnt(0)
-            s_and_b32 s0, s0, 0xffff
-            s_mul_i32 s8, s8, s0
-            v_add_u32_e32 v0, s8, v0
-            v_cmp_gt_u32_e32 vcc,  s1, v0
-            s_and_saveexec_b64 s[0:1], vcc
-            s_cbranch_execz.LBB0_2
-  ; %bb.1:
-            s_load_dwordx4 s[0:3], s[6:7], 0x8
-            v_mov_b32_e32 v1, 0
-            v_lshlrev_b64 v[0:1], 2, v[0:1]
-            s_waitcnt lgkmcnt(0)
-            v_mov_b32_e32 v3, s1
-            v_add_co_u32_e32 v2, vcc, s0, v0
-            v_addc_co_u32_e32 v3, vcc, v3, v1, vcc
-            global_load_dword v2, v[2:3], off
-            v_mov_b32_e32 v3, s3
-            v_add_co_u32_e32 v0, vcc, s2, v0
-            v_addc_co_u32_e32 v1, vcc, v3, v1, vcc
-            global_load_dword v3, v[0:1], off
-            s_load_dword s0, s[6:7], 0x0
-            s_waitcnt vmcnt(0) lgkmcnt(0)
-            v_fmac_f32_e32 v3, s0, v2
-            global_store_dword v[0:1], v3, off
- .LBB0_2:
-            s_endpgm
-           ...
-```
-
-## Windows and NVIDIA
-
-Unlike HIP on AMD, when compiling using the NVIDIA support for HIP, the resulting binary will be a valid CUDA executable. Therefore, it'll incorporate PTX ISA (Parallel Thread eXecution Instruction Set Architecture) instead of AMDGPU binary. As a result, tooling included with the CUDA SDK can be used to inspect which device ISA was compiled into a specific executable. The most helpful to us currently is cuobjdump .
-
-```
-<_Bash_>
-```
-
-```
-| P T X \ f i l e
-```
-
-```
-1:  saxpy. 1. sm_5. ptx
-```
-
-This example shows that the SAXPY kernel is stored as sm\_52 . It also shows that a compute capability 5.2 ISA was embedded into the executable, so devices that support compute capability 5.2 or newer will be able to run this code.
-
-Now that you've found what binary got embedded into the executable, find which format our available devices use.
-
-## Linux and AMD
-
-On Linux a utility called rocminfo helps us list all the properties of the devices available on the system, including which version of graphics IP ( gfxXYZ ) they employ. You can filter the output to have only these lines:
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?php?com/bin/rocminfo | grep gfx
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        </?php?com/bin/rocminfo | grep gfx
-                                                                                                                                                                                        
-	              Name:                                                                                                                                                                                                        &
-```
-
-Now that you know which graphics IPs our devices use, recompile your program with the appropriate parameters.
-
-```
-                                                                                                                                                                                                        |                                                                                                                                                                                                       
-                                                                                                                                                                                                        -                                                                                                                                                                                                        --                                                                                                                                                                                                        \                                                                                                                                                                                                        +                                                                                                                                                                                                        <                                                                                                                                                                                                        </                                                                                                                                                                                                        }                                                                                                                                                                                                        >                                                                                                                                                                                                        &                                                                                                                                                                                                        )                                                                                                                                                                                                        ]                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        :                                                                                                                                                                                                        ;                                                                                                                                                                                                       .                                                                                                                                                                                                        "
-```
-
-Now the sample will run.
-
-```
-        /saxpy
-        Calculating y[i] = a * x[i] + y[i] over 10000000 elements.
-        First 10 elements of the results: [ 3, 5, 7, 9, 11, 13, 15, 17, 19, 21 ]
-```
-
-```
-<_Python_>
-```
-
-## Linux and NVIDIA
-
-On Linux HIP with the NVIDIA back-end, the deviceQuery CUDA SDK sample can help us list all the properties of the devices available on the system, including which version of compute capability a device sports. &lt;major&gt;.&lt;minor&gt; compute capability is passed to nvcc on the command-line as sm\_&lt;major&gt;&lt;minor&gt; , for eg. 8.6 is sm\_86 .
-
-Because it's not included as a binary, compile the matching example from ROCm.
-
-```
-                                                                                                                                                                                                        |                                                                                                                                                                                                       
-                                                                                                                                                                                                        <.02                                                                                                                                                                                                        </.00                                                                                                                                                                                                        >.00                                                                                                                                                                                                      <.00                                                                                                                                                                                                      </.01                                                                                                                                                                                                        }
-```
-
-Filter the output to have only the lines of interest, for example:
-
-```
-<_YAML_>
-```
-
-Note: In addition to the nvcc executable is another tool called \_\_nvcc\_device\_query which prints the SM Architecture numbers to standard out as a comma separated list of numbers. The utility's name suggests it's not a user-facing executable but is used by nvcc to determine what devices are in the system at hand.
-
-Now that you know which graphics IPs our devices use, recompile your program with the appropriate parameters.
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <_arch=sm_70,sm_86
-```
-
-Note: If you want to portably target the development machine which is compiling, you may specify -arch=native instead.
-
-Now the sample will run.
-
-```
-           ./saxpy
-            Calculating y[i] = a * x[i] + y[i] over 10000000 elements.
-            First 10 elements of the results: [ 3, 5, 7, 9, 11, 13, 15, 17, 19, 21 ]
-```
-
-## Windows and AMD
-
-On Windows, a utility called hipInfo.exe helps us list all the properties of the devices available on the system, including which version of graphics IP ( gfxXYZ ) they employ. Filter the output to have only these lines:
-
-```
-& ${env:HIP_PATH}bin\hipInfo.exe | Select-String gfx
-
-gcnArchName:                    gfx1032
-gcnArchName:                    gfx1035
-```
-
-Now that you know which graphics IPs our devices use, recompile your program with the appropriate parameters.
-
-```
-                                                                                                                                                                                                        |clang++.\HIP-Basic\saxpy\main.hip -o saxpy.exe -I.\Common -lamdhip64 -L ${env:HIP_PATH}                                                                                                                                                                                                       
-                                                                                                                                                                                                        -lib -02 --offload-arch=gfx1032 --offload-arch=gfx1035                                                                                                                                                                                                        --lib -02 --offload-arch=gfx1035
-```
-
-Now the sample will run.
-
-```
-       .\saxpy.exe
-        Calculating y[i] = a * x[i] + y[i] over 10000000 elements.
-        First 10 elements of the results: [ 3, 5, 7, 9, 11, 13, 15, 17, 19, 21 ]
-```
-
-## Windows and NVIDIA
-
-On Windows HIP with the NVIDIA back-end, the deviceQuery CUDASDKsample can help us list all the properties of the devices available on the system, including which version of compute capability a device sports. &lt;major&gt;. &lt;minor&gt; compute capability is passed to nvcc on the command-line as sm\_&lt;major&gt;&lt;minor&gt; , for eg. 8.6 is sm\_86 .
-
-Because it's not included as a binary, compile the matching example from ROCm.
-
-```
-                                                                                                                                                                                                        |nvcc.\HIP-Basic\device_query\main.cpp -o device_query.exe -I.\Common -I ${env:HIP_PATH}                                                                                                                                                                                                       
-                                                                                                                                                                                                        -include -02                                                                                                                                                                                                        --include -0022
-```
-
-Filter the output to have only the lines of interest, for example:
-
-```
- .\device_query.exe | Select-String "major.minor"
-
-  major.minor:              8.6
-  major.minor:              7.0
-```
-
-Note: Next to the nvcc executable is another tool called \_\_nvcc\_device\_query.exe which simply prints the SM Architecture numbers to standard out as a comma separated list of numbers. The naming of this utility suggests it's not a user facing executable but is used by nvcc to determine what devices are in the system at hand.
-
-Now that you know which graphics IPs our devices use, recompile your program with the appropriate parameters.
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        --x                                                                                                                                                                                                        -x
-```
-
-Note: If you want to portably target the development machine which is compiling, you may specify -arch=native instead.
-
-Now the sample will run.
-
-```
-       .\saxpy.exe
-        Calculating y[i] = a * x[i] + y[i] over 10000000 elements.
-        First 10 elements of the results: [ 3, 5, 7, 9, 11, 13, 15, 17, 19, 21 ]
-```
-
-```
-<_Python_>
-```
-
-## CHAPTER
-
-## TWENTYNINE
-
-## REDUCTION
-
-Reduction is a common algorithmic operation used in parallel programming to reduce an array of elements into a shorter array of elements or a single value. This document exploits reduction to introduce some key considerations while designing and optimizing GPU algorithms.
-
-This document is a rejuvenation and extension of the invaluable work of Mark Harris. While the author approaches the topic with a less naive approach, reviewing some original material is valuable to see how much the underlying hardware has changed. This document provides a greater insight to demonstrate progress.
-
-## 29.1 The algorithm
-
-Reduction has many names depending on the domain; in functional programming it's referred to as fold, in C++, it's called std::accumulate and in C++17, as std::reduce . A reduction takes a range of inputs and 'reduces' the given range with a binary operation to a singular or scalar output. Canonically, a reduction requires a 'zero' element that bootstraps the algorithm and serves as one of the initial operands to the binary operation. The 'zero' element is generally called identity or neutral element in the group theory, which implies that it is an operand that doesn't change the result. Some typical use cases are: calculating a sum or normalizing a dataset and finding the maximum value in the dataset. The latter use case is discussed further in this tutorial.
-
-There are multiple variations of reduction that allow parallel processing. The approach taken by std::reduce requires the user-provided binary operator to operate on any combination of identity and input range elements, or even exclusively on any of them. This allows you to insert any number of identities to facilitate parallel processing and then combine the partial results of parallel execution.
-
-## 29.2 Reduction on GPUs
-
-Implementing reductions on GPUs requires a basic understanding of the /understand/programming\_model\_reference. The document explores aspects of low-level optimization best discussed through the Inherent thread model , and refrains from using cooperative groups.
-
-Synchronizing parallel threads of execution across a GPU is crucial for correctness as the partial results can't be synchronized before they manifest. Synchronizing all the threads running on a GPU at any given time is possible, however, it is a costly and intricate operation. If synchronization is not absolutely necessary, map the parallel algorithm so that multiprocessors and blocks can make independent progress and need not sync frequently.
-
-There are ten reduction implementations in the rocm-examples, which are described in the following sections.
-
-## 29.2.1 Naive shared reduction
-
-The naive algorithm takes a tree-like shape, where the computational domain is purposefully distributed among blocks. In all blocks, all threads participate in loading data from persistent (from the kernel's perspective) global memory into the shared memory. This helps to perform tree-like reduction for a single thread by writing the partial result to global, in a location unique to the block, which allows the block to make independent progress. The partial results are combined in subsequent launches of the same kernel until a scalar result is reached.
-
-This approach requires temporary storage based on the number of blocks launched, as each block outputs a scalar partial result. Depending on the need to store or destroy the input, a second temporary storage might be needed, which could be large enough to store the results of the second kernel launch. Alternatively, you can reuse the storage of the larger than necessary original input. These implementations differ so slightly that the document only considers the use case where the input could be destroyed.
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <std::size_t factor = block_size; // block_size from hipGetDeviceProperties()
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        </std::endl;
-                                                                                                                                                                                                       <int>                                                                                                                                                                                                        //                                                                                                                                                                                                       	                                                                                                                                                                                                      
-//                                                                                                                                                                                                        +                                                                                                                                                                                                        -                                                                                                                                                                                                        *                                                                                                                                                                                                        /                                                                                                                                                                                                        */
-                                                                                                                                                                                                       +
-                                                                                                                                                                                                       *
-                                                                                                                                                                                                       -
-                                                                                                                                                                                                       */
-```
-
-For threads that don't have unique inputs, feed zero\_elem instances to threads. The backing of double-buffering is allocated as such:
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <void>                                                                                                                                                                                                        </void>                                                                                                                                                                                                     
- 
-                                                                                                                                                                                                      <void><void>                                                                                                                                                                                                      <void></void>                                                                                                                                                                                                     
-
- 
-                                                                                                                                                                                                     
- 
-
-                                                                                                                                                                                                      <void>"                                                                                                                                                                                                        >void>                                                                                                                                                                                                      </void></void>                                                                                                                                                                                                    <void> 
-                                                                                                                                                                                                      </void><void>                                                                                                                                                                                                    <void></void></void>                                                                                                                                                                                                   
-   
-                                                                                                                                                                                                    <void>
-```
-
-Data is initialized on the host and dispatched to the device followed by the commencement of device-side reduction. The swapping of the double-buffer on the last iteration is omitted, therefore the result is in the back-buffer irrespective of the input size.
-
-```
-of the input size.
-
-for (uint32_t curr = input_count; curr > 1;)
-{
-      hipLaunchKernelGGL(
-           kernel,
-           dim3(new_size(curr)),
-           dim3(block_size),
-           factor * sizeof(unsigned),
-           hipStreamDefault,
-           front,
-           back,
-           kernel_op,
-```
-
-```
-1;)
-```
-
-(continues on next page)
-
-(continued from previous page)
-
-```
-        zero_elem,
-        curr);
-
-     curr = new_size(curr);
-     if (curr > 1)
-        std::swap(front, back);
-}
-```
-
-This structure persists in the kernel throughout all the variations of reduction with slight modifications to factor and shared memory allocation:
-
-```
-<_Cuda_>
-```
-
-While the tid % (2 * i) == 0 indexing scheme yields correct results, it also leads to high thread divergence. Thread divergence indicates the event when the threads in a warp diverge, which implies that the threads have to execute different instructions in a given clock cycle. This is easily manifested using if-else statements as shown here, but can also be manifested as for loop dependent on thread ID lengths. Even though the number of active threads participating in the reduction reduces, warps remain active longer than necessary, as at least one lane in a warp hits the if statement.
-
-## 29.2.2 Reducing thread divergence
-
-You can reduce divergence by keeping dataflow between memory addresses identical but reassigning the thread ids.
-
-```
-// Shared reduction
-for (uint32_t i = 1; i < blockDim.x; i *= 2)
-{
--    if (tid % (2 * i) == 0)
--        shared[tid] = op(shared[tid], shared[tid + i]);
-+    if (uint32_t j = 2 * i * tid; j < blockDim.x)
-+        shared[j] = op(shared[j], shared[j + i]);
-    __syncthreads();
-}
-```
-
-This way inactive threads start accumulating uniformly towards the higher thread ID index range and might uniformly skip to \_\_syncthreads() . However, this introduces a bank conflicts issue.
-
-## 29.2.3 Resolving bank conflicts
-
-Both AMD and NVIDIA implement shared memory in the hardware by organizing storage into banks of various sizes. This hardware element is known as Local Data Share (LDS) on AMD hardware. On NVIDIA hardware, it's implemented using the same silicon as the L1 data cache. You can think of shared memory as a striped 2-dimensional range of memory. Shared memory bank's count, width, and depth depend on the architecture. A bank conflict occurs when different threads in a warp access the same bank during the same operation. In this case, the hardware prevents the attempted concurrent accesses to the same bank by converting them into serial accesses.
-
-- 'AMD Instinct MI200' Instruction Set Architecture, Chapter 11.1
-- 'RDNA 2' Instruction Set Architecture, Chapter 10.1
-
-A notable exception is when the shared read uniformly broadcasts to the same address across the entire warp. A better implementation of the naive algorithm is to form continuous ranges of the threads activities and their memory accesses.
-
-```
-
-        implementation of the naive algorithm is to form continuous ranges of the threads activ
-        
-        // Shared reduction
-        -for (uint32_t i = 1; i < blockDim.x; i *= 2)
-        -{
-        -                                                                                                                                                                                                        
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        -f                                                                                                                                                                                                        +f
-```
-
-Note: To avoid bank conflicts, read shared memory in a coalesced manner, which implies that reads/writes of each lane in a warp evaluate to consecutive locations. Analyzing the read/write patterns could help you to understand the cause of bank conflicts. For more details, check CDNA3 ISA or RDNA3 ISA data share operations chapter.
-
-## 29.2.4 Utilize upper half of the block
-
-The preceding implementation is free of low-level GPU-specific anti-patterns. However, it still exhibits some common shortcomings. The loop performing the reduction in the shared memory starts from i = blockDim.x / 2 and the first predicate if (tid &lt; i) immediately disables half of the block, which only helps load the data into the shared memory. You can change the kernel along with the calculation of factor on the host, as shown here:
-
-```
-<_Cuda_>
-```
-
-By eliminating half of the threads and giving meaningful work to all the threads by unconditionally performing a binary op , you can prevent the wastage of half of the threads.
-
-Even though global memory is read in a coalesced fashion, as preferred by the memory controller, optimal performance is still limited by the instruction throughput. Omit superfluous synchronization -----------
-
-Warps are known to execute in a strict lockstep fashion. Therefore, once shared reduction reaches a point where only a single warp participates meaningfully, you can cut short the loop and let the rest of the warps terminate. Moreover, you can also unroll the loop without syncing the entire block.
-
-The tmp namespace used beyond this point in this document holds a handful of template meta-programmed utilities to facilitate writing flexible and optimal code.
-
-tmp::static\_for is not just a constant folding within the optimizer but a variation of the language for loop, where the running index is a compile-time constant and is eligible for use in compile-time evaluated contexts.
-
-Consider the following code:
-
-```
-constexpr int size = 4;
-for (int i = 0 ; i < size ; ++i)
-{
-    printf("%d", i);
-}
-```
-
-This compiles to the following binaries:
-
-## LLVM Block
-
-```
-LLVM Block
-main:
-    push    rbx
-    lea      rbx, [rip +.L.str]
-    mov     rdi, rbx
-    xor     esi, esi
-    xor     eax, eax
-    call    printf@PLT
-    mov     rdi, rbx
-    mov     esi, 1
-    xor     eax, eax
-    call    printf@PLT
-    mov     rdi, rbx
-```
-
-(continues on next page)
-
-```
-      mov     esi, 2
-      xor     eax, eax
-      call    printf@PLT
-      mov     rdi, rbx
-      mov     esi, 3
-      xor     eax, eax
-      call    printf@PLT
-      xor     eax, eax
-      pop     rbx
-      ret
-.L.str:
-     .asciz  "%d"
-      
- GCC
-```
-
-## GCC
-
-```
-  GCC
- .LC0:
-     .string "%d"
-  main:
-      push    rbx
-      xor     ebx, ebx
- .L2:
-      mov     esi, ebx
-      mov     edi, 0FFSET FLAT:.LC0
-      xor     eax, eax
-      add     ebx, 1
-      call    printf
-      cmp     ebx, 4
-      jne    .L2
-      xor     eax, eax
-      pop     rbx
-      ret
-
-  MSVC
-```
-
-## MSVC
-
-```
-  MSVC
-
-main     PROC
-      $LN12:
-      push    rbx
-      sub     rsp, 32
-      xor     ebx, ebx
-      npad    8
-  $LL4@main:
-      mov     edx, ebx
-      lea     rcx, OFFSET FLAT:'string'
-      call    printf
-      inc     ebx
-      cmp     ebx, 4
-      jl      SHORT $LL4@main
-      xor     eax, eax
-      add     rsp, 32
-      pop     rbx
-      ret     0
-  main    ENDP
-```
-
-(continued from previous page)
-
-LLVM unrolls the loop and compiles to a flat series of printf invocations, while both GCC and MSVC keep the loop intact, as visible from the compare ( cmp ) and the jump ( jne , jl ) instructions. LLVM code generation is identical to manually writing the unrolled loop:
-
-```
-printf("%d", 0);
-printf("%d", 1);
-printf("%d", 2);
-printf("%d", 3);
-```
-
-While various non-standard pragmas are available to hint or force the compiler to unroll the loop, we instead use template meta-programming to force feed the compiler the unrolled loop.
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?xml version="1.0" encoding="UTF-8" />
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        </?xml version="1.0" encoding="UTF-8" />
-```
-
-The most notable structural difference is that in the language for loop, the loop variable is given a name in the beginning, while in the static\_for utility, the loop variable is given a name in the end. An important bonus is that in the loop's body, you can use the running index i in contexts requiring constant expressions such as template arguments or inside if constexpr .
-
-tmp::static\_switch takes runtime value and runtime dispatches to a range of set of tabulated functions, where said value is a compile-time constant and is eligible for use in compile-time evaluated contexts.
-
-Consider the following code:
-
-```
-        Consider the following code:
-
-        int  warp_size  = device_props.warpSize;
-
-        switch  (warp_size)
-
-        {
-
-        case  32:
-
-            hipLaunchKernelGGL(kernel<32>, ...);
-
-            break;
-
-        case  64:
-
-            hipLaunchKernelGGL(kernel<64>, ...);
-
-            break;
-
-        }
-```
-
-In the preceding code, note the code repetition for all possible values of warp\_size , the code is prepared to handle. To avoid this, use tmp::static\_switch , as shown:
-
-```
-  tmp::static_switch<std::array{32, 64}>(warp_size, [&]<int WarpSize>
-  {
-      hipLaunchKernelGGL(kernel<WarpSize>,...);
-  });
-```
-
-```
-
-t WarpSize>()
-```
-
-```
-
-        HIP Documentation, Release 6.1.40092
-
-
-        
-        -template<typename T, typename F>
-        +template<uint32_t WarpSize, typename T, typename F>
-        __global__ void kernel(
-           ...
-        )
-        {
-           ...
-        // Shared reduction
-        -for (uint32_t i = blockDim.x / 2; i!= 0; i /= 2)
-        +for (uint32_t i = blockDim.x / 2; i > WarpSize; i /= 2)
-        {
-            if (tid < i)
-                shared[tid] = op(shared[tid], shared[tid + i]);
-            __syncthreads();
-        }
-        +// Warp reduction
-        +tmp::static_for<WarpSize, tmp::not_equal<0>, tmp::divide<2>>([&]<int I>()
-        +{
-        +     if (tid < I)
-        +          shared[tid] = op(shared[tid], shared[tid + I]);
-        +#ifdef __HIP_PLATFORM_NVIDIA__
-        +     __syncwarp(0xffffffff >> (WarpSize - I));
-        +#endif
-        +});
-
-        Because HIP typically targets hardware with warp sizes of 32(NVIDIA GPUs and RDNA AMD GPUs) and 64 (CD!
-        AMD GPUs), portable HIP code must handle both. That is why instead of assuming a warp size of 32, make the w:
-        size a template argument of the kernel. This allows you to unroll the final loop using tmp::static_for in a paramet
-```
-
-Because HIP typically targets hardware with warp sizes of 32 (NVIDIA GPUs and RDNA AMD GPUs) and 64 (CDNA AMDGPUs), portable HIP code must handle both. That is why instead of assuming a warp size of 32, make the warp size a template argument of the kernel. This allows you to unroll the final loop using tmp::static\_for in a parametric way but still having the code read much like an ordinary loop.
-
-Promoting the warp size to being a compile-time constant also requires you to handle it similarly on the host-side. You can sandwich the kernel launch with tmp::static\_switch , promoting the snake-case run-time warp\_size variable to a camel-case compile-time constant WarpSize .
-
-```
-<_C++_>
-```
-
-Note: Neither RDNA- nor CDNA-based AMD hardware provides guaranteed independent progress to lanes of the same warp. When targeting NVIDIA hardware, lanes of a warp might execute somewhat independently as long as the programmer assists the compiler using dedicated built-in functions. This feature is called Independent Thread Scheduling. The HIP headers don't expose the necessary warp primitives and their overloads.
-
-Portable applications can still tap into this feature with carefully #ifdef -ed code, but at this particular optimization level, it's a requirement. The code implicitly relies on the lockstep behavior of an ROCm wavefront, but CUDA warps don't share this property. You must synchronize all the active lanes of a warp to avoid a data race with some lanes progressing faster than others in the same warp.
-
-## 29.2.5 Unroll all loops
-
-While the previous step primarily aims to remove unnecessary syncing, it also unrolls the end of the loop. However, you could also force unrolling the first part of the loop. This saves a few scalar registers (values the compiler can prove to be uniform across warps).
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <Linear                                                                                                                                                                                                        </Linear                                                                                                                                                                                                      <Linar                                                                                                                                                                                                        >                                                                                                                                                                                                        &Linear                                                                                                                                                                                                     
- 
-                                                                                                                                                                                                      <Lin                                                                                                                                                                                                        +                                                                                                                                                                                                        -                                                                                                                                                                                                        |                                                                                                                                                                                                        }                                                                                                                                                                                                        \
-                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       <L                                                                                                                                                                                                        1                                                                                                                                                                                                        0
-```
-
-Introducing yet another template argument for the kernel and moving from for to tmp::static\_for leads to the following two notable improvements:
-
-- Introducing new attribute \_\_launch\_bounds\_\_(BlockSize) to the kernel instructs the compiler that the kernel will only be launched using the designated block size. This implies that the launches of differing block sizes will fail. This allows the optimizer to enroll the blockDim.x variable in constant folding as well as get information about register usage.
-- Turning the block size into a compile-time constant allows you to statically allocate the shared memory.
-
-## 29.2.6 Communicate using warp-collective functions
-
-Shared memory provides a fast communication path within a block, however when performing reduction within the last warp, you can use faster means of communication, which is warp-collective or cross-lane functions. Instead of using the hardware-backed shared memory, you can directly copy between the local memory (registers) of each lane in a warp. This can be achieve using the shuffle functions.
-
-See how to use \_\_shfl\_down() , which is one of the most restrictive but also the most structured communication schemes.
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        // Warp reduction
-```
-
-Using warp-collective functions for communication requires the control flow to be uniform across warps, as the name warp-collective implies. Therefore, you can see that the thread ID is being checked outside the loop, but the result is written inside due to variable scoping.
-
-## 29.2.7 Prefer warp communication over shared
-
-As mentioned in the previous step, communication between local memory is faster than shared memory. Instead of relying on the local memory only at the end of the tree-like reduction, a better approach is to turn the tree reduction inside out and perform multiple warp reductions in parallel on all active threads, thus communicating only their partial results through the shared memory.
-
-The kernel versions differ significantly enough to be described using a diff; use afresh instead.
-
-```
-        The kernel versions differ significantly enough to be described using a diff; use afresh instead.
-
-        template<uint32_t BlockSize,  uint32_t WarpSize,  typename  T,  typename  F>
-        __global__ __launch_bounds__(BlockSize)  void kernel(
-            T*  front,
-            T*  back,
-            F  op,
-            T zero_elem,
-            uint32_t  front_size)
-        {
-            // ...
-        }
-
-        The kernel estimate and the reduction factor as the comma as in variance access only the imlamantation diffar.
-```
-
-The kernel signature and the reduction factor are the same as in previous cases; only the implementation differs.
-
-```
-static constexpr uint32_t WarpCount = BlockSize / WarpSize;
-
-__shared__ T shared[WarpCount];
-
-auto read_global_safe =
-    [&](const uint32_t i) { return i < front_size? front[i] : zero_elem; };
-auto read_shared_safe =
-    [&](const uint32_t i) { return i < WarpCount? shared[i] : zero_elem; };
-
-const uint32_t tid = threadIdx.x,
-                     bid = blockIdx.x,
-                     gid = bid * (blockDim.x * 2) + tid,
-                     wid = tid / WarpSize,
-                     lid = tid % WarpSize;
-
-// Read input from front buffer to local
-T res = op(read_global_safe(gid), read_global_safe(gid + blockDim.x));
-
-As we communicate the results of warps through shared memory, the same number of elements are required in the
-shared memory as warps within the block. Similar to how you can only launch kernels at block granularity. you can
-```
-
-As we communicate the results of warps through shared memory, the same number of elements are required in the shared memory as warps within the block. Similar to how you can only launch kernels at block granularity, you can only warp reduce with WarpSize granularity due to the collective nature of the cross-lane builtins. To address this, you can use read\_shared\_safe to pad overindexing by reading zero\_elem . Reading from global remains unaffected. // Perform warp reductions and communicate results via shared // for (uint32\_t ActiveWarps = WarpCount; // ActiveWarps != 0; // ActiveWarps = ActiveWarps != 1 ? // divide\_ceil(ActiveWarps, WarpSize) : // ActiveWarps = 0) tmp::static\_for&lt; WarpCount, tmp::not\_equal&lt;0&gt;, tmp::select&lt; tmp::not\_equal&lt;1&gt;, tmp::divide\_ceil&lt;WarpSize&gt;, tmp::constant&lt;0&gt;&gt;&gt;([&amp;]&lt; uint32\_t ActiveWarps&gt;() { if (wid &lt; ActiveWarps) { // Warp reduction tmp::static\_for&lt;WarpSize / 2, tmp::not\_equal&lt;0&gt;, tmp::divide&lt;2&gt;&gt;([&amp;]&lt; int Delta&gt;() { res = op(res, \_\_shfl\_down(res, Delta)); }); // Write warp result from local to shared if (lid == 0) shared[wid] = res; } \_\_syncthreads(); // Read warp result from shared to local res = read\_shared\_safe(tid); (continues on next page)
-
-(continued from previous page)
-
-```
-});
-
-// Write result from local to back buffer
-if(tid == 0)
-    back[bid] = res;
-```
-
-ActiveWarps iterates from WarpCount until it reaches 0 . Every iteration of ActiveWarps reduces the WarpSize . In cases where the partial result count isn't a divisor of ActiveWarps and you need to launch an extra warp, use tmp::divide\_ceil , which always rounds to positive infinity. The tertiary tmp::select is required because such division never reaches 0 , so you must terminate the loop after the last warp concludes.
-
-In each iteration, if the warp is active, which means it has at least a single valid input, it carries out a pass of warp reduction and writes output based on warp ID. Reading is carried out based on thread ID. Global output continues to be based on block ID.
-
-## 29.2.8 Amortize bookkeeping variable overhead
-
-The previous sections explained how to reduce register usage to improve occupancy. This allows more blocks to execute in parallel on all multiprocessors, leading to more global store/load latency to be hidden. Reducing the number of kernels in flight while still carrying out the same workload reduces the wastage of registers while loading and maintaining bookkeeping variables such as kernel indices.
-
-An example of this optimization is performing one binary op while loading input from global. Even though the operation is said to be carried out 'in flight', the two values are loaded into local memory (registers) before op is called.
-
-Amore general form of this optimization is wrapping most kernel logic in loops that carry out the workload of multiple kernel instances but require storing only a single instance of most of the bookkeeping logic. In code, this multiplicity factor is referred to via the ItemsPerThread compile-time constant, which is supplied by a template argument to allow for loop unrolling.
-
-This kernel variant utilizes another generally applicable utility known as hip::static\_array , which is a more restrictive wrapper over the builtin array than std::array , as it allows indexing only compile-time constants using the usual tuple-like template &lt;size\_t I&gt; auto get&lt;I&gt;(...) interface.
-
-Note: On a GPU, there is no stack, and the local memory is provisioned from the register file. This provisioning takes place statically. To paraphrase, the address range of a thread's local memory is determined at compile-time. When an array is defined and used in the local storage, the compiler can only maintain its storage in the register file as long as all accesses to the array are computable by the compiler at compile-time. It doesn't need to be a compile-time constant as long as the compiler can resolve the addresses of the accesses through constant folding or some other means. If the compiler fails to do so, the array will be backed by global memory, which is indicated by allocating a non-zero number of spill registers observable using static analysis tools. However, this is slower by the magnitude of multiple order. hip::static\_array via its hip::get&lt;&gt; interface ensures that no such spills occur.
-
-```
-_t  ItemsPerThread>
-```
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        --global__ static __launch_bounds__(BlockSize) void kernel(...)
-```
-
-The kernel now has three compile-time configurable parameters. The only part of the kernel that changes depends on how you load data from global and perform the binary operation on those loaded values. So, the following step to read input from front buffer to global is now split into two steps: reading ``ItemsPerThread` &lt;reading-items&gt;`and processing ``ItemsPerThread` &lt;processing-items&gt;`.
-
-```
-<_C_>
-```
-
-## 29.2.8.1 Reading ItemsPerThread
-
-The change to reading happens inside read\_global\_safe :
-
-```
-        The change to reading happens inside read_global_safe:
-        auto  read_global_safe = [&](const  int32_t  i)  -> hip::static_array<T,  ItemsPerThread>
-        {
-            return  [&]<int32_t...  I>(std::integer_sequence<int32_t,  I...>)
-            {
-                if(i + ItemsPerThread < front_size)
-                        return hip::static_array<T,  ItemsPerThread>{
-                              front[i + I]...
-                        };
-                else
-                        return hip::static_array<T,  ItemsPerThread>{
-                              (i + I < front_size? front[i + I] : zero_elem)...
-                        };
-            }(std::make_integer_sequence<int32_t,  ItemsPerThread>());
-        };
-
-        Note that each array element is being loaded consecutively without the flexibility of a configurable ItemsPerThread
-```
-
-Note that each array element is being loaded consecutively without the flexibility of a configurable ItemsPerThread property. This is morally equivalent to:
-
-```
-T arr[4] = {
-    front[gid + 0],
-    front[gid + 1],
-    front[gid + 2],
-    front[gid + 3]
-}
-```
-
-This is exactly what's happening in the front[i + I]... fold-expression. However, this can only be issued if the entire read operates on real input without padding using zero\_elem . If some reads over-index the input, the read turns into:
-
-```
-T arr[4] = {
-    i + 0 < front_size? front[i + 0] : zero_elem,
-    i + 1 < front_size? front[i + 1] : zero_elem,
-    i + 2 < front_size? front[i + 2] : zero_elem,
-    i + 3 < front_size? front[i + 3] : zero_elem
-}
-```
-
-This makes it easier for the compiler to recognize vector loads from global. As the performance at large is dominated by how you move the data, it's only natural to utilize dedicated instructions to move more data with less binary. This is evident by the huge performance improvement when loading two values per thread. For more information, see the compiler explorer to learn how loading for AMD (both RDNA and CDNA) compiles to global\_load\_dwordx4 , where x4 denotes the 4-vector variant of the instruction.
-
-Note: Note that read\_global\_safe , which used to take an uint32\_t as the index type, now takes a signed integer. When indexing an array with unsigned integers, the compiler has to handle integer overflows, as the C/C++ standards defined them. It might happen that some part of the vector load indices overflow, thus resulting in a non-contiguous
-
-read. If you change the previously linked code to use an unsigned integer as the thread ID, the compiler won't emit a vector load. Signed integer overflow is an undefined behavior, and hence, unknown to the optimizer. To convey the absence of overflow to the compiler with unsigned indices, add \_\_builtin\_assume(gid + 4 &gt; gid) , or the more portable [[assume]](gid + 4 &gt; gid) , once amdclang++ supports it.
-
-read\_global\_safe implementation is an Immediately Invoked Lambda Expression (IILE), because ItemsPerThread is an integer value, while you need a compile-time iota -like sequence of integers as a pack for the fold-expressions to expand on. This can only occur as part of template argument deduction on the IILE.
-
-## 29.2.8.2 Processing ItemsPerThread
-
-Once the kernel reads ItemsPerThread number of inputs to local, it immediately reduces them to a scalar. There is no reason to propagate the input element multiplicity to the warp reduction phase.
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?>                                                                                                                                                                                                        </?>
-```
-
-## 29.2.9 Two-pass reduction
-
-Alter kernel launch and input fetching such that no more blocks are launched than what a subsequent kernel launch's single block can conveniently reduce, while performing multiple passes of input reading from global and combining their results before engaging in the end game tree-like reduction.
-
-With this method, you can save at least one to two kernel launches for large inputs.
-
-## 29.2.10 Global data share
-
-Warning: This modification can only be executed on AMD hardware.
-
-Perform the first step of the two-pass reduction, but in the end, instead of writing to global and reading it back in a subsequent kernel, write the partial results to the Global Data Share (GDS). This is an N+1 th shared memory that is accessed by all multiprocessors and is also on-chip memory.
-
-Note: The API doesn't guarantee the order in which blocks are scheduled even though all GPUs schedule them in the same monotonically increasing order of block ids. Relying on this implicitly, the last block of a grid is in the optimal position to observe the side effects of all other blocks (using spinlocks or other methods) without occupying a multiprocessor for longer than necessary.
-
-Without launching a second kernel, you can make the last block collect the results of all other blocks from GDS by implicitly exploiting the scheduling behavior or relying on another AMD-specific feature called Global Wave Sync (GWS) to merge them for a final tree-like reduction.
-
-Note: GDS and GWS are reserved runtime features that the HIP API doesn't cover. Invoking these functionalities requires inline AMDGCN assembly. Moreover, the fact that the runtime doesn't virtualize the GDS, imposes further restrictions on concurrent scheduling of other kernels.
-
-## 29.3 Conclusion
-
-Optimizing code on GPUs, like on any other architecture, requires careful consideration and balancing of resources and costs of various operations to obtain optimal performance. This document explored optimizing reductions much beyond the territory of diminishing returns. This approach introduced multiple optimization techniques and discussed opportunities.
-
-The document focused on reductions when an entire device participates in it. Still, the choice of optimal compile-time constants or even the algorithm itself might not be optimal when its multiple blocks participate in multiple parallel reductions or when each thread performs its reduction. However, when multiple devices participate in the same reduction, other aspects must be considered.
-
-Most solutions, including the ones covered in this document, are given to the end users in a turnkey fashion via algorithm primitive libraries. These solutions might not be the fastest in all cases, but they are close to being the gold standard for carrying out certain operations as reasonably as possible.
-
-CHAPTER
-
-## THIRTY
-
-## COOPERATIVE GROUPS
-
-This tutorial demonstrates the basic concepts of cooperative groups in the HIP (Heterogeneous-computing Interface for Portability) programming model and the most essential tooling supporting it. This topic also reviews the commonalities of heterogeneous APIs. Familiarity with the C/C++ compilation model and the language is assumed.
-
-## 30.1 Prerequisites
-
-To follow this tutorial, you'll need properly installed drivers and a HIP compiler toolchain to compile your code. Because ROCm HIP supports compiling and running on Linux and Microsoft Windows with AMD and NVIDIA GPUs, review the HIP development package installation before starting this tutorial. For more information, see Install HIP .
-
-## 30.2 Simple HIP Code
-
-To become familiar with heterogeneous programming, review the SAXPY tutorial and the first HIP code subsection. Compiling is also described in that tutorial.
-
-## 30.3 Tiled partition
-
-You can use tiled partition to calculate the sum of partition\_size length sequences and the sum of result\_size / BlockSize length sequences. The host-side reference implementation is the following:
-
-```
-    You can use ued partition to calculate the sum or partition_size length sequences and the sum or result_size/
-    BlockSize length sequences. The host-side reference implementation is the following:
-    
-    // Host-side function to perform the same reductions as executed on the GPU
-    std::vector<unsigned int> ref_reduced(const unsigned int          partition_size,
-                                                   std::vector<unsigned int> input)
-    {
-        const unsigned int          input_size  = input.size();
-        const unsigned int          result_size = input_size / partition_size;
-        std::vector<unsigned int> result(result_size);
-
-        for(unsigned int i = 0; i < result_size; i++)
-        {
-            unsigned int partition_result = 0;
-            for(unsigned int j = 0; j < partition_size; j++)
-            {
-                partition_result += input[partition_size * i + j];
-            }
-                                                                                                                                                                                                         (continues on next page)
-```
-
-(continues on next page)
-
-```
-            result[i] = partition_result;
-        }
-
-        return result;
-    }
-```
-
-## 30.3.1 Device-side code
-
-To calculate the sum of the sets of numbers, the tutorial uses the shared memory-based reduction on the device side. The warp level intrinsics usage is not covered in this tutorial, unlike in the reduction tutorial. x input variable is a shared pointer, which needs to be synchronized after every value change. The thread\_group input parameter can be thread\_block\_tile or thread\_block because the thread\_group is the parent class of these types. The val are the numbers to calculate the sum of. The returned results of this function return the final results of the reduction on thread ID 0 of the thread\_group , and for every other thread, the function results are 0.
-
-```
-        The warp level intrinsics usage is not covered in this tutorial, unlike in the reduction tutorial. x input variable is a
-        shared pointer, which needs to be synchronized after every value change. The thread_group input parameter can be
-        thread_block_tile or thread_block because the thread_group is the parent class of these types. The val are
-        the numbers to calculate the sum of. The returned results of this function return the final results of the reduction on
-        thread ID 0 of the thread_group, and for every other thread, the function results are 0.
-
-        /// \brief Summation of `unsigned int val`s in `thread_group g` using shared memory `x`
-        __device__ unsigned int reduce_sum(thread_group g, unsigned int* x, unsigned int val)
-    {
-            // Rank of this thread in the group
-            const unsigned int group_thread_id = g.thread_rank();
-
-            // We start with half the group size as active threads
-            // Every iteration the number of active threads halves, until we processed all values
-            for(unsigned int i = g.size() / 2; i > 0; i /= 2)
-            {
-                // Store value for this thread in a shared, temporary array
-                x[group_thread_id] = val;
-
-                // Synchronize all threads in the group
-                g.sync();
-
-                // If our thread is still active, sum with its counterpart in the other half
-                if(group_thread_id < i)
-                {
-                    val += x[group_thread_id + i];
-                }
-
-                // Synchronize all threads in the group
-                g.sync();
-            }
-
-            // Only the first thread returns a valid value
-            if(g.thread_rank() == 0)
-                return val;
-            else
-                return 0;
-    }
-
-        The reduce_sum device function is reused to calculate the block and custom partition sum of the input numbers. The
-        kernel has three sections:
-
-        1. Initialization of the reduction function variables.
-```
-
-The reduce\_sum device function is reused to calculate the block and custom partition sum of the input numbers. The kernel has three sections:
-
-1. Initialization of the reduction function variables.
-
-(continued from previous page)
-
-2. The reduction of thread block and store the results in global memory.
-3. The reduction of custom partition and store the results in global memory.
-
-## 30.3.1.1 1. Initialization of the reduction function variables
-
-In this code section, the shared memory is declared, the thread\_block\_group and custom\_partition are defined, and the input variables are loaded from global memory.
-
-```
-
-
-in this code section, the shared memory is declared, the thread_block_group and custom_partition are define
-input variables are loaded from global memory.
-
-// threadBlockGroup consists of all threads in the block
-thread_block thread_block_group = this_thread_block();
-
-// Workspace array in shared memory required for reduction
-__shared__ unsigned int workspace[2048];
-
-unsigned int output;
-
-// Input to reduce
-const unsigned int input = d_vector[thread_block_group.thread_rank()];
-
-//...
-
-// Every custom_partition group consists of 16 threads
-thread_block_tile<PartitionSize> custom_partition
-           = tiled_partition<PartitionSize>(thread_block_group);
-
-
-
-as a 2 - 2 The read-line of thread block
-```
-
-## 30.3.1.2 2. The reduction of thread block
-
-In this code section, the sum is calculated on thread\_block\_group level, then the results are stored in global memory.
-
-```
-// Perform reduction
-output = reduce_sum(thread_block_group, workspace, input);
-
-// Only the first thread returns a valid value
-if(thread_block_group.thread_rank() == 0)
-{
-    d_block_reduced_vector[0] = output;
-}
-```
-
-## 30.3.1.3 3. The reduction of custom partition
-
-In this code section, the sum is calculated on the custom partition level, then the results are stored in global memory. The custom partition is a partial block of the thread block, it means the reduction calculates on a shorter sequence of input numbers than at the thread\_block\_group case.
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        // Perform reduction                                                                                                                                                                                                        }
-                                                                                                                                                                                                      
-output = reduce_sum(custom_partition, &workspace[group_offset], input);
-
-                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       // Only the first thread in each partition returns a valid value                                                                                                                                                                                                        \
-                                                                                                                                                                                                       \
-
-                                                                                                                                                                                                       \
-```
-
-(continued from previous page)
-
-```
-        const unsigned int partition_id           = thread_block_group.thread_rank() /\__
-        ~PartitionSize;
-        d_partition_reduced_vector[partition_id] = output;
-    }
-```
-
-## 30.3.2 Host-side code
-
-On the host-side, the following steps are done in the example:
-
-1. Confirm the cooperative group support on AMD GPUs.
-2. Initialize the cooperative group configuration.
-3. Allocate and copy input to global memory.
-4. Launch the cooperative kernel.
-5. Save the results from global memory.
-6. Free the global memory.
-
-Only the first, second and fourth steps are important from the cooperative groups aspect, that's why those steps are detailed further.
-
-## 30.3.2.1 1. Confirm the cooperative group support on AMD GPUs
-
-Not all AMD GPUs support cooperative groups. You can confirm support with the following code:
-
-```
-<_C++_>
-```
-
-## 30.3.2.2 2. Initialize the cooperative group configuration
-
-In the example, there is only one block in the grid, and the threads\_per\_block must be dividable with partition\_size .
-
-```
-<_C_>
-```
-
-## 30.3.2.3 4. Launch the kernel
-
-The kernel launch is done with the hipLaunchCooperativeKernel of the cooperative groups API.
-
-```
-        The kernel launch is done with the hipLaunchCooperativeKernel of the cooperative groups API.
-        void* params[] = {&d_vector,  &d_block_reduced,  &d_partition_reduced};
-        // Launching kernel from host.
-        HIP_CHECK(hipLaunchCooperativeKernel(vector_reduce_kernel<partition_size>,
-```
-
-## 30.4 Conclusion
-
-With cooperative groups, you can easily use custom partitions to create custom tiles for custom solutions. You can find the complete code at cooperative groups ROCm example.
-
-## CHAPTER
-
-## THIRTYONE
-
-## LICENSE
-
-Copyright © 2008 - 2024 Advanced Micro Devices, Inc.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-## INDEX
-
-| C                                                                                                           | hipArrayCreate ( C++ function ), 183                                                                        |    |     |      |     |          |
-|-------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------|----|-----|------|-----|----------|
-| cooperative_groups::coalesced_group class ), 237                                                            | C++ hipArrayDestroy ( C++ function ), 183 hipArrayGetDescriptor ( C++ function ), 185 ( C++ function ), 185 | (  |     |      |     |          |
-| cooperative_groups::grid_group ( C++ class ), 234                                                           | hipArrayGetInfo hipCreateSurfaceObject ( C++ function ), 133                                                |    |     |      |     |          |
-| cooperative_groups::multi_grid_group ( C++                                                                  | ( C++ function ), 197                                                                                       |    |     |      |     |          |
-| class ), 234 cooperative_groups::thread_block ( C++                                                         | ), hipDestroyExternalMemory ( C++ function ), 196                                                           |    |     |      |     |          |
-| class 234                                                                                                   | hipDestroyExternalSemaphore hipDestroySurfaceObject ( C++ function ), 133 C++ function                      |    |     |      |     |          |
-| cooperative_groups::thread_block_tile ( C++ class ), 234                                                    | hipDeviceCanAccessPeer ( ), 163 hipDeviceDisablePeerAccess ( C++ function ), 164 ( C++ function ), 163      |    |     |      |     |          |
-| cooperative_groups::thread_block_tile::all ( C++ function ), 236 cooperative_groups::thread_block_tile::any | hipDeviceEnablePeerAccess hipDeviceGetStreamPriorityRange ( C++ function ), 148                             |    |     |      |     |          |
-| ( C++ function ), 236                                                                                       | hipDrvMemcpy3D ( C++ function ), 192                                                                        |    |     |      |     |          |
-| cooperative_groups::thread_block_tile::ballot                                                               | hipDrvMemcpy3DAsync ( C++ function ), 192                                                                   |    |     |      |     |          |
-|                                                                                                             | hipDrvPointerGetAttributes ( C++ function ), 166                                                            |    |     |      |     |          |
-| ( C++ function ), 236                                                                                       |                                                                                                             |    |     |      |     |          |
-| cooperative_groups::thread_block_tile::match_all                                                            | hipExternalMemoryGetMappedBuffer ( C++ func- tion ), 196                                                    |    |     |      |     |          |
-| ( C++ function ), 237 cooperative_groups::thread_block_tile::match_any                                      | hipExternalMemoryGetMappedMipmappedArray ( C++ function ), 197 hipExtMallocWithFlags ( C++ function ), 167  |    | 236 | ( ), | C++ | function |
-| cooperative_groups::thread_block_tile::meta_group_rank ( C++ function ), 235                                | hipExtStreamCreateWithCUMask ( C++function ), 151 hipExtStreamGetCUMask ( C++ function ), 152               |    |     |      |     |          |
-|                                                                                                             | hipFree ( C++ function ), 171 hipFreeArray ( C++ function ), 184                                            |    |     |      |     |          |
-| cooperative_groups::thread_block_tile::meta_group_size ( C++ function ), 235                                | hipFreeAsync                                                                                                |    |     |      |     |          |
-| cooperative_groups::thread_block_tile::shfl ( C++ function ), 235                                           |                                                                                                             |    |     |      |     |          |
-|                                                                                                             | ( C++ function ), 154                                                                                       |    |     |      |     |          |
-| cooperative_groups::thread_block_tile::shfl_down                                                            |                                                                                                             |    |     |      |     |          |
-| ( C++ function ), 235                                                                                       | hipFreeHost ( C++ function ), 172 hipGetProcAddress ( C++ function ), 176                                   |    |     |      |     |          |
-| cooperative_groups::thread_block_tile::shfl_up                                                              | hipGetSymbolAddress ( C++ function ), 176, 193 ( C++ function ), 176, 193                                   |    |     |      |     |          |
-| ( C++ function ), 235                                                                                       | hipHostAlloc ( C++ function ), 168 hipHostFree ( C++ function ), 172                                        |    |     |      |     |          |
-| ( C++ function ), 236                                                                                       | ( C++ function ),                                                                                           |    |     |      |     |          |
-| cooperative_groups::thread_block_tile::sync ( C++ function ), 235                                           | 169 ( C++ function ), 169                                                                                   |    |     |      |     |          |
-| cooperative_groups::thread_block_tile::thread_rank ( C++ function ), 235 ),                                 | ( C++ function ), 169                                                                                       |    |     |      |     |          |
-| cooperative_groups::thread_group ( C++ class                                                                | ( C++ function ), 170 ( C++ function ),                                                                     |    |     |      |     |          |
-| 234                                                                                                         | 196 ( C++ function ),                                                                                       |    |     |      |     |          |
-|                                                                                                             | ( C++ function ), 166, 194                                                                                  |    |     |      |     |          |
-| H                                                                                                           | hipMalloc hipMalloc3D                                                                                       |    |     |      |     |          |
-|                                                                                                             | ( C++ function ), 184                                                                                       |    |     |      |     |          |
-| hipArray3DCreate ( C++ function ), 183                                                                      |                                                                                                             |    |     |      |     |          |
-| 185                                                                                                         | hipMalloc3DArray ( C++ function ),                                                                          |    |     |      |     |          |
-| hipArray3DGetDescriptor ( C++ function ),                                                                   |                                                                                                             |    |     |      |     |          |
-|                                                                                                             | 195                                                                                                         |    |     |      |     |          |
-|                                                                                                             | 184                                                                                                         |    |     |      |     |          |
-|                                                                                                             | hipImportExternalSemaphore                                                                                  |    |     |      |     |          |
-|                                                                                                             | hipImportExternalMemory                                                                                     |    |     |      |     |          |
-|                                                                                                             | hipHostMalloc ( C++ function ), 168, 194 hipHostRegister hipHostUnregister                                  |    |     |      |     |          |
-|                                                                                                             | hipHostGetDevicePointer hipHostGetFlags                                                                     |    |     |      |     |          |
-|                                                                                                             | hipGetSymbolSize                                                                                            |    |     |      |     |          |
-|                                                                                                             | cooperative_groups::thread_block_tile::shfl_xor                                                             |    |     |      |     |          |
-
-| hipMallocArray ( C++ function ), 182 ( C++ function ), 152,                                |
-|--------------------------------------------------------------------------------------------|
-| 153 hipMallocFromPoolAsync ( C++ function ), 153, 160                                      |
-| hipMallocHost ( C++ function ), 167                                                        |
-| hipMallocManaged ( C++ function ), 247, 249                                                |
-| hipMallocPitch ( C++ function ), 170                                                       |
-| hipMemAddressFree ( C++ function ), 251                                                    |
-| hipMemAddressReserve ( C++ function ), 251                                                 |
-| hipMemAdvise ( C++ function ), 247                                                         |
-| hipMemAllocHost ( C++ function ), 167                                                      |
-| hipMemAllocPitch ( C++ function ), 171                                                     |
-| hipMemcpy ( C++ function ), 172                                                            |
-| hipMemcpy2D ( C++ function ), 186                                                          |
-| hipMemcpy2DAsync ( C++ function ), 187                                                     |
-| hipMemcpy2DFromArray ( C++ function ), 190                                                 |
-| hipMemcpy2DFromArrayAsync ( C++ function ), 190                                            |
-| hipMemcpy2DToArray ( C++ function ), 188                                                   |
-| hipMemcpy2DToArrayAsync ( C++ function ), 188                                              |
-| hipMemcpy3D ( C++ function ), 191                                                          |
-| hipMemcpy3DAsync ( C++ function ), 192                                                     |
-| hipMemcpyAsync ( C++ function ), 178                                                       |
-| hipMemcpyAtoH ( C++ function ), 191                                                        |
-| hipMemcpyDtoD ( C++ function ), 174                                                        |
-| hipMemcpyDtoDAsync ( C++ function ), 175 hipMemcpyDtoH ( C++ function ), 174               |
-| hipMemcpyDtoHAsync ( C++ function ), 175                                                   |
-| hipMemcpyFromArray ( C++ function ), 189                                                   |
-| hipMemcpyFromSymbol ( C++ function ),                                                      |
-| 177,                                                                                       |
-| 194 hipMemcpyFromSymbolAsync ( C++ function ), 178, 194                                    |
-| hipMemcpyHtoA ( C++ function ), 191                                                        |
-| hipMemcpyHtoD ( C++ function ), 173 hipMemcpyHtoDAsync ( C++ function ),                   |
-| hipMemcpyParam2D ( C++ function ),                                                         |
-| 174 186                                                                                    |
-| hipMemcpyParam2DAsync ( C++ function ),                                                    |
-| 187 hipMemcpyToArray ( C++ function ), 189 ( C++ function ), 177,                          |
-| hipMemcpyToSymbol 193 hipMemcpyToSymbolAsync ( C++ function ), 193                         |
-| 177, ( C++ function ), 173                                                                 |
-| hipMemcpyWithStream hipMemCreate ( C++ function ), 252                                     |
-| hipMemExportToShareableHandle (                                                            |
-| C++ function 252 ( C++ function ), 252                                                     |
-| hipMemGetAddressRange ( C++ function ), 164 hipMemGetAllocationGranularity ( C++           |
-| function 253 hipMemGetAllocationPropertiesFromHandle                                       |
-| ( C++ function ), 253                                                                      |
-| hipMemGetInfo ( C++ function ), 182 hipMemImportFromShareableHandle ( C++ function         |
-| 253 hipMemMap ( C++ function ), 254 hipMemMapArrayAsync ( C++ function ), hipMemPoolCreate |
-| 254 ( C++ function ), 158                                                                  |
-| hipMemPoolDestroy 159                                                                      |
-| ( C++ function ),                                                                          |
-
-C++ function
-
-(
-
-), 162
-
-| hipMemPoolExportPointer hipMemPoolExportToShareableHandle ( C++                          | func-                                                                                    |
-|------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------|
-| tion ), 160                                                                              | tion ), 160                                                                              |
-| hipMemPoolGetAccess ( C++ function ), 158 hipMemPoolGetAttribute ( C++ function ), 156   | hipMemPoolGetAccess ( C++ function ), 158 hipMemPoolGetAttribute ( C++ function ), 156   |
-| hipMemPoolImportFromShareableHandle function ), 161                                      | ( C++                                                                                    |
-| hipMemPoolImportPointer ( C++ function ), 162 hipMemPoolSetAccess ( C++ function ), 157  | hipMemPoolImportPointer ( C++ function ), 162 hipMemPoolSetAccess ( C++ function ), 157  |
-| hipMemPoolSetAttribute ( C++ function ), 156                                             | hipMemPoolSetAttribute ( C++ function ), 156                                             |
-| hipMemPoolTrimTo ( C++ function ), 155                                                   | hipMemPoolTrimTo ( C++ function ), 155                                                   |
-| hipMemPrefetchAsync ( C++ function ), 247                                                | hipMemPrefetchAsync ( C++ function ), 247                                                |
-| hipMemPtrGetInfo ( C++ function ), 182                                                   | hipMemPtrGetInfo ( C++ function ), 182                                                   |
-| hipMemRangeGetAttribute ( C++ function ), 248                                            | hipMemRangeGetAttribute ( C++ function ), 248                                            |
-| hipMemRangeGetAttributes ( C++ function ), 248                                           | hipMemRangeGetAttributes ( C++ function ), 248                                           |
-| hipMemRelease ( C++ function ), 255                                                      | hipMemRelease ( C++ function ), 255                                                      |
-| hipMemRetainAllocationHandle ( C++function ), 255                                        | hipMemRetainAllocationHandle ( C++function ), 255                                        |
-| hipMemset ( C++ function ), 179                                                          | hipMemset ( C++ function ), 179                                                          |
-| hipMemset2D ( C++ function ), 181                                                        | hipMemset2D ( C++ function ), 181                                                        |
-| hipMemset2DAsync ( C++ function ), 181                                                   | hipMemset2DAsync ( C++ function ), 181                                                   |
-| hipMemset3D ( C++ function ), 181                                                        | hipMemset3D ( C++ function ), 181                                                        |
-| hipMemset3DAsync ( C++ function ), 182                                                   | hipMemset3DAsync ( C++ function ), 182                                                   |
-| hipMemSetAccess ( C++ function ), 255                                                    | hipMemSetAccess ( C++ function ), 255                                                    |
-| hipMemsetAsync ( C++ function ), 180                                                     | hipMemsetAsync ( C++ function ), 180                                                     |
-| hipMemsetD16 ( C++ function ), 180 hipMemsetD16Async ( C++ function ), 180               | hipMemsetD16 ( C++ function ), 180 hipMemsetD16Async ( C++ function ), 180               |
-| hipMemsetD32 ( C++ function ), 180                                                       | hipMemsetD32 ( C++ function ), 180                                                       |
-| hipMemsetD32Async ( C++ function ), 181                                                  | hipMemsetD32Async ( C++ function ), 181                                                  |
-| hipMemsetD8 ( C++ function ), 179                                                        | hipMemsetD8 ( C++ function ), 179                                                        |
-| hipMemsetD8Async ( C++ function ), 179                                                   | hipMemsetD8Async ( C++ function ), 179                                                   |
-| hipMemUnmap ( C++ function ), 256                                                        | hipMemUnmap ( C++ function ), 256                                                        |
-| hipModuleGetGlobal ( C++ function ), 176                                                 | hipModuleGetGlobal ( C++ function ), 176                                                 |
-| ( C++ function ), 165                                                                    | ( C++ function ), 165                                                                    |
-| hipPointerGetAttribute hipPointerGetAttributes ( C++ function ), 165                     | hipPointerGetAttribute hipPointerGetAttributes ( C++ function ), 165                     |
-| hipPointerSetAttribute ( C++ function ), 165                                             | hipPointerSetAttribute ( C++ function ), 165                                             |
-| hipSignalExternalSemaphoresAsync ( C++ func- tion ), 195                                 | hipSignalExternalSemaphoresAsync ( C++ func- tion ), 195                                 |
-| hipStreamAddCallback ( C++ function ), 152 hipStreamAttachMemAsync ( C++ function ), 249 | hipStreamAddCallback ( C++ function ), 152 hipStreamAttachMemAsync ( C++ function ), 249 |
-| hipStreamCallback_t ( C++ type ), 147 ( C++ function ), 147                              | hipStreamCallback_t ( C++ type ), 147 ( C++ function ), 147                              |
-| hipStreamCreate hipStreamCreateWithFlags ( C++ function ), 147                           | hipStreamCreate hipStreamCreateWithFlags ( C++ function ), 147                           |
-| hipStreamCreateWithPriority ( C++ function ), 147 hipStreamDestroy ( C++ function ), 148 | hipStreamCreateWithPriority ( C++ function ), 147 hipStreamDestroy ( C++ function ), 148 |
-| hipStreamGetDevice ( C++ function ), 151                                                 | hipStreamGetDevice ( C++ function ), 151                                                 |
-| hipStreamGetFlags ( C++ function ), 150                                                  | hipStreamGetFlags ( C++ function ), 150                                                  |
-| hipStreamGetPriority ( C++ function ), 150 hipStreamQuery ( C++ function ), 149          | hipStreamGetPriority ( C++ function ), 150 hipStreamQuery ( C++ function ), 149          |
-| hipStreamSynchronize ( C++ function ), 149                                               | hipStreamSynchronize ( C++ function ), 149                                               |
-| hipStreamWaitEvent                                                                       | hipStreamWaitEvent                                                                       |
-| ( C++ function ), 149                                                                    | ( C++ function ), 149                                                                    |
-| hipWaitExternalSemaphoresAsync ( C++ function ), 195                                     | hipWaitExternalSemaphoresAsync ( C++ function ), 195                                     |
-| hsa_amd_vmem_address_free ( C++ function ), 241                                          | hsa_amd_vmem_address_free ( C++ function ), 241                                          |
-| hsa_amd_vmem_address_reserve ( C++function ),                                            |                                                                                          |
-| 241                                                                                      | 241                                                                                      |
-
-| hsa_amd_vmem_export_shareable_handle function ), 244                |                                                                     |
-|---------------------------------------------------------------------|---------------------------------------------------------------------|
-| hsa_amd_vmem_get_access ( C++ function ), 243                       | hsa_amd_vmem_get_access ( C++ function ), 243                       |
-| hsa_amd_vmem_get_alloc_properties_from_handle ( C++ function ), 245 | hsa_amd_vmem_get_alloc_properties_from_handle ( C++ function ), 245 |
-| hsa_amd_vmem_handle_create ( C++ function ), 242                    | hsa_amd_vmem_handle_create ( C++ function ), 242                    |
-| hsa_amd_vmem_handle_release ( C++ function ), 242                   | hsa_amd_vmem_handle_release ( C++ function ), 242                   |
-| hsa_amd_vmem_import_shareable_handle function ), 244                | ( C++                                                               |
-| hsa_amd_vmem_map ( C++ function ), 242                              | hsa_amd_vmem_map ( C++ function ), 242                              |
-| hsa_amd_vmem_retain_alloc_handle ( C++ tion ), 245                  | func-                                                               |
-| hsa_amd_vmem_set_access ( C++ function ), 243                       | hsa_amd_vmem_set_access ( C++ function ), 243                       |
-| hsa_amd_vmem_unmap ( C++ function ), 243                            | hsa_amd_vmem_unmap ( C++ function ), 243                            |
-
-## S
-
-| surf1DLayeredread                             |
-|-----------------------------------------------|
-| surf1DLayeredwrite ( C++ function ), 135      |
-| surf1Dread ( C++ function ), 133              |
-| surf1Dwrite ( C++ function ), 133             |
-| surf2DLayeredread ( C++ function ), 135       |
-| surf2DLayeredwrite ( C++ function ), 135      |
-| surf2Dread ( C++ function ), 134              |
-| surf2Dwrite ( C++ function ), 134             |
-| surf3Dread ( C++ function ), 134              |
-| surf3Dwrite ( C++ function ), 134             |
-| surfCubemapLayeredread ( C++ function ), 136  |
-| surfCubemapLayeredwrite ( C++ function ), 137 |
-| surfCubemapread ( C++ function ), 136         |
-| surfCubemapwrite ( C++ function ), 136        |
-
-## U
-
-USE\_PEER\_NON\_UNIFIED ( C macro ), 164
\ No newline at end of file
diff --git a/kernel-agentic/docs/hip/hip_spec_mm/hip_spec-with-image-refs_artifacts/image_000000_5208c655dc4611802372524b387216259e5e5c3c192ee9dd1c1c8e76383cd3f6.png b/kernel-agentic/docs/hip/hip_spec_mm/hip_spec-with-image-refs_artifacts/image_000000_5208c655dc4611802372524b387216259e5e5c3c192ee9dd1c1c8e76383cd3f6.png
deleted file mode 100644
index f8ff16e..0000000
Binary files a/kernel-agentic/docs/hip/hip_spec_mm/hip_spec-with-image-refs_artifacts/image_000000_5208c655dc4611802372524b387216259e5e5c3c192ee9dd1c1c8e76383cd3f6.png and /dev/null differ
diff --git a/kernel-agentic/docs/hip/hip_spec_mm/hip_spec-with-image-refs_artifacts/image_000001_bfcf0651eef1f236f619420b33a1d732aeb71e35bd879a965fdc6375d5204886.png b/kernel-agentic/docs/hip/hip_spec_mm/hip_spec-with-image-refs_artifacts/image_000001_bfcf0651eef1f236f619420b33a1d732aeb71e35bd879a965fdc6375d5204886.png
deleted file mode 100644
index e1e135e..0000000
Binary files a/kernel-agentic/docs/hip/hip_spec_mm/hip_spec-with-image-refs_artifacts/image_000001_bfcf0651eef1f236f619420b33a1d732aeb71e35bd879a965fdc6375d5204886.png and /dev/null differ
diff --git a/kernel-agentic/docs/hip/hip_spec_mm/hip_spec-with-image-refs_artifacts/image_000002_cfbddcc77ec59fe03ed26460c2aa6a54c9646387476d59ddc5eaabf5c6641187.png b/kernel-agentic/docs/hip/hip_spec_mm/hip_spec-with-image-refs_artifacts/image_000002_cfbddcc77ec59fe03ed26460c2aa6a54c9646387476d59ddc5eaabf5c6641187.png
deleted file mode 100644
index d8b8f39..0000000
Binary files a/kernel-agentic/docs/hip/hip_spec_mm/hip_spec-with-image-refs_artifacts/image_000002_cfbddcc77ec59fe03ed26460c2aa6a54c9646387476d59ddc5eaabf5c6641187.png and /dev/null differ
diff --git a/kernel-agentic/docs/hip/hip_spec_mm/hip_spec-with-image-refs_artifacts/image_000003_8ba501e7c1e4fd45f649ac07d48e9985a382fa290507dbd9ebd5ecafa7f23bd2.png b/kernel-agentic/docs/hip/hip_spec_mm/hip_spec-with-image-refs_artifacts/image_000003_8ba501e7c1e4fd45f649ac07d48e9985a382fa290507dbd9ebd5ecafa7f23bd2.png
deleted file mode 100644
index cf1c264..0000000
Binary files a/kernel-agentic/docs/hip/hip_spec_mm/hip_spec-with-image-refs_artifacts/image_000003_8ba501e7c1e4fd45f649ac07d48e9985a382fa290507dbd9ebd5ecafa7f23bd2.png and /dev/null differ
diff --git a/kernel-agentic/docs/hip/hip_spec_mm/hip_spec-with-image-refs_artifacts/image_000004_b494ff70840b694ceb0cb8c49613faf77041d4148e4ceb04903608a8022e3cbd.png b/kernel-agentic/docs/hip/hip_spec_mm/hip_spec-with-image-refs_artifacts/image_000004_b494ff70840b694ceb0cb8c49613faf77041d4148e4ceb04903608a8022e3cbd.png
deleted file mode 100644
index 48edb1d..0000000
Binary files a/kernel-agentic/docs/hip/hip_spec_mm/hip_spec-with-image-refs_artifacts/image_000004_b494ff70840b694ceb0cb8c49613faf77041d4148e4ceb04903608a8022e3cbd.png and /dev/null differ
diff --git a/kernel-agentic/docs/hip/hip_spec_mm/hip_spec-with-images-enhanced.md b/kernel-agentic/docs/hip/hip_spec_mm/hip_spec-with-images-enhanced.md
deleted file mode 100644
index 69ae041..0000000
--- a/kernel-agentic/docs/hip/hip_spec_mm/hip_spec-with-images-enhanced.md
+++ /dev/null
@@ -1,12243 +0,0 @@
-## HIP Documentation Release 6.1.40092
-
-Advanced Micro Devices, Inc.
-
-Sep 13, 2024
-
-## INSTALL
-**Following table contains:** The table appears to represent a structured outline or table of contents for a document or guide related to installing and building HIP (Heterogeneous-Compute Interface for Portability). Each row corresponds to a section or subsection of the document.
-
-- The first column seems to indicate the main section number or title.
-- The second column provides a more detailed section or subsection number.
-- The third column contains the title or description of the section or subsection.
-- The fourth column appears to indicate a page number where the section or subsection can be found.
-
-Noteworthy values include:
-- The main sections are "1 Overview" and "3 Build HIP from source."
-- Subsections under "Install HIP" include "Prerequisites," "Installation," and "Verify your installation."
-- The page numbers suggest that the "Overview" section spans pages 3 to 6, while "Build HIP from source" starts on page 7.
-
-
-| 1 Overview   | 1 Overview                                                   | 1 Overview                                                   | 3     |
-|--------------|--------------------------------------------------------------|--------------------------------------------------------------|-------|
-|              | Install HIP                                                  | Install HIP                                                  |       |
-| 2            |                                                              |                                                              | 5     |
-|              | 2.1                                                          | Prerequisites . . . . . . . . .                              | 5     |
-|              | 2.2                                                          | Installation . . .                                           | 5     |
-|              | 2.3                                                          | . . . . . Verify your installation . . .                     | 6     |
-| 3            | Build HIP from source                                        | Build HIP from source                                        | 7     |
-|              | 3.1 Prerequisites                                            | . . . . . .                                                  |       |
-|              |                                                              | . .                                                          | 7     |
-|              | 3.2 Building the HIP runtime 3.3 . .                         | .                                                            | 7     |
-|              | Build HIP tests . . .                                        | Build HIP tests . . .                                        | 10    |
-|              | . . . 3.4 Run HIP . . . . . . . . . . .                      | . . . 3.4 Run HIP . . . . . . . . . . .                      | 11    |
-| 4            | HIP programming model                                        | HIP programming model                                        | 13    |
-|              | 4.1                                                          | 4.1                                                          | 13    |
-| 4.2          | RDNA &CDNAarchitecture summary Heterogeneous Programming . . | RDNA &CDNAarchitecture summary Heterogeneous Programming . . | 14    |
-|              | Single instruction multiple threads (SIMT) . . .             | Single instruction multiple threads (SIMT) . . .             | 14    |
-| 4.3 4.4      | Inherent thread model . .                                    | Inherent thread model . .                                    | 15    |
-| 4.5          | . . . . 4.4.1 Cooperative groups thread                      | . . . . 4.4.1 Cooperative groups thread                      | 16    |
-|              | Memory model . . . . . . . . .                               | Memory model . . . . . . . . .                               | 16    |
-|              | 4.6 Execution model .                                        | . . . . .                                                    | 17    |
-|              | 4.6.1 Host-side                                              | 4.6.1 Host-side                                              |       |
-|              |                                                              | execution                                                    | 17 17 |
-|              | 4.6.2                                                        | Device-side execution . .                                    |       |
-|              | 4.6.3                                                        | Kernel launch .                                              | 18    |
-| 5            | Hardware implementation                                      | Hardware implementation                                      | 19    |
-|              | Compute units                                                | . . . . . . .                                                | 19    |
-|              |                                                              | . . . . .                                                    | 20    |
-| 5.1          | 5.1.1 5.1.2                                                  | SIMD . . Vector cache . .                                    | 20    |
-|              | 5.1.3                                                        | . . Local data share . .                                     | 20    |
-|              | 5.1.4                                                        | Scalar Unit . . . .                                          | 20    |
-|              | 5.2 CDNA architecture .                                      | . . . .                                                      | 20    |
-|              | 5.3 RDNA architecture . .                                    | . . . .                                                      | 21    |
-|              | 5.4 Shader engines . .                                       | . . . .                                                      | 21    |
-|              | (CLR)                                                        | (CLR)                                                        |       |
-| 6            | AMDcommon language runtimes                                  | AMDcommon language runtimes                                  | 23    |
-|              | 6.1 Project organization                                     | . . . .                                                      | 23    |
-|              | How to build/install .                                       | . . .                                                        | 23    |
-| 6.2          | 6.2.1                                                        | Prerequisites . . .                                          | 23    |
-|              | 6.2.2                                                        | Linux . . . . . . .                                          | 23    |
-|              | 6.2.3                                                        | Test . . . . . . . .                                         | 24    |
-
-|                                           | 6.2.4                                                                                      | Release notes . . . . . . . . . . . . . . . . . . . . .                                    | 24    |
-|-------------------------------------------|--------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------|-------|
-| HIP programming manual                    | HIP programming manual                                                                     | HIP programming manual                                                                     | 25    |
-| 7 7.1                                     | Host Memory . . . . .                                                                      | . . . . . . . . . . . . . . . . . . . . .                                                  | 25    |
-|                                           | 7.1.1                                                                                      | Introduction . . . . . . . . . . . . . . .                                                 | 25    |
-|                                           | 7.1.2                                                                                      | . . . . . . . Memory allocation flags . . . . . . . . .                                    | 25    |
-|                                           | 7.1.3                                                                                      | . . . . . . Numa-aware host memory allocation . . . . . . . . .                            | 26    |
-|                                           | 7.1.4                                                                                      | Coherency Controls . . . . . . . . .                                                       | 26    |
-|                                           | 7.1.5                                                                                      | . . . . . . . . . Visibility of Zero-Copy Host Memory . . . . . . . .                      | 27    |
-|                                           | 7.1.6                                                                                      | hipEventSynchronize . . . . . . . . . . .                                                  | 27    |
-|                                           | 7.1.7                                                                                      | . . . . Summary and Recommendations . . . . . . . . . . .                                  | 27    |
-|                                           | 7.1.8                                                                                      | Managed memory allocation . . . . . . . . . . . . .                                        | 28    |
-|                                           | 7.1.9                                                                                      | HIP Stream Memory Operations . . . . . . . . . . .                                         | 28    |
-| 7.2                                       | Direct Dispatch . . . . . .                                                                | . . . . . . . . . . . . . . . . . . .                                                      | 28    |
-| 7.3                                       | HIP Runtime Compilation                                                                    | . . . . . . . . . .                                                                        | 29    |
-| 7.4                                       | . . . . . . . . . HIP Graph . . . . . . . . . . . . . . . . .                              | . . . . . . . . . .                                                                        | 29    |
-| 7.5                                       | Device-Side Malloc . . . . . .                                                             | . . . . . . . . . . . . .                                                                  | 29    |
-| 7.6                                       | . . . Use of Per-thread default stream . . .                                               | . . . . . . . . . . . . .                                                                  | 29    |
-| 7.7                                       | Use of Long Double Type . . . . .                                                          | . . . . . . . . . . . . . .                                                                | 30    |
-| 7.8                                       | Use of _Float16 Type . . . . . . .                                                         | Use of _Float16 Type . . . . . . .                                                         | 30    |
-| 7.9                                       | . . . . . . . . . . . . . . FMA and contractions . . . . . . . . . . . . . . . . . . . . . | . . . . . . . . . . . . . . FMA and contractions . . . . . . . . . . . . . . . . . . . . . | 30    |
-| 7.10                                      | Math functions with special rounding modes . . . . . . . . . . . . . . . .                 | . . . . .                                                                                  | 30    |
-| 7.11                                      | Creating Static Libraries . . .                                                            | . . . . .                                                                                  | 30    |
-| 8 HIP porting guide . . . . . . . . . . . | 8 HIP porting guide . . . . . . . . . . .                                                  | 8 HIP porting guide . . . . . . . . . . .                                                  | 33    |
-| 8.1                                       | Porting a New CUDA Project .                                                               | . . . . .                                                                                  | 33    |
-|                                           |                                                                                            | General Tips . .                                                                           |       |
-|                                           | 8.1.1                                                                                      | . . . . . . . . . . . . . . . . . . .                                                      | 33    |
-|                                           | 8.1.2                                                                                      | Scanning existing CUDA code to scope the porting effort 'in-place' . . . . . . . . . .     | 33 34 |
-|                                           | 8.1.3                                                                                      | Converting a project . .                                                                   |       |
-|                                           | 8.1.4                                                                                      | Library Equivalents . . . . . . . . . . . . . . . . . .                                    | 35 35 |
-| 8.2                                       | Distinguishing 8.2.1                                                                       | Compiler Modes . . . . . . . . . . . . . . . . Identifying HIP Target Platform . . .       | 35    |
-|                                           | 8.2.2                                                                                      | . . . . . . . . Identifying the Compiler: hip-clang or NVCC . . .                          | 36    |
-|                                           | 8.2.3                                                                                      | . Identifying Current Compilation Pass: Host or Device                                     | 36    |
-|                                           | 8.2.4                                                                                      | Compiler Defines: Summary . . . . . . . . . . . . . . .                                    | 37    |
-| 8.3                                       | Identifying Architecture Features . .                                                      | . . . . . . . . . . . . .                                                                  | 37    |
-|                                           | 8.3.1                                                                                      | HIP_ARCH Defines . . . . . . . . . . . . . . .                                             | 37    |
-|                                           | 8.3.2                                                                                      | Device-Architecture Properties . . . . . . . . . . . .                                     | 38    |
-|                                           | 8.3.3                                                                                      | Table of Architecture Properties . . . . . . . . . . . . . . . . . .                       | 38    |
-| 8.4                                       | Finding HIP . . . . . . .                                                                  | . . . . . . . . . . . .                                                                    | 39 40 |
-| 8.5 8.6                                   | Identifying HIP Runtime . . . . . hipLaunchKernelGGL . . . . .                             | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                | 40    |
-| 8.7                                       | Compiler Options . . . . . . . 8.7.1 Compiler options supported                            | . . . . . . . . . . . . . . . .                                                            | 40    |
-|                                           |                                                                                            | on AMDplatforms . . .                                                                      | 40    |
-| 8.8                                       | Linking Issues . . .                                                                       | . . . . . . . . . . . . . . . . . . . .                                                    | 41    |
-|                                           | . . 8.8.1 Linking With hipcc                                                               | . . . . . . . . . . . . . . . . . .                                                        | 41    |
-|                                           | 8.8.2                                                                                      | -lm Option . . . . . . . . . . . . . . . . .                                               | 41    |
-| 8.9                                       | . . . . . Linking Code With Other Compilers                                                | . . . . . . . . . . . . .                                                                  | 41    |
-|                                           | 8.9.1 libc++ and libstdc++                                                                 | 8.9.1 libc++ and libstdc++                                                                 |       |
-|                                           |                                                                                            | . . . . . . . . . . . . . . . . .                                                          | 41    |
-|                                           | 8.9.2                                                                                      | HIP Headers ( hip_runtime.h , hip_runtime_api.h Compiler . . . . . . . . . . .             | 42 42 |
-|                                           | 8.9.3 Using a Standard C++ 8.9.3.1 . .                                                     | . . . . . . . . . . . .                                                                    | 42    |
-|                                           | cuda.h . . . . . 8.9.4 Choosing HIP File Extensions . .                                    | . . . . . . . . . . . .                                                                    | 42    |
-| 8.10                                      | Workarounds . . . . . . . . . . . .                                                        | . . . . . . . . . . . .                                                                    | 43    |
-
-8.10.1
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-43
-
-|      |                                                                                                                                                                           |                                                                                                                                                                           | warpSize                                                                                                                                                                  |       |
-|------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------|
-|      |                                                                                                                                                                           | 8.10.2 Kernel launch with group size > 256 . . . . . . . . . . . . . . . . . . . . .                                                                                      | 8.10.2 Kernel launch with group size > 256 . . . . . . . . . . . . . . . . . . . . .                                                                                      | 43    |
-|      | 8.11                                                                                                                                                                      | memcpyToSymbol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                            | memcpyToSymbol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                            | 43    |
-|      | 8.12                                                                                                                                                                      | CU_POINTER_ATTRIBUTE_MEMORY_TYPE                                                                                                                                          | . . .                                                                                                                                                                     | 44    |
-|      | 8.13                                                                                                                                                                      | threadfence_system . . .                                                                                                                                                  | . . . . . . . .                                                                                                                                                           | 45    |
-|      |                                                                                                                                                                           | . . . . . . 8.13.1 Textures and Cache Control . . .                                                                                                                       | . . . . . . . .                                                                                                                                                           | 45    |
-|      | 8.14                                                                                                                                                                      | More Tips . . . .                                                                                                                                                         | . . . . . . . . .                                                                                                                                                         | 46    |
-|      | 8.14.1                                                                                                                                                                    | . . . . . . . . . . . HIP Logging . . . . . . . . .                                                                                                                       | . . . . . . . . .                                                                                                                                                         | 46    |
-|      | 8.14.2                                                                                                                                                                    | Debugging hipcc                                                                                                                                                           | . . . . . . . . . . . . . . . .                                                                                                                                           | 47    |
-|      | 8.14.3                                                                                                                                                                    | Editor Highlighting . .                                                                                                                                                   | . . . . . . . . . . . . .                                                                                                                                                 | 47    |
-| 9    | Porting CUDA driver API                                                                                                                                                   | Porting CUDA driver API                                                                                                                                                   | Porting CUDA driver API                                                                                                                                                   | 49    |
-| 9.1  | Introduction to the CUDA Driver and Runtime APIs . . . . . . . .                                                                                                          | Introduction to the CUDA Driver and Runtime APIs . . . . . . . .                                                                                                          | Introduction to the CUDA Driver and Runtime APIs . . . . . . . .                                                                                                          | 49    |
-|      | 9.1.1                                                                                                                                                                     | cuModule API . . . . . . . . . . . . . .                                                                                                                                  | cuModule API . . . . . . . . . . . . . .                                                                                                                                  | 49    |
-|      | 9.1.2                                                                                                                                                                     | . . . . . . . . . cuCtx API . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                             | . . . . . . . . . cuCtx API . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                             | 50    |
-| 9.2  | HIP                                                                                                                                                                       | Module and Ctx APIs . . . . . . . . . . . . .                                                                                                                             | . . .                                                                                                                                                                     | 50    |
-|      | 9.2.1                                                                                                                                                                     | hipModule API . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                       | hipModule API . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                       | 50    |
-|      | 9.2.2                                                                                                                                                                     | . hipCtx API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                  | . hipCtx API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                  | 51    |
-|      | 9.2.3                                                                                                                                                                     | hipify translation of CUDA Driver API . . . . . .                                                                                                                         | hipify translation of CUDA Driver API . . . . . .                                                                                                                         | 51    |
-|      |                                                                                                                                                                           | 9.2.3.1                                                                                                                                                                   | Address Spaces . . . . . .                                                                                                                                                | 51    |
-|      |                                                                                                                                                                           | 9.2.3.2                                                                                                                                                                   | . . . . . . Using hipModuleLaunchKernel . .                                                                                                                               | 51    |
-|      |                                                                                                                                                                           | 9.2.3.3                                                                                                                                                                   | Additional Information                                                                                                                                                    | 51    |
-|      | 9.2.4                                                                                                                                                                     | . . . . . . . . . . . hip-clang Implementation Notes . . . . . . . . . .                                                                                                  | . . . . . . . . . . . hip-clang Implementation Notes . . . . . . . . . .                                                                                                  | 51    |
-|      |                                                                                                                                                                           | 9.2.4.1                                                                                                                                                                   | .hip_fatbin . . . . . . . . . . . . .                                                                                                                                     | 51    |
-|      |                                                                                                                                                                           | 9.2.4.2                                                                                                                                                                   | Initialization and Termination Functions                                                                                                                                  | 52    |
-|      |                                                                                                                                                                           | 9.2.4.3                                                                                                                                                                   | Kernel Launching                                                                                                                                                          | 52    |
-|      | 9.2.5                                                                                                                                                                     | . . . . . . . . . . . . . . . . . . NVCC Implementation Notes . . . . . . . . . . . . . . . . .                                                                           | . . . . . . . . . . . . . . . . . . NVCC Implementation Notes . . . . . . . . . . . . . . . . .                                                                           | 52    |
-|      |                                                                                                                                                                           | . . . . 9.2.5.1 Interoperation between HIP and CUDA Driver . . . . . . .                                                                                                  | . . . . 9.2.5.1 Interoperation between HIP and CUDA Driver . . . . . . .                                                                                                  | 52    |
-|      |                                                                                                                                                                           | 9.2.5.2 Compilation Options . . .                                                                                                                                         | . . . . . .                                                                                                                                                               | 53    |
-| 9.3  | HIP                                                                                                                                                                       | Module and Texture Driver API . . . .                                                                                                                                     | . . . . . . .                                                                                                                                                             | 55    |
-| 10   | Programming for HIP runtime compiler (RTC)                                                                                                                                | Programming for HIP runtime compiler (RTC)                                                                                                                                | Programming for HIP runtime compiler (RTC)                                                                                                                                | 57    |
-| 10.1 | Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                       | Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                       | Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                       | 57    |
-| 10.2 | HIPRTC                                                                                                                                                                    | specific options . . . . . . . .                                                                                                                                          | . . . . . . . . .                                                                                                                                                         | 61    |
-|      | 10.2.1                                                                                                                                                                    | Bitcode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                             | Bitcode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                             | 62    |
-|      | 10.2.2                                                                                                                                                                    | CU Mode vs WGP mode . . . . . .                                                                                                                                           | CU Mode vs WGP mode . . . . . .                                                                                                                                           | 62    |
-| 10.3 | Linker                                                                                                                                                                    | APIs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                        | APIs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                        | 62    |
-|      | 10.3.1                                                                                                                                                                    | Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                 | Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                 | 63 63 |
-|      | 10.3.2                                                                                                                                                                    | 10.3.1.1 Note . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Input Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                     | 10.3.1.1 Note . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Input Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                     | 64    |
-|      | 10.3.3                                                                                                                                                                    | . Backward Compatibility of LLVM Bitcode/IR . . . . . . . . . . . . . .                                                                                                   | . Backward Compatibility of LLVM Bitcode/IR . . . . . . . . . . . . . .                                                                                                   | 64    |
-|      | 10.3.4                                                                                                                                                                    | Link Options . . . . . . . . . .                                                                                                                                          | . . . . . . . .                                                                                                                                                           | 64    |
-| 10.4 | Error Handling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                | Error Handling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                | Error Handling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                | 65    |
-| 10.5 | HIPRTC General APIs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                   | HIPRTC General APIs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                   | HIPRTC General APIs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                   | 65    |
-| 10.6 | Lowered Names (Mangled Names) . . . . . . . . . . .                                                                                                                       | Lowered Names (Mangled Names) . . . . . . . . . . .                                                                                                                       | Lowered Names (Mangled Names) . . . . . . . . . . .                                                                                                                       | 66    |
-|      | 10.6.1 10.6.2                                                                                                                                                             | Note . . . . . . . . . . . . . . . . . . . . . . . . . . . Example . . . . . . . . . . . . . . . . . . . . . . . . .                                                      | Note . . . . . . . . . . . . . . . . . . . . . . . . . . . Example . . . . . . . . . . . . . . . . . . . . . . . . .                                                      | 66 66 |
-| 10.7 | . . . . . . . . . . .                                                                                                                                                     | . . . . . . . . . . .                                                                                                                                                     | . . . . . . . . . . .                                                                                                                                                     | 67    |
-| 10.8 | Versioning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . HIP header support . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . | Versioning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . HIP header support . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . | Versioning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . HIP header support . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . | 68    |
-| 10.9 | Deprecation notice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                      | Deprecation notice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                      | Deprecation notice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                      | 68    |
-| 11   |                                                                                                                                                                           |                                                                                                                                                                           |                                                                                                                                                                           | 69    |
-| 11.1 | Performance guidelines Parallel                                                                                                                                           | execution                                                                                                                                                                 | . . . . . . . . . . . . . . . . . . . . .                                                                                                                                 | 69    |
-
-11.1.2
-
-Device level
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-69
-
-|                                               | 11.1.3                                                            | Multiprocessor level . . . . . . . . . . . . . .                                       | 70      |
-|-----------------------------------------------|-------------------------------------------------------------------|----------------------------------------------------------------------------------------|---------|
-| 11.2                                          | Memory                                                            | optimization . . . . . . . . . . . .                                                   | 70      |
-|                                               | 11.2.1                                                            | Data Transfer . . . . . . . . . . . . .                                                | 70      |
-|                                               | 11.2.2                                                            | . . Device Memory Access . . . . . . . . . .                                           | 71      |
-| 11.3                                          | Optimization for maximum instruction throughput                   | Optimization for maximum instruction throughput                                        | 71      |
-|                                               | 11.3.1                                                            | Arithmetic instructions . . . . . . . . .                                              | 72      |
-|                                               | 11.3.2                                                            | . Control flow instructions . . . . . . . . .                                          | 72      |
-|                                               | 11.3.3                                                            | Synchronization . . . . . . . . . .                                                    | 72      |
-| 11.4                                          | . . . . Minimizing memory thrashing .                             | . . . . . . . . . .                                                                    | 73      |
-| 12 Debugging with HIP                         | 12 Debugging with HIP                                             | 12 Debugging with HIP                                                                  | 75      |
-| 12.1                                          | Tracing . .                                                       | . . . . . . . . . . . . . . . . . . . . .                                              | 75      |
-| 12.2                                          | Debugging . . . . . .                                             | . . . . . . . .                                                                        | 77      |
-|                                               | . . . . . . . 12.2.1 Debugging HIP applications                   | . . . . . . .                                                                          | 77      |
-| 12.3                                          | Useful environment variables                                      | . . . . . . .                                                                          | 79      |
-|                                               | 12.3.1                                                            | . . . . Kernel enqueue serialization . . . . . . .                                     | 79      |
-|                                               | 12.3.2                                                            | Making device visible . . . . . . . . . . .                                            | 79      |
-|                                               | 12.3.3                                                            | Dump code object . .                                                                   | 79      |
-|                                               | 12.3.4                                                            | . . . . . . . . . . . HSA-related environment variables (Linux)                        | 80      |
-|                                               | 12.3.5 HIP environment variable summary . .                       | .                                                                                      | 80      |
-| 12.4                                          | General debugging tips . . .                                      | . . . . . . . . . . . .                                                                | 82      |
-| 13 Logging HIP activity                       | 13 Logging HIP activity                                           | 13 Logging HIP activity                                                                | 83      |
-| 13.1                                          | Logging level . . . . . . . .                                     | . . . . . . . . . . . .                                                                | 83      |
-| 13.2                                          | Logging mask . . . . .                                            | . . .                                                                                  | 84      |
-| 13.3                                          | . . . . . . . . . . . Logging command . . . . . . . . . . . . . . | . . .                                                                                  | 84      |
-| 13.4                                          | Logging examples . . . . . .                                      | . . . . . . . . . . .                                                                  | 85      |
-| 14 Cooperative groups . . . . . . . . . . . . | 14 Cooperative groups . . . . . . . . . . . .                     | 14 Cooperative groups . . . . . . . . . . . .                                          | 89      |
-| 14.1                                          | Cooperative groups thread model . . .                             | Cooperative groups thread model . . .                                                  | 89      |
-| 14.2                                          | Group types . . . . . . . . group                                 | . . . . . . . . .                                                                      | 90      |
-|                                               | 14.2.1                                                            | Thread-block . . . . . . . . . . . . .                                                 | 90      |
-|                                               | 14.2.2                                                            | Grid group . . . . . . . . . . . . . .                                                 | 90      |
-|                                               | 14.2.3                                                            | . Multi-grid group . . . . . . . . . . . . .                                           | 90      |
-|                                               | 14.2.4 14.2.5                                                     | Thread-block tile . . . . . . . . . . . . . Coalesced groups . . . . . . . . . . . . . | 91 91   |
-| 14.3                                          | Cooperative groups simple example . .                             | . . . . . .                                                                            | 92      |
-| 14.4                                          | Synchronization . . . . . .                                       | . . . . . . . .                                                                        | 94      |
-| 14.5                                          | . . . .                                                           | . . . .                                                                                | 97      |
-|                                               | Unsupported NVIDIA CUDA features . . .                            | Unsupported NVIDIA CUDA features . . .                                                 |         |
-| 15 Unified memory                             | 15 Unified memory                                                 | 15 Unified memory                                                                      | 99      |
-| 15.1                                          | Unified memory . . .                                              | . . . . . . . . . . . . . . .                                                          | 99 99   |
-| 15.2                                          | System requirements . . . . .                                     | . . . . . . . . . . .                                                                  | 100     |
-| 15.3                                          | Unified memory programming models                                 | . . . . . .                                                                            |         |
-|                                               | 15.3.1                                                            | Checking unified memory management support                                             | 100     |
-|                                               | 15.3.2 Example for unified memory management                      | 15.3.2 Example for unified memory management                                           | 101     |
-| 15.4                                          | Using unified memory management (UMM)                             | . . .                                                                                  | 104     |
-| 15.5                                          | Unified memory HIP runtime hints . . . . .                        | for the better performance                                                             | 104     |
-|                                               | 15.5.1                                                            | Data prefetching . . . . . . . . .                                                     | 105     |
-|                                               | 15.5.2                                                            | Memory advice . . . . . . . . . . . . . .                                              | 106 107 |
-|                                               | 15.5.3 15.5.4                                                     | Memory range attributes . . . . . . . . . Asynchronously attach memory to a stream     | 108     |
-| 16 Virtual memory management                  | 16 Virtual memory management                                      | 16 Virtual memory management                                                           | 109     |
-
-| 16.1                          | Memory allocation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16.1.1                                                                                                                                                | . . . 109 . . .     |
-|-------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------|
-|                               | Allocate physical memory . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                                  | 109                 |
-| 16.1.2                        | Reserve virtual address range . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                               | . . . 110           |
-| 16.1.3                        | Set memory access . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                                 | . . . 110           |
-|                               | Free virtual memory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                                 | . . . 110           |
-| 16.2                          | 16.1.4 Memory usage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                 | . . . 111           |
-|                               | 16.2.1 Dynamically increase allocation size . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                         | . . . 111           |
-| 17 Frequently asked questions | 17 Frequently asked questions                                                                                                                                                                                                                     | 113                 |
-| 17.1                          | What APIs and features does HIP support? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                      | . . . 113           |
-| 17.2                          | What is not supported? . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                                          | . . . 113           |
-|                               | 17.2.1 Runtime/Driver API features . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                          | . . . 113           |
-|                               | 17.2.2 Kernel language features . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                         | . . . 114           |
-| 17.3 Is                       | HIP a drop-in replacement for CUDA? . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                             | . . . 114           |
-| 17.4                          | What specific version of CUDA does HIP support? . . . . . . . . . . . . . . . . . . . .                                                                                                                                                           | . . . 114           |
-| 17.5                          | What libraries does HIP support? . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                        | . . . 115           |
-| 17.6                          | How does HIP compare with OpenCL? . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                             | . . . 115           |
-| 17.7                          | How does porting CUDA to HIP compare to porting CUDA to OpenCL? . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                         | . . . 115           |
-| 17.8                          | What hardware does HIP support? . . . . . . . .                                                                                                                                                                                                   | . . . 116           |
-| 17.9                          | Do HIPIFY tools automatically convert all source code? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                  | . . . 116           |
-| 17.10                         | What is NVCC? . . . . . . . . . . . . . . . .                                                                                                                                                                                                     | . . . 116           |
-| 17.11                         | . . What is HIP-Clang? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                    | . . . 116           |
-| 17.12                         | Why use HIP rather than supporting CUDA directly? . . . . . . . . . . . . . . . . . . .                                                                                                                                                           | . . . 116 117       |
-| 17.13                         | Can I develop HIP code on an NVIDIA CUDA platform? . . . . . . . . . . . . . . . . Can I develop HIP code on an AMDHIP-Clang platform? . . . . . . . . . . . . . . . .                                                                            | . . . . . . 117     |
-| 17.14                         | How to use HIP-Clang to build HIP programs? . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                   | . . . 117           |
-| 17.15                         | . . . . . . . . . . . . . .                                                                                                                                                                                                                       |                     |
-| 17.16 17.17                   | What is AMDclr? . . . . . . . . . . . . . . . . . . . What is hipother? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                               | . . . 117 . . . 118 |
-| 17.18                         | Can I get HIP open source repository . . . . . . . . . . . . . . . .                                                                                                                                                                              | . . . 118           |
-| 17.19                         | for Windows? . . . Can a HIP binary run on both AMDand NVIDIA platforms? .                                                                                                                                                                        | . . . 118           |
-| 17.20 or                      | . . . . . . . . . . . . . On HIP-Clang, can I link HIP code with host code compiled with another compiler such clang? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                         | icc, . . . 118      |
-| 17.21                         | Can HIP API support C style application? What is the difference between C and C++? . .                                                                                                                                                            | . . . 118           |
-| 17.22                         | Can I install both CUDA SDK and HIP-Clang on the same machine? . . . . . . . . .                                                                                                                                                                  | . . . 119           |
-| 17.23                         | HIP detected my platform (HIP-Clang vs NVCC) incorrectly * what should I do? . . . . . . . . . . . . . . .                                                                                                                                        | . . . 119           |
-| 17.24                         | On CUDA, can I mix CUDA code with HIP code? . . . . . . . . . . . . . .                                                                                                                                                                           | . . . 120           |
-| 17.25                         | How do I trace HIP application flow? . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                                  | . . . 120           |
-| 17.26                         | What are the maximum limits of kernel launch parameters? . . . . . . . . . . . . . . .                                                                                                                                                            | . . . 120           |
-| 17.27                         | Are __shfl_*_sync functions supported on HIP platform? . . . . . . . . . . . . . . .                                                                                                                                                              | . . . 120           |
-| 17.28                         | How to create a guard for code that is specific to the host or the GPU? . . . . . . . . . .                                                                                                                                                       | . . . 120           |
-| 17.29                         | Why _OpenMP is undefined when compiling with -fopenmp ? . . . . . . . . . . . . . .                                                                                                                                                               | . . . 121           |
-| 17.30                         | Does the HIP-Clang compiler support extern shared declarations? . . . . . . . . . . . .                                                                                                                                                           | . . . 121 code      |
-| 17.31                         | I have multiple HIP enabled devices and I am getting an error hipErrorSharedObjectInitFailed with the message 'Error: shared object initialization failed'? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . | . . . 121           |
-| 17.32                         | How to use per-thread default stream in HIP? . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                        | . . . 122           |
-| 17.33                         | How to use complex multiplication and division operations? . . . . . . . . .                                                                                                                                                                      | . . . 122           |
-| 17.34                         | . . . . . . Can I develop applications with HIP APIs on Windows the same on Linux? . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                      | . . . 122           |
-| 17.35                         | Does HIP support LUID? . . . . . . . . . . .                                                                                                                                                                                                      | . . . 123           |
-| 17.36                         | How can I know the version of HIP? . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                        | . . . 123           |
-| 18 HIP Runtime 18.1 Related   | API Reference Pages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                               | 125 . . . 126       |
-
-18.3
-
-Namespaces
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-126
-
-|      | 18.3.1                                                                                                                  | Namespace List . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                        | Namespace List . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                        | 126     |
-|------|-------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------|---------|
-|      | 18.3.2                                                                                                                  | Namespace Members . . . . . . . . . . . . . .                                                                           | Namespace Members . . . . . . . . . . . . . .                                                                           | 126     |
-|      |                                                                                                                         | 18.3.2.1 Namespace Members . . . . .                                                                                    | 18.3.2.1 Namespace Members . . . . .                                                                                    | 126     |
-|      |                                                                                                                         | 18.3.2.2 Namespace Members .                                                                                            | 18.3.2.2 Namespace Members .                                                                                            | 126     |
-| 18.4 | . . . . . Data Structures . . . . . . . . . . . . . . . . . . .                                                         | . . . . . Data Structures . . . . . . . . . . . . . . . . . . .                                                         | . . . . . Data Structures . . . . . . . . . . . . . . . . . . .                                                         | 126     |
-|      | 18.4.1 Data                                                                                                             | Structures . . . . . . . .                                                                                              | . .                                                                                                                     | 126     |
-|      | 18.4.2                                                                                                                  | . . . Data Structure Index . . . . . . . .                                                                              | . . . Data Structure Index . . . . . . . .                                                                              | 126     |
-|      | 18.4.3                                                                                                                  | . . . Class Hierarchy . . . . . . . . . . . . . .                                                                       | . . . Class Hierarchy . . . . . . . . . . . . . .                                                                       | 126     |
-|      | 18.4.4                                                                                                                  | . . Data Fields . . . . . . . . . . . . . . . . . .                                                                     | . . Data Fields . . . . . . . . . . . . . . . . . .                                                                     | 126     |
-|      |                                                                                                                         | 18.4.4.1 All . . . . . . . . . . . . . .                                                                                | .                                                                                                                       | 126     |
-|      |                                                                                                                         | 18.4.4.1.1                                                                                                              | Data Fields . . . . .                                                                                                   | 126     |
-|      |                                                                                                                         | 18.4.4.1.2                                                                                                              | Data Fields . . . . .                                                                                                   | 126     |
-|      |                                                                                                                         | 18.4.4.1.3                                                                                                              | Data Fields . . . . .                                                                                                   | 126     |
-|      |                                                                                                                         | 18.4.4.1.4                                                                                                              | Data Fields . . . . .                                                                                                   | 126     |
-|      |                                                                                                                         | 18.4.4.1.5                                                                                                              | Data Fields . . . . .                                                                                                   | 126     |
-|      |                                                                                                                         | 18.4.4.1.6                                                                                                              | Data Fields . . . .                                                                                                     | 126     |
-|      |                                                                                                                         | 18.4.4.1.7                                                                                                              | . Data Fields . . . . . .                                                                                               | 126     |
-|      |                                                                                                                         | 18.4.4.1.8                                                                                                              | Data Fields . . . .                                                                                                     | 126     |
-|      |                                                                                                                         | 18.4.4.1.9                                                                                                              | Data Fields . . . . . . .                                                                                               | 126     |
-|      |                                                                                                                         | 18.4.4.1.10                                                                                                             | Data Fields . . .                                                                                                       | 126     |
-|      |                                                                                                                         | 18.4.4.1.11                                                                                                             | Data Fields . . . . . . .                                                                                               | 126     |
-|      |                                                                                                                         | 18.4.4.1.12                                                                                                             | Data Fields . . .                                                                                                       | 126     |
-|      |                                                                                                                         | 18.4.4.1.13                                                                                                             | Data Fields . . . . . Data Fields .                                                                                     | 126     |
-|      |                                                                                                                         | 18.4.4.1.14                                                                                                             | . . . . Data Fields                                                                                                     | 126     |
-|      |                                                                                                                         | 18.4.4.1.15                                                                                                             | . . . . . .                                                                                                             | 126     |
-|      |                                                                                                                         | 18.4.4.1.16                                                                                                             | Data Fields . . . .                                                                                                     | 126     |
-|      |                                                                                                                         | 18.4.4.1.17                                                                                                             | Data Fields . . . . .                                                                                                   | 126     |
-|      |                                                                                                                         | 18.4.4.1.18                                                                                                             | Data Fields . . . . .                                                                                                   | 126     |
-|      |                                                                                                                         | 18.4.4.1.19                                                                                                             | Data Fields . . . . .                                                                                                   | 126     |
-|      |                                                                                                                         | 18.4.4.1.20                                                                                                             | Data Fields . . . . . .                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.1.21                                                                                                             | Data Fields . . . .                                                                                                     | 126     |
-|      |                                                                                                                         | 18.4.4.1.22                                                                                                             | Data Fields . . . . .                                                                                                   | 126     |
-|      |                                                                                                                         | 18.4.4.1.23                                                                                                             | Data Fields . . . . .                                                                                                   | 126     |
-|      |                                                                                                                         | 18.4.4.1.24                                                                                                             | Data Fields . . . .                                                                                                     | 126     |
-|      |                                                                                                                         | 18.4.4.1.25                                                                                                             | . Data Fields . . . . .                                                                                                 | 126 126 |
-|      | 18.4.4.2 Data Fields - Functions . . . . . . . . . . . . . 18.4.4.3 Variables . . . . . . . . . . . . . . . . . . . . . | 18.4.4.2 Data Fields - Functions . . . . . . . . . . . . . 18.4.4.3 Variables . . . . . . . . . . . . . . . . . . . . . | 18.4.4.2 Data Fields - Functions . . . . . . . . . . . . . 18.4.4.3 Variables . . . . . . . . . . . . . . . . . . . . . | 126     |
-|      |                                                                                                                         | 18.4.4.3.1                                                                                                              | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.2                                                                                                              | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.3                                                                                                              | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.4                                                                                                              | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.5                                                                                                              | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.6                                                                                                              | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.7                                                                                                              | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.8                                                                                                              | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.9                                                                                                              | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.10                                                                                                             | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.11                                                                                                             | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.12                                                                                                             | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.13                                                                                                             | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.14 18.4.4.3.15                                                                                                 | Data Fields - Variables Data Fields - Variables                                                                         | 126 126 |
-|      |                                                                                                                         | 18.4.4.3.16                                                                                                             | Data Fields - Variables                                                                                                 | 126     |
-
-18.4.4.3.17
-
-Data Fields - Variables
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-126
-
-|           |                                                                                                 | 18.4.4.3.18                                                                                     | Data Fields - Variables                                                                         | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                               | 126     |
-|-----------|-------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------|---------|
-|           |                                                                                                 | 18.4.4.3.19                                                                                     | Data Fields - Variables                                                                         | . . . . . . . . . . . . . . . . . . . . .                                                                                       | 126     |
-|           |                                                                                                 | 18.4.4.3.20                                                                                     | Data Fields -                                                                                   | Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                       | 126     |
-|           |                                                                                                 | 18.4.4.3.21                                                                                     | Data Fields - Variables                                                                         | . . . . . . . . . . . . . . . . . . . . . .                                                                                     | 126     |
-|           |                                                                                                 | 18.4.4.3.22                                                                                     | Data                                                                                            | Fields - Variables . . . . . . . . . . . . . . . . . . . . .                                                                    | 126     |
-|           |                                                                                                 | 18.4.4.3.23                                                                                     | Data Fields -                                                                                   | . . . . . . Variables . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                     | 126     |
-|           |                                                                                                 | 18.4.4.3.24                                                                                     | Data                                                                                            | Fields - Variables . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                        | 126     |
-|           |                                                                                                 | 18.4.4.3.25                                                                                     | Data                                                                                            | Fields - Variables . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                        | 126     |
-| 18.5      | 18.4.4.4 Data Fields - Related Symbols . .                                                      | . . . . . . . . .                                                                               | 18.4.4.4 Data Fields - Related Symbols . .                                                      | . . . . . . . . . . . . . . . . . . . . . . . . . . 126 . . . . . . . . .                                                       | 126     |
-|           | Files 18.5.1                                                                                    | File List . . . . .                                                                             | . . . . . . . . . . . . . .                                                                     | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .           | 126     |
-|           | 18.5.2                                                                                          | Globals . . .                                                                                   | . . . . . . . .                                                                                 | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                               | 126     |
-|           |                                                                                                 | 18.5.2.1 All . .                                                                                | . . . . . . . . . .                                                                             | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 126     |
-|           |                                                                                                 | 18.5.2.1.1                                                                                      | Globals . . . .                                                                                 | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 126     |
-|           |                                                                                                 | 18.5.2.1.2                                                                                      | Globals . . . .                                                                                 | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 126     |
-|           |                                                                                                 | 18.5.2.1.3                                                                                      | Globals . . . .                                                                                 | . . . . . . . . . . . . . . . . . . . . . . . . .                                                                               | 126     |
-|           |                                                                                                 | 18.5.2.1.4                                                                                      | Globals . . . .                                                                                 | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                       | 126     |
-|           |                                                                                                 | 18.5.2.1.5                                                                                      | Globals . . . .                                                                                 | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 126     |
-|           |                                                                                                 | 18.5.2.1.6                                                                                      | Globals . . . .                                                                                 | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 126     |
-|           |                                                                                                 | 18.5.2.1.7                                                                                      | Globals . . . .                                                                                 | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                     | 126     |
-|           |                                                                                                 | 18.5.2.1.8                                                                                      | Globals . .                                                                                     | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 126     |
-|           |                                                                                                 | 18.5.2.1.9                                                                                      | Globals                                                                                         |                                                                                                                                 | 126     |
-|           |                                                                                                 |                                                                                                 | . .                                                                                             | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                         | 126     |
-|           |                                                                                                 | 18.5.2.2 Functions 18.5.2.2.1                                                                   | . . . . . . . Globals . . .                                                                     | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . | 126     |
-|           |                                                                                                 | 18.5.2.2.2                                                                                      | Globals . .                                                                                     | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 126     |
-|           |                                                                                                 | 18.5.2.2.3                                                                                      | Globals . .                                                                                     | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                             | 126     |
-|           |                                                                                                 | 18.5.2.3 Globals                                                                                | . . . . . . .                                                                                   | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                             | 126     |
-|           |                                                                                                 | 18.5.2.4 Globals                                                                                | . . . . . . .                                                                                   | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                               | 126     |
-|           |                                                                                                 |                                                                                                 | . . . . . .                                                                                     | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                       | 126     |
-|           |                                                                                                 | 18.5.2.5 Globals                                                                                | Enumerator . . . . . .                                                                          | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                 | 126     |
-|           |                                                                                                 | 18.5.2.6 18.5.2.6.1                                                                             | Globals . . . .                                                                                 | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 126     |
-|           |                                                                                                 | 18.5.2.6.2                                                                                      | Globals .                                                                                       | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                     | 126     |
-|           |                                                                                                 | Globals                                                                                         | .                                                                                               | . . . .                                                                                                                         |         |
-|           | 18.5.2.7                                                                                        |                                                                                                 | . . . . . .                                                                                     | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                             | 126     |
-|           | C++ language extensions                                                                         | C++ language extensions                                                                         | C++ language extensions                                                                         |                                                                                                                                 | 127     |
-| 19.1      | Function-type                                                                                   | qualifiers                                                                                      | . . . . . . . . . .                                                                             | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 127 127 |
-|           | 19.1.1                                                                                          | __device__ . .                                                                                  | . . . . . . . . . . . . . .                                                                     | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .     | 128     |
-|           | 19.1.2                                                                                          | __global__                                                                                      | . . . . . .                                                                                     |                                                                                                                                 |         |
-|           | 19.1.3                                                                                          | __host__ . . .                                                                                  | . . . . . . . . . .                                                                             | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 128     |
-| 19.2 19.3 | Calling __global__ functions . . . . .                                                          | Calling __global__ functions . . . . .                                                          | . . . .                                                                                         | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .     | 128 129 |
-| 19.4      | Kernel launch example . . . . . . . . Variable type qualifiers . . . . . . . .                  | Kernel launch example . . . . . . . . Variable type qualifiers . . . . . . . .                  | . .                                                                                             | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 130     |
-|           | .                                                                                               | .                                                                                               | .                                                                                               |                                                                                                                                 | 130     |
-|           | 19.4.1                                                                                          | __constant__                                                                                    | . . . . . . . . . .                                                                             | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                 |         |
-|           | 19.4.2                                                                                          | __shared__ .                                                                                    | . . . . . . . . . .                                                                             | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                     | 130     |
-|           | 19.4.3                                                                                          | __managed__ .                                                                                   | . . . . . . . . . .                                                                             | . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                             | 130     |
-|           | 19.4.4                                                                                          | __restrict__                                                                                    | . . . . . . . . .                                                                               | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                         | 130     |
-| 19.5      | . Built-in variables . . . . . . . . . . .                                                      | . Built-in variables . . . . . . . . . . .                                                      | . .                                                                                             | . . . . . . . . .                                                                                                               | 130     |
-|           | 19.5.1                                                                                          | Coordinate built-ins                                                                            | . . . . . . .                                                                                   | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                   | 130     |
-|           | 19.5.2                                                                                          | warpSize . . .                                                                                  | . . . . . . . . . .                                                                             | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 131     |
-| 19.6      | Vector types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                    | Vector types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                    | Vector types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                    | . . . . . . . . .                                                                                                               | 131     |
-|           | 19.6.1                                                                                          | Short vector types                                                                              | . . . . . .                                                                                     | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                 | 131     |
-| 19.7      | 19.6.2 dim3 . . . . . . . . . . . . . . . . . . Memory fence instructions . . . . . . . . . . . | 19.6.2 dim3 . . . . . . . . . . . . . . . . . . Memory fence instructions . . . . . . . . . . . | 19.6.2 dim3 . . . . . . . . . . . . . . . . . . Memory fence instructions . . . . . . . . . . . | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132         | 132     |
-
-19.8
-
-Synchronization functions
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-132
-
-|                   | .                                                                                                             | . .                                                                                                           |         |
-|-------------------|---------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------|---------|
-| 19.9              | Math                                                                                                          | functions . . . . . . . . . . .                                                                               | 132     |
-| 19.10             | Texture                                                                                                       | functions . . . . . . . . . . . . .                                                                           | 133     |
-| 19.11             | Surface                                                                                                       | functions . . . . . . . . . . . . .                                                                           | 133     |
-| 19.12             | Timer                                                                                                         | functions . . . . . . . . . . . . . .                                                                         | 137     |
-| 19.13             | Atomic                                                                                                        | functions                                                                                                     | 138     |
-|                   | 19.13.1                                                                                                       | . . . . . . . . . . . . . Unsafe floating-point atomic RMWoperations                                          | 139     |
-| 19.14             | Warp cross-lane                                                                                               | functions . .                                                                                                 | 140     |
-|                   | 19.14.1                                                                                                       | . . . . . . Warp vote and ballot functions .                                                                  | 140     |
-|                   | 19.14.2 Warp                                                                                                  | match functions . . . . .                                                                                     | 141     |
-|                   | 19.14.3                                                                                                       | . Warp shuffle functions . . . . .                                                                            | 142     |
-| 19.15             | Cooperative groups                                                                                            | functions . . . . . .                                                                                         | 142     |
-| 19.16             | Warp matrix                                                                                                   | functions . . . . . . .                                                                                       | 143     |
-| 19.17             | Independent                                                                                                   | . . . thread scheduling . . . . . .                                                                           | 144     |
-| 19.18             | Profiler                                                                                                      | Counter Function . . . . . . . .                                                                              | 144     |
-| 19.19             | Assert . . . . .                                                                                              | . . . . . . . . . . . . . .                                                                                   | 144     |
-| 19.20             | . . . .                                                                                                       | printf . . . . . . . . . . . . . .                                                                            | 144     |
-| 19.21             |                                                                                                               | Device-Side Dynamic Global Memory Allocation . . . . . . . .                                                  | 145     |
-| 19.22             |                                                                                                               | __launch_bounds__ . .                                                                                         | 145     |
-|                   | 19.22.1                                                                                                       | Compiler Impact . . . . . . . .                                                                               | 145     |
-|                   | 19.22.2                                                                                                       | CU and EU Definitions . . . . .                                                                               | 146 146 |
-|                   | 19.22.3 19.22.4 maxregcount                                                                                   | Porting from CUDA __launch_bounds . . . . . . . . . .                                                         | 146     |
-| 19.23             |                                                                                                               | Asynchronous Functions . . . . . . . . .                                                                      | 147     |
-|                   | 19.23.1                                                                                                       | Memory stream . . . . . . . . .                                                                               | 147     |
-|                   | 19.23.2                                                                                                       | Peer to peer . . . . . .                                                                                      | 163     |
-|                   | 19.23.3                                                                                                       | . . . . . Memory management . . .                                                                             | 165     |
-|                   | 19.23.4                                                                                                       | . . . External Resource Interoperability                                                                      | 195     |
-|                   | Register                                                                                                      | Keyword . . . . . . . . . . . . .                                                                             | 197     |
-| 19.24             | 19.25 Pragma                                                                                                  | Unroll . . . . . . . . . . . . .                                                                              | 198     |
-| 19.26             | In-Line                                                                                                       | Assembly . . . . . . . . . . . .                                                                              | 198     |
-| 19.27             | Kernel                                                                                                        | Compilation . . . . . . . . . . .                                                                             | 198     |
-| 19.28             |                                                                                                               |                                                                                                               |         |
-|                   |                                                                                                               | gfx-arch-specific-kernel . . . . . . . . .                                                                    | 199     |
-| C++ language 20.1 | 20.1.1                                                                                                        | Modern C++ support . . . . . . . . . . . C++11 support . . . . . . . . .                                      | 201 201 |
-|                   | 20.1.2                                                                                                        | C++14 support . . . . . . . . .                                                                               | 202     |
-|                   | 20.1.3                                                                                                        | C++17 support . . . . . . . . .                                                                               | 202     |
-|                   | 20.1.4                                                                                                        | C++20 support . . . . . . . . .                                                                               | 202     |
-| 20.2              | Extensions                                                                                                    | and restrictions . . . . . . . .                                                                              | 202     |
-|                   | 20.2.1                                                                                                        | Global functions . .                                                                                          | 202     |
-|                   | 20.2.2                                                                                                        | . . . . . . Device space memory specifiers . . . .                                                            | 202     |
-|                   | 20.2.3                                                                                                        | Exception handling . . . . .                                                                                  | 203     |
-|                   | 20.2.4                                                                                                        | Kernel parameters . . . . . .                                                                                 | 203     |
-|                   | 20.2.5                                                                                                        | Classes . . . .                                                                                               | 203     |
-|                   | 20.2.6                                                                                                        | . . . . . . . . . Polymorphic function wrappers .                                                             | 203     |
-|                   | 20.2.7                                                                                                        | Extended lambdas . . . . . . . .                                                                              | 203     |
-|                   |                                                                                                               | Inline namespaces                                                                                             |         |
-|                   | 20.2.8                                                                                                        | . . . . . . .                                                                                                 | 203     |
-|                   |                                                                                                               | .                                                                                                             | 205     |
-| 21 HIP math       | API                                                                                                           | API                                                                                                           | 205     |
-| 21.1              | Single precision mathematical functions . . . . Double precision mathematical functions . . . Integer . . . . | Single precision mathematical functions . . . . Double precision mathematical functions . . . Integer . . . . | 215     |
-| 21.2              | intrinsics . . . . . . . . . . . .                                                                            | intrinsics . . . . . . . . . . . .                                                                            |         |
-| 21.3              |                                                                                                               |                                                                                                               | 225     |
-
-|    | 21.4                                                                                       | Floating-point Intrinsics . . . . . . . . . . . . . .                                      | 227   |
-|----|--------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------|-------|
-| 22 | Table                                                                                      | comparing syntax for different compute APIs                                                | 231   |
-|    | 22.1                                                                                       | Notes . . . . . . . . . . . . . . . . . . . . . . . .                                      | 232   |
-| 23 | HIP                                                                                        | Cooperative groups API                                                                     | 233   |
-|    | 23.1                                                                                       | Cooperative kernel launches . . . . . . . . . . . .                                        | 233   |
-|    | 23.2                                                                                       | Cooperative groups classes . . . . . . . . . . . . .                                       | 234   |
-|    | 23.3                                                                                       | Cooperative groups construct functions . . . .                                             | 237   |
-|    | 23.4                                                                                       | . . Cooperative groups exposed API functions . . . .                                       | 238   |
-| 24 | HSA runtime API for ROCm                                                                   | HSA runtime API for ROCm                                                                   | 241   |
-| 25 | HIP managed memory allocation API                                                          | HIP managed memory allocation API                                                          | 247   |
-| 26 | HIP virtual memory management API                                                          | HIP virtual memory management API                                                          | 251   |
-| 27 | HIP deprecated                                                                             | runtime API functions                                                                      |       |
-|    |                                                                                            |                                                                                            | 257   |
-|    | 27.1                                                                                       | Context management . . . . . . . . . . . . . . . .                                         | 257   |
-|    | 27.2                                                                                       | Memory management . . . . . . . . . . . . . . . . . .                                      | 258   |
-|    | 27.3                                                                                       | Profiler control . . . . . . . . . . . . . . . .                                           | 258   |
-|    | 27.4                                                                                       | Texture management . . . . . . . . . . . . . . . .                                         | 258   |
-| 28 | SAXPY - Hello, HIP                                                                         | SAXPY - Hello, HIP                                                                         | 261   |
-|    | 28.1 Prerequisites . . . . . .                                                             | . . . . . . . . . . .                                                                      | 261   |
-|    | . . . 28.2 Heterogeneous programming                                                       | . . . . . . . . .                                                                          | 261   |
-|    | . . 28.3 Your first lines of HIP code . . .                                                | . . . . . .                                                                                | 261   |
-|    | . . . 28.4 Compiling on the command line . . . .                                           | . . . . . .                                                                                | 263   |
-|    | 28.4.1 Setting up the command line                                                         | . . . . . . .                                                                              | 263   |
-|    | 28.4.2                                                                                     | Invoking the compiler manually . . . . .                                                   | 266   |
-| 29 | Reduction                                                                                  | Reduction                                                                                  | 273   |
-|    | 29.1 The algorithm . . . 29.2                                                              | . . . . . . . . . . . . . . . .                                                            | 273   |
-|    | Reduction on GPUs                                                                          | . . . . . . . . . . . . . . . .                                                            | 273   |
-|    | 29.2.1 Naive shared reduction                                                              | . . . . . . . . . .                                                                        | 274   |
-|    | 29.2.2                                                                                     | Reducing thread divergence . . . . . . . .                                                 | 276   |
-|    | 29.2.3                                                                                     | Resolving bank conflicts . . . . . . . . .                                                 | 276   |
-|    | 29.2.4                                                                                     | Utilize upper half of the block . . . . . . . . . . . . .                                  | 277   |
-|    | 29.2.5                                                                                     | Unroll all loops . . . . . . .                                                             | 281   |
-|    | 29.2.6                                                                                     | Communicate using warp-collective functions                                                | 282   |
-|    | 29.2.7                                                                                     | Prefer warp communication over shared                                                      | 282   |
-|    | 29.2.8                                                                                     | . Amortize bookkeeping variable overhead                                                   | 284   |
-|    | 29.2.8.1 Reading ItemsPerThread                                                            | . . .                                                                                      | 285   |
-|    | 29.2.8.2 Processing ItemsPerThread                                                         | . .                                                                                        | 286   |
-|    | 29.2.9 Two-pass reduction                                                                  | . . . . . . . . . . . .                                                                    | 286   |
-|    | 29.2.10 Global data share                                                                  | . . . . . . . . . . . . .                                                                  | 286   |
-|    | 29.3 Conclusion . . . . .                                                                  | . . . . . . . . . . . . . . . .                                                            | 287   |
-| 30 | Cooperative groups .                                                                       | Cooperative groups .                                                                       | 289   |
-|    | 30.1 Prerequisites                                                                         | . . . . . . . . . . . . . . . . . . .                                                      | 289   |
-|    | 30.2 Simple HIP Code                                                                       | . . . . . . . . . . . . . . . . . .                                                        | 289   |
-|    | Tiled partition                                                                            | . . . . . . .                                                                              | 289   |
-|    | 30.3 . . . . . . . . . . . . 30.3.1 Device-side code . . . . . .                           | . . .                                                                                      | 290   |
-|    | . . . . 30.3.1.1 1. Initialization of the reduction                                        | . . . . 30.3.1.1 1. Initialization of the reduction                                        | 291   |
-|    | function variables . . . 30.3.1.2 2. The reduction of thread block . . . . . . . . . . . . | function variables . . . 30.3.1.2 2. The reduction of thread block . . . . . . . . . . . . | 291   |
-
-|                     | 30.3.1.3 3. The reduction of custom partition . . . . . . . . . . . . . . . . . . . . . . . . . .   |   291 |
-|---------------------|-----------------------------------------------------------------------------------------------------|-------|
-| 30.3.2              | Host-side code . . . . . . . . . . . .                                                              |   292 |
-|                     | 30.3.2.1 1. Confirm the cooperative group support on AMDGPUs 30.3.2.2 . . . . .                     |   292 |
-|                     | 2. Initialize the cooperative group configuration . . . . . . . . . . . . . . . . . . .             |   293 |
-| 30.3.2.3 Conclusion | 4. Launch the kernel . . . . .                                                                      |   293 |
-| 30.4 .              | . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                           |   293 |
-| 31 License          |                                                                                                     |   295 |
-
-Index
-
-297
-
-The Heterogeneous-computing Interface for Portability (HIP) API is a C++ runtime API and kernel language that lets developers create portable applications for AMD and NVIDIA GPUs from single source code.
-
-For HIP supported AMD GPUs on multiple operating systems, see:
-
-- Linux system requirements
-- Microsoft Windows system requirements
-
-The CUDA enabled NVIDIA GPUs are supported by HIP. For more information, see GPU Compute Capability.
-
-On the AMD ROCm platform, HIP provides header files and runtime library built on top of HIP-Clang compiler in the repository Common Language Runtimes (CLR) , which contains source codes for AMD's compute languages runtimes as follows,
-
-On non-AMD platforms, like NVIDIA, HIP provides header files required to support non-AMD specific back-end implementation in the repository 'hipother', which translates from the HIP runtime APIs to CUDA runtime APIs.
-
-## Install
-
-- Installing HIP
-- Building HIP from source
-
-## Conceptual
-
-- HIP programming model
-- Hardware implementation
-- AMD common language runtimes (CLR)
-
-## How to
-
-- Programming manual
-- HIP porting guide
-- HIP porting: driver API guide
-- Programming for HIP runtime compiler (RTC)
-- Performance guidelines
-- Debugging with HIP
-- Logging HIP activity
-- Unified memory
-- Virtual memory
-- Cooperative groups
-- Frequently asked questions
-
-## Reference
-
-- HIP Runtime API Reference
-- C++ language extensions
-- C++ language support
-- HIP math API
-- Comparing syntax for different APIs
-- HSA runtime API for ROCm
-- HIP managed memory allocation API
-
-## CHAPTER ONE
-
-## OVERVIEW
-
-- HIP virtual memory management API
-- HIP Cooperative groups API
-- List of deprecated APIs
-
-## Tutorial
-
-- HIP basic examples
-- HIP examples
-- HIP test samples
-- SAXPY tutorial
-- Reduction tutorial
-- Cooperative groups tutorial
-
-Known issues are listed on the HIP GitHub repository.
-
-To contribute features or functions to the HIP project, refer to Contributing to HIP. To contribute to the documentation, refer to Contributing to ROCm docs page.
-
-You can find licensing information on the Licensing page.
-
-## CHAPTER
-
-## TWO
-
-## INSTALL HIP
-
-HIP can be installed on AMD (ROCm with HIP-Clang) and NVIDIA (CUDA with NVCC) platforms.
-
-Note: The version definition for the HIP runtime is different from CUDA. On an AMD platform, the hipRuntimeGerVersion function returns the HIP runtime version; on an NVIDIA platform, this function returns the CUDA runtime version.
-
-## 2.1 Prerequisites
-
-## AMD
-
-Refer to the Prerequisites section in the ROCm install guides:
-
-- System requirements (Linux)
-- System requirements (Windows)
-
-## NVIDIA
-
-Check the system requirements in the NVIDIA CUDA Installation Guide.
-
-## 2.2 Installation
-
-## AMD
-
-HIP is automatically installed during the ROCm installation. If you haven't yet installed ROCm, you can find installation instructions here:
-
-- ROCm installation for Linux
-- HIP SDK installation for Windows
-
-By default, HIP is installed into /opt/rocm/hip .
-
-Note: There is no autodetection for the HIP installation. If you choose to install it somewhere other than the default location, you must set the HIP\_PATH environment variable as explained in Build HIP from source.
-
-## NVIDIA
-
-1. Install the NVIDIA driver.
-
-sudo apt-get install ubuntu-drivers-common &amp;&amp; sudo ubuntu-drivers autoinstall sudo reboot
-
-Alternatively, you can download the latest CUDA Toolkit.
-
-2. Install the hip-runtime-nvidia and hip-dev packages. This installs the CUDA SDK and HIP porting layer.
-**Following code does:** This code snippet defines an enumeration `hipMemoryType` in C/C++ for the AMD platform, specifically within the HIP (Heterogeneous-Compute Interface for Portability) runtime API. The enumeration categorizes different types of memory based on their physical location and management. The types include:
-
-- `hipMemoryTypeHost`: Memory located on the host (CPU).
-- `hipMemoryTypeDevice`: Memory located on a specific device (GPU).
-- `hipMemoryTypeArray`: Array memory located on a specific device.
-- `hipMemoryTypeUnified`: Currently not used.
-- `hipMemoryTypeManaged`: Managed memory that is automatically handled by the unified memory system.
-
-This enumeration helps in identifying and managing different memory types in heterogeneous computing environments.
-
-
-```
-  | apt-get install hi
-```
-**Following code does:** The code snippet `<_Cuda_>` appears to be a placeholder or a symbolic representation rather than actual executable code. In the context of programming, particularly with Python, it might suggest a reference to CUDA, which is a parallel computing platform and application programming interface (API) model created by NVIDIA. CUDA allows developers to use a GPU for general purpose processing, which can significantly accelerate computations. However, without additional context or actual code, it is not possible to determine any specific functionality or purpose from this snippet alone.
-
-
-```
-tall hip-runtime-nvidia hip-dev
-```
-
-## The default paths are:
-
-- CUDA SDK: /usr/local/cuda
-- HIP: /opt/rocm/hip
-
-You can optionally add /opt/rocm/bin to your path, which can make it easier to use the tools.
-
-## 2.3 Verify your installation
-
-Run hipconfig in your installation path.
-
-/opt/rocm/bin/hipconfig --full
-
-CHAPTER
-
-## THREE
-
-## BUILD HIP FROM SOURCE
-
-## 3.1 Prerequisites
-
-HIP code can be developed either on AMD ROCm platform using HIP-Clang compiler, or a CUDA platform with nvcc installed. Before building and running HIP, make sure drivers and prebuilt packages are installed properly on the platform.
-
-You also need to install Python 3, which includes the CppHeaderParser package. Install Python 3 using the following command:
-**Following code does:** It seems there is a formatting error in your request. The code snippet is labeled as C++ but is enclosed within Python code tags. Please provide the correct code snippet or clarify the language so I can assist you accurately.
-
-
-```
-    | apt-get install python3
-```
-
-Check and install CppHeaderParser package using the command:
-**Following code does:** It seems there is a formatting error in your request. The code snippet is labeled as Python, but it contains a placeholder that suggests it should be C++ code. Please provide the correct code snippet or clarify the language so I can assist you accurately.
-
-
-```
-      | pip3 install CppHeaderParser
-```
-
-## 3.2 Building the HIP runtime
-
-Set the repository branch using the variable: ROCM\_BRANCH . For example, for ROCm 6.1, use:
-**Following code does:** This code snippet is part of a build process for a project that involves compiling CUDA code using the HIP (Heterogeneous-Compute Interface for Portability) compiler. The `export HIPCC_VERBOSE=1` command sets an environment variable to enable verbose output from the HIP compiler, which provides detailed information about the compilation process. The `make` command is then executed, which typically runs a Makefile to build the project. The output shown (`hipcc-cmd: ...`) indicates that the HIP compiler (`hipcc`) is being invoked to compile a CUDA source file (`backprop_cuda.cu`) with specific options, such as targeting the native architecture for offloading. This process is likely part of porting or optimizing CUDA code for different hardware using HIP.
-
-
-```
-| export
-```
-**Following code does:** The code snippet `<_Cuda_>` appears to be a placeholder or a symbolic representation rather than actual executable code. In the context of programming, "Cuda" typically refers to NVIDIA's parallel computing platform and application programming interface (API) model, which allows developers to use a CUDA-enabled graphics processing unit (GPU) for general purpose processing. However, without additional context or actual code, it's not possible to determine the specific functionality or purpose of this snippet. It might be used in documentation, pseudocode, or as a marker in a larger codebase to indicate where CUDA-related code or functionality is intended to be implemented.
-
-
-```
-<_Bash_>
-```
-
-## AMD
-
-1. Get HIP source code.
-
-Note: Starting in ROCM 5.6, CLR is a new repository that includes the former ROCclr, HIPAMD and OpenCl repositories. OpenCL provides headers that ROCclr runtime depends on.
-
-Note: Starting in ROCM 6.1, a new repository hipother is added to ROCm, which is branched out from HIP. hipother provides files required to support the HIP back-end implementation on some non-AMD platforms, like NVIDIA.
-**Following code does:** The provided code snippet appears to be a series of malformed XML declarations interspersed with various symbols and whitespace. It does not perform any functional operations or represent valid XML or Python code. Its high-level purpose is unclear, as it does not conform to any recognizable programming or markup language syntax. It seems to be a nonsensical or corrupted text rather than executable code.
-
-
-```
-<_Bash_>
-```
-**Following code does:** This code snippet is the beginning of a C++ program that is set up to use the HIP (Heterogeneous-computing Interface for Portability) API, which is designed for writing portable code that can run on both AMD and NVIDIA GPUs. The `#include` directives are used to include the necessary headers for HIP runtime functions (`hip_runtime.h` and `hip_runtime_api.h`) and standard C++ functionalities (`iostream` for input/output stream operations, `fstream` for file stream operations, and `vector` for using the vector container). This setup suggests that the program will likely involve GPU computations and possibly handle input/output operations and data storage using vectors.
-
-
-```
-:lone -b "$ROCM_BRANCH" https://github.com/ROCm/clr.git
-:lone -b "$ROCM_BRANCH" https://github.com/ROCm/hip.git
-```
-
-CLR (Common Language Runtime) repository includes ROCclr, HIPAMD and OpenCL.
-
-ROCclr (Radeon Open Compute Common Language Runtime) is a virtual device interface which is defined on the AMD platform. HIP runtime uses ROCclr to interact with different backends.
-
-HIPAMD provides implementation specifically for HIP on the AMD platform.
-
-OpenCL provides headers that ROCclr runtime currently depends on. hipother provides headers and implementation specifically for non-AMD HIP platforms, like NVIDIA.
-
-2. Set the environment variables.
-3. Build HIP.
-**Following code does:** This code snippet is a C++ program that includes headers for HIP (Heterogeneous-Compute Interface for Portability) runtime and API, which are used for GPU programming, particularly with AMD hardware. Additionally, it includes standard C++ headers for input/output operations (`iostream`), file handling (`fstream`), and using the vector container (`vector`). The purpose of this setup is likely to perform GPU-accelerated computations while also handling input/output operations and managing data using vectors in a C++ application.
-
-
-```
-<_Bash_>
-```
-**Following code does:** This code snippet is a C++ program that uses the HIP (Heterogeneous-Compute Interface for Portability) API to perform a vector copy operation on a GPU. The program is designed to work on both AMD and NVIDIA platforms, as indicated by the conditional compilation directives. Here's a high-level summary of what the code does:
-
-1. **Define Constants**: It defines constants for the length of the vectors (`LEN`) and the size in bytes (`SIZE`).
-
-2. **Platform-Specific File Names**: Depending on whether the code is compiled for an AMD or NVIDIA platform, it sets the appropriate file name for the compiled GPU kernel.
-
-3. **Initialize Vectors**: It allocates and initializes two float arrays, `A` and `B`, each of length `LEN`. Array `A` is initialized with sequential float values, while `B` is initialized with zeros.
-
-4. **GPU Initialization (NVIDIA only)**: If compiled for an NVIDIA platform, it initializes the HIP runtime, gets a device, and creates a context.
-
-5. **Memory Allocation on GPU**: It allocates memory on the GPU for both arrays `A` and `B`.
-
-6. **Data Transfer to GPU**: It copies the contents of arrays `A` and `B` from host memory to the allocated GPU memory.
-
-7. **Kernel Loading and Execution Setup**: It loads a GPU module from a file and retrieves a function (kernel) named "hello_world" from the module. It prepares the arguments for the kernel launch.
-
-The code is incomplete, as it ends abruptly, but it appears to be setting up for launching a GPU kernel that would likely perform some operation on the vectors `A` and `B`.
-
-
-```
-        cd "$CLR_DIR"
-        mkdir -p build; cd build
-        cmake -DHIP_COMMON_DIR=$HIP_DIR -DHIP_PLATFORM=amd -DCMAKE_PREFIX_PATH="/opt/rocm/"_
-        ---DCMAKE_INSTALL_PREFIX=$PWD/install -DHIP_CATCH_TEST=0 -DCLR_BUILD_HIP=ON -DCLR_
-        --BUILD_OCL=OFF..
-        
-        make -j$(nproc)
-        sudo make install
-```
-
-Note: Note, if you don't specify CMAKE\_INSTALL\_PREFIX , the HIP runtime is installed at &lt;ROCM\_PATH&gt;/hip .
-
-By default, release version of HIP is built. If need debug version, you can put the option CMAKE\_BUILD\_TYPE=Debug in the command line.
-
-Default paths and environment variables:
-
-- HIP is installed into &lt;ROCM\_PATH&gt;/hip . This can be overridden by setting the HIP\_PATH environment variable.
-
-•
-
-HSA is in
-
-&lt;ROCM\_PATH&gt;/hsa
-
-. This can be overridden by setting the
-
-HSA\_PATH
-
-environment variable.
-
-- Clang is in &lt;ROCM\_PATH&gt;/llvm/bin . This can be overridden by setting the HIP\_CLANG\_PATH environment variable.
-- The device library is in &lt;ROCM\_PATH&gt;/lib . This can be overridden by setting the DEVICE\_LIB\_PATH environment variable.
-- Optionally, you can add &lt;ROCM\_PATH&gt;/bin to your PATH , which can make it easier to use the tools.
-- Optionally, you can set HIPCC\_VERBOSE=7 to output the command line for compilation.
-
-After you run the make install command, make sure HIP\_PATH points to $PWD/install/hip .
-
-1. Generate a profiling header after adding/changing a HIP API.
-
-Whenyouadd or change a HIP API, you may need to generate a new hip\_prof\_str.h header. This header is used by ROCm tools to track HIP APIs, such as rocprofiler and roctracer .
-
-To generate the header after your change, use the hip\_prof\_gen.py tool located in hipamd/src .
-
-Usage:
-**Following code does:** The code snippet appears to be part of a larger program that utilizes HIP (Heterogeneous-Compute Interface for Portability) to perform parallel computation on a GPU. Here's a high-level summary of what the code does:
-
-1. **Kernel Launch**: It launches a GPU kernel using `hipModuleLaunchKernel`. The kernel is specified by `Function`, and it is configured to execute with a grid size of 1x1x1 and a block size of `LEN`x1x1. The kernel is passed a configuration parameter `config`.
-
-2. **Data Transfer**: After the kernel execution, the code copies data from the device (GPU) to the host (CPU) using `hipMemcpyDtoH`. The data is copied from `Bd` (device memory) to `B` (host memory), with the size specified by `SIZE`.
-
-3. **Output**: It iterates over the length `LEN` and prints the values of arrays `A` and `B` to the standard output, displaying them in a formatted manner.
-
-4. **Context Detachment**: If the code is compiled for an NVIDIA platform (`__HIP_PLATFORM_NVIDIA__`), it detaches the HIP context using `hipCtxDetach`.
-
-5. **Return**: The function returns 0, indicating successful execution.
-
-Overall, this code is part of a GPU computing application that sets up and executes a kernel on a GPU, retrieves the results, and prints them.
-
-
-```
-<_PHP_>
-```
-**Following code does:** This code snippet is part of a CUDA or HIP (Heterogeneous-Compute Interface for Portability) program, which is used for parallel computing on GPUs. It declares an external 2D texture reference named `tex` that holds floating-point data. The snippet also includes the beginning of a kernel function definition, `tex2dKernel`, which is intended to be executed on the GPU. This kernel function takes a parameter `outputData`, which is likely an array where the results of the texture operations will be stored. The `hipLaunchParm lp` is a parameter used for launching the kernel with specific execution configurations. The code is incomplete, so the specific operations performed by the kernel are not shown.
-
-
-```
-                                                                                                                                                                                                        |                                                                                                                                                                                                       
-                                                                                                                                                                                                        <! hip_prof_gen.py                                                                                                                                                                                                        </!                                                                                                                                                                                                        >
-                                                                                                                                                                                                       <?php                                                                                                                                                                                                        +
-```
-
-## Flags:
-
-- -v : Verbose messages
-- -r : Process source directory recursively
-- -t : API types matching check
-- --priv : Private API check
-- -e : On error exit mode
-- -p : HIP\_INIT\_API macro patching mode
-
-Example usage:
-**Following code does:** This code snippet is part of a host program that interacts with a GPU using the HIP (Heterogeneous-Compute Interface for Portability) API, which is used for writing portable applications across different GPU architectures. The code sets up a 2D texture reference for use in GPU computations. Specifically, it retrieves a texture reference from a module, sets the address mode for both dimensions to wrap (which means texture coordinates will wrap around), and sets the filter mode to point sampling (which means the nearest texel value will be used). This setup is typically used to configure how textures are accessed and sampled in GPU kernels.
-
-
-```
-<_Bash_>
-```
-
-## NVIDIA
-**Following code does:** This code snippet is configuring a texture reference in a HIP (Heterogeneous-Compute Interface for Portability) application, which is used for GPU programming. Specifically, it sets the flags for the texture reference to zero, specifies the format of the texture data as a single-channel floating-point format, and associates the texture reference with a specified array while overriding the format. This setup is typically used to prepare texture data for use in GPU computations, such as in graphics or parallel processing tasks.
-
-
-```
-git clone -b "$ROCM_BRANCH" https://github.com/ROCm/clr.git
-git clone -b "$ROCM_BRANCH" https://github.com/ROCm/hip.git
-git clone -b "$ROCM_BRANCH" https://github.com/ROCm/hipother.git
-```
-**Following code does:** The code snippet `<_C_>` appears to be incomplete or not a valid Python code. It does not represent any recognizable Python construct or functionality. It might be a placeholder or a typo. Without additional context or surrounding code, it's not possible to determine its purpose or functionality.
-
-
-```
---- ---
-
-    1. Get the HIP source code.
-        git clone -b "$ROCM_BRANCH"
-        git clone -b "$ROCM_BRANCH"
-        git clone -b "$ROCM_BRANCH"
-
-    2. Set the environment variables.
-```
-**Following code does:** This code snippet is a call to the `hiprtcCreateProgram` function, which is part of the HIP Runtime Compilation (HIPRTC) API. The function is used to create a program object for a GPU kernel written in CUDA C/C++. The parameters provided include the kernel source code as a string, the name of the file for the kernel, the number of header files, and arrays containing the header source code and their corresponding names. This setup is typically used to compile and execute GPU kernels dynamically at runtime.
-
-
-```
-export CLR_DIR="$(readlink -f clr)"
-export HIP_DIR="$(readlink -f hip)"
-export HIP_OTHER="$(readlink -f hipother)"
-```
-**Following code does:** This code snippet appears to be a call to the `hiprtcCompileProgram` function, which is part of the HIP (Heterogeneous-Compute Interface for Portability) runtime compilation library. The function is used to compile a HIPRTC program, which is typically written in a CUDA-like language, into a binary that can be executed on a GPU. In this specific call, the function is provided with a `hiprtcProgram` object (`prog`) and is instructed to compile it with zero additional options (`0`), although there is a placeholder for options (`options`) which suggests that options could be passed if needed. The comment indicates that supported Clang options can be used, but none are specified here.
-
-
-```
-3.  Build HIP.
-```
-**Following code does:** It seems there is a formatting error in your request. The code snippet is labeled as Python, but the placeholder `<_C++_>` suggests it might be intended for C++. Please provide the correct code snippet or clarify the language so I can assist you accurately.
-
-
-```
-cd "$CLR_DIR"
-mkdir -p build; cd build
-cmake -DHIP_COMMON_DIR=$HIP_DIR -DHIP_PLATFORM=nvidia -DCMAKE_INSTALL_PREFIX=$PWD/
- --install -DHIP_CATCH_TEST=0 -DCLR_BUILD_HIP=ON -DCLR_BUILD_OCL=OFF -DHIPNV_DIR=
- --$HIP_OTHER/hipnv..
-make -j$(nproc)
-sudo make install
-```
-
-## 3.3 Build HIP tests
-
-## AMD
-
-- Build HIP catch tests.
-**Following code does:** This code snippet retrieves the compiled binary code of a GPU kernel using the HIP runtime compilation (hipRTC) API. It first determines the size of the compiled code with `hiprtcGetCodeSize`, storing it in `codeSize`. Then, it allocates a vector `kernel_binary` of the appropriate size to hold the binary data. Finally, it populates this vector with the actual compiled kernel code using `hiprtcGetCode`. This process is typically part of a workflow where GPU kernels are dynamically compiled and executed.
-
-
-```
-git clone -b "$ROCM_BRANCH" https://github.com/ROCm/hip-tests.git  |
-```
-**Following code does:** This code snippet is using the HIP (Heterogeneous-Compute Interface for Portability) API to load and prepare a GPU kernel for execution. Specifically, it performs the following high-level tasks:
-
-1. Loads a compiled GPU kernel binary into a HIP module using `hipModuleLoadData`.
-2. Retrieves a specific function, named "vector_add", from the loaded module using `hipModuleGetFunction`.
-
-This setup is typically used in GPU programming to execute parallel computations on a GPU, where "vector_add" likely refers to a kernel function that performs vector addition.
-
-
-```
-        - npm -m -cos no-source.
-
-            export HIPTESTS_DIR="$(readlink -f hip-tests)"
-            cd "$HIPTESTS_DIR"
-            mkdir -p build; cd build
-            cmake../catch -DHIP_PLATFORM=amd -DHIP_PATH=$CLR_DIR/build/
-            --install  # or any path where HIP is installed; for example: ``/
-            --opt/rocm``
-            make build_tests
-            ctest # run tests
-```
-**Following code does:** The code snippet provided is essentially empty and does not perform any operations or have any functionality. It consists only of whitespace and a comment symbol (`//`), which is typically used for comments in languages like C, C++, and Java, but not in Python. In Python, comments are denoted by the `#` symbol. Therefore, this snippet does not execute any code or serve any purpose.
-
-
-```
-AMD
-
-     *  Build HIP catch tests.
-
-                HIP catch tests are separate from the HIP project and use Catch2.
-
-                    - Get HIP tests source code.
-```
-**Following code does:** The code snippet provided consists entirely of a series of angle brackets (`<` and `>`) and hyphens (`-`). It does not contain any executable Python code or meaningful syntax. Therefore, it does not perform any operations or have any functional purpose in a Python program. It appears to be a visual pattern or placeholder rather than actual code.
-
-
-```
-      - command: command.json.
-        
-          cd "$HIPTESTS_DIR"
-          hipcc $HIPTESTS_DIR/catch/unit/memory/hipPointerGetAttributes.cc \
-          -I./catch/include./catch/hipTestMain/standalone_main.cc \
-          -I./catch/external/Catch2 -o hipPointerGetAttributes
-         ./hipPointerGetAttributes
-         ...
-
-          All tests passed
-```
-
-## NVIDIA
-
-The commands to build HIP tests on an NVIDIA platform are the same as on an AMD platform. However, you must first set -DHIP\_PLATFORM=nvidia .
-
-## 3.4 Run HIP
-
-After installation and building HIP, you can compile your application and run. A simple example is square sample.
-
-## FOUR
-
-## HIP PROGRAMMING MODEL
-
-The HIP programming model makes it easy to map data-parallel C/C++ algorithms to massively parallel, wide single instruction, multiple data (SIMD) architectures, such as GPUs.
-
-While the model may be expressed in most imperative languages, (for example Python via PyHIP) this document will focus on the original C/C++ API of HIP.
-
-A basic understanding of the underlying device architecture helps you make efficient use of HIP and general purpose graphics processing unit (GPGPU) programming in general.
-
-## 4.1 RDNA &amp; CDNA architecture summary
-
-GPUs in general are made up of basic building blocks called compute units (CUs), that execute the threads of a kernel. These CUs provide the necessary resources for the threads: the Arithmetic Logical Units (ALUs), register files, caches and shared memory for efficient communication between the threads.
-
-This design allows for efficient execution of kernels while also being able to scale from small GPUs embedded in APUs with few CUs up to GPUs designed for data centers with hundreds of CUs. Figure Block Diagram of an RDNA3 Compute Unit. and Block Diagram of a CDNA3 Compute Unit. show examples of such compute units.
-
-For architecture details, check Hardware implementation .
-
-Fig. 1: Block Diagram of an RDNA3 Compute Unit.
-
-Schedule.
-
-**Image description:** The image is a block diagram representing the architecture of a graphics processing unit (GPU). It is divided into two main sections, each containing multiple components that are responsible for different computational tasks. 
-
-On the left side, there are two identical blocks labeled "Scheduler," each containing:
-- Vector GPR (General Purpose Registers) for handling operations like Float/INT/Matrix SIMD32, Float/Matrix SIMD32, and Transcendental SIMD8.
-- AI MATRIX Accelerator for artificial intelligence matrix operations.
-- DPFP (Double Precision Floating Point) unit.
-- Scalar GPR and Scalar ALU (Arithmetic Logic Unit) for scalar operations.
-
-In the center, there are two caches:
-- Scalar Cache for storing scalar data.
-- Shader Instruction Cache for storing shader instructions.
-
-On the right side, there are two identical blocks labeled "Scheduler," each containing:
-- Scalar GPR and Scalar ALU.
-- Vector GPR for similar operations as the left side.
-- AI MATRIX Accelerator and DPFP unit.
-
-Adjacent to these blocks is a section labeled "Shared Memory," which is used for data exchange between different processing units.
-
-Finally, on the far right, there are components for handling graphics-specific tasks:
-- Ray Accelerator for ray tracing operations.
-- Texture Filters for texture processing.
-- LD/ST/Tex Addr for load/store and texture addressing.
-- L0 cache for fast data access.
-
-The diagram uses red to highlight the functional units and white for the cache and shared memory areas, indicating a focus on computational and memory management capabilities within the GPU architecture.
-
-![Image](data:image/png;base64,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)
-
-Fig. 2: Block Diagram of a CDNA3 Compute Unit.
-
-The image depicts a horizontal bar chart titled "Local Data Share." The chart is divided into two main sections: the left section and the right section.
-
-### Left Section:
-- **Title:** "Local Data Share"
-- **X-axis:** Labeled "Schedule"
-- **Y-axis:** Labeled "Matrix Core Unit"
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
--
-
-**Image description:** The image depicts a horizontal bar chart titled "Local Data Share." The chart is divided into two main sections: the left section and the right section.
-
-### Left Section:
-- **Title:** "Local Data Share"
-- **X-axis:** Labeled "Schedule"
-- **Y-axis:** Labeled "Matrix Core Unit"
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
--
-
-![Image](data:image/png;base64,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)
-
-## 4.2 Heterogeneous Programming
-
-The HIP programming model assumes two execution contexts. One is referred to as host while compute kernels execute on a device . These contexts have different capabilities, therefor slightly different rules apply. The host execution is defined by the C++ abstract machine, while device execution follows the SIMT model of HIP. These execution contexts in code are signified by the \_\_host\_\_ and \_\_device\_\_ decorators. There are a few key differences between the two:
-
-- The C++ abstract machine assumes a unified memory address space, meaning that one can always access any given address in memory (assuming the absence of data races). HIP however introduces several memory namespaces, an address from one means nothing in another. Moreover, not all address spaces are accessible from all contexts.
-- Looking at Block Diagram of an RDNA3 Compute Unit. and Block Diagram of a CDNA3 Compute Unit. , you can see that every CU has an instance of storage backing the namespace \_\_shared\_\_ . Even if the host were to have access to these regions of memory, the performance benefits of the segmented memory subsystem are supported by the inability of asynchronous access from the host.
-- Not all C++ language features map cleanly to typical device architectures, some are very expensive (meaning slow) to implement on GPU devices, therefor they are forbidden in device contexts to avoid users tapping into features that unexpectedly decimate their program's performance. Offload devices targeted by HIP aren't general purpose devices, at least not in the sense that a CPU is. HIP focuses on data parallel computations and as such caters to throughput optimized architectures, such as GPUs or accelerators derived from GPU architectures.
-- Asynchrony is at the forefront of the HIP API. Computations launched on the device execute asynchronously with respect to the host, and it is the user's responsibility to synchronize their data dispatch/fetch with computations on the device.
-
-Note: HIP does perform implicit synchronization on occasions, more advanced than other APIs such as OpenCL or SYCL, in which the responsibility of synchronization mostly depends on the user.
-
-## 4.3 Single instruction multiple threads (SIMT)
-
-The SIMT programming model behind the HIP device-side execution is a middle-ground between SMT (Simultaneous Multi-Threading) programming known from multicore CPUs, and SIMD (Single Instruction, Multiple Data) programming mostly known from exploiting relevant instruction sets on CPUs (for example SSE/AVX/Neon).
-
-A HIP device compiler maps SIMT code written in HIP C++ to an inherently SIMD architecture (like GPUs). This is done by scalarizing the entire kernel and issuing the scalar instructions of multiple kernel instances (called threads) to each of the SIMD engine lanes, rather than exploiting data parallelism within a single instance of a kernel and spreading identical instructions over the available SIMD engines.
-
-Consider the following kernel:
-**Following code does:** The code snippet appears to be a fragment of a documentation header or title, rather than executable code. It likely indicates the version of a software release, specifically version 6.1.40092, for a project or product abbreviated as "HIP." This kind of line is typically used to label or identify the version of documentation associated with a particular release of the software.
-
-
-```
-__global__ void k(float4* a, const float4* b)
-{
-  int tid = threadIdx.x;
-  int bid = blockIdx.x;
-  int dim = blockDim.x;
-
-  a[tid] += (tid + bid - dim) * b[tid];
-}
-```
-
-The incoming four-vector of floating-point values b is multiplied by a scalar and then added element-wise to the fourvector floating-point values of a . On modern SIMD-capable architectures, the four-vector ops are expected to compile to a single SIMD instruction. However, GPU execution of this kernel will typically break down the vector elements into 4 separate threads for parallel execution, as seen in the following figure:
-
-Fig. 3: Instruction flow of the sample SIMT program.
-
-In HIP, lanes of the SIMD architecture are fed by mapping threads of a SIMT execution, one thread down each lane of an SIMD engine. Execution parallelism usually isn't exploited from the width of the built-in vector types, but across multiple threads via the thread ID constants threadIdx.x , blockIdx.x , etc.
-
-## 4.4 Inherent thread model
-
-The SIMT nature of HIP is captured by the ability to execute user-provided device programs, expressed as single-source C/C++ functions or sources compiled online/offline to binaries, in bulk.
-
-All threads of a kernel are uniquely identified by a set of integral values, called thread IDs. The set of integers identifying a thread relate to the hierarchy in which the threads execute.
-
-The thread hierarchy inherent to how AMD GPUs operate is depicted in the following figure.
-
-Fig. 4: Hierarchy of thread groups.
-
-## Warp (or Wavefront)
-
-The innermost grouping of threads is called a warp, or a wavefront in ISA terms. A warp is the most tightly coupled groups of threads, both physically and logically. Threads inside a warp are also called lanes, and the integral value identifying them is the lane ID.
-
-Tip: Lane IDs aren't queried like other thread IDs, but are user-calculated. As a consequence, they are only as multidimensional as the user interprets the calculated values to be.
-
-The size of a warp is architecture dependent and always fixed. For AMD GPUs the wavefront is typically 64 threads, though sometimes 32 threads. Warps are signified by the set of communication primitives at their disposal, as discussed in Warp cross-lane functions .
-
-The middle grouping is called a block or thread block. The defining feature of a block is that all threads in a block will share an instance of memory which they may use to share data or synchronize with one another.
-
-The size of a block is user-configurable but is limited by the queryable capabilities of the executing hardware. The unique ID of the thread within a block is 3-dimensional as provided by the API. When linearizing thread IDs within a block, assume the 'fast index' being dimension x , followed by the y and z dimensions.
-
-## Block
-
-## Grid
-
-The outermost grouping is called a grid. A grid manifests as a single dispatch of kernels for execution. The unique ID of each block within a grid is 3-dimensional, as provided by the API and is queryable by every thread within the block.
-
-## 4.4.1 Cooperative groups thread model
-
-The Cooperative groups API introduces new APIs to launch, group, subdivide, synchronize and identify threads, as well as some predefined group-collective algorithms, but most importantly a matching threading model to think in terms of. It relaxes some restrictions of the Inherent thread model imposed by the strict 1:1 mapping of architectural details to the programming model. Cooperative groups let you define your own set of thread groups which may fit your user-cases better than the defaults defined by the hardware.
-
-Note: The implicit groups defined by kernel launch parameters are still available when working with cooperative groups.
-
-For further information, see Cooperative groups.
-
-## 4.5 Memory model
-
-The hierarchy of threads introduced by the Inherent thread model is induced by the memory subsystem of GPUs. The following figure summarizes the memory namespaces and how they relate to the various levels of the threading model.
-
-Fig. 5: Memory hierarchy.
-
-## Local or per-thread memory
-
-Read-write storage only visible to the threads defining the given variables, also called per-thread memory. The size of a block for a given kernel, and thereby the number of concurrent warps, are limited by local memory usage. This relates to an important aspect: occupancy. This is the default memory namespace.
-
-## Shared memory
-
-Read-write storage visible to all the threads in a given block.
-
-## Global
-
-Read-write storage visible to all threads in a given grid. There are specialized versions of global memory with different usage semantics which are typically backed by the same hardware storing global.
-
-## Constant
-
-Read-only storage visible to all threads in a given grid. It is a limited segment of global with queryable size.
-
-## Texture
-
-Read-only storage visible to all threads in a given grid and accessible through additional APIs.
-
-## Surface
-
-A read-write version of texture memory.
-
-## 4.6 Execution model
-
-HIP programs consist of two distinct scopes:
-
-- The host-side API running on the host processor. There are two APIs available:
-- -The HIP runtime API which enables use of the single-source programming model.
-- -The HIP driver API which sits at a lower level and most importantly differs by removing some facilities provided by the runtime API, most importantly around kernel launching and argument setting. It is geared towards implementing abstractions atop, such as the runtime API itself. Offers two additional pieces of functionality not provided by the Runtime API: hipModule and hipCtx APIs. For further details, check HIP driver API.
-- The device-side kernels running on GPUs. Both the host and the device-side APIs have synchronous and asynchronous functions in them.
-
-Note: The HIP does not present two separate APIs link NVIDIA CUDA. HIP only extends the HIP runtime API with new APIs for hipModule and hipCtx .
-
-## 4.6.1 Host-side execution
-
-The part of the host-side API which deals with device management and their queries are synchronous. All asynchronous APIs, such as kernel execution, data movement and potentially data allocation/freeing all happen in the context of device streams.
-
-Streams are FIFO buffers of commands to execute relating to a given device. Commands which enqueue tasks on a stream all return promptly and the command is executed asynchronously. All side effects of a command on a stream are visible to all subsequent commands on the same stream. Multiple streams may point to the same device and those streams may be fed from multiple concurrent host-side threads. Execution on multiple streams may be concurrent but isn't required to be.
-
-Asynchronous APIs involving a stream all return a stream event which may be used to synchronize the execution of multiple streams. A user may enqueue a barrier onto a stream referencing an event. The barrier will block until the command related to the event does not complete, at which point all side effects of the command shall be visible to commands following the barrier, even if those side effects manifest on different devices.
-
-Streams also support executing user-defined functions as callbacks on the host. The stream will not launch subsequent commands until the callback completes.
-
-## 4.6.2 Device-side execution
-
-The SIMT programming model behind the HIP device-side execution is a middle-ground between SMT (Simultaneous Multi-Threading) programming known from multicore CPUs, and SIMD (Single Instruction, Multiple Data) programming mostly known from exploiting relevant instruction sets on CPUs (for example SSE/AVX/Neon).
-
-## 4.6.3 Kernel launch
-
-Kernels may be launched in multiple ways all with different syntaxes and intended use-cases.
-
-- Using the triple-chevron &lt;&lt;&lt;...&gt;&gt;&gt; operator on a \_\_global\_\_ annotated function.
-- Using hipLaunchKernelGGL() on a \_\_global\_\_ annotated function.
-
-Tip: This name by default is a macro expanding to triple-chevron. In cases where language syntax extensions are undesirable, or where launching templated and/or overloaded kernel functions define the HIP\_TEMPLATE\_KERNEL\_LAUNCH preprocessor macro before including the HIP headers to turn it into a templated function.
-
-- Using the launch APIs supporting the triple-chevron syntax directly.
-
-Caution: These APIs are intended to be used/generated by tools such as the HIP compiler itself and not intended towards end-user code. Should you be writing a tool having to launch device code using HIP, consider using these over the alternatives.
-
-## HARDWARE IMPLEMENTATION
-
-This chapter describes the typical hardware implementation of GPUs supported by HIP, and how the Inherent thread model maps to the hardware.
-
-## 5.1 Compute units
-
-The basic building block of a GPU is a compute unit (CU), also known as streaming multiprocessor (SM) on NVIDIA GPUs. The thread blocks making up a grid are scheduled for execution on CUs. Each block is assigned to an individual CU, and a CU can accommodate several blocks. Depending on their resource usage up to thousands of threads can reside on a CU.
-
-CUs contain an array of processing elements, referred to as vector ALU (VALU), that execute the actual instructions of the threads according to the SIMT model , together with the necessary registers and caches.
-
-The threads are executed in groupings called warps. The amount of threads making up a warp is architecture dependent. On AMD GPUs the warp size is commonly 64 threads, except in RDNA architectures which can utilize a warp size of 32 or 64 respectively. The warp size of supported AMD GPUs is listed in the Accelerator and GPU hardware specifications. NVIDIA GPUs have a warp size of 32.
-
-In contrast to CPUs, GPUs generally do not employ complex cache structures or control logic, like branch prediction or out-of-order execution, but instead rely on massive hardware multithreading to hide latency.
-
-Context switching between warps residing on a CU incurs no overhead, as the context for the warps is stored on the CU and does not need to be fetched from memory. If there are not enough free registers to accommodate all warps of a block, the block can not be scheduled to that CU and it has to wait until other blocks finish execution.
-
-The amount of warps that can reside concurrently on a CU, known as occupancy, is determined by the warp's resource usage of registers and shared memory.
-
-Fig. 1: An AMD Graphics Core Next (GCN) CU. The CDNA and RDNA CUs are based on variations of the GCN CU.
-
-On AMD GCN GPUs the basic structure of a CU is:
-
-- four Single Instruction Multiple Data units (SIMDs)
-- a vector cache
-- a local data share
-- and a scalar unit
-
-## 5.1.1 SIMD
-
-A SIMD consists of a VALU, that executes the instruction of a warp, together with a register file, that provides the registers warps.
-
-The size of the warp is inherently related to the width of the vector ALU of the SIMD. On GCN compute units the width of the VALU is 16, so a warp can be issued to a SIMD every 4 cycles. Since a CU has 4 SIMDs it issues one warp per cycle. The instructions of a warp are effectively executed in lock-step.
-
-A SIMD always executes the same instruction for the whole VALU. If the control flow of a warp diverges, the performance is decreased, as the results for the threads that do not participate in that branch have to be masked out, and the instructions of the other branch have to be executed in the same way. The best performance can therefore be achieved when thread divergence is kept to a warp level, i.e. when all threads in a warp take the same execution path.
-
-## 5.1.2 Vector cache
-
-The usage of cache on a GPU differs from that on a CPU, as there is less cache available per thread. Its main purpose is to coalesce memory accesses of the warps in order to reduce the amount of accesses to device memory, and make that memory available for other warps that currently reside on the compute unit, that also need to load those values.
-
-## 5.1.3 Local data share
-
-The local data share is memory that is accessible to all threads within a block. Its latency and bandwidth is comparable to that of the vector cache. It can be used to share memory between the threads in a block, or as a software managed cache.
-
-## 5.1.4 Scalar Unit
-
-The scalar unit performs instructions that are uniform within a warp. It thereby improves efficiency and reduces the pressure on the vector ALUs and the vector register file.
-
-## 5.2 CDNA architecture
-
-The general structure of CUs stays mostly as it is in GCN architectures. The most prominent change is the addition of matrix ALUs, which can greatly improve the performance of algorithms involving matrix multiply-accumulate operations for int8, float16, bfloat16 or float32.
-
-Fig. 2: Block Diagram of a CDNA3 Compute Unit.
-
-The image depicts a horizontal bar chart titled "Local Data Share." The chart is divided into two main sections: the left section and the right section.
-
-### Left Section:
-- **Title:** Local Data Share
-- **X-Axis:** Labeled as "Scheduler" and "Matrix Core Unit"
-- **Y-Axis:** Labeled as "Local Data Share"
-- **Data Points:**
-  - **Leftmost Data Point:** 100
-  - **Rightmost Data Point:** 100
-  - **Leftmost Data Point:** 100
-  - **Rightmost Data Point:** 100
-
-### Right Section:
-- **Title:** Shader Core
-- **X-Axis:** Labeled as "L1 Cache"
-- **Y-Axis:** Labeled as "Shader Core"
-- **Data Points:**
-  - **Leftmost Data Point:** 100
-  - **Rightmost
-
-**Image description:** The image depicts a horizontal bar chart titled "Local Data Share." The chart is divided into two main sections: the left section and the right section.
-
-### Left Section:
-- **Title:** Local Data Share
-- **X-Axis:** Labeled as "Scheduler" and "Matrix Core Unit"
-- **Y-Axis:** Labeled as "Local Data Share"
-- **Data Points:**
-  - **Leftmost Data Point:** 100
-  - **Rightmost Data Point:** 100
-  - **Leftmost Data Point:** 100
-  - **Rightmost Data Point:** 100
-
-### Right Section:
-- **Title:** Shader Core
-- **X-Axis:** Labeled as "L1 Cache"
-- **Y-Axis:** Labeled as "Shader Core"
-- **Data Points:**
-  - **Leftmost Data Point:** 100
-  - **Rightmost
-
-![Image](data:image/png;base64,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)
-
-## 5.3 RDNA architecture
-
-RDNA makes a fundamental change to CU design, by changing the size of a warp to 32 threads. This is done by effectively combining two GCN5 SIMDs, creating a VALU of width 32, so that a whole warp can be issued in one cycle. The CU is also replaced by the work group processor (WGP), which encompasses two CUs. For backwards compatibility the WGP can also run in wave64 mode, in which it issues a warp of size 64 in two cycles.
-
-It also adds an extra layer of cache to the WGP, shared by the CUs within it. This cache is referred to as L1 cache, promoting the per-CU cache to an L0 cache.
-
-Fig. 3: Block Diagram of an RDNA3 work group processor.
-
-Scheduler Vector GPR.
-
-**Image description:** The image is a block diagram illustrating the architecture of a graphics processing unit (GPU) or a similar parallel processing unit. The diagram is divided into two main sections, each representing a compute unit with various components.
-
-Each compute unit contains:
-- **Scheduler**: Manages the execution of instructions.
-- **Vector GPR (General Purpose Registers)**: Handles vector operations with components like "Float/INT/Matrix SIMD32" for single instruction, multiple data operations, "AI MATRIX Accelerator" for AI-related tasks, and "Transcendental SIMD8" for complex mathematical functions.
-- **Scalar GPR**: Manages scalar operations.
-- **Scalar ALU (Arithmetic Logic Unit)**: Performs arithmetic and logical operations on scalar data.
-- **DPFP (Double Precision Floating Point)**: Indicates support for double precision calculations.
-
-The central part of the diagram shows:
-- **Scalar Cache** and **Shader Instruction Cache**: These are shared resources for storing scalar data and shader instructions, respectively.
-
-On the right side of the diagram:
-- **Shared Memory**: A memory space accessible by all units for efficient data sharing.
-- **Ray Accelerator**: Dedicated hardware for accelerating ray tracing operations.
-- **LD/ST/Tex Addr**: Likely stands for Load/Store/Texture Address, handling memory operations and texture addressing.
-- **Texture Filters**: Processes texture data for rendering.
-- **L0**: Possibly indicates a level of cache or memory hierarchy.
-
-The diagram uses a consistent color scheme with red blocks indicating functional units and white/grey blocks for caches and shared resources. The layout suggests a focus on parallel processing capabilities, with emphasis on both vector and scalar operations, AI acceleration, and ray tracing support.
-
-![Image](data:image/png;base64,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)
-
-## 5.4 Shader engines
-
-For hardware implementation's sake, multiple CUs are grouped together into a Shader Engine or Compute Engine, typically sharing some fixed function units or memory subsystem resources.
-
-Fig. 4: Block Diagram of a CDNA2 Graphics Compute Die.
-
-The image is a table that contains data about different types of fabric. The table is divided into rows and columns, with each row representing a different type of fabric. The columns are labeled as follows:
-
-- Memory
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-
-**Image description:** The image is a table that contains data about different types of fabric. The table is divided into rows and columns, with each row representing a different type of fabric. The columns are labeled as follows:
-
-- Memory
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-
-![Image](data:image/png;base64,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)
-
-## CHAPTER
-
-## SIX
-
-## AMD COMMON LANGUAGE RUNTIMES (CLR)
-
-CLRcontains source codes for AMD's compute languages runtimes: HIP and OpenCL ™ . CLR is the part of HIP runtime which is supported on the AMD ROCm platform, it provides a header and runtime library built on top of HIP-Clang compiler. For developers and users, CLR implements HIP runtime APIs including streams, events, and memory APIs, which is a object library that is linked with the application. The source codes for all headers and the library implementation are available on GitHub in the CLR repository.
-
-## 6.1 Project organization
-
-CLR includes the following source code,
-
-- hipamd - contains implementation of HIP language on the AMD platform. It is hosted at clr/hipamd.
-- opencl - contains implementation of OpenCL™ on AMD platform. It is hosted at clr/opencl.
-- rocclr - contains common runtime used in HIP and OpenCL™ . This is hosted at clr/rocclr.
-
-## 6.2 How to build/install
-
-## 6.2.1 Prerequisites
-
-Please refer to Quick Start Guide in ROCm Docs.
-
-Building CLR requires rocm-hip-libraries meta package, which provides the pre-requisites for CLR.
-
-## 6.2.2 Linux
-
-- Clone this repository
-- For OpenCL ™
-**Following code does:** The provided code snippet appears to be a series of closing curly braces (`}`) with no accompanying opening braces or any other code. In most programming languages, such as C, C++, Java, or JavaScript, curly braces are used to define blocks of code, such as functions, loops, or conditional statements. However, without any opening braces or context, this snippet does not perform any meaningful operation or represent a valid code structure. It is likely incomplete or incorrectly formatted.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        * For HIP
-```
-**Following code does:** This code snippet is written in C++ and is used to compile a HIP (Heterogeneous-Compute Interface for Portability) runtime compilation program. It sets up a compilation option for the program by creating a string `sarg` with the value "-fgpu-rdc", which is a flag typically used to enable relocatable device code in GPU programming. This string is then converted to a C-style string and stored in an array `options`. The `hiprtcCompileProgram` function is called with the program `prog`, specifying that there is one compilation option, and passing the `options` array to apply the "-fgpu-rdc" flag during the compilation process.
-
-
-```
-<_Bash_>
-```
-**Following code does:** This code snippet is used to retrieve the compiled bitcode of a HIP (Heterogeneous-Compute Interface for Portability) program. It first determines the size of the bitcode using `hiprtcGetBitcodeSize`, storing the size in `bitCodeSize`. Then, it creates a vector `kernel_bitcode` of the appropriate size to hold the bitcode. Finally, it retrieves the actual bitcode from the program `prog` and stores it in the `kernel_bitcode` vector using `hiprtcGetBitcode`. This process is typically part of compiling and managing GPU kernels in a HIP runtime environment.
-
-
-```
-<_Haskell_>
-```
-
-Users can also build OCL and HIP at the same time by passing -DCLR\_BUILD\_HIP=ON -DCLR\_BUILD\_OCL=ON to configure command.
-
-For detail instructions, please refer to build HIP.
-
-## 6.2.3 Test
-
-hip-tests is a separate repository hosted at hip-tests.
-
-To run hip-tests please go to the repository and follow the steps.
-
-## 6.2.4 Release notes
-
-HIP provides release notes in CLR change log, which has records of changes in each release.
-
-## 7.1 Host Memory
-
-## 7.1.1 Introduction
-
-hipHostMalloc allocates pinned host memory which is mapped into the address space of all GPUs in the system, the memory can be accessed directly by the GPU device, and can be read or written with much higher bandwidth than pageable memory obtained with functions such as malloc() . There are two use cases for this host memory:
-
-- Faster HostToDevice and DeviceToHost Data Transfers: The runtime tracks the hipHostMalloc allocations and can avoid some of the setup required for regular unpinned memory. For exact measurements on a specific system, experiment with --unpinned and --pinned switches for the hipBusBandwidth tool.
-- Zero-Copy GPU Access: GPU can directly access the host memory over the CPU/GPU interconnect, without need to copy the data. This avoids the need for the copy, but during the kernel access each memory access must traverse the interconnect, which can be tens of times slower than accessing the GPU's local device memory. Zerocopy memory can be a good choice when the memory accesses are infrequent (perhaps only once). Zero-copy memory is typically 'Coherent' and thus not cached by the GPU but this can be overridden if desired.
-
-## 7.1.2 Memory allocation flags
-
-There are flags parameter which can specify options how to allocate the memory, for example, hipHostMallocPortable , the memory is considered allocated by all contexts, not just the one on which the allocation is made. hipHostMallocMapped , will map the allocation into the address space for the current device, and the device pointer can be obtained with the API hipHostGetDevicePointer() . hipHostMallocNumaUser is the flag to allow host memory allocation to follow Numa policy by user. Please note this flag is currently only applicable on Linux, under development on Windows.
-
-All allocation flags are independent, and can be used in any combination without restriction, for instance, hipHostMalloc can be called with both hipHostMallocPortable and hipHostMallocMapped flags set. Both usage models described above use the same allocation flags, and the difference is in how the surrounding code uses the host memory.
-
-## HIP PROGRAMMING MANUAL
-
-## 7.1.3 Numa-aware host memory allocation
-
-Numa policy determines how memory is allocated. Target of Numa policy is to select a CPU that is closest to each GPU. Numa distance is the measurement of how far between GPU and CPU devices.
-
-By default, each GPU selects a Numa CPU node that has the least Numa distance between them, that is, host memory will be automatically allocated closest on the memory pool of Numa node of the current GPU device. Using hipSetDevice API to a different GPU will still be able to access the host allocation, but can have longer Numa distance. Note, Numa policy is so far implemented on Linux, and under development on Windows.
-
-## 7.1.4 Coherency Controls
-
-ROCm defines two coherency options for host memory:
-
-- Coherent memory : Supports fine-grain synchronization while the kernel is running. For example, a kernel can perform atomic operations that are visible to the host CPU or to other (peer) GPUs. Synchronization instructions include threadfence\_system and C++11-style atomic operations. In order to achieve this fine-grained coherence, many AMD GPUs use a limited cache policy, such as leaving these allocations uncached by the GPU, or making them read-only.
-- Non-coherent memory : Can be cached by GPU, but cannot support synchronization while the kernel is running. Non-coherent memory can be optionally synchronized only at command (end-of-kernel or copy command) boundaries. This memory is appropriate for high-performance access when fine-grain synchronization is not required.
-
-HIP provides the developer with controls to select which type of memory is used via allocation flags passed to hipHostMalloc and the HIP\_HOST\_COHERENT environment variable. By default, the environment variable HIP\_HOST\_COHERENT is set to 0 in HIP. The control logic in the current version of HIP is as follows:
-
-- No flags are passed in: the host memory allocation is coherent, the HIP\_HOST\_COHERENT environment variable is ignored.
-- hipHostMallocCoherent=1 : The host memory allocation will be coherent, the HIP\_HOST\_COHERENT environment variable is ignored.
-- hipHostMallocMapped=1 : The host memory allocation will be coherent, the HIP\_HOST\_COHERENT environment variable is ignored.
-- hipHostMallocNonCoherent=1 , hipHostMallocCoherent=0 , and hipHostMallocMapped=0 : The host memory will be non-coherent, the HIP\_HOST\_COHERENT environment variable is ignored.
-- hipHostMallocCoherent=0 , hipHostMallocNonCoherent=0 , hipHostMallocMapped=0 , but one of the other HostMalloc flags is set:
-- -If HIP\_HOST\_COHERENT is defined as 1, the host memory allocation is coherent.
-- -If HIP\_HOST\_COHERENT is not defined, or defined as 0, the host memory allocation is non-coherent.
-- hipHostMallocCoherent=1 , hipHostMallocNonCoherent=1 : Illegal.
-
-## 7.1.5 Visibility of Zero-Copy Host Memory
-
-Coherent host memory is automatically visible at synchronization points. Non-coherent
-
-| HIP API Synchronization Effect                                                                        | Fence                 | Coherent Memory ity   | Host Visibil-   | Non-Coherent Host Memory Visi- bility   |
-|-------------------------------------------------------------------------------------------------------|-----------------------|-----------------------|-----------------|-----------------------------------------|
-| hipStreamSynchronize host waits for all commands in the spec- ified stream to complete                | system- scope release | yes                   |                 | yes                                     |
-| hipDeviceSynchronize host waits for all commands in all streams on the specified device to com- plete | system- scope release | yes                   |                 | yes                                     |
-| hipEventSynchronize host waits for the specified event to com- plete                                  | device- scope release | yes                   |                 | depends - see below                     |
-| hipStreamWaitEvent stream waits for the specified event to complete                                   | none                  | yes                   |                 | no                                      |
-
-## 7.1.6 hipEventSynchronize
-
-Developers can control the release scope for hipEvents :
-
-- By default, the GPU performs a device-scope acquire and release operation with each recorded event. This will make host and device memory visible to other commands executing on the same device.
-
-A stronger system-level fence can be specified when the event is created with hipEventCreateWithFlags :
-
-- hipEventReleaseToSystem : Perform a system-scope release operation when the event is recorded. This will make both Coherent and Non-Coherent host memory visible to other agents in the system, but may involve heavyweight operations such as cache flushing. Coherent memory will typically use lighter-weight in-kernel synchronization mechanisms such as an atomic operation and thus does not need to use hipEventReleaseToSystem .
-- hipEventDisableTiming : Events created with this flag will not record profiling data and provide the best performance if used for synchronization.
-
-## 7.1.7 Summary and Recommendations
-
-- Coherent host memory is the default and is the easiest to use since the memory is visible to the CPU at typical synchronization points. This memory allows in-kernel synchronization commands such as threadfence\_system to work transparently.
-- HIP/ROCm also supports the ability to cache host memory in the GPU using the 'Non-Coherent' host memory allocations. This can provide performance benefit, but care must be taken to use the correct synchronization.
-
-## 7.1.8 Managed memory allocation
-
-Managed memory, including the \_\_managed\_\_ keyword, is supported in HIP combined host/device compilation, on Linux, not on Windows (under development).
-
-Managed memory, via unified memory allocation, allows data be shared and accessible to both the CPU and GPU using a single pointer. The allocation will be managed by AMD GPU driver using the Linux HMM (Heterogeneous Memory Management) mechanism, the user can call managed memory API hipMallocManaged to allocate a large chunk of HMMmemory, execute kernels on device and fetch data between the host and device as needed.
-
-In HIP application, it is recommended to do the capability check before calling the managed memory APIs. For example:
-**Following code does:** It seems there is a formatting error in your request. The code snippet is labeled as C++ but is enclosed within Python code tags. Please provide the correct code snippet or clarify the language so I can assist you accurately.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?>                                                                                                                                                                                                        </?>
-```
-
-Please note, the managed memory capability check may not be necessary, but if HMM is not supported, then managed malloc will fall back to using system memory and other managed memory API calls will have undefined behavior.
-
-Note, managed memory management is implemented on Linux, not supported on Windows yet.
-
-## 7.1.9 HIP Stream Memory Operations
-
-HIP supports Stream Memory Operations to enable direct synchronization between Network Nodes and GPU. Following new APIs are added, hipStreamWaitValue32 hipStreamWaitValue64 hipStreamWriteValue32 hipStreamWriteValue64
-
-Note, CPU access to the semaphore's memory requires volatile keyword to disable CPU compiler's optimizations on memory access. For more details, please check the documentation HIP-API.pdf .
-
-Please note, HIP stream does not guarantee concurrency on AMD hardware for the case of multiple (at least 6) longrunning streams executing concurrently, using hipStreamSynchronize(nullptr) for synchronization.
-
-## 7.2 Direct Dispatch
-
-HIP runtime has Direct Dispatch enabled by default in ROCM 4.4 on Linux. With this feature we move away from our conventional producer-consumer model where the runtime creates a worker thread(consumer) for each HIP Stream, and the host thread(producer) enqueues commands to a command queue(per stream).
-
-For Direct Dispatch, HIP runtime would directly enqueue a packet to the AQL queue (user mode queue on GPU) on the Dispatch API call from the application. That has shown to reduce the latency to launch the first wave on the idle GPU and total time of tiny dispatches synchronized with the host.
-
-In addition, eliminating the threads in runtime has reduced the variance in the dispatch numbers as the thread scheduling delays and atomics/locks synchronization latencies are reduced.
-
-This feature can be disabled via setting the following environment variable, AMD\_DIRECT\_DISPATCH=0
-
-Note, Direct Dispatch is implemented on Linux. It is currently not supported on Windows.
-
-## 7.3 HIP Runtime Compilation
-
-HIP now supports runtime compilation (HIP RTC), the usage of which will provide the possibility of optimizations and performance improvement compared with other APIs via regular offline static compilation.
-
-HIP RTC APIs accept HIP source files in character string format as input parameters and create handles of programs by compiling the HIP source files without spawning separate processes.
-
-For more details on HIP RTC APIs, refer to HIP Runtime API Reference .
-
-For Linux developers, the link here shows an example how to program HIP application using runtime compilation mechanism, and a detailed HIP RTC programming guide is also available.
-
-## 7.4 HIP Graph
-
-HIP graph is supported. For more details, refer to the HIP API Guide.
-
-## 7.5 Device-Side Malloc
-
-HIP-Clang now supports device-side malloc and free. This implementation does not require the use of hipDeviceSetLimit(hipLimitMallocHeapSize,value) nor respects any setting. The heap is fully dynamic and can grow until the available free memory on the device is consumed.
-
-## 7.6 Use of Per-thread default stream
-
-The per-thread default stream is supported in HIP. It is an implicit stream local to both the thread and the current device. This means that the command issued to the per-thread default stream by the thread does not implicitly synchronize with other streams (like explicitly created streams), or default per-thread stream on other threads. The per-thread default stream is a blocking stream and will synchronize with the default null stream if both are used in a program. The per-thread default stream can be enabled via adding a compilation option, -fgpu-default-stream=per-thread .
-
-And users can explicitly use hipStreamPerThread as per-thread default stream handle as input in API commands. There are test codes as examples in the link.
-
-## 7.7 Use of Long Double Type
-
-In HIP-Clang, long double type is 80-bit extended precision format for x86\_64, which is not supported by AMDGPU. HIP-Clang treats long double type as IEEE double type for AMDGPU. Using long double type in HIP source code will not cause issue as long as data of long double type is not transferred between host and device. However, long double type should not be used as kernel argument type.
-
-## 7.8 Use of \_Float16 Type
-
-If a host function is to be used between clang (or hipcc) and gcc for x86\_64, i.e. its definition is compiled by one compiler but the caller is compiled by a different compiler, \_Float16 or aggregates containing \_Float16 should not be used as function argument or return type. This is due to lack of stable ABI for \_Float16 on x86\_64. Passing \_Float16 or aggregates containing \_Float16 between clang and gcc could cause undefined behavior.
-
-## 7.9 FMA and contractions
-
-By default HIP-Clang assumes -ffp-contract=fast-honor-pragmas . Users can use #pragma clang fp contract(on|off|fast) to control fp contraction of a block of code. For x86\_64, FMA is off by default since the generic x86\_64 target does not support FMA by default. To turn on FMA on x86\_64, either use -mfma or -march=native on CPU's supporting FMA.
-
-When contractions are enabled and the CPU has not enabled FMA instructions, the GPU can produce different numerical results than the CPU for expressions that can be contracted. Tolerance should be used for floating point comparisons.
-
-## 7.10 Math functions with special rounding modes
-
-Note: Currently, HIP only supports basic math functions with rounding modern (round to nearest). HIP does not support basic math functions with rounding modes ru (round up), rd (round down), and rz (round towards zero).
-
-## 7.11 Creating Static Libraries
-
-HIP-Clang supports generating two types of static libraries. The first type of static library does not export device functions, and only exports and launches host functions within the same library. The advantage of this type is the ability to link with a non-hipcc compiler such as gcc. The second type exports device functions to be linked by other code objects. However, this requires using hipcc as the linker.
-
-In addition, the first type of library contains host objects with device code embedded as fat binaries. It is generated using the flag -emit-static-lib. The second type of library contains relocatable device objects and is generated using ar .
-
-Here is an example to create and use static libraries:
-
-- Type 1 using --emit-static-lib :
-- Type 2 using system ar :
-**Following code does:** This code snippet is a function call to `hiprtcLinkAddData`, which is part of the HIPRTC (Heterogeneous Interface for Portability Runtime Compilation) API. The function is used to add input data, such as bitcode or other types of data, to a HIPRTC link state object. This is typically part of a process to compile or link GPU code at runtime. The parameters specify the link state object, the type and size of the input data, an optional name for the input, and any options or option values that might be applied to this input. In this case, no options or option values are provided.
-
-
-```
-<_Bash_>
-```
-**Following code does:** This code snippet is a function call to `hiprtcLinkAddFile`, which is part of the HIPRTC (Heterogeneous-Compute Interface for Portability Runtime Compilation) API. The function is used to add a file to the HIPRTC link state. Specifically, it adds a file containing input data or bitcode to the current link state, which is a part of the process of compiling and linking GPU code at runtime. The parameters specify the link state, the type of input, the file path to the bitcode, and options related to the input, although in this case, no additional options are provided (indicated by the zero values).
-
-
-```
-hipcc hipDevice.cpp -c -fgpu-rdc -o hipDevice.o
-ar rcsD libHipDevice.a hipDevice.o
-hipcc libHipDevice.a test.cpp -fgpu-rdc -o test.out
-```
-
-For more information, please see HIP samples host functions and device\_functions.
-
-CHAPTER
-
-## EIGHT
-
-## HIP PORTING GUIDE
-
-In addition to providing a portable C++ programming environment for GPUs, HIP is designed to ease the porting of existing CUDA code into the HIP environment. This section describes the available tools and provides practical suggestions on how to port CUDA code and work through common issues.
-
-## 8.1 Porting a New CUDA Project
-
-## 8.1.1 General Tips
-
-- Starting the port on a CUDA machine is often the easiest approach, since you can incrementally port pieces of the code to HIP while leaving the rest in CUDA. (Recall that on CUDA machines HIP is just a thin layer over CUDA, so the two code types can interoperate on NVCC platforms.) Also, the HIP port can be compared with the original CUDA code for function and performance.
-- Once the CUDA code is ported to HIP and is running on the CUDA machine, compile the HIP code using the HIP compiler on an AMD machine.
-- HIP ports can replace CUDA versions: HIP can deliver the same performance as a native CUDA implementation, with the benefit of portability to both NVIDIA and AMD architectures as well as a path to future C++ standard support. You can handle platform-specific features through conditional compilation or by adding them to the open-source HIP infrastructure.
-- Use hipconvertinplace-perl.sh to hipify all code files in the CUDA source directory.
-
-## 8.1.2 Scanning existing CUDA code to scope the porting effort
-
-The hipexamine-perl.sh tool will scan a source directory to determine which files contain CUDA code and how much of that code can be automatically hipified.
-**Following code does:** The code snippet `<_C_>` is not a valid or recognizable Python code. It appears to be a placeholder or a typographical error rather than functional code. Without additional context or correction, it is not possible to determine its purpose or functionality.
-
-
-```
-<_Cuda_>
-```
-
-(continued from previous page)
-**Following code does:** The code snippet appears to be part of a larger program written in C++ that uses the HIP (Heterogeneous-Compute Interface for Portability) API, which is designed for writing portable code that can run on both AMD and NVIDIA GPUs. The specific function call `hipModuleLoadData(&module, bina)` is used to load a compiled GPU module from binary data into the `module` variable. This is typically a step in preparing GPU code for execution, where `bina` represents the binary data of the compiled GPU program.
-
-
-```
-                                                                                                                                                                                                        (continued from previous page)
-```
-
-hipexamine-perl scans each code file (cpp, c, h, hpp, etc.) found in the specified directory:
-
-- Files with no CUDA code ( kmeans.h ) print one line summary just listing the source file name.
-- Files with CUDA code print a summary of what was found - for example the kmeans\_cuda\_kernel.cu file:
-- Interesting information in kmeans\_cuda\_kernel.cu :
-- -How many CUDA calls were converted to HIP (40)
-- -Breakdown of the CUDA functionality used ( dev:0 mem:0 etc). This file uses many CUDA builtins (37) and texture functions (3).
-- -Warning for code that looks like CUDA API but was not converted (0 in this file).
-- -Count Lines-of-Code (LOC) - 185 for this file.
-- hipexamine-perl also presents a summary at the end of the process for the statistics collected across all files. This has similar format to the per-file reporting, and also includes a list of all kernels which have been called. An example from above:
-**Following code does:** The code snippet you provided, `binary);`, appears to be incomplete and does not represent a valid or meaningful Python statement on its own. It seems like it might be a fragment of a larger piece of code or a typographical error. Without additional context or surrounding code, it's not possible to determine its purpose or functionality.
-
-
-```
-<_SQL_>
-```
-**Following code does:** The code snippet `<_Cuda_>` appears to be a placeholder or a symbolic representation rather than actual executable code. In the context of programming, "Cuda" typically refers to NVIDIA's parallel computing platform and application programming interface (API) model, which allows developers to use a CUDA-enabled graphics processing unit (GPU) for general purpose processing. However, without additional context or actual code, it is not possible to determine the specific functionality or purpose of this snippet.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        --event:0                                                                                                                                                                                                        -event:0
-```
-
-## 8.1.3 Converting a project 'in-place'
-**Following code does:** This code snippet is setting up options for a Just-In-Time (JIT) compilation process, likely related to GPU programming using the HIP (Heterogeneous-Compute Interface for Portability) runtime. The `isaopts` array contains command-line options for the LLVM compiler, specifically to set the inline threshold to 1, which influences function inlining decisions during compilation. The `jit_options` vector is initialized with specific JIT options that are likely used to configure the compilation process to include these LLVM options. The `isaoptssize` variable indicates the size of the `isaopts` array, which is used to pass these options to the compiler. Overall, this setup is preparing to customize the behavior of the JIT compiler with specific optimization settings.
-
-
-```
->
-```
-**Following code does:** This code snippet is setting up and initiating a linking process for a HIP (Heterogeneous-Compute Interface for Portability) runtime compilation. It creates an array `lopts` containing pointers to ISA (Instruction Set Architecture) options and their size, which are then used as input parameters for the `hiprtcLinkCreate` function. This function initializes a `hiprtcLinkState` object, `linkstate`, which represents the state of the linking process. The purpose of this code is to configure and start the linking of compiled code for execution on a GPU using HIP.
-
-
-```
-| > hipify-perl --inplace
-```
-
-For each input file FILE, this script will:
-
-- If FILE.prehip file does not exist, copy the original code to a new file with extension .prehip . Then hipify the code file.
-- If FILE.prehip file exists, hipify FILE.prehip and save to FILE.
-
-This is useful for testing improvements to the hipify toolset.
-
-The hipconvertinplace-perl.sh script will perform inplace conversion for all code files in the specified directory. This can be quite handy when dealing with an existing CUDA code base since the script preserves the existing directory structure and filenames - and includes work. After converting in-place, you can review the code to add additional parameters to directory names.
-
-- &gt; hipconvertinplace-perl.sh MY\_SRC\_DIR
-
-## 8.1.4 Library Equivalents
-
-Most CUDA libraries have a corresponding ROCm library with similar functionality and APIs. However, ROCm also provides HIP marshalling libraries that greatly simplify the porting process because they more precisely reflect their CUDAcounterparts and can be used with either the AMD or NVIDIA platforms (see 'Identifying HIP Target Platform' below). There are a few notable exceptions:
-
-- MIOpen does not have a marshalling library interface to ease porting from cuDNN.
-- RCCL is a drop-in replacement for NCCL and implements the NCCL APIs.
-- hipBLASLt does not have a ROCm library but can still target the NVIDIA platform, as needed.
-- EIGEN's HIP support is part of the library.
-
-| CUDA brary   | Li-   | HIP Li- brary   | ROCm Li- brary   | Comment                                                                          |
-|--------------|-------|-----------------|------------------|----------------------------------------------------------------------------------|
-| cuBLAS       |       | hipBLAS         | rocBLAS          | Basic Linear Algebra Subroutines                                                 |
-| cuBLASLt     |       | hip- BLASLt     | N/A              | Basic Linear Algebra Subroutines, lightweight and new flexible API               |
-| cuFFT        |       | hipFFT          | rocFFT           | Fast Fourier Transfer Library                                                    |
-| cuSPARSE     |       | hipSPARSE       | rocSPARSE        | Sparse BLAS + SPMV                                                               |
-| cuSOLVER     |       | hip- SOLVER     | rocSOLVER        | Lapack library                                                                   |
-| AmgX         |       | N/A             | rocALU- TION     | Sparse iterative solvers and preconditioners with algebraic multigrid            |
-| Thrust       |       | N/A             | rocThrust        | C++ parallel algorithms library                                                  |
-| CUB          |       | hipCUB          | rocPRIM          | Low Level Optimized Parallel Primitives                                          |
-| cuDNN        |       | N/A             | MIOpen           | Deep learning Solver Library                                                     |
-| cuRAND       |       | hipRAND         | rocRAND          | Random Number Generator Library                                                  |
-| EIGEN        |       | EIGEN           | N/A              | C++ template library for linear algebra: matrices, vectors, numeri- cal solvers, |
-| NCCL         |       | N/A             | RCCL             | Communications Primitives Library based on the MPI equivalents                   |
-
-## 8.2 Distinguishing Compiler Modes
-
-## 8.2.1 Identifying HIP Target Platform
-
-All HIP projects target either AMD or NVIDIA platform. The platform affects which headers are included and which libraries are used for linking.
-
-- HIP\_PLATFORM\_AMD is defined if the HIP platform targets AMD. Note, HIP\_PLATFORM\_HCC was previously defined if the HIP platform targeted AMD, it is deprecated.
-- HIP\_PLATFORM\_NVDIA is defined if the HIP platform targets NVIDIA. Note, HIP\_PLATFORM\_NVCC was previously defined if the HIP platform targeted NVIDIA, it is deprecated.
-
-## 8.2.2 Identifying the Compiler: hip-clang or NVCC
-
-Often, it's useful to know whether the underlying compiler is HIP-Clang or NVCC. This knowledge can guard platformspecific code or aid in platform-specific performance tuning.
-**Following code does:** It seems like you've provided a placeholder or incomplete code snippet. If you have a specific Python code snippet you'd like me to explain, please provide the actual code, and I'll be happy to help!
-
-
-```
-    #ifdef __HIP_PLATFORM_AMD__
-    // Compiled with HIP-Clang
-    #endif
-```
-**Following code does:** This code snippet is part of a program that uses the HIPRTC (Heterogeneous-Compute Interface for Portability Runtime Compilation) API to compile a GPU program at runtime. It attempts to compile a program represented by `prog` with a single compilation option specified in `opts`. The result of the compilation is stored in `result`. If the compilation fails (i.e., `result` is not `HIPRTC_SUCCESS`), it outputs an error message to the standard output, including the error string corresponding to the failure.
-
-
-```
-#ifdef __HIP_PLATFORM_NVIDIA__
-// Compiled with nvcc
-//  Could be compiling with CUDA language extensions enabled (for example, a ".cu file)
-//  Could be in pass-through mode to an underlying host compile OR (for example, a.cpp_
---file)
-```
-**Following code does:** The code snippet appears to be the beginning of a C++ declaration for a static constant character array named `gpu_program`. This array is likely intended to store a sequence of characters, which could represent a GPU program or shader code. The `static constexpr` keywords suggest that this array is both constant and has static storage duration, meaning its value is fixed at compile time and it is shared across all instances of the class or file in which it is declared. The actual content of the array is not shown in the snippet.
-
-
-```
-        #ifdef __CUDACC__
-        // Compiled with nvcc (CUDA language extensions enabled)
-```
-**Following code does:** This code snippet is written in C++ and is part of a program that likely involves GPU programming, possibly using the HIP runtime for compiling and managing GPU kernels. The code performs the following high-level tasks:
-
-1. It initializes a vector `kernel_name_vec` with strings representing kernel function names or expressions. These names include `&f1`, `N1::N2::f2`, and `f3<int>`, which suggest different ways of referring to functions or templates in C++.
-
-2. It iterates over each element in `kernel_name_vec` and calls the function `hiprtcAddNameExpression` with the current element converted to a C-style string (`c_str()`) and a program object `prog`. This function is likely used to register or associate these kernel names with the program for later compilation or execution on a GPU.
-
-3. It initializes another vector `variable_name_vec` with a single string `&V1`, which might represent a variable name or address that could be used later in the program.
-
-Overall, the code is setting up kernel and possibly variable names for a GPU program, preparing them for further processing or compilation.
-
-
-```
-; enab1ed)
-```
-
-Compiler directly generates the host code (using the Clang x86 target) and passes the code to another host compiler. Thus, they have no equivalent of the \_\_CUDACC\_\_ define.
-
-## 8.2.3 Identifying Current Compilation Pass: Host or Device
-
-NVCCmakestwo passes over the code: one for host code and one for device code. HIP-Clang will have multiple passes over the code: one for the host code, and one for each architecture on the device code. \_\_HIP\_DEVICE\_COMPILE\_\_ is set to a nonzero value when the compiler (HIP-Clang or NVCC) is compiling code for a device inside a \_\_global\_\_ kernel or for a device function. \_\_HIP\_DEVICE\_COMPILE\_\_ can replace #ifdef checks on the \_\_CUDA\_ARCH\_\_ define.
-**Following code does:** This code snippet appears to be part of a loop in C++ (though it is formatted like Python, it is not valid Python syntax). It iterates over a collection named `variable_name_vec`, which is likely a vector or similar container of strings or string-like objects. For each element `x` in this collection, it calls the function `hiprtcAddNameExpression`, passing `prog` and `x.c_str()` as arguments. The purpose of this operation is to add name expressions to a HIPRTC (Heterogeneous-Compute Interface for Portability Runtime Compilation) program, where `prog` is likely a handle or reference to a runtime compilation program, and `x.c_str()` converts the string `x` to a C-style string (null-terminated character array). This is typically used in GPU programming to manage and compile code at runtime.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                        #if __HIP__DEVICE__COMPILE__
-```
-
-Unlike \_\_CUDA\_ARCH\_\_ , the \_\_HIP\_DEVICE\_COMPILE\_\_ value is 1 or undefined, and it doesn't represent the feature capability of the target device.
-
-## 8.2.4 Compiler Defines: Summary
-
-| Define                      | HIP-Clang                                                         | NVCC                                                                                          | Other (GCC, ICC, Clang, etc.)                               |
-|-----------------------------|-------------------------------------------------------------------|-----------------------------------------------------------------------------------------------|-------------------------------------------------------------|
-| HIP-related defines:        |                                                                   |                                                                                               |                                                             |
-| __HIP_PLATFORM_AMD__        | Defined                                                           | Undefined                                                                                     | Defined if targetingAMD platform; undefined oth- erwise     |
-| __HIP_PLATFORM_NVIDIA__     | Undefined                                                         | Defined                                                                                       | Defined if targeting NVIDIA platform; unde- fined otherwise |
-| __HIP_DEVICE_COMPILE__      | 1 if compiling for device; un- defined if compiling for host      | 1 if compiling for device; undefined if compiling for host                                    | Undefined                                                   |
-| __HIPCC__                   | Defined                                                           | Defined                                                                                       | Undefined                                                   |
-| __HIP_ARCH_*                | 0 or 1 depending on feature support (see below)                   | 0 or 1 depending on feature support (see below)                                               | 0                                                           |
-| NVCC- related defines:      |                                                                   |                                                                                               |                                                             |
-| __CUDACC__                  | Defined if source code is compiled by NVCC; unde- fined otherwise | Undefined                                                                                     |                                                             |
-| __NVCC__ Undefined          | Defined                                                           | Undefined                                                                                     |                                                             |
-| __CUDA_ARCH__               | Undefined                                                         | Unsigned representing compute capa- bility (e.g., '130') if in device code; 0 if in host code | Undefined                                                   |
-| hip-clang- related defines: |                                                                   |                                                                                               |                                                             |
-| __HIP__ HIP-Clang common    | Defined                                                           | Undefined                                                                                     | Undefined                                                   |
-| defines: __clang__          | Defined                                                           | Defined                                                                                       | Undefined                                                   |
-
-## 8.3 Identifying Architecture Features
-
-## 8.3.1 HIP\_ARCH Defines
-
-Some CUDA code tests \_\_CUDA\_ARCH\_\_ for a specific value to determine whether the machine supports a certain architectural feature. For instance,
-**Following code does:** This code snippet appears to be part of a C++ program. It performs the following high-level actions:
-
-1. It adds a string literal `"&N1::N2::V2"` to a vector named `variable_name_vec`. This vector is likely intended to store names or identifiers, possibly for variables or functions.
-
-2. It then iterates over each element in `variable_name_vec` using a range-based for loop. For each element `x`, it calls a function or macro `hiprtcAddNameExp`. This function or macro is likely related to the HIP runtime compilation (hiprtc) library, which is used for compiling and managing GPU kernels in AMD's ROCm platform. The purpose of `hiprtcAddNameExp` is probably to register or process the names stored in the vector for use in GPU kernel compilation or execution.
-
-Overall, the code is managing a collection of names and performing an operation on each name, likely in the context of GPU programming.
-
-
-```
-        | #if (__CUDA_ARCH__ >= 13 0)
-```
-**Following code does:** This code snippet iterates over a vector named `variable_name_vec` and retrieves the "lowered" name for each element in the vector using the `hiprtcGetLoweredName` function. The `decltype(variable_name_vec.size())` is used to ensure the loop index `i` is of the same type as the size of the vector. The `hiprtcGetLoweredName` function is likely part of the HIP runtime compilation (hipRTC) API, which is used for compiling and managing GPU kernels. The lowered name is stored in the `name` pointer for each variable in the vector.
-
-
-```
-    |// doubles are supported
-```
-
-This type of code requires special attention, since AMD and CUDA devices have different architectural capabilities. Moreover, you can't determine the presence of a feature using a simple comparison against an architecture's version
-
-number. HIP provides a set of defines and device properties to query whether a specific architectural feature is supported.
-
-The \_\_HIP\_ARCH\_* defines can replace comparisons of \_\_CUDA\_ARCH\_\_ values:
-**Following code does:** This code snippet iterates over a vector named `kernel_name_vec`, which presumably contains kernel names as strings. For each kernel name in the vector, it calls the function `hiprtcGetLoweredName`, passing in a program object `prog`, the current kernel name, and a pointer to a `const char*` variable `name`. The purpose of this function call is likely to retrieve the "lowered" or transformed version of the kernel name, which is stored in the `name` variable. This is typically used in the context of GPU programming, where kernel names might need to be transformed or resolved for further processing or compilation.
-
-
-```
-//#if (__CUDA_ARCH__ >= 130)   // non-portable
-if __HIP_ARCH_HAS_DOUBLES__ {  // portable HIP feature query
-    // doubles are supported
-}
-```
-
-For host code, the \_\_HIP\_ARCH\_\_* defines are set to 0. You should only use the \_\_HIP\_ARCH\_\_ fields in device code.
-
-## 8.3.2 Device-Architecture Properties
-
-Host code should query the architecture feature flags in the device properties that hipGetDeviceProperties returns, rather than testing the 'major' and 'minor' fields directly:
-**Following code does:** This code snippet is part of a GPU programming workflow using the HIP (Heterogeneous-Compute Interface for Portability) API, which is designed for writing portable applications that can run on AMD and NVIDIA GPUs. The code performs the following high-level tasks:
-
-1. It declares a variable `variable_addr` to hold the device pointer to a global variable within a GPU module, and a `bytes` variable to store the size of this global variable.
-2. It retrieves the address and size of a global variable from a specified GPU module using `hipModuleGetGlobal`.
-3. It copies an initial value from the host (CPU) memory to the device (GPU) memory at the location specified by `variable_addr` using `hipMemcpyHtoD`.
-
-Overall, this code initializes a global variable in a GPU module with a specified initial value from the host.
-
-
-```
-hipGetDeviceProperties(&deviceProp, device);
-//if ((deviceProp.major == 1 && deviceProp.minor < 2))  // non-portable
-if (deviceProp.arch.hasSharedInt32Atomics) {            // portable HIP feature query
-    // has shared int32 atomic operations...
-}
-```
-
-## 8.3.3 Table of Architecture Properties
-
-The table below shows the full set of architectural properties that HIP supports.
-
-| Define (use only in device code)                                                                                               | Device Property (run- time query)                       | Comment                                                                                                                                |
-|--------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------|
-| 32-bit atomics:                                                                                                                |                                                         |                                                                                                                                        |
-| __HIP_ARCH_HAS_GLOBAL_INT32_ATOMICS__ __HIP_ARCH_HAS_GLOBAL_FLOAT_ATOMIC_EXCH__                                                | hasGlobalInt32Atomics hasGlobalFloatAtomicExch          | 32-bit integer atomics for global memory 32-bit float atomic exchange for global mem- ory                                              |
-| __HIP_ARCH_HAS_SHARED_INT32_ATOMICS__ __HIP_ARCH_HAS_SHARED_FLOAT_ATOMIC_EXCH__                                                | hasSharedInt32Atomics hasSharedFloatAtomicExch          | 32-bit integer atomics for shared memory 32-bit float atomic exchange for shared mem- ory                                              |
-| __HIP_ARCH_HAS_FLOAT_ATOMIC_ADD__                                                                                              | hasFloatAtomicAdd                                       | 32-bit float atomic add in global and shared memory                                                                                    |
-| 64-bit atomics:                                                                                                                |                                                         |                                                                                                                                        |
-| __HIP_ARCH_HAS_GLOBAL_INT64_ATOMICS__ __HIP_ARCH_HAS_SHARED_INT64_ATOMICS__ Doubles:                                           | hasGlobalInt64Atomics hasSharedInt64Atomics             | 64-bit integer atomics for global memory 64-bit integer atomics for shared memory                                                      |
-| __HIP_ARCH_HAS_DOUBLES__ Warp cross-lane operations:                                                                           | hasDoubles                                              | Double-precision floating point                                                                                                        |
-| __HIP_ARCH_HAS_WARP_VOTE__ __HIP_ARCH_HAS_WARP_BALLOT__ __HIP_ARCH_HAS_WARP_SHUFFLE__ __HIP_ARCH_HAS_WARP_FUNNEL_SHIFT__ Sync: | hasWarpVote hasWarpBallot hasWarpShuffle hasFunnelShift | Warp vote instructions ( any , all ) Warp ballot instructions Warp shuffle operations ( shfl_* ) Funnel shift two input words into one |
-|                                                                                                                                | hasThreadFenceSystem hasSyncThreadsExt                  | threadfence_system syncthreads_count , syncthreads_and                                                                                 |
-| __HIP_ARCH_HAS_THREAD_FENCE_SYSTEM__                                                                                           |                                                         |                                                                                                                                        |
-| __HIP_ARCH_HAS_SYNC_THREAD_EXT__                                                                                               |                                                         | , syncthreads_or                                                                                                                       |
-| Miscellaneous:                                                                                                                 |                                                         |                                                                                                                                        |
-| __HIP_ARCH_HAS_SURFACE_FUNCS__                                                                                                 | hasSurfaceFuncs                                         |                                                                                                                                        |
-| __HIP_ARCH_HAS_3DGRID__                                                                                                        | has3dGrid                                               | Grids and groups are 3D                                                                                                                |
-| __HIP_ARCH_HAS_DYNAMIC_PARALLEL__                                                                                              | hasDynamicParallelism                                   |                                                                                                                                        |
-
-## 8.4 Finding HIP
-
-Makefiles can use the following syntax to conditionally provide a default HIP\_PATH if one does not exist:
-
-HIP\_PATH ?= $( shell hipconfig --path )
-
-## 8.5 Identifying HIP Runtime
-
-HIP can depend on rocclr, or CUDA as runtime
-
-- AMDplatform On AMD platform, HIP uses Radeon Open Compute Common Language Runtime, called ROCclr. ROCclr is a virtual device interface that HIP runtimes interact with different backends which allows runtimes to work on Linux , as well as Windows without much efforts.
-- NVIDIA platform On NVIDIA platform, HIP is just a thin layer on top of CUDA. On non-AMD platform, HIP runtime determines if CUDA is available and can be used. If available, HIP\_PLATFORM is set to nvidia and underneath CUDA path is used.
-
-## 8.6 hipLaunchKernelGGL
-
-hipLaunchKernelGGL is a macro that can serve as an alternative way to launch kernel, which accepts parameters of launch configurations (grid dims, group dims, stream, dynamic shared size) followed by a variable number of kernel arguments. It can replace &lt;&lt;&lt; &gt;&gt;&gt;, if the user so desires.
-
-## 8.7 Compiler Options
-
-hipcc is a portable compiler driver that will call NVCC or HIP-Clang (depending on the target system) and attach all required include and library options. It passes options through to the target compiler. Tools that call hipcc must ensure the compiler options are appropriate for the target compiler. The hipconfig script may helpful in identifying the target platform, compiler and runtime. It can also help set options appropriately.
-
-## 8.7.1 Compiler options supported on AMD platforms
-
-Here are the main compiler options supported on AMD platforms by HIP-Clang.
-
-| Option      | Description                                                                                                                                                                                                                                                                                                                                                                           |
-|-------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-|             | --amdgpu-target=<gpu_arch> [DEPRECATED] This option is being replaced by --offload-arch=<target> . Generate code for the given GPU target. Supported targets are gfx701, gfx801, gfx802, gfx803, gfx900, gfx906, gfx908, gfx1010, gfx1011, gfx1012, gfx1030, gfx1031. This option could appear multiple times on the same command line to generate a fat binary for multiple targets. |
-| --fgpu-rdc  | Generate relocatable device code, which allows kernels or device functions calling device functions in different translation units.                                                                                                                                                                                                                                                   |
-| -ggdb       | Equivalent to -g plus tuning for GDB. This is recommended when using ROCm's GDB to debug GPU code.                                                                                                                                                                                                                                                                                    |
-|             | --gpu-max-threads-per-block=<num> Generate code to support up to the specified number of threads per block.                                                                                                                                                                                                                                                                           |
-| -O<n>       | Specify the optimization level.                                                                                                                                                                                                                                                                                                                                                       |
-|             | -offload-arch=<target> Specify the AMDGPUtarget ID.                                                                                                                                                                                                                                                                                                                                   |
-| -save-temps | Save the compiler generated intermediate files.                                                                                                                                                                                                                                                                                                                                       |
-| -v          | Show the compilation steps.                                                                                                                                                                                                                                                                                                                                                           |
-
-## 8.8 Linking Issues
-
-## 8.8.1 Linking With hipcc
-
-hipcc adds the necessary libraries for HIP as well as for the accelerator compiler (NVCC or AMD compiler). We recommend linking with hipcc since it automatically links the binary to the necessary HIP runtime libraries. It also has knowledge on how to link and to manage the GPU objects.
-
-## 8.8.2 -lm Option
-
-hipcc adds -lm by default to the link command.
-
-## 8.9 Linking Code With Other Compilers
-
-CUDA code often uses NVCC for accelerator code (defining and launching kernels, typically defined in .cu or .cuh files). It also uses a standard compiler (g++) for the rest of the application. NVCC is a preprocessor that employs a standard host compiler (gcc) to generate the host code. Code compiled using this tool can employ only the intersection of language features supported by both NVCC and the host compiler. In some cases, you must take care to ensure the data types and alignment of the host compiler are identical to those of the device compiler. Only some host compilers are supported-for example, recent NVCC versions lack Clang host-compiler capability.
-
-HIP-Clang generates both device and host code using the same Clang-based compiler. The code uses the same API as gcc, which allows code generated by different gcc-compatible compilers to be linked together. For example, code compiled using HIP-Clang can link with code compiled using 'standard' compilers (such as gcc, ICC and Clang). Take care to ensure all compilers use the same standard C++ header and library formats.
-
-## 8.9.1 libc++ and libstdc++
-
-hipcc links to libstdc++ by default. This provides better compatibility between g++ and HIP.
-
-If you pass --stdlib=libc++ to hipcc, hipcc will use the libc++ library. Generally, libc++ provides a broader set of C++ features while libstdc++ is the standard for more compilers (notably including g++).
-
-When cross-linking C++ code, any C++ functions that use types from the C++ standard library (including std::string, std::vector and other containers) must use the same standard-library implementation. They include the following:
-
-- Functions or kernels defined in HIP-Clang that are called from a standard compiler
-- Functions defined in a standard compiler that are called from HIP-Clang.
-
-Applications with these interfaces should use the default libstdc++ linking.
-
-Applications which are compiled entirely with hipcc, and which benefit from advanced C++ features not supported in libstdc++, and which do not require portability to NVCC, may choose to use libc++.
-
-## 8.9.2 HIP Headers ( hip\_runtime.h , hip\_runtime\_api.h )
-
-The hip\_runtime.h and hip\_runtime\_api.h files define the types, functions and enumerations needed to compile a HIP program:
-
-- hip\_runtime\_api.h : defines all the HIP runtime APIs (e.g., hipMalloc ) and the types required to call them. A source file that is only calling HIP APIs but neither defines nor launches any kernels can include hip\_runtime\_api.h . hip\_runtime\_api.h uses no custom Heterogeneous Compute (HC) language features and can be compiled using a standard C++ compiler.
-- hip\_runtime.h : included in hip\_runtime\_api.h . It additionally provides the types and defines required to create and launch kernels. hip\_runtime.h can be compiled using a standard C++ compiler but will expose a subset of the available functions.
-
-CUDAhasslightly different contents for these two files. In some cases you may need to convert hipified code to include the richer hip\_runtime.h instead of hip\_runtime\_api.h .
-
-## 8.9.3 Using a Standard C++ Compiler
-
-You can compile hip\_runtime\_api.h using a standard C or C++ compiler (e.g., gcc or ICC). The HIP include paths and defines ( \_\_HIP\_PLATFORM\_AMD\_\_ or \_\_HIP\_PLATFORM\_NVIDIA\_\_ ) must pass to the standard compiler; hipconfig then returns the necessary options:
-
-- &gt;
-**Following code does:** This code snippet is part of a HIP (Heterogeneous-Compute Interface for Portability) application, which is used for running code on GPUs. The code performs the following high-level tasks:
-
-1. It retrieves a GPU kernel function from a given module using `hipModuleGetFunction`, storing the function in the `kernel` variable.
-2. It then launches this kernel function on the GPU using `hipModuleLaunchKernel`. The kernel is launched with a grid and block size of 1x1x1, meaning it will execute a single thread. The function is executed with no shared memory (`0`), no stream (`nullptr`), no extra arguments (`nullptr`), and a configuration specified by `config`.
-
-Overall, this code is setting up and executing a GPU kernel with minimal configuration, likely for testing or demonstration purposes.
-
-
-```
-|> hipconfig --cxx_config
-```
-**Following code does:** The provided code snippet appears to be a mix of PHP and HTML-like syntax, but it is mostly nonsensical and does not form a valid or functional script. It includes PHP opening and closing tags (`<?php` and `?>`), but the content within these tags is not meaningful or executable PHP code. The snippet also contains HTML-like tags (`<!`, `<%`, `</%>`) that do not correspond to any standard HTML or server-side scripting language syntax. Overall, this code does not serve any practical purpose and seems to be a random or corrupted text rather than a functional script.
-
-
-```
-                                                                                                                                                                                                        |  -D___HIP_PLATFORM_AMD___ -I/home/user1/hip/include
-```
-
-You can capture the hipconfig output and passed it to the standard compiler; below is a sample makefile syntax:
-**Following code does:** This code snippet is an example of using the `ltrace` command to trace calls to HSA (Heterogeneous System Architecture) APIs. The command `ltrace -C -e "hsa*" ./hipGetChanDesc` is executed to monitor and log the function calls made by the `hipGetChanDesc` program that involve HSA-related libraries. The output shows a sequence of HSA API calls, including initialization, memory allocation, and event creation, along with their parameters and return values. This is useful for debugging or understanding the interactions between the program and the HSA runtime.
-
-
-```
-            |CPPFLAGS += $(shell $(HIP_PATH)/bin/hipconfig --cpp_config)
-```
-**Following code does:** The line you provided appears to be a version identifier or a header comment, rather than executable code. It likely indicates the version of a software release or documentation for a project named "HIP." This version is labeled as "6.1.40092." Such a line is typically used in documentation files to specify the version of the document or software it pertains to, helping users identify the correct version they are referencing or using.
-
-
-```
-
-)
-```
-
-NVCC includes some headers by default. However, HIP does not include default headers, and instead all required files must be explicitly included. Specifically, files that call HIP run-time APIs or define HIP kernels must explicitly include the appropriate HIP headers. If the compilation process reports that it cannot find necessary APIs (for example, error: identifier hipSetDevice is undefined ), ensure that the file includes hip\_runtime.h (or hip\_runtime\_api.h, if appropriate). The hipify-perl script automatically converts cuda\_runtime.h to hip\_runtime.h , and it converts cuda\_runtime\_api.h to hip\_runtime\_api.h , but it may miss nested headers or macros.
-
-## 8.9.3.1 cuda.h
-
-The HIP-Clang path provides an empty cuda.h file. Some existing CUDA programs include this file but don't require any of the functions.
-
-## 8.9.4 Choosing HIP File Extensions
-
-Many existing CUDA projects use the .cu and .cuh file extensions to indicate code that should be run through the NVCC compiler. For quick HIP ports, leaving these file extensions unchanged is often easier, as it minimizes the work required to change file names in the directory and #include statements in the files.
-
-For new projects or ports which can be re-factored, we recommend the use of the extension .hip.cpp for source files, and .hip.h or .hip.hpp for header files. This indicates that the code is standard C++ code, but also provides a unique indication for make tools to run hipcc when appropriate.
-
-## 8.10 Workarounds
-
-## 8.10.1 warpSize
-
-Code should not assume a warp size of 32 or 64. See Warp Cross-Lane Functions for information on how to write portable wave-aware code.
-
-## 8.10.2 Kernel launch with group size &gt; 256
-
-Kernel code should use \_\_attribute\_\_((amdgpu\_flat\_work\_group\_size(&lt;min&gt;,&lt;max&gt;))) . For example:
-**Following code does:** The provided code snippet appears to be a mix of HTML tags with unusual formatting and indentation. However, it does not form a valid or meaningful HTML structure. The code includes opening and closing tags for paragraphs (`<p>`), headings (`<h1>`), anchors (`<a>`), and bold text (`<b>`), but they are not properly nested or used in a coherent way. As it stands, this code does not serve any functional purpose in a web page and would not render any meaningful content. It seems to be a collection of HTML tags without a clear intent or structure.
-
-
-```
-<_SQL_>
-```
-
-## 8.11 memcpyToSymbol
-
-HIP support for hipMemcpyToSymbol is complete. This feature allows a kernel to define a device-side data symbol which can be accessed on the host side. The symbol can be in \_\_constant or device space.
-
-Note that the symbol name needs to be encased in the HIP\_SYMBOL macro, as shown in the code example below. This also applies to hipMemcpyFromSymbol , hipGetSymbolAddress , and hipGetSymbolSize .
-
-For example:
-
-Device Code:
-**Following code does:** The provided snippet appears to be a fragment of HTML code rather than a complete Python script. It includes an HTML paragraph (`<p>`) and an anchor (`<a>`) tag. The paragraph contains a brief description mentioning a "test" that caused a "segmentation fault issue." The anchor tag seems to reference a URL or file path related to a source file (`hipMemcpy_simple.cpp`) at a specific line (147), which is likely part of a test or example code related to memory operations in a runtime API, possibly for a GPU or parallel computing context. The snippet is incomplete and lacks context, but it suggests documentation or a report of a specific issue in a codebase.
-
-
-```
-<_C++_>
-```
-
-(continued from previous page)
-**Following code does:** The provided text does not appear to be a functional code snippet. Instead, it seems to be a fragment of a document or a placeholder text, possibly from a documentation file related to a software release (HIP Documentation, Release 6.1.40092). The text includes various symbols and characters that do not form a coherent or executable code. It might be part of a larger document or a formatting artifact.
-
-
-```
-        {
-            A[i] = -1*i;
-            B[i] = 0;
-        }
-
-        HIP_ASSERT(hipMalloc((void**)&Ad, SIZE));
-
-        HIP_ASSERT(hipMemcpyToSymbol(HIP_SYMBOL(Value), A, SIZE, 0, hipMemcpyHostToDevice));
-        hipLaunchKernelGGL(Get, dim3(1,1,1), dim3(LEN,1,1), 0, 0, Ad);
-        HIP_ASSERT(hipMemcpy(B, Ad, SIZE, hipMemcpyDeviceToHost));
-
-        for(unsigned i=0;i<LEN;i++)
-        {
-            assert(A[i] == B[i]);
-        }
-        std::cout<<"Passed"<<std::endl;
-    }
-    
-    
-    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-```
-
-## 8.12 CU\_POINTER\_ATTRIBUTE\_MEMORY\_TYPE
-
-To get pointer's memory type in HIP/HIP-Clang, developers should use hipPointerGetAttributes API. First parameter of the API is hipPointerAttribute\_t which has 'type' as member variable. 'type' indicates input pointer is allocated on device or host.
-
-For example:
-**Following code does:** This code snippet is a shell command that sets the environment variable `HIP_VISIBLE_DEVICES` to `0,1`. This variable is used in systems with AMD GPUs to specify which GPUs should be visible and accessible to applications using the HIP (Heterogeneous-Compute Interface for Portability) platform. By setting it to `0,1`, the command is indicating that only the GPUs with IDs 0 and 1 should be available for use by HIP-enabled applications. This is useful for managing GPU resources and controlling which GPUs are used for specific tasks.
-
-
-```
-            For example:
-            double * ptr;
-            hipMalloc(reinterpret_cast<void**>(&ptr), sizeof(double));
-            hipPointerAttribute_t attr;
-            hipPointerGetAttributes(&attr, ptr); /*attr.type will have value as hipMemoryTypeDevice*/
-
-            double* ptrHost;
-            hipHostMalloc(&ptrHost, sizeof(double));
-            hipPointerAttribute_t attr;
-            hipPointerGetAttributes(&attr, ptrHost); /*attr.type will have value as _
-           ...hipMemoryTypeHost*/
-
-            Data data file.MaximumTime amount value as different from end.MaximumTime amount value
-```
-
-Please note, hipMemoryType enum values are different from cudaMemoryType enum values.
-
-For example, on AMD platform, hipMemoryType is defined in hip\_runtime\_api.h ,
-**Following code does:** It seems like you've provided a placeholder or incomplete code snippet. If you have a specific Python code snippet you'd like me to explain, please provide the actual code, and I'll be happy to help!
-
-
-```
-            For example, on AMD platform, hipMemoryType is defined in hip_runtime_api.h,
-            
-        typedef enum hipMemoryType {
-            hipMemoryTypeHost = 0,     ///< Memory is physically located on host
-            hipMemoryTypeDevice = 1,  ///< Memory is physically located on device. (see deviceId,
-        --for specific device)
-            hipMemoryTypeArray = 2,   ///< Array memory, physically located on device. (see_,
-        --deviceId for specific device)
-            hipMemoryTypeUnified = 3, ///< Not used currently
-            hipMemoryTypeManaged = 4  ///< Managed memory, automatically managed by the unified.
-        --memory system
-        } hipMemoryType;
-```
-
-Looking into CUDA toolkit, it defines cudaMemoryType as following,
-**Following code does:** This code snippet is part of a larger program that is likely managing GPU devices for computation. It checks if the total number of devices (`totalDeviceNum`) is greater than 2. If this condition is true, it sets an environment variable `HIP_VISIBLE_DEVICES` to "0,1,2", which specifies that only the first three devices (indexed 0, 1, and 2) should be visible and used by the program. The `setenv` function is used to set this environment variable, with the last argument `1` indicating that it should overwrite any existing value. The `assert` statement then checks that the function `getDeviceNumber(false)` returns 3, ensuring that exactly three devices are recognized as available for use. This setup is likely part of a configuration process for a program that utilizes GPU resources.
-
-
-```
-<_Cuda_>
-```
-
-In this case, memory type translation for hipPointerGetAttributes needs to be handled properly on NVIDIA platform to get the correct memory type in CUDA, which is done in the file nvidia\_hip\_runtime\_api.h .
-
-So in any HIP applications which use HIP APIs involving memory types, developers should use #ifdef in order to assign the correct enum values depending on NVIDIA or AMD platform.
-
-As an example, please see the code from the link.
-
-With the #ifdef condition, HIP APIs work as expected on both AMD and NVIDIA platforms.
-
-Note, cudaMemoryTypeUnregstered is currently not supported in hipMemoryType enum, due to HIP functionality backward compatibility.
-
-## 8.13 threadfence\_system
-
-threadfence\_system makes all device memory writes, all writes to mapped host memory, and all writes to peer memory visible to CPU and other GPU devices. Some implementations can provide this behavior by flushing the GPU L2 cache. HIP/HIP-Clang does not provide this functionality. As a workaround, users can set the environment variable HSA\_DISABLE\_CACHE=1 to disable the GPU L2 cache. This will affect all accesses and for all kernels and so may have a performance impact.
-
-## 8.13.1 Textures and Cache Control
-
-Compute programs sometimes use textures either to access dedicated texture caches or to use the texture-sampling hardware for interpolation and clamping. The former approach uses simple point samplers with linear interpolation, essentially only reading a single point. The latter approach uses the sampler hardware to interpolate and combine multiple samples. AMD hardware, as well as recent competing hardware, has a unified texture/L1 cache, so it no longer has a dedicated texture cache. But the NVCC path often caches global loads in the L2 cache, and some programs may benefit from explicit control of the L1 cache contents. We recommend the \_\_ldg instruction for this purpose.
-
-AMDcompilers currently load all data into both the L1 and L2 caches, so \_\_ldg is treated as a no-op.
-
-We recommend the following for functional portability:
-
-- For programs that use textures only to benefit from improved caching, use the \_\_ldg instruction
-- Programs that use texture object and reference APIs, work well on HIP
-
-## 8.14 More Tips
-
-## 8.14.1 HIP Logging
-
-Onan AMDplatform, set the AMD\_LOG\_LEVEL environment variable to log HIP application execution information.
-
-The value of the setting controls different logging level,
-**Following code does:** This code snippet is a command used in the GNU Debugger (GDB) environment. It sets an environment variable named `AND_SERIALIZE_KERNEL` to the value `3` for the program being debugged. This can be used to influence the behavior of the program during debugging, potentially enabling or configuring specific features or modes related to kernel serialization, depending on how the program interprets this environment variable.
-
-
-```
-<_C++_>
-```
-
-Logging mask is used to print types of functionalities during the execution of HIP application. It can be set as one of the following values,
-**Following code does:** The code snippet is a shell command that executes a program named `hipinfo` located in the `~/hip/bin` directory. The output of this program is redirected twice: first to a file named `~/hipinfo` and then to another file named `~/hip_log.txt`. However, due to the syntax used, the output will only be redirected to `~/hip_log.txt`, as the second redirection overwrites the first one.
-
-
-```
-<_C++_>
-```
-
-## 8.14.2 Debugging hipcc
-
-To see the detailed commands that hipcc issues, set the environment variable HIPCC\_VERBOSE to 1. Doing so will print to stderr the HIP-clang (or NVCC) commands that hipcc generates.
-**Following code does:** This code defines an enumeration called `LogLevel` in Python, which is used to represent different levels of logging severity. Each log level is associated with an integer value, starting from 0 for `LOG_NONE` (indicating no logging) up to 4 for `LOG_DEBUG` (indicating the most detailed logging). This enumeration can be used in a logging system to categorize and filter log messages based on their severity.
-
-
-```
-export HIPCC_VERBOSE=1
-make
-
-...
-hipcc-cmd: /opt/rcm/bin/hipcc --offload-arch=native -x hip backprop_cuda.cu
-```
-
-## 8.14.3 Editor Highlighting
-
-See the utils/vim or utils/gedit directories to add handy highlighting to hip files.
-
-## PORTING CUDA DRIVER API
-
-## 9.1 Introduction to the CUDA Driver and Runtime APIs
-
-CUDA provides a separate CUDA Driver and Runtime APIs. The two APIs have significant overlap in functionality:
-
-- Both APIs support events, streams, memory management, memory copy, and error handling.
-- Both APIs deliver similar performance.
-- Driver APIs calls begin with the prefix cu while Runtime APIs begin with the prefix cuda . For example, the Driver API API contains cuEventCreate while the Runtime API contains cudaEventCreate , with similar functionality.
-- The Driver API defines a different but largely overlapping error code space than the Runtime API, and uses a different coding convention. For example, Driver API defines CUDA\_ERROR\_INVALID\_VALUE while the Runtime API defines cudaErrorInvalidValue
-
-The Driver API offers two additional pieces of functionality not provided by the Runtime API: cuModule and cuCtx APIs.
-
-## 9.1.1 cuModule API
-
-The Module section of the Driver API provides additional control over how and when accelerator code objects are loaded. For example, the driver API allows code objects to be loaded from files or memory pointers. Symbols for kernels or global data can be extracted from the loaded code objects. In contrast, the Runtime API automatically loads and (if necessary) compiles all of the kernels from an executable binary when run. In this mode, NVCC must be used to compile kernel code so the automatic loading can function correctly.
-
-Both Driver and Runtime APIs define a function for launching kernels (called cuLaunchKernel or cudaLaunchKernel . The kernel arguments and the execution configuration (grid dimensions, group dimensions, dynamic shared memory, and stream) are passed as arguments to the launch function. The Runtime additionally provides the &lt;&lt;&lt; &gt;&gt;&gt; syntax for launching kernels, which resembles a special function call and is easier to use than explicit launch API (in particular with respect to handling of kernel arguments). However, this syntax is not standard C++ and is available only when NVCC is used to compile the host code.
-
-The Module features are useful in an environment which generates the code objects directly, such as a new accelerator language front-end. Here, NVCC is not used. Instead, the environment may have a different kernel language or different compilation flow. Other environments have many kernels and do not want them to be all loaded automatically. The Module functions can be used to load the generated code objects and launch kernels. As we will see below, HIP defines a Module API which provides similar explicit control over code object management.
-
-## 9.1.2 cuCtx API
-
-The Driver API defines 'Context' and 'Devices' as separate entities. Contexts contain a single device, and a device can theoretically have multiple contexts. Each context contains a set of streams and events specific to the context. Historically contexts also defined a unique address space for the GPU, though this may no longer be the case in Unified Memory platforms (since the CPU and all the devices in the same process share a single unified address space). The Context APIs also provide a mechanism to switch between devices, which allowed a single CPU thread to send commands to different GPUs. HIP as well as a recent versions of CUDA Runtime provide other mechanisms to accomplish this feat - for example using streams or cudaSetDevice .
-
-The CUDA Runtime API unifies the Context API with the Device API. This simplifies the APIs and has little loss of functionality since each Context can contain a single device, and the benefits of multiple contexts has been replaced with other interfaces. HIP provides a context API to facilitate easy porting from existing Driver codes. In HIP, the Ctx functions largely provide an alternate syntax for changing the active device.
-
-Most new applications will prefer to use hipSetDevice or the stream APIs, therefore HIP has marked hipCtx APIs as deprecated . Support for these APIs may not be available in future releases. For more details on deprecated APIs please refer HIP deprecated APIs .
-
-## 9.2 HIP Module and Ctx APIs
-
-Rather than present two separate APIs, HIP extends the HIP API with new APIs for Modules and Ctx control.
-
-## 9.2.1 hipModule API
-
-Like the CUDA Driver API, the Module API provides additional control over how code is loaded, including options to load code from files or from in-memory pointers. NVCC and HIP-Clang target different architectures and use different code object formats: NVCC is cubin or ptx files, while the HIP-Clang path is the hsaco format. The external compilers which generate these code objects are responsible for generating and loading the correct code object for each platform. Notably, there is not a fat binary format that can contain code for both NVCC and HIP-Clang platforms. The following table summarizes the formats used on each platform:
-
-| Format                 | APIs                                                  | NVCC                       | HIP-CLANG          |
-|------------------------|-------------------------------------------------------|----------------------------|--------------------|
-| Code Object Fat Binary | hipModuleLoad , hipModuleLoadData hipModuleLoadFatBin | .cubin or PTX text .fatbin | .hsaco .hip_fatbin |
-
-hipcc uses HIP-Clang or NVCC to compile host codes. Both of these may embed code objects into the final executable, and these code objects will be automatically loaded when the application starts. The hipModule API can be used to load additional code objects, and in this way provides an extended capability to the automatically loaded code objects. HIP-Clang allows both of these capabilities to be used together, if desired. Of course it is possible to create a program with no kernels and thus no automatic loading.
-
-## 9.2.2 hipCtx API
-
-HIP provides a Ctx API as a thin layer over the existing Device functions. This Ctx API can be used to set the current context, or to query properties of the device associated with the context. The current context is implicitly used by other APIs such as hipStreamCreate .
-
-## 9.2.3 hipify translation of CUDA Driver API
-
-The HIPIFY tools convert CUDA Driver APIs for streams, events, modules, devices, memory management, context, profiler to the equivalent HIP driver calls. For example, cuEventCreate will be translated to hipEventCreate . HIPIFY tools also convert error codes from the Driver namespace and coding convention to the equivalent HIP error code. Thus, HIP unifies the APIs for these common functions.
-
-The memory copy API requires additional explanation. The CUDA driver includes the memory direction in the name of the API ( cuMemcpyH2D ) while the CUDA driver API provides a single memory copy API with a parameter that specifies the direction and additionally supports a 'default' direction where the runtime determines the direction automatically. HIP provides APIs with both styles: for example, hipMemcpyH2D as well as hipMemcpy . The first flavor may be faster in some cases since they avoid host overhead to detect the different memory directions.
-
-HIP defines a single error space, and uses camel-case for all errors (i.e. hipErrorInvalidValue ).
-
-## 9.2.3.1 Address Spaces
-
-HIP-Clang defines a process-wide address space where the CPU and all devices allocate addresses from a single unified pool. Thus addresses may be shared between contexts, and unlike the original CUDA definition a new context does not create a new address space for the device.
-
-## 9.2.3.2 Using hipModuleLaunchKernel
-
-hipModuleLaunchKernel is cuLaunchKernel in HIP world. It takes the same arguments as cuLaunchKernel .
-
-## 9.2.3.3 Additional Information
-
-- HIP-Clang creates a primary context when the HIP API is called. So in a pure driver API code, HIP-Clang will create a primary context while HIP/NVCC will have empty context stack. HIP-Clang will push primary context to context stack when it is empty. This can have subtle differences on applications which mix the runtime and driver APIs.
-
-## 9.2.4 hip-clang Implementation Notes
-
-## 9.2.4.1 .hip\_fatbin
-
-hip-clang links device code from different translation units together. For each device target, a code object is generated. Code objects for different device targets are bundled by clang-offload-bundler as one fatbinary, which is embeded as a global symbol \_\_hip\_fatbin in the .hip\_fatbin section of the ELF file of the executable or shared object.
-
-## 9.2.4.2 Initialization and Termination Functions
-
-hip-clang generates initialization and termination functions for each translation unit for host code compilation. The initialization functions call \_\_hipRegisterFatBinary to register the fatbinary embeded in the ELF file. They also call \_\_hipRegisterFunction and \_\_hipRegisterVar to register kernel functions and device side global variables. The termination functions call \_\_hipUnregisterFatBinary . hip-clang emits a global variable \_\_hip\_gpubin\_handle of void** type with linkonce linkage and inital value 0 for each host translation unit. Each initialization function checks \_\_hip\_gpubin\_handle and register the fatbinary only if \_\_hip\_gpubin\_handle is 0 and saves the return value of \_\_hip\_gpubin\_handle to \_\_hip\_gpubin\_handle . This is to guarantee that the fatbinary is only registered once. Similar check is done in the termination functions.
-
-## 9.2.4.3 Kernel Launching
-
-hip-clang supports kernel launching by CUDA &lt;&lt;&lt;&gt;&gt;&gt; syntax, hipLaunchKernelGGL. The latter one is macro which expand to CUDA &lt;&lt;&lt;&gt;&gt;&gt; syntax.
-
-When the executable or shared library is loaded by the dynamic linker, the initialization functions are called. In the initialization functions, when \_\_hipRegisterFatBinary is called, the code objects containing all kernels are loaded; when \_\_hipRegisterFunction is called, the stub functions are associated with the corresponding kernels in code objects.
-
-hip-clang implements two sets of kernel launching APIs.
-
-By default, in the host code, for the &lt;&lt;&lt;&gt;&gt;&gt; statement, hip-clang first emits call of hipConfigureCall to set up the threads and grids, then emits call of the stub function with the given arguments. In the stub function, hipSetupArgument is called for each kernel argument, then hipLaunchByPtr is called with a function pointer to the stub function. In hipLaunchByPtr , the real kernel associated with the stub function is launched.
-
-## 9.2.5 NVCC Implementation Notes
-
-## 9.2.5.1 Interoperation between HIP and CUDA Driver
-
-CUDA applications may want to mix CUDA driver code with HIP code (see example below). This table shows the type equivalence to enable this interaction.
-
-| HIP Type      | CU Driver Type   | CUDA Runtime Type   |
-|---------------|------------------|---------------------|
-| hipModule_t   | CUmodule         |                     |
-| hipFunction_t | CUfunction       |                     |
-| hipCtx_t      | CUcontext        |                     |
-| hipDevice_t   | CUdevice         |                     |
-| hipStream_t   | CUstream         | cudaStream_t        |
-| hipEvent_t    | CUevent          | cudaEvent_t         |
-| hipArray      | CUarray          | cudaArray           |
-
-## 9.2.5.2 Compilation Options
-
-The hipModule\_t interface does not support cuModuleLoadDataEx function, which is used to control PTX compilation options. HIP-Clang does not use PTX and does not support these compilation options. In fact, HIP-Clang code objects always contain fully compiled ISA and do not require additional compilation as a part of the load step. The corresponding HIP function hipModuleLoadDataEx behaves as hipModuleLoadData on HIP-Clang path (compilation options are not used) and as cuModuleLoadDataEx on NVCC path. For example (CUDA):
-**Following code does:** This code snippet describes a logging system for a HIP (Heterogeneous-Compute Interface for Portability) application. It defines an enumeration `LogMask` with various bitmask values, each representing a different type of logging functionality, such as API calls, synchronization, memory allocation, and more. The logging mask is used to control which types of log messages are printed during the execution of a HIP application. By default, the logging mask is set to a value that enables all logging types, but it can be customized by setting the `AMD_LOG_MASK` environment variable to include only specific types of logs. This allows developers to filter and focus on particular areas of interest when debugging or monitoring the application.
-
-
-```
-<_Cuda_>
-```
-
-HIP:
-**Following code does:** The code snippet provided is not a valid or meaningful Python code. It appears to be a collection of random characters, including HTML-like tags and whitespace, but it does not perform any computational task or serve any functional purpose. It might be an accidental paste or a placeholder.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?xml version="1.0" encoding="UTF-8" />
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        </?xml version="2.0" encoding="UTF-8" />
-                                                                                                                                                                                             <?xml version="3.0" encoding="UTF-8" />
-                                                                                                                                                                                            
-	         
-                                                                                                                                                                                             
-         
-                                                                                                                                                                                              <?xml version="4.0" encoding="UTF-8" />
-                                                                                                                                                                                             </?xml version="5.0" encoding="UTF-8" />
-                                                                                                                                                                                            
-
-          
-                                                                                                                                                                                             <?xml version="6.0" encoding="UTF-8" />
-                                                                                                                                                                                             >
-                                                                                                                                                                                                       <!xml version="7.0" encoding="UTF-8" />
-                                                                                                                                                                                             //
-                                                                                                                                                                                                       </!xml version="8.0" encoding="UTF-8" />
-                                                                                                                                                                                             }
-```
-
-The below sample shows how to use hipModuleGetFunction .
-**Following code does:** This code snippet logs a message indicating that the HSA (Heterogeneous System Architecture) stack is being initialized. It uses a logging function `ClPrint` from the `amd` namespace, specifying the log level as `LOG_INFO` and the log category as `LOG_INIT`. This is likely part of a larger system where logging is used to track the initialization process of various components.
-
-
-```
-#include<hip_runtime.h>
-#include<hip_runtime_api.h>
-#include<iostream>
-#include<fstream>
-#include<vector>
-```
-**Following code does:** The provided code snippet appears to be a fragment of HTML or a similar markup language. It includes various HTML tags such as `<HR>`, `<HIP Documentation, Release 6.1.40092>`, `<BR>`, and `<B>`. However, the snippet is mostly empty or improperly formatted, with many tags not closed or used incorrectly. The high-level purpose seems to be related to documentation, possibly for a software release (version 6.1.40092), and it might be intended to format or display logging examples. However, due to the lack of proper structure and content, it does not achieve any meaningful functionality or display.
-
-
-```
-#include<hip_runtime.h>
-#include<hip_runtime_api.h>
-#include<iostream>
-#include<fstream>
-#include<vector>
-```
-**Following code does:** This line appears to be a version identifier or header for a document related to "HIP Documentation." It indicates that the document is associated with a release version "6.1.40092." This is not executable code but rather a label or title that likely precedes detailed documentation about a software product or library named "HIP."
-
-
-```
-HIP Documentation, Release 6.1.40092
-
-
-
-
-#define LEN 64
-#define SIZE LEN<<2
-
-#ifdef __HIP_PLATFORM_AMD__
-#define fileName "vcpy_isa.co"
-#endif
-
-#ifdef __HIP_PLATFORM_NVIDIA__
-#define fileName "vcpy_isa.ptx"
-#endif
-
-#define kernel_name "hello_world"
-
-int main(){
-	float *A, *B;
-	hipDeviceptr_t Ad, Bd;
-	A = new float[LEN];
-	B = new float[LEN];
-
-	for(uint32_t i=0;i<LEN;i++){
-		A[i] = i*1.0f;
-		B[i] = 0.0f;
-		std::cout<<A[i] << " "<<B[i]<<std::endl;
-	}
-
-
-#ifdef __HIP_PLATFORM_NVIDIA__
-		hipInit(0);
-		hipDevice_t device;
-		hipCtx_t context;
-		hipDeviceGet(&device, 0);
-		hipCtxCreate(&context, 0, device);
-#endif
-
-	hipMalloc((void**)&Ad, SIZE);
-	hipMalloc((void**)&Bd, SIZE);
-
-	hipMemcpyHtoD(Ad, A, SIZE);
-	hipMemcpyHtoD(Bd, B, SIZE);
-	hipModule_t Module;
-	hipFunction_t Function;
-	hipModuleLoad(&Module, fileName);
-	hipModuleGetFunction(&Function, Module, kernel_name);
-
-	std::vector<void*>argBuffer(2);
-	memcpy(&argBuffer[0], &Ad, sizeof(void*));
-	memcpy(&argBuffer[1], &Bd, sizeof(void*));
-
-	size_t size = argBuffer.size()*sizeof(void*);
-
-	void *config[] = {
-		HIP_LAUNCH_PARAM_BUFFER_POINTER, &argBuffer[0],
-
-
-
-54
-```
-
-(continued from previous page)
-
-(continues on next page)
-
-(continued from previous page)
-**Following code does:** The code snippet provided appears to be malformed or corrupted, as it contains excessive whitespace and incomplete or nonsensical elements. Specifically, it includes what looks like an HTML/XML-like tag `<kendo runume. </kendo>runume.`, which is not valid Python syntax. Without additional context or correction, it is not possible to determine a high-level purpose for this code.
-
-
-```
-        HIP_LAUNCH_PARAM_BUFFER_SIZE, &size,
-        HIP_LAUNCH_PARAM_END
-    };
-
-    hipModuleLaunchKernel(Function, 1, 1, 1, LEN, 1, 1, 0, 0, NULL, (void**)&config);
-
-    hipMemcpyDtoH(B, Bd, SIZE);
-    for(uint32_t i=0;i<LEN;i++){
-        std::cout<<A[i]<<" - "<<B[i]<<std::endl;
-    }
-
-#ifdef __HIP_PLATFORM_NVIDIA__
-          hipCtxDetach(context);
-#endif
-
-    return 0;
-}
-
-__A__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ ======"__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__= "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "_ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = '__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ from "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "___ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "'
-```
-
-## 9.3 HIP Module and Texture Driver API
-
-HIP supports texture driver APIs however texture reference should be declared in host scope. Following code explains the use of texture reference for \_\_HIP\_PLATFORM\_AMD\_\_ platform.
-**Following code does:** The provided code snippet does not contain any valid Python code. Instead, it appears to be a malformed and nonsensical mix of XML-like tags and URLs, specifically referencing "amazonaws.com" multiple times. This could potentially be an attempt at obfuscation or a corrupted piece of data, but it does not perform any meaningful function or operation as it stands.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        // Code to generate code object
-
-                                                                                                                                                                                                      
-#include "hip/hip_runtime.h"
-                                                                                                                                                                                                      
-extern texture<float, 2, hipReadModeElementType> tex;
-
-        __global__ void tex2dKernel(hipLaunchParm lp, float* outputData,
-                                                                                                                                                                                                       //
-```
-**Following code does:** This code snippet appears to be a log output from a graphics or compute driver, specifically related to memory allocation and management. It logs the allocation of memory buffers, including the size of the allocation (100,000 bytes in each case), the memory address ranges for the allocated pointers, and the associated objects. Additionally, it logs a call to `hipMemGetInfo`, which returns the total and free memory available, indicating that the system has 12.06 GB of total memory with 11.93 GB free, representing 99% availability. The log entries include timestamps and thread identifiers for context.
-
-
-```
-  }
-
-  // Host code:
-
-  texture<float, 2, hipReadModeElementType> tex;
-
-  void myFunc ()
-  {
-
-      //...
-
-      textureReference* texref;
-      hipModuleGetTexRef(&texref, Module1, "tex");
-      hipTexRefSetAddressMode(texref, 0, hipAddressModeWrap);
-      hipTexRefSetAddressMode(texref, 1, hipAddressModeWrap);
-      hipTexRefSetFilterMode(texref, hipFilterModePoint);
-```
-
-(continues on next page)
-**Following code does:** This code snippet appears to be a part of a parallel programming framework, likely related to GPU programming, such as CUDA. The `thread_block` class is used to represent a group of threads that can cooperate and synchronize with each other during execution. The line `thread_block g = this_thread_block();` constructs an instance `g` of the `thread_block` class, which represents the current block of threads that the executing thread belongs to. This allows the thread to access information and perform operations specific to its block, such as synchronization or shared memory access.
-
-
-```
-    hipTexRefSetFlags(texref, 0);
-    hipTexRefSetFormat(texref, HIP_AD_FORMAT_FLOAT, 1);
-    hipTexRefSetArray(texref, array, HIP_TRSA_OVERRIDE_FORMAT);
-
-    //...
-}
-```
-
-(continued from previous page)
-
-## TEN
-
-## PROGRAMMING FOR HIP RUNTIME COMPILER (RTC)
-
-HIP lets you compile kernels at runtime with the hiprtc* APIs. Kernels can be stored as a text string and can be passed to HIPRTC APIs alongside options to guide the compilation.
-
-NOTE:
-
-- This library can be used on systems without HIP installed nor AMD GPU driver installed at all (offline compilation). Therefore, it does not depend on any HIP runtime library.
-- But it does depend on comgr. You may try to statically link comgr into HIPRTC to avoid any ambiguity.
-- Developers can decide to bundle this library with their application.
-
-## 10.1 Example
-
-To use HIPRTC functionality, HIPRTC header needs to be included first. #include &lt;hip/hiprtc.h&gt;
-
-Kernels can be stored in a string:
-**Following code does:** The code snippet appears to be a fragment of a larger codebase, likely related to a grid or parallel computing framework. The `grid_group` is defined as a class, but the snippet does not provide its implementation details. The comment "Constructed via:" suggests that instances of `grid_group` are created using a function or method called `this_grid()`. This implies that `this_grid()` is a factory function or method that returns an instance of `grid_group`, possibly representing a group or collection of grid elements or processes. The purpose of this setup is likely to manage or interact with a grid structure in a computational context.
-
-
-```
-<_C_>
-```
-
-Now to compile this kernel, it needs to be associated with hiprtcProgram type, which is done by declaring hiprtcProgram prog; and associating the string of kernel with this program:
-**Following code does:** The code snippet appears to be a syntax error or incomplete code. In Python, the `class` keyword is used to define a new class, but the snippet includes a `|` character at the beginning and ends with a semicolon, both of which are not valid in Python class definitions. Additionally, the class body is missing. If this were intended to be a Python class definition, it should start with `class multi_grid_group:` followed by an indented block defining the class's attributes and methods.
-
-
-```
-hiprtcCreateProgram(&prog,                    // HIPRTC program
-                       kernel,                // kernel string
-                       "gpu_kernel.cu",       // Name of the file
-                       num_headers,            // Number of headers
-                       &header_sources[0],     // Header sources
-                       &header_names[0]);      // Name of header files
-```
-
-hiprtcCreateProgram API also allows you to add headers which can be included in your RTC program. For online compilation, the compiler pre-defines HIP device API functions, HIP specific types and macros for device compilation, but does not include standard C/C++ headers by default. Users can only include header files provided to hiprtcCreateProgram .
-
-After associating the kernel string with hiprtcProgram , you can now compile this program using:
-**Following code does:** The code snippet provided is a single semicolon (`;`). In Python, a semicolon is used to separate multiple statements on a single line, but on its own, it does nothing and has no effect. Therefore, this code snippet does not perform any operation or have any functional purpose.
-
-
-```
-
-
-hiprtcCompileProgram(prog,     // hiprtcProgram
-                         0,          // Number of options
-                          options);  // Clang Options [Supported Clang Options](clang_options.
-
---md)
-```
-
-hiprtcCompileProgram returns a status value which can be converted to string via hiprtcGetErrorString . If compilation is successful, hiprtcCompileProgram will return HIPRTC\_SUCCESS .
-
-If the compilation fails, you can look up the logs via:
-**Following code does:** The code snippet `<_C_>` appears to be a placeholder or a non-functional piece of code. It does not represent any valid Python syntax or operation. It might be used as a marker or a template in a larger codebase where actual code is intended to be inserted later.
-
-
-```
-<_C++_>
-```
-
-If the compilation is successful, you can load the compiled binary in a local variable.
-**Following code does:** The code snippet you provided seems to be a placeholder or a tag indicating a YAML (YAML Ain't Markup Language) document or section, rather than actual executable code. YAML is a human-readable data serialization standard often used for configuration files and data exchange between languages with different data structures. Without specific YAML content, it's not possible to determine the exact purpose or functionality. If you have a YAML document or configuration, it typically defines settings, parameters, or data structures in a structured format.
-
-
-```
-  size_t codeSize;
-  hiprtcGetCodeSize(prog, &codeSize);
-
-  vector<char> kernel_binary(codeSize);
-  hiprtcGetCode(prog, kernel_binary.data());
-```
-
-After loading the binary, hiprtcProgram can be destroyed. hiprtcDestroyProgram(&amp;prog);
-
-The binary present in kernel\_binary can now be loaded via hipModuleLoadData API.
-**Following code does:** It seems there is a formatting error in your request. The code snippet is labeled as Python, but the placeholder `<_C++_>` suggests it might be intended for C++. Please provide the correct code snippet or clarify the language so I can assist you accurately.
-
-
-```
-hipModule_t module;
-hipFunction_t kernel;
-
-hipModuleLoadData(&module, kernel_binary.data());
-hipModuleGetFunction(&kernel, module, "vector_add");
-```
-
-And now this kernel can be launched via hipModule APIs.
-
-The full example is below:
-**Following code does:** The placeholder `<_SQL_>` suggests that this is not actual code but rather a placeholder for SQL code. In this context, it indicates that the code snippet is intended to represent a section where SQL queries or statements would be placed. Without specific SQL code, it's not possible to determine the exact functionality, but generally, SQL code is used to interact with databases, performing operations such as querying data, updating records, inserting new data, or deleting existing data.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        //
-```
-
-(continued from previous page)
-**Following code does:** The code snippet appears to be a fragment of code that is not complete or syntactically correct in Python. The line seems to be attempting to define a class named `coalesced_group`, but it includes a syntax error with the presence of the `|` character at the beginning, which is not valid in Python class definitions. In a correct context, this line would be part of a class definition, but as it stands, it does not perform any function or operation.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        </----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                    <-----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        >----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                   
-    <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                <----------------------------------------------------------------------------------------------------------------------    <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                               
-        <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                            <----------------------------------------------------------------------------------------------------------------------        <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                           
-            <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                        <----------------------------------------------------------------------------------------------------------------------            <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                       
-                <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                    <----------------------------------------------------------------------------------------------------------------------                <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                   
-                    <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                <----------------------------------------------------------------------------------------------------------------------                    <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                               
-                        <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                            <----------------------------------------------------------------------------------------------------------------------                        <----------------------------------------------------------------------------------------------------------------------
-```
-**Following code does:** The code snippet appears to be a fragment of a larger codebase, likely related to parallel computing or GPU programming. The line seems to be attempting to define a variable named `active` within a group or context, possibly using a syntax specific to a particular framework or language extension. The `coalesced_threads()` function or method is likely intended to return a set of threads that are coalesced, meaning they are grouped together to execute in a more efficient manner, often to optimize memory access patterns in parallel processing environments. However, the syntax is unusual and may contain typographical errors or be specific to a non-standard language or domain-specific language.
-
-
-```
-HIP Documentation,Release 6.1.40092
-```
-
-(continued from previous page)
-**Following code does:** The code snippet `<_Cuda_>` appears to be a placeholder or a symbolic representation rather than actual executable Python code. In the context of programming, "Cuda" typically refers to NVIDIA's parallel computing platform and application programming interface (API) model, which allows developers to use a CUDA-enabled graphics processing unit (GPU) for general purpose processing. However, without additional context or actual code, it's not possible to determine the specific functionality or purpose of this placeholder.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        }
-                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       }
-
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                       	                                                                                                                                                                                                      
-
-                                                                                                                                                                                                      
-                                                                                                                                                                                                     
-
-                                                                                                                                                                                                    
- 
-                                                                                                                                                                                                    
-
-                                                                                                                                                                                                      
-
- 
-                                                                                                                                                                                                     }
- 
-                                                                                                                                                                                                    }
-  
-                                                                                                                                                                                                    }
-
-  
-                                                                                                                                                                                                   
-  
-                                                                                                                                                                                                   }
-```
-
-## 10.2 HIPRTC specific options
-
-HIPRTC provides a few HIPRTC specific flags
-
-- --gpu-architecture : This flag can guide the code object generation for a specific gpu arch. Example: --gpu-architecture=gfx906:sramecc+:xnack, its equivalent to --offload-arch .
-- -This option is compulsory if compilation is done on a system without AMD GPUs supported by HIP runtime.
-- -Otherwise, HIPRTC will load the hip runtime and gather the current device and its architecture info and use it as option.
-- -fgpu-rdc : This flag when provided during the hiprtcCompileProgram generates the bitcode (HIPRTC doesn't convert this bitcode into ISA and binary). This bitcode can later be fetched using hiprtcGetBitcode and hiprtcGetBitcodeSize APIs.
-
-## 10.2.1 Bitcode
-
-In the usual scenario, the kernel associated with hiprtcProgram is compiled into the binary which can be loaded and run. However, if -fpu-rdc option is provided in the compile options, HIPRTC calls comgr and generates only the LLVM bitcode. It doesn't convert this bitcode to ISA and generate the final binary.
-**Following code does:** The code snippet provided is not functional Python code. It consists mostly of whitespace and a few non-Python elements such as `//`, `/*`, and `*/`, which are comment syntax from languages like C or C++. The snippet appears to be an attempt to create a comment block, but it is not valid in Python. Therefore, it does not perform any operations or have any high-level purpose in a Python context.
-
-
-```
-  std::string sarg = std::string("-fgpu-rdc");
-  const char* options[] = {
-      sarg.c_str() };
-  hiprtcCompileProgram(prog, // hiprtcProgram
-                        1,     // Number of options
-                        options);
-```
-
-If the compilation is successful, one can load the bitcode in a local variable using the bitcode APIs provided by HIPRTC.
-**Following code does:** This code snippet is part of a parallel reduction algorithm, typically used in GPU programming or multi-threaded environments. The purpose of this code is to perform a reduction operation, specifically summing up elements in a data set using a hierarchical approach. Here's a high-level summary of what it does:
-
-1. **Initialization**: The loop starts with `i` set to half the size of the group `g`, which likely represents a group of threads or processing units.
-
-2. **Shared Memory Usage**: Each thread stores its value (`val`) in a shared memory array indexed by its thread ID (`group_thread_id`).
-
-3. **Synchronization**: The `g.sync()` calls ensure that all threads in the group reach the same point in the code before proceeding, which is crucial for correct data sharing and avoiding race conditions.
-
-4. **Reduction Step**: Threads with IDs less than `i` add the value from another thread (offset by `i`) to their own value. This effectively reduces the number of active threads by half each iteration, combining values in a tree-like structure.
-
-5. **Iterative Halving**: The loop continues, halving `i` each time, until `i` becomes zero, at which point the reduction is complete, and the final sum is likely stored in one of the threads.
-
-Overall, this code is implementing a parallel reduction to sum up values efficiently across multiple threads, leveraging shared memory and synchronization to ensure correct results.
-
-
-```
-size_t bitCodeSize;
-hiprtcGetBitcodeSize(prog, &bitCodeSize);
-
-vector<char> kernel_bitcode(bitCodeSize);
-hiprtcGetBitcode(prog, kernel_bitcode.data());
-```
-
-## 10.2.2 CU Mode vs WGP mode
-
-AMDGPUs consist of an array of workgroup processors, each built with 2 compute units (CUs) capable of executing SIMD32. All the CUs inside a workgroup processor use local data share (LDS).
-
-gfx10+ support execution of wavefront in CU mode and work-group processor mode (WGP). Please refer to section 2.3 of RDNA3 ISA reference.
-
-gfx9 and below only supports CU mode.
-
-In WGP mode, 4 warps of a block can simultaneously be executed on the workgroup processor, where as in CU mode only 2 warps of a block can simultaneously execute on a CU. In theory, WGP mode might help with occupancy and increase the performance of certain HIP programs (if not bound to inter warp communication), but might incur performance penalty on other HIP programs which rely on atomics and inter warp communication. This also has effect of how the LDS is split between warps, please refer to RDNA3 ISA reference for more information.
-
-HIPRTCassumes WGPmodebydefault for gfx10+. This can be overridden by passing -mcumode to HIPRTC compile options in hiprtcCompileProgram .
-
-## 10.3 Linker APIs
-
-The bitcode generated using the HIPRTC Bitcode APIs can be loaded using hipModule APIs and also can be linked with other generated bitcodes with appropriate linker flags using the HIPRTC linker APIs. This also provides more flexibility and optimizations to the applications who want to generate the binary dynamically according to their needs. The input bitcodes can be generated only for a specific architecture or it can be a bundled bitcode which is generated for multiple architectures.
-
-## 10.3.1 Example
-
-Firstly, HIPRTC link instance or a pending linker invocation must be created using hiprtcLinkCreate , with the appropriate linker options provided.
-**Following code does:** This code snippet is part of a CUDA kernel function, which is designed to run on a GPU. The kernel, named `sum_kernel`, performs a parallel reduction operation. It utilizes shared memory, specifically an array named `workspace`, to efficiently compute the sum of elements from an input array. The `reduce_sum` function is likely responsible for aggregating the values stored in `workspace` and `input`, ultimately producing a single output value that represents the sum of the input elements. This approach leverages the parallel processing capabilities of the GPU to accelerate the summation process.
-
-
-```
-<_C++_>
-```
-
-Following which, the bitcode data can be added to this link instance via hiprtcLinkAddData (if the data is present as a string) or hiprtcLinkAddFile (if the data is present as a file) with the appropriate input type according to the data or the bitcode used.
-**Following code does:** The provided code snippet is a mix of Python and C++ syntax, but it is mostly composed of whitespace and special characters. It does not form any valid or meaningful code in either language. The snippet includes C++ keywords like `const` and `auto`, as well as comment syntax (`//` and `/* */`), but they are not used in a coherent or executable manner. Therefore, this code does not perform any specific function or task.
-
-
-```
-
-hiprtcLinkAddData(rtc_link_state,        // HIPRTC link state
-                         input_type,            // type of the input data or bitcode
-                         bit_code_ptr,           // input data which is null terminated
-                         bit_code_size,          // size of the input data
-                          "a",                   // optional name for this input
-                          0,                     // size of the options
-                          0,                     // Array of options applied to this input
-                          0);                      // Array of option values cast to void*
-```
-**Following code does:** This code snippet is part of a parallel computing operation, likely using a GPU programming model such as CUDA. It involves two main steps:
-
-1. **Thread Block Initialization**: The `this_thread_block()` function is called to obtain a `thread_block` object, which represents a group of threads that can cooperate and share data during execution.
-
-2. **Reduction Operation**: The `reduce_sum` function is used to perform a reduction operation on the `input` data. This operation typically involves summing up elements across the threads within the `thread_block_group`, storing the result in `output`. The `workspace` parameter likely provides temporary storage needed for the reduction process.
-
-Overall, the code is designed to efficiently compute the sum of elements in parallel using a group of threads.
-
-
-```
-hiprtcLinkAddFile(rtc_link_state,        // HIPRTC link state
-                         input_type,            // type of the input data or bitcode
-                         bc_file_path.c_str(),  // path to the input file where bitcode is_
---present
-                         0,                   // size of the options
-                          0,                    // Array of options applied to this input
-                          0);                    // Array of option values cast to void*
-```
-
-Once the bitcodes for multiple architectures are added to the link instance, the linking of the device code must be completed using hiprtcLinkComplete which generates the final binary.
-**Following code does:** This code snippet is written in C++ using the HIP (Heterogeneous-Compute Interface for Portability) API, which is used for GPU programming. The code checks if a single AMD GPU supports cooperative launch capabilities. It first retrieves the current GPU device ID and then queries the device to determine if it supports cooperative launch features. If the device does not support cooperative groups, it outputs a message indicating this and exits the program. This check is important for ensuring that the GPU can handle tasks that require cooperation between multiple threads or blocks.
-
-
-```
-<_C_>
-```
-
-If the hiprtcLinkComplete returns successfully, the generated binary can be loaded and run using the hipModule* APIs.
-**Following code does:** This code snippet is designed to check the capability of multiple GPUs to support cooperative group launches, specifically in a multi-GPU environment. It iterates over available devices, checking each one for support of the `hipDeviceAttributeCooperativeMultiDeviceLaunch` attribute, which indicates whether the device can participate in cooperative multi-device launches. If a device supports this feature, its ID is added to a list of valid device IDs. If not, a message is printed indicating that the device does not support cooperative groups. This setup is typically used in scenarios where tasks need to be distributed across multiple GPUs that can work together cooperatively.
-
-
-```
-      |hipModuleLoadData(&module, bina
-```
-**Following code does:** The code snippet provided is not a valid Python code. It appears to contain a comment written in C/C++ style (using `//` for comments), which suggests that it might be part of a larger C/C++ program. The comment indicates that the code is related to launching a kernel from the host, which is a common operation in parallel computing environments such as CUDA or OpenCL. In such contexts, "launching a kernel" typically means executing a function (the kernel) on a GPU or other parallel processing device from the host CPU. However, without additional context or code, this snippet alone does not perform any operations.
-
-
-```
-binary);
-```
-
-## 10.3.1.1 Note
-
-- The compiled binary must be loaded before HIPRTC link instance is destroyed using the hiprtcLinkDestroy API.
-
-## hiprtcLinkDestroy(rtc\_link\_state);
-
-- The correct sequence of calls is : hiprtcLinkCreate , hiprtcLinkAddData or hiprtcLinkAddFile , hiprtcLinkComplete , hiprtcModuleLoadData , hiprtcLinkDestroy .
-
-## 10.3.2 Input Types
-
-HIPRTC provides hiprtcJITInputType enumeration type which defines the input types accepted by the Linker APIs. Here are the enum values of hiprtcJITInputType . However only the input types HIPRTC\_JIT\_INPUT\_LLVM\_BITCODE , HIPRTC\_JIT\_INPUT\_LLVM\_BUNDLED\_BITCODE and HIPRTC\_JIT\_INPUT\_LLVM\_ARCHIVES\_OF\_BUNDLED\_BITCODE are supported currently.
-
-HIPRTC\_JIT\_INPUT\_LLVM\_BITCODE can be used to load both LLVM bitcode or LLVM IR assembly code. However, HIPRTC\_JIT\_INPUT\_LLVM\_BUNDLED\_BITCODE and HIPRTC\_JIT\_INPUT\_LLVM\_ARCHIVES\_OF\_BUNDLED\_BITCODE are only for bundled bitcode and archive of bundled bitcode.
-**Following code does:** The code snippet `<_C_>` appears to be a placeholder or a fragment that does not represent any valid or complete Python code. It might be intended as a marker or a template for something to be filled in later. Without additional context or surrounding code, it does not perform any specific function or operation.
-
-
-```
-<_Cuda_>
-```
-
-## 10.3.3 Backward Compatibility of LLVM Bitcode/IR
-
-For HIP applications utilizing HIPRTC to compile LLVM bitcode/IR, compatibility is assured only when the ROCm or HIP SDK version used for generating the LLVM bitcode/IR matches the version used during the runtime compilation. When an application requires the ingestion of bitcode/IR not derived from the currently installed AMD compiler, it must run with HIPRTC and comgr dynamic libraries that are compatible with the version of the bitcode/IR.
-
-comgr, a shared library, incorporates the LLVM/Clang compiler that HIPRTC relies on. To identify the bitcode/IR version that comgr is compatible with, one can execute 'clang -v' using the clang binary from the same ROCm or HIP SDK package. For instance, if compiling bitcode/IR version 14, the HIPRTC and comgr libraries released by AMD around mid 2022 would be the best choice, assuming the LLVM/Clang version included in the package is also version 14.
-
-To ensure smooth operation and compatibility, an application may choose to ship the specific versions of HIPRTC and comgr dynamic libraries, or it may opt to clearly specify the version requirements and dependencies. This approach guarantees that the application can correctly compile the specified version of bitcode/IR.
-
-## 10.3.4 Link Options
-
-- HIPRTC\_JIT\_IR\_TO\_ISA\_OPT\_EXT - AMD Only. Options to be passed on to link step of compiler by hiprtcLinkCreate .
-- HIPRTC\_JIT\_IR\_TO\_ISA\_OPT\_COUNT\_EXT - AMD Only. Count of options passed on to link step of compiler.
-
-Example:
-**Following code does:** This code snippet is designed to launch a cooperative kernel across multiple GPUs using the HIP (Heterogeneous-Compute Interface for Portability) API. It sets up and manages the execution of a parallel computation task on multiple devices. The code performs the following high-level tasks:
-
-1. Allocates memory for an array of `hipLaunchParams` structures, which will hold the configuration for launching kernels on each GPU.
-2. Iterates over a list of device IDs to configure each GPU:
-   - Sets the current device to the specified GPU.
-   - Creates a stream for asynchronous execution on the GPU.
-   - Prepares the kernel parameters, which include pointers to device memory arrays.
-   - Configures the launch parameters for the kernel, including the function to execute, grid and block dimensions, shared memory size, and the stream.
-3. Launches the cooperative kernel across all specified GPUs using `hipLaunchCooperativeKernelMultiDevice`, allowing the kernels to work together across devices.
-4. The code implies that there is synchronization on the device side after the kernel execution, ensuring that all operations are completed before proceeding.
-
-Overall, this code is used for executing a parallel reduction operation across multiple GPUs in a coordinated manner.
-
-
-```
-const char* isaopts[] = {"-mllvm", "-inline-threshold=1", "-mllvm", "-inlinehint-
---threshold=1"};
-std::vector<hiprtcJIT_option> jit_options = {HIPRTC_JIT_IR_TO_ISA_OPT_EXT,
-                                                                                                                                                                                                         HIPRTC_JIT_IR_TO_ISA_OPT_COUNT_EXT};
-size_t isaoptssize = 4;
-                                                                                                                                                                                                       (continues on next page)
-```
-**Following code does:** The code snippet `<_C_>` appears to be a placeholder or a non-functional piece of code. It does not represent any valid Python syntax or operation. It might be used as a marker or a template in a larger codebase where actual code is intended to be inserted later.
-
-
-```
-        const void* lopts[] = {(void*)isaopts, (void*)(isaoptssize)};
-        hiprtcLinkState linkstate;
-        hiprtcLinkCreate(2, jit_options.data(), (void**)lopts, &linkstate);
-```
-
-## 10.4 Error Handling
-
-HIPRTC defines the hiprtcResult enumeration type and a function hiprtcGetErrorString for API call error handling. hiprtcResult enum defines the API result codes. HIPRTC APIs return hiprtcResult to indicate the call result. hiprtcGetErrorString function returns a string describing the given hiprtcResult code, e.g., HIPRTC\_SUCCESS to 'HIPRTC\_SUCCESS'. For unrecognized enumeration values, it returns 'Invalid HIPRTC error code'.
-
-hiprtcResult enum supported values and the hiprtcGetErrorString usage are mentioned below.
-**Following code does:** The code snippet `<_Cython_>` appears to be a placeholder or a reference to Cython, which is a programming language that makes writing C extensions for Python as easy as Python itself. Cython is used to improve the performance of Python code by compiling it into C, which can then be executed more efficiently. However, the snippet itself does not contain any executable code or functionality; it simply seems to indicate the use of Cython in some context. Without additional context or code, it does not perform any specific action.
-
-
-```
-<_Python_>
-```
-**Following code does:** The code snippet appears to be incomplete or malformed, as it starts with an assignment operator (`=`) without a variable on the left-hand side. However, the part `this._grid()` suggests that it is calling a method named `_grid` on an object referred to by `this`. In a complete and correctly formatted context, this line would typically assign the result of the `_grid()` method to a variable. The purpose of the `_grid()` method would depend on its implementation, but it likely relates to some grid-related functionality within the object.
-
-
-```
-hiprtcResult result;
-result = hiprtcCompileProgram(prog, 1, opts);
-if (result!= HIPRTC_SUCCESS) {
-std::cout << "hiprtcCompileProgram fails with error " << hiprtcGetErrorString(result);
-}
-```
-
-## 10.5 HIPRTC General APIs
-
-HIPRTC provides the following API for querying the version.
-
-hiprtcVersion(int* major, int* minor) - This sets the output parameters major and minor with the HIP Runtime compilation major version and minor version number respectively.
-
-Currently, it returns hardcoded value. This should be implemented to return HIP runtime major and minor version in the future releases.
-
-(continued from previous page)
-
-## 10.6 Lowered Names (Mangled Names)
-
-HIPRTC mangles the \_\_global\_\_ function names and names of \_\_device\_\_ and \_\_constant\_\_ variables. If the generated binary is being loaded using the HIP Runtime API, the kernel function or \_\_device\_\_/\_\_constant\_\_ variable must be looked up by name, but this is very hard when the name has been mangled. To overcome this, HIPRTC provides API functions that map \_\_global\_\_ function or \_\_device\_\_/\_\_constant\_\_ variable names in the source to the mangled names present in the generated binary.
-
-The two APIs hiprtcAddNameExpression and hiprtcGetLoweredName provide this functionality. First, a 'name expression' string denoting the address for the \_\_global\_\_ function or \_\_device\_\_/\_\_constant\_\_ variable is provided to hiprtcAddNameExpression . Then, the program is compiled with hiprtcCompileProgram . During compilation, HIPRTC will parse the name expression string as a C++ constant expression at the end of the user program. Finally, the function hiprtcGetLoweredName is called with the original name expression and it returns a pointer to the lowered name. The lowered name can be used to refer to the kernel or variable in the HIP Runtime API.
-
-## 10.6.1 Note
-
-- The identical name expression string must be provided on a subsequent call to hiprtcGetLoweredName to extract the lowered name.
-- The correct sequence of calls is : hiprtcAddNameExpression , hiprtcCompileProgram , hiprtcGetLoweredName , hiprtcDestroyProgram .
-- The lowered names must be fetched using hiprtcGetLoweredName only after the HIPRTC program has been compiled, and before it has been destroyed.
-
-## 10.6.2 Example
-
-kernel containing various definitions \_\_global\_\_ functions/function templates and \_\_device\_\_/\_\_constant\_\_ variables can be stored in a string.
-**Following code does:** This code snippet appears to be part of a larger codebase, likely written in a language that supports object-oriented programming, such as C++ or a similar language. The line of code is performing the following high-level operation:
-
-- It declares a variable named `multi_grid` of type `multi_grid_group`.
-- It initializes this variable by calling a function or method named `this_multi_grid()`, which presumably returns an object or value of type `multi_grid_group`.
-
-The purpose of this line is to create an instance of `multi_grid_group` and assign it to the variable `multi_grid`, using the result from `this_multi_grid()`. This suggests that `this_multi_grid()` is a function that provides or constructs a `multi_grid_group` object, possibly representing a grid or a collection of grids in a multi-grid system.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-        static constexpr const char gpu_program[] {
-```
-
-hiprtcAddNameExpression is called with various name expressions referring to the address of \_\_global\_\_ functions and \_\_device\_\_/\_\_constant\_\_ variables.
-**Following code does:** This code snippet appears to be a method call on an object or module named `multi_grid`. The method `sync()` is likely intended to synchronize or coordinate data or processes across multiple grids or components within a system. This could involve ensuring that all parts of a distributed system are updated to the same state or that parallel computations are aligned. The exact functionality would depend on the implementation details of the `multi_grid` object and its `sync()` method.
-
-
-```
-kernel_name_vec.push_back("&f1");
-kernel_name_vec.push_back("N1::N2::f2");
-kernel_name_vec.push_back("f3<int>");
-for (auto&& x : kernel_name_vec) hiprtcAddNameExpression(prog, x.c_str());
-variable_name_vec.push_back("&V1");
-```
-
-(continues on next page)
-
-(continued from previous page)
-**Following code does:** This code is a C++ program that uses the HIP (Heterogeneous-Compute Interface for Portability) runtime API to check if the current GPU device supports concurrent managed memory access. It retrieves the current GPU device, checks the `hipDeviceAttributeConcurrentManagedAccess` attribute, and then prints a message to the console indicating whether concurrent managed memory access is supported by the device.
-
-
-```
-auto&& x : variable_name_vec) hiprtcAddNameExpression(prog, x.c_str());
-```
-**Following code does:** The code snippet provided appears to be mostly empty space with some scattered characters, including slashes and curly braces, which are typically used in programming languages like C, C++, or Java for comments and code blocks. However, the snippet does not contain any functional code or meaningful structure. It seems to be either incomplete or corrupted, and thus does not perform any specific operation or serve a high-level purpose.
-
-
-```
-        | variable_name_vec.push_back("&N1::N2::V2");
-        for (auto&& x : variable_name_vec) hiprtcAddNameExp
-```
-
-After which, the program is compiled using hiprtcCompileProgram and the generated binary is loaded using hipModuleLoadData . And the mangled names can be fetched using hirtcGetLoweredName .
-**Following code does:** This code is a simple GPU program using HIP (Heterogeneous-Compute Interface for Portability) to perform the addition of two integers on a GPU. It defines a kernel function `add` that takes pointers to three integers and computes the sum of the first two, storing the result in the third. The variables `a`, `b`, and `c` are declared as managed memory, allowing them to be accessed by both the host (CPU) and the device (GPU). The `main` function initializes `a` and `b` with values 1 and 2, respectively, and then launches the `add` kernel on the GPU. After ensuring the GPU computation is complete with `hipDeviceSynchronize`, it prints the result of the addition. The code demonstrates basic GPU computation and memory management using HIP.
-
-
-```
-for (decltype(variable_name_vec.size()) i = 0; i!= variable_name_vec.size(); ++i) {
-  const char* name;
-  hiprtcGetLoweredName(prog, variable_name_vec[i].c_str(), &name);
-}
-```
-**Following code does:** This code snippet is a partial implementation of a program using HIP (Heterogeneous-Compute Interface for Portability) to perform addition on a GPU. It defines a simple CUDA kernel function `add` that takes pointers to three integers and assigns the sum of the first two integers to the third. In the `main` function, memory is allocated on the host for three integer pointers `a`, `b`, and `c`, and initial values are assigned to `a` and `b`. The code is incomplete as it does not include the necessary steps to allocate memory on the GPU, copy data to the GPU, launch the kernel, or retrieve the result from the GPU.
-
-
-```
-    for (decltype(kernel_name_vec.size()) i = 0; i!= kernel_name_vec.size(); ++i) {
-      const char* name;
-      hiprtcGetLoweredName(prog, kernel_name_vec[i].c_str(), &name);
-    }
-```
-
-The mangled name of the variables are used to look up the variable in the module and update its value.
-**Following code does:** This code snippet is part of a program that performs a simple addition operation on a GPU using the HIP (Heterogeneous-Compute Interface for Portability) API. It launches a kernel function named `add` on the GPU with a single thread block and a single thread. After the kernel execution, it synchronizes the device to ensure the GPU has finished processing before accessing the results on the host. The result of the addition is then printed to the console. Finally, it frees the allocated memory for the variables `a`, `b`, and `c` before the program terminates.
-
-
-```
-        hipDeviceptr_t variable_addr;
-        size_t bytes{};
-        hipModuleGetGlobal(&variable_addr, &bytes, module, name);
-        hipMemcpyHtoD(variable_addr, &initial_value, sizeof(initial_value));
-```
-
-Finally, the mangled name of the kernel is used to launch it using the hipModule APIs.
-**Following code does:** This code snippet is a simple example of using HIP (Heterogeneous-Compute Interface for Portability) to perform addition on a GPU. It demonstrates explicit memory management in a GPU programming context. The code allocates memory on the GPU for three integers, copies two input values from the host (CPU) to the GPU, and then launches a kernel function `add` on the GPU to compute the sum of these two values. The result is then copied back from the GPU to the host. This example illustrates basic GPU programming concepts such as memory allocation, data transfer between host and device, and kernel execution.
-
-
-```
-        hipFunction_t kernel;
-        hipModuleGetFunction(&kernel, module, name);
-        hipModuleLaunchKernel(kernel, 1, 1, 1, 1, 1, 0, nullptr, nullptr, config);
-```
-
-Please have a look at hiprtcGetLoweredName.cpp for the detailed example.
-
-## 10.7 Versioning
-
-HIPRTC follows the below versioning.
-
-- Linux
-- -HIPRTC follows the same versioning as HIP runtime library.
-- -The so name field for the shared library is set to MAJOR version. For example, for HIP 5.3 the so name is set to 5 ( hiprtc.so.5 ).
-- Windows
-- -HIPRTC dll is named as hiprtcXXYY.dll where XX is MAJOR version and YY is MINOR version. For example, for HIP 5.3 the name is hiprtc0503.dll .
-
-## 10.8 HIP header support
-
-- Added HIPRTC support for all the hip common header files such as library\_types.h, hip\_math\_constants.h, hip\_complex.h, math\_functions.h, surface\_types.h etc. from 6.1. HIPRTC users need not include any HIP macros or constants explicitly in their header files. All of these should get included via HIPRTC builtins when the app links to HIPRTC library.
-
-## 10.9 Deprecation notice
-
-- Currently HIPRTC APIs are separated from HIP APIs and HIPRTC is available as a separate library libhiprtc. so / libhiprtc.dll . But on Linux, HIPRTC symbols are also present in libamdhip64.so in order to support the existing applications. Gradually, these symbols will be removed from HIP library and applications using HIPRTC will be required to explicitly link to HIPRTC library. However, on Windows hiprtc.dll must be used as the amdhip64.dll doesn't contain the HIPRTC symbols.
-- Data types such as uint32\_t , uint64\_t , int32\_t , int64\_t defined in std namespace in HIPRTC are deprecated earlier and are being removed from ROCm release 6.1 since these can conflict with the standard C++ data types. These data types are now prefixed with \_\_hip\_\_ , e.g. \_\_hip\_uint32\_t . Applications previously using std::uint32\_t or similar types can use \_\_hip\_ prefixed types to avoid conflicts with standard std namespace or application can have their own definitions for these types. Also, type\_traits templates previously defined in std namespace are moved to \_\_hip\_internal namespace as implementation details.
-
-## CHAPTER
-
-## ELEVEN
-
-## PERFORMANCE GUIDELINES
-
-The AMDHIPPerformance Guidelines are a set of best practices designed to help developers optimize the performance of AMD GPUs. They cover established parallelization and optimization techniques, coding metaphors, and idioms that can greatly simplify programming for HIP-capable GPU architectures.
-
-By following four main cornerstones, we can exploit the performance optimization potential of HIP.
-
-- parallel execution
-- memory usage optimization
-- optimization for maximum throughput
-- minimizing memory thrashing
-
-In the following chapters, we will show you their benefits and how to use them effectively.
-
-## 11.1 Parallel execution
-
-For optimal use, the application should reveal and efficiently imply as much parallelism as possible to keep all system components active.
-
-## 11.1.1 Application level
-
-The application should optimize parallel execution across the host and devices using asynchronous calls and streams. Workloads should be assigned based on efficiency: serial to the host, parallel to the devices.
-
-For parallel workloads, when threads need to synchronize to share data, if they belong to the same block, they should use \_\_syncthreads() (see: Synchronization functions ) within the same kernel invocation. If they belong to different blocks, they must use global memory with two separate kernel invocations. The latter should be minimized as it adds overhead.
-
-## 11.1.2 Device level
-
-Device-level optimization primarily involves maximizing parallel execution across the multiprocessors of the device. This can be achieved by executing multiple kernels concurrently on a device. The management of these kernels is facilitated by streams, which allow for the overlapping of computation and data transfers, enhancing performance. The aim is to keep all multiprocessors busy by executing enough kernels concurrently. However, launching too many kernels can lead to resource contention, so a balance must be found for optimal performance. This approach helps in achieving maximum utilization of the resources of the device.
-
-## 11.1.3 Multiprocessor level
-
-Multiprocessor-level optimization involves maximizing parallel execution within each multiprocessor on a device. Each multiprocessor can execute a number of threads concurrently, and the total number of threads that can run in parallel is determined by the number of concurrent threads each multiprocessor can handle.
-
-The key to multiprocessor-level optimization is to efficiently utilize the various functional units within a multiprocessor. This can be achieved by ensuring a sufficient number of resident warps, as at every instruction issue time, a warp scheduler selects an instruction that is ready to execute. This instruction can be another independent instruction of the same warp, exploiting Optimization for maximum instruction throughput , or more commonly an instruction of another warp, exploiting thread-level parallelism.
-
-In comparison, device-level optimization focuses on the device as a whole, aiming to keep all multiprocessors busy by executing enough kernels concurrently. Both levels of optimization are crucial for achieving maximum performance. They work together to ensure efficient utilization of the resources of the GPU, from the individual multiprocessors to the device as a whole.
-
-## 11.2 Memory optimization
-
-The first step in maximizing memory throughput is to minimize low-bandwidth data transfers. This involves reducing data transfers between the host and the device, as these have lower bandwidth than transfers between global memory and the device.
-
-Additionally, data transfers between global memory and the device should be minimized by maximizing the use of on-chip memory: shared memory and caches. Shared memory acts as a user-managed cache, where the application explicitly allocates and accesses it. A common programming pattern is to stage data from device memory into shared memory. This involves each thread of a block loading data from device memory to shared memory, synchronizing with all other threads of the block, processing the data in shared memory, synchronizing again if necessary, and writing the results back to device global memory.
-
-For some applications, a traditional hardware-managed cache is more appropriate to exploit data locality. On devices of certain compute capabilities, the same on-chip memory is used for both L1 and shared memory, and the amount dedicated to each is configurable for each kernel call.
-
-Finally, the throughput of memory accesses by a kernel can vary significantly depending on the access pattern for each type of memory. Therefore, the next step in maximizing memory throughput is to organize memory accesses as optimally as possible. This is especially important for global memory accesses, as global memory bandwidth is low compared to available on-chip bandwidths and arithmetic instruction throughput. Thus, non-optimal global memory accesses generally have a high impact on performance.
-
-## 11.2.1 Data Transfer
-
-Applications should aim to minimize data transfers between the host and the device. This can be achieved by moving more computations from the host to the device, even if it means running kernels that do not fully utilize the parallelism for device. Intermediate data structures can be created, used, and discarded in device memory without being mapped or copied to host memory.
-
-Batching small transfers into a single large transfer can improve performance due to the overhead associated with each transfer. On systems with a front-side bus, using page-locked host memory can enhance data transfer performance.
-
-When using mapped page-locked memory, there is no need to allocate device memory or explicitly copy data between device and host memory. Data transfers occur implicitly each time the kernel accesses the mapped memory. For optimal performance, these memory accesses should be coalesced, similar to global memory accesses.
-
-On integrated systems where device and host memory are physically the same, any copy operation between host and device memory is unnecessary, and mapped page-locked memory should be used instead. Applications can check if a device is integrated by querying the integrated device property.
-
-## 11.2.2 Device Memory Access
-
-Memory access instructions may be repeated due to the spread of memory addresses across warp threads. The impact on throughput varies with memory type and is generally reduced when addresses are more scattered, especially in global memory.
-
-Device memory is accessed via 32-, 64-, or 128-byte transactions that must be naturally aligned. Maximizing memory throughput involves coalescing memory accesses of threads within a warp into minimal transactions, following optimal access patterns, using properly sized and aligned data types, and padding data when necessary.
-
-Global memory instructions support reading or writing data of specific sizes (1, 2, 4, 8, or 16 bytes) that are naturally aligned. If the size and alignment requirements are not met, it leads to multiple instructions, reducing performance. Therefore, using data types that meet these requirements, ensuring alignment for structures, and maintaining alignment for all values or arrays is crucial for correct results and optimal performance.
-
-Threads often access 2D arrays at an address calculated as BaseAddress + xIndex + width * yIndex . For efficient memory access, the array and thread block widths should be multiples of the warp size. If the array width is not a multiple of the warp size, it is usually more efficient to allocate it with a width rounded up to the nearest multiple and pad the rows accordingly.
-
-Local memory is used for certain automatic variables, such as arrays with non-constant indices, large structures or arrays, and any variable when the kernel uses more registers than available. Local memory resides in device memory, leading to high latency and low bandwidth similar to global memory accesses. However, it is organized for consecutive 32-bit words to be accessed by consecutive thread IDs, allowing full coalescing when all threads in a warp access the same relative address.
-
-Shared memory, located on-chip, provides higher bandwidth and lower latency than local or global memory. It is divided into banks that can be simultaneously accessed, boosting bandwidth. However, bank conflicts, where two addresses fall in the same bank, lead to serialized access and decreased throughput. Therefore, understanding how memory addresses map to banks and scheduling requests to minimize conflicts is crucial for optimal performance.
-
-Constant memory is in device memory and cached in the constant cache. Requests are split based on different memory addresses, affecting throughput, and are serviced at the throughput of the constant cache for cache hits, or the throughput of the device memory otherwise.
-
-Texture and surface memory are stored in device memory and cached in texture cache. This setup optimizes 2D spatial locality, leading to better performance for threads reading close 2D addresses. Reading device memory through texture or surface fetching can be advantageous, offering higher bandwidth for local texture fetches or surface reads, offloading addressing calculations, allowing data broadcasting, and optional conversion of 8-bit and 16-bit integer input data to 32-bit floating-point values on-the-fly.
-
-## 11.3 Optimization for maximum instruction throughput
-
-To maximize instruction throughput:
-
-- minimize low throughput arithmetic instructions
-- minimize divergent warps inflicted by control flow instructions
-- minimize the number of instruction as possible
-- maximize instruction parallelism
-
-## 11.3.1 Arithmetic instructions
-
-The type and complexity of arithmetic operations can significantly impact the performance of your application. We are highlighting some hints how to maximize it.
-
-Using efficient operations: Some arithmetic operations are more costly than others. For example, multiplication is typically faster than division, and integer operations are usually faster than floating-point operations, especially with double-precision.
-
-Minimizing low-throughput instructions: This might involve trading precision for speed when it does not affect the final result. For instance, consider using single-precision arithmetic instead of double-precision.
-
-Leverage intrinsic functions: Intrinsic functions are pre-defined functions available in HIP that can often be executed faster than equivalent arithmetic operations (subject to some input or accuracy restrictions). They can help optimize performance by replacing more complex arithmetic operations.
-
-Avoiding divergent warps: Divergent warps occur when threads within the same warp follow different execution paths. This can happen due to conditional statements that lead to different arithmetic operations being performed by different threads. Divergent warps can significantly reduce instruction throughput, so try to structure your code to minimize divergence.
-
-Optimizing memory access: The efficiency of memory access can impact the speed of arithmetic operations. Coalesced memory access, where threads in a warp access consecutive memory locations, can improve memory throughput and thus the speed of arithmetic operations.
-
-Maximizing instruction parallelism: Some GPU architectures could issue parallel independent instructions simultaneously, for example integer and floating point, or two operations with independent inputs and outputs. Mostly this is a work for compiler, but expressing parallelism in the code explicitly can improve instructions throughput.
-
-## 11.3.2 Control flow instructions
-
-Flow control instructions ( if , else , for , do , while , break , continue , switch ) can impact instruction throughput by causing threads within a warp to diverge and follow different execution paths. To optimize performance, control conditions should be written to minimize divergent warps. For example, when the control condition depends on ( threadIdx / warpSize ), no warp diverges. The compiler may optimize loops or short if or switch blocks using branch predication, preventing warp divergence. With branch predication, instructions associated with a false predicate are scheduled but not executed, avoiding unnecessary operations.
-
-## 11.3.3 Synchronization
-
-Synchronization ensures that all threads within a block have completed their computations and memory accesses before moving forward, which is critical when threads are dependent on the results of other threads. However, synchronization can also lead to performance overhead, as it requires threads to wait, potentially leading to idle GPU resources.
-
-\_\_syncthreads() is used to synchronize all threads in a block, ensuring that all threads have reached the same point in the code and that shared memory is visible to all threads after the point of synchronization.
-
-An alternative way to synchronize is using streams. Different streams can execute commands out of order with respect to one another or concurrently. This allows for more fine-grained control over the execution order of commands, which can be beneficial in certain scenarios.
-
-## 11.4 Minimizing memory thrashing
-
-Applications frequently allocating and freeing memory may experience slower allocation calls over time. This is expected as memory is released back to the operating system. To optimize performance in such scenarios, consider some recommendations:
-
-- avoid allocating all available memory with hipMalloc / hipHostMalloc , as this immediately reserves memory and can block other applications from using it. This could strain the operating system schedulers or even prevent other applications from running on the same GPU.
-- aim to allocate memory in suitably sized blocks early in the lifecycle of the application and deallocate only when the application no longer needs it. Minimize the number of hipMalloc and hipFree calls in your application, particularly in areas critical to performance.
-- if an application is unable to allocate sufficient device memory, consider resorting to other memory types such as hipHostMalloc or hipMallocManaged . While these may not offer the same performance, they can allow the application to continue running.
-- For supported platforms, hipMallocManaged allows for oversubscription. With the right memory advise policies, it can maintain most, if not all, of the performance of hipMalloc . hipMallocManaged does not require an allocation to be resident until it is needed or prefetched, easing the load on the operating system schedulers and facilitating multi-tenant scenarios.
-
-CHAPTER
-
-## TWELVE
-
-## DEBUGGING WITH HIP
-
-AMDdebugging tools include ltrace and ROCgdb . External tools are available and can be found online. For example, if you're using Windows, you can use Microsoft Visual Studio and WinGDB .
-
-You can trace and debug your code using the following tools and techniques.
-
-## 12.1 Tracing
-
-You can use tracing to quickly observe the flow of an application before reviewing the detailed information provided by a command-line debugger. Tracing can be used to identify issues ranging from accidental API calls to calls made on a critical path.
-
-ltrace is a standard Linux tool that provides a message to stderr on every dynamic library call. You can use ltrace to visualize the runtime behavior of the entire ROCm software stack.
-
-Here's a simple command-line example that uses ltrace to trace HIP APIs and output:
-**Following code does:** This code snippet is part of a larger program that uses HIP, a C++ runtime API for GPU programming. The snippet performs two main tasks: 
-
-1. It frees up memory that was previously allocated on the GPU for three variables (`d_a`, `d_b`, and `d_c`) using the `hipFree` function. This is a cleanup operation to release resources and prevent memory leaks.
-
-2. It prints the result of an addition operation to the console, displaying the values of `a`, `b`, and their sum `c` in the format "a + b = c".
-
-Finally, the function returns 0, indicating successful execution.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?php?^"./hipGetChanDesc
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        </?php?^"
-	                                                                                                                                                                                                     
-		                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       <!
-                                                                                                                                                                                                      
-
-	                                                                                                                                                                                                       <%
-                                                                                                                                                                                                       </%
-                                                                                                                                                                                                      <?>
-                                                                                                                                                                                                       >
-```
-
-Here's another example that uses ltrace to trace hsa APIs and output:
-**Following code does:** This code snippet appears to be a collection of comments and symbols that do not form a valid or functional piece of code. It seems to be a mix of comment syntax from different programming languages (e.g., `//`, `/* ... */`) and other characters, but it does not perform any operations or have any executable logic. It might be a placeholder or an artifact from code formatting or editing.
-
-
-```
-        Here's another example that uses ltrace to trace hsa APIs and output:
-        $ ltrace  -C -e "hsa*"./hipGetChanDesc
-        libamdhip64.so.4->hsa_init(0, 0x7fff325a69d0, 0x9c80e0, 0 <unfinished...>
-        libhsa-runtime64.so.1->hsaKmtOpenKFD(0x7fff325a6590, 0x9c38c0, 0, 1) = 0
-        libhsa-runtime64.so.1->hsaKmtGetVersion(0x7fff325a6608, 0, 0, 0) = 0
-        libhsa-runtime64.so.1->hsaKmtReleaseSystemProperties(3, 0x80084b01, 0, 0) = 0
-        libhsa-runtime64.so.1->hsaKmtAcquireSystemProperties(0x7fff325a6610, 0, 0, 1) = 0
-        libhsa-runtime64.so.1->hsaKmtGetNodeProperties(0, 0x7fff325a66a0, 0, 0) = 0
-        libhsa-runtime64.so.1->hsaKmtGetNodeMemoryProperties(0, 1, 0x9c42b0, 0x936012) = 0
-       ...
-        <... hsaKmtCreateEvent  resumed> )                                                                                                                                                                                                        
-        libhsa-runtime64.so.1->hsaKmtAllocMemory(0, 4096, 64, 0x7fff325a6690) = 0
-        libhsa-runtime64.so.1->hsaKmtMapMemoryToGPUNodes(0x7f1202749000, 4096, 0x7fff325a6690,,...
-        --0) = 0
-        libhsa-runtime64.so.1->hsaKmtCreateEvent(0x7fff325a6700, 0, 0, 0x7fff325a66f0) = 0
-                                                                                                                                                                                                        (continues on next page)
-```
-
-(continues on next page)
-
-(continued from previous page)
-**Following code does:** This code snippet demonstrates a simple GPU-accelerated program using HIP (Heterogeneous-Compute Interface for Portability) to perform the addition of two integers. It allocates managed memory for three integers (`a`, `b`, and `c`) that can be accessed by both the CPU and GPU. The program sets memory advice to optimize data placement and access patterns, indicating that the memory should be preferred for CPU access and read mostly from the GPU. It initializes the values of `a` and `b`, launches a GPU kernel to compute their sum, synchronizes the device to ensure computation is complete, and then prints the result. Finally, it frees the allocated memory. The use of `hipMemAdvise` helps optimize performance by guiding the runtime on how to handle memory access efficiently.
-
-
-```
-HIP Documentation, Release 6.1.40092
-```
-
-## 12.2 Debugging
-
-You can use ROCgdb for debugging and profiling.
-
-ROCgdbis the ROCm source-level debugger for Linux and is based on GNU Project debugger (GDB). the GNU sourcelevel debugger, equivalent of CUDA-GDB, can be used with debugger frontends, such as Eclipse, Visual Studio Code, or GDB dashboard. For details, see (https://github.com/ROCm/ROCgdb).
-
-Below is a sample how to use ROCgdb run and debug HIP application, ROCgdb is installed with ROCM package in the folder /opt/rocm/bin.
-**Following code does:** This code snippet is part of a larger program that uses the HIP (Heterogeneous-Compute Interface for Portability) API, which is designed for GPU programming. The specific lines shown here are responsible for freeing or deallocating memory that was previously allocated on the GPU for the variables `b` and `c`. This is done using the `hipFree` function, which releases the memory resources associated with these variables. The `return 0;` statement indicates that the program is terminating successfully. Overall, this snippet is part of the cleanup process in a GPU-accelerated application.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <p>
-                                                                                                                                                                                                       <h1>
-                                                                                                                                                                                                      <p/>
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        </p>
-                                                                                                                                                                                                     <p>
-
-                                                                                                                                                                                                       <a>
-                                                                                                                                                                                                     
- 	                                                                                                                                                                                                       <b>
-                                                                                                                                                                                                      </a>
-                                                                                                                                                                                                     <a>
-
-                                                                                                                                                                                                      <b/>
-                                                                                                                                                                                                      <a/>
-                                                                                                                                                                                                     
-		                                                                                                                                                                                                      
-
-	                                                                                                                                                                                                      <a></b>
-```
-
-## 12.2.1 Debugging HIP applications
-
-The following Linux example shows how to get useful information from the debugger while running a simple memory copy test, which caused a segmentation fault issue.
-**Following code does:** This code snippet demonstrates a simple example of using HIP (Heterogeneous-Compute Interface for Portability) to perform a basic addition operation on a GPU. It allocates managed memory for three integers (`a`, `b`, and `c`) that can be accessed by both the host (CPU) and the device (GPU). The `add` kernel function is launched on the GPU to compute the sum of `a` and `b`, storing the result in `c`. After synchronizing the device to ensure the computation is complete, the code queries a memory range attribute (`hipMemRangeAttributeReadMostly`) for the memory range pointed to by `a` and stores the result in `attributeValue`. Finally, it prints the result of the addition. The code illustrates basic memory management and kernel execution in a HIP environment.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <p>test, which caused a segmentation fault issue.                                                                                                                                                                                                        </p>                                                                                                                                                                                                        >
-                                                                                                                                                                                                       <a>http://tests/src/runtimeApi/memory/hipMemcpy_simple.cpp:147
-```
-
-(continues on next page)
-
-(continued from previous page)
-**Following code does:** This code snippet is part of a C++ program that outputs the value of a queried attribute to the console. After displaying the attribute value, it performs cleanup by freeing memory that was previously allocated for three variables (`a`, `b`, and `c`) using the `hipFree` function, which is typically used in programs that utilize HIP (Heterogeneous-Compute Interface for Portability) for managing GPU memory. Finally, the program returns 0, indicating successful execution.
-
-
-```
-HIP Documentation, Release 6.1.40092
-
-
-                                                                                                                                                                                                         (continued from previous page)                                                                                                                                                                                                       
-                                                                                                                                                                                                      
-1                                                                                                                                                                                                        "                                                                                                                                                                                                        <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        </----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                    <-----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        >----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                   
-1   //                                                                                                                                                                                                        :                                                                                                                                                                                                        |                                                                                                                                                                                                        -                                                                                                                                                                                                        +                                                                                                                                                                                                        \
-                                                                                                                                                                                                       |
-                                                                                                                                                                                                       <============================================================================================                                                                                                                                                                                                        }                                                                                                                                                                                                        )
-```
-
-Debugging HIP applications using Windows tools can be more informative than on Linux. Windows tools provides more visibility into debug codes, which makes it easier to inspect variables, watch multiple details, and examine call stacks.
-
-## 12.3 Useful environment variables
-
-HIP provides environment variables that allow HIP, hip-clang, or HSA drivers to prevent certain features and optimizations. These are not intended for production, but can be useful to diagnose synchronization problems in the application (or driver).
-
-Some of the more widely used environment variables are described in this section. These are supported on the Linux ROCm path and Windows.
-
-## 12.3.1 Kernel enqueue serialization
-
-You can control kernel command serialization from the host:
-
-## AMD\_SERIALIZE\_KERNEL , for serializing kernel enqueue
-
-AMD\_SERIALIZE\_KERNEL = 1 , Wait for completion before enqueue AMD\_SERIALIZE\_KERNEL = 2 , Wait for completion after enqueue AMD\_SERIALIZE\_KERNEL = 3 , Both
-
-Or
-
-## AMD\_SERIALIZE\_COPY , for serializing copies
-
-AMD\_SERIALIZE\_COPY = 1 , Wait for completion before enqueue AMD\_SERIALIZE\_COPY = 2 , Wait for completion after enqueue AMD\_SERIALIZE\_COPY = 3 , Both
-
-So HIP runtime can wait for GPU idle before/after any GPU command depending on the environment setting.
-
-## 12.3.2 Making device visible
-
-For systems with multiple devices, you can choose to make only certain device(s) visible to HIP using HIP\_VISIBLE\_DEVICES (or CUDA\_VISIBLE\_DEVICES on an NVIDIA platform). Once enabled, HIP can only view devices that have indices present in the sequence. For example:
-**Following code does:** The code snippet `<_C_>` appears to be a placeholder or a non-functional piece of code. It does not represent any valid Python syntax or operation. It might be intended as a marker or a template for where actual code should be inserted.
-
-
-```
-    | $ HIP_VISIBLE_DEVICES=0,1
-```
-**Following code does:** The code snippet `0) ;` is not valid Python code. It appears to be a fragment or typo, as it does not form a complete or meaningful statement in Python.
-
-
-```
-<_Python_>
-```
-**Following code does:** It seems there is a formatting error in your request. The code snippet is labeled as Python, but the content is marked as C++. Please provide the correct code snippet or clarify the language so I can assist you accurately.
-
-
-```
-if (totalDeviceNum > 2) {
-setenv("HIP_VISIBLE_DEVICES", "0,1,2", 1);
-assert(getDeviceNumber(false) == 3);
-
-.......
-}
-```
-
-## 12.3.3 Dump code object
-
-To analyze compiler-related issues, you can use the dump code object: GPU\_DUMP\_CODE\_OBJECT .
-
-## 12.3.4 HSA-related environment variables (Linux)
-
-HSA provides environment variables that help analyze issues in drivers or hardware.
-
-- To isolate issues with hardware copy engines, you can use HSA\_ENABLE\_SDMA .
-- HSA\_ENABLE\_SDMA=0 causes host-to-device and device-to-host copies to use compute shader blit kernels, rather than the dedicated DMA copy engines. Compute shader copies have low latency (typically &lt; 5 us) and can achieve approximately 80% of the bandwidth of the DMA copy engine.
-- To diagnose interrupt storm issues in the driver, you can use HSA\_ENABLE\_INTERRUPT .
-
-HSA\_ENABLE\_INTERRUPT=0 causes completion signals to be detected with memory-based polling, rather than interrupts.
-
-## 12.3.5 HIP environment variable summary
-
-Here are some of the more commonly used environment variables:
-
-| Environment variable                                                                                                          | De- fault value   | Usage                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-|-------------------------------------------------------------------------------------------------------------------------------|-------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| AMD_LOG_LEVEL Enable HIP log on different Level                                                                               | 0                 | 0: Disable log. 1: Enable log on error level 2: Enable log on warning and below levels 0x3: Enable log on information and below levels 0x4: Decode and display AQL packets                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-| AMD_LOG_MASK Enable HIP log on different Level                                                                                |                   | 0x7FFFFFFF 0x1: Log API calls 0x02: Kernel and Copy Commands and Barriers 0x4: Synchroniza- tion and waiting for commands to finish 0x8: Enable log on information and below levels 0x20: Queue commands and queue contents 0x40: Signal creation, allocation, pool 0x80: Locks and thread-safety code 0x100: Copy debug 0x200: Detailed copy debug 0x400: Resource allocation, performance-impacting events 0x800: Initialization and shutdown 0x1000: Misc debug, not yet classified 0x2000: Show raw bytes of AQL packet 0x4000: Show code creation debug 0x8000: More detailed command info, including barrier com- mands 0x10000: Log message location 0xFFFFFFFF: Log always even mask flag is zero |
-| HIP_LAUNCH_BLOCKING Used for serial- ization on kernel execution.                                                             | 0                 | 0: Disable. Kernel executes normally. 1: Enable. Serializes kernel enqueue, behaves the same as AMD_SERIALIZE_KERNEL.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| HIP_VISIBLE_DEVICES (or CUDA_VISIBLE_DEVICES) Only devices whose index is present in the sequence are visible to HIP          |                   | 0,1,2: Depending on the number of devices on the system                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| GPU_DUMP_CODE_OBJECT Dump code ob- ject                                                                                       | 0                 | 0: Disable 1: Enable                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| AMD_SERIALIZE_KERNEL Serialize kernel enqueue                                                                                 | 0                 | 1: Wait for completion before enqueue 2: Wait for completion after enqueue 3: Both                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
-| AMD_SERIALIZE_COPY Serialize copies                                                                                           | 0                 | 1: Wait for completion before enqueue 2: Wait for completion after enqueue 3: Both                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
-| HIP_HOST_COHERENT Coherent mem-                                                                                               | 0                 | 0: memory is not coherent between host and GPU 1: memory is coherent with host                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
-| ory in hipHost- Malloc AMD_DIRECT_DISPATCH Enable direct kernel dispatch (Currently for Linux; under development for Windows) | 1                 | 0: Disable 1: Enable                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| GPU_MAX_HW_QUEUES The maximum number of hard- ware queues allocated per device                                                | 4                 | The variable controls how many independent hardware queues HIP runtime can create per process, per device. If an application allocates more HIP streams than this number, then HIP runtime reuses the same hardware queues for the new streams in a round-robin manner. Note that this maximum number does not apply to hardware queues that are created for CU-masked HIP streams, or cooperative queues for HIP Cooperative Groups (single queue per device).                                                                                                                                                                                                                                           |
-
-## 12.4 General debugging tips
-
-- gdb --args can be used to pass the executable and arguments to gdb .
-- You can set environment variables ( set env ) from within GDB on Linux:
-**Following code does:** This code snippet is configuring memory access permissions for a specific memory region in a HIP (Heterogeneous-Compute Interface for Portability) application, which is used for GPU programming. It sets up a `hipMemAccessDesc` structure to specify that a memory region, identified by `ptr` and of size `padded_size`, should be accessible for both reading and writing on a specific GPU device (`currentDev`). The `hipMemSetAccess` function is then called to apply these access permissions.
-
-
-```
-        | (gdb)  set env  AND_SERIALIZE_KERNEL  3
-```
-
-Note: This gdb command does not use an equal (=) sign.
-
-- The GDB backtrace shows a path in the runtime. This is because a fault is caught by the runtime, but it is generated by an asynchronous command running on the GPU.
-- To determine the true location of a fault, you can force the kernels to run synchronously by setting the environment variables AMD\_SERIALIZE\_KERNEL=3 and AMD\_SERIALIZE\_COPY=3 . This forces HIP runtime to wait for the kernel to finish running before returning. If the fault occurs when a kernel is running, you can see the code that launched the kernel inside the backtrace. The thread that's causing the issue is typically the one inside libhsa-runtime64.so .
-- VMfaults inside kernels can be caused by:
-- -Incorrect code (e.g., a for loop that extends past array boundaries)
-- -Memory issues, such as invalid kernel arguments (null pointers, unregistered host pointers, bad pointers)
-- -Synchronization issues
-- -Compiler issues (incorrect code generation from the compiler)
-- -Runtime issues
-
-## CHAPTER
-
-## THIRTEEN
-
-## LOGGING HIP ACTIVITY
-
-HIP provides a logging mechanism that allows you to trace HIP API and runtime codes when running a HIP application. In addition to being useful to our users/developers, the HIP development team uses these logs to improve the HIP runtime.
-
-By adjusting the logging settings and logging mask, you can get different types of information for different functionalities, such as HIP APIs, executed kernels, queue commands, and queue contents. Refer to the following sections for examples.
-
-Tip: Logging works for the release and debug versions of HIP. If you want to save logging output in a file, define the file when running the application via command line. For example:
-**Following code does:** This code snippet is related to memory management in a GPU context using the HIP (Heterogeneous-Compute Interface for Portability) API, which is used for writing portable applications that can run on AMD and NVIDIA GPUs. 
-
-The two functions perform the following high-level tasks:
-
-1. `hipMemUnmap(ptr, size);`: This function unmaps a previously mapped memory region from the host's address space. The `ptr` is the pointer to the memory region, and `size` specifies the size of the memory to be unmapped.
-
-2. `hipMemRelease(allocHandle);`: This function releases or deallocates the memory associated with a given allocation handle (`allocHandle`). It effectively frees the memory resources that were previously allocated.
-
-Overall, the code is responsible for cleaning up GPU memory resources by unmapping and releasing them, which is crucial for preventing memory leaks and ensuring efficient memory usage in GPU applications.
-
-
-```
-            |user@user-test:~/hip/bin$./hipinfo > ~/hipinfo > ~/hip_log.txt
-```
-
-## 13.1 Logging level
-
-HIP logging is disabled by default. You can enable it via the AMD\_LOG\_LEVEL environment variable. The value of this variable controls your logging level. Levels are defined as follows:
-**Following code does:** This code snippet appears to be a call to a function named `hipMemAddressFree`, which is likely part of the HIP (Heterogeneous-Compute Interface for Portability) API used for GPU programming. The function is intended to free or release a block of memory that was previously allocated, identified by the pointer `ptr`, and of a specified `size`. This operation is typically used to manage memory resources efficiently in GPU applications. The vertical bar `|` at the beginning seems to be a typographical error or an artifact, as it is not standard syntax in Python or C/C++.
-
-
-```
-                                                                                                                                                                                                       
-  enum LogLevel {
-      LOG_NONE       = 0,
-      LOG_ERROR     = 1,
-      LOG_WARNING = 2,
-      LOG_INFO       = 3,
-      LOG_DEBUG     = 4
-  };
-```
-
-Tip: You can call a logging function with different logging levels. All information under the value set for AMD\_LOG\_LEVEL is printed.
-
-## 13.2 Logging mask
-
-The logging mask is designed to print functionality types when you're running a HIP application. Once you set AMD\_LOG\_LEVEL , the logging mask is set as the default value ( 0x7FFFFFFF ). You can change this to any of the valid values:
-**Following code does:** This code snippet is part of a memory management process using HIP (Heterogeneous-Compute Interface for Portability), which is a framework for GPU programming. The code performs the following high-level tasks:
-
-1. **Memory Reservation**: It reserves a block of memory starting at a specified address (`ptr + padded_size`) with a size of `new_size - padded_size`. This is done using `hipMemAddressReserve`, which allocates a virtual address space without actually allocating physical memory.
-
-2. **Memory Mapping**: It maps the reserved virtual memory to a physical memory allocation using `hipMemMap`. This associates the reserved address space (`new_ptr`) with a physical memory allocation identified by `newAllocHandle`.
-
-3. **Setting Memory Access**: It sets the access permissions for the mapped memory using `hipMemSetAccess`. This specifies how the memory can be accessed (e.g., read, write) based on the provided `accessDesc`.
-
-Overall, this code is setting up a reserved and mapped memory region with specific access permissions in a GPU context.
-
-
-```
-        The logging mask is designed to print functionality types when you're running a HIP application.  Once you set
-        AMD_LOG_LEVEL, the logging mask is set as the default value (0x7FFFFFFF). You can change this to any of the valid
-        values:
-
-        enum LogMask {
-          LOG_API         = 0x000000001,  //!< API call
-          LOG_CMD         = 0x000000002,  //!< Kernel and Copy Commands and Barriers
-          LOG_WAIT        = 0x000000004,  //!< Synchronization and waiting for commands to finish
-          LOG_AQL         = 0x000000008,  //!< Decode and display AQL packets
-          LOG_QUEUE      = 0x00000010,  //!< Queue commands and queue contents
-          LOG_SIG         = 0x00000020,  //!< Signal creation, allocation, pool
-          LOG_LOCK        = 0x00000040,  //!< Locks and thread-safety code.
-          LOG_KERN        = 0x00000080,  //!< kernel creations and arguments, etc.
-          LOG_COPY        = 0x000000100,  //!< Copy debug
-          LOG_COPY2       = 0x000000200,  //!< Detailed copy debug
-          LOG_RESOURCE   = 0x000000400,  //!< Resource allocation, performance-impacting events.
-          LOG_INIT        = 0x00000080,  //!< Initialization and shutdown
-          LOG_MISC        = 0x00001000,  //!< misc debug, not yet classified
-          LOG_AQL2        = 0x00002000,  //!< Show raw bytes of AQL packet
-          LOG_CODE        = 0x00004000,  //!< Show code creation debug
-          LOG_CMD2        = 0x00008000,  //!< More detailed command info, including barrier commands
-          LOG_LOCATION   = 0x00010000,  //!< Log message location
-          LOG_MEM         = 0x0000200000,  //!< Memory allocation
-          LOG_MEM_POOL   = 0x00040000,  //!< Memory pool allocation, including memory in graphs
-          LOG_ALWAYS     = 0xFFFFFFFF,  //!< Log always even mask flag is zero
-        };
-
-        You can also define the logging mask via the AMD_LOG_MASK environment variable.
-```
-
-You can also define the logging mask via the AMD\_LOG\_MASK environment variable.
-
-## 13.3 Logging command
-
-You can use the following code to print HIP logging information:
-**Following code does:** This code snippet is a simple C++ program that uses the HIP API, which is a C++ runtime API for GPU programming. The program initializes two `dim3` objects, which are typically used to define the dimensions of a grid or block in GPU programming. The first `dim3` object, `grid1`, is default-initialized, meaning its dimensions are set to zero. The second `dim3` object, `grid2`, is explicitly initialized with dimensions (1, 1, 1). The program then prints the dimensions of both `dim3` objects to the console. The purpose of this code is to demonstrate the initialization and usage of `dim3` objects in HIP.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?                                                                                                                                                                                                        </?                                                                                                                                                                                                       <!                                                                                                                                                                                                        >
-                                                                                                                                                                                                       <&                                                                                                                                                                                                        &
-                                                                                                                                                                                                      
-																																																																																																																																																																																																								                                                                                                                                                                                                       																																																																																																																																																																																																							<?                                                                                                                                                                                                      	                                                                                                                                                                                                      	
-																																																																																																																																																																																																						 																																																																																																																																																																																																						  <?
-```
-
-Using HIP code, call the ClPrint() function with the desired input variables. For example:
-**Following code does:** This code snippet compiles and runs a C++ program that likely involves GPU programming using the HIP (Heterogeneous-Compute Interface for Portability) API, which is used for writing portable code that can run on both AMD and NVIDIA GPUs. 
-
-1. The first line is a shell command that compiles a C++ source file named `test3.hip.cpp` using the `gcc` compiler. The `-x c++` flag specifies that the input file is a C++ source file. The `$(hipconfig --cpp_config)` part dynamically inserts the necessary compiler flags for HIP, which are obtained by running the `hipconfig --cpp_config` command. The output of the compilation is an executable named `test`.
-
-2. The second line executes the compiled program `./test`. The output suggests that the program is demonstrating the initialization and use of `dim3` objects, which are typically used in GPU programming to specify the dimensions of grid and block structures for kernel launches. The output shows two `dim3` objects, `grid1` and `grid2`, both initialized with dimensions `x=1, y=1, z=1`. This indicates that the program is likely testing or demonstrating basic grid configuration for GPU kernels.
-
-
-```
-            |ClPrint(amd::LOG_INFO, amd::LOG_INIT, "Initializing HSA stack.");
-```
-
-## 13.4 Logging examples
-
-On Linux , you can enable HIP logging and retrieve logging information when you run hipinfo .
-**Following code does:** This code snippet appears to be a comment in Python that is referencing a C++ style of initialization. The comment suggests that there is a variable `grid` of type `dim3` being initialized with the values `{1,1,1}`. In C++, `dim3` is typically used in CUDA programming to specify the dimensions of a grid or block for parallel execution on a GPU. The comment is likely indicating that the `grid` variable is being set to a 1x1x1 configuration, which means it is a single block with a single thread in each dimension (x, y, z). However, since this is a comment in Python, it does not execute any code but rather provides information or context about how a similar operation might be performed in C++.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <HR>
-                                                                                                                                                                                                       <HIP Documentation, Release 6.1.40092                                                                                                                                                                                                        </HIP Documentation, Release 6.1.40092                                                                                                                                                                                             <HR>
-        Loggging examples                                                                                                                                                                                                        >
-                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       >
-
-                                                                                                                                                                                                       <BR>
-                                                                                                                                                                                                      <BR><BR>
-                                                                                                                                                                                                     <BR>
-
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                       	                                                                                                                                                                                                       <B>
-                                                                                                                                                                                                     
-  <B>
-                                                                                                                                                                                                   <BR>
-  <B>
-                                                                                                                                                                                                  <BR>
-```
-
-(continues on next page)
-
-(continued from previous page)
-**Following code does:** The code snippet you provided appears to be a mistake or a mix-up. It seems to be an attempt to specify a programming language (C++) rather than actual code. If you intended to provide a C++ code snippet, please include the relevant code so I can help explain its purpose.
-
-
-```
-HIP Documentation, Release 6.1.40092
-```
-
-On Windows , you can set AMD\_LOG\_LEVEL via environment variable from the advanced system settings or the command prompt (when run as administrator). The following example shows debug log information when calling the backend runtime.
-**Following code does:** The code snippet `| export` appears to be incomplete or out of context for a typical Python script. In Python, the `|` character is not used in this way, and `export` is not a standard Python keyword. This snippet might be part of a shell command or a configuration file where `export` is used to set environment variables, but as it stands, it does not represent a valid or complete Python statement.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <kendo runume.                                                                                                                                                                                                        </kendo>runume.
-```
-
-(continues on next page)
-
-(continued from previous page)
-**Following code does:** The code snippet appears to be a shell command that sets an environment variable named `HIP_PLATFORM` to the value `amd`. This is typically used in a shell or terminal to configure the environment for software that relies on the HIP (Heterogeneous-Compute Interface for Portability) platform, indicating that the target platform for HIP operations should be AMD hardware.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <![
-                                                                                                                                                                                                       <?xml:%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/.%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/)
-                                                                                                                                                                                                      
-
-                                                                                                                                                                                                      
-
-
-                                                                                                                                                                                                       </?xml:%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazon AWS.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazon AWS.com/.%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazon AWS.com%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/"
-                                                                                                                                                                                                       :
-                                                                                                                                                                                                       >
-                                                                                                                                                                                                      ?xml:%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws,com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws,com%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.
-```
-
-(continues on next page)
-
-(continued from previous page)
-**Following code does:** It seems like you've provided a placeholder instead of actual code. If you provide the actual Python code snippet, I'd be happy to help explain its purpose.
-
-
-```
-  --copyBuffer
-...
-:4:C:\constructicon\builds\gfx\two\22.40\drivers\compute\vdi\device\pal\palmemory.
-  --cpp:206 : 605414523422 us: 29864: [tid:0x9298] Alloc: 100000 bytes,_,
-  --ptr[0000003008D0000-0000003009D0000], obj[0000003007D0000-0000003047D0000]
-:4:C:\constructicon\builds\gfx\two\22.40\drivers\compute\vdi\device\pal\palmemory.
-  --cpp:206 : 605414523767 us: 29864: [tid:0x9298] Alloc: 100000 bytes,_,
-  --ptr[0000003009D0000-000000300AD0000], obj[0000003007D0000-0000003047D0000]
-:3:C:\constructicon\builds\gfx\two\22.40\drivers\compute\hipamd\src\hip_memory.cpp:681 :_,
-  --605414524092 us: 29864: [tid:0x9298] hipMemGetInfo: Returned hipSuccess :
-memInfo.total:                     12.06 GB
-memInfo.free:                     11.93 GB (99%)
-```
-
-## CHAPTER
-
-## FOURTEEN
-
-## COOPERATIVE GROUPS
-
-Cooperative groups API is an extension to the HIP programming model, which provides developers with a flexible, dynamic grouping mechanism for the communicating threads. Cooperative groups let you define your own set of thread groups which may fit your user-cases better than those defined by the hardware. This lets you specify the level of granularity for thread communication which can lead to more efficient parallel decompositions.
-
-The API is accessible in the cooperative\_groups namespace after the hip\_cooperative\_groups.h is included. The header contains the following elements:
-
-- Static functions to create groups and subgroups.
-- Hardware-accelerated operations over the whole group, like shuffles.
-- Data types of cooperative groups.
-- Synchronize member function of the groups.
-- Get group properties member functions.
-
-## 14.1 Cooperative groups thread model
-
-The thread hierarchy abstraction of cooperative groups are in grid hierarchy and block hierarchy .
-
-Fig. 1: Cooperative group thread hierarchy in grids.
-
-The multi grid is an abstraction of potentially multiple simultaneous launches of the same kernel over multiple devices (Deprecated since 5.0). The grid in cooperative groups is a single dispatch of kernels for execution like the original grid.
-
-Note: The ability to synchronize over a grid or multi grid requires the kernel to be launched using the specific cooperative groups API.
-
-The block is the same as the Inherent thread model block entity.
-
-Note: Explicit warp-level thread handling is absent from the Cooperative groups API. In order to exploit the known hardware SIMD width on which built-in functionality translates to simpler logic, you can use the group partitioning part of the API, such as tiled\_partition .
-
-Fig. 2: Cooperative group thread hierarchy in blocks.
-
-The cooperative groups API introduce a new level between block thread and threads. The thread-block tile give the opportunity to have tiles in the thread block, while the coalesced group holds the active threads of the parent group. These groups further discussed in the groups types section.
-
-For details on memory model, check the memory model description .
-
-## 14.2 Group types
-
-Group types are based on the levels of synchronization and data sharing among threads.
-
-## 14.2.1 Thread-block group
-
-Represents an intra-block cooperative groups type where the participating threads within the group are the same threads that participated in the currently executing block .
-**Following code does:** This code snippet is a configuration or environment variable assignment in a shell or script. It sets the `HIP_COMPILER` variable to the value `cuda`. This is likely used in the context of configuring the HIP (Heterogeneous-Compute Interface for Portability) framework, which is designed to allow code to run on both AMD and NVIDIA GPUs. By setting `HIP_COMPILER` to `cuda`, it indicates that the HIP code should be compiled using the CUDA compiler, targeting NVIDIA GPUs.
-
-
-```
-    class thread_block;
-
-    Constructed via:
-
-    thread_block g = this_thread_block();
-```
-
-The group\_index() , thread\_index() , thread\_rank() , size() , cg\_type() , is\_valid() , sync() and group\_dim() member functions are public of the thread\_block class. For further details, check the thread\_block references .
-
-## 14.2.2 Grid group
-
-Represents an inter-block cooperative groups type where the group's participating threads span multiple blocks running the same kernel on the same device. Use the cooperative launch API to enable synchronization across the grid group.
-**Following code does:** This code snippet sets an environment variable named `HIP_RUNTIME` to the value `nvcc`. This is typically used in the context of configuring or building software that involves GPU programming, particularly when working with HIP (Heterogeneous-Compute Interface for Portability) and CUDA. By setting `HIP_RUNTIME` to `nvcc`, it indicates that the HIP code should be compiled using NVIDIA's CUDA compiler (`nvcc`), which is part of the CUDA toolkit. This setup is often used to ensure compatibility or optimize performance on NVIDIA GPUs.
-
-
-```
-class grid_group;
-
- Constructed via:
-
-grid_group g = this_grid();
-```
-
-The thread\_rank() , size() , cg\_type() , is\_valid() and sync() member functions are public of the grid\_group class. For further details, check the grid\_group references .
-
-## 14.2.3 Multi-grid group
-
-Represents an inter-device cooperative groups type where the participating threads within the group span multiple devices that run the same kernel on the devices. Use the cooperative launch API to enable synchronization across the multi-grid group.
-**Following code does:** The code snippet `<_C_>` appears to be incomplete or not a valid Python code. It does not represent any recognizable Python syntax or functionality. It might be a placeholder or a typographical error. Without additional context or information, it's not possible to determine its purpose or functionality.
-
-
-```
-    |class multi_grid_group;
-```
-**Following code does:** The code snippet `<_SQL_>` appears to be a placeholder or a tag indicating that the actual SQL code is not provided. It suggests that the content is intended to be SQL-related, possibly involving database queries or operations. Without the actual SQL code, it's not possible to determine the specific functionality or purpose. If you have the actual SQL code, I can help explain what it does.
-
-
-```
-;
-```
-
-Constructed via:
-**Following code does:** The code snippet you provided appears to be a comment or placeholder text rather than actual executable code. It seems to be referencing an example of using `hipLaunchKernelGGL`, which is a macro used in the HIP (Heterogeneous-Compute Interface for Portability) API. HIP is a C++ runtime API that allows developers to write portable code that can run on both AMD and NVIDIA GPUs.
-
-The purpose of `hipLaunchKernelGGL` is to launch a kernel function on a GPU. It abstracts the details of setting up the execution configuration (such as grid and block dimensions) and launching the kernel. However, without the actual code or context, this snippet doesn't perform any operations or provide further details.
-
-
-```
-<_C_>
-```
-**Following code does:** The provided code snippet appears to be incomplete and contains a syntax error. It seems to be a fragment of a function signature or declaration, possibly from a C or C++ program, rather than Python. The term `size_t` is a data type commonly used in C/C++ to represent sizes and is typically used for array indexing and loop counting. The `N` likely represents a parameter name. However, without additional context or code, it's not possible to determine the exact purpose or functionality of this snippet.
-
-
-```
-<_YAML_>
-```
-
-The num\_grids() , grid\_rank() , thread\_rank() , size() , cg\_type() , is\_valid() , and sync() member functions are public of the multi\_grid\_group class. For further details check the multi\_grid\_group references .
-
-## 14.2.4 Thread-block tile
-
-This constructs a templated class derived from thread\_group . The template defines the tile size of the new thread group at compile time. This group type also supports sub-wave level intrinsics.
-**Following code does:** This code snippet is related to launching a GPU kernel using HIP, which is a C++ runtime API and kernel language that allows developers to write portable code that can run on AMD and NVIDIA GPUs. The code launches a kernel function named `MyKernel` on the GPU. The kernel is executed with a specified grid and block (group) dimensions, which are defined by `gridDim` and `groupDim`, respectively. The parameters `a`, `b`, `c`, and `n` are passed to the kernel function, which likely represent data or configuration settings needed for the computation. The snippet also includes an alternative way to launch the kernel using the `hipLaunchKernelGGL` macro, which provides more flexibility, such as specifying a stream for asynchronous execution.
-
-
-```
-<_C++_>
-```
-
-Constructed via:
-**Following code does:** This code snippet is a GPU kernel implementation using HIP, a C++ runtime API and kernel language that allows developers to write portable code for AMD and NVIDIA GPUs. The code defines a simple kernel function `MyKernel` that operates on arrays of floating-point numbers. The kernel adds each element of array `a` to the corresponding element of array `b` after incrementing it by one, storing the result in array `c`. The `PlusOne` function is defined to increment a float by 1.0 and is marked to be compiled for both the host and device. The `callMyKernel` function sets up the necessary parameters and launches the kernel on the GPU, processing `N` elements with a specified block size.
-
-
-```
-<_SQL_>
-```
-
-## Note:
-
-- Size must be a power of 2 and not larger than warp (wavefront) size.
-- shfl() functions support integer or float type.
-
-The thread\_rank() , size() , cg\_type() , is\_valid() , sync() , meta\_group\_rank() , meta\_group\_size() , shfl() , shfl\_down() , shfl\_up() , shfl\_xor() , ballot() , any() , all() , match\_any() and match\_all() member functions are public of the thread\_block\_tile class. For further details, check the thread\_block\_tile references .
-
-## 14.2.5 Coalesced groups
-
-Threads (64 threads on CDNA and 32 threads on RDNA) in a warp cannot execute different instructions simultaneously, so conditional branches are executed serially within the warp. When threads encounter a conditional branch, they can diverge, resulting in some threads being disabled, if they do not meet the condition to execute that branch. The active threads referred as coalesced, and coalesced group represents an active thread group within a warp.
-
-Note: The NVIDIA GPU's independent thread scheduling presents the appearance that threads on different branches execute concurrently.
-
-Warning: AMD GPUs do not support independent thread scheduling. Some CUDA application can rely on this feature and the ported HIP version on AMD GPUs can deadlock, when they try to make use of independent thread scheduling.
-
-This group type also supports sub-wave level intrinsics.
-**Following code does:** The code snippet `<_C_>` appears to be incomplete or not a valid Python code. It does not represent any recognizable Python syntax or functionality. It might be a placeholder or a typographical error. Without additional context or information, it's not possible to determine its purpose or functionality.
-
-
-```
-    | class coalesced_group;
-```
-
-Constructed via:
-
-coalesced\_group
-**Following code does:** The code snippet `<_SQL_>` appears to be a placeholder or a tag indicating where SQL-related code or content should be inserted. It does not perform any operations or have any functionality on its own. Its purpose is likely to serve as a marker within a larger codebase or documentation to denote the section where SQL code is relevant or expected to be included.
-
-
-```
-    |roup active  = coalesced_threads() ;
-```
-
-Note: shfl() functions support integer or float type.
-
-The thread\_rank() , size() , cg\_type() , is\_valid() , sync() , meta\_group\_rank() , meta\_group\_size() , shfl() , shfl\_down() , shfl\_up() , ballot() , any() , all() , match\_any() and match\_all() member functions are public of the coalesced\_group class. For more information, see coalesced\_group references .
-
-## 14.3 Cooperative groups simple example
-
-The difference to the original block model in the reduce\_sum device function is the following.
-
-## Original Block
-**Following code does:** The provided code snippet appears to be incomplete and contains syntax errors, making it difficult to determine its exact purpose. However, it seems to be attempting to use or declare variables related to time measurement, possibly involving a clock function and a variable named `close`. Without additional context or corrections, it's not possible to provide a meaningful high-level summary of its functionality.
-
-
-```
-<_Cuda_>
-```
-
-## Cooperative groups
-**Following code does:** The code snippet appears to be a malformed or incomplete line of Python code. It seems to be attempting to declare a variable `w` with a type annotation of `long long int`, which is not a valid type in Python. In Python, type annotations typically use Python's built-in types or types from the `typing` module, and `long long int` is a C/C++ type, not a Python type. Therefore, this line does not serve any functional purpose in Python as it stands.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        // Thread ID
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        /                                                                                                                                                                                                        *                                                                                                                                                                                                        /*                                                                                                                                                                                                        */
-                                                                                                                                                                                                       */
-```
-
-(continues on next page)
-
-(continued from previous page)
-**Following code does:** The code snippet `it will_clock64()` appears to be a function call in Python. However, without additional context or definition of the function `it will_clock64`, it's not possible to determine its purpose or functionality. The name suggests it might be related to a clock or timing mechanism, possibly involving 64-bit operations, but this is purely speculative. To understand what this code does, one would need to see the implementation or documentation of the `it will_clock64` function.
-
-
-```
-      for(unsigned int i = g.size() / 2; i > 0; i /= 2) {
-          // Store value in shared memory with thread ID
-          shared[group_thread_id] = val;
-
-          // Synchronize all threads in the group
-          g.sync();
-
-          // Active thread sum up
-          if(group_thread_id < i)
-               val += shared[group_thread_id + i];
-
-          // Synchronize all threads in the group
-          g.sync();
-      }
-
-      //...
-}
-
-The reduce_sum() function call and input data initialization difference to the origin.
-```
-
-The reduce\_sum() function call and input data initialization difference to the original block model is the following.
-
-## Original Block
-**Following code does:** This code snippet is written in C++ and uses the HIP (Heterogeneous-Compute Interface for Portability) API, which is designed for writing portable applications that can run on both AMD and NVIDIA GPUs. The code retrieves the wall clock rate of a GPU device in kilohertz. Specifically, it initializes an integer variable `wallClkRate` to store the clock rate, and then calls the `hipDeviceGetAttribute` function to obtain the wall clock rate attribute (`hipDeviceAttributeWallClockRate`) for a specific GPU device identified by `deviceId`. The `HIPCHECK` macro is likely used to check for errors in the HIP API call.
-
-
-```
-Original Block
-
-__global__ void sum_kernel(...) {
-
-    //...
-
-    // Workspace array in shared memory
-    __shared__ unsigned int workspace[2048];
-
-    //...
-
-    // Perform reduction
-    output = reduce_sum(workspace, input);
-
-    //...
-}
-```
-
-## Cooperative groups
-**Following code does:** This code snippet retrieves the properties of a CUDA-enabled device specified by `deviceID` and stores them in a `cudaDeviceProp` structure named `props`. It then extracts the `warpSize` property, which indicates the number of threads in a warp for that device, and assigns it to the variable `w`. The comment suggests that the subsequent code will implement an algorithm that adapts to the device's warp size, ensuring portability across devices with different warp sizes, rather than assuming a fixed size like 32 or 64.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        //                                                                                                                                                                                                        const auto                                                                                                                                                                                                        }                                                                                                                                                                                                        /*                                                                                                                                                                                                        */                                                                                                                                                                                                        *
-```
-
-(continued from previous page)
-**Following code does:** This code snippet appears to define a set of functions typically used in parallel computing environments, such as CUDA for GPU programming. These functions are likely intended for use in managing and synchronizing threads within a warp (a group of threads that execute instructions in lockstep on a GPU). Here's a high-level summary of each function's purpose:
-
-1. `__all(int predicate)`: This function checks if a given condition (predicate) is true for all threads in a warp. It returns a non-zero value if the condition is true for all threads, otherwise it returns zero.
-
-2. `__any(int predicate)`: This function checks if a given condition (predicate) is true for any thread in a warp. It returns a non-zero value if the condition is true for at least one thread, otherwise it returns zero.
-
-3. `__ballot(int predicate)`: This function returns a bitmask representing which threads in a warp have a true predicate. Each bit in the returned value corresponds to a thread in the warp, with the bit set if the predicate is true for that thread.
-
-4. `__activemask()`: This function returns a bitmask indicating which threads in the warp are currently active. Active threads are those that are currently participating in the execution of the warp.
-
-5. `__all_sync(unsigned long long mask, int predicate)`: This function is similar to `__all`, but it allows specifying a mask to indicate which threads should be considered in the check. It synchronizes the threads specified by the mask and checks if the predicate is true for all of them.
-
-These functions are useful for coordinating and synchronizing operations across threads within a warp, ensuring that certain conditions are met before proceeding with further computations.
-
-
-```
-    thread_block thread_block_group = this_thread_block();
-    // Perform reduction
-    output = reduce_sum(thread_block_group, workspace, input);
-
-    //...
-}
-```
-
-At the device function, the input group type is the thread\_group , which is the parent class of all the cooperative groups type. With this, you can write generic functions, which can work with any type of cooperative groups.
-
-## 14.4 Synchronization
-
-With each group type, the synchronization requires using the correct cooperative groups launch API.
-
-## Check the kernel launch capability
-
-## Thread-block
-
-Do not need kernel launch validation.
-
-## Grid
-
-Confirm the cooperative launch capability on the single AMD GPU:
-**Following code does:** It seems like there is a placeholder or a formatting error in your request, as the code snippet is not visible. Please provide the actual code snippet so I can help explain its purpose.
-
-
-```
-    Confirm the cooperative launch capability on the single AMD GPU:
-
-    int device                       = 0;
-    int supports_coop_launch = 0;
-    // Check support
-    // Use hipDeviceAttributeCooperativeMultiDeviceLaunch when launching across multiple_
-    --devices
-    HIP_CHECK(hipGetDevice(&device));
-    HIP_CHECK(
-        hipDeviceGetAttribute(&supports_coop_launch, hipDeviceAttributeCooperativeLaunch,\
-    --device));
-    if(!supports_coop_launch)
-    {
-        std::cout << "Skipping, device " << device << " does not support cooperative groups"
-                       << std::endl;
-        return 0;
-    }
-```
-
-## Multi-grid
-
-Confirm the cooperative launch capability over multiple GPUs:
-**Following code does:** This code snippet appears to define function prototypes for a set of operations that involve matching values in a parallel computing context, likely using CUDA or a similar parallel processing framework. The functions are designed to perform matching operations across multiple threads or processing units:
-
-1. `__match_any(T value)`: This function likely checks if any thread in a group has a value that matches the specified `value`.
-
-2. `__match_all(T value, int *pred)`: This function probably checks if all threads in a group have a value that matches the specified `value`, and it might use the `pred` pointer to store or influence the result.
-
-3. `__match_any_sync(unsigned long long mask, T value)`: Similar to `__match_any`, but includes a `mask` parameter to specify which threads participate in the operation, ensuring synchronization among them.
-
-4. `__match_all_sync(unsigned long long mask, T value, int *pred)`: Similar to `__match_all`, but includes a `mask` parameter for synchronized participation and possibly uses `pred` for additional logic or result storage.
-
-Overall, these functions are likely used for efficient data comparison and synchronization across multiple threads in a parallel processing environment.
-
-
-```
-    Multi-grid
-
-    Confirm the cooperative launch capability over multiple GPUs:
-
-    // Check support of cooperative groups
-    std::vector<int> deviceIDs;
-    for(int deviceID = 0; deviceID < device_count; deviceID++) {
-    #ifdef __HIP_PLATFORM_AMD__
-        int supports_coop_launch = 0;
-        HIP_CHECK(
-            hipDeviceGetAttribute(
-                &supports_coop_launch,
-                hipDeviceAttributeCooperativeMultiDeviceLaunch,
-                deviceID));
-        if(!supports_coop_launch) {
-            std::cout << "Skipping, device " << deviceID << " does not support cooperative_
-    --groups"
-                        << std::endl;
-        }
-        else
-    #endif
-        {
-            std::cout << deviceID << std::endl;
-            // Collect valid deviceIDs.
-            deviceIDs.push_back(deviceID);
-        }
-    }
-
-    Kernel launch
-
-    __   ...  .
-```
-
-## Kernel launch
-
-## Thread-block
-
-You can access the new block representation using the original kernel launch methods.
-**Following code does:** The code snippet is a description of a CUDA intrinsic function `__shfl`. This function is used in parallel programming with NVIDIA GPUs to perform a shuffle operation within a warp. Specifically, it allows threads within a warp to exchange data. The function takes three parameters: `var`, which is the variable to be shuffled; `srcLane`, which specifies the source lane (or thread) from which to copy the value; and `width`, which defines the width of the shuffle operation, defaulting to the warp size. The note mentions that half-float data types are not supported for this shuffle operation.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        // Launching kernel  from host.
-```
-
-## Grid
-
-Launch the cooperative kernel on a single GPU:
-**Following code does:** The code snippet appears to be incomplete and contains a syntax error. It seems to be a mix of Python and C/C++ syntax, as it starts with a pipe character (`|`) and uses a C/C++ style function declaration (`void assert(int ir`). However, based on the visible part, it seems intended to define a function named `assert` that takes an integer parameter `ir` and returns no value (`void`). Without more context or the rest of the code, it's not possible to determine the specific purpose or functionality of this function.
-
-
-```
-<_C_>
-```
-
-## Multi-grid
-
-Launch the cooperative kernel over multiple GPUs:
-**Following code does:** This code snippet waits for the user to input data from the standard input (typically the keyboard) and press Enter. It effectively pauses the program's execution until the user provides some input. The input function can also be used to capture the user's input as a string, but in this case, since the result is not assigned to any variable, the input is simply discarded.
-
-
-```
-    Multi-grid
-
-    Launch the cooperative kernel over multiple GPUs:
-
-    hipLaunchParams *launchParamsList = (hipLaunchParams*)malloc(sizeof(hipLaunchParams) *_
-    --deviceIDs.size());
-    for(int deviceID : deviceIDs) {
-
-        // Set device
-        HIP_CHECK(hipSetDevice(deviceID));
-
-        // Create stream
-        hipStream_t stream;
-        HIP_CHECK(hipStreamCreate(&stream));
-
-        // Parameters
-        void* params[] = {&(d_vector[deviceID]), &(d_block_reduced[deviceID]), &(d_partition_
-    --reduced[deviceID])};
-
-        // Set launchParams
-        launchParamsList[deviceID].func = (void*)vector_reduce_kernel<partition_size>;
-        launchParamsList[deviceID].gridDim = dim3(1);
-        launchParamsList[deviceID].blockDim = dim3(threads_per_block);
-        launchParamsList[deviceID].sharedMem = 0;
-        launchParamsList[deviceID].stream = stream;
-        launchParamsList[deviceID].args = params;
-    }
-
-    HIP_CHECK(hipLaunchCooperativeKernelMultiDevice(launchParamsList,
-                                                                                                                                                                                                         (int)deviceIDs.size(),
-                                                                                                                                                                                                       )
-    --hipCooperativeLaunchMultiDeviceNoPreSync));
-
-    Device side synchronization
-```
-
-Device side synchronization
-
-## Thread-block
-
-The device side code of the thread\_block synchronization over single GPUs:
-**Following code does:** This code is a simple CUDA program using the HIP (Heterogeneous-Compute Interface for Portability) API, which is designed to run on AMD GPUs. The program defines a kernel function `run_printf` that prints "Hello World" to the console. The `main` function launches this kernel with a single thread block and a single thread, effectively executing the `printf` statement on the GPU. The purpose of this code is to demonstrate how to execute a basic "Hello World" program using GPU parallel computing with HIP.
-
-
-```
-<_C_>
-```
-
-## Grid
-
-The device side code of the grid synchronization over single GPUs:
-**Following code does:** The code snippet `<_Cython_>` appears to be a placeholder or a tag rather than actual executable code. In a typical context, "Cython" refers to a programming language that makes writing C extensions for Python as easy as Python itself. It is used to improve the performance of Python code by compiling it into C. However, without additional context or actual code, this snippet does not perform any specific function or operation.
-
-
-```
-<_Cython_>
-```
-**Following code does:** The code snippet appears to define a constant named `MIN_WARPS_PER_EXECUTION_UNIT`. This constant is calculated by dividing the product of `MIN_BLOCKS_PER_MULTIPROCESSOR` and `MAX_THREADS_PER_BLOCK` by an unknown operator represented by `/_\`. However, the snippet includes a series of unusual characters and formatting that suggest it might be incomplete or corrupted. In a typical context, such a calculation might be used to determine the minimum number of warps (groups of threads) that can be executed per unit in a parallel computing environment, such as on a GPU. However, without a clear definition of `/_\`, the exact calculation is unclear.
-
-
-```
-  =  this._grid() ;
-```
-
-## Multi-grid
-
-The device side code of the multi-grid synchronization over multiple GPUs:
-**Following code does:** The code snippet appears to be a warning message indicating that a particular API is deprecated. Specifically, it suggests that the user should replace the deprecated API with `hipHostMalloc()`. This message is likely part of a larger codebase or documentation related to memory allocation in a computing environment that uses the HIP (Heterogeneous-Compute Interface for Portability) API, which is commonly used for GPU programming. The purpose of the message is to inform developers to update their code to use the recommended function for host memory allocation.
-
-
-```
-            |multi_grid_group multi_grid = this_multi_grid();
-```
-**Following code does:** The provided text appears to be a fragment of a warning message rather than a complete code snippet. It indicates that a particular API is deprecated and suggests using `hipHostFree()` as an alternative. This typically means that the current API or function being used is outdated and may be removed in future versions, so developers are advised to switch to the recommended `hipHostFree()` function for managing host memory in HIP (Heterogeneous-Compute Interface for Portability) applications.
-
-
-```
-|multi_grid.sync();
-```
-
-## 14.5 Unsupported NVIDIA CUDA features
-
-HIP doesn't support the following NVIDIA CUDA optional headers:
-
-- cooperative\_groups/memcpy\_async.h
-- cooperative\_groups/reduce.h
-- cooperative\_groups/scan.h
-
-HIP doesn't support the following CUDA class in cooperative\_groups namespace:
-
-- cluster\_group
-
-HIP doesn't support the following CUDA functions/operators in cooperative\_groups namespace:
-
-- synchronize
-- memcpy\_async
-- wait and wait\_prior
-- barrier\_arrive and barrier\_wait
-- invoke\_one and invoke\_one\_broadcast
-- reduce
-- reduce\_update\_async and reduce\_store\_async
-- Reduce operators plus , less , greater , bit\_and , bit\_xor and bit\_or
-- inclusive\_scan and exclusive\_scan
-
-## CHAPTER
-
-## FIFTEEN
-
-## UNIFIED MEMORY
-
-In conventional architectures, CPUs and GPUs have dedicated memory like Random Access Memory (RAM) and Video Random Access Memory (VRAM). This architectural design, while effective, can be limiting in terms of memory capacity and bandwidth, as continuous memory copying is required to allow the processors to access the appropriate data. New architectural features like Heterogeneous System Architectures (HSA) and Unified Memory (UM) help avoid these limitations and promise increased efficiency and innovation.
-
-## 15.1 Unified memory
-
-Unified Memory is a single memory address space accessible from any processor within a system. This setup simplifies memory management processes and enables applications to allocate data that can be read or written by code running on either CPUs or GPUs. The Unified memory model is shown in the following figure.
-
-AMD Accelerated Processing Unit (APU) is a typical example of a Unified Memory Architecture. On a single die, a central processing unit (CPU) is combined with an integrated graphics processing unit (iGPU), and both have access to a high-bandwidth memory (HBM) module named Unified Memory. The CPU enables high-performance, low-latency operations, while the GPU is optimized for high throughput (data processed by unit time).
-
-## 15.2 System requirements
-
-Unified memory is supported on Linux by all modern AMD GPUs from the Vega series onward. Unified memory management can be achieved with managed memory allocation and, for the latest GPUs, with a system allocator.
-
-The table below lists the supported allocators. The allocators are described in the next section.
-
-Table 1: Supported Unified Memory Allocators
-
-| Architecture        | hipMallocManaged()   | __managed__   | malloc()   |
-|---------------------|----------------------|---------------|------------|
-| MI200, MI300 Series |                      |               | 1          |
-| MI100               |                      |               |            |
-| RDNA (Navi) Series  |                      |               |            |
-| GCN5 (Vega) Series  |                      |               |            |
-
-## : Supported
-
-- : Unsupported
-
-1 Works only with XNACK=1 . First GPU access causes recoverable page-fault. For more details, visit GPU memory.
-
-## 15.3 Unified memory programming models
-
-Showcasing various unified memory programming models, the model availability depends on your architecture. For more information, see System requirements and Checking unified memory management support .
-
-- HIP managed memory allocation API :
-
-The hipMallocManaged() is a dynamic memory allocator available on all GPUs with unified memory support. For more details, visit HIP managed memory allocation API .
-
-- HIP managed variables :
-
-The \_\_managed\_\_ declaration specifier, which serves as its counterpart, is supported on all modern AMD cards and can be utilized for static allocation.
-
-- System allocation API :
-
-Starting with the AMD MI300 series, the malloc() system allocator allows you to reserve unified memory. The system allocator is more versatile and offers an easy transition from a CPU written C++ code to a HIP code as the same system allocation API is used.
-
-## 15.3.1 Checking unified memory management support
-
-Some device attributes can offer information about which Unified memory programming models are supported. The attribute value is 1 if the functionality is supported, and 0 if it is not supported.
-
-Table 2: Device attributes for unified memory management
-
-| attribute description                                                                                 |
-|-------------------------------------------------------------------------------------------------------|
-| hipDeviceAttributeManagedMemory unified addressing is supported                                       |
-| hipDeviceAttributeConcurrentManagedAccess full managed memory support, concurrent access is supported |
-| hipDeviceAttributePageableMemoryAccess both managed and system memory allocation API is supported     |
-
-The following examples show how to use device attributes:
-**Following code does:** The code snippet is a command intended to be run in a Unix-like terminal that uses the Advanced Package Tool (APT) package management system. The command `apt-get install hi` attempts to install a software package named "hi" from the system's package repositories. If the package "hi" exists in the repositories and the user has the necessary permissions, it will be downloaded and installed on the system.
-
-
-```
-
-
-#include <hip/hip_runtime.h>
-#include <iostream>
-
-int main()  {
-        int d;
-        hipGetDevice(&d);
-
-        int  is_cma = 0;
-        hipDeviceGetAttribute(&is_cma, hipDeviceAttributeConcurrentManagedAccess, d);
-        std::cout << "HIP Managed Memory: "
-                       << (is_cma == 1? "is" : "NOT")
-                        << " " supported" << std::endl;
-        return 0;
-}
-```
-
-## 15.3.2 Example for unified memory management
-
-The following example shows how to use unified memory management with hipMallocManaged() , function, with \_\_managed\_\_ attribute for static allocation and standard malloc() allocation. For comparison, the Explicit Memory Management example is presented in the last tab.
-
-## hipMallocManaged()
-**Following code does:** The code snippet you provided appears to be a fragment of a command or a list of package names, but it is not a complete or valid Python code. It seems to be related to package management, possibly for installing or managing software packages related to HIP (Heterogeneous-Compute Interface for Portability) and NVIDIA GPU support. However, without additional context or a complete command, it's difficult to determine its exact purpose.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        //                                                                                                                                                                                                        }                                                                                                                                                                                                        */
-                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       //
-                                                                                                                                                                                                      
-
-
-                                                                                                                                                                                                       }
-                                                                                                                                                                                                       */
-```
-
-\_\_managed\_\_
-**Following code does:** This code is a command-line instruction used in a Unix-based operating system, such as Linux, to install Python 3 using the package manager `apt-get`. The command fetches the Python 3 package from the software repositories and installs it on the system, making Python 3 available for use.
-
-
-```
-__managed__
-
-#include <hip/hip_runtime.h>
-#include <iostream>
-
-// Addition of two values.
-__global__ void add(int *a, int *b, int *c) {
-    *c = *a + *b;
-}
-
-// Declare a, b and c as static variables.
-__managed__ int a, b, c;
-
-int main() {
-    // Setup input values.
-    a = 1;
-    b = 2;
-
-    // Launch add() kernel on GPU.
-    hipLaunchKernelGGL(add, dim3(1), dim3(1), 0, 0, &a, &b, &c);
-
-    // Wait for GPU to finish before accessing on host.
-    hipDeviceSynchronize();
-
-    // Prints the result.
-    std::cout << a << " + " << b << " = " << c << std::endl;
-
-    return 0;
-}
-
-
-malloc()
-```
-
-## malloc()
-**Following code does:** This code installs the Python package `CppHeaderParser` using the `pip3` package manager. `CppHeaderParser` is a library that allows users to parse C++ header files, extracting information such as classes, functions, and other declarations. The `pip3` command specifically uses Python 3's package manager to perform the installation.
-
-
-```
-malloc()
-
-#include <hip/hip_runtime.h>
-#include <iostream>
-
-// Addition of two values.
-__global__ void add(int* a, int* b, int* c) {
-    *c = *a + *b;
-}
-
-int main() {
-    int* a, * b, * c;
-
-    // Allocate memory for a, b, and c.
-    a = (int*)malloc(sizeof(*a));
-    b = (int*)malloc(sizeof(*b));
-    c = (int*)malloc(sizeof(*c));
-
-    // Setup input values.
-    *a = 1;
-    *b = 2;
-```
-
-(continues on next page)
-
-(continued from previous page)
-**Following code does:** The code snippet `| export` appears to be incomplete or out of context. In Python, this syntax is not valid. It might be part of a larger script or command in a different context, such as a shell command or a configuration file, where `export` is used to set environment variables. Without additional context, it's unclear what the intended purpose is.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-        // Launch add() kernel on GPU.
-        hipLaunchKernelGGL(add, dim3(1), dim3(1), 0, 0, a, b, c);
-
-        // Wait for GPU to finish before accessing on host.
-        hipDeviceSynchronize();
-
-        // Prints the result.
-        std::cout << *a << " + " << *b << " = " << *c << std::endl;
-
-        // Cleanup allocated memory.
-        free(a);
-        free(b);
-        free(c);
-
-        return 0;
-    }
-```
-**Following code does:** The code snippet you provided appears to be a placeholder or a tag indicating that the actual code is written in Bash, a Unix shell and command language. However, without the actual Bash code, it's not possible to determine its functionality or purpose. If you have a specific Bash script or command, please provide it for a more detailed explanation.
-
-
-```
-        tree<J;
-
-        return 0;
-    }
-
-
-    Explicit Memory Management
-
-    #include <hip/hip_runtime.h>
-    #include <iostream>
-
-    // Addition of two values.
-    __global__ void add(int *a, int *b, int *c) {
-        *c = *a + *b;
-    }
-
-    int main() {
-        int a, b, c;
-        int *d_a, *d_b, *d_c;
-
-        // Setup input values.
-        a = 1;
-        b = 2;
-
-        // Allocate device copies of a, b and c.
-        hipMalloc(&d_a, sizeof(*d_a));
-        hipMalloc(&d_b, sizeof(*d_b));
-        hipMalloc(&d_c, sizeof(*d_c));
-
-        // Copy input values to device.
-        hipMemcpy(d_a, &a, sizeof(*d_a), hipMemcpyHostToDevice);
-        hipMemcpy(d_b, &b, sizeof(*d_b), hipMemcpyHostToDevice);
-
-        // Launch add() kernel on GPU.
-        hipLaunchKernelGGL(add, dim3(1), dim3(1), 0, 0, d_a, d_b, d_c);
-
-        // Copy the result back to the host.
-        hipMemcpy(&c, d_c, sizeof(*d_c), hipMemcpyDeviceToHost);
-                                                                                                                                                                                                         (continues on next page)
-
-
-    15.3. Unified memory programming models                                                                                                                                                                                                        103
-```
-**Following code does:** The code snippet `<_Bash_>` appears to be a placeholder or a tag indicating that a section of code written in the Bash scripting language should be inserted or is expected there. It does not perform any specific function or operation by itself. Instead, it likely serves as a marker within a larger document or system to denote where Bash code is relevant or should be included.
-
-
-```
-
-    // Cleanup allocated memory.
-    hipFree(d_a);
-    hipFree(d_b);
-    hipFree(d_c);
-
-    // Prints the result.
-    std::cout << a << " + " << b << " = " << c << std::endl;
-
-    return 0;
-}
-```
-
-## 15.4 Using unified memory management (UMM)
-
-Unified memory management (UMM) is a feature that can simplify the complexities of memory management in GPU computing. It is particularly useful in heterogeneous computing environments with heavy memory usage with both a CPU and a GPU, which would require large memory transfers. Here are some areas where UMM can be beneficial:
-
-- Simplification of Memory Management :
-
-UMMcan help to simplify the complexities of memory management. This can make it easier for developers to write code without worrying about memory allocation and deallocation details.
-
-- Data Migration :
-
-UMMallows for efficient data migration between the host (CPU) and the device (GPU). This can be particularly useful for applications that need to move data back and forth between the device and host.
-
-- Improved Programming Productivity :
-
-As a positive side effect, UMM can reduce the lines of code, thereby improving programming productivity.
-
-In HIP, pinned memory allocations are coherent by default. Pinned memory is host memory mapped into the address space of all GPUs, meaning that the pointer can be used on both host and device. Using pinned memory instead of pageable memory on the host can improve bandwidth.
-
-While UMMcanprovide numerous benefits, it's important to be aware of the potential performance overhead associated with UMM. You must thoroughly test and profile your code to ensure it's the most suitable choice for your use case.
-
-## 15.5 Unified memory HIP runtime hints for the better performance
-
-Unified memory HIP runtime hints can help improve the performance of your code if you know your code's ability and infrastructure. Some hint techniques are presented in this section.
-
-Thehint functions can set actions on a selected device, which can be identified by hipGetDeviceProperties(&amp;prop, device\_id) . There are two special device\_id values:
-
-- hipCpuDeviceId = -1 means that the advised device is the CPU.
-- hipInvalidDeviceId = -2 means that the device is invalid.
-
-For the best performance, profile your application to optimize the utilization of HIP runtime hints.
-
-(continued from previous page)
-
-## 15.5.1 Data prefetching
-
-Data prefetching is a technique used to improve the performance of your application by moving data closer to the processing unit before it's actually needed.
-**Following code does:** The code snippet appears to be a malformed attempt to clone specific branches of two Git repositories from GitHub using the `git clone` command. The intention is to clone the repositories `clr` and `hip` from the `ROCm` organization, checking out the branch specified by the environment variable `ROCM_BRANCH`. However, the command is incorrectly written with `:lone` instead of `git clone`, which would result in an error if executed as is.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        // All                                                                                                                                                                                                        }
-                                                                                                                                                                                                      
-//                                                                                                                                                                                                        #                                                                                                                                                                                                        */
-                                                                                                                                                                                                       //                                                                                                                                                                                                        *
-                                                                                                                                                                                                       */
-
-                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       *
-
-                                                                                                                                                                                                       *                                                                                                                                                                                                        /*
-                                                                                                                                                                                                       /*
-
-                                                                                                                                                                                                       */                                                                                                                                                                                                        /
-                                                                                                                                                                                                       }
-```
-
-Remember to check the return status of hipMemPrefetchAsync() to ensure that the prefetch operations are completed successfully.
-
-## 15.5.2 Memory advice
-
-The effectiveness of hipMemAdvise() comes from its ability to inform the runtime system of the developer's intentions regarding memory usage. When the runtime system has knowledge of the expected memory access patterns, it can make better decisions about data placement and caching, leading to more efficient execution of the application. However, the actual impact on performance can vary based on the specific use case and the hardware architecture.
-
-For the description of hipMemAdvise() and the detailed list of advice, visit the HIP managed memory allocation API .
-
-Here is the updated version of the example above with memory advice.
-**Following code does:** The code snippet `<_Bash_>` appears to be a placeholder or a tag indicating that a Bash script or command is expected to be inserted or referenced there. It does not contain any actual executable code or commands. Therefore, it does not perform any operations or have a specific functionality on its own.
-
-
-```
-
-    The effectiveness of nipMemAdvise() comes from its ability to inform the runtime system at the developer's intentions
-    regarding memory usage. When the runtime system has knowledge of the expected memory access patterns, it can make
-    better decisions about data placement and caching, leading to more efficient execution of the application. However, the
-    actual impact on performance can vary based on the specific use case and the hardware architecture.
-    For the description of hipMemAdvise() and the detailed list of advice, visit the HIP managed memory allocation API.
-    Here is the updated version of the example above with memory advice.
-    
-  #include <hip/hip_runtime.h>
-  #include <iostream>
-    
-  // Addition of two values.
-  __global__ void add(int *a, int *b, int *c) {
-      *c = *a + *b;
-  }
-  
-  int main() {
-      int *a, *b, *c;
-      
-      // Allocate memory for a, b, and c accessible to both device and host codes.
-      hipMallocManaged(&a, sizeof(*a));
-      hipMallocManaged(&b, sizeof(*b));
-      hipMallocManaged(&c, sizeof(*c));
-      
-      // Set memory advice for a, b, and c to be accessed by the CPU.
-      hipMemAdvise(a, sizeof(*a), hipMemAdviseSetPreferredLocation, hipCpuDeviceId);
-      hipMemAdvise(b, sizeof(*b), hipMemAdviseSetPreferredLocation, hipCpuDeviceId);
-      hipMemAdvise(c, sizeof(*c), hipMemAdviseSetPreferredLocation, hipCpuDeviceId);
-      
-      // Additionally, set memory advice for a, b, and c to be read mostly from the device.
-  __0.
-      constexpr int device = 0;
-      hipMemAdvise(a, sizeof(*a), hipMemAdviseSetReadMostly, device);
-      hipMemAdvise(b, sizeof(*b), hipMemAdviseSetReadMostly, device);
-      hipMemAdvise(c, sizeof(*c), hipMemAdviseSetReadMostly, device);
-      
-      // Setup input values.
-      *a = 1;
-      *b = 2;
-      
-      // Launch add() kernel on GPU.
-      hipLaunchKernelGGL(add, dim3(1), dim3(1), 0, 0, a, b, c);
-      
-      // Wait for GPU to finish before accessing on host.
-      hipDeviceSynchronize();
-      
-      // Prints the result.
-      std::cout << *a << " + " << *b << " = " << *c << std::endl;
-      
-      // Cleanup allocated memory.
-      hipFree(a);
-      
-                                                                                                                                                                                                         (continues on next page)
-      
-      
-      
-  106
-```
-
-(continues on next page)
-**Following code does:** This code snippet is a shell script that automates the process of building and installing a software project using CMake and Make. Here's a high-level summary of what it does:
-
-1. It changes the current directory to the one specified by the `CLR_DIR` environment variable.
-2. It creates a `build` directory if it doesn't already exist and then changes into that directory.
-3. It runs the `cmake` command to configure the build system. This command specifies various options, such as the HIP common directory, the HIP platform, and the CMake prefix path. It also sets certain build flags, like enabling HIP support and disabling OpenCL support.
-4. It compiles the project using `make`, utilizing all available CPU cores (`-j$(nproc)`).
-5. Finally, it installs the compiled software using `sudo make install`, which typically requires administrative privileges.
-
-
-```
-      hipFree(b);
-      hipFree(c);
-
-      return 0;
-}
-```
-
-## 15.5.3 Memory range attributes
-
-Memory Range attributes allow you to query attributes of a given memory range.
-
-The hipMemRangeGetAttribute() is added to the example to query the hipMemRangeAttributeReadMostly attribute of the memory range pointed to by a . The result is stored in attributeValue and then printed out.
-
-For more details, visit the HIP managed memory allocation API .
-**Following code does:** The code snippet you provided seems to be a placeholder or a tag indicating PHP code, but it does not contain any actual PHP code to analyze. If you have a specific PHP code snippet you'd like me to explain, please provide the actual code, and I'd be happy to help!
-
-
-```
-
-        Memory Range attributes allow you to query attributes of a given memory range.
-        The hipMemRangeGetAttribute() is added to the example to query the hipMemRangeAttributeReadMostly at-
-        title of the memory range pointed to by a. The result is stored in attributeValue and then printed out.
-        For more details, visit the HIP managed memory allocation API.
-        #include <hip/hip_runtime.h>
-        #include <iostream>
-        
-        // Addition of two values.
-        __global__ void add(int *a, int *b, int *c) {
-            *c = *a + *b;
-        }
-        
-        int main() {
-            int *a, *b, *c;
-            unsigned int attributeValue;
-            constexpr size_t attributeSize = sizeof(attributeValue);
-            
-            // Allocate memory for a, b and c that is accessible to both device and host codes.
-            hipMallocManaged(&a, sizeof(*a));
-            hipMallocManaged(&b, sizeof(*b));
-            hipMallocManaged(&c, sizeof(*c));
-            
-            // Setup input values.
-            *a = 1;
-            *b = 2;
-            
-            // Launch add() kernel on GPU.
-            hipLaunchKernelGGL(add, dim3(1), dim3(1), 0, 0, a, b, c);
-            
-            // Wait for GPU to finish before accessing on host.
-            hipDeviceSynchronize();
-            
-            // Query an attribute of the memory range.
-            hipMemRangeGetAttribute(&attributeValue,
-                                             attributeSize,
-                                              hipMemRangeAttributeReadMostly,
-                                              a,
-                                               sizeof(*a));
-             
-            // Prints the result.
-            std::cout << *a << " + " << *b << " = " << *c << std::endl;
-                                                                                                                                                                                                         (continues on next page)
-                                                                                                                                                                                                      
-                                                                                                                                                                                                       )
-                                                                                                                                                                                                       (Continues on next page)
-```
-
-(continues on next page)
-
-(continued from previous page)
-
-(continued from previous page)
-**Following code does:** The code snippet provided appears to be a malformed or corrupted text, possibly due to formatting issues or errors in copying. It includes a mix of symbols and text that do not form a valid or meaningful Python code. Therefore, it does not perform any specific function or task in its current state.
-
-
-```
-    std::cout << "The queried attribute value is: " << attributeValue << std::endl;
-
-    // Cleanup allocated memory.
-    hipFree(a);
-    hipFree(b);
-    hipFree(c);
-
-    return 0;
-}
-```
-
-## 15.5.4 Asynchronously attach memory to a stream
-
-The hipStreamAttachMemAsync function would be able to asynchronously attach memory to a stream, which can help concurrent execution when using streams.
-
-Currently, this function is a no-operation (NOP) function on AMD GPUs. It simply returns success after the runtime memory validation passed. This function is necessary on Microsoft Windows, and UMM is not supported on this operating system with AMD GPUs at the moment.
-
-CHAPTER
-
-## SIXTEEN
-
-## VIRTUAL MEMORY MANAGEMENT
-
-Memorymanagement is important when creating high-performance applications in the HIP ecosystem. Both allocating and copying memory can result in bottlenecks, which can significantly impact performance.
-
-Global memory allocation in HIP uses the C language style allocation function. This works fine for simple cases but can cause problems if your memory needs change. If you need to increase the size of your memory, you must allocate a second larger buffer and copy the data to it before you can free the original buffer. This increases overall memory usage and causes unnecessary memcpy calls. Another solution is to allocate a larger buffer than you initially need. However, this isn't an efficient way to handle resources and doesn't solve the issue of reallocation when the extra buffer runs out.
-
-Virtual memory management solves these memory management problems. It helps to reduce memory usage and unnecessary memcpy calls.
-
-## 16.1 Memory allocation
-
-Standard memory allocation uses the hipMalloc function to allocate a block of memory on the device. However, when using virtual memory, this process is separated into multiple steps using the hipMemCreate , hipMemAddressReserve , hipMemMap , and hipMemSetAccess functions. This guide explains what these functions do and how you can use them for virtual memory management.
-
-## 16.1.1 Allocate physical memory
-
-The first step is to allocate the physical memory itself with the hipMemCreate function. This function accepts the size of the buffer, an unsigned long long variable for the flags, and a hipMemAllocationProp variable. hipMemAllocationProp contains the properties of the memory to be allocated, such as where the memory is physically located and what kind of shareable handles are available. If the allocation is successful, the function returns a value of hipSuccess , with hipMemGenericAllocationHandle\_t representing a valid physical memory allocation. The allocated memory size must be aligned with the granularity appropriate for the properties of the allocation. You can use the hipMemGetAllocationGranularity function to determine the correct granularity.
-**Following code does:** The code snippet you provided seems to be a placeholder or an incomplete representation of a code block, as it only contains `<_Bash_>`. This suggests that it might be intended to indicate a section where Bash script or commands should be inserted. Without actual Bash code or commands, it's not possible to determine its purpose or functionality. If you have a specific Bash script or command in mind, please provide the complete code for a more detailed explanation.
-
-
-```
-<_C_>
-```
-
-## 16.1.2 Reserve virtual address range
-
-After you have acquired an allocation of physical memory, you must map it before you can use it. To do so, you need a virtual address to map it to. Mapping means the physical memory allocation is available from the virtual address range it is mapped to. To reserve a virtual memory range, use the hipMemAddressReserve function. The size of the virtual memory must match the amount of physical memory previously allocated. You can then map the physical memory allocation to the newly-acquired virtual memory address range using the hipMemMap function.
-**Following code does:** The code snippet appears to be a mix of Python and C/C++ style comments and directives. However, it is mostly composed of whitespace and does not contain any executable code. The only meaningful part is the `#pragma unroll 16`, which is a compiler directive typically used in C/C++ to suggest that the compiler should unroll the following loop 16 times to potentially optimize performance. However, without any actual loop or surrounding code, this directive has no effect. Overall, the snippet does not perform any operations or have a functional purpose.
-
-
-```
-0) ;
-```
-**Following code does:** The code snippet appears to be malformed and does not represent valid Python code. It seems to contain HTML-like tags (`<img>` and `</img>`) with the word "void" inside them, but these are not valid in Python. The snippet does not perform any meaningful operation or serve a functional purpose in a Python context.
-
-
-```
-<_C++_>
-```
-
-## 16.1.3 Set memory access
-
-Finally, use the hipMemSetAccess function to enable memory access. It accepts the pointer to the virtual memory, the size, and a hipMemAccessDesc descriptor as parameters. In a multi-GPU environment, you can map the device memory of one GPU to another. This feature also works with the traditional memory management system, but isn't as scalable as with virtual memory. When memory is allocated with hipMalloc , hipDeviceEnablePeerAccess is used to enable peer access. This function enables access between two devices, but it means that every call to hipMalloc takes more time to perform the checks and the mapping between the devices. When using virtual memory management, peer access is enabled by hipMemSetAccess , which provides a finer level of control over what is shared. This has no performance impact on memory allocation and gives you more control over what memory buffers are shared with which devices.
-**Following code does:** This code snippet is a command-line instruction using `hipcc`, which is a compiler for HIP (Heterogeneous-Compute Interface for Portability) programs. The command is used to generate a code object file for a specific GPU architecture. It takes an input file containing GPU kernels, compiles it for the specified target GPU architecture, and outputs the compiled code into a designated output file. The `--genco` flag indicates that the command is specifically for generating code objects, and `--offload-arch` specifies the target GPU architecture for which the code should be compiled.
-
-
-```
-hipMemAccessDesc accessDesc = {};
-accessDesc.location.type = HIP_MEM_LOCATION_TYPE_DEVICE;
-accessDesc.location.id = currentDev;
-accessDesc.flags = HIP_MEM_ACCESS_FLAGS_PROT_READWRITE;
-hipMemSetAccess(ptr, padded_size, &accessDesc, 1);
-```
-
-At this point the memory is allocated, mapped, and ready for use. You can read and write to it, just like you would a C style memory allocation.
-
-## 16.1.4 Free virtual memory
-
-To free the memory allocated in this manner, use the corresponding free functions. To unmap the memory, use hipMemUnmap . To release the virtual address range, use hipMemAddressFree . Finally, to release the physical memory, use hipMemRelease . A side effect of these functions is the lack of synchronization when memory is released. If you call hipFree when you have multiple streams running in parallel, it synchronizes the device. This causes worse resource usage and performance.
-**Following code does:** This code snippet is a series of shell commands that clone specific branches of three different repositories from GitHub. The repositories are related to the ROCm (Radeon Open Compute) platform, which is an open-source software platform for GPU computing. The branches being cloned are specified by the environment variable `ROCM_BRANCH`. The repositories being cloned are `clr`, `hip`, and `hipother`, all from the ROCm organization on GitHub. This setup is typically used to obtain specific versions of these projects for development or deployment purposes.
-
-
-```
-        |hipMemUnmap(ptr, size);
-        |hipMemRelease(allocHandle);
-```
-**Following code does:** The code snippet appears to be part of a script or instructions for setting up a development environment related to HIP (Heterogeneous-Compute Interface for Portability). It outlines two main steps: 
-
-1. Cloning the HIP source code from a repository using Git, specifically checking out a branch specified by the environment variable `$ROCM_BRANCH`. The repetition of the `git clone` command suggests either a mistake or an incomplete snippet where different repositories or directories might be intended.
-
-2. Setting environment variables, which is a common step in configuring a development environment to ensure that the necessary paths and settings are available for building or running the software.
-
-Overall, the snippet is part of a setup process for working with HIP, likely in the context of ROCm (Radeon Open Compute), a platform for GPU computing.
-
-
-```
-        |hipMemAddressFree(ptr,  size);
-```
-
-## 16.2 Memory usage
-
-## 16.2.1 Dynamically increase allocation size
-
-The hipMemAddressReserve function allows you to increase the amount of pre-allocated memory. This function accepts a parameter representing the requested starting address of the virtual memory. This allows you to have a continuous virtual address space without worrying about the underlying physical allocation.
-**Following code does:** This code snippet sets three environment variables (`CLR_DIR`, `HIP_DIR`, and `HIP_OTHER`) to the absolute paths of the directories named `clr`, `hip`, and `hipother`, respectively. The `readlink -f` command is used to resolve and return the full path of each directory, ensuring that any symbolic links are followed to their final target locations. This setup is typically used in shell scripts to configure paths for use in subsequent commands or scripts.
-
-
-```
-            hipMemAddressReserve(&new_ptr, (new_size - padded_size), 0, ptr + padded_size, 0);
-            hipMemMap(new_ptr, (new_size - padded_size), 0, newAllocHandle, 0);
-            hipMemSetAccess(new_ptr, (new_size - padded_size), &accessDesc, 1);
-```
-
-The code sample above assumes that hipMemAddressReserve was able to reserve the memory address at the specified location. However, this isn't guaranteed to be true, so you should validate that new\_ptr points to a specific virtual address before using it.
-
-## CHAPTER
-
-## SEVENTEEN
-
-## FREQUENTLY ASKED QUESTIONS
-
-## 17.1 What APIs and features does HIP support?
-
-HIP provides the following:
-
-- Devices ( hipSetDevice() , hipGetDeviceProperties() , etc.)
-- Memory management ( hipMalloc() , hipMemcpy() , hipFree() , etc.)
-- Streams ( hipStreamCreate() , hipStreamSynchronize() , hipStreamWaitEvent() , etc.)
-- Events ( hipEventRecord() , hipEventElapsedTime() , etc.)
-- Kernel launching ( hipLaunchKernel / hipLaunchKernelGGL is the preferred way of launching kernels. hipLaunchKernelGGL is a standard C/C++ macro that can serve as an alternative way to launch kernels, replacing the CUDA triple-chevron ( &lt;&lt;&lt; &gt;&gt;&gt; ) syntax).
-- HIP Module API to control when and how code is loaded.
-- CUDA-style kernel coordinate functions ( threadIdx , blockIdx , blockDim , gridDim )
-- Cross-lane instructions including shfl , ballot , any , all
-- Most device-side math built-ins
-- Error reporting ( hipGetLastError() , hipGetErrorString() )
-
-The HIP API documentation describes each API and its limitations, if any, compared with the equivalent CUDA API.
-
-## 17.2 What is not supported?
-
-## 17.2.1 Runtime/Driver API features
-
-At a high-level, the following features are not supported:
-
-- Textures (partial support available)
-- Dynamic parallelism (CUDA 5.0)
-- Graphics interoperability with OpenGL or Direct3D
-- CUDA IPC Functions (Under Development)
-- CUDA array, mipmappedArray and pitched memory
-- Queue priority controls
-
-See the API Support Table for more detailed information.
-
-## 17.2.2 Kernel language features
-
-- C+ ± style device-side dynamic memory allocations (free, new, delete) (CUDA 4.0)
-- Virtual functions, indirect functions and try/catch (CUDA 4.0)
-- \_\_prof\_trigger
-- PTX assembly (CUDA 4.0). HIP-Clang supports inline GCN assembly.
-- Several kernel features are under development. See the C++ language extensions for more information.
-
-## 17.3 Is HIP a drop-in replacement for CUDA?
-
-No. HIP provides porting tools which do most of the work to convert CUDA code into portable C++ code that uses the HIP APIs. Most developers will port their code from CUDA to HIP and then maintain the HIP version. HIP code provides the same performance as native CUDA code, plus the benefits of running on AMD platforms.
-
-## 17.4 What specific version of CUDA does HIP support?
-
-HIP APIs and features do not map to a specific CUDA version. HIP provides a strong subset of the functionality provided in CUDA, and the hipify tools can scan code to identify any unsupported CUDA functions - this is useful for identifying the specific features required by a given application.
-
-However, we can provide a rough summary of the features included in each CUDA SDK and the support level in HIP. Each bullet below lists the major new language features in each CUDA release and then indicate which are supported/not supported in HIP:
-
-- CUDA 4.0 and earlier :
-- -HIP supports CUDA 4.0 except for the limitations described above.
-- CUDA 5.0 :
-- -Dynamic Parallelism (not supported)
-- -cuIpc functions (under development).
-- CUDA 6.0 :
-- -Managed memory (under development)
-- CUDA 6.5 :
-- -\_\_shfl intrinsic (supported)
-- CUDA 7.0 :
-- -Per-thread default streams (supported)
-- -C++11 (Hip-Clang supports all of C++11, all of C++14 and some C++17 features)
-- CUDA 7.5 :
-- -float16 (supported)
-- CUDA 8.0 :
-- -Page Migration including cudaMemAdvise , cudaMemPrefetch , other cudaMem* APIs(not supported)
-- CUDA 9.0 :
-
-- -Cooperative Launch, Surface Object Management, Version Management
-
-## 17.5 What libraries does HIP support?
-
-HIP includes growing support for the four key math libraries using hipBLAS, hipFFT, hipRAND and hipSPARSE, as well as MIOpen for machine intelligence applications. These offer pointer-based memory interfaces (as opposed to opaque buffers) and can be easily interfaced with other HIP applications. The hip interfaces support both ROCm and CUDA paths, with familiar library interfaces.
-
-- hipBLAS, which utilizes rocBlas.
-- hipFFT
-- hipsSPARSE
-- hipRAND
-- MIOpen
-
-Additionally, some of the cuBLAS routines are automatically converted to hipblas equivalents by the HIPIFY tools. These APIs use cuBLAS or hcBLAS depending on the platform and replace the need to use conditional compilation.
-
-## 17.6 How does HIP compare with OpenCL?
-
-Both AMD and NVIDIA support OpenCL 1.2 on their devices so that developers can write portable code. HIP offers several benefits over OpenCL:
-
-- Developers can code in C++ as well as mix host and device C++ code in their source files. HIP C++ code can use templates, lambdas, classes and so on.
-- The HIP API is less verbose than OpenCL and is familiar to CUDA developers.
-- Because both CUDA and HIP are C++ languages, porting from CUDA to HIP is significantly easier than porting from CUDA to OpenCL.
-- HIP uses the best available development tools on each platform: on NVIDIA GPUs, HIP code compiles using NVCC and can employ the Nsight profiler and debugger (unlike OpenCL on NVIDIA GPUs).
-- HIP provides pointers and host-side pointer arithmetic.
-- HIP provides device-level control over memory allocation and placement.
-- HIP offers an offline compilation model.
-
-## 17.7 How does porting CUDA to HIP compare to porting CUDA to OpenCL?
-
-Both HIP and CUDA are dialects of C++, and thus porting between them is relatively straightforward. Both dialects support templates, classes, lambdas, and other C++ constructs. As one example, the hipify-perl tool was originally a Perl script that used simple text conversions from CUDA to HIP. HIP and CUDA provide similar math library calls as well. In summary, the HIP philosophy was to make the HIP language close enough to CUDA that the porting effort is relatively simple. This reduces the potential for error, and also makes it easy to automate the translation. HIP goal is to quickly get the ported program running on both platforms with little manual intervention, so that the programmer can focus on performance optimizations.
-
-There have been several tools that have attempted to convert CUDA into OpenCL, such as CU2CL. OpenCL is a C99based kernel language (rather than C++) and also does not support single-source compilation. As a result, the OpenCL syntax is different from CUDA, and the porting tools have to perform some heroic transformations to bridge this gap. The tools also struggle with more complex CUDA applications, in particular, those that use templates, classes, or other C++ features inside the kernel.
-
-## 17.8 What hardware does HIP support?
-
-- For AMD platforms, see the ROCm documentation for the list of supported platforms.
-- For NVIDIA platforms, HIP requires unified memory and should run on any device supporting CUDA SDK 6.0 or newer. We have tested the NVIDIA Titan and Tesla K40.
-
-## 17.9 Do HIPIFY tools automatically convert all source code?
-
-Typically, HIPIFY tools can automatically convert almost all run-time code. Most device code needs no additional conversion since HIP and CUDA have similar names for math and built-in functions. The hipify-clang tool will automatically modify the kernel signature as needed (automating a step that used to be done manually). Additional porting may be required to deal with architecture feature queries or with CUDA capabilities that HIP doesn't support. In general, developers should always expect to perform some platform-specific tuning and optimization.
-
-## 17.10 What is NVCC?
-
-NVCC is NVIDIA's compiler driver for compiling 'CUDA C++' code into PTX or device code for NVIDIA GPUs. It's a closed-source binary compiler that is provided by the CUDA SDK.
-
-## 17.11 What is HIP-Clang?
-
-HIP-Clang is a Clang/LLVM based compiler to compile HIP programs which can run on AMD platform.
-
-## 17.12 Why use HIP rather than supporting CUDA directly?
-
-While HIP is a strong subset of the CUDA, it is a subset. The HIP layer allows that subset to be clearly defined and documented. Developers who code to the HIP API can be assured their code will remain portable across NVIDIA and AMD platforms. In addition, HIP defines portable mechanisms to query architectural features and supports a larger 64-bit WaveSize which expands the return type for cross-lane functions like ballot and shuffle from 32-bit integers to 64-bit integers.
-
-## 17.13 Can I develop HIP code on an NVIDIA CUDA platform?
-
-Yes. HIP's CUDA path only exposes the APIs and functionality that work on both NVCC and AMDGPU back-ends. 'Extra' APIs, parameters, and features which exist in CUDA but not in HIP-Clang will typically result in compile-time or run-time errors. Developers need to use the HIP API for most accelerator code and bracket any CUDA-specific code with preprocessor conditionals. Developers concerned about portability should, of course, run on both platforms, and should expect to tune for performance. In some cases, CUDA has a richer set of modes for some APIs, and some C++ capabilities such as virtual functions - see the HIP @API documentation for more details.
-
-## 17.14 Can I develop HIP code on an AMD HIP-Clang platform?
-
-Yes. HIP's HIP-Clang path only exposes the APIs and functions that work on AMD runtime back ends. 'Extra' APIs, parameters and features that appear in HIP-Clang but not CUDA will typically cause compile- or run-time errors. Developers must use the HIP API for most accelerator code and bracket any HIP-Clang specific code with preprocessor conditionals. Those concerned about portability should, of course, test their code on both platforms and should tune it for performance. Typically, HIP-Clang supports a more modern set of C++11/C++14/C++17 features, so HIP developers who want portability should be careful when using advanced C++ features on the HIP-Clang path.
-
-## 17.15 How to use HIP-Clang to build HIP programs?
-
-The environment variable can be used to set compiler path:
-
-- HIP\_CLANG\_PATH: path to hip-clang. When set, this variable let hipcc to use hip-clang for compilation/linking.
-
-There is an alternative environment variable to set compiler path:
-
-- HIP\_ROCCLR\_HOME: path to root directory of the HIP-ROCclr runtime. When set, this variable let hipcc use hip-clang from the ROCclr distribution. NOTE: If HIP\_ROCCLR\_HOME is set, there is no need to set HIP\_CLANG\_PATH since hipcc will deduce them from HIP\_ROCCLR\_HOME.
-
-## 17.16 What is AMD clr?
-
-AMD Common Language Runtime (CLR) is a repository for the AMD platform, which contains source codes for AMD's compute languages runtimes as follows,
-
-- hipamd - contains implementation of HIP language for AMD GPU.
-- rocclr - contains virtual device interfaces that compute runtimes interact with backends, such as ROCr on Linux and PAL on Windows.
-- opencl - contains implementation of OpenCL™ on the AMD platform.
-
-## 17.17 What is hipother?
-
-A new repository 'hipother' is added in the ROCm 6.1 release, which is branched out from HIP. hipother supports the HIP back-end implementation on some non-AMD platforms, like NVIDIA.
-
-## 17.18 Can I get HIP open source repository for Windows?
-
-No, there is no HIP repository open publicly on Windows.
-
-## 17.19 Can a HIP binary run on both AMD and NVIDIA platforms?
-
-HIP is a source-portable language that can be compiled to run on either AMD or NVIDIA platform. HIP tools don't create a 'fat binary' that can run on either platform, however.
-
-## 17.20 On HIP-Clang, can I link HIP code with host code compiled with another compiler such as gcc, icc, or clang?
-
-Yes. HIP generates the object code which conforms to the GCC ABI, and also links with libstdc++. This means you can compile host code with the compiler of your choice and link the generated object code with GPU code compiled with HIP. Larger projects often contain a mixture of accelerator code (initially written in CUDA with NVCC) and host code (compiled with gcc, icc, or clang). These projects can convert the accelerator code to HIP, compile that code with hipcc, and link with object code from their preferred compiler.
-
-## 17.21 Can HIP API support C style application? What is the difference between C and C++?
-
-HIP is C++ runtime API that supports C style applications as well.
-
-Some C style applications (and interfaces to other languages (FORTRAN, Python)) would call certain HIP APIs but not use kernel programming. They can be compiled with a C compiler and run correctly, however, small details must be considered in the code. For example, initialization, as shown in the simple application below, uses HIP structs dim3 with the file name 'test.hip.cpp'
-**Following code does:** The code snippet provided is not a valid Python code. It appears to be a fragment of a list or a set of instructions, specifically the third step in a sequence, which is "Build HIP." Without additional context, it's unclear what "HIP" refers to, but it could be an acronym or a specific component in a larger process. The snippet suggests that this step involves constructing or assembling something referred to as HIP.
-
-
-```
-                                                                                                                                                                                                        //the file name `test.hip.cpp`
-                                                                                                                                                                                                       
-                                                                                                                                                                                                      
-#include "hip/hip_runtime_api.h"
-                                                                                                                                                                                                       //this file name `test.hip.cpp`
-                                                                                                                                                                                             
-          int main(int argc, char** argv) {
-            dim3 grid1;
-            printf("dim3 grid1; x=%d, y=%d, z=%d\n",grid1.x,grid1.y,grid1.z);
-            dim3 grid2 = {1,1,1};
-            printf("dim3 grid2 = {1,1,1}; x=%d, y=%d, z=%d\n",grid2.x,grid2.y,grid2.z);
-            return 0;
-            }
-```
-
-When using a C++ compiler,
-**Following code does:** This code snippet is a shell script that automates the process of building and installing a software project using CMake and Make, specifically targeting a HIP (Heterogeneous-Compute Interface for Portability) platform with NVIDIA support. Here's a high-level breakdown of its purpose:
-
-1. **Change Directory**: It navigates to a directory specified by the environment variable `CLR_DIR`.
-
-2. **Create and Navigate to Build Directory**: It creates a `build` directory if it doesn't exist and then changes into it.
-
-3. **Configure the Build with CMake**: It runs the `cmake` command to configure the build system. Various options are set, such as:
-   - `HIP_COMMON_DIR` and `HIPNV_DIR` for specifying directories related to HIP.
-   - `HIP_PLATFORM=nvidia` to target NVIDIA GPUs.
-   - `CMAKE_INSTALL_PREFIX` to set the installation directory to the current working directory.
-   - Disabling certain build options like `HIP_CATCH_TEST` and `CLR_BUILD_OCL`.
-
-4. **Compile the Project**: It uses `make` with parallel execution (`-j$(nproc)`) to compile the project, utilizing all available CPU cores.
-
-5. **Install the Compiled Software**: It runs `sudo make install` to install the compiled software, which typically requires superuser privileges.
-
-Overall, this script is used to build and install a HIP-based software project configured for NVIDIA GPUs.
-
-
-```
-$ gcc -x c++  $(hipconfig --cpp_config) test3.hip.cpp -o test
-$./test
-dim3 grid1; x=1, y=1, z=1
-dim3 grid2 = {1,1,1}; x=1, y=1, z=1
-```
-
-In which 'dim3 grid1;' will yield a dim3 grid with all dimensional members x,y,z initialized to 1, as the default constructor behaves that way. Further, if written: dim3 grid(2); // yields {2,1,1} dim3 grid(2,3); yields {2,3,1} In comparison, when using the C compiler, $ gcc -x c $( hipconfig --cpp\_config ) test.hip.cpp -o test $ ./test dim3 grid1; x=646881376, y=21975, z=1517277280 dim3 grid2 = {1,1,1}; x=1, y=1, z=1 In which 'dim3 grid;' does not imply any initialization, no constructor is called, and dimensional values x,y,z of grid are undefined. NOTE: To get the C++ default behavior, C programmers must additionally specify the right-hand side as shown below,
-**Following code does:** This code snippet is a shell command that uses `git` to clone a specific branch of a repository from GitHub. It clones the `hip-tests` repository from the ROCm (Radeon Open Compute) GitHub organization. The branch to be cloned is specified by the environment variable `ROCM_BRANCH`. This command is typically used to obtain a local copy of the code from a particular branch of the repository for development, testing, or deployment purposes.
-
-
-```
-        |dim3 grid = {1,1,1}; // initialized as in C++
-```
-**Following code does:** This code snippet appears to be a shell script intended for setting up and running tests for a project that uses HIP (Heterogeneous-Compute Interface for Portability), which is a C++ runtime API and kernel language that allows developers to create portable applications across different GPU platforms. Here's a high-level summary of what it does:
-
-1. **Set Environment Variable**: It sets the `HIPTESTS_DIR` environment variable to the absolute path of the `hip-tests` directory using `readlink -f`.
-
-2. **Navigate to Directory**: It changes the current directory to `HIPTESTS_DIR`.
-
-3. **Create and Navigate to Build Directory**: It creates a `build` directory if it doesn't exist and navigates into it.
-
-4. **Configure Build with CMake**: It runs `cmake` to configure the build system for the project, specifying the HIP platform as AMD and setting the HIP path to a specified directory.
-
-5. **Build Tests**: It compiles the test suite using `make build_tests`.
-
-6. **Run Tests**: It executes the tests using `ctest`.
-
-Overall, this script automates the process of setting up the environment, configuring, building, and running tests for a HIP-based project.
-
-
-```
-C++
-```
-
-## 17.22 Can I install both CUDA SDK and HIP-Clang on the same machine?
-
-Yes. You can use HIP\_PLATFORM to choose which path hipcc targets. This configuration can be useful when using HIP to develop an application which is portable to both AMD and NVIDIA.
-
-## 17.23 HIP detected my platform (HIP-Clang vs NVCC) incorrectly * what should I do?
-
-HIP will set the platform to AMD and use HIP-Clang as compiler if it sees that the AMD graphics driver is installed and has detected an AMD GPU. Sometimes this isn't what you want * you can force HIP to recognize the platform by setting the following,
-**Following code does:** The code snippet defines a function `ynf` that calculates and returns the value of the Bessel function of the second kind of order `n` for a given input `x`. Bessel functions are a family of solutions to Bessel's differential equation and are commonly used in various fields such as physics and engineering, particularly in problems involving cylindrical or spherical symmetry.
-
-
-```
-| export
-```
-**Following code does:** The code snippet appears to be a comment or documentation rather than executable code. It describes the process of building HIP (Heterogeneous-Compute Interface for Portability) tests using Catch2, a unit testing framework. Specifically, it mentions that these HIP tests are separate from the main HIP project and outlines a step to obtain the source code for these tests.
-
-
-```
-rt HIP_PLATFORM=amd
-```
-**Following code does:** This code snippet appears to be a part of a script or configuration file that compiles and runs a specific test for a HIP (Heterogeneous-Compute Interface for Portability) application. It navigates to a directory specified by the environment variable `HIPTESTS_DIR`, then uses the `hipcc` compiler to compile a C++ test file named `hipPointerGetAttributes.cc` along with some include directories. The compiled output is an executable named `hipPointerGetAttributes`, which is then executed. The purpose of this script is to test the functionality related to HIP pointer attributes, and it concludes with a message indicating that all tests have passed.
-
-
-```
-<_Python_>
-```
-**Following code does:** The code snippet `++i)` appears to be a syntax error in Python. In Python, the `++` operator does not exist as it does in languages like C++ or JavaScript. Instead, Python uses `i += 1` to increment a variable. The snippet seems to be an incomplete or incorrect attempt to increment a variable, possibly influenced by syntax from another programming language.
-
-
-```
-  | HIP_COMPILER=cuda
-```
-**Following code does:** The code snippet `<_SQL_>` appears to be a placeholder or a tag indicating that the actual SQL code is not provided. It suggests that the content is related to SQL, which is a language used for managing and manipulating relational databases. Without the actual SQL code, it's not possible to determine the specific operations or queries being performed. The placeholder might be used in documentation, templates, or code generation tools to signify where SQL code should be inserted or referenced.
-
-
-```
-  | HIP_RUNTIME=nvcc
-```
-
-One symptom of this problem is the message 'error: 'unknown error'(11) at square.hipref.cpp:56 . This can occur if you have a CUDA installation on an AMD platform, and HIP incorrectly detects the platform as NVCC. HIP may be able to compile the application using the NVCC tool-chain but will generate this error at runtime since the platform does not have a CUDA device.
-
-## 17.24 On CUDA, can I mix CUDA code with HIP code?
-
-Yes. Most HIP data structures ( hipStream\_t , hipEvent\_t ) are typedefs to CUDA equivalents and can be intermixed. Both CUDA and HIP use integer device ids. One notable exception is that hipError\_t is a new type, and cannot be used where a cudaError\_t is expected. In these cases, refactor the code to remove the expectation. Alternatively, hip\_runtime\_api.h defines functions which convert between the error code spaces:
-
-hipErrorToCudaError hipCUDAErrorTohipError hipCUResultTohipError
-
-If platform portability is important, use #ifdef \_\_HIP\_PLATFORM\_NVIDIA\_\_ to guard the CUDA-specific code.
-
-## 17.25 How do I trace HIP application flow?
-
-See Logging HIP activity for more information.
-
-## 17.26 What are the maximum limits of kernel launch parameters?
-
-Product of block.x, block.y, and block.z should be less than 1024. Please note, HIP does not support kernel launch with total work items defined in dimension with size gridDim x blockDim &gt;= 2^32 , so gridDim.x * blockDim.x, gridDim.y * blockDim.y and gridDim.z * blockDim.z are always less than 2^32.
-
-## 17.27 Are \_\_shfl\_*\_sync functions supported on HIP platform?
-
-\_\_shfl\_*\_sync is not supported on HIP but for NVCC path CUDA 9.0 and above all shuffle calls get redirected to it's sync version.
-
-## 17.28 How to create a guard for code that is specific to the host or the GPU?
-
-The compiler defines the \_\_HIP\_DEVICE\_COMPILE\_\_ macro only when compiling the code for the GPU. It could be used to guard code that is specific to the host or the GPU.
-
-## 17.29 Why \_OpenMP is undefined when compiling with -fopenmp ?
-
-When compiling an OpenMP source file with hipcc -fopenmp , the compiler may generate error if there is a reference to the \_OPENMP macro. This is due to a limitation in hipcc that treats any source file type (for example .cpp ) as an HIP translation unit leading to some conflicts with the OpenMP language switch. If the OpenMP source file doesn't contain any HIP language constructs you could work around this issue by adding the -x c++ switch to force the compiler to treat the file as regular C++. Another approach would be to guard the OpenMP code with #ifdef \_OPENMP so that the code block is disabled when compiling for the GPU. The \_\_HIP\_DEVICE\_COMPILE\_\_ macro defined by the HIP compiler when compiling GPU code could also be used for guarding code paths specific to the host or the GPU.
-
-## 17.30 Does the HIP-Clang compiler support extern shared declarations?
-
-Previously, it was essential to declare dynamic shared memory using the HIP\_DYNAMIC\_SHARED macro for accuracy, as using static shared memory in the same kernel could result in overlapping memory ranges and data-races.
-
-Now, the HIP-Clang compiler provides support for extern shared declarations, and the HIP\_DYNAMIC\_SHARED option is no longer required. You may use the standard extern definition: extern shared type var[];
-
-## 17.31 I have multiple HIP enabled devices and I am getting an error code hipErrorSharedObjectInitFailed with the message 'Error: shared object initialization failed'?
-
-This error message is seen due to the fact that you do not have valid code object for all of your devices.
-
-If you have compiled the application yourself, make sure you have given the correct device name(s) and its features via: --offload-arch . If you are not mentioning the --offload-arch , make sure that hipcc is using the correct offload arch by verifying the hipcc output generated by setting the environment variable HIPCC\_VERBOSE=1 .
-
-If you have a precompiled application/library (like rocblas, TensorFlow etc) which gives you such error, there are one of two possibilities.
-
-- The application/library does not ship code object bundles for all of your device(s): in this case you need to recompile the application/library yourself with correct --offload-arch .
-- The application/library does not ship code object bundles for some of your device(s), for example you have a system with an APU + GPU and the library does not ship code objects for your APU. For this you can set the environment variable HIP\_VISIBLE\_DEVICES or CUDA\_VISIBLE\_DEVICES on NVIDIA platform, to only enable GPUs for which code object is available. This will limit the GPUs visible to your application and allow it to run.
-
-Note: In previous releases, the error code is hipErrorNoBinaryForGpu with message 'Unable to find code object for all current devices'. The error code handling behavior is changed. HIP runtime shows the error code hipErrorSharedObjectInitFailed with message 'Error: shared object initialization failed' on unsupported GPU.
-
-## 17.32 How to use per-thread default stream in HIP?
-
-The per-thread default stream is an implicit stream local to both the thread and the current device. It does not do any implicit synchronization with other streams (like explicitly created streams), or default per-thread stream on other threads.
-
-The per-thread default stream is a blocking stream and will synchronize with the default null stream if both are used in a program.
-
-In ROCm, a compilation option should be added in order to compile the translation unit with per-thread default stream enabled. -fgpu-default-stream=per-thread . Once source is compiled with per-thread default stream enabled, all APIs will be executed on per thread default stream, hence there will not be any implicit synchronization with other streams.
-
-Besides, per-thread default stream be enabled per translation unit, users can compile some files with feature enabled and some with feature disabled. Feature enabled translation unit will have default stream as per thread and there will not be any implicit synchronization done but other modules will have legacy default stream which will do implicit synchronization.
-
-## 17.33 How to use complex multiplication and division operations?
-
-In HIP, hipFloatComplex and hipDoubleComplex are defined as complex data types,
-**Following code does:** This code is a command-line instruction that uses the `git` version control system to create a local copy (clone) of the repository located at the specified URL, `https://github.com/amd/rcm-examples.git`. This repository is hosted on GitHub and likely contains example code or resources related to AMD's RCM (Resource and Configuration Management) tools or projects. The cloned repository will be downloaded to the current directory where the command is executed.
-
-
-```
-<_C_>
-```
-
-Any application uses complex multiplication and division operations, need to replace '*' and '/' operators with the following,
-
-- hipCmulf() and hipCdivf() for hipFloatComplex
-- hipCmul() and hipCdiv() for hipDoubleComplex
-
-Note: These complex operations are equivalent to corresponding types/functions on the NVIDIA platform.
-
-## 17.34 Can I develop applications with HIP APIs on Windows the same on Linux?
-
-Yes, HIP APIs are available to use on both Linux and Windows. Due to different working mechanisms on operating systems like Windows vs Linux, HIP APIs call corresponding lower level backend runtime libraries and kernel drivers for the OS, in order to control the executions on GPU hardware accordingly. There might be a few differences on the related backend software and driver support, which might affect usage of HIP APIs. See OS support details in HIP API document.
-
-## 17.35 Does HIP support LUID?
-
-Starting ROCm 6.0, HIP runtime supports Locally Unique Identifier (LUID). This feature enables the local physical device(s) to interoperate with other devices. For example, DirectX 12.
-
-HIP runtime sets device LUID properties so the driver can query LUID to identify each device for interoperability.
-
-Note: HIP supports LUID only on Windows OS.
-
-## 17.36 How can I know the version of HIP?
-
-HIP version definition has been updated since ROCm 4.2 release as the following:
-**Following code does:** This code snippet is written in C++ using the HIP API, which is used for GPU programming. The code's high-level purpose is to allocate memory on a GPU device and copy data from the host (CPU) to the device (GPU). Specifically, it allocates memory for two float arrays (`d_x` and `d_y`) on the GPU, each with a size specified by `size_bytes`. It then copies data from two host arrays (`x` and `y`) to these newly allocated device arrays. The `HIP_CHECK` macro is likely used to handle errors that may occur during these operations.
-
-
-```
-<_SQL_>
-```
-
-HIP version can be queried from HIP API call, hipRuntimeGetVersion(&amp;runtimeVersion);
-
-The version returned will always be greater than the versions in previous ROCm releases.
-
-Note: The version definition of HIP runtime is different from CUDA. On AMD platform, the function returns HIP runtime version, while on NVIDIA platform, it returns CUDA runtime version. And there is no mapping/correlation between HIP version and CUDA version.
-
-## 18.1 Related Pages
-
-18.2 Topics
-
-## 18.3 Namespaces
-
-18.3.1 Namespace List
-
-18.3.2 Namespace Members
-
-18.3.2.1 Namespace Members
-
-18.3.2.2 Namespace Members
-
-## 18.4 Data Structures
-
-- 18.4.1 Data Structures
-- 18.4.2 Data Structure Index
-- 18.4.3 Class Hierarchy
-
-18.4.4 Data Fields
-
-18.4.4.1 All
-
-18.4.4.1.1 Data Fields
-
-18.4.4.1.2 Data Fields
-
-18.4.4.1.3 Data Fields
-
-18.4.4.1.4 Data Fields
-
-18.4.4.1.5 Data Fields
-
-18.4.4.1.6 Data Fields 26
-
-18.4.4.1.7 Data Fields
-
-CHAPTER
-
-## EIGHTEEN
-
-## HIP RUNTIME API REFERENCE
-
-## CHAPTER
-
-## NINETEEN
-
-## C++ LANGUAGE EXTENSIONS
-
-HIP provides a C++ syntax that is suitable for compiling most code that commonly appears in compute kernels (classes, namespaces, operator overloading, and templates). HIP also defines other language features that are designed to target accelerators, such as:
-
-- A kernel-launch syntax that uses standard C++ (this resembles a function call and is portable to all HIP targets)
-- Short-vector headers that can serve on a host or device
-- Math functions that resemble those in math.h , which is included with standard C++ compilers
-- Built-in functions for accessing specific GPU hardware capabilities
-
-Note: This chapter describes the built-in variables and functions that are accessible from the HIP kernel. It's intended for users who are familiar with CUDA kernel syntax and want to learn how HIP differs from CUDA.
-
-Features are labeled with one of the following keywords:
-
-- Supported : HIP supports the feature with a CUDA-equivalent function
-- Not supported : HIP does not support the feature
-- Under development : The feature is under development and not yet available
-
-## 19.1 Function-type qualifiers
-
-## 19.1.1 \_\_device\_\_
-
-Supported \_\_device\_\_ functions are:
-
-- Run on the device
-- Called from the device only
-
-You can combine \_\_device\_\_ with the host keyword ( \_\_host\_\_ ).
-
-## 19.1.2 \_\_global\_\_
-
-Supported \_\_global\_\_ functions are:
-
-- Run on the device
-- Called (launched) from the host
-
-HIP \_\_global\_\_ functions must have a void return type.
-
-HIP doesn't support dynamic-parallelism, which means that you can't call \_\_global\_\_ functions from the device.
-
-## 19.1.3 \_\_host\_\_
-
-Supported \_\_host\_\_ functions are:
-
-- Run on the host
-- Called from the host
-
-You can combine \_\_host\_\_ with \_\_device\_\_ ; in this case, the function compiles for the host and the device. Note that these functions can't use the HIP grid coordinate functions (e.g., threadIdx.x ). If you need to use HIP grid coordinate functions, you can pass the necessary coordinate information as an argument.
-
-You can't combine \_\_host\_\_ with \_\_global\_\_ .
-
-HIP parses the \_\_noinline\_\_ and \_\_forceinline\_\_ keywords and converts them into the appropriate Clang attributes.
-
-## 19.2 Calling \_\_global\_\_ functions
-
-\_\_global\_\_ functions are often referred to as kernels . When you call a global function, you're launching a kernel . When launching a kernel, you must specify an execution configuration that includes the grid and block dimensions. The execution configuration can also include other information for the launch, such as the amount of additional shared memory to allocate and the stream where you want to execute the kernel.
-
-HIP introduces a standard C++ calling convention ( hipLaunchKernelGGL ) to pass the run configuration to the kernel. However, you can also use the CUDA &lt;&lt;&lt; &gt;&gt;&gt; syntax.
-
-When using hipLaunchKernelGGL , your first five parameters must be:
-
-- symbol kernelName : The name of the kernel you want to launch. To support template kernels that contain "," , use the HIP\_KERNEL\_NAME macro (HIPIFY tools insert this automatically).
-- dim3 gridDim : 3D-grid dimensions that specify the number of blocks to launch.
-- dim3 blockDim : 3D-block dimensions that specify the number of threads in each block.
-- size\_t dynamicShared : The amount of additional shared memory that you want to allocate when launching the kernel (see \_\_shared\_\_ ).
-- hipStream\_t : The stream where you want to run the kernel. A value of 0 corresponds to the NULL stream (see Synchronization functions ).
-
-You can include your kernel arguments after these parameters.
-**Following code does:** This code snippet is part of a GPU programming context, likely using a framework like CUDA or HIP for parallel computing. The high-level purpose of the code is to perform a SAXPY operation (Single-Precision A·X Plus Y) on a GPU. The `saxpy_kernel` function is a kernel function that runs on the GPU and performs the SAXPY operation on arrays `d_x` and `d_y` with a scalar `a`. The `main` function sets up the execution environment and launches this kernel on the GPU using a specified grid and block size configuration. The kernel is executed on the default stream, which is a queue for managing the execution order of operations on the GPU.
-
-
-```
-                                                                                                                                                                                                        // Example hipLaunchKernelGGL pseudocode:
-```
-**Following code does:** The code snippet `<_Cuda_>` appears to be a placeholder or a symbolic representation rather than actual executable Python code. In a typical context, "Cuda" refers to NVIDIA's parallel computing platform and application programming interface (API) model, which allows developers to use a CUDA-enabled graphics processing unit (GPU) for general purpose processing. However, without additional context or surrounding code, it is not possible to determine the specific functionality or purpose of this snippet.
-
-
-```
-
-ize_t  N)
-```
-
-(continued from previous page)
-**Following code does:** This code snippet is part of a program that uses HIP, a C++ runtime API and kernel language that allows developers to write portable code to run on AMD and NVIDIA GPUs. The specific line of code is performing a memory copy operation from a GPU device to the host (CPU) memory. 
-
-Here's a high-level explanation of what it does:
-
-- `hipMemcpy` is a function that copies data between host and device memory.
-- `y.data()` is likely a pointer or an array on the host where the data will be copied to.
-- `d_y` is a pointer or an array on the device (GPU) from which the data will be copied.
-- `size_bytes` specifies the number of bytes to copy.
-- `hipMemcpyDeviceToHost` is an enumeration that indicates the direction of the copy, from device to host.
-
-The `HIP_CHECK` macro is likely used to check for errors in the `hipMemcpy` operation, ensuring that the memory copy was successful.
-
-
-```
-                                                                                                                                                                                                        (continued from previous page)
-                                                                                                                                                                                                       
-                                                                                                                                                                                                      
-}
-
-MyKernel<<<dim3(gridDim), dim3(groupDim), 0, 0>>> (a,b,c,n);
-
-// Alternatively, you can launch the kernel using:
-// hipLaunchKernelGGL(MyKernel, dim3(gridDim), dim3(groupDim), 0/*dynamicShared*/, 0/
-                                                                                                                                                                                                       :*stream), a, b, c, n);
-```
-
-You can use HIPIFY tools to convert CUDA launch syntax to hipLaunchKernelGGL . This includes the conversion of optional &lt;&lt;&lt; &gt;&gt;&gt; arguments into the five required hipLaunchKernelGGL parameters. Note: HIP doesn't support dimension sizes of 𝑔𝑟𝑖𝑑𝐷𝑖𝑚 * 𝑏𝑙𝑜𝑐𝑘𝐷𝑖𝑚 ≥ 2 32 when launching a kernel.
-
-## 19.3 Kernel launch example
-**Following code does:** This code snippet is a shell command that modifies the `PATH` environment variable. It prepends the directory `/opt/rcm/bin` to the existing `PATH`. This means that when the system searches for executable files, it will first look in `/opt/rcm/bin` before checking the other directories listed in the current `PATH`. This is typically done to prioritize custom or specific versions of executables located in `/opt/rcm/bin` over those in other directories.
-
-
-```
-
-// Example showing device function, __device__ __host__
-// <- compile for both device and host
-float PlusOne(float x)
-{
-  return x + 1.0;
-}
-
-__global__
-void
-MyKernel (hipLaunchParm lp, /*lp parm for execution configuration */
-          const float *a, const float *b, float *c, unsigned N)
-{
-  unsigned gid = threadIdx.x; // <- coordinate index function
-  if (gid < N) {
-    c[gid] = a[gid] + PlusOne(b[gid]);
-  }
-}
-void callMyKernel()
-{
-  float *a, *b, *c; // initialization not shown...
-  unsigned N = 1000000;
-  const unsigned blockSize = 256;
-
-  MyKernel<<<dim3(gridDim), dim3(groupDim), 0, 0>>> (a,b,c,n);
-  // Alternatively, kernel can be launched by
-  // hipLaunchKernelGGL(MyKernel, dim3(N/blockSize), dim3(blockSize), 0, 0, a,b,c,N);
-}
-```
-
-## 19.4 Variable type qualifiers
-
-## 19.4.1 \_\_constant\_\_
-
-The host writes constant memory before launching the kernel. This memory is read-only from the GPU while the kernel is running. The functions for accessing constant memory are:
-
-- hipGetSymbolAddress()
-- hipGetSymbolSize()
-- hipMemcpyToSymbol()
-- hipMemcpyToSymbolAsync()
-- hipMemcpyFromSymbol()
-- hipMemcpyFromSymbolAsync()
-
-## 19.4.2 \_\_shared\_\_
-
-To allow the host to dynamically allocate shared memory, you can specify extern \_\_shared\_\_ as a launch parameter.
-
-Note: Prior to the HIP-Clang compiler, dynamic shared memory had to be declared using the HIP\_DYNAMIC\_SHARED macro in order to ensure accuracy. This is because using static shared memory in the same kernel could've resulted in overlapping memory ranges and data-races. The HIP-Clang compiler provides support for extern \_\_shared\_ declarations, so HIP\_DYNAMIC\_SHARED is no longer required.
-
-## 19.4.3 \_\_managed\_\_
-
-Managed memory, including the \_\_managed\_\_ keyword, is supported in HIP combined host/device compilation.
-
-## 19.4.4 \_\_restrict\_\_
-
-\_\_restrict\_\_ tells the compiler that the associated memory pointer not to alias with any other pointer in the kernel or function. This can help the compiler generate better code. In most use cases, every pointer argument should use this keyword in order to achieve the benefit.
-
-## 19.5 Built-in variables
-
-## 19.5.1 Coordinate built-ins
-
-The kernel uses coordinate built-ins ( thread* , block* , grid* ) to determine the coordinate index and bounds for the active work item.
-
-Built-ins are defined in amd\_hip\_runtime.h , rather than being implicitly defined by the compiler.
-
-Coordinate variable definitions for built-ins are the same for HIP and CUDA. For example: threadIdx.x , blockIdx. y , and gridDim.y . The products gridDim.x * blockDim.x , gridDim.y * blockDim.y , and gridDim.z * blockDim.z are always less than 2^32 .
-
-Coordinate built-ins are implemented as structures for improved performance. When used with printf , they must be explicitly cast to integer types.
-
-## 19.5.2 warpSize
-
-The warpSize variable type is int . It contains the warp size (in threads) for the target device. warpSize should only be used in device functions that develop portable wave-aware code.
-
-Note: NVIDIA devices return 32 for this variable; AMD devices return 64 for gfx9 and 32 for gfx10 and above.
-
-## 19.6 Vector types
-
-The following vector types are defined in hip\_runtime.h . They are not automatically provided by the compiler.
-
-## 19.6.1 Short vector types
-
-Short vector types derive from basic integer and floating-point types. These structures are defined in hip\_vector\_types.h . The first, second, third, and fourth components of the vector are defined by the x , y , z , and w fields, respectively. All short vector types support a constructor function of the form make\_&lt;type\_name&gt;() . For example, float4 make\_float4(float x, float y, float z, float w) creates a vector with type float4 and value (x,y,z,w) .
-
-HIP supports the following short vector formats:
-
-- Signed Integers:
-- -char1 , char2 , char3 , char4
-- -short1 , short2 , short3 , short4
-- -int1 , int2 , int3 , int4
-- -long1 , long2 , long3 , long4
-- -longlong1 , longlong2 , longlong3 , longlong4
-- Unsigned Integers:
-- -uchar1 , uchar2 , uchar3 , uchar4
-- -ushort1 , ushort2 , ushort3 , ushort4
-- -uint1 , uint2 , uint3 , uint4
-- -ulong1 , ulong2 , ulong3 , ulong4
-- -ulonglong1 , ulonglong2 , ulonglong3 , ulonglong4
-- Floating Points:
-- -float1 , float2 , float3 , float4
-- -double1 , double2 , double3 , double4
-
-## 19.6.2 dim3
-
-dim3 is a three-dimensional integer vector type that is commonly used to specify grid and group dimensions.
-
-The dim3 constructor accepts between zero and three arguments. By default, it initializes unspecified dimensions to 1.
-**Following code does:** The code snippet provided is not valid Python code. It consists of a single closing curly brace `}`, which is not used in Python syntax. Curly braces are typically used in languages like C, C++, Java, and JavaScript to denote blocks of code, but in Python, indentation is used instead. Therefore, this snippet does not perform any function or operation in Python.
-
-
-```
-<_C_>
-```
-
-## 19.7 Memory fence instructions
-
-HIP supports \_\_threadfence() and \_\_threadfence\_block() . If you're using threadfence\_system() in the HIP-Clang path, you can use the following workaround:
-
-1. Build HIP with the HIP\_COHERENT\_HOST\_ALLOC environment variable enabled.
-2. Modify kernels that use \_\_threadfence\_system() as follows:
-- Ensure the kernel operates only on fine-grained system memory, which should be allocated with hipHostMalloc() .
-- Remove memcpy for all allocated fine-grained system memory regions.
-
-## 19.8 Synchronization functions
-
-Synchronization functions causes all threads in the group to wait at this synchronization point, and for all shared and global memory accesses by the threads to complete, before running synchronization. This guarantees the visibility of accessed data for all threads in the group.
-
-The \_\_syncthreads() built-in function is supported in HIP. The \_\_syncthreads\_count(int) , \_\_syncthreads\_and(int) , and \_\_syncthreads\_or(int) functions are under development.
-
-The Cooperative Groups API offer options to do synchronization on a developer defined set of thread groups. For further information, check Cooperative Groups API or Cooperative Groups how to .
-
-## 19.9 Math functions
-
-HIP-Clang supports a set of math operations that are callable from the device. HIP supports most of the device functions supported by CUDA. These are described on Math API page .
-
-## 19.10 Texture functions
-
-The supported texture functions are listed in texture\_fetch\_functions.h and texture\_indirect\_functions. h header files in the HIP-AMD backend repository.
-
-Texture functions are not supported on some devices. To determine if texture functions are supported on your device, use Macro \_\_HIP\_NO\_IMAGE\_SUPPORT == 1 . You can query the attribute hipDeviceAttributeImageSupport to check if texture functions are supported in the host runtime code.
-
-## 19.11 Surface functions
-
-The following surface functions are supported in HIP:
-
-hipError\_t hipCreateSurfaceObject ( hipSurfaceObject\_t *pSurfObject, const hipResourceDesc *pResDesc )
-
-Create a surface object.
-
-## Parameters
-
-- pSurfObject -[out] Pointer of surface object to be created.
-- pResDesc -[in] Pointer of suface object descriptor.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipDestroySurfaceObject ( hipSurfaceObject\_t surfaceObject )
-
-Destroy a surface object.
-
-## Parameters
-
-surfaceObject -[in] Surface object to be destroyed.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf1Dread ( T *data, hipSurfaceObject\_t surfObj, int x, int boundaryMode = hipBoundaryModeZero )
-
-Reads the value at coordinate x from the one-dimensional surface.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [out] The T type result is stored in this pointer.
-- surfObj - [in] The surface descriptor.
-- x - [in] The coordinate where the value will be read out.
-- boundaryMode - [in] The boundary mode is currently ignored.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf1Dwrite ( T data, hipSurfaceObject\_t surfObj, int x )
-
-Writes the value data to the one-dimensional surface at coordinate x.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [in] The T type value is written to surface.
-
-- surfObj - [in] The surface descriptor.
-- x - [in] The coordinate where the data will be written.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf2Dread ( T *data, hipSurfaceObject\_t surfObj, int x, int y )
-
-Reads the value from the two-dimensional surface at coordinate x, y.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [out] The T type result is stored in this pointer.
-- surfObj - [in] The surface descriptor.
-- x - [in] The x coordinate where the value will be read out.
-- y - [in] The y coordinate where the value will be read out.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf2Dwrite ( T data, hipSurfaceObject\_t surfObj, int x, int y )
-
-Writes the value data to the two-dimensional surface at coordinate x, y.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [in] The T type value is written to surface.
-- surfObj - [in] The surface descriptor.
-- x - [in] The x coordinate where the data will be written.
-- y - [in] The y coordinate where the data will be written.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf3Dread ( T *data, hipSurfaceObject\_t surfObj, int x, int y, int z )
-
-Reads the value from the three-dimensional surface at coordinate x, y, z.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [out] The T type result is stored in this pointer.
-- surfObj - [in] The surface descriptor.
-- x - [in] The x coordinate where the value will be read out.
-- y - [in] The y coordinate where the value will be read out.
-- z - [in] The z coordinate where the value will be read out.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf3Dwrite ( T data, hipSurfaceObject\_t surfObj, int x, int y, int z )
-
-Writes the value data to the three-dimensional surface at coordinate x, y, z.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [in] The T type value is written to surface.
-- surfObj - [in] The surface descriptor.
-- x - [in] The x coordinate where the data will be written.
-- y - [in] The y coordinate where the data will be written.
-- z - [in] The z coordinate where the data will be written.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf1DLayeredread ( T *data, hipSurfaceObject\_t surfObj, int x, int layer )
-
-Reads the value from the one-dimensional layered surface at coordinate x and layer index.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [out] The T type result is stored in this pointer.
-- surfObj - [in] The surface descriptor.
-- x - [in] The coordinate where the value will be read out.
-- layer - [in] The layer index where the value will be read out.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf1DLayeredwrite ( T data, hipSurfaceObject\_t surfObj, int x, int layer )
-
-Writes the value data to the one-dimensional layered surface at coordinate x and layer index.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [in] The T type value is written to surface.
-- surfObj - [in] The surface descriptor.
-- x - [in] The x coordinate where the data will be written.
-- layer - [in] The layer index where the data will be written.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf2DLayeredread ( T *data, hipSurfaceObject\_t surfObj, int x, int y, int layer )
-
-Reads the value from the two-dimensional layered surface at coordinate x, y and layer index.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [out] The T type result is stored in this pointer.
-- surfObj - [in] The surface descriptor.
-- x - [in] The x coordinate where the value will be read out.
-- y - [in] The y coordinate where the value will be read out.
-- layer - [in] The layer index where the value will be read out.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt;
-
-static void surf2DLayeredwrite ( T data, hipSurfaceObject\_t surfObj, int x, int y, int layer )
-
-Writes the value data to the two-dimensional layered surface at coordinate x, y and layer index.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [in] The T type value is written to surface.
-- surfObj - [in] The surface descriptor.
-- x - [in] The x coordinate where the data will be written.
-- y - [in] The y coordinate where the data will be written.
-- layer - [in] The layer index where the data will be written.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surfCubemapread ( T *data, hipSurfaceObject\_t surfObj, int x, int y, int face )
-
-Reads the value from the cubemap surface at coordinate x, y and face index.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [out] The T type result is stored in this pointer.
-- surfObj - [in] The surface descriptor.
-- x - [in] The x coordinate where the value will be read out.
-- y - [in] The y coordinate where the value will be read out.
-- face - [in] The face index where the value will be read out.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surfCubemapwrite ( T data, hipSurfaceObject\_t surfObj, int x, int y, int face )
-
-Writes the value data to the cubemap surface at coordinate x, y and face index.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [in] The T type value is written to surface.
-- surfObj - [in] The surface descriptor.
-- x - [in] The x coordinate where the data will be written.
-- y - [in] The y coordinate where the data will be written.
-- face - [in] The face index where the data will be written.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surfCubemapLayeredread ( T *data, hipSurfaceObject\_t surfObj, int x, int y, int face, int layer )
-
-Reads the value from the layered cubemap surface at coordinate x, y and face, layer index.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [out] The T type result is stored in this pointer.
-
-- surfObj - [in] The surface descriptor.
-- x - [in] The x coordinate where the value will be read out.
-- y - [in] The y coordinate where the value will be read out.
-- face - [in] The face index where the value will be read out.
-- layer - [in] The layer index where the data will be written.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surfCubemapLayeredwrite ( T *data, hipSurfaceObject\_t surfObj, int x, int y, int face, int layer )
-
-Writes the value data to the layered cubemap surface at coordinate x, y and face, layer index.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [in] The T type value to write to the surface.
-- surfObj - [in] The surface descriptor.
-- x - [in] The x coordinate where the data will be written.
-- y - [in] The y coordinate where the data will be written.
-- face - [in] The face index where the data will be written.
-- layer - [in] The layer index where the data will be written.
-
-## 19.12 Timer functions
-
-To read a high-resolution timer from the device, HIP provides the following built-in functions:
-
-- Returning the incremental counter value for every clock cycle on a device:
-**Following code does:** The code snippet is not actually a code but rather an instruction. It suggests that you should be able to execute a command in the command line to check the version of a compiler named `amdclang++`. This implies that `amdclang++` is a C++ compiler, likely provided by AMD, and the command `amdclang++ --version` is used to display the version information of this compiler.
-
-
-```
-<_SQL_>
-```
-**Following code does:** This code snippet is a shell command that checks the version of the NVIDIA CUDA Compiler (nvcc) installed on the system. By executing `nvcc --version`, it outputs the version information of the nvcc tool, which is part of the CUDA Toolkit used for compiling CUDA programs. This is useful for verifying the installation and version of CUDA on a machine.
-
-
-```
-    [clock_t clock()
-    long long int close
-```
-
-The difference between the values that are returned represents the cycles used.
-
-- Returning the wall clock count at a constant frequency on the device:
-**Following code does:** This PowerShell script is designed to set up a development environment for Visual Studio. Here's a high-level summary of what it does:
-
-1. **Locate Visual Studio Installation**: It retrieves a list of installed Visual Studio instances, sorts them by version in descending order, and selects the most recent one. It then extracts the installation path of this latest version.
-
-2. **Import Visual Studio Module**: It imports a specific Visual Studio module (`Microsoft.VisualStudio.DevShell.dll`) from the installation path. This module is likely used to facilitate the setup of a development shell environment.
-
-3. **Enter Visual Studio Developer Shell**: It enters the Visual Studio Developer Shell using the installation path determined earlier. It specifies the architecture as `amd64` for both the host and the development environment, and it suppresses the display of the logo with the `-no_logo` argument.
-
-4. **Modify Environment Path**: It updates the system's `PATH` environment variable by prepending a directory (`bin` subdirectory of `HIP_PATH`) to the existing `PATH`. This ensures that executables in this directory are prioritized when running commands.
-
-Overall, the script automates the process of setting up a Visual Studio development environment with specific configurations and updates the system path to include additional tools.
-
-
-```
-  | long long int w:
-```
-**Following code does:** This code snippet is a shell command that checks the version of the `clang++` compiler installed on the system. `clang++` is the C++ compiler that is part of the LLVM project. Running this command will output the version information of the `clang++` compiler, including details like the version number, target architecture, and possibly the build date.
-
-
-```
-    it will_clock64()
-```
-
-This can be queried using the HIP API with the hipDeviceAttributeWallClockRate attribute of the device in HIP application code. For example:
-**Following code does:** This PowerShell script is designed to set up a development environment for Visual Studio. It performs the following high-level tasks:
-
-1. **Retrieve Visual Studio Installation Path**: It queries the system for installed Visual Studio instances, sorts them by version in descending order, and selects the installation path of the latest version.
-
-2. **Import Visual Studio Development Shell Module**: It imports a specific module (`Microsoft.VisualStudio.DevShell.dll`) from the selected Visual Studio installation. This module is used to configure the development environment.
-
-3. **Enter Visual Studio Development Shell**: It initializes the Visual Studio Developer Command Prompt environment for the specified installation path, targeting the `amd64` architecture for both the host and the development environment, while suppressing the display of the logo. This sets up the necessary environment variables and paths for development tasks.
-
-
-```
-            int wallClkRate = 0; //in kilohertz
-            HIPCHECK(hipDeviceGetAttribute(&wallClkRate, hipDeviceAttributeWallClockRate, _
-            --deviceId));
-```
-
-Where hipDeviceAttributeWallClockRate is a device attribute. Note that wall clock frequency is a perdevice attribute.
-
-Note that clock() and clock64() do not work properly on AMD RDNA3 (GFX11) graphic processors.
-
-## 19.13 Atomic functions
-
-Atomic functions are run as read-modify-write (RMW) operations that reside in global or shared memory. No other device or thread can observe or modify the memory location during an atomic operation. If multiple instructions from different devices or threads target the same memory location, the instructions are serialized in an undefined order.
-
-To support system scope atomic operations, you can use the HIP APIs that contain the \_system suffix. For example:
-
-- atomicAnd : This function is atomic and coherent within the GPU device running the function
-- atomicAnd\_system : This function extends the atomic operation from the GPU device to other CPUs and GPU devices in the system.
-
-HIP supports the following atomic operations.
-
-Table 1: Atomic operations
-
-| Function int atomicAdd(int* address, int val) int atomicAdd_system(int* address, int val) unsigned int atomicAdd(unsigned int* address,unsigned unsigned int atomicAdd_system(unsigned int* address, unsigned long long atomicAdd(unsigned long long* unsigned long long atomicAdd_system(unsigned long long* float atomicAdd(float* address, float val) float atomicAdd_system(float* address, float val) double atomicAdd(double* address, double val) double atomicAdd_system(double* address, double val) float unsafeAtomicAdd(float* address, float val) float safeAtomicAdd(float* address, float val)   |
-|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| int val) unsigned int val) address,unsigned long long val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| address, unsigned long long val) double unsafeAtomicAdd(double* address, double val) double safeAtomicAdd(double* address, double val) int atomicSub(int* address, int val) int atomicSub_system(int* address, int val) unsigned int atomicSub(unsigned int* address,unsigned int val) unsigned int atomicSub_system(unsigned int* address, unsigned int val)                                                                                                                                                                                                                                                   |
-| int atomicExch(int* address, int val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
-| int atomicExch_system(int* address, int val) unsigned int atomicExch(unsigned int* address,unsigned int val) unsigned int atomicExch_system(unsigned int* address, unsigned int val)                                                                                                                                                                                                                                                                                                                                                                                                                            |
-| unsigned long long atomicExch(unsigned long long int* address,unsigned long val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-| long unsigned long long atomicExch_system(unsigned long long* address, unsigned long                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
-| int long val) unsigned long long atomicExch_system(unsigned long long* address, unsigned long long val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| float atomicExch(float* address, float val) int atomicMin(int* address, int val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-| int atomicMin_system(int* address, int val) unsigned int atomicMin(unsigned int* address,unsigned int                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
-| val) unsigned int atomicMin_system(unsigned int* address, unsigned int                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
-| val) unsigned long long atomicMin(unsigned long long* address,unsigned long long val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
-| atomicMax(int* address, int val) atomicMax_system(int* address, int val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
-| int unsigned int atomicMax(unsigned int* address,unsigned int val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
-| unsigned int atomicMax_system(unsigned int* address, unsigned int                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
-| int                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
-| val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
-| unsigned long long atomicMax(unsigned long long* address,unsigned long long val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-
-Table 1 - continued from previous page
-
-| unsigned int atomicDec(unsigned int* address)                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| int atomicCAS(int* address, int compare, int val)                                                                                                                                                                                                                                                                                                                                                                                                                              |
-| int atomicCAS_system(int* address, int compare, int val)                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| unsigned int atomicCAS(unsigned int* address,unsigned int compare,unsigned int val) unsigned int atomicCAS_system(unsigned int* address, unsigned int compare, unsigned int val) unsigned long long atomicCAS(unsigned long long* address,unsigned long long compare,unsigned long long unsigned long long atomicCAS_system(unsigned long long* address, unsigned long long compare, unsigned int atomicAnd(int* address, int val) int atomicAnd_system(int* address, int val) |
-| unsigned int atomicAnd(unsigned int* address,unsigned int val) unsigned int atomicAnd_system(unsigned int* address, unsigned int val)                                                                                                                                                                                                                                                                                                                                          |
-| unsigned long long atomicAnd(unsigned long long* address,unsigned long long val) unsigned long long atomicAnd_system(unsigned long long* address, unsigned long                                                                                                                                                                                                                                                                                                                |
-| long val) int atomicOr(int* address, int val)                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| int atomicOr_system(int* address, int val)                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| unsigned int atomicOr(unsigned int* address,unsigned int val) unsigned int atomicOr_system(unsigned int* address, unsigned                                                                                                                                                                                                                                                                                                                                                     |
-| int val) unsigned int atomicOr_system(unsigned int* address, unsigned int val)                                                                                                                                                                                                                                                                                                                                                                                                 |
-| unsigned long long atomicOr(unsigned long long int* address,unsigned long long val)                                                                                                                                                                                                                                                                                                                                                                                            |
-| unsigned long long atomicOr_system(unsigned long long* address, unsigned long long val)                                                                                                                                                                                                                                                                                                                                                                                        |
-| int atomicXor(int* address, int val)                                                                                                                                                                                                                                                                                                                                                                                                                                           |
-| int atomicXor_system(int* address, int val)                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| unsigned int atomicXor(unsigned int* address,unsigned int val)                                                                                                                                                                                                                                                                                                                                                                                                                 |
-| unsigned int atomicXor_system(unsigned int* address, unsigned int val)                                                                                                                                                                                                                                                                                                                                                                                                         |
-| unsigned long long atomicXor(unsigned long long* address,unsigned long long val)                                                                                                                                                                                                                                                                                                                                                                                               |
-| unsigned long long atomicXor_system(unsigned long long* address, unsigned long long                                                                                                                                                                                                                                                                                                                                                                                            |
-| val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
-
-## 19.13.1 Unsafe floating-point atomic RMW operations
-
-Some HIP devices support fast atomic RMW operations on floating-point values. For example, atomicAdd on singleor double-precision floating-point values may generate a hardware RMW instruction that is faster than emulating the atomic operation using an atomic compare-and-swap (CAS) loop.
-
-On some devices, fast atomic RMW instructions can produce results that differ from the same functions implemented with atomic CAS loops. For example, some devices will use different rounding or denormal modes, and some devices produce incorrect answers if fast floating-point atomic RMW instructions target fine-grained memory allocations.
-
-The HIP-Clang compiler offers a compile-time option, so you can choose fast-but potentially unsafe-atomic instructions for your code. On devices that support these instructions, you can include the -munsafe-fp-atomics option. This flag indicates to the compiler that all floating-point atomic function calls are allowed to use an unsafe version, if one exists. For example, on some devices, this flag indicates to the compiler that no floating-point atomicAdd function can target fine-grained memory.
-
-If you want to avoid using unsafe use a floating-point atomic RMW operations, you can use the -mno-unsafe-fp-atomics option. Note that the compiler default is to not produce unsafe floating-point atomic RMW instructions, so the -mno-unsafe-fp-atomics option is not necessarily required. However, passing this option to the compiler is good practice.
-
-When you pass -munsafe-fp-atomics or -mno-unsafe-fp-atomics to the compiler's command line, the option is applied globally for the entire compilation. Note that if some of the atomic RMW function calls cannot safely use the faster floating-point atomic RMW instructions, you must use -mno-unsafe-fp-atomics in order to ensure that your atomic RMW function calls produce correct results.
-
-HIP has four extra functions that you can use to more precisely control which floating-point atomic RMW functions produce unsafe atomic RMW instructions:
-
-- float unsafeAtomicAdd(float* address, float val)
-- double unsafeAtomicAdd(double* address, double val) (Always produces fast atomic RMW instructions on devices that have them, even when -mno-unsafe-fp-atomics is used)
-- float safeAtomicAdd(float* address, float val)
-- double safeAtomicAdd(double* address, double val) (Always produces safe atomic RMW operations, even when -munsafe-fp-atomics is used)
-
-## 19.14 Warp cross-lane functions
-
-Threads in a warp are referred to as lanes and are numbered from 0 to warpSize - 1 . Warp cross-lane functions operate across all lanes in a warp. The hardware guarantees that all warp lanes will execute in lockstep, so additional synchronization is unnecessary, and the instructions use no shared memory.
-
-Note that NVIDIA and AMD devices have different warp sizes. You can use warpSize built-ins in you portable code to query the warp size.
-
-Tip: Be sure to review HIP code generated from the CUDA path to ensure that it doesn't assume a waveSize of 32. 'Wave-aware' code that assumes a waveSize of 32 can run on a wave-64 machine, but it only utilizes half of the machine's resources.
-
-To get the default warp size of a GPU device, use hipGetDeviceProperties in you host functions.
-**Following code does:** This code snippet is a shell command that checks the version of the NVIDIA CUDA Compiler (nvcc) installed on the system. By executing `nvcc --version`, it outputs information about the installed version of nvcc, which is part of the CUDA toolkit used for compiling CUDA programs that run on NVIDIA GPUs.
-
-
-```
-    cudaDeviceProp props;
-    cudaGetDeviceProperties(&props, deviceID);
-    int w = props.warpSize;
-    // implement portable algorithm based on w (rather than assume 32 or 64)
-```
-
-Only use warpSize built-ins in device functions, and don't assume warpSize to be a compile-time constant.
-
-Note that assembly kernels may be built for a warp size that is different from the default. All mask values either returned or accepted by these builtins are 64-bit unsigned integer values, even when compiled for a wave-32 device, where all the higher bits are unused. CUDA code ported to HIP requires changes to ensure that the correct type is used.
-
-Note that the \_\_sync variants are made available in ROCm 6.2, but disabled by default to help with the transition to 64-bit masks. They can be enabled by setting the preprocessor macro HIP\_ENABLE\_WARP\_SYNC\_BUILTINS . These builtins will be enabled unconditionally in ROCm 6.3. Wherever possible, the implementation includes a static assert to check that the program source uses the correct type for the mask.
-
-## 19.14.1 Warp vote and ballot functions
-**Following code does:** The code snippet provided appears to be a series of ASCII art arrows and lines, rather than functional code. It does not perform any computational tasks or have any executable logic. Its high-level purpose seems to be purely decorative or illustrative, possibly intended to visually represent directional arrows or boundaries.
-
-
-```
-int __all(int predicate)
-int __any(int predicate)
-unsigned long long __ballot(int predicate)
-unsigned long long __activemask()
-
-int __all_sync(unsigned long long mask, int predicate)
-```
-
-(continued from previous page)
-**Following code does:** This code snippet is a command-line instruction for compiling a HIP (Heterogeneous-Compute Interface for Portability) program using the NVIDIA CUDA Compiler (`nvcc`). The command is set to compile a source file located at `./HIP-Basic/saxpy/main.hip` into an executable named `saxpy`. It includes additional header files from the directories `./Common` and `/opt/rocm/include`. The `-O2` flag is used to optimize the code for better performance. The `-x cu` flag specifies that the input file is a CUDA source file. This setup is typically used for compiling GPU-accelerated applications that can run on both NVIDIA and AMD hardware using HIP.
-
-
-```
-<_Python_>
-```
-
-You can use \_\_any and \_\_all to get a summary view of the predicates evaluated by the participating lanes.
-
-- \_\_any() : Returns 1 if the predicate is non-zero for any participating lane, otherwise it returns 0.
-- \_\_all() : Returns 1 if the predicate is non-zero for all participating lanes, otherwise it returns 0.
-
-To determine if the target platform supports the any/all instruction, you can use the hasWarpVote device property or the HIP\_ARCH\_HAS\_WARP\_VOTE compiler definition.
-
-\_\_ballot returns a bit mask containing the 1-bit predicate value from each lane. The nth bit of the result contains the 1 bit contributed by the nth warp lane.
-
-\_\_activemask() returns a bit mask of currently active warp lanes. The nth bit of the result is 1 if the nth warp lane is active.
-
-Note that the \_\_ballot and \_\_activemask builtins in HIP have a 64-bit return value (unlike the 32-bit value returned by the CUDA builtins). Code ported from CUDA should be adapted to support the larger warp sizes that the HIP version requires.
-
-Applications can test whether the target platform supports the \_\_ballot or \_\_activemask instructions using the hasWarpBallot device property in host code or the HIP\_ARCH\_HAS\_WARP\_BALLOT macro defined by the compiler for device code.
-
-The \_sync variants require a 64-bit unsigned integer mask argument that specifies the lanes in the warp that will participate in cross-lane communication with the calling lane. Each participating thread must have its own bit set in its mask argument, and all active threads specified in any mask argument must execute the same call with the same mask, otherwise the result is undefined.
-
-## 19.14.2 Warp match functions
-**Following code does:** This code snippet is a command to compile a C++ program using the `clang++` compiler. It specifically compiles a file named `main.hip` located in the `HIP-Basic\saxpy` directory into an executable named `saxpy.exe`. The command includes several options:
-
-- `-I.\Common`: Specifies an additional directory (`.\Common`) to search for header files.
-- `-lamdhip64`: Links against the `amdhip64` library, which is likely related to AMD's HIP (Heterogeneous-Compute Interface for Portability) framework.
-- `-L ${env:HIP_PATH}`: Adds the directory specified by the environment variable `HIP_PATH` to the library search path.
-- `-lib`: Indicates that the output should be a library (though this seems inconsistent with the `-o saxpy.exe` option for an executable).
-- `-02`: This appears to be a typo or misconfiguration; it might be intended to be `-O2`, which is an optimization flag for the compiler.
-
-Overall, the command is intended to compile a HIP-based C++ program, linking it with necessary libraries and including specific directories for headers and libraries.
-
-
-```
-    unsigned long long __match_any(T value)
-    unsigned long long __match_all(T value, int *pred)
-
-    unsigned long long __match_any_sync(unsigned long long mask, T value)
-    unsigned long long __match_all_sync(unsigned long long mask, T value, int *pred)
-```
-
-T can be a 32-bit integer type, 64-bit integer type or a single precision or double precision floating point type.
-
-\_\_match\_any returns a bit mask containing a 1-bit for every participating lane if and only if that lane has the same value in value as the current lane, and a 0-bit for all other lanes.
-
-\_\_match\_all returns a bit mask containing a 1-bit for every participating lane if and only if they all have the same value in value as the current lane, and a 0-bit for all other lanes. The predicate pred is set to true if and only if all participating threads have the same value in value .
-
-The \_sync variants require a 64-bit unsigned integer mask argument that specifies the lanes in the warp that will participate in cross-lane communication with the calling lane. Each participating thread must have its own bit set in its mask argument, and all active threads specified in any mask argument must execute the same call with the same mask, otherwise the result is undefined.
-
-## 19.14.3 Warp shuffle functions
-
-The default width is warpSize (see Warp cross-lane functions ). Half-float shuffles are not supported.
-**Following code does:** The code snippet appears to be a command for compiling a HIP (Heterogeneous-Compute Interface for Portability) program using the `nvcc` compiler. The command is intended to compile a source file named `main.hip` located in the `saxpy` directory under `HIP-Basic`, and produce an executable named `saxpy.exe`. The command includes options to specify include directories (`-I ${env:HIP_PATH}include` and `-I.\Common`) and an optimization level (`-O2`). However, the snippet seems to be corrupted or improperly formatted, as it contains extraneous characters and symbols that do not form a valid command.
-
-
-```
-            The default width is warpSize (see Warp cross-lane functions). Half-float shuffles are not supported.
-                                                                                                                                                                                                        
-                                                                                                                                                                                                      
-int       __shfl           (T var,     int srcLane,  int width=warpSize);
-```
-
-T can be a 32-bit integer type, 64-bit integer type or a single precision or double precision floating point type.
-
-The \_sync variants require a 64-bit unsigned integer mask argument that specifies the lanes in the warp that will participate in cross-lane communication with the calling lane. Each participating thread must have its own bit set in its mask argument, and all active threads specified in any mask argument must execute the same call with the same mask, otherwise the result is undefined.
-
-## 19.15 Cooperative groups functions
-
-You can use cooperative groups to synchronize groups of threads. Cooperative groups also provide a way of communicating between groups of threads at a granularity that is different from the block.
-
-HIP supports the following kernel language cooperative groups types and functions:
-
-Table 2: Cooperative groups functions
-
-| Function                                | Supported in HIP   | Supported in CUDA   |
-|-----------------------------------------|--------------------|---------------------|
-| void thread_group.sync();               | ✓                  | ✓                   |
-| unsigned thread_group.size();           | ✓                  | ✓                   |
-| unsigned thread_group.thread_rank()     | ✓                  | ✓                   |
-| bool thread_group.is_valid();           | ✓                  | ✓                   |
-| grid_group this_grid()                  | ✓                  | ✓                   |
-| void grid_group.sync()                  | ✓                  | ✓                   |
-| unsigned grid_group.size()              | ✓                  | ✓                   |
-| unsigned grid_group.thread_rank()       | ✓                  | ✓                   |
-| bool grid_group.is_valid()              | ✓                  | ✓                   |
-| multi_grid_group this_multi_grid()      | ✓                  | ✓                   |
-| void multi_grid_group.sync()            | ✓                  | ✓                   |
-| unsigned multi_grid_group.size()        | ✓                  | ✓                   |
-| unsigned multi_grid_group.thread_rank() | ✓                  | ✓                   |
-| bool multi_grid_group.is_valid()        | ✓                  | ✓                   |
-| unsigned multi_grid_group.num_grids()   | ✓                  | ✓                   |
-| unsigned multi_grid_group.grid_rank()   | ✓                  | ✓                   |
-| thread_block this_thread_block()        | ✓                  | ✓                   |
-| multi_grid_group this_multi_grid()      | ✓                  | ✓                   |
-| void multi_grid_group.sync()            | ✓                  | ✓                   |
-| void thread_block.sync()                | ✓                  | ✓                   |
-| unsigned thread_block.size()            | ✓                  | ✓                   |
-| unsigned thread_block.thread_rank()     | ✓                  | ✓                   |
-| bool thread_block.is_valid()            | ✓                  | ✓                   |
-| dim3 thread_block.group_index()         | ✓                  | ✓                   |
-| dim3 thread_block.thread_index()        | ✓                  | ✓                   |
-
-For further information, check Cooperative Groups API or Cooperative Groups how to .
-
-## 19.16 Warp matrix functions
-
-Warp matrix functions allow a warp to cooperatively operate on small matrices that have elements spread over lanes in an unspecified manner.
-
-HIP does not support kernel language warp matrix types or functions.
-
-Table 3: Warp matrix functions
-
-| Function                                                                                                     | Sup- ported in HIP   | Supported in CUDA   |
-|--------------------------------------------------------------------------------------------------------------|----------------------|---------------------|
-| void load_matrix_sync(fragment<...> &a, const T* mptr, unsigned lda)                                         |                      | ✓                   |
-| void load_matrix_sync(fragment<...> &a, const T* mptr, unsigned lda, layout_t layout)                        |                      | ✓                   |
-| void store_matrix_sync(T* mptr, fragment<...> &a, unsigned lda, layout_t layout)                             |                      | ✓                   |
-| void fill_fragment(fragment<...> &a, const T &value) void mma_sync(fragment<...> &d, const fragment<...> &a, |                      | ✓                   |
-| const fragment<...> &b, const fragment<...> &c , bool sat)                                                   |                      | ✓                   |
-
-## 19.17 Independent thread scheduling
-
-Certain architectures that support CUDA allow threads to progress independently of each other. This independent thread scheduling makes intra-warp synchronization possible.
-
-HIP does not support this type of scheduling.
-
-## 19.18 Profiler Counter Function
-
-The CUDA \_\_prof\_trigger() instruction is not supported.
-
-## 19.19 Assert
-
-The assert function is supported in HIP. Assert function is used for debugging purpose, when the input expression equals to zero, the execution will be stopped.
-**Following code does:** This code snippet appears to be a series of special characters and whitespace, but it does not represent any valid or meaningful Python code. It seems to be a random arrangement of symbols and spaces without any executable purpose or functionality in a programming context.
-
-
-```
-|void assert(int ir
-```
-**Following code does:** The code snippet `<_SQL_>` appears to be a placeholder or a tag indicating that the actual SQL code is not provided. Without the specific SQL code, it's not possible to determine its functionality. Typically, SQL code is used for interacting with databases, such as querying data, updating records, or managing database structures. If you have the actual SQL code, I can help explain its purpose.
-
-
-```
-    input()
-```
-
-There are two kinds of implementations for assert functions depending on the use sceneries, - One is for the host version of assert, which is defined in assert.h , - Another is the device version of assert, which is implemented in hip/hip\_runtime.h . Users need to include assert.h to use assert . For assert to work in both device and host functions, users need to include "hip/hip\_runtime.h" .
-
-HIP provides the function abort() which can be used to terminate the application when terminal failures are detected. It is implemented using the \_\_builtin\_trap() function.
-
-This function produces a similar effect of using asm("trap") in the CUDA code.
-
-Note: In HIP, the function terminates the entire application, while in CUDA, asm("trap") only terminates the dispatch and the application continues to run.
-
-## 19.20 printf
-
-printf function is supported in HIP. The following is a simple example to print information in the kernel.
-**Following code does:** The code snippet you've provided appears to be a command line instruction rather than a typical Python code snippet. It seems to be a command for a build or compilation tool, possibly related to a makefile or a build script. Here's a breakdown of its components:
-
-- `|` and `\` are shell operators. `|` is used for piping the output of one command into another, and `\` is used to escape characters or continue a command on the next line.
-- `roc-obj` could be a reference to a specific object file or a target within a build system.
-- `-t` and `-d` are likely flags or options for the command being executed.
-- `gfx803` might refer to a specific architecture or hardware target, possibly related to AMD's GCN (Graphics Core Next) architecture.
-- `./saxpy` suggests that the command is operating on or with a file or executable named `saxpy` in the current directory.
-
-Overall, this command seems to be part of a build process, possibly compiling or linking code for a specific hardware target.
-
-
-```
-                                                                                                                                                                                                       
-#include <hip/hip_runtime.h>
-
-    __global__ void run_printf() { printf("Hello World\n"); }
-
-    int main() {
-      run_printf<<<dim3(1), dim3(1), 0, 0>>>();
-    }
-```
-
-## 19.21 Device-Side Dynamic Global Memory Allocation
-
-Device-side dynamic global memory allocation is under development. HIP now includes a preliminary implementation of malloc and free that can be called from device functions.
-
-## 19.22 \_\_launch\_bounds\_\_
-
-GPU multiprocessors have a fixed pool of resources (primarily registers and shared memory) which are shared by the actively running warps. Using more resources can increase IPC of the kernel but reduces the resources available for other warps and limits the number of warps that can be simultaneously running. Thus GPUs have a complex relationship between resource usage and performance.
-
-\_\_launch\_bounds\_\_ allows the application to provide usage hints that influence the resources (primarily registers) used by the generated code. It is a function attribute that must be attached to a \_\_global\_\_ function:
-**Following code does:** The code snippet `<_XML_>` appears to be a placeholder or a tag, rather than actual executable Python code. It might be used in a larger context to denote a section where XML data or XML-related processing is expected. Without additional context or surrounding code, it does not perform any specific function or operation by itself.
-
-
-```
-<_Cython_>
-```
-
-\_\_launch\_bounds\_\_ supports two parameters: - MAX\_THREADS\_PER\_BLOCK - The programmers guarantees that kernel will be launched with threads less than MAX\_THREADS\_PER\_BLOCK. (On NVCC this maps to the . maxntid PTX directive). If no launch\_bounds is specified, MAX\_THREADS\_PER\_BLOCK is the maximum block size supported by the device (typically 1024 or larger). Specifying MAX\_THREADS\_PER\_BLOCK less than the maximum effectively allows the compiler to use more resources than a default unconstrained compilation that supports all possible block sizes at launch time. The threads-per-block is the product of ( blockDim.x * blockDim. y * blockDim.z ). - MIN\_WARPS\_PER\_EXECUTION\_UNIT - directs the compiler to minimize resource usage so that the requested number of warps can be simultaneously active on a multi-processor. Since active warps compete for the same fixed pool of resources, the compiler must reduce resources required by each warp(primarily registers). MIN\_WARPS\_PER\_EXECUTION\_UNIT is optional and defaults to 1 if not specified. Specifying a MIN\_WARPS\_PER\_EXECUTION\_UNIT greater than the default 1 effectively constrains the compiler's resource usage.
-
-When launch kernel with HIP APIs, for example, hipModuleLaunchKernel() , HIP will do validation to make sure input kernel dimension size is not larger than specified launch\_bounds. In case exceeded, HIP would return launch failure, if AMD\_LOG\_LEVEL is set with proper value (for details, please refer to docs/markdown/hip\_logging. md ), detail information will be shown in the error log message, including launch parameters of kernel dim size, launch bounds, and the name of the faulting kernel. It's helpful to figure out which is the faulting kernel, besides, the kernel dim size and launch bounds values will also assist in debugging such failures.
-
-## 19.22.1 Compiler Impact
-
-The compiler uses these parameters as follows: - The compiler uses the hints only to manage register usage, and does not automatically reduce shared memory or other resources. - Compilation fails if compiler cannot generate a kernel which meets the requirements of the specified launch bounds. - From MAX\_THREADS\_PER\_BLOCK, the compiler derives the maximum number of warps/block that can be used at launch time. Values of MAX\_THREADS\_PER\_BLOCK less than the default allows the compiler to use a larger pool of registers : each warp uses registers, and this hint constrains the launch to a warps/block size which is less than maximum. - From MIN\_WARPS\_PER\_EXECUTION\_UNIT, the compiler derives a maximum number of registers that can be used by the kernel (to meet the required #simultaneous active blocks). If MIN\_WARPS\_PER\_EXECUTION\_UNIT is 1, then the kernel can use all registers supported by the multiprocessor. - The compiler ensures that the registers used in the kernel is less than both allowed maximums, typically by spilling registers (to shared or global memory), or by using more instructions. - The compiler may use heuristics to increase register usage, or may simply be able to avoid spilling. The MAX\_THREADS\_PER\_BLOCK
-
-is particularly useful in this cases, since it allows the compiler to use more registers and avoid situations where the compiler constrains the register usage (potentially spilling) to meet the requirements of a large block size that is never used at launch time.
-
-## 19.22.2 CU and EU Definitions
-
-A compute unit (CU) is responsible for executing the waves of a work-group. It is composed of one or more execution units (EU) which are responsible for executing waves. An EU can have enough resources to maintain the state of more than one executing wave. This allows an EU to hide latency by switching between waves in a similar way to symmetric multithreading on a CPU. In order to allow the state for multiple waves to fit on an EU, the resources used by a single wave have to be limited. Limiting such resources can allow greater latency hiding, but can result in having to spill some register state to memory. This attribute allows an advanced developer to tune the number of waves that are capable of fitting within the resources of an EU. It can be used to ensure at least a certain number will fit to help hide latency, and can also be used to ensure no more than a certain number will fit to limit cache thrashing.
-
-## 19.22.3 Porting from CUDA \_\_launch\_bounds
-
-CUDA defines a \_\_launch\_bounds which is also designed to control occupancy:
-
-- \_\_launch\_bounds(MAX\_THREADS\_PER\_BLOCK, MIN\_BLOCKS\_PER\_MULTIPROCESSOR)
-- The second parameter \_\_launch\_bounds parameters must be converted to the format used \_\_hip\_launch\_bounds, which uses warps and execution-units rather than blocks and multi-processors (this conversion is performed automatically by HIPIFY tools).
-**Following code does:** This code snippet appears to be a collection of various symbols and characters arranged in a seemingly random manner. It does not form a valid or meaningful Python program. The arrangement of characters does not follow any recognizable syntax or structure that would perform a specific function or task in Python. Therefore, it does not have a high-level purpose or functionality.
-
-
-```
-                                                                                                                                                                                                        | MIN_WARPS_PER_EXECUTION_UNIT  =  (MIN_BLOCKS_PER_MULTIPROCESSOR  *  MAX_THREADS_PER_BLOCK)  /_\                                                                                                                                                                                                       
-                                                                                                                                                                                                        :                                                                                                                                                                                                        --                                                                                                                                                                                                        <                                                                                                                                                                                                        </                                                                                                                                                                                                        >                                                                                                                                                                                                        }
-```
-
-The key differences in the interface are: - Warps (rather than blocks): The developer is trying to tell the compiler to control resource utilization to guarantee some amount of active Warps/EU for latency hiding. Specifying active warps in terms of blocks appears to hide the micro-architectural details of the warp size, but makes the interface more confusing since the developer ultimately needs to compute the number of warps to obtain the desired level of control. - Execution Units (rather than multiprocessor): The use of execution units rather than multiprocessors provides support for architectures with multiple execution units/multi-processor. For example, the AMD GCN architecture has 4 execution units per multiprocessor. The hipDeviceProps has a field executionUnitsPerMultiprocessor . Platform-specific coding techniques such as #ifdef can be used to specify different launch\_bounds for NVCC and HIP-Clang platforms, if desired.
-
-## 19.22.4 maxregcount
-
-Unlike NVCC, HIP-Clang does not support the --maxregcount option. Instead, users are encouraged to use the hip\_launch\_bounds directive since the parameters are more intuitive and portable than micro-architecture details like registers, and also the directive allows per-kernel control rather than an entire file. hip\_launch\_bounds works on both HIP-Clang and NVCC targets.
-
-## 19.23 Asynchronous Functions
-
-## 19.23.1 Memory stream
-
-typedef void (* hipStreamCallback\_t )(hipStream\_t stream, hipError\_t status, void *userData)
-
-Stream CallBack struct hipError\_t hipStreamCreate ( hipStream\_t *stream )
-
-Create an asynchronous stream.
-
-Create a new asynchronous stream. stream returns an opaque handle that can be used to reference the newly created stream in subsequent hipStream* commands. The stream is allocated on the heap and will remain allocated even if the handle goes out-of-scope. To release the memory used by the stream, application must call hipStreamDestroy.
-
-## See also:
-
-hipStreamCreateWithFlags , hipStreamCreateWithPriority , hipStreamSynchronize , hipStreamWaitEvent , hipStreamDestroy
-
-## Parameters
-
-stream -[inout] Valid pointer to hipStream\_t. This function writes the memory with the newly created stream.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipStreamCreateWithFlags ( hipStream\_t *stream, unsigned int flags )
-
-Create an asynchronous stream.
-
-Create a new asynchronous stream. stream returns an opaque handle that can be used to reference the newly created stream in subsequent hipStream* commands. The stream is allocated on the heap and will remain allocated even if the handle goes out-of-scope. To release the memory used by the stream, application must call hipStreamDestroy. Flags controls behavior of the stream. See hipStreamDefault, hipStreamNonBlocking.
-
-## See also:
-
-hipStreamCreate , hipStreamCreateWithPriority , hipStreamSynchronize , hipStreamWaitEvent , hipStreamDestroy
-
-## Parameters
-
-- stream -[inout] Pointer to new stream
-- flags -[in] to control stream creation.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue
-
-hipError\_t hipStreamCreateWithPriority ( hipStream\_t *stream, unsigned int flags, int priority )
-
-Create an asynchronous stream with the specified priority.
-
-Create a new asynchronous stream with the specified priority. stream returns an opaque handle that can be used to reference the newly created stream in subsequent hipStream* commands. The stream is allocated on the heap and will remain allocated even if the handle goes out-of-scope. To release the memory used by the stream, application must call hipStreamDestroy. Flags controls behavior of the stream. See hipStreamDefault, hipStreamNonBlocking.
-
-## See also:
-
-hipStreamCreate , hipStreamSynchronize , hipStreamWaitEvent , hipStreamDestroy
-
-## Parameters
-
-- stream -[inout] Pointer to new stream
-- flags -[in] to control stream creation.
-- priority -[in] of the stream. Lower numbers represent higher priorities.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipDeviceGetStreamPriorityRange ( int *leastPriority, int *greatestPriority )
-
-Returns numerical values that correspond to the least and greatest stream priority.
-
-Returns in *leastPriority and *greatestPriority the numerical values that correspond to the least and greatest stream priority respectively. Stream priorities follow a convention where lower numbers imply greater priorities. The range of meaningful stream priorities is given by [*greatestPriority, *leastPriority]. If the user attempts to create a stream with a priority value that is outside the meaningful range as specified by this API, the priority is automatically clamped to within the valid range.
-
-## Parameters
-
-- leastPriority -[inout] pointer in which value corresponding to least priority is returned.
-- greatestPriority -[inout] pointer in which value corresponding to greatest priority is returned.
-
-## Returns
-
-hipSuccess hipError\_t hipStreamDestroy ( hipStream\_t stream )
-
-Destroys the specified stream.
-
-Destroys the specified stream.
-
-If commands are still executing on the specified stream, some may complete execution before the queue is deleted.
-
-The queue may be destroyed while some commands are still inflight, or may wait for all commands queued to the stream before destroying it.
-
-## See also:
-
-hipStreamCreate , hipStreamCreateWithFlags , hipStreamCreateWithPriority , hipStreamQuery , hipStreamWaitEvent , hipStreamSynchronize
-
-## Parameters
-
-stream -[in] stream identifier.
-
-## Returns
-
-hipSuccess hipErrorInvalidHandle
-
-## hipError\_t hipStreamQuery ( hipStream\_t stream )
-
-Return hipSuccess if all of the operations in the specified stream have completed, or hipErrorNotReady if not.
-
-This is thread-safe and returns a snapshot of the current state of the queue. However, if other host threads are sending work to the stream, the status may change immediately after the function is called. It is typically used for debug.
-
-## See also:
-
-hipStreamCreate , hipStreamCreateWithFlags , hipStreamCreateWithPriority , hipStreamWaitEvent , hipStreamSynchronize , hipStreamDestroy
-
-## Parameters
-
-stream -[in] stream to query
-
-## Returns
-
-hipSuccess, hipErrorNotReady, hipErrorInvalidHandle
-
-## hipError\_t hipStreamSynchronize ( hipStream\_t stream )
-
-Wait for all commands in stream to complete.
-
-This command is host-synchronous : the host will block until the specified stream is empty.
-
-This command follows standard null-stream semantics. Specifically, specifying the null stream will cause the command to wait for other streams on the same device to complete all pending operations.
-
-This command honors the hipDeviceLaunchBlocking flag, which controls whether the wait is active or blocking.
-
-## See also:
-
-hipStreamCreate , hipStreamCreateWithFlags , hipStreamCreateWithPriority , hipStreamWaitEvent , hipStreamDestroy
-
-## Parameters
-
-stream -[in] stream identifier.
-
-## Returns
-
-hipSuccess, hipErrorInvalidHandle
-
-hipError\_t hipStreamWaitEvent ( hipStream\_t stream, hipEvent\_t event, unsigned int flags )
-
-Make the specified compute stream wait for an event.
-
-This function inserts a wait operation into the specified stream. All future work submitted to stream will wait until event reports completion before beginning execution.
-
-This function only waits for commands in the current stream to complete. Notably, this function does not implicitly wait for commands in the default stream to complete, even if the specified stream is created with hipStreamNonBlocking = 0.
-
-## See also:
-
-hipStreamCreate , hipStreamCreateWithFlags , hipStreamCreateWithPriority , hipStreamSynchronize , hipStreamDestroy
-
-## Parameters
-
-- stream -[in] stream to make wait.
-- event -[in] event to wait on
-- flags -[in] control operation [must be 0]
-
-## Returns
-
-hipSuccess, hipErrorInvalidHandle hipError\_t hipStreamGetFlags ( hipStream\_t stream, unsigned int *flags )
-
-Return flags associated with this stream.
-
-Return flags associated with this stream in * flags .
-
-## See also:
-
-hipStreamCreateWithFlags
-
-## Parameters
-
-- stream -[in] stream to be queried
-- flags -[inout] Pointer to an unsigned integer in which the stream's flags are returned
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidHandle
-
-## Returns
-
-hipSuccess hipErrorInvalidValue hipErrorInvalidHandle hipError\_t hipStreamGetPriority ( hipStream\_t stream, int *priority )
-
-Query the priority of a stream.
-
-Query the priority of a stream. The priority is returned in in priority.
-
-## See also:
-
-hipStreamCreateWithFlags
-
-## Parameters
-
-- stream -[in] stream to be queried
-- priority -[inout] Pointer to an unsigned integer in which the stream's priority is returned
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidHandle
-
-## Returns
-
-hipSuccess hipErrorInvalidValue hipErrorInvalidHandle hipError\_t hipStreamGetDevice ( hipStream\_t stream, hipDevice\_t *device )
-
-Get the device assocaited with the stream.
-
-## See also:
-
-hipStreamCreate , hipStreamDestroy , hipDeviceGetStreamPriorityRange
-
-## Parameters
-
-- stream -[in] stream to be queried
-- device -[out] device associated with the stream
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorContextIsDestroyed, hipErrorInvalidHandle, hipErrorNotInitialized, hipErrorDeinitialized, hipErrorInvalidContext hipError\_t hipExtStreamCreateWithCUMask ( hipStream\_t *stream, uint32\_t cuMaskSize, const uint32\_t *cuMask )
-
-Create an asynchronous stream with the specified CU mask.
-
-Create a new asynchronous stream with the specified CU mask. stream returns an opaque handle that can be used to reference the newly created stream in subsequent hipStream* commands. The stream is allocated on the heap and will remain allocated even if the handle goes out-of-scope. To release the memory used by the stream, application must call hipStreamDestroy.
-
-## See also:
-
-hipStreamCreate , hipStreamSynchronize , hipStreamWaitEvent , hipStreamDestroy
-
-## Parameters
-
-- stream -[inout] Pointer to new stream
-- cuMaskSize -[in] Size of CU mask bit array passed in.
-- cuMask -[in] Bit-vector representing the CU mask. Each active bit represents using one CU. The first 32 bits represent the first 32 CUs, and so on. If its size is greater than physical CU number (i.e., multiProcessorCount member of hipDeviceProp\_t), the extra elements are ignored. It is user's responsibility to make sure the input is meaningful.
-
-## Returns
-
-hipSuccess, hipErrorInvalidHandle, hipErrorInvalidValue hipError\_t hipExtStreamGetCUMask ( hipStream\_t stream, uint32\_t cuMaskSize, uint32\_t *cuMask )
-
-Get CU mask associated with an asynchronous stream.
-
-## See also:
-
-hipStreamCreate , hipStreamSynchronize , hipStreamWaitEvent , hipStreamDestroy
-
-## Parameters
-
-- stream -[in] stream to be queried
-- cuMaskSize -[in] number of the block of memories (uint32\_t *) allocated by user
-- cuMask -[out] Pointer to a pre-allocated block of memories (uint32\_t *) in which the stream's CU mask is returned. The CU mask is returned in a chunck of 32 bits where each active bit represents one active CU
-
-## Returns
-
-hipSuccess, hipErrorInvalidHandle, hipErrorInvalidValue hipError\_t hipStreamAddCallback ( hipStream\_t stream, hipStreamCallback\_t callback, void *userData, unsigned int flags )
-
-Adds a callback to be called on the host after all currently enqueued items in the stream have completed. For each hipStreamAddCallback call, a callback will be executed exactly once. The callback will block later work in the stream until it is finished.
-
-## See also:
-
-hipStreamCreate , hipStreamCreateWithFlags , hipStreamQuery , hipStreamSynchronize , hipStreamWaitEvent , hipStreamDestroy , hipStreamCreateWithPriority
-
-## Parameters
-
-- stream -[in] - Stream to add callback to
-- callback -[in] - The function to call once preceding stream operations are complete
-- userData -[in] - User specified data to be passed to the callback function
-- flags -[in] - Reserved for future use, must be 0
-
-## Returns
-
-hipSuccess, hipErrorInvalidHandle, hipErrorNotSupported static inline hipError\_t hipMallocAsync ( void **dev\_ptr, size\_t size, hipMemPool\_t mem\_pool, hipStream\_t stream )
-
-C++ wrappers for allocations from a memory pool.
-
-This section describes wrappers for stream Ordered allocation from memory pool functions of HIP runtime API.
-
-This is an alternate C++ calls for hipMallocFromPoolAsync made available through function overloading.
-
-## See also:
-
-hipMallocFromPoolAsync
-
-Note: APIs in this section are implemented on Linux, under development on Windows.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-## template&lt;class T &gt;
-
-static inline hipError\_t hipMallocAsync ( T **dev\_ptr, size\_t size, hipMemPool\_t mem\_pool, hipStream\_t stream C++ wrappers for allocations from a memory pool on the stream.
-
-This is an alternate C++ calls for hipMallocFromPoolAsync made available through function overloading.
-
-## See also:
-
-hipMallocFromPoolAsync
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-## template&lt;class T &gt;
-
-static inline hipError\_t hipMallocAsync ( T **dev\_ptr, size\_t size, hipStream\_t stream )
-
-C++ wrappers for allocations from a memory pool.
-
-This is an alternate C++ calls for hipMallocFromPoolAsync made available through function overloading.
-
-## See also:
-
-hipMallocFromPoolAsync
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-## template&lt;class T &gt;
-
-static inline hipError\_t hipMallocFromPoolAsync ( T **dev\_ptr, size\_t size, hipMemPool\_t mem\_pool, hipStream\_t stream )
-
-C++ wrappers for allocations from a memory pool.
-
-This is an alternate C++ calls for hipMallocFromPoolAsync made available through function overloading.
-
-## See also:
-
-hipMallocFromPoolAsync
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-)
-
-hipError\_t hipMallocAsync ( void **dev\_ptr, size\_t size, hipStream\_t stream )
-
-Allocates memory with stream ordered semantics.
-
-Inserts a memory allocation operation into stream . A pointer to the allocated memory is returned immediately in *dptr. The allocation must not be accessed until the allocation operation completes. The allocation comes from the memory pool associated with the stream's device.
-
-## See also:
-
-hipMallocFromPoolAsync , hipFreeAsync , hipMemPoolTrimTo , hipMemPoolGetAttribute , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess , hipMemPoolGetAccess
-
-Note: The default memory pool of a device contains device memory from that device.
-
-Note: Basic stream ordering allows future work submitted into the same stream to use the allocation. Stream query, stream synchronize, and HIP events can be used to guarantee that the allocation operation completes before work submitted in a separate stream runs.
-
-Note: During stream capture, this function results in the creation of an allocation node. In this case, the allocation is owned by the graph instead of the memory pool. The memory pool's properties are used to set the node's creation parameters.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- dev\_ptr -[out] Returned device pointer of memory allocation
-- size -[in] Number of bytes to allocate
-- stream -[in] The stream establishing the stream ordering contract and the memory pool to allocate from
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported, hipErrorOutOfMemory hipError\_t hipFreeAsync ( void *dev\_ptr, hipStream\_t stream )
-
-Frees memory with stream ordered semantics.
-
-Inserts a free operation into stream . The allocation must not be used after stream execution reaches the free. After this API returns, accessing the memory from any subsequent work launched on the GPU or querying its pointer attributes results in undefined behavior.
-
-## See also:
-
-hipMallocFromPoolAsync , hipMallocAsync , hipMemPoolTrimTo , hipMemPoolGetAttribute , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess , hipMemPoolGetAccess
-
-Note: During stream capture, this function results in the creation of a free node and must therefore be passed the address of a graph allocation.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- dev\_ptr -[in] Pointer to device memory to free
-- stream -[in] The stream, where the destruciton will occur according to the execution order
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemPoolTrimTo ( hipMemPool\_t mem\_pool, size\_t min\_bytes\_to\_hold )
-
-Releases freed memory back to the OS.
-
-Releases memory back to the OS until the pool contains fewer than min\_bytes\_to\_keep reserved bytes, or there is no more memory that the allocator can safely release. The allocator cannot release OS allocations that back outstanding asynchronous allocations. The OS allocations may happen at different granularity from the user allocations.
-
-## See also:
-
-hipMallocFromPoolAsync , hipMallocAsync , hipFreeAsync , hipMemPoolGetAttribute , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess , hipMemPoolGetAccess
-
-Note: Allocations that have not been freed count as outstanding.
-
-Note: Allocations that have been asynchronously freed but whose completion has not been observed on the host (eg. by a synchronize) can count as outstanding.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- mem\_pool -[in] The memory pool to trim allocations
-- min\_bytes\_to\_hold -[in] If the pool has less than min\_bytes\_to\_hold reserved, then the TrimTo operation is a no-op. Otherwise the memory pool will contain at least min\_bytes\_to\_hold bytes reserved after the operation.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemPoolSetAttribute ( hipMemPool\_t mem\_pool, hipMemPoolAttr attr, void *value )
-
-Sets attributes of a memory pool.
-
-Supported attributes are:
-
-- hipMemPoolAttrReleaseThreshold: (value type = cuuint64\_t) Amount of reserved memory in bytes to hold onto before trying to release memory back to the OS. When more than the release threshold bytes of memory are held by the memory pool, the allocator will try to release memory back to the OS on the next call to stream, event or context synchronize. (default 0)
-- hipMemPoolReuseFollowEventDependencies: (value type = int) Allow hipMallocAsync to use memory asynchronously freed in another stream as long as a stream ordering dependency of the allocating stream on the free action exists. HIP events and null stream interactions can create the required stream ordered dependencies. (default enabled)
-- hipMemPoolReuseAllowOpportunistic: (value type = int) Allow reuse of already completed frees when there is no dependency between the free and allocation. (default enabled)
-- hipMemPoolReuseAllowInternalDependencies: (value type = int) Allow hipMallocAsync to insert new stream dependencies in order to establish the stream ordering required to reuse a piece of memory released by hipFreeAsync (default enabled).
-
-## See also:
-
-hipMallocFromPoolAsync , hipMallocAsync , hipFreeAsync , hipMemPoolGetAttribute , hipMemPoolTrimTo , hipDeviceSetMemPool, hipMemPoolSetAccess , hipMemPoolGetAccess
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- mem\_pool -[in] The memory pool to modify
-- attr -[in] The attribute to modify
-- value -[in] Pointer to the value to assign
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue
-
-hipError\_t hipMemPoolGetAttribute ( hipMemPool\_t mem\_pool, hipMemPoolAttr attr, void *value )
-
-Gets attributes of a memory pool.
-
-Supported attributes are:
-
-- hipMemPoolAttrReleaseThreshold: (value type = cuuint64\_t) Amount of reserved memory in bytes to hold onto before trying to release memory back to the OS. When more than the release threshold bytes of memory are held by the memory pool, the allocator will try to release memory back to the OS on the next call to stream, event or context synchronize. (default 0)
-- hipMemPoolReuseFollowEventDependencies: (value type = int) Allow hipMallocAsync to use memory asynchronously freed in another stream as long as a stream ordering dependency of the allocating stream on the free action exists. HIP events and null stream interactions can create the required stream ordered dependencies. (default enabled)
-- hipMemPoolReuseAllowOpportunistic: (value type = int) Allow reuse of already completed frees when there is no dependency between the free and allocation. (default enabled)
-- hipMemPoolReuseAllowInternalDependencies: (value type = int) Allow hipMallocAsync to insert new stream dependencies in order to establish the stream ordering required to reuse a piece of memory released by hipFreeAsync (default enabled).
-
-## See also:
-
-hipMallocFromPoolAsync , hipMallocAsync , hipFreeAsync , hipMemPoolTrimTo , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess , hipMemPoolGetAccess
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- mem\_pool -[in] The memory pool to get attributes of
-- attr -[in] The attribute to get
-- value -[in] Retrieved value
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemPoolSetAccess ( hipMemPool\_t mem\_pool, const hipMemAccessDesc *desc\_list, size\_t count ) Controls visibility of the specified pool between devices.
-
-## See also:
-
-hipMallocFromPoolAsync , hipMallocAsync , hipFreeAsync , hipMemPoolGetAttribute , hipMemPoolTrimTo , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolGetAccess
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- mem\_pool -[in] Memory pool for acccess change
-- desc\_list -[in] Array of access descriptors. Each descriptor instructs the access to enable for a single gpu
-- count -[in] Number of descriptors in the map array.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemPoolGetAccess ( hipMemAccessFlags *flags, hipMemPool\_t mem\_pool, hipMemLocation *location )
-
-Returns the accessibility of a pool from a device.
-
-Returns the accessibility of the pool's memory from the specified location.
-
-## See also:
-
-hipMallocFromPoolAsync , hipMallocAsync , hipFreeAsync , hipMemPoolGetAttribute , hipMemPoolTrimTo , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- flags -[out] Accessibility of the memory pool from the specified location/device
-- mem\_pool -[in] Memory pool being queried
-- location -[in] Location/device for memory pool access
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemPoolCreate ( hipMemPool\_t *mem\_pool, const hipMemPoolProps *pool\_props )
-
-Creates a memory pool.
-
-Creates a HIP memory pool and returns the handle in mem\_pool . The pool\_props determines the properties of the pool such as the backing device and IPC capabilities.
-
-By default, the memory pool will be accessible from the device it is allocated on.
-
-## See also:
-
-hipMallocFromPoolAsync , hipMallocAsync , hipFreeAsync , hipMemPoolGetAttribute , hipMemPoolDestroy , hipMemPoolTrimTo , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess , hipMemPoolGetAccess
-
-Note: Specifying hipMemHandleTypeNone creates a memory pool that will not support IPC.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- mem\_pool -[out] Contains createed memory pool
-- pool\_props -[in] Memory pool properties
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemPoolDestroy ( hipMemPool\_t mem\_pool )
-
-Destroys the specified memory pool.
-
-If any pointers obtained from this pool haven't been freed or the pool has free operations that haven't completed when hipMemPoolDestroy is invoked, the function will return immediately and the resources associated with the pool will be released automatically once there are no more outstanding allocations.
-
-Destroying the current mempool of a device sets the default mempool of that device as the current mempool for that device.
-
-## See also:
-
-hipMallocFromPoolAsync , hipMallocAsync , hipFreeAsync , hipMemPoolGetAttribute , hipMemPoolCreate hipMemPoolTrimTo , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess , hipMemPoolGetAccess
-
-Note: A device's default memory pool cannot be destroyed.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-mem\_pool -[in] Memory pool for destruction
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t void **dev\_ptr, size\_t size, hipMemPool\_t mem\_pool, hipStream\_t stream
-
-hipMallocFromPoolAsync ( ) Allocates memory from a specified pool with stream ordered semantics.
-
-Inserts an allocation operation into stream . A pointer to the allocated memory is returned immediately in dev\_ptr . The allocation must not be accessed until the allocation operation completes. The allocation comes from the specified memory pool.
-
-Basic stream ordering allows future work submitted into the same stream to use the allocation. Stream query, stream synchronize, and HIP events can be used to guarantee that the allocation operation completes before work submitted in a separate stream runs.
-
-## See also:
-
-hipMallocAsync , hipFreeAsync , hipMemPoolGetAttribute , hipMemPoolCreate hipMemPoolTrimTo , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess , hipMemPoolGetAccess ,
-
-Note: The specified memory pool may be from a device different than that of the specified stream .
-
-Note: During stream capture, this function results in the creation of an allocation node. In this case, the allocation is owned by the graph instead of the memory pool. The memory pool's properties are used to set the node's creation parameters.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- dev\_ptr -[out] Returned device pointer
-- size -[in] Number of bytes to allocate
-- mem\_pool -[in] The pool to allocate from
-- stream -[in] The stream establishing the stream ordering semantic
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported, hipErrorOutOfMemory hipError\_t hipMemPoolExportToShareableHandle ( void *shared\_handle, hipMemPool\_t mem\_pool, hipMemAllocationHandleType handle\_type, unsigned int flags )
-
-Exports a memory pool to the requested handle type.
-
-Given an IPC capable mempool, create an OS handle to share the pool with another process. A recipient process can convert the shareable handle into a mempool with hipMemPoolImportFromShareableHandle . Individual pointers can then be shared with the hipMemPoolExportPointer and hipMemPoolImportPointer APIs. The implementation of what the shareable handle is and how it can be transferred is defined by the requested handle type.
-
-## See also:
-
-hipMemPoolImportFromShareableHandle
-
-Note: To create an IPC capable mempool, create a mempool with a hipMemAllocationHandleType other than hipMemHandleTypeNone .
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- shared\_handle -[out] Pointer to the location in which to store the requested handle
-- mem\_pool -[in] Pool to export
-- handle\_type -[in] The type of handle to create
-- flags -[in] Must be 0
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorOutOfMemory hipError\_t hipMemPoolImportFromShareableHandle ( hipMemPool\_t *mem\_pool, void *shared\_handle, hipMemAllocationHandleType handle\_type, unsigned int flags )
-
-Imports a memory pool from a shared handle.
-
-Specific allocations can be imported from the imported pool with hipMemPoolImportPointer .
-
-## See also:
-
-hipMemPoolExportToShareableHandle
-
-Note: Imported memory pools do not support creating new allocations. As such imported memory pools may not be used in hipDeviceSetMemPool or hipMallocFromPoolAsync calls.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- mem\_pool -[out] Returned memory pool
-- shared\_handle -[in] OS handle of the pool to open
-- handle\_type -[in] The type of handle being imported
-- flags -[in] Must be 0
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorOutOfMemory hipError\_t hipMemPoolExportPointer ( hipMemPoolPtrExportData *export\_data, void *dev\_ptr )
-
-Export data to share a memory pool allocation between processes.
-
-Constructs export\_data for sharing a specific allocation from an already shared memory pool. The recipient process can import the allocation with the hipMemPoolImportPointer api. The data is not a handle and may be shared through any IPC mechanism.
-
-## See also:
-
-hipMemPoolImportPointer
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- export\_data -[out] Returned export data
-- dev\_ptr -[in] Pointer to memory being exported
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorOutOfMemory hipError\_t hipMemPoolImportPointer ( void **dev\_ptr, hipMemPool\_t mem\_pool, hipMemPoolPtrExportData *export\_data )
-
-Import a memory pool allocation from another process.
-
-Returns in dev\_ptr a pointer to the imported memory. The imported memory must not be accessed before the allocation operation completes in the exporting process. The imported memory must be freed from all importing processes before being freed in the exporting process. The pointer may be freed with hipFree or hipFreeAsync . If hipFreeAsync is used, the free must be completed on the importing process before the free operation on the exporting process.
-
-## See also:
-
-hipMemPoolExportPointer
-
-Note: The hipFreeAsync api may be used in the exporting process before the hipFreeAsync operation completes in its stream as long as the hipFreeAsync in the exporting process specifies a stream with a stream dependency on the importing process's hipFreeAsync .
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- dev\_ptr -[out] Pointer to imported memory
-- mem\_pool -[in] Memory pool from which to import a pointer
-- export\_data -[in] Data specifying the memory to import
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized, hipErrorOutOfMemory
-
-## 19.23.2 Peer to peer
-
-hipError\_t hipDeviceCanAccessPeer ( int *canAccessPeer, int deviceId, int peerDeviceId )
-
-Determine if a device can access a peer's memory.
-
-Returns '1' in canAccessPeer if the specified device is capable of directly accessing memory physically located on peerDevice , or '0' if not.
-
-Returns '0' in canAccessPeer if deviceId == peerDeviceId, and both are valid devices : a device is not a peer of itself.
-
-## Parameters
-
-- canAccessPeer -[out] Returns the peer access capability (0 or 1)
-- deviceId -[in] - device from where memory may be accessed.
-- peerDeviceId -[in] - device where memory is physically located
-
-## Returns
-
-hipSuccess,
-
-## Returns
-
-hipErrorInvalidDevice if deviceId or peerDeviceId are not valid devices hipError\_t hipDeviceEnablePeerAccess ( int peerDeviceId, unsigned int flags )
-
-Enable direct access from current device's virtual address space to memory allocations physically located on a peer device.
-
-Memory which already allocated on peer device will be mapped into the address space of the current device. In addition, all future memory allocations on peerDeviceId will be mapped into the address space of the current device when the memory is allocated. The peer memory remains accessible from the current device until a call to hipDeviceDisablePeerAccess or hipDeviceReset.
-
-Returns hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue,
-
-## Parameters
-
-- peerDeviceId -[in] Peer device to enable direct access to from the current device
-- flags -[in] Reserved for future use, must be zero
-
-## Returns
-
-hipErrorPeerAccessAlreadyEnabled if peer access is already enabled for this device.
-
-## hipError\_t hipDeviceDisablePeerAccess ( int peerDeviceId )
-
-Disable direct access from current device's virtual address space to memory allocations physically located on a peer device.
-
-Returns hipErrorPeerAccessNotEnabled if direct access to memory on peerDevice has not yet been enabled from the current device.
-
-## Parameters
-
-peerDeviceId -[in] Peer device to disable direct access to
-
-## Returns
-
-hipSuccess, hipErrorPeerAccessNotEnabled hipError\_t hipMemGetAddressRange ( hipDeviceptr\_t *pbase, size\_t *psize, hipDeviceptr\_t dptr )
-
-Get information on memory allocations.
-
-## See also:
-
-hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent, hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice
-
-## Parameters
-
-- pbase -[out] - BAse pointer address
-- psize -[out] - Size of allocation
-- dptr--[in] Device Pointer
-
-## Returns
-
-hipSuccess, hipErrorNotFound
-
-## USE\_PEER\_NON\_UNIFIED
-
-## 19.23.3 Memory management
-
-hipError\_t hipPointerSetAttribute ( const void *value, hipPointer\_attribute attribute, hipDeviceptr\_t ptr )
-
-Sets information on the specified pointer.[BETA].
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- value -[in] Sets pointer attribute value
-- attribute -[in] Attribute to set
-- ptr -[in] Pointer to set attributes for
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError\_t hipPointerGetAttributes ( hipPointerAttribute\_t *attributes, const void *ptr )
-
-Returns attributes for the specified pointer.
-
-The output parameter 'attributes' has a member named 'type' that describes what memory the pointer is associated with, such as device memory, host memory, managed memory, and others. Otherwise, the API cannot handle the pointer and returns hipErrorInvalidValue.
-
-## See also:
-
-hipPointerGetAttribute
-
-Note: The unrecognized memory type is unsupported to keep the HIP functionality backward compatibility due to hipMemoryType enum values.
-
-Note: The current behavior of this HIP API corresponds to the CUDA API before version 11.0.
-
-## Parameters
-
-- attributes -[out] attributes for the specified pointer
-- ptr -[in] pointer to get attributes for
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError\_t hipPointerGetAttribute ( void *data, hipPointer\_attribute attribute, hipDeviceptr\_t ptr ) Returns information about the specified pointer.[BETA].
-
-## See also:
-
-hipPointerGetAttributes
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- data -[inout] Returned pointer attribute value
-- attribute -[in] Attribute to query for
-- ptr -[in] Pointer to get attributes for
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError\_t hipDrvPointerGetAttributes ( unsigned int numAttributes, hipPointer\_attribute *attributes, void **data, hipDeviceptr\_t ptr )
-
-Returns information about the specified pointer.[BETA].
-
-## See also:
-
-hipPointerGetAttribute
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- numAttributes -[in] number of attributes to query for
-- attributes -[in] attributes to query for
-- data -[inout] a two-dimensional containing pointers to memory locations where the result of each attribute query will be written to
-- ptr -[in] pointer to get attributes for
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError\_t hipMalloc ( void **ptr, size\_t size )
-
-Allocate memory on the default accelerator.
-
-If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.
-
-## See also:
-
-hipMallocPitch , hipFree , hipMallocArray , hipFreeArray , hipMalloc3D , hipMalloc3DArray , hipHostFree , hipHostMalloc
-
-## Parameters
-
-- ptr -[out] Pointer to the allocated memory
-- size -[in] Requested memory size
-
-## Returns
-
-hipSuccess, hipErrorOutOfMemory, hipErrorInvalidValue (bad context, null *ptr)
-
-hipError\_t hipExtMallocWithFlags ( void **ptr, size\_t sizeBytes, unsigned int flags )
-
-Allocate memory on the default accelerator.
-
-If requested memory size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.
-
-The memory allocation flag should be either hipDeviceMallocDefault, hipDeviceMallocFinegrained, hipDeviceMallocUncached, or hipMallocSignalMemory. If the flag is any other value, the API returns hipErrorInvalidValue.
-
-## See also:
-
-hipMallocPitch , hipFree , hipMallocArray , hipFreeArray , hipMalloc3D , hipMalloc3DArray , hipHostFree , hipHostMalloc
-
-## Parameters
-
-- ptr -[out] Pointer to the allocated memory
-- sizeBytes -[in] Requested memory size
-- flags -[in] Type of memory allocation
-
-## Returns
-
-hipSuccess, hipErrorOutOfMemory, hipErrorInvalidValue (bad context, null *ptr)
-
-hipError\_t hipMallocHost ( void **ptr, size\_t size )
-
-Allocate pinned host memory [Deprecated].
-
-If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.
-
-Warning:
-**Following code does:** The code snippet is a shell command that lists files in the current directory with names starting with "main-hip-amdgcn-amd-amdhsa-" and ending with any extension. The output shows a list of files that match this pattern, indicating that these files are likely related to a project or build process involving AMD GPU architecture (specifically the GFX803 series) and the HIP (Heterogeneous-Compute Interface for Portability) platform. The files have various extensions, suggesting they are different types of build artifacts, such as bytecode (.bc), object files (.o), assembly (.s), and output files (.out).
-
-
-```
-
-
-arning:   This API is deprecated, use hipHostMalloc() instead
-```
-
-## Parameters
-
-- ptr -[out] Pointer to the allocated host pinned memory
-- size -[in] Requested memory size
-
-## Returns
-
-hipSuccess, hipErrorOutOfMemory
-
-## hipError\_t hipMemAllocHost ( void **ptr, size\_t size )
-
-Allocate pinned host memory [Deprecated].
-
-If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.
-
-Warning: This API is deprecated, use hipHostMalloc() instead
-
-## Parameters
-
-- ptr -[out] Pointer to the allocated host pinned memory
-- size -[in] Requested memory size
-
-## Returns
-
-hipSuccess, hipErrorOutOfMemory hipError\_t hipHostMalloc ( void **ptr, size\_t size, unsigned int flags )
-
-Allocates device accessible page locked (pinned) host memory.
-
-This API allocates pinned host memory which is mapped into the address space of all GPUs in the system, the memory can be accessed directly by the GPU device, and can be read or written with much higher bandwidth than pageable memory obtained with functions such as malloc().
-
-Using the pinned host memory, applications can implement faster data transfers for HostToDevice and DeviceToHost. The runtime tracks the hipHostMalloc allocations and can avoid some of the setup required for regular unpinned memory.
-
-When the memory accesses are infrequent, zero-copy memory can be a good choice, for coherent allocation. GPU can directly access the host memory over the CPU/GPU interconnect, without need to copy the data.
-
-Currently the allocation granularity is 4KB for the API.
-
-Developers need to choose proper allocation flag with consideration of synchronization.
-
-If no input for flags, it will be the default pinned memory allocation on the host.
-
-## See also:
-
-hipSetDeviceFlags, hipHostFree
-
-## Parameters
-
-- ptr -[out] Pointer to the allocated host pinned memory
-- size -[in] Requested memory size in bytes If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.
-- flags -[in] Type of host memory allocation. See the description of flags in hipSetDeviceFlags.
-
-## Returns
-
-hipSuccess, hipErrorOutOfMemory hipError\_t hipHostAlloc ( void **ptr, size\_t size, unsigned int flags )
-
-Allocate device accessible page locked host memory [Deprecated].
-
-If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.
-
-Warning: This API is deprecated, use hipHostMalloc() instead
-
-## Parameters
-
-- ptr -[out] Pointer to the allocated host pinned memory
-
-- size -[in] Requested memory size in bytes
-- flags -[in] Type of host memory allocation
-
-## Returns
-
-hipSuccess, hipErrorOutOfMemory hipError\_t hipHostGetDevicePointer ( void **devPtr, void *hstPtr, unsigned int flags )
-
-Get Device pointer from Host Pointer allocated through hipHostMalloc.
-
-## See also:
-
-hipSetDeviceFlags, hipHostMalloc
-
-## Parameters
-
-- devPtr -[out] Device Pointer mapped to passed host pointer
-- hstPtr -[in] Host Pointer allocated through hipHostMalloc
-- flags -[in] Flags to be passed for extension
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorOutOfMemory hipError\_t hipHostGetFlags ( unsigned int *flagsPtr, void *hostPtr )
-
-Return flags associated with host pointer.
-
-## See also:
-
-## hipHostMalloc
-
-## Parameters
-
-- flagsPtr -[out] Memory location to store flags
-- hostPtr -[in] Host Pointer allocated through hipHostMalloc
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipHostRegister ( void *hostPtr, size\_t sizeBytes, unsigned int flags )
-
-Register host memory so it can be accessed from the current device.
-
-## Flags:
-
-- hipHostRegisterDefault Memory is Mapped and Portable
-- hipHostRegisterPortable Memory is considered registered by all contexts. HIP only supports one context so this is always assumed true.
-- hipHostRegisterMapped Map the allocation into the address space for the current device. The device pointer can be obtained with hipHostGetDevicePointer .
-
-After registering the memory, use hipHostGetDevicePointer to obtain the mapped device pointer. On many systems, the mapped device pointer will have a different value than the mapped host pointer. Applications must use the device pointer in device code, and the host pointer in host code.
-
-On some systems, registered memory is pinned. On some systems, registered memory may not be actually be pinned but uses OS or hardware facilities to all GPU access to the host memory.
-
-Developers are strongly encouraged to register memory blocks which are aligned to the host cache-line size. (typically 64-bytes but can be obtains from the CPUID instruction).
-
-If registering non-aligned pointers, the application must take care when register pointers from the same cache line on different devices. HIP's coarse-grained synchronization model does not guarantee correct results if different devices write to different parts of the same cache block - typically one of the writes will 'win' and overwrite data from the other registered memory region.
-
-## See also:
-
-hipHostUnregister , hipHostGetFlags , hipHostGetDevicePointer
-
-## Parameters
-
-- hostPtr -[out] Pointer to host memory to be registered.
-- sizeBytes -[in] Size of the host memory
-- flags -[in] See below.
-
-## Returns
-
-hipSuccess, hipErrorOutOfMemory hipError\_t hipHostUnregister ( void *hostPtr )
-
-Un-register host pointer.
-
-## See also:
-
-hipHostRegister
-
-## Parameters
-
-hostPtr -[in] Host pointer previously registered with hipHostRegister
-
-## Returns
-
-Error code hipError\_t hipMallocPitch ( void **ptr, size\_t *pitch, size\_t width, size\_t height )
-
-Allocates at least width (in bytes) * height bytes of linear memory Padding may occur to ensure alighnment requirements are met for the given row The change in width size due to padding will be returned in *pitch. Currently the alignment is set to 128 bytes
-
-If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.
-
-## See also:
-
-hipMalloc , hipFree , hipMallocArray , hipFreeArray , hipHostFree , hipMalloc3D , hipMalloc3DArray , hipHostMalloc
-
-## Parameters
-
-- ptr -[out] Pointer to the allocated device memory
-
-- pitch -[out] Pitch for allocation (in bytes)
-- width -[in] Requested pitched allocation width (in bytes)
-- height -[in] Requested pitched allocation height
-
-## Returns
-
-Error code hipError\_t hipMemAllocPitch ( hipDeviceptr\_t *dptr, size\_t *pitch, size\_t widthInBytes, size\_t height, unsigned int elementSizeBytes )
-
-Allocates at least width (in bytes) * height bytes of linear memory Padding may occur to ensure alighnment requirements are met for the given row The change in width size due to padding will be returned in *pitch. Currently the alignment is set to 128 bytes
-
-If size is 0, no memory is allocated, ptr returns nullptr, and hipSuccess is returned. The intended usage of pitch is as a separate parameter of the allocation, used to compute addresses within the 2D array. Given the row and column of an array element of type T, the address is computed as: T pElement = (T*)((char*)BaseAddress + Row * Pitch) + Column;
-
-## See also:
-
-hipMalloc , hipFree , hipMallocArray , hipFreeArray , hipHostFree , hipMalloc3D , hipMalloc3DArray , hipHostMalloc
-
-## Parameters
-
-- dptr -[out] Pointer to the allocated device memory
-- pitch -[out] Pitch for allocation (in bytes)
-- widthInBytes -[in] Requested pitched allocation width (in bytes)
-- height -[in] Requested pitched allocation height
-- elementSizeBytes -[in] The size of element bytes, should be 4, 8 or 16
-
-## Returns
-
-Error code
-
-## hipError\_t hipFree ( void *ptr )
-
-Free memory allocated by the hcc hip memory allocation API. This API performs an implicit hipDeviceSynchronize() call. If pointer is NULL, the hip runtime is initialized and hipSuccess is returned.
-
-## See also:
-
-hipMalloc , hipMallocPitch , hipMallocArray , hipFreeArray , hipHostFree , hipMalloc3D , hipMalloc3DArray , hipHostMalloc
-
-## Parameters
-
-ptr -[in] Pointer to memory to be freed
-
-## Returns
-
-hipSuccess
-
-## Returns
-
-hipErrorInvalidDevicePointer (if pointer is invalid, including host pointers allocated with hipHostMalloc)
-
-## hipError\_t hipFreeHost ( void *ptr )
-
-Free memory allocated by the hcc hip host memory allocation API [Deprecated].
-
-Warning:
-**Following code does:** The code snippet appears to be a command intended to be run in a terminal or command line interface, rather than a Python script. The command `cuobjdump --list-ptx ./saxpy` is used to extract and list the PTX (Parallel Thread Execution) code from a compiled CUDA binary file, in this case, named `saxpy`. PTX is an intermediate representation of CUDA code that is closer to assembly language. This command is typically used by developers to inspect the PTX code generated by the CUDA compiler for debugging or optimization purposes. The output of this command would display the PTX code sections contained within the `saxpy` binary.
-
-
-```
-
-
-urning:   This API is deprecated, use hipHostFree() instead
-```
-
-## Parameters
-
-ptr -[in] Pointer to memory to be freed
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue (if pointer is invalid, including device pointers allocated with hipMalloc)
-
-## hipError\_t hipHostFree ( void *ptr )
-
-Free memory allocated by the hcc hip host memory allocation API This API performs an implicit hipDeviceSynchronize() call. If pointer is NULL, the hip runtime is initialized and hipSuccess is returned.
-
-## See also:
-
-hipMalloc , hipMallocPitch , hipFree , hipMallocArray , hipFreeArray , hipMalloc3D , hipMalloc3DArray , hipHostMalloc
-
-## Parameters
-
-ptr -[in] Pointer to memory to be freed
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue (if pointer is invalid, including device pointers allocated with hipMalloc)
-
-hipError\_t hipMemcpy ( void *dst, const void *src, size\_t sizeBytes, hipMemcpyKind kind )
-
-Copy data from src to dst.
-
-It supports memory from host to device, device to host, device to device and host to host The src and dst must not overlap.
-
-For hipMemcpy, the copy is always performed by the current device (set by hipSetDevice). For multi-gpu or peerto-peer configurations, it is recommended to set the current device to the device where the src data is physically located. For optimal peer-to-peer copies, the copy device must be able to access the src and dst pointers (by calling hipDeviceEnablePeerAccess with copy agent as the current device and src/dest as the peerDevice argument. if this is not done, the hipMemcpy will still work, but will perform the copy using a staging buffer on the host. Calling hipMemcpy with dst and src pointers that do not match the hipMemcpyKind results in undefined behavior.
-
-## See also:
-
-hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer
-
-## Parameters
-
-- dst -[out] Data being copy to
-- src -[in] Data being copy from
-- sizeBytes -[in] Data size in bytes
-- kind -[in] Kind of transfer
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorUnknown hipError\_t hipMemcpyWithStream ( void *dst, const void *src, size\_t sizeBytes, hipMemcpyKind kind, hipStream\_t stream )
-
-Memory copy on the stream. It allows single or multiple devices to do memory copy on single or multiple streams.
-
-## See also:
-
-hipMemcpy , hipStreamCreate , hipStreamSynchronize , hipStreamDestroy , hipSetDevice, hipLaunchKernelGGL
-
-## Parameters
-
-- dst -[out] Data being copy to
-- src -[in] Data being copy from
-- sizeBytes -[in] Data size in bytes
-- kind -[in] Kind of transfer
-- stream -[in] Valid stream
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorUnknown, hipErrorContextIsDestroyed hipError\_t hipMemcpyHtoD ( hipDeviceptr\_t dst, void *src, size\_t sizeBytes )
-
-Copy data from Host to Device.
-
-## See also:
-
-hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer
-
-## Parameters
-
-- dst -[out] Data being copy to
-- src -[in] Data being copy from
-- sizeBytes -[in] Data size in bytes
-
-## Returns
-
-hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue
-
-hipError\_t hipMemcpyDtoH ( void *dst, hipDeviceptr\_t src, size\_t sizeBytes )
-
-Copy data from Device to Host.
-
-## See also:
-
-hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer
-
-## Parameters
-
-- dst -[out] Data being copy to
-- src -[in] Data being copy from
-- sizeBytes -[in] Data size in bytes
-
-## Returns
-
-hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue hipError\_t hipMemcpyDtoD ( hipDeviceptr\_t dst, hipDeviceptr\_t src, size\_t sizeBytes )
-
-Copy data from Device to Device.
-
-## See also:
-
-hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer
-
-## Parameters
-
-- dst -[out] Data being copy to
-- src -[in] Data being copy from
-- sizeBytes -[in] Data size in bytes
-
-## Returns
-
-hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue hipError\_t hipMemcpyHtoDAsync ( hipDeviceptr\_t dst, void *src, size\_t sizeBytes, hipStream\_t stream )
-
-Copy data from Host to Device asynchronously.
-
-## See also:
-
-hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpyAtoA, hipMemcpyAtoD,
-
-hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer
-
-## Parameters
-
-- dst -[out] Data being copy to
-- src -[in] Data being copy from
-- sizeBytes -[in] Data size in bytes
-- stream -[in] Stream identifier
-
-## Returns
-
-hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue hipError\_t hipMemcpyDtoHAsync ( void *dst, hipDeviceptr\_t src, size\_t sizeBytes, hipStream\_t stream )
-
-Copy data from Device to Host asynchronously.
-
-## See also:
-
-hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer
-
-## Parameters
-
-- dst -[out] Data being copy to
-- src -[in] Data being copy from
-- sizeBytes -[in] Data size in bytes
-- stream -[in] Stream identifier
-
-## Returns
-
-hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue hipError\_t hipMemcpyDtoDAsync ( hipDeviceptr\_t dst, hipDeviceptr\_t src, size\_t sizeBytes, hipStream\_t stream )
-
-Copy data from Device to Device asynchronously.
-
-## See also:
-
-hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer
-
-## Parameters
-
-- dst -[out] Data being copy to
-- src -[in] Data being copy from
-- sizeBytes -[in] Data size in bytes
-- stream -[in] Stream identifier
-
-## Returns
-
-hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue hipError\_t hipModuleGetGlobal ( hipDeviceptr\_t *dptr, size\_t *bytes, hipModule\_t hmod, const char *name )
-
-Returns a global pointer from a module. Returns in *dptr and *bytes the pointer and size of the global of name name located in module hmod. If no variable of that name exists, it returns hipErrorNotFound. Both parameters dptr and bytes are optional. If one of them is NULL, it is ignored and hipSuccess is returned.
-
-## Parameters
-
-- dptr -[out] Returns global device pointer
-- bytes -[out] Returns global size in bytes
-- hmod -[in] Module to retrieve global from
-- name -[in] Name of global to retrieve
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotFound, hipErrorInvalidContext hipError\_t hipGetSymbolAddress ( void **devPtr, const void *symbol )
-
-Gets device pointer associated with symbol on the device.
-
-## Parameters
-
-- devPtr -[out] pointer to the device associated the symbole
-- symbol -[in] pointer to the symbole of the device
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipGetSymbolSize ( size\_t *size, const void *symbol )
-
-Gets the size of the given symbol on the device.
-
-## Parameters
-
-- symbol -[in] pointer to the device symbole
-- size -[out] pointer to the size
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipGetProcAddress ( const char *symbol, void **pfn, int hipVersion, uint64\_t flags, hipDriverProcAddressQueryResult *symbolStatus )
-
-Gets the pointer of requested HIP driver function.
-
-Returns hipSuccess if the returned pfn is addressed to the pointer of found driver function.
-
-## Parameters
-
-- symbol -[in] The Symbol name of the driver function to request.
-- pfn -[out] Output pointer to the requested driver function.
-- hipVersion -[in] The HIP version for the requested driver function symbol. HIP version is defined as 100*version\_major + version\_minor. For example, in HIP 6.1, the hipversion is 601, for the symbol function 'hipGetDeviceProperties', the specified hipVersion 601 is greater or equal to the version 600, the symbol function will be handle properly as backend compatible function.
-- flags -[in] Currently only default flag is suppported.
-- symbolStatus -[out] Optional enumeration for returned status of searching for symbol driver function based on the input hipVersion.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue.
-
-hipError\_t hipMemcpyToSymbol ( const void *symbol, const void *src, size\_t sizeBytes, size\_t offset, hipMemcpyKind kind )
-
-Copies data to the given symbol on the device. Symbol HIP APIs allow a kernel to define a device-side data symbol which can be accessed on the host side. The symbol can be in \_\_constant or device space. Note that the symbol name needs to be encased in the HIP\_SYMBOL macro. This also applies to hipMemcpyFromSymbol, hipGetSymbolAddress, and hipGetSymbolSize. For detailed usage, see the memcpyToSymbol example in the HIP Porting Guide.
-
-## Parameters
-
-- symbol -[out] pointer to the device symbole
-- src -[in] pointer to the source address
-- sizeBytes -[in] size in bytes to copy
-- offset -[in] offset in bytes from start of symbole
-- kind -[in] type of memory transfer
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemcpyToSymbolAsync ( const void *symbol, const void *src, size\_t sizeBytes, size\_t offset, hipMemcpyKind kind, hipStream\_t stream )
-
-Copies data to the given symbol on the device asynchronously.
-
-## Parameters
-
-- symbol -[out] pointer to the device symbole
-- src -[in] pointer to the source address
-- sizeBytes -[in] size in bytes to copy
-- offset -[in] offset in bytes from start of symbole
-- kind -[in] type of memory transfer
-- stream -[in] stream identifier
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue
-
-hipError\_t hipMemcpyFromSymbol ( void *dst, const void *symbol, size\_t sizeBytes, size\_t offset, hipMemcpyKind kind )
-
-Copies data from the given symbol on the device.
-
-## Parameters
-
-- dst -[out] Returns pointer to destinition memory address
-- symbol -[in] Pointer to the symbole address on the device
-- sizeBytes -[in] Size in bytes to copy
-- offset -[in] Offset in bytes from the start of symbole
-- kind -[in] Type of memory transfer
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemcpyFromSymbolAsync ( void *dst, const void *symbol, size\_t sizeBytes, size\_t offset, hipMemcpyKind kind, hipStream\_t stream )
-
-Copies data from the given symbol on the device asynchronously.
-
-## Parameters
-
-- dst -[out] Returns pointer to destinition memory address
-- symbol -[in] pointer to the symbole address on the device
-- sizeBytes -[in] size in bytes to copy
-- offset -[in] offset in bytes from the start of symbole
-- kind -[in] type of memory transfer
-- stream -[in] stream identifier
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemcpyAsync ( void *dst, const void *src, size\_t sizeBytes, hipMemcpyKind kind, hipStream\_t stream )
-
-Copy data from src to dst asynchronously.
-
-For multi-gpu or peer-to-peer configurations, it is recommended to use a stream which is a attached to the device where the src data is physically located. For optimal peer-to-peer copies, the copy device must be able to access the src and dst pointers (by calling hipDeviceEnablePeerAccess with copy agent as the current device and src/dest as the peerDevice argument. if this is not done, the hipMemcpy will still work, but will perform the copy using a staging buffer on the host.
-
-## See also:
-
-hipMemcpy , hipMemcpy2D , hipMemcpyToArray , hipMemcpy2DToArray , hipMemcpyFromArray , hipMemcpy2DFromArray , hipMemcpyArrayToArray, hipMemcpy2DArrayToArray, hipMemcpyToSymbol , hipMemcpyFromSymbol , hipMemcpy2DAsync , hipMemcpyToArrayAsync, hipMemcpy2DToArrayAsync , hipMemcpyFromArrayAsync, hipMemcpy2DFromArrayAsync , hipMemcpyToSymbolAsync , hipMemcpyFromSymbolAsync
-
-Warning: If host or dest are not pinned, the memory copy will be performed synchronously. For best performance, use hipHostMalloc to allocate host memory that is transferred asynchronously.
-
-Warning: on HCC hipMemcpyAsync does not support overlapped H2D and D2H copies. For hipMemcpy, the copy is always performed by the device associated with the specified stream.
-
-## Parameters
-
-- dst -[out] Data being copy to
-- src -[in] Data being copy from
-- sizeBytes -[in] Data size in bytes
-- kind -[in] Type of memory transfer
-- stream -[in] Stream identifier
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorUnknown hipError\_t hipMemset ( void *dst, int value, size\_t sizeBytes )
-
-Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant byte value value.
-
-## Parameters
-
-- dst -[out] Data being filled
-- value -[in] Value to be set
-- sizeBytes -[in] Data size in bytes
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized hipError\_t hipMemsetD8 ( hipDeviceptr\_t dest, unsigned char value, size\_t count )
-
-Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant byte value value.
-
-## Parameters
-
-- dest -[out] Data ptr to be filled
-- value -[in] Value to be set
-- count -[in] Number of values to be set
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized hipError\_t hipMemsetD8Async ( hipDeviceptr\_t dest, unsigned char value, size\_t count, hipStream\_t stream )
-
-Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant byte value value.
-
-hipMemsetD8Async() is asynchronous with respect to the host, so the call may return before the memset is complete. The operation can optionally be associated to a stream by passing a non-zero stream argument. If stream is non-zero, the operation may overlap with operations in other streams.
-
-## Parameters
-
-- dest -[out] Data ptr to be filled
-- value -[in] Constant value to be set
-
-- count -[in] Number of values to be set
-- stream -[in] Stream identifier
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized hipError\_t hipMemsetD16 ( hipDeviceptr\_t dest, unsigned short value, size\_t count )
-
-Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant short value value.
-
-## Parameters
-
-- dest -[out] Data ptr to be filled
-- value -[in] Constant value to be set
-- count -[in] Number of values to be set
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized hipError\_t hipMemsetD16Async ( hipDeviceptr\_t dest, unsigned short value, size\_t count, hipStream\_t stream )
-
-Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant short value value.
-
-hipMemsetD16Async() is asynchronous with respect to the host, so the call may return before the memset is complete. The operation can optionally be associated to a stream by passing a non-zero stream argument. If stream is non-zero, the operation may overlap with operations in other streams.
-
-## Parameters
-
-- dest -[out] Data ptr to be filled
-- value -[in] Constant value to be set
-- count -[in] Number of values to be set
-- stream -[in] Stream identifier
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized hipError\_t hipMemsetD32 ( hipDeviceptr\_t dest, int value, size\_t count )
-
-Fills the memory area pointed to by dest with the constant integer value for specified number of times.
-
-## Parameters
-
-- dest -[out] Data being filled
-- value -[in] Constant value to be set
-- count -[in] Number of values to be set
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized hipError\_t hipMemsetAsync ( void *dst, int value, size\_t sizeBytes, hipStream\_t stream )
-
-Fills the first sizeBytes bytes of the memory area pointed to by dev with the constant byte value value.
-
-hipMemsetAsync() is asynchronous with respect to the host, so the call may return before the memset is complete. The operation can optionally be associated to a stream by passing a non-zero stream argument. If stream is nonzero, the operation may overlap with operations in other streams.
-
-## Parameters
-
-- dst -[out] Pointer to device memory
-
-- value -[in] Value to set for each byte of specified memory
-- sizeBytes -[in] Size in bytes to set
-- stream -[in] Stream identifier
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemsetD32Async ( hipDeviceptr\_t dst, int value, size\_t count, hipStream\_t stream )
-
-Fills the memory area pointed to by dev with the constant integer value for specified number of times.
-
-hipMemsetD32Async() is asynchronous with respect to the host, so the call may return before the memset is complete. The operation can optionally be associated to a stream by passing a non-zero stream argument. If stream is non-zero, the operation may overlap with operations in other streams.
-
-## Parameters
-
-- dst -[out] Pointer to device memory
-- value -[in] Value to set for each byte of specified memory
-- count -[in] Number of values to be set
-- stream -[in] Stream identifier
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemset2D ( void *dst, size\_t pitch, int value, size\_t width, size\_t height )
-
-Fills the memory area pointed to by dst with the constant value.
-
-## Parameters
-
-- dst -[out] Pointer to device memory
-- pitch -[in] Data size in bytes
-- value -[in] Constant value to be set
-- width -[in]
-- height -[in]
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemset2DAsync ( void *dst, size\_t pitch, int value, size\_t width, size\_t height, hipStream\_t stream ) Fills asynchronously the memory area pointed to by dst with the constant value.
-
-## Parameters
-
-- dst -[in] Pointer to 2D device memory
-- pitch -[in] Pitch size in bytes
-- value -[in] Value to be set for each byte of specified memory
-- width -[in] Width of matrix set columns in bytes
-- height -[in] Height of matrix set rows in bytes
-- stream -[in] Stream identifier
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue
-
-hipError\_t hipMemset3D ( hipPitchedPtr pitchedDevPtr, int value, hipExtent extent )
-
-Fills synchronously the memory area pointed to by pitchedDevPtr with the constant value.
-
-## Parameters
-
-- pitchedDevPtr -[in] Pointer to pitched device memory
-- value -[in] Value to set for each byte of specified memory
-- extent -[in] Size parameters for width field in bytes in device memory
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemset3DAsync ( hipPitchedPtr pitchedDevPtr, int value, hipExtent extent, hipStream\_t stream )
-
-Fills asynchronously the memory area pointed to by pitchedDevPtr with the constant value.
-
-## Parameters
-
-- pitchedDevPtr -[in] Pointer to pitched device memory
-- value -[in] Value to set for each byte of specified memory
-- extent -[in] Size parameters for width field in bytes in device memory
-- stream -[in] Stream identifier
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemGetInfo ( size\_t *free, size\_t *total )
-
-Query memory info.
-
-On ROCM, this function gets the actual free memory left on the current device, so supports the cases while running multi-workload (such as multiple processes, multiple threads, and multiple GPUs).
-
-Warning: On Windows, the free memory only accounts for memory allocated by this process and may be optimistic.
-
-## Parameters
-
-- free -[out] Returns free memory on the current device in bytes
-- total -[out] Returns total allocatable memory on the current device in bytes
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError\_t hipMemPtrGetInfo ( void *ptr, size\_t *size )
-
-Get allocated memory size via memory pointer.
-
-This function gets the allocated shared virtual memory size from memory pointer.
-
-## Parameters
-
-- ptr -[in] Pointer to allocated memory
-- size -[out] Returns the allocated memory size in bytes
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue
-
-hipError\_t hipMallocArray ( hipArray\_t *array, const hipChannelFormatDesc *desc, size\_t width, size\_t height, unsigned int flags )
-
-Allocate an array on the device.
-
-## See also:
-
-hipMalloc , hipMallocPitch , hipFree , hipFreeArray , hipHostMalloc , hipHostFree
-
-## Parameters
-
-- array -[out] Pointer to allocated array in device memory
-- desc -[in] Requested channel format
-- width -[in] Requested array allocation width
-- height -[in] Requested array allocation height
-- flags -[in] Requested properties of allocated array
-
-## Returns
-
-hipSuccess, hipErrorOutOfMemory hipError\_t hipArrayCreate ( hipArray\_t *pHandle, const HIP\_ARRAY\_DESCRIPTOR *pAllocateArray )
-
-Create an array memory pointer on the device.
-
-## See also:
-
-hipMallocArray , hipArrayDestroy , hipFreeArray
-
-## Parameters
-
-- pHandle -[out] Pointer to the array memory
-- pAllocateArray -[in] Requested array desciptor
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipArrayDestroy ( hipArray\_t array )
-
-Destroy an array memory pointer on the device.
-
-## See also:
-
-hipArrayCreate , hipArrayDestroy , hipFreeArray
-
-## Parameters
-
-array -[in] Pointer to the array memory
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue
-
-hipError\_t hipArray3DCreate ( hipArray\_t *array, const HIP\_ARRAY3D\_DESCRIPTOR *pAllocateArray )
-
-Create a 3D array memory pointer on the device.
-
-## See also:
-
-hipMallocArray , hipArrayDestroy , hipFreeArray
-
-## Parameters
-
-- array -[out] Pointer to the 3D array memory
-- pAllocateArray -[in] Requested array desciptor
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMalloc3D ( hipPitchedPtr *pitchedDevPtr, hipExtent extent )
-
-Create a 3D memory pointer on the device.
-
-## See also:
-
-hipMallocPitch , hipMemGetInfo , hipFree
-
-## Parameters
-
-- pitchedDevPtr -[out] Pointer to the 3D memory
-- extent -[in] Requested extent
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipFreeArray ( hipArray\_t array )
-
-Frees an array on the device.
-
-## See also:
-
-hipMalloc , hipMallocPitch , hipFree , hipMallocArray , hipHostMalloc , hipHostFree
-
-## Parameters
-
-array -[in] Pointer to array to free
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized hipError\_t hipMalloc3DArray ( hipArray\_t *array, const struct hipChannelFormatDesc *desc, struct hipExtent extent, unsigned int flags )
-
-Allocate an array on the device.
-
-## See also:
-
-hipMalloc , hipMallocPitch , hipFree , hipFreeArray , hipHostMalloc , hipHostFree
-
-## Parameters
-
-- array -[out] Pointer to allocated array in device memory
-- desc -[in] Requested channel format
-- extent -[in] Requested array allocation width, height and depth
-- flags -[in] Requested properties of allocated array
-
-## Returns
-
-hipSuccess, hipErrorOutOfMemory hipError\_t hipArrayGetInfo ( hipChannelFormatDesc *desc, hipExtent *extent, unsigned int *flags, hipArray\_t array )
-
-Gets info about the specified array.
-
-## See also:
-
-hipArrayGetDescriptor , hipArray3DGetDescriptor
-
-## Parameters
-
-- desc -[out] - Returned array type
-- extent -[out] - Returned array shape. 2D arrays will have depth of zero
-- flags -[out] - Returned array flags
-- array -[in] - The HIP array to get info for
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipErrorInvalidHandle hipError\_t hipArrayGetDescriptor ( HIP\_ARRAY\_DESCRIPTOR *pArrayDescriptor, hipArray\_t array )
-
-Gets a 1D or 2D array descriptor.
-
-## See also:
-
-hipArray3DCreate , hipArray3DGetDescriptor , hipArrayCreate , hipArrayDestroy , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpy3D , hipMemcpy3DAsync , hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoD , hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer, hipMemsetD8 , hipMemsetD16 , hipMemsetD32 , hipArrayGetInfo
-
-## Parameters
-
-- pArrayDescriptor -[out] - Returned array descriptor
-- array -[in] - Array to get descriptor of
-
-## Returns
-
-hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue hipErrorInvalidHandle
-
-hipError\_t hipArray3DGetDescriptor ( HIP\_ARRAY3D\_DESCRIPTOR *pArrayDescriptor, hipArray\_t array )
-
-Gets a 3D array descriptor.
-
-## See also:
-
-hipArray3DCreate , hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpy3D , hipMemcpy3DAsync , hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoD , hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer, hipMemsetD8 , hipMemsetD16 , hipMemsetD32 , hipArrayGetInfo
-
-## Parameters
-
-- pArrayDescriptor -[out] - Returned 3D array descriptor
-- array -[in] - 3D array to get descriptor of
-
-## Returns
-
-hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue hipErrorInvalidHandle, hipErrorContextIsDestroyed hipError\_t hipMemcpy2D ( void *dst, size\_t dpitch, const void *src, size\_t spitch, size\_t width, size\_t height, hipMemcpyKind kind )
-
-Copies data between host and device.
-
-## See also:
-
-hipMemcpy , hipMemcpyToArray , hipMemcpy2DToArray , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-- dst -[in] Destination memory address
-- dpitch -[in] Pitch of destination memory
-- src -[in] Source memory address
-- spitch -[in] Pitch of source memory
-- width -[in] Width of matrix transfer (columns in bytes)
-- height -[in] Height of matrix transfer (rows)
-- kind -[in] Type of transfer
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpyParam2D ( const hip\_Memcpy2D *pCopy )
-
-Copies memory for 2D arrays.
-
-## See also:
-
-hipMemcpy , hipMemcpy2D , hipMemcpyToArray , hipMemcpy2DToArray , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-pCopy -[in] Parameters for the memory copy
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpyParam2DAsync ( const hip\_Memcpy2D *pCopy, hipStream\_t stream )
-
-Copies memory for 2D arrays.
-
-## See also:
-
-hipMemcpy , hipMemcpy2D , hipMemcpyToArray , hipMemcpy2DToArray , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-- pCopy -[in] Parameters for the memory copy
-- stream -[in] Stream to use
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpy2DAsync ( void *dst, size\_t dpitch, const void *src, size\_t spitch, size\_t width, size\_t height, hipMemcpyKind kind, hipStream\_t stream )
-
-Copies data between host and device.
-
-## See also:
-
-hipMemcpy , hipMemcpyToArray , hipMemcpy2DToArray , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-- dst -[in] Destination memory address
-- dpitch -[in] Pitch of destination memory
-- src -[in] Source memory address
-- spitch -[in] Pitch of source memory
-- width -[in] Width of matrix transfer (columns in bytes)
-- height -[in] Height of matrix transfer (rows)
-- kind -[in] Type of transfer
-- stream -[in] Stream to use
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpy2DToArray ( hipArray\_t dst, size\_t wOffset, size\_t hOffset, const void *src, size\_t spitch, size\_t width, size\_t height, hipMemcpyKind kind )
-
-Copies data between host and device.
-
-## See also:
-
-hipMemcpy , hipMemcpyToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-- dst -[in] Destination memory address
-- wOffset -[in] Destination starting X offset
-- hOffset -[in] Destination starting Y offset
-- src -[in] Source memory address
-- spitch -[in] Pitch of source memory
-- width -[in] Width of matrix transfer (columns in bytes)
-- height -[in] Height of matrix transfer (rows)
-- kind -[in] Type of transfer
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpy2DToArrayAsync ( hipArray\_t dst, size\_t wOffset, size\_t hOffset, const void *src, size\_t spitch, size\_t width, size\_t height, hipMemcpyKind kind, hipStream\_t stream )
-
-Copies data between host and device.
-
-## See also:
-
-hipMemcpy , hipMemcpyToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-- dst -[in] Destination memory address
-- wOffset -[in] Destination starting X offset
-- hOffset -[in] Destination starting Y offset
-- src -[in] Source memory address
-- spitch -[in] Pitch of source memory
-- width -[in] Width of matrix transfer (columns in bytes)
-- height -[in] Height of matrix transfer (rows)
-
-- kind -[in] Type of transfer
-- stream -[in] Accelerator view which the copy is being enqueued
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpyToArray ( hipArray\_t dst, size\_t wOffset, size\_t hOffset, const void *src, size\_t count, hipMemcpyKind kind )
-
-Copies data between host and device.
-
-## See also:
-
-hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-Warning: This API is deprecated.
-
-## Parameters
-
-- dst -[in] Destination memory address
-- wOffset -[in] Destination starting X offset
-- hOffset -[in] Destination starting Y offset
-- src -[in] Source memory address
-- count -[in] size in bytes to copy
-- kind -[in] Type of transfer
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpyFromArray ( void *dst, hipArray\_const\_t srcArray, size\_t wOffset, size\_t hOffset, size\_t count, hipMemcpyKind kind )
-
-Copies data between host and device.
-
-## See also:
-
-hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-Warning: This API is deprecated.
-
-## Parameters
-
-- dst -[in] Destination memory address
-- srcArray -[in] Source memory address
-- wOffset -[in] Source starting X offset
-
-- hOffset -[in] Source starting Y offset
-- count -[in] Size in bytes to copy
-- kind -[in] Type of transfer
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpy2DFromArray ( void *dst, size\_t dpitch, hipArray\_const\_t src, size\_t wOffset, size\_t hOffset, size\_t width, size\_t height, hipMemcpyKind kind )
-
-Copies data between host and device.
-
-## See also:
-
-hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-- dst -[in] Destination memory address
-- dpitch -[in] Pitch of destination memory
-- src -[in] Source memory address
-- wOffset -[in] Source starting X offset
-- hOffset -[in] Source starting Y offset
-- width -[in] Width of matrix transfer (columns in bytes)
-- height -[in] Height of matrix transfer (rows)
-- kind -[in] Type of transfer
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpy2DFromArrayAsync ( void *dst, size\_t dpitch, hipArray\_const\_t src, size\_t wOffset, size\_t hOffset, size\_t width, size\_t height, hipMemcpyKind kind, hipStream\_t stream )
-
-Copies data between host and device asynchronously.
-
-## See also:
-
-hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-- dst -[in] Destination memory address
-- dpitch -[in] Pitch of destination memory
-- src -[in] Source memory address
-- wOffset -[in] Source starting X offset
-
-- hOffset -[in] Source starting Y offset
-- width -[in] Width of matrix transfer (columns in bytes)
-- height -[in] Height of matrix transfer (rows)
-- kind -[in] Type of transfer
-- stream -[in] Accelerator view which the copy is being enqueued
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpyAtoH ( void *dst, hipArray\_t srcArray, size\_t srcOffset, size\_t count )
-
-Copies data between host and device.
-
-## See also:
-
-hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-- dst -[in] Destination memory address
-- srcArray -[in] Source array
-- srcOffset -[in] Offset in bytes of source array
-- count -[in] Size of memory copy in bytes
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpyHtoA ( hipArray\_t dstArray, size\_t dstOffset, const void *srcHost, size\_t count )
-
-Copies data between host and device.
-
-## See also:
-
-hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-- dstArray -[in] Destination memory address
-- dstOffset -[in] Offset in bytes of destination array
-- srcHost -[in] Source host pointer
-- count -[in] Size of memory copy in bytes
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection
-
-hipError\_t hipMemcpy3D ( const struct hipMemcpy3DParms *p )
-
-Copies data between host and device.
-
-## See also:
-
-hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-p -[in] 3D memory copy parameters
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpy3DAsync ( const struct hipMemcpy3DParms *p, hipStream\_t stream )
-
-Copies data between host and device asynchronously.
-
-## See also:
-
-hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-- p -[in] 3D memory copy parameters
-- stream -[in] Stream to use
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipDrvMemcpy3D ( const HIP\_MEMCPY3D *pCopy )
-
-Copies data between host and device.
-
-## See also:
-
-hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-pCopy -[in] 3D memory copy parameters
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipDrvMemcpy3DAsync ( const HIP\_MEMCPY3D *pCopy, hipStream\_t stream )
-
-Copies data between host and device asynchronously.
-
-## See also:
-
-hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-- pCopy -[in] 3D memory copy parameters
-- stream -[in] Stream to use
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection template&lt;typename T &gt; hipError\_t hipGetSymbolAddress ( void **devPtr, const T &amp;symbol ) Gets the address of a symbol.
-
-## Parameters
-
-- devPtr -[out] - Returns device pointer associated with symbol.
-- symbol -[in] - Device symbol.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue template&lt;typename T &gt; hipError\_t hipGetSymbolSize ( size\_t *size, const T &amp;symbol ) Gets the size of a symbol.
-
-## Parameters
-
-- size -[out] - Returns the size of a symbol.
-- symbol -[in] - Device symbol address.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue template&lt;typename T &gt;
-
-hipError\_t hipMemcpyToSymbol ( const T &amp;symbol, const void *src, size\_t sizeBytes, size\_t offset, hipMemcpyKind kind )
-
-Copies data to the given symbol on the device.
-
-## See also:
-
-hipMemcpyToSymbol
-
-## Returns
-
-hipSuccess, hipErrorInvalidMemcpyDirection, hipErrorInvalidValue template&lt;typename T &gt;
-
-hipError\_t hipMemcpyToSymbolAsync ( const T &amp;symbol, const void *src, size\_t sizeBytes, size\_t offset, hipMemcpyKind kind, hipStream\_t stream )
-
-Copies data to the given symbol on the device asynchronously on the stream.
-
-## See also:
-
-hipMemcpyToSymbolAsync
-
-## Returns
-
-hipSuccess, hipErrorInvalidMemcpyDirection, hipErrorInvalidValue template&lt;typename T &gt;
-
-hipError\_t hipMemcpyFromSymbol ( void *dst, const T &amp;symbol, size\_t sizeBytes, size\_t offset, hipMemcpyKind kind )
-
-Copies data from the given symbol on the device.
-
-## See also:
-
-hipMemcpyFromSymbol
-
-## Returns
-
-hipSuccess, hipErrorInvalidMemcpyDirection, hipErrorInvalidValue template&lt;typename T &gt;
-
-hipError\_t hipMemcpyFromSymbolAsync ( void *dst, const T &amp;symbol, size\_t sizeBytes, size\_t offset, hipMemcpyKind kind, hipStream\_t stream )
-
-Copies data from the given symbol on the device asynchronously on the stream.
-
-## See also:
-
-hipMemcpyFromSymbolAsync
-
-## Returns
-
-hipSuccess, hipErrorInvalidMemcpyDirection, hipErrorInvalidValue template&lt;class T &gt;
-
-static inline hipError\_t hipMalloc ( T **devPtr, size\_t size )
-
-- : C++ wrapper for hipMalloc
-
-Perform automatic type conversion to eliminate need for excessive typecasting (ie void**)
-
-HIP\_DISABLE\_CPP\_FUNCTIONS macro can be defined to suppress these wrappers. It is useful for applications which need to obtain decltypes of HIP runtime APIs.
-
-## See also:
-
-hipMalloc
-
-## template&lt;class T &gt;
-
-static inline hipError\_t hipHostMalloc ( T **ptr, size\_t size, unsigned int flags = hipHostMallocDefault )
-
-- : C++ wrapper for hipHostMalloc
-
-Provide an override to automatically typecast the pointer type from void**, and also provide a default for the flags.
-
-HIP\_DISABLE\_CPP\_FUNCTIONS macro can be defined to suppress these wrappers. It is useful for applications which need to obtain decltypes of HIP runtime APIs.
-
-## See also:
-
-hipHostMalloc
-
-## 19.23.4 External Resource Interoperability
-
-hipError\_t hipImportExternalSemaphore ( hipExternalSemaphore\_t *extSem\_out, const hipExternalSemaphoreHandleDesc *semHandleDesc )
-
-Imports an external semaphore.
-
-See also:
-
-## Parameters
-
-- extSem\_out -[out] External semaphores to be waited on
-- semHandleDesc -[in] Semaphore import handle descriptor
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError\_t hipSignalExternalSemaphoresAsync ( const hipExternalSemaphore\_t *extSemArray, const hipExternalSemaphoreSignalParams *paramsArray, unsigned int numExtSems, hipStream\_t stream )
-
-Signals a set of external semaphore objects.
-
-## See also:
-
-## Parameters
-
-- extSemArray -[in] External semaphores to be waited on
-- paramsArray -[in] Array of semaphore parameters
-- numExtSems -[in] Number of semaphores to wait on
-- stream -[in] Stream to enqueue the wait operations in
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError\_t hipWaitExternalSemaphoresAsync ( const hipExternalSemaphore\_t *extSemArray, const hipExternalSemaphoreWaitParams *paramsArray, unsigned int numExtSems, hipStream\_t stream )
-
-Waits on a set of external semaphore objects.
-
-See also:
-
-## Parameters
-
-- extSemArray -[in] External semaphores to be waited on
-- paramsArray -[in] Array of semaphore parameters
-- numExtSems -[in] Number of semaphores to wait on
-- stream -[in] Stream to enqueue the wait operations in
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue
-
-## hipError\_t hipDestroyExternalSemaphore ( hipExternalSemaphore\_t extSem )
-
-Destroys an external semaphore object and releases any references to the underlying resource. Any outstanding signals or waits must have completed before the semaphore is destroyed.
-
-## See also:
-
-## Parameters
-
-extSem -[in] handle to an external memory object
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError\_t hipImportExternalMemory ( hipExternalMemory\_t *extMem\_out, const hipExternalMemoryHandleDesc *memHandleDesc )
-
-Imports an external memory object.
-
-## See also:
-
-## Parameters
-
-- extMem\_out -[out] Returned handle to an external memory object
-- memHandleDesc -[in] Memory import handle descriptor
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError\_t hipExternalMemoryGetMappedBuffer ( void **devPtr, hipExternalMemory\_t extMem, const hipExternalMemoryBufferDesc *bufferDesc )
-
-Maps a buffer onto an imported memory object.
-
-## See also:
-
-## Parameters
-
-- devPtr -[out] Returned device pointer to buffer
-- extMem -[in] Handle to external memory object
-- bufferDesc -[in] Buffer descriptor
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue
-
-## hipError\_t hipDestroyExternalMemory ( hipExternalMemory\_t extMem )
-
-Destroys an external memory object.
-
-See also:
-
-## Parameters
-
-extMem -[in] External memory object to be destroyed
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError\_t hipExternalMemoryGetMappedMipmappedArray ( hipMipmappedArray\_t *mipmap,
-
-hipExternalMemory\_t extMem, const hipExternalMemoryMipmappedArrayDesc *mipmapDesc )
-
-Maps a mipmapped array onto an external memory object.
-
-Returned mipmapped array must be freed using hipFreeMipmappedArray.
-
-## See also:
-
-hipImportExternalMemory , hipFreeMipmappedArray
-
-hipDestroyExternalMemory ,
-
-## Parameters
-
-- mipmap -[out] mipmapped array to return
-- extMem -[in] external memory object handle
-- mipmapDesc -[in] external mipmapped array descriptor
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidResourceHandle
-
-## 19.24 Register Keyword
-
-The register keyword is deprecated in C++, and is silently ignored by both NVCC and HIP-Clang. You can pass the option -Wdeprecated-register the compiler warning message.
-
-hipExternalMemoryGetMappedBuffer ,
-
-## 19.25 Pragma Unroll
-
-Unroll with a bounds that is known at compile-time is supported. For example:
-**Following code does:** The code snippet appears to be a corrupted or incorrectly formatted text, possibly due to a copy-paste error or encoding issue. It does not represent valid Python code or any recognizable programming construct. Therefore, it does not perform any specific function or task in its current form.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        //                                                                                                                                                                                                        #pragma unroll 16 /* hint to compiler to unroll next loop by 16 */
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        }                                                                                                                                                                                                        /*                                                                                                                                                                                                        */
-                                                                                                                                                                                                     
-		                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       //
-                                                                                                                                                                                                       }
-                                                                                                                                                                                                       */
-```
-
-## 19.26 In-Line Assembly
-
-GCN ISA In-line assembly, is supported. For example:
-**Following code does:** The code snippet you provided appears to be a command or a reference to a file rather than a typical code snippet. It seems to be related to a SAXPY operation, which stands for "Single-Precision A·X Plus Y." SAXPY is a common operation in linear algebra used to perform a scaled vector addition. The rest of the line suggests it might be related to a specific implementation or version (possibly for a GPU architecture, given the "sm_5" which could refer to a specific compute capability of NVIDIA GPUs) and "ptx" which typically refers to Parallel Thread Execution, NVIDIA's intermediate representation for GPU code. Overall, this line likely refers to a file or command related to executing or compiling a SAXPY operation for a specific GPU architecture.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <img>void                                                                                                                                                                                                        </img>void
-```
-
-We insert the GCN isa into the kernel using asm() Assembler statement. volatile keyword is used so that the optimizers must not change the number of volatile operations or change their order of execution relative to other volatile operations. v\_mac\_f32\_e32 is the GCN instruction, for more information please refer - [AMD GCN3 ISA architecture manual](http://gpuopen.com/compute-product/amd-gcn3-isa-architecture-manual/) Index for the respective operand in the ordered fashion is provided by % followed by position in the list of operands 'v' is the constraint code (for target-specific AMDGPU) for 32-bit VGPR register, for more info please refer - [Supported Constraint Code List for AMDGPU](https://llvm.org/docs/LangRef.html#supported-constraint-code-list) Output Constraints are specified by an '=' prefix as shown above ('=v'). This indicate that assembly will write to this operand, and the operand will then be made available as a return value of the asm expression. Input constraints do not have a prefix - just the constraint code. The constraint string of '0' says to use the assigned register for output as an input as well (it being the 0'th constraint).
-
-## C++ Support The following C++ features are not supported: - Run-time-type information (RTTI) - Try/catch Virtual functions Virtual functions are not supported if objects containing virtual function tables are passed between GPU's of different offload arch's, e.g. between gfx906 and gfx1030. Otherwise virtual functions are supported.
-
-## 19.27 Kernel Compilation
-
-hipcc now supports compiling C++/HIP kernels to binary code objects. The file format for binary is .co which means Code Object. The following command builds the code object using hipcc .
-**Following code does:** The code snippet appears to be a command-line operation that uses `dumpbin.exe` to analyze a specific section of an executable file (`saxpy.exe`). It targets the `.hip_fat` section and extracts raw data with a specified format. The output is then piped into a `select` command, which skips the first 20 lines and selects the next 12 lines from the output. This operation is likely used for inspecting or debugging specific parts of the executable's binary data.
-
-
-```
-hipcc --genco --offload-arch=[TARGET GPU] [INPUT FILE] -o [OUTPUT FILE]
-
-[TARGET GPU] = GPU architecture
-[INPUT FILE] = Name of the file containing kernels
-[OUTPUT FILE] = Name of the generated code object file
-```
-
-Note: When using binary code objects is that the number of arguments to the kernel is different on HIP-Clang and NVCC path. Refer to the HIP module\_api sample for differences in the arguments to be passed to the kernel.
-
-## 19.28 gfx-arch-specific-kernel
-
-Clang defined '\_\_gfx*\_\_' macros can be used to execute gfx arch specific codes inside the kernel. Refer to the sample in HIP 14\_gpu\_arch sample.
-
-## CHAPTER
-
-## TWENTY
-
-## C++ LANGUAGE SUPPORT
-
-The ROCm platform enables the power of combined C++ and HIP (Heterogeneous-computing Interface for Portability) code. This code is compiled with a clang or clang++ compiler. The official compilers support the HIP platform, or you can use the amdclang or amdclang++ included in the ROCm installation, which are a wrapper for the official versions.
-
-The source code is compiled according to the C++03 , C++11 , C++14 , C++17 , and C++20 standards, along with HIPspecific extensions, but is subject to restrictions. The key restriction is the reduced support of standard library in device code. This is due to the fact that by default a function is considered to run on host, except for constexpr functions, which can run on host and device as well.
-
-## 20.1 Modern C++ support
-
-C++ is considered a modern programming language as of C++11. This section describes how HIP supports these new C++ features.
-
-## 20.1.1 C++11 support
-
-The C++11 standard introduced many new features. These features are supported in HIP host code, with some notable omissions on the device side. The rule of thumb here is that constexpr functions work on device, the rest doesn't. This means that some important functionality like std::function is missing on the device, but unfortunately the standard library wasn't designed with HIP in mind, which means that the support is in a state of 'works as-is'.
-
-Certain features have restrictions and clarifications. For example, any functions using the constexpr qualifier or the new initializer lists , std::move or std::forward features are implicitly considered to have the \_\_host\_\_ and \_\_device\_\_ execution space specifier. Also, constexpr variables that are static members or namespace scoped can be used from both host and device, but only for read access. Dereferencing a static constexpr outside its specified execution space causes an error.
-
-Lambdas are supported, but there are some extensions and restrictions on their usage. For more information, see the Extended lambdas section below.
-
-## 20.1.2 C++14 support
-
-The C++14 language features are supported.
-
-## 20.1.3 C++17 support
-
-All C++17 language features are supported.
-
-## 20.1.4 C++20 support
-
-All C++20 language features are supported, but extensions and restrictions apply. C++20 introduced coroutines and modules, which fundamentally changed how programs are written. HIP doesn't support these features. However, consteval functions can be called from host and device, even if specified for host use only.
-
-The three-way comparison operator (spaceship operator &lt;=&gt; ) works with host and device code.
-
-## 20.2 Extensions and restrictions
-
-In addition to the deviations from the standard, there are some general extensions and restrictions to consider.
-
-## 20.2.1 Global functions
-
-Functions that serve as an entry point for device execution are called kernels and are specified with the \_\_global\_\_ qualifier. To call a kernel function, use the triple chevron operator: &lt;&lt;&lt; &gt;&gt;&gt; . Kernel functions must have a void return type. These functions can't:
-
-- have a constexpr specifier
-- have a parameter of type std::initializer\_list or va\_list
-- use an rvalue reference as a parameter.
-- use parameters having different sizes in host and device code, e.g. long double arguments, or structs containing long double members.
-- use struct-type arguments which have different layout in host and device code.
-
-Kernels can have variadic template parameters, but only one parameter pack, which must be the last item in the template parameter list.
-
-## 20.2.2 Device space memory specifiers
-
-HIP includes device space memory specifiers to indicate whether a variable is allocated in host or device memory and howits memory should be allocated. HIP supports the \_\_device\_\_ , \_\_shared\_\_ , \_\_managed\_\_ , and \_\_constant\_\_ specifiers.
-
-The \_\_device\_\_ and \_\_constant\_\_ specifiers define global variables, which are allocated within global memory on the HIP devices. The only difference is that \_\_constant\_\_ variables can't be changed after allocation. The \_\_shared\_\_ specifier allocates the variable within shared memory, which is available for all threads in a block.
-
-The \_\_managed\_\_ variable specifier creates global variables that are initially undefined and unaddressed within the global symbol table. The HIP runtime allocates managed memory and defines the symbol when it loads the device binary. A managed variable can be accessed in both device and host code.
-
-It's important to know where a variable is stored because it is only available from certain locations. Generally, variables allocated in the host memory are not accessible from the device code, while variables allocated in the device memory are not directly accessible from the host code. Dereferencing a pointer to device memory on the host results in a segmentation fault. Accessing device variables in host code should be done through kernel execution or HIP functions like hipMemCpyToSymbol .
-
-## 20.2.3 Exception handling
-
-An important difference between the host and device code is exception handling. In device code, this control flow isn't available due to the hardware architecture. The device code must use return codes to handle errors.
-
-## 20.2.4 Kernel parameters
-
-There are some restrictions on kernel function parameters. They cannot be passed by reference, because these functions are called from the host but run on the device. Also, a variable number of arguments is not allowed.
-
-## 20.2.5 Classes
-
-Classes work on both the host and device side, but there are some constraints. The static member functions can't be \_\_global\_\_ . Virtual member functions work, but a virtual function must not be called from the host if the parent object was created on the device, or the other way around, because this behavior is undefined. Another minor restriction is that \_\_device\_\_ variables, that are global scoped must have trivial constructors.
-
-## 20.2.6 Polymorphic function wrappers
-
-HIP doesn't support the polymorphic function wrapper std::function , which was introduced in C++11.
-
-## 20.2.7 Extended lambdas
-
-HIP supports Lambdas, which by default work as expected.
-
-Lambdas have implicit host device attributes. This means that they can be executed by both host and device code, and works the way you would expect. To make a lambda callable only by host or device code, users can add \_\_host\_\_ or \_\_device\_\_ attribute. The only restriction is that host variables can only be accessed through copy on the device. Accessing through reference will cause undefined behavior.
-
-## 20.2.8 Inline namespaces
-
-Inline namespaces are supported, but with a few exceptions. The following entities can't be declared in namespace scope within an inline unnamed namespace:
-
-- \_\_managed\_\_ , \_\_device\_\_ , \_\_shared\_\_ and \_\_constant\_\_ variables
-- \_\_global\_\_ function and function templates
-- variables with surface or texture type
-
-## CHAPTER
-
-## TWENTYONE
-
-## HIP MATH API
-
-HIP-Clang supports a set of math operations that are callable from the device. HIP supports most of the device functions supported by NVIDIA CUDA. These are described in the following sections.
-
-## 21.1 Single precision mathematical functions
-
-Following is the list of supported single precision mathematical functions.
-
-Table 1: Single precision mathematical functions
-
-| Function                                                                   | Supported on Host   | Supported on Device   |
-|----------------------------------------------------------------------------|---------------------|-----------------------|
-| float abs(float x) Returns the absolute value of 𝑥                         | ✓                   | ✓                     |
-| float acosf(float x) Returns the arc cosine of 𝑥 .                         | ✓                   | ✓                     |
-| float acoshf(float x) Returns the nonnegative arc hyperbolic cosine of 𝑥 . | ✓                   | ✓                     |
-| float asinf(float x) Returns the arc sine of 𝑥 .                           | ✓                   | ✓                     |
-| float asinhf(float x) Returns the arc hyperbolic sine of 𝑥 .               | ✓                   | ✓                     |
-| float atanf(float x) Returns the arc tangent of 𝑥 .                        | ✓                   | ✓                     |
-
-continues on next page
-
-|                                                                                                                        | Table   | 1 - continued from previous page   |
-|------------------------------------------------------------------------------------------------------------------------|---------|------------------------------------|
-| float atan2f(float x, float y) Returns the arc tangent of the ratio of 𝑥 and 𝑦 .                                       | ✓       | ✓                                  |
-| float atanhf(float x) Returns the arc hyperbolic tangent of 𝑥 .                                                        | ✓       | ✓                                  |
-| float cbrtf(float x) Returns the cube root of 𝑥 .                                                                      | ✓       | ✓                                  |
-| float ceilf(float x) Returns ceiling of 𝑥 .                                                                            | ✓       | ✓                                  |
-| float copysignf(float x, float y) Create value with given magnitude, copying sign of second value.                     | ✓       | ✓                                  |
-| float cosf(float x) Returns the cosine of 𝑥 .                                                                          | ✓       | ✓                                  |
-| float coshf(float x) Returns the hyperbolic cosine of 𝑥 .                                                              | ✓       | ✓                                  |
-| float cospif(float x) Returns the cosine of 𝜋 · 𝑥 .                                                                    | ✓       | ✓                                  |
-| float cyl_bessel_i0f(float x) Returns the value of the regular modified cylindrical Bessel function of order 0 for 𝑥 . |         |                                    |
-
-continues on next page
-
-Table 1 - continued from previous page
-
-| float cyl_bessel_i1f(float x) Returns the value of the regular modified cylindrical Bessel function of order 1 for 𝑥 .   |    |    |
-|--------------------------------------------------------------------------------------------------------------------------|----|----|
-| float erff(float x) Returns the error function of 𝑥 .                                                                    | ✓  | ✓  |
-| float erfcf(float x) Returns the complementary error function of 𝑥 .                                                     | ✓  | ✓  |
-| float erfcinvf(float x) Returns the inverse complementary function of 𝑥 .                                                | ✓  | ✓  |
-| float erfcxf(float x) Returns the scaled complementary error function of 𝑥 .                                             | ✓  | ✓  |
-| float erfinvf(float x) Returns the inverse error function of 𝑥 .                                                         | ✓  | ✓  |
-| float expf(float x) Returns 𝑒 𝑥 .                                                                                        | ✓  | ✓  |
-| float exp10f(float x) Returns 10 𝑥 .                                                                                     | ✓  | ✓  |
-| float exp2f( float x) Returns 2 𝑥 .                                                                                      | ✓  | ✓  |
-| float expm1f(float x) Returns 𝑙𝑛 ( 𝑥 - 1)                                                                                | ✓  | ✓  |
-
-continues on next page
-
-Table
-
-1 - continued from previous page
-
-| float fabsf(float x) Returns the absolute value of x                               | ✓   | ✓   |
-|------------------------------------------------------------------------------------|-----|-----|
-| float fdimf(float x, float y) Returns the positive difference between 𝑥 and 𝑦 .    | ✓   | ✓   |
-| float fdividef(float x, float y) Divide two floating point values.                 | ✓   | ✓   |
-| float floorf(float x) Returns the largest integer less than or equal to 𝑥 .        | ✓   | ✓   |
-| float fmaf(float x, float y, float z) Returns 𝑥 · 𝑦 + 𝑧 as a single operation.     | ✓   | ✓   |
-| float fmaxf(float x, float y) Determine the maximum numeric value of 𝑥 and 𝑦 .     | ✓   | ✓   |
-| float fminf(float x, float y) Determine the minimum numeric value of 𝑥 and 𝑦 .     | ✓   | ✓   |
-| float fmodf(float x, float y) Returns the floating-point remainder of 𝑥/𝑦 .        | ✓   | ✓   |
-| float modff(float x, float* iptr) Break down 𝑥 into fractional and integral parts. | ✓   |     |
-
-continues on next page
-
-Table 1 - continued from previous page
-
-| float frexpf(float x, int* nptr) Extract mantissa and exponent of 𝑥 .                                   | ✓   |
-|---------------------------------------------------------------------------------------------------------|-----|
-| float hypotf(float x, float y) Returns the square root of the sum of squares of 𝑥 and 𝑦 .               | ✓   |
-| int ilogbf(float x) Returns the unbiased integer exponent of 𝑥 .                                        | ✓   |
-| bool isfinite(float x) Determine whether 𝑥 is finite.                                                   | ✓   |
-| bool isinf(float x) Determine whether 𝑥 is infinite.                                                    | ✓   |
-| bool isnan(float x) Determine whether 𝑥 is a NAN .                                                      | ✓   |
-| float j0f(float x) Returns the value of the Bessel function of the first kind of order 0 for 𝑥 .        | ✓   |
-| float j1f(float x) Returns the value of the Bessel function of the first kind of order 1 for 𝑥 .        | ✓   |
-| float jnf(int n, float x) Returns the value of the Bessel function of the first kind of order n for 𝑥 . | ✓   |
-
-continues on next page
-
-Table
-
-1 - continued from previous page
-
-| float ldexpf(float x, int exp) Returns the natural logarithm of the absolute value of the gamma function of 𝑥 .   | ✓   | ✓   |
-|-------------------------------------------------------------------------------------------------------------------|-----|-----|
-| float lgammaf(float x) Returns the natural logarithm of the absolute value of the gamma function of 𝑥 .           | ✓   |     |
-| long int lrintf(float x) Round 𝑥 to nearest integer value.                                                        | ✓   | ✓   |
-| long long int llrintf(float x) Round 𝑥 to nearest integer value.                                                  | ✓   | ✓   |
-| long int lroundf(float x) Round to nearest integer value.                                                         | ✓   | ✓   |
-| long long int llroundf(float x) Round to nearest integer value.                                                   | ✓   | ✓   |
-| float log10f(float x) Returns the base 10 logarithm of 𝑥 .                                                        | ✓   | ✓   |
-| float log1pf(float x) Returns the natural logarithm of 𝑥 +1 .                                                     | ✓   | ✓   |
-| float log2f(float x) Returns the base 2 logarithm of 𝑥 .                                                          | ✓   | ✓   |
-| float logf(float x) Returns the natural logarithm of 𝑥 .                                                          | ✓   | ✓   |
-
-continues on next page
-
-Table 1 - continued from previous page
-
-|                                                                                                                      |    | ✓   |
-|----------------------------------------------------------------------------------------------------------------------|----|-----|
-| float logbf(float x) Returns the floating point representation of the exponent of 𝑥 .                                | ✓  |     |
-| float nanf(const char* tagp) Returns 'Not a Number' value.                                                           |    | ✓   |
-| float nearbyintf(float x) Round 𝑥 to the nearest integer.                                                            | ✓  | ✓   |
-| float nextafterf(float x, float y) Returns next representable single-precision floating-point value after argument.  | ✓  |     |
-| float norm3df(float x, float y, float z) Returns the square root of the sum of squares of 𝑥 , 𝑦 and 𝑧 .              | ✓  | ✓   |
-| float norm4df(float x, float y, float z, float w) Returns the square root of the sum of squares of 𝑥 , 𝑦 , 𝑧 and 𝑤 . | ✓  | ✓   |
-| float normcdff(float y) Returns the standard normal cumulative distribution function.                                | ✓  | ✓   |
-| float normcdfinvf(float y) Returns the inverse of the standard normal cumulative distribution function.              | ✓  | ✓   |
-| float normf(int dim, const float *a) Returns the square root of the sum of squares of any number of coordinates.     | ✓  | ✓   |
-
-continues on next page
-
-|                                                                                                                   | Table   | 1 - continued from previous page   |
-|-------------------------------------------------------------------------------------------------------------------|---------|------------------------------------|
-| float powf(float x, float y) Returns 𝑥 𝑦 .                                                                        | ✓       | ✓                                  |
-| float powif(float base, int iexp) Returns the value of first argument to the power of second argument.            | ✓       | ✓                                  |
-| float remainderf(float x, float y) Returns single-precision floating-point remainder.                             | ✓       | ✓                                  |
-| float remquof(float x, float y, int* quo) Returns single-precision floating-point remainder and part of quotient. | ✓       | ✓                                  |
-| float roundf(float x) Round to nearest integer value in floating-point.                                           | ✓       | ✓                                  |
-| float rcbrtf(float x) Returns the reciprocal cube root function.                                                  | ✓       | ✓                                  |
-| float rhypotf(float x, float y) Returns one over the square root of the sum of squares of two arguments.          | ✓       | ✓                                  |
-| float rintf(float x) Round input to nearest integer value in floating-point.                                      | ✓       | ✓                                  |
-
-continues on next page
-
-Table
-
-1 - continued from previous page
-
-| float rnorm3df(float x, float y, float z) Returns one over the square root of the sum of squares of three coordinates of the argument.         | ✓   | ✓   |
-|------------------------------------------------------------------------------------------------------------------------------------------------|-----|-----|
-| float rnorm4df(float x, float y, float z, float w) Returns one over the square root of the sum of squares of four coordinates of the argument. | ✓   | ✓   |
-| float rnormf(int dim, const float *a) Returns the reciprocal of square root of the sum of squares of any number of coordinates.                | ✓   | ✓   |
-| float scalblnf(float x, long int n) Scale 𝑥 by 2 𝑛 .                                                                                           | ✓   | ✓   |
-| float scalbnf(float x, int n) Scale 𝑥 by 2 𝑛 .                                                                                                 | ✓   | ✓   |
-| bool signbit(float x) Return the sign bit of 𝑥 .                                                                                               | ✓   | ✓   |
-| float sinf(float x) Returns the sine of 𝑥 .                                                                                                    | ✓   | ✓   |
-| float sinhf(float x) Returns the hyperbolic sine of 𝑥 .                                                                                        | ✓   | ✓   |
-| float sinpif(float x) Returns the hyperbolic sine of 𝜋 · 𝑥 .                                                                                   | ✓   | ✓   |
-
-continues on next page
-
-Table
-
-1 - continued from previous page
-
-| void sincosf(float x, float *sptr, float *cptr) Returns the sine and cosine of 𝑥 .                | ✓   | ✓   |
-|---------------------------------------------------------------------------------------------------|-----|-----|
-| void sincospif(float x, float *sptr, float *cptr) Returns the sine and cosine of 𝜋 · 𝑥 .          | ✓   | ✓   |
-| float sqrtf(float x) Returns the square root of 𝑥 .                                               | ✓   | ✓   |
-| float rsqrtf(float x) Returns the reciprocal of the square root of 𝑥 .                            |     | ✓   |
-| float tanf(float x) Returns the tangent of 𝑥 .                                                    | ✓   | ✓   |
-| float tanhf(float x) Returns the hyperbolic tangent of 𝑥 .                                        | ✓   | ✓   |
-| float tgammaf(float x) Returns the gamma function of 𝑥 .                                          | ✓   | ✓   |
-| float truncf(float x) Truncate 𝑥 to the integral part.                                            | ✓   | ✓   |
-| float y0f(float x) Returns the value of the Bessel function of the second kind of order 0 for 𝑥 . | ✓   | ✓   |
-| float y1f(float x) Returns the value of the Bessel function of the second kind of order 1 for 𝑥 . | ✓   | ✓   |
-
-continues on next page
-**Following code does:** It seems like there is a placeholder or an error in your request, as the code snippet is missing. Please provide the actual code snippet you would like me to analyze, and I'll be happy to help!
-
-
-```
-                                                                                                                                                                                                        \
-    float  ynf(int  n,  float  x)
-    Returns the value of the Bessel
-    function of the second kind of order
-    n for x.
-```
-
-Table 1 - continued from previous page
-
-## 21.2 Double precision mathematical functions
-
-Following is the list of supported double precision mathematical functions.
-
-Table 2: Double precision mathematical functions
-
-| Function                                                                           | Supported on Host   | Supported on Device   |
-|------------------------------------------------------------------------------------|---------------------|-----------------------|
-| double abs(double x) Returns the absolute value of 𝑥                               | ✓                   | ✓                     |
-| double acos(double x) Returns the arc cosine of 𝑥 .                                | ✓                   | ✓                     |
-| double acosh(double x) Returns the nonnegative arc hyperbolic cosine of 𝑥 .        | ✓                   | ✓                     |
-| double asin(double x) Returns the arc sine of 𝑥 .                                  | ✓                   | ✓                     |
-| double asinh(double x) Returns the arc hyperbolic sine of 𝑥 .                      | ✓                   | ✓                     |
-| double atan(double x) Returns the arc tangent of 𝑥 .                               | ✓                   | ✓                     |
-| double atan2(double x, double y) Returns the arc tangent of the ratio of 𝑥 and 𝑦 . | ✓                   | ✓                     |
-
-continues on next page
-
-Table 2 - continued from previous page
-
-| double atanh(double x) Returns the arc hyperbolic tangent of 𝑥 .                                                        | ✓   | ✓   |
-|-------------------------------------------------------------------------------------------------------------------------|-----|-----|
-| double cbrt(double x) Returns the cube root of 𝑥 .                                                                      | ✓   | ✓   |
-| double ceil(double x) Returns ceiling of 𝑥 .                                                                            | ✓   | ✓   |
-| double copysign(double x, double y) Create value with given magnitude, copying sign of second value.                    | ✓   | ✓   |
-| double cos(double x) Returns the cosine of 𝑥 .                                                                          | ✓   | ✓   |
-| double cosh(double x) Returns the hyperbolic cosine of 𝑥 .                                                              | ✓   | ✓   |
-| double cospi(double x) Returns the cosine of 𝜋 · 𝑥 .                                                                    | ✓   | ✓   |
-| double cyl_bessel_i0(double x) Returns the value of the regular modified cylindrical Bessel function of order 0 for 𝑥 . |     |     |
-| double cyl_bessel_i1(double x) Returns the value of the regular modified cylindrical Bessel function of order 1 for     | 𝑥 . |     |
-| double erf(double x) Returns the error function of 𝑥 .                                                                  | ✓   | ✓   |
-
-continues on next page
-
-Table 2 - continued from previous page
-
-| double erfc(double x) Returns the complementary error function of 𝑥 .             | ✓   | ✓   |
-|-----------------------------------------------------------------------------------|-----|-----|
-| double erfcinv(double x) Returns the inverse complementary function of 𝑥 .        | ✓   | ✓   |
-| double erfcx(double x) Returns the scaled complementary error function of 𝑥 .     | ✓   | ✓   |
-| double erfinv(double x) Returns the inverse error function of 𝑥 .                 | ✓   | ✓   |
-| double exp(double x) Returns 𝑒 𝑥 .                                                | ✓   | ✓   |
-| double exp10(double x) Returns 10 𝑥 .                                             | ✓   | ✓   |
-| double exp2( double x) Returns 2 𝑥 .                                              | ✓   | ✓   |
-| double expm1(double x) Returns 𝑙𝑛 ( 𝑥 - 1)                                        | ✓   | ✓   |
-| double fabs(double x) Returns the absolute value of x                             | ✓   | ✓   |
-| double fdim(double x, double y) Returns the positive difference between 𝑥 and 𝑦 . | ✓   | ✓   |
-
-continues on next page
-
-Table 2 - continued from previous page
-
-| double floor(double x) Returns the largest integer less than or equal to 𝑥 .                | ✓   | ✓   |
-|---------------------------------------------------------------------------------------------|-----|-----|
-| double fma(double x, double y, double z) Returns 𝑥 · 𝑦 + 𝑧 as a single operation.           | ✓   | ✓   |
-| double fmax(double x, double y) Determine the maximum numeric value of 𝑥 and 𝑦 .            | ✓   | ✓   |
-| double fmin(double x, double y) Determine the minimum numeric value of 𝑥 and 𝑦 .            | ✓   | ✓   |
-| double fmod(double x, double y) Returns the floating-point remainder of 𝑥/𝑦 .               | ✓   | ✓   |
-| double modf(double x, double* iptr) Break down 𝑥 into fractional and integral parts.        | ✓   |     |
-| double frexp(double x, int* nptr) Extract mantissa and exponent of 𝑥 .                      | ✓   |     |
-| double hypot(double x, double y) Returns the square root of the sum of squares of 𝑥 and 𝑦 . | ✓   | ✓   |
-| int ilogb(double x) Returns the unbiased integer exponent of 𝑥 .                            | ✓   | ✓   |
-
-continues on next page
-
-Table 2 - continued from previous page
-
-| bool isfinite(double x) Determine whether 𝑥 is finite.                                                           | ✓   | ✓   |
-|------------------------------------------------------------------------------------------------------------------|-----|-----|
-| bool isin(double x) Determine whether 𝑥 is infinite.                                                             | ✓   | ✓   |
-| bool isnan(double x) Determine whether 𝑥 is a NAN .                                                              | ✓   | ✓   |
-| double j0(double x) Returns the value of the Bessel function of the first kind of order 0 for 𝑥 .                | ✓   | ✓   |
-| double j1(double x) Returns the value of the Bessel function of the first kind of order 1 for 𝑥 .                | ✓   | ✓   |
-| double jn(int n, double x) Returns the value of the Bessel function of the first kind of order n for 𝑥 .         | ✓   | ✓   |
-| double ldexp(double x, int exp) Returns the natural logarithm of the absolute value of the gamma function of 𝑥 . | ✓   | ✓   |
-| double lgamma(double x) Returns the natural logarithm of the absolute value of the gamma function of 𝑥 .         | ✓   |     |
-| long int lrint(double x) Round 𝑥 to nearest integer value.                                                       | ✓   | ✓   |
-
-continues on next page
-
-Table 2 - continued from previous page
-
-| long long int llrint(double x) Round 𝑥 to nearest integer value.                       | ✓   | ✓   |
-|----------------------------------------------------------------------------------------|-----|-----|
-| long int lround(double x) Round to nearest integer value.                              | ✓   | ✓   |
-| long long int llround(double x) Round to nearest integer value.                        | ✓   | ✓   |
-| double log10(double x) Returns the base 10 logarithm of 𝑥 .                            | ✓   | ✓   |
-| double log1p(double x) Returns the natural logarithm of 𝑥 +1 .                         | ✓   | ✓   |
-| double log2(double x) Returns the base 2 logarithm of 𝑥 .                              | ✓   | ✓   |
-| double log(double x) Returns the natural logarithm of 𝑥 .                              | ✓   | ✓   |
-| double logb(double x) Returns the floating point representation of the exponent of 𝑥 . | ✓   | ✓   |
-| double nan(const char* tagp) Returns 'Not a Number' value.                             |     | ✓   |
-| double nearbyint(double x) Round 𝑥 to the nearest integer.                             | ✓   | ✓   |
-
-continues on next page
-
-Table 2 - continued from previous page
-
-|                                                                                                                          |    | ✓   |
-|--------------------------------------------------------------------------------------------------------------------------|----|-----|
-| double nextafter(double x, double y) Returns next representable double-precision floating-point value after argument.    | ✓  |     |
-| double norm3d(double x, double y, double z) Returns the square root of the sum of squares of 𝑥 , 𝑦 and 𝑧 .               | ✓  | ✓   |
-| double norm4d(double x, double y, double z, double w) Returns the square root of the sum of squares of 𝑥 , 𝑦 , 𝑧 and 𝑤 . | ✓  | ✓   |
-| double normcdf(double y) Returns the standard normal cumulative distribution function.                                   | ✓  | ✓   |
-| double normcdfinv(double y) Returns the inverse of the standard normal cumulative distribution function.                 | ✓  | ✓   |
-| double norm(int dim, const double *a) Returns the square root of the sum of squares of any number of coordinates.        | ✓  | ✓   |
-| double pow(double x, double y) Returns 𝑥 𝑦 .                                                                             | ✓  | ✓   |
-| double powi(double base, int iexp) Returns the value of first argument to the power of second argument.                  | ✓  | ✓   |
-
-continues on next page
-
-|                                                                                                                                                    | Table   | 2 - continued from previous page   |
-|----------------------------------------------------------------------------------------------------------------------------------------------------|---------|------------------------------------|
-| double remainder(double x, double y) Returns double-precision floating-point remainder.                                                            | ✓       | ✓                                  |
-| double remquo(double x, double y, int* quo) Returns double-precision floating-point remainder and part quotient.                                   | ✓       | of                                 |
-| double round(double x) Round to nearest integer value in floating-point.                                                                           | ✓       | ✓                                  |
-| double rcbrt(double x) Returns the reciprocal cube root function.                                                                                  | ✓       | ✓                                  |
-| double rhypot(double x, double y) Returns one over the square root of the sum of squares of two arguments.                                         | ✓       | ✓                                  |
-| double rint(double x) Round input to nearest integer value in floating-point.                                                                      | ✓       | ✓                                  |
-| double rnorm3d(double x, double y, double z) Returns one over the square root of the sum of squares of three coordinates of the argument.          | ✓       | ✓                                  |
-| double rnorm4d(double x, double y, double z, double w) Returns one over the square root of the sum of squares of four coordinates of the argument. | ✓       | ✓                                  |
-
-continues on next page
-
-Table 2 - continued from previous page
-
-|                                                                                                                                  | ✓   |    |
-|----------------------------------------------------------------------------------------------------------------------------------|-----|----|
-| double rnorm(int dim, const double *a) Returns the reciprocal of square root of the sum of squares of any number of coordinates. |     | ✓  |
-| double scalbln(double x, long int n) Scale 𝑥 by 2 𝑛 .                                                                            | ✓   | ✓  |
-| double scalbn(double x, int n) Scale 𝑥 by 2 𝑛 .                                                                                  | ✓   | ✓  |
-| bool signbit(double x) Return the sign bit of 𝑥 .                                                                                | ✓   | ✓  |
-| double sin(double x) Returns the sine of 𝑥 .                                                                                     | ✓   | ✓  |
-| double sinh(double x) Returns the hyperbolic sine of 𝑥 .                                                                         | ✓   | ✓  |
-| double sinpi(double x) Returns the hyperbolic sine of 𝜋 · 𝑥 .                                                                    | ✓   | ✓  |
-| void sincos(double x, double *sptr, double *cptr) Returns the sine and cosine of 𝑥 .                                             | ✓   | ✓  |
-| void sincospi(double x, double *sptr, double *cptr) Returns the sine and cosine of 𝜋 · 𝑥 .                                       | ✓   | ✓  |
-| double sqrt(double x) Returns the square root of 𝑥 .                                                                             | ✓   | ✓  |
-
-continues on next page
-
-Table 2 - continued from previous page
-
-| double rsqrt(double x) Returns the reciprocal of the square root of 𝑥 .                                   | ✓   |
-|-----------------------------------------------------------------------------------------------------------|-----|
-| double tan(double x) Returns the tangent of 𝑥 .                                                           | ✓   |
-| double tanh(double x) Returns the hyperbolic tangent of 𝑥 .                                               | ✓   |
-| double tgamma(double x) Returns the gamma function of 𝑥 .                                                 | ✓   |
-| double trunc(double x) Truncate 𝑥 to the integral part.                                                   | ✓   |
-| double y0(double x) Returns the value of the Bessel function of the second kind of order 0 for 𝑥 .        | ✓   |
-| double y1(double x) Returns the value of the Bessel function of the second kind of order 1 for 𝑥 .        | ✓   |
-| double yn(int n, double x) Returns the value of the Bessel function of the second kind of order n for 𝑥 . | ✓   |
-
-## 21.3 Integer intrinsics
-
-Following is the list of supported integer intrinsics. Note that intrinsics are supported on device only.
-
-Table 3: Integer intrinsics mathematical functions
-
-## Function
-
-unsigned int \_\_brev(unsigned int x) Reverse the bit order of a 32 bit unsigned integer.
-
-unsigned long long int \_\_brevll(unsigned long long int x) Reverse the bit order of a 64 bit unsigned integer.
-
-unsigned int \_\_byte\_perm(unsigned int x, unsigned int y, unsigned int z) Return selected bytes from two 32-bit unsigned integers.
-
-unsigned int \_\_clz(int x) Return the number of consecutive high-order zero bits in 32 bit integer.
-
-unsigned int \_\_clzll(long long int x) Return the number of consecutive high-order zero bits in 64 bit integer.
-
-unsigned int \_\_ffs(int x) Find the position of least significant bit set to 1 in a 32 bit integer.
-
-unsigned int \_\_ffsll(long long int x) Find the position of least significant bit set to 1 in a 64 bit signed integer.
-
-unsigned int \_\_fns32(unsigned long long mask, unsigned int base, int offset) Find the position of the n-th set to 1 bit in a 32-bit integer.
-
-unsigned int \_\_fns64(unsigned long long int mask, unsigned int base, int offset) Find the position of the n-th set to 1 bit in a 64-bit integer.
-
-unsigned int \_\_funnelshift\_l(unsigned int lo, unsigned int hi, unsigned int shift) Concatenate ℎ𝑖 and 𝑙𝑜 , shift left by shift &amp; 31 bits, return the most significant 32 bits.
-
-unsigned int \_\_funnelshift\_lc(unsigned int lo, unsigned int hi, unsigned int shift) Concatenate ℎ𝑖 and 𝑙𝑜 , shift left by min(shift, 32) bits, return the most significant 32 bits.
-
-unsigned int \_\_funnelshift\_r(unsigned int lo, unsigned int hi, unsigned int shift) Concatenate ℎ𝑖 and 𝑙𝑜 , shift right by shift &amp; 31 bits, return the least significant 32 bits. 226 Chapter 21. HIP math API
-
-The HIP-Clang implementation of \_\_ffs() and \_\_ffsll() contains code to add a constant +1 to produce the ffs result format. For the cases where this overhead is not acceptable and programmer is willing to specialize for the platform, HIP-Clang provides \_\_lastbit\_u32\_u32(unsigned int input) and \_\_lastbit\_u32\_u64(unsigned long long int input) . The index returned by \_\_lastbit\_ instructions starts at -1, while for ffs the index starts at 0.
-
-## 21.4 Floating-point Intrinsics
-
-Following is the list of supported floating-point intrinsics. Note that intrinsics are supported on device only.
-
-Note: Only the nearest even rounding mode supported on AMD GPUs by defaults. The \_rz , \_ru and \_rd suffixed intrinsic functions are existing in HIP AMD backend, if the OCML\_BASIC\_ROUNDED\_OPERATIONS macro is defined.
-
-Table 4: Single precision intrinsics mathematical functions
-
-Function float \_\_cosf(float x) Returns the fast approximate cosine of 𝑥 . float \_\_exp10f(float x) Returns the fast approximate for 10 x . float \_\_expf(float x) Returns the fast approximate for e x . float \_\_fadd\_rn(float x, float y) Add two floating-point values in round-to-nearest-even mode. float \_\_fdiv\_rn(float x, float y) Divide two floating point values in round-to-nearest-even mode. float \_\_fmaf\_rn(float x, float y, float z) Returns x × y + z as a single operation in round-to-nearest-even mode. float \_\_fmul\_rn(float x, float y) Multiply two floating-point values in round-to-nearest-even mode. float \_\_frcp\_rn(float x, float y) Returns 1 / x in round-to-nearest-even mode. float \_\_frsqrt\_rn(float x) Returns 1 / x in round-to-nearest-even mode. float \_\_fsqrt\_rn(float x) Returns x in round-to-nearest-even mode. float \_\_fsub\_rn(float x, float y) Subtract two floating-point values in round-to-nearest-even mode. float \_\_log10f(float x) Returns the fast approximate for base 10 logarithm of 𝑥 . 228 Chapter 21. HIP math API
-
-Table 5: Double precision intrinsics mathematical functions
-
-Function double \_\_dadd\_rn(double x, double y) Add two floating-point values in round-to-nearest-even mode. double \_\_ddiv\_rn(double x, double y) Divide two floating-point values in round-to-nearest-even mode. double \_\_dmul\_rn(double x, double y) Multiply two floating-point values in round-to-nearest-even mode. double \_\_drcp\_rn(double x, double y) Returns 1 / x in round-to-nearest-even mode. double \_\_dsqrt\_rn(double x) Returns x in round-to-nearest-even mode. double \_\_dsub\_rn(double x, double y) Subtract two floating-point values in round-to-nearest-even mode. double \_\_fma\_rn(double x, double y, double z) Returns x × y + z as a single operation in round-to-nearest-even mode.
-
-## CHAPTER
-
-## TWENTYTWO
-
-## TABLE COMPARING SYNTAX FOR DIFFERENT COMPUTE APIS
-
-| Term                   | CUDA                | HIP                                        | OpenCL                 |
-|------------------------|---------------------|--------------------------------------------|------------------------|
-| Device                 | int deviceId        | int deviceId                               | cl_device              |
-| Queue                  | cudaStream_t        | hipStream_t                                | cl_command_queue       |
-| Event                  | cudaEvent_t         | hipEvent_t                                 | cl_event               |
-| Memory                 | void *              | void *                                     | cl_mem                 |
-|                        | grid                | grid                                       | NDRange                |
-|                        | block               | block                                      | work-group             |
-|                        | thread              | thread                                     | work-item              |
-|                        | warp                | warp                                       | sub-group              |
-| Thread-index           | threadIdx.x         | threadIdx.x                                | get_local_id(0)        |
-| Block-index            | blockIdx.x          | blockIdx.x                                 | get_group_id(0)        |
-| Block-dim              | blockDim.x          | blockDim.x                                 | get_local_size(0)      |
-| Grid-dim               | gridDim.x           | gridDim.x                                  | get_num_groups(0)      |
-| Device Kernel          | __global__          | __global__                                 | __kernel               |
-| Device Function        | __device__          | __device__                                 | Implied in device com  |
-| Host Function          | __host_ (default)   | __host_ (default)                          | Implied in host compil |
-| Host + Device Function | __host__ __device__ | __host__ __device__                        | No equivalent          |
-| Kernel Launch          | <<< >>>             | hipLaunchKernel / hipLaunchKernelGGL / <<< | clEnqueueNDRangeK      |
-| Global Memory          | __global__          | __global__                                 | __global               |
-| Group Memory           | __shared__          | __shared__                                 | __local                |
-| Constant               | __constant__        | __constant__                               | __constant             |
-|                        | __syncthreads       | __syncthreads                              | barrier(CLK_LOCAL      |
-| Atomic Builtins        | atomicAdd           | atomicAdd                                  | atomic_add             |
-| Precise Math           | cos(f)              | cos(f)                                     | cos(f)                 |
-| Fast Math              | __cos(f)            | __cos(f)                                   | native_cos(f)          |
-| Vector                 | float4              | float4                                     | float4                 |
-
-## 22.1 Notes
-
-The indexing functions (starting with thread-index ) show the terminology for a 1D grid. Some APIs use reverse order of xyz / 012 indexing for 3D grids.
-
-## CHAPTER
-
-## TWENTYTHREE
-
-## HIP COOPERATIVE GROUPS API
-
-## 23.1 Cooperative kernel launches
-
-The following host-side functions are used for cooperative kernel launches.
-
-| Warning:                                                                                    | Warning:                                                                                    | doxygenfunction:                                                                            | doxygenfunction:                                                                            | doxygenfunction:                                                                            | Cannot                                                                                      | find function                                                                               | 'hipLaunchCooperativeKernel' Documentation'                                                 | 'hipLaunchCooperativeKernel' Documentation'                                                 |                                                                                             |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
-| in                                                                                          | doxygen                                                                                     | xml                                                                                         | output                                                                                      | for project                                                                                 | 'HIP                                                                                        | 6.1.40092                                                                                   | from                                                                                        | directory:                                                                                  |                                                                                             |
-| /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- |
-| 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      |
-
-| Warning:                                                                                    | Warning:                                                                                    | doxygenfunction: project                                                                    | doxygenfunction: project                                                                    | doxygenfunction: project                                                                    | Cannot                                                                                      | Cannot                                                                                      | find function                                                                               | 'hipLaunchCooperativeKernel'                                                                | 'hipLaunchCooperativeKernel'                                                                |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
-| in                                                                                          | doxygen                                                                                     | xml                                                                                         | output                                                                                      | for                                                                                         |                                                                                             | 'HIP                                                                                        | 6.1.40092                                                                                   | Documentation'                                                                              | from                                                                                        |
-| /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- |
-| 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      |
-
-| Warning:                                                                                    | Warning:                                                                                    | doxygenfunction:                                                                            | doxygenfunction:                                                                            | doxygenfunction:                                                                            | Cannot                                                                                      | find                                                                                        | function                                                                                    | 'hipLaunchCooperativeKernelMultiDe-                                                         | 'hipLaunchCooperativeKernelMultiDe-                                                         | 'hipLaunchCooperativeKernelMultiDe-                                                         |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
-| vice'                                                                                       | in                                                                                          | doxygen                                                                                     | xml                                                                                         | output for                                                                                  | project                                                                                     | 'HIP                                                                                        | 6.1.40092                                                                                   | Documentation'                                                                              | from                                                                                        | directory:                                                                                  |
-| /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- |
-| 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      |
-
-| Warning: in                                                                                 | doxygenfunction: Cannot find xml output for project 'HIP                                    | doxygenfunction: Cannot find xml output for project 'HIP                                    |                                                                                             |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
-| nel'                                                                                        | function 6.1.40092                                                                          | 'hipModuleLaunchCooperativeKer- Documentation' from directory:                              |                                                                                             |
-| /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- |
-| 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      |
-
-Warning: doxygenfunction: Cannot find function 'hipModuleLaunchCooperativeKernelMultiDevice' in doxygen xml output for project 'HIP 6.1.40092 Documentation' from directory: /home/docs/checkouts/readthedocs.org/user\_builds/advanced-micro-devices-hip/checkouts/docs6.1.2/docs/doxygen/xml
-
-## 23.2 Cooperative groups classes
-
-The following cooperative groups classes can be used on the device side.
-
-## class thread\_group
-
-The base type of all cooperative group types.
-
-Holds the key properties of a constructed cooperative group types object, like the group type, its size, etc.
-
-Note: Cooperative groups feature is implemented on Linux, under development on Microsoft Windows.
-
-Subclassed by cooperative\_groups::coalesced\_group , cooperative\_groups::grid\_group , coopera-tive\_groups::multi\_grid\_group , cooperative\_groups::thread\_block , cooperative\_groups::tiled\_group class thread\_block : public cooperative\_groups:: thread\_group
-
-The workgroup (thread-block in CUDA terminology) cooperative group type.
-
-Represents an intra-workgroup cooperative group type, where the participating threads within the group are the same threads that participated in the currently executing workgroup .
-
-Note: This function is implemented on Linux and is under development on Microsoft Windows.
-
-class grid\_group : public cooperative\_groups:: thread\_group
-
-The grid cooperative group type.
-
-Represents an inter-workgroup cooperative group type, where the participating threads within the group spans across multiple workgroups running the (same) kernel on the same device.
-
-Note: This is implemented on Linux and is under development on Microsoft Windows.
-
-class multi\_grid\_group : public cooperative\_groups:: thread\_group
-
-The multi-grid cooperative group type.
-
-Represents an inter-device cooperative group type, where the participating threads within the group span across multiple devices, running the (same) kernel on these devices.
-
-Note: The multi-grid cooperative group type is implemented on Linux, under development on Microsoft Windows.
-
-## template&lt;unsigned int size , class ParentCGTy &gt;
-
-class thread\_block\_tile : public cooperative\_groups::impl::thread\_block\_tile\_internal&lt; size , ParentCGTy &gt; Group type -thread\_block\_tile .
-
-Represents one tiled thread group in a wavefront. This group type also supports sub-wave level intrinsics.
-
-Note: This type is implemented on Linux, under development on Microsoft Windows.
-
-## Public Functions
-
-unsigned int thread\_rank () const
-
-Rank of the calling thread within [0, size() ).
-
-## void sync ()
-
-Synchronizes the threads in the group.
-
-Causes all threads in the group to wait at this synchronization point, and for all shared and global memory accesses by the threads to complete, before running synchronization. This guarantees the visibility of accessed data for all threads in the group.
-
-Note: There are potential read-after-write (RAW), write-after-read (WAR), or write-after-write (WAW) hazards, when threads in the group access the same addresses in shared or global memory. The data hazards can be avoided with synchronization of the group.
-
-## unsigned int meta\_group\_rank () const
-
-Returns the linear rank of the group within the set of tiles partitioned from a parent group (bounded by meta\_group\_size)
-
-unsigned int meta\_group\_size () const
-
-Returns the number of groups created when the parent group was partitioned.
-
-## template&lt;class T &gt;
-
-T shfl ( T var, int srcRank ) const
-
-Shuffle operation on group level.
-
-Exchanging variables between threads without use of shared memory. Shuffle operation is a direct copy of var from srcRank thread ID of group.
-
-## Template Parameters
-
-T - The type can be a 32-bit integer or single-precision floating point.
-
-## Parameters
-
-- var - [in] The source variable to copy. Only the srcRank thread ID of group is copied to other threads.
-- srcRank - [in] The source thread ID of the group for copy.
-
-## template&lt;class T &gt;
-
-T shfl\_down ( T var, unsigned int lane\_delta ) const
-
-Shuffle down operation on group level.
-
-Exchanging variables between threads without use of shared memory. Shuffle down operation is copy of var from thread with thread ID of group relative higher with lane\_delta to caller thread ID.
-
-## Template Parameters
-
-T - The type can be a 32-bit integer or single-precision floating point.
-
-## Parameters
-
-- var - [in] The source variable to copy.
-- lane\_delta - [in] The lane\_delta is the relative thread ID difference between caller thread ID and source of copy thread ID. sourceID = (threadID + lane\_delta) % size()
-
-template&lt;class T &gt;
-
-## T shfl\_up ( T var, unsigned int lane\_delta ) const
-
-Shuffle up operation on group level.
-
-Exchanging variables between threads without use of shared memory. Shuffle up operation is copy of var from thread with thread ID of group relative lower with lane\_delta to caller thread ID.
-
-## Template Parameters
-
-T - The type can be a 32-bit integer or single-precision floating point.
-
-## Parameters
-
-- var - [in] The source variable to copy.
-- lane\_delta - [in] The lane\_delta is the relative thread ID difference between caller thread ID and source of copy thread ID. sourceID = (threadID - lane\_delta) % size()
-
-## template&lt;class T &gt;
-
-T shfl\_xor ( T var, unsigned int laneMask ) const
-
-Shuffle xor operation on group level.
-
-Exchanging variables between threads without use of shared memory. Shuffle xor operation is copy of var from thread with thread ID of group based on laneMask XOR of the caller thread ID.
-
-## Template Parameters
-
-- T - The type can be a 32-bit integer or single-precision floating point.
-
-## Parameters
-
-- var - [in] The source variable to copy.
-- laneMask - [in] The laneMask is the mask for XOR operation. sourceID = threadID ^ laneMask
-
-unsigned long long ballot ( int pred ) const
-
-Ballot function on group level.
-
-Returns a bit mask with the Nth bit set to one if the Nth thread predicate evaluates true.
-
-## Parameters
-
-pred - [in] The predicate to evaluate on group threads.
-
-int any ( int pred ) const
-
-Any function on group level.
-
-Returns non-zero if a predicate evaluates true for any threads.
-
-## Parameters
-
-pred - [in] The predicate to evaluate on group threads.
-
-int all ( int pred ) const
-
-All function on group level.
-
-Returns non-zero if a predicate evaluates true for all threads.
-
-## Parameters
-
-pred - [in] The predicate to evaluate on group threads.
-
-template&lt;typename T &gt;
-
-unsigned long long match\_any ( T value ) const
-
-Match any function on group level.
-
-Returns a bit mask containing a 1-bit for every participating thread if that thread has the same value in value as the caller thread.
-
-## Parameters
-
-value - [in] The value to examine on the current thread in group.
-
-template&lt;typename T &gt; unsigned long long match\_all ( T value, int &amp;pred ) const
-
-Match all function on group level.
-
-Returns a bit mask containing a 1-bit for every participating thread if they all have the same value in value as the caller thread. The predicate pred is set to true if all participating threads have the same value in value .
-
-## Parameters
-
-- value - [in] The value to examine on the current thread in group.
-- pred - [out] The predicate is set to true if all participating threads in the thread group have the same value.
-
-class coalesced\_group : public cooperative\_groups:: thread\_group
-
-The coalesced\_group cooperative group type.
-
-Represents an active thread group in a wavefront. This group type also supports sub-wave level intrinsics.
-
-Note: This is implemented on Linux and is under development on Microsoft Windows.
-
-## 23.3 Cooperative groups construct functions
-
-The following functions are used to construct different group-type instances on the device side.
-
-| Warning:                                                                                    | Warning:                                                                                    | doxygenfunction:                                                                            | doxygenfunction:                                                                            | doxygenfunction:                                                                            | Cannot find                                                                                 | Cannot find                                                                                 | function                                                                                    | 'cooperative_groups::this_multi_grid'                                                       | 'cooperative_groups::this_multi_grid'                                                       | 'cooperative_groups::this_multi_grid'                                                       |                                                                                             |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
-| in                                                                                          | doxygen                                                                                     | xml                                                                                         | output                                                                                      | for                                                                                         | project                                                                                     | 'HIP                                                                                        | 6.1.40092                                                                                   | Documentation'                                                                              | from                                                                                        | directory:                                                                                  |                                                                                             |
-| /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- |
-| 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      |
-
-Warning: doxygenfunction: Cannot find function 'cooperative\_groups::this\_grid' in doxygen xml output for project 'HIP 6.1.40092 Documentation' from directory: /home/docs/checkouts/readthedocs.org/user\_builds/advanced-micro-devices-hip/checkouts/docs6.1.2/docs/doxygen/xml
-
-Warning: doxygenfunction: Cannot find function 'cooperative\_groups::this\_thread\_block' in doxygen xml output for project 'HIP 6.1.40092 Documentation' from directory: /home/docs/checkouts/readthedocs.org/user\_builds/advanced-micro-devices-hip/checkouts/docs6.1.2/docs/doxygen/xml
-
-| Warning:   | Warning:   | doxygenfunction:   | doxygenfunction:   | doxygenfunction:   | Cannot   | find   | function   | 'cooperative_groups::coalesced_threads'   | 'cooperative_groups::coalesced_threads'   |            |
-|------------|------------|--------------------|--------------------|--------------------|----------|--------|------------|-------------------------------------------|-------------------------------------------|------------|
-| in         | doxygen    | xml                | output             | for                | project  | 'HIP   | 6.1.40092  | Documentation'                            | from                                      | directory: |
-
-/home/docs/checkouts/readthedocs.org/user\_builds/advanced-micro-devices-hip/checkouts/docs6.1.2/docs/doxygen/xml
-
-| Warning:                                                                                    | Warning:                                                                                    | doxygenfunction:                                                                            | doxygenfunction:                                                                            | doxygenfunction:                                                                            | Cannot find                                                                                 | Cannot find                                                                                 | function                                                                                    | 'cooperative_groups::tiled_partition'                                                       | 'cooperative_groups::tiled_partition'                                                       | 'cooperative_groups::tiled_partition'                                                       |                                                                                             |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
-| in                                                                                          | doxygen                                                                                     | xml                                                                                         | output                                                                                      | for                                                                                         | project                                                                                     | 'HIP                                                                                        | 6.1.40092                                                                                   | Documentation'                                                                              | from                                                                                        | directory:                                                                                  |                                                                                             |
-| /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- |
-| 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      |
-
-| Warning:                                                                                    | Warning:                                                                                    | doxygenfunction:                                                                            | doxygenfunction:                                                                            | doxygenfunction:                                                                            | Cannot                                                                                      | find                                                                                        | function 'cooperative_groups::tiled_partition' 6.1.40092                                    | function 'cooperative_groups::tiled_partition' 6.1.40092                                    | function 'cooperative_groups::tiled_partition' 6.1.40092                                    |                                                                                             |                                                                                             |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
-| in                                                                                          | doxygen                                                                                     | xml                                                                                         | output                                                                                      | for                                                                                         | project                                                                                     | 'HIP                                                                                        | Documentation'                                                                              | from                                                                                        | directory:                                                                                  |                                                                                             |                                                                                             |
-| /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- |
-| 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      |
-
-| Warning:                                                                                    | Warning:                                                                                    | doxygenfunction:                                                                            | doxygenfunction:                                                                            | doxygenfunction:                                                                            | Cannot find                                                                                 | Cannot find                                                                                 | function                                                                                    | function                                                                                    | 'cooperative_groups::binary_partition'                                                      | 'cooperative_groups::binary_partition'                                                      |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
-| in                                                                                          | doxygen                                                                                     | xml                                                                                         | output                                                                                      | for                                                                                         | project                                                                                     | 'HIP                                                                                        |                                                                                             | 6.1.40092                                                                                   | Documentation'                                                                              | from                                                                                        |
-| /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- |
-| 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      |
-
-| Warning:                                                                                    | Warning:                                                                                    | doxygenfunction:                                                                            | doxygenfunction:                                                                            | doxygenfunction:                                                                            | Cannot find                                                                                 | Cannot find                                                                                 | function 'cooperative_groups::binary_partition' 6.1.40092                                   | function 'cooperative_groups::binary_partition' 6.1.40092                                   | function 'cooperative_groups::binary_partition' 6.1.40092                                   |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
-| in                                                                                          | doxygen                                                                                     | xml                                                                                         | output                                                                                      | for                                                                                         | project                                                                                     | 'HIP                                                                                        | Documentation'                                                                              | from                                                                                        | directory:                                                                                  |
-| /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- |
-| 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      |
-
-## 23.4 Cooperative groups exposed API functions
-
-The following functions are the exposed API for different group-type instances on the device side.
-
-| Warning:                                                                                    | Warning:                                                                                    | doxygenfunction: project                                                                    | doxygenfunction: project                                                                    | doxygenfunction: project                                                                    | Cannot find                                                                                 | function                                                                                    | 'cooperative_groups::group_size'                                                            | 'cooperative_groups::group_size'                                                            | 'cooperative_groups::group_size'                                                            |                                                                                             |                                                                                             |                                                                                             |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
-| in                                                                                          | doxygen                                                                                     | xml                                                                                         | output                                                                                      | for                                                                                         | 'HIP                                                                                        | 6.1.40092                                                                                   | Documentation'                                                                              | from                                                                                        | directory:                                                                                  |                                                                                             |                                                                                             |                                                                                             |
-| /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- |
-| 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      |
-
-| Warning:                                                                                    | Warning:                                                                                    | doxygenfunction: Cannot                                                                     | doxygenfunction: Cannot                                                                     | doxygenfunction: Cannot                                                                     | doxygenfunction: Cannot                                                                     | find 'HIP                                                                                   | find 'HIP                                                                                   | function 'cooperative_groups::thread_rank'                                                  | function 'cooperative_groups::thread_rank'                                                  | function 'cooperative_groups::thread_rank'                                                  |                                                                                             |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
-| in                                                                                          | doxygen                                                                                     | xml                                                                                         | output                                                                                      | for                                                                                         | project                                                                                     |                                                                                             | 6.1.40092                                                                                   | Documentation'                                                                              | from                                                                                        | directory:                                                                                  |                                                                                             |
-| /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- |
-| 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      |
-
-Warning: doxygenfunction: Cannot find function 'cooperative\_groups::is\_valid' in doxygen xml output for project 'HIP 6.1.40092 Documentation' from directory: /home/docs/checkouts/readthedocs.org/user\_builds/advanced-micro-devices-hip/checkouts/docs6.1.2/docs/doxygen/xml
-
-Warning: doxygenfunction: Cannot find function 'cooperative\_groups::sync' in doxygen xml output for project 'HIP 6.1.40092 Documentation' from directory: /home/docs/checkouts/readthedocs.org/user\_builds/advancedmicro-devices-hip/checkouts/docs-6.1.2/docs/doxygen/xml
-
-## CHAPTER
-
-## TWENTYFOUR
-
-## HSA RUNTIME API FOR ROCM
-
-The following functions are located in the https://github.com/ROCm/ROCR-Runtime repository.
-
-hsa\_status\_t hsa\_amd\_vmem\_address\_reserve ( void **va, size\_t size, uint64\_t address, uint64\_t flags )
-
-Allocate a reserved address range.
-
-Reserve a virtual address range. The size must be a multiple of the system page size. If it is not possible to allocate the address specified by address , then va will be a different address range. Address range should be released by calling hsa\_amd\_vmem\_address\_free.
-
-Note that this API will be deprecated in a future release and replaced by hsa\_amd\_vmem\_address\_reserve\_align
-
-## Parameters
-
-- va -[out] virtual address allocated
-- size -[in] of address range requested
-- address -[in] requested
-- flags -[in] currently unsupported
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS - Address range allocated successfully
-- ::HSA\_STATUS\_ERROR\_NOT\_INITIALIZED - The HSA runtime has not been initialized.
-- ::HSA\_STATUS\_ERROR\_OUT\_OF\_RESOURCES - Insufficient resources to allocate an address range of this size.
-
-hsa\_status\_t hsa\_amd\_vmem\_address\_free ( void *va, size\_t size )
-
-Free a reserved address range.
-
-Free a previously allocated address range. The size must match the size of a previously allocated address range.
-
-## Parameters
-
-- va -[out] virtual address to be freed
-- size -[in] of address range
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS - Address range released successfully
-- ::HSA\_STATUS\_ERROR\_INVALID\_ALLOCATION - Invalid va specified
-- ::HSA\_STATUS\_ERROR\_INVALID\_ARGUMENT - Invalid size specified
-- ::HSA\_STATUS\_ERROR\_RESOURCE\_FREE - Address range is still in use
-
-· ::HSA\_STATUS\_ERROR - Internal unexpected error
-
-hsa\_status\_t hsa\_amd\_vmem\_handle\_create ( hsa\_amd\_memory\_pool\_t pool, size\_t size, hsa\_amd\_memory\_type\_t type, uint64\_t flags, hsa\_amd\_vmem\_alloc\_handle\_t *memory\_handle
-
-)
-
-Create a virtual memory handle.
-
-Create a virtual memory handle within this pool size must be a aligned to allocation granule size for this memory pool, see HSA\_AMD\_MEMORY\_POOL\_INFO\_RUNTIME\_ALLOC\_GRANULE To minimize internal memory fragmentation, align the size to the recommended allocation granule size, see HSA\_AMD\_MEMORY\_POOL\_INFO\_RUNTIME\_ALLOC\_REC\_GRANULE
-
-## Parameters
-
-- pool -[in] memory to use
-- size -[in] of the memory allocation
-- type -[in] of memory
-- flags -[in] - currently unsupported
-- memory\_handle -[out] - handle for the allocation
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS - memory allocated successfully
-- ::HSA\_STATUS\_ERROR\_NOT\_INITIALIZED - The HSA runtime has not been initialized.
-- ::HSA\_STATUS\_ERROR\_INVALID\_ARGUMENT - Invalid arguments
-- ::HSA\_STATUS\_ERROR\_INVALID\_ALLOCATION - This memory pool does not support allocations
-- ::HSA\_STATUS\_ERROR\_OUT\_OF\_RESOURCES - Insufficient resources to allocate this memory
-
-hsa\_status\_t hsa\_amd\_vmem\_handle\_release ( hsa\_amd\_vmem\_alloc\_handle\_t memory\_handle )
-
-Release a virtual memory handle.
-
-## Parameters
-
-memory -[in] handle that was previously allocated
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS - Address range allocated successfully
-- ::HSA\_STATUS\_ERROR\_INVALID\_ALLOCATION - Invalid memory handle
-
-hsa\_status\_t hsa\_amd\_vmem\_map ( void *va, size\_t size, size\_t in\_offset, hsa\_amd\_vmem\_alloc\_handle\_t memory\_handle, uint64\_t flags )
-
-Map a virtual memory handle.
-
-Map a virtual memory handle to a reserved address range. The virtual address requested must be within a previously reserved address range. va and ( va + size) must be must be within (va + size) of the previous allocated address range. size must be equal to size of the memory\_handle hsa\_amd\_vmem\_set\_access needs to be called to make the memory accessible to specific agents
-
-## Parameters
-
-- va -[in] virtual address range where memory will be mapped
-- size -[in] of memory mapping
-- in\_offset -[in] offset into memory. Currently unsupported
-
-- memory\_handle -[in] virtual memory handle to be mapped
-- flags. -[in] Currently unsupported
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS - Memory mapped successfully
-- ::HSA\_STATUS\_ERROR\_INVALID\_ARGUMENT - va, size or memory\_handle are invalid
-- ::HSA\_STATUS\_ERROR\_OUT\_OF\_RESOURCES - Insufficient resources
-- ::HSA\_STATUS\_ERROR - Unexpected internal error
-
-## hsa\_status\_t hsa\_amd\_vmem\_unmap ( void *va, size\_t size )
-
-Unmap a virtual memory handle.
-
-Unmap previously mapped virtual address range
-
-## Parameters
-
-- va -[in] virtual address range where memory will be mapped
-- size -[in] of memory mapping
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS - Memory backing unmapped successfully
-- ::HSA\_STATUS\_ERROR\_INVALID\_ALLOCATION - memory\_handle is invalid
-- ::HSA\_STATUS\_ERROR\_INVALID\_ARGUMENT - size is invalid
-- ::HSA\_STATUS\_ERROR - Unexpected internal error
-
-hsa\_status\_t hsa\_amd\_vmem\_set\_access ( void *va, size\_t size, const hsa\_amd\_memory\_access\_desc\_t *desc, size\_t desc\_cnt )
-
-Make a memory mapping accessible.
-
-Make previously mapped virtual address accessible to specific agents. size must be equal to size of previously mapped virtual memory handle. Calling hsa\_amd\_vmem\_set\_access multiple times on the same va will overwrite previous permissions for all agents
-
-## Parameters
-
-- va -[in] previously mapped virtual address
-- size -[in] of memory mapping
-- desc -[in] list of access permissions for each agent
-- desc\_cnt -[in] number of elements in desc
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS -
-- ::HSA\_STATUS\_ERROR\_INVALID\_ARGUMENT - va, size or memory\_handle are invalid
-- ::HSA\_STATUS\_ERROR\_INVALID\_ALLOCATION - memory\_handle is invalid
-- ::HSA\_STATUS\_ERROR\_OUT\_OF\_RESOURCES - Insufficient resources
-- ::HSA\_STATUS\_ERROR\_INVALID\_AGENT - Invalid agent in desc
-- ::HSA\_STATUS\_ERROR - Unexpected internal error
-
-hsa\_status\_t hsa\_amd\_vmem\_get\_access ( void *va, hsa\_access\_permission\_t *perms, hsa\_agent\_t agent\_handle )
-
-Get current access permissions for memory mapping.
-
-Get access permissions for memory mapping for specific agent.
-
-## Parameters
-
-- va -[in] previously mapped virtual address
-- perms -[in] current permissions
-- agent\_handle -[in] agent
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS -
-- ::HSA\_STATUS\_ERROR\_INVALID\_AGENT - Invalid agent
-- ::HSA\_STATUS\_ERROR\_INVALID\_ALLOCATION - va is not mapped or permissions never set for this agent
-- ::HSA\_STATUS\_ERROR - Unexpected internal error
-
-hsa\_status\_t hsa\_amd\_vmem\_export\_shareable\_handle ( int *dmabuf\_fd, hsa\_amd\_vmem\_alloc\_handle\_t handle, uint64\_t flags )
-
-Get an exportable shareable handle.
-
-Get an exportable shareable handle for a memory\_handle. This shareabl handle can then be used to re-create a virtual memory handle using hsa\_amd\_vmem\_import\_shareable\_handle. The shareable handle can be transferred using mechanisms that support posix file descriptors Once all shareable handles are closed, the memory\_handle is released.
-
-## Parameters
-
-- dmabuf\_fd -[out] shareable handle
-- handle -[in] previously allocated virtual memory handle
-- flags -[in] Currently unsupported
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS -
-- ::HSA\_STATUS\_ERROR\_INVALID\_ALLOCATION - Invalid memory handle
-- ::HSA\_STATUS\_ERROR\_OUT\_OF\_RESOURCES - Out of resources
-- ::HSA\_STATUS\_ERROR - Unexpected internal error
-
-## hsa\_status\_t hsa\_amd\_vmem\_import\_shareable\_handle ( int dmabuf\_fd, hsa\_amd\_vmem\_alloc\_handle\_t *handle )
-
-Import a shareable handle.
-
-Import a shareable handle for a memory handle. Importing a shareable handle that has been closed and released results in undefined behavior.
-
-## Parameters
-
-- dmabuf\_fd -[in] shareable handle exported with hsa\_amd\_vmem\_export\_shareable\_handle
-- handle -[out] virtual memory handle
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS -
-
-- ::HSA\_STATUS\_ERROR\_INVALID\_ALLOCATION - Invalid memory handle
-- ::HSA\_STATUS\_ERROR\_OUT\_OF\_RESOURCES - Out of resources
-- ::HSA\_STATUS\_ERROR - Unexpected internal error
-
-hsa\_status\_t hsa\_amd\_vmem\_retain\_alloc\_handle ( hsa\_amd\_vmem\_alloc\_handle\_t *memory\_handle, void *addr )
-
-Returns memory handle for mapped memory.
-
-Return a memory handle for previously mapped memory. The handle will be the same value of handle used to map the memory. The returned handle must be released with corresponding number of calls to hsa\_amd\_vmem\_handle\_release.
-
-## Parameters
-
-- memory\_handle -[out] memory handle for this mapped address
-- mapped -[in] address
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS -
-- ::HSA\_STATUS\_ERROR\_INVALID\_ALLOCATION - Invalid address
-
-hsa\_status\_t hsa\_amd\_vmem\_get\_alloc\_properties\_from\_handle ( hsa\_amd\_vmem\_alloc\_handle\_t memory\_handle, hsa\_amd\_memory\_pool\_t *pool, hsa\_amd\_memory\_type\_t *type )
-
-Returns the current allocation properties of a handle.
-
-Returns the allocation properties of an existing handle
-
-## Parameters
-
-- memory\_handle -[in] memory handle to be queried
-- pool -[out] memory pool that owns this handle
-- memory -[out] type
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS -
-- ::HSA\_STATUS\_ERROR\_INVALID\_ALLOCATION - Invalid memory\_handle
-
-## CHAPTER
-
-## TWENTYFIVE
-
-## HIP MANAGED MEMORY ALLOCATION API
-
-hipError\_t hipMallocManaged ( void **dev\_ptr, size\_t size, unsigned int flags )
-
-Allocates memory that will be automatically managed by HIP.
-
-This API is used for managed memory, allows data be shared and accessible to both CPU and GPU using a single pointer.
-
-The API returns the allocation pointer, managed by HMM, can be used further to execute kernels on device and fetch data between the host and device as needed.
-
-Note: It is recommend to do the capability check before call this API.
-
-## Parameters
-
-- dev\_ptr -[out] - pointer to allocated device memory
-- size -[in] - requested allocation size in bytes, it should be granularity of 4KB
-- flags -[in] - must be either hipMemAttachGlobal or hipMemAttachHost (defaults to hipMemAttachGlobal)
-
-## Returns
-
-hipSuccess, hipErrorMemoryAllocation, hipErrorNotSupported, hipErrorInvalidValue hipError\_t hipMemPrefetchAsync ( const void *dev\_ptr, size\_t count, int device, hipStream\_t stream
-
-) Prefetches memory to the specified destination device using HIP.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-## Parameters
-
-- dev\_ptr -[in] pointer to be prefetched
-- count -[in] size in bytes for prefetching
-- device -[in] destination device to prefetch to
-- stream -[in] stream to enqueue prefetch operation
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue
-
-hipError\_t hipMemAdvise ( const void *dev\_ptr, size\_t count, hipMemoryAdvise advice, int device )
-
-Advise about the usage of a given memory range to HIP.
-
-This HIP API advises about the usage to be applied on unified memory allocation in the range starting from the pointer address devPtr, with the size of count bytes. The memory range must refer to managed memory allocated via the API hipMallocManaged, and the range will be handled with proper round down and round up respectively in the driver to be aligned to CPU page size, the same way as corresponding CUDA API behaves in CUDA version 8.0 and afterwards.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-## Parameters
-
-- dev\_ptr -[in] pointer to memory to set the advice for
-- count -[in] size in bytes of the memory range, it should be CPU page size alligned.
-- advice -[in] advice to be applied for the specified memory range
-- device -[in] device to apply the advice for
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemRangeGetAttribute ( void *data, size\_t data\_size, hipMemRangeAttribute attribute, const void *dev\_ptr, size\_t count )
-
-Query an attribute of a given memory range in HIP.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-## Parameters
-
-- data -[inout] a pointer to a memory location where the result of each attribute query will be written to
-- data\_size -[in] the size of data
-- attribute -[in] the attribute to query
-- dev\_ptr -[in] start of the range to query
-- count -[in] size of the range to query
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemRangeGetAttributes ( void **data, size\_t *data\_sizes, hipMemRangeAttribute *attributes, size\_t num\_attributes, const void *dev\_ptr, size\_t count )
-
-Query attributes of a given memory range in HIP.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-## Parameters
-
-- data -[inout] a two-dimensional array containing pointers to memory locations where the result of each attribute query will be written to
-- data\_sizes -[in] an array, containing the sizes of each result
-- attributes -[in] the attribute to query
-- num\_attributes -[in] an array of attributes to query (numAttributes and the number of attributes in this array should match)
-- dev\_ptr -[in] start of the range to query
-- count -[in] size of the range to query
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipStreamAttachMemAsync ( hipStream\_t stream, void *dev\_ptr, size\_t length, unsigned int flags ) Attach memory to a stream asynchronously in HIP.
-
-Warning: This API is under development. Currently it is a no-operation (NOP) function on AMD GPUs and returns hipSuccess.
-
-## Parameters
-
-- stream -[in] - stream in which to enqueue the attach operation
-- dev\_ptr -[in] - pointer to memory (must be a pointer to managed memory or to a valid host-accessible region of system-allocated memory)
-- length -[in] - length of memory (defaults to zero)
-- flags -[in] - must be one of hipMemAttachGlobal, hipMemAttachHost or hipMemAttachSingle (defaults to hipMemAttachSingle)
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue
-
-## template&lt;class T &gt;
-
-static inline hipError\_t hipMallocManaged ( T **devPtr, size\_t size, unsigned int flags = hipMemAttachGlobal )
-
-- : C++ wrapper for hipMallocManaged
-
-Provide an override to automatically typecast the pointer type from void**, and also provide a default for the flags.
-
-HIP\_DISABLE\_CPP\_FUNCTIONS macro can be defined to suppress these wrappers. It is useful for applications which need to obtain decltypes of HIP runtime APIs.
-
-## See also:
-
-hipMallocManaged
-
-## CHAPTER
-
-## TWENTYSIX
-
-## HIP VIRTUAL MEMORY MANAGEMENT API
-
-hipError\_t hipMemAddressFree ( void *devPtr, size\_t size )
-
-Frees an address range reservation made via hipMemAddressReserve.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- devPtr -[in] - starting address of the range.
-- size -[in] - size of the range.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemAddressReserve ( void **ptr, size\_t size, size\_t alignment, void *addr, unsigned long long flags )
-
-Reserves an address range.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- ptr -[out] - starting address of the reserved range.
-- size -[in] - size of the reservation.
-- alignment -[in] - alignment of the address.
-- addr -[in] - requested starting address of the range.
-- flags -[in] - currently unused, must be zero.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported
-
-hipError\_t hipMemCreate ( hipMemGenericAllocationHandle\_t *handle, size\_t size, const hipMemAllocationProp *prop, unsigned long long flags )
-
-Creates a memory allocation described by the properties and size.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- handle -[out] - value of the returned handle.
-- size -[in] - size of the allocation.
-- prop -[in] - properties of the allocation.
-- flags -[in] - currently unused, must be zero.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemExportToShareableHandle ( void *shareableHandle, hipMemGenericAllocationHandle\_t handle, hipMemAllocationHandleType handleType, unsigned long long flags )
-
-Exports an allocation to a requested shareable handle type.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- shareableHandle -[out] - value of the returned handle.
-- handle -[in] - handle to share.
-- handleType -[in] - type of the shareable handle.
-- flags -[in] - currently unused, must be zero.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemGetAccess ( unsigned long long *flags, const hipMemLocation *location, void *ptr
-
-) Get the access flags set for the given location and ptr.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- flags -[out] - flags for this location.
-- location -[in] - target location.
-- ptr -[in] - address to check the access flags.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemGetAllocationGranularity ( size\_t *granularity, const hipMemAllocationProp *prop, hipMemAllocationGranularity\_flags option )
-
-Calculates either the minimal or recommended granularity.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- granularity -[out] - returned granularity.
-- prop -[in] - location properties.
-- option -[in] - determines which granularity to return.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemGetAllocationPropertiesFromHandle ( hipMemAllocationProp *prop,
-
-hipMemGenericAllocationHandle\_t handle )
-
-Retrieve the property structure of the given handle.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- prop -[out] - properties of the given handle.
-- handle -[in] - handle to perform the query on.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported
-
-hipError\_t hipMemImportFromShareableHandle ( hipMemGenericAllocationHandle\_t *handle, void *osHandle, hipMemAllocationHandleType shHandleType )
-
-Imports an allocation from a requested shareable handle type.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- handle -[out] - returned value.
-- osHandle -[in] - shareable handle representing the memory allocation.
-- shHandleType -[in] - handle type.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemMap ( void *ptr, size\_t size, size\_t offset, hipMemGenericAllocationHandle\_t handle, unsigned long long flags )
-
-Maps an allocation handle to a reserved virtual address range.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- ptr -[in] - address where the memory will be mapped.
-- size -[in] - size of the mapping.
-- offset -[in] - offset into the memory, currently must be zero.
-- handle -[in] - memory allocation to be mapped.
-- flags -[in] - currently unused, must be zero.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemMapArrayAsync ( hipArrayMapInfo *mapInfoList, unsigned int count, hipStream\_t stream )
-
-Maps or unmaps subregions of sparse HIP arrays and sparse HIP mipmapped arrays.
-
-Warning: This API is under development. Currently it is not supported on AMD GPUs and returns hipErrorNotSupported.
-
-## Parameters
-
-- mapInfoList -[in] - list of hipArrayMapInfo.
-- count -[in] - number of hipArrayMapInfo in mapInfoList.
-- stream -[in] - stream identifier for the stream to use for map or unmap operations.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemRelease ( hipMemGenericAllocationHandle\_t handle )
-
-Release a memory handle representing a memory allocation which was previously allocated through hipMemCreate.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-handle -[in] - handle of the memory allocation.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemRetainAllocationHandle ( hipMemGenericAllocationHandle\_t *handle, void *addr )
-
-Returns the allocation handle of the backing memory allocation given the address.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- handle -[out] - handle representing addr.
-- addr -[in] - address to look up.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemSetAccess ( void *ptr, size\_t size, const hipMemAccessDesc *desc, size\_t count )
-
-Set the access flags for each location specified in desc for the given virtual address range.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- ptr -[in] - starting address of the virtual address range.
-- size -[in] - size of the range.
-- desc -[in] - array of hipMemAccessDesc.
-- count -[in] - number of hipMemAccessDesc in desc.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported
-
-## hipError\_t hipMemUnmap ( void *ptr, size\_t size )
-
-Unmap memory allocation of a given address range.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- ptr -[in] - starting address of the range to unmap.
-- size -[in] - size of the virtual address range.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported
-
-## CHAPTER
-
-## TWENTYSEVEN
-
-## HIP DEPRECATED RUNTIME API FUNCTIONS
-
-Several of our API functions have been flagged for deprecation. Using the following functions results in errors and unexpected results, so we encourage you to update your code accordingly.
-
-## 27.1 Context management
-
-CUDAsupports cuCtx API, which is the driver API that defines 'Context' and 'Devices' as separate entities. Context contains a single device, and a device can theoretically have multiple contexts. HIP initially added limited support for these APIs in order to facilitate porting from existing driver codes. These APIs are now marked as deprecated because there are better alternate interfaces (such as hipSetDevice or the stream API) to achieve these functions.
-
-- hipCtxCreate
-- hipCtxDestroy
-- hipCtxPopCurrent
-- hipCtxPushCurrent
-- hipCtxSetCurrent
-- hipCtxGetCurrent
-- hipCtxGetDevice
-- hipCtxGetApiVersion
-- hipCtxGetCacheConfig
-- hipCtxSetCacheConfig
-- hipCtxSetSharedMemConfig
-- hipCtxGetSharedMemConfig
-- hipCtxSynchronize
-- hipCtxGetFlags
-- hipCtxEnablePeerAccess
-- hipCtxDisablePeerAccess
-- hipDevicePrimaryCtxGetState
-- hipDevicePrimaryCtxRelease
-- hipDevicePrimaryCtxRetain
-- hipDevicePrimaryCtxReset
-
-- hipDevicePrimaryCtxSetFlags
-
-## 27.2 Memory management
-
-- hipMallocHost (replaced with hipHostMalloc )
-- hipMemAllocHost (replaced with hipHostMalloc )
-- hipHostAlloc (replaced with hipHostMalloc )
-- hipFreeHost (replaced with hipHostFree )
-- hipMemcpyToArray
-- hipMemcpyFromArray
-
-## 27.3 Profiler control
-
-- hipProfilerStart (use roctracer/rocTX)
-- hipProfilerStop (use roctracer/rocTX)
-
-## 27.4 Texture management
-
-- hipGetTextureReference
-- hipTexRefSetAddressMode
-- hipTexRefSetArray
-- hipTexRefSetFilterMode
-- hipTexRefSetFlags
-- hipTexRefSetFormat
-- hipTexRefGetAddress
-- hipTexRefGetAddressMode
-- hipTexRefGetFilterMode
-- hipTexRefGetFlags
-- hipTexRefGetFormat
-- hipTexRefGetMaxAnisotropy
-- hipTexRefGetMipmapFilterMode
-- hipTexRefGetMipmapLevelBias
-- hipTexRefGetMipmapLevelClamp
-- hipTexRefGetMipMappedArray
-- hipTexRefSetAddress
-- hipTexRefSetAddress2D
-- hipTexRefSetMaxAnisotropy
-
-- hipTexRefSetBorderColor
-- hipTexRefSetMipmapFilterMode
-- hipTexRefSetMipmapLevelBias
-- hipTexRefSetMipmapLevelClamp
-- hipTexRefSetMipmappedArray
-- hipTexRefGetBorderColor
-- hipTexRefGetArray
-- hipBindTexture
-- hipBindTexture2D
-- hipBindTextureToArray
-- hipGetTextureAlignmentOffset
-- hipUnbindTexture
-- hipBindTextureToMipmappedArray
-
-## CHAPTER
-
-## TWENTYEIGHT
-
-## SAXPY - HELLO, HIP
-
-This tutorial explains the basic concepts of the single-source Heterogeneous-computing Interface for Portability (HIP) programming model and the essential tooling around it. It also reviews some commonalities of heterogenous APIs in general. This topic assumes basic familiarity with the C/C++ compilation model and language.
-
-## 28.1 Prerequisites
-
-To follow this tutorial, you'll need installed drivers and a HIP compiler toolchain to compile your code. Because HIP for ROCm supports compiling and running on Linux and Windows with AMD and NVIDIA GPUs, the combination of install instructions is more than worth covering as part of this tutorial. For more information about installing HIP development packages, see Install HIP .
-
-## 28.2 Heterogeneous programming
-
-Heterogeneous programming and offloading APIs are often mentioned together. Heterogeneous programming deals with devices of varying capabilities simultaneously. Offloading focuses on the 'remote' and asynchronous aspects of computation. HIP encompasses both. It exposes GPGPU (general-purpose GPU) programming much like ordinary host-side CPU programming and lets you move data across various devices.
-
-When programming in HIP (and other heterogenous APIs for that matter), remember that target devices are built for a specific purpose. They are designed with different tradeoffs than traditional CPUs and therefore have very different performance characteristics. Even subtle changes in code might adversely affect execution time.
-
-## 28.3 Your first lines of HIP code
-
-First, let's do the 'Hello, World!' of GPGPU: SAXPY. Single-precision A times X Plus Y ( SAXPY ) is a mathematical acronym; a vector equation 𝑎 · 𝑥 + 𝑦 = 𝑧 where 𝑎 ∈ R is a scalar and 𝑥, 𝑦, 𝑧 ∈ V are vector quantities of some large dimensionality. This vector space is defined over the set of reals. Practically speaking, you can compute this using a single for loop over three arrays.
-**Following code does:** This code snippet is a command to compile a C++ program using the `clang++` compiler. It is specifically compiling a HIP (Heterogeneous-Compute Interface for Portability) program, which is used for writing portable code that can run on both AMD and NVIDIA GPUs. The command compiles the source file `main.hip` located in the `HIP-Basic\saxpy` directory into an executable named `saxpy.exe`. It includes headers from the `.\Common` directory, links against the `amdhip64` library, and uses the library path specified by the `HIP_PATH` environment variable. The `-O2` flag is used for optimization, and `--save-temps` is used to save intermediate compilation files.
-
-
-```
-++i)
-```
-**Following code does:** This code snippet is a partial command written in PowerShell. It uses the `Get-ChildItem` cmdlet to list items (files and directories) in the current directory that match a specific pattern. The `-Filter main-hip-*` option specifies that only items with names starting with "main-hip-" should be included in the output. The command is incomplete, as it ends with `selec`, which is likely intended to be `Select-Object` to further process or filter the properties of the listed items.
-
-
-```
-<_SQL_>
-```
-
-In linear algebra libraries, such as BLAS (Basic Linear Algebra Subsystem) this operation is defined as AXPY 'A times X Plus Y'. The 'S' comes from single-precision , meaning that array element is float -s (IEEE 754 binary32 representation).
-
-To quickly get started, use the set of HIP samples from GitHub. With Git configured on your machine, open a commandline and navigate to your desired working directory, then run:
-**Following code does:** The code snippet appears to be incomplete and seems to be a mix of Python and PowerShell syntax. The part `n-hip-* | select -Property Name` resembles a PowerShell command rather than Python. In PowerShell, this command would filter objects whose names match the pattern `n-hip-*` and then select only the `Name` property of those objects. However, without additional context or a complete command, it's difficult to provide a precise explanation.
-
-
-```
-            |git clone https://github.com/amd/rcm-examples.git
-```
-
-A simple implementation of SAXPY resides in the HIP-Basic/saxpy/main.hip file in this repository. The HIP code here mostly deals with where data has to be and when, and how devices transform this data. The first HIP calls deal with allocating device-side memory and copying data from host-side memory to device side in a C runtime-like fashion.
-**Following code does:** The code snippet appears to be a list of filenames rather than executable code. These filenames suggest that they are related to a project or compilation process targeting the AMD GCN (Graphics Core Next) architecture, specifically the gfx906 variant, which is used in AMD GPUs. The files likely represent different stages or outputs of compiling a program using the HIP (Heterogeneous-Compute Interface for Portability) framework for AMD hardware. The extensions indicate various file types: 
-
-- `.bc` is likely a LLVM bitcode file.
-- `.hipi` could be an intermediate file specific to HIP.
-- `.o` is an object file.
-- `.out` is an executable or output file.
-- `.out.resolution.txt` might be a text file containing resolution or linking information.
-- `.s` is an assembly file.
-
-Overall, these files are part of the build process for a HIP application targeting AMD GPUs.
-
-
-```
-// Allocate and copy vectors to device memory.
-float* d_x{};
-float* d_y{};
-HIP_CHECK(hipMalloc(&d_x, size_bytes));
-HIP_CHECK(hipMalloc(&d_y, size_bytes));
-HIP_CHECK(hipMemcpy(d_x, x.data(), size_bytes, hipMemcpyHostToDevice));
-HIP_CHECK(hipMemcpy(d_y, y.data(), size_bytes, hipMemcpyHostToDevice));
-```
-
-HIP\_CHECK is a custom macro borrowed from the examples utilities which checks the error code returned by API functions for errors and reports them to the console. It is not essential to the API, but it is a good practice to check the error codes of the HIP APIs in case you pass on incorrect values to the API, or the API might be out of resources.
-
-The code selects the device to allocate to and to copy to. Commands are issued to the HIP runtime per thread, and every thread has a device set as the target of commands. The default device is 0 , which is equivalent to calling hipSetDevice(0) .
-
-Launch the calculation on the device after the input data has been prepared.
-**Following code does:** This code snippet appears to be a disassembled output of a compiled program targeting AMD's GCN (Graphics Core Next) architecture, specifically the gfx906 variant. The disassembly is likely generated from a HIP (Heterogeneous-Compute Interface for Portability) application, which is used for GPU programming on AMD hardware.
-
-The code includes assembly instructions for a function named `_Z12saxpy_kernelPKfPfj`, which suggests it is implementing a SAXPY (Single-Precision A·X Plus Y) operation, a common vector operation in linear algebra. The SAXPY operation computes the result of `Y = a * X + Y`, where `a` is a scalar and `X` and `Y` are vectors.
-
-The assembly instructions involve loading data, performing arithmetic operations, and storing results back to memory, which are typical steps in executing a SAXPY operation on a GPU. The use of specific instructions like `s_load_dword`, `v_add_u32_e32`, and `global_store_dword` indicates manipulation of scalar and vector registers, memory access, and arithmetic operations optimized for parallel execution on the GPU.
-
-
-```
-    Launch the calculation on the device after the input data has been prepared.
-    __global__ void saxpy_kernel(const float a, const float* d_x, float* d_y, const unsigned_
-    __int size)
-    {
-        //...
-    }
-
-    int main()
-    {
-        //...
-
-        // Launch the kernel on the default stream.
-        saxpy_kernel<<<dim3(grid_size), dim3(block_size), 0, hipStreamDefault>>>(a, d_x, d_y,
-    -- size);
-    }
-
-    Analyze at the signature of the offloaded function:
-```
-
-Analyze at the signature of the offloaded function:
-
-- \_\_global\_\_ instructs the compiler to generate code for this function as an entrypoint to a device program, such that it can be launched from the host.
-- The function does not return anything, because there is no trivial way to construct a return channel of a parallel invocation. Device-side entrypoints may not return a value, their results should be communicated using output parameters.
-- Device-side functions are typically called compute kernels, or just kernels for short. This is to distinguish them from non-graphics-related graphics shaders, or just shaders for short.
-- Arguments are taken by value and all arguments shall be TriviallyCopyable, meaning they should be memcpy -friendly. (Imagine if they had custom copy constructors. Where would that logic execute? On the host? On the device?) Pointer arguments are pointers to device memory, one typically backed by VRAM.
-
-- We said that we'll be computing 𝑎 · 𝑥 + 𝑦 = 𝑧 , however we only pass two pointers to the function. We'll be canonically reusing one of the inputs as outputs.
-
-This function is launched from the host using a language extension often called the triple chevron syntax. Inside the angle brackets, provide the following.
-
-- The number of blocks to launch (our grid size)
-- The number of threads in a block (our block size)
-- The amount of shared memory to allocate by the host
-- The device stream to enqueue the operation on
-
-The block size and shared memory become important later in Reduction . For now, a hardcoded 256 is a safe default for simple kernels such as this. Following the triple chevron is ordinary function argument passing.
-
-Look at how the kernel is implemented.
-**Following code does:** The code snippet you provided seems to be a placeholder or an incomplete representation of a Bash script. The `<_Bash_>` tag does not contain any actual Bash code or commands. Therefore, it does not perform any specific function or task. If you have a specific Bash script or code snippet you would like explained, please provide the actual code.
-
-
-```
-<_Cuda_>
-```
-
-- The unique linear index identifying the thread is computed from the block ID the thread is a member of, the block 's size and the ID of the thread within the block .
-- A check is made to avoid overindexing the input.
-- The useful part of the computation is carried out.
-
-Retrieval of the result from the device is done much like input data copy. In this current step the results copied from device to host. The opposite direction of the input data copy:
-**Following code does:** The code snippet you've provided appears to be a corrupted or improperly formatted text, possibly due to a copy-paste error or encoding issue. It does not represent valid Python code or any recognizable programming construct. If you intended to share a specific piece of code, please ensure it is correctly formatted and complete.
-
-
-```
-                |HIP_CHECK(hipMemcpy(y.data()),  d_y,  size_bytes,  hipMemcpyDeviceToHost));
-```
-
-## 28.4 Compiling on the command line
-
-## 28.4.1 Setting up the command line
-
-Strictly speaking there's no such thing as 'setting up the command-line for compilation' on Linux. To make invocations more terse, Linux and Windows example follow.
-
-## Linux and AMD
-
-While distro maintainers might package ROCm so that it installs to system-default locations, AMD's packages aren't installed that way. They need to be added to the PATH by the user.
-**Following code does:** The code snippet you provided appears to be a command or a reference to a file rather than a typical code snippet. It seems to be related to a SAXPY operation, which stands for "Single-Precision A·X Plus Y." SAXPY is a common operation in linear algebra used to scale a vector `X` by a scalar `A` and add it to another vector `Y`. The term "sm_5" likely refers to a specific compute capability or architecture version for NVIDIA GPUs, and "ptx" indicates that this is a PTX (Parallel Thread Execution) file, which is an intermediate representation used in CUDA programming for NVIDIA GPUs. Overall, this line likely refers to a compiled or source file related to performing a SAXPY operation on a GPU.
-
-
-```
-        | export PATH=/opt/rcm/bin:${PATH}
-```
-**Following code does:** The code snippet appears to be a mix of Python and PHP syntax, but it is not valid code in either language. It seems to be an attempt to execute a shell command using PHP tags, specifically running `rocminfo` and filtering the output with `grep gfx`. The intention might be to extract information about AMD GPU architectures (gfx) from the `rocminfo` command output. However, due to the incorrect syntax and formatting, this code will not execute as intended in any programming environment.
-
-
-```
-}
-```
-**Following code does:** This code snippet appears to be a series of special characters and symbols arranged in a specific pattern. However, it does not constitute valid or meaningful Python code. It seems to be more of an artistic or visual arrangement of characters rather than a functional code snippet with a high-level purpose.
-
-
-```
-    You should be able to call the compiler on the command line now:
-    
-    amdclang++  --version
-```
-
-Note: Docker images distributed by AMD, such as rocm-terminal already have /opt/rocm/bin on the Path for convenience. This subtly affects CMake package detection logic of ROCm libraries.
-
-## Linux and NVIDIA
-
-Both distro maintainers and NVIDIA package CUDA so that nvcc and related tools are available on the command line by default. You can call the compiler on the command line with:
-**Following code does:** The code snippet describes a SAXPY operation, which stands for "Single-Precision A·X Plus Y". It performs a linear algebra operation where each element of an array `y` is updated by multiplying a scalar `a` with the corresponding element of another array `x` and then adding the result to the original element in `y`. This operation is applied over 10,000,000 elements. The snippet also provides the first 10 elements of the resulting array `y` after the operation, which are `[3, 5, 7, 9, 11, 13, 15, 17, 19, 21]`.
-
-
-```
-| nvcc --version
-```
-
-## Windows and AMD
-
-Windows compilers and command line tooling have traditionally relied on extra environmental variables and PATH entries to function correctly. Visual Studio refers to command lines with this setup as 'Developer Command Prompt' or 'Developer PowerShell' for cmd.exe and PowerShell respectively.
-
-The HIP SDK on Windows doesn't include a complete toolchain. You will also need:
-
-- The Microsoft Windows SDK. It provides the import libs to crucial system libraries that all executables must link to and some auxiliary compiler tooling.
-- A Standard Template Library (STL). Installed as part of the Microsoft Visual C++ compiler (MSVC) or with Visual Studio.
-
-If you don't have a version of Visual Studio 2022 installed, for a minimal command line experience, install the Build Tools for Visual Studio 2022 with the Desktop Developemnt Workload. Under Individual Components select:
-
-- A version of the Windows SDK
-- 'MSVC v143 - VS 2022 C++ x64/x86 build tools (Latest)'
-- 'C++ CMake tools for Windows' (optional)
-
-Note: The 'C++ CMake tools for Windows' individual component is a convenience which puts both cmake.exe and ninja.exe onto the PATH inside developer command prompts. You can install these manually, but then you must manage them manually.
-
-Visual Studio 2017 and later are detectable as COM object instances via WMI. To setup a command line from any shell for the latest Visual Studio's default Visual C++ toolset issue:
-**Following code does:** It seems like there is a placeholder `<_Python_>` instead of actual code. Please provide the code snippet you would like me to explain.
-
-
-```
-$InstallationPath = Get-CimInstance MSFT_VSInstance | Sort-Object -Property Version -
- --Descending | Select-Object -First 1 -ExpandProperty InstallLocation
- Import-Module $InstallationPath\Common?\Tools\Microsoft.VisualStudio.DevShell.dll
-Enter-VsDevShell -InstallPath $InstallationPath -SkipAutomaticLocation -Arch amd64 -
- --HostArch amd64 -DevCmdArguments '-no_logo'
-$env:PATH = "${env:HIP_PATH}bin;${env:PATH}"
-```
-
-You should be able to call the compiler on the command line now:
-**Following code does:** This code snippet appears to be a series of symbols and numbers, but it does not represent valid or meaningful Python code. It seems to be a random arrangement of characters and does not perform any computational task or serve any high-level purpose in programming.
-
-
-```
-  | clang++ --version
-```
-
-## Windows and NVIDIA
-
-Windows compilers and command line tooling have traditionally relied on extra environmental variables and PATH entries to function correctly. Visual Studio refers to command lines with this setup as 'Developer Command Prompt' or 'Developer PowerShell' for cmd.exe and PowerShell respectively.
-
-The HIP and CUDA SDKs on Windows don't include complete toolchains. You will also need:
-
-- The Microsoft Windows SDK. It provides the import libs to crucial system libraries that all executables must link to and some auxiliary compiler tooling.
-- A Standard Template Library (STL). Installed as part of the Microsoft Visual C++ compiler (MSVC) or with Visual Studio.
-
-If you don't have a version of Visual Studio 2022 installed, for a minimal command line experience, install the Build Tools for Visual Studio 2022 with the Desktop Developemnt Workload. Under Individual Components select:
-
-- A version of the Windows SDK
-- 'MSVC v143 - VS 2022 C++ x64/x86 build tools (Latest)'
-- 'C++ CMake tools for Windows' (optional)
-
-Note: The 'C++ CMake tools for Windows' individual component is a convenience which puts both cmake.exe and ninja.exe onto the PATH inside developer command prompts. You can install these manually, but then you must manage them manually.
-
-Visual Studio 2017 and later are detectable as COM object instances via WMI. To setup a command line from any shell for the latest Visual Studio's default Visual C++ toolset issue:
-**Following code does:** The code snippet you provided seems to be a placeholder or a tag indicating a YAML (YAML Ain't Markup Language) document or section, rather than actual executable code. YAML is a human-readable data serialization standard often used for configuration files or data exchange between languages with different data structures. Without specific YAML content, it's not possible to determine what data or configuration it represents. If you have a YAML file or content, it would typically define structured data in a readable format, such as lists, dictionaries, or configuration settings.
-
-
-```
-$InstallationPath = Get-CimInstance MSFT_VSInstance | Sort-Object -Property Version -
---Descending | Select-Object -First 1 -ExpandProperty InstallLocation
-Import-Module $InstallationPath\Common7\Tools\Microsoft.VisualStudio.DevShell.dll
-Enter-VsDevShell -InstallPath $InstallationPath -SkipAutomaticLocation -Arch amd64 -
---HostArch amd64 -DevCmdArguments '-no_logo'
-```
-
-You should be able to call the compiler on the command line now:
-**Following code does:** The code snippet provided is not a valid or complete Python code. It appears to be a fragment with a lot of whitespace and a string that looks like a comment or a directive related to architecture specifications, possibly for CUDA (Compute Unified Device Architecture) which is used for programming NVIDIA GPUs. The `<_arch=sm_70,sm_86` part suggests specifying the compute capabilities (sm_70 and sm_86) for which the code might be intended to run. However, without additional context or surrounding code, it's not possible to determine its exact purpose or functionality.
-
-
-```
-| nvcc --version
-```
-
-## 28.4.2 Invoking the compiler manually
-
-To compile and link a single-file application, use the following commands:
-
-## Linux and AMD
-**Following code does:** The code snippet appears to be executing a program or script named `saxpy`, which performs the SAXPY operation (Single-Precision A·X Plus Y). This operation is a common vector operation in numerical computing, where each element of a vector `y` is updated by multiplying a scalar `a` with the corresponding element of another vector `x` and then adding the result to the original element of `y`. The operation is performed over 10,000,000 elements. After the computation, the first 10 elements of the resulting vector `y` are displayed, showing a sequence of odd numbers starting from 3.
-
-
-```
-                                                                                                                                                                                                        |                                                                                                                                                                                                       
-                                                                                                                                                                                                        <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        </----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                    <---------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        >----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                    |   
-                                                                                                                                                                                                    |   
-
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                   
-    </----------------------------------------------------------------------------------------------------------------------
-```
-
-## Linux and NVIDIA
-**Following code does:** This code snippet is a PowerShell command that executes the `hipInfo.exe` program located in the `bin` directory of the path specified by the `HIP_PATH` environment variable. The output of this program is then filtered using `Select-String` to search for lines containing the string "gfx". The purpose of this command is to extract and display information related to graphics architecture names (e.g., `gfx1032`, `gfx1035`) from the output of `hipInfo.exe`.
-
-
-```
-                                                                                                                                                                                                        | nvcc ./HIP-Basic/saxpy/main.hip  -o  saxpy  -I ./Common  -I  /opt/rocm/include  -02  -x  cu                                                                                                                                                                                                       
-                                                                                                                                                                                                        -x  cu                                                                                                                                                                                                  |                                                                                                                                                                                                        }
-```
-
-## Windows and AMD
-**Following code does:** This code snippet is a command line instruction for compiling a HIP (Heterogeneous-Compute Interface for Portability) program using the `clang++` compiler. The command is set up to compile a source file named `main.hip` located in the `HIP-Basic\saxpy` directory into an executable named `saxpy.exe`. It includes a directory `.\Common` for header files and links against the `amdhip64` library. The command also specifies the HIP installation path using the environment variable `${env:HIP_PATH}`. Additionally, it targets specific GPU architectures (`gfx1032` and `gfx1035`) for offloading, and uses optimization level `-O2` for the compilation process.
-
-
-```
-                                                                                                                                                                                                        |clang++.\HIP-Basic\saxpy\main.hip -o saxpy.exe -I.\Common -lamdhip64 -L ${env:HIP_PATH}                                                                                                                                                                                                       
-                                                                                                                                                                                                        -lib -02
-```
-
-## Windows and NVIDIA
-**Following code does:** This code snippet appears to be executing a compiled program named `saxpy.exe`, which performs the SAXPY operation (Single-Precision A·X Plus Y). The operation involves scaling a vector `x` by a scalar `a` and adding it to another vector `y`, element-wise. The program processes 10,000,000 elements and outputs the first 10 elements of the resulting vector `y` after the computation. The output suggests that the operation has been successfully completed, showing the first 10 elements of the updated vector `y`.
-
-
-```
-                                                                                                                                                                                                        | nvcc.\HIP-Basic\saxpy\main.hip -o saxpy.exe -I ${env:HIP_PATH}include -I.\Common -02 - -
-                                                                                                                                                                                                        -x                                                                                                                                                                                                       
-                                                                                                                                                                                                       |                                                                                                                                                                                                        +x                                                                                                                                                                                                       |
-```
-
-Depending on your computer, the resulting binary might or might not run. If not, it typically complains about 'Invalid device function'. That error (corresponding to the hipErrorInvalidDeviceFunction entry of hipError\_t ) means that the runtime could not find a device program binary of the appropriate flavor embedded into the executable.
-
-So far, the discussion has covered how data makes it from the host to the device and back. It has also discussed the device code as source, with the HIP runtime arguing that the correct binary to dispatch for execution. How can you find out what device binary flavors are embedded into the executable?
-
-## Linux and AMD
-
-The utilities included with ROCm help significantly to inspect binary artifacts on disk. Add the ROCmCC installation folder to your PATH if you want to use these utilities (the utilities expect them to be on the PATH).
-
-You can list embedded program binaries using roc-obj-ls .
-**Following code does:** The code snippet appears to be a command for compiling a C++ program using `nvcc`, which is the NVIDIA CUDA Compiler. The command is intended to compile a source file named `main.cpp` located in the `HIP-Basic/device_query` directory, and produce an executable named `device_query.exe`. It includes additional directories for header files specified by `-I.\Common` and `-I ${env:HIP_PATH}`. However, the command seems to be malformed or incomplete, as it includes unusual formatting and options like `-include -02` and `--include -0022`, which are not standard or correctly formatted compiler options. This suggests that the command might be incorrectly copied or formatted.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?>
-                                                                                                                                                                                                       <!>
-                                                                                                                                                                                                      <!>"
-```
-**Following code does:** This code snippet executes a command-line program called `device_query.exe` and pipes its output to the `Select-String` command, which searches for occurrences of the string "major.minor". The output shows that the program found two instances of "major.minor" with associated version numbers, 8.6 and 7.0. This suggests that the code is used to query and display the major and minor version numbers of certain devices or software components.
-
-
-```
-<_SQL_>
-```
-
-The compiler embeds a version 4 code object (more on code object versions) and used the LLVM target triple amdgcnamd-amdhsa-gfx803 (more on target triples). You can extract that program object in a disassembled fashion for human consumption via roc-obj .
-**Following code does:** The code snippet provided appears to be a series of whitespace characters followed by two lines with the decrement operation `--x` and `-x`. However, this is not valid Python code due to the excessive whitespace and lack of context or structure. In Python, `--x` is not a valid operation as it would be interpreted as two separate unary negations, effectively leaving `x` unchanged. Similarly, `-x` is a unary negation that simply returns the negative value of `x`. Without additional context or surrounding code, this snippet does not perform any meaningful operation.
-
-
-```
-        | r o c - o b j \ - t \ g f x 8 0 3 \ - d \. / s a x p y
-```
-
-This creates two files on disk and .s extension is of most interest. Opening this file or dumping it to the console using cat lets find the disassembled binary of the SAXPY compute kernel, something similar to:
-**Following code does:** This code snippet appears to be executing a compiled program named `saxpy.exe`, which performs the SAXPY operation (Single-Precision A·X Plus Y). The operation involves scaling a vector `x` by a scalar `a` and adding it to another vector `y`, element-wise, over 10,000,000 elements. The output shows the first 10 elements of the resulting vector `y` after the operation has been completed.
-
-
-```
-<_XML_>
-```
-
-Alternatively, call the compiler with --save-temps to dump all device binary to disk in separate files.
-**Following code does:** It seems like you've provided a placeholder or incomplete code snippet. Please provide the actual code so I can help explain its purpose.
-
-
-```
-                                                                                                                                                                                                        |                                                                                                                                                                                                       
-                                                                                                                                                                                                        -                                                                                                                                                                                                        --                                                                                                                                                                                                        \                                                                                                                                                                                                        +                                                                                                                                                                                                        <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        }                                                                                                                                                                                                        </----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                    |   
-                                                                                                                                                                                                    |    -                                                                                                                                                                                                    |    0                                                                                                                                                                                                        ]                                                                                                                                                                                                        )                                                                                                                                                                                                       .                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        :                                                                                                                                                                                                       '
-```
-
-List all the temporaries created while compiling main.hip with:
-**Following code does:** This code defines a CUDA kernel function named `k` that operates on arrays of `float4` structures. The kernel is intended to be executed on a GPU, where each thread in a block performs a computation on elements of the input arrays `a` and `b`. Specifically, for each thread, it calculates an index using the thread ID (`tid`), block ID (`bid`), and block dimension (`dim`). It then updates the element in array `a` at the current thread index by adding the product of the calculated index and the corresponding element in array `b`. This operation is performed in parallel across all threads in a block.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-    ls main-hip-amdgcn-amd-amdhsa-*
-    main-hip-amdgcn-amd-amdhsa-gfx803.bc
-    main-hip-amdgcn-amd-amdhsa-gfx803.cui
-    main-hip-amdgcn-amd-amdhsa-gfx803.o
-    main-hip-amdgcn-amd-amdhsa-gfx803.out
-    main-hip-amdgcn-amd-amdhsa-gfx803.out.resolution.txt
-    main-hip-amdgcn-amd-amdhsa-gfx803.s
-```
-
-Files with the .s extension hold the disassembled contents of the binary. The filename notes the graphics IPs used by the compiler. The contents of this file are similar to what roc-obj printed to the console.
-
-## Linux and NVIDIA
-
-Unlike HIP on AMD, when compiling using the NVIDIA support of HIP the resulting binary will be a valid CUDA executable as far as the binary goes. Therefor it'll incorporate PTX ISA (Parallel Thread eXecution Instruction Set Architecture) instead of AMDGPU binary. As s result, tooling shipping with the CUDA SDK can be used to inspect which device ISA got compiled into a specific executable. The tool most useful to us currently is cuobjdump .
-**Following code does:** The provided code snippet appears to be a mix of Python and C++ syntax, but it is largely nonsensical and does not perform any meaningful operation. It includes fragments of C++ code, such as `<std::size_t factor = block_size;` and `</std::endl;`, which are not valid in Python. Additionally, there are scattered mathematical operators and comments that do not form a coherent program. Overall, this snippet does not achieve any functional purpose and seems to be a collection of random code fragments.
-
-
-```
-  cuobjdump --list-ptx./saxpy
-
-  Which will print something like:
-```
-**Following code does:** The provided code snippet appears to be a series of `<void>` and `</void>` tags interspersed with whitespace. It does not contain any executable Python code or meaningful logic. It seems to be a nonsensical or malformed attempt at using XML-like tags, but without any context or structure that would give it a functional purpose. Therefore, the code does not perform any operations or have a high-level purpose.
-
-
-```
-| P T X \ f i l e
-```
-**Following code does:** This code snippet appears to be part of a loop that launches a GPU kernel using the HIP (Heterogeneous-Compute Interface for Portability) API. The loop iterates in reverse, starting from `input_count` and decrementing until it is greater than 1. Within the loop, the `hipLaunchKernelGGL` function is called to execute a kernel function named `kernel` on the GPU. The kernel is launched with a grid configuration determined by `dim3(new_size(curr))` and a block size of `dim3(block_size)`. The kernel is provided with shared memory of size `factor * sizeof(unsigned)` and is executed on the default HIP stream. The parameters `front`, `back`, and `kernel_op` are passed to the kernel, likely as arguments for processing data. The purpose of this code is to perform parallel computations on a GPU, potentially for tasks like data processing or transformation, by repeatedly launching a kernel with varying configurations.
-
-
-```
-1:  saxpy. 1. sm_5. ptx
-```
-
-From this we can see that the saxpy kernel is stored as sm\_52 , which shows that a compute capability 5.2 ISA got embedded into the executable, so devices which sport compute capability 5.2 or newer will be able to run this code.
-
-## Windows and AMD
-
-The HIP SDK for Windows don't yet sport the roc-* set of utilities to work with binary artifacts. To find out what binary formats are embedded into an executable, one may use dumpbin tool from the Windows SDK to obtain the raw data of the .hip\_fat section of an executable. (This binary payload is what gets parsed by the roc-* set of utilities on Linux.) Skipping over the reported header, the rendered raw data as ASCII has ~3 lines per entries. Depending on how many binaries are embedded, you may need to alter the number of rendered lines. An invocation such as:
-**Following code does:** The code snippet `1;)` is not valid Python code. It appears to be a syntax error, as Python does not allow a semicolon to follow a number without a preceding valid statement. This snippet will result in a syntax error if executed in a Python interpreter.
-
-
-```
-                                                                                                                                                                                                        | dumpbin.exe  /nologo  /section:.hip_fat  /rawdata:8 .\saxpy.exe  |  select  -Skip  20  -First  12                                                                                                                                                                                                       
-                                                                                                                                                                                                        -                                                                                                                                                                                                        --                                                                                                                                                                                                        +                                                                                                                                                                                                        <--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        </--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                   | dumpbin .exe  /nologo  /section:.hip_fat  /rawdata:8 .\saxpy.exe  |  select  -Skip  20  -First  12                                                                                                                                                             |                                                                                                                                                                                                        >--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                  
-     |  dumpbin.exe  /nologo  /section:.hip_fat  /rawdata:8 .\saxpy.exe  |  select  -Skip  20  -First  12                                                                                                                                                        |                                               
-     |                                                                                                                                                                                                   |                                          
-     |                                                                                                                                                       
-     |                                                                                                                                                   |                                                    
-     |                                                                                                                                             
-     |                                                    
-     |                                                                                                                                        
-     |                                                         
-     |
-```
-
-The output may look like:
-**Following code does:** This code snippet appears to be part of a larger function or program, likely written in C++ given the use of `std::swap`. The code performs the following high-level operations:
-
-1. It assigns a new value to the variable `curr` by calling a function `new_size(curr)`.
-2. It checks if the updated value of `curr` is greater than 1.
-3. If `curr` is greater than 1, it swaps the values of two variables, `front` and `back`, using the `std::swap` function.
-
-Overall, the code seems to be adjusting the size of something (possibly a container or data structure) and conditionally swapping two elements based on the new size.
-
-
-```
-<_Python_>
-```
-
-We can see that the compiler embedded a version 4 code object (more on code object versions) and used the LLVM target triple amdgcn-amd-amdhsa-gfx906 (more on target triples). Don't be alarmed about linux showing up as a binary format, AMDGPU binaries uploaded to the GPU for execution are proper linux ELF binaries in their format.
-
-Alternatively we can call the compiler with --save-temps to dump all device binary to disk in separate files.
-**Following code does:** The code snippet `<_Cuda_>` appears to be a placeholder or a symbolic representation rather than actual executable code. In the context of programming, particularly with Python, it might be intended to represent a CUDA-related object or module. CUDA (Compute Unified Device Architecture) is a parallel computing platform and application programming interface (API) model created by NVIDIA, which allows developers to use a GPU for general purpose processing. However, without additional context or actual code, it's not possible to determine the specific functionality or purpose of this placeholder.
-
-
-```
-                                                                                                                                                                                                        |clang++.\HIP-Basic\saxpy\main.hip -o saxpy.exe -I.\Common -lamdhip64 -L ${env:HIP_PATH}                                                                                                                                                                                                       
-                                                                                                                                                                                                        -lib -02 --save-temps                                                                                                                                                                                                        \
-```
-
-Now we can list all the temporaries created while compiling main.hip via
-**Following code does:** This code snippet is part of a parallel reduction algorithm typically used in GPU programming, such as with CUDA. The purpose of this code is to perform a reduction operation (e.g., summation, finding the maximum) on an array of data stored in shared memory (`shared`). The reduction is done in parallel by multiple threads within a block.
-
-The loop iteratively reduces the number of elements by combining pairs of elements using a binary operation `op`. The `for` loop iterates over increasing powers of two, effectively halving the number of active elements in each iteration. The `__syncthreads()` function is used to synchronize all threads in the block, ensuring that all threads have completed their operations before proceeding to the next iteration.
-
-The code has been modified to use a different indexing strategy, where the index `j` is calculated based on the thread ID (`tid`) and the current step size (`i`). This change aims to ensure that only valid indices within the bounds of the block are accessed, preventing out-of-bounds memory access.
-
-
-```
-        |Get-ChildItem -Filter main-hip-* | selec
-```
-**Following code does:** The provided code snippet appears to be a fragment of a larger codebase, possibly related to parallel computing or GPU programming, given the use of `blockDim.x` which is common in CUDA programming for defining the number of threads in a block. The snippet seems to be part of a loop intended for a shared reduction operation, which is a common parallel algorithm used to reduce an array of values to a single value (e.g., sum, max). However, the snippet is incomplete and contains some formatting artifacts (e.g., `-` and `+` symbols), which suggest it might be part of a diff or patch file showing changes to the code. The high-level purpose of this snippet is likely to perform a reduction operation across threads within a block.
-
-
-```
-n-hip-* | select -Property Name
-                                                                                                                                                                                                         (continues on next page)
-```
-
-(continued from previous page)
-**Following code does:** The code snippet `<_Cuda_>` appears to be a placeholder or a symbolic representation rather than actual executable Python code. In the context of programming, "Cuda" typically refers to NVIDIA's parallel computing platform and application programming interface (API) model, which allows developers to use a CUDA-enabled graphics processing unit (GPU) for general purpose processing. However, without additional context or actual code, it's not possible to determine the specific functionality or purpose of this placeholder.
-
-
-```
-Name
------
-main-hip-amdgcn-amd-amdhsa-gfx906.bc
-main-hip-amdgcn-amd-amdhsa-gfx906.hipi
-main-hip-amdgcn-amd-amdhsa-gfx906.o
-main-hip-amdgcn-amd-amdhsa-gfx906.out
-main-hip-amdgcn-amd-amdhsa-gfx906.out.resolution.txt
-main-hip-amdgcn-amd-amdhsa-gfx906.s
-```
-
-Files with the .s extension hold the disassembled contents of the binary and the filename directly informs us of the graphics IPs used by the compiler.
-**Following code does:** This code snippet is written in C++ and its purpose is to print the numbers from 0 to 3 sequentially. It uses a `for` loop to iterate over a range of integers starting from 0 up to, but not including, 4. During each iteration, it prints the current value of the loop variable `i` using the `printf` function.
-
-
-```
-main-hip-amdgcn-amd-amdsha-gfx906.out
-main-hip-amdgcn-amd-amdsha-gfx906.out.resolution.txt
-main-hip-amdgcn-amd-amdsha-gfx906.s
-
-Files with the.s extension hold the disassembled contents of the binary and the filename directly informs us of the
-graphics IPs used by the compiler.
-
-Get-ChildItem main-hip-*.s | Get-Content
-           .text
-           .amdgcn_target "amdgcn-amd-amdsha--gfx906"
-           .protected        _Z12saxpy_kernelPKfPfj ; -- Begin  function _Z12saxpy_
-  --kernelPKfPfj
-           .glob1   _Z12saxpy_kernelPKfPfj
-           .p2align           8
-           .type     _Z12saxpy_kernelPKfPfj,@function
-_Z12saxpy_kernelPKfPfj:                                                                                                                                                                                                        
-  ; %bb.0:
-            s_load_dword s0, s[4:5], 0x4
-            s_load_dword s1, s[6:7], 0x18
-            s_waitcnt lgkmcnt(0)
-            s_and_b32 s0, s0, 0xffff
-            s_mul_i32 s8, s8, s0
-            v_add_u32_e32 v0, s8, v0
-            v_cmp_gt_u32_e32 vcc,  s1, v0
-            s_and_saveexec_b64 s[0:1], vcc
-            s_cbranch_execz.LBB0_2
-  ; %bb.1:
-            s_load_dwordx4 s[0:3], s[6:7], 0x8
-            v_mov_b32_e32 v1, 0
-            v_lshlrev_b64 v[0:1], 2, v[0:1]
-            s_waitcnt lgkmcnt(0)
-            v_mov_b32_e32 v3, s1
-            v_add_co_u32_e32 v2, vcc, s0, v0
-            v_addc_co_u32_e32 v3, vcc, v3, v1, vcc
-            global_load_dword v2, v[2:3], off
-            v_mov_b32_e32 v3, s3
-            v_add_co_u32_e32 v0, vcc, s2, v0
-            v_addc_co_u32_e32 v1, vcc, v3, v1, vcc
-            global_load_dword v3, v[0:1], off
-            s_load_dword s0, s[6:7], 0x0
-            s_waitcnt vmcnt(0) lgkmcnt(0)
-            v_fmac_f32_e32 v3, s0, v2
-            global_store_dword v[0:1], v3, off
- .LBB0_2:
-            s_endpgm
-           ...
-```
-
-## Windows and NVIDIA
-
-Unlike HIP on AMD, when compiling using the NVIDIA support for HIP, the resulting binary will be a valid CUDA executable. Therefore, it'll incorporate PTX ISA (Parallel Thread eXecution Instruction Set Architecture) instead of AMDGPU binary. As a result, tooling included with the CUDA SDK can be used to inspect which device ISA was compiled into a specific executable. The most helpful to us currently is cuobjdump .
-**Following code does:** This code snippet is a portion of assembly code that is part of a function, likely the `main` function of a program. It primarily performs the following actions:
-
-1. It saves the `rbx` register onto the stack to preserve its value.
-2. It loads the address of a string (likely a format string) into the `rbx` register.
-3. It sets up arguments for the `printf` function call by moving the address of the string into the `rdi` register and zeroing out the `esi` and `eax` registers, which are used for additional arguments and return values, respectively.
-4. It calls the `printf` function twice, first with `esi` set to zero and then with `esi` set to one, likely printing the same string twice with different formatting or arguments.
-5. The code does not show the complete function, but it is likely part of a simple program that prints a string to the console using the `printf` function from the C standard library.
-
-Overall, the code is focused on printing a string to the console using the `printf` function.
-
-
-```
-<_Bash_>
-```
-**Following code does:** This code snippet is a fragment of assembly code, likely generated by the GCC compiler, that involves calling the `printf` function twice. The purpose of this code is to print two integers to the standard output using the format string "%d". 
-
-1. The first `printf` call prints the integer `2`.
-2. The second `printf` call prints the integer `3`.
-
-The code uses the `printf` function from the Procedure Linkage Table (PLT), which is a common technique in dynamically linked executables to resolve function addresses at runtime. The `xor eax, eax` instructions are used to set the `eax` register to zero, which is a common way to prepare for a function call in x86-64 assembly. The `pop rbx` and `ret` instructions are used to restore the base pointer and return from the function, respectively.
-
-
-```
-| P T X \ f i l e
-```
-**Following code does:** This code is a low-level assembly representation of a simple C program that prints the numbers 0 through 3, each on a new line. It uses a loop to increment a counter (`ebx`) from 0 to 3, and in each iteration, it calls the `printf` function to print the current value of the counter. The loop continues until the counter reaches 4, at which point the program exits. The `.string "%d"` is used as the format string for `printf` to print integers.
-
-
-```
-1:  saxpy. 1. sm_5. ptx
-```
-
-This example shows that the SAXPY kernel is stored as sm\_52 . It also shows that a compute capability 5.2 ISA was embedded into the executable, so devices that support compute capability 5.2 or newer will be able to run this code.
-
-Now that you've found what binary got embedded into the executable, find which format our available devices use.
-
-## Linux and AMD
-
-On Linux a utility called rocminfo helps us list all the properties of the devices available on the system, including which version of graphics IP ( gfxXYZ ) they employ. You can filter the output to have only these lines:
-**Following code does:** This code is an assembly routine for a function named `main`, likely compiled from a C/C++ program using the Microsoft Visual C++ (MSVC) compiler. The function's high-level purpose is to print a string (referred to as `'string'` in the code) four times using a loop. It uses the `printf` function to output the string. The loop is controlled by the `ebx` register, which is incremented each iteration until it reaches 4. The function sets up and cleans up the stack frame before and after the loop, respectively, and returns 0 upon completion.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?php?com/bin/rocminfo | grep gfx
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        </?php?com/bin/rocminfo | grep gfx
-                                                                                                                                                                                        
-	              Name:                                                                                                                                                                                                        &
-```
-
-Now that you know which graphics IPs our devices use, recompile your program with the appropriate parameters.
-**Following code does:** This code snippet sequentially prints the integers 0, 1, 2, and 3 to the standard output. Each `printf` function call outputs one integer, formatted as a decimal integer (`%d`).
-
-
-```
-                                                                                                                                                                                                        |                                                                                                                                                                                                       
-                                                                                                                                                                                                        -                                                                                                                                                                                                        --                                                                                                                                                                                                        \                                                                                                                                                                                                        +                                                                                                                                                                                                        <                                                                                                                                                                                                        </                                                                                                                                                                                                        }                                                                                                                                                                                                        >                                                                                                                                                                                                        &                                                                                                                                                                                                        )                                                                                                                                                                                                        ]                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        :                                                                                                                                                                                                        ;                                                                                                                                                                                                       .                                                                                                                                                                                                        "
-```
-
-Now the sample will run.
-**Following code does:** The code snippet appears to be an incorrectly formatted XML declaration. It contains two XML declaration lines, which are not valid in XML syntax. The first line is a correctly formatted XML declaration, while the second line is incorrectly closed with a question mark before the "xml" keyword. This snippet does not perform any functional operation and would likely result in a parsing error if used in an XML document.
-
-
-```
-        /saxpy
-        Calculating y[i] = a * x[i] + y[i] over 10000000 elements.
-        First 10 elements of the results: [ 3, 5, 7, 9, 11, 13, 15, 17, 19, 21 ]
-```
-**Following code does:** This code snippet is written in C++ and is used in a GPU programming context, likely with the HIP (Heterogeneous-Compute Interface for Portability) API, which is used for writing portable code across AMD and NVIDIA GPUs. The code retrieves the warp size from the device properties and uses a switch statement to launch a GPU kernel with a template parameter that matches the warp size. Specifically, if the warp size is 32, it launches a kernel with a template argument of 32; if the warp size is 64, it launches a kernel with a template argument of 64. This allows the kernel to be optimized based on the warp size of the GPU being used.
-
-
-```
-<_Python_>
-```
-
-## Linux and NVIDIA
-
-On Linux HIP with the NVIDIA back-end, the deviceQuery CUDA SDK sample can help us list all the properties of the devices available on the system, including which version of compute capability a device sports. &lt;major&gt;.&lt;minor&gt; compute capability is passed to nvcc on the command-line as sm\_&lt;major&gt;&lt;minor&gt; , for eg. 8.6 is sm\_86 .
-
-Because it's not included as a binary, compile the matching example from ROCm.
-**Following code does:** This code snippet is a template-based mechanism that uses a static switch to select between different compile-time options for a CUDA or HIP kernel launch. Specifically, it uses `tmp::static_switch` to choose between two possible values for `warp_size` (32 or 64). Depending on the selected value, it launches a GPU kernel (`kernel`) with the corresponding warp size as a template parameter. This allows the code to optimize the kernel execution for different warp sizes at compile time, potentially improving performance by tailoring the execution to the specific hardware configuration.
-
-
-```
-                                                                                                                                                                                                        |                                                                                                                                                                                                       
-                                                                                                                                                                                                        <.02                                                                                                                                                                                                        </.00                                                                                                                                                                                                        >.00                                                                                                                                                                                                      <.00                                                                                                                                                                                                      </.01                                                                                                                                                                                                        }
-```
-
-Filter the output to have only the lines of interest, for example:
-**Following code does:** The code snippet appears to be incomplete or malformed. It seems to be missing context or additional code that would clarify its purpose. The snippet includes a generic placeholder `t WarpSize>()`, which might suggest a template or a function call in a language like C++ rather than Python. However, without additional context or surrounding code, it's not possible to determine its high-level purpose or functionality.
-
-
-```
-<_YAML_>
-```
-
-Note: In addition to the nvcc executable is another tool called \_\_nvcc\_device\_query which prints the SM Architecture numbers to standard out as a comma separated list of numbers. The utility's name suggests it's not a user-facing executable but is used by nvcc to determine what devices are in the system at hand.
-
-Now that you know which graphics IPs our devices use, recompile your program with the appropriate parameters.
-**Following code does:** This code snippet is a modification of a GPU kernel function written in HIP (Heterogeneous-Compute Interface for Portability), which is used for parallel computing on AMD and NVIDIA GPUs. The changes introduce a template parameter `WarpSize` to the kernel, allowing it to handle different warp sizes (32 for NVIDIA and RDNA AMD GPUs, 64 for CDNA AMD GPUs) more flexibly. The shared memory reduction loop is adjusted to stop at the warp size, and a new warp-level reduction is added using a static loop unrolling technique (`tmp::static_for`). This ensures that the kernel can efficiently perform reductions across threads within a warp, adapting to the specific warp size of the target hardware.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <_arch=sm_70,sm_86
-```
-
-Note: If you want to portably target the development machine which is compiling, you may specify -arch=native instead.
-
-Now the sample will run.
-**Following code does:** It seems there is a formatting error in your request. The code snippet is labeled as C++ but is enclosed within Python code tags. Please provide the correct code snippet or clarify the language so I can assist you accurately.
-
-
-```
-           ./saxpy
-            Calculating y[i] = a * x[i] + y[i] over 10000000 elements.
-            First 10 elements of the results: [ 3, 5, 7, 9, 11, 13, 15, 17, 19, 21 ]
-```
-
-## Windows and AMD
-
-On Windows, a utility called hipInfo.exe helps us list all the properties of the devices available on the system, including which version of graphics IP ( gfxXYZ ) they employ. Filter the output to have only these lines:
-**Following code does:** The provided code snippet appears to be a collection of random characters and symbols, including some that resemble HTML/XML tags and others that are typical in programming syntax. However, it does not form any valid or meaningful code in Python or any other programming language. It seems to be a nonsensical or corrupted text rather than a functional code snippet.
-
-
-```
-& ${env:HIP_PATH}bin\hipInfo.exe | Select-String gfx
-
-gcnArchName:                    gfx1032
-gcnArchName:                    gfx1035
-```
-
-Now that you know which graphics IPs our devices use, recompile your program with the appropriate parameters.
-**Following code does:** The code snippet provided is incomplete and contains only a comment: `// Warp reduction`. This comment suggests that the code is likely part of a larger program, possibly written in a language like CUDA C/C++ for GPU programming, where "warp reduction" is a common technique. Warp reduction is used to efficiently perform parallel reduction operations (such as summing elements) within a warp, which is a group of threads that execute the same instruction simultaneously on a GPU. However, without additional context or code, it's not possible to describe the specific implementation or purpose beyond this general concept.
-
-
-```
-                                                                                                                                                                                                        |clang++.\HIP-Basic\saxpy\main.hip -o saxpy.exe -I.\Common -lamdhip64 -L ${env:HIP_PATH}                                                                                                                                                                                                       
-                                                                                                                                                                                                        -lib -02 --offload-arch=gfx1032 --offload-arch=gfx1035                                                                                                                                                                                                        --lib -02 --offload-arch=gfx1035
-```
-
-Now the sample will run.
-**Following code does:** The provided code snippet is a partial definition of a CUDA kernel function template in C++. This kernel is designed to be executed on a GPU. It uses template parameters to allow flexibility in specifying the block size, warp size, data type, and operation type. The kernel function, named `kernel`, takes several parameters: pointers to two arrays (`front` and `back`), an operation (`op`), a zero element (`zero_elem`), and the size of the `front` array (`front_size`). The `__launch_bounds__(BlockSize)` attribute is used to specify the maximum number of threads per block, optimizing the kernel's execution configuration. The actual implementation of the kernel is not provided in the snippet.
-
-
-```
-       .\saxpy.exe
-        Calculating y[i] = a * x[i] + y[i] over 10000000 elements.
-        First 10 elements of the results: [ 3, 5, 7, 9, 11, 13, 15, 17, 19, 21 ]
-```
-
-## Windows and NVIDIA
-
-On Windows HIP with the NVIDIA back-end, the deviceQuery CUDASDKsample can help us list all the properties of the devices available on the system, including which version of compute capability a device sports. &lt;major&gt;. &lt;minor&gt; compute capability is passed to nvcc on the command-line as sm\_&lt;major&gt;&lt;minor&gt; , for eg. 8.6 is sm\_86 .
-
-Because it's not included as a binary, compile the matching example from ROCm.
-**Following code does:** This code snippet is part of a CUDA kernel designed for parallel computation on a GPU. It involves reading data from a global memory buffer (`front`) and performing operations on it using shared memory to optimize performance. Here's a high-level summary of what the code does:
-
-1. **Warp and Block Configuration**: It calculates the number of warps (`WarpCount`) within a block based on the block size and warp size. Warps are groups of threads that execute instructions in lockstep.
-
-2. **Shared Memory Allocation**: It allocates shared memory (`shared`) for storing intermediate results. The size of this shared memory is determined by the number of warps in the block.
-
-3. **Safe Reading Functions**: It defines two lambda functions, `read_global_safe` and `read_shared_safe`, to safely read elements from global and shared memory, respectively. These functions ensure that reads do not exceed the bounds of the memory arrays.
-
-4. **Thread and Block Indexing**: It calculates various indices (`tid`, `bid`, `gid`, `wid`, `lid`) to identify the thread's position within the block and grid. These indices are used to determine which data elements each thread should process.
-
-5. **Data Processing**: Each thread reads two elements from the global memory (`front`) using the `read_global_safe` function and applies an operation (`op`) on them. The result is stored in a local variable (`res`).
-
-Overall, this code is part of a larger CUDA kernel that performs parallel data processing using shared memory to improve performance by reducing global memory accesses. The use of shared memory allows for efficient communication of results between threads within the same block.
-
-
-```
-                                                                                                                                                                                                        |nvcc.\HIP-Basic\device_query\main.cpp -o device_query.exe -I.\Common -I ${env:HIP_PATH}                                                                                                                                                                                                       
-                                                                                                                                                                                                        -include -02                                                                                                                                                                                                        --include -0022
-```
-
-Filter the output to have only the lines of interest, for example:
-**Following code does:** This code snippet appears to be part of a parallel computing or multi-threading context, likely using a GPU or a similar architecture where threads are organized into blocks. The code checks if the current thread's identifier (`tid`) is zero, which typically means it is the first thread in a block. If this condition is true, it writes a computed result (`res`) from local memory to a shared or global memory location (`back`) indexed by the block identifier (`bid`). This pattern is often used to consolidate results from multiple threads within a block into a single output.
-
-
-```
- .\device_query.exe | Select-String "major.minor"
-
-  major.minor:              8.6
-  major.minor:              7.0
-```
-
-Note: Next to the nvcc executable is another tool called \_\_nvcc\_device\_query.exe which simply prints the SM Architecture numbers to standard out as a comma separated list of numbers. The naming of this utility suggests it's not a user facing executable but is used by nvcc to determine what devices are in the system at hand.
-
-Now that you know which graphics IPs our devices use, recompile your program with the appropriate parameters.
-**Following code does:** The code snippet appears to be incomplete and contains a syntax error. It seems like it might be part of a larger piece of code, possibly involving threading or parallel processing, given the mention of "ItemsPerThread". However, without additional context or complete code, it's not possible to determine its high-level purpose.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        --x                                                                                                                                                                                                        -x
-```
-
-Note: If you want to portably target the development machine which is compiling, you may specify -arch=native instead.
-
-Now the sample will run.
-**Following code does:** The code snippet provided is a fragment of a CUDA kernel function declaration in C++. CUDA is a parallel computing platform and application programming interface model created by NVIDIA. The purpose of this code is to define a GPU kernel function that can be executed on an NVIDIA GPU.
-
-- `__global__`: This keyword indicates that the function is a CUDA kernel, which means it is executed on the GPU but can be called from the host (CPU) code.
-- `static`: This keyword suggests that the kernel function has internal linkage, meaning it is only visible within the translation unit it is defined in.
-- `__launch_bounds__(BlockSize)`: This is an optional CUDA attribute that specifies the maximum number of threads per block (`BlockSize`) that the kernel is optimized for. It helps the compiler optimize the kernel for specific execution configurations.
-
-The ellipsis (`...`) indicates that the function's parameters and body are not shown. Overall, this snippet is part of a larger CUDA program designed to perform parallel computations on a GPU.
-
-
-```
-       .\saxpy.exe
-        Calculating y[i] = a * x[i] + y[i] over 10000000 elements.
-        First 10 elements of the results: [ 3, 5, 7, 9, 11, 13, 15, 17, 19, 21 ]
-```
-**Following code does:** The code snippet `<_C_>` appears to be a placeholder or a symbolic representation rather than actual executable code. It does not perform any operations or have any functionality in Python as it stands. It might be used as a marker or a template in a larger context where specific code or content is meant to be inserted.
-
-
-```
-<_Python_>
-```
-
-## CHAPTER
-
-## TWENTYNINE
-
-## REDUCTION
-
-Reduction is a common algorithmic operation used in parallel programming to reduce an array of elements into a shorter array of elements or a single value. This document exploits reduction to introduce some key considerations while designing and optimizing GPU algorithms.
-
-This document is a rejuvenation and extension of the invaluable work of Mark Harris. While the author approaches the topic with a less naive approach, reviewing some original material is valuable to see how much the underlying hardware has changed. This document provides a greater insight to demonstrate progress.
-
-## 29.1 The algorithm
-
-Reduction has many names depending on the domain; in functional programming it's referred to as fold, in C++, it's called std::accumulate and in C++17, as std::reduce . A reduction takes a range of inputs and 'reduces' the given range with a binary operation to a singular or scalar output. Canonically, a reduction requires a 'zero' element that bootstraps the algorithm and serves as one of the initial operands to the binary operation. The 'zero' element is generally called identity or neutral element in the group theory, which implies that it is an operand that doesn't change the result. Some typical use cases are: calculating a sum or normalizing a dataset and finding the maximum value in the dataset. The latter use case is discussed further in this tutorial.
-
-There are multiple variations of reduction that allow parallel processing. The approach taken by std::reduce requires the user-provided binary operator to operate on any combination of identity and input range elements, or even exclusively on any of them. This allows you to insert any number of identities to facilitate parallel processing and then combine the partial results of parallel execution.
-
-## 29.2 Reduction on GPUs
-
-Implementing reductions on GPUs requires a basic understanding of the /understand/programming\_model\_reference. The document explores aspects of low-level optimization best discussed through the Inherent thread model , and refrains from using cooperative groups.
-
-Synchronizing parallel threads of execution across a GPU is crucial for correctness as the partial results can't be synchronized before they manifest. Synchronizing all the threads running on a GPU at any given time is possible, however, it is a costly and intricate operation. If synchronization is not absolutely necessary, map the parallel algorithm so that multiprocessors and blocks can make independent progress and need not sync frequently.
-
-There are ten reduction implementations in the rocm-examples, which are described in the following sections.
-
-## 29.2.1 Naive shared reduction
-
-The naive algorithm takes a tree-like shape, where the computational domain is purposefully distributed among blocks. In all blocks, all threads participate in loading data from persistent (from the kernel's perspective) global memory into the shared memory. This helps to perform tree-like reduction for a single thread by writing the partial result to global, in a location unique to the block, which allows the block to make independent progress. The partial results are combined in subsequent launches of the same kernel until a scalar result is reached.
-
-This approach requires temporary storage based on the number of blocks launched, as each block outputs a scalar partial result. Depending on the need to store or destroy the input, a second temporary storage might be needed, which could be large enough to store the results of the second kernel launch. Alternatively, you can reuse the storage of the larger than necessary original input. These implementations differ so slightly that the document only considers the use case where the input could be destroyed.
-**Following code does:** The code snippet defines a lambda function `read_global_safe` in C++ that reads a sequence of elements from an array `front` into a static array of a specified size `ItemsPerThread`. The lambda uses a template parameter pack and `std::integer_sequence` to iterate over indices. If the index plus the number of items per thread is within the bounds of `front_size`, it directly loads elements from `front`. Otherwise, it loads elements conditionally, substituting a `zero_elem` for out-of-bounds indices. This ensures safe reading from the array without exceeding its bounds.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <std::size_t factor = block_size; // block_size from hipGetDeviceProperties()
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        </std::endl;
-                                                                                                                                                                                                       <int>                                                                                                                                                                                                        //                                                                                                                                                                                                       	                                                                                                                                                                                                      
-//                                                                                                                                                                                                        +                                                                                                                                                                                                        -                                                                                                                                                                                                        *                                                                                                                                                                                                        /                                                                                                                                                                                                        */
-                                                                                                                                                                                                       +
-                                                                                                                                                                                                       *
-                                                                                                                                                                                                       -
-                                                                                                                                                                                                       */
-```
-
-For threads that don't have unique inputs, feed zero\_elem instances to threads. The backing of double-buffering is allocated as such:
-**Following code does:** This code snippet initializes an array `arr` of size 4 with elements from another array or list called `front`. The elements are selected based on an index `gid`, such that `arr` contains four consecutive elements starting from `front[gid]` to `front[gid + 3]`. The type of the elements in `arr` is denoted by `T`, which suggests that this code is likely written in a language that uses templates or generics, such as C++ or a similar language. The purpose of this code is to create a subarray or slice of four elements from the `front` array starting at a specific index `gid`.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <void>                                                                                                                                                                                                        </void>                                                                                                                                                                                                     
- 
-                                                                                                                                                                                                      <void><void>                                                                                                                                                                                                      <void></void>                                                                                                                                                                                                     
-
- 
-                                                                                                                                                                                                     
- 
-
-                                                                                                                                                                                                      <void>"                                                                                                                                                                                                        >void>                                                                                                                                                                                                      </void></void>                                                                                                                                                                                                    <void> 
-                                                                                                                                                                                                      </void><void>                                                                                                                                                                                                    <void></void></void>                                                                                                                                                                                                   
-   
-                                                                                                                                                                                                    <void>
-```
-
-Data is initialized on the host and dispatched to the device followed by the commencement of device-side reduction. The swapping of the double-buffer on the last iteration is omitted, therefore the result is in the back-buffer irrespective of the input size.
-**Following code does:** This code snippet initializes an array `arr` of size 4 with elements from another array `front`. It uses a conditional expression to fill each position in `arr`. For each index `i` from 0 to 3, it checks if `i` is within the bounds of `front` (i.e., `i < front_size`). If it is, the corresponding element from `front` is used; otherwise, a default value `zero_elem` is used. This effectively copies up to four elements from `front` into `arr`, filling any out-of-bounds positions with `zero_elem`.
-
-
-```
-of the input size.
-
-for (uint32_t curr = input_count; curr > 1;)
-{
-      hipLaunchKernelGGL(
-           kernel,
-           dim3(new_size(curr)),
-           dim3(block_size),
-           factor * sizeof(unsigned),
-           hipStreamDefault,
-           front,
-           back,
-           kernel_op,
-```
-**Following code does:** This code snippet appears to be a series of empty lines with a placeholder or invalid tag `<?>` in the middle. It doesn't perform any functional operation or have any meaningful purpose in its current form. It might be intended as a placeholder or a template for future code development.
-
-
-```
-1;)
-```
-
-(continues on next page)
-
-(continued from previous page)
-**Following code does:** This code snippet is a host-side reference implementation of a reduction operation typically executed on a GPU. It processes an input vector of unsigned integers by dividing it into partitions of a specified size (`partition_size`). For each partition, it calculates the sum of its elements and stores the result in a new vector (`result`). The size of the result vector is determined by dividing the total input size by the partition size, effectively reducing the input data by aggregating sums of each partition. This operation is useful for tasks like parallel processing where data needs to be reduced or aggregated efficiently.
-
-
-```
-        zero_elem,
-        curr);
-
-     curr = new_size(curr);
-     if (curr > 1)
-        std::swap(front, back);
-}
-```
-
-This structure persists in the kernel throughout all the variations of reduction with slight modifications to factor and shared memory allocation:
-**Following code does:** The code snippet appears to be part of a function in a programming language that uses semicolons to terminate statements, likely C, C++, or Java. It seems to be iterating over some collection or array, assigning a value `partition_result` to an element at index `i` in an array or list called `result`. After the loop completes, the function returns the `result` array or list. The high-level purpose of this code is to populate the `result` array with values computed or retrieved during the loop and then return this populated array.
-
-
-```
-<_Cuda_>
-```
-
-While the tid % (2 * i) == 0 indexing scheme yields correct results, it also leads to high thread divergence. Thread divergence indicates the event when the threads in a warp diverge, which implies that the threads have to execute different instructions in a given clock cycle. This is easily manifested using if-else statements as shown here, but can also be manifested as for loop dependent on thread ID lengths. Even though the number of active threads participating in the reduction reduces, warps remain active longer than necessary, as at least one lane in a warp hits the if statement.
-
-## 29.2.2 Reducing thread divergence
-
-You can reduce divergence by keeping dataflow between memory addresses identical but reassigning the thread ids.
-**Following code does:** The provided code snippet is a CUDA device function named `reduce_sum` that performs a parallel reduction to compute the sum of unsigned integer values within a thread group using shared memory. The function takes a `thread_group` object `g`, a shared memory pointer `x`, and an unsigned integer `val` as inputs. It uses a loop to iteratively halve the number of active threads, synchronizing them at each step, and accumulates the sum of values from different threads. The final result of the reduction is stored in the first thread of the group, while other threads return 0. This function is typically used in GPU programming to efficiently compute sums across threads in a block or custom partition.
-
-
-```
-// Shared reduction
-for (uint32_t i = 1; i < blockDim.x; i *= 2)
-{
--    if (tid % (2 * i) == 0)
--        shared[tid] = op(shared[tid], shared[tid + i]);
-+    if (uint32_t j = 2 * i * tid; j < blockDim.x)
-+        shared[j] = op(shared[j], shared[j + i]);
-    __syncthreads();
-}
-```
-
-This way inactive threads start accumulating uniformly towards the higher thread ID index range and might uniformly skip to \_\_syncthreads() . However, this introduces a bank conflicts issue.
-
-## 29.2.3 Resolving bank conflicts
-
-Both AMD and NVIDIA implement shared memory in the hardware by organizing storage into banks of various sizes. This hardware element is known as Local Data Share (LDS) on AMD hardware. On NVIDIA hardware, it's implemented using the same silicon as the L1 data cache. You can think of shared memory as a striped 2-dimensional range of memory. Shared memory bank's count, width, and depth depend on the architecture. A bank conflict occurs when different threads in a warp access the same bank during the same operation. In this case, the hardware prevents the attempted concurrent accesses to the same bank by converting them into serial accesses.
-
-- 'AMD Instinct MI200' Instruction Set Architecture, Chapter 11.1
-- 'RDNA 2' Instruction Set Architecture, Chapter 10.1
-
-A notable exception is when the shared read uniformly broadcasts to the same address across the entire warp. A better implementation of the naive algorithm is to form continuous ranges of the threads activities and their memory accesses.
-**Following code does:** This code snippet is part of a CUDA program, which is designed to run on NVIDIA GPUs. Its high-level purpose is to set up a parallel computation environment using CUDA's thread block and shared memory features. Specifically, it:
-
-1. Declares shared memory (`workspace`) to be used by threads within a block for operations like reduction, which is a common parallel algorithm for combining elements (e.g., summing an array).
-2. Defines a `thread_block` object (`thread_block_group`) that represents all threads within a CUDA block, allowing them to coordinate and share data.
-3. Loads an input value from global memory (`d_vector`) into a local variable (`input`) for each thread, based on the thread's rank within the block.
-4. Creates a `custom_partition` of threads within the block, where each partition consists of 16 threads. This partitioning allows for more fine-grained control over thread collaboration and data sharing within the block.
-
-Overall, the code sets up the necessary structures for performing parallel computations on a GPU, leveraging shared memory and thread coordination to optimize performance.
-
-
-```
-
-        implementation of the naive algorithm is to form continuous ranges of the threads activ
-        
-        // Shared reduction
-        -for (uint32_t i = 1; i < blockDim.x; i *= 2)
-        -{
-        -                                                                                                                                                                                                        
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        -f                                                                                                                                                                                                        +f
-```
-
-Note: To avoid bank conflicts, read shared memory in a coalesced manner, which implies that reads/writes of each lane in a warp evaluate to consecutive locations. Analyzing the read/write patterns could help you to understand the cause of bank conflicts. For more details, check CDNA3 ISA or RDNA3 ISA data share operations chapter.
-
-## 29.2.4 Utilize upper half of the block
-
-The preceding implementation is free of low-level GPU-specific anti-patterns. However, it still exhibits some common shortcomings. The loop performing the reduction in the shared memory starts from i = blockDim.x / 2 and the first predicate if (tid &lt; i) immediately disables half of the block, which only helps load the data into the shared memory. You can change the kernel along with the calculation of factor on the host, as shown here:
-**Following code does:** This code snippet performs a parallel reduction operation on a set of input data using a thread block group, which is a collection of threads that work together. The `reduce_sum` function aggregates the input data into a single sum, storing the result in the `output` variable. After the reduction, only the first thread in the thread block group (determined by checking if its rank is 0) writes the computed sum to the first element of the `d_block_reduced_vector` array. This ensures that only one thread outputs the final reduced value, preventing race conditions or redundant writes.
-
-
-```
-<_Cuda_>
-```
-
-By eliminating half of the threads and giving meaningful work to all the threads by unconditionally performing a binary op , you can prevent the wastage of half of the threads.
-
-Even though global memory is read in a coalesced fashion, as preferred by the memory controller, optimal performance is still limited by the instruction throughput. Omit superfluous synchronization -----------
-
-Warps are known to execute in a strict lockstep fashion. Therefore, once shared reduction reaches a point where only a single warp participates meaningfully, you can cut short the loop and let the rest of the warps terminate. Moreover, you can also unroll the loop without syncing the entire block.
-
-The tmp namespace used beyond this point in this document holds a handful of template meta-programmed utilities to facilitate writing flexible and optimal code.
-
-tmp::static\_for is not just a constant folding within the optimizer but a variation of the language for loop, where the running index is a compile-time constant and is eligible for use in compile-time evaluated contexts.
-
-Consider the following code:
-**Following code does:** This code snippet appears to be part of a parallel computing or GPU programming context, where it performs a reduction operation. The `reduce_sum` function is used to sum elements within a specified partition of data. The `custom_partition` likely defines how the data is divided, and `workspace[group_offset]` and `input` are the data sources involved in the reduction. The comment indicates that only the first thread in each partition will return a valid result, which is a common pattern in parallel reductions to ensure that only one thread writes the final result of the reduction for each partition.
-
-
-```
-constexpr int size = 4;
-for (int i = 0 ; i < size ; ++i)
-{
-    printf("%d", i);
-}
-```
-
-This compiles to the following binaries:
-
-## LLVM Block
-**Following code does:** This code snippet appears to be part of a parallel computing operation, likely using CUDA or a similar framework for GPU programming. The code calculates a `partition_id` for a thread within a block by dividing the thread's rank by a constant `PartitionSize`. It then assigns a value `output` to an element in the `d_partition_reduced_vector` array at the index corresponding to this `partition_id`. The purpose is to organize or reduce data into partitions based on thread ranks within a block.
-
-
-```
-LLVM Block
-main:
-    push    rbx
-    lea      rbx, [rip +.L.str]
-    mov     rdi, rbx
-    xor     esi, esi
-    xor     eax, eax
-    call    printf@PLT
-    mov     rdi, rbx
-    mov     esi, 1
-    xor     eax, eax
-    call    printf@PLT
-    mov     rdi, rbx
-```
-
-(continues on next page)
-**Following code does:** It seems there is a formatting error in your request. The code snippet is labeled as Python, but it contains a placeholder that suggests it might be C++ code. Please provide the actual code snippet you would like me to analyze, and I'll be happy to help!
-
-
-```
-      mov     esi, 2
-      xor     eax, eax
-      call    printf@PLT
-      mov     rdi, rbx
-      mov     esi, 3
-      xor     eax, eax
-      call    printf@PLT
-      xor     eax, eax
-      pop     rbx
-      ret
-.L.str:
-     .asciz  "%d"
-      
- GCC
-```
-
-## GCC
-**Following code does:** The code snippet `<_C_>` appears to be incomplete or not a valid Python code. It does not represent any known Python syntax or construct. It might be a placeholder or a typo. Without additional context or surrounding code, it's not possible to determine its purpose or functionality.
-
-
-```
-  GCC
- .LC0:
-     .string "%d"
-  main:
-      push    rbx
-      xor     ebx, ebx
- .L2:
-      mov     esi, ebx
-      mov     edi, 0FFSET FLAT:.LC0
-      xor     eax, eax
-      add     ebx, 1
-      call    printf
-      cmp     ebx, 4
-      jne    .L2
-      xor     eax, eax
-      pop     rbx
-      ret
-
-  MSVC
-```
-
-## MSVC
-**Following code does:** This code snippet is part of a program that uses the HIP (Heterogeneous-Compute Interface for Portability) API to launch a cooperative kernel on a GPU. The cooperative kernel is likely designed to perform a reduction operation on a vector, as suggested by the variable names. The `hipLaunchCooperativeKernel` function is used to initiate the execution of the `vector_reduce_kernel` on the GPU, with `params` being an array of pointers to the data structures (`d_vector`, `d_block_reduced`, and `d_partition_reduced`) that the kernel will operate on. The cooperative groups API allows for more efficient synchronization and communication between threads within a GPU kernel.
-
-
-```
-  MSVC
-
-main     PROC
-      $LN12:
-      push    rbx
-      sub     rsp, 32
-      xor     ebx, ebx
-      npad    8
-  $LL4@main:
-      mov     edx, ebx
-      lea     rcx, OFFSET FLAT:'string'
-      call    printf
-      inc     ebx
-      cmp     ebx, 4
-      jl      SHORT $LL4@main
-      xor     eax, eax
-      add     rsp, 32
-      pop     rbx
-      ret     0
-  main    ENDP
-```
-
-(continued from previous page)
-
-LLVM unrolls the loop and compiles to a flat series of printf invocations, while both GCC and MSVC keep the loop intact, as visible from the compare ( cmp ) and the jump ( jne , jl ) instructions. LLVM code generation is identical to manually writing the unrolled loop:
-**Following code does:** The provided snippet appears to be incomplete and lacks any functional code. It only contains a comment line that reads "* For HIP". This suggests that the code might be related to or intended for use with HIP, which is a C++ runtime API and kernel language that allows developers to create portable applications that can run on AMD and NVIDIA GPUs. However, without additional context or code, it's not possible to determine any specific functionality or purpose.
-
-
-```
-printf("%d", 0);
-printf("%d", 1);
-printf("%d", 2);
-printf("%d", 3);
-```
-
-While various non-standard pragmas are available to hint or force the compiler to unroll the loop, we instead use template meta-programming to force feed the compiler the unrolled loop.
-**Following code does:** The code snippet `<_Bash_>` appears to be a placeholder or a tag indicating that a section of code written in the Bash scripting language should be inserted or is expected in that location. It does not perform any operations or have any functionality on its own. Instead, it likely serves as a marker for where Bash code should be included or referenced in a larger context, such as in documentation, a template, or a code generation tool.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?xml version="1.0" encoding="UTF-8" />
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        </?xml version="1.0" encoding="UTF-8" />
-```
-
-The most notable structural difference is that in the language for loop, the loop variable is given a name in the beginning, while in the static\_for utility, the loop variable is given a name in the end. An important bonus is that in the loop's body, you can use the running index i in contexts requiring constant expressions such as template arguments or inside if constexpr .
-
-tmp::static\_switch takes runtime value and runtime dispatches to a range of set of tabulated functions, where said value is a compile-time constant and is eligible for use in compile-time evaluated contexts.
-
-Consider the following code:
-**Following code does:** It seems there is a misunderstanding in the code snippet provided. The snippet `<_Haskell_>` does not represent valid Python code or any executable code in any programming language. It appears to be a placeholder or a tag indicating that Haskell code might be expected or referenced. If you intended to provide a Haskell code snippet, please share the correct code so I can help explain its purpose.
-
-
-```
-        Consider the following code:
-
-        int  warp_size  = device_props.warpSize;
-
-        switch  (warp_size)
-
-        {
-
-        case  32:
-
-            hipLaunchKernelGGL(kernel<32>, ...);
-
-            break;
-
-        case  64:
-
-            hipLaunchKernelGGL(kernel<64>, ...);
-
-            break;
-
-        }
-```
-
-In the preceding code, note the code repetition for all possible values of warp\_size , the code is prepared to handle. To avoid this, use tmp::static\_switch , as shown:
-**Following code does:** This code snippet appears to be a series of empty lines with a placeholder or invalid tag `<?>` in the middle. It doesn't perform any functional operation or have any meaningful purpose in its current form. It might be intended as a placeholder or template for further development, but as it stands, it doesn't execute any logic or serve a specific function.
-
-
-```
-  tmp::static_switch<std::array{32, 64}>(warp_size, [&]<int WarpSize>
-  {
-      hipLaunchKernelGGL(kernel<WarpSize>,...);
-  });
-```
-**Following code does:** The code snippet `<_Bash_>` appears to be a placeholder or a formatting artifact rather than actual executable code. It does not perform any operations or have any functionality as it stands. If this is meant to indicate a section where Bash code should be inserted, it would typically be replaced with actual Bash script content to perform specific tasks in a Unix-like shell environment.
-
-
-```
-
-t WarpSize>()
-```
-**Following code does:** This code snippet is a sequence of shell commands used to compile and link a C++ program that utilizes GPU resources with the HIP (Heterogeneous-Compute Interface for Portability) compiler, `hipcc`. 
-
-1. The first command compiles `hipDevice.cpp` into an object file `hipDevice.o` with GPU relocatable device code enabled (`-fgpu-rdc`).
-2. The second command creates a static library `libHipDevice.a` from the object file `hipDevice.o` using the `ar` archiving tool.
-3. The third command links the static library `libHipDevice.a` with another source file `test.cpp`, again with GPU relocatable device code enabled, and produces an executable `test.out`.
-
-Overall, this process compiles and links a GPU-accelerated application using HIP, organizing the code into a static library before creating the final executable.
-
-
-```
-
-        HIP Documentation, Release 6.1.40092
-
-
-        
-        -template<typename T, typename F>
-        +template<uint32_t WarpSize, typename T, typename F>
-        __global__ void kernel(
-           ...
-        )
-        {
-           ...
-        // Shared reduction
-        -for (uint32_t i = blockDim.x / 2; i!= 0; i /= 2)
-        +for (uint32_t i = blockDim.x / 2; i > WarpSize; i /= 2)
-        {
-            if (tid < i)
-                shared[tid] = op(shared[tid], shared[tid + i]);
-            __syncthreads();
-        }
-        +// Warp reduction
-        +tmp::static_for<WarpSize, tmp::not_equal<0>, tmp::divide<2>>([&]<int I>()
-        +{
-        +     if (tid < I)
-        +          shared[tid] = op(shared[tid], shared[tid + I]);
-        +#ifdef __HIP_PLATFORM_NVIDIA__
-        +     __syncwarp(0xffffffff >> (WarpSize - I));
-        +#endif
-        +});
-
-        Because HIP typically targets hardware with warp sizes of 32(NVIDIA GPUs and RDNA AMD GPUs) and 64 (CD!
-        AMD GPUs), portable HIP code must handle both. That is why instead of assuming a warp size of 32, make the w:
-        size a template argument of the kernel. This allows you to unroll the final loop using tmp::static_for in a paramet
-```
-
-Because HIP typically targets hardware with warp sizes of 32 (NVIDIA GPUs and RDNA AMD GPUs) and 64 (CDNA AMDGPUs), portable HIP code must handle both. That is why instead of assuming a warp size of 32, make the warp size a template argument of the kernel. This allows you to unroll the final loop using tmp::static\_for in a parametric way but still having the code read much like an ordinary loop.
-
-Promoting the warp size to being a compile-time constant also requires you to handle it similarly on the host-side. You can sandwich the kernel launch with tmp::static\_switch , promoting the snake-case run-time warp\_size variable to a camel-case compile-time constant WarpSize .
-**Following code does:** The code snippet `<_Cuda_>` appears to be a placeholder or a symbolic representation rather than actual executable Python code. In the context of programming, "Cuda" typically refers to NVIDIA's parallel computing platform and application programming interface (API) model, which allows developers to use a CUDA-enabled graphics processing unit (GPU) for general purpose processing. However, without additional context or actual code, it's not possible to determine the specific functionality or purpose of this placeholder.
-
-
-```
-<_C++_>
-```
-
-Note: Neither RDNA- nor CDNA-based AMD hardware provides guaranteed independent progress to lanes of the same warp. When targeting NVIDIA hardware, lanes of a warp might execute somewhat independently as long as the programmer assists the compiler using dedicated built-in functions. This feature is called Independent Thread Scheduling. The HIP headers don't expose the necessary warp primitives and their overloads.
-
-Portable applications can still tap into this feature with carefully #ifdef -ed code, but at this particular optimization level, it's a requirement. The code implicitly relies on the lockstep behavior of an ROCm wavefront, but CUDA warps don't share this property. You must synchronize all the active lanes of a warp to avoid a data race with some lanes progressing faster than others in the same warp.
-
-## 29.2.5 Unroll all loops
-
-While the previous step primarily aims to remove unnecessary syncing, it also unrolls the end of the loop. However, you could also force unrolling the first part of the loop. This saves a few scalar registers (values the compiler can prove to be uniform across warps).
-**Following code does:** The provided text appears to be a continuation marker from a previous page, indicating that the code snippet is incomplete. Without the actual code, it's not possible to determine its purpose or functionality. If you can provide the complete code snippet, I would be happy to help explain what it does.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <Linear                                                                                                                                                                                                        </Linear                                                                                                                                                                                                      <Linar                                                                                                                                                                                                        >                                                                                                                                                                                                        &Linear                                                                                                                                                                                                     
- 
-                                                                                                                                                                                                      <Lin                                                                                                                                                                                                        +                                                                                                                                                                                                        -                                                                                                                                                                                                        |                                                                                                                                                                                                        }                                                                                                                                                                                                        \
-                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       <L                                                                                                                                                                                                        1                                                                                                                                                                                                        0
-```
-
-Introducing yet another template argument for the kernel and moving from for to tmp::static\_for leads to the following two notable improvements:
-
-- Introducing new attribute \_\_launch\_bounds\_\_(BlockSize) to the kernel instructs the compiler that the kernel will only be launched using the designated block size. This implies that the launches of differing block sizes will fail. This allows the optimizer to enroll the blockDim.x variable in constant folding as well as get information about register usage.
-- Turning the block size into a compile-time constant allows you to statically allocate the shared memory.
-
-## 29.2.6 Communicate using warp-collective functions
-
-Shared memory provides a fast communication path within a block, however when performing reduction within the last warp, you can use faster means of communication, which is warp-collective or cross-lane functions. Instead of using the hardware-backed shared memory, you can directly copy between the local memory (registers) of each lane in a warp. This can be achieve using the shuffle functions.
-
-See how to use \_\_shfl\_down() , which is one of the most restrictive but also the most structured communication schemes.
-**Following code does:** The placeholder `<_SQL_>` suggests that this is not actual code but rather a placeholder indicating where SQL code would be inserted. Without specific SQL statements, it's not possible to determine the exact functionality. However, generally, SQL code is used for interacting with databases, which can include operations such as querying data, updating records, inserting new data, or deleting existing records. The high-level purpose of SQL code is to manage and manipulate data stored in a relational database.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        // Warp reduction
-```
-
-Using warp-collective functions for communication requires the control flow to be uniform across warps, as the name warp-collective implies. Therefore, you can see that the thread ID is being checked outside the loop, but the result is written inside due to variable scoping.
-
-## 29.2.7 Prefer warp communication over shared
-
-As mentioned in the previous step, communication between local memory is faster than shared memory. Instead of relying on the local memory only at the end of the tree-like reduction, a better approach is to turn the tree reduction inside out and perform multiple warp reductions in parallel on all active threads, thus communicating only their partial results through the shared memory.
-
-The kernel versions differ significantly enough to be described using a diff; use afresh instead.
-**Following code does:** The provided code snippet appears to be malformed or incomplete. It consists of a series of spaces and dashes followed by the text `--event:0` and `-event:0`. This does not represent valid or executable Python code. It seems more like a formatting error or a placeholder rather than a functional script. Without additional context or correction, it is not possible to determine a high-level purpose for this snippet.
-
-
-```
-        The kernel versions differ significantly enough to be described using a diff; use afresh instead.
-
-        template<uint32_t BlockSize,  uint32_t WarpSize,  typename  T,  typename  F>
-        __global__ __launch_bounds__(BlockSize)  void kernel(
-            T*  front,
-            T*  back,
-            F  op,
-            T zero_elem,
-            uint32_t  front_size)
-        {
-            // ...
-        }
-
-        The kernel estimate and the reduction factor as the comma as in variance access only the imlamantation diffar.
-```
-
-The kernel signature and the reduction factor are the same as in previous cases; only the implementation differs.
-**Following code does:** It seems that you've provided a single character `>` instead of a code snippet. Could you please provide the complete code so I can help explain its purpose?
-
-
-```
-static constexpr uint32_t WarpCount = BlockSize / WarpSize;
-
-__shared__ T shared[WarpCount];
-
-auto read_global_safe =
-    [&](const uint32_t i) { return i < front_size? front[i] : zero_elem; };
-auto read_shared_safe =
-    [&](const uint32_t i) { return i < WarpCount? shared[i] : zero_elem; };
-
-const uint32_t tid = threadIdx.x,
-                     bid = blockIdx.x,
-                     gid = bid * (blockDim.x * 2) + tid,
-                     wid = tid / WarpSize,
-                     lid = tid % WarpSize;
-
-// Read input from front buffer to local
-T res = op(read_global_safe(gid), read_global_safe(gid + blockDim.x));
-
-As we communicate the results of warps through shared memory, the same number of elements are required in the
-shared memory as warps within the block. Similar to how you can only launch kernels at block granularity. you can
-```
-
-As we communicate the results of warps through shared memory, the same number of elements are required in the shared memory as warps within the block. Similar to how you can only launch kernels at block granularity, you can only warp reduce with WarpSize granularity due to the collective nature of the cross-lane builtins. To address this, you can use read\_shared\_safe to pad overindexing by reading zero\_elem . Reading from global remains unaffected. // Perform warp reductions and communicate results via shared // for (uint32\_t ActiveWarps = WarpCount; // ActiveWarps != 0; // ActiveWarps = ActiveWarps != 1 ? // divide\_ceil(ActiveWarps, WarpSize) : // ActiveWarps = 0) tmp::static\_for&lt; WarpCount, tmp::not\_equal&lt;0&gt;, tmp::select&lt; tmp::not\_equal&lt;1&gt;, tmp::divide\_ceil&lt;WarpSize&gt;, tmp::constant&lt;0&gt;&gt;&gt;([&amp;]&lt; uint32\_t ActiveWarps&gt;() { if (wid &lt; ActiveWarps) { // Warp reduction tmp::static\_for&lt;WarpSize / 2, tmp::not\_equal&lt;0&gt;, tmp::divide&lt;2&gt;&gt;([&amp;]&lt; int Delta&gt;() { res = op(res, \_\_shfl\_down(res, Delta)); }); // Write warp result from local to shared if (lid == 0) shared[wid] = res; } \_\_syncthreads(); // Read warp result from shared to local res = read\_shared\_safe(tid); (continues on next page)
-
-(continued from previous page)
-**Following code does:** The code snippet is a command-line instruction that uses the `hipify-perl` tool to convert CUDA code into HIP (Heterogeneous-Compute Interface for Portability) code. The `--inplace` option indicates that the conversion should be done directly in the original files, modifying them in place rather than creating new output files. This is typically used to facilitate the migration of CUDA applications to run on AMD GPUs by translating CUDA-specific syntax and API calls to their HIP equivalents.
-
-
-```
-});
-
-// Write result from local to back buffer
-if(tid == 0)
-    back[bid] = res;
-```
-
-ActiveWarps iterates from WarpCount until it reaches 0 . Every iteration of ActiveWarps reduces the WarpSize . In cases where the partial result count isn't a divisor of ActiveWarps and you need to launch an extra warp, use tmp::divide\_ceil , which always rounds to positive infinity. The tertiary tmp::select is required because such division never reaches 0 , so you must terminate the loop after the last warp concludes.
-
-In each iteration, if the warp is active, which means it has at least a single valid input, it carries out a pass of warp reduction and writes output based on warp ID. Reading is carried out based on thread ID. Global output continues to be based on block ID.
-
-## 29.2.8 Amortize bookkeeping variable overhead
-
-The previous sections explained how to reduce register usage to improve occupancy. This allows more blocks to execute in parallel on all multiprocessors, leading to more global store/load latency to be hidden. Reducing the number of kernels in flight while still carrying out the same workload reduces the wastage of registers while loading and maintaining bookkeeping variables such as kernel indices.
-
-An example of this optimization is performing one binary op while loading input from global. Even though the operation is said to be carried out 'in flight', the two values are loaded into local memory (registers) before op is called.
-
-Amore general form of this optimization is wrapping most kernel logic in loops that carry out the workload of multiple kernel instances but require storing only a single instance of most of the bookkeeping logic. In code, this multiplicity factor is referred to via the ItemsPerThread compile-time constant, which is supplied by a template argument to allow for loop unrolling.
-
-This kernel variant utilizes another generally applicable utility known as hip::static\_array , which is a more restrictive wrapper over the builtin array than std::array , as it allows indexing only compile-time constants using the usual tuple-like template &lt;size\_t I&gt; auto get&lt;I&gt;(...) interface.
-
-Note: On a GPU, there is no stack, and the local memory is provisioned from the register file. This provisioning takes place statically. To paraphrase, the address range of a thread's local memory is determined at compile-time. When an array is defined and used in the local storage, the compiler can only maintain its storage in the register file as long as all accesses to the array are computable by the compiler at compile-time. It doesn't need to be a compile-time constant as long as the compiler can resolve the addresses of the accesses through constant folding or some other means. If the compiler fails to do so, the array will be backed by global memory, which is indicated by allocating a non-zero number of spill registers observable using static analysis tools. However, this is slower by the magnitude of multiple order. hip::static\_array via its hip::get&lt;&gt; interface ensures that no such spills occur.
-**Following code does:** This code snippet is a preprocessor directive used in C/C++ programming, specifically when working with the HIP (Heterogeneous-Compute Interface for Portability) framework. The `#ifdef __HIP_PLATFORM_AMD__` checks if the macro `__HIP_PLATFORM_AMD__` is defined, which indicates that the code is being compiled for AMD platforms using HIP-Clang. If this condition is true, the comment `// Compiled with HIP-Clang` is included in the code. This is typically used to conditionally compile code specific to AMD hardware when using the HIP framework.
-
-
-```
-_t  ItemsPerThread>
-```
-**Following code does:** This code snippet is a preprocessor directive used in a C/C++ program to conditionally compile code based on the target platform. Specifically, it checks if the code is being compiled for an NVIDIA platform using the HIP (Heterogeneous-Compute Interface for Portability) API. If the `__HIP_PLATFORM_NVIDIA__` macro is defined, it indicates that the code is being compiled with NVIDIA's CUDA compiler (`nvcc`). The comments suggest that the code could be using CUDA language extensions or be in a pass-through mode to an underlying host compiler, depending on the file type or compilation settings.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        --global__ static __launch_bounds__(BlockSize) void kernel(...)
-```
-
-The kernel now has three compile-time configurable parameters. The only part of the kernel that changes depends on how you load data from global and perform the binary operation on those loaded values. So, the following step to read input from front buffer to global is now split into two steps: reading ``ItemsPerThread` &lt;reading-items&gt;`and processing ``ItemsPerThread` &lt;processing-items&gt;`.
-**Following code does:** This code snippet is a preprocessor directive used in C/C++ programming to check if the code is being compiled with NVIDIA's CUDA Compiler (nvcc). The `#ifdef __CUDACC__` checks if the `__CUDACC__` macro is defined, which indicates that the CUDA language extensions are enabled. This is typically used to conditionally include or exclude code that is specific to CUDA, allowing the same source file to be compiled with or without CUDA support.
-
-
-```
-<_C_>
-```
-
-## 29.2.8.1 Reading ItemsPerThread
-
-The change to reading happens inside read\_global\_safe :
-**Following code does:** The code snippet you provided appears to be incomplete or malformed. It does not represent valid Python code, as it contains a semicolon at the beginning and a misspelled or incorrectly formatted word "enab1ed" (with a numeral '1' instead of the letter 'l'). Without additional context or correction, it's not possible to determine its high-level purpose.
-
-
-```
-        The change to reading happens inside read_global_safe:
-        auto  read_global_safe = [&](const  int32_t  i)  -> hip::static_array<T,  ItemsPerThread>
-        {
-            return  [&]<int32_t...  I>(std::integer_sequence<int32_t,  I...>)
-            {
-                if(i + ItemsPerThread < front_size)
-                        return hip::static_array<T,  ItemsPerThread>{
-                              front[i + I]...
-                        };
-                else
-                        return hip::static_array<T,  ItemsPerThread>{
-                              (i + I < front_size? front[i + I] : zero_elem)...
-                        };
-            }(std::make_integer_sequence<int32_t,  ItemsPerThread>());
-        };
-
-        Note that each array element is being loaded consecutively without the flexibility of a configurable ItemsPerThread
-```
-
-Note that each array element is being loaded consecutively without the flexibility of a configurable ItemsPerThread property. This is morally equivalent to:
-**Following code does:** This code snippet is a preprocessor directive used in the context of HIP (Heterogeneous-Compute Interface for Portability), which is a C++ runtime API that allows developers to write portable code to run on AMD and NVIDIA GPUs. The line `#if __HIP__DEVICE__COMPILE__` is a conditional compilation directive that checks if the code is being compiled for a GPU device. If the condition is true, the code following this directive will be included in the compilation process for the device. This is typically used to separate code that should only be executed on the GPU from code that runs on the host (CPU).
-
-
-```
-T arr[4] = {
-    front[gid + 0],
-    front[gid + 1],
-    front[gid + 2],
-    front[gid + 3]
-}
-```
-
-This is exactly what's happening in the front[i + I]... fold-expression. However, this can only be issued if the entire read operates on real input without padding using zero\_elem . If some reads over-index the input, the read turns into:
-**Following code does:** This code snippet is a preprocessor directive used in CUDA programming, which is a parallel computing platform and application programming interface model created by NVIDIA. The directive `#if (__CUDA_ARCH__ >= 130)` checks if the code is being compiled for a CUDA architecture version that is 1.3 or higher. If the condition is true, the code following this directive will be included in the compilation process. This is typically used to ensure that certain code segments are only compiled for specific GPU architectures that support the required features or capabilities.
-
-
-```
-T arr[4] = {
-    i + 0 < front_size? front[i + 0] : zero_elem,
-    i + 1 < front_size? front[i + 1] : zero_elem,
-    i + 2 < front_size? front[i + 2] : zero_elem,
-    i + 3 < front_size? front[i + 3] : zero_elem
-}
-```
-
-This makes it easier for the compiler to recognize vector loads from global. As the performance at large is dominated by how you move the data, it's only natural to utilize dedicated instructions to move more data with less binary. This is evident by the huge performance improvement when loading two values per thread. For more information, see the compiler explorer to learn how loading for AMD (both RDNA and CDNA) compiles to global\_load\_dwordx4 , where x4 denotes the 4-vector variant of the instruction.
-
-Note: Note that read\_global\_safe , which used to take an uint32\_t as the index type, now takes a signed integer. When indexing an array with unsigned integers, the compiler has to handle integer overflows, as the C/C++ standards defined them. It might happen that some part of the vector load indices overflow, thus resulting in a non-contiguous
-
-read. If you change the previously linked code to use an unsigned integer as the thread ID, the compiler won't emit a vector load. Signed integer overflow is an undefined behavior, and hence, unknown to the optimizer. To convey the absence of overflow to the compiler with unsigned indices, add \_\_builtin\_assume(gid + 4 &gt; gid) , or the more portable [[assume]](gid + 4 &gt; gid) , once amdclang++ supports it.
-
-read\_global\_safe implementation is an Immediately Invoked Lambda Expression (IILE), because ItemsPerThread is an integer value, while you need a compile-time iota -like sequence of integers as a pack for the fold-expressions to expand on. This can only occur as part of template argument deduction on the IILE.
-
-## 29.2.8.2 Processing ItemsPerThread
-
-Once the kernel reads ItemsPerThread number of inputs to local, it immediately reduces them to a scalar. There is no reason to propagate the input element multiplicity to the warp reduction phase.
-**Following code does:** This code snippet appears to be a comment rather than executable code. It suggests that the programming environment or language being used supports the use of "doubles," which typically refers to double-precision floating-point numbers. This comment might be indicating that the code or system can handle numerical data types that require more precision than single-precision floating-point numbers.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?>                                                                                                                                                                                                        </?>
-```
-
-## 29.2.9 Two-pass reduction
-
-Alter kernel launch and input fetching such that no more blocks are launched than what a subsequent kernel launch's single block can conveniently reduce, while performing multiple passes of input reading from global and combining their results before engaging in the end game tree-like reduction.
-
-With this method, you can save at least one to two kernel launches for large inputs.
-
-## 29.2.10 Global data share
-
-Warning: This modification can only be executed on AMD hardware.
-
-Perform the first step of the two-pass reduction, but in the end, instead of writing to global and reading it back in a subsequent kernel, write the partial results to the Global Data Share (GDS). This is an N+1 th shared memory that is accessed by all multiprocessors and is also on-chip memory.
-
-Note: The API doesn't guarantee the order in which blocks are scheduled even though all GPUs schedule them in the same monotonically increasing order of block ids. Relying on this implicitly, the last block of a grid is in the optimal position to observe the side effects of all other blocks (using spinlocks or other methods) without occupying a multiprocessor for longer than necessary.
-
-Without launching a second kernel, you can make the last block collect the results of all other blocks from GDS by implicitly exploiting the scheduling behavior or relying on another AMD-specific feature called Global Wave Sync (GWS) to merge them for a final tree-like reduction.
-
-Note: GDS and GWS are reserved runtime features that the HIP API doesn't cover. Invoking these functionalities requires inline AMDGCN assembly. Moreover, the fact that the runtime doesn't virtualize the GDS, imposes further restrictions on concurrent scheduling of other kernels.
-
-## 29.3 Conclusion
-
-Optimizing code on GPUs, like on any other architecture, requires careful consideration and balancing of resources and costs of various operations to obtain optimal performance. This document explored optimizing reductions much beyond the territory of diminishing returns. This approach introduced multiple optimization techniques and discussed opportunities.
-
-The document focused on reductions when an entire device participates in it. Still, the choice of optimal compile-time constants or even the algorithm itself might not be optimal when its multiple blocks participate in multiple parallel reductions or when each thread performs its reduction. However, when multiple devices participate in the same reduction, other aspects must be considered.
-
-Most solutions, including the ones covered in this document, are given to the end users in a turnkey fashion via algorithm primitive libraries. These solutions might not be the fastest in all cases, but they are close to being the gold standard for carrying out certain operations as reasonably as possible.
-
-CHAPTER
-
-## THIRTY
-
-## COOPERATIVE GROUPS
-
-This tutorial demonstrates the basic concepts of cooperative groups in the HIP (Heterogeneous-computing Interface for Portability) programming model and the most essential tooling supporting it. This topic also reviews the commonalities of heterogeneous APIs. Familiarity with the C/C++ compilation model and the language is assumed.
-
-## 30.1 Prerequisites
-
-To follow this tutorial, you'll need properly installed drivers and a HIP compiler toolchain to compile your code. Because ROCm HIP supports compiling and running on Linux and Microsoft Windows with AMD and NVIDIA GPUs, review the HIP development package installation before starting this tutorial. For more information, see Install HIP .
-
-## 30.2 Simple HIP Code
-
-To become familiar with heterogeneous programming, review the SAXPY tutorial and the first HIP code subsection. Compiling is also described in that tutorial.
-
-## 30.3 Tiled partition
-
-You can use tiled partition to calculate the sum of partition\_size length sequences and the sum of result\_size / BlockSize length sequences. The host-side reference implementation is the following:
-**Following code does:** This code snippet is a conditional check to determine if the hardware architecture supports double-precision floating-point operations. The commented-out line `//#if (__CUDA_ARCH__ >= 130)` is a non-portable way to check for this support in CUDA, which is specific to NVIDIA GPUs. The active line `if __HIP_ARCH_HAS_DOUBLES__` is a portable way to perform a similar check in HIP, which is a framework designed to run on both NVIDIA and AMD GPUs. If the condition is true, it indicates that the architecture supports double-precision operations, and the code within the block can safely use double-precision data types.
-
-
-```
-    You can use ued partition to calculate the sum or partition_size length sequences and the sum or result_size/
-    BlockSize length sequences. The host-side reference implementation is the following:
-    
-    // Host-side function to perform the same reductions as executed on the GPU
-    std::vector<unsigned int> ref_reduced(const unsigned int          partition_size,
-                                                   std::vector<unsigned int> input)
-    {
-        const unsigned int          input_size  = input.size();
-        const unsigned int          result_size = input_size / partition_size;
-        std::vector<unsigned int> result(result_size);
-
-        for(unsigned int i = 0; i < result_size; i++)
-        {
-            unsigned int partition_result = 0;
-            for(unsigned int j = 0; j < partition_size; j++)
-            {
-                partition_result += input[partition_size * i + j];
-            }
-                                                                                                                                                                                                         (continues on next page)
-```
-
-(continues on next page)
-**Following code does:** This code snippet is querying the properties of a GPU device using the HIP (Heterogeneous-Compute Interface for Portability) API. It retrieves the properties of a specified device and checks if the device supports shared 32-bit integer atomic operations. The commented-out line suggests an alternative, non-portable way of checking device capabilities based on major and minor version numbers, but the actual code uses a more portable method by directly querying the `hasSharedInt32Atomics` feature of the device architecture. If the device supports this feature, the code within the conditional block (not shown) would execute.
-
-
-```
-            result[i] = partition_result;
-        }
-
-        return result;
-    }
-```
-
-## 30.3.1 Device-side code
-
-To calculate the sum of the sets of numbers, the tutorial uses the shared memory-based reduction on the device side. The warp level intrinsics usage is not covered in this tutorial, unlike in the reduction tutorial. x input variable is a shared pointer, which needs to be synchronized after every value change. The thread\_group input parameter can be thread\_block\_tile or thread\_block because the thread\_group is the parent class of these types. The val are the numbers to calculate the sum of. The returned results of this function return the final results of the reduction on thread ID 0 of the thread\_group , and for every other thread, the function results are 0.
-**Following code does:** The code snippet is a command-line instruction that uses the `hipconfig` tool with the `--cxx_config` option. `hipconfig` is a utility associated with the HIP (Heterogeneous-Compute Interface for Portability) framework, which is used for developing applications that can run on both AMD and NVIDIA GPUs. The `--cxx_config` option specifically retrieves and displays the C++ compiler configuration settings used by HIP. This information is useful for developers to understand or verify the compiler settings being applied in their HIP-based projects.
-
-
-```
-        The warp level intrinsics usage is not covered in this tutorial, unlike in the reduction tutorial. x input variable is a
-        shared pointer, which needs to be synchronized after every value change. The thread_group input parameter can be
-        thread_block_tile or thread_block because the thread_group is the parent class of these types. The val are
-        the numbers to calculate the sum of. The returned results of this function return the final results of the reduction on
-        thread ID 0 of the thread_group, and for every other thread, the function results are 0.
-
-        /// \brief Summation of `unsigned int val`s in `thread_group g` using shared memory `x`
-        __device__ unsigned int reduce_sum(thread_group g, unsigned int* x, unsigned int val)
-    {
-            // Rank of this thread in the group
-            const unsigned int group_thread_id = g.thread_rank();
-
-            // We start with half the group size as active threads
-            // Every iteration the number of active threads halves, until we processed all values
-            for(unsigned int i = g.size() / 2; i > 0; i /= 2)
-            {
-                // Store value for this thread in a shared, temporary array
-                x[group_thread_id] = val;
-
-                // Synchronize all threads in the group
-                g.sync();
-
-                // If our thread is still active, sum with its counterpart in the other half
-                if(group_thread_id < i)
-                {
-                    val += x[group_thread_id + i];
-                }
-
-                // Synchronize all threads in the group
-                g.sync();
-            }
-
-            // Only the first thread returns a valid value
-            if(g.thread_rank() == 0)
-                return val;
-            else
-                return 0;
-    }
-
-        The reduce_sum device function is reused to calculate the block and custom partition sum of the input numbers. The
-        kernel has three sections:
-
-        1. Initialization of the reduction function variables.
-```
-
-The reduce\_sum device function is reused to calculate the block and custom partition sum of the input numbers. The kernel has three sections:
-
-1. Initialization of the reduction function variables.
-
-(continued from previous page)
-
-2. The reduction of thread block and store the results in global memory.
-3. The reduction of custom partition and store the results in global memory.
-
-## 30.3.1.1 1. Initialization of the reduction function variables
-
-In this code section, the shared memory is declared, the thread\_block\_group and custom\_partition are defined, and the input variables are loaded from global memory.
-**Following code does:** The code snippet appears to be a fragment of a command or configuration related to compiling or building software that uses the HIP (Heterogeneous-Compute Interface for Portability) platform. Specifically, it includes a compiler definition `-D___HIP_PLATFORM_AMD___`, which indicates that the target platform is AMD, and an include path `-I/home/user1/hip/include`, which specifies where to find the HIP header files during compilation. This setup is typically used in environments where code is being prepared to run on AMD GPUs using HIP.
-
-
-```
-
-
-in this code section, the shared memory is declared, the thread_block_group and custom_partition are define
-input variables are loaded from global memory.
-
-// threadBlockGroup consists of all threads in the block
-thread_block thread_block_group = this_thread_block();
-
-// Workspace array in shared memory required for reduction
-__shared__ unsigned int workspace[2048];
-
-unsigned int output;
-
-// Input to reduce
-const unsigned int input = d_vector[thread_block_group.thread_rank()];
-
-//...
-
-// Every custom_partition group consists of 16 threads
-thread_block_tile<PartitionSize> custom_partition
-           = tiled_partition<PartitionSize>(thread_block_group);
-
-
-
-as a 2 - 2 The read-line of thread block
-```
-
-## 30.3.1.2 2. The reduction of thread block
-
-In this code section, the sum is calculated on thread\_block\_group level, then the results are stored in global memory.
-**Following code does:** This code snippet is a Makefile command that appends additional preprocessor flags to the `CPPFLAGS` variable. It uses the `hipconfig` tool, which is part of the HIP (Heterogeneous-Compute Interface for Portability) framework, to generate the necessary preprocessor configuration flags for compiling HIP code. The `$(shell ...)` function executes the `hipconfig --cpp_config` command and captures its output, which is then added to `CPPFLAGS`. This setup is typically used to ensure that the correct compiler flags are used when building applications that utilize HIP for GPU programming.
-
-
-```
-// Perform reduction
-output = reduce_sum(thread_block_group, workspace, input);
-
-// Only the first thread returns a valid value
-if(thread_block_group.thread_rank() == 0)
-{
-    d_block_reduced_vector[0] = output;
-}
-```
-
-## 30.3.1.3 3. The reduction of custom partition
-
-In this code section, the sum is calculated on the custom partition level, then the results are stored in global memory. The custom partition is a partial block of the thread block, it means the reduction calculates on a shorter sequence of input numbers than at the thread\_block\_group case.
-**Following code does:** The code snippet you provided appears to be incomplete or malformed, as it only contains a closing parenthesis `)`. Without additional context or surrounding code, it is not possible to determine its purpose or functionality.
-
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        // Perform reduction                                                                                                                                                                                                        }
-                                                                                                                                                                                                      
-output = reduce_sum(custom_partition, &workspace[group_offset], input);
-
-                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       // Only the first thread in each partition returns a valid value                                                                                                                                                                                                        \
-                                                                                                                                                                                                       \
-
-                                                                                                                                                                                                       \
-```
-
-(continued from previous page)
-**Following code does:** The code snippet `<_SQL_>` appears to be a placeholder or a tag indicating that the actual SQL code is not provided. In this context, it suggests that the code is related to SQL (Structured Query Language), which is used for managing and manipulating relational databases. Without the actual SQL code, it's not possible to determine the specific operations or queries being performed. The placeholder might be used in documentation, templates, or code generation tools to signify where SQL code should be inserted or processed.
-
-
-```
-        const unsigned int partition_id           = thread_block_group.thread_rank() /\__
-        ~PartitionSize;
-        d_partition_reduced_vector[partition_id] = output;
-    }
-```
-
-## 30.3.2 Host-side code
-
-On the host-side, the following steps are done in the example:
-
-1. Confirm the cooperative group support on AMD GPUs.
-2. Initialize the cooperative group configuration.
-3. Allocate and copy input to global memory.
-4. Launch the cooperative kernel.
-5. Save the results from global memory.
-6. Free the global memory.
-
-Only the first, second and fourth steps are important from the cooperative groups aspect, that's why those steps are detailed further.
-
-## 30.3.2.1 1. Confirm the cooperative group support on AMD GPUs
-
-Not all AMD GPUs support cooperative groups. You can confirm support with the following code:
-**Following code does:** It seems there is a formatting error in your request. The code snippet is labeled as Python, but it contains a placeholder that suggests it should be C++ code. Please provide the correct code snippet or clarify the language so I can assist you accurately.
-
-
-```
-<_C++_>
-```
-
-## 30.3.2.2 2. Initialize the cooperative group configuration
-
-In the example, there is only one block in the grid, and the threads\_per\_block must be dividable with partition\_size .
-**Following code does:** This code snippet is part of a GPU programming workflow using HIP, a C++ runtime API and kernel language that allows developers to write portable code for AMD and NVIDIA GPUs. The code performs the following high-level tasks:
-
-1. **Initialization**: It initializes two arrays, `A` and `B`, where `A` is filled with negative indices and `B` is initialized to zero.
-
-2. **Memory Allocation**: It allocates memory on the GPU for the array `Ad` using `hipMalloc`.
-
-3. **Data Transfer to GPU**: It copies the contents of array `A` from the host (CPU) to a symbol on the device (GPU) using `hipMemcpyToSymbol`.
-
-4. **Kernel Launch**: It launches a GPU kernel named `Get` with a specific grid and block configuration to perform operations on the data stored in `Ad`.
-
-5. **Data Transfer to Host**: It copies the results from the device array `Ad` back to the host array `B` using `hipMemcpy`.
-
-6. **Validation**: It checks if the contents of arrays `A` and `B` are equal, asserting that the GPU computation was performed correctly.
-
-7. **Output**: If the assertion passes, it prints "Passed" to indicate successful execution and validation of the GPU operations.
-
-Overall, this code tests the correctness of a GPU computation by comparing the results with expected values.
-
-
-```
-<_C_>
-```
-
-## 30.3.2.3 4. Launch the kernel
-
-The kernel launch is done with the hipLaunchCooperativeKernel of the cooperative groups API.
-**Following code does:** This code snippet demonstrates the allocation of memory on both the device (GPU) and the host (CPU) using HIP, a C++ runtime API for GPU programming. It first allocates memory on the device for a double pointer using `hipMalloc` and retrieves its attributes with `hipPointerGetAttributes`, which would indicate that the memory type is `hipMemoryTypeDevice`. Then, it allocates memory on the host using `hipHostMalloc` for another double pointer and again retrieves its attributes, which would indicate that the memory type is `hipMemoryTypeHost`. The comments suggest that the code is checking the type of memory allocated (device vs. host). The last line seems to be incomplete and unrelated to the memory operations shown.
-
-
-```
-        The kernel launch is done with the hipLaunchCooperativeKernel of the cooperative groups API.
-        void* params[] = {&d_vector,  &d_block_reduced,  &d_partition_reduced};
-        // Launching kernel from host.
-        HIP_CHECK(hipLaunchCooperativeKernel(vector_reduce_kernel<partition_size>,
-```
-
-## 30.4 Conclusion
-
-With cooperative groups, you can easily use custom partitions to create custom tiles for custom solutions. You can find the complete code at cooperative groups ROCm example.
-
-## CHAPTER
-
-## THIRTYONE
-
-## LICENSE
-
-Copyright © 2008 - 2024 Advanced Micro Devices, Inc.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-## INDEX
-
-| C                                                                                                           | hipArrayCreate ( C++ function ), 183                                                                        |    |     |      |     |          |
-|-------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------|----|-----|------|-----|----------|
-| cooperative_groups::coalesced_group class ), 237                                                            | C++ hipArrayDestroy ( C++ function ), 183 hipArrayGetDescriptor ( C++ function ), 185 ( C++ function ), 185 | (  |     |      |     |          |
-| cooperative_groups::grid_group ( C++ class ), 234                                                           | hipArrayGetInfo hipCreateSurfaceObject ( C++ function ), 133                                                |    |     |      |     |          |
-| cooperative_groups::multi_grid_group ( C++                                                                  | ( C++ function ), 197                                                                                       |    |     |      |     |          |
-| class ), 234 cooperative_groups::thread_block ( C++                                                         | ), hipDestroyExternalMemory ( C++ function ), 196                                                           |    |     |      |     |          |
-| class 234                                                                                                   | hipDestroyExternalSemaphore hipDestroySurfaceObject ( C++ function ), 133 C++ function                      |    |     |      |     |          |
-| cooperative_groups::thread_block_tile ( C++ class ), 234                                                    | hipDeviceCanAccessPeer ( ), 163 hipDeviceDisablePeerAccess ( C++ function ), 164 ( C++ function ), 163      |    |     |      |     |          |
-| cooperative_groups::thread_block_tile::all ( C++ function ), 236 cooperative_groups::thread_block_tile::any | hipDeviceEnablePeerAccess hipDeviceGetStreamPriorityRange ( C++ function ), 148                             |    |     |      |     |          |
-| ( C++ function ), 236                                                                                       | hipDrvMemcpy3D ( C++ function ), 192                                                                        |    |     |      |     |          |
-| cooperative_groups::thread_block_tile::ballot                                                               | hipDrvMemcpy3DAsync ( C++ function ), 192                                                                   |    |     |      |     |          |
-|                                                                                                             | hipDrvPointerGetAttributes ( C++ function ), 166                                                            |    |     |      |     |          |
-| ( C++ function ), 236                                                                                       |                                                                                                             |    |     |      |     |          |
-| cooperative_groups::thread_block_tile::match_all                                                            | hipExternalMemoryGetMappedBuffer ( C++ func- tion ), 196                                                    |    |     |      |     |          |
-| ( C++ function ), 237 cooperative_groups::thread_block_tile::match_any                                      | hipExternalMemoryGetMappedMipmappedArray ( C++ function ), 197 hipExtMallocWithFlags ( C++ function ), 167  |    | 236 | ( ), | C++ | function |
-| cooperative_groups::thread_block_tile::meta_group_rank ( C++ function ), 235                                | hipExtStreamCreateWithCUMask ( C++function ), 151 hipExtStreamGetCUMask ( C++ function ), 152               |    |     |      |     |          |
-|                                                                                                             | hipFree ( C++ function ), 171 hipFreeArray ( C++ function ), 184                                            |    |     |      |     |          |
-| cooperative_groups::thread_block_tile::meta_group_size ( C++ function ), 235                                | hipFreeAsync                                                                                                |    |     |      |     |          |
-| cooperative_groups::thread_block_tile::shfl ( C++ function ), 235                                           |                                                                                                             |    |     |      |     |          |
-|                                                                                                             | ( C++ function ), 154                                                                                       |    |     |      |     |          |
-| cooperative_groups::thread_block_tile::shfl_down                                                            |                                                                                                             |    |     |      |     |          |
-| ( C++ function ), 235                                                                                       | hipFreeHost ( C++ function ), 172 hipGetProcAddress ( C++ function ), 176                                   |    |     |      |     |          |
-| cooperative_groups::thread_block_tile::shfl_up                                                              | hipGetSymbolAddress ( C++ function ), 176, 193 ( C++ function ), 176, 193                                   |    |     |      |     |          |
-| ( C++ function ), 235                                                                                       | hipHostAlloc ( C++ function ), 168 hipHostFree ( C++ function ), 172                                        |    |     |      |     |          |
-| ( C++ function ), 236                                                                                       | ( C++ function ),                                                                                           |    |     |      |     |          |
-| cooperative_groups::thread_block_tile::sync ( C++ function ), 235                                           | 169 ( C++ function ), 169                                                                                   |    |     |      |     |          |
-| cooperative_groups::thread_block_tile::thread_rank ( C++ function ), 235 ),                                 | ( C++ function ), 169                                                                                       |    |     |      |     |          |
-| cooperative_groups::thread_group ( C++ class                                                                | ( C++ function ), 170 ( C++ function ),                                                                     |    |     |      |     |          |
-| 234                                                                                                         | 196 ( C++ function ),                                                                                       |    |     |      |     |          |
-|                                                                                                             | ( C++ function ), 166, 194                                                                                  |    |     |      |     |          |
-| H                                                                                                           | hipMalloc hipMalloc3D                                                                                       |    |     |      |     |          |
-|                                                                                                             | ( C++ function ), 184                                                                                       |    |     |      |     |          |
-| hipArray3DCreate ( C++ function ), 183                                                                      |                                                                                                             |    |     |      |     |          |
-| 185                                                                                                         | hipMalloc3DArray ( C++ function ),                                                                          |    |     |      |     |          |
-| hipArray3DGetDescriptor ( C++ function ),                                                                   |                                                                                                             |    |     |      |     |          |
-|                                                                                                             | 195                                                                                                         |    |     |      |     |          |
-|                                                                                                             | 184                                                                                                         |    |     |      |     |          |
-|                                                                                                             | hipImportExternalSemaphore                                                                                  |    |     |      |     |          |
-|                                                                                                             | hipImportExternalMemory                                                                                     |    |     |      |     |          |
-|                                                                                                             | hipHostMalloc ( C++ function ), 168, 194 hipHostRegister hipHostUnregister                                  |    |     |      |     |          |
-|                                                                                                             | hipHostGetDevicePointer hipHostGetFlags                                                                     |    |     |      |     |          |
-|                                                                                                             | hipGetSymbolSize                                                                                            |    |     |      |     |          |
-|                                                                                                             | cooperative_groups::thread_block_tile::shfl_xor                                                             |    |     |      |     |          |
-
-| hipMallocArray ( C++ function ), 182 ( C++ function ), 152,                                |
-|--------------------------------------------------------------------------------------------|
-| 153 hipMallocFromPoolAsync ( C++ function ), 153, 160                                      |
-| hipMallocHost ( C++ function ), 167                                                        |
-| hipMallocManaged ( C++ function ), 247, 249                                                |
-| hipMallocPitch ( C++ function ), 170                                                       |
-| hipMemAddressFree ( C++ function ), 251                                                    |
-| hipMemAddressReserve ( C++ function ), 251                                                 |
-| hipMemAdvise ( C++ function ), 247                                                         |
-| hipMemAllocHost ( C++ function ), 167                                                      |
-| hipMemAllocPitch ( C++ function ), 171                                                     |
-| hipMemcpy ( C++ function ), 172                                                            |
-| hipMemcpy2D ( C++ function ), 186                                                          |
-| hipMemcpy2DAsync ( C++ function ), 187                                                     |
-| hipMemcpy2DFromArray ( C++ function ), 190                                                 |
-| hipMemcpy2DFromArrayAsync ( C++ function ), 190                                            |
-| hipMemcpy2DToArray ( C++ function ), 188                                                   |
-| hipMemcpy2DToArrayAsync ( C++ function ), 188                                              |
-| hipMemcpy3D ( C++ function ), 191                                                          |
-| hipMemcpy3DAsync ( C++ function ), 192                                                     |
-| hipMemcpyAsync ( C++ function ), 178                                                       |
-| hipMemcpyAtoH ( C++ function ), 191                                                        |
-| hipMemcpyDtoD ( C++ function ), 174                                                        |
-| hipMemcpyDtoDAsync ( C++ function ), 175 hipMemcpyDtoH ( C++ function ), 174               |
-| hipMemcpyDtoHAsync ( C++ function ), 175                                                   |
-| hipMemcpyFromArray ( C++ function ), 189                                                   |
-| hipMemcpyFromSymbol ( C++ function ),                                                      |
-| 177,                                                                                       |
-| 194 hipMemcpyFromSymbolAsync ( C++ function ), 178, 194                                    |
-| hipMemcpyHtoA ( C++ function ), 191                                                        |
-| hipMemcpyHtoD ( C++ function ), 173 hipMemcpyHtoDAsync ( C++ function ),                   |
-| hipMemcpyParam2D ( C++ function ),                                                         |
-| 174 186                                                                                    |
-| hipMemcpyParam2DAsync ( C++ function ),                                                    |
-| 187 hipMemcpyToArray ( C++ function ), 189 ( C++ function ), 177,                          |
-| hipMemcpyToSymbol 193 hipMemcpyToSymbolAsync ( C++ function ), 193                         |
-| 177, ( C++ function ), 173                                                                 |
-| hipMemcpyWithStream hipMemCreate ( C++ function ), 252                                     |
-| hipMemExportToShareableHandle (                                                            |
-| C++ function 252 ( C++ function ), 252                                                     |
-| hipMemGetAddressRange ( C++ function ), 164 hipMemGetAllocationGranularity ( C++           |
-| function 253 hipMemGetAllocationPropertiesFromHandle                                       |
-| ( C++ function ), 253                                                                      |
-| hipMemGetInfo ( C++ function ), 182 hipMemImportFromShareableHandle ( C++ function         |
-| 253 hipMemMap ( C++ function ), 254 hipMemMapArrayAsync ( C++ function ), hipMemPoolCreate |
-| 254 ( C++ function ), 158                                                                  |
-| hipMemPoolDestroy 159                                                                      |
-| ( C++ function ),                                                                          |
-
-C++ function
-
-(
-
-), 162
-
-| hipMemPoolExportPointer hipMemPoolExportToShareableHandle ( C++                          | func-                                                                                    |
-|------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------|
-| tion ), 160                                                                              | tion ), 160                                                                              |
-| hipMemPoolGetAccess ( C++ function ), 158 hipMemPoolGetAttribute ( C++ function ), 156   | hipMemPoolGetAccess ( C++ function ), 158 hipMemPoolGetAttribute ( C++ function ), 156   |
-| hipMemPoolImportFromShareableHandle function ), 161                                      | ( C++                                                                                    |
-| hipMemPoolImportPointer ( C++ function ), 162 hipMemPoolSetAccess ( C++ function ), 157  | hipMemPoolImportPointer ( C++ function ), 162 hipMemPoolSetAccess ( C++ function ), 157  |
-| hipMemPoolSetAttribute ( C++ function ), 156                                             | hipMemPoolSetAttribute ( C++ function ), 156                                             |
-| hipMemPoolTrimTo ( C++ function ), 155                                                   | hipMemPoolTrimTo ( C++ function ), 155                                                   |
-| hipMemPrefetchAsync ( C++ function ), 247                                                | hipMemPrefetchAsync ( C++ function ), 247                                                |
-| hipMemPtrGetInfo ( C++ function ), 182                                                   | hipMemPtrGetInfo ( C++ function ), 182                                                   |
-| hipMemRangeGetAttribute ( C++ function ), 248                                            | hipMemRangeGetAttribute ( C++ function ), 248                                            |
-| hipMemRangeGetAttributes ( C++ function ), 248                                           | hipMemRangeGetAttributes ( C++ function ), 248                                           |
-| hipMemRelease ( C++ function ), 255                                                      | hipMemRelease ( C++ function ), 255                                                      |
-| hipMemRetainAllocationHandle ( C++function ), 255                                        | hipMemRetainAllocationHandle ( C++function ), 255                                        |
-| hipMemset ( C++ function ), 179                                                          | hipMemset ( C++ function ), 179                                                          |
-| hipMemset2D ( C++ function ), 181                                                        | hipMemset2D ( C++ function ), 181                                                        |
-| hipMemset2DAsync ( C++ function ), 181                                                   | hipMemset2DAsync ( C++ function ), 181                                                   |
-| hipMemset3D ( C++ function ), 181                                                        | hipMemset3D ( C++ function ), 181                                                        |
-| hipMemset3DAsync ( C++ function ), 182                                                   | hipMemset3DAsync ( C++ function ), 182                                                   |
-| hipMemSetAccess ( C++ function ), 255                                                    | hipMemSetAccess ( C++ function ), 255                                                    |
-| hipMemsetAsync ( C++ function ), 180                                                     | hipMemsetAsync ( C++ function ), 180                                                     |
-| hipMemsetD16 ( C++ function ), 180 hipMemsetD16Async ( C++ function ), 180               | hipMemsetD16 ( C++ function ), 180 hipMemsetD16Async ( C++ function ), 180               |
-| hipMemsetD32 ( C++ function ), 180                                                       | hipMemsetD32 ( C++ function ), 180                                                       |
-| hipMemsetD32Async ( C++ function ), 181                                                  | hipMemsetD32Async ( C++ function ), 181                                                  |
-| hipMemsetD8 ( C++ function ), 179                                                        | hipMemsetD8 ( C++ function ), 179                                                        |
-| hipMemsetD8Async ( C++ function ), 179                                                   | hipMemsetD8Async ( C++ function ), 179                                                   |
-| hipMemUnmap ( C++ function ), 256                                                        | hipMemUnmap ( C++ function ), 256                                                        |
-| hipModuleGetGlobal ( C++ function ), 176                                                 | hipModuleGetGlobal ( C++ function ), 176                                                 |
-| ( C++ function ), 165                                                                    | ( C++ function ), 165                                                                    |
-| hipPointerGetAttribute hipPointerGetAttributes ( C++ function ), 165                     | hipPointerGetAttribute hipPointerGetAttributes ( C++ function ), 165                     |
-| hipPointerSetAttribute ( C++ function ), 165                                             | hipPointerSetAttribute ( C++ function ), 165                                             |
-| hipSignalExternalSemaphoresAsync ( C++ func- tion ), 195                                 | hipSignalExternalSemaphoresAsync ( C++ func- tion ), 195                                 |
-| hipStreamAddCallback ( C++ function ), 152 hipStreamAttachMemAsync ( C++ function ), 249 | hipStreamAddCallback ( C++ function ), 152 hipStreamAttachMemAsync ( C++ function ), 249 |
-| hipStreamCallback_t ( C++ type ), 147 ( C++ function ), 147                              | hipStreamCallback_t ( C++ type ), 147 ( C++ function ), 147                              |
-| hipStreamCreate hipStreamCreateWithFlags ( C++ function ), 147                           | hipStreamCreate hipStreamCreateWithFlags ( C++ function ), 147                           |
-| hipStreamCreateWithPriority ( C++ function ), 147 hipStreamDestroy ( C++ function ), 148 | hipStreamCreateWithPriority ( C++ function ), 147 hipStreamDestroy ( C++ function ), 148 |
-| hipStreamGetDevice ( C++ function ), 151                                                 | hipStreamGetDevice ( C++ function ), 151                                                 |
-| hipStreamGetFlags ( C++ function ), 150                                                  | hipStreamGetFlags ( C++ function ), 150                                                  |
-| hipStreamGetPriority ( C++ function ), 150 hipStreamQuery ( C++ function ), 149          | hipStreamGetPriority ( C++ function ), 150 hipStreamQuery ( C++ function ), 149          |
-| hipStreamSynchronize ( C++ function ), 149                                               | hipStreamSynchronize ( C++ function ), 149                                               |
-| hipStreamWaitEvent                                                                       | hipStreamWaitEvent                                                                       |
-| ( C++ function ), 149                                                                    | ( C++ function ), 149                                                                    |
-| hipWaitExternalSemaphoresAsync ( C++ function ), 195                                     | hipWaitExternalSemaphoresAsync ( C++ function ), 195                                     |
-| hsa_amd_vmem_address_free ( C++ function ), 241                                          | hsa_amd_vmem_address_free ( C++ function ), 241                                          |
-| hsa_amd_vmem_address_reserve ( C++function ),                                            |                                                                                          |
-| 241                                                                                      | 241                                                                                      |
-
-| hsa_amd_vmem_export_shareable_handle function ), 244                |                                                                     |
-|---------------------------------------------------------------------|---------------------------------------------------------------------|
-| hsa_amd_vmem_get_access ( C++ function ), 243                       | hsa_amd_vmem_get_access ( C++ function ), 243                       |
-| hsa_amd_vmem_get_alloc_properties_from_handle ( C++ function ), 245 | hsa_amd_vmem_get_alloc_properties_from_handle ( C++ function ), 245 |
-| hsa_amd_vmem_handle_create ( C++ function ), 242                    | hsa_amd_vmem_handle_create ( C++ function ), 242                    |
-| hsa_amd_vmem_handle_release ( C++ function ), 242                   | hsa_amd_vmem_handle_release ( C++ function ), 242                   |
-| hsa_amd_vmem_import_shareable_handle function ), 244                | ( C++                                                               |
-| hsa_amd_vmem_map ( C++ function ), 242                              | hsa_amd_vmem_map ( C++ function ), 242                              |
-| hsa_amd_vmem_retain_alloc_handle ( C++ tion ), 245                  | func-                                                               |
-| hsa_amd_vmem_set_access ( C++ function ), 243                       | hsa_amd_vmem_set_access ( C++ function ), 243                       |
-| hsa_amd_vmem_unmap ( C++ function ), 243                            | hsa_amd_vmem_unmap ( C++ function ), 243                            |
-
-## S
-
-| surf1DLayeredread                             |
-|-----------------------------------------------|
-| surf1DLayeredwrite ( C++ function ), 135      |
-| surf1Dread ( C++ function ), 133              |
-| surf1Dwrite ( C++ function ), 133             |
-| surf2DLayeredread ( C++ function ), 135       |
-| surf2DLayeredwrite ( C++ function ), 135      |
-| surf2Dread ( C++ function ), 134              |
-| surf2Dwrite ( C++ function ), 134             |
-| surf3Dread ( C++ function ), 134              |
-| surf3Dwrite ( C++ function ), 134             |
-| surfCubemapLayeredread ( C++ function ), 136  |
-| surfCubemapLayeredwrite ( C++ function ), 137 |
-| surfCubemapread ( C++ function ), 136         |
-| surfCubemapwrite ( C++ function ), 136        |
-
-## U
-
-USE\_PEER\_NON\_UNIFIED ( C macro ), 164
\ No newline at end of file
diff --git a/kernel-agentic/docs/hip/hip_spec_mm/hip_spec-with-images.md b/kernel-agentic/docs/hip/hip_spec_mm/hip_spec-with-images.md
deleted file mode 100644
index 5b76d44..0000000
--- a/kernel-agentic/docs/hip/hip_spec_mm/hip_spec-with-images.md
+++ /dev/null
@@ -1,11189 +0,0 @@
-## HIP Documentation Release 6.1.40092
-
-Advanced Micro Devices, Inc.
-
-Sep 13, 2024
-
-## INSTALL
-
-| 1 Overview   | 1 Overview                                                   | 1 Overview                                                   | 3     |
-|--------------|--------------------------------------------------------------|--------------------------------------------------------------|-------|
-|              | Install HIP                                                  | Install HIP                                                  |       |
-| 2            |                                                              |                                                              | 5     |
-|              | 2.1                                                          | Prerequisites . . . . . . . . .                              | 5     |
-|              | 2.2                                                          | Installation . . .                                           | 5     |
-|              | 2.3                                                          | . . . . . Verify your installation . . .                     | 6     |
-| 3            | Build HIP from source                                        | Build HIP from source                                        | 7     |
-|              | 3.1 Prerequisites                                            | . . . . . .                                                  |       |
-|              |                                                              | . .                                                          | 7     |
-|              | 3.2 Building the HIP runtime 3.3 . .                         | .                                                            | 7     |
-|              | Build HIP tests . . .                                        | Build HIP tests . . .                                        | 10    |
-|              | . . . 3.4 Run HIP . . . . . . . . . . .                      | . . . 3.4 Run HIP . . . . . . . . . . .                      | 11    |
-| 4            | HIP programming model                                        | HIP programming model                                        | 13    |
-|              | 4.1                                                          | 4.1                                                          | 13    |
-| 4.2          | RDNA &CDNAarchitecture summary Heterogeneous Programming . . | RDNA &CDNAarchitecture summary Heterogeneous Programming . . | 14    |
-|              | Single instruction multiple threads (SIMT) . . .             | Single instruction multiple threads (SIMT) . . .             | 14    |
-| 4.3 4.4      | Inherent thread model . .                                    | Inherent thread model . .                                    | 15    |
-| 4.5          | . . . . 4.4.1 Cooperative groups thread                      | . . . . 4.4.1 Cooperative groups thread                      | 16    |
-|              | Memory model . . . . . . . . .                               | Memory model . . . . . . . . .                               | 16    |
-|              | 4.6 Execution model .                                        | . . . . .                                                    | 17    |
-|              | 4.6.1 Host-side                                              | 4.6.1 Host-side                                              |       |
-|              |                                                              | execution                                                    | 17 17 |
-|              | 4.6.2                                                        | Device-side execution . .                                    |       |
-|              | 4.6.3                                                        | Kernel launch .                                              | 18    |
-| 5            | Hardware implementation                                      | Hardware implementation                                      | 19    |
-|              | Compute units                                                | . . . . . . .                                                | 19    |
-|              |                                                              | . . . . .                                                    | 20    |
-| 5.1          | 5.1.1 5.1.2                                                  | SIMD . . Vector cache . .                                    | 20    |
-|              | 5.1.3                                                        | . . Local data share . .                                     | 20    |
-|              | 5.1.4                                                        | Scalar Unit . . . .                                          | 20    |
-|              | 5.2 CDNA architecture .                                      | . . . .                                                      | 20    |
-|              | 5.3 RDNA architecture . .                                    | . . . .                                                      | 21    |
-|              | 5.4 Shader engines . .                                       | . . . .                                                      | 21    |
-|              | (CLR)                                                        | (CLR)                                                        |       |
-| 6            | AMDcommon language runtimes                                  | AMDcommon language runtimes                                  | 23    |
-|              | 6.1 Project organization                                     | . . . .                                                      | 23    |
-|              | How to build/install .                                       | . . .                                                        | 23    |
-| 6.2          | 6.2.1                                                        | Prerequisites . . .                                          | 23    |
-|              | 6.2.2                                                        | Linux . . . . . . .                                          | 23    |
-|              | 6.2.3                                                        | Test . . . . . . . .                                         | 24    |
-
-|                                           | 6.2.4                                                                                      | Release notes . . . . . . . . . . . . . . . . . . . . .                                    | 24    |
-|-------------------------------------------|--------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------|-------|
-| HIP programming manual                    | HIP programming manual                                                                     | HIP programming manual                                                                     | 25    |
-| 7 7.1                                     | Host Memory . . . . .                                                                      | . . . . . . . . . . . . . . . . . . . . .                                                  | 25    |
-|                                           | 7.1.1                                                                                      | Introduction . . . . . . . . . . . . . . .                                                 | 25    |
-|                                           | 7.1.2                                                                                      | . . . . . . . Memory allocation flags . . . . . . . . .                                    | 25    |
-|                                           | 7.1.3                                                                                      | . . . . . . Numa-aware host memory allocation . . . . . . . . .                            | 26    |
-|                                           | 7.1.4                                                                                      | Coherency Controls . . . . . . . . .                                                       | 26    |
-|                                           | 7.1.5                                                                                      | . . . . . . . . . Visibility of Zero-Copy Host Memory . . . . . . . .                      | 27    |
-|                                           | 7.1.6                                                                                      | hipEventSynchronize . . . . . . . . . . .                                                  | 27    |
-|                                           | 7.1.7                                                                                      | . . . . Summary and Recommendations . . . . . . . . . . .                                  | 27    |
-|                                           | 7.1.8                                                                                      | Managed memory allocation . . . . . . . . . . . . .                                        | 28    |
-|                                           | 7.1.9                                                                                      | HIP Stream Memory Operations . . . . . . . . . . .                                         | 28    |
-| 7.2                                       | Direct Dispatch . . . . . .                                                                | . . . . . . . . . . . . . . . . . . .                                                      | 28    |
-| 7.3                                       | HIP Runtime Compilation                                                                    | . . . . . . . . . .                                                                        | 29    |
-| 7.4                                       | . . . . . . . . . HIP Graph . . . . . . . . . . . . . . . . .                              | . . . . . . . . . .                                                                        | 29    |
-| 7.5                                       | Device-Side Malloc . . . . . .                                                             | . . . . . . . . . . . . .                                                                  | 29    |
-| 7.6                                       | . . . Use of Per-thread default stream . . .                                               | . . . . . . . . . . . . .                                                                  | 29    |
-| 7.7                                       | Use of Long Double Type . . . . .                                                          | . . . . . . . . . . . . . .                                                                | 30    |
-| 7.8                                       | Use of _Float16 Type . . . . . . .                                                         | Use of _Float16 Type . . . . . . .                                                         | 30    |
-| 7.9                                       | . . . . . . . . . . . . . . FMA and contractions . . . . . . . . . . . . . . . . . . . . . | . . . . . . . . . . . . . . FMA and contractions . . . . . . . . . . . . . . . . . . . . . | 30    |
-| 7.10                                      | Math functions with special rounding modes . . . . . . . . . . . . . . . .                 | . . . . .                                                                                  | 30    |
-| 7.11                                      | Creating Static Libraries . . .                                                            | . . . . .                                                                                  | 30    |
-| 8 HIP porting guide . . . . . . . . . . . | 8 HIP porting guide . . . . . . . . . . .                                                  | 8 HIP porting guide . . . . . . . . . . .                                                  | 33    |
-| 8.1                                       | Porting a New CUDA Project .                                                               | . . . . .                                                                                  | 33    |
-|                                           |                                                                                            | General Tips . .                                                                           |       |
-|                                           | 8.1.1                                                                                      | . . . . . . . . . . . . . . . . . . .                                                      | 33    |
-|                                           | 8.1.2                                                                                      | Scanning existing CUDA code to scope the porting effort 'in-place' . . . . . . . . . .     | 33 34 |
-|                                           | 8.1.3                                                                                      | Converting a project . .                                                                   |       |
-|                                           | 8.1.4                                                                                      | Library Equivalents . . . . . . . . . . . . . . . . . .                                    | 35 35 |
-| 8.2                                       | Distinguishing 8.2.1                                                                       | Compiler Modes . . . . . . . . . . . . . . . . Identifying HIP Target Platform . . .       | 35    |
-|                                           | 8.2.2                                                                                      | . . . . . . . . Identifying the Compiler: hip-clang or NVCC . . .                          | 36    |
-|                                           | 8.2.3                                                                                      | . Identifying Current Compilation Pass: Host or Device                                     | 36    |
-|                                           | 8.2.4                                                                                      | Compiler Defines: Summary . . . . . . . . . . . . . . .                                    | 37    |
-| 8.3                                       | Identifying Architecture Features . .                                                      | . . . . . . . . . . . . .                                                                  | 37    |
-|                                           | 8.3.1                                                                                      | HIP_ARCH Defines . . . . . . . . . . . . . . .                                             | 37    |
-|                                           | 8.3.2                                                                                      | Device-Architecture Properties . . . . . . . . . . . .                                     | 38    |
-|                                           | 8.3.3                                                                                      | Table of Architecture Properties . . . . . . . . . . . . . . . . . .                       | 38    |
-| 8.4                                       | Finding HIP . . . . . . .                                                                  | . . . . . . . . . . . .                                                                    | 39 40 |
-| 8.5 8.6                                   | Identifying HIP Runtime . . . . . hipLaunchKernelGGL . . . . .                             | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                | 40    |
-| 8.7                                       | Compiler Options . . . . . . . 8.7.1 Compiler options supported                            | . . . . . . . . . . . . . . . .                                                            | 40    |
-|                                           |                                                                                            | on AMDplatforms . . .                                                                      | 40    |
-| 8.8                                       | Linking Issues . . .                                                                       | . . . . . . . . . . . . . . . . . . . .                                                    | 41    |
-|                                           | . . 8.8.1 Linking With hipcc                                                               | . . . . . . . . . . . . . . . . . .                                                        | 41    |
-|                                           | 8.8.2                                                                                      | -lm Option . . . . . . . . . . . . . . . . .                                               | 41    |
-| 8.9                                       | . . . . . Linking Code With Other Compilers                                                | . . . . . . . . . . . . .                                                                  | 41    |
-|                                           | 8.9.1 libc++ and libstdc++                                                                 | 8.9.1 libc++ and libstdc++                                                                 |       |
-|                                           |                                                                                            | . . . . . . . . . . . . . . . . .                                                          | 41    |
-|                                           | 8.9.2                                                                                      | HIP Headers ( hip_runtime.h , hip_runtime_api.h Compiler . . . . . . . . . . .             | 42 42 |
-|                                           | 8.9.3 Using a Standard C++ 8.9.3.1 . .                                                     | . . . . . . . . . . . .                                                                    | 42    |
-|                                           | cuda.h . . . . . 8.9.4 Choosing HIP File Extensions . .                                    | . . . . . . . . . . . .                                                                    | 42    |
-| 8.10                                      | Workarounds . . . . . . . . . . . .                                                        | . . . . . . . . . . . .                                                                    | 43    |
-
-8.10.1
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-43
-
-|      |                                                                                                                                                                           |                                                                                                                                                                           | warpSize                                                                                                                                                                  |       |
-|------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------|
-|      |                                                                                                                                                                           | 8.10.2 Kernel launch with group size > 256 . . . . . . . . . . . . . . . . . . . . .                                                                                      | 8.10.2 Kernel launch with group size > 256 . . . . . . . . . . . . . . . . . . . . .                                                                                      | 43    |
-|      | 8.11                                                                                                                                                                      | memcpyToSymbol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                            | memcpyToSymbol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                            | 43    |
-|      | 8.12                                                                                                                                                                      | CU_POINTER_ATTRIBUTE_MEMORY_TYPE                                                                                                                                          | . . .                                                                                                                                                                     | 44    |
-|      | 8.13                                                                                                                                                                      | threadfence_system . . .                                                                                                                                                  | . . . . . . . .                                                                                                                                                           | 45    |
-|      |                                                                                                                                                                           | . . . . . . 8.13.1 Textures and Cache Control . . .                                                                                                                       | . . . . . . . .                                                                                                                                                           | 45    |
-|      | 8.14                                                                                                                                                                      | More Tips . . . .                                                                                                                                                         | . . . . . . . . .                                                                                                                                                         | 46    |
-|      | 8.14.1                                                                                                                                                                    | . . . . . . . . . . . HIP Logging . . . . . . . . .                                                                                                                       | . . . . . . . . .                                                                                                                                                         | 46    |
-|      | 8.14.2                                                                                                                                                                    | Debugging hipcc                                                                                                                                                           | . . . . . . . . . . . . . . . .                                                                                                                                           | 47    |
-|      | 8.14.3                                                                                                                                                                    | Editor Highlighting . .                                                                                                                                                   | . . . . . . . . . . . . .                                                                                                                                                 | 47    |
-| 9    | Porting CUDA driver API                                                                                                                                                   | Porting CUDA driver API                                                                                                                                                   | Porting CUDA driver API                                                                                                                                                   | 49    |
-| 9.1  | Introduction to the CUDA Driver and Runtime APIs . . . . . . . .                                                                                                          | Introduction to the CUDA Driver and Runtime APIs . . . . . . . .                                                                                                          | Introduction to the CUDA Driver and Runtime APIs . . . . . . . .                                                                                                          | 49    |
-|      | 9.1.1                                                                                                                                                                     | cuModule API . . . . . . . . . . . . . .                                                                                                                                  | cuModule API . . . . . . . . . . . . . .                                                                                                                                  | 49    |
-|      | 9.1.2                                                                                                                                                                     | . . . . . . . . . cuCtx API . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                             | . . . . . . . . . cuCtx API . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                             | 50    |
-| 9.2  | HIP                                                                                                                                                                       | Module and Ctx APIs . . . . . . . . . . . . .                                                                                                                             | . . .                                                                                                                                                                     | 50    |
-|      | 9.2.1                                                                                                                                                                     | hipModule API . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                       | hipModule API . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                       | 50    |
-|      | 9.2.2                                                                                                                                                                     | . hipCtx API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                  | . hipCtx API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                  | 51    |
-|      | 9.2.3                                                                                                                                                                     | hipify translation of CUDA Driver API . . . . . .                                                                                                                         | hipify translation of CUDA Driver API . . . . . .                                                                                                                         | 51    |
-|      |                                                                                                                                                                           | 9.2.3.1                                                                                                                                                                   | Address Spaces . . . . . .                                                                                                                                                | 51    |
-|      |                                                                                                                                                                           | 9.2.3.2                                                                                                                                                                   | . . . . . . Using hipModuleLaunchKernel . .                                                                                                                               | 51    |
-|      |                                                                                                                                                                           | 9.2.3.3                                                                                                                                                                   | Additional Information                                                                                                                                                    | 51    |
-|      | 9.2.4                                                                                                                                                                     | . . . . . . . . . . . hip-clang Implementation Notes . . . . . . . . . .                                                                                                  | . . . . . . . . . . . hip-clang Implementation Notes . . . . . . . . . .                                                                                                  | 51    |
-|      |                                                                                                                                                                           | 9.2.4.1                                                                                                                                                                   | .hip_fatbin . . . . . . . . . . . . .                                                                                                                                     | 51    |
-|      |                                                                                                                                                                           | 9.2.4.2                                                                                                                                                                   | Initialization and Termination Functions                                                                                                                                  | 52    |
-|      |                                                                                                                                                                           | 9.2.4.3                                                                                                                                                                   | Kernel Launching                                                                                                                                                          | 52    |
-|      | 9.2.5                                                                                                                                                                     | . . . . . . . . . . . . . . . . . . NVCC Implementation Notes . . . . . . . . . . . . . . . . .                                                                           | . . . . . . . . . . . . . . . . . . NVCC Implementation Notes . . . . . . . . . . . . . . . . .                                                                           | 52    |
-|      |                                                                                                                                                                           | . . . . 9.2.5.1 Interoperation between HIP and CUDA Driver . . . . . . .                                                                                                  | . . . . 9.2.5.1 Interoperation between HIP and CUDA Driver . . . . . . .                                                                                                  | 52    |
-|      |                                                                                                                                                                           | 9.2.5.2 Compilation Options . . .                                                                                                                                         | . . . . . .                                                                                                                                                               | 53    |
-| 9.3  | HIP                                                                                                                                                                       | Module and Texture Driver API . . . .                                                                                                                                     | . . . . . . .                                                                                                                                                             | 55    |
-| 10   | Programming for HIP runtime compiler (RTC)                                                                                                                                | Programming for HIP runtime compiler (RTC)                                                                                                                                | Programming for HIP runtime compiler (RTC)                                                                                                                                | 57    |
-| 10.1 | Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                       | Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                       | Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                       | 57    |
-| 10.2 | HIPRTC                                                                                                                                                                    | specific options . . . . . . . .                                                                                                                                          | . . . . . . . . .                                                                                                                                                         | 61    |
-|      | 10.2.1                                                                                                                                                                    | Bitcode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                             | Bitcode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                             | 62    |
-|      | 10.2.2                                                                                                                                                                    | CU Mode vs WGP mode . . . . . .                                                                                                                                           | CU Mode vs WGP mode . . . . . .                                                                                                                                           | 62    |
-| 10.3 | Linker                                                                                                                                                                    | APIs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                        | APIs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                        | 62    |
-|      | 10.3.1                                                                                                                                                                    | Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                 | Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                 | 63 63 |
-|      | 10.3.2                                                                                                                                                                    | 10.3.1.1 Note . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Input Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                     | 10.3.1.1 Note . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Input Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                     | 64    |
-|      | 10.3.3                                                                                                                                                                    | . Backward Compatibility of LLVM Bitcode/IR . . . . . . . . . . . . . .                                                                                                   | . Backward Compatibility of LLVM Bitcode/IR . . . . . . . . . . . . . .                                                                                                   | 64    |
-|      | 10.3.4                                                                                                                                                                    | Link Options . . . . . . . . . .                                                                                                                                          | . . . . . . . .                                                                                                                                                           | 64    |
-| 10.4 | Error Handling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                | Error Handling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                | Error Handling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                | 65    |
-| 10.5 | HIPRTC General APIs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                   | HIPRTC General APIs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                   | HIPRTC General APIs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                   | 65    |
-| 10.6 | Lowered Names (Mangled Names) . . . . . . . . . . .                                                                                                                       | Lowered Names (Mangled Names) . . . . . . . . . . .                                                                                                                       | Lowered Names (Mangled Names) . . . . . . . . . . .                                                                                                                       | 66    |
-|      | 10.6.1 10.6.2                                                                                                                                                             | Note . . . . . . . . . . . . . . . . . . . . . . . . . . . Example . . . . . . . . . . . . . . . . . . . . . . . . .                                                      | Note . . . . . . . . . . . . . . . . . . . . . . . . . . . Example . . . . . . . . . . . . . . . . . . . . . . . . .                                                      | 66 66 |
-| 10.7 | . . . . . . . . . . .                                                                                                                                                     | . . . . . . . . . . .                                                                                                                                                     | . . . . . . . . . . .                                                                                                                                                     | 67    |
-| 10.8 | Versioning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . HIP header support . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . | Versioning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . HIP header support . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . | Versioning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . HIP header support . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . | 68    |
-| 10.9 | Deprecation notice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                      | Deprecation notice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                      | Deprecation notice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                      | 68    |
-| 11   |                                                                                                                                                                           |                                                                                                                                                                           |                                                                                                                                                                           | 69    |
-| 11.1 | Performance guidelines Parallel                                                                                                                                           | execution                                                                                                                                                                 | . . . . . . . . . . . . . . . . . . . . .                                                                                                                                 | 69    |
-
-11.1.2
-
-Device level
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-69
-
-|                                               | 11.1.3                                                            | Multiprocessor level . . . . . . . . . . . . . .                                       | 70      |
-|-----------------------------------------------|-------------------------------------------------------------------|----------------------------------------------------------------------------------------|---------|
-| 11.2                                          | Memory                                                            | optimization . . . . . . . . . . . .                                                   | 70      |
-|                                               | 11.2.1                                                            | Data Transfer . . . . . . . . . . . . .                                                | 70      |
-|                                               | 11.2.2                                                            | . . Device Memory Access . . . . . . . . . .                                           | 71      |
-| 11.3                                          | Optimization for maximum instruction throughput                   | Optimization for maximum instruction throughput                                        | 71      |
-|                                               | 11.3.1                                                            | Arithmetic instructions . . . . . . . . .                                              | 72      |
-|                                               | 11.3.2                                                            | . Control flow instructions . . . . . . . . .                                          | 72      |
-|                                               | 11.3.3                                                            | Synchronization . . . . . . . . . .                                                    | 72      |
-| 11.4                                          | . . . . Minimizing memory thrashing .                             | . . . . . . . . . .                                                                    | 73      |
-| 12 Debugging with HIP                         | 12 Debugging with HIP                                             | 12 Debugging with HIP                                                                  | 75      |
-| 12.1                                          | Tracing . .                                                       | . . . . . . . . . . . . . . . . . . . . .                                              | 75      |
-| 12.2                                          | Debugging . . . . . .                                             | . . . . . . . .                                                                        | 77      |
-|                                               | . . . . . . . 12.2.1 Debugging HIP applications                   | . . . . . . .                                                                          | 77      |
-| 12.3                                          | Useful environment variables                                      | . . . . . . .                                                                          | 79      |
-|                                               | 12.3.1                                                            | . . . . Kernel enqueue serialization . . . . . . .                                     | 79      |
-|                                               | 12.3.2                                                            | Making device visible . . . . . . . . . . .                                            | 79      |
-|                                               | 12.3.3                                                            | Dump code object . .                                                                   | 79      |
-|                                               | 12.3.4                                                            | . . . . . . . . . . . HSA-related environment variables (Linux)                        | 80      |
-|                                               | 12.3.5 HIP environment variable summary . .                       | .                                                                                      | 80      |
-| 12.4                                          | General debugging tips . . .                                      | . . . . . . . . . . . .                                                                | 82      |
-| 13 Logging HIP activity                       | 13 Logging HIP activity                                           | 13 Logging HIP activity                                                                | 83      |
-| 13.1                                          | Logging level . . . . . . . .                                     | . . . . . . . . . . . .                                                                | 83      |
-| 13.2                                          | Logging mask . . . . .                                            | . . .                                                                                  | 84      |
-| 13.3                                          | . . . . . . . . . . . Logging command . . . . . . . . . . . . . . | . . .                                                                                  | 84      |
-| 13.4                                          | Logging examples . . . . . .                                      | . . . . . . . . . . .                                                                  | 85      |
-| 14 Cooperative groups . . . . . . . . . . . . | 14 Cooperative groups . . . . . . . . . . . .                     | 14 Cooperative groups . . . . . . . . . . . .                                          | 89      |
-| 14.1                                          | Cooperative groups thread model . . .                             | Cooperative groups thread model . . .                                                  | 89      |
-| 14.2                                          | Group types . . . . . . . . group                                 | . . . . . . . . .                                                                      | 90      |
-|                                               | 14.2.1                                                            | Thread-block . . . . . . . . . . . . .                                                 | 90      |
-|                                               | 14.2.2                                                            | Grid group . . . . . . . . . . . . . .                                                 | 90      |
-|                                               | 14.2.3                                                            | . Multi-grid group . . . . . . . . . . . . .                                           | 90      |
-|                                               | 14.2.4 14.2.5                                                     | Thread-block tile . . . . . . . . . . . . . Coalesced groups . . . . . . . . . . . . . | 91 91   |
-| 14.3                                          | Cooperative groups simple example . .                             | . . . . . .                                                                            | 92      |
-| 14.4                                          | Synchronization . . . . . .                                       | . . . . . . . .                                                                        | 94      |
-| 14.5                                          | . . . .                                                           | . . . .                                                                                | 97      |
-|                                               | Unsupported NVIDIA CUDA features . . .                            | Unsupported NVIDIA CUDA features . . .                                                 |         |
-| 15 Unified memory                             | 15 Unified memory                                                 | 15 Unified memory                                                                      | 99      |
-| 15.1                                          | Unified memory . . .                                              | . . . . . . . . . . . . . . .                                                          | 99 99   |
-| 15.2                                          | System requirements . . . . .                                     | . . . . . . . . . . .                                                                  | 100     |
-| 15.3                                          | Unified memory programming models                                 | . . . . . .                                                                            |         |
-|                                               | 15.3.1                                                            | Checking unified memory management support                                             | 100     |
-|                                               | 15.3.2 Example for unified memory management                      | 15.3.2 Example for unified memory management                                           | 101     |
-| 15.4                                          | Using unified memory management (UMM)                             | . . .                                                                                  | 104     |
-| 15.5                                          | Unified memory HIP runtime hints . . . . .                        | for the better performance                                                             | 104     |
-|                                               | 15.5.1                                                            | Data prefetching . . . . . . . . .                                                     | 105     |
-|                                               | 15.5.2                                                            | Memory advice . . . . . . . . . . . . . .                                              | 106 107 |
-|                                               | 15.5.3 15.5.4                                                     | Memory range attributes . . . . . . . . . Asynchronously attach memory to a stream     | 108     |
-| 16 Virtual memory management                  | 16 Virtual memory management                                      | 16 Virtual memory management                                                           | 109     |
-
-| 16.1                          | Memory allocation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16.1.1                                                                                                                                                | . . . 109 . . .     |
-|-------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------|
-|                               | Allocate physical memory . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                                  | 109                 |
-| 16.1.2                        | Reserve virtual address range . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                               | . . . 110           |
-| 16.1.3                        | Set memory access . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                                 | . . . 110           |
-|                               | Free virtual memory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                                 | . . . 110           |
-| 16.2                          | 16.1.4 Memory usage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                 | . . . 111           |
-|                               | 16.2.1 Dynamically increase allocation size . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                         | . . . 111           |
-| 17 Frequently asked questions | 17 Frequently asked questions                                                                                                                                                                                                                     | 113                 |
-| 17.1                          | What APIs and features does HIP support? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                      | . . . 113           |
-| 17.2                          | What is not supported? . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                                          | . . . 113           |
-|                               | 17.2.1 Runtime/Driver API features . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                          | . . . 113           |
-|                               | 17.2.2 Kernel language features . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                         | . . . 114           |
-| 17.3 Is                       | HIP a drop-in replacement for CUDA? . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                             | . . . 114           |
-| 17.4                          | What specific version of CUDA does HIP support? . . . . . . . . . . . . . . . . . . . .                                                                                                                                                           | . . . 114           |
-| 17.5                          | What libraries does HIP support? . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                        | . . . 115           |
-| 17.6                          | How does HIP compare with OpenCL? . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                             | . . . 115           |
-| 17.7                          | How does porting CUDA to HIP compare to porting CUDA to OpenCL? . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                         | . . . 115           |
-| 17.8                          | What hardware does HIP support? . . . . . . . .                                                                                                                                                                                                   | . . . 116           |
-| 17.9                          | Do HIPIFY tools automatically convert all source code? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                  | . . . 116           |
-| 17.10                         | What is NVCC? . . . . . . . . . . . . . . . .                                                                                                                                                                                                     | . . . 116           |
-| 17.11                         | . . What is HIP-Clang? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                    | . . . 116           |
-| 17.12                         | Why use HIP rather than supporting CUDA directly? . . . . . . . . . . . . . . . . . . .                                                                                                                                                           | . . . 116 117       |
-| 17.13                         | Can I develop HIP code on an NVIDIA CUDA platform? . . . . . . . . . . . . . . . . Can I develop HIP code on an AMDHIP-Clang platform? . . . . . . . . . . . . . . . .                                                                            | . . . . . . 117     |
-| 17.14                         | How to use HIP-Clang to build HIP programs? . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                   | . . . 117           |
-| 17.15                         | . . . . . . . . . . . . . .                                                                                                                                                                                                                       |                     |
-| 17.16 17.17                   | What is AMDclr? . . . . . . . . . . . . . . . . . . . What is hipother? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                               | . . . 117 . . . 118 |
-| 17.18                         | Can I get HIP open source repository . . . . . . . . . . . . . . . .                                                                                                                                                                              | . . . 118           |
-| 17.19                         | for Windows? . . . Can a HIP binary run on both AMDand NVIDIA platforms? .                                                                                                                                                                        | . . . 118           |
-| 17.20 or                      | . . . . . . . . . . . . . On HIP-Clang, can I link HIP code with host code compiled with another compiler such clang? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                         | icc, . . . 118      |
-| 17.21                         | Can HIP API support C style application? What is the difference between C and C++? . .                                                                                                                                                            | . . . 118           |
-| 17.22                         | Can I install both CUDA SDK and HIP-Clang on the same machine? . . . . . . . . .                                                                                                                                                                  | . . . 119           |
-| 17.23                         | HIP detected my platform (HIP-Clang vs NVCC) incorrectly * what should I do? . . . . . . . . . . . . . . .                                                                                                                                        | . . . 119           |
-| 17.24                         | On CUDA, can I mix CUDA code with HIP code? . . . . . . . . . . . . . .                                                                                                                                                                           | . . . 120           |
-| 17.25                         | How do I trace HIP application flow? . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                                  | . . . 120           |
-| 17.26                         | What are the maximum limits of kernel launch parameters? . . . . . . . . . . . . . . .                                                                                                                                                            | . . . 120           |
-| 17.27                         | Are __shfl_*_sync functions supported on HIP platform? . . . . . . . . . . . . . . .                                                                                                                                                              | . . . 120           |
-| 17.28                         | How to create a guard for code that is specific to the host or the GPU? . . . . . . . . . .                                                                                                                                                       | . . . 120           |
-| 17.29                         | Why _OpenMP is undefined when compiling with -fopenmp ? . . . . . . . . . . . . . .                                                                                                                                                               | . . . 121           |
-| 17.30                         | Does the HIP-Clang compiler support extern shared declarations? . . . . . . . . . . . .                                                                                                                                                           | . . . 121 code      |
-| 17.31                         | I have multiple HIP enabled devices and I am getting an error hipErrorSharedObjectInitFailed with the message 'Error: shared object initialization failed'? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . | . . . 121           |
-| 17.32                         | How to use per-thread default stream in HIP? . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                        | . . . 122           |
-| 17.33                         | How to use complex multiplication and division operations? . . . . . . . . .                                                                                                                                                                      | . . . 122           |
-| 17.34                         | . . . . . . Can I develop applications with HIP APIs on Windows the same on Linux? . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                      | . . . 122           |
-| 17.35                         | Does HIP support LUID? . . . . . . . . . . .                                                                                                                                                                                                      | . . . 123           |
-| 17.36                         | How can I know the version of HIP? . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                                        | . . . 123           |
-| 18 HIP Runtime 18.1 Related   | API Reference Pages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                                                                                               | 125 . . . 126       |
-
-18.3
-
-Namespaces
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-126
-
-|      | 18.3.1                                                                                                                  | Namespace List . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                        | Namespace List . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                        | 126     |
-|------|-------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------|---------|
-|      | 18.3.2                                                                                                                  | Namespace Members . . . . . . . . . . . . . .                                                                           | Namespace Members . . . . . . . . . . . . . .                                                                           | 126     |
-|      |                                                                                                                         | 18.3.2.1 Namespace Members . . . . .                                                                                    | 18.3.2.1 Namespace Members . . . . .                                                                                    | 126     |
-|      |                                                                                                                         | 18.3.2.2 Namespace Members .                                                                                            | 18.3.2.2 Namespace Members .                                                                                            | 126     |
-| 18.4 | . . . . . Data Structures . . . . . . . . . . . . . . . . . . .                                                         | . . . . . Data Structures . . . . . . . . . . . . . . . . . . .                                                         | . . . . . Data Structures . . . . . . . . . . . . . . . . . . .                                                         | 126     |
-|      | 18.4.1 Data                                                                                                             | Structures . . . . . . . .                                                                                              | . .                                                                                                                     | 126     |
-|      | 18.4.2                                                                                                                  | . . . Data Structure Index . . . . . . . .                                                                              | . . . Data Structure Index . . . . . . . .                                                                              | 126     |
-|      | 18.4.3                                                                                                                  | . . . Class Hierarchy . . . . . . . . . . . . . .                                                                       | . . . Class Hierarchy . . . . . . . . . . . . . .                                                                       | 126     |
-|      | 18.4.4                                                                                                                  | . . Data Fields . . . . . . . . . . . . . . . . . .                                                                     | . . Data Fields . . . . . . . . . . . . . . . . . .                                                                     | 126     |
-|      |                                                                                                                         | 18.4.4.1 All . . . . . . . . . . . . . .                                                                                | .                                                                                                                       | 126     |
-|      |                                                                                                                         | 18.4.4.1.1                                                                                                              | Data Fields . . . . .                                                                                                   | 126     |
-|      |                                                                                                                         | 18.4.4.1.2                                                                                                              | Data Fields . . . . .                                                                                                   | 126     |
-|      |                                                                                                                         | 18.4.4.1.3                                                                                                              | Data Fields . . . . .                                                                                                   | 126     |
-|      |                                                                                                                         | 18.4.4.1.4                                                                                                              | Data Fields . . . . .                                                                                                   | 126     |
-|      |                                                                                                                         | 18.4.4.1.5                                                                                                              | Data Fields . . . . .                                                                                                   | 126     |
-|      |                                                                                                                         | 18.4.4.1.6                                                                                                              | Data Fields . . . .                                                                                                     | 126     |
-|      |                                                                                                                         | 18.4.4.1.7                                                                                                              | . Data Fields . . . . . .                                                                                               | 126     |
-|      |                                                                                                                         | 18.4.4.1.8                                                                                                              | Data Fields . . . .                                                                                                     | 126     |
-|      |                                                                                                                         | 18.4.4.1.9                                                                                                              | Data Fields . . . . . . .                                                                                               | 126     |
-|      |                                                                                                                         | 18.4.4.1.10                                                                                                             | Data Fields . . .                                                                                                       | 126     |
-|      |                                                                                                                         | 18.4.4.1.11                                                                                                             | Data Fields . . . . . . .                                                                                               | 126     |
-|      |                                                                                                                         | 18.4.4.1.12                                                                                                             | Data Fields . . .                                                                                                       | 126     |
-|      |                                                                                                                         | 18.4.4.1.13                                                                                                             | Data Fields . . . . . Data Fields .                                                                                     | 126     |
-|      |                                                                                                                         | 18.4.4.1.14                                                                                                             | . . . . Data Fields                                                                                                     | 126     |
-|      |                                                                                                                         | 18.4.4.1.15                                                                                                             | . . . . . .                                                                                                             | 126     |
-|      |                                                                                                                         | 18.4.4.1.16                                                                                                             | Data Fields . . . .                                                                                                     | 126     |
-|      |                                                                                                                         | 18.4.4.1.17                                                                                                             | Data Fields . . . . .                                                                                                   | 126     |
-|      |                                                                                                                         | 18.4.4.1.18                                                                                                             | Data Fields . . . . .                                                                                                   | 126     |
-|      |                                                                                                                         | 18.4.4.1.19                                                                                                             | Data Fields . . . . .                                                                                                   | 126     |
-|      |                                                                                                                         | 18.4.4.1.20                                                                                                             | Data Fields . . . . . .                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.1.21                                                                                                             | Data Fields . . . .                                                                                                     | 126     |
-|      |                                                                                                                         | 18.4.4.1.22                                                                                                             | Data Fields . . . . .                                                                                                   | 126     |
-|      |                                                                                                                         | 18.4.4.1.23                                                                                                             | Data Fields . . . . .                                                                                                   | 126     |
-|      |                                                                                                                         | 18.4.4.1.24                                                                                                             | Data Fields . . . .                                                                                                     | 126     |
-|      |                                                                                                                         | 18.4.4.1.25                                                                                                             | . Data Fields . . . . .                                                                                                 | 126 126 |
-|      | 18.4.4.2 Data Fields - Functions . . . . . . . . . . . . . 18.4.4.3 Variables . . . . . . . . . . . . . . . . . . . . . | 18.4.4.2 Data Fields - Functions . . . . . . . . . . . . . 18.4.4.3 Variables . . . . . . . . . . . . . . . . . . . . . | 18.4.4.2 Data Fields - Functions . . . . . . . . . . . . . 18.4.4.3 Variables . . . . . . . . . . . . . . . . . . . . . | 126     |
-|      |                                                                                                                         | 18.4.4.3.1                                                                                                              | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.2                                                                                                              | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.3                                                                                                              | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.4                                                                                                              | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.5                                                                                                              | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.6                                                                                                              | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.7                                                                                                              | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.8                                                                                                              | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.9                                                                                                              | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.10                                                                                                             | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.11                                                                                                             | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.12                                                                                                             | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.13                                                                                                             | Data Fields - Variables                                                                                                 | 126     |
-|      |                                                                                                                         | 18.4.4.3.14 18.4.4.3.15                                                                                                 | Data Fields - Variables Data Fields - Variables                                                                         | 126 126 |
-|      |                                                                                                                         | 18.4.4.3.16                                                                                                             | Data Fields - Variables                                                                                                 | 126     |
-
-18.4.4.3.17
-
-Data Fields - Variables
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-126
-
-|           |                                                                                                 | 18.4.4.3.18                                                                                     | Data Fields - Variables                                                                         | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                               | 126     |
-|-----------|-------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------|---------|
-|           |                                                                                                 | 18.4.4.3.19                                                                                     | Data Fields - Variables                                                                         | . . . . . . . . . . . . . . . . . . . . .                                                                                       | 126     |
-|           |                                                                                                 | 18.4.4.3.20                                                                                     | Data Fields -                                                                                   | Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                       | 126     |
-|           |                                                                                                 | 18.4.4.3.21                                                                                     | Data Fields - Variables                                                                         | . . . . . . . . . . . . . . . . . . . . . .                                                                                     | 126     |
-|           |                                                                                                 | 18.4.4.3.22                                                                                     | Data                                                                                            | Fields - Variables . . . . . . . . . . . . . . . . . . . . .                                                                    | 126     |
-|           |                                                                                                 | 18.4.4.3.23                                                                                     | Data Fields -                                                                                   | . . . . . . Variables . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                     | 126     |
-|           |                                                                                                 | 18.4.4.3.24                                                                                     | Data                                                                                            | Fields - Variables . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                        | 126     |
-|           |                                                                                                 | 18.4.4.3.25                                                                                     | Data                                                                                            | Fields - Variables . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                        | 126     |
-| 18.5      | 18.4.4.4 Data Fields - Related Symbols . .                                                      | . . . . . . . . .                                                                               | 18.4.4.4 Data Fields - Related Symbols . .                                                      | . . . . . . . . . . . . . . . . . . . . . . . . . . 126 . . . . . . . . .                                                       | 126     |
-|           | Files 18.5.1                                                                                    | File List . . . . .                                                                             | . . . . . . . . . . . . . .                                                                     | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .           | 126     |
-|           | 18.5.2                                                                                          | Globals . . .                                                                                   | . . . . . . . .                                                                                 | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                               | 126     |
-|           |                                                                                                 | 18.5.2.1 All . .                                                                                | . . . . . . . . . .                                                                             | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 126     |
-|           |                                                                                                 | 18.5.2.1.1                                                                                      | Globals . . . .                                                                                 | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 126     |
-|           |                                                                                                 | 18.5.2.1.2                                                                                      | Globals . . . .                                                                                 | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 126     |
-|           |                                                                                                 | 18.5.2.1.3                                                                                      | Globals . . . .                                                                                 | . . . . . . . . . . . . . . . . . . . . . . . . .                                                                               | 126     |
-|           |                                                                                                 | 18.5.2.1.4                                                                                      | Globals . . . .                                                                                 | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                       | 126     |
-|           |                                                                                                 | 18.5.2.1.5                                                                                      | Globals . . . .                                                                                 | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 126     |
-|           |                                                                                                 | 18.5.2.1.6                                                                                      | Globals . . . .                                                                                 | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 126     |
-|           |                                                                                                 | 18.5.2.1.7                                                                                      | Globals . . . .                                                                                 | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                     | 126     |
-|           |                                                                                                 | 18.5.2.1.8                                                                                      | Globals . .                                                                                     | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 126     |
-|           |                                                                                                 | 18.5.2.1.9                                                                                      | Globals                                                                                         |                                                                                                                                 | 126     |
-|           |                                                                                                 |                                                                                                 | . .                                                                                             | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                         | 126     |
-|           |                                                                                                 | 18.5.2.2 Functions 18.5.2.2.1                                                                   | . . . . . . . Globals . . .                                                                     | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . | 126     |
-|           |                                                                                                 | 18.5.2.2.2                                                                                      | Globals . .                                                                                     | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 126     |
-|           |                                                                                                 | 18.5.2.2.3                                                                                      | Globals . .                                                                                     | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                             | 126     |
-|           |                                                                                                 | 18.5.2.3 Globals                                                                                | . . . . . . .                                                                                   | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                             | 126     |
-|           |                                                                                                 | 18.5.2.4 Globals                                                                                | . . . . . . .                                                                                   | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                               | 126     |
-|           |                                                                                                 |                                                                                                 | . . . . . .                                                                                     | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                       | 126     |
-|           |                                                                                                 | 18.5.2.5 Globals                                                                                | Enumerator . . . . . .                                                                          | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                 | 126     |
-|           |                                                                                                 | 18.5.2.6 18.5.2.6.1                                                                             | Globals . . . .                                                                                 | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 126     |
-|           |                                                                                                 | 18.5.2.6.2                                                                                      | Globals .                                                                                       | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                     | 126     |
-|           |                                                                                                 | Globals                                                                                         | .                                                                                               | . . . .                                                                                                                         |         |
-|           | 18.5.2.7                                                                                        |                                                                                                 | . . . . . .                                                                                     | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                             | 126     |
-|           | C++ language extensions                                                                         | C++ language extensions                                                                         | C++ language extensions                                                                         |                                                                                                                                 | 127     |
-| 19.1      | Function-type                                                                                   | qualifiers                                                                                      | . . . . . . . . . .                                                                             | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 127 127 |
-|           | 19.1.1                                                                                          | __device__ . .                                                                                  | . . . . . . . . . . . . . .                                                                     | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .     | 128     |
-|           | 19.1.2                                                                                          | __global__                                                                                      | . . . . . .                                                                                     |                                                                                                                                 |         |
-|           | 19.1.3                                                                                          | __host__ . . .                                                                                  | . . . . . . . . . .                                                                             | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 128     |
-| 19.2 19.3 | Calling __global__ functions . . . . .                                                          | Calling __global__ functions . . . . .                                                          | . . . .                                                                                         | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .     | 128 129 |
-| 19.4      | Kernel launch example . . . . . . . . Variable type qualifiers . . . . . . . .                  | Kernel launch example . . . . . . . . Variable type qualifiers . . . . . . . .                  | . .                                                                                             | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 130     |
-|           | .                                                                                               | .                                                                                               | .                                                                                               |                                                                                                                                 | 130     |
-|           | 19.4.1                                                                                          | __constant__                                                                                    | . . . . . . . . . .                                                                             | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                 |         |
-|           | 19.4.2                                                                                          | __shared__ .                                                                                    | . . . . . . . . . .                                                                             | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                     | 130     |
-|           | 19.4.3                                                                                          | __managed__ .                                                                                   | . . . . . . . . . .                                                                             | . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                             | 130     |
-|           | 19.4.4                                                                                          | __restrict__                                                                                    | . . . . . . . . .                                                                               | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                         | 130     |
-| 19.5      | . Built-in variables . . . . . . . . . . .                                                      | . Built-in variables . . . . . . . . . . .                                                      | . .                                                                                             | . . . . . . . . .                                                                                                               | 130     |
-|           | 19.5.1                                                                                          | Coordinate built-ins                                                                            | . . . . . . .                                                                                   | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                   | 130     |
-|           | 19.5.2                                                                                          | warpSize . . .                                                                                  | . . . . . . . . . .                                                                             | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                                   | 131     |
-| 19.6      | Vector types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                    | Vector types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                    | Vector types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                    | . . . . . . . . .                                                                                                               | 131     |
-|           | 19.6.1                                                                                          | Short vector types                                                                              | . . . . . .                                                                                     | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                                 | 131     |
-| 19.7      | 19.6.2 dim3 . . . . . . . . . . . . . . . . . . Memory fence instructions . . . . . . . . . . . | 19.6.2 dim3 . . . . . . . . . . . . . . . . . . Memory fence instructions . . . . . . . . . . . | 19.6.2 dim3 . . . . . . . . . . . . . . . . . . Memory fence instructions . . . . . . . . . . . | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132         | 132     |
-
-19.8
-
-Synchronization functions
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-.
-
-132
-
-|                   | .                                                                                                             | . .                                                                                                           |         |
-|-------------------|---------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------|---------|
-| 19.9              | Math                                                                                                          | functions . . . . . . . . . . .                                                                               | 132     |
-| 19.10             | Texture                                                                                                       | functions . . . . . . . . . . . . .                                                                           | 133     |
-| 19.11             | Surface                                                                                                       | functions . . . . . . . . . . . . .                                                                           | 133     |
-| 19.12             | Timer                                                                                                         | functions . . . . . . . . . . . . . .                                                                         | 137     |
-| 19.13             | Atomic                                                                                                        | functions                                                                                                     | 138     |
-|                   | 19.13.1                                                                                                       | . . . . . . . . . . . . . Unsafe floating-point atomic RMWoperations                                          | 139     |
-| 19.14             | Warp cross-lane                                                                                               | functions . .                                                                                                 | 140     |
-|                   | 19.14.1                                                                                                       | . . . . . . Warp vote and ballot functions .                                                                  | 140     |
-|                   | 19.14.2 Warp                                                                                                  | match functions . . . . .                                                                                     | 141     |
-|                   | 19.14.3                                                                                                       | . Warp shuffle functions . . . . .                                                                            | 142     |
-| 19.15             | Cooperative groups                                                                                            | functions . . . . . .                                                                                         | 142     |
-| 19.16             | Warp matrix                                                                                                   | functions . . . . . . .                                                                                       | 143     |
-| 19.17             | Independent                                                                                                   | . . . thread scheduling . . . . . .                                                                           | 144     |
-| 19.18             | Profiler                                                                                                      | Counter Function . . . . . . . .                                                                              | 144     |
-| 19.19             | Assert . . . . .                                                                                              | . . . . . . . . . . . . . .                                                                                   | 144     |
-| 19.20             | . . . .                                                                                                       | printf . . . . . . . . . . . . . .                                                                            | 144     |
-| 19.21             |                                                                                                               | Device-Side Dynamic Global Memory Allocation . . . . . . . .                                                  | 145     |
-| 19.22             |                                                                                                               | __launch_bounds__ . .                                                                                         | 145     |
-|                   | 19.22.1                                                                                                       | Compiler Impact . . . . . . . .                                                                               | 145     |
-|                   | 19.22.2                                                                                                       | CU and EU Definitions . . . . .                                                                               | 146 146 |
-|                   | 19.22.3 19.22.4 maxregcount                                                                                   | Porting from CUDA __launch_bounds . . . . . . . . . .                                                         | 146     |
-| 19.23             |                                                                                                               | Asynchronous Functions . . . . . . . . .                                                                      | 147     |
-|                   | 19.23.1                                                                                                       | Memory stream . . . . . . . . .                                                                               | 147     |
-|                   | 19.23.2                                                                                                       | Peer to peer . . . . . .                                                                                      | 163     |
-|                   | 19.23.3                                                                                                       | . . . . . Memory management . . .                                                                             | 165     |
-|                   | 19.23.4                                                                                                       | . . . External Resource Interoperability                                                                      | 195     |
-|                   | Register                                                                                                      | Keyword . . . . . . . . . . . . .                                                                             | 197     |
-| 19.24             | 19.25 Pragma                                                                                                  | Unroll . . . . . . . . . . . . .                                                                              | 198     |
-| 19.26             | In-Line                                                                                                       | Assembly . . . . . . . . . . . .                                                                              | 198     |
-| 19.27             | Kernel                                                                                                        | Compilation . . . . . . . . . . .                                                                             | 198     |
-| 19.28             |                                                                                                               |                                                                                                               |         |
-|                   |                                                                                                               | gfx-arch-specific-kernel . . . . . . . . .                                                                    | 199     |
-| C++ language 20.1 | 20.1.1                                                                                                        | Modern C++ support . . . . . . . . . . . C++11 support . . . . . . . . .                                      | 201 201 |
-|                   | 20.1.2                                                                                                        | C++14 support . . . . . . . . .                                                                               | 202     |
-|                   | 20.1.3                                                                                                        | C++17 support . . . . . . . . .                                                                               | 202     |
-|                   | 20.1.4                                                                                                        | C++20 support . . . . . . . . .                                                                               | 202     |
-| 20.2              | Extensions                                                                                                    | and restrictions . . . . . . . .                                                                              | 202     |
-|                   | 20.2.1                                                                                                        | Global functions . .                                                                                          | 202     |
-|                   | 20.2.2                                                                                                        | . . . . . . Device space memory specifiers . . . .                                                            | 202     |
-|                   | 20.2.3                                                                                                        | Exception handling . . . . .                                                                                  | 203     |
-|                   | 20.2.4                                                                                                        | Kernel parameters . . . . . .                                                                                 | 203     |
-|                   | 20.2.5                                                                                                        | Classes . . . .                                                                                               | 203     |
-|                   | 20.2.6                                                                                                        | . . . . . . . . . Polymorphic function wrappers .                                                             | 203     |
-|                   | 20.2.7                                                                                                        | Extended lambdas . . . . . . . .                                                                              | 203     |
-|                   |                                                                                                               | Inline namespaces                                                                                             |         |
-|                   | 20.2.8                                                                                                        | . . . . . . .                                                                                                 | 203     |
-|                   |                                                                                                               | .                                                                                                             | 205     |
-| 21 HIP math       | API                                                                                                           | API                                                                                                           | 205     |
-| 21.1              | Single precision mathematical functions . . . . Double precision mathematical functions . . . Integer . . . . | Single precision mathematical functions . . . . Double precision mathematical functions . . . Integer . . . . | 215     |
-| 21.2              | intrinsics . . . . . . . . . . . .                                                                            | intrinsics . . . . . . . . . . . .                                                                            |         |
-| 21.3              |                                                                                                               |                                                                                                               | 225     |
-
-|    | 21.4                                                                                       | Floating-point Intrinsics . . . . . . . . . . . . . .                                      | 227   |
-|----|--------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------|-------|
-| 22 | Table                                                                                      | comparing syntax for different compute APIs                                                | 231   |
-|    | 22.1                                                                                       | Notes . . . . . . . . . . . . . . . . . . . . . . . .                                      | 232   |
-| 23 | HIP                                                                                        | Cooperative groups API                                                                     | 233   |
-|    | 23.1                                                                                       | Cooperative kernel launches . . . . . . . . . . . .                                        | 233   |
-|    | 23.2                                                                                       | Cooperative groups classes . . . . . . . . . . . . .                                       | 234   |
-|    | 23.3                                                                                       | Cooperative groups construct functions . . . .                                             | 237   |
-|    | 23.4                                                                                       | . . Cooperative groups exposed API functions . . . .                                       | 238   |
-| 24 | HSA runtime API for ROCm                                                                   | HSA runtime API for ROCm                                                                   | 241   |
-| 25 | HIP managed memory allocation API                                                          | HIP managed memory allocation API                                                          | 247   |
-| 26 | HIP virtual memory management API                                                          | HIP virtual memory management API                                                          | 251   |
-| 27 | HIP deprecated                                                                             | runtime API functions                                                                      |       |
-|    |                                                                                            |                                                                                            | 257   |
-|    | 27.1                                                                                       | Context management . . . . . . . . . . . . . . . .                                         | 257   |
-|    | 27.2                                                                                       | Memory management . . . . . . . . . . . . . . . . . .                                      | 258   |
-|    | 27.3                                                                                       | Profiler control . . . . . . . . . . . . . . . .                                           | 258   |
-|    | 27.4                                                                                       | Texture management . . . . . . . . . . . . . . . .                                         | 258   |
-| 28 | SAXPY - Hello, HIP                                                                         | SAXPY - Hello, HIP                                                                         | 261   |
-|    | 28.1 Prerequisites . . . . . .                                                             | . . . . . . . . . . .                                                                      | 261   |
-|    | . . . 28.2 Heterogeneous programming                                                       | . . . . . . . . .                                                                          | 261   |
-|    | . . 28.3 Your first lines of HIP code . . .                                                | . . . . . .                                                                                | 261   |
-|    | . . . 28.4 Compiling on the command line . . . .                                           | . . . . . .                                                                                | 263   |
-|    | 28.4.1 Setting up the command line                                                         | . . . . . . .                                                                              | 263   |
-|    | 28.4.2                                                                                     | Invoking the compiler manually . . . . .                                                   | 266   |
-| 29 | Reduction                                                                                  | Reduction                                                                                  | 273   |
-|    | 29.1 The algorithm . . . 29.2                                                              | . . . . . . . . . . . . . . . .                                                            | 273   |
-|    | Reduction on GPUs                                                                          | . . . . . . . . . . . . . . . .                                                            | 273   |
-|    | 29.2.1 Naive shared reduction                                                              | . . . . . . . . . .                                                                        | 274   |
-|    | 29.2.2                                                                                     | Reducing thread divergence . . . . . . . .                                                 | 276   |
-|    | 29.2.3                                                                                     | Resolving bank conflicts . . . . . . . . .                                                 | 276   |
-|    | 29.2.4                                                                                     | Utilize upper half of the block . . . . . . . . . . . . .                                  | 277   |
-|    | 29.2.5                                                                                     | Unroll all loops . . . . . . .                                                             | 281   |
-|    | 29.2.6                                                                                     | Communicate using warp-collective functions                                                | 282   |
-|    | 29.2.7                                                                                     | Prefer warp communication over shared                                                      | 282   |
-|    | 29.2.8                                                                                     | . Amortize bookkeeping variable overhead                                                   | 284   |
-|    | 29.2.8.1 Reading ItemsPerThread                                                            | . . .                                                                                      | 285   |
-|    | 29.2.8.2 Processing ItemsPerThread                                                         | . .                                                                                        | 286   |
-|    | 29.2.9 Two-pass reduction                                                                  | . . . . . . . . . . . .                                                                    | 286   |
-|    | 29.2.10 Global data share                                                                  | . . . . . . . . . . . . .                                                                  | 286   |
-|    | 29.3 Conclusion . . . . .                                                                  | . . . . . . . . . . . . . . . .                                                            | 287   |
-| 30 | Cooperative groups .                                                                       | Cooperative groups .                                                                       | 289   |
-|    | 30.1 Prerequisites                                                                         | . . . . . . . . . . . . . . . . . . .                                                      | 289   |
-|    | 30.2 Simple HIP Code                                                                       | . . . . . . . . . . . . . . . . . .                                                        | 289   |
-|    | Tiled partition                                                                            | . . . . . . .                                                                              | 289   |
-|    | 30.3 . . . . . . . . . . . . 30.3.1 Device-side code . . . . . .                           | . . .                                                                                      | 290   |
-|    | . . . . 30.3.1.1 1. Initialization of the reduction                                        | . . . . 30.3.1.1 1. Initialization of the reduction                                        | 291   |
-|    | function variables . . . 30.3.1.2 2. The reduction of thread block . . . . . . . . . . . . | function variables . . . 30.3.1.2 2. The reduction of thread block . . . . . . . . . . . . | 291   |
-
-|                     | 30.3.1.3 3. The reduction of custom partition . . . . . . . . . . . . . . . . . . . . . . . . . .   |   291 |
-|---------------------|-----------------------------------------------------------------------------------------------------|-------|
-| 30.3.2              | Host-side code . . . . . . . . . . . .                                                              |   292 |
-|                     | 30.3.2.1 1. Confirm the cooperative group support on AMDGPUs 30.3.2.2 . . . . .                     |   292 |
-|                     | 2. Initialize the cooperative group configuration . . . . . . . . . . . . . . . . . . .             |   293 |
-| 30.3.2.3 Conclusion | 4. Launch the kernel . . . . .                                                                      |   293 |
-| 30.4 .              | . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                           |   293 |
-| 31 License          |                                                                                                     |   295 |
-
-Index
-
-297
-
-The Heterogeneous-computing Interface for Portability (HIP) API is a C++ runtime API and kernel language that lets developers create portable applications for AMD and NVIDIA GPUs from single source code.
-
-For HIP supported AMD GPUs on multiple operating systems, see:
-
-- Linux system requirements
-- Microsoft Windows system requirements
-
-The CUDA enabled NVIDIA GPUs are supported by HIP. For more information, see GPU Compute Capability.
-
-On the AMD ROCm platform, HIP provides header files and runtime library built on top of HIP-Clang compiler in the repository Common Language Runtimes (CLR) , which contains source codes for AMD's compute languages runtimes as follows,
-
-On non-AMD platforms, like NVIDIA, HIP provides header files required to support non-AMD specific back-end implementation in the repository 'hipother', which translates from the HIP runtime APIs to CUDA runtime APIs.
-
-## Install
-
-- Installing HIP
-- Building HIP from source
-
-## Conceptual
-
-- HIP programming model
-- Hardware implementation
-- AMD common language runtimes (CLR)
-
-## How to
-
-- Programming manual
-- HIP porting guide
-- HIP porting: driver API guide
-- Programming for HIP runtime compiler (RTC)
-- Performance guidelines
-- Debugging with HIP
-- Logging HIP activity
-- Unified memory
-- Virtual memory
-- Cooperative groups
-- Frequently asked questions
-
-## Reference
-
-- HIP Runtime API Reference
-- C++ language extensions
-- C++ language support
-- HIP math API
-- Comparing syntax for different APIs
-- HSA runtime API for ROCm
-- HIP managed memory allocation API
-
-## CHAPTER ONE
-
-## OVERVIEW
-
-- HIP virtual memory management API
-- HIP Cooperative groups API
-- List of deprecated APIs
-
-## Tutorial
-
-- HIP basic examples
-- HIP examples
-- HIP test samples
-- SAXPY tutorial
-- Reduction tutorial
-- Cooperative groups tutorial
-
-Known issues are listed on the HIP GitHub repository.
-
-To contribute features or functions to the HIP project, refer to Contributing to HIP. To contribute to the documentation, refer to Contributing to ROCm docs page.
-
-You can find licensing information on the Licensing page.
-
-## CHAPTER
-
-## TWO
-
-## INSTALL HIP
-
-HIP can be installed on AMD (ROCm with HIP-Clang) and NVIDIA (CUDA with NVCC) platforms.
-
-Note: The version definition for the HIP runtime is different from CUDA. On an AMD platform, the hipRuntimeGerVersion function returns the HIP runtime version; on an NVIDIA platform, this function returns the CUDA runtime version.
-
-## 2.1 Prerequisites
-
-## AMD
-
-Refer to the Prerequisites section in the ROCm install guides:
-
-- System requirements (Linux)
-- System requirements (Windows)
-
-## NVIDIA
-
-Check the system requirements in the NVIDIA CUDA Installation Guide.
-
-## 2.2 Installation
-
-## AMD
-
-HIP is automatically installed during the ROCm installation. If you haven't yet installed ROCm, you can find installation instructions here:
-
-- ROCm installation for Linux
-- HIP SDK installation for Windows
-
-By default, HIP is installed into /opt/rocm/hip .
-
-Note: There is no autodetection for the HIP installation. If you choose to install it somewhere other than the default location, you must set the HIP\_PATH environment variable as explained in Build HIP from source.
-
-## NVIDIA
-
-1. Install the NVIDIA driver.
-
-sudo apt-get install ubuntu-drivers-common &amp;&amp; sudo ubuntu-drivers autoinstall sudo reboot
-
-Alternatively, you can download the latest CUDA Toolkit.
-
-2. Install the hip-runtime-nvidia and hip-dev packages. This installs the CUDA SDK and HIP porting layer.
-
-```
-  | apt-get install hi
-```
-
-```
-tall hip-runtime-nvidia hip-dev
-```
-
-## The default paths are:
-
-- CUDA SDK: /usr/local/cuda
-- HIP: /opt/rocm/hip
-
-You can optionally add /opt/rocm/bin to your path, which can make it easier to use the tools.
-
-## 2.3 Verify your installation
-
-Run hipconfig in your installation path.
-
-/opt/rocm/bin/hipconfig --full
-
-CHAPTER
-
-## THREE
-
-## BUILD HIP FROM SOURCE
-
-## 3.1 Prerequisites
-
-HIP code can be developed either on AMD ROCm platform using HIP-Clang compiler, or a CUDA platform with nvcc installed. Before building and running HIP, make sure drivers and prebuilt packages are installed properly on the platform.
-
-You also need to install Python 3, which includes the CppHeaderParser package. Install Python 3 using the following command:
-
-```
-    | apt-get install python3
-```
-
-Check and install CppHeaderParser package using the command:
-
-```
-      | pip3 install CppHeaderParser
-```
-
-## 3.2 Building the HIP runtime
-
-Set the repository branch using the variable: ROCM\_BRANCH . For example, for ROCm 6.1, use:
-
-```
-| export
-```
-
-```
-<_Bash_>
-```
-
-## AMD
-
-1. Get HIP source code.
-
-Note: Starting in ROCM 5.6, CLR is a new repository that includes the former ROCclr, HIPAMD and OpenCl repositories. OpenCL provides headers that ROCclr runtime depends on.
-
-Note: Starting in ROCM 6.1, a new repository hipother is added to ROCm, which is branched out from HIP. hipother provides files required to support the HIP back-end implementation on some non-AMD platforms, like NVIDIA.
-
-```
-<_Bash_>
-```
-
-```
-:lone -b "$ROCM_BRANCH" https://github.com/ROCm/clr.git
-:lone -b "$ROCM_BRANCH" https://github.com/ROCm/hip.git
-```
-
-CLR (Common Language Runtime) repository includes ROCclr, HIPAMD and OpenCL.
-
-ROCclr (Radeon Open Compute Common Language Runtime) is a virtual device interface which is defined on the AMD platform. HIP runtime uses ROCclr to interact with different backends.
-
-HIPAMD provides implementation specifically for HIP on the AMD platform.
-
-OpenCL provides headers that ROCclr runtime currently depends on. hipother provides headers and implementation specifically for non-AMD HIP platforms, like NVIDIA.
-
-2. Set the environment variables.
-3. Build HIP.
-
-```
-<_Bash_>
-```
-
-```
-        cd "$CLR_DIR"
-        mkdir -p build; cd build
-        cmake -DHIP_COMMON_DIR=$HIP_DIR -DHIP_PLATFORM=amd -DCMAKE_PREFIX_PATH="/opt/rocm/"_
-        ---DCMAKE_INSTALL_PREFIX=$PWD/install -DHIP_CATCH_TEST=0 -DCLR_BUILD_HIP=ON -DCLR_
-        --BUILD_OCL=OFF..
-        
-        make -j$(nproc)
-        sudo make install
-```
-
-Note: Note, if you don't specify CMAKE\_INSTALL\_PREFIX , the HIP runtime is installed at &lt;ROCM\_PATH&gt;/hip .
-
-By default, release version of HIP is built. If need debug version, you can put the option CMAKE\_BUILD\_TYPE=Debug in the command line.
-
-Default paths and environment variables:
-
-- HIP is installed into &lt;ROCM\_PATH&gt;/hip . This can be overridden by setting the HIP\_PATH environment variable.
-
-•
-
-HSA is in
-
-&lt;ROCM\_PATH&gt;/hsa
-
-. This can be overridden by setting the
-
-HSA\_PATH
-
-environment variable.
-
-- Clang is in &lt;ROCM\_PATH&gt;/llvm/bin . This can be overridden by setting the HIP\_CLANG\_PATH environment variable.
-- The device library is in &lt;ROCM\_PATH&gt;/lib . This can be overridden by setting the DEVICE\_LIB\_PATH environment variable.
-- Optionally, you can add &lt;ROCM\_PATH&gt;/bin to your PATH , which can make it easier to use the tools.
-- Optionally, you can set HIPCC\_VERBOSE=7 to output the command line for compilation.
-
-After you run the make install command, make sure HIP\_PATH points to $PWD/install/hip .
-
-1. Generate a profiling header after adding/changing a HIP API.
-
-Whenyouadd or change a HIP API, you may need to generate a new hip\_prof\_str.h header. This header is used by ROCm tools to track HIP APIs, such as rocprofiler and roctracer .
-
-To generate the header after your change, use the hip\_prof\_gen.py tool located in hipamd/src .
-
-Usage:
-
-```
-<_PHP_>
-```
-
-```
-                                                                                                                                                                                                        |                                                                                                                                                                                                       
-                                                                                                                                                                                                        <! hip_prof_gen.py                                                                                                                                                                                                        </!                                                                                                                                                                                                        >
-                                                                                                                                                                                                       <?php                                                                                                                                                                                                        +
-```
-
-## Flags:
-
-- -v : Verbose messages
-- -r : Process source directory recursively
-- -t : API types matching check
-- --priv : Private API check
-- -e : On error exit mode
-- -p : HIP\_INIT\_API macro patching mode
-
-Example usage:
-
-```
-<_Bash_>
-```
-
-## NVIDIA
-
-```
-git clone -b "$ROCM_BRANCH" https://github.com/ROCm/clr.git
-git clone -b "$ROCM_BRANCH" https://github.com/ROCm/hip.git
-git clone -b "$ROCM_BRANCH" https://github.com/ROCm/hipother.git
-```
-
-```
---- ---
-
-    1. Get the HIP source code.
-        git clone -b "$ROCM_BRANCH"
-        git clone -b "$ROCM_BRANCH"
-        git clone -b "$ROCM_BRANCH"
-
-    2. Set the environment variables.
-```
-
-```
-export CLR_DIR="$(readlink -f clr)"
-export HIP_DIR="$(readlink -f hip)"
-export HIP_OTHER="$(readlink -f hipother)"
-```
-
-```
-3.  Build HIP.
-```
-
-```
-cd "$CLR_DIR"
-mkdir -p build; cd build
-cmake -DHIP_COMMON_DIR=$HIP_DIR -DHIP_PLATFORM=nvidia -DCMAKE_INSTALL_PREFIX=$PWD/
- --install -DHIP_CATCH_TEST=0 -DCLR_BUILD_HIP=ON -DCLR_BUILD_OCL=OFF -DHIPNV_DIR=
- --$HIP_OTHER/hipnv..
-make -j$(nproc)
-sudo make install
-```
-
-## 3.3 Build HIP tests
-
-## AMD
-
-- Build HIP catch tests.
-
-```
-git clone -b "$ROCM_BRANCH" https://github.com/ROCm/hip-tests.git  |
-```
-
-```
-        - npm -m -cos no-source.
-
-            export HIPTESTS_DIR="$(readlink -f hip-tests)"
-            cd "$HIPTESTS_DIR"
-            mkdir -p build; cd build
-            cmake../catch -DHIP_PLATFORM=amd -DHIP_PATH=$CLR_DIR/build/
-            --install  # or any path where HIP is installed; for example: ``/
-            --opt/rocm``
-            make build_tests
-            ctest # run tests
-```
-
-```
-AMD
-
-     *  Build HIP catch tests.
-
-                HIP catch tests are separate from the HIP project and use Catch2.
-
-                    - Get HIP tests source code.
-```
-
-```
-      - command: command.json.
-        
-          cd "$HIPTESTS_DIR"
-          hipcc $HIPTESTS_DIR/catch/unit/memory/hipPointerGetAttributes.cc \
-          -I./catch/include./catch/hipTestMain/standalone_main.cc \
-          -I./catch/external/Catch2 -o hipPointerGetAttributes
-         ./hipPointerGetAttributes
-         ...
-
-          All tests passed
-```
-
-## NVIDIA
-
-The commands to build HIP tests on an NVIDIA platform are the same as on an AMD platform. However, you must first set -DHIP\_PLATFORM=nvidia .
-
-## 3.4 Run HIP
-
-After installation and building HIP, you can compile your application and run. A simple example is square sample.
-
-## FOUR
-
-## HIP PROGRAMMING MODEL
-
-The HIP programming model makes it easy to map data-parallel C/C++ algorithms to massively parallel, wide single instruction, multiple data (SIMD) architectures, such as GPUs.
-
-While the model may be expressed in most imperative languages, (for example Python via PyHIP) this document will focus on the original C/C++ API of HIP.
-
-A basic understanding of the underlying device architecture helps you make efficient use of HIP and general purpose graphics processing unit (GPGPU) programming in general.
-
-## 4.1 RDNA &amp; CDNA architecture summary
-
-GPUs in general are made up of basic building blocks called compute units (CUs), that execute the threads of a kernel. These CUs provide the necessary resources for the threads: the Arithmetic Logical Units (ALUs), register files, caches and shared memory for efficient communication between the threads.
-
-This design allows for efficient execution of kernels while also being able to scale from small GPUs embedded in APUs with few CUs up to GPUs designed for data centers with hundreds of CUs. Figure Block Diagram of an RDNA3 Compute Unit. and Block Diagram of a CDNA3 Compute Unit. show examples of such compute units.
-
-For architecture details, check Hardware implementation .
-
-Fig. 1: Block Diagram of an RDNA3 Compute Unit.
-
-Schedule.
-
-![Image](data:image/png;base64,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)
-
-Fig. 2: Block Diagram of a CDNA3 Compute Unit.
-
-The image depicts a horizontal bar chart titled "Local Data Share." The chart is divided into two main sections: the left section and the right section.
-
-### Left Section:
-- **Title:** "Local Data Share"
-- **X-axis:** Labeled "Schedule"
-- **Y-axis:** Labeled "Matrix Core Unit"
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
-- **Data Points:** 10
--
-
-![Image](data:image/png;base64,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)
-
-## 4.2 Heterogeneous Programming
-
-The HIP programming model assumes two execution contexts. One is referred to as host while compute kernels execute on a device . These contexts have different capabilities, therefor slightly different rules apply. The host execution is defined by the C++ abstract machine, while device execution follows the SIMT model of HIP. These execution contexts in code are signified by the \_\_host\_\_ and \_\_device\_\_ decorators. There are a few key differences between the two:
-
-- The C++ abstract machine assumes a unified memory address space, meaning that one can always access any given address in memory (assuming the absence of data races). HIP however introduces several memory namespaces, an address from one means nothing in another. Moreover, not all address spaces are accessible from all contexts.
-- Looking at Block Diagram of an RDNA3 Compute Unit. and Block Diagram of a CDNA3 Compute Unit. , you can see that every CU has an instance of storage backing the namespace \_\_shared\_\_ . Even if the host were to have access to these regions of memory, the performance benefits of the segmented memory subsystem are supported by the inability of asynchronous access from the host.
-- Not all C++ language features map cleanly to typical device architectures, some are very expensive (meaning slow) to implement on GPU devices, therefor they are forbidden in device contexts to avoid users tapping into features that unexpectedly decimate their program's performance. Offload devices targeted by HIP aren't general purpose devices, at least not in the sense that a CPU is. HIP focuses on data parallel computations and as such caters to throughput optimized architectures, such as GPUs or accelerators derived from GPU architectures.
-- Asynchrony is at the forefront of the HIP API. Computations launched on the device execute asynchronously with respect to the host, and it is the user's responsibility to synchronize their data dispatch/fetch with computations on the device.
-
-Note: HIP does perform implicit synchronization on occasions, more advanced than other APIs such as OpenCL or SYCL, in which the responsibility of synchronization mostly depends on the user.
-
-## 4.3 Single instruction multiple threads (SIMT)
-
-The SIMT programming model behind the HIP device-side execution is a middle-ground between SMT (Simultaneous Multi-Threading) programming known from multicore CPUs, and SIMD (Single Instruction, Multiple Data) programming mostly known from exploiting relevant instruction sets on CPUs (for example SSE/AVX/Neon).
-
-A HIP device compiler maps SIMT code written in HIP C++ to an inherently SIMD architecture (like GPUs). This is done by scalarizing the entire kernel and issuing the scalar instructions of multiple kernel instances (called threads) to each of the SIMD engine lanes, rather than exploiting data parallelism within a single instance of a kernel and spreading identical instructions over the available SIMD engines.
-
-Consider the following kernel:
-
-```
-__global__ void k(float4* a, const float4* b)
-{
-  int tid = threadIdx.x;
-  int bid = blockIdx.x;
-  int dim = blockDim.x;
-
-  a[tid] += (tid + bid - dim) * b[tid];
-}
-```
-
-The incoming four-vector of floating-point values b is multiplied by a scalar and then added element-wise to the fourvector floating-point values of a . On modern SIMD-capable architectures, the four-vector ops are expected to compile to a single SIMD instruction. However, GPU execution of this kernel will typically break down the vector elements into 4 separate threads for parallel execution, as seen in the following figure:
-
-Fig. 3: Instruction flow of the sample SIMT program.
-
-In HIP, lanes of the SIMD architecture are fed by mapping threads of a SIMT execution, one thread down each lane of an SIMD engine. Execution parallelism usually isn't exploited from the width of the built-in vector types, but across multiple threads via the thread ID constants threadIdx.x , blockIdx.x , etc.
-
-## 4.4 Inherent thread model
-
-The SIMT nature of HIP is captured by the ability to execute user-provided device programs, expressed as single-source C/C++ functions or sources compiled online/offline to binaries, in bulk.
-
-All threads of a kernel are uniquely identified by a set of integral values, called thread IDs. The set of integers identifying a thread relate to the hierarchy in which the threads execute.
-
-The thread hierarchy inherent to how AMD GPUs operate is depicted in the following figure.
-
-Fig. 4: Hierarchy of thread groups.
-
-## Warp (or Wavefront)
-
-The innermost grouping of threads is called a warp, or a wavefront in ISA terms. A warp is the most tightly coupled groups of threads, both physically and logically. Threads inside a warp are also called lanes, and the integral value identifying them is the lane ID.
-
-Tip: Lane IDs aren't queried like other thread IDs, but are user-calculated. As a consequence, they are only as multidimensional as the user interprets the calculated values to be.
-
-The size of a warp is architecture dependent and always fixed. For AMD GPUs the wavefront is typically 64 threads, though sometimes 32 threads. Warps are signified by the set of communication primitives at their disposal, as discussed in Warp cross-lane functions .
-
-The middle grouping is called a block or thread block. The defining feature of a block is that all threads in a block will share an instance of memory which they may use to share data or synchronize with one another.
-
-The size of a block is user-configurable but is limited by the queryable capabilities of the executing hardware. The unique ID of the thread within a block is 3-dimensional as provided by the API. When linearizing thread IDs within a block, assume the 'fast index' being dimension x , followed by the y and z dimensions.
-
-## Block
-
-## Grid
-
-The outermost grouping is called a grid. A grid manifests as a single dispatch of kernels for execution. The unique ID of each block within a grid is 3-dimensional, as provided by the API and is queryable by every thread within the block.
-
-## 4.4.1 Cooperative groups thread model
-
-The Cooperative groups API introduces new APIs to launch, group, subdivide, synchronize and identify threads, as well as some predefined group-collective algorithms, but most importantly a matching threading model to think in terms of. It relaxes some restrictions of the Inherent thread model imposed by the strict 1:1 mapping of architectural details to the programming model. Cooperative groups let you define your own set of thread groups which may fit your user-cases better than the defaults defined by the hardware.
-
-Note: The implicit groups defined by kernel launch parameters are still available when working with cooperative groups.
-
-For further information, see Cooperative groups.
-
-## 4.5 Memory model
-
-The hierarchy of threads introduced by the Inherent thread model is induced by the memory subsystem of GPUs. The following figure summarizes the memory namespaces and how they relate to the various levels of the threading model.
-
-Fig. 5: Memory hierarchy.
-
-## Local or per-thread memory
-
-Read-write storage only visible to the threads defining the given variables, also called per-thread memory. The size of a block for a given kernel, and thereby the number of concurrent warps, are limited by local memory usage. This relates to an important aspect: occupancy. This is the default memory namespace.
-
-## Shared memory
-
-Read-write storage visible to all the threads in a given block.
-
-## Global
-
-Read-write storage visible to all threads in a given grid. There are specialized versions of global memory with different usage semantics which are typically backed by the same hardware storing global.
-
-## Constant
-
-Read-only storage visible to all threads in a given grid. It is a limited segment of global with queryable size.
-
-## Texture
-
-Read-only storage visible to all threads in a given grid and accessible through additional APIs.
-
-## Surface
-
-A read-write version of texture memory.
-
-## 4.6 Execution model
-
-HIP programs consist of two distinct scopes:
-
-- The host-side API running on the host processor. There are two APIs available:
-- -The HIP runtime API which enables use of the single-source programming model.
-- -The HIP driver API which sits at a lower level and most importantly differs by removing some facilities provided by the runtime API, most importantly around kernel launching and argument setting. It is geared towards implementing abstractions atop, such as the runtime API itself. Offers two additional pieces of functionality not provided by the Runtime API: hipModule and hipCtx APIs. For further details, check HIP driver API.
-- The device-side kernels running on GPUs. Both the host and the device-side APIs have synchronous and asynchronous functions in them.
-
-Note: The HIP does not present two separate APIs link NVIDIA CUDA. HIP only extends the HIP runtime API with new APIs for hipModule and hipCtx .
-
-## 4.6.1 Host-side execution
-
-The part of the host-side API which deals with device management and their queries are synchronous. All asynchronous APIs, such as kernel execution, data movement and potentially data allocation/freeing all happen in the context of device streams.
-
-Streams are FIFO buffers of commands to execute relating to a given device. Commands which enqueue tasks on a stream all return promptly and the command is executed asynchronously. All side effects of a command on a stream are visible to all subsequent commands on the same stream. Multiple streams may point to the same device and those streams may be fed from multiple concurrent host-side threads. Execution on multiple streams may be concurrent but isn't required to be.
-
-Asynchronous APIs involving a stream all return a stream event which may be used to synchronize the execution of multiple streams. A user may enqueue a barrier onto a stream referencing an event. The barrier will block until the command related to the event does not complete, at which point all side effects of the command shall be visible to commands following the barrier, even if those side effects manifest on different devices.
-
-Streams also support executing user-defined functions as callbacks on the host. The stream will not launch subsequent commands until the callback completes.
-
-## 4.6.2 Device-side execution
-
-The SIMT programming model behind the HIP device-side execution is a middle-ground between SMT (Simultaneous Multi-Threading) programming known from multicore CPUs, and SIMD (Single Instruction, Multiple Data) programming mostly known from exploiting relevant instruction sets on CPUs (for example SSE/AVX/Neon).
-
-## 4.6.3 Kernel launch
-
-Kernels may be launched in multiple ways all with different syntaxes and intended use-cases.
-
-- Using the triple-chevron &lt;&lt;&lt;...&gt;&gt;&gt; operator on a \_\_global\_\_ annotated function.
-- Using hipLaunchKernelGGL() on a \_\_global\_\_ annotated function.
-
-Tip: This name by default is a macro expanding to triple-chevron. In cases where language syntax extensions are undesirable, or where launching templated and/or overloaded kernel functions define the HIP\_TEMPLATE\_KERNEL\_LAUNCH preprocessor macro before including the HIP headers to turn it into a templated function.
-
-- Using the launch APIs supporting the triple-chevron syntax directly.
-
-Caution: These APIs are intended to be used/generated by tools such as the HIP compiler itself and not intended towards end-user code. Should you be writing a tool having to launch device code using HIP, consider using these over the alternatives.
-
-## HARDWARE IMPLEMENTATION
-
-This chapter describes the typical hardware implementation of GPUs supported by HIP, and how the Inherent thread model maps to the hardware.
-
-## 5.1 Compute units
-
-The basic building block of a GPU is a compute unit (CU), also known as streaming multiprocessor (SM) on NVIDIA GPUs. The thread blocks making up a grid are scheduled for execution on CUs. Each block is assigned to an individual CU, and a CU can accommodate several blocks. Depending on their resource usage up to thousands of threads can reside on a CU.
-
-CUs contain an array of processing elements, referred to as vector ALU (VALU), that execute the actual instructions of the threads according to the SIMT model , together with the necessary registers and caches.
-
-The threads are executed in groupings called warps. The amount of threads making up a warp is architecture dependent. On AMD GPUs the warp size is commonly 64 threads, except in RDNA architectures which can utilize a warp size of 32 or 64 respectively. The warp size of supported AMD GPUs is listed in the Accelerator and GPU hardware specifications. NVIDIA GPUs have a warp size of 32.
-
-In contrast to CPUs, GPUs generally do not employ complex cache structures or control logic, like branch prediction or out-of-order execution, but instead rely on massive hardware multithreading to hide latency.
-
-Context switching between warps residing on a CU incurs no overhead, as the context for the warps is stored on the CU and does not need to be fetched from memory. If there are not enough free registers to accommodate all warps of a block, the block can not be scheduled to that CU and it has to wait until other blocks finish execution.
-
-The amount of warps that can reside concurrently on a CU, known as occupancy, is determined by the warp's resource usage of registers and shared memory.
-
-Fig. 1: An AMD Graphics Core Next (GCN) CU. The CDNA and RDNA CUs are based on variations of the GCN CU.
-
-On AMD GCN GPUs the basic structure of a CU is:
-
-- four Single Instruction Multiple Data units (SIMDs)
-- a vector cache
-- a local data share
-- and a scalar unit
-
-## 5.1.1 SIMD
-
-A SIMD consists of a VALU, that executes the instruction of a warp, together with a register file, that provides the registers warps.
-
-The size of the warp is inherently related to the width of the vector ALU of the SIMD. On GCN compute units the width of the VALU is 16, so a warp can be issued to a SIMD every 4 cycles. Since a CU has 4 SIMDs it issues one warp per cycle. The instructions of a warp are effectively executed in lock-step.
-
-A SIMD always executes the same instruction for the whole VALU. If the control flow of a warp diverges, the performance is decreased, as the results for the threads that do not participate in that branch have to be masked out, and the instructions of the other branch have to be executed in the same way. The best performance can therefore be achieved when thread divergence is kept to a warp level, i.e. when all threads in a warp take the same execution path.
-
-## 5.1.2 Vector cache
-
-The usage of cache on a GPU differs from that on a CPU, as there is less cache available per thread. Its main purpose is to coalesce memory accesses of the warps in order to reduce the amount of accesses to device memory, and make that memory available for other warps that currently reside on the compute unit, that also need to load those values.
-
-## 5.1.3 Local data share
-
-The local data share is memory that is accessible to all threads within a block. Its latency and bandwidth is comparable to that of the vector cache. It can be used to share memory between the threads in a block, or as a software managed cache.
-
-## 5.1.4 Scalar Unit
-
-The scalar unit performs instructions that are uniform within a warp. It thereby improves efficiency and reduces the pressure on the vector ALUs and the vector register file.
-
-## 5.2 CDNA architecture
-
-The general structure of CUs stays mostly as it is in GCN architectures. The most prominent change is the addition of matrix ALUs, which can greatly improve the performance of algorithms involving matrix multiply-accumulate operations for int8, float16, bfloat16 or float32.
-
-Fig. 2: Block Diagram of a CDNA3 Compute Unit.
-
-The image depicts a horizontal bar chart titled "Local Data Share." The chart is divided into two main sections: the left section and the right section.
-
-### Left Section:
-- **Title:** Local Data Share
-- **X-Axis:** Labeled as "Scheduler" and "Matrix Core Unit"
-- **Y-Axis:** Labeled as "Local Data Share"
-- **Data Points:**
-  - **Leftmost Data Point:** 100
-  - **Rightmost Data Point:** 100
-  - **Leftmost Data Point:** 100
-  - **Rightmost Data Point:** 100
-
-### Right Section:
-- **Title:** Shader Core
-- **X-Axis:** Labeled as "L1 Cache"
-- **Y-Axis:** Labeled as "Shader Core"
-- **Data Points:**
-  - **Leftmost Data Point:** 100
-  - **Rightmost
-
-![Image](data:image/png;base64,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)
-
-## 5.3 RDNA architecture
-
-RDNA makes a fundamental change to CU design, by changing the size of a warp to 32 threads. This is done by effectively combining two GCN5 SIMDs, creating a VALU of width 32, so that a whole warp can be issued in one cycle. The CU is also replaced by the work group processor (WGP), which encompasses two CUs. For backwards compatibility the WGP can also run in wave64 mode, in which it issues a warp of size 64 in two cycles.
-
-It also adds an extra layer of cache to the WGP, shared by the CUs within it. This cache is referred to as L1 cache, promoting the per-CU cache to an L0 cache.
-
-Fig. 3: Block Diagram of an RDNA3 work group processor.
-
-Scheduler Vector GPR.
-
-![Image](data:image/png;base64,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)
-
-## 5.4 Shader engines
-
-For hardware implementation's sake, multiple CUs are grouped together into a Shader Engine or Compute Engine, typically sharing some fixed function units or memory subsystem resources.
-
-Fig. 4: Block Diagram of a CDNA2 Graphics Compute Die.
-
-The image is a table that contains data about different types of fabric. The table is divided into rows and columns, with each row representing a different type of fabric. The columns are labeled as follows:
-
-- Memory
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-- Memory Controller
-
-![Image](data:image/png;base64,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)
-
-## CHAPTER
-
-## SIX
-
-## AMD COMMON LANGUAGE RUNTIMES (CLR)
-
-CLRcontains source codes for AMD's compute languages runtimes: HIP and OpenCL ™ . CLR is the part of HIP runtime which is supported on the AMD ROCm platform, it provides a header and runtime library built on top of HIP-Clang compiler. For developers and users, CLR implements HIP runtime APIs including streams, events, and memory APIs, which is a object library that is linked with the application. The source codes for all headers and the library implementation are available on GitHub in the CLR repository.
-
-## 6.1 Project organization
-
-CLR includes the following source code,
-
-- hipamd - contains implementation of HIP language on the AMD platform. It is hosted at clr/hipamd.
-- opencl - contains implementation of OpenCL™ on AMD platform. It is hosted at clr/opencl.
-- rocclr - contains common runtime used in HIP and OpenCL™ . This is hosted at clr/rocclr.
-
-## 6.2 How to build/install
-
-## 6.2.1 Prerequisites
-
-Please refer to Quick Start Guide in ROCm Docs.
-
-Building CLR requires rocm-hip-libraries meta package, which provides the pre-requisites for CLR.
-
-## 6.2.2 Linux
-
-- Clone this repository
-- For OpenCL ™
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        * For HIP
-```
-
-```
-<_Bash_>
-```
-
-```
-<_Haskell_>
-```
-
-Users can also build OCL and HIP at the same time by passing -DCLR\_BUILD\_HIP=ON -DCLR\_BUILD\_OCL=ON to configure command.
-
-For detail instructions, please refer to build HIP.
-
-## 6.2.3 Test
-
-hip-tests is a separate repository hosted at hip-tests.
-
-To run hip-tests please go to the repository and follow the steps.
-
-## 6.2.4 Release notes
-
-HIP provides release notes in CLR change log, which has records of changes in each release.
-
-## 7.1 Host Memory
-
-## 7.1.1 Introduction
-
-hipHostMalloc allocates pinned host memory which is mapped into the address space of all GPUs in the system, the memory can be accessed directly by the GPU device, and can be read or written with much higher bandwidth than pageable memory obtained with functions such as malloc() . There are two use cases for this host memory:
-
-- Faster HostToDevice and DeviceToHost Data Transfers: The runtime tracks the hipHostMalloc allocations and can avoid some of the setup required for regular unpinned memory. For exact measurements on a specific system, experiment with --unpinned and --pinned switches for the hipBusBandwidth tool.
-- Zero-Copy GPU Access: GPU can directly access the host memory over the CPU/GPU interconnect, without need to copy the data. This avoids the need for the copy, but during the kernel access each memory access must traverse the interconnect, which can be tens of times slower than accessing the GPU's local device memory. Zerocopy memory can be a good choice when the memory accesses are infrequent (perhaps only once). Zero-copy memory is typically 'Coherent' and thus not cached by the GPU but this can be overridden if desired.
-
-## 7.1.2 Memory allocation flags
-
-There are flags parameter which can specify options how to allocate the memory, for example, hipHostMallocPortable , the memory is considered allocated by all contexts, not just the one on which the allocation is made. hipHostMallocMapped , will map the allocation into the address space for the current device, and the device pointer can be obtained with the API hipHostGetDevicePointer() . hipHostMallocNumaUser is the flag to allow host memory allocation to follow Numa policy by user. Please note this flag is currently only applicable on Linux, under development on Windows.
-
-All allocation flags are independent, and can be used in any combination without restriction, for instance, hipHostMalloc can be called with both hipHostMallocPortable and hipHostMallocMapped flags set. Both usage models described above use the same allocation flags, and the difference is in how the surrounding code uses the host memory.
-
-## HIP PROGRAMMING MANUAL
-
-## 7.1.3 Numa-aware host memory allocation
-
-Numa policy determines how memory is allocated. Target of Numa policy is to select a CPU that is closest to each GPU. Numa distance is the measurement of how far between GPU and CPU devices.
-
-By default, each GPU selects a Numa CPU node that has the least Numa distance between them, that is, host memory will be automatically allocated closest on the memory pool of Numa node of the current GPU device. Using hipSetDevice API to a different GPU will still be able to access the host allocation, but can have longer Numa distance. Note, Numa policy is so far implemented on Linux, and under development on Windows.
-
-## 7.1.4 Coherency Controls
-
-ROCm defines two coherency options for host memory:
-
-- Coherent memory : Supports fine-grain synchronization while the kernel is running. For example, a kernel can perform atomic operations that are visible to the host CPU or to other (peer) GPUs. Synchronization instructions include threadfence\_system and C++11-style atomic operations. In order to achieve this fine-grained coherence, many AMD GPUs use a limited cache policy, such as leaving these allocations uncached by the GPU, or making them read-only.
-- Non-coherent memory : Can be cached by GPU, but cannot support synchronization while the kernel is running. Non-coherent memory can be optionally synchronized only at command (end-of-kernel or copy command) boundaries. This memory is appropriate for high-performance access when fine-grain synchronization is not required.
-
-HIP provides the developer with controls to select which type of memory is used via allocation flags passed to hipHostMalloc and the HIP\_HOST\_COHERENT environment variable. By default, the environment variable HIP\_HOST\_COHERENT is set to 0 in HIP. The control logic in the current version of HIP is as follows:
-
-- No flags are passed in: the host memory allocation is coherent, the HIP\_HOST\_COHERENT environment variable is ignored.
-- hipHostMallocCoherent=1 : The host memory allocation will be coherent, the HIP\_HOST\_COHERENT environment variable is ignored.
-- hipHostMallocMapped=1 : The host memory allocation will be coherent, the HIP\_HOST\_COHERENT environment variable is ignored.
-- hipHostMallocNonCoherent=1 , hipHostMallocCoherent=0 , and hipHostMallocMapped=0 : The host memory will be non-coherent, the HIP\_HOST\_COHERENT environment variable is ignored.
-- hipHostMallocCoherent=0 , hipHostMallocNonCoherent=0 , hipHostMallocMapped=0 , but one of the other HostMalloc flags is set:
-- -If HIP\_HOST\_COHERENT is defined as 1, the host memory allocation is coherent.
-- -If HIP\_HOST\_COHERENT is not defined, or defined as 0, the host memory allocation is non-coherent.
-- hipHostMallocCoherent=1 , hipHostMallocNonCoherent=1 : Illegal.
-
-## 7.1.5 Visibility of Zero-Copy Host Memory
-
-Coherent host memory is automatically visible at synchronization points. Non-coherent
-
-| HIP API Synchronization Effect                                                                        | Fence                 | Coherent Memory ity   | Host Visibil-   | Non-Coherent Host Memory Visi- bility   |
-|-------------------------------------------------------------------------------------------------------|-----------------------|-----------------------|-----------------|-----------------------------------------|
-| hipStreamSynchronize host waits for all commands in the spec- ified stream to complete                | system- scope release | yes                   |                 | yes                                     |
-| hipDeviceSynchronize host waits for all commands in all streams on the specified device to com- plete | system- scope release | yes                   |                 | yes                                     |
-| hipEventSynchronize host waits for the specified event to com- plete                                  | device- scope release | yes                   |                 | depends - see below                     |
-| hipStreamWaitEvent stream waits for the specified event to complete                                   | none                  | yes                   |                 | no                                      |
-
-## 7.1.6 hipEventSynchronize
-
-Developers can control the release scope for hipEvents :
-
-- By default, the GPU performs a device-scope acquire and release operation with each recorded event. This will make host and device memory visible to other commands executing on the same device.
-
-A stronger system-level fence can be specified when the event is created with hipEventCreateWithFlags :
-
-- hipEventReleaseToSystem : Perform a system-scope release operation when the event is recorded. This will make both Coherent and Non-Coherent host memory visible to other agents in the system, but may involve heavyweight operations such as cache flushing. Coherent memory will typically use lighter-weight in-kernel synchronization mechanisms such as an atomic operation and thus does not need to use hipEventReleaseToSystem .
-- hipEventDisableTiming : Events created with this flag will not record profiling data and provide the best performance if used for synchronization.
-
-## 7.1.7 Summary and Recommendations
-
-- Coherent host memory is the default and is the easiest to use since the memory is visible to the CPU at typical synchronization points. This memory allows in-kernel synchronization commands such as threadfence\_system to work transparently.
-- HIP/ROCm also supports the ability to cache host memory in the GPU using the 'Non-Coherent' host memory allocations. This can provide performance benefit, but care must be taken to use the correct synchronization.
-
-## 7.1.8 Managed memory allocation
-
-Managed memory, including the \_\_managed\_\_ keyword, is supported in HIP combined host/device compilation, on Linux, not on Windows (under development).
-
-Managed memory, via unified memory allocation, allows data be shared and accessible to both the CPU and GPU using a single pointer. The allocation will be managed by AMD GPU driver using the Linux HMM (Heterogeneous Memory Management) mechanism, the user can call managed memory API hipMallocManaged to allocate a large chunk of HMMmemory, execute kernels on device and fetch data between the host and device as needed.
-
-In HIP application, it is recommended to do the capability check before calling the managed memory APIs. For example:
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?>                                                                                                                                                                                                        </?>
-```
-
-Please note, the managed memory capability check may not be necessary, but if HMM is not supported, then managed malloc will fall back to using system memory and other managed memory API calls will have undefined behavior.
-
-Note, managed memory management is implemented on Linux, not supported on Windows yet.
-
-## 7.1.9 HIP Stream Memory Operations
-
-HIP supports Stream Memory Operations to enable direct synchronization between Network Nodes and GPU. Following new APIs are added, hipStreamWaitValue32 hipStreamWaitValue64 hipStreamWriteValue32 hipStreamWriteValue64
-
-Note, CPU access to the semaphore's memory requires volatile keyword to disable CPU compiler's optimizations on memory access. For more details, please check the documentation HIP-API.pdf .
-
-Please note, HIP stream does not guarantee concurrency on AMD hardware for the case of multiple (at least 6) longrunning streams executing concurrently, using hipStreamSynchronize(nullptr) for synchronization.
-
-## 7.2 Direct Dispatch
-
-HIP runtime has Direct Dispatch enabled by default in ROCM 4.4 on Linux. With this feature we move away from our conventional producer-consumer model where the runtime creates a worker thread(consumer) for each HIP Stream, and the host thread(producer) enqueues commands to a command queue(per stream).
-
-For Direct Dispatch, HIP runtime would directly enqueue a packet to the AQL queue (user mode queue on GPU) on the Dispatch API call from the application. That has shown to reduce the latency to launch the first wave on the idle GPU and total time of tiny dispatches synchronized with the host.
-
-In addition, eliminating the threads in runtime has reduced the variance in the dispatch numbers as the thread scheduling delays and atomics/locks synchronization latencies are reduced.
-
-This feature can be disabled via setting the following environment variable, AMD\_DIRECT\_DISPATCH=0
-
-Note, Direct Dispatch is implemented on Linux. It is currently not supported on Windows.
-
-## 7.3 HIP Runtime Compilation
-
-HIP now supports runtime compilation (HIP RTC), the usage of which will provide the possibility of optimizations and performance improvement compared with other APIs via regular offline static compilation.
-
-HIP RTC APIs accept HIP source files in character string format as input parameters and create handles of programs by compiling the HIP source files without spawning separate processes.
-
-For more details on HIP RTC APIs, refer to HIP Runtime API Reference .
-
-For Linux developers, the link here shows an example how to program HIP application using runtime compilation mechanism, and a detailed HIP RTC programming guide is also available.
-
-## 7.4 HIP Graph
-
-HIP graph is supported. For more details, refer to the HIP API Guide.
-
-## 7.5 Device-Side Malloc
-
-HIP-Clang now supports device-side malloc and free. This implementation does not require the use of hipDeviceSetLimit(hipLimitMallocHeapSize,value) nor respects any setting. The heap is fully dynamic and can grow until the available free memory on the device is consumed.
-
-## 7.6 Use of Per-thread default stream
-
-The per-thread default stream is supported in HIP. It is an implicit stream local to both the thread and the current device. This means that the command issued to the per-thread default stream by the thread does not implicitly synchronize with other streams (like explicitly created streams), or default per-thread stream on other threads. The per-thread default stream is a blocking stream and will synchronize with the default null stream if both are used in a program. The per-thread default stream can be enabled via adding a compilation option, -fgpu-default-stream=per-thread .
-
-And users can explicitly use hipStreamPerThread as per-thread default stream handle as input in API commands. There are test codes as examples in the link.
-
-## 7.7 Use of Long Double Type
-
-In HIP-Clang, long double type is 80-bit extended precision format for x86\_64, which is not supported by AMDGPU. HIP-Clang treats long double type as IEEE double type for AMDGPU. Using long double type in HIP source code will not cause issue as long as data of long double type is not transferred between host and device. However, long double type should not be used as kernel argument type.
-
-## 7.8 Use of \_Float16 Type
-
-If a host function is to be used between clang (or hipcc) and gcc for x86\_64, i.e. its definition is compiled by one compiler but the caller is compiled by a different compiler, \_Float16 or aggregates containing \_Float16 should not be used as function argument or return type. This is due to lack of stable ABI for \_Float16 on x86\_64. Passing \_Float16 or aggregates containing \_Float16 between clang and gcc could cause undefined behavior.
-
-## 7.9 FMA and contractions
-
-By default HIP-Clang assumes -ffp-contract=fast-honor-pragmas . Users can use #pragma clang fp contract(on|off|fast) to control fp contraction of a block of code. For x86\_64, FMA is off by default since the generic x86\_64 target does not support FMA by default. To turn on FMA on x86\_64, either use -mfma or -march=native on CPU's supporting FMA.
-
-When contractions are enabled and the CPU has not enabled FMA instructions, the GPU can produce different numerical results than the CPU for expressions that can be contracted. Tolerance should be used for floating point comparisons.
-
-## 7.10 Math functions with special rounding modes
-
-Note: Currently, HIP only supports basic math functions with rounding modern (round to nearest). HIP does not support basic math functions with rounding modes ru (round up), rd (round down), and rz (round towards zero).
-
-## 7.11 Creating Static Libraries
-
-HIP-Clang supports generating two types of static libraries. The first type of static library does not export device functions, and only exports and launches host functions within the same library. The advantage of this type is the ability to link with a non-hipcc compiler such as gcc. The second type exports device functions to be linked by other code objects. However, this requires using hipcc as the linker.
-
-In addition, the first type of library contains host objects with device code embedded as fat binaries. It is generated using the flag -emit-static-lib. The second type of library contains relocatable device objects and is generated using ar .
-
-Here is an example to create and use static libraries:
-
-- Type 1 using --emit-static-lib :
-- Type 2 using system ar :
-
-```
-<_Bash_>
-```
-
-```
-hipcc hipDevice.cpp -c -fgpu-rdc -o hipDevice.o
-ar rcsD libHipDevice.a hipDevice.o
-hipcc libHipDevice.a test.cpp -fgpu-rdc -o test.out
-```
-
-For more information, please see HIP samples host functions and device\_functions.
-
-CHAPTER
-
-## EIGHT
-
-## HIP PORTING GUIDE
-
-In addition to providing a portable C++ programming environment for GPUs, HIP is designed to ease the porting of existing CUDA code into the HIP environment. This section describes the available tools and provides practical suggestions on how to port CUDA code and work through common issues.
-
-## 8.1 Porting a New CUDA Project
-
-## 8.1.1 General Tips
-
-- Starting the port on a CUDA machine is often the easiest approach, since you can incrementally port pieces of the code to HIP while leaving the rest in CUDA. (Recall that on CUDA machines HIP is just a thin layer over CUDA, so the two code types can interoperate on NVCC platforms.) Also, the HIP port can be compared with the original CUDA code for function and performance.
-- Once the CUDA code is ported to HIP and is running on the CUDA machine, compile the HIP code using the HIP compiler on an AMD machine.
-- HIP ports can replace CUDA versions: HIP can deliver the same performance as a native CUDA implementation, with the benefit of portability to both NVIDIA and AMD architectures as well as a path to future C++ standard support. You can handle platform-specific features through conditional compilation or by adding them to the open-source HIP infrastructure.
-- Use hipconvertinplace-perl.sh to hipify all code files in the CUDA source directory.
-
-## 8.1.2 Scanning existing CUDA code to scope the porting effort
-
-The hipexamine-perl.sh tool will scan a source directory to determine which files contain CUDA code and how much of that code can be automatically hipified.
-
-```
-<_Cuda_>
-```
-
-(continued from previous page)
-
-```
-                                                                                                                                                                                                        (continued from previous page)
-```
-
-hipexamine-perl scans each code file (cpp, c, h, hpp, etc.) found in the specified directory:
-
-- Files with no CUDA code ( kmeans.h ) print one line summary just listing the source file name.
-- Files with CUDA code print a summary of what was found - for example the kmeans\_cuda\_kernel.cu file:
-- Interesting information in kmeans\_cuda\_kernel.cu :
-- -How many CUDA calls were converted to HIP (40)
-- -Breakdown of the CUDA functionality used ( dev:0 mem:0 etc). This file uses many CUDA builtins (37) and texture functions (3).
-- -Warning for code that looks like CUDA API but was not converted (0 in this file).
-- -Count Lines-of-Code (LOC) - 185 for this file.
-- hipexamine-perl also presents a summary at the end of the process for the statistics collected across all files. This has similar format to the per-file reporting, and also includes a list of all kernels which have been called. An example from above:
-
-```
-<_SQL_>
-```
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        --event:0                                                                                                                                                                                                        -event:0
-```
-
-## 8.1.3 Converting a project 'in-place'
-
-```
->
-```
-
-```
-| > hipify-perl --inplace
-```
-
-For each input file FILE, this script will:
-
-- If FILE.prehip file does not exist, copy the original code to a new file with extension .prehip . Then hipify the code file.
-- If FILE.prehip file exists, hipify FILE.prehip and save to FILE.
-
-This is useful for testing improvements to the hipify toolset.
-
-The hipconvertinplace-perl.sh script will perform inplace conversion for all code files in the specified directory. This can be quite handy when dealing with an existing CUDA code base since the script preserves the existing directory structure and filenames - and includes work. After converting in-place, you can review the code to add additional parameters to directory names.
-
-- &gt; hipconvertinplace-perl.sh MY\_SRC\_DIR
-
-## 8.1.4 Library Equivalents
-
-Most CUDA libraries have a corresponding ROCm library with similar functionality and APIs. However, ROCm also provides HIP marshalling libraries that greatly simplify the porting process because they more precisely reflect their CUDAcounterparts and can be used with either the AMD or NVIDIA platforms (see 'Identifying HIP Target Platform' below). There are a few notable exceptions:
-
-- MIOpen does not have a marshalling library interface to ease porting from cuDNN.
-- RCCL is a drop-in replacement for NCCL and implements the NCCL APIs.
-- hipBLASLt does not have a ROCm library but can still target the NVIDIA platform, as needed.
-- EIGEN's HIP support is part of the library.
-
-| CUDA brary   | Li-   | HIP Li- brary   | ROCm Li- brary   | Comment                                                                          |
-|--------------|-------|-----------------|------------------|----------------------------------------------------------------------------------|
-| cuBLAS       |       | hipBLAS         | rocBLAS          | Basic Linear Algebra Subroutines                                                 |
-| cuBLASLt     |       | hip- BLASLt     | N/A              | Basic Linear Algebra Subroutines, lightweight and new flexible API               |
-| cuFFT        |       | hipFFT          | rocFFT           | Fast Fourier Transfer Library                                                    |
-| cuSPARSE     |       | hipSPARSE       | rocSPARSE        | Sparse BLAS + SPMV                                                               |
-| cuSOLVER     |       | hip- SOLVER     | rocSOLVER        | Lapack library                                                                   |
-| AmgX         |       | N/A             | rocALU- TION     | Sparse iterative solvers and preconditioners with algebraic multigrid            |
-| Thrust       |       | N/A             | rocThrust        | C++ parallel algorithms library                                                  |
-| CUB          |       | hipCUB          | rocPRIM          | Low Level Optimized Parallel Primitives                                          |
-| cuDNN        |       | N/A             | MIOpen           | Deep learning Solver Library                                                     |
-| cuRAND       |       | hipRAND         | rocRAND          | Random Number Generator Library                                                  |
-| EIGEN        |       | EIGEN           | N/A              | C++ template library for linear algebra: matrices, vectors, numeri- cal solvers, |
-| NCCL         |       | N/A             | RCCL             | Communications Primitives Library based on the MPI equivalents                   |
-
-## 8.2 Distinguishing Compiler Modes
-
-## 8.2.1 Identifying HIP Target Platform
-
-All HIP projects target either AMD or NVIDIA platform. The platform affects which headers are included and which libraries are used for linking.
-
-- HIP\_PLATFORM\_AMD is defined if the HIP platform targets AMD. Note, HIP\_PLATFORM\_HCC was previously defined if the HIP platform targeted AMD, it is deprecated.
-- HIP\_PLATFORM\_NVDIA is defined if the HIP platform targets NVIDIA. Note, HIP\_PLATFORM\_NVCC was previously defined if the HIP platform targeted NVIDIA, it is deprecated.
-
-## 8.2.2 Identifying the Compiler: hip-clang or NVCC
-
-Often, it's useful to know whether the underlying compiler is HIP-Clang or NVCC. This knowledge can guard platformspecific code or aid in platform-specific performance tuning.
-
-```
-    #ifdef __HIP_PLATFORM_AMD__
-    // Compiled with HIP-Clang
-    #endif
-```
-
-```
-#ifdef __HIP_PLATFORM_NVIDIA__
-// Compiled with nvcc
-//  Could be compiling with CUDA language extensions enabled (for example, a ".cu file)
-//  Could be in pass-through mode to an underlying host compile OR (for example, a.cpp_
---file)
-```
-
-```
-        #ifdef __CUDACC__
-        // Compiled with nvcc (CUDA language extensions enabled)
-```
-
-```
-; enab1ed)
-```
-
-Compiler directly generates the host code (using the Clang x86 target) and passes the code to another host compiler. Thus, they have no equivalent of the \_\_CUDACC\_\_ define.
-
-## 8.2.3 Identifying Current Compilation Pass: Host or Device
-
-NVCCmakestwo passes over the code: one for host code and one for device code. HIP-Clang will have multiple passes over the code: one for the host code, and one for each architecture on the device code. \_\_HIP\_DEVICE\_COMPILE\_\_ is set to a nonzero value when the compiler (HIP-Clang or NVCC) is compiling code for a device inside a \_\_global\_\_ kernel or for a device function. \_\_HIP\_DEVICE\_COMPILE\_\_ can replace #ifdef checks on the \_\_CUDA\_ARCH\_\_ define.
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                        #if __HIP__DEVICE__COMPILE__
-```
-
-Unlike \_\_CUDA\_ARCH\_\_ , the \_\_HIP\_DEVICE\_COMPILE\_\_ value is 1 or undefined, and it doesn't represent the feature capability of the target device.
-
-## 8.2.4 Compiler Defines: Summary
-
-| Define                      | HIP-Clang                                                         | NVCC                                                                                          | Other (GCC, ICC, Clang, etc.)                               |
-|-----------------------------|-------------------------------------------------------------------|-----------------------------------------------------------------------------------------------|-------------------------------------------------------------|
-| HIP-related defines:        |                                                                   |                                                                                               |                                                             |
-| __HIP_PLATFORM_AMD__        | Defined                                                           | Undefined                                                                                     | Defined if targetingAMD platform; undefined oth- erwise     |
-| __HIP_PLATFORM_NVIDIA__     | Undefined                                                         | Defined                                                                                       | Defined if targeting NVIDIA platform; unde- fined otherwise |
-| __HIP_DEVICE_COMPILE__      | 1 if compiling for device; un- defined if compiling for host      | 1 if compiling for device; undefined if compiling for host                                    | Undefined                                                   |
-| __HIPCC__                   | Defined                                                           | Defined                                                                                       | Undefined                                                   |
-| __HIP_ARCH_*                | 0 or 1 depending on feature support (see below)                   | 0 or 1 depending on feature support (see below)                                               | 0                                                           |
-| NVCC- related defines:      |                                                                   |                                                                                               |                                                             |
-| __CUDACC__                  | Defined if source code is compiled by NVCC; unde- fined otherwise | Undefined                                                                                     |                                                             |
-| __NVCC__ Undefined          | Defined                                                           | Undefined                                                                                     |                                                             |
-| __CUDA_ARCH__               | Undefined                                                         | Unsigned representing compute capa- bility (e.g., '130') if in device code; 0 if in host code | Undefined                                                   |
-| hip-clang- related defines: |                                                                   |                                                                                               |                                                             |
-| __HIP__ HIP-Clang common    | Defined                                                           | Undefined                                                                                     | Undefined                                                   |
-| defines: __clang__          | Defined                                                           | Defined                                                                                       | Undefined                                                   |
-
-## 8.3 Identifying Architecture Features
-
-## 8.3.1 HIP\_ARCH Defines
-
-Some CUDA code tests \_\_CUDA\_ARCH\_\_ for a specific value to determine whether the machine supports a certain architectural feature. For instance,
-
-```
-        | #if (__CUDA_ARCH__ >= 13 0)
-```
-
-```
-    |// doubles are supported
-```
-
-This type of code requires special attention, since AMD and CUDA devices have different architectural capabilities. Moreover, you can't determine the presence of a feature using a simple comparison against an architecture's version
-
-number. HIP provides a set of defines and device properties to query whether a specific architectural feature is supported.
-
-The \_\_HIP\_ARCH\_* defines can replace comparisons of \_\_CUDA\_ARCH\_\_ values:
-
-```
-//#if (__CUDA_ARCH__ >= 130)   // non-portable
-if __HIP_ARCH_HAS_DOUBLES__ {  // portable HIP feature query
-    // doubles are supported
-}
-```
-
-For host code, the \_\_HIP\_ARCH\_\_* defines are set to 0. You should only use the \_\_HIP\_ARCH\_\_ fields in device code.
-
-## 8.3.2 Device-Architecture Properties
-
-Host code should query the architecture feature flags in the device properties that hipGetDeviceProperties returns, rather than testing the 'major' and 'minor' fields directly:
-
-```
-hipGetDeviceProperties(&deviceProp, device);
-//if ((deviceProp.major == 1 && deviceProp.minor < 2))  // non-portable
-if (deviceProp.arch.hasSharedInt32Atomics) {            // portable HIP feature query
-    // has shared int32 atomic operations...
-}
-```
-
-## 8.3.3 Table of Architecture Properties
-
-The table below shows the full set of architectural properties that HIP supports.
-
-| Define (use only in device code)                                                                                               | Device Property (run- time query)                       | Comment                                                                                                                                |
-|--------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------|
-| 32-bit atomics:                                                                                                                |                                                         |                                                                                                                                        |
-| __HIP_ARCH_HAS_GLOBAL_INT32_ATOMICS__ __HIP_ARCH_HAS_GLOBAL_FLOAT_ATOMIC_EXCH__                                                | hasGlobalInt32Atomics hasGlobalFloatAtomicExch          | 32-bit integer atomics for global memory 32-bit float atomic exchange for global mem- ory                                              |
-| __HIP_ARCH_HAS_SHARED_INT32_ATOMICS__ __HIP_ARCH_HAS_SHARED_FLOAT_ATOMIC_EXCH__                                                | hasSharedInt32Atomics hasSharedFloatAtomicExch          | 32-bit integer atomics for shared memory 32-bit float atomic exchange for shared mem- ory                                              |
-| __HIP_ARCH_HAS_FLOAT_ATOMIC_ADD__                                                                                              | hasFloatAtomicAdd                                       | 32-bit float atomic add in global and shared memory                                                                                    |
-| 64-bit atomics:                                                                                                                |                                                         |                                                                                                                                        |
-| __HIP_ARCH_HAS_GLOBAL_INT64_ATOMICS__ __HIP_ARCH_HAS_SHARED_INT64_ATOMICS__ Doubles:                                           | hasGlobalInt64Atomics hasSharedInt64Atomics             | 64-bit integer atomics for global memory 64-bit integer atomics for shared memory                                                      |
-| __HIP_ARCH_HAS_DOUBLES__ Warp cross-lane operations:                                                                           | hasDoubles                                              | Double-precision floating point                                                                                                        |
-| __HIP_ARCH_HAS_WARP_VOTE__ __HIP_ARCH_HAS_WARP_BALLOT__ __HIP_ARCH_HAS_WARP_SHUFFLE__ __HIP_ARCH_HAS_WARP_FUNNEL_SHIFT__ Sync: | hasWarpVote hasWarpBallot hasWarpShuffle hasFunnelShift | Warp vote instructions ( any , all ) Warp ballot instructions Warp shuffle operations ( shfl_* ) Funnel shift two input words into one |
-|                                                                                                                                | hasThreadFenceSystem hasSyncThreadsExt                  | threadfence_system syncthreads_count , syncthreads_and                                                                                 |
-| __HIP_ARCH_HAS_THREAD_FENCE_SYSTEM__                                                                                           |                                                         |                                                                                                                                        |
-| __HIP_ARCH_HAS_SYNC_THREAD_EXT__                                                                                               |                                                         | , syncthreads_or                                                                                                                       |
-| Miscellaneous:                                                                                                                 |                                                         |                                                                                                                                        |
-| __HIP_ARCH_HAS_SURFACE_FUNCS__                                                                                                 | hasSurfaceFuncs                                         |                                                                                                                                        |
-| __HIP_ARCH_HAS_3DGRID__                                                                                                        | has3dGrid                                               | Grids and groups are 3D                                                                                                                |
-| __HIP_ARCH_HAS_DYNAMIC_PARALLEL__                                                                                              | hasDynamicParallelism                                   |                                                                                                                                        |
-
-## 8.4 Finding HIP
-
-Makefiles can use the following syntax to conditionally provide a default HIP\_PATH if one does not exist:
-
-HIP\_PATH ?= $( shell hipconfig --path )
-
-## 8.5 Identifying HIP Runtime
-
-HIP can depend on rocclr, or CUDA as runtime
-
-- AMDplatform On AMD platform, HIP uses Radeon Open Compute Common Language Runtime, called ROCclr. ROCclr is a virtual device interface that HIP runtimes interact with different backends which allows runtimes to work on Linux , as well as Windows without much efforts.
-- NVIDIA platform On NVIDIA platform, HIP is just a thin layer on top of CUDA. On non-AMD platform, HIP runtime determines if CUDA is available and can be used. If available, HIP\_PLATFORM is set to nvidia and underneath CUDA path is used.
-
-## 8.6 hipLaunchKernelGGL
-
-hipLaunchKernelGGL is a macro that can serve as an alternative way to launch kernel, which accepts parameters of launch configurations (grid dims, group dims, stream, dynamic shared size) followed by a variable number of kernel arguments. It can replace &lt;&lt;&lt; &gt;&gt;&gt;, if the user so desires.
-
-## 8.7 Compiler Options
-
-hipcc is a portable compiler driver that will call NVCC or HIP-Clang (depending on the target system) and attach all required include and library options. It passes options through to the target compiler. Tools that call hipcc must ensure the compiler options are appropriate for the target compiler. The hipconfig script may helpful in identifying the target platform, compiler and runtime. It can also help set options appropriately.
-
-## 8.7.1 Compiler options supported on AMD platforms
-
-Here are the main compiler options supported on AMD platforms by HIP-Clang.
-
-| Option      | Description                                                                                                                                                                                                                                                                                                                                                                           |
-|-------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-|             | --amdgpu-target=<gpu_arch> [DEPRECATED] This option is being replaced by --offload-arch=<target> . Generate code for the given GPU target. Supported targets are gfx701, gfx801, gfx802, gfx803, gfx900, gfx906, gfx908, gfx1010, gfx1011, gfx1012, gfx1030, gfx1031. This option could appear multiple times on the same command line to generate a fat binary for multiple targets. |
-| --fgpu-rdc  | Generate relocatable device code, which allows kernels or device functions calling device functions in different translation units.                                                                                                                                                                                                                                                   |
-| -ggdb       | Equivalent to -g plus tuning for GDB. This is recommended when using ROCm's GDB to debug GPU code.                                                                                                                                                                                                                                                                                    |
-|             | --gpu-max-threads-per-block=<num> Generate code to support up to the specified number of threads per block.                                                                                                                                                                                                                                                                           |
-| -O<n>       | Specify the optimization level.                                                                                                                                                                                                                                                                                                                                                       |
-|             | -offload-arch=<target> Specify the AMDGPUtarget ID.                                                                                                                                                                                                                                                                                                                                   |
-| -save-temps | Save the compiler generated intermediate files.                                                                                                                                                                                                                                                                                                                                       |
-| -v          | Show the compilation steps.                                                                                                                                                                                                                                                                                                                                                           |
-
-## 8.8 Linking Issues
-
-## 8.8.1 Linking With hipcc
-
-hipcc adds the necessary libraries for HIP as well as for the accelerator compiler (NVCC or AMD compiler). We recommend linking with hipcc since it automatically links the binary to the necessary HIP runtime libraries. It also has knowledge on how to link and to manage the GPU objects.
-
-## 8.8.2 -lm Option
-
-hipcc adds -lm by default to the link command.
-
-## 8.9 Linking Code With Other Compilers
-
-CUDA code often uses NVCC for accelerator code (defining and launching kernels, typically defined in .cu or .cuh files). It also uses a standard compiler (g++) for the rest of the application. NVCC is a preprocessor that employs a standard host compiler (gcc) to generate the host code. Code compiled using this tool can employ only the intersection of language features supported by both NVCC and the host compiler. In some cases, you must take care to ensure the data types and alignment of the host compiler are identical to those of the device compiler. Only some host compilers are supported-for example, recent NVCC versions lack Clang host-compiler capability.
-
-HIP-Clang generates both device and host code using the same Clang-based compiler. The code uses the same API as gcc, which allows code generated by different gcc-compatible compilers to be linked together. For example, code compiled using HIP-Clang can link with code compiled using 'standard' compilers (such as gcc, ICC and Clang). Take care to ensure all compilers use the same standard C++ header and library formats.
-
-## 8.9.1 libc++ and libstdc++
-
-hipcc links to libstdc++ by default. This provides better compatibility between g++ and HIP.
-
-If you pass --stdlib=libc++ to hipcc, hipcc will use the libc++ library. Generally, libc++ provides a broader set of C++ features while libstdc++ is the standard for more compilers (notably including g++).
-
-When cross-linking C++ code, any C++ functions that use types from the C++ standard library (including std::string, std::vector and other containers) must use the same standard-library implementation. They include the following:
-
-- Functions or kernels defined in HIP-Clang that are called from a standard compiler
-- Functions defined in a standard compiler that are called from HIP-Clang.
-
-Applications with these interfaces should use the default libstdc++ linking.
-
-Applications which are compiled entirely with hipcc, and which benefit from advanced C++ features not supported in libstdc++, and which do not require portability to NVCC, may choose to use libc++.
-
-## 8.9.2 HIP Headers ( hip\_runtime.h , hip\_runtime\_api.h )
-
-The hip\_runtime.h and hip\_runtime\_api.h files define the types, functions and enumerations needed to compile a HIP program:
-
-- hip\_runtime\_api.h : defines all the HIP runtime APIs (e.g., hipMalloc ) and the types required to call them. A source file that is only calling HIP APIs but neither defines nor launches any kernels can include hip\_runtime\_api.h . hip\_runtime\_api.h uses no custom Heterogeneous Compute (HC) language features and can be compiled using a standard C++ compiler.
-- hip\_runtime.h : included in hip\_runtime\_api.h . It additionally provides the types and defines required to create and launch kernels. hip\_runtime.h can be compiled using a standard C++ compiler but will expose a subset of the available functions.
-
-CUDAhasslightly different contents for these two files. In some cases you may need to convert hipified code to include the richer hip\_runtime.h instead of hip\_runtime\_api.h .
-
-## 8.9.3 Using a Standard C++ Compiler
-
-You can compile hip\_runtime\_api.h using a standard C or C++ compiler (e.g., gcc or ICC). The HIP include paths and defines ( \_\_HIP\_PLATFORM\_AMD\_\_ or \_\_HIP\_PLATFORM\_NVIDIA\_\_ ) must pass to the standard compiler; hipconfig then returns the necessary options:
-
-- &gt;
-
-```
-|> hipconfig --cxx_config
-```
-
-```
-                                                                                                                                                                                                        |  -D___HIP_PLATFORM_AMD___ -I/home/user1/hip/include
-```
-
-You can capture the hipconfig output and passed it to the standard compiler; below is a sample makefile syntax:
-
-```
-            |CPPFLAGS += $(shell $(HIP_PATH)/bin/hipconfig --cpp_config)
-```
-
-```
-
-)
-```
-
-NVCC includes some headers by default. However, HIP does not include default headers, and instead all required files must be explicitly included. Specifically, files that call HIP run-time APIs or define HIP kernels must explicitly include the appropriate HIP headers. If the compilation process reports that it cannot find necessary APIs (for example, error: identifier hipSetDevice is undefined ), ensure that the file includes hip\_runtime.h (or hip\_runtime\_api.h, if appropriate). The hipify-perl script automatically converts cuda\_runtime.h to hip\_runtime.h , and it converts cuda\_runtime\_api.h to hip\_runtime\_api.h , but it may miss nested headers or macros.
-
-## 8.9.3.1 cuda.h
-
-The HIP-Clang path provides an empty cuda.h file. Some existing CUDA programs include this file but don't require any of the functions.
-
-## 8.9.4 Choosing HIP File Extensions
-
-Many existing CUDA projects use the .cu and .cuh file extensions to indicate code that should be run through the NVCC compiler. For quick HIP ports, leaving these file extensions unchanged is often easier, as it minimizes the work required to change file names in the directory and #include statements in the files.
-
-For new projects or ports which can be re-factored, we recommend the use of the extension .hip.cpp for source files, and .hip.h or .hip.hpp for header files. This indicates that the code is standard C++ code, but also provides a unique indication for make tools to run hipcc when appropriate.
-
-## 8.10 Workarounds
-
-## 8.10.1 warpSize
-
-Code should not assume a warp size of 32 or 64. See Warp Cross-Lane Functions for information on how to write portable wave-aware code.
-
-## 8.10.2 Kernel launch with group size &gt; 256
-
-Kernel code should use \_\_attribute\_\_((amdgpu\_flat\_work\_group\_size(&lt;min&gt;,&lt;max&gt;))) . For example:
-
-```
-<_SQL_>
-```
-
-## 8.11 memcpyToSymbol
-
-HIP support for hipMemcpyToSymbol is complete. This feature allows a kernel to define a device-side data symbol which can be accessed on the host side. The symbol can be in \_\_constant or device space.
-
-Note that the symbol name needs to be encased in the HIP\_SYMBOL macro, as shown in the code example below. This also applies to hipMemcpyFromSymbol , hipGetSymbolAddress , and hipGetSymbolSize .
-
-For example:
-
-Device Code:
-
-```
-<_C++_>
-```
-
-(continued from previous page)
-
-```
-        {
-            A[i] = -1*i;
-            B[i] = 0;
-        }
-
-        HIP_ASSERT(hipMalloc((void**)&Ad, SIZE));
-
-        HIP_ASSERT(hipMemcpyToSymbol(HIP_SYMBOL(Value), A, SIZE, 0, hipMemcpyHostToDevice));
-        hipLaunchKernelGGL(Get, dim3(1,1,1), dim3(LEN,1,1), 0, 0, Ad);
-        HIP_ASSERT(hipMemcpy(B, Ad, SIZE, hipMemcpyDeviceToHost));
-
-        for(unsigned i=0;i<LEN;i++)
-        {
-            assert(A[i] == B[i]);
-        }
-        std::cout<<"Passed"<<std::endl;
-    }
-    
-    
-    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-```
-
-## 8.12 CU\_POINTER\_ATTRIBUTE\_MEMORY\_TYPE
-
-To get pointer's memory type in HIP/HIP-Clang, developers should use hipPointerGetAttributes API. First parameter of the API is hipPointerAttribute\_t which has 'type' as member variable. 'type' indicates input pointer is allocated on device or host.
-
-For example:
-
-```
-            For example:
-            double * ptr;
-            hipMalloc(reinterpret_cast<void**>(&ptr), sizeof(double));
-            hipPointerAttribute_t attr;
-            hipPointerGetAttributes(&attr, ptr); /*attr.type will have value as hipMemoryTypeDevice*/
-
-            double* ptrHost;
-            hipHostMalloc(&ptrHost, sizeof(double));
-            hipPointerAttribute_t attr;
-            hipPointerGetAttributes(&attr, ptrHost); /*attr.type will have value as _
-           ...hipMemoryTypeHost*/
-
-            Data data file.MaximumTime amount value as different from end.MaximumTime amount value
-```
-
-Please note, hipMemoryType enum values are different from cudaMemoryType enum values.
-
-For example, on AMD platform, hipMemoryType is defined in hip\_runtime\_api.h ,
-
-```
-            For example, on AMD platform, hipMemoryType is defined in hip_runtime_api.h,
-            
-        typedef enum hipMemoryType {
-            hipMemoryTypeHost = 0,     ///< Memory is physically located on host
-            hipMemoryTypeDevice = 1,  ///< Memory is physically located on device. (see deviceId,
-        --for specific device)
-            hipMemoryTypeArray = 2,   ///< Array memory, physically located on device. (see_,
-        --deviceId for specific device)
-            hipMemoryTypeUnified = 3, ///< Not used currently
-            hipMemoryTypeManaged = 4  ///< Managed memory, automatically managed by the unified.
-        --memory system
-        } hipMemoryType;
-```
-
-Looking into CUDA toolkit, it defines cudaMemoryType as following,
-
-```
-<_Cuda_>
-```
-
-In this case, memory type translation for hipPointerGetAttributes needs to be handled properly on NVIDIA platform to get the correct memory type in CUDA, which is done in the file nvidia\_hip\_runtime\_api.h .
-
-So in any HIP applications which use HIP APIs involving memory types, developers should use #ifdef in order to assign the correct enum values depending on NVIDIA or AMD platform.
-
-As an example, please see the code from the link.
-
-With the #ifdef condition, HIP APIs work as expected on both AMD and NVIDIA platforms.
-
-Note, cudaMemoryTypeUnregstered is currently not supported in hipMemoryType enum, due to HIP functionality backward compatibility.
-
-## 8.13 threadfence\_system
-
-threadfence\_system makes all device memory writes, all writes to mapped host memory, and all writes to peer memory visible to CPU and other GPU devices. Some implementations can provide this behavior by flushing the GPU L2 cache. HIP/HIP-Clang does not provide this functionality. As a workaround, users can set the environment variable HSA\_DISABLE\_CACHE=1 to disable the GPU L2 cache. This will affect all accesses and for all kernels and so may have a performance impact.
-
-## 8.13.1 Textures and Cache Control
-
-Compute programs sometimes use textures either to access dedicated texture caches or to use the texture-sampling hardware for interpolation and clamping. The former approach uses simple point samplers with linear interpolation, essentially only reading a single point. The latter approach uses the sampler hardware to interpolate and combine multiple samples. AMD hardware, as well as recent competing hardware, has a unified texture/L1 cache, so it no longer has a dedicated texture cache. But the NVCC path often caches global loads in the L2 cache, and some programs may benefit from explicit control of the L1 cache contents. We recommend the \_\_ldg instruction for this purpose.
-
-AMDcompilers currently load all data into both the L1 and L2 caches, so \_\_ldg is treated as a no-op.
-
-We recommend the following for functional portability:
-
-- For programs that use textures only to benefit from improved caching, use the \_\_ldg instruction
-- Programs that use texture object and reference APIs, work well on HIP
-
-## 8.14 More Tips
-
-## 8.14.1 HIP Logging
-
-Onan AMDplatform, set the AMD\_LOG\_LEVEL environment variable to log HIP application execution information.
-
-The value of the setting controls different logging level,
-
-```
-<_C++_>
-```
-
-Logging mask is used to print types of functionalities during the execution of HIP application. It can be set as one of the following values,
-
-```
-<_C++_>
-```
-
-## 8.14.2 Debugging hipcc
-
-To see the detailed commands that hipcc issues, set the environment variable HIPCC\_VERBOSE to 1. Doing so will print to stderr the HIP-clang (or NVCC) commands that hipcc generates.
-
-```
-export HIPCC_VERBOSE=1
-make
-
-...
-hipcc-cmd: /opt/rcm/bin/hipcc --offload-arch=native -x hip backprop_cuda.cu
-```
-
-## 8.14.3 Editor Highlighting
-
-See the utils/vim or utils/gedit directories to add handy highlighting to hip files.
-
-## PORTING CUDA DRIVER API
-
-## 9.1 Introduction to the CUDA Driver and Runtime APIs
-
-CUDA provides a separate CUDA Driver and Runtime APIs. The two APIs have significant overlap in functionality:
-
-- Both APIs support events, streams, memory management, memory copy, and error handling.
-- Both APIs deliver similar performance.
-- Driver APIs calls begin with the prefix cu while Runtime APIs begin with the prefix cuda . For example, the Driver API API contains cuEventCreate while the Runtime API contains cudaEventCreate , with similar functionality.
-- The Driver API defines a different but largely overlapping error code space than the Runtime API, and uses a different coding convention. For example, Driver API defines CUDA\_ERROR\_INVALID\_VALUE while the Runtime API defines cudaErrorInvalidValue
-
-The Driver API offers two additional pieces of functionality not provided by the Runtime API: cuModule and cuCtx APIs.
-
-## 9.1.1 cuModule API
-
-The Module section of the Driver API provides additional control over how and when accelerator code objects are loaded. For example, the driver API allows code objects to be loaded from files or memory pointers. Symbols for kernels or global data can be extracted from the loaded code objects. In contrast, the Runtime API automatically loads and (if necessary) compiles all of the kernels from an executable binary when run. In this mode, NVCC must be used to compile kernel code so the automatic loading can function correctly.
-
-Both Driver and Runtime APIs define a function for launching kernels (called cuLaunchKernel or cudaLaunchKernel . The kernel arguments and the execution configuration (grid dimensions, group dimensions, dynamic shared memory, and stream) are passed as arguments to the launch function. The Runtime additionally provides the &lt;&lt;&lt; &gt;&gt;&gt; syntax for launching kernels, which resembles a special function call and is easier to use than explicit launch API (in particular with respect to handling of kernel arguments). However, this syntax is not standard C++ and is available only when NVCC is used to compile the host code.
-
-The Module features are useful in an environment which generates the code objects directly, such as a new accelerator language front-end. Here, NVCC is not used. Instead, the environment may have a different kernel language or different compilation flow. Other environments have many kernels and do not want them to be all loaded automatically. The Module functions can be used to load the generated code objects and launch kernels. As we will see below, HIP defines a Module API which provides similar explicit control over code object management.
-
-## 9.1.2 cuCtx API
-
-The Driver API defines 'Context' and 'Devices' as separate entities. Contexts contain a single device, and a device can theoretically have multiple contexts. Each context contains a set of streams and events specific to the context. Historically contexts also defined a unique address space for the GPU, though this may no longer be the case in Unified Memory platforms (since the CPU and all the devices in the same process share a single unified address space). The Context APIs also provide a mechanism to switch between devices, which allowed a single CPU thread to send commands to different GPUs. HIP as well as a recent versions of CUDA Runtime provide other mechanisms to accomplish this feat - for example using streams or cudaSetDevice .
-
-The CUDA Runtime API unifies the Context API with the Device API. This simplifies the APIs and has little loss of functionality since each Context can contain a single device, and the benefits of multiple contexts has been replaced with other interfaces. HIP provides a context API to facilitate easy porting from existing Driver codes. In HIP, the Ctx functions largely provide an alternate syntax for changing the active device.
-
-Most new applications will prefer to use hipSetDevice or the stream APIs, therefore HIP has marked hipCtx APIs as deprecated . Support for these APIs may not be available in future releases. For more details on deprecated APIs please refer HIP deprecated APIs .
-
-## 9.2 HIP Module and Ctx APIs
-
-Rather than present two separate APIs, HIP extends the HIP API with new APIs for Modules and Ctx control.
-
-## 9.2.1 hipModule API
-
-Like the CUDA Driver API, the Module API provides additional control over how code is loaded, including options to load code from files or from in-memory pointers. NVCC and HIP-Clang target different architectures and use different code object formats: NVCC is cubin or ptx files, while the HIP-Clang path is the hsaco format. The external compilers which generate these code objects are responsible for generating and loading the correct code object for each platform. Notably, there is not a fat binary format that can contain code for both NVCC and HIP-Clang platforms. The following table summarizes the formats used on each platform:
-
-| Format                 | APIs                                                  | NVCC                       | HIP-CLANG          |
-|------------------------|-------------------------------------------------------|----------------------------|--------------------|
-| Code Object Fat Binary | hipModuleLoad , hipModuleLoadData hipModuleLoadFatBin | .cubin or PTX text .fatbin | .hsaco .hip_fatbin |
-
-hipcc uses HIP-Clang or NVCC to compile host codes. Both of these may embed code objects into the final executable, and these code objects will be automatically loaded when the application starts. The hipModule API can be used to load additional code objects, and in this way provides an extended capability to the automatically loaded code objects. HIP-Clang allows both of these capabilities to be used together, if desired. Of course it is possible to create a program with no kernels and thus no automatic loading.
-
-## 9.2.2 hipCtx API
-
-HIP provides a Ctx API as a thin layer over the existing Device functions. This Ctx API can be used to set the current context, or to query properties of the device associated with the context. The current context is implicitly used by other APIs such as hipStreamCreate .
-
-## 9.2.3 hipify translation of CUDA Driver API
-
-The HIPIFY tools convert CUDA Driver APIs for streams, events, modules, devices, memory management, context, profiler to the equivalent HIP driver calls. For example, cuEventCreate will be translated to hipEventCreate . HIPIFY tools also convert error codes from the Driver namespace and coding convention to the equivalent HIP error code. Thus, HIP unifies the APIs for these common functions.
-
-The memory copy API requires additional explanation. The CUDA driver includes the memory direction in the name of the API ( cuMemcpyH2D ) while the CUDA driver API provides a single memory copy API with a parameter that specifies the direction and additionally supports a 'default' direction where the runtime determines the direction automatically. HIP provides APIs with both styles: for example, hipMemcpyH2D as well as hipMemcpy . The first flavor may be faster in some cases since they avoid host overhead to detect the different memory directions.
-
-HIP defines a single error space, and uses camel-case for all errors (i.e. hipErrorInvalidValue ).
-
-## 9.2.3.1 Address Spaces
-
-HIP-Clang defines a process-wide address space where the CPU and all devices allocate addresses from a single unified pool. Thus addresses may be shared between contexts, and unlike the original CUDA definition a new context does not create a new address space for the device.
-
-## 9.2.3.2 Using hipModuleLaunchKernel
-
-hipModuleLaunchKernel is cuLaunchKernel in HIP world. It takes the same arguments as cuLaunchKernel .
-
-## 9.2.3.3 Additional Information
-
-- HIP-Clang creates a primary context when the HIP API is called. So in a pure driver API code, HIP-Clang will create a primary context while HIP/NVCC will have empty context stack. HIP-Clang will push primary context to context stack when it is empty. This can have subtle differences on applications which mix the runtime and driver APIs.
-
-## 9.2.4 hip-clang Implementation Notes
-
-## 9.2.4.1 .hip\_fatbin
-
-hip-clang links device code from different translation units together. For each device target, a code object is generated. Code objects for different device targets are bundled by clang-offload-bundler as one fatbinary, which is embeded as a global symbol \_\_hip\_fatbin in the .hip\_fatbin section of the ELF file of the executable or shared object.
-
-## 9.2.4.2 Initialization and Termination Functions
-
-hip-clang generates initialization and termination functions for each translation unit for host code compilation. The initialization functions call \_\_hipRegisterFatBinary to register the fatbinary embeded in the ELF file. They also call \_\_hipRegisterFunction and \_\_hipRegisterVar to register kernel functions and device side global variables. The termination functions call \_\_hipUnregisterFatBinary . hip-clang emits a global variable \_\_hip\_gpubin\_handle of void** type with linkonce linkage and inital value 0 for each host translation unit. Each initialization function checks \_\_hip\_gpubin\_handle and register the fatbinary only if \_\_hip\_gpubin\_handle is 0 and saves the return value of \_\_hip\_gpubin\_handle to \_\_hip\_gpubin\_handle . This is to guarantee that the fatbinary is only registered once. Similar check is done in the termination functions.
-
-## 9.2.4.3 Kernel Launching
-
-hip-clang supports kernel launching by CUDA &lt;&lt;&lt;&gt;&gt;&gt; syntax, hipLaunchKernelGGL. The latter one is macro which expand to CUDA &lt;&lt;&lt;&gt;&gt;&gt; syntax.
-
-When the executable or shared library is loaded by the dynamic linker, the initialization functions are called. In the initialization functions, when \_\_hipRegisterFatBinary is called, the code objects containing all kernels are loaded; when \_\_hipRegisterFunction is called, the stub functions are associated with the corresponding kernels in code objects.
-
-hip-clang implements two sets of kernel launching APIs.
-
-By default, in the host code, for the &lt;&lt;&lt;&gt;&gt;&gt; statement, hip-clang first emits call of hipConfigureCall to set up the threads and grids, then emits call of the stub function with the given arguments. In the stub function, hipSetupArgument is called for each kernel argument, then hipLaunchByPtr is called with a function pointer to the stub function. In hipLaunchByPtr , the real kernel associated with the stub function is launched.
-
-## 9.2.5 NVCC Implementation Notes
-
-## 9.2.5.1 Interoperation between HIP and CUDA Driver
-
-CUDA applications may want to mix CUDA driver code with HIP code (see example below). This table shows the type equivalence to enable this interaction.
-
-| HIP Type      | CU Driver Type   | CUDA Runtime Type   |
-|---------------|------------------|---------------------|
-| hipModule_t   | CUmodule         |                     |
-| hipFunction_t | CUfunction       |                     |
-| hipCtx_t      | CUcontext        |                     |
-| hipDevice_t   | CUdevice         |                     |
-| hipStream_t   | CUstream         | cudaStream_t        |
-| hipEvent_t    | CUevent          | cudaEvent_t         |
-| hipArray      | CUarray          | cudaArray           |
-
-## 9.2.5.2 Compilation Options
-
-The hipModule\_t interface does not support cuModuleLoadDataEx function, which is used to control PTX compilation options. HIP-Clang does not use PTX and does not support these compilation options. In fact, HIP-Clang code objects always contain fully compiled ISA and do not require additional compilation as a part of the load step. The corresponding HIP function hipModuleLoadDataEx behaves as hipModuleLoadData on HIP-Clang path (compilation options are not used) and as cuModuleLoadDataEx on NVCC path. For example (CUDA):
-
-```
-<_Cuda_>
-```
-
-HIP:
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?xml version="1.0" encoding="UTF-8" />
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        </?xml version="2.0" encoding="UTF-8" />
-                                                                                                                                                                                             <?xml version="3.0" encoding="UTF-8" />
-                                                                                                                                                                                            
-	         
-                                                                                                                                                                                             
-         
-                                                                                                                                                                                              <?xml version="4.0" encoding="UTF-8" />
-                                                                                                                                                                                             </?xml version="5.0" encoding="UTF-8" />
-                                                                                                                                                                                            
-
-          
-                                                                                                                                                                                             <?xml version="6.0" encoding="UTF-8" />
-                                                                                                                                                                                             >
-                                                                                                                                                                                                       <!xml version="7.0" encoding="UTF-8" />
-                                                                                                                                                                                             //
-                                                                                                                                                                                                       </!xml version="8.0" encoding="UTF-8" />
-                                                                                                                                                                                             }
-```
-
-The below sample shows how to use hipModuleGetFunction .
-
-```
-#include<hip_runtime.h>
-#include<hip_runtime_api.h>
-#include<iostream>
-#include<fstream>
-#include<vector>
-```
-
-```
-#include<hip_runtime.h>
-#include<hip_runtime_api.h>
-#include<iostream>
-#include<fstream>
-#include<vector>
-```
-
-```
-HIP Documentation, Release 6.1.40092
-
-
-
-
-#define LEN 64
-#define SIZE LEN<<2
-
-#ifdef __HIP_PLATFORM_AMD__
-#define fileName "vcpy_isa.co"
-#endif
-
-#ifdef __HIP_PLATFORM_NVIDIA__
-#define fileName "vcpy_isa.ptx"
-#endif
-
-#define kernel_name "hello_world"
-
-int main(){
-	float *A, *B;
-	hipDeviceptr_t Ad, Bd;
-	A = new float[LEN];
-	B = new float[LEN];
-
-	for(uint32_t i=0;i<LEN;i++){
-		A[i] = i*1.0f;
-		B[i] = 0.0f;
-		std::cout<<A[i] << " "<<B[i]<<std::endl;
-	}
-
-
-#ifdef __HIP_PLATFORM_NVIDIA__
-		hipInit(0);
-		hipDevice_t device;
-		hipCtx_t context;
-		hipDeviceGet(&device, 0);
-		hipCtxCreate(&context, 0, device);
-#endif
-
-	hipMalloc((void**)&Ad, SIZE);
-	hipMalloc((void**)&Bd, SIZE);
-
-	hipMemcpyHtoD(Ad, A, SIZE);
-	hipMemcpyHtoD(Bd, B, SIZE);
-	hipModule_t Module;
-	hipFunction_t Function;
-	hipModuleLoad(&Module, fileName);
-	hipModuleGetFunction(&Function, Module, kernel_name);
-
-	std::vector<void*>argBuffer(2);
-	memcpy(&argBuffer[0], &Ad, sizeof(void*));
-	memcpy(&argBuffer[1], &Bd, sizeof(void*));
-
-	size_t size = argBuffer.size()*sizeof(void*);
-
-	void *config[] = {
-		HIP_LAUNCH_PARAM_BUFFER_POINTER, &argBuffer[0],
-
-
-
-54
-```
-
-(continued from previous page)
-
-(continues on next page)
-
-(continued from previous page)
-
-```
-        HIP_LAUNCH_PARAM_BUFFER_SIZE, &size,
-        HIP_LAUNCH_PARAM_END
-    };
-
-    hipModuleLaunchKernel(Function, 1, 1, 1, LEN, 1, 1, 0, 0, NULL, (void**)&config);
-
-    hipMemcpyDtoH(B, Bd, SIZE);
-    for(uint32_t i=0;i<LEN;i++){
-        std::cout<<A[i]<<" - "<<B[i]<<std::endl;
-    }
-
-#ifdef __HIP_PLATFORM_NVIDIA__
-          hipCtxDetach(context);
-#endif
-
-    return 0;
-}
-
-__A__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ ======"__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__= "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "_ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = '__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ from "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "___ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "__ = "'
-```
-
-## 9.3 HIP Module and Texture Driver API
-
-HIP supports texture driver APIs however texture reference should be declared in host scope. Following code explains the use of texture reference for \_\_HIP\_PLATFORM\_AMD\_\_ platform.
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        // Code to generate code object
-
-                                                                                                                                                                                                      
-#include "hip/hip_runtime.h"
-                                                                                                                                                                                                      
-extern texture<float, 2, hipReadModeElementType> tex;
-
-        __global__ void tex2dKernel(hipLaunchParm lp, float* outputData,
-                                                                                                                                                                                                       //
-```
-
-```
-  }
-
-  // Host code:
-
-  texture<float, 2, hipReadModeElementType> tex;
-
-  void myFunc ()
-  {
-
-      //...
-
-      textureReference* texref;
-      hipModuleGetTexRef(&texref, Module1, "tex");
-      hipTexRefSetAddressMode(texref, 0, hipAddressModeWrap);
-      hipTexRefSetAddressMode(texref, 1, hipAddressModeWrap);
-      hipTexRefSetFilterMode(texref, hipFilterModePoint);
-```
-
-(continues on next page)
-
-```
-    hipTexRefSetFlags(texref, 0);
-    hipTexRefSetFormat(texref, HIP_AD_FORMAT_FLOAT, 1);
-    hipTexRefSetArray(texref, array, HIP_TRSA_OVERRIDE_FORMAT);
-
-    //...
-}
-```
-
-(continued from previous page)
-
-## TEN
-
-## PROGRAMMING FOR HIP RUNTIME COMPILER (RTC)
-
-HIP lets you compile kernels at runtime with the hiprtc* APIs. Kernels can be stored as a text string and can be passed to HIPRTC APIs alongside options to guide the compilation.
-
-NOTE:
-
-- This library can be used on systems without HIP installed nor AMD GPU driver installed at all (offline compilation). Therefore, it does not depend on any HIP runtime library.
-- But it does depend on comgr. You may try to statically link comgr into HIPRTC to avoid any ambiguity.
-- Developers can decide to bundle this library with their application.
-
-## 10.1 Example
-
-To use HIPRTC functionality, HIPRTC header needs to be included first. #include &lt;hip/hiprtc.h&gt;
-
-Kernels can be stored in a string:
-
-```
-<_C_>
-```
-
-Now to compile this kernel, it needs to be associated with hiprtcProgram type, which is done by declaring hiprtcProgram prog; and associating the string of kernel with this program:
-
-```
-hiprtcCreateProgram(&prog,                    // HIPRTC program
-                       kernel,                // kernel string
-                       "gpu_kernel.cu",       // Name of the file
-                       num_headers,            // Number of headers
-                       &header_sources[0],     // Header sources
-                       &header_names[0]);      // Name of header files
-```
-
-hiprtcCreateProgram API also allows you to add headers which can be included in your RTC program. For online compilation, the compiler pre-defines HIP device API functions, HIP specific types and macros for device compilation, but does not include standard C/C++ headers by default. Users can only include header files provided to hiprtcCreateProgram .
-
-After associating the kernel string with hiprtcProgram , you can now compile this program using:
-
-```
-
-
-hiprtcCompileProgram(prog,     // hiprtcProgram
-                         0,          // Number of options
-                          options);  // Clang Options [Supported Clang Options](clang_options.
-
---md)
-```
-
-hiprtcCompileProgram returns a status value which can be converted to string via hiprtcGetErrorString . If compilation is successful, hiprtcCompileProgram will return HIPRTC\_SUCCESS .
-
-If the compilation fails, you can look up the logs via:
-
-```
-<_C++_>
-```
-
-If the compilation is successful, you can load the compiled binary in a local variable.
-
-```
-  size_t codeSize;
-  hiprtcGetCodeSize(prog, &codeSize);
-
-  vector<char> kernel_binary(codeSize);
-  hiprtcGetCode(prog, kernel_binary.data());
-```
-
-After loading the binary, hiprtcProgram can be destroyed. hiprtcDestroyProgram(&amp;prog);
-
-The binary present in kernel\_binary can now be loaded via hipModuleLoadData API.
-
-```
-hipModule_t module;
-hipFunction_t kernel;
-
-hipModuleLoadData(&module, kernel_binary.data());
-hipModuleGetFunction(&kernel, module, "vector_add");
-```
-
-And now this kernel can be launched via hipModule APIs.
-
-The full example is below:
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        //
-```
-
-(continued from previous page)
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        </----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                    <-----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        >----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                   
-    <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                <----------------------------------------------------------------------------------------------------------------------    <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                               
-        <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                            <----------------------------------------------------------------------------------------------------------------------        <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                           
-            <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                        <----------------------------------------------------------------------------------------------------------------------            <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                       
-                <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                    <----------------------------------------------------------------------------------------------------------------------                <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                   
-                    <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                <----------------------------------------------------------------------------------------------------------------------                    <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                               
-                        <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                            <----------------------------------------------------------------------------------------------------------------------                        <----------------------------------------------------------------------------------------------------------------------
-```
-
-```
-HIP Documentation,Release 6.1.40092
-```
-
-(continued from previous page)
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        }
-                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       }
-
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                       	                                                                                                                                                                                                      
-
-                                                                                                                                                                                                      
-                                                                                                                                                                                                     
-
-                                                                                                                                                                                                    
- 
-                                                                                                                                                                                                    
-
-                                                                                                                                                                                                      
-
- 
-                                                                                                                                                                                                     }
- 
-                                                                                                                                                                                                    }
-  
-                                                                                                                                                                                                    }
-
-  
-                                                                                                                                                                                                   
-  
-                                                                                                                                                                                                   }
-```
-
-## 10.2 HIPRTC specific options
-
-HIPRTC provides a few HIPRTC specific flags
-
-- --gpu-architecture : This flag can guide the code object generation for a specific gpu arch. Example: --gpu-architecture=gfx906:sramecc+:xnack, its equivalent to --offload-arch .
-- -This option is compulsory if compilation is done on a system without AMD GPUs supported by HIP runtime.
-- -Otherwise, HIPRTC will load the hip runtime and gather the current device and its architecture info and use it as option.
-- -fgpu-rdc : This flag when provided during the hiprtcCompileProgram generates the bitcode (HIPRTC doesn't convert this bitcode into ISA and binary). This bitcode can later be fetched using hiprtcGetBitcode and hiprtcGetBitcodeSize APIs.
-
-## 10.2.1 Bitcode
-
-In the usual scenario, the kernel associated with hiprtcProgram is compiled into the binary which can be loaded and run. However, if -fpu-rdc option is provided in the compile options, HIPRTC calls comgr and generates only the LLVM bitcode. It doesn't convert this bitcode to ISA and generate the final binary.
-
-```
-  std::string sarg = std::string("-fgpu-rdc");
-  const char* options[] = {
-      sarg.c_str() };
-  hiprtcCompileProgram(prog, // hiprtcProgram
-                        1,     // Number of options
-                        options);
-```
-
-If the compilation is successful, one can load the bitcode in a local variable using the bitcode APIs provided by HIPRTC.
-
-```
-size_t bitCodeSize;
-hiprtcGetBitcodeSize(prog, &bitCodeSize);
-
-vector<char> kernel_bitcode(bitCodeSize);
-hiprtcGetBitcode(prog, kernel_bitcode.data());
-```
-
-## 10.2.2 CU Mode vs WGP mode
-
-AMDGPUs consist of an array of workgroup processors, each built with 2 compute units (CUs) capable of executing SIMD32. All the CUs inside a workgroup processor use local data share (LDS).
-
-gfx10+ support execution of wavefront in CU mode and work-group processor mode (WGP). Please refer to section 2.3 of RDNA3 ISA reference.
-
-gfx9 and below only supports CU mode.
-
-In WGP mode, 4 warps of a block can simultaneously be executed on the workgroup processor, where as in CU mode only 2 warps of a block can simultaneously execute on a CU. In theory, WGP mode might help with occupancy and increase the performance of certain HIP programs (if not bound to inter warp communication), but might incur performance penalty on other HIP programs which rely on atomics and inter warp communication. This also has effect of how the LDS is split between warps, please refer to RDNA3 ISA reference for more information.
-
-HIPRTCassumes WGPmodebydefault for gfx10+. This can be overridden by passing -mcumode to HIPRTC compile options in hiprtcCompileProgram .
-
-## 10.3 Linker APIs
-
-The bitcode generated using the HIPRTC Bitcode APIs can be loaded using hipModule APIs and also can be linked with other generated bitcodes with appropriate linker flags using the HIPRTC linker APIs. This also provides more flexibility and optimizations to the applications who want to generate the binary dynamically according to their needs. The input bitcodes can be generated only for a specific architecture or it can be a bundled bitcode which is generated for multiple architectures.
-
-## 10.3.1 Example
-
-Firstly, HIPRTC link instance or a pending linker invocation must be created using hiprtcLinkCreate , with the appropriate linker options provided.
-
-```
-<_C++_>
-```
-
-Following which, the bitcode data can be added to this link instance via hiprtcLinkAddData (if the data is present as a string) or hiprtcLinkAddFile (if the data is present as a file) with the appropriate input type according to the data or the bitcode used.
-
-```
-
-hiprtcLinkAddData(rtc_link_state,        // HIPRTC link state
-                         input_type,            // type of the input data or bitcode
-                         bit_code_ptr,           // input data which is null terminated
-                         bit_code_size,          // size of the input data
-                          "a",                   // optional name for this input
-                          0,                     // size of the options
-                          0,                     // Array of options applied to this input
-                          0);                      // Array of option values cast to void*
-```
-
-```
-hiprtcLinkAddFile(rtc_link_state,        // HIPRTC link state
-                         input_type,            // type of the input data or bitcode
-                         bc_file_path.c_str(),  // path to the input file where bitcode is_
---present
-                         0,                   // size of the options
-                          0,                    // Array of options applied to this input
-                          0);                    // Array of option values cast to void*
-```
-
-Once the bitcodes for multiple architectures are added to the link instance, the linking of the device code must be completed using hiprtcLinkComplete which generates the final binary.
-
-```
-<_C_>
-```
-
-If the hiprtcLinkComplete returns successfully, the generated binary can be loaded and run using the hipModule* APIs.
-
-```
-      |hipModuleLoadData(&module, bina
-```
-
-```
-binary);
-```
-
-## 10.3.1.1 Note
-
-- The compiled binary must be loaded before HIPRTC link instance is destroyed using the hiprtcLinkDestroy API.
-
-## hiprtcLinkDestroy(rtc\_link\_state);
-
-- The correct sequence of calls is : hiprtcLinkCreate , hiprtcLinkAddData or hiprtcLinkAddFile , hiprtcLinkComplete , hiprtcModuleLoadData , hiprtcLinkDestroy .
-
-## 10.3.2 Input Types
-
-HIPRTC provides hiprtcJITInputType enumeration type which defines the input types accepted by the Linker APIs. Here are the enum values of hiprtcJITInputType . However only the input types HIPRTC\_JIT\_INPUT\_LLVM\_BITCODE , HIPRTC\_JIT\_INPUT\_LLVM\_BUNDLED\_BITCODE and HIPRTC\_JIT\_INPUT\_LLVM\_ARCHIVES\_OF\_BUNDLED\_BITCODE are supported currently.
-
-HIPRTC\_JIT\_INPUT\_LLVM\_BITCODE can be used to load both LLVM bitcode or LLVM IR assembly code. However, HIPRTC\_JIT\_INPUT\_LLVM\_BUNDLED\_BITCODE and HIPRTC\_JIT\_INPUT\_LLVM\_ARCHIVES\_OF\_BUNDLED\_BITCODE are only for bundled bitcode and archive of bundled bitcode.
-
-```
-<_Cuda_>
-```
-
-## 10.3.3 Backward Compatibility of LLVM Bitcode/IR
-
-For HIP applications utilizing HIPRTC to compile LLVM bitcode/IR, compatibility is assured only when the ROCm or HIP SDK version used for generating the LLVM bitcode/IR matches the version used during the runtime compilation. When an application requires the ingestion of bitcode/IR not derived from the currently installed AMD compiler, it must run with HIPRTC and comgr dynamic libraries that are compatible with the version of the bitcode/IR.
-
-comgr, a shared library, incorporates the LLVM/Clang compiler that HIPRTC relies on. To identify the bitcode/IR version that comgr is compatible with, one can execute 'clang -v' using the clang binary from the same ROCm or HIP SDK package. For instance, if compiling bitcode/IR version 14, the HIPRTC and comgr libraries released by AMD around mid 2022 would be the best choice, assuming the LLVM/Clang version included in the package is also version 14.
-
-To ensure smooth operation and compatibility, an application may choose to ship the specific versions of HIPRTC and comgr dynamic libraries, or it may opt to clearly specify the version requirements and dependencies. This approach guarantees that the application can correctly compile the specified version of bitcode/IR.
-
-## 10.3.4 Link Options
-
-- HIPRTC\_JIT\_IR\_TO\_ISA\_OPT\_EXT - AMD Only. Options to be passed on to link step of compiler by hiprtcLinkCreate .
-- HIPRTC\_JIT\_IR\_TO\_ISA\_OPT\_COUNT\_EXT - AMD Only. Count of options passed on to link step of compiler.
-
-Example:
-
-```
-const char* isaopts[] = {"-mllvm", "-inline-threshold=1", "-mllvm", "-inlinehint-
---threshold=1"};
-std::vector<hiprtcJIT_option> jit_options = {HIPRTC_JIT_IR_TO_ISA_OPT_EXT,
-                                                                                                                                                                                                         HIPRTC_JIT_IR_TO_ISA_OPT_COUNT_EXT};
-size_t isaoptssize = 4;
-                                                                                                                                                                                                       (continues on next page)
-```
-
-```
-        const void* lopts[] = {(void*)isaopts, (void*)(isaoptssize)};
-        hiprtcLinkState linkstate;
-        hiprtcLinkCreate(2, jit_options.data(), (void**)lopts, &linkstate);
-```
-
-## 10.4 Error Handling
-
-HIPRTC defines the hiprtcResult enumeration type and a function hiprtcGetErrorString for API call error handling. hiprtcResult enum defines the API result codes. HIPRTC APIs return hiprtcResult to indicate the call result. hiprtcGetErrorString function returns a string describing the given hiprtcResult code, e.g., HIPRTC\_SUCCESS to 'HIPRTC\_SUCCESS'. For unrecognized enumeration values, it returns 'Invalid HIPRTC error code'.
-
-hiprtcResult enum supported values and the hiprtcGetErrorString usage are mentioned below.
-
-```
-<_Python_>
-```
-
-```
-hiprtcResult result;
-result = hiprtcCompileProgram(prog, 1, opts);
-if (result!= HIPRTC_SUCCESS) {
-std::cout << "hiprtcCompileProgram fails with error " << hiprtcGetErrorString(result);
-}
-```
-
-## 10.5 HIPRTC General APIs
-
-HIPRTC provides the following API for querying the version.
-
-hiprtcVersion(int* major, int* minor) - This sets the output parameters major and minor with the HIP Runtime compilation major version and minor version number respectively.
-
-Currently, it returns hardcoded value. This should be implemented to return HIP runtime major and minor version in the future releases.
-
-(continued from previous page)
-
-## 10.6 Lowered Names (Mangled Names)
-
-HIPRTC mangles the \_\_global\_\_ function names and names of \_\_device\_\_ and \_\_constant\_\_ variables. If the generated binary is being loaded using the HIP Runtime API, the kernel function or \_\_device\_\_/\_\_constant\_\_ variable must be looked up by name, but this is very hard when the name has been mangled. To overcome this, HIPRTC provides API functions that map \_\_global\_\_ function or \_\_device\_\_/\_\_constant\_\_ variable names in the source to the mangled names present in the generated binary.
-
-The two APIs hiprtcAddNameExpression and hiprtcGetLoweredName provide this functionality. First, a 'name expression' string denoting the address for the \_\_global\_\_ function or \_\_device\_\_/\_\_constant\_\_ variable is provided to hiprtcAddNameExpression . Then, the program is compiled with hiprtcCompileProgram . During compilation, HIPRTC will parse the name expression string as a C++ constant expression at the end of the user program. Finally, the function hiprtcGetLoweredName is called with the original name expression and it returns a pointer to the lowered name. The lowered name can be used to refer to the kernel or variable in the HIP Runtime API.
-
-## 10.6.1 Note
-
-- The identical name expression string must be provided on a subsequent call to hiprtcGetLoweredName to extract the lowered name.
-- The correct sequence of calls is : hiprtcAddNameExpression , hiprtcCompileProgram , hiprtcGetLoweredName , hiprtcDestroyProgram .
-- The lowered names must be fetched using hiprtcGetLoweredName only after the HIPRTC program has been compiled, and before it has been destroyed.
-
-## 10.6.2 Example
-
-kernel containing various definitions \_\_global\_\_ functions/function templates and \_\_device\_\_/\_\_constant\_\_ variables can be stored in a string.
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-        static constexpr const char gpu_program[] {
-```
-
-hiprtcAddNameExpression is called with various name expressions referring to the address of \_\_global\_\_ functions and \_\_device\_\_/\_\_constant\_\_ variables.
-
-```
-kernel_name_vec.push_back("&f1");
-kernel_name_vec.push_back("N1::N2::f2");
-kernel_name_vec.push_back("f3<int>");
-for (auto&& x : kernel_name_vec) hiprtcAddNameExpression(prog, x.c_str());
-variable_name_vec.push_back("&V1");
-```
-
-(continues on next page)
-
-(continued from previous page)
-
-```
-auto&& x : variable_name_vec) hiprtcAddNameExpression(prog, x.c_str());
-```
-
-```
-        | variable_name_vec.push_back("&N1::N2::V2");
-        for (auto&& x : variable_name_vec) hiprtcAddNameExp
-```
-
-After which, the program is compiled using hiprtcCompileProgram and the generated binary is loaded using hipModuleLoadData . And the mangled names can be fetched using hirtcGetLoweredName .
-
-```
-for (decltype(variable_name_vec.size()) i = 0; i!= variable_name_vec.size(); ++i) {
-  const char* name;
-  hiprtcGetLoweredName(prog, variable_name_vec[i].c_str(), &name);
-}
-```
-
-```
-    for (decltype(kernel_name_vec.size()) i = 0; i!= kernel_name_vec.size(); ++i) {
-      const char* name;
-      hiprtcGetLoweredName(prog, kernel_name_vec[i].c_str(), &name);
-    }
-```
-
-The mangled name of the variables are used to look up the variable in the module and update its value.
-
-```
-        hipDeviceptr_t variable_addr;
-        size_t bytes{};
-        hipModuleGetGlobal(&variable_addr, &bytes, module, name);
-        hipMemcpyHtoD(variable_addr, &initial_value, sizeof(initial_value));
-```
-
-Finally, the mangled name of the kernel is used to launch it using the hipModule APIs.
-
-```
-        hipFunction_t kernel;
-        hipModuleGetFunction(&kernel, module, name);
-        hipModuleLaunchKernel(kernel, 1, 1, 1, 1, 1, 0, nullptr, nullptr, config);
-```
-
-Please have a look at hiprtcGetLoweredName.cpp for the detailed example.
-
-## 10.7 Versioning
-
-HIPRTC follows the below versioning.
-
-- Linux
-- -HIPRTC follows the same versioning as HIP runtime library.
-- -The so name field for the shared library is set to MAJOR version. For example, for HIP 5.3 the so name is set to 5 ( hiprtc.so.5 ).
-- Windows
-- -HIPRTC dll is named as hiprtcXXYY.dll where XX is MAJOR version and YY is MINOR version. For example, for HIP 5.3 the name is hiprtc0503.dll .
-
-## 10.8 HIP header support
-
-- Added HIPRTC support for all the hip common header files such as library\_types.h, hip\_math\_constants.h, hip\_complex.h, math\_functions.h, surface\_types.h etc. from 6.1. HIPRTC users need not include any HIP macros or constants explicitly in their header files. All of these should get included via HIPRTC builtins when the app links to HIPRTC library.
-
-## 10.9 Deprecation notice
-
-- Currently HIPRTC APIs are separated from HIP APIs and HIPRTC is available as a separate library libhiprtc. so / libhiprtc.dll . But on Linux, HIPRTC symbols are also present in libamdhip64.so in order to support the existing applications. Gradually, these symbols will be removed from HIP library and applications using HIPRTC will be required to explicitly link to HIPRTC library. However, on Windows hiprtc.dll must be used as the amdhip64.dll doesn't contain the HIPRTC symbols.
-- Data types such as uint32\_t , uint64\_t , int32\_t , int64\_t defined in std namespace in HIPRTC are deprecated earlier and are being removed from ROCm release 6.1 since these can conflict with the standard C++ data types. These data types are now prefixed with \_\_hip\_\_ , e.g. \_\_hip\_uint32\_t . Applications previously using std::uint32\_t or similar types can use \_\_hip\_ prefixed types to avoid conflicts with standard std namespace or application can have their own definitions for these types. Also, type\_traits templates previously defined in std namespace are moved to \_\_hip\_internal namespace as implementation details.
-
-## CHAPTER
-
-## ELEVEN
-
-## PERFORMANCE GUIDELINES
-
-The AMDHIPPerformance Guidelines are a set of best practices designed to help developers optimize the performance of AMD GPUs. They cover established parallelization and optimization techniques, coding metaphors, and idioms that can greatly simplify programming for HIP-capable GPU architectures.
-
-By following four main cornerstones, we can exploit the performance optimization potential of HIP.
-
-- parallel execution
-- memory usage optimization
-- optimization for maximum throughput
-- minimizing memory thrashing
-
-In the following chapters, we will show you their benefits and how to use them effectively.
-
-## 11.1 Parallel execution
-
-For optimal use, the application should reveal and efficiently imply as much parallelism as possible to keep all system components active.
-
-## 11.1.1 Application level
-
-The application should optimize parallel execution across the host and devices using asynchronous calls and streams. Workloads should be assigned based on efficiency: serial to the host, parallel to the devices.
-
-For parallel workloads, when threads need to synchronize to share data, if they belong to the same block, they should use \_\_syncthreads() (see: Synchronization functions ) within the same kernel invocation. If they belong to different blocks, they must use global memory with two separate kernel invocations. The latter should be minimized as it adds overhead.
-
-## 11.1.2 Device level
-
-Device-level optimization primarily involves maximizing parallel execution across the multiprocessors of the device. This can be achieved by executing multiple kernels concurrently on a device. The management of these kernels is facilitated by streams, which allow for the overlapping of computation and data transfers, enhancing performance. The aim is to keep all multiprocessors busy by executing enough kernels concurrently. However, launching too many kernels can lead to resource contention, so a balance must be found for optimal performance. This approach helps in achieving maximum utilization of the resources of the device.
-
-## 11.1.3 Multiprocessor level
-
-Multiprocessor-level optimization involves maximizing parallel execution within each multiprocessor on a device. Each multiprocessor can execute a number of threads concurrently, and the total number of threads that can run in parallel is determined by the number of concurrent threads each multiprocessor can handle.
-
-The key to multiprocessor-level optimization is to efficiently utilize the various functional units within a multiprocessor. This can be achieved by ensuring a sufficient number of resident warps, as at every instruction issue time, a warp scheduler selects an instruction that is ready to execute. This instruction can be another independent instruction of the same warp, exploiting Optimization for maximum instruction throughput , or more commonly an instruction of another warp, exploiting thread-level parallelism.
-
-In comparison, device-level optimization focuses on the device as a whole, aiming to keep all multiprocessors busy by executing enough kernels concurrently. Both levels of optimization are crucial for achieving maximum performance. They work together to ensure efficient utilization of the resources of the GPU, from the individual multiprocessors to the device as a whole.
-
-## 11.2 Memory optimization
-
-The first step in maximizing memory throughput is to minimize low-bandwidth data transfers. This involves reducing data transfers between the host and the device, as these have lower bandwidth than transfers between global memory and the device.
-
-Additionally, data transfers between global memory and the device should be minimized by maximizing the use of on-chip memory: shared memory and caches. Shared memory acts as a user-managed cache, where the application explicitly allocates and accesses it. A common programming pattern is to stage data from device memory into shared memory. This involves each thread of a block loading data from device memory to shared memory, synchronizing with all other threads of the block, processing the data in shared memory, synchronizing again if necessary, and writing the results back to device global memory.
-
-For some applications, a traditional hardware-managed cache is more appropriate to exploit data locality. On devices of certain compute capabilities, the same on-chip memory is used for both L1 and shared memory, and the amount dedicated to each is configurable for each kernel call.
-
-Finally, the throughput of memory accesses by a kernel can vary significantly depending on the access pattern for each type of memory. Therefore, the next step in maximizing memory throughput is to organize memory accesses as optimally as possible. This is especially important for global memory accesses, as global memory bandwidth is low compared to available on-chip bandwidths and arithmetic instruction throughput. Thus, non-optimal global memory accesses generally have a high impact on performance.
-
-## 11.2.1 Data Transfer
-
-Applications should aim to minimize data transfers between the host and the device. This can be achieved by moving more computations from the host to the device, even if it means running kernels that do not fully utilize the parallelism for device. Intermediate data structures can be created, used, and discarded in device memory without being mapped or copied to host memory.
-
-Batching small transfers into a single large transfer can improve performance due to the overhead associated with each transfer. On systems with a front-side bus, using page-locked host memory can enhance data transfer performance.
-
-When using mapped page-locked memory, there is no need to allocate device memory or explicitly copy data between device and host memory. Data transfers occur implicitly each time the kernel accesses the mapped memory. For optimal performance, these memory accesses should be coalesced, similar to global memory accesses.
-
-On integrated systems where device and host memory are physically the same, any copy operation between host and device memory is unnecessary, and mapped page-locked memory should be used instead. Applications can check if a device is integrated by querying the integrated device property.
-
-## 11.2.2 Device Memory Access
-
-Memory access instructions may be repeated due to the spread of memory addresses across warp threads. The impact on throughput varies with memory type and is generally reduced when addresses are more scattered, especially in global memory.
-
-Device memory is accessed via 32-, 64-, or 128-byte transactions that must be naturally aligned. Maximizing memory throughput involves coalescing memory accesses of threads within a warp into minimal transactions, following optimal access patterns, using properly sized and aligned data types, and padding data when necessary.
-
-Global memory instructions support reading or writing data of specific sizes (1, 2, 4, 8, or 16 bytes) that are naturally aligned. If the size and alignment requirements are not met, it leads to multiple instructions, reducing performance. Therefore, using data types that meet these requirements, ensuring alignment for structures, and maintaining alignment for all values or arrays is crucial for correct results and optimal performance.
-
-Threads often access 2D arrays at an address calculated as BaseAddress + xIndex + width * yIndex . For efficient memory access, the array and thread block widths should be multiples of the warp size. If the array width is not a multiple of the warp size, it is usually more efficient to allocate it with a width rounded up to the nearest multiple and pad the rows accordingly.
-
-Local memory is used for certain automatic variables, such as arrays with non-constant indices, large structures or arrays, and any variable when the kernel uses more registers than available. Local memory resides in device memory, leading to high latency and low bandwidth similar to global memory accesses. However, it is organized for consecutive 32-bit words to be accessed by consecutive thread IDs, allowing full coalescing when all threads in a warp access the same relative address.
-
-Shared memory, located on-chip, provides higher bandwidth and lower latency than local or global memory. It is divided into banks that can be simultaneously accessed, boosting bandwidth. However, bank conflicts, where two addresses fall in the same bank, lead to serialized access and decreased throughput. Therefore, understanding how memory addresses map to banks and scheduling requests to minimize conflicts is crucial for optimal performance.
-
-Constant memory is in device memory and cached in the constant cache. Requests are split based on different memory addresses, affecting throughput, and are serviced at the throughput of the constant cache for cache hits, or the throughput of the device memory otherwise.
-
-Texture and surface memory are stored in device memory and cached in texture cache. This setup optimizes 2D spatial locality, leading to better performance for threads reading close 2D addresses. Reading device memory through texture or surface fetching can be advantageous, offering higher bandwidth for local texture fetches or surface reads, offloading addressing calculations, allowing data broadcasting, and optional conversion of 8-bit and 16-bit integer input data to 32-bit floating-point values on-the-fly.
-
-## 11.3 Optimization for maximum instruction throughput
-
-To maximize instruction throughput:
-
-- minimize low throughput arithmetic instructions
-- minimize divergent warps inflicted by control flow instructions
-- minimize the number of instruction as possible
-- maximize instruction parallelism
-
-## 11.3.1 Arithmetic instructions
-
-The type and complexity of arithmetic operations can significantly impact the performance of your application. We are highlighting some hints how to maximize it.
-
-Using efficient operations: Some arithmetic operations are more costly than others. For example, multiplication is typically faster than division, and integer operations are usually faster than floating-point operations, especially with double-precision.
-
-Minimizing low-throughput instructions: This might involve trading precision for speed when it does not affect the final result. For instance, consider using single-precision arithmetic instead of double-precision.
-
-Leverage intrinsic functions: Intrinsic functions are pre-defined functions available in HIP that can often be executed faster than equivalent arithmetic operations (subject to some input or accuracy restrictions). They can help optimize performance by replacing more complex arithmetic operations.
-
-Avoiding divergent warps: Divergent warps occur when threads within the same warp follow different execution paths. This can happen due to conditional statements that lead to different arithmetic operations being performed by different threads. Divergent warps can significantly reduce instruction throughput, so try to structure your code to minimize divergence.
-
-Optimizing memory access: The efficiency of memory access can impact the speed of arithmetic operations. Coalesced memory access, where threads in a warp access consecutive memory locations, can improve memory throughput and thus the speed of arithmetic operations.
-
-Maximizing instruction parallelism: Some GPU architectures could issue parallel independent instructions simultaneously, for example integer and floating point, or two operations with independent inputs and outputs. Mostly this is a work for compiler, but expressing parallelism in the code explicitly can improve instructions throughput.
-
-## 11.3.2 Control flow instructions
-
-Flow control instructions ( if , else , for , do , while , break , continue , switch ) can impact instruction throughput by causing threads within a warp to diverge and follow different execution paths. To optimize performance, control conditions should be written to minimize divergent warps. For example, when the control condition depends on ( threadIdx / warpSize ), no warp diverges. The compiler may optimize loops or short if or switch blocks using branch predication, preventing warp divergence. With branch predication, instructions associated with a false predicate are scheduled but not executed, avoiding unnecessary operations.
-
-## 11.3.3 Synchronization
-
-Synchronization ensures that all threads within a block have completed their computations and memory accesses before moving forward, which is critical when threads are dependent on the results of other threads. However, synchronization can also lead to performance overhead, as it requires threads to wait, potentially leading to idle GPU resources.
-
-\_\_syncthreads() is used to synchronize all threads in a block, ensuring that all threads have reached the same point in the code and that shared memory is visible to all threads after the point of synchronization.
-
-An alternative way to synchronize is using streams. Different streams can execute commands out of order with respect to one another or concurrently. This allows for more fine-grained control over the execution order of commands, which can be beneficial in certain scenarios.
-
-## 11.4 Minimizing memory thrashing
-
-Applications frequently allocating and freeing memory may experience slower allocation calls over time. This is expected as memory is released back to the operating system. To optimize performance in such scenarios, consider some recommendations:
-
-- avoid allocating all available memory with hipMalloc / hipHostMalloc , as this immediately reserves memory and can block other applications from using it. This could strain the operating system schedulers or even prevent other applications from running on the same GPU.
-- aim to allocate memory in suitably sized blocks early in the lifecycle of the application and deallocate only when the application no longer needs it. Minimize the number of hipMalloc and hipFree calls in your application, particularly in areas critical to performance.
-- if an application is unable to allocate sufficient device memory, consider resorting to other memory types such as hipHostMalloc or hipMallocManaged . While these may not offer the same performance, they can allow the application to continue running.
-- For supported platforms, hipMallocManaged allows for oversubscription. With the right memory advise policies, it can maintain most, if not all, of the performance of hipMalloc . hipMallocManaged does not require an allocation to be resident until it is needed or prefetched, easing the load on the operating system schedulers and facilitating multi-tenant scenarios.
-
-CHAPTER
-
-## TWELVE
-
-## DEBUGGING WITH HIP
-
-AMDdebugging tools include ltrace and ROCgdb . External tools are available and can be found online. For example, if you're using Windows, you can use Microsoft Visual Studio and WinGDB .
-
-You can trace and debug your code using the following tools and techniques.
-
-## 12.1 Tracing
-
-You can use tracing to quickly observe the flow of an application before reviewing the detailed information provided by a command-line debugger. Tracing can be used to identify issues ranging from accidental API calls to calls made on a critical path.
-
-ltrace is a standard Linux tool that provides a message to stderr on every dynamic library call. You can use ltrace to visualize the runtime behavior of the entire ROCm software stack.
-
-Here's a simple command-line example that uses ltrace to trace HIP APIs and output:
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?php?^"./hipGetChanDesc
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        </?php?^"
-	                                                                                                                                                                                                     
-		                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       <!
-                                                                                                                                                                                                      
-
-	                                                                                                                                                                                                       <%
-                                                                                                                                                                                                       </%
-                                                                                                                                                                                                      <?>
-                                                                                                                                                                                                       >
-```
-
-Here's another example that uses ltrace to trace hsa APIs and output:
-
-```
-        Here's another example that uses ltrace to trace hsa APIs and output:
-        $ ltrace  -C -e "hsa*"./hipGetChanDesc
-        libamdhip64.so.4->hsa_init(0, 0x7fff325a69d0, 0x9c80e0, 0 <unfinished...>
-        libhsa-runtime64.so.1->hsaKmtOpenKFD(0x7fff325a6590, 0x9c38c0, 0, 1) = 0
-        libhsa-runtime64.so.1->hsaKmtGetVersion(0x7fff325a6608, 0, 0, 0) = 0
-        libhsa-runtime64.so.1->hsaKmtReleaseSystemProperties(3, 0x80084b01, 0, 0) = 0
-        libhsa-runtime64.so.1->hsaKmtAcquireSystemProperties(0x7fff325a6610, 0, 0, 1) = 0
-        libhsa-runtime64.so.1->hsaKmtGetNodeProperties(0, 0x7fff325a66a0, 0, 0) = 0
-        libhsa-runtime64.so.1->hsaKmtGetNodeMemoryProperties(0, 1, 0x9c42b0, 0x936012) = 0
-       ...
-        <... hsaKmtCreateEvent  resumed> )                                                                                                                                                                                                        
-        libhsa-runtime64.so.1->hsaKmtAllocMemory(0, 4096, 64, 0x7fff325a6690) = 0
-        libhsa-runtime64.so.1->hsaKmtMapMemoryToGPUNodes(0x7f1202749000, 4096, 0x7fff325a6690,,...
-        --0) = 0
-        libhsa-runtime64.so.1->hsaKmtCreateEvent(0x7fff325a6700, 0, 0, 0x7fff325a66f0) = 0
-                                                                                                                                                                                                        (continues on next page)
-```
-
-(continues on next page)
-
-(continued from previous page)
-
-```
-HIP Documentation, Release 6.1.40092
-```
-
-## 12.2 Debugging
-
-You can use ROCgdb for debugging and profiling.
-
-ROCgdbis the ROCm source-level debugger for Linux and is based on GNU Project debugger (GDB). the GNU sourcelevel debugger, equivalent of CUDA-GDB, can be used with debugger frontends, such as Eclipse, Visual Studio Code, or GDB dashboard. For details, see (https://github.com/ROCm/ROCgdb).
-
-Below is a sample how to use ROCgdb run and debug HIP application, ROCgdb is installed with ROCM package in the folder /opt/rocm/bin.
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <p>
-                                                                                                                                                                                                       <h1>
-                                                                                                                                                                                                      <p/>
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        </p>
-                                                                                                                                                                                                     <p>
-
-                                                                                                                                                                                                       <a>
-                                                                                                                                                                                                     
- 	                                                                                                                                                                                                       <b>
-                                                                                                                                                                                                      </a>
-                                                                                                                                                                                                     <a>
-
-                                                                                                                                                                                                      <b/>
-                                                                                                                                                                                                      <a/>
-                                                                                                                                                                                                     
-		                                                                                                                                                                                                      
-
-	                                                                                                                                                                                                      <a></b>
-```
-
-## 12.2.1 Debugging HIP applications
-
-The following Linux example shows how to get useful information from the debugger while running a simple memory copy test, which caused a segmentation fault issue.
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <p>test, which caused a segmentation fault issue.                                                                                                                                                                                                        </p>                                                                                                                                                                                                        >
-                                                                                                                                                                                                       <a>http://tests/src/runtimeApi/memory/hipMemcpy_simple.cpp:147
-```
-
-(continues on next page)
-
-(continued from previous page)
-
-```
-HIP Documentation, Release 6.1.40092
-
-
-                                                                                                                                                                                                         (continued from previous page)                                                                                                                                                                                                       
-                                                                                                                                                                                                      
-1                                                                                                                                                                                                        "                                                                                                                                                                                                        <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        </----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                    <-----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        >----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                   
-1   //                                                                                                                                                                                                        :                                                                                                                                                                                                        |                                                                                                                                                                                                        -                                                                                                                                                                                                        +                                                                                                                                                                                                        \
-                                                                                                                                                                                                       |
-                                                                                                                                                                                                       <============================================================================================                                                                                                                                                                                                        }                                                                                                                                                                                                        )
-```
-
-Debugging HIP applications using Windows tools can be more informative than on Linux. Windows tools provides more visibility into debug codes, which makes it easier to inspect variables, watch multiple details, and examine call stacks.
-
-## 12.3 Useful environment variables
-
-HIP provides environment variables that allow HIP, hip-clang, or HSA drivers to prevent certain features and optimizations. These are not intended for production, but can be useful to diagnose synchronization problems in the application (or driver).
-
-Some of the more widely used environment variables are described in this section. These are supported on the Linux ROCm path and Windows.
-
-## 12.3.1 Kernel enqueue serialization
-
-You can control kernel command serialization from the host:
-
-## AMD\_SERIALIZE\_KERNEL , for serializing kernel enqueue
-
-AMD\_SERIALIZE\_KERNEL = 1 , Wait for completion before enqueue AMD\_SERIALIZE\_KERNEL = 2 , Wait for completion after enqueue AMD\_SERIALIZE\_KERNEL = 3 , Both
-
-Or
-
-## AMD\_SERIALIZE\_COPY , for serializing copies
-
-AMD\_SERIALIZE\_COPY = 1 , Wait for completion before enqueue AMD\_SERIALIZE\_COPY = 2 , Wait for completion after enqueue AMD\_SERIALIZE\_COPY = 3 , Both
-
-So HIP runtime can wait for GPU idle before/after any GPU command depending on the environment setting.
-
-## 12.3.2 Making device visible
-
-For systems with multiple devices, you can choose to make only certain device(s) visible to HIP using HIP\_VISIBLE\_DEVICES (or CUDA\_VISIBLE\_DEVICES on an NVIDIA platform). Once enabled, HIP can only view devices that have indices present in the sequence. For example:
-
-```
-    | $ HIP_VISIBLE_DEVICES=0,1
-```
-
-```
-<_Python_>
-```
-
-```
-if (totalDeviceNum > 2) {
-setenv("HIP_VISIBLE_DEVICES", "0,1,2", 1);
-assert(getDeviceNumber(false) == 3);
-
-.......
-}
-```
-
-## 12.3.3 Dump code object
-
-To analyze compiler-related issues, you can use the dump code object: GPU\_DUMP\_CODE\_OBJECT .
-
-## 12.3.4 HSA-related environment variables (Linux)
-
-HSA provides environment variables that help analyze issues in drivers or hardware.
-
-- To isolate issues with hardware copy engines, you can use HSA\_ENABLE\_SDMA .
-- HSA\_ENABLE\_SDMA=0 causes host-to-device and device-to-host copies to use compute shader blit kernels, rather than the dedicated DMA copy engines. Compute shader copies have low latency (typically &lt; 5 us) and can achieve approximately 80% of the bandwidth of the DMA copy engine.
-- To diagnose interrupt storm issues in the driver, you can use HSA\_ENABLE\_INTERRUPT .
-
-HSA\_ENABLE\_INTERRUPT=0 causes completion signals to be detected with memory-based polling, rather than interrupts.
-
-## 12.3.5 HIP environment variable summary
-
-Here are some of the more commonly used environment variables:
-
-| Environment variable                                                                                                          | De- fault value   | Usage                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-|-------------------------------------------------------------------------------------------------------------------------------|-------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| AMD_LOG_LEVEL Enable HIP log on different Level                                                                               | 0                 | 0: Disable log. 1: Enable log on error level 2: Enable log on warning and below levels 0x3: Enable log on information and below levels 0x4: Decode and display AQL packets                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-| AMD_LOG_MASK Enable HIP log on different Level                                                                                |                   | 0x7FFFFFFF 0x1: Log API calls 0x02: Kernel and Copy Commands and Barriers 0x4: Synchroniza- tion and waiting for commands to finish 0x8: Enable log on information and below levels 0x20: Queue commands and queue contents 0x40: Signal creation, allocation, pool 0x80: Locks and thread-safety code 0x100: Copy debug 0x200: Detailed copy debug 0x400: Resource allocation, performance-impacting events 0x800: Initialization and shutdown 0x1000: Misc debug, not yet classified 0x2000: Show raw bytes of AQL packet 0x4000: Show code creation debug 0x8000: More detailed command info, including barrier com- mands 0x10000: Log message location 0xFFFFFFFF: Log always even mask flag is zero |
-| HIP_LAUNCH_BLOCKING Used for serial- ization on kernel execution.                                                             | 0                 | 0: Disable. Kernel executes normally. 1: Enable. Serializes kernel enqueue, behaves the same as AMD_SERIALIZE_KERNEL.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| HIP_VISIBLE_DEVICES (or CUDA_VISIBLE_DEVICES) Only devices whose index is present in the sequence are visible to HIP          |                   | 0,1,2: Depending on the number of devices on the system                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| GPU_DUMP_CODE_OBJECT Dump code ob- ject                                                                                       | 0                 | 0: Disable 1: Enable                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| AMD_SERIALIZE_KERNEL Serialize kernel enqueue                                                                                 | 0                 | 1: Wait for completion before enqueue 2: Wait for completion after enqueue 3: Both                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
-| AMD_SERIALIZE_COPY Serialize copies                                                                                           | 0                 | 1: Wait for completion before enqueue 2: Wait for completion after enqueue 3: Both                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
-| HIP_HOST_COHERENT Coherent mem-                                                                                               | 0                 | 0: memory is not coherent between host and GPU 1: memory is coherent with host                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
-| ory in hipHost- Malloc AMD_DIRECT_DISPATCH Enable direct kernel dispatch (Currently for Linux; under development for Windows) | 1                 | 0: Disable 1: Enable                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| GPU_MAX_HW_QUEUES The maximum number of hard- ware queues allocated per device                                                | 4                 | The variable controls how many independent hardware queues HIP runtime can create per process, per device. If an application allocates more HIP streams than this number, then HIP runtime reuses the same hardware queues for the new streams in a round-robin manner. Note that this maximum number does not apply to hardware queues that are created for CU-masked HIP streams, or cooperative queues for HIP Cooperative Groups (single queue per device).                                                                                                                                                                                                                                           |
-
-## 12.4 General debugging tips
-
-- gdb --args can be used to pass the executable and arguments to gdb .
-- You can set environment variables ( set env ) from within GDB on Linux:
-
-```
-        | (gdb)  set env  AND_SERIALIZE_KERNEL  3
-```
-
-Note: This gdb command does not use an equal (=) sign.
-
-- The GDB backtrace shows a path in the runtime. This is because a fault is caught by the runtime, but it is generated by an asynchronous command running on the GPU.
-- To determine the true location of a fault, you can force the kernels to run synchronously by setting the environment variables AMD\_SERIALIZE\_KERNEL=3 and AMD\_SERIALIZE\_COPY=3 . This forces HIP runtime to wait for the kernel to finish running before returning. If the fault occurs when a kernel is running, you can see the code that launched the kernel inside the backtrace. The thread that's causing the issue is typically the one inside libhsa-runtime64.so .
-- VMfaults inside kernels can be caused by:
-- -Incorrect code (e.g., a for loop that extends past array boundaries)
-- -Memory issues, such as invalid kernel arguments (null pointers, unregistered host pointers, bad pointers)
-- -Synchronization issues
-- -Compiler issues (incorrect code generation from the compiler)
-- -Runtime issues
-
-## CHAPTER
-
-## THIRTEEN
-
-## LOGGING HIP ACTIVITY
-
-HIP provides a logging mechanism that allows you to trace HIP API and runtime codes when running a HIP application. In addition to being useful to our users/developers, the HIP development team uses these logs to improve the HIP runtime.
-
-By adjusting the logging settings and logging mask, you can get different types of information for different functionalities, such as HIP APIs, executed kernels, queue commands, and queue contents. Refer to the following sections for examples.
-
-Tip: Logging works for the release and debug versions of HIP. If you want to save logging output in a file, define the file when running the application via command line. For example:
-
-```
-            |user@user-test:~/hip/bin$./hipinfo > ~/hipinfo > ~/hip_log.txt
-```
-
-## 13.1 Logging level
-
-HIP logging is disabled by default. You can enable it via the AMD\_LOG\_LEVEL environment variable. The value of this variable controls your logging level. Levels are defined as follows:
-
-```
-                                                                                                                                                                                                       
-  enum LogLevel {
-      LOG_NONE       = 0,
-      LOG_ERROR     = 1,
-      LOG_WARNING = 2,
-      LOG_INFO       = 3,
-      LOG_DEBUG     = 4
-  };
-```
-
-Tip: You can call a logging function with different logging levels. All information under the value set for AMD\_LOG\_LEVEL is printed.
-
-## 13.2 Logging mask
-
-The logging mask is designed to print functionality types when you're running a HIP application. Once you set AMD\_LOG\_LEVEL , the logging mask is set as the default value ( 0x7FFFFFFF ). You can change this to any of the valid values:
-
-```
-        The logging mask is designed to print functionality types when you're running a HIP application.  Once you set
-        AMD_LOG_LEVEL, the logging mask is set as the default value (0x7FFFFFFF). You can change this to any of the valid
-        values:
-
-        enum LogMask {
-          LOG_API         = 0x000000001,  //!< API call
-          LOG_CMD         = 0x000000002,  //!< Kernel and Copy Commands and Barriers
-          LOG_WAIT        = 0x000000004,  //!< Synchronization and waiting for commands to finish
-          LOG_AQL         = 0x000000008,  //!< Decode and display AQL packets
-          LOG_QUEUE      = 0x00000010,  //!< Queue commands and queue contents
-          LOG_SIG         = 0x00000020,  //!< Signal creation, allocation, pool
-          LOG_LOCK        = 0x00000040,  //!< Locks and thread-safety code.
-          LOG_KERN        = 0x00000080,  //!< kernel creations and arguments, etc.
-          LOG_COPY        = 0x000000100,  //!< Copy debug
-          LOG_COPY2       = 0x000000200,  //!< Detailed copy debug
-          LOG_RESOURCE   = 0x000000400,  //!< Resource allocation, performance-impacting events.
-          LOG_INIT        = 0x00000080,  //!< Initialization and shutdown
-          LOG_MISC        = 0x00001000,  //!< misc debug, not yet classified
-          LOG_AQL2        = 0x00002000,  //!< Show raw bytes of AQL packet
-          LOG_CODE        = 0x00004000,  //!< Show code creation debug
-          LOG_CMD2        = 0x00008000,  //!< More detailed command info, including barrier commands
-          LOG_LOCATION   = 0x00010000,  //!< Log message location
-          LOG_MEM         = 0x0000200000,  //!< Memory allocation
-          LOG_MEM_POOL   = 0x00040000,  //!< Memory pool allocation, including memory in graphs
-          LOG_ALWAYS     = 0xFFFFFFFF,  //!< Log always even mask flag is zero
-        };
-
-        You can also define the logging mask via the AMD_LOG_MASK environment variable.
-```
-
-You can also define the logging mask via the AMD\_LOG\_MASK environment variable.
-
-## 13.3 Logging command
-
-You can use the following code to print HIP logging information:
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?                                                                                                                                                                                                        </?                                                                                                                                                                                                       <!                                                                                                                                                                                                        >
-                                                                                                                                                                                                       <&                                                                                                                                                                                                        &
-                                                                                                                                                                                                      
-																																																																																																																																																																																																								                                                                                                                                                                                                       																																																																																																																																																																																																							<?                                                                                                                                                                                                      	                                                                                                                                                                                                      	
-																																																																																																																																																																																																						 																																																																																																																																																																																																						  <?
-```
-
-Using HIP code, call the ClPrint() function with the desired input variables. For example:
-
-```
-            |ClPrint(amd::LOG_INFO, amd::LOG_INIT, "Initializing HSA stack.");
-```
-
-## 13.4 Logging examples
-
-On Linux , you can enable HIP logging and retrieve logging information when you run hipinfo .
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <HR>
-                                                                                                                                                                                                       <HIP Documentation, Release 6.1.40092                                                                                                                                                                                                        </HIP Documentation, Release 6.1.40092                                                                                                                                                                                             <HR>
-        Loggging examples                                                                                                                                                                                                        >
-                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       >
-
-                                                                                                                                                                                                       <BR>
-                                                                                                                                                                                                      <BR><BR>
-                                                                                                                                                                                                     <BR>
-
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                       	                                                                                                                                                                                                       <B>
-                                                                                                                                                                                                     
-  <B>
-                                                                                                                                                                                                   <BR>
-  <B>
-                                                                                                                                                                                                  <BR>
-```
-
-(continues on next page)
-
-(continued from previous page)
-
-```
-HIP Documentation, Release 6.1.40092
-```
-
-On Windows , you can set AMD\_LOG\_LEVEL via environment variable from the advanced system settings or the command prompt (when run as administrator). The following example shows debug log information when calling the backend runtime.
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <kendo runume.                                                                                                                                                                                                        </kendo>runume.
-```
-
-(continues on next page)
-
-(continued from previous page)
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <![
-                                                                                                                                                                                                       <?xml:%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/.%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/)
-                                                                                                                                                                                                      
-
-                                                                                                                                                                                                      
-
-
-                                                                                                                                                                                                       </?xml:%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazon AWS.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazon AWS.com/.%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazon AWS.com%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/"
-                                                                                                                                                                                                       :
-                                                                                                                                                                                                       >
-                                                                                                                                                                                                      ?xml:%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws,com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws,com%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.
-```
-
-(continues on next page)
-
-(continued from previous page)
-
-```
-  --copyBuffer
-...
-:4:C:\constructicon\builds\gfx\two\22.40\drivers\compute\vdi\device\pal\palmemory.
-  --cpp:206 : 605414523422 us: 29864: [tid:0x9298] Alloc: 100000 bytes,_,
-  --ptr[0000003008D0000-0000003009D0000], obj[0000003007D0000-0000003047D0000]
-:4:C:\constructicon\builds\gfx\two\22.40\drivers\compute\vdi\device\pal\palmemory.
-  --cpp:206 : 605414523767 us: 29864: [tid:0x9298] Alloc: 100000 bytes,_,
-  --ptr[0000003009D0000-000000300AD0000], obj[0000003007D0000-0000003047D0000]
-:3:C:\constructicon\builds\gfx\two\22.40\drivers\compute\hipamd\src\hip_memory.cpp:681 :_,
-  --605414524092 us: 29864: [tid:0x9298] hipMemGetInfo: Returned hipSuccess :
-memInfo.total:                     12.06 GB
-memInfo.free:                     11.93 GB (99%)
-```
-
-## CHAPTER
-
-## FOURTEEN
-
-## COOPERATIVE GROUPS
-
-Cooperative groups API is an extension to the HIP programming model, which provides developers with a flexible, dynamic grouping mechanism for the communicating threads. Cooperative groups let you define your own set of thread groups which may fit your user-cases better than those defined by the hardware. This lets you specify the level of granularity for thread communication which can lead to more efficient parallel decompositions.
-
-The API is accessible in the cooperative\_groups namespace after the hip\_cooperative\_groups.h is included. The header contains the following elements:
-
-- Static functions to create groups and subgroups.
-- Hardware-accelerated operations over the whole group, like shuffles.
-- Data types of cooperative groups.
-- Synchronize member function of the groups.
-- Get group properties member functions.
-
-## 14.1 Cooperative groups thread model
-
-The thread hierarchy abstraction of cooperative groups are in grid hierarchy and block hierarchy .
-
-Fig. 1: Cooperative group thread hierarchy in grids.
-
-The multi grid is an abstraction of potentially multiple simultaneous launches of the same kernel over multiple devices (Deprecated since 5.0). The grid in cooperative groups is a single dispatch of kernels for execution like the original grid.
-
-Note: The ability to synchronize over a grid or multi grid requires the kernel to be launched using the specific cooperative groups API.
-
-The block is the same as the Inherent thread model block entity.
-
-Note: Explicit warp-level thread handling is absent from the Cooperative groups API. In order to exploit the known hardware SIMD width on which built-in functionality translates to simpler logic, you can use the group partitioning part of the API, such as tiled\_partition .
-
-Fig. 2: Cooperative group thread hierarchy in blocks.
-
-The cooperative groups API introduce a new level between block thread and threads. The thread-block tile give the opportunity to have tiles in the thread block, while the coalesced group holds the active threads of the parent group. These groups further discussed in the groups types section.
-
-For details on memory model, check the memory model description .
-
-## 14.2 Group types
-
-Group types are based on the levels of synchronization and data sharing among threads.
-
-## 14.2.1 Thread-block group
-
-Represents an intra-block cooperative groups type where the participating threads within the group are the same threads that participated in the currently executing block .
-
-```
-    class thread_block;
-
-    Constructed via:
-
-    thread_block g = this_thread_block();
-```
-
-The group\_index() , thread\_index() , thread\_rank() , size() , cg\_type() , is\_valid() , sync() and group\_dim() member functions are public of the thread\_block class. For further details, check the thread\_block references .
-
-## 14.2.2 Grid group
-
-Represents an inter-block cooperative groups type where the group's participating threads span multiple blocks running the same kernel on the same device. Use the cooperative launch API to enable synchronization across the grid group.
-
-```
-class grid_group;
-
- Constructed via:
-
-grid_group g = this_grid();
-```
-
-The thread\_rank() , size() , cg\_type() , is\_valid() and sync() member functions are public of the grid\_group class. For further details, check the grid\_group references .
-
-## 14.2.3 Multi-grid group
-
-Represents an inter-device cooperative groups type where the participating threads within the group span multiple devices that run the same kernel on the devices. Use the cooperative launch API to enable synchronization across the multi-grid group.
-
-```
-    |class multi_grid_group;
-```
-
-```
-;
-```
-
-Constructed via:
-
-```
-<_C_>
-```
-
-```
-<_YAML_>
-```
-
-The num\_grids() , grid\_rank() , thread\_rank() , size() , cg\_type() , is\_valid() , and sync() member functions are public of the multi\_grid\_group class. For further details check the multi\_grid\_group references .
-
-## 14.2.4 Thread-block tile
-
-This constructs a templated class derived from thread\_group . The template defines the tile size of the new thread group at compile time. This group type also supports sub-wave level intrinsics.
-
-```
-<_C++_>
-```
-
-Constructed via:
-
-```
-<_SQL_>
-```
-
-## Note:
-
-- Size must be a power of 2 and not larger than warp (wavefront) size.
-- shfl() functions support integer or float type.
-
-The thread\_rank() , size() , cg\_type() , is\_valid() , sync() , meta\_group\_rank() , meta\_group\_size() , shfl() , shfl\_down() , shfl\_up() , shfl\_xor() , ballot() , any() , all() , match\_any() and match\_all() member functions are public of the thread\_block\_tile class. For further details, check the thread\_block\_tile references .
-
-## 14.2.5 Coalesced groups
-
-Threads (64 threads on CDNA and 32 threads on RDNA) in a warp cannot execute different instructions simultaneously, so conditional branches are executed serially within the warp. When threads encounter a conditional branch, they can diverge, resulting in some threads being disabled, if they do not meet the condition to execute that branch. The active threads referred as coalesced, and coalesced group represents an active thread group within a warp.
-
-Note: The NVIDIA GPU's independent thread scheduling presents the appearance that threads on different branches execute concurrently.
-
-Warning: AMD GPUs do not support independent thread scheduling. Some CUDA application can rely on this feature and the ported HIP version on AMD GPUs can deadlock, when they try to make use of independent thread scheduling.
-
-This group type also supports sub-wave level intrinsics.
-
-```
-    | class coalesced_group;
-```
-
-Constructed via:
-
-coalesced\_group
-
-```
-    |roup active  = coalesced_threads() ;
-```
-
-Note: shfl() functions support integer or float type.
-
-The thread\_rank() , size() , cg\_type() , is\_valid() , sync() , meta\_group\_rank() , meta\_group\_size() , shfl() , shfl\_down() , shfl\_up() , ballot() , any() , all() , match\_any() and match\_all() member functions are public of the coalesced\_group class. For more information, see coalesced\_group references .
-
-## 14.3 Cooperative groups simple example
-
-The difference to the original block model in the reduce\_sum device function is the following.
-
-## Original Block
-
-```
-<_Cuda_>
-```
-
-## Cooperative groups
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        // Thread ID
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        /                                                                                                                                                                                                        *                                                                                                                                                                                                        /*                                                                                                                                                                                                        */
-                                                                                                                                                                                                       */
-```
-
-(continues on next page)
-
-(continued from previous page)
-
-```
-      for(unsigned int i = g.size() / 2; i > 0; i /= 2) {
-          // Store value in shared memory with thread ID
-          shared[group_thread_id] = val;
-
-          // Synchronize all threads in the group
-          g.sync();
-
-          // Active thread sum up
-          if(group_thread_id < i)
-               val += shared[group_thread_id + i];
-
-          // Synchronize all threads in the group
-          g.sync();
-      }
-
-      //...
-}
-
-The reduce_sum() function call and input data initialization difference to the origin.
-```
-
-The reduce\_sum() function call and input data initialization difference to the original block model is the following.
-
-## Original Block
-
-```
-Original Block
-
-__global__ void sum_kernel(...) {
-
-    //...
-
-    // Workspace array in shared memory
-    __shared__ unsigned int workspace[2048];
-
-    //...
-
-    // Perform reduction
-    output = reduce_sum(workspace, input);
-
-    //...
-}
-```
-
-## Cooperative groups
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        //                                                                                                                                                                                                        const auto                                                                                                                                                                                                        }                                                                                                                                                                                                        /*                                                                                                                                                                                                        */                                                                                                                                                                                                        *
-```
-
-(continued from previous page)
-
-```
-    thread_block thread_block_group = this_thread_block();
-    // Perform reduction
-    output = reduce_sum(thread_block_group, workspace, input);
-
-    //...
-}
-```
-
-At the device function, the input group type is the thread\_group , which is the parent class of all the cooperative groups type. With this, you can write generic functions, which can work with any type of cooperative groups.
-
-## 14.4 Synchronization
-
-With each group type, the synchronization requires using the correct cooperative groups launch API.
-
-## Check the kernel launch capability
-
-## Thread-block
-
-Do not need kernel launch validation.
-
-## Grid
-
-Confirm the cooperative launch capability on the single AMD GPU:
-
-```
-    Confirm the cooperative launch capability on the single AMD GPU:
-
-    int device                       = 0;
-    int supports_coop_launch = 0;
-    // Check support
-    // Use hipDeviceAttributeCooperativeMultiDeviceLaunch when launching across multiple_
-    --devices
-    HIP_CHECK(hipGetDevice(&device));
-    HIP_CHECK(
-        hipDeviceGetAttribute(&supports_coop_launch, hipDeviceAttributeCooperativeLaunch,\
-    --device));
-    if(!supports_coop_launch)
-    {
-        std::cout << "Skipping, device " << device << " does not support cooperative groups"
-                       << std::endl;
-        return 0;
-    }
-```
-
-## Multi-grid
-
-Confirm the cooperative launch capability over multiple GPUs:
-
-```
-    Multi-grid
-
-    Confirm the cooperative launch capability over multiple GPUs:
-
-    // Check support of cooperative groups
-    std::vector<int> deviceIDs;
-    for(int deviceID = 0; deviceID < device_count; deviceID++) {
-    #ifdef __HIP_PLATFORM_AMD__
-        int supports_coop_launch = 0;
-        HIP_CHECK(
-            hipDeviceGetAttribute(
-                &supports_coop_launch,
-                hipDeviceAttributeCooperativeMultiDeviceLaunch,
-                deviceID));
-        if(!supports_coop_launch) {
-            std::cout << "Skipping, device " << deviceID << " does not support cooperative_
-    --groups"
-                        << std::endl;
-        }
-        else
-    #endif
-        {
-            std::cout << deviceID << std::endl;
-            // Collect valid deviceIDs.
-            deviceIDs.push_back(deviceID);
-        }
-    }
-
-    Kernel launch
-
-    __   ...  .
-```
-
-## Kernel launch
-
-## Thread-block
-
-You can access the new block representation using the original kernel launch methods.
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        // Launching kernel  from host.
-```
-
-## Grid
-
-Launch the cooperative kernel on a single GPU:
-
-```
-<_C_>
-```
-
-## Multi-grid
-
-Launch the cooperative kernel over multiple GPUs:
-
-```
-    Multi-grid
-
-    Launch the cooperative kernel over multiple GPUs:
-
-    hipLaunchParams *launchParamsList = (hipLaunchParams*)malloc(sizeof(hipLaunchParams) *_
-    --deviceIDs.size());
-    for(int deviceID : deviceIDs) {
-
-        // Set device
-        HIP_CHECK(hipSetDevice(deviceID));
-
-        // Create stream
-        hipStream_t stream;
-        HIP_CHECK(hipStreamCreate(&stream));
-
-        // Parameters
-        void* params[] = {&(d_vector[deviceID]), &(d_block_reduced[deviceID]), &(d_partition_
-    --reduced[deviceID])};
-
-        // Set launchParams
-        launchParamsList[deviceID].func = (void*)vector_reduce_kernel<partition_size>;
-        launchParamsList[deviceID].gridDim = dim3(1);
-        launchParamsList[deviceID].blockDim = dim3(threads_per_block);
-        launchParamsList[deviceID].sharedMem = 0;
-        launchParamsList[deviceID].stream = stream;
-        launchParamsList[deviceID].args = params;
-    }
-
-    HIP_CHECK(hipLaunchCooperativeKernelMultiDevice(launchParamsList,
-                                                                                                                                                                                                         (int)deviceIDs.size(),
-                                                                                                                                                                                                       )
-    --hipCooperativeLaunchMultiDeviceNoPreSync));
-
-    Device side synchronization
-```
-
-Device side synchronization
-
-## Thread-block
-
-The device side code of the thread\_block synchronization over single GPUs:
-
-```
-<_C_>
-```
-
-## Grid
-
-The device side code of the grid synchronization over single GPUs:
-
-```
-<_Cython_>
-```
-
-```
-  =  this._grid() ;
-```
-
-## Multi-grid
-
-The device side code of the multi-grid synchronization over multiple GPUs:
-
-```
-            |multi_grid_group multi_grid = this_multi_grid();
-```
-
-```
-|multi_grid.sync();
-```
-
-## 14.5 Unsupported NVIDIA CUDA features
-
-HIP doesn't support the following NVIDIA CUDA optional headers:
-
-- cooperative\_groups/memcpy\_async.h
-- cooperative\_groups/reduce.h
-- cooperative\_groups/scan.h
-
-HIP doesn't support the following CUDA class in cooperative\_groups namespace:
-
-- cluster\_group
-
-HIP doesn't support the following CUDA functions/operators in cooperative\_groups namespace:
-
-- synchronize
-- memcpy\_async
-- wait and wait\_prior
-- barrier\_arrive and barrier\_wait
-- invoke\_one and invoke\_one\_broadcast
-- reduce
-- reduce\_update\_async and reduce\_store\_async
-- Reduce operators plus , less , greater , bit\_and , bit\_xor and bit\_or
-- inclusive\_scan and exclusive\_scan
-
-## CHAPTER
-
-## FIFTEEN
-
-## UNIFIED MEMORY
-
-In conventional architectures, CPUs and GPUs have dedicated memory like Random Access Memory (RAM) and Video Random Access Memory (VRAM). This architectural design, while effective, can be limiting in terms of memory capacity and bandwidth, as continuous memory copying is required to allow the processors to access the appropriate data. New architectural features like Heterogeneous System Architectures (HSA) and Unified Memory (UM) help avoid these limitations and promise increased efficiency and innovation.
-
-## 15.1 Unified memory
-
-Unified Memory is a single memory address space accessible from any processor within a system. This setup simplifies memory management processes and enables applications to allocate data that can be read or written by code running on either CPUs or GPUs. The Unified memory model is shown in the following figure.
-
-AMD Accelerated Processing Unit (APU) is a typical example of a Unified Memory Architecture. On a single die, a central processing unit (CPU) is combined with an integrated graphics processing unit (iGPU), and both have access to a high-bandwidth memory (HBM) module named Unified Memory. The CPU enables high-performance, low-latency operations, while the GPU is optimized for high throughput (data processed by unit time).
-
-## 15.2 System requirements
-
-Unified memory is supported on Linux by all modern AMD GPUs from the Vega series onward. Unified memory management can be achieved with managed memory allocation and, for the latest GPUs, with a system allocator.
-
-The table below lists the supported allocators. The allocators are described in the next section.
-
-Table 1: Supported Unified Memory Allocators
-
-| Architecture        | hipMallocManaged()   | __managed__   | malloc()   |
-|---------------------|----------------------|---------------|------------|
-| MI200, MI300 Series |                      |               | 1          |
-| MI100               |                      |               |            |
-| RDNA (Navi) Series  |                      |               |            |
-| GCN5 (Vega) Series  |                      |               |            |
-
-## : Supported
-
-- : Unsupported
-
-1 Works only with XNACK=1 . First GPU access causes recoverable page-fault. For more details, visit GPU memory.
-
-## 15.3 Unified memory programming models
-
-Showcasing various unified memory programming models, the model availability depends on your architecture. For more information, see System requirements and Checking unified memory management support .
-
-- HIP managed memory allocation API :
-
-The hipMallocManaged() is a dynamic memory allocator available on all GPUs with unified memory support. For more details, visit HIP managed memory allocation API .
-
-- HIP managed variables :
-
-The \_\_managed\_\_ declaration specifier, which serves as its counterpart, is supported on all modern AMD cards and can be utilized for static allocation.
-
-- System allocation API :
-
-Starting with the AMD MI300 series, the malloc() system allocator allows you to reserve unified memory. The system allocator is more versatile and offers an easy transition from a CPU written C++ code to a HIP code as the same system allocation API is used.
-
-## 15.3.1 Checking unified memory management support
-
-Some device attributes can offer information about which Unified memory programming models are supported. The attribute value is 1 if the functionality is supported, and 0 if it is not supported.
-
-Table 2: Device attributes for unified memory management
-
-| attribute description                                                                                 |
-|-------------------------------------------------------------------------------------------------------|
-| hipDeviceAttributeManagedMemory unified addressing is supported                                       |
-| hipDeviceAttributeConcurrentManagedAccess full managed memory support, concurrent access is supported |
-| hipDeviceAttributePageableMemoryAccess both managed and system memory allocation API is supported     |
-
-The following examples show how to use device attributes:
-
-```
-
-
-#include <hip/hip_runtime.h>
-#include <iostream>
-
-int main()  {
-        int d;
-        hipGetDevice(&d);
-
-        int  is_cma = 0;
-        hipDeviceGetAttribute(&is_cma, hipDeviceAttributeConcurrentManagedAccess, d);
-        std::cout << "HIP Managed Memory: "
-                       << (is_cma == 1? "is" : "NOT")
-                        << " " supported" << std::endl;
-        return 0;
-}
-```
-
-## 15.3.2 Example for unified memory management
-
-The following example shows how to use unified memory management with hipMallocManaged() , function, with \_\_managed\_\_ attribute for static allocation and standard malloc() allocation. For comparison, the Explicit Memory Management example is presented in the last tab.
-
-## hipMallocManaged()
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        //                                                                                                                                                                                                        }                                                                                                                                                                                                        */
-                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       //
-                                                                                                                                                                                                      
-
-
-                                                                                                                                                                                                       }
-                                                                                                                                                                                                       */
-```
-
-\_\_managed\_\_
-
-```
-__managed__
-
-#include <hip/hip_runtime.h>
-#include <iostream>
-
-// Addition of two values.
-__global__ void add(int *a, int *b, int *c) {
-    *c = *a + *b;
-}
-
-// Declare a, b and c as static variables.
-__managed__ int a, b, c;
-
-int main() {
-    // Setup input values.
-    a = 1;
-    b = 2;
-
-    // Launch add() kernel on GPU.
-    hipLaunchKernelGGL(add, dim3(1), dim3(1), 0, 0, &a, &b, &c);
-
-    // Wait for GPU to finish before accessing on host.
-    hipDeviceSynchronize();
-
-    // Prints the result.
-    std::cout << a << " + " << b << " = " << c << std::endl;
-
-    return 0;
-}
-
-
-malloc()
-```
-
-## malloc()
-
-```
-malloc()
-
-#include <hip/hip_runtime.h>
-#include <iostream>
-
-// Addition of two values.
-__global__ void add(int* a, int* b, int* c) {
-    *c = *a + *b;
-}
-
-int main() {
-    int* a, * b, * c;
-
-    // Allocate memory for a, b, and c.
-    a = (int*)malloc(sizeof(*a));
-    b = (int*)malloc(sizeof(*b));
-    c = (int*)malloc(sizeof(*c));
-
-    // Setup input values.
-    *a = 1;
-    *b = 2;
-```
-
-(continues on next page)
-
-(continued from previous page)
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-        // Launch add() kernel on GPU.
-        hipLaunchKernelGGL(add, dim3(1), dim3(1), 0, 0, a, b, c);
-
-        // Wait for GPU to finish before accessing on host.
-        hipDeviceSynchronize();
-
-        // Prints the result.
-        std::cout << *a << " + " << *b << " = " << *c << std::endl;
-
-        // Cleanup allocated memory.
-        free(a);
-        free(b);
-        free(c);
-
-        return 0;
-    }
-```
-
-```
-        tree<J;
-
-        return 0;
-    }
-
-
-    Explicit Memory Management
-
-    #include <hip/hip_runtime.h>
-    #include <iostream>
-
-    // Addition of two values.
-    __global__ void add(int *a, int *b, int *c) {
-        *c = *a + *b;
-    }
-
-    int main() {
-        int a, b, c;
-        int *d_a, *d_b, *d_c;
-
-        // Setup input values.
-        a = 1;
-        b = 2;
-
-        // Allocate device copies of a, b and c.
-        hipMalloc(&d_a, sizeof(*d_a));
-        hipMalloc(&d_b, sizeof(*d_b));
-        hipMalloc(&d_c, sizeof(*d_c));
-
-        // Copy input values to device.
-        hipMemcpy(d_a, &a, sizeof(*d_a), hipMemcpyHostToDevice);
-        hipMemcpy(d_b, &b, sizeof(*d_b), hipMemcpyHostToDevice);
-
-        // Launch add() kernel on GPU.
-        hipLaunchKernelGGL(add, dim3(1), dim3(1), 0, 0, d_a, d_b, d_c);
-
-        // Copy the result back to the host.
-        hipMemcpy(&c, d_c, sizeof(*d_c), hipMemcpyDeviceToHost);
-                                                                                                                                                                                                         (continues on next page)
-
-
-    15.3. Unified memory programming models                                                                                                                                                                                                        103
-```
-
-```
-
-    // Cleanup allocated memory.
-    hipFree(d_a);
-    hipFree(d_b);
-    hipFree(d_c);
-
-    // Prints the result.
-    std::cout << a << " + " << b << " = " << c << std::endl;
-
-    return 0;
-}
-```
-
-## 15.4 Using unified memory management (UMM)
-
-Unified memory management (UMM) is a feature that can simplify the complexities of memory management in GPU computing. It is particularly useful in heterogeneous computing environments with heavy memory usage with both a CPU and a GPU, which would require large memory transfers. Here are some areas where UMM can be beneficial:
-
-- Simplification of Memory Management :
-
-UMMcan help to simplify the complexities of memory management. This can make it easier for developers to write code without worrying about memory allocation and deallocation details.
-
-- Data Migration :
-
-UMMallows for efficient data migration between the host (CPU) and the device (GPU). This can be particularly useful for applications that need to move data back and forth between the device and host.
-
-- Improved Programming Productivity :
-
-As a positive side effect, UMM can reduce the lines of code, thereby improving programming productivity.
-
-In HIP, pinned memory allocations are coherent by default. Pinned memory is host memory mapped into the address space of all GPUs, meaning that the pointer can be used on both host and device. Using pinned memory instead of pageable memory on the host can improve bandwidth.
-
-While UMMcanprovide numerous benefits, it's important to be aware of the potential performance overhead associated with UMM. You must thoroughly test and profile your code to ensure it's the most suitable choice for your use case.
-
-## 15.5 Unified memory HIP runtime hints for the better performance
-
-Unified memory HIP runtime hints can help improve the performance of your code if you know your code's ability and infrastructure. Some hint techniques are presented in this section.
-
-Thehint functions can set actions on a selected device, which can be identified by hipGetDeviceProperties(&amp;prop, device\_id) . There are two special device\_id values:
-
-- hipCpuDeviceId = -1 means that the advised device is the CPU.
-- hipInvalidDeviceId = -2 means that the device is invalid.
-
-For the best performance, profile your application to optimize the utilization of HIP runtime hints.
-
-(continued from previous page)
-
-## 15.5.1 Data prefetching
-
-Data prefetching is a technique used to improve the performance of your application by moving data closer to the processing unit before it's actually needed.
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        // All                                                                                                                                                                                                        }
-                                                                                                                                                                                                      
-//                                                                                                                                                                                                        #                                                                                                                                                                                                        */
-                                                                                                                                                                                                       //                                                                                                                                                                                                        *
-                                                                                                                                                                                                       */
-
-                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       *
-
-                                                                                                                                                                                                       *                                                                                                                                                                                                        /*
-                                                                                                                                                                                                       /*
-
-                                                                                                                                                                                                       */                                                                                                                                                                                                        /
-                                                                                                                                                                                                       }
-```
-
-Remember to check the return status of hipMemPrefetchAsync() to ensure that the prefetch operations are completed successfully.
-
-## 15.5.2 Memory advice
-
-The effectiveness of hipMemAdvise() comes from its ability to inform the runtime system of the developer's intentions regarding memory usage. When the runtime system has knowledge of the expected memory access patterns, it can make better decisions about data placement and caching, leading to more efficient execution of the application. However, the actual impact on performance can vary based on the specific use case and the hardware architecture.
-
-For the description of hipMemAdvise() and the detailed list of advice, visit the HIP managed memory allocation API .
-
-Here is the updated version of the example above with memory advice.
-
-```
-
-    The effectiveness of nipMemAdvise() comes from its ability to inform the runtime system at the developer's intentions
-    regarding memory usage. When the runtime system has knowledge of the expected memory access patterns, it can make
-    better decisions about data placement and caching, leading to more efficient execution of the application. However, the
-    actual impact on performance can vary based on the specific use case and the hardware architecture.
-    For the description of hipMemAdvise() and the detailed list of advice, visit the HIP managed memory allocation API.
-    Here is the updated version of the example above with memory advice.
-    
-  #include <hip/hip_runtime.h>
-  #include <iostream>
-    
-  // Addition of two values.
-  __global__ void add(int *a, int *b, int *c) {
-      *c = *a + *b;
-  }
-  
-  int main() {
-      int *a, *b, *c;
-      
-      // Allocate memory for a, b, and c accessible to both device and host codes.
-      hipMallocManaged(&a, sizeof(*a));
-      hipMallocManaged(&b, sizeof(*b));
-      hipMallocManaged(&c, sizeof(*c));
-      
-      // Set memory advice for a, b, and c to be accessed by the CPU.
-      hipMemAdvise(a, sizeof(*a), hipMemAdviseSetPreferredLocation, hipCpuDeviceId);
-      hipMemAdvise(b, sizeof(*b), hipMemAdviseSetPreferredLocation, hipCpuDeviceId);
-      hipMemAdvise(c, sizeof(*c), hipMemAdviseSetPreferredLocation, hipCpuDeviceId);
-      
-      // Additionally, set memory advice for a, b, and c to be read mostly from the device.
-  __0.
-      constexpr int device = 0;
-      hipMemAdvise(a, sizeof(*a), hipMemAdviseSetReadMostly, device);
-      hipMemAdvise(b, sizeof(*b), hipMemAdviseSetReadMostly, device);
-      hipMemAdvise(c, sizeof(*c), hipMemAdviseSetReadMostly, device);
-      
-      // Setup input values.
-      *a = 1;
-      *b = 2;
-      
-      // Launch add() kernel on GPU.
-      hipLaunchKernelGGL(add, dim3(1), dim3(1), 0, 0, a, b, c);
-      
-      // Wait for GPU to finish before accessing on host.
-      hipDeviceSynchronize();
-      
-      // Prints the result.
-      std::cout << *a << " + " << *b << " = " << *c << std::endl;
-      
-      // Cleanup allocated memory.
-      hipFree(a);
-      
-                                                                                                                                                                                                         (continues on next page)
-      
-      
-      
-  106
-```
-
-(continues on next page)
-
-```
-      hipFree(b);
-      hipFree(c);
-
-      return 0;
-}
-```
-
-## 15.5.3 Memory range attributes
-
-Memory Range attributes allow you to query attributes of a given memory range.
-
-The hipMemRangeGetAttribute() is added to the example to query the hipMemRangeAttributeReadMostly attribute of the memory range pointed to by a . The result is stored in attributeValue and then printed out.
-
-For more details, visit the HIP managed memory allocation API .
-
-```
-
-        Memory Range attributes allow you to query attributes of a given memory range.
-        The hipMemRangeGetAttribute() is added to the example to query the hipMemRangeAttributeReadMostly at-
-        title of the memory range pointed to by a. The result is stored in attributeValue and then printed out.
-        For more details, visit the HIP managed memory allocation API.
-        #include <hip/hip_runtime.h>
-        #include <iostream>
-        
-        // Addition of two values.
-        __global__ void add(int *a, int *b, int *c) {
-            *c = *a + *b;
-        }
-        
-        int main() {
-            int *a, *b, *c;
-            unsigned int attributeValue;
-            constexpr size_t attributeSize = sizeof(attributeValue);
-            
-            // Allocate memory for a, b and c that is accessible to both device and host codes.
-            hipMallocManaged(&a, sizeof(*a));
-            hipMallocManaged(&b, sizeof(*b));
-            hipMallocManaged(&c, sizeof(*c));
-            
-            // Setup input values.
-            *a = 1;
-            *b = 2;
-            
-            // Launch add() kernel on GPU.
-            hipLaunchKernelGGL(add, dim3(1), dim3(1), 0, 0, a, b, c);
-            
-            // Wait for GPU to finish before accessing on host.
-            hipDeviceSynchronize();
-            
-            // Query an attribute of the memory range.
-            hipMemRangeGetAttribute(&attributeValue,
-                                             attributeSize,
-                                              hipMemRangeAttributeReadMostly,
-                                              a,
-                                               sizeof(*a));
-             
-            // Prints the result.
-            std::cout << *a << " + " << *b << " = " << *c << std::endl;
-                                                                                                                                                                                                         (continues on next page)
-                                                                                                                                                                                                      
-                                                                                                                                                                                                       )
-                                                                                                                                                                                                       (Continues on next page)
-```
-
-(continues on next page)
-
-(continued from previous page)
-
-(continued from previous page)
-
-```
-    std::cout << "The queried attribute value is: " << attributeValue << std::endl;
-
-    // Cleanup allocated memory.
-    hipFree(a);
-    hipFree(b);
-    hipFree(c);
-
-    return 0;
-}
-```
-
-## 15.5.4 Asynchronously attach memory to a stream
-
-The hipStreamAttachMemAsync function would be able to asynchronously attach memory to a stream, which can help concurrent execution when using streams.
-
-Currently, this function is a no-operation (NOP) function on AMD GPUs. It simply returns success after the runtime memory validation passed. This function is necessary on Microsoft Windows, and UMM is not supported on this operating system with AMD GPUs at the moment.
-
-CHAPTER
-
-## SIXTEEN
-
-## VIRTUAL MEMORY MANAGEMENT
-
-Memorymanagement is important when creating high-performance applications in the HIP ecosystem. Both allocating and copying memory can result in bottlenecks, which can significantly impact performance.
-
-Global memory allocation in HIP uses the C language style allocation function. This works fine for simple cases but can cause problems if your memory needs change. If you need to increase the size of your memory, you must allocate a second larger buffer and copy the data to it before you can free the original buffer. This increases overall memory usage and causes unnecessary memcpy calls. Another solution is to allocate a larger buffer than you initially need. However, this isn't an efficient way to handle resources and doesn't solve the issue of reallocation when the extra buffer runs out.
-
-Virtual memory management solves these memory management problems. It helps to reduce memory usage and unnecessary memcpy calls.
-
-## 16.1 Memory allocation
-
-Standard memory allocation uses the hipMalloc function to allocate a block of memory on the device. However, when using virtual memory, this process is separated into multiple steps using the hipMemCreate , hipMemAddressReserve , hipMemMap , and hipMemSetAccess functions. This guide explains what these functions do and how you can use them for virtual memory management.
-
-## 16.1.1 Allocate physical memory
-
-The first step is to allocate the physical memory itself with the hipMemCreate function. This function accepts the size of the buffer, an unsigned long long variable for the flags, and a hipMemAllocationProp variable. hipMemAllocationProp contains the properties of the memory to be allocated, such as where the memory is physically located and what kind of shareable handles are available. If the allocation is successful, the function returns a value of hipSuccess , with hipMemGenericAllocationHandle\_t representing a valid physical memory allocation. The allocated memory size must be aligned with the granularity appropriate for the properties of the allocation. You can use the hipMemGetAllocationGranularity function to determine the correct granularity.
-
-```
-<_C_>
-```
-
-## 16.1.2 Reserve virtual address range
-
-After you have acquired an allocation of physical memory, you must map it before you can use it. To do so, you need a virtual address to map it to. Mapping means the physical memory allocation is available from the virtual address range it is mapped to. To reserve a virtual memory range, use the hipMemAddressReserve function. The size of the virtual memory must match the amount of physical memory previously allocated. You can then map the physical memory allocation to the newly-acquired virtual memory address range using the hipMemMap function.
-
-```
-0) ;
-```
-
-```
-<_C++_>
-```
-
-## 16.1.3 Set memory access
-
-Finally, use the hipMemSetAccess function to enable memory access. It accepts the pointer to the virtual memory, the size, and a hipMemAccessDesc descriptor as parameters. In a multi-GPU environment, you can map the device memory of one GPU to another. This feature also works with the traditional memory management system, but isn't as scalable as with virtual memory. When memory is allocated with hipMalloc , hipDeviceEnablePeerAccess is used to enable peer access. This function enables access between two devices, but it means that every call to hipMalloc takes more time to perform the checks and the mapping between the devices. When using virtual memory management, peer access is enabled by hipMemSetAccess , which provides a finer level of control over what is shared. This has no performance impact on memory allocation and gives you more control over what memory buffers are shared with which devices.
-
-```
-hipMemAccessDesc accessDesc = {};
-accessDesc.location.type = HIP_MEM_LOCATION_TYPE_DEVICE;
-accessDesc.location.id = currentDev;
-accessDesc.flags = HIP_MEM_ACCESS_FLAGS_PROT_READWRITE;
-hipMemSetAccess(ptr, padded_size, &accessDesc, 1);
-```
-
-At this point the memory is allocated, mapped, and ready for use. You can read and write to it, just like you would a C style memory allocation.
-
-## 16.1.4 Free virtual memory
-
-To free the memory allocated in this manner, use the corresponding free functions. To unmap the memory, use hipMemUnmap . To release the virtual address range, use hipMemAddressFree . Finally, to release the physical memory, use hipMemRelease . A side effect of these functions is the lack of synchronization when memory is released. If you call hipFree when you have multiple streams running in parallel, it synchronizes the device. This causes worse resource usage and performance.
-
-```
-        |hipMemUnmap(ptr, size);
-        |hipMemRelease(allocHandle);
-```
-
-```
-        |hipMemAddressFree(ptr,  size);
-```
-
-## 16.2 Memory usage
-
-## 16.2.1 Dynamically increase allocation size
-
-The hipMemAddressReserve function allows you to increase the amount of pre-allocated memory. This function accepts a parameter representing the requested starting address of the virtual memory. This allows you to have a continuous virtual address space without worrying about the underlying physical allocation.
-
-```
-            hipMemAddressReserve(&new_ptr, (new_size - padded_size), 0, ptr + padded_size, 0);
-            hipMemMap(new_ptr, (new_size - padded_size), 0, newAllocHandle, 0);
-            hipMemSetAccess(new_ptr, (new_size - padded_size), &accessDesc, 1);
-```
-
-The code sample above assumes that hipMemAddressReserve was able to reserve the memory address at the specified location. However, this isn't guaranteed to be true, so you should validate that new\_ptr points to a specific virtual address before using it.
-
-## CHAPTER
-
-## SEVENTEEN
-
-## FREQUENTLY ASKED QUESTIONS
-
-## 17.1 What APIs and features does HIP support?
-
-HIP provides the following:
-
-- Devices ( hipSetDevice() , hipGetDeviceProperties() , etc.)
-- Memory management ( hipMalloc() , hipMemcpy() , hipFree() , etc.)
-- Streams ( hipStreamCreate() , hipStreamSynchronize() , hipStreamWaitEvent() , etc.)
-- Events ( hipEventRecord() , hipEventElapsedTime() , etc.)
-- Kernel launching ( hipLaunchKernel / hipLaunchKernelGGL is the preferred way of launching kernels. hipLaunchKernelGGL is a standard C/C++ macro that can serve as an alternative way to launch kernels, replacing the CUDA triple-chevron ( &lt;&lt;&lt; &gt;&gt;&gt; ) syntax).
-- HIP Module API to control when and how code is loaded.
-- CUDA-style kernel coordinate functions ( threadIdx , blockIdx , blockDim , gridDim )
-- Cross-lane instructions including shfl , ballot , any , all
-- Most device-side math built-ins
-- Error reporting ( hipGetLastError() , hipGetErrorString() )
-
-The HIP API documentation describes each API and its limitations, if any, compared with the equivalent CUDA API.
-
-## 17.2 What is not supported?
-
-## 17.2.1 Runtime/Driver API features
-
-At a high-level, the following features are not supported:
-
-- Textures (partial support available)
-- Dynamic parallelism (CUDA 5.0)
-- Graphics interoperability with OpenGL or Direct3D
-- CUDA IPC Functions (Under Development)
-- CUDA array, mipmappedArray and pitched memory
-- Queue priority controls
-
-See the API Support Table for more detailed information.
-
-## 17.2.2 Kernel language features
-
-- C+ ± style device-side dynamic memory allocations (free, new, delete) (CUDA 4.0)
-- Virtual functions, indirect functions and try/catch (CUDA 4.0)
-- \_\_prof\_trigger
-- PTX assembly (CUDA 4.0). HIP-Clang supports inline GCN assembly.
-- Several kernel features are under development. See the C++ language extensions for more information.
-
-## 17.3 Is HIP a drop-in replacement for CUDA?
-
-No. HIP provides porting tools which do most of the work to convert CUDA code into portable C++ code that uses the HIP APIs. Most developers will port their code from CUDA to HIP and then maintain the HIP version. HIP code provides the same performance as native CUDA code, plus the benefits of running on AMD platforms.
-
-## 17.4 What specific version of CUDA does HIP support?
-
-HIP APIs and features do not map to a specific CUDA version. HIP provides a strong subset of the functionality provided in CUDA, and the hipify tools can scan code to identify any unsupported CUDA functions - this is useful for identifying the specific features required by a given application.
-
-However, we can provide a rough summary of the features included in each CUDA SDK and the support level in HIP. Each bullet below lists the major new language features in each CUDA release and then indicate which are supported/not supported in HIP:
-
-- CUDA 4.0 and earlier :
-- -HIP supports CUDA 4.0 except for the limitations described above.
-- CUDA 5.0 :
-- -Dynamic Parallelism (not supported)
-- -cuIpc functions (under development).
-- CUDA 6.0 :
-- -Managed memory (under development)
-- CUDA 6.5 :
-- -\_\_shfl intrinsic (supported)
-- CUDA 7.0 :
-- -Per-thread default streams (supported)
-- -C++11 (Hip-Clang supports all of C++11, all of C++14 and some C++17 features)
-- CUDA 7.5 :
-- -float16 (supported)
-- CUDA 8.0 :
-- -Page Migration including cudaMemAdvise , cudaMemPrefetch , other cudaMem* APIs(not supported)
-- CUDA 9.0 :
-
-- -Cooperative Launch, Surface Object Management, Version Management
-
-## 17.5 What libraries does HIP support?
-
-HIP includes growing support for the four key math libraries using hipBLAS, hipFFT, hipRAND and hipSPARSE, as well as MIOpen for machine intelligence applications. These offer pointer-based memory interfaces (as opposed to opaque buffers) and can be easily interfaced with other HIP applications. The hip interfaces support both ROCm and CUDA paths, with familiar library interfaces.
-
-- hipBLAS, which utilizes rocBlas.
-- hipFFT
-- hipsSPARSE
-- hipRAND
-- MIOpen
-
-Additionally, some of the cuBLAS routines are automatically converted to hipblas equivalents by the HIPIFY tools. These APIs use cuBLAS or hcBLAS depending on the platform and replace the need to use conditional compilation.
-
-## 17.6 How does HIP compare with OpenCL?
-
-Both AMD and NVIDIA support OpenCL 1.2 on their devices so that developers can write portable code. HIP offers several benefits over OpenCL:
-
-- Developers can code in C++ as well as mix host and device C++ code in their source files. HIP C++ code can use templates, lambdas, classes and so on.
-- The HIP API is less verbose than OpenCL and is familiar to CUDA developers.
-- Because both CUDA and HIP are C++ languages, porting from CUDA to HIP is significantly easier than porting from CUDA to OpenCL.
-- HIP uses the best available development tools on each platform: on NVIDIA GPUs, HIP code compiles using NVCC and can employ the Nsight profiler and debugger (unlike OpenCL on NVIDIA GPUs).
-- HIP provides pointers and host-side pointer arithmetic.
-- HIP provides device-level control over memory allocation and placement.
-- HIP offers an offline compilation model.
-
-## 17.7 How does porting CUDA to HIP compare to porting CUDA to OpenCL?
-
-Both HIP and CUDA are dialects of C++, and thus porting between them is relatively straightforward. Both dialects support templates, classes, lambdas, and other C++ constructs. As one example, the hipify-perl tool was originally a Perl script that used simple text conversions from CUDA to HIP. HIP and CUDA provide similar math library calls as well. In summary, the HIP philosophy was to make the HIP language close enough to CUDA that the porting effort is relatively simple. This reduces the potential for error, and also makes it easy to automate the translation. HIP goal is to quickly get the ported program running on both platforms with little manual intervention, so that the programmer can focus on performance optimizations.
-
-There have been several tools that have attempted to convert CUDA into OpenCL, such as CU2CL. OpenCL is a C99based kernel language (rather than C++) and also does not support single-source compilation. As a result, the OpenCL syntax is different from CUDA, and the porting tools have to perform some heroic transformations to bridge this gap. The tools also struggle with more complex CUDA applications, in particular, those that use templates, classes, or other C++ features inside the kernel.
-
-## 17.8 What hardware does HIP support?
-
-- For AMD platforms, see the ROCm documentation for the list of supported platforms.
-- For NVIDIA platforms, HIP requires unified memory and should run on any device supporting CUDA SDK 6.0 or newer. We have tested the NVIDIA Titan and Tesla K40.
-
-## 17.9 Do HIPIFY tools automatically convert all source code?
-
-Typically, HIPIFY tools can automatically convert almost all run-time code. Most device code needs no additional conversion since HIP and CUDA have similar names for math and built-in functions. The hipify-clang tool will automatically modify the kernel signature as needed (automating a step that used to be done manually). Additional porting may be required to deal with architecture feature queries or with CUDA capabilities that HIP doesn't support. In general, developers should always expect to perform some platform-specific tuning and optimization.
-
-## 17.10 What is NVCC?
-
-NVCC is NVIDIA's compiler driver for compiling 'CUDA C++' code into PTX or device code for NVIDIA GPUs. It's a closed-source binary compiler that is provided by the CUDA SDK.
-
-## 17.11 What is HIP-Clang?
-
-HIP-Clang is a Clang/LLVM based compiler to compile HIP programs which can run on AMD platform.
-
-## 17.12 Why use HIP rather than supporting CUDA directly?
-
-While HIP is a strong subset of the CUDA, it is a subset. The HIP layer allows that subset to be clearly defined and documented. Developers who code to the HIP API can be assured their code will remain portable across NVIDIA and AMD platforms. In addition, HIP defines portable mechanisms to query architectural features and supports a larger 64-bit WaveSize which expands the return type for cross-lane functions like ballot and shuffle from 32-bit integers to 64-bit integers.
-
-## 17.13 Can I develop HIP code on an NVIDIA CUDA platform?
-
-Yes. HIP's CUDA path only exposes the APIs and functionality that work on both NVCC and AMDGPU back-ends. 'Extra' APIs, parameters, and features which exist in CUDA but not in HIP-Clang will typically result in compile-time or run-time errors. Developers need to use the HIP API for most accelerator code and bracket any CUDA-specific code with preprocessor conditionals. Developers concerned about portability should, of course, run on both platforms, and should expect to tune for performance. In some cases, CUDA has a richer set of modes for some APIs, and some C++ capabilities such as virtual functions - see the HIP @API documentation for more details.
-
-## 17.14 Can I develop HIP code on an AMD HIP-Clang platform?
-
-Yes. HIP's HIP-Clang path only exposes the APIs and functions that work on AMD runtime back ends. 'Extra' APIs, parameters and features that appear in HIP-Clang but not CUDA will typically cause compile- or run-time errors. Developers must use the HIP API for most accelerator code and bracket any HIP-Clang specific code with preprocessor conditionals. Those concerned about portability should, of course, test their code on both platforms and should tune it for performance. Typically, HIP-Clang supports a more modern set of C++11/C++14/C++17 features, so HIP developers who want portability should be careful when using advanced C++ features on the HIP-Clang path.
-
-## 17.15 How to use HIP-Clang to build HIP programs?
-
-The environment variable can be used to set compiler path:
-
-- HIP\_CLANG\_PATH: path to hip-clang. When set, this variable let hipcc to use hip-clang for compilation/linking.
-
-There is an alternative environment variable to set compiler path:
-
-- HIP\_ROCCLR\_HOME: path to root directory of the HIP-ROCclr runtime. When set, this variable let hipcc use hip-clang from the ROCclr distribution. NOTE: If HIP\_ROCCLR\_HOME is set, there is no need to set HIP\_CLANG\_PATH since hipcc will deduce them from HIP\_ROCCLR\_HOME.
-
-## 17.16 What is AMD clr?
-
-AMD Common Language Runtime (CLR) is a repository for the AMD platform, which contains source codes for AMD's compute languages runtimes as follows,
-
-- hipamd - contains implementation of HIP language for AMD GPU.
-- rocclr - contains virtual device interfaces that compute runtimes interact with backends, such as ROCr on Linux and PAL on Windows.
-- opencl - contains implementation of OpenCL™ on the AMD platform.
-
-## 17.17 What is hipother?
-
-A new repository 'hipother' is added in the ROCm 6.1 release, which is branched out from HIP. hipother supports the HIP back-end implementation on some non-AMD platforms, like NVIDIA.
-
-## 17.18 Can I get HIP open source repository for Windows?
-
-No, there is no HIP repository open publicly on Windows.
-
-## 17.19 Can a HIP binary run on both AMD and NVIDIA platforms?
-
-HIP is a source-portable language that can be compiled to run on either AMD or NVIDIA platform. HIP tools don't create a 'fat binary' that can run on either platform, however.
-
-## 17.20 On HIP-Clang, can I link HIP code with host code compiled with another compiler such as gcc, icc, or clang?
-
-Yes. HIP generates the object code which conforms to the GCC ABI, and also links with libstdc++. This means you can compile host code with the compiler of your choice and link the generated object code with GPU code compiled with HIP. Larger projects often contain a mixture of accelerator code (initially written in CUDA with NVCC) and host code (compiled with gcc, icc, or clang). These projects can convert the accelerator code to HIP, compile that code with hipcc, and link with object code from their preferred compiler.
-
-## 17.21 Can HIP API support C style application? What is the difference between C and C++?
-
-HIP is C++ runtime API that supports C style applications as well.
-
-Some C style applications (and interfaces to other languages (FORTRAN, Python)) would call certain HIP APIs but not use kernel programming. They can be compiled with a C compiler and run correctly, however, small details must be considered in the code. For example, initialization, as shown in the simple application below, uses HIP structs dim3 with the file name 'test.hip.cpp'
-
-```
-                                                                                                                                                                                                        //the file name `test.hip.cpp`
-                                                                                                                                                                                                       
-                                                                                                                                                                                                      
-#include "hip/hip_runtime_api.h"
-                                                                                                                                                                                                       //this file name `test.hip.cpp`
-                                                                                                                                                                                             
-          int main(int argc, char** argv) {
-            dim3 grid1;
-            printf("dim3 grid1; x=%d, y=%d, z=%d\n",grid1.x,grid1.y,grid1.z);
-            dim3 grid2 = {1,1,1};
-            printf("dim3 grid2 = {1,1,1}; x=%d, y=%d, z=%d\n",grid2.x,grid2.y,grid2.z);
-            return 0;
-            }
-```
-
-When using a C++ compiler,
-
-```
-$ gcc -x c++  $(hipconfig --cpp_config) test3.hip.cpp -o test
-$./test
-dim3 grid1; x=1, y=1, z=1
-dim3 grid2 = {1,1,1}; x=1, y=1, z=1
-```
-
-In which 'dim3 grid1;' will yield a dim3 grid with all dimensional members x,y,z initialized to 1, as the default constructor behaves that way. Further, if written: dim3 grid(2); // yields {2,1,1} dim3 grid(2,3); yields {2,3,1} In comparison, when using the C compiler, $ gcc -x c $( hipconfig --cpp\_config ) test.hip.cpp -o test $ ./test dim3 grid1; x=646881376, y=21975, z=1517277280 dim3 grid2 = {1,1,1}; x=1, y=1, z=1 In which 'dim3 grid;' does not imply any initialization, no constructor is called, and dimensional values x,y,z of grid are undefined. NOTE: To get the C++ default behavior, C programmers must additionally specify the right-hand side as shown below,
-
-```
-        |dim3 grid = {1,1,1}; // initialized as in C++
-```
-
-```
-C++
-```
-
-## 17.22 Can I install both CUDA SDK and HIP-Clang on the same machine?
-
-Yes. You can use HIP\_PLATFORM to choose which path hipcc targets. This configuration can be useful when using HIP to develop an application which is portable to both AMD and NVIDIA.
-
-## 17.23 HIP detected my platform (HIP-Clang vs NVCC) incorrectly * what should I do?
-
-HIP will set the platform to AMD and use HIP-Clang as compiler if it sees that the AMD graphics driver is installed and has detected an AMD GPU. Sometimes this isn't what you want * you can force HIP to recognize the platform by setting the following,
-
-```
-| export
-```
-
-```
-rt HIP_PLATFORM=amd
-```
-
-```
-<_Python_>
-```
-
-```
-  | HIP_COMPILER=cuda
-```
-
-```
-  | HIP_RUNTIME=nvcc
-```
-
-One symptom of this problem is the message 'error: 'unknown error'(11) at square.hipref.cpp:56 . This can occur if you have a CUDA installation on an AMD platform, and HIP incorrectly detects the platform as NVCC. HIP may be able to compile the application using the NVCC tool-chain but will generate this error at runtime since the platform does not have a CUDA device.
-
-## 17.24 On CUDA, can I mix CUDA code with HIP code?
-
-Yes. Most HIP data structures ( hipStream\_t , hipEvent\_t ) are typedefs to CUDA equivalents and can be intermixed. Both CUDA and HIP use integer device ids. One notable exception is that hipError\_t is a new type, and cannot be used where a cudaError\_t is expected. In these cases, refactor the code to remove the expectation. Alternatively, hip\_runtime\_api.h defines functions which convert between the error code spaces:
-
-hipErrorToCudaError hipCUDAErrorTohipError hipCUResultTohipError
-
-If platform portability is important, use #ifdef \_\_HIP\_PLATFORM\_NVIDIA\_\_ to guard the CUDA-specific code.
-
-## 17.25 How do I trace HIP application flow?
-
-See Logging HIP activity for more information.
-
-## 17.26 What are the maximum limits of kernel launch parameters?
-
-Product of block.x, block.y, and block.z should be less than 1024. Please note, HIP does not support kernel launch with total work items defined in dimension with size gridDim x blockDim &gt;= 2^32 , so gridDim.x * blockDim.x, gridDim.y * blockDim.y and gridDim.z * blockDim.z are always less than 2^32.
-
-## 17.27 Are \_\_shfl\_*\_sync functions supported on HIP platform?
-
-\_\_shfl\_*\_sync is not supported on HIP but for NVCC path CUDA 9.0 and above all shuffle calls get redirected to it's sync version.
-
-## 17.28 How to create a guard for code that is specific to the host or the GPU?
-
-The compiler defines the \_\_HIP\_DEVICE\_COMPILE\_\_ macro only when compiling the code for the GPU. It could be used to guard code that is specific to the host or the GPU.
-
-## 17.29 Why \_OpenMP is undefined when compiling with -fopenmp ?
-
-When compiling an OpenMP source file with hipcc -fopenmp , the compiler may generate error if there is a reference to the \_OPENMP macro. This is due to a limitation in hipcc that treats any source file type (for example .cpp ) as an HIP translation unit leading to some conflicts with the OpenMP language switch. If the OpenMP source file doesn't contain any HIP language constructs you could work around this issue by adding the -x c++ switch to force the compiler to treat the file as regular C++. Another approach would be to guard the OpenMP code with #ifdef \_OPENMP so that the code block is disabled when compiling for the GPU. The \_\_HIP\_DEVICE\_COMPILE\_\_ macro defined by the HIP compiler when compiling GPU code could also be used for guarding code paths specific to the host or the GPU.
-
-## 17.30 Does the HIP-Clang compiler support extern shared declarations?
-
-Previously, it was essential to declare dynamic shared memory using the HIP\_DYNAMIC\_SHARED macro for accuracy, as using static shared memory in the same kernel could result in overlapping memory ranges and data-races.
-
-Now, the HIP-Clang compiler provides support for extern shared declarations, and the HIP\_DYNAMIC\_SHARED option is no longer required. You may use the standard extern definition: extern shared type var[];
-
-## 17.31 I have multiple HIP enabled devices and I am getting an error code hipErrorSharedObjectInitFailed with the message 'Error: shared object initialization failed'?
-
-This error message is seen due to the fact that you do not have valid code object for all of your devices.
-
-If you have compiled the application yourself, make sure you have given the correct device name(s) and its features via: --offload-arch . If you are not mentioning the --offload-arch , make sure that hipcc is using the correct offload arch by verifying the hipcc output generated by setting the environment variable HIPCC\_VERBOSE=1 .
-
-If you have a precompiled application/library (like rocblas, TensorFlow etc) which gives you such error, there are one of two possibilities.
-
-- The application/library does not ship code object bundles for all of your device(s): in this case you need to recompile the application/library yourself with correct --offload-arch .
-- The application/library does not ship code object bundles for some of your device(s), for example you have a system with an APU + GPU and the library does not ship code objects for your APU. For this you can set the environment variable HIP\_VISIBLE\_DEVICES or CUDA\_VISIBLE\_DEVICES on NVIDIA platform, to only enable GPUs for which code object is available. This will limit the GPUs visible to your application and allow it to run.
-
-Note: In previous releases, the error code is hipErrorNoBinaryForGpu with message 'Unable to find code object for all current devices'. The error code handling behavior is changed. HIP runtime shows the error code hipErrorSharedObjectInitFailed with message 'Error: shared object initialization failed' on unsupported GPU.
-
-## 17.32 How to use per-thread default stream in HIP?
-
-The per-thread default stream is an implicit stream local to both the thread and the current device. It does not do any implicit synchronization with other streams (like explicitly created streams), or default per-thread stream on other threads.
-
-The per-thread default stream is a blocking stream and will synchronize with the default null stream if both are used in a program.
-
-In ROCm, a compilation option should be added in order to compile the translation unit with per-thread default stream enabled. -fgpu-default-stream=per-thread . Once source is compiled with per-thread default stream enabled, all APIs will be executed on per thread default stream, hence there will not be any implicit synchronization with other streams.
-
-Besides, per-thread default stream be enabled per translation unit, users can compile some files with feature enabled and some with feature disabled. Feature enabled translation unit will have default stream as per thread and there will not be any implicit synchronization done but other modules will have legacy default stream which will do implicit synchronization.
-
-## 17.33 How to use complex multiplication and division operations?
-
-In HIP, hipFloatComplex and hipDoubleComplex are defined as complex data types,
-
-```
-<_C_>
-```
-
-Any application uses complex multiplication and division operations, need to replace '*' and '/' operators with the following,
-
-- hipCmulf() and hipCdivf() for hipFloatComplex
-- hipCmul() and hipCdiv() for hipDoubleComplex
-
-Note: These complex operations are equivalent to corresponding types/functions on the NVIDIA platform.
-
-## 17.34 Can I develop applications with HIP APIs on Windows the same on Linux?
-
-Yes, HIP APIs are available to use on both Linux and Windows. Due to different working mechanisms on operating systems like Windows vs Linux, HIP APIs call corresponding lower level backend runtime libraries and kernel drivers for the OS, in order to control the executions on GPU hardware accordingly. There might be a few differences on the related backend software and driver support, which might affect usage of HIP APIs. See OS support details in HIP API document.
-
-## 17.35 Does HIP support LUID?
-
-Starting ROCm 6.0, HIP runtime supports Locally Unique Identifier (LUID). This feature enables the local physical device(s) to interoperate with other devices. For example, DirectX 12.
-
-HIP runtime sets device LUID properties so the driver can query LUID to identify each device for interoperability.
-
-Note: HIP supports LUID only on Windows OS.
-
-## 17.36 How can I know the version of HIP?
-
-HIP version definition has been updated since ROCm 4.2 release as the following:
-
-```
-<_SQL_>
-```
-
-HIP version can be queried from HIP API call, hipRuntimeGetVersion(&amp;runtimeVersion);
-
-The version returned will always be greater than the versions in previous ROCm releases.
-
-Note: The version definition of HIP runtime is different from CUDA. On AMD platform, the function returns HIP runtime version, while on NVIDIA platform, it returns CUDA runtime version. And there is no mapping/correlation between HIP version and CUDA version.
-
-## 18.1 Related Pages
-
-18.2 Topics
-
-## 18.3 Namespaces
-
-18.3.1 Namespace List
-
-18.3.2 Namespace Members
-
-18.3.2.1 Namespace Members
-
-18.3.2.2 Namespace Members
-
-## 18.4 Data Structures
-
-- 18.4.1 Data Structures
-- 18.4.2 Data Structure Index
-- 18.4.3 Class Hierarchy
-
-18.4.4 Data Fields
-
-18.4.4.1 All
-
-18.4.4.1.1 Data Fields
-
-18.4.4.1.2 Data Fields
-
-18.4.4.1.3 Data Fields
-
-18.4.4.1.4 Data Fields
-
-18.4.4.1.5 Data Fields
-
-18.4.4.1.6 Data Fields 26
-
-18.4.4.1.7 Data Fields
-
-CHAPTER
-
-## EIGHTEEN
-
-## HIP RUNTIME API REFERENCE
-
-## CHAPTER
-
-## NINETEEN
-
-## C++ LANGUAGE EXTENSIONS
-
-HIP provides a C++ syntax that is suitable for compiling most code that commonly appears in compute kernels (classes, namespaces, operator overloading, and templates). HIP also defines other language features that are designed to target accelerators, such as:
-
-- A kernel-launch syntax that uses standard C++ (this resembles a function call and is portable to all HIP targets)
-- Short-vector headers that can serve on a host or device
-- Math functions that resemble those in math.h , which is included with standard C++ compilers
-- Built-in functions for accessing specific GPU hardware capabilities
-
-Note: This chapter describes the built-in variables and functions that are accessible from the HIP kernel. It's intended for users who are familiar with CUDA kernel syntax and want to learn how HIP differs from CUDA.
-
-Features are labeled with one of the following keywords:
-
-- Supported : HIP supports the feature with a CUDA-equivalent function
-- Not supported : HIP does not support the feature
-- Under development : The feature is under development and not yet available
-
-## 19.1 Function-type qualifiers
-
-## 19.1.1 \_\_device\_\_
-
-Supported \_\_device\_\_ functions are:
-
-- Run on the device
-- Called from the device only
-
-You can combine \_\_device\_\_ with the host keyword ( \_\_host\_\_ ).
-
-## 19.1.2 \_\_global\_\_
-
-Supported \_\_global\_\_ functions are:
-
-- Run on the device
-- Called (launched) from the host
-
-HIP \_\_global\_\_ functions must have a void return type.
-
-HIP doesn't support dynamic-parallelism, which means that you can't call \_\_global\_\_ functions from the device.
-
-## 19.1.3 \_\_host\_\_
-
-Supported \_\_host\_\_ functions are:
-
-- Run on the host
-- Called from the host
-
-You can combine \_\_host\_\_ with \_\_device\_\_ ; in this case, the function compiles for the host and the device. Note that these functions can't use the HIP grid coordinate functions (e.g., threadIdx.x ). If you need to use HIP grid coordinate functions, you can pass the necessary coordinate information as an argument.
-
-You can't combine \_\_host\_\_ with \_\_global\_\_ .
-
-HIP parses the \_\_noinline\_\_ and \_\_forceinline\_\_ keywords and converts them into the appropriate Clang attributes.
-
-## 19.2 Calling \_\_global\_\_ functions
-
-\_\_global\_\_ functions are often referred to as kernels . When you call a global function, you're launching a kernel . When launching a kernel, you must specify an execution configuration that includes the grid and block dimensions. The execution configuration can also include other information for the launch, such as the amount of additional shared memory to allocate and the stream where you want to execute the kernel.
-
-HIP introduces a standard C++ calling convention ( hipLaunchKernelGGL ) to pass the run configuration to the kernel. However, you can also use the CUDA &lt;&lt;&lt; &gt;&gt;&gt; syntax.
-
-When using hipLaunchKernelGGL , your first five parameters must be:
-
-- symbol kernelName : The name of the kernel you want to launch. To support template kernels that contain "," , use the HIP\_KERNEL\_NAME macro (HIPIFY tools insert this automatically).
-- dim3 gridDim : 3D-grid dimensions that specify the number of blocks to launch.
-- dim3 blockDim : 3D-block dimensions that specify the number of threads in each block.
-- size\_t dynamicShared : The amount of additional shared memory that you want to allocate when launching the kernel (see \_\_shared\_\_ ).
-- hipStream\_t : The stream where you want to run the kernel. A value of 0 corresponds to the NULL stream (see Synchronization functions ).
-
-You can include your kernel arguments after these parameters.
-
-```
-                                                                                                                                                                                                        // Example hipLaunchKernelGGL pseudocode:
-```
-
-```
-
-ize_t  N)
-```
-
-(continued from previous page)
-
-```
-                                                                                                                                                                                                        (continued from previous page)
-                                                                                                                                                                                                       
-                                                                                                                                                                                                      
-}
-
-MyKernel<<<dim3(gridDim), dim3(groupDim), 0, 0>>> (a,b,c,n);
-
-// Alternatively, you can launch the kernel using:
-// hipLaunchKernelGGL(MyKernel, dim3(gridDim), dim3(groupDim), 0/*dynamicShared*/, 0/
-                                                                                                                                                                                                       :*stream), a, b, c, n);
-```
-
-You can use HIPIFY tools to convert CUDA launch syntax to hipLaunchKernelGGL . This includes the conversion of optional &lt;&lt;&lt; &gt;&gt;&gt; arguments into the five required hipLaunchKernelGGL parameters. Note: HIP doesn't support dimension sizes of 𝑔𝑟𝑖𝑑𝐷𝑖𝑚 * 𝑏𝑙𝑜𝑐𝑘𝐷𝑖𝑚 ≥ 2 32 when launching a kernel.
-
-## 19.3 Kernel launch example
-
-```
-
-// Example showing device function, __device__ __host__
-// <- compile for both device and host
-float PlusOne(float x)
-{
-  return x + 1.0;
-}
-
-__global__
-void
-MyKernel (hipLaunchParm lp, /*lp parm for execution configuration */
-          const float *a, const float *b, float *c, unsigned N)
-{
-  unsigned gid = threadIdx.x; // <- coordinate index function
-  if (gid < N) {
-    c[gid] = a[gid] + PlusOne(b[gid]);
-  }
-}
-void callMyKernel()
-{
-  float *a, *b, *c; // initialization not shown...
-  unsigned N = 1000000;
-  const unsigned blockSize = 256;
-
-  MyKernel<<<dim3(gridDim), dim3(groupDim), 0, 0>>> (a,b,c,n);
-  // Alternatively, kernel can be launched by
-  // hipLaunchKernelGGL(MyKernel, dim3(N/blockSize), dim3(blockSize), 0, 0, a,b,c,N);
-}
-```
-
-## 19.4 Variable type qualifiers
-
-## 19.4.1 \_\_constant\_\_
-
-The host writes constant memory before launching the kernel. This memory is read-only from the GPU while the kernel is running. The functions for accessing constant memory are:
-
-- hipGetSymbolAddress()
-- hipGetSymbolSize()
-- hipMemcpyToSymbol()
-- hipMemcpyToSymbolAsync()
-- hipMemcpyFromSymbol()
-- hipMemcpyFromSymbolAsync()
-
-## 19.4.2 \_\_shared\_\_
-
-To allow the host to dynamically allocate shared memory, you can specify extern \_\_shared\_\_ as a launch parameter.
-
-Note: Prior to the HIP-Clang compiler, dynamic shared memory had to be declared using the HIP\_DYNAMIC\_SHARED macro in order to ensure accuracy. This is because using static shared memory in the same kernel could've resulted in overlapping memory ranges and data-races. The HIP-Clang compiler provides support for extern \_\_shared\_ declarations, so HIP\_DYNAMIC\_SHARED is no longer required.
-
-## 19.4.3 \_\_managed\_\_
-
-Managed memory, including the \_\_managed\_\_ keyword, is supported in HIP combined host/device compilation.
-
-## 19.4.4 \_\_restrict\_\_
-
-\_\_restrict\_\_ tells the compiler that the associated memory pointer not to alias with any other pointer in the kernel or function. This can help the compiler generate better code. In most use cases, every pointer argument should use this keyword in order to achieve the benefit.
-
-## 19.5 Built-in variables
-
-## 19.5.1 Coordinate built-ins
-
-The kernel uses coordinate built-ins ( thread* , block* , grid* ) to determine the coordinate index and bounds for the active work item.
-
-Built-ins are defined in amd\_hip\_runtime.h , rather than being implicitly defined by the compiler.
-
-Coordinate variable definitions for built-ins are the same for HIP and CUDA. For example: threadIdx.x , blockIdx. y , and gridDim.y . The products gridDim.x * blockDim.x , gridDim.y * blockDim.y , and gridDim.z * blockDim.z are always less than 2^32 .
-
-Coordinate built-ins are implemented as structures for improved performance. When used with printf , they must be explicitly cast to integer types.
-
-## 19.5.2 warpSize
-
-The warpSize variable type is int . It contains the warp size (in threads) for the target device. warpSize should only be used in device functions that develop portable wave-aware code.
-
-Note: NVIDIA devices return 32 for this variable; AMD devices return 64 for gfx9 and 32 for gfx10 and above.
-
-## 19.6 Vector types
-
-The following vector types are defined in hip\_runtime.h . They are not automatically provided by the compiler.
-
-## 19.6.1 Short vector types
-
-Short vector types derive from basic integer and floating-point types. These structures are defined in hip\_vector\_types.h . The first, second, third, and fourth components of the vector are defined by the x , y , z , and w fields, respectively. All short vector types support a constructor function of the form make\_&lt;type\_name&gt;() . For example, float4 make\_float4(float x, float y, float z, float w) creates a vector with type float4 and value (x,y,z,w) .
-
-HIP supports the following short vector formats:
-
-- Signed Integers:
-- -char1 , char2 , char3 , char4
-- -short1 , short2 , short3 , short4
-- -int1 , int2 , int3 , int4
-- -long1 , long2 , long3 , long4
-- -longlong1 , longlong2 , longlong3 , longlong4
-- Unsigned Integers:
-- -uchar1 , uchar2 , uchar3 , uchar4
-- -ushort1 , ushort2 , ushort3 , ushort4
-- -uint1 , uint2 , uint3 , uint4
-- -ulong1 , ulong2 , ulong3 , ulong4
-- -ulonglong1 , ulonglong2 , ulonglong3 , ulonglong4
-- Floating Points:
-- -float1 , float2 , float3 , float4
-- -double1 , double2 , double3 , double4
-
-## 19.6.2 dim3
-
-dim3 is a three-dimensional integer vector type that is commonly used to specify grid and group dimensions.
-
-The dim3 constructor accepts between zero and three arguments. By default, it initializes unspecified dimensions to 1.
-
-```
-<_C_>
-```
-
-## 19.7 Memory fence instructions
-
-HIP supports \_\_threadfence() and \_\_threadfence\_block() . If you're using threadfence\_system() in the HIP-Clang path, you can use the following workaround:
-
-1. Build HIP with the HIP\_COHERENT\_HOST\_ALLOC environment variable enabled.
-2. Modify kernels that use \_\_threadfence\_system() as follows:
-- Ensure the kernel operates only on fine-grained system memory, which should be allocated with hipHostMalloc() .
-- Remove memcpy for all allocated fine-grained system memory regions.
-
-## 19.8 Synchronization functions
-
-Synchronization functions causes all threads in the group to wait at this synchronization point, and for all shared and global memory accesses by the threads to complete, before running synchronization. This guarantees the visibility of accessed data for all threads in the group.
-
-The \_\_syncthreads() built-in function is supported in HIP. The \_\_syncthreads\_count(int) , \_\_syncthreads\_and(int) , and \_\_syncthreads\_or(int) functions are under development.
-
-The Cooperative Groups API offer options to do synchronization on a developer defined set of thread groups. For further information, check Cooperative Groups API or Cooperative Groups how to .
-
-## 19.9 Math functions
-
-HIP-Clang supports a set of math operations that are callable from the device. HIP supports most of the device functions supported by CUDA. These are described on Math API page .
-
-## 19.10 Texture functions
-
-The supported texture functions are listed in texture\_fetch\_functions.h and texture\_indirect\_functions. h header files in the HIP-AMD backend repository.
-
-Texture functions are not supported on some devices. To determine if texture functions are supported on your device, use Macro \_\_HIP\_NO\_IMAGE\_SUPPORT == 1 . You can query the attribute hipDeviceAttributeImageSupport to check if texture functions are supported in the host runtime code.
-
-## 19.11 Surface functions
-
-The following surface functions are supported in HIP:
-
-hipError\_t hipCreateSurfaceObject ( hipSurfaceObject\_t *pSurfObject, const hipResourceDesc *pResDesc )
-
-Create a surface object.
-
-## Parameters
-
-- pSurfObject -[out] Pointer of surface object to be created.
-- pResDesc -[in] Pointer of suface object descriptor.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipDestroySurfaceObject ( hipSurfaceObject\_t surfaceObject )
-
-Destroy a surface object.
-
-## Parameters
-
-surfaceObject -[in] Surface object to be destroyed.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf1Dread ( T *data, hipSurfaceObject\_t surfObj, int x, int boundaryMode = hipBoundaryModeZero )
-
-Reads the value at coordinate x from the one-dimensional surface.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [out] The T type result is stored in this pointer.
-- surfObj - [in] The surface descriptor.
-- x - [in] The coordinate where the value will be read out.
-- boundaryMode - [in] The boundary mode is currently ignored.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf1Dwrite ( T data, hipSurfaceObject\_t surfObj, int x )
-
-Writes the value data to the one-dimensional surface at coordinate x.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [in] The T type value is written to surface.
-
-- surfObj - [in] The surface descriptor.
-- x - [in] The coordinate where the data will be written.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf2Dread ( T *data, hipSurfaceObject\_t surfObj, int x, int y )
-
-Reads the value from the two-dimensional surface at coordinate x, y.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [out] The T type result is stored in this pointer.
-- surfObj - [in] The surface descriptor.
-- x - [in] The x coordinate where the value will be read out.
-- y - [in] The y coordinate where the value will be read out.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf2Dwrite ( T data, hipSurfaceObject\_t surfObj, int x, int y )
-
-Writes the value data to the two-dimensional surface at coordinate x, y.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [in] The T type value is written to surface.
-- surfObj - [in] The surface descriptor.
-- x - [in] The x coordinate where the data will be written.
-- y - [in] The y coordinate where the data will be written.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf3Dread ( T *data, hipSurfaceObject\_t surfObj, int x, int y, int z )
-
-Reads the value from the three-dimensional surface at coordinate x, y, z.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [out] The T type result is stored in this pointer.
-- surfObj - [in] The surface descriptor.
-- x - [in] The x coordinate where the value will be read out.
-- y - [in] The y coordinate where the value will be read out.
-- z - [in] The z coordinate where the value will be read out.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf3Dwrite ( T data, hipSurfaceObject\_t surfObj, int x, int y, int z )
-
-Writes the value data to the three-dimensional surface at coordinate x, y, z.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [in] The T type value is written to surface.
-- surfObj - [in] The surface descriptor.
-- x - [in] The x coordinate where the data will be written.
-- y - [in] The y coordinate where the data will be written.
-- z - [in] The z coordinate where the data will be written.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf1DLayeredread ( T *data, hipSurfaceObject\_t surfObj, int x, int layer )
-
-Reads the value from the one-dimensional layered surface at coordinate x and layer index.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [out] The T type result is stored in this pointer.
-- surfObj - [in] The surface descriptor.
-- x - [in] The coordinate where the value will be read out.
-- layer - [in] The layer index where the value will be read out.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf1DLayeredwrite ( T data, hipSurfaceObject\_t surfObj, int x, int layer )
-
-Writes the value data to the one-dimensional layered surface at coordinate x and layer index.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [in] The T type value is written to surface.
-- surfObj - [in] The surface descriptor.
-- x - [in] The x coordinate where the data will be written.
-- layer - [in] The layer index where the data will be written.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surf2DLayeredread ( T *data, hipSurfaceObject\_t surfObj, int x, int y, int layer )
-
-Reads the value from the two-dimensional layered surface at coordinate x, y and layer index.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [out] The T type result is stored in this pointer.
-- surfObj - [in] The surface descriptor.
-- x - [in] The x coordinate where the value will be read out.
-- y - [in] The y coordinate where the value will be read out.
-- layer - [in] The layer index where the value will be read out.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt;
-
-static void surf2DLayeredwrite ( T data, hipSurfaceObject\_t surfObj, int x, int y, int layer )
-
-Writes the value data to the two-dimensional layered surface at coordinate x, y and layer index.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [in] The T type value is written to surface.
-- surfObj - [in] The surface descriptor.
-- x - [in] The x coordinate where the data will be written.
-- y - [in] The y coordinate where the data will be written.
-- layer - [in] The layer index where the data will be written.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surfCubemapread ( T *data, hipSurfaceObject\_t surfObj, int x, int y, int face )
-
-Reads the value from the cubemap surface at coordinate x, y and face index.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [out] The T type result is stored in this pointer.
-- surfObj - [in] The surface descriptor.
-- x - [in] The x coordinate where the value will be read out.
-- y - [in] The y coordinate where the value will be read out.
-- face - [in] The face index where the value will be read out.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surfCubemapwrite ( T data, hipSurfaceObject\_t surfObj, int x, int y, int face )
-
-Writes the value data to the cubemap surface at coordinate x, y and face index.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [in] The T type value is written to surface.
-- surfObj - [in] The surface descriptor.
-- x - [in] The x coordinate where the data will be written.
-- y - [in] The y coordinate where the data will be written.
-- face - [in] The face index where the data will be written.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surfCubemapLayeredread ( T *data, hipSurfaceObject\_t surfObj, int x, int y, int face, int layer )
-
-Reads the value from the layered cubemap surface at coordinate x, y and face, layer index.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [out] The T type result is stored in this pointer.
-
-- surfObj - [in] The surface descriptor.
-- x - [in] The x coordinate where the value will be read out.
-- y - [in] The y coordinate where the value will be read out.
-- face - [in] The face index where the value will be read out.
-- layer - [in] The layer index where the data will be written.
-
-template&lt;typename T , typename std::enable\_if&lt;\_\_hip\_is\_tex\_surf\_channel\_type&lt; T &gt;::value&gt;::type* = nullptr&gt; static void surfCubemapLayeredwrite ( T *data, hipSurfaceObject\_t surfObj, int x, int y, int face, int layer )
-
-Writes the value data to the layered cubemap surface at coordinate x, y and face, layer index.
-
-## Template Parameters
-
-T - The data type of the surface.
-
-## Parameters
-
-- data - [in] The T type value to write to the surface.
-- surfObj - [in] The surface descriptor.
-- x - [in] The x coordinate where the data will be written.
-- y - [in] The y coordinate where the data will be written.
-- face - [in] The face index where the data will be written.
-- layer - [in] The layer index where the data will be written.
-
-## 19.12 Timer functions
-
-To read a high-resolution timer from the device, HIP provides the following built-in functions:
-
-- Returning the incremental counter value for every clock cycle on a device:
-
-```
-<_SQL_>
-```
-
-```
-    [clock_t clock()
-    long long int close
-```
-
-The difference between the values that are returned represents the cycles used.
-
-- Returning the wall clock count at a constant frequency on the device:
-
-```
-  | long long int w:
-```
-
-```
-    it will_clock64()
-```
-
-This can be queried using the HIP API with the hipDeviceAttributeWallClockRate attribute of the device in HIP application code. For example:
-
-```
-            int wallClkRate = 0; //in kilohertz
-            HIPCHECK(hipDeviceGetAttribute(&wallClkRate, hipDeviceAttributeWallClockRate, _
-            --deviceId));
-```
-
-Where hipDeviceAttributeWallClockRate is a device attribute. Note that wall clock frequency is a perdevice attribute.
-
-Note that clock() and clock64() do not work properly on AMD RDNA3 (GFX11) graphic processors.
-
-## 19.13 Atomic functions
-
-Atomic functions are run as read-modify-write (RMW) operations that reside in global or shared memory. No other device or thread can observe or modify the memory location during an atomic operation. If multiple instructions from different devices or threads target the same memory location, the instructions are serialized in an undefined order.
-
-To support system scope atomic operations, you can use the HIP APIs that contain the \_system suffix. For example:
-
-- atomicAnd : This function is atomic and coherent within the GPU device running the function
-- atomicAnd\_system : This function extends the atomic operation from the GPU device to other CPUs and GPU devices in the system.
-
-HIP supports the following atomic operations.
-
-Table 1: Atomic operations
-
-| Function int atomicAdd(int* address, int val) int atomicAdd_system(int* address, int val) unsigned int atomicAdd(unsigned int* address,unsigned unsigned int atomicAdd_system(unsigned int* address, unsigned long long atomicAdd(unsigned long long* unsigned long long atomicAdd_system(unsigned long long* float atomicAdd(float* address, float val) float atomicAdd_system(float* address, float val) double atomicAdd(double* address, double val) double atomicAdd_system(double* address, double val) float unsafeAtomicAdd(float* address, float val) float safeAtomicAdd(float* address, float val)   |
-|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| int val) unsigned int val) address,unsigned long long val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| address, unsigned long long val) double unsafeAtomicAdd(double* address, double val) double safeAtomicAdd(double* address, double val) int atomicSub(int* address, int val) int atomicSub_system(int* address, int val) unsigned int atomicSub(unsigned int* address,unsigned int val) unsigned int atomicSub_system(unsigned int* address, unsigned int val)                                                                                                                                                                                                                                                   |
-| int atomicExch(int* address, int val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
-| int atomicExch_system(int* address, int val) unsigned int atomicExch(unsigned int* address,unsigned int val) unsigned int atomicExch_system(unsigned int* address, unsigned int val)                                                                                                                                                                                                                                                                                                                                                                                                                            |
-| unsigned long long atomicExch(unsigned long long int* address,unsigned long val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-| long unsigned long long atomicExch_system(unsigned long long* address, unsigned long                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
-| int long val) unsigned long long atomicExch_system(unsigned long long* address, unsigned long long val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| float atomicExch(float* address, float val) int atomicMin(int* address, int val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-| int atomicMin_system(int* address, int val) unsigned int atomicMin(unsigned int* address,unsigned int                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
-| val) unsigned int atomicMin_system(unsigned int* address, unsigned int                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
-| val) unsigned long long atomicMin(unsigned long long* address,unsigned long long val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
-| atomicMax(int* address, int val) atomicMax_system(int* address, int val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
-| int unsigned int atomicMax(unsigned int* address,unsigned int val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
-| unsigned int atomicMax_system(unsigned int* address, unsigned int                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
-| int                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
-| val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
-| unsigned long long atomicMax(unsigned long long* address,unsigned long long val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-
-Table 1 - continued from previous page
-
-| unsigned int atomicDec(unsigned int* address)                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| int atomicCAS(int* address, int compare, int val)                                                                                                                                                                                                                                                                                                                                                                                                                              |
-| int atomicCAS_system(int* address, int compare, int val)                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| unsigned int atomicCAS(unsigned int* address,unsigned int compare,unsigned int val) unsigned int atomicCAS_system(unsigned int* address, unsigned int compare, unsigned int val) unsigned long long atomicCAS(unsigned long long* address,unsigned long long compare,unsigned long long unsigned long long atomicCAS_system(unsigned long long* address, unsigned long long compare, unsigned int atomicAnd(int* address, int val) int atomicAnd_system(int* address, int val) |
-| unsigned int atomicAnd(unsigned int* address,unsigned int val) unsigned int atomicAnd_system(unsigned int* address, unsigned int val)                                                                                                                                                                                                                                                                                                                                          |
-| unsigned long long atomicAnd(unsigned long long* address,unsigned long long val) unsigned long long atomicAnd_system(unsigned long long* address, unsigned long                                                                                                                                                                                                                                                                                                                |
-| long val) int atomicOr(int* address, int val)                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| int atomicOr_system(int* address, int val)                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| unsigned int atomicOr(unsigned int* address,unsigned int val) unsigned int atomicOr_system(unsigned int* address, unsigned                                                                                                                                                                                                                                                                                                                                                     |
-| int val) unsigned int atomicOr_system(unsigned int* address, unsigned int val)                                                                                                                                                                                                                                                                                                                                                                                                 |
-| unsigned long long atomicOr(unsigned long long int* address,unsigned long long val)                                                                                                                                                                                                                                                                                                                                                                                            |
-| unsigned long long atomicOr_system(unsigned long long* address, unsigned long long val)                                                                                                                                                                                                                                                                                                                                                                                        |
-| int atomicXor(int* address, int val)                                                                                                                                                                                                                                                                                                                                                                                                                                           |
-| int atomicXor_system(int* address, int val)                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| unsigned int atomicXor(unsigned int* address,unsigned int val)                                                                                                                                                                                                                                                                                                                                                                                                                 |
-| unsigned int atomicXor_system(unsigned int* address, unsigned int val)                                                                                                                                                                                                                                                                                                                                                                                                         |
-| unsigned long long atomicXor(unsigned long long* address,unsigned long long val)                                                                                                                                                                                                                                                                                                                                                                                               |
-| unsigned long long atomicXor_system(unsigned long long* address, unsigned long long                                                                                                                                                                                                                                                                                                                                                                                            |
-| val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
-
-## 19.13.1 Unsafe floating-point atomic RMW operations
-
-Some HIP devices support fast atomic RMW operations on floating-point values. For example, atomicAdd on singleor double-precision floating-point values may generate a hardware RMW instruction that is faster than emulating the atomic operation using an atomic compare-and-swap (CAS) loop.
-
-On some devices, fast atomic RMW instructions can produce results that differ from the same functions implemented with atomic CAS loops. For example, some devices will use different rounding or denormal modes, and some devices produce incorrect answers if fast floating-point atomic RMW instructions target fine-grained memory allocations.
-
-The HIP-Clang compiler offers a compile-time option, so you can choose fast-but potentially unsafe-atomic instructions for your code. On devices that support these instructions, you can include the -munsafe-fp-atomics option. This flag indicates to the compiler that all floating-point atomic function calls are allowed to use an unsafe version, if one exists. For example, on some devices, this flag indicates to the compiler that no floating-point atomicAdd function can target fine-grained memory.
-
-If you want to avoid using unsafe use a floating-point atomic RMW operations, you can use the -mno-unsafe-fp-atomics option. Note that the compiler default is to not produce unsafe floating-point atomic RMW instructions, so the -mno-unsafe-fp-atomics option is not necessarily required. However, passing this option to the compiler is good practice.
-
-When you pass -munsafe-fp-atomics or -mno-unsafe-fp-atomics to the compiler's command line, the option is applied globally for the entire compilation. Note that if some of the atomic RMW function calls cannot safely use the faster floating-point atomic RMW instructions, you must use -mno-unsafe-fp-atomics in order to ensure that your atomic RMW function calls produce correct results.
-
-HIP has four extra functions that you can use to more precisely control which floating-point atomic RMW functions produce unsafe atomic RMW instructions:
-
-- float unsafeAtomicAdd(float* address, float val)
-- double unsafeAtomicAdd(double* address, double val) (Always produces fast atomic RMW instructions on devices that have them, even when -mno-unsafe-fp-atomics is used)
-- float safeAtomicAdd(float* address, float val)
-- double safeAtomicAdd(double* address, double val) (Always produces safe atomic RMW operations, even when -munsafe-fp-atomics is used)
-
-## 19.14 Warp cross-lane functions
-
-Threads in a warp are referred to as lanes and are numbered from 0 to warpSize - 1 . Warp cross-lane functions operate across all lanes in a warp. The hardware guarantees that all warp lanes will execute in lockstep, so additional synchronization is unnecessary, and the instructions use no shared memory.
-
-Note that NVIDIA and AMD devices have different warp sizes. You can use warpSize built-ins in you portable code to query the warp size.
-
-Tip: Be sure to review HIP code generated from the CUDA path to ensure that it doesn't assume a waveSize of 32. 'Wave-aware' code that assumes a waveSize of 32 can run on a wave-64 machine, but it only utilizes half of the machine's resources.
-
-To get the default warp size of a GPU device, use hipGetDeviceProperties in you host functions.
-
-```
-    cudaDeviceProp props;
-    cudaGetDeviceProperties(&props, deviceID);
-    int w = props.warpSize;
-    // implement portable algorithm based on w (rather than assume 32 or 64)
-```
-
-Only use warpSize built-ins in device functions, and don't assume warpSize to be a compile-time constant.
-
-Note that assembly kernels may be built for a warp size that is different from the default. All mask values either returned or accepted by these builtins are 64-bit unsigned integer values, even when compiled for a wave-32 device, where all the higher bits are unused. CUDA code ported to HIP requires changes to ensure that the correct type is used.
-
-Note that the \_\_sync variants are made available in ROCm 6.2, but disabled by default to help with the transition to 64-bit masks. They can be enabled by setting the preprocessor macro HIP\_ENABLE\_WARP\_SYNC\_BUILTINS . These builtins will be enabled unconditionally in ROCm 6.3. Wherever possible, the implementation includes a static assert to check that the program source uses the correct type for the mask.
-
-## 19.14.1 Warp vote and ballot functions
-
-```
-int __all(int predicate)
-int __any(int predicate)
-unsigned long long __ballot(int predicate)
-unsigned long long __activemask()
-
-int __all_sync(unsigned long long mask, int predicate)
-```
-
-(continued from previous page)
-
-```
-<_Python_>
-```
-
-You can use \_\_any and \_\_all to get a summary view of the predicates evaluated by the participating lanes.
-
-- \_\_any() : Returns 1 if the predicate is non-zero for any participating lane, otherwise it returns 0.
-- \_\_all() : Returns 1 if the predicate is non-zero for all participating lanes, otherwise it returns 0.
-
-To determine if the target platform supports the any/all instruction, you can use the hasWarpVote device property or the HIP\_ARCH\_HAS\_WARP\_VOTE compiler definition.
-
-\_\_ballot returns a bit mask containing the 1-bit predicate value from each lane. The nth bit of the result contains the 1 bit contributed by the nth warp lane.
-
-\_\_activemask() returns a bit mask of currently active warp lanes. The nth bit of the result is 1 if the nth warp lane is active.
-
-Note that the \_\_ballot and \_\_activemask builtins in HIP have a 64-bit return value (unlike the 32-bit value returned by the CUDA builtins). Code ported from CUDA should be adapted to support the larger warp sizes that the HIP version requires.
-
-Applications can test whether the target platform supports the \_\_ballot or \_\_activemask instructions using the hasWarpBallot device property in host code or the HIP\_ARCH\_HAS\_WARP\_BALLOT macro defined by the compiler for device code.
-
-The \_sync variants require a 64-bit unsigned integer mask argument that specifies the lanes in the warp that will participate in cross-lane communication with the calling lane. Each participating thread must have its own bit set in its mask argument, and all active threads specified in any mask argument must execute the same call with the same mask, otherwise the result is undefined.
-
-## 19.14.2 Warp match functions
-
-```
-    unsigned long long __match_any(T value)
-    unsigned long long __match_all(T value, int *pred)
-
-    unsigned long long __match_any_sync(unsigned long long mask, T value)
-    unsigned long long __match_all_sync(unsigned long long mask, T value, int *pred)
-```
-
-T can be a 32-bit integer type, 64-bit integer type or a single precision or double precision floating point type.
-
-\_\_match\_any returns a bit mask containing a 1-bit for every participating lane if and only if that lane has the same value in value as the current lane, and a 0-bit for all other lanes.
-
-\_\_match\_all returns a bit mask containing a 1-bit for every participating lane if and only if they all have the same value in value as the current lane, and a 0-bit for all other lanes. The predicate pred is set to true if and only if all participating threads have the same value in value .
-
-The \_sync variants require a 64-bit unsigned integer mask argument that specifies the lanes in the warp that will participate in cross-lane communication with the calling lane. Each participating thread must have its own bit set in its mask argument, and all active threads specified in any mask argument must execute the same call with the same mask, otherwise the result is undefined.
-
-## 19.14.3 Warp shuffle functions
-
-The default width is warpSize (see Warp cross-lane functions ). Half-float shuffles are not supported.
-
-```
-            The default width is warpSize (see Warp cross-lane functions). Half-float shuffles are not supported.
-                                                                                                                                                                                                        
-                                                                                                                                                                                                      
-int       __shfl           (T var,     int srcLane,  int width=warpSize);
-```
-
-T can be a 32-bit integer type, 64-bit integer type or a single precision or double precision floating point type.
-
-The \_sync variants require a 64-bit unsigned integer mask argument that specifies the lanes in the warp that will participate in cross-lane communication with the calling lane. Each participating thread must have its own bit set in its mask argument, and all active threads specified in any mask argument must execute the same call with the same mask, otherwise the result is undefined.
-
-## 19.15 Cooperative groups functions
-
-You can use cooperative groups to synchronize groups of threads. Cooperative groups also provide a way of communicating between groups of threads at a granularity that is different from the block.
-
-HIP supports the following kernel language cooperative groups types and functions:
-
-Table 2: Cooperative groups functions
-
-| Function                                | Supported in HIP   | Supported in CUDA   |
-|-----------------------------------------|--------------------|---------------------|
-| void thread_group.sync();               | ✓                  | ✓                   |
-| unsigned thread_group.size();           | ✓                  | ✓                   |
-| unsigned thread_group.thread_rank()     | ✓                  | ✓                   |
-| bool thread_group.is_valid();           | ✓                  | ✓                   |
-| grid_group this_grid()                  | ✓                  | ✓                   |
-| void grid_group.sync()                  | ✓                  | ✓                   |
-| unsigned grid_group.size()              | ✓                  | ✓                   |
-| unsigned grid_group.thread_rank()       | ✓                  | ✓                   |
-| bool grid_group.is_valid()              | ✓                  | ✓                   |
-| multi_grid_group this_multi_grid()      | ✓                  | ✓                   |
-| void multi_grid_group.sync()            | ✓                  | ✓                   |
-| unsigned multi_grid_group.size()        | ✓                  | ✓                   |
-| unsigned multi_grid_group.thread_rank() | ✓                  | ✓                   |
-| bool multi_grid_group.is_valid()        | ✓                  | ✓                   |
-| unsigned multi_grid_group.num_grids()   | ✓                  | ✓                   |
-| unsigned multi_grid_group.grid_rank()   | ✓                  | ✓                   |
-| thread_block this_thread_block()        | ✓                  | ✓                   |
-| multi_grid_group this_multi_grid()      | ✓                  | ✓                   |
-| void multi_grid_group.sync()            | ✓                  | ✓                   |
-| void thread_block.sync()                | ✓                  | ✓                   |
-| unsigned thread_block.size()            | ✓                  | ✓                   |
-| unsigned thread_block.thread_rank()     | ✓                  | ✓                   |
-| bool thread_block.is_valid()            | ✓                  | ✓                   |
-| dim3 thread_block.group_index()         | ✓                  | ✓                   |
-| dim3 thread_block.thread_index()        | ✓                  | ✓                   |
-
-For further information, check Cooperative Groups API or Cooperative Groups how to .
-
-## 19.16 Warp matrix functions
-
-Warp matrix functions allow a warp to cooperatively operate on small matrices that have elements spread over lanes in an unspecified manner.
-
-HIP does not support kernel language warp matrix types or functions.
-
-Table 3: Warp matrix functions
-
-| Function                                                                                                     | Sup- ported in HIP   | Supported in CUDA   |
-|--------------------------------------------------------------------------------------------------------------|----------------------|---------------------|
-| void load_matrix_sync(fragment<...> &a, const T* mptr, unsigned lda)                                         |                      | ✓                   |
-| void load_matrix_sync(fragment<...> &a, const T* mptr, unsigned lda, layout_t layout)                        |                      | ✓                   |
-| void store_matrix_sync(T* mptr, fragment<...> &a, unsigned lda, layout_t layout)                             |                      | ✓                   |
-| void fill_fragment(fragment<...> &a, const T &value) void mma_sync(fragment<...> &d, const fragment<...> &a, |                      | ✓                   |
-| const fragment<...> &b, const fragment<...> &c , bool sat)                                                   |                      | ✓                   |
-
-## 19.17 Independent thread scheduling
-
-Certain architectures that support CUDA allow threads to progress independently of each other. This independent thread scheduling makes intra-warp synchronization possible.
-
-HIP does not support this type of scheduling.
-
-## 19.18 Profiler Counter Function
-
-The CUDA \_\_prof\_trigger() instruction is not supported.
-
-## 19.19 Assert
-
-The assert function is supported in HIP. Assert function is used for debugging purpose, when the input expression equals to zero, the execution will be stopped.
-
-```
-|void assert(int ir
-```
-
-```
-    input()
-```
-
-There are two kinds of implementations for assert functions depending on the use sceneries, - One is for the host version of assert, which is defined in assert.h , - Another is the device version of assert, which is implemented in hip/hip\_runtime.h . Users need to include assert.h to use assert . For assert to work in both device and host functions, users need to include "hip/hip\_runtime.h" .
-
-HIP provides the function abort() which can be used to terminate the application when terminal failures are detected. It is implemented using the \_\_builtin\_trap() function.
-
-This function produces a similar effect of using asm("trap") in the CUDA code.
-
-Note: In HIP, the function terminates the entire application, while in CUDA, asm("trap") only terminates the dispatch and the application continues to run.
-
-## 19.20 printf
-
-printf function is supported in HIP. The following is a simple example to print information in the kernel.
-
-```
-                                                                                                                                                                                                       
-#include <hip/hip_runtime.h>
-
-    __global__ void run_printf() { printf("Hello World\n"); }
-
-    int main() {
-      run_printf<<<dim3(1), dim3(1), 0, 0>>>();
-    }
-```
-
-## 19.21 Device-Side Dynamic Global Memory Allocation
-
-Device-side dynamic global memory allocation is under development. HIP now includes a preliminary implementation of malloc and free that can be called from device functions.
-
-## 19.22 \_\_launch\_bounds\_\_
-
-GPU multiprocessors have a fixed pool of resources (primarily registers and shared memory) which are shared by the actively running warps. Using more resources can increase IPC of the kernel but reduces the resources available for other warps and limits the number of warps that can be simultaneously running. Thus GPUs have a complex relationship between resource usage and performance.
-
-\_\_launch\_bounds\_\_ allows the application to provide usage hints that influence the resources (primarily registers) used by the generated code. It is a function attribute that must be attached to a \_\_global\_\_ function:
-
-```
-<_Cython_>
-```
-
-\_\_launch\_bounds\_\_ supports two parameters: - MAX\_THREADS\_PER\_BLOCK - The programmers guarantees that kernel will be launched with threads less than MAX\_THREADS\_PER\_BLOCK. (On NVCC this maps to the . maxntid PTX directive). If no launch\_bounds is specified, MAX\_THREADS\_PER\_BLOCK is the maximum block size supported by the device (typically 1024 or larger). Specifying MAX\_THREADS\_PER\_BLOCK less than the maximum effectively allows the compiler to use more resources than a default unconstrained compilation that supports all possible block sizes at launch time. The threads-per-block is the product of ( blockDim.x * blockDim. y * blockDim.z ). - MIN\_WARPS\_PER\_EXECUTION\_UNIT - directs the compiler to minimize resource usage so that the requested number of warps can be simultaneously active on a multi-processor. Since active warps compete for the same fixed pool of resources, the compiler must reduce resources required by each warp(primarily registers). MIN\_WARPS\_PER\_EXECUTION\_UNIT is optional and defaults to 1 if not specified. Specifying a MIN\_WARPS\_PER\_EXECUTION\_UNIT greater than the default 1 effectively constrains the compiler's resource usage.
-
-When launch kernel with HIP APIs, for example, hipModuleLaunchKernel() , HIP will do validation to make sure input kernel dimension size is not larger than specified launch\_bounds. In case exceeded, HIP would return launch failure, if AMD\_LOG\_LEVEL is set with proper value (for details, please refer to docs/markdown/hip\_logging. md ), detail information will be shown in the error log message, including launch parameters of kernel dim size, launch bounds, and the name of the faulting kernel. It's helpful to figure out which is the faulting kernel, besides, the kernel dim size and launch bounds values will also assist in debugging such failures.
-
-## 19.22.1 Compiler Impact
-
-The compiler uses these parameters as follows: - The compiler uses the hints only to manage register usage, and does not automatically reduce shared memory or other resources. - Compilation fails if compiler cannot generate a kernel which meets the requirements of the specified launch bounds. - From MAX\_THREADS\_PER\_BLOCK, the compiler derives the maximum number of warps/block that can be used at launch time. Values of MAX\_THREADS\_PER\_BLOCK less than the default allows the compiler to use a larger pool of registers : each warp uses registers, and this hint constrains the launch to a warps/block size which is less than maximum. - From MIN\_WARPS\_PER\_EXECUTION\_UNIT, the compiler derives a maximum number of registers that can be used by the kernel (to meet the required #simultaneous active blocks). If MIN\_WARPS\_PER\_EXECUTION\_UNIT is 1, then the kernel can use all registers supported by the multiprocessor. - The compiler ensures that the registers used in the kernel is less than both allowed maximums, typically by spilling registers (to shared or global memory), or by using more instructions. - The compiler may use heuristics to increase register usage, or may simply be able to avoid spilling. The MAX\_THREADS\_PER\_BLOCK
-
-is particularly useful in this cases, since it allows the compiler to use more registers and avoid situations where the compiler constrains the register usage (potentially spilling) to meet the requirements of a large block size that is never used at launch time.
-
-## 19.22.2 CU and EU Definitions
-
-A compute unit (CU) is responsible for executing the waves of a work-group. It is composed of one or more execution units (EU) which are responsible for executing waves. An EU can have enough resources to maintain the state of more than one executing wave. This allows an EU to hide latency by switching between waves in a similar way to symmetric multithreading on a CPU. In order to allow the state for multiple waves to fit on an EU, the resources used by a single wave have to be limited. Limiting such resources can allow greater latency hiding, but can result in having to spill some register state to memory. This attribute allows an advanced developer to tune the number of waves that are capable of fitting within the resources of an EU. It can be used to ensure at least a certain number will fit to help hide latency, and can also be used to ensure no more than a certain number will fit to limit cache thrashing.
-
-## 19.22.3 Porting from CUDA \_\_launch\_bounds
-
-CUDA defines a \_\_launch\_bounds which is also designed to control occupancy:
-
-- \_\_launch\_bounds(MAX\_THREADS\_PER\_BLOCK, MIN\_BLOCKS\_PER\_MULTIPROCESSOR)
-- The second parameter \_\_launch\_bounds parameters must be converted to the format used \_\_hip\_launch\_bounds, which uses warps and execution-units rather than blocks and multi-processors (this conversion is performed automatically by HIPIFY tools).
-
-```
-                                                                                                                                                                                                        | MIN_WARPS_PER_EXECUTION_UNIT  =  (MIN_BLOCKS_PER_MULTIPROCESSOR  *  MAX_THREADS_PER_BLOCK)  /_\                                                                                                                                                                                                       
-                                                                                                                                                                                                        :                                                                                                                                                                                                        --                                                                                                                                                                                                        <                                                                                                                                                                                                        </                                                                                                                                                                                                        >                                                                                                                                                                                                        }
-```
-
-The key differences in the interface are: - Warps (rather than blocks): The developer is trying to tell the compiler to control resource utilization to guarantee some amount of active Warps/EU for latency hiding. Specifying active warps in terms of blocks appears to hide the micro-architectural details of the warp size, but makes the interface more confusing since the developer ultimately needs to compute the number of warps to obtain the desired level of control. - Execution Units (rather than multiprocessor): The use of execution units rather than multiprocessors provides support for architectures with multiple execution units/multi-processor. For example, the AMD GCN architecture has 4 execution units per multiprocessor. The hipDeviceProps has a field executionUnitsPerMultiprocessor . Platform-specific coding techniques such as #ifdef can be used to specify different launch\_bounds for NVCC and HIP-Clang platforms, if desired.
-
-## 19.22.4 maxregcount
-
-Unlike NVCC, HIP-Clang does not support the --maxregcount option. Instead, users are encouraged to use the hip\_launch\_bounds directive since the parameters are more intuitive and portable than micro-architecture details like registers, and also the directive allows per-kernel control rather than an entire file. hip\_launch\_bounds works on both HIP-Clang and NVCC targets.
-
-## 19.23 Asynchronous Functions
-
-## 19.23.1 Memory stream
-
-typedef void (* hipStreamCallback\_t )(hipStream\_t stream, hipError\_t status, void *userData)
-
-Stream CallBack struct hipError\_t hipStreamCreate ( hipStream\_t *stream )
-
-Create an asynchronous stream.
-
-Create a new asynchronous stream. stream returns an opaque handle that can be used to reference the newly created stream in subsequent hipStream* commands. The stream is allocated on the heap and will remain allocated even if the handle goes out-of-scope. To release the memory used by the stream, application must call hipStreamDestroy.
-
-## See also:
-
-hipStreamCreateWithFlags , hipStreamCreateWithPriority , hipStreamSynchronize , hipStreamWaitEvent , hipStreamDestroy
-
-## Parameters
-
-stream -[inout] Valid pointer to hipStream\_t. This function writes the memory with the newly created stream.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipStreamCreateWithFlags ( hipStream\_t *stream, unsigned int flags )
-
-Create an asynchronous stream.
-
-Create a new asynchronous stream. stream returns an opaque handle that can be used to reference the newly created stream in subsequent hipStream* commands. The stream is allocated on the heap and will remain allocated even if the handle goes out-of-scope. To release the memory used by the stream, application must call hipStreamDestroy. Flags controls behavior of the stream. See hipStreamDefault, hipStreamNonBlocking.
-
-## See also:
-
-hipStreamCreate , hipStreamCreateWithPriority , hipStreamSynchronize , hipStreamWaitEvent , hipStreamDestroy
-
-## Parameters
-
-- stream -[inout] Pointer to new stream
-- flags -[in] to control stream creation.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue
-
-hipError\_t hipStreamCreateWithPriority ( hipStream\_t *stream, unsigned int flags, int priority )
-
-Create an asynchronous stream with the specified priority.
-
-Create a new asynchronous stream with the specified priority. stream returns an opaque handle that can be used to reference the newly created stream in subsequent hipStream* commands. The stream is allocated on the heap and will remain allocated even if the handle goes out-of-scope. To release the memory used by the stream, application must call hipStreamDestroy. Flags controls behavior of the stream. See hipStreamDefault, hipStreamNonBlocking.
-
-## See also:
-
-hipStreamCreate , hipStreamSynchronize , hipStreamWaitEvent , hipStreamDestroy
-
-## Parameters
-
-- stream -[inout] Pointer to new stream
-- flags -[in] to control stream creation.
-- priority -[in] of the stream. Lower numbers represent higher priorities.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipDeviceGetStreamPriorityRange ( int *leastPriority, int *greatestPriority )
-
-Returns numerical values that correspond to the least and greatest stream priority.
-
-Returns in *leastPriority and *greatestPriority the numerical values that correspond to the least and greatest stream priority respectively. Stream priorities follow a convention where lower numbers imply greater priorities. The range of meaningful stream priorities is given by [*greatestPriority, *leastPriority]. If the user attempts to create a stream with a priority value that is outside the meaningful range as specified by this API, the priority is automatically clamped to within the valid range.
-
-## Parameters
-
-- leastPriority -[inout] pointer in which value corresponding to least priority is returned.
-- greatestPriority -[inout] pointer in which value corresponding to greatest priority is returned.
-
-## Returns
-
-hipSuccess hipError\_t hipStreamDestroy ( hipStream\_t stream )
-
-Destroys the specified stream.
-
-Destroys the specified stream.
-
-If commands are still executing on the specified stream, some may complete execution before the queue is deleted.
-
-The queue may be destroyed while some commands are still inflight, or may wait for all commands queued to the stream before destroying it.
-
-## See also:
-
-hipStreamCreate , hipStreamCreateWithFlags , hipStreamCreateWithPriority , hipStreamQuery , hipStreamWaitEvent , hipStreamSynchronize
-
-## Parameters
-
-stream -[in] stream identifier.
-
-## Returns
-
-hipSuccess hipErrorInvalidHandle
-
-## hipError\_t hipStreamQuery ( hipStream\_t stream )
-
-Return hipSuccess if all of the operations in the specified stream have completed, or hipErrorNotReady if not.
-
-This is thread-safe and returns a snapshot of the current state of the queue. However, if other host threads are sending work to the stream, the status may change immediately after the function is called. It is typically used for debug.
-
-## See also:
-
-hipStreamCreate , hipStreamCreateWithFlags , hipStreamCreateWithPriority , hipStreamWaitEvent , hipStreamSynchronize , hipStreamDestroy
-
-## Parameters
-
-stream -[in] stream to query
-
-## Returns
-
-hipSuccess, hipErrorNotReady, hipErrorInvalidHandle
-
-## hipError\_t hipStreamSynchronize ( hipStream\_t stream )
-
-Wait for all commands in stream to complete.
-
-This command is host-synchronous : the host will block until the specified stream is empty.
-
-This command follows standard null-stream semantics. Specifically, specifying the null stream will cause the command to wait for other streams on the same device to complete all pending operations.
-
-This command honors the hipDeviceLaunchBlocking flag, which controls whether the wait is active or blocking.
-
-## See also:
-
-hipStreamCreate , hipStreamCreateWithFlags , hipStreamCreateWithPriority , hipStreamWaitEvent , hipStreamDestroy
-
-## Parameters
-
-stream -[in] stream identifier.
-
-## Returns
-
-hipSuccess, hipErrorInvalidHandle
-
-hipError\_t hipStreamWaitEvent ( hipStream\_t stream, hipEvent\_t event, unsigned int flags )
-
-Make the specified compute stream wait for an event.
-
-This function inserts a wait operation into the specified stream. All future work submitted to stream will wait until event reports completion before beginning execution.
-
-This function only waits for commands in the current stream to complete. Notably, this function does not implicitly wait for commands in the default stream to complete, even if the specified stream is created with hipStreamNonBlocking = 0.
-
-## See also:
-
-hipStreamCreate , hipStreamCreateWithFlags , hipStreamCreateWithPriority , hipStreamSynchronize , hipStreamDestroy
-
-## Parameters
-
-- stream -[in] stream to make wait.
-- event -[in] event to wait on
-- flags -[in] control operation [must be 0]
-
-## Returns
-
-hipSuccess, hipErrorInvalidHandle hipError\_t hipStreamGetFlags ( hipStream\_t stream, unsigned int *flags )
-
-Return flags associated with this stream.
-
-Return flags associated with this stream in * flags .
-
-## See also:
-
-hipStreamCreateWithFlags
-
-## Parameters
-
-- stream -[in] stream to be queried
-- flags -[inout] Pointer to an unsigned integer in which the stream's flags are returned
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidHandle
-
-## Returns
-
-hipSuccess hipErrorInvalidValue hipErrorInvalidHandle hipError\_t hipStreamGetPriority ( hipStream\_t stream, int *priority )
-
-Query the priority of a stream.
-
-Query the priority of a stream. The priority is returned in in priority.
-
-## See also:
-
-hipStreamCreateWithFlags
-
-## Parameters
-
-- stream -[in] stream to be queried
-- priority -[inout] Pointer to an unsigned integer in which the stream's priority is returned
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidHandle
-
-## Returns
-
-hipSuccess hipErrorInvalidValue hipErrorInvalidHandle hipError\_t hipStreamGetDevice ( hipStream\_t stream, hipDevice\_t *device )
-
-Get the device assocaited with the stream.
-
-## See also:
-
-hipStreamCreate , hipStreamDestroy , hipDeviceGetStreamPriorityRange
-
-## Parameters
-
-- stream -[in] stream to be queried
-- device -[out] device associated with the stream
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorContextIsDestroyed, hipErrorInvalidHandle, hipErrorNotInitialized, hipErrorDeinitialized, hipErrorInvalidContext hipError\_t hipExtStreamCreateWithCUMask ( hipStream\_t *stream, uint32\_t cuMaskSize, const uint32\_t *cuMask )
-
-Create an asynchronous stream with the specified CU mask.
-
-Create a new asynchronous stream with the specified CU mask. stream returns an opaque handle that can be used to reference the newly created stream in subsequent hipStream* commands. The stream is allocated on the heap and will remain allocated even if the handle goes out-of-scope. To release the memory used by the stream, application must call hipStreamDestroy.
-
-## See also:
-
-hipStreamCreate , hipStreamSynchronize , hipStreamWaitEvent , hipStreamDestroy
-
-## Parameters
-
-- stream -[inout] Pointer to new stream
-- cuMaskSize -[in] Size of CU mask bit array passed in.
-- cuMask -[in] Bit-vector representing the CU mask. Each active bit represents using one CU. The first 32 bits represent the first 32 CUs, and so on. If its size is greater than physical CU number (i.e., multiProcessorCount member of hipDeviceProp\_t), the extra elements are ignored. It is user's responsibility to make sure the input is meaningful.
-
-## Returns
-
-hipSuccess, hipErrorInvalidHandle, hipErrorInvalidValue hipError\_t hipExtStreamGetCUMask ( hipStream\_t stream, uint32\_t cuMaskSize, uint32\_t *cuMask )
-
-Get CU mask associated with an asynchronous stream.
-
-## See also:
-
-hipStreamCreate , hipStreamSynchronize , hipStreamWaitEvent , hipStreamDestroy
-
-## Parameters
-
-- stream -[in] stream to be queried
-- cuMaskSize -[in] number of the block of memories (uint32\_t *) allocated by user
-- cuMask -[out] Pointer to a pre-allocated block of memories (uint32\_t *) in which the stream's CU mask is returned. The CU mask is returned in a chunck of 32 bits where each active bit represents one active CU
-
-## Returns
-
-hipSuccess, hipErrorInvalidHandle, hipErrorInvalidValue hipError\_t hipStreamAddCallback ( hipStream\_t stream, hipStreamCallback\_t callback, void *userData, unsigned int flags )
-
-Adds a callback to be called on the host after all currently enqueued items in the stream have completed. For each hipStreamAddCallback call, a callback will be executed exactly once. The callback will block later work in the stream until it is finished.
-
-## See also:
-
-hipStreamCreate , hipStreamCreateWithFlags , hipStreamQuery , hipStreamSynchronize , hipStreamWaitEvent , hipStreamDestroy , hipStreamCreateWithPriority
-
-## Parameters
-
-- stream -[in] - Stream to add callback to
-- callback -[in] - The function to call once preceding stream operations are complete
-- userData -[in] - User specified data to be passed to the callback function
-- flags -[in] - Reserved for future use, must be 0
-
-## Returns
-
-hipSuccess, hipErrorInvalidHandle, hipErrorNotSupported static inline hipError\_t hipMallocAsync ( void **dev\_ptr, size\_t size, hipMemPool\_t mem\_pool, hipStream\_t stream )
-
-C++ wrappers for allocations from a memory pool.
-
-This section describes wrappers for stream Ordered allocation from memory pool functions of HIP runtime API.
-
-This is an alternate C++ calls for hipMallocFromPoolAsync made available through function overloading.
-
-## See also:
-
-hipMallocFromPoolAsync
-
-Note: APIs in this section are implemented on Linux, under development on Windows.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-## template&lt;class T &gt;
-
-static inline hipError\_t hipMallocAsync ( T **dev\_ptr, size\_t size, hipMemPool\_t mem\_pool, hipStream\_t stream C++ wrappers for allocations from a memory pool on the stream.
-
-This is an alternate C++ calls for hipMallocFromPoolAsync made available through function overloading.
-
-## See also:
-
-hipMallocFromPoolAsync
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-## template&lt;class T &gt;
-
-static inline hipError\_t hipMallocAsync ( T **dev\_ptr, size\_t size, hipStream\_t stream )
-
-C++ wrappers for allocations from a memory pool.
-
-This is an alternate C++ calls for hipMallocFromPoolAsync made available through function overloading.
-
-## See also:
-
-hipMallocFromPoolAsync
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-## template&lt;class T &gt;
-
-static inline hipError\_t hipMallocFromPoolAsync ( T **dev\_ptr, size\_t size, hipMemPool\_t mem\_pool, hipStream\_t stream )
-
-C++ wrappers for allocations from a memory pool.
-
-This is an alternate C++ calls for hipMallocFromPoolAsync made available through function overloading.
-
-## See also:
-
-hipMallocFromPoolAsync
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-)
-
-hipError\_t hipMallocAsync ( void **dev\_ptr, size\_t size, hipStream\_t stream )
-
-Allocates memory with stream ordered semantics.
-
-Inserts a memory allocation operation into stream . A pointer to the allocated memory is returned immediately in *dptr. The allocation must not be accessed until the allocation operation completes. The allocation comes from the memory pool associated with the stream's device.
-
-## See also:
-
-hipMallocFromPoolAsync , hipFreeAsync , hipMemPoolTrimTo , hipMemPoolGetAttribute , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess , hipMemPoolGetAccess
-
-Note: The default memory pool of a device contains device memory from that device.
-
-Note: Basic stream ordering allows future work submitted into the same stream to use the allocation. Stream query, stream synchronize, and HIP events can be used to guarantee that the allocation operation completes before work submitted in a separate stream runs.
-
-Note: During stream capture, this function results in the creation of an allocation node. In this case, the allocation is owned by the graph instead of the memory pool. The memory pool's properties are used to set the node's creation parameters.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- dev\_ptr -[out] Returned device pointer of memory allocation
-- size -[in] Number of bytes to allocate
-- stream -[in] The stream establishing the stream ordering contract and the memory pool to allocate from
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported, hipErrorOutOfMemory hipError\_t hipFreeAsync ( void *dev\_ptr, hipStream\_t stream )
-
-Frees memory with stream ordered semantics.
-
-Inserts a free operation into stream . The allocation must not be used after stream execution reaches the free. After this API returns, accessing the memory from any subsequent work launched on the GPU or querying its pointer attributes results in undefined behavior.
-
-## See also:
-
-hipMallocFromPoolAsync , hipMallocAsync , hipMemPoolTrimTo , hipMemPoolGetAttribute , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess , hipMemPoolGetAccess
-
-Note: During stream capture, this function results in the creation of a free node and must therefore be passed the address of a graph allocation.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- dev\_ptr -[in] Pointer to device memory to free
-- stream -[in] The stream, where the destruciton will occur according to the execution order
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemPoolTrimTo ( hipMemPool\_t mem\_pool, size\_t min\_bytes\_to\_hold )
-
-Releases freed memory back to the OS.
-
-Releases memory back to the OS until the pool contains fewer than min\_bytes\_to\_keep reserved bytes, or there is no more memory that the allocator can safely release. The allocator cannot release OS allocations that back outstanding asynchronous allocations. The OS allocations may happen at different granularity from the user allocations.
-
-## See also:
-
-hipMallocFromPoolAsync , hipMallocAsync , hipFreeAsync , hipMemPoolGetAttribute , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess , hipMemPoolGetAccess
-
-Note: Allocations that have not been freed count as outstanding.
-
-Note: Allocations that have been asynchronously freed but whose completion has not been observed on the host (eg. by a synchronize) can count as outstanding.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- mem\_pool -[in] The memory pool to trim allocations
-- min\_bytes\_to\_hold -[in] If the pool has less than min\_bytes\_to\_hold reserved, then the TrimTo operation is a no-op. Otherwise the memory pool will contain at least min\_bytes\_to\_hold bytes reserved after the operation.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemPoolSetAttribute ( hipMemPool\_t mem\_pool, hipMemPoolAttr attr, void *value )
-
-Sets attributes of a memory pool.
-
-Supported attributes are:
-
-- hipMemPoolAttrReleaseThreshold: (value type = cuuint64\_t) Amount of reserved memory in bytes to hold onto before trying to release memory back to the OS. When more than the release threshold bytes of memory are held by the memory pool, the allocator will try to release memory back to the OS on the next call to stream, event or context synchronize. (default 0)
-- hipMemPoolReuseFollowEventDependencies: (value type = int) Allow hipMallocAsync to use memory asynchronously freed in another stream as long as a stream ordering dependency of the allocating stream on the free action exists. HIP events and null stream interactions can create the required stream ordered dependencies. (default enabled)
-- hipMemPoolReuseAllowOpportunistic: (value type = int) Allow reuse of already completed frees when there is no dependency between the free and allocation. (default enabled)
-- hipMemPoolReuseAllowInternalDependencies: (value type = int) Allow hipMallocAsync to insert new stream dependencies in order to establish the stream ordering required to reuse a piece of memory released by hipFreeAsync (default enabled).
-
-## See also:
-
-hipMallocFromPoolAsync , hipMallocAsync , hipFreeAsync , hipMemPoolGetAttribute , hipMemPoolTrimTo , hipDeviceSetMemPool, hipMemPoolSetAccess , hipMemPoolGetAccess
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- mem\_pool -[in] The memory pool to modify
-- attr -[in] The attribute to modify
-- value -[in] Pointer to the value to assign
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue
-
-hipError\_t hipMemPoolGetAttribute ( hipMemPool\_t mem\_pool, hipMemPoolAttr attr, void *value )
-
-Gets attributes of a memory pool.
-
-Supported attributes are:
-
-- hipMemPoolAttrReleaseThreshold: (value type = cuuint64\_t) Amount of reserved memory in bytes to hold onto before trying to release memory back to the OS. When more than the release threshold bytes of memory are held by the memory pool, the allocator will try to release memory back to the OS on the next call to stream, event or context synchronize. (default 0)
-- hipMemPoolReuseFollowEventDependencies: (value type = int) Allow hipMallocAsync to use memory asynchronously freed in another stream as long as a stream ordering dependency of the allocating stream on the free action exists. HIP events and null stream interactions can create the required stream ordered dependencies. (default enabled)
-- hipMemPoolReuseAllowOpportunistic: (value type = int) Allow reuse of already completed frees when there is no dependency between the free and allocation. (default enabled)
-- hipMemPoolReuseAllowInternalDependencies: (value type = int) Allow hipMallocAsync to insert new stream dependencies in order to establish the stream ordering required to reuse a piece of memory released by hipFreeAsync (default enabled).
-
-## See also:
-
-hipMallocFromPoolAsync , hipMallocAsync , hipFreeAsync , hipMemPoolTrimTo , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess , hipMemPoolGetAccess
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- mem\_pool -[in] The memory pool to get attributes of
-- attr -[in] The attribute to get
-- value -[in] Retrieved value
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemPoolSetAccess ( hipMemPool\_t mem\_pool, const hipMemAccessDesc *desc\_list, size\_t count ) Controls visibility of the specified pool between devices.
-
-## See also:
-
-hipMallocFromPoolAsync , hipMallocAsync , hipFreeAsync , hipMemPoolGetAttribute , hipMemPoolTrimTo , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolGetAccess
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- mem\_pool -[in] Memory pool for acccess change
-- desc\_list -[in] Array of access descriptors. Each descriptor instructs the access to enable for a single gpu
-- count -[in] Number of descriptors in the map array.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemPoolGetAccess ( hipMemAccessFlags *flags, hipMemPool\_t mem\_pool, hipMemLocation *location )
-
-Returns the accessibility of a pool from a device.
-
-Returns the accessibility of the pool's memory from the specified location.
-
-## See also:
-
-hipMallocFromPoolAsync , hipMallocAsync , hipFreeAsync , hipMemPoolGetAttribute , hipMemPoolTrimTo , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- flags -[out] Accessibility of the memory pool from the specified location/device
-- mem\_pool -[in] Memory pool being queried
-- location -[in] Location/device for memory pool access
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemPoolCreate ( hipMemPool\_t *mem\_pool, const hipMemPoolProps *pool\_props )
-
-Creates a memory pool.
-
-Creates a HIP memory pool and returns the handle in mem\_pool . The pool\_props determines the properties of the pool such as the backing device and IPC capabilities.
-
-By default, the memory pool will be accessible from the device it is allocated on.
-
-## See also:
-
-hipMallocFromPoolAsync , hipMallocAsync , hipFreeAsync , hipMemPoolGetAttribute , hipMemPoolDestroy , hipMemPoolTrimTo , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess , hipMemPoolGetAccess
-
-Note: Specifying hipMemHandleTypeNone creates a memory pool that will not support IPC.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- mem\_pool -[out] Contains createed memory pool
-- pool\_props -[in] Memory pool properties
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemPoolDestroy ( hipMemPool\_t mem\_pool )
-
-Destroys the specified memory pool.
-
-If any pointers obtained from this pool haven't been freed or the pool has free operations that haven't completed when hipMemPoolDestroy is invoked, the function will return immediately and the resources associated with the pool will be released automatically once there are no more outstanding allocations.
-
-Destroying the current mempool of a device sets the default mempool of that device as the current mempool for that device.
-
-## See also:
-
-hipMallocFromPoolAsync , hipMallocAsync , hipFreeAsync , hipMemPoolGetAttribute , hipMemPoolCreate hipMemPoolTrimTo , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess , hipMemPoolGetAccess
-
-Note: A device's default memory pool cannot be destroyed.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-mem\_pool -[in] Memory pool for destruction
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t void **dev\_ptr, size\_t size, hipMemPool\_t mem\_pool, hipStream\_t stream
-
-hipMallocFromPoolAsync ( ) Allocates memory from a specified pool with stream ordered semantics.
-
-Inserts an allocation operation into stream . A pointer to the allocated memory is returned immediately in dev\_ptr . The allocation must not be accessed until the allocation operation completes. The allocation comes from the specified memory pool.
-
-Basic stream ordering allows future work submitted into the same stream to use the allocation. Stream query, stream synchronize, and HIP events can be used to guarantee that the allocation operation completes before work submitted in a separate stream runs.
-
-## See also:
-
-hipMallocAsync , hipFreeAsync , hipMemPoolGetAttribute , hipMemPoolCreate hipMemPoolTrimTo , hipDeviceSetMemPool, hipMemPoolSetAttribute , hipMemPoolSetAccess , hipMemPoolGetAccess ,
-
-Note: The specified memory pool may be from a device different than that of the specified stream .
-
-Note: During stream capture, this function results in the creation of an allocation node. In this case, the allocation is owned by the graph instead of the memory pool. The memory pool's properties are used to set the node's creation parameters.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- dev\_ptr -[out] Returned device pointer
-- size -[in] Number of bytes to allocate
-- mem\_pool -[in] The pool to allocate from
-- stream -[in] The stream establishing the stream ordering semantic
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported, hipErrorOutOfMemory hipError\_t hipMemPoolExportToShareableHandle ( void *shared\_handle, hipMemPool\_t mem\_pool, hipMemAllocationHandleType handle\_type, unsigned int flags )
-
-Exports a memory pool to the requested handle type.
-
-Given an IPC capable mempool, create an OS handle to share the pool with another process. A recipient process can convert the shareable handle into a mempool with hipMemPoolImportFromShareableHandle . Individual pointers can then be shared with the hipMemPoolExportPointer and hipMemPoolImportPointer APIs. The implementation of what the shareable handle is and how it can be transferred is defined by the requested handle type.
-
-## See also:
-
-hipMemPoolImportFromShareableHandle
-
-Note: To create an IPC capable mempool, create a mempool with a hipMemAllocationHandleType other than hipMemHandleTypeNone .
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- shared\_handle -[out] Pointer to the location in which to store the requested handle
-- mem\_pool -[in] Pool to export
-- handle\_type -[in] The type of handle to create
-- flags -[in] Must be 0
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorOutOfMemory hipError\_t hipMemPoolImportFromShareableHandle ( hipMemPool\_t *mem\_pool, void *shared\_handle, hipMemAllocationHandleType handle\_type, unsigned int flags )
-
-Imports a memory pool from a shared handle.
-
-Specific allocations can be imported from the imported pool with hipMemPoolImportPointer .
-
-## See also:
-
-hipMemPoolExportToShareableHandle
-
-Note: Imported memory pools do not support creating new allocations. As such imported memory pools may not be used in hipDeviceSetMemPool or hipMallocFromPoolAsync calls.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- mem\_pool -[out] Returned memory pool
-- shared\_handle -[in] OS handle of the pool to open
-- handle\_type -[in] The type of handle being imported
-- flags -[in] Must be 0
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorOutOfMemory hipError\_t hipMemPoolExportPointer ( hipMemPoolPtrExportData *export\_data, void *dev\_ptr )
-
-Export data to share a memory pool allocation between processes.
-
-Constructs export\_data for sharing a specific allocation from an already shared memory pool. The recipient process can import the allocation with the hipMemPoolImportPointer api. The data is not a handle and may be shared through any IPC mechanism.
-
-## See also:
-
-hipMemPoolImportPointer
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- export\_data -[out] Returned export data
-- dev\_ptr -[in] Pointer to memory being exported
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorOutOfMemory hipError\_t hipMemPoolImportPointer ( void **dev\_ptr, hipMemPool\_t mem\_pool, hipMemPoolPtrExportData *export\_data )
-
-Import a memory pool allocation from another process.
-
-Returns in dev\_ptr a pointer to the imported memory. The imported memory must not be accessed before the allocation operation completes in the exporting process. The imported memory must be freed from all importing processes before being freed in the exporting process. The pointer may be freed with hipFree or hipFreeAsync . If hipFreeAsync is used, the free must be completed on the importing process before the free operation on the exporting process.
-
-## See also:
-
-hipMemPoolExportPointer
-
-Note: The hipFreeAsync api may be used in the exporting process before the hipFreeAsync operation completes in its stream as long as the hipFreeAsync in the exporting process specifies a stream with a stream dependency on the importing process's hipFreeAsync .
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- dev\_ptr -[out] Pointer to imported memory
-- mem\_pool -[in] Memory pool from which to import a pointer
-- export\_data -[in] Data specifying the memory to import
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized, hipErrorOutOfMemory
-
-## 19.23.2 Peer to peer
-
-hipError\_t hipDeviceCanAccessPeer ( int *canAccessPeer, int deviceId, int peerDeviceId )
-
-Determine if a device can access a peer's memory.
-
-Returns '1' in canAccessPeer if the specified device is capable of directly accessing memory physically located on peerDevice , or '0' if not.
-
-Returns '0' in canAccessPeer if deviceId == peerDeviceId, and both are valid devices : a device is not a peer of itself.
-
-## Parameters
-
-- canAccessPeer -[out] Returns the peer access capability (0 or 1)
-- deviceId -[in] - device from where memory may be accessed.
-- peerDeviceId -[in] - device where memory is physically located
-
-## Returns
-
-hipSuccess,
-
-## Returns
-
-hipErrorInvalidDevice if deviceId or peerDeviceId are not valid devices hipError\_t hipDeviceEnablePeerAccess ( int peerDeviceId, unsigned int flags )
-
-Enable direct access from current device's virtual address space to memory allocations physically located on a peer device.
-
-Memory which already allocated on peer device will be mapped into the address space of the current device. In addition, all future memory allocations on peerDeviceId will be mapped into the address space of the current device when the memory is allocated. The peer memory remains accessible from the current device until a call to hipDeviceDisablePeerAccess or hipDeviceReset.
-
-Returns hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue,
-
-## Parameters
-
-- peerDeviceId -[in] Peer device to enable direct access to from the current device
-- flags -[in] Reserved for future use, must be zero
-
-## Returns
-
-hipErrorPeerAccessAlreadyEnabled if peer access is already enabled for this device.
-
-## hipError\_t hipDeviceDisablePeerAccess ( int peerDeviceId )
-
-Disable direct access from current device's virtual address space to memory allocations physically located on a peer device.
-
-Returns hipErrorPeerAccessNotEnabled if direct access to memory on peerDevice has not yet been enabled from the current device.
-
-## Parameters
-
-peerDeviceId -[in] Peer device to disable direct access to
-
-## Returns
-
-hipSuccess, hipErrorPeerAccessNotEnabled hipError\_t hipMemGetAddressRange ( hipDeviceptr\_t *pbase, size\_t *psize, hipDeviceptr\_t dptr )
-
-Get information on memory allocations.
-
-## See also:
-
-hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent, hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice
-
-## Parameters
-
-- pbase -[out] - BAse pointer address
-- psize -[out] - Size of allocation
-- dptr--[in] Device Pointer
-
-## Returns
-
-hipSuccess, hipErrorNotFound
-
-## USE\_PEER\_NON\_UNIFIED
-
-## 19.23.3 Memory management
-
-hipError\_t hipPointerSetAttribute ( const void *value, hipPointer\_attribute attribute, hipDeviceptr\_t ptr )
-
-Sets information on the specified pointer.[BETA].
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- value -[in] Sets pointer attribute value
-- attribute -[in] Attribute to set
-- ptr -[in] Pointer to set attributes for
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError\_t hipPointerGetAttributes ( hipPointerAttribute\_t *attributes, const void *ptr )
-
-Returns attributes for the specified pointer.
-
-The output parameter 'attributes' has a member named 'type' that describes what memory the pointer is associated with, such as device memory, host memory, managed memory, and others. Otherwise, the API cannot handle the pointer and returns hipErrorInvalidValue.
-
-## See also:
-
-hipPointerGetAttribute
-
-Note: The unrecognized memory type is unsupported to keep the HIP functionality backward compatibility due to hipMemoryType enum values.
-
-Note: The current behavior of this HIP API corresponds to the CUDA API before version 11.0.
-
-## Parameters
-
-- attributes -[out] attributes for the specified pointer
-- ptr -[in] pointer to get attributes for
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError\_t hipPointerGetAttribute ( void *data, hipPointer\_attribute attribute, hipDeviceptr\_t ptr ) Returns information about the specified pointer.[BETA].
-
-## See also:
-
-hipPointerGetAttributes
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- data -[inout] Returned pointer attribute value
-- attribute -[in] Attribute to query for
-- ptr -[in] Pointer to get attributes for
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError\_t hipDrvPointerGetAttributes ( unsigned int numAttributes, hipPointer\_attribute *attributes, void **data, hipDeviceptr\_t ptr )
-
-Returns information about the specified pointer.[BETA].
-
-## See also:
-
-hipPointerGetAttribute
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- numAttributes -[in] number of attributes to query for
-- attributes -[in] attributes to query for
-- data -[inout] a two-dimensional containing pointers to memory locations where the result of each attribute query will be written to
-- ptr -[in] pointer to get attributes for
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError\_t hipMalloc ( void **ptr, size\_t size )
-
-Allocate memory on the default accelerator.
-
-If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.
-
-## See also:
-
-hipMallocPitch , hipFree , hipMallocArray , hipFreeArray , hipMalloc3D , hipMalloc3DArray , hipHostFree , hipHostMalloc
-
-## Parameters
-
-- ptr -[out] Pointer to the allocated memory
-- size -[in] Requested memory size
-
-## Returns
-
-hipSuccess, hipErrorOutOfMemory, hipErrorInvalidValue (bad context, null *ptr)
-
-hipError\_t hipExtMallocWithFlags ( void **ptr, size\_t sizeBytes, unsigned int flags )
-
-Allocate memory on the default accelerator.
-
-If requested memory size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.
-
-The memory allocation flag should be either hipDeviceMallocDefault, hipDeviceMallocFinegrained, hipDeviceMallocUncached, or hipMallocSignalMemory. If the flag is any other value, the API returns hipErrorInvalidValue.
-
-## See also:
-
-hipMallocPitch , hipFree , hipMallocArray , hipFreeArray , hipMalloc3D , hipMalloc3DArray , hipHostFree , hipHostMalloc
-
-## Parameters
-
-- ptr -[out] Pointer to the allocated memory
-- sizeBytes -[in] Requested memory size
-- flags -[in] Type of memory allocation
-
-## Returns
-
-hipSuccess, hipErrorOutOfMemory, hipErrorInvalidValue (bad context, null *ptr)
-
-hipError\_t hipMallocHost ( void **ptr, size\_t size )
-
-Allocate pinned host memory [Deprecated].
-
-If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.
-
-Warning:
-
-```
-
-
-arning:   This API is deprecated, use hipHostMalloc() instead
-```
-
-## Parameters
-
-- ptr -[out] Pointer to the allocated host pinned memory
-- size -[in] Requested memory size
-
-## Returns
-
-hipSuccess, hipErrorOutOfMemory
-
-## hipError\_t hipMemAllocHost ( void **ptr, size\_t size )
-
-Allocate pinned host memory [Deprecated].
-
-If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.
-
-Warning: This API is deprecated, use hipHostMalloc() instead
-
-## Parameters
-
-- ptr -[out] Pointer to the allocated host pinned memory
-- size -[in] Requested memory size
-
-## Returns
-
-hipSuccess, hipErrorOutOfMemory hipError\_t hipHostMalloc ( void **ptr, size\_t size, unsigned int flags )
-
-Allocates device accessible page locked (pinned) host memory.
-
-This API allocates pinned host memory which is mapped into the address space of all GPUs in the system, the memory can be accessed directly by the GPU device, and can be read or written with much higher bandwidth than pageable memory obtained with functions such as malloc().
-
-Using the pinned host memory, applications can implement faster data transfers for HostToDevice and DeviceToHost. The runtime tracks the hipHostMalloc allocations and can avoid some of the setup required for regular unpinned memory.
-
-When the memory accesses are infrequent, zero-copy memory can be a good choice, for coherent allocation. GPU can directly access the host memory over the CPU/GPU interconnect, without need to copy the data.
-
-Currently the allocation granularity is 4KB for the API.
-
-Developers need to choose proper allocation flag with consideration of synchronization.
-
-If no input for flags, it will be the default pinned memory allocation on the host.
-
-## See also:
-
-hipSetDeviceFlags, hipHostFree
-
-## Parameters
-
-- ptr -[out] Pointer to the allocated host pinned memory
-- size -[in] Requested memory size in bytes If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.
-- flags -[in] Type of host memory allocation. See the description of flags in hipSetDeviceFlags.
-
-## Returns
-
-hipSuccess, hipErrorOutOfMemory hipError\_t hipHostAlloc ( void **ptr, size\_t size, unsigned int flags )
-
-Allocate device accessible page locked host memory [Deprecated].
-
-If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.
-
-Warning: This API is deprecated, use hipHostMalloc() instead
-
-## Parameters
-
-- ptr -[out] Pointer to the allocated host pinned memory
-
-- size -[in] Requested memory size in bytes
-- flags -[in] Type of host memory allocation
-
-## Returns
-
-hipSuccess, hipErrorOutOfMemory hipError\_t hipHostGetDevicePointer ( void **devPtr, void *hstPtr, unsigned int flags )
-
-Get Device pointer from Host Pointer allocated through hipHostMalloc.
-
-## See also:
-
-hipSetDeviceFlags, hipHostMalloc
-
-## Parameters
-
-- devPtr -[out] Device Pointer mapped to passed host pointer
-- hstPtr -[in] Host Pointer allocated through hipHostMalloc
-- flags -[in] Flags to be passed for extension
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorOutOfMemory hipError\_t hipHostGetFlags ( unsigned int *flagsPtr, void *hostPtr )
-
-Return flags associated with host pointer.
-
-## See also:
-
-## hipHostMalloc
-
-## Parameters
-
-- flagsPtr -[out] Memory location to store flags
-- hostPtr -[in] Host Pointer allocated through hipHostMalloc
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipHostRegister ( void *hostPtr, size\_t sizeBytes, unsigned int flags )
-
-Register host memory so it can be accessed from the current device.
-
-## Flags:
-
-- hipHostRegisterDefault Memory is Mapped and Portable
-- hipHostRegisterPortable Memory is considered registered by all contexts. HIP only supports one context so this is always assumed true.
-- hipHostRegisterMapped Map the allocation into the address space for the current device. The device pointer can be obtained with hipHostGetDevicePointer .
-
-After registering the memory, use hipHostGetDevicePointer to obtain the mapped device pointer. On many systems, the mapped device pointer will have a different value than the mapped host pointer. Applications must use the device pointer in device code, and the host pointer in host code.
-
-On some systems, registered memory is pinned. On some systems, registered memory may not be actually be pinned but uses OS or hardware facilities to all GPU access to the host memory.
-
-Developers are strongly encouraged to register memory blocks which are aligned to the host cache-line size. (typically 64-bytes but can be obtains from the CPUID instruction).
-
-If registering non-aligned pointers, the application must take care when register pointers from the same cache line on different devices. HIP's coarse-grained synchronization model does not guarantee correct results if different devices write to different parts of the same cache block - typically one of the writes will 'win' and overwrite data from the other registered memory region.
-
-## See also:
-
-hipHostUnregister , hipHostGetFlags , hipHostGetDevicePointer
-
-## Parameters
-
-- hostPtr -[out] Pointer to host memory to be registered.
-- sizeBytes -[in] Size of the host memory
-- flags -[in] See below.
-
-## Returns
-
-hipSuccess, hipErrorOutOfMemory hipError\_t hipHostUnregister ( void *hostPtr )
-
-Un-register host pointer.
-
-## See also:
-
-hipHostRegister
-
-## Parameters
-
-hostPtr -[in] Host pointer previously registered with hipHostRegister
-
-## Returns
-
-Error code hipError\_t hipMallocPitch ( void **ptr, size\_t *pitch, size\_t width, size\_t height )
-
-Allocates at least width (in bytes) * height bytes of linear memory Padding may occur to ensure alighnment requirements are met for the given row The change in width size due to padding will be returned in *pitch. Currently the alignment is set to 128 bytes
-
-If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned.
-
-## See also:
-
-hipMalloc , hipFree , hipMallocArray , hipFreeArray , hipHostFree , hipMalloc3D , hipMalloc3DArray , hipHostMalloc
-
-## Parameters
-
-- ptr -[out] Pointer to the allocated device memory
-
-- pitch -[out] Pitch for allocation (in bytes)
-- width -[in] Requested pitched allocation width (in bytes)
-- height -[in] Requested pitched allocation height
-
-## Returns
-
-Error code hipError\_t hipMemAllocPitch ( hipDeviceptr\_t *dptr, size\_t *pitch, size\_t widthInBytes, size\_t height, unsigned int elementSizeBytes )
-
-Allocates at least width (in bytes) * height bytes of linear memory Padding may occur to ensure alighnment requirements are met for the given row The change in width size due to padding will be returned in *pitch. Currently the alignment is set to 128 bytes
-
-If size is 0, no memory is allocated, ptr returns nullptr, and hipSuccess is returned. The intended usage of pitch is as a separate parameter of the allocation, used to compute addresses within the 2D array. Given the row and column of an array element of type T, the address is computed as: T pElement = (T*)((char*)BaseAddress + Row * Pitch) + Column;
-
-## See also:
-
-hipMalloc , hipFree , hipMallocArray , hipFreeArray , hipHostFree , hipMalloc3D , hipMalloc3DArray , hipHostMalloc
-
-## Parameters
-
-- dptr -[out] Pointer to the allocated device memory
-- pitch -[out] Pitch for allocation (in bytes)
-- widthInBytes -[in] Requested pitched allocation width (in bytes)
-- height -[in] Requested pitched allocation height
-- elementSizeBytes -[in] The size of element bytes, should be 4, 8 or 16
-
-## Returns
-
-Error code
-
-## hipError\_t hipFree ( void *ptr )
-
-Free memory allocated by the hcc hip memory allocation API. This API performs an implicit hipDeviceSynchronize() call. If pointer is NULL, the hip runtime is initialized and hipSuccess is returned.
-
-## See also:
-
-hipMalloc , hipMallocPitch , hipMallocArray , hipFreeArray , hipHostFree , hipMalloc3D , hipMalloc3DArray , hipHostMalloc
-
-## Parameters
-
-ptr -[in] Pointer to memory to be freed
-
-## Returns
-
-hipSuccess
-
-## Returns
-
-hipErrorInvalidDevicePointer (if pointer is invalid, including host pointers allocated with hipHostMalloc)
-
-## hipError\_t hipFreeHost ( void *ptr )
-
-Free memory allocated by the hcc hip host memory allocation API [Deprecated].
-
-Warning:
-
-```
-
-
-urning:   This API is deprecated, use hipHostFree() instead
-```
-
-## Parameters
-
-ptr -[in] Pointer to memory to be freed
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue (if pointer is invalid, including device pointers allocated with hipMalloc)
-
-## hipError\_t hipHostFree ( void *ptr )
-
-Free memory allocated by the hcc hip host memory allocation API This API performs an implicit hipDeviceSynchronize() call. If pointer is NULL, the hip runtime is initialized and hipSuccess is returned.
-
-## See also:
-
-hipMalloc , hipMallocPitch , hipFree , hipMallocArray , hipFreeArray , hipMalloc3D , hipMalloc3DArray , hipHostMalloc
-
-## Parameters
-
-ptr -[in] Pointer to memory to be freed
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue (if pointer is invalid, including device pointers allocated with hipMalloc)
-
-hipError\_t hipMemcpy ( void *dst, const void *src, size\_t sizeBytes, hipMemcpyKind kind )
-
-Copy data from src to dst.
-
-It supports memory from host to device, device to host, device to device and host to host The src and dst must not overlap.
-
-For hipMemcpy, the copy is always performed by the current device (set by hipSetDevice). For multi-gpu or peerto-peer configurations, it is recommended to set the current device to the device where the src data is physically located. For optimal peer-to-peer copies, the copy device must be able to access the src and dst pointers (by calling hipDeviceEnablePeerAccess with copy agent as the current device and src/dest as the peerDevice argument. if this is not done, the hipMemcpy will still work, but will perform the copy using a staging buffer on the host. Calling hipMemcpy with dst and src pointers that do not match the hipMemcpyKind results in undefined behavior.
-
-## See also:
-
-hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer
-
-## Parameters
-
-- dst -[out] Data being copy to
-- src -[in] Data being copy from
-- sizeBytes -[in] Data size in bytes
-- kind -[in] Kind of transfer
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorUnknown hipError\_t hipMemcpyWithStream ( void *dst, const void *src, size\_t sizeBytes, hipMemcpyKind kind, hipStream\_t stream )
-
-Memory copy on the stream. It allows single or multiple devices to do memory copy on single or multiple streams.
-
-## See also:
-
-hipMemcpy , hipStreamCreate , hipStreamSynchronize , hipStreamDestroy , hipSetDevice, hipLaunchKernelGGL
-
-## Parameters
-
-- dst -[out] Data being copy to
-- src -[in] Data being copy from
-- sizeBytes -[in] Data size in bytes
-- kind -[in] Kind of transfer
-- stream -[in] Valid stream
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorUnknown, hipErrorContextIsDestroyed hipError\_t hipMemcpyHtoD ( hipDeviceptr\_t dst, void *src, size\_t sizeBytes )
-
-Copy data from Host to Device.
-
-## See also:
-
-hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer
-
-## Parameters
-
-- dst -[out] Data being copy to
-- src -[in] Data being copy from
-- sizeBytes -[in] Data size in bytes
-
-## Returns
-
-hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue
-
-hipError\_t hipMemcpyDtoH ( void *dst, hipDeviceptr\_t src, size\_t sizeBytes )
-
-Copy data from Device to Host.
-
-## See also:
-
-hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer
-
-## Parameters
-
-- dst -[out] Data being copy to
-- src -[in] Data being copy from
-- sizeBytes -[in] Data size in bytes
-
-## Returns
-
-hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue hipError\_t hipMemcpyDtoD ( hipDeviceptr\_t dst, hipDeviceptr\_t src, size\_t sizeBytes )
-
-Copy data from Device to Device.
-
-## See also:
-
-hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer
-
-## Parameters
-
-- dst -[out] Data being copy to
-- src -[in] Data being copy from
-- sizeBytes -[in] Data size in bytes
-
-## Returns
-
-hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue hipError\_t hipMemcpyHtoDAsync ( hipDeviceptr\_t dst, void *src, size\_t sizeBytes, hipStream\_t stream )
-
-Copy data from Host to Device asynchronously.
-
-## See also:
-
-hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpyAtoA, hipMemcpyAtoD,
-
-hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer
-
-## Parameters
-
-- dst -[out] Data being copy to
-- src -[in] Data being copy from
-- sizeBytes -[in] Data size in bytes
-- stream -[in] Stream identifier
-
-## Returns
-
-hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue hipError\_t hipMemcpyDtoHAsync ( void *dst, hipDeviceptr\_t src, size\_t sizeBytes, hipStream\_t stream )
-
-Copy data from Device to Host asynchronously.
-
-## See also:
-
-hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer
-
-## Parameters
-
-- dst -[out] Data being copy to
-- src -[in] Data being copy from
-- sizeBytes -[in] Data size in bytes
-- stream -[in] Stream identifier
-
-## Returns
-
-hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue hipError\_t hipMemcpyDtoDAsync ( hipDeviceptr\_t dst, hipDeviceptr\_t src, size\_t sizeBytes, hipStream\_t stream )
-
-Copy data from Device to Device asynchronously.
-
-## See also:
-
-hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer
-
-## Parameters
-
-- dst -[out] Data being copy to
-- src -[in] Data being copy from
-- sizeBytes -[in] Data size in bytes
-- stream -[in] Stream identifier
-
-## Returns
-
-hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue hipError\_t hipModuleGetGlobal ( hipDeviceptr\_t *dptr, size\_t *bytes, hipModule\_t hmod, const char *name )
-
-Returns a global pointer from a module. Returns in *dptr and *bytes the pointer and size of the global of name name located in module hmod. If no variable of that name exists, it returns hipErrorNotFound. Both parameters dptr and bytes are optional. If one of them is NULL, it is ignored and hipSuccess is returned.
-
-## Parameters
-
-- dptr -[out] Returns global device pointer
-- bytes -[out] Returns global size in bytes
-- hmod -[in] Module to retrieve global from
-- name -[in] Name of global to retrieve
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotFound, hipErrorInvalidContext hipError\_t hipGetSymbolAddress ( void **devPtr, const void *symbol )
-
-Gets device pointer associated with symbol on the device.
-
-## Parameters
-
-- devPtr -[out] pointer to the device associated the symbole
-- symbol -[in] pointer to the symbole of the device
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipGetSymbolSize ( size\_t *size, const void *symbol )
-
-Gets the size of the given symbol on the device.
-
-## Parameters
-
-- symbol -[in] pointer to the device symbole
-- size -[out] pointer to the size
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipGetProcAddress ( const char *symbol, void **pfn, int hipVersion, uint64\_t flags, hipDriverProcAddressQueryResult *symbolStatus )
-
-Gets the pointer of requested HIP driver function.
-
-Returns hipSuccess if the returned pfn is addressed to the pointer of found driver function.
-
-## Parameters
-
-- symbol -[in] The Symbol name of the driver function to request.
-- pfn -[out] Output pointer to the requested driver function.
-- hipVersion -[in] The HIP version for the requested driver function symbol. HIP version is defined as 100*version\_major + version\_minor. For example, in HIP 6.1, the hipversion is 601, for the symbol function 'hipGetDeviceProperties', the specified hipVersion 601 is greater or equal to the version 600, the symbol function will be handle properly as backend compatible function.
-- flags -[in] Currently only default flag is suppported.
-- symbolStatus -[out] Optional enumeration for returned status of searching for symbol driver function based on the input hipVersion.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue.
-
-hipError\_t hipMemcpyToSymbol ( const void *symbol, const void *src, size\_t sizeBytes, size\_t offset, hipMemcpyKind kind )
-
-Copies data to the given symbol on the device. Symbol HIP APIs allow a kernel to define a device-side data symbol which can be accessed on the host side. The symbol can be in \_\_constant or device space. Note that the symbol name needs to be encased in the HIP\_SYMBOL macro. This also applies to hipMemcpyFromSymbol, hipGetSymbolAddress, and hipGetSymbolSize. For detailed usage, see the memcpyToSymbol example in the HIP Porting Guide.
-
-## Parameters
-
-- symbol -[out] pointer to the device symbole
-- src -[in] pointer to the source address
-- sizeBytes -[in] size in bytes to copy
-- offset -[in] offset in bytes from start of symbole
-- kind -[in] type of memory transfer
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemcpyToSymbolAsync ( const void *symbol, const void *src, size\_t sizeBytes, size\_t offset, hipMemcpyKind kind, hipStream\_t stream )
-
-Copies data to the given symbol on the device asynchronously.
-
-## Parameters
-
-- symbol -[out] pointer to the device symbole
-- src -[in] pointer to the source address
-- sizeBytes -[in] size in bytes to copy
-- offset -[in] offset in bytes from start of symbole
-- kind -[in] type of memory transfer
-- stream -[in] stream identifier
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue
-
-hipError\_t hipMemcpyFromSymbol ( void *dst, const void *symbol, size\_t sizeBytes, size\_t offset, hipMemcpyKind kind )
-
-Copies data from the given symbol on the device.
-
-## Parameters
-
-- dst -[out] Returns pointer to destinition memory address
-- symbol -[in] Pointer to the symbole address on the device
-- sizeBytes -[in] Size in bytes to copy
-- offset -[in] Offset in bytes from the start of symbole
-- kind -[in] Type of memory transfer
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemcpyFromSymbolAsync ( void *dst, const void *symbol, size\_t sizeBytes, size\_t offset, hipMemcpyKind kind, hipStream\_t stream )
-
-Copies data from the given symbol on the device asynchronously.
-
-## Parameters
-
-- dst -[out] Returns pointer to destinition memory address
-- symbol -[in] pointer to the symbole address on the device
-- sizeBytes -[in] size in bytes to copy
-- offset -[in] offset in bytes from the start of symbole
-- kind -[in] type of memory transfer
-- stream -[in] stream identifier
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemcpyAsync ( void *dst, const void *src, size\_t sizeBytes, hipMemcpyKind kind, hipStream\_t stream )
-
-Copy data from src to dst asynchronously.
-
-For multi-gpu or peer-to-peer configurations, it is recommended to use a stream which is a attached to the device where the src data is physically located. For optimal peer-to-peer copies, the copy device must be able to access the src and dst pointers (by calling hipDeviceEnablePeerAccess with copy agent as the current device and src/dest as the peerDevice argument. if this is not done, the hipMemcpy will still work, but will perform the copy using a staging buffer on the host.
-
-## See also:
-
-hipMemcpy , hipMemcpy2D , hipMemcpyToArray , hipMemcpy2DToArray , hipMemcpyFromArray , hipMemcpy2DFromArray , hipMemcpyArrayToArray, hipMemcpy2DArrayToArray, hipMemcpyToSymbol , hipMemcpyFromSymbol , hipMemcpy2DAsync , hipMemcpyToArrayAsync, hipMemcpy2DToArrayAsync , hipMemcpyFromArrayAsync, hipMemcpy2DFromArrayAsync , hipMemcpyToSymbolAsync , hipMemcpyFromSymbolAsync
-
-Warning: If host or dest are not pinned, the memory copy will be performed synchronously. For best performance, use hipHostMalloc to allocate host memory that is transferred asynchronously.
-
-Warning: on HCC hipMemcpyAsync does not support overlapped H2D and D2H copies. For hipMemcpy, the copy is always performed by the device associated with the specified stream.
-
-## Parameters
-
-- dst -[out] Data being copy to
-- src -[in] Data being copy from
-- sizeBytes -[in] Data size in bytes
-- kind -[in] Type of memory transfer
-- stream -[in] Stream identifier
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorUnknown hipError\_t hipMemset ( void *dst, int value, size\_t sizeBytes )
-
-Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant byte value value.
-
-## Parameters
-
-- dst -[out] Data being filled
-- value -[in] Value to be set
-- sizeBytes -[in] Data size in bytes
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized hipError\_t hipMemsetD8 ( hipDeviceptr\_t dest, unsigned char value, size\_t count )
-
-Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant byte value value.
-
-## Parameters
-
-- dest -[out] Data ptr to be filled
-- value -[in] Value to be set
-- count -[in] Number of values to be set
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized hipError\_t hipMemsetD8Async ( hipDeviceptr\_t dest, unsigned char value, size\_t count, hipStream\_t stream )
-
-Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant byte value value.
-
-hipMemsetD8Async() is asynchronous with respect to the host, so the call may return before the memset is complete. The operation can optionally be associated to a stream by passing a non-zero stream argument. If stream is non-zero, the operation may overlap with operations in other streams.
-
-## Parameters
-
-- dest -[out] Data ptr to be filled
-- value -[in] Constant value to be set
-
-- count -[in] Number of values to be set
-- stream -[in] Stream identifier
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized hipError\_t hipMemsetD16 ( hipDeviceptr\_t dest, unsigned short value, size\_t count )
-
-Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant short value value.
-
-## Parameters
-
-- dest -[out] Data ptr to be filled
-- value -[in] Constant value to be set
-- count -[in] Number of values to be set
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized hipError\_t hipMemsetD16Async ( hipDeviceptr\_t dest, unsigned short value, size\_t count, hipStream\_t stream )
-
-Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant short value value.
-
-hipMemsetD16Async() is asynchronous with respect to the host, so the call may return before the memset is complete. The operation can optionally be associated to a stream by passing a non-zero stream argument. If stream is non-zero, the operation may overlap with operations in other streams.
-
-## Parameters
-
-- dest -[out] Data ptr to be filled
-- value -[in] Constant value to be set
-- count -[in] Number of values to be set
-- stream -[in] Stream identifier
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized hipError\_t hipMemsetD32 ( hipDeviceptr\_t dest, int value, size\_t count )
-
-Fills the memory area pointed to by dest with the constant integer value for specified number of times.
-
-## Parameters
-
-- dest -[out] Data being filled
-- value -[in] Constant value to be set
-- count -[in] Number of values to be set
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized hipError\_t hipMemsetAsync ( void *dst, int value, size\_t sizeBytes, hipStream\_t stream )
-
-Fills the first sizeBytes bytes of the memory area pointed to by dev with the constant byte value value.
-
-hipMemsetAsync() is asynchronous with respect to the host, so the call may return before the memset is complete. The operation can optionally be associated to a stream by passing a non-zero stream argument. If stream is nonzero, the operation may overlap with operations in other streams.
-
-## Parameters
-
-- dst -[out] Pointer to device memory
-
-- value -[in] Value to set for each byte of specified memory
-- sizeBytes -[in] Size in bytes to set
-- stream -[in] Stream identifier
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemsetD32Async ( hipDeviceptr\_t dst, int value, size\_t count, hipStream\_t stream )
-
-Fills the memory area pointed to by dev with the constant integer value for specified number of times.
-
-hipMemsetD32Async() is asynchronous with respect to the host, so the call may return before the memset is complete. The operation can optionally be associated to a stream by passing a non-zero stream argument. If stream is non-zero, the operation may overlap with operations in other streams.
-
-## Parameters
-
-- dst -[out] Pointer to device memory
-- value -[in] Value to set for each byte of specified memory
-- count -[in] Number of values to be set
-- stream -[in] Stream identifier
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemset2D ( void *dst, size\_t pitch, int value, size\_t width, size\_t height )
-
-Fills the memory area pointed to by dst with the constant value.
-
-## Parameters
-
-- dst -[out] Pointer to device memory
-- pitch -[in] Data size in bytes
-- value -[in] Constant value to be set
-- width -[in]
-- height -[in]
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemset2DAsync ( void *dst, size\_t pitch, int value, size\_t width, size\_t height, hipStream\_t stream ) Fills asynchronously the memory area pointed to by dst with the constant value.
-
-## Parameters
-
-- dst -[in] Pointer to 2D device memory
-- pitch -[in] Pitch size in bytes
-- value -[in] Value to be set for each byte of specified memory
-- width -[in] Width of matrix set columns in bytes
-- height -[in] Height of matrix set rows in bytes
-- stream -[in] Stream identifier
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue
-
-hipError\_t hipMemset3D ( hipPitchedPtr pitchedDevPtr, int value, hipExtent extent )
-
-Fills synchronously the memory area pointed to by pitchedDevPtr with the constant value.
-
-## Parameters
-
-- pitchedDevPtr -[in] Pointer to pitched device memory
-- value -[in] Value to set for each byte of specified memory
-- extent -[in] Size parameters for width field in bytes in device memory
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemset3DAsync ( hipPitchedPtr pitchedDevPtr, int value, hipExtent extent, hipStream\_t stream )
-
-Fills asynchronously the memory area pointed to by pitchedDevPtr with the constant value.
-
-## Parameters
-
-- pitchedDevPtr -[in] Pointer to pitched device memory
-- value -[in] Value to set for each byte of specified memory
-- extent -[in] Size parameters for width field in bytes in device memory
-- stream -[in] Stream identifier
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemGetInfo ( size\_t *free, size\_t *total )
-
-Query memory info.
-
-On ROCM, this function gets the actual free memory left on the current device, so supports the cases while running multi-workload (such as multiple processes, multiple threads, and multiple GPUs).
-
-Warning: On Windows, the free memory only accounts for memory allocated by this process and may be optimistic.
-
-## Parameters
-
-- free -[out] Returns free memory on the current device in bytes
-- total -[out] Returns total allocatable memory on the current device in bytes
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError\_t hipMemPtrGetInfo ( void *ptr, size\_t *size )
-
-Get allocated memory size via memory pointer.
-
-This function gets the allocated shared virtual memory size from memory pointer.
-
-## Parameters
-
-- ptr -[in] Pointer to allocated memory
-- size -[out] Returns the allocated memory size in bytes
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue
-
-hipError\_t hipMallocArray ( hipArray\_t *array, const hipChannelFormatDesc *desc, size\_t width, size\_t height, unsigned int flags )
-
-Allocate an array on the device.
-
-## See also:
-
-hipMalloc , hipMallocPitch , hipFree , hipFreeArray , hipHostMalloc , hipHostFree
-
-## Parameters
-
-- array -[out] Pointer to allocated array in device memory
-- desc -[in] Requested channel format
-- width -[in] Requested array allocation width
-- height -[in] Requested array allocation height
-- flags -[in] Requested properties of allocated array
-
-## Returns
-
-hipSuccess, hipErrorOutOfMemory hipError\_t hipArrayCreate ( hipArray\_t *pHandle, const HIP\_ARRAY\_DESCRIPTOR *pAllocateArray )
-
-Create an array memory pointer on the device.
-
-## See also:
-
-hipMallocArray , hipArrayDestroy , hipFreeArray
-
-## Parameters
-
-- pHandle -[out] Pointer to the array memory
-- pAllocateArray -[in] Requested array desciptor
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipArrayDestroy ( hipArray\_t array )
-
-Destroy an array memory pointer on the device.
-
-## See also:
-
-hipArrayCreate , hipArrayDestroy , hipFreeArray
-
-## Parameters
-
-array -[in] Pointer to the array memory
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue
-
-hipError\_t hipArray3DCreate ( hipArray\_t *array, const HIP\_ARRAY3D\_DESCRIPTOR *pAllocateArray )
-
-Create a 3D array memory pointer on the device.
-
-## See also:
-
-hipMallocArray , hipArrayDestroy , hipFreeArray
-
-## Parameters
-
-- array -[out] Pointer to the 3D array memory
-- pAllocateArray -[in] Requested array desciptor
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMalloc3D ( hipPitchedPtr *pitchedDevPtr, hipExtent extent )
-
-Create a 3D memory pointer on the device.
-
-## See also:
-
-hipMallocPitch , hipMemGetInfo , hipFree
-
-## Parameters
-
-- pitchedDevPtr -[out] Pointer to the 3D memory
-- extent -[in] Requested extent
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipFreeArray ( hipArray\_t array )
-
-Frees an array on the device.
-
-## See also:
-
-hipMalloc , hipMallocPitch , hipFree , hipMallocArray , hipHostMalloc , hipHostFree
-
-## Parameters
-
-array -[in] Pointer to array to free
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotInitialized hipError\_t hipMalloc3DArray ( hipArray\_t *array, const struct hipChannelFormatDesc *desc, struct hipExtent extent, unsigned int flags )
-
-Allocate an array on the device.
-
-## See also:
-
-hipMalloc , hipMallocPitch , hipFree , hipFreeArray , hipHostMalloc , hipHostFree
-
-## Parameters
-
-- array -[out] Pointer to allocated array in device memory
-- desc -[in] Requested channel format
-- extent -[in] Requested array allocation width, height and depth
-- flags -[in] Requested properties of allocated array
-
-## Returns
-
-hipSuccess, hipErrorOutOfMemory hipError\_t hipArrayGetInfo ( hipChannelFormatDesc *desc, hipExtent *extent, unsigned int *flags, hipArray\_t array )
-
-Gets info about the specified array.
-
-## See also:
-
-hipArrayGetDescriptor , hipArray3DGetDescriptor
-
-## Parameters
-
-- desc -[out] - Returned array type
-- extent -[out] - Returned array shape. 2D arrays will have depth of zero
-- flags -[out] - Returned array flags
-- array -[in] - The HIP array to get info for
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipErrorInvalidHandle hipError\_t hipArrayGetDescriptor ( HIP\_ARRAY\_DESCRIPTOR *pArrayDescriptor, hipArray\_t array )
-
-Gets a 1D or 2D array descriptor.
-
-## See also:
-
-hipArray3DCreate , hipArray3DGetDescriptor , hipArrayCreate , hipArrayDestroy , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpy3D , hipMemcpy3DAsync , hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoD , hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer, hipMemsetD8 , hipMemsetD16 , hipMemsetD32 , hipArrayGetInfo
-
-## Parameters
-
-- pArrayDescriptor -[out] - Returned array descriptor
-- array -[in] - Array to get descriptor of
-
-## Returns
-
-hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue hipErrorInvalidHandle
-
-hipError\_t hipArray3DGetDescriptor ( HIP\_ARRAY3D\_DESCRIPTOR *pArrayDescriptor, hipArray\_t array )
-
-Gets a 3D array descriptor.
-
-## See also:
-
-hipArray3DCreate , hipArrayCreate , hipArrayDestroy , hipArrayGetDescriptor , hipMemAlloc, hipMemAllocHost , hipMemAllocPitch , hipMemcpy2D , hipMemcpy2DAsync , hipMemcpy2DUnaligned, hipMemcpy3D , hipMemcpy3DAsync , hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH , hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD , hipMemcpyDtoDAsync , hipMemcpyDtoH , hipMemcpyDtoHAsync , hipMemcpyHtoA , hipMemcpyHtoAAsync, hipMemcpyHtoD , hipMemcpyHtoDAsync , hipMemFree, hipMemFreeHost, hipMemGetAddressRange , hipMemGetInfo , hipMemHostAlloc, hipMemHostGetDevicePointer, hipMemsetD8 , hipMemsetD16 , hipMemsetD32 , hipArrayGetInfo
-
-## Parameters
-
-- pArrayDescriptor -[out] - Returned 3D array descriptor
-- array -[in] - 3D array to get descriptor of
-
-## Returns
-
-hipSuccess, hipErrorDeinitialized, hipErrorNotInitialized, hipErrorInvalidContext, hipErrorInvalidValue hipErrorInvalidHandle, hipErrorContextIsDestroyed hipError\_t hipMemcpy2D ( void *dst, size\_t dpitch, const void *src, size\_t spitch, size\_t width, size\_t height, hipMemcpyKind kind )
-
-Copies data between host and device.
-
-## See also:
-
-hipMemcpy , hipMemcpyToArray , hipMemcpy2DToArray , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-- dst -[in] Destination memory address
-- dpitch -[in] Pitch of destination memory
-- src -[in] Source memory address
-- spitch -[in] Pitch of source memory
-- width -[in] Width of matrix transfer (columns in bytes)
-- height -[in] Height of matrix transfer (rows)
-- kind -[in] Type of transfer
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpyParam2D ( const hip\_Memcpy2D *pCopy )
-
-Copies memory for 2D arrays.
-
-## See also:
-
-hipMemcpy , hipMemcpy2D , hipMemcpyToArray , hipMemcpy2DToArray , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-pCopy -[in] Parameters for the memory copy
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpyParam2DAsync ( const hip\_Memcpy2D *pCopy, hipStream\_t stream )
-
-Copies memory for 2D arrays.
-
-## See also:
-
-hipMemcpy , hipMemcpy2D , hipMemcpyToArray , hipMemcpy2DToArray , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-- pCopy -[in] Parameters for the memory copy
-- stream -[in] Stream to use
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpy2DAsync ( void *dst, size\_t dpitch, const void *src, size\_t spitch, size\_t width, size\_t height, hipMemcpyKind kind, hipStream\_t stream )
-
-Copies data between host and device.
-
-## See also:
-
-hipMemcpy , hipMemcpyToArray , hipMemcpy2DToArray , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-- dst -[in] Destination memory address
-- dpitch -[in] Pitch of destination memory
-- src -[in] Source memory address
-- spitch -[in] Pitch of source memory
-- width -[in] Width of matrix transfer (columns in bytes)
-- height -[in] Height of matrix transfer (rows)
-- kind -[in] Type of transfer
-- stream -[in] Stream to use
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpy2DToArray ( hipArray\_t dst, size\_t wOffset, size\_t hOffset, const void *src, size\_t spitch, size\_t width, size\_t height, hipMemcpyKind kind )
-
-Copies data between host and device.
-
-## See also:
-
-hipMemcpy , hipMemcpyToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-- dst -[in] Destination memory address
-- wOffset -[in] Destination starting X offset
-- hOffset -[in] Destination starting Y offset
-- src -[in] Source memory address
-- spitch -[in] Pitch of source memory
-- width -[in] Width of matrix transfer (columns in bytes)
-- height -[in] Height of matrix transfer (rows)
-- kind -[in] Type of transfer
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpy2DToArrayAsync ( hipArray\_t dst, size\_t wOffset, size\_t hOffset, const void *src, size\_t spitch, size\_t width, size\_t height, hipMemcpyKind kind, hipStream\_t stream )
-
-Copies data between host and device.
-
-## See also:
-
-hipMemcpy , hipMemcpyToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-- dst -[in] Destination memory address
-- wOffset -[in] Destination starting X offset
-- hOffset -[in] Destination starting Y offset
-- src -[in] Source memory address
-- spitch -[in] Pitch of source memory
-- width -[in] Width of matrix transfer (columns in bytes)
-- height -[in] Height of matrix transfer (rows)
-
-- kind -[in] Type of transfer
-- stream -[in] Accelerator view which the copy is being enqueued
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpyToArray ( hipArray\_t dst, size\_t wOffset, size\_t hOffset, const void *src, size\_t count, hipMemcpyKind kind )
-
-Copies data between host and device.
-
-## See also:
-
-hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-Warning: This API is deprecated.
-
-## Parameters
-
-- dst -[in] Destination memory address
-- wOffset -[in] Destination starting X offset
-- hOffset -[in] Destination starting Y offset
-- src -[in] Source memory address
-- count -[in] size in bytes to copy
-- kind -[in] Type of transfer
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpyFromArray ( void *dst, hipArray\_const\_t srcArray, size\_t wOffset, size\_t hOffset, size\_t count, hipMemcpyKind kind )
-
-Copies data between host and device.
-
-## See also:
-
-hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-Warning: This API is deprecated.
-
-## Parameters
-
-- dst -[in] Destination memory address
-- srcArray -[in] Source memory address
-- wOffset -[in] Source starting X offset
-
-- hOffset -[in] Source starting Y offset
-- count -[in] Size in bytes to copy
-- kind -[in] Type of transfer
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpy2DFromArray ( void *dst, size\_t dpitch, hipArray\_const\_t src, size\_t wOffset, size\_t hOffset, size\_t width, size\_t height, hipMemcpyKind kind )
-
-Copies data between host and device.
-
-## See also:
-
-hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-- dst -[in] Destination memory address
-- dpitch -[in] Pitch of destination memory
-- src -[in] Source memory address
-- wOffset -[in] Source starting X offset
-- hOffset -[in] Source starting Y offset
-- width -[in] Width of matrix transfer (columns in bytes)
-- height -[in] Height of matrix transfer (rows)
-- kind -[in] Type of transfer
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpy2DFromArrayAsync ( void *dst, size\_t dpitch, hipArray\_const\_t src, size\_t wOffset, size\_t hOffset, size\_t width, size\_t height, hipMemcpyKind kind, hipStream\_t stream )
-
-Copies data between host and device asynchronously.
-
-## See also:
-
-hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-- dst -[in] Destination memory address
-- dpitch -[in] Pitch of destination memory
-- src -[in] Source memory address
-- wOffset -[in] Source starting X offset
-
-- hOffset -[in] Source starting Y offset
-- width -[in] Width of matrix transfer (columns in bytes)
-- height -[in] Height of matrix transfer (rows)
-- kind -[in] Type of transfer
-- stream -[in] Accelerator view which the copy is being enqueued
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpyAtoH ( void *dst, hipArray\_t srcArray, size\_t srcOffset, size\_t count )
-
-Copies data between host and device.
-
-## See also:
-
-hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-- dst -[in] Destination memory address
-- srcArray -[in] Source array
-- srcOffset -[in] Offset in bytes of source array
-- count -[in] Size of memory copy in bytes
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpyHtoA ( hipArray\_t dstArray, size\_t dstOffset, const void *srcHost, size\_t count )
-
-Copies data between host and device.
-
-## See also:
-
-hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-- dstArray -[in] Destination memory address
-- dstOffset -[in] Offset in bytes of destination array
-- srcHost -[in] Source host pointer
-- count -[in] Size of memory copy in bytes
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection
-
-hipError\_t hipMemcpy3D ( const struct hipMemcpy3DParms *p )
-
-Copies data between host and device.
-
-## See also:
-
-hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-p -[in] 3D memory copy parameters
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipMemcpy3DAsync ( const struct hipMemcpy3DParms *p, hipStream\_t stream )
-
-Copies data between host and device asynchronously.
-
-## See also:
-
-hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-- p -[in] 3D memory copy parameters
-- stream -[in] Stream to use
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipDrvMemcpy3D ( const HIP\_MEMCPY3D *pCopy )
-
-Copies data between host and device.
-
-## See also:
-
-hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-pCopy -[in] 3D memory copy parameters
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection hipError\_t hipDrvMemcpy3DAsync ( const HIP\_MEMCPY3D *pCopy, hipStream\_t stream )
-
-Copies data between host and device asynchronously.
-
-## See also:
-
-hipMemcpy , hipMemcpy2DToArray , hipMemcpy2D , hipMemcpyFromArray , hipMemcpyToSymbol , hipMemcpyAsync
-
-## Parameters
-
-- pCopy -[in] 3D memory copy parameters
-- stream -[in] Stream to use
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidPitchValue, hipErrorInvalidDevicePointer, hipErrorInvalidMemcpyDirection template&lt;typename T &gt; hipError\_t hipGetSymbolAddress ( void **devPtr, const T &amp;symbol ) Gets the address of a symbol.
-
-## Parameters
-
-- devPtr -[out] - Returns device pointer associated with symbol.
-- symbol -[in] - Device symbol.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue template&lt;typename T &gt; hipError\_t hipGetSymbolSize ( size\_t *size, const T &amp;symbol ) Gets the size of a symbol.
-
-## Parameters
-
-- size -[out] - Returns the size of a symbol.
-- symbol -[in] - Device symbol address.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue template&lt;typename T &gt;
-
-hipError\_t hipMemcpyToSymbol ( const T &amp;symbol, const void *src, size\_t sizeBytes, size\_t offset, hipMemcpyKind kind )
-
-Copies data to the given symbol on the device.
-
-## See also:
-
-hipMemcpyToSymbol
-
-## Returns
-
-hipSuccess, hipErrorInvalidMemcpyDirection, hipErrorInvalidValue template&lt;typename T &gt;
-
-hipError\_t hipMemcpyToSymbolAsync ( const T &amp;symbol, const void *src, size\_t sizeBytes, size\_t offset, hipMemcpyKind kind, hipStream\_t stream )
-
-Copies data to the given symbol on the device asynchronously on the stream.
-
-## See also:
-
-hipMemcpyToSymbolAsync
-
-## Returns
-
-hipSuccess, hipErrorInvalidMemcpyDirection, hipErrorInvalidValue template&lt;typename T &gt;
-
-hipError\_t hipMemcpyFromSymbol ( void *dst, const T &amp;symbol, size\_t sizeBytes, size\_t offset, hipMemcpyKind kind )
-
-Copies data from the given symbol on the device.
-
-## See also:
-
-hipMemcpyFromSymbol
-
-## Returns
-
-hipSuccess, hipErrorInvalidMemcpyDirection, hipErrorInvalidValue template&lt;typename T &gt;
-
-hipError\_t hipMemcpyFromSymbolAsync ( void *dst, const T &amp;symbol, size\_t sizeBytes, size\_t offset, hipMemcpyKind kind, hipStream\_t stream )
-
-Copies data from the given symbol on the device asynchronously on the stream.
-
-## See also:
-
-hipMemcpyFromSymbolAsync
-
-## Returns
-
-hipSuccess, hipErrorInvalidMemcpyDirection, hipErrorInvalidValue template&lt;class T &gt;
-
-static inline hipError\_t hipMalloc ( T **devPtr, size\_t size )
-
-- : C++ wrapper for hipMalloc
-
-Perform automatic type conversion to eliminate need for excessive typecasting (ie void**)
-
-HIP\_DISABLE\_CPP\_FUNCTIONS macro can be defined to suppress these wrappers. It is useful for applications which need to obtain decltypes of HIP runtime APIs.
-
-## See also:
-
-hipMalloc
-
-## template&lt;class T &gt;
-
-static inline hipError\_t hipHostMalloc ( T **ptr, size\_t size, unsigned int flags = hipHostMallocDefault )
-
-- : C++ wrapper for hipHostMalloc
-
-Provide an override to automatically typecast the pointer type from void**, and also provide a default for the flags.
-
-HIP\_DISABLE\_CPP\_FUNCTIONS macro can be defined to suppress these wrappers. It is useful for applications which need to obtain decltypes of HIP runtime APIs.
-
-## See also:
-
-hipHostMalloc
-
-## 19.23.4 External Resource Interoperability
-
-hipError\_t hipImportExternalSemaphore ( hipExternalSemaphore\_t *extSem\_out, const hipExternalSemaphoreHandleDesc *semHandleDesc )
-
-Imports an external semaphore.
-
-See also:
-
-## Parameters
-
-- extSem\_out -[out] External semaphores to be waited on
-- semHandleDesc -[in] Semaphore import handle descriptor
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError\_t hipSignalExternalSemaphoresAsync ( const hipExternalSemaphore\_t *extSemArray, const hipExternalSemaphoreSignalParams *paramsArray, unsigned int numExtSems, hipStream\_t stream )
-
-Signals a set of external semaphore objects.
-
-## See also:
-
-## Parameters
-
-- extSemArray -[in] External semaphores to be waited on
-- paramsArray -[in] Array of semaphore parameters
-- numExtSems -[in] Number of semaphores to wait on
-- stream -[in] Stream to enqueue the wait operations in
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError\_t hipWaitExternalSemaphoresAsync ( const hipExternalSemaphore\_t *extSemArray, const hipExternalSemaphoreWaitParams *paramsArray, unsigned int numExtSems, hipStream\_t stream )
-
-Waits on a set of external semaphore objects.
-
-See also:
-
-## Parameters
-
-- extSemArray -[in] External semaphores to be waited on
-- paramsArray -[in] Array of semaphore parameters
-- numExtSems -[in] Number of semaphores to wait on
-- stream -[in] Stream to enqueue the wait operations in
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue
-
-## hipError\_t hipDestroyExternalSemaphore ( hipExternalSemaphore\_t extSem )
-
-Destroys an external semaphore object and releases any references to the underlying resource. Any outstanding signals or waits must have completed before the semaphore is destroyed.
-
-## See also:
-
-## Parameters
-
-extSem -[in] handle to an external memory object
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError\_t hipImportExternalMemory ( hipExternalMemory\_t *extMem\_out, const hipExternalMemoryHandleDesc *memHandleDesc )
-
-Imports an external memory object.
-
-## See also:
-
-## Parameters
-
-- extMem\_out -[out] Returned handle to an external memory object
-- memHandleDesc -[in] Memory import handle descriptor
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError\_t hipExternalMemoryGetMappedBuffer ( void **devPtr, hipExternalMemory\_t extMem, const hipExternalMemoryBufferDesc *bufferDesc )
-
-Maps a buffer onto an imported memory object.
-
-## See also:
-
-## Parameters
-
-- devPtr -[out] Returned device pointer to buffer
-- extMem -[in] Handle to external memory object
-- bufferDesc -[in] Buffer descriptor
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue
-
-## hipError\_t hipDestroyExternalMemory ( hipExternalMemory\_t extMem )
-
-Destroys an external memory object.
-
-See also:
-
-## Parameters
-
-extMem -[in] External memory object to be destroyed
-
-## Returns
-
-hipSuccess, hipErrorInvalidDevice, hipErrorInvalidValue hipError\_t hipExternalMemoryGetMappedMipmappedArray ( hipMipmappedArray\_t *mipmap,
-
-hipExternalMemory\_t extMem, const hipExternalMemoryMipmappedArrayDesc *mipmapDesc )
-
-Maps a mipmapped array onto an external memory object.
-
-Returned mipmapped array must be freed using hipFreeMipmappedArray.
-
-## See also:
-
-hipImportExternalMemory , hipFreeMipmappedArray
-
-hipDestroyExternalMemory ,
-
-## Parameters
-
-- mipmap -[out] mipmapped array to return
-- extMem -[in] external memory object handle
-- mipmapDesc -[in] external mipmapped array descriptor
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorInvalidResourceHandle
-
-## 19.24 Register Keyword
-
-The register keyword is deprecated in C++, and is silently ignored by both NVCC and HIP-Clang. You can pass the option -Wdeprecated-register the compiler warning message.
-
-hipExternalMemoryGetMappedBuffer ,
-
-## 19.25 Pragma Unroll
-
-Unroll with a bounds that is known at compile-time is supported. For example:
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        //                                                                                                                                                                                                        #pragma unroll 16 /* hint to compiler to unroll next loop by 16 */
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        }                                                                                                                                                                                                        /*                                                                                                                                                                                                        */
-                                                                                                                                                                                                     
-		                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       //
-                                                                                                                                                                                                       }
-                                                                                                                                                                                                       */
-```
-
-## 19.26 In-Line Assembly
-
-GCN ISA In-line assembly, is supported. For example:
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <img>void                                                                                                                                                                                                        </img>void
-```
-
-We insert the GCN isa into the kernel using asm() Assembler statement. volatile keyword is used so that the optimizers must not change the number of volatile operations or change their order of execution relative to other volatile operations. v\_mac\_f32\_e32 is the GCN instruction, for more information please refer - [AMD GCN3 ISA architecture manual](http://gpuopen.com/compute-product/amd-gcn3-isa-architecture-manual/) Index for the respective operand in the ordered fashion is provided by % followed by position in the list of operands 'v' is the constraint code (for target-specific AMDGPU) for 32-bit VGPR register, for more info please refer - [Supported Constraint Code List for AMDGPU](https://llvm.org/docs/LangRef.html#supported-constraint-code-list) Output Constraints are specified by an '=' prefix as shown above ('=v'). This indicate that assembly will write to this operand, and the operand will then be made available as a return value of the asm expression. Input constraints do not have a prefix - just the constraint code. The constraint string of '0' says to use the assigned register for output as an input as well (it being the 0'th constraint).
-
-## C++ Support The following C++ features are not supported: - Run-time-type information (RTTI) - Try/catch Virtual functions Virtual functions are not supported if objects containing virtual function tables are passed between GPU's of different offload arch's, e.g. between gfx906 and gfx1030. Otherwise virtual functions are supported.
-
-## 19.27 Kernel Compilation
-
-hipcc now supports compiling C++/HIP kernels to binary code objects. The file format for binary is .co which means Code Object. The following command builds the code object using hipcc .
-
-```
-hipcc --genco --offload-arch=[TARGET GPU] [INPUT FILE] -o [OUTPUT FILE]
-
-[TARGET GPU] = GPU architecture
-[INPUT FILE] = Name of the file containing kernels
-[OUTPUT FILE] = Name of the generated code object file
-```
-
-Note: When using binary code objects is that the number of arguments to the kernel is different on HIP-Clang and NVCC path. Refer to the HIP module\_api sample for differences in the arguments to be passed to the kernel.
-
-## 19.28 gfx-arch-specific-kernel
-
-Clang defined '\_\_gfx*\_\_' macros can be used to execute gfx arch specific codes inside the kernel. Refer to the sample in HIP 14\_gpu\_arch sample.
-
-## CHAPTER
-
-## TWENTY
-
-## C++ LANGUAGE SUPPORT
-
-The ROCm platform enables the power of combined C++ and HIP (Heterogeneous-computing Interface for Portability) code. This code is compiled with a clang or clang++ compiler. The official compilers support the HIP platform, or you can use the amdclang or amdclang++ included in the ROCm installation, which are a wrapper for the official versions.
-
-The source code is compiled according to the C++03 , C++11 , C++14 , C++17 , and C++20 standards, along with HIPspecific extensions, but is subject to restrictions. The key restriction is the reduced support of standard library in device code. This is due to the fact that by default a function is considered to run on host, except for constexpr functions, which can run on host and device as well.
-
-## 20.1 Modern C++ support
-
-C++ is considered a modern programming language as of C++11. This section describes how HIP supports these new C++ features.
-
-## 20.1.1 C++11 support
-
-The C++11 standard introduced many new features. These features are supported in HIP host code, with some notable omissions on the device side. The rule of thumb here is that constexpr functions work on device, the rest doesn't. This means that some important functionality like std::function is missing on the device, but unfortunately the standard library wasn't designed with HIP in mind, which means that the support is in a state of 'works as-is'.
-
-Certain features have restrictions and clarifications. For example, any functions using the constexpr qualifier or the new initializer lists , std::move or std::forward features are implicitly considered to have the \_\_host\_\_ and \_\_device\_\_ execution space specifier. Also, constexpr variables that are static members or namespace scoped can be used from both host and device, but only for read access. Dereferencing a static constexpr outside its specified execution space causes an error.
-
-Lambdas are supported, but there are some extensions and restrictions on their usage. For more information, see the Extended lambdas section below.
-
-## 20.1.2 C++14 support
-
-The C++14 language features are supported.
-
-## 20.1.3 C++17 support
-
-All C++17 language features are supported.
-
-## 20.1.4 C++20 support
-
-All C++20 language features are supported, but extensions and restrictions apply. C++20 introduced coroutines and modules, which fundamentally changed how programs are written. HIP doesn't support these features. However, consteval functions can be called from host and device, even if specified for host use only.
-
-The three-way comparison operator (spaceship operator &lt;=&gt; ) works with host and device code.
-
-## 20.2 Extensions and restrictions
-
-In addition to the deviations from the standard, there are some general extensions and restrictions to consider.
-
-## 20.2.1 Global functions
-
-Functions that serve as an entry point for device execution are called kernels and are specified with the \_\_global\_\_ qualifier. To call a kernel function, use the triple chevron operator: &lt;&lt;&lt; &gt;&gt;&gt; . Kernel functions must have a void return type. These functions can't:
-
-- have a constexpr specifier
-- have a parameter of type std::initializer\_list or va\_list
-- use an rvalue reference as a parameter.
-- use parameters having different sizes in host and device code, e.g. long double arguments, or structs containing long double members.
-- use struct-type arguments which have different layout in host and device code.
-
-Kernels can have variadic template parameters, but only one parameter pack, which must be the last item in the template parameter list.
-
-## 20.2.2 Device space memory specifiers
-
-HIP includes device space memory specifiers to indicate whether a variable is allocated in host or device memory and howits memory should be allocated. HIP supports the \_\_device\_\_ , \_\_shared\_\_ , \_\_managed\_\_ , and \_\_constant\_\_ specifiers.
-
-The \_\_device\_\_ and \_\_constant\_\_ specifiers define global variables, which are allocated within global memory on the HIP devices. The only difference is that \_\_constant\_\_ variables can't be changed after allocation. The \_\_shared\_\_ specifier allocates the variable within shared memory, which is available for all threads in a block.
-
-The \_\_managed\_\_ variable specifier creates global variables that are initially undefined and unaddressed within the global symbol table. The HIP runtime allocates managed memory and defines the symbol when it loads the device binary. A managed variable can be accessed in both device and host code.
-
-It's important to know where a variable is stored because it is only available from certain locations. Generally, variables allocated in the host memory are not accessible from the device code, while variables allocated in the device memory are not directly accessible from the host code. Dereferencing a pointer to device memory on the host results in a segmentation fault. Accessing device variables in host code should be done through kernel execution or HIP functions like hipMemCpyToSymbol .
-
-## 20.2.3 Exception handling
-
-An important difference between the host and device code is exception handling. In device code, this control flow isn't available due to the hardware architecture. The device code must use return codes to handle errors.
-
-## 20.2.4 Kernel parameters
-
-There are some restrictions on kernel function parameters. They cannot be passed by reference, because these functions are called from the host but run on the device. Also, a variable number of arguments is not allowed.
-
-## 20.2.5 Classes
-
-Classes work on both the host and device side, but there are some constraints. The static member functions can't be \_\_global\_\_ . Virtual member functions work, but a virtual function must not be called from the host if the parent object was created on the device, or the other way around, because this behavior is undefined. Another minor restriction is that \_\_device\_\_ variables, that are global scoped must have trivial constructors.
-
-## 20.2.6 Polymorphic function wrappers
-
-HIP doesn't support the polymorphic function wrapper std::function , which was introduced in C++11.
-
-## 20.2.7 Extended lambdas
-
-HIP supports Lambdas, which by default work as expected.
-
-Lambdas have implicit host device attributes. This means that they can be executed by both host and device code, and works the way you would expect. To make a lambda callable only by host or device code, users can add \_\_host\_\_ or \_\_device\_\_ attribute. The only restriction is that host variables can only be accessed through copy on the device. Accessing through reference will cause undefined behavior.
-
-## 20.2.8 Inline namespaces
-
-Inline namespaces are supported, but with a few exceptions. The following entities can't be declared in namespace scope within an inline unnamed namespace:
-
-- \_\_managed\_\_ , \_\_device\_\_ , \_\_shared\_\_ and \_\_constant\_\_ variables
-- \_\_global\_\_ function and function templates
-- variables with surface or texture type
-
-## CHAPTER
-
-## TWENTYONE
-
-## HIP MATH API
-
-HIP-Clang supports a set of math operations that are callable from the device. HIP supports most of the device functions supported by NVIDIA CUDA. These are described in the following sections.
-
-## 21.1 Single precision mathematical functions
-
-Following is the list of supported single precision mathematical functions.
-
-Table 1: Single precision mathematical functions
-
-| Function                                                                   | Supported on Host   | Supported on Device   |
-|----------------------------------------------------------------------------|---------------------|-----------------------|
-| float abs(float x) Returns the absolute value of 𝑥                         | ✓                   | ✓                     |
-| float acosf(float x) Returns the arc cosine of 𝑥 .                         | ✓                   | ✓                     |
-| float acoshf(float x) Returns the nonnegative arc hyperbolic cosine of 𝑥 . | ✓                   | ✓                     |
-| float asinf(float x) Returns the arc sine of 𝑥 .                           | ✓                   | ✓                     |
-| float asinhf(float x) Returns the arc hyperbolic sine of 𝑥 .               | ✓                   | ✓                     |
-| float atanf(float x) Returns the arc tangent of 𝑥 .                        | ✓                   | ✓                     |
-
-continues on next page
-
-|                                                                                                                        | Table   | 1 - continued from previous page   |
-|------------------------------------------------------------------------------------------------------------------------|---------|------------------------------------|
-| float atan2f(float x, float y) Returns the arc tangent of the ratio of 𝑥 and 𝑦 .                                       | ✓       | ✓                                  |
-| float atanhf(float x) Returns the arc hyperbolic tangent of 𝑥 .                                                        | ✓       | ✓                                  |
-| float cbrtf(float x) Returns the cube root of 𝑥 .                                                                      | ✓       | ✓                                  |
-| float ceilf(float x) Returns ceiling of 𝑥 .                                                                            | ✓       | ✓                                  |
-| float copysignf(float x, float y) Create value with given magnitude, copying sign of second value.                     | ✓       | ✓                                  |
-| float cosf(float x) Returns the cosine of 𝑥 .                                                                          | ✓       | ✓                                  |
-| float coshf(float x) Returns the hyperbolic cosine of 𝑥 .                                                              | ✓       | ✓                                  |
-| float cospif(float x) Returns the cosine of 𝜋 · 𝑥 .                                                                    | ✓       | ✓                                  |
-| float cyl_bessel_i0f(float x) Returns the value of the regular modified cylindrical Bessel function of order 0 for 𝑥 . |         |                                    |
-
-continues on next page
-
-Table 1 - continued from previous page
-
-| float cyl_bessel_i1f(float x) Returns the value of the regular modified cylindrical Bessel function of order 1 for 𝑥 .   |    |    |
-|--------------------------------------------------------------------------------------------------------------------------|----|----|
-| float erff(float x) Returns the error function of 𝑥 .                                                                    | ✓  | ✓  |
-| float erfcf(float x) Returns the complementary error function of 𝑥 .                                                     | ✓  | ✓  |
-| float erfcinvf(float x) Returns the inverse complementary function of 𝑥 .                                                | ✓  | ✓  |
-| float erfcxf(float x) Returns the scaled complementary error function of 𝑥 .                                             | ✓  | ✓  |
-| float erfinvf(float x) Returns the inverse error function of 𝑥 .                                                         | ✓  | ✓  |
-| float expf(float x) Returns 𝑒 𝑥 .                                                                                        | ✓  | ✓  |
-| float exp10f(float x) Returns 10 𝑥 .                                                                                     | ✓  | ✓  |
-| float exp2f( float x) Returns 2 𝑥 .                                                                                      | ✓  | ✓  |
-| float expm1f(float x) Returns 𝑙𝑛 ( 𝑥 - 1)                                                                                | ✓  | ✓  |
-
-continues on next page
-
-Table
-
-1 - continued from previous page
-
-| float fabsf(float x) Returns the absolute value of x                               | ✓   | ✓   |
-|------------------------------------------------------------------------------------|-----|-----|
-| float fdimf(float x, float y) Returns the positive difference between 𝑥 and 𝑦 .    | ✓   | ✓   |
-| float fdividef(float x, float y) Divide two floating point values.                 | ✓   | ✓   |
-| float floorf(float x) Returns the largest integer less than or equal to 𝑥 .        | ✓   | ✓   |
-| float fmaf(float x, float y, float z) Returns 𝑥 · 𝑦 + 𝑧 as a single operation.     | ✓   | ✓   |
-| float fmaxf(float x, float y) Determine the maximum numeric value of 𝑥 and 𝑦 .     | ✓   | ✓   |
-| float fminf(float x, float y) Determine the minimum numeric value of 𝑥 and 𝑦 .     | ✓   | ✓   |
-| float fmodf(float x, float y) Returns the floating-point remainder of 𝑥/𝑦 .        | ✓   | ✓   |
-| float modff(float x, float* iptr) Break down 𝑥 into fractional and integral parts. | ✓   |     |
-
-continues on next page
-
-Table 1 - continued from previous page
-
-| float frexpf(float x, int* nptr) Extract mantissa and exponent of 𝑥 .                                   | ✓   |
-|---------------------------------------------------------------------------------------------------------|-----|
-| float hypotf(float x, float y) Returns the square root of the sum of squares of 𝑥 and 𝑦 .               | ✓   |
-| int ilogbf(float x) Returns the unbiased integer exponent of 𝑥 .                                        | ✓   |
-| bool isfinite(float x) Determine whether 𝑥 is finite.                                                   | ✓   |
-| bool isinf(float x) Determine whether 𝑥 is infinite.                                                    | ✓   |
-| bool isnan(float x) Determine whether 𝑥 is a NAN .                                                      | ✓   |
-| float j0f(float x) Returns the value of the Bessel function of the first kind of order 0 for 𝑥 .        | ✓   |
-| float j1f(float x) Returns the value of the Bessel function of the first kind of order 1 for 𝑥 .        | ✓   |
-| float jnf(int n, float x) Returns the value of the Bessel function of the first kind of order n for 𝑥 . | ✓   |
-
-continues on next page
-
-Table
-
-1 - continued from previous page
-
-| float ldexpf(float x, int exp) Returns the natural logarithm of the absolute value of the gamma function of 𝑥 .   | ✓   | ✓   |
-|-------------------------------------------------------------------------------------------------------------------|-----|-----|
-| float lgammaf(float x) Returns the natural logarithm of the absolute value of the gamma function of 𝑥 .           | ✓   |     |
-| long int lrintf(float x) Round 𝑥 to nearest integer value.                                                        | ✓   | ✓   |
-| long long int llrintf(float x) Round 𝑥 to nearest integer value.                                                  | ✓   | ✓   |
-| long int lroundf(float x) Round to nearest integer value.                                                         | ✓   | ✓   |
-| long long int llroundf(float x) Round to nearest integer value.                                                   | ✓   | ✓   |
-| float log10f(float x) Returns the base 10 logarithm of 𝑥 .                                                        | ✓   | ✓   |
-| float log1pf(float x) Returns the natural logarithm of 𝑥 +1 .                                                     | ✓   | ✓   |
-| float log2f(float x) Returns the base 2 logarithm of 𝑥 .                                                          | ✓   | ✓   |
-| float logf(float x) Returns the natural logarithm of 𝑥 .                                                          | ✓   | ✓   |
-
-continues on next page
-
-Table 1 - continued from previous page
-
-|                                                                                                                      |    | ✓   |
-|----------------------------------------------------------------------------------------------------------------------|----|-----|
-| float logbf(float x) Returns the floating point representation of the exponent of 𝑥 .                                | ✓  |     |
-| float nanf(const char* tagp) Returns 'Not a Number' value.                                                           |    | ✓   |
-| float nearbyintf(float x) Round 𝑥 to the nearest integer.                                                            | ✓  | ✓   |
-| float nextafterf(float x, float y) Returns next representable single-precision floating-point value after argument.  | ✓  |     |
-| float norm3df(float x, float y, float z) Returns the square root of the sum of squares of 𝑥 , 𝑦 and 𝑧 .              | ✓  | ✓   |
-| float norm4df(float x, float y, float z, float w) Returns the square root of the sum of squares of 𝑥 , 𝑦 , 𝑧 and 𝑤 . | ✓  | ✓   |
-| float normcdff(float y) Returns the standard normal cumulative distribution function.                                | ✓  | ✓   |
-| float normcdfinvf(float y) Returns the inverse of the standard normal cumulative distribution function.              | ✓  | ✓   |
-| float normf(int dim, const float *a) Returns the square root of the sum of squares of any number of coordinates.     | ✓  | ✓   |
-
-continues on next page
-
-|                                                                                                                   | Table   | 1 - continued from previous page   |
-|-------------------------------------------------------------------------------------------------------------------|---------|------------------------------------|
-| float powf(float x, float y) Returns 𝑥 𝑦 .                                                                        | ✓       | ✓                                  |
-| float powif(float base, int iexp) Returns the value of first argument to the power of second argument.            | ✓       | ✓                                  |
-| float remainderf(float x, float y) Returns single-precision floating-point remainder.                             | ✓       | ✓                                  |
-| float remquof(float x, float y, int* quo) Returns single-precision floating-point remainder and part of quotient. | ✓       | ✓                                  |
-| float roundf(float x) Round to nearest integer value in floating-point.                                           | ✓       | ✓                                  |
-| float rcbrtf(float x) Returns the reciprocal cube root function.                                                  | ✓       | ✓                                  |
-| float rhypotf(float x, float y) Returns one over the square root of the sum of squares of two arguments.          | ✓       | ✓                                  |
-| float rintf(float x) Round input to nearest integer value in floating-point.                                      | ✓       | ✓                                  |
-
-continues on next page
-
-Table
-
-1 - continued from previous page
-
-| float rnorm3df(float x, float y, float z) Returns one over the square root of the sum of squares of three coordinates of the argument.         | ✓   | ✓   |
-|------------------------------------------------------------------------------------------------------------------------------------------------|-----|-----|
-| float rnorm4df(float x, float y, float z, float w) Returns one over the square root of the sum of squares of four coordinates of the argument. | ✓   | ✓   |
-| float rnormf(int dim, const float *a) Returns the reciprocal of square root of the sum of squares of any number of coordinates.                | ✓   | ✓   |
-| float scalblnf(float x, long int n) Scale 𝑥 by 2 𝑛 .                                                                                           | ✓   | ✓   |
-| float scalbnf(float x, int n) Scale 𝑥 by 2 𝑛 .                                                                                                 | ✓   | ✓   |
-| bool signbit(float x) Return the sign bit of 𝑥 .                                                                                               | ✓   | ✓   |
-| float sinf(float x) Returns the sine of 𝑥 .                                                                                                    | ✓   | ✓   |
-| float sinhf(float x) Returns the hyperbolic sine of 𝑥 .                                                                                        | ✓   | ✓   |
-| float sinpif(float x) Returns the hyperbolic sine of 𝜋 · 𝑥 .                                                                                   | ✓   | ✓   |
-
-continues on next page
-
-Table
-
-1 - continued from previous page
-
-| void sincosf(float x, float *sptr, float *cptr) Returns the sine and cosine of 𝑥 .                | ✓   | ✓   |
-|---------------------------------------------------------------------------------------------------|-----|-----|
-| void sincospif(float x, float *sptr, float *cptr) Returns the sine and cosine of 𝜋 · 𝑥 .          | ✓   | ✓   |
-| float sqrtf(float x) Returns the square root of 𝑥 .                                               | ✓   | ✓   |
-| float rsqrtf(float x) Returns the reciprocal of the square root of 𝑥 .                            |     | ✓   |
-| float tanf(float x) Returns the tangent of 𝑥 .                                                    | ✓   | ✓   |
-| float tanhf(float x) Returns the hyperbolic tangent of 𝑥 .                                        | ✓   | ✓   |
-| float tgammaf(float x) Returns the gamma function of 𝑥 .                                          | ✓   | ✓   |
-| float truncf(float x) Truncate 𝑥 to the integral part.                                            | ✓   | ✓   |
-| float y0f(float x) Returns the value of the Bessel function of the second kind of order 0 for 𝑥 . | ✓   | ✓   |
-| float y1f(float x) Returns the value of the Bessel function of the second kind of order 1 for 𝑥 . | ✓   | ✓   |
-
-continues on next page
-
-```
-                                                                                                                                                                                                        \
-    float  ynf(int  n,  float  x)
-    Returns the value of the Bessel
-    function of the second kind of order
-    n for x.
-```
-
-Table 1 - continued from previous page
-
-## 21.2 Double precision mathematical functions
-
-Following is the list of supported double precision mathematical functions.
-
-Table 2: Double precision mathematical functions
-
-| Function                                                                           | Supported on Host   | Supported on Device   |
-|------------------------------------------------------------------------------------|---------------------|-----------------------|
-| double abs(double x) Returns the absolute value of 𝑥                               | ✓                   | ✓                     |
-| double acos(double x) Returns the arc cosine of 𝑥 .                                | ✓                   | ✓                     |
-| double acosh(double x) Returns the nonnegative arc hyperbolic cosine of 𝑥 .        | ✓                   | ✓                     |
-| double asin(double x) Returns the arc sine of 𝑥 .                                  | ✓                   | ✓                     |
-| double asinh(double x) Returns the arc hyperbolic sine of 𝑥 .                      | ✓                   | ✓                     |
-| double atan(double x) Returns the arc tangent of 𝑥 .                               | ✓                   | ✓                     |
-| double atan2(double x, double y) Returns the arc tangent of the ratio of 𝑥 and 𝑦 . | ✓                   | ✓                     |
-
-continues on next page
-
-Table 2 - continued from previous page
-
-| double atanh(double x) Returns the arc hyperbolic tangent of 𝑥 .                                                        | ✓   | ✓   |
-|-------------------------------------------------------------------------------------------------------------------------|-----|-----|
-| double cbrt(double x) Returns the cube root of 𝑥 .                                                                      | ✓   | ✓   |
-| double ceil(double x) Returns ceiling of 𝑥 .                                                                            | ✓   | ✓   |
-| double copysign(double x, double y) Create value with given magnitude, copying sign of second value.                    | ✓   | ✓   |
-| double cos(double x) Returns the cosine of 𝑥 .                                                                          | ✓   | ✓   |
-| double cosh(double x) Returns the hyperbolic cosine of 𝑥 .                                                              | ✓   | ✓   |
-| double cospi(double x) Returns the cosine of 𝜋 · 𝑥 .                                                                    | ✓   | ✓   |
-| double cyl_bessel_i0(double x) Returns the value of the regular modified cylindrical Bessel function of order 0 for 𝑥 . |     |     |
-| double cyl_bessel_i1(double x) Returns the value of the regular modified cylindrical Bessel function of order 1 for     | 𝑥 . |     |
-| double erf(double x) Returns the error function of 𝑥 .                                                                  | ✓   | ✓   |
-
-continues on next page
-
-Table 2 - continued from previous page
-
-| double erfc(double x) Returns the complementary error function of 𝑥 .             | ✓   | ✓   |
-|-----------------------------------------------------------------------------------|-----|-----|
-| double erfcinv(double x) Returns the inverse complementary function of 𝑥 .        | ✓   | ✓   |
-| double erfcx(double x) Returns the scaled complementary error function of 𝑥 .     | ✓   | ✓   |
-| double erfinv(double x) Returns the inverse error function of 𝑥 .                 | ✓   | ✓   |
-| double exp(double x) Returns 𝑒 𝑥 .                                                | ✓   | ✓   |
-| double exp10(double x) Returns 10 𝑥 .                                             | ✓   | ✓   |
-| double exp2( double x) Returns 2 𝑥 .                                              | ✓   | ✓   |
-| double expm1(double x) Returns 𝑙𝑛 ( 𝑥 - 1)                                        | ✓   | ✓   |
-| double fabs(double x) Returns the absolute value of x                             | ✓   | ✓   |
-| double fdim(double x, double y) Returns the positive difference between 𝑥 and 𝑦 . | ✓   | ✓   |
-
-continues on next page
-
-Table 2 - continued from previous page
-
-| double floor(double x) Returns the largest integer less than or equal to 𝑥 .                | ✓   | ✓   |
-|---------------------------------------------------------------------------------------------|-----|-----|
-| double fma(double x, double y, double z) Returns 𝑥 · 𝑦 + 𝑧 as a single operation.           | ✓   | ✓   |
-| double fmax(double x, double y) Determine the maximum numeric value of 𝑥 and 𝑦 .            | ✓   | ✓   |
-| double fmin(double x, double y) Determine the minimum numeric value of 𝑥 and 𝑦 .            | ✓   | ✓   |
-| double fmod(double x, double y) Returns the floating-point remainder of 𝑥/𝑦 .               | ✓   | ✓   |
-| double modf(double x, double* iptr) Break down 𝑥 into fractional and integral parts.        | ✓   |     |
-| double frexp(double x, int* nptr) Extract mantissa and exponent of 𝑥 .                      | ✓   |     |
-| double hypot(double x, double y) Returns the square root of the sum of squares of 𝑥 and 𝑦 . | ✓   | ✓   |
-| int ilogb(double x) Returns the unbiased integer exponent of 𝑥 .                            | ✓   | ✓   |
-
-continues on next page
-
-Table 2 - continued from previous page
-
-| bool isfinite(double x) Determine whether 𝑥 is finite.                                                           | ✓   | ✓   |
-|------------------------------------------------------------------------------------------------------------------|-----|-----|
-| bool isin(double x) Determine whether 𝑥 is infinite.                                                             | ✓   | ✓   |
-| bool isnan(double x) Determine whether 𝑥 is a NAN .                                                              | ✓   | ✓   |
-| double j0(double x) Returns the value of the Bessel function of the first kind of order 0 for 𝑥 .                | ✓   | ✓   |
-| double j1(double x) Returns the value of the Bessel function of the first kind of order 1 for 𝑥 .                | ✓   | ✓   |
-| double jn(int n, double x) Returns the value of the Bessel function of the first kind of order n for 𝑥 .         | ✓   | ✓   |
-| double ldexp(double x, int exp) Returns the natural logarithm of the absolute value of the gamma function of 𝑥 . | ✓   | ✓   |
-| double lgamma(double x) Returns the natural logarithm of the absolute value of the gamma function of 𝑥 .         | ✓   |     |
-| long int lrint(double x) Round 𝑥 to nearest integer value.                                                       | ✓   | ✓   |
-
-continues on next page
-
-Table 2 - continued from previous page
-
-| long long int llrint(double x) Round 𝑥 to nearest integer value.                       | ✓   | ✓   |
-|----------------------------------------------------------------------------------------|-----|-----|
-| long int lround(double x) Round to nearest integer value.                              | ✓   | ✓   |
-| long long int llround(double x) Round to nearest integer value.                        | ✓   | ✓   |
-| double log10(double x) Returns the base 10 logarithm of 𝑥 .                            | ✓   | ✓   |
-| double log1p(double x) Returns the natural logarithm of 𝑥 +1 .                         | ✓   | ✓   |
-| double log2(double x) Returns the base 2 logarithm of 𝑥 .                              | ✓   | ✓   |
-| double log(double x) Returns the natural logarithm of 𝑥 .                              | ✓   | ✓   |
-| double logb(double x) Returns the floating point representation of the exponent of 𝑥 . | ✓   | ✓   |
-| double nan(const char* tagp) Returns 'Not a Number' value.                             |     | ✓   |
-| double nearbyint(double x) Round 𝑥 to the nearest integer.                             | ✓   | ✓   |
-
-continues on next page
-
-Table 2 - continued from previous page
-
-|                                                                                                                          |    | ✓   |
-|--------------------------------------------------------------------------------------------------------------------------|----|-----|
-| double nextafter(double x, double y) Returns next representable double-precision floating-point value after argument.    | ✓  |     |
-| double norm3d(double x, double y, double z) Returns the square root of the sum of squares of 𝑥 , 𝑦 and 𝑧 .               | ✓  | ✓   |
-| double norm4d(double x, double y, double z, double w) Returns the square root of the sum of squares of 𝑥 , 𝑦 , 𝑧 and 𝑤 . | ✓  | ✓   |
-| double normcdf(double y) Returns the standard normal cumulative distribution function.                                   | ✓  | ✓   |
-| double normcdfinv(double y) Returns the inverse of the standard normal cumulative distribution function.                 | ✓  | ✓   |
-| double norm(int dim, const double *a) Returns the square root of the sum of squares of any number of coordinates.        | ✓  | ✓   |
-| double pow(double x, double y) Returns 𝑥 𝑦 .                                                                             | ✓  | ✓   |
-| double powi(double base, int iexp) Returns the value of first argument to the power of second argument.                  | ✓  | ✓   |
-
-continues on next page
-
-|                                                                                                                                                    | Table   | 2 - continued from previous page   |
-|----------------------------------------------------------------------------------------------------------------------------------------------------|---------|------------------------------------|
-| double remainder(double x, double y) Returns double-precision floating-point remainder.                                                            | ✓       | ✓                                  |
-| double remquo(double x, double y, int* quo) Returns double-precision floating-point remainder and part quotient.                                   | ✓       | of                                 |
-| double round(double x) Round to nearest integer value in floating-point.                                                                           | ✓       | ✓                                  |
-| double rcbrt(double x) Returns the reciprocal cube root function.                                                                                  | ✓       | ✓                                  |
-| double rhypot(double x, double y) Returns one over the square root of the sum of squares of two arguments.                                         | ✓       | ✓                                  |
-| double rint(double x) Round input to nearest integer value in floating-point.                                                                      | ✓       | ✓                                  |
-| double rnorm3d(double x, double y, double z) Returns one over the square root of the sum of squares of three coordinates of the argument.          | ✓       | ✓                                  |
-| double rnorm4d(double x, double y, double z, double w) Returns one over the square root of the sum of squares of four coordinates of the argument. | ✓       | ✓                                  |
-
-continues on next page
-
-Table 2 - continued from previous page
-
-|                                                                                                                                  | ✓   |    |
-|----------------------------------------------------------------------------------------------------------------------------------|-----|----|
-| double rnorm(int dim, const double *a) Returns the reciprocal of square root of the sum of squares of any number of coordinates. |     | ✓  |
-| double scalbln(double x, long int n) Scale 𝑥 by 2 𝑛 .                                                                            | ✓   | ✓  |
-| double scalbn(double x, int n) Scale 𝑥 by 2 𝑛 .                                                                                  | ✓   | ✓  |
-| bool signbit(double x) Return the sign bit of 𝑥 .                                                                                | ✓   | ✓  |
-| double sin(double x) Returns the sine of 𝑥 .                                                                                     | ✓   | ✓  |
-| double sinh(double x) Returns the hyperbolic sine of 𝑥 .                                                                         | ✓   | ✓  |
-| double sinpi(double x) Returns the hyperbolic sine of 𝜋 · 𝑥 .                                                                    | ✓   | ✓  |
-| void sincos(double x, double *sptr, double *cptr) Returns the sine and cosine of 𝑥 .                                             | ✓   | ✓  |
-| void sincospi(double x, double *sptr, double *cptr) Returns the sine and cosine of 𝜋 · 𝑥 .                                       | ✓   | ✓  |
-| double sqrt(double x) Returns the square root of 𝑥 .                                                                             | ✓   | ✓  |
-
-continues on next page
-
-Table 2 - continued from previous page
-
-| double rsqrt(double x) Returns the reciprocal of the square root of 𝑥 .                                   | ✓   |
-|-----------------------------------------------------------------------------------------------------------|-----|
-| double tan(double x) Returns the tangent of 𝑥 .                                                           | ✓   |
-| double tanh(double x) Returns the hyperbolic tangent of 𝑥 .                                               | ✓   |
-| double tgamma(double x) Returns the gamma function of 𝑥 .                                                 | ✓   |
-| double trunc(double x) Truncate 𝑥 to the integral part.                                                   | ✓   |
-| double y0(double x) Returns the value of the Bessel function of the second kind of order 0 for 𝑥 .        | ✓   |
-| double y1(double x) Returns the value of the Bessel function of the second kind of order 1 for 𝑥 .        | ✓   |
-| double yn(int n, double x) Returns the value of the Bessel function of the second kind of order n for 𝑥 . | ✓   |
-
-## 21.3 Integer intrinsics
-
-Following is the list of supported integer intrinsics. Note that intrinsics are supported on device only.
-
-Table 3: Integer intrinsics mathematical functions
-
-## Function
-
-unsigned int \_\_brev(unsigned int x) Reverse the bit order of a 32 bit unsigned integer.
-
-unsigned long long int \_\_brevll(unsigned long long int x) Reverse the bit order of a 64 bit unsigned integer.
-
-unsigned int \_\_byte\_perm(unsigned int x, unsigned int y, unsigned int z) Return selected bytes from two 32-bit unsigned integers.
-
-unsigned int \_\_clz(int x) Return the number of consecutive high-order zero bits in 32 bit integer.
-
-unsigned int \_\_clzll(long long int x) Return the number of consecutive high-order zero bits in 64 bit integer.
-
-unsigned int \_\_ffs(int x) Find the position of least significant bit set to 1 in a 32 bit integer.
-
-unsigned int \_\_ffsll(long long int x) Find the position of least significant bit set to 1 in a 64 bit signed integer.
-
-unsigned int \_\_fns32(unsigned long long mask, unsigned int base, int offset) Find the position of the n-th set to 1 bit in a 32-bit integer.
-
-unsigned int \_\_fns64(unsigned long long int mask, unsigned int base, int offset) Find the position of the n-th set to 1 bit in a 64-bit integer.
-
-unsigned int \_\_funnelshift\_l(unsigned int lo, unsigned int hi, unsigned int shift) Concatenate ℎ𝑖 and 𝑙𝑜 , shift left by shift &amp; 31 bits, return the most significant 32 bits.
-
-unsigned int \_\_funnelshift\_lc(unsigned int lo, unsigned int hi, unsigned int shift) Concatenate ℎ𝑖 and 𝑙𝑜 , shift left by min(shift, 32) bits, return the most significant 32 bits.
-
-unsigned int \_\_funnelshift\_r(unsigned int lo, unsigned int hi, unsigned int shift) Concatenate ℎ𝑖 and 𝑙𝑜 , shift right by shift &amp; 31 bits, return the least significant 32 bits. 226 Chapter 21. HIP math API
-
-The HIP-Clang implementation of \_\_ffs() and \_\_ffsll() contains code to add a constant +1 to produce the ffs result format. For the cases where this overhead is not acceptable and programmer is willing to specialize for the platform, HIP-Clang provides \_\_lastbit\_u32\_u32(unsigned int input) and \_\_lastbit\_u32\_u64(unsigned long long int input) . The index returned by \_\_lastbit\_ instructions starts at -1, while for ffs the index starts at 0.
-
-## 21.4 Floating-point Intrinsics
-
-Following is the list of supported floating-point intrinsics. Note that intrinsics are supported on device only.
-
-Note: Only the nearest even rounding mode supported on AMD GPUs by defaults. The \_rz , \_ru and \_rd suffixed intrinsic functions are existing in HIP AMD backend, if the OCML\_BASIC\_ROUNDED\_OPERATIONS macro is defined.
-
-Table 4: Single precision intrinsics mathematical functions
-
-Function float \_\_cosf(float x) Returns the fast approximate cosine of 𝑥 . float \_\_exp10f(float x) Returns the fast approximate for 10 x . float \_\_expf(float x) Returns the fast approximate for e x . float \_\_fadd\_rn(float x, float y) Add two floating-point values in round-to-nearest-even mode. float \_\_fdiv\_rn(float x, float y) Divide two floating point values in round-to-nearest-even mode. float \_\_fmaf\_rn(float x, float y, float z) Returns x × y + z as a single operation in round-to-nearest-even mode. float \_\_fmul\_rn(float x, float y) Multiply two floating-point values in round-to-nearest-even mode. float \_\_frcp\_rn(float x, float y) Returns 1 / x in round-to-nearest-even mode. float \_\_frsqrt\_rn(float x) Returns 1 / x in round-to-nearest-even mode. float \_\_fsqrt\_rn(float x) Returns x in round-to-nearest-even mode. float \_\_fsub\_rn(float x, float y) Subtract two floating-point values in round-to-nearest-even mode. float \_\_log10f(float x) Returns the fast approximate for base 10 logarithm of 𝑥 . 228 Chapter 21. HIP math API
-
-Table 5: Double precision intrinsics mathematical functions
-
-Function double \_\_dadd\_rn(double x, double y) Add two floating-point values in round-to-nearest-even mode. double \_\_ddiv\_rn(double x, double y) Divide two floating-point values in round-to-nearest-even mode. double \_\_dmul\_rn(double x, double y) Multiply two floating-point values in round-to-nearest-even mode. double \_\_drcp\_rn(double x, double y) Returns 1 / x in round-to-nearest-even mode. double \_\_dsqrt\_rn(double x) Returns x in round-to-nearest-even mode. double \_\_dsub\_rn(double x, double y) Subtract two floating-point values in round-to-nearest-even mode. double \_\_fma\_rn(double x, double y, double z) Returns x × y + z as a single operation in round-to-nearest-even mode.
-
-## CHAPTER
-
-## TWENTYTWO
-
-## TABLE COMPARING SYNTAX FOR DIFFERENT COMPUTE APIS
-
-| Term                   | CUDA                | HIP                                        | OpenCL                 |
-|------------------------|---------------------|--------------------------------------------|------------------------|
-| Device                 | int deviceId        | int deviceId                               | cl_device              |
-| Queue                  | cudaStream_t        | hipStream_t                                | cl_command_queue       |
-| Event                  | cudaEvent_t         | hipEvent_t                                 | cl_event               |
-| Memory                 | void *              | void *                                     | cl_mem                 |
-|                        | grid                | grid                                       | NDRange                |
-|                        | block               | block                                      | work-group             |
-|                        | thread              | thread                                     | work-item              |
-|                        | warp                | warp                                       | sub-group              |
-| Thread-index           | threadIdx.x         | threadIdx.x                                | get_local_id(0)        |
-| Block-index            | blockIdx.x          | blockIdx.x                                 | get_group_id(0)        |
-| Block-dim              | blockDim.x          | blockDim.x                                 | get_local_size(0)      |
-| Grid-dim               | gridDim.x           | gridDim.x                                  | get_num_groups(0)      |
-| Device Kernel          | __global__          | __global__                                 | __kernel               |
-| Device Function        | __device__          | __device__                                 | Implied in device com  |
-| Host Function          | __host_ (default)   | __host_ (default)                          | Implied in host compil |
-| Host + Device Function | __host__ __device__ | __host__ __device__                        | No equivalent          |
-| Kernel Launch          | <<< >>>             | hipLaunchKernel / hipLaunchKernelGGL / <<< | clEnqueueNDRangeK      |
-| Global Memory          | __global__          | __global__                                 | __global               |
-| Group Memory           | __shared__          | __shared__                                 | __local                |
-| Constant               | __constant__        | __constant__                               | __constant             |
-|                        | __syncthreads       | __syncthreads                              | barrier(CLK_LOCAL      |
-| Atomic Builtins        | atomicAdd           | atomicAdd                                  | atomic_add             |
-| Precise Math           | cos(f)              | cos(f)                                     | cos(f)                 |
-| Fast Math              | __cos(f)            | __cos(f)                                   | native_cos(f)          |
-| Vector                 | float4              | float4                                     | float4                 |
-
-## 22.1 Notes
-
-The indexing functions (starting with thread-index ) show the terminology for a 1D grid. Some APIs use reverse order of xyz / 012 indexing for 3D grids.
-
-## CHAPTER
-
-## TWENTYTHREE
-
-## HIP COOPERATIVE GROUPS API
-
-## 23.1 Cooperative kernel launches
-
-The following host-side functions are used for cooperative kernel launches.
-
-| Warning:                                                                                    | Warning:                                                                                    | doxygenfunction:                                                                            | doxygenfunction:                                                                            | doxygenfunction:                                                                            | Cannot                                                                                      | find function                                                                               | 'hipLaunchCooperativeKernel' Documentation'                                                 | 'hipLaunchCooperativeKernel' Documentation'                                                 |                                                                                             |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
-| in                                                                                          | doxygen                                                                                     | xml                                                                                         | output                                                                                      | for project                                                                                 | 'HIP                                                                                        | 6.1.40092                                                                                   | from                                                                                        | directory:                                                                                  |                                                                                             |
-| /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- |
-| 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      |
-
-| Warning:                                                                                    | Warning:                                                                                    | doxygenfunction: project                                                                    | doxygenfunction: project                                                                    | doxygenfunction: project                                                                    | Cannot                                                                                      | Cannot                                                                                      | find function                                                                               | 'hipLaunchCooperativeKernel'                                                                | 'hipLaunchCooperativeKernel'                                                                |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
-| in                                                                                          | doxygen                                                                                     | xml                                                                                         | output                                                                                      | for                                                                                         |                                                                                             | 'HIP                                                                                        | 6.1.40092                                                                                   | Documentation'                                                                              | from                                                                                        |
-| /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- |
-| 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      |
-
-| Warning:                                                                                    | Warning:                                                                                    | doxygenfunction:                                                                            | doxygenfunction:                                                                            | doxygenfunction:                                                                            | Cannot                                                                                      | find                                                                                        | function                                                                                    | 'hipLaunchCooperativeKernelMultiDe-                                                         | 'hipLaunchCooperativeKernelMultiDe-                                                         | 'hipLaunchCooperativeKernelMultiDe-                                                         |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
-| vice'                                                                                       | in                                                                                          | doxygen                                                                                     | xml                                                                                         | output for                                                                                  | project                                                                                     | 'HIP                                                                                        | 6.1.40092                                                                                   | Documentation'                                                                              | from                                                                                        | directory:                                                                                  |
-| /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- |
-| 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      |
-
-| Warning: in                                                                                 | doxygenfunction: Cannot find xml output for project 'HIP                                    | doxygenfunction: Cannot find xml output for project 'HIP                                    |                                                                                             |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
-| nel'                                                                                        | function 6.1.40092                                                                          | 'hipModuleLaunchCooperativeKer- Documentation' from directory:                              |                                                                                             |
-| /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- |
-| 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      |
-
-Warning: doxygenfunction: Cannot find function 'hipModuleLaunchCooperativeKernelMultiDevice' in doxygen xml output for project 'HIP 6.1.40092 Documentation' from directory: /home/docs/checkouts/readthedocs.org/user\_builds/advanced-micro-devices-hip/checkouts/docs6.1.2/docs/doxygen/xml
-
-## 23.2 Cooperative groups classes
-
-The following cooperative groups classes can be used on the device side.
-
-## class thread\_group
-
-The base type of all cooperative group types.
-
-Holds the key properties of a constructed cooperative group types object, like the group type, its size, etc.
-
-Note: Cooperative groups feature is implemented on Linux, under development on Microsoft Windows.
-
-Subclassed by cooperative\_groups::coalesced\_group , cooperative\_groups::grid\_group , coopera-tive\_groups::multi\_grid\_group , cooperative\_groups::thread\_block , cooperative\_groups::tiled\_group class thread\_block : public cooperative\_groups:: thread\_group
-
-The workgroup (thread-block in CUDA terminology) cooperative group type.
-
-Represents an intra-workgroup cooperative group type, where the participating threads within the group are the same threads that participated in the currently executing workgroup .
-
-Note: This function is implemented on Linux and is under development on Microsoft Windows.
-
-class grid\_group : public cooperative\_groups:: thread\_group
-
-The grid cooperative group type.
-
-Represents an inter-workgroup cooperative group type, where the participating threads within the group spans across multiple workgroups running the (same) kernel on the same device.
-
-Note: This is implemented on Linux and is under development on Microsoft Windows.
-
-class multi\_grid\_group : public cooperative\_groups:: thread\_group
-
-The multi-grid cooperative group type.
-
-Represents an inter-device cooperative group type, where the participating threads within the group span across multiple devices, running the (same) kernel on these devices.
-
-Note: The multi-grid cooperative group type is implemented on Linux, under development on Microsoft Windows.
-
-## template&lt;unsigned int size , class ParentCGTy &gt;
-
-class thread\_block\_tile : public cooperative\_groups::impl::thread\_block\_tile\_internal&lt; size , ParentCGTy &gt; Group type -thread\_block\_tile .
-
-Represents one tiled thread group in a wavefront. This group type also supports sub-wave level intrinsics.
-
-Note: This type is implemented on Linux, under development on Microsoft Windows.
-
-## Public Functions
-
-unsigned int thread\_rank () const
-
-Rank of the calling thread within [0, size() ).
-
-## void sync ()
-
-Synchronizes the threads in the group.
-
-Causes all threads in the group to wait at this synchronization point, and for all shared and global memory accesses by the threads to complete, before running synchronization. This guarantees the visibility of accessed data for all threads in the group.
-
-Note: There are potential read-after-write (RAW), write-after-read (WAR), or write-after-write (WAW) hazards, when threads in the group access the same addresses in shared or global memory. The data hazards can be avoided with synchronization of the group.
-
-## unsigned int meta\_group\_rank () const
-
-Returns the linear rank of the group within the set of tiles partitioned from a parent group (bounded by meta\_group\_size)
-
-unsigned int meta\_group\_size () const
-
-Returns the number of groups created when the parent group was partitioned.
-
-## template&lt;class T &gt;
-
-T shfl ( T var, int srcRank ) const
-
-Shuffle operation on group level.
-
-Exchanging variables between threads without use of shared memory. Shuffle operation is a direct copy of var from srcRank thread ID of group.
-
-## Template Parameters
-
-T - The type can be a 32-bit integer or single-precision floating point.
-
-## Parameters
-
-- var - [in] The source variable to copy. Only the srcRank thread ID of group is copied to other threads.
-- srcRank - [in] The source thread ID of the group for copy.
-
-## template&lt;class T &gt;
-
-T shfl\_down ( T var, unsigned int lane\_delta ) const
-
-Shuffle down operation on group level.
-
-Exchanging variables between threads without use of shared memory. Shuffle down operation is copy of var from thread with thread ID of group relative higher with lane\_delta to caller thread ID.
-
-## Template Parameters
-
-T - The type can be a 32-bit integer or single-precision floating point.
-
-## Parameters
-
-- var - [in] The source variable to copy.
-- lane\_delta - [in] The lane\_delta is the relative thread ID difference between caller thread ID and source of copy thread ID. sourceID = (threadID + lane\_delta) % size()
-
-template&lt;class T &gt;
-
-## T shfl\_up ( T var, unsigned int lane\_delta ) const
-
-Shuffle up operation on group level.
-
-Exchanging variables between threads without use of shared memory. Shuffle up operation is copy of var from thread with thread ID of group relative lower with lane\_delta to caller thread ID.
-
-## Template Parameters
-
-T - The type can be a 32-bit integer or single-precision floating point.
-
-## Parameters
-
-- var - [in] The source variable to copy.
-- lane\_delta - [in] The lane\_delta is the relative thread ID difference between caller thread ID and source of copy thread ID. sourceID = (threadID - lane\_delta) % size()
-
-## template&lt;class T &gt;
-
-T shfl\_xor ( T var, unsigned int laneMask ) const
-
-Shuffle xor operation on group level.
-
-Exchanging variables between threads without use of shared memory. Shuffle xor operation is copy of var from thread with thread ID of group based on laneMask XOR of the caller thread ID.
-
-## Template Parameters
-
-- T - The type can be a 32-bit integer or single-precision floating point.
-
-## Parameters
-
-- var - [in] The source variable to copy.
-- laneMask - [in] The laneMask is the mask for XOR operation. sourceID = threadID ^ laneMask
-
-unsigned long long ballot ( int pred ) const
-
-Ballot function on group level.
-
-Returns a bit mask with the Nth bit set to one if the Nth thread predicate evaluates true.
-
-## Parameters
-
-pred - [in] The predicate to evaluate on group threads.
-
-int any ( int pred ) const
-
-Any function on group level.
-
-Returns non-zero if a predicate evaluates true for any threads.
-
-## Parameters
-
-pred - [in] The predicate to evaluate on group threads.
-
-int all ( int pred ) const
-
-All function on group level.
-
-Returns non-zero if a predicate evaluates true for all threads.
-
-## Parameters
-
-pred - [in] The predicate to evaluate on group threads.
-
-template&lt;typename T &gt;
-
-unsigned long long match\_any ( T value ) const
-
-Match any function on group level.
-
-Returns a bit mask containing a 1-bit for every participating thread if that thread has the same value in value as the caller thread.
-
-## Parameters
-
-value - [in] The value to examine on the current thread in group.
-
-template&lt;typename T &gt; unsigned long long match\_all ( T value, int &amp;pred ) const
-
-Match all function on group level.
-
-Returns a bit mask containing a 1-bit for every participating thread if they all have the same value in value as the caller thread. The predicate pred is set to true if all participating threads have the same value in value .
-
-## Parameters
-
-- value - [in] The value to examine on the current thread in group.
-- pred - [out] The predicate is set to true if all participating threads in the thread group have the same value.
-
-class coalesced\_group : public cooperative\_groups:: thread\_group
-
-The coalesced\_group cooperative group type.
-
-Represents an active thread group in a wavefront. This group type also supports sub-wave level intrinsics.
-
-Note: This is implemented on Linux and is under development on Microsoft Windows.
-
-## 23.3 Cooperative groups construct functions
-
-The following functions are used to construct different group-type instances on the device side.
-
-| Warning:                                                                                    | Warning:                                                                                    | doxygenfunction:                                                                            | doxygenfunction:                                                                            | doxygenfunction:                                                                            | Cannot find                                                                                 | Cannot find                                                                                 | function                                                                                    | 'cooperative_groups::this_multi_grid'                                                       | 'cooperative_groups::this_multi_grid'                                                       | 'cooperative_groups::this_multi_grid'                                                       |                                                                                             |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
-| in                                                                                          | doxygen                                                                                     | xml                                                                                         | output                                                                                      | for                                                                                         | project                                                                                     | 'HIP                                                                                        | 6.1.40092                                                                                   | Documentation'                                                                              | from                                                                                        | directory:                                                                                  |                                                                                             |
-| /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- |
-| 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      |
-
-Warning: doxygenfunction: Cannot find function 'cooperative\_groups::this\_grid' in doxygen xml output for project 'HIP 6.1.40092 Documentation' from directory: /home/docs/checkouts/readthedocs.org/user\_builds/advanced-micro-devices-hip/checkouts/docs6.1.2/docs/doxygen/xml
-
-Warning: doxygenfunction: Cannot find function 'cooperative\_groups::this\_thread\_block' in doxygen xml output for project 'HIP 6.1.40092 Documentation' from directory: /home/docs/checkouts/readthedocs.org/user\_builds/advanced-micro-devices-hip/checkouts/docs6.1.2/docs/doxygen/xml
-
-| Warning:   | Warning:   | doxygenfunction:   | doxygenfunction:   | doxygenfunction:   | Cannot   | find   | function   | 'cooperative_groups::coalesced_threads'   | 'cooperative_groups::coalesced_threads'   |            |
-|------------|------------|--------------------|--------------------|--------------------|----------|--------|------------|-------------------------------------------|-------------------------------------------|------------|
-| in         | doxygen    | xml                | output             | for                | project  | 'HIP   | 6.1.40092  | Documentation'                            | from                                      | directory: |
-
-/home/docs/checkouts/readthedocs.org/user\_builds/advanced-micro-devices-hip/checkouts/docs6.1.2/docs/doxygen/xml
-
-| Warning:                                                                                    | Warning:                                                                                    | doxygenfunction:                                                                            | doxygenfunction:                                                                            | doxygenfunction:                                                                            | Cannot find                                                                                 | Cannot find                                                                                 | function                                                                                    | 'cooperative_groups::tiled_partition'                                                       | 'cooperative_groups::tiled_partition'                                                       | 'cooperative_groups::tiled_partition'                                                       |                                                                                             |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
-| in                                                                                          | doxygen                                                                                     | xml                                                                                         | output                                                                                      | for                                                                                         | project                                                                                     | 'HIP                                                                                        | 6.1.40092                                                                                   | Documentation'                                                                              | from                                                                                        | directory:                                                                                  |                                                                                             |
-| /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- |
-| 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      |
-
-| Warning:                                                                                    | Warning:                                                                                    | doxygenfunction:                                                                            | doxygenfunction:                                                                            | doxygenfunction:                                                                            | Cannot                                                                                      | find                                                                                        | function 'cooperative_groups::tiled_partition' 6.1.40092                                    | function 'cooperative_groups::tiled_partition' 6.1.40092                                    | function 'cooperative_groups::tiled_partition' 6.1.40092                                    |                                                                                             |                                                                                             |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
-| in                                                                                          | doxygen                                                                                     | xml                                                                                         | output                                                                                      | for                                                                                         | project                                                                                     | 'HIP                                                                                        | Documentation'                                                                              | from                                                                                        | directory:                                                                                  |                                                                                             |                                                                                             |
-| /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- |
-| 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      |
-
-| Warning:                                                                                    | Warning:                                                                                    | doxygenfunction:                                                                            | doxygenfunction:                                                                            | doxygenfunction:                                                                            | Cannot find                                                                                 | Cannot find                                                                                 | function                                                                                    | function                                                                                    | 'cooperative_groups::binary_partition'                                                      | 'cooperative_groups::binary_partition'                                                      |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
-| in                                                                                          | doxygen                                                                                     | xml                                                                                         | output                                                                                      | for                                                                                         | project                                                                                     | 'HIP                                                                                        |                                                                                             | 6.1.40092                                                                                   | Documentation'                                                                              | from                                                                                        |
-| /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- |
-| 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      |
-
-| Warning:                                                                                    | Warning:                                                                                    | doxygenfunction:                                                                            | doxygenfunction:                                                                            | doxygenfunction:                                                                            | Cannot find                                                                                 | Cannot find                                                                                 | function 'cooperative_groups::binary_partition' 6.1.40092                                   | function 'cooperative_groups::binary_partition' 6.1.40092                                   | function 'cooperative_groups::binary_partition' 6.1.40092                                   |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
-| in                                                                                          | doxygen                                                                                     | xml                                                                                         | output                                                                                      | for                                                                                         | project                                                                                     | 'HIP                                                                                        | Documentation'                                                                              | from                                                                                        | directory:                                                                                  |
-| /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- |
-| 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      |
-
-## 23.4 Cooperative groups exposed API functions
-
-The following functions are the exposed API for different group-type instances on the device side.
-
-| Warning:                                                                                    | Warning:                                                                                    | doxygenfunction: project                                                                    | doxygenfunction: project                                                                    | doxygenfunction: project                                                                    | Cannot find                                                                                 | function                                                                                    | 'cooperative_groups::group_size'                                                            | 'cooperative_groups::group_size'                                                            | 'cooperative_groups::group_size'                                                            |                                                                                             |                                                                                             |                                                                                             |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
-| in                                                                                          | doxygen                                                                                     | xml                                                                                         | output                                                                                      | for                                                                                         | 'HIP                                                                                        | 6.1.40092                                                                                   | Documentation'                                                                              | from                                                                                        | directory:                                                                                  |                                                                                             |                                                                                             |                                                                                             |
-| /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- |
-| 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      |
-
-| Warning:                                                                                    | Warning:                                                                                    | doxygenfunction: Cannot                                                                     | doxygenfunction: Cannot                                                                     | doxygenfunction: Cannot                                                                     | doxygenfunction: Cannot                                                                     | find 'HIP                                                                                   | find 'HIP                                                                                   | function 'cooperative_groups::thread_rank'                                                  | function 'cooperative_groups::thread_rank'                                                  | function 'cooperative_groups::thread_rank'                                                  |                                                                                             |
-|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
-| in                                                                                          | doxygen                                                                                     | xml                                                                                         | output                                                                                      | for                                                                                         | project                                                                                     |                                                                                             | 6.1.40092                                                                                   | Documentation'                                                                              | from                                                                                        | directory:                                                                                  |                                                                                             |
-| /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- | /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs- |
-| 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      | 6.1.2/docs/doxygen/xml                                                                      |
-
-Warning: doxygenfunction: Cannot find function 'cooperative\_groups::is\_valid' in doxygen xml output for project 'HIP 6.1.40092 Documentation' from directory: /home/docs/checkouts/readthedocs.org/user\_builds/advanced-micro-devices-hip/checkouts/docs6.1.2/docs/doxygen/xml
-
-Warning: doxygenfunction: Cannot find function 'cooperative\_groups::sync' in doxygen xml output for project 'HIP 6.1.40092 Documentation' from directory: /home/docs/checkouts/readthedocs.org/user\_builds/advancedmicro-devices-hip/checkouts/docs-6.1.2/docs/doxygen/xml
-
-## CHAPTER
-
-## TWENTYFOUR
-
-## HSA RUNTIME API FOR ROCM
-
-The following functions are located in the https://github.com/ROCm/ROCR-Runtime repository.
-
-hsa\_status\_t hsa\_amd\_vmem\_address\_reserve ( void **va, size\_t size, uint64\_t address, uint64\_t flags )
-
-Allocate a reserved address range.
-
-Reserve a virtual address range. The size must be a multiple of the system page size. If it is not possible to allocate the address specified by address , then va will be a different address range. Address range should be released by calling hsa\_amd\_vmem\_address\_free.
-
-Note that this API will be deprecated in a future release and replaced by hsa\_amd\_vmem\_address\_reserve\_align
-
-## Parameters
-
-- va -[out] virtual address allocated
-- size -[in] of address range requested
-- address -[in] requested
-- flags -[in] currently unsupported
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS - Address range allocated successfully
-- ::HSA\_STATUS\_ERROR\_NOT\_INITIALIZED - The HSA runtime has not been initialized.
-- ::HSA\_STATUS\_ERROR\_OUT\_OF\_RESOURCES - Insufficient resources to allocate an address range of this size.
-
-hsa\_status\_t hsa\_amd\_vmem\_address\_free ( void *va, size\_t size )
-
-Free a reserved address range.
-
-Free a previously allocated address range. The size must match the size of a previously allocated address range.
-
-## Parameters
-
-- va -[out] virtual address to be freed
-- size -[in] of address range
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS - Address range released successfully
-- ::HSA\_STATUS\_ERROR\_INVALID\_ALLOCATION - Invalid va specified
-- ::HSA\_STATUS\_ERROR\_INVALID\_ARGUMENT - Invalid size specified
-- ::HSA\_STATUS\_ERROR\_RESOURCE\_FREE - Address range is still in use
-
-· ::HSA\_STATUS\_ERROR - Internal unexpected error
-
-hsa\_status\_t hsa\_amd\_vmem\_handle\_create ( hsa\_amd\_memory\_pool\_t pool, size\_t size, hsa\_amd\_memory\_type\_t type, uint64\_t flags, hsa\_amd\_vmem\_alloc\_handle\_t *memory\_handle
-
-)
-
-Create a virtual memory handle.
-
-Create a virtual memory handle within this pool size must be a aligned to allocation granule size for this memory pool, see HSA\_AMD\_MEMORY\_POOL\_INFO\_RUNTIME\_ALLOC\_GRANULE To minimize internal memory fragmentation, align the size to the recommended allocation granule size, see HSA\_AMD\_MEMORY\_POOL\_INFO\_RUNTIME\_ALLOC\_REC\_GRANULE
-
-## Parameters
-
-- pool -[in] memory to use
-- size -[in] of the memory allocation
-- type -[in] of memory
-- flags -[in] - currently unsupported
-- memory\_handle -[out] - handle for the allocation
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS - memory allocated successfully
-- ::HSA\_STATUS\_ERROR\_NOT\_INITIALIZED - The HSA runtime has not been initialized.
-- ::HSA\_STATUS\_ERROR\_INVALID\_ARGUMENT - Invalid arguments
-- ::HSA\_STATUS\_ERROR\_INVALID\_ALLOCATION - This memory pool does not support allocations
-- ::HSA\_STATUS\_ERROR\_OUT\_OF\_RESOURCES - Insufficient resources to allocate this memory
-
-hsa\_status\_t hsa\_amd\_vmem\_handle\_release ( hsa\_amd\_vmem\_alloc\_handle\_t memory\_handle )
-
-Release a virtual memory handle.
-
-## Parameters
-
-memory -[in] handle that was previously allocated
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS - Address range allocated successfully
-- ::HSA\_STATUS\_ERROR\_INVALID\_ALLOCATION - Invalid memory handle
-
-hsa\_status\_t hsa\_amd\_vmem\_map ( void *va, size\_t size, size\_t in\_offset, hsa\_amd\_vmem\_alloc\_handle\_t memory\_handle, uint64\_t flags )
-
-Map a virtual memory handle.
-
-Map a virtual memory handle to a reserved address range. The virtual address requested must be within a previously reserved address range. va and ( va + size) must be must be within (va + size) of the previous allocated address range. size must be equal to size of the memory\_handle hsa\_amd\_vmem\_set\_access needs to be called to make the memory accessible to specific agents
-
-## Parameters
-
-- va -[in] virtual address range where memory will be mapped
-- size -[in] of memory mapping
-- in\_offset -[in] offset into memory. Currently unsupported
-
-- memory\_handle -[in] virtual memory handle to be mapped
-- flags. -[in] Currently unsupported
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS - Memory mapped successfully
-- ::HSA\_STATUS\_ERROR\_INVALID\_ARGUMENT - va, size or memory\_handle are invalid
-- ::HSA\_STATUS\_ERROR\_OUT\_OF\_RESOURCES - Insufficient resources
-- ::HSA\_STATUS\_ERROR - Unexpected internal error
-
-## hsa\_status\_t hsa\_amd\_vmem\_unmap ( void *va, size\_t size )
-
-Unmap a virtual memory handle.
-
-Unmap previously mapped virtual address range
-
-## Parameters
-
-- va -[in] virtual address range where memory will be mapped
-- size -[in] of memory mapping
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS - Memory backing unmapped successfully
-- ::HSA\_STATUS\_ERROR\_INVALID\_ALLOCATION - memory\_handle is invalid
-- ::HSA\_STATUS\_ERROR\_INVALID\_ARGUMENT - size is invalid
-- ::HSA\_STATUS\_ERROR - Unexpected internal error
-
-hsa\_status\_t hsa\_amd\_vmem\_set\_access ( void *va, size\_t size, const hsa\_amd\_memory\_access\_desc\_t *desc, size\_t desc\_cnt )
-
-Make a memory mapping accessible.
-
-Make previously mapped virtual address accessible to specific agents. size must be equal to size of previously mapped virtual memory handle. Calling hsa\_amd\_vmem\_set\_access multiple times on the same va will overwrite previous permissions for all agents
-
-## Parameters
-
-- va -[in] previously mapped virtual address
-- size -[in] of memory mapping
-- desc -[in] list of access permissions for each agent
-- desc\_cnt -[in] number of elements in desc
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS -
-- ::HSA\_STATUS\_ERROR\_INVALID\_ARGUMENT - va, size or memory\_handle are invalid
-- ::HSA\_STATUS\_ERROR\_INVALID\_ALLOCATION - memory\_handle is invalid
-- ::HSA\_STATUS\_ERROR\_OUT\_OF\_RESOURCES - Insufficient resources
-- ::HSA\_STATUS\_ERROR\_INVALID\_AGENT - Invalid agent in desc
-- ::HSA\_STATUS\_ERROR - Unexpected internal error
-
-hsa\_status\_t hsa\_amd\_vmem\_get\_access ( void *va, hsa\_access\_permission\_t *perms, hsa\_agent\_t agent\_handle )
-
-Get current access permissions for memory mapping.
-
-Get access permissions for memory mapping for specific agent.
-
-## Parameters
-
-- va -[in] previously mapped virtual address
-- perms -[in] current permissions
-- agent\_handle -[in] agent
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS -
-- ::HSA\_STATUS\_ERROR\_INVALID\_AGENT - Invalid agent
-- ::HSA\_STATUS\_ERROR\_INVALID\_ALLOCATION - va is not mapped or permissions never set for this agent
-- ::HSA\_STATUS\_ERROR - Unexpected internal error
-
-hsa\_status\_t hsa\_amd\_vmem\_export\_shareable\_handle ( int *dmabuf\_fd, hsa\_amd\_vmem\_alloc\_handle\_t handle, uint64\_t flags )
-
-Get an exportable shareable handle.
-
-Get an exportable shareable handle for a memory\_handle. This shareabl handle can then be used to re-create a virtual memory handle using hsa\_amd\_vmem\_import\_shareable\_handle. The shareable handle can be transferred using mechanisms that support posix file descriptors Once all shareable handles are closed, the memory\_handle is released.
-
-## Parameters
-
-- dmabuf\_fd -[out] shareable handle
-- handle -[in] previously allocated virtual memory handle
-- flags -[in] Currently unsupported
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS -
-- ::HSA\_STATUS\_ERROR\_INVALID\_ALLOCATION - Invalid memory handle
-- ::HSA\_STATUS\_ERROR\_OUT\_OF\_RESOURCES - Out of resources
-- ::HSA\_STATUS\_ERROR - Unexpected internal error
-
-## hsa\_status\_t hsa\_amd\_vmem\_import\_shareable\_handle ( int dmabuf\_fd, hsa\_amd\_vmem\_alloc\_handle\_t *handle )
-
-Import a shareable handle.
-
-Import a shareable handle for a memory handle. Importing a shareable handle that has been closed and released results in undefined behavior.
-
-## Parameters
-
-- dmabuf\_fd -[in] shareable handle exported with hsa\_amd\_vmem\_export\_shareable\_handle
-- handle -[out] virtual memory handle
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS -
-
-- ::HSA\_STATUS\_ERROR\_INVALID\_ALLOCATION - Invalid memory handle
-- ::HSA\_STATUS\_ERROR\_OUT\_OF\_RESOURCES - Out of resources
-- ::HSA\_STATUS\_ERROR - Unexpected internal error
-
-hsa\_status\_t hsa\_amd\_vmem\_retain\_alloc\_handle ( hsa\_amd\_vmem\_alloc\_handle\_t *memory\_handle, void *addr )
-
-Returns memory handle for mapped memory.
-
-Return a memory handle for previously mapped memory. The handle will be the same value of handle used to map the memory. The returned handle must be released with corresponding number of calls to hsa\_amd\_vmem\_handle\_release.
-
-## Parameters
-
-- memory\_handle -[out] memory handle for this mapped address
-- mapped -[in] address
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS -
-- ::HSA\_STATUS\_ERROR\_INVALID\_ALLOCATION - Invalid address
-
-hsa\_status\_t hsa\_amd\_vmem\_get\_alloc\_properties\_from\_handle ( hsa\_amd\_vmem\_alloc\_handle\_t memory\_handle, hsa\_amd\_memory\_pool\_t *pool, hsa\_amd\_memory\_type\_t *type )
-
-Returns the current allocation properties of a handle.
-
-Returns the allocation properties of an existing handle
-
-## Parameters
-
-- memory\_handle -[in] memory handle to be queried
-- pool -[out] memory pool that owns this handle
-- memory -[out] type
-
-## Return values
-
-- ::HSA\_STATUS\_SUCCESS -
-- ::HSA\_STATUS\_ERROR\_INVALID\_ALLOCATION - Invalid memory\_handle
-
-## CHAPTER
-
-## TWENTYFIVE
-
-## HIP MANAGED MEMORY ALLOCATION API
-
-hipError\_t hipMallocManaged ( void **dev\_ptr, size\_t size, unsigned int flags )
-
-Allocates memory that will be automatically managed by HIP.
-
-This API is used for managed memory, allows data be shared and accessible to both CPU and GPU using a single pointer.
-
-The API returns the allocation pointer, managed by HMM, can be used further to execute kernels on device and fetch data between the host and device as needed.
-
-Note: It is recommend to do the capability check before call this API.
-
-## Parameters
-
-- dev\_ptr -[out] - pointer to allocated device memory
-- size -[in] - requested allocation size in bytes, it should be granularity of 4KB
-- flags -[in] - must be either hipMemAttachGlobal or hipMemAttachHost (defaults to hipMemAttachGlobal)
-
-## Returns
-
-hipSuccess, hipErrorMemoryAllocation, hipErrorNotSupported, hipErrorInvalidValue hipError\_t hipMemPrefetchAsync ( const void *dev\_ptr, size\_t count, int device, hipStream\_t stream
-
-) Prefetches memory to the specified destination device using HIP.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-## Parameters
-
-- dev\_ptr -[in] pointer to be prefetched
-- count -[in] size in bytes for prefetching
-- device -[in] destination device to prefetch to
-- stream -[in] stream to enqueue prefetch operation
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue
-
-hipError\_t hipMemAdvise ( const void *dev\_ptr, size\_t count, hipMemoryAdvise advice, int device )
-
-Advise about the usage of a given memory range to HIP.
-
-This HIP API advises about the usage to be applied on unified memory allocation in the range starting from the pointer address devPtr, with the size of count bytes. The memory range must refer to managed memory allocated via the API hipMallocManaged, and the range will be handled with proper round down and round up respectively in the driver to be aligned to CPU page size, the same way as corresponding CUDA API behaves in CUDA version 8.0 and afterwards.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-## Parameters
-
-- dev\_ptr -[in] pointer to memory to set the advice for
-- count -[in] size in bytes of the memory range, it should be CPU page size alligned.
-- advice -[in] advice to be applied for the specified memory range
-- device -[in] device to apply the advice for
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemRangeGetAttribute ( void *data, size\_t data\_size, hipMemRangeAttribute attribute, const void *dev\_ptr, size\_t count )
-
-Query an attribute of a given memory range in HIP.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-## Parameters
-
-- data -[inout] a pointer to a memory location where the result of each attribute query will be written to
-- data\_size -[in] the size of data
-- attribute -[in] the attribute to query
-- dev\_ptr -[in] start of the range to query
-- count -[in] size of the range to query
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipMemRangeGetAttributes ( void **data, size\_t *data\_sizes, hipMemRangeAttribute *attributes, size\_t num\_attributes, const void *dev\_ptr, size\_t count )
-
-Query attributes of a given memory range in HIP.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-## Parameters
-
-- data -[inout] a two-dimensional array containing pointers to memory locations where the result of each attribute query will be written to
-- data\_sizes -[in] an array, containing the sizes of each result
-- attributes -[in] the attribute to query
-- num\_attributes -[in] an array of attributes to query (numAttributes and the number of attributes in this array should match)
-- dev\_ptr -[in] start of the range to query
-- count -[in] size of the range to query
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue hipError\_t hipStreamAttachMemAsync ( hipStream\_t stream, void *dev\_ptr, size\_t length, unsigned int flags ) Attach memory to a stream asynchronously in HIP.
-
-Warning: This API is under development. Currently it is a no-operation (NOP) function on AMD GPUs and returns hipSuccess.
-
-## Parameters
-
-- stream -[in] - stream in which to enqueue the attach operation
-- dev\_ptr -[in] - pointer to memory (must be a pointer to managed memory or to a valid host-accessible region of system-allocated memory)
-- length -[in] - length of memory (defaults to zero)
-- flags -[in] - must be one of hipMemAttachGlobal, hipMemAttachHost or hipMemAttachSingle (defaults to hipMemAttachSingle)
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue
-
-## template&lt;class T &gt;
-
-static inline hipError\_t hipMallocManaged ( T **devPtr, size\_t size, unsigned int flags = hipMemAttachGlobal )
-
-- : C++ wrapper for hipMallocManaged
-
-Provide an override to automatically typecast the pointer type from void**, and also provide a default for the flags.
-
-HIP\_DISABLE\_CPP\_FUNCTIONS macro can be defined to suppress these wrappers. It is useful for applications which need to obtain decltypes of HIP runtime APIs.
-
-## See also:
-
-hipMallocManaged
-
-## CHAPTER
-
-## TWENTYSIX
-
-## HIP VIRTUAL MEMORY MANAGEMENT API
-
-hipError\_t hipMemAddressFree ( void *devPtr, size\_t size )
-
-Frees an address range reservation made via hipMemAddressReserve.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- devPtr -[in] - starting address of the range.
-- size -[in] - size of the range.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemAddressReserve ( void **ptr, size\_t size, size\_t alignment, void *addr, unsigned long long flags )
-
-Reserves an address range.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- ptr -[out] - starting address of the reserved range.
-- size -[in] - size of the reservation.
-- alignment -[in] - alignment of the address.
-- addr -[in] - requested starting address of the range.
-- flags -[in] - currently unused, must be zero.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported
-
-hipError\_t hipMemCreate ( hipMemGenericAllocationHandle\_t *handle, size\_t size, const hipMemAllocationProp *prop, unsigned long long flags )
-
-Creates a memory allocation described by the properties and size.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- handle -[out] - value of the returned handle.
-- size -[in] - size of the allocation.
-- prop -[in] - properties of the allocation.
-- flags -[in] - currently unused, must be zero.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemExportToShareableHandle ( void *shareableHandle, hipMemGenericAllocationHandle\_t handle, hipMemAllocationHandleType handleType, unsigned long long flags )
-
-Exports an allocation to a requested shareable handle type.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- shareableHandle -[out] - value of the returned handle.
-- handle -[in] - handle to share.
-- handleType -[in] - type of the shareable handle.
-- flags -[in] - currently unused, must be zero.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemGetAccess ( unsigned long long *flags, const hipMemLocation *location, void *ptr
-
-) Get the access flags set for the given location and ptr.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- flags -[out] - flags for this location.
-- location -[in] - target location.
-- ptr -[in] - address to check the access flags.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemGetAllocationGranularity ( size\_t *granularity, const hipMemAllocationProp *prop, hipMemAllocationGranularity\_flags option )
-
-Calculates either the minimal or recommended granularity.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- granularity -[out] - returned granularity.
-- prop -[in] - location properties.
-- option -[in] - determines which granularity to return.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemGetAllocationPropertiesFromHandle ( hipMemAllocationProp *prop,
-
-hipMemGenericAllocationHandle\_t handle )
-
-Retrieve the property structure of the given handle.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- prop -[out] - properties of the given handle.
-- handle -[in] - handle to perform the query on.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported
-
-hipError\_t hipMemImportFromShareableHandle ( hipMemGenericAllocationHandle\_t *handle, void *osHandle, hipMemAllocationHandleType shHandleType )
-
-Imports an allocation from a requested shareable handle type.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- handle -[out] - returned value.
-- osHandle -[in] - shareable handle representing the memory allocation.
-- shHandleType -[in] - handle type.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemMap ( void *ptr, size\_t size, size\_t offset, hipMemGenericAllocationHandle\_t handle, unsigned long long flags )
-
-Maps an allocation handle to a reserved virtual address range.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- ptr -[in] - address where the memory will be mapped.
-- size -[in] - size of the mapping.
-- offset -[in] - offset into the memory, currently must be zero.
-- handle -[in] - memory allocation to be mapped.
-- flags -[in] - currently unused, must be zero.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemMapArrayAsync ( hipArrayMapInfo *mapInfoList, unsigned int count, hipStream\_t stream )
-
-Maps or unmaps subregions of sparse HIP arrays and sparse HIP mipmapped arrays.
-
-Warning: This API is under development. Currently it is not supported on AMD GPUs and returns hipErrorNotSupported.
-
-## Parameters
-
-- mapInfoList -[in] - list of hipArrayMapInfo.
-- count -[in] - number of hipArrayMapInfo in mapInfoList.
-- stream -[in] - stream identifier for the stream to use for map or unmap operations.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemRelease ( hipMemGenericAllocationHandle\_t handle )
-
-Release a memory handle representing a memory allocation which was previously allocated through hipMemCreate.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-handle -[in] - handle of the memory allocation.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemRetainAllocationHandle ( hipMemGenericAllocationHandle\_t *handle, void *addr )
-
-Returns the allocation handle of the backing memory allocation given the address.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- handle -[out] - handle representing addr.
-- addr -[in] - address to look up.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported hipError\_t hipMemSetAccess ( void *ptr, size\_t size, const hipMemAccessDesc *desc, size\_t count )
-
-Set the access flags for each location specified in desc for the given virtual address range.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- ptr -[in] - starting address of the virtual address range.
-- size -[in] - size of the range.
-- desc -[in] - array of hipMemAccessDesc.
-- count -[in] - number of hipMemAccessDesc in desc.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported
-
-## hipError\_t hipMemUnmap ( void *ptr, size\_t size )
-
-Unmap memory allocation of a given address range.
-
-Note: This API is implemented on Linux and is under development on Microsoft Windows.
-
-Warning: This API is marked as Beta. While this feature is complete, it can change and might have outstanding issues.
-
-## Parameters
-
-- ptr -[in] - starting address of the range to unmap.
-- size -[in] - size of the virtual address range.
-
-## Returns
-
-hipSuccess, hipErrorInvalidValue, hipErrorNotSupported
-
-## CHAPTER
-
-## TWENTYSEVEN
-
-## HIP DEPRECATED RUNTIME API FUNCTIONS
-
-Several of our API functions have been flagged for deprecation. Using the following functions results in errors and unexpected results, so we encourage you to update your code accordingly.
-
-## 27.1 Context management
-
-CUDAsupports cuCtx API, which is the driver API that defines 'Context' and 'Devices' as separate entities. Context contains a single device, and a device can theoretically have multiple contexts. HIP initially added limited support for these APIs in order to facilitate porting from existing driver codes. These APIs are now marked as deprecated because there are better alternate interfaces (such as hipSetDevice or the stream API) to achieve these functions.
-
-- hipCtxCreate
-- hipCtxDestroy
-- hipCtxPopCurrent
-- hipCtxPushCurrent
-- hipCtxSetCurrent
-- hipCtxGetCurrent
-- hipCtxGetDevice
-- hipCtxGetApiVersion
-- hipCtxGetCacheConfig
-- hipCtxSetCacheConfig
-- hipCtxSetSharedMemConfig
-- hipCtxGetSharedMemConfig
-- hipCtxSynchronize
-- hipCtxGetFlags
-- hipCtxEnablePeerAccess
-- hipCtxDisablePeerAccess
-- hipDevicePrimaryCtxGetState
-- hipDevicePrimaryCtxRelease
-- hipDevicePrimaryCtxRetain
-- hipDevicePrimaryCtxReset
-
-- hipDevicePrimaryCtxSetFlags
-
-## 27.2 Memory management
-
-- hipMallocHost (replaced with hipHostMalloc )
-- hipMemAllocHost (replaced with hipHostMalloc )
-- hipHostAlloc (replaced with hipHostMalloc )
-- hipFreeHost (replaced with hipHostFree )
-- hipMemcpyToArray
-- hipMemcpyFromArray
-
-## 27.3 Profiler control
-
-- hipProfilerStart (use roctracer/rocTX)
-- hipProfilerStop (use roctracer/rocTX)
-
-## 27.4 Texture management
-
-- hipGetTextureReference
-- hipTexRefSetAddressMode
-- hipTexRefSetArray
-- hipTexRefSetFilterMode
-- hipTexRefSetFlags
-- hipTexRefSetFormat
-- hipTexRefGetAddress
-- hipTexRefGetAddressMode
-- hipTexRefGetFilterMode
-- hipTexRefGetFlags
-- hipTexRefGetFormat
-- hipTexRefGetMaxAnisotropy
-- hipTexRefGetMipmapFilterMode
-- hipTexRefGetMipmapLevelBias
-- hipTexRefGetMipmapLevelClamp
-- hipTexRefGetMipMappedArray
-- hipTexRefSetAddress
-- hipTexRefSetAddress2D
-- hipTexRefSetMaxAnisotropy
-
-- hipTexRefSetBorderColor
-- hipTexRefSetMipmapFilterMode
-- hipTexRefSetMipmapLevelBias
-- hipTexRefSetMipmapLevelClamp
-- hipTexRefSetMipmappedArray
-- hipTexRefGetBorderColor
-- hipTexRefGetArray
-- hipBindTexture
-- hipBindTexture2D
-- hipBindTextureToArray
-- hipGetTextureAlignmentOffset
-- hipUnbindTexture
-- hipBindTextureToMipmappedArray
-
-## CHAPTER
-
-## TWENTYEIGHT
-
-## SAXPY - HELLO, HIP
-
-This tutorial explains the basic concepts of the single-source Heterogeneous-computing Interface for Portability (HIP) programming model and the essential tooling around it. It also reviews some commonalities of heterogenous APIs in general. This topic assumes basic familiarity with the C/C++ compilation model and language.
-
-## 28.1 Prerequisites
-
-To follow this tutorial, you'll need installed drivers and a HIP compiler toolchain to compile your code. Because HIP for ROCm supports compiling and running on Linux and Windows with AMD and NVIDIA GPUs, the combination of install instructions is more than worth covering as part of this tutorial. For more information about installing HIP development packages, see Install HIP .
-
-## 28.2 Heterogeneous programming
-
-Heterogeneous programming and offloading APIs are often mentioned together. Heterogeneous programming deals with devices of varying capabilities simultaneously. Offloading focuses on the 'remote' and asynchronous aspects of computation. HIP encompasses both. It exposes GPGPU (general-purpose GPU) programming much like ordinary host-side CPU programming and lets you move data across various devices.
-
-When programming in HIP (and other heterogenous APIs for that matter), remember that target devices are built for a specific purpose. They are designed with different tradeoffs than traditional CPUs and therefore have very different performance characteristics. Even subtle changes in code might adversely affect execution time.
-
-## 28.3 Your first lines of HIP code
-
-First, let's do the 'Hello, World!' of GPGPU: SAXPY. Single-precision A times X Plus Y ( SAXPY ) is a mathematical acronym; a vector equation 𝑎 · 𝑥 + 𝑦 = 𝑧 where 𝑎 ∈ R is a scalar and 𝑥, 𝑦, 𝑧 ∈ V are vector quantities of some large dimensionality. This vector space is defined over the set of reals. Practically speaking, you can compute this using a single for loop over three arrays.
-
-```
-++i)
-```
-
-```
-<_SQL_>
-```
-
-In linear algebra libraries, such as BLAS (Basic Linear Algebra Subsystem) this operation is defined as AXPY 'A times X Plus Y'. The 'S' comes from single-precision , meaning that array element is float -s (IEEE 754 binary32 representation).
-
-To quickly get started, use the set of HIP samples from GitHub. With Git configured on your machine, open a commandline and navigate to your desired working directory, then run:
-
-```
-            |git clone https://github.com/amd/rcm-examples.git
-```
-
-A simple implementation of SAXPY resides in the HIP-Basic/saxpy/main.hip file in this repository. The HIP code here mostly deals with where data has to be and when, and how devices transform this data. The first HIP calls deal with allocating device-side memory and copying data from host-side memory to device side in a C runtime-like fashion.
-
-```
-// Allocate and copy vectors to device memory.
-float* d_x{};
-float* d_y{};
-HIP_CHECK(hipMalloc(&d_x, size_bytes));
-HIP_CHECK(hipMalloc(&d_y, size_bytes));
-HIP_CHECK(hipMemcpy(d_x, x.data(), size_bytes, hipMemcpyHostToDevice));
-HIP_CHECK(hipMemcpy(d_y, y.data(), size_bytes, hipMemcpyHostToDevice));
-```
-
-HIP\_CHECK is a custom macro borrowed from the examples utilities which checks the error code returned by API functions for errors and reports them to the console. It is not essential to the API, but it is a good practice to check the error codes of the HIP APIs in case you pass on incorrect values to the API, or the API might be out of resources.
-
-The code selects the device to allocate to and to copy to. Commands are issued to the HIP runtime per thread, and every thread has a device set as the target of commands. The default device is 0 , which is equivalent to calling hipSetDevice(0) .
-
-Launch the calculation on the device after the input data has been prepared.
-
-```
-    Launch the calculation on the device after the input data has been prepared.
-    __global__ void saxpy_kernel(const float a, const float* d_x, float* d_y, const unsigned_
-    __int size)
-    {
-        //...
-    }
-
-    int main()
-    {
-        //...
-
-        // Launch the kernel on the default stream.
-        saxpy_kernel<<<dim3(grid_size), dim3(block_size), 0, hipStreamDefault>>>(a, d_x, d_y,
-    -- size);
-    }
-
-    Analyze at the signature of the offloaded function:
-```
-
-Analyze at the signature of the offloaded function:
-
-- \_\_global\_\_ instructs the compiler to generate code for this function as an entrypoint to a device program, such that it can be launched from the host.
-- The function does not return anything, because there is no trivial way to construct a return channel of a parallel invocation. Device-side entrypoints may not return a value, their results should be communicated using output parameters.
-- Device-side functions are typically called compute kernels, or just kernels for short. This is to distinguish them from non-graphics-related graphics shaders, or just shaders for short.
-- Arguments are taken by value and all arguments shall be TriviallyCopyable, meaning they should be memcpy -friendly. (Imagine if they had custom copy constructors. Where would that logic execute? On the host? On the device?) Pointer arguments are pointers to device memory, one typically backed by VRAM.
-
-- We said that we'll be computing 𝑎 · 𝑥 + 𝑦 = 𝑧 , however we only pass two pointers to the function. We'll be canonically reusing one of the inputs as outputs.
-
-This function is launched from the host using a language extension often called the triple chevron syntax. Inside the angle brackets, provide the following.
-
-- The number of blocks to launch (our grid size)
-- The number of threads in a block (our block size)
-- The amount of shared memory to allocate by the host
-- The device stream to enqueue the operation on
-
-The block size and shared memory become important later in Reduction . For now, a hardcoded 256 is a safe default for simple kernels such as this. Following the triple chevron is ordinary function argument passing.
-
-Look at how the kernel is implemented.
-
-```
-<_Cuda_>
-```
-
-- The unique linear index identifying the thread is computed from the block ID the thread is a member of, the block 's size and the ID of the thread within the block .
-- A check is made to avoid overindexing the input.
-- The useful part of the computation is carried out.
-
-Retrieval of the result from the device is done much like input data copy. In this current step the results copied from device to host. The opposite direction of the input data copy:
-
-```
-                |HIP_CHECK(hipMemcpy(y.data()),  d_y,  size_bytes,  hipMemcpyDeviceToHost));
-```
-
-## 28.4 Compiling on the command line
-
-## 28.4.1 Setting up the command line
-
-Strictly speaking there's no such thing as 'setting up the command-line for compilation' on Linux. To make invocations more terse, Linux and Windows example follow.
-
-## Linux and AMD
-
-While distro maintainers might package ROCm so that it installs to system-default locations, AMD's packages aren't installed that way. They need to be added to the PATH by the user.
-
-```
-        | export PATH=/opt/rcm/bin:${PATH}
-```
-
-```
-}
-```
-
-```
-    You should be able to call the compiler on the command line now:
-    
-    amdclang++  --version
-```
-
-Note: Docker images distributed by AMD, such as rocm-terminal already have /opt/rocm/bin on the Path for convenience. This subtly affects CMake package detection logic of ROCm libraries.
-
-## Linux and NVIDIA
-
-Both distro maintainers and NVIDIA package CUDA so that nvcc and related tools are available on the command line by default. You can call the compiler on the command line with:
-
-```
-| nvcc --version
-```
-
-## Windows and AMD
-
-Windows compilers and command line tooling have traditionally relied on extra environmental variables and PATH entries to function correctly. Visual Studio refers to command lines with this setup as 'Developer Command Prompt' or 'Developer PowerShell' for cmd.exe and PowerShell respectively.
-
-The HIP SDK on Windows doesn't include a complete toolchain. You will also need:
-
-- The Microsoft Windows SDK. It provides the import libs to crucial system libraries that all executables must link to and some auxiliary compiler tooling.
-- A Standard Template Library (STL). Installed as part of the Microsoft Visual C++ compiler (MSVC) or with Visual Studio.
-
-If you don't have a version of Visual Studio 2022 installed, for a minimal command line experience, install the Build Tools for Visual Studio 2022 with the Desktop Developemnt Workload. Under Individual Components select:
-
-- A version of the Windows SDK
-- 'MSVC v143 - VS 2022 C++ x64/x86 build tools (Latest)'
-- 'C++ CMake tools for Windows' (optional)
-
-Note: The 'C++ CMake tools for Windows' individual component is a convenience which puts both cmake.exe and ninja.exe onto the PATH inside developer command prompts. You can install these manually, but then you must manage them manually.
-
-Visual Studio 2017 and later are detectable as COM object instances via WMI. To setup a command line from any shell for the latest Visual Studio's default Visual C++ toolset issue:
-
-```
-$InstallationPath = Get-CimInstance MSFT_VSInstance | Sort-Object -Property Version -
- --Descending | Select-Object -First 1 -ExpandProperty InstallLocation
- Import-Module $InstallationPath\Common?\Tools\Microsoft.VisualStudio.DevShell.dll
-Enter-VsDevShell -InstallPath $InstallationPath -SkipAutomaticLocation -Arch amd64 -
- --HostArch amd64 -DevCmdArguments '-no_logo'
-$env:PATH = "${env:HIP_PATH}bin;${env:PATH}"
-```
-
-You should be able to call the compiler on the command line now:
-
-```
-  | clang++ --version
-```
-
-## Windows and NVIDIA
-
-Windows compilers and command line tooling have traditionally relied on extra environmental variables and PATH entries to function correctly. Visual Studio refers to command lines with this setup as 'Developer Command Prompt' or 'Developer PowerShell' for cmd.exe and PowerShell respectively.
-
-The HIP and CUDA SDKs on Windows don't include complete toolchains. You will also need:
-
-- The Microsoft Windows SDK. It provides the import libs to crucial system libraries that all executables must link to and some auxiliary compiler tooling.
-- A Standard Template Library (STL). Installed as part of the Microsoft Visual C++ compiler (MSVC) or with Visual Studio.
-
-If you don't have a version of Visual Studio 2022 installed, for a minimal command line experience, install the Build Tools for Visual Studio 2022 with the Desktop Developemnt Workload. Under Individual Components select:
-
-- A version of the Windows SDK
-- 'MSVC v143 - VS 2022 C++ x64/x86 build tools (Latest)'
-- 'C++ CMake tools for Windows' (optional)
-
-Note: The 'C++ CMake tools for Windows' individual component is a convenience which puts both cmake.exe and ninja.exe onto the PATH inside developer command prompts. You can install these manually, but then you must manage them manually.
-
-Visual Studio 2017 and later are detectable as COM object instances via WMI. To setup a command line from any shell for the latest Visual Studio's default Visual C++ toolset issue:
-
-```
-$InstallationPath = Get-CimInstance MSFT_VSInstance | Sort-Object -Property Version -
---Descending | Select-Object -First 1 -ExpandProperty InstallLocation
-Import-Module $InstallationPath\Common7\Tools\Microsoft.VisualStudio.DevShell.dll
-Enter-VsDevShell -InstallPath $InstallationPath -SkipAutomaticLocation -Arch amd64 -
---HostArch amd64 -DevCmdArguments '-no_logo'
-```
-
-You should be able to call the compiler on the command line now:
-
-```
-| nvcc --version
-```
-
-## 28.4.2 Invoking the compiler manually
-
-To compile and link a single-file application, use the following commands:
-
-## Linux and AMD
-
-```
-                                                                                                                                                                                                        |                                                                                                                                                                                                       
-                                                                                                                                                                                                        <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        </----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                    <---------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        >----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                    |   
-                                                                                                                                                                                                    |   
-
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                   
-    </----------------------------------------------------------------------------------------------------------------------
-```
-
-## Linux and NVIDIA
-
-```
-                                                                                                                                                                                                        | nvcc ./HIP-Basic/saxpy/main.hip  -o  saxpy  -I ./Common  -I  /opt/rocm/include  -02  -x  cu                                                                                                                                                                                                       
-                                                                                                                                                                                                        -x  cu                                                                                                                                                                                                  |                                                                                                                                                                                                        }
-```
-
-## Windows and AMD
-
-```
-                                                                                                                                                                                                        |clang++.\HIP-Basic\saxpy\main.hip -o saxpy.exe -I.\Common -lamdhip64 -L ${env:HIP_PATH}                                                                                                                                                                                                       
-                                                                                                                                                                                                        -lib -02
-```
-
-## Windows and NVIDIA
-
-```
-                                                                                                                                                                                                        | nvcc.\HIP-Basic\saxpy\main.hip -o saxpy.exe -I ${env:HIP_PATH}include -I.\Common -02 - -
-                                                                                                                                                                                                        -x                                                                                                                                                                                                       
-                                                                                                                                                                                                       |                                                                                                                                                                                                        +x                                                                                                                                                                                                       |
-```
-
-Depending on your computer, the resulting binary might or might not run. If not, it typically complains about 'Invalid device function'. That error (corresponding to the hipErrorInvalidDeviceFunction entry of hipError\_t ) means that the runtime could not find a device program binary of the appropriate flavor embedded into the executable.
-
-So far, the discussion has covered how data makes it from the host to the device and back. It has also discussed the device code as source, with the HIP runtime arguing that the correct binary to dispatch for execution. How can you find out what device binary flavors are embedded into the executable?
-
-## Linux and AMD
-
-The utilities included with ROCm help significantly to inspect binary artifacts on disk. Add the ROCmCC installation folder to your PATH if you want to use these utilities (the utilities expect them to be on the PATH).
-
-You can list embedded program binaries using roc-obj-ls .
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?>
-                                                                                                                                                                                                       <!>
-                                                                                                                                                                                                      <!>"
-```
-
-```
-<_SQL_>
-```
-
-The compiler embeds a version 4 code object (more on code object versions) and used the LLVM target triple amdgcnamd-amdhsa-gfx803 (more on target triples). You can extract that program object in a disassembled fashion for human consumption via roc-obj .
-
-```
-        | r o c - o b j \ - t \ g f x 8 0 3 \ - d \. / s a x p y
-```
-
-This creates two files on disk and .s extension is of most interest. Opening this file or dumping it to the console using cat lets find the disassembled binary of the SAXPY compute kernel, something similar to:
-
-```
-<_XML_>
-```
-
-Alternatively, call the compiler with --save-temps to dump all device binary to disk in separate files.
-
-```
-                                                                                                                                                                                                        |                                                                                                                                                                                                       
-                                                                                                                                                                                                        -                                                                                                                                                                                                        --                                                                                                                                                                                                        \                                                                                                                                                                                                        +                                                                                                                                                                                                        <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        }                                                                                                                                                                                                        </----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                    |   
-                                                                                                                                                                                                    |    -                                                                                                                                                                                                    |    0                                                                                                                                                                                                        ]                                                                                                                                                                                                        )                                                                                                                                                                                                       .                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        :                                                                                                                                                                                                       '
-```
-
-List all the temporaries created while compiling main.hip with:
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-    ls main-hip-amdgcn-amd-amdhsa-*
-    main-hip-amdgcn-amd-amdhsa-gfx803.bc
-    main-hip-amdgcn-amd-amdhsa-gfx803.cui
-    main-hip-amdgcn-amd-amdhsa-gfx803.o
-    main-hip-amdgcn-amd-amdhsa-gfx803.out
-    main-hip-amdgcn-amd-amdhsa-gfx803.out.resolution.txt
-    main-hip-amdgcn-amd-amdhsa-gfx803.s
-```
-
-Files with the .s extension hold the disassembled contents of the binary. The filename notes the graphics IPs used by the compiler. The contents of this file are similar to what roc-obj printed to the console.
-
-## Linux and NVIDIA
-
-Unlike HIP on AMD, when compiling using the NVIDIA support of HIP the resulting binary will be a valid CUDA executable as far as the binary goes. Therefor it'll incorporate PTX ISA (Parallel Thread eXecution Instruction Set Architecture) instead of AMDGPU binary. As s result, tooling shipping with the CUDA SDK can be used to inspect which device ISA got compiled into a specific executable. The tool most useful to us currently is cuobjdump .
-
-```
-  cuobjdump --list-ptx./saxpy
-
-  Which will print something like:
-```
-
-```
-| P T X \ f i l e
-```
-
-```
-1:  saxpy. 1. sm_5. ptx
-```
-
-From this we can see that the saxpy kernel is stored as sm\_52 , which shows that a compute capability 5.2 ISA got embedded into the executable, so devices which sport compute capability 5.2 or newer will be able to run this code.
-
-## Windows and AMD
-
-The HIP SDK for Windows don't yet sport the roc-* set of utilities to work with binary artifacts. To find out what binary formats are embedded into an executable, one may use dumpbin tool from the Windows SDK to obtain the raw data of the .hip\_fat section of an executable. (This binary payload is what gets parsed by the roc-* set of utilities on Linux.) Skipping over the reported header, the rendered raw data as ASCII has ~3 lines per entries. Depending on how many binaries are embedded, you may need to alter the number of rendered lines. An invocation such as:
-
-```
-                                                                                                                                                                                                        | dumpbin.exe  /nologo  /section:.hip_fat  /rawdata:8 .\saxpy.exe  |  select  -Skip  20  -First  12                                                                                                                                                                                                       
-                                                                                                                                                                                                        -                                                                                                                                                                                                        --                                                                                                                                                                                                        +                                                                                                                                                                                                        <--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        </--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                   | dumpbin .exe  /nologo  /section:.hip_fat  /rawdata:8 .\saxpy.exe  |  select  -Skip  20  -First  12                                                                                                                                                             |                                                                                                                                                                                                        >--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                  
-     |  dumpbin.exe  /nologo  /section:.hip_fat  /rawdata:8 .\saxpy.exe  |  select  -Skip  20  -First  12                                                                                                                                                        |                                               
-     |                                                                                                                                                                                                   |                                          
-     |                                                                                                                                                       
-     |                                                                                                                                                   |                                                    
-     |                                                                                                                                             
-     |                                                    
-     |                                                                                                                                        
-     |                                                         
-     |
-```
-
-The output may look like:
-
-```
-<_Python_>
-```
-
-We can see that the compiler embedded a version 4 code object (more on code object versions) and used the LLVM target triple amdgcn-amd-amdhsa-gfx906 (more on target triples). Don't be alarmed about linux showing up as a binary format, AMDGPU binaries uploaded to the GPU for execution are proper linux ELF binaries in their format.
-
-Alternatively we can call the compiler with --save-temps to dump all device binary to disk in separate files.
-
-```
-                                                                                                                                                                                                        |clang++.\HIP-Basic\saxpy\main.hip -o saxpy.exe -I.\Common -lamdhip64 -L ${env:HIP_PATH}                                                                                                                                                                                                       
-                                                                                                                                                                                                        -lib -02 --save-temps                                                                                                                                                                                                        \
-```
-
-Now we can list all the temporaries created while compiling main.hip via
-
-```
-        |Get-ChildItem -Filter main-hip-* | selec
-```
-
-```
-n-hip-* | select -Property Name
-                                                                                                                                                                                                         (continues on next page)
-```
-
-(continued from previous page)
-
-```
-Name
------
-main-hip-amdgcn-amd-amdhsa-gfx906.bc
-main-hip-amdgcn-amd-amdhsa-gfx906.hipi
-main-hip-amdgcn-amd-amdhsa-gfx906.o
-main-hip-amdgcn-amd-amdhsa-gfx906.out
-main-hip-amdgcn-amd-amdhsa-gfx906.out.resolution.txt
-main-hip-amdgcn-amd-amdhsa-gfx906.s
-```
-
-Files with the .s extension hold the disassembled contents of the binary and the filename directly informs us of the graphics IPs used by the compiler.
-
-```
-main-hip-amdgcn-amd-amdsha-gfx906.out
-main-hip-amdgcn-amd-amdsha-gfx906.out.resolution.txt
-main-hip-amdgcn-amd-amdsha-gfx906.s
-
-Files with the.s extension hold the disassembled contents of the binary and the filename directly informs us of the
-graphics IPs used by the compiler.
-
-Get-ChildItem main-hip-*.s | Get-Content
-           .text
-           .amdgcn_target "amdgcn-amd-amdsha--gfx906"
-           .protected        _Z12saxpy_kernelPKfPfj ; -- Begin  function _Z12saxpy_
-  --kernelPKfPfj
-           .glob1   _Z12saxpy_kernelPKfPfj
-           .p2align           8
-           .type     _Z12saxpy_kernelPKfPfj,@function
-_Z12saxpy_kernelPKfPfj:                                                                                                                                                                                                        
-  ; %bb.0:
-            s_load_dword s0, s[4:5], 0x4
-            s_load_dword s1, s[6:7], 0x18
-            s_waitcnt lgkmcnt(0)
-            s_and_b32 s0, s0, 0xffff
-            s_mul_i32 s8, s8, s0
-            v_add_u32_e32 v0, s8, v0
-            v_cmp_gt_u32_e32 vcc,  s1, v0
-            s_and_saveexec_b64 s[0:1], vcc
-            s_cbranch_execz.LBB0_2
-  ; %bb.1:
-            s_load_dwordx4 s[0:3], s[6:7], 0x8
-            v_mov_b32_e32 v1, 0
-            v_lshlrev_b64 v[0:1], 2, v[0:1]
-            s_waitcnt lgkmcnt(0)
-            v_mov_b32_e32 v3, s1
-            v_add_co_u32_e32 v2, vcc, s0, v0
-            v_addc_co_u32_e32 v3, vcc, v3, v1, vcc
-            global_load_dword v2, v[2:3], off
-            v_mov_b32_e32 v3, s3
-            v_add_co_u32_e32 v0, vcc, s2, v0
-            v_addc_co_u32_e32 v1, vcc, v3, v1, vcc
-            global_load_dword v3, v[0:1], off
-            s_load_dword s0, s[6:7], 0x0
-            s_waitcnt vmcnt(0) lgkmcnt(0)
-            v_fmac_f32_e32 v3, s0, v2
-            global_store_dword v[0:1], v3, off
- .LBB0_2:
-            s_endpgm
-           ...
-```
-
-## Windows and NVIDIA
-
-Unlike HIP on AMD, when compiling using the NVIDIA support for HIP, the resulting binary will be a valid CUDA executable. Therefore, it'll incorporate PTX ISA (Parallel Thread eXecution Instruction Set Architecture) instead of AMDGPU binary. As a result, tooling included with the CUDA SDK can be used to inspect which device ISA was compiled into a specific executable. The most helpful to us currently is cuobjdump .
-
-```
-<_Bash_>
-```
-
-```
-| P T X \ f i l e
-```
-
-```
-1:  saxpy. 1. sm_5. ptx
-```
-
-This example shows that the SAXPY kernel is stored as sm\_52 . It also shows that a compute capability 5.2 ISA was embedded into the executable, so devices that support compute capability 5.2 or newer will be able to run this code.
-
-Now that you've found what binary got embedded into the executable, find which format our available devices use.
-
-## Linux and AMD
-
-On Linux a utility called rocminfo helps us list all the properties of the devices available on the system, including which version of graphics IP ( gfxXYZ ) they employ. You can filter the output to have only these lines:
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?php?com/bin/rocminfo | grep gfx
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        </?php?com/bin/rocminfo | grep gfx
-                                                                                                                                                                                        
-	              Name:                                                                                                                                                                                                        &
-```
-
-Now that you know which graphics IPs our devices use, recompile your program with the appropriate parameters.
-
-```
-                                                                                                                                                                                                        |                                                                                                                                                                                                       
-                                                                                                                                                                                                        -                                                                                                                                                                                                        --                                                                                                                                                                                                        \                                                                                                                                                                                                        +                                                                                                                                                                                                        <                                                                                                                                                                                                        </                                                                                                                                                                                                        }                                                                                                                                                                                                        >                                                                                                                                                                                                        &                                                                                                                                                                                                        )                                                                                                                                                                                                        ]                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        :                                                                                                                                                                                                        ;                                                                                                                                                                                                       .                                                                                                                                                                                                        "
-```
-
-Now the sample will run.
-
-```
-        /saxpy
-        Calculating y[i] = a * x[i] + y[i] over 10000000 elements.
-        First 10 elements of the results: [ 3, 5, 7, 9, 11, 13, 15, 17, 19, 21 ]
-```
-
-```
-<_Python_>
-```
-
-## Linux and NVIDIA
-
-On Linux HIP with the NVIDIA back-end, the deviceQuery CUDA SDK sample can help us list all the properties of the devices available on the system, including which version of compute capability a device sports. &lt;major&gt;.&lt;minor&gt; compute capability is passed to nvcc on the command-line as sm\_&lt;major&gt;&lt;minor&gt; , for eg. 8.6 is sm\_86 .
-
-Because it's not included as a binary, compile the matching example from ROCm.
-
-```
-                                                                                                                                                                                                        |                                                                                                                                                                                                       
-                                                                                                                                                                                                        <.02                                                                                                                                                                                                        </.00                                                                                                                                                                                                        >.00                                                                                                                                                                                                      <.00                                                                                                                                                                                                      </.01                                                                                                                                                                                                        }
-```
-
-Filter the output to have only the lines of interest, for example:
-
-```
-<_YAML_>
-```
-
-Note: In addition to the nvcc executable is another tool called \_\_nvcc\_device\_query which prints the SM Architecture numbers to standard out as a comma separated list of numbers. The utility's name suggests it's not a user-facing executable but is used by nvcc to determine what devices are in the system at hand.
-
-Now that you know which graphics IPs our devices use, recompile your program with the appropriate parameters.
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <_arch=sm_70,sm_86
-```
-
-Note: If you want to portably target the development machine which is compiling, you may specify -arch=native instead.
-
-Now the sample will run.
-
-```
-           ./saxpy
-            Calculating y[i] = a * x[i] + y[i] over 10000000 elements.
-            First 10 elements of the results: [ 3, 5, 7, 9, 11, 13, 15, 17, 19, 21 ]
-```
-
-## Windows and AMD
-
-On Windows, a utility called hipInfo.exe helps us list all the properties of the devices available on the system, including which version of graphics IP ( gfxXYZ ) they employ. Filter the output to have only these lines:
-
-```
-& ${env:HIP_PATH}bin\hipInfo.exe | Select-String gfx
-
-gcnArchName:                    gfx1032
-gcnArchName:                    gfx1035
-```
-
-Now that you know which graphics IPs our devices use, recompile your program with the appropriate parameters.
-
-```
-                                                                                                                                                                                                        |clang++.\HIP-Basic\saxpy\main.hip -o saxpy.exe -I.\Common -lamdhip64 -L ${env:HIP_PATH}                                                                                                                                                                                                       
-                                                                                                                                                                                                        -lib -02 --offload-arch=gfx1032 --offload-arch=gfx1035                                                                                                                                                                                                        --lib -02 --offload-arch=gfx1035
-```
-
-Now the sample will run.
-
-```
-       .\saxpy.exe
-        Calculating y[i] = a * x[i] + y[i] over 10000000 elements.
-        First 10 elements of the results: [ 3, 5, 7, 9, 11, 13, 15, 17, 19, 21 ]
-```
-
-## Windows and NVIDIA
-
-On Windows HIP with the NVIDIA back-end, the deviceQuery CUDASDKsample can help us list all the properties of the devices available on the system, including which version of compute capability a device sports. &lt;major&gt;. &lt;minor&gt; compute capability is passed to nvcc on the command-line as sm\_&lt;major&gt;&lt;minor&gt; , for eg. 8.6 is sm\_86 .
-
-Because it's not included as a binary, compile the matching example from ROCm.
-
-```
-                                                                                                                                                                                                        |nvcc.\HIP-Basic\device_query\main.cpp -o device_query.exe -I.\Common -I ${env:HIP_PATH}                                                                                                                                                                                                       
-                                                                                                                                                                                                        -include -02                                                                                                                                                                                                        --include -0022
-```
-
-Filter the output to have only the lines of interest, for example:
-
-```
- .\device_query.exe | Select-String "major.minor"
-
-  major.minor:              8.6
-  major.minor:              7.0
-```
-
-Note: Next to the nvcc executable is another tool called \_\_nvcc\_device\_query.exe which simply prints the SM Architecture numbers to standard out as a comma separated list of numbers. The naming of this utility suggests it's not a user facing executable but is used by nvcc to determine what devices are in the system at hand.
-
-Now that you know which graphics IPs our devices use, recompile your program with the appropriate parameters.
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        --x                                                                                                                                                                                                        -x
-```
-
-Note: If you want to portably target the development machine which is compiling, you may specify -arch=native instead.
-
-Now the sample will run.
-
-```
-       .\saxpy.exe
-        Calculating y[i] = a * x[i] + y[i] over 10000000 elements.
-        First 10 elements of the results: [ 3, 5, 7, 9, 11, 13, 15, 17, 19, 21 ]
-```
-
-```
-<_Python_>
-```
-
-## CHAPTER
-
-## TWENTYNINE
-
-## REDUCTION
-
-Reduction is a common algorithmic operation used in parallel programming to reduce an array of elements into a shorter array of elements or a single value. This document exploits reduction to introduce some key considerations while designing and optimizing GPU algorithms.
-
-This document is a rejuvenation and extension of the invaluable work of Mark Harris. While the author approaches the topic with a less naive approach, reviewing some original material is valuable to see how much the underlying hardware has changed. This document provides a greater insight to demonstrate progress.
-
-## 29.1 The algorithm
-
-Reduction has many names depending on the domain; in functional programming it's referred to as fold, in C++, it's called std::accumulate and in C++17, as std::reduce . A reduction takes a range of inputs and 'reduces' the given range with a binary operation to a singular or scalar output. Canonically, a reduction requires a 'zero' element that bootstraps the algorithm and serves as one of the initial operands to the binary operation. The 'zero' element is generally called identity or neutral element in the group theory, which implies that it is an operand that doesn't change the result. Some typical use cases are: calculating a sum or normalizing a dataset and finding the maximum value in the dataset. The latter use case is discussed further in this tutorial.
-
-There are multiple variations of reduction that allow parallel processing. The approach taken by std::reduce requires the user-provided binary operator to operate on any combination of identity and input range elements, or even exclusively on any of them. This allows you to insert any number of identities to facilitate parallel processing and then combine the partial results of parallel execution.
-
-## 29.2 Reduction on GPUs
-
-Implementing reductions on GPUs requires a basic understanding of the /understand/programming\_model\_reference. The document explores aspects of low-level optimization best discussed through the Inherent thread model , and refrains from using cooperative groups.
-
-Synchronizing parallel threads of execution across a GPU is crucial for correctness as the partial results can't be synchronized before they manifest. Synchronizing all the threads running on a GPU at any given time is possible, however, it is a costly and intricate operation. If synchronization is not absolutely necessary, map the parallel algorithm so that multiprocessors and blocks can make independent progress and need not sync frequently.
-
-There are ten reduction implementations in the rocm-examples, which are described in the following sections.
-
-## 29.2.1 Naive shared reduction
-
-The naive algorithm takes a tree-like shape, where the computational domain is purposefully distributed among blocks. In all blocks, all threads participate in loading data from persistent (from the kernel's perspective) global memory into the shared memory. This helps to perform tree-like reduction for a single thread by writing the partial result to global, in a location unique to the block, which allows the block to make independent progress. The partial results are combined in subsequent launches of the same kernel until a scalar result is reached.
-
-This approach requires temporary storage based on the number of blocks launched, as each block outputs a scalar partial result. Depending on the need to store or destroy the input, a second temporary storage might be needed, which could be large enough to store the results of the second kernel launch. Alternatively, you can reuse the storage of the larger than necessary original input. These implementations differ so slightly that the document only considers the use case where the input could be destroyed.
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <std::size_t factor = block_size; // block_size from hipGetDeviceProperties()
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        </std::endl;
-                                                                                                                                                                                                       <int>                                                                                                                                                                                                        //                                                                                                                                                                                                       	                                                                                                                                                                                                      
-//                                                                                                                                                                                                        +                                                                                                                                                                                                        -                                                                                                                                                                                                        *                                                                                                                                                                                                        /                                                                                                                                                                                                        */
-                                                                                                                                                                                                       +
-                                                                                                                                                                                                       *
-                                                                                                                                                                                                       -
-                                                                                                                                                                                                       */
-```
-
-For threads that don't have unique inputs, feed zero\_elem instances to threads. The backing of double-buffering is allocated as such:
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <void>                                                                                                                                                                                                        </void>                                                                                                                                                                                                     
- 
-                                                                                                                                                                                                      <void><void>                                                                                                                                                                                                      <void></void>                                                                                                                                                                                                     
-
- 
-                                                                                                                                                                                                     
- 
-
-                                                                                                                                                                                                      <void>"                                                                                                                                                                                                        >void>                                                                                                                                                                                                      </void></void>                                                                                                                                                                                                    <void> 
-                                                                                                                                                                                                      </void><void>                                                                                                                                                                                                    <void></void></void>                                                                                                                                                                                                   
-   
-                                                                                                                                                                                                    <void>
-```
-
-Data is initialized on the host and dispatched to the device followed by the commencement of device-side reduction. The swapping of the double-buffer on the last iteration is omitted, therefore the result is in the back-buffer irrespective of the input size.
-
-```
-of the input size.
-
-for (uint32_t curr = input_count; curr > 1;)
-{
-      hipLaunchKernelGGL(
-           kernel,
-           dim3(new_size(curr)),
-           dim3(block_size),
-           factor * sizeof(unsigned),
-           hipStreamDefault,
-           front,
-           back,
-           kernel_op,
-```
-
-```
-1;)
-```
-
-(continues on next page)
-
-(continued from previous page)
-
-```
-        zero_elem,
-        curr);
-
-     curr = new_size(curr);
-     if (curr > 1)
-        std::swap(front, back);
-}
-```
-
-This structure persists in the kernel throughout all the variations of reduction with slight modifications to factor and shared memory allocation:
-
-```
-<_Cuda_>
-```
-
-While the tid % (2 * i) == 0 indexing scheme yields correct results, it also leads to high thread divergence. Thread divergence indicates the event when the threads in a warp diverge, which implies that the threads have to execute different instructions in a given clock cycle. This is easily manifested using if-else statements as shown here, but can also be manifested as for loop dependent on thread ID lengths. Even though the number of active threads participating in the reduction reduces, warps remain active longer than necessary, as at least one lane in a warp hits the if statement.
-
-## 29.2.2 Reducing thread divergence
-
-You can reduce divergence by keeping dataflow between memory addresses identical but reassigning the thread ids.
-
-```
-// Shared reduction
-for (uint32_t i = 1; i < blockDim.x; i *= 2)
-{
--    if (tid % (2 * i) == 0)
--        shared[tid] = op(shared[tid], shared[tid + i]);
-+    if (uint32_t j = 2 * i * tid; j < blockDim.x)
-+        shared[j] = op(shared[j], shared[j + i]);
-    __syncthreads();
-}
-```
-
-This way inactive threads start accumulating uniformly towards the higher thread ID index range and might uniformly skip to \_\_syncthreads() . However, this introduces a bank conflicts issue.
-
-## 29.2.3 Resolving bank conflicts
-
-Both AMD and NVIDIA implement shared memory in the hardware by organizing storage into banks of various sizes. This hardware element is known as Local Data Share (LDS) on AMD hardware. On NVIDIA hardware, it's implemented using the same silicon as the L1 data cache. You can think of shared memory as a striped 2-dimensional range of memory. Shared memory bank's count, width, and depth depend on the architecture. A bank conflict occurs when different threads in a warp access the same bank during the same operation. In this case, the hardware prevents the attempted concurrent accesses to the same bank by converting them into serial accesses.
-
-- 'AMD Instinct MI200' Instruction Set Architecture, Chapter 11.1
-- 'RDNA 2' Instruction Set Architecture, Chapter 10.1
-
-A notable exception is when the shared read uniformly broadcasts to the same address across the entire warp. A better implementation of the naive algorithm is to form continuous ranges of the threads activities and their memory accesses.
-
-```
-
-        implementation of the naive algorithm is to form continuous ranges of the threads activ
-        
-        // Shared reduction
-        -for (uint32_t i = 1; i < blockDim.x; i *= 2)
-        -{
-        -                                                                                                                                                                                                        
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        -f                                                                                                                                                                                                        +f
-```
-
-Note: To avoid bank conflicts, read shared memory in a coalesced manner, which implies that reads/writes of each lane in a warp evaluate to consecutive locations. Analyzing the read/write patterns could help you to understand the cause of bank conflicts. For more details, check CDNA3 ISA or RDNA3 ISA data share operations chapter.
-
-## 29.2.4 Utilize upper half of the block
-
-The preceding implementation is free of low-level GPU-specific anti-patterns. However, it still exhibits some common shortcomings. The loop performing the reduction in the shared memory starts from i = blockDim.x / 2 and the first predicate if (tid &lt; i) immediately disables half of the block, which only helps load the data into the shared memory. You can change the kernel along with the calculation of factor on the host, as shown here:
-
-```
-<_Cuda_>
-```
-
-By eliminating half of the threads and giving meaningful work to all the threads by unconditionally performing a binary op , you can prevent the wastage of half of the threads.
-
-Even though global memory is read in a coalesced fashion, as preferred by the memory controller, optimal performance is still limited by the instruction throughput. Omit superfluous synchronization -----------
-
-Warps are known to execute in a strict lockstep fashion. Therefore, once shared reduction reaches a point where only a single warp participates meaningfully, you can cut short the loop and let the rest of the warps terminate. Moreover, you can also unroll the loop without syncing the entire block.
-
-The tmp namespace used beyond this point in this document holds a handful of template meta-programmed utilities to facilitate writing flexible and optimal code.
-
-tmp::static\_for is not just a constant folding within the optimizer but a variation of the language for loop, where the running index is a compile-time constant and is eligible for use in compile-time evaluated contexts.
-
-Consider the following code:
-
-```
-constexpr int size = 4;
-for (int i = 0 ; i < size ; ++i)
-{
-    printf("%d", i);
-}
-```
-
-This compiles to the following binaries:
-
-## LLVM Block
-
-```
-LLVM Block
-main:
-    push    rbx
-    lea      rbx, [rip +.L.str]
-    mov     rdi, rbx
-    xor     esi, esi
-    xor     eax, eax
-    call    printf@PLT
-    mov     rdi, rbx
-    mov     esi, 1
-    xor     eax, eax
-    call    printf@PLT
-    mov     rdi, rbx
-```
-
-(continues on next page)
-
-```
-      mov     esi, 2
-      xor     eax, eax
-      call    printf@PLT
-      mov     rdi, rbx
-      mov     esi, 3
-      xor     eax, eax
-      call    printf@PLT
-      xor     eax, eax
-      pop     rbx
-      ret
-.L.str:
-     .asciz  "%d"
-      
- GCC
-```
-
-## GCC
-
-```
-  GCC
- .LC0:
-     .string "%d"
-  main:
-      push    rbx
-      xor     ebx, ebx
- .L2:
-      mov     esi, ebx
-      mov     edi, 0FFSET FLAT:.LC0
-      xor     eax, eax
-      add     ebx, 1
-      call    printf
-      cmp     ebx, 4
-      jne    .L2
-      xor     eax, eax
-      pop     rbx
-      ret
-
-  MSVC
-```
-
-## MSVC
-
-```
-  MSVC
-
-main     PROC
-      $LN12:
-      push    rbx
-      sub     rsp, 32
-      xor     ebx, ebx
-      npad    8
-  $LL4@main:
-      mov     edx, ebx
-      lea     rcx, OFFSET FLAT:'string'
-      call    printf
-      inc     ebx
-      cmp     ebx, 4
-      jl      SHORT $LL4@main
-      xor     eax, eax
-      add     rsp, 32
-      pop     rbx
-      ret     0
-  main    ENDP
-```
-
-(continued from previous page)
-
-LLVM unrolls the loop and compiles to a flat series of printf invocations, while both GCC and MSVC keep the loop intact, as visible from the compare ( cmp ) and the jump ( jne , jl ) instructions. LLVM code generation is identical to manually writing the unrolled loop:
-
-```
-printf("%d", 0);
-printf("%d", 1);
-printf("%d", 2);
-printf("%d", 3);
-```
-
-While various non-standard pragmas are available to hint or force the compiler to unroll the loop, we instead use template meta-programming to force feed the compiler the unrolled loop.
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?xml version="1.0" encoding="UTF-8" />
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        </?xml version="1.0" encoding="UTF-8" />
-```
-
-The most notable structural difference is that in the language for loop, the loop variable is given a name in the beginning, while in the static\_for utility, the loop variable is given a name in the end. An important bonus is that in the loop's body, you can use the running index i in contexts requiring constant expressions such as template arguments or inside if constexpr .
-
-tmp::static\_switch takes runtime value and runtime dispatches to a range of set of tabulated functions, where said value is a compile-time constant and is eligible for use in compile-time evaluated contexts.
-
-Consider the following code:
-
-```
-        Consider the following code:
-
-        int  warp_size  = device_props.warpSize;
-
-        switch  (warp_size)
-
-        {
-
-        case  32:
-
-            hipLaunchKernelGGL(kernel<32>, ...);
-
-            break;
-
-        case  64:
-
-            hipLaunchKernelGGL(kernel<64>, ...);
-
-            break;
-
-        }
-```
-
-In the preceding code, note the code repetition for all possible values of warp\_size , the code is prepared to handle. To avoid this, use tmp::static\_switch , as shown:
-
-```
-  tmp::static_switch<std::array{32, 64}>(warp_size, [&]<int WarpSize>
-  {
-      hipLaunchKernelGGL(kernel<WarpSize>,...);
-  });
-```
-
-```
-
-t WarpSize>()
-```
-
-```
-
-        HIP Documentation, Release 6.1.40092
-
-
-        
-        -template<typename T, typename F>
-        +template<uint32_t WarpSize, typename T, typename F>
-        __global__ void kernel(
-           ...
-        )
-        {
-           ...
-        // Shared reduction
-        -for (uint32_t i = blockDim.x / 2; i!= 0; i /= 2)
-        +for (uint32_t i = blockDim.x / 2; i > WarpSize; i /= 2)
-        {
-            if (tid < i)
-                shared[tid] = op(shared[tid], shared[tid + i]);
-            __syncthreads();
-        }
-        +// Warp reduction
-        +tmp::static_for<WarpSize, tmp::not_equal<0>, tmp::divide<2>>([&]<int I>()
-        +{
-        +     if (tid < I)
-        +          shared[tid] = op(shared[tid], shared[tid + I]);
-        +#ifdef __HIP_PLATFORM_NVIDIA__
-        +     __syncwarp(0xffffffff >> (WarpSize - I));
-        +#endif
-        +});
-
-        Because HIP typically targets hardware with warp sizes of 32(NVIDIA GPUs and RDNA AMD GPUs) and 64 (CD!
-        AMD GPUs), portable HIP code must handle both. That is why instead of assuming a warp size of 32, make the w:
-        size a template argument of the kernel. This allows you to unroll the final loop using tmp::static_for in a paramet
-```
-
-Because HIP typically targets hardware with warp sizes of 32 (NVIDIA GPUs and RDNA AMD GPUs) and 64 (CDNA AMDGPUs), portable HIP code must handle both. That is why instead of assuming a warp size of 32, make the warp size a template argument of the kernel. This allows you to unroll the final loop using tmp::static\_for in a parametric way but still having the code read much like an ordinary loop.
-
-Promoting the warp size to being a compile-time constant also requires you to handle it similarly on the host-side. You can sandwich the kernel launch with tmp::static\_switch , promoting the snake-case run-time warp\_size variable to a camel-case compile-time constant WarpSize .
-
-```
-<_C++_>
-```
-
-Note: Neither RDNA- nor CDNA-based AMD hardware provides guaranteed independent progress to lanes of the same warp. When targeting NVIDIA hardware, lanes of a warp might execute somewhat independently as long as the programmer assists the compiler using dedicated built-in functions. This feature is called Independent Thread Scheduling. The HIP headers don't expose the necessary warp primitives and their overloads.
-
-Portable applications can still tap into this feature with carefully #ifdef -ed code, but at this particular optimization level, it's a requirement. The code implicitly relies on the lockstep behavior of an ROCm wavefront, but CUDA warps don't share this property. You must synchronize all the active lanes of a warp to avoid a data race with some lanes progressing faster than others in the same warp.
-
-## 29.2.5 Unroll all loops
-
-While the previous step primarily aims to remove unnecessary syncing, it also unrolls the end of the loop. However, you could also force unrolling the first part of the loop. This saves a few scalar registers (values the compiler can prove to be uniform across warps).
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <Linear                                                                                                                                                                                                        </Linear                                                                                                                                                                                                      <Linar                                                                                                                                                                                                        >                                                                                                                                                                                                        &Linear                                                                                                                                                                                                     
- 
-                                                                                                                                                                                                      <Lin                                                                                                                                                                                                        +                                                                                                                                                                                                        -                                                                                                                                                                                                        |                                                                                                                                                                                                        }                                                                                                                                                                                                        \
-                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       <L                                                                                                                                                                                                        1                                                                                                                                                                                                        0
-```
-
-Introducing yet another template argument for the kernel and moving from for to tmp::static\_for leads to the following two notable improvements:
-
-- Introducing new attribute \_\_launch\_bounds\_\_(BlockSize) to the kernel instructs the compiler that the kernel will only be launched using the designated block size. This implies that the launches of differing block sizes will fail. This allows the optimizer to enroll the blockDim.x variable in constant folding as well as get information about register usage.
-- Turning the block size into a compile-time constant allows you to statically allocate the shared memory.
-
-## 29.2.6 Communicate using warp-collective functions
-
-Shared memory provides a fast communication path within a block, however when performing reduction within the last warp, you can use faster means of communication, which is warp-collective or cross-lane functions. Instead of using the hardware-backed shared memory, you can directly copy between the local memory (registers) of each lane in a warp. This can be achieve using the shuffle functions.
-
-See how to use \_\_shfl\_down() , which is one of the most restrictive but also the most structured communication schemes.
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        // Warp reduction
-```
-
-Using warp-collective functions for communication requires the control flow to be uniform across warps, as the name warp-collective implies. Therefore, you can see that the thread ID is being checked outside the loop, but the result is written inside due to variable scoping.
-
-## 29.2.7 Prefer warp communication over shared
-
-As mentioned in the previous step, communication between local memory is faster than shared memory. Instead of relying on the local memory only at the end of the tree-like reduction, a better approach is to turn the tree reduction inside out and perform multiple warp reductions in parallel on all active threads, thus communicating only their partial results through the shared memory.
-
-The kernel versions differ significantly enough to be described using a diff; use afresh instead.
-
-```
-        The kernel versions differ significantly enough to be described using a diff; use afresh instead.
-
-        template<uint32_t BlockSize,  uint32_t WarpSize,  typename  T,  typename  F>
-        __global__ __launch_bounds__(BlockSize)  void kernel(
-            T*  front,
-            T*  back,
-            F  op,
-            T zero_elem,
-            uint32_t  front_size)
-        {
-            // ...
-        }
-
-        The kernel estimate and the reduction factor as the comma as in variance access only the imlamantation diffar.
-```
-
-The kernel signature and the reduction factor are the same as in previous cases; only the implementation differs.
-
-```
-static constexpr uint32_t WarpCount = BlockSize / WarpSize;
-
-__shared__ T shared[WarpCount];
-
-auto read_global_safe =
-    [&](const uint32_t i) { return i < front_size? front[i] : zero_elem; };
-auto read_shared_safe =
-    [&](const uint32_t i) { return i < WarpCount? shared[i] : zero_elem; };
-
-const uint32_t tid = threadIdx.x,
-                     bid = blockIdx.x,
-                     gid = bid * (blockDim.x * 2) + tid,
-                     wid = tid / WarpSize,
-                     lid = tid % WarpSize;
-
-// Read input from front buffer to local
-T res = op(read_global_safe(gid), read_global_safe(gid + blockDim.x));
-
-As we communicate the results of warps through shared memory, the same number of elements are required in the
-shared memory as warps within the block. Similar to how you can only launch kernels at block granularity. you can
-```
-
-As we communicate the results of warps through shared memory, the same number of elements are required in the shared memory as warps within the block. Similar to how you can only launch kernels at block granularity, you can only warp reduce with WarpSize granularity due to the collective nature of the cross-lane builtins. To address this, you can use read\_shared\_safe to pad overindexing by reading zero\_elem . Reading from global remains unaffected. // Perform warp reductions and communicate results via shared // for (uint32\_t ActiveWarps = WarpCount; // ActiveWarps != 0; // ActiveWarps = ActiveWarps != 1 ? // divide\_ceil(ActiveWarps, WarpSize) : // ActiveWarps = 0) tmp::static\_for&lt; WarpCount, tmp::not\_equal&lt;0&gt;, tmp::select&lt; tmp::not\_equal&lt;1&gt;, tmp::divide\_ceil&lt;WarpSize&gt;, tmp::constant&lt;0&gt;&gt;&gt;([&amp;]&lt; uint32\_t ActiveWarps&gt;() { if (wid &lt; ActiveWarps) { // Warp reduction tmp::static\_for&lt;WarpSize / 2, tmp::not\_equal&lt;0&gt;, tmp::divide&lt;2&gt;&gt;([&amp;]&lt; int Delta&gt;() { res = op(res, \_\_shfl\_down(res, Delta)); }); // Write warp result from local to shared if (lid == 0) shared[wid] = res; } \_\_syncthreads(); // Read warp result from shared to local res = read\_shared\_safe(tid); (continues on next page)
-
-(continued from previous page)
-
-```
-});
-
-// Write result from local to back buffer
-if(tid == 0)
-    back[bid] = res;
-```
-
-ActiveWarps iterates from WarpCount until it reaches 0 . Every iteration of ActiveWarps reduces the WarpSize . In cases where the partial result count isn't a divisor of ActiveWarps and you need to launch an extra warp, use tmp::divide\_ceil , which always rounds to positive infinity. The tertiary tmp::select is required because such division never reaches 0 , so you must terminate the loop after the last warp concludes.
-
-In each iteration, if the warp is active, which means it has at least a single valid input, it carries out a pass of warp reduction and writes output based on warp ID. Reading is carried out based on thread ID. Global output continues to be based on block ID.
-
-## 29.2.8 Amortize bookkeeping variable overhead
-
-The previous sections explained how to reduce register usage to improve occupancy. This allows more blocks to execute in parallel on all multiprocessors, leading to more global store/load latency to be hidden. Reducing the number of kernels in flight while still carrying out the same workload reduces the wastage of registers while loading and maintaining bookkeeping variables such as kernel indices.
-
-An example of this optimization is performing one binary op while loading input from global. Even though the operation is said to be carried out 'in flight', the two values are loaded into local memory (registers) before op is called.
-
-Amore general form of this optimization is wrapping most kernel logic in loops that carry out the workload of multiple kernel instances but require storing only a single instance of most of the bookkeeping logic. In code, this multiplicity factor is referred to via the ItemsPerThread compile-time constant, which is supplied by a template argument to allow for loop unrolling.
-
-This kernel variant utilizes another generally applicable utility known as hip::static\_array , which is a more restrictive wrapper over the builtin array than std::array , as it allows indexing only compile-time constants using the usual tuple-like template &lt;size\_t I&gt; auto get&lt;I&gt;(...) interface.
-
-Note: On a GPU, there is no stack, and the local memory is provisioned from the register file. This provisioning takes place statically. To paraphrase, the address range of a thread's local memory is determined at compile-time. When an array is defined and used in the local storage, the compiler can only maintain its storage in the register file as long as all accesses to the array are computable by the compiler at compile-time. It doesn't need to be a compile-time constant as long as the compiler can resolve the addresses of the accesses through constant folding or some other means. If the compiler fails to do so, the array will be backed by global memory, which is indicated by allocating a non-zero number of spill registers observable using static analysis tools. However, this is slower by the magnitude of multiple order. hip::static\_array via its hip::get&lt;&gt; interface ensures that no such spills occur.
-
-```
-_t  ItemsPerThread>
-```
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        --global__ static __launch_bounds__(BlockSize) void kernel(...)
-```
-
-The kernel now has three compile-time configurable parameters. The only part of the kernel that changes depends on how you load data from global and perform the binary operation on those loaded values. So, the following step to read input from front buffer to global is now split into two steps: reading ``ItemsPerThread` &lt;reading-items&gt;`and processing ``ItemsPerThread` &lt;processing-items&gt;`.
-
-```
-<_C_>
-```
-
-## 29.2.8.1 Reading ItemsPerThread
-
-The change to reading happens inside read\_global\_safe :
-
-```
-        The change to reading happens inside read_global_safe:
-        auto  read_global_safe = [&](const  int32_t  i)  -> hip::static_array<T,  ItemsPerThread>
-        {
-            return  [&]<int32_t...  I>(std::integer_sequence<int32_t,  I...>)
-            {
-                if(i + ItemsPerThread < front_size)
-                        return hip::static_array<T,  ItemsPerThread>{
-                              front[i + I]...
-                        };
-                else
-                        return hip::static_array<T,  ItemsPerThread>{
-                              (i + I < front_size? front[i + I] : zero_elem)...
-                        };
-            }(std::make_integer_sequence<int32_t,  ItemsPerThread>());
-        };
-
-        Note that each array element is being loaded consecutively without the flexibility of a configurable ItemsPerThread
-```
-
-Note that each array element is being loaded consecutively without the flexibility of a configurable ItemsPerThread property. This is morally equivalent to:
-
-```
-T arr[4] = {
-    front[gid + 0],
-    front[gid + 1],
-    front[gid + 2],
-    front[gid + 3]
-}
-```
-
-This is exactly what's happening in the front[i + I]... fold-expression. However, this can only be issued if the entire read operates on real input without padding using zero\_elem . If some reads over-index the input, the read turns into:
-
-```
-T arr[4] = {
-    i + 0 < front_size? front[i + 0] : zero_elem,
-    i + 1 < front_size? front[i + 1] : zero_elem,
-    i + 2 < front_size? front[i + 2] : zero_elem,
-    i + 3 < front_size? front[i + 3] : zero_elem
-}
-```
-
-This makes it easier for the compiler to recognize vector loads from global. As the performance at large is dominated by how you move the data, it's only natural to utilize dedicated instructions to move more data with less binary. This is evident by the huge performance improvement when loading two values per thread. For more information, see the compiler explorer to learn how loading for AMD (both RDNA and CDNA) compiles to global\_load\_dwordx4 , where x4 denotes the 4-vector variant of the instruction.
-
-Note: Note that read\_global\_safe , which used to take an uint32\_t as the index type, now takes a signed integer. When indexing an array with unsigned integers, the compiler has to handle integer overflows, as the C/C++ standards defined them. It might happen that some part of the vector load indices overflow, thus resulting in a non-contiguous
-
-read. If you change the previously linked code to use an unsigned integer as the thread ID, the compiler won't emit a vector load. Signed integer overflow is an undefined behavior, and hence, unknown to the optimizer. To convey the absence of overflow to the compiler with unsigned indices, add \_\_builtin\_assume(gid + 4 &gt; gid) , or the more portable [[assume]](gid + 4 &gt; gid) , once amdclang++ supports it.
-
-read\_global\_safe implementation is an Immediately Invoked Lambda Expression (IILE), because ItemsPerThread is an integer value, while you need a compile-time iota -like sequence of integers as a pack for the fold-expressions to expand on. This can only occur as part of template argument deduction on the IILE.
-
-## 29.2.8.2 Processing ItemsPerThread
-
-Once the kernel reads ItemsPerThread number of inputs to local, it immediately reduces them to a scalar. There is no reason to propagate the input element multiplicity to the warp reduction phase.
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        <?>                                                                                                                                                                                                        </?>
-```
-
-## 29.2.9 Two-pass reduction
-
-Alter kernel launch and input fetching such that no more blocks are launched than what a subsequent kernel launch's single block can conveniently reduce, while performing multiple passes of input reading from global and combining their results before engaging in the end game tree-like reduction.
-
-With this method, you can save at least one to two kernel launches for large inputs.
-
-## 29.2.10 Global data share
-
-Warning: This modification can only be executed on AMD hardware.
-
-Perform the first step of the two-pass reduction, but in the end, instead of writing to global and reading it back in a subsequent kernel, write the partial results to the Global Data Share (GDS). This is an N+1 th shared memory that is accessed by all multiprocessors and is also on-chip memory.
-
-Note: The API doesn't guarantee the order in which blocks are scheduled even though all GPUs schedule them in the same monotonically increasing order of block ids. Relying on this implicitly, the last block of a grid is in the optimal position to observe the side effects of all other blocks (using spinlocks or other methods) without occupying a multiprocessor for longer than necessary.
-
-Without launching a second kernel, you can make the last block collect the results of all other blocks from GDS by implicitly exploiting the scheduling behavior or relying on another AMD-specific feature called Global Wave Sync (GWS) to merge them for a final tree-like reduction.
-
-Note: GDS and GWS are reserved runtime features that the HIP API doesn't cover. Invoking these functionalities requires inline AMDGCN assembly. Moreover, the fact that the runtime doesn't virtualize the GDS, imposes further restrictions on concurrent scheduling of other kernels.
-
-## 29.3 Conclusion
-
-Optimizing code on GPUs, like on any other architecture, requires careful consideration and balancing of resources and costs of various operations to obtain optimal performance. This document explored optimizing reductions much beyond the territory of diminishing returns. This approach introduced multiple optimization techniques and discussed opportunities.
-
-The document focused on reductions when an entire device participates in it. Still, the choice of optimal compile-time constants or even the algorithm itself might not be optimal when its multiple blocks participate in multiple parallel reductions or when each thread performs its reduction. However, when multiple devices participate in the same reduction, other aspects must be considered.
-
-Most solutions, including the ones covered in this document, are given to the end users in a turnkey fashion via algorithm primitive libraries. These solutions might not be the fastest in all cases, but they are close to being the gold standard for carrying out certain operations as reasonably as possible.
-
-CHAPTER
-
-## THIRTY
-
-## COOPERATIVE GROUPS
-
-This tutorial demonstrates the basic concepts of cooperative groups in the HIP (Heterogeneous-computing Interface for Portability) programming model and the most essential tooling supporting it. This topic also reviews the commonalities of heterogeneous APIs. Familiarity with the C/C++ compilation model and the language is assumed.
-
-## 30.1 Prerequisites
-
-To follow this tutorial, you'll need properly installed drivers and a HIP compiler toolchain to compile your code. Because ROCm HIP supports compiling and running on Linux and Microsoft Windows with AMD and NVIDIA GPUs, review the HIP development package installation before starting this tutorial. For more information, see Install HIP .
-
-## 30.2 Simple HIP Code
-
-To become familiar with heterogeneous programming, review the SAXPY tutorial and the first HIP code subsection. Compiling is also described in that tutorial.
-
-## 30.3 Tiled partition
-
-You can use tiled partition to calculate the sum of partition\_size length sequences and the sum of result\_size / BlockSize length sequences. The host-side reference implementation is the following:
-
-```
-    You can use ued partition to calculate the sum or partition_size length sequences and the sum or result_size/
-    BlockSize length sequences. The host-side reference implementation is the following:
-    
-    // Host-side function to perform the same reductions as executed on the GPU
-    std::vector<unsigned int> ref_reduced(const unsigned int          partition_size,
-                                                   std::vector<unsigned int> input)
-    {
-        const unsigned int          input_size  = input.size();
-        const unsigned int          result_size = input_size / partition_size;
-        std::vector<unsigned int> result(result_size);
-
-        for(unsigned int i = 0; i < result_size; i++)
-        {
-            unsigned int partition_result = 0;
-            for(unsigned int j = 0; j < partition_size; j++)
-            {
-                partition_result += input[partition_size * i + j];
-            }
-                                                                                                                                                                                                         (continues on next page)
-```
-
-(continues on next page)
-
-```
-            result[i] = partition_result;
-        }
-
-        return result;
-    }
-```
-
-## 30.3.1 Device-side code
-
-To calculate the sum of the sets of numbers, the tutorial uses the shared memory-based reduction on the device side. The warp level intrinsics usage is not covered in this tutorial, unlike in the reduction tutorial. x input variable is a shared pointer, which needs to be synchronized after every value change. The thread\_group input parameter can be thread\_block\_tile or thread\_block because the thread\_group is the parent class of these types. The val are the numbers to calculate the sum of. The returned results of this function return the final results of the reduction on thread ID 0 of the thread\_group , and for every other thread, the function results are 0.
-
-```
-        The warp level intrinsics usage is not covered in this tutorial, unlike in the reduction tutorial. x input variable is a
-        shared pointer, which needs to be synchronized after every value change. The thread_group input parameter can be
-        thread_block_tile or thread_block because the thread_group is the parent class of these types. The val are
-        the numbers to calculate the sum of. The returned results of this function return the final results of the reduction on
-        thread ID 0 of the thread_group, and for every other thread, the function results are 0.
-
-        /// \brief Summation of `unsigned int val`s in `thread_group g` using shared memory `x`
-        __device__ unsigned int reduce_sum(thread_group g, unsigned int* x, unsigned int val)
-    {
-            // Rank of this thread in the group
-            const unsigned int group_thread_id = g.thread_rank();
-
-            // We start with half the group size as active threads
-            // Every iteration the number of active threads halves, until we processed all values
-            for(unsigned int i = g.size() / 2; i > 0; i /= 2)
-            {
-                // Store value for this thread in a shared, temporary array
-                x[group_thread_id] = val;
-
-                // Synchronize all threads in the group
-                g.sync();
-
-                // If our thread is still active, sum with its counterpart in the other half
-                if(group_thread_id < i)
-                {
-                    val += x[group_thread_id + i];
-                }
-
-                // Synchronize all threads in the group
-                g.sync();
-            }
-
-            // Only the first thread returns a valid value
-            if(g.thread_rank() == 0)
-                return val;
-            else
-                return 0;
-    }
-
-        The reduce_sum device function is reused to calculate the block and custom partition sum of the input numbers. The
-        kernel has three sections:
-
-        1. Initialization of the reduction function variables.
-```
-
-The reduce\_sum device function is reused to calculate the block and custom partition sum of the input numbers. The kernel has three sections:
-
-1. Initialization of the reduction function variables.
-
-(continued from previous page)
-
-2. The reduction of thread block and store the results in global memory.
-3. The reduction of custom partition and store the results in global memory.
-
-## 30.3.1.1 1. Initialization of the reduction function variables
-
-In this code section, the shared memory is declared, the thread\_block\_group and custom\_partition are defined, and the input variables are loaded from global memory.
-
-```
-
-
-in this code section, the shared memory is declared, the thread_block_group and custom_partition are define
-input variables are loaded from global memory.
-
-// threadBlockGroup consists of all threads in the block
-thread_block thread_block_group = this_thread_block();
-
-// Workspace array in shared memory required for reduction
-__shared__ unsigned int workspace[2048];
-
-unsigned int output;
-
-// Input to reduce
-const unsigned int input = d_vector[thread_block_group.thread_rank()];
-
-//...
-
-// Every custom_partition group consists of 16 threads
-thread_block_tile<PartitionSize> custom_partition
-           = tiled_partition<PartitionSize>(thread_block_group);
-
-
-
-as a 2 - 2 The read-line of thread block
-```
-
-## 30.3.1.2 2. The reduction of thread block
-
-In this code section, the sum is calculated on thread\_block\_group level, then the results are stored in global memory.
-
-```
-// Perform reduction
-output = reduce_sum(thread_block_group, workspace, input);
-
-// Only the first thread returns a valid value
-if(thread_block_group.thread_rank() == 0)
-{
-    d_block_reduced_vector[0] = output;
-}
-```
-
-## 30.3.1.3 3. The reduction of custom partition
-
-In this code section, the sum is calculated on the custom partition level, then the results are stored in global memory. The custom partition is a partial block of the thread block, it means the reduction calculates on a shorter sequence of input numbers than at the thread\_block\_group case.
-
-```
-                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        // Perform reduction                                                                                                                                                                                                        }
-                                                                                                                                                                                                      
-output = reduce_sum(custom_partition, &workspace[group_offset], input);
-
-                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       // Only the first thread in each partition returns a valid value                                                                                                                                                                                                        \
-                                                                                                                                                                                                       \
-
-                                                                                                                                                                                                       \
-```
-
-(continued from previous page)
-
-```
-        const unsigned int partition_id           = thread_block_group.thread_rank() /\__
-        ~PartitionSize;
-        d_partition_reduced_vector[partition_id] = output;
-    }
-```
-
-## 30.3.2 Host-side code
-
-On the host-side, the following steps are done in the example:
-
-1. Confirm the cooperative group support on AMD GPUs.
-2. Initialize the cooperative group configuration.
-3. Allocate and copy input to global memory.
-4. Launch the cooperative kernel.
-5. Save the results from global memory.
-6. Free the global memory.
-
-Only the first, second and fourth steps are important from the cooperative groups aspect, that's why those steps are detailed further.
-
-## 30.3.2.1 1. Confirm the cooperative group support on AMD GPUs
-
-Not all AMD GPUs support cooperative groups. You can confirm support with the following code:
-
-```
-<_C++_>
-```
-
-## 30.3.2.2 2. Initialize the cooperative group configuration
-
-In the example, there is only one block in the grid, and the threads\_per\_block must be dividable with partition\_size .
-
-```
-<_C_>
-```
-
-## 30.3.2.3 4. Launch the kernel
-
-The kernel launch is done with the hipLaunchCooperativeKernel of the cooperative groups API.
-
-```
-        The kernel launch is done with the hipLaunchCooperativeKernel of the cooperative groups API.
-        void* params[] = {&d_vector,  &d_block_reduced,  &d_partition_reduced};
-        // Launching kernel from host.
-        HIP_CHECK(hipLaunchCooperativeKernel(vector_reduce_kernel<partition_size>,
-```
-
-## 30.4 Conclusion
-
-With cooperative groups, you can easily use custom partitions to create custom tiles for custom solutions. You can find the complete code at cooperative groups ROCm example.
-
-## CHAPTER
-
-## THIRTYONE
-
-## LICENSE
-
-Copyright © 2008 - 2024 Advanced Micro Devices, Inc.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-## INDEX
-
-| C                                                                                                           | hipArrayCreate ( C++ function ), 183                                                                        |    |     |      |     |          |
-|-------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------|----|-----|------|-----|----------|
-| cooperative_groups::coalesced_group class ), 237                                                            | C++ hipArrayDestroy ( C++ function ), 183 hipArrayGetDescriptor ( C++ function ), 185 ( C++ function ), 185 | (  |     |      |     |          |
-| cooperative_groups::grid_group ( C++ class ), 234                                                           | hipArrayGetInfo hipCreateSurfaceObject ( C++ function ), 133                                                |    |     |      |     |          |
-| cooperative_groups::multi_grid_group ( C++                                                                  | ( C++ function ), 197                                                                                       |    |     |      |     |          |
-| class ), 234 cooperative_groups::thread_block ( C++                                                         | ), hipDestroyExternalMemory ( C++ function ), 196                                                           |    |     |      |     |          |
-| class 234                                                                                                   | hipDestroyExternalSemaphore hipDestroySurfaceObject ( C++ function ), 133 C++ function                      |    |     |      |     |          |
-| cooperative_groups::thread_block_tile ( C++ class ), 234                                                    | hipDeviceCanAccessPeer ( ), 163 hipDeviceDisablePeerAccess ( C++ function ), 164 ( C++ function ), 163      |    |     |      |     |          |
-| cooperative_groups::thread_block_tile::all ( C++ function ), 236 cooperative_groups::thread_block_tile::any | hipDeviceEnablePeerAccess hipDeviceGetStreamPriorityRange ( C++ function ), 148                             |    |     |      |     |          |
-| ( C++ function ), 236                                                                                       | hipDrvMemcpy3D ( C++ function ), 192                                                                        |    |     |      |     |          |
-| cooperative_groups::thread_block_tile::ballot                                                               | hipDrvMemcpy3DAsync ( C++ function ), 192                                                                   |    |     |      |     |          |
-|                                                                                                             | hipDrvPointerGetAttributes ( C++ function ), 166                                                            |    |     |      |     |          |
-| ( C++ function ), 236                                                                                       |                                                                                                             |    |     |      |     |          |
-| cooperative_groups::thread_block_tile::match_all                                                            | hipExternalMemoryGetMappedBuffer ( C++ func- tion ), 196                                                    |    |     |      |     |          |
-| ( C++ function ), 237 cooperative_groups::thread_block_tile::match_any                                      | hipExternalMemoryGetMappedMipmappedArray ( C++ function ), 197 hipExtMallocWithFlags ( C++ function ), 167  |    | 236 | ( ), | C++ | function |
-| cooperative_groups::thread_block_tile::meta_group_rank ( C++ function ), 235                                | hipExtStreamCreateWithCUMask ( C++function ), 151 hipExtStreamGetCUMask ( C++ function ), 152               |    |     |      |     |          |
-|                                                                                                             | hipFree ( C++ function ), 171 hipFreeArray ( C++ function ), 184                                            |    |     |      |     |          |
-| cooperative_groups::thread_block_tile::meta_group_size ( C++ function ), 235                                | hipFreeAsync                                                                                                |    |     |      |     |          |
-| cooperative_groups::thread_block_tile::shfl ( C++ function ), 235                                           |                                                                                                             |    |     |      |     |          |
-|                                                                                                             | ( C++ function ), 154                                                                                       |    |     |      |     |          |
-| cooperative_groups::thread_block_tile::shfl_down                                                            |                                                                                                             |    |     |      |     |          |
-| ( C++ function ), 235                                                                                       | hipFreeHost ( C++ function ), 172 hipGetProcAddress ( C++ function ), 176                                   |    |     |      |     |          |
-| cooperative_groups::thread_block_tile::shfl_up                                                              | hipGetSymbolAddress ( C++ function ), 176, 193 ( C++ function ), 176, 193                                   |    |     |      |     |          |
-| ( C++ function ), 235                                                                                       | hipHostAlloc ( C++ function ), 168 hipHostFree ( C++ function ), 172                                        |    |     |      |     |          |
-| ( C++ function ), 236                                                                                       | ( C++ function ),                                                                                           |    |     |      |     |          |
-| cooperative_groups::thread_block_tile::sync ( C++ function ), 235                                           | 169 ( C++ function ), 169                                                                                   |    |     |      |     |          |
-| cooperative_groups::thread_block_tile::thread_rank ( C++ function ), 235 ),                                 | ( C++ function ), 169                                                                                       |    |     |      |     |          |
-| cooperative_groups::thread_group ( C++ class                                                                | ( C++ function ), 170 ( C++ function ),                                                                     |    |     |      |     |          |
-| 234                                                                                                         | 196 ( C++ function ),                                                                                       |    |     |      |     |          |
-|                                                                                                             | ( C++ function ), 166, 194                                                                                  |    |     |      |     |          |
-| H                                                                                                           | hipMalloc hipMalloc3D                                                                                       |    |     |      |     |          |
-|                                                                                                             | ( C++ function ), 184                                                                                       |    |     |      |     |          |
-| hipArray3DCreate ( C++ function ), 183                                                                      |                                                                                                             |    |     |      |     |          |
-| 185                                                                                                         | hipMalloc3DArray ( C++ function ),                                                                          |    |     |      |     |          |
-| hipArray3DGetDescriptor ( C++ function ),                                                                   |                                                                                                             |    |     |      |     |          |
-|                                                                                                             | 195                                                                                                         |    |     |      |     |          |
-|                                                                                                             | 184                                                                                                         |    |     |      |     |          |
-|                                                                                                             | hipImportExternalSemaphore                                                                                  |    |     |      |     |          |
-|                                                                                                             | hipImportExternalMemory                                                                                     |    |     |      |     |          |
-|                                                                                                             | hipHostMalloc ( C++ function ), 168, 194 hipHostRegister hipHostUnregister                                  |    |     |      |     |          |
-|                                                                                                             | hipHostGetDevicePointer hipHostGetFlags                                                                     |    |     |      |     |          |
-|                                                                                                             | hipGetSymbolSize                                                                                            |    |     |      |     |          |
-|                                                                                                             | cooperative_groups::thread_block_tile::shfl_xor                                                             |    |     |      |     |          |
-
-| hipMallocArray ( C++ function ), 182 ( C++ function ), 152,                                |
-|--------------------------------------------------------------------------------------------|
-| 153 hipMallocFromPoolAsync ( C++ function ), 153, 160                                      |
-| hipMallocHost ( C++ function ), 167                                                        |
-| hipMallocManaged ( C++ function ), 247, 249                                                |
-| hipMallocPitch ( C++ function ), 170                                                       |
-| hipMemAddressFree ( C++ function ), 251                                                    |
-| hipMemAddressReserve ( C++ function ), 251                                                 |
-| hipMemAdvise ( C++ function ), 247                                                         |
-| hipMemAllocHost ( C++ function ), 167                                                      |
-| hipMemAllocPitch ( C++ function ), 171                                                     |
-| hipMemcpy ( C++ function ), 172                                                            |
-| hipMemcpy2D ( C++ function ), 186                                                          |
-| hipMemcpy2DAsync ( C++ function ), 187                                                     |
-| hipMemcpy2DFromArray ( C++ function ), 190                                                 |
-| hipMemcpy2DFromArrayAsync ( C++ function ), 190                                            |
-| hipMemcpy2DToArray ( C++ function ), 188                                                   |
-| hipMemcpy2DToArrayAsync ( C++ function ), 188                                              |
-| hipMemcpy3D ( C++ function ), 191                                                          |
-| hipMemcpy3DAsync ( C++ function ), 192                                                     |
-| hipMemcpyAsync ( C++ function ), 178                                                       |
-| hipMemcpyAtoH ( C++ function ), 191                                                        |
-| hipMemcpyDtoD ( C++ function ), 174                                                        |
-| hipMemcpyDtoDAsync ( C++ function ), 175 hipMemcpyDtoH ( C++ function ), 174               |
-| hipMemcpyDtoHAsync ( C++ function ), 175                                                   |
-| hipMemcpyFromArray ( C++ function ), 189                                                   |
-| hipMemcpyFromSymbol ( C++ function ),                                                      |
-| 177,                                                                                       |
-| 194 hipMemcpyFromSymbolAsync ( C++ function ), 178, 194                                    |
-| hipMemcpyHtoA ( C++ function ), 191                                                        |
-| hipMemcpyHtoD ( C++ function ), 173 hipMemcpyHtoDAsync ( C++ function ),                   |
-| hipMemcpyParam2D ( C++ function ),                                                         |
-| 174 186                                                                                    |
-| hipMemcpyParam2DAsync ( C++ function ),                                                    |
-| 187 hipMemcpyToArray ( C++ function ), 189 ( C++ function ), 177,                          |
-| hipMemcpyToSymbol 193 hipMemcpyToSymbolAsync ( C++ function ), 193                         |
-| 177, ( C++ function ), 173                                                                 |
-| hipMemcpyWithStream hipMemCreate ( C++ function ), 252                                     |
-| hipMemExportToShareableHandle (                                                            |
-| C++ function 252 ( C++ function ), 252                                                     |
-| hipMemGetAddressRange ( C++ function ), 164 hipMemGetAllocationGranularity ( C++           |
-| function 253 hipMemGetAllocationPropertiesFromHandle                                       |
-| ( C++ function ), 253                                                                      |
-| hipMemGetInfo ( C++ function ), 182 hipMemImportFromShareableHandle ( C++ function         |
-| 253 hipMemMap ( C++ function ), 254 hipMemMapArrayAsync ( C++ function ), hipMemPoolCreate |
-| 254 ( C++ function ), 158                                                                  |
-| hipMemPoolDestroy 159                                                                      |
-| ( C++ function ),                                                                          |
-
-C++ function
-
-(
-
-), 162
-
-| hipMemPoolExportPointer hipMemPoolExportToShareableHandle ( C++                          | func-                                                                                    |
-|------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------|
-| tion ), 160                                                                              | tion ), 160                                                                              |
-| hipMemPoolGetAccess ( C++ function ), 158 hipMemPoolGetAttribute ( C++ function ), 156   | hipMemPoolGetAccess ( C++ function ), 158 hipMemPoolGetAttribute ( C++ function ), 156   |
-| hipMemPoolImportFromShareableHandle function ), 161                                      | ( C++                                                                                    |
-| hipMemPoolImportPointer ( C++ function ), 162 hipMemPoolSetAccess ( C++ function ), 157  | hipMemPoolImportPointer ( C++ function ), 162 hipMemPoolSetAccess ( C++ function ), 157  |
-| hipMemPoolSetAttribute ( C++ function ), 156                                             | hipMemPoolSetAttribute ( C++ function ), 156                                             |
-| hipMemPoolTrimTo ( C++ function ), 155                                                   | hipMemPoolTrimTo ( C++ function ), 155                                                   |
-| hipMemPrefetchAsync ( C++ function ), 247                                                | hipMemPrefetchAsync ( C++ function ), 247                                                |
-| hipMemPtrGetInfo ( C++ function ), 182                                                   | hipMemPtrGetInfo ( C++ function ), 182                                                   |
-| hipMemRangeGetAttribute ( C++ function ), 248                                            | hipMemRangeGetAttribute ( C++ function ), 248                                            |
-| hipMemRangeGetAttributes ( C++ function ), 248                                           | hipMemRangeGetAttributes ( C++ function ), 248                                           |
-| hipMemRelease ( C++ function ), 255                                                      | hipMemRelease ( C++ function ), 255                                                      |
-| hipMemRetainAllocationHandle ( C++function ), 255                                        | hipMemRetainAllocationHandle ( C++function ), 255                                        |
-| hipMemset ( C++ function ), 179                                                          | hipMemset ( C++ function ), 179                                                          |
-| hipMemset2D ( C++ function ), 181                                                        | hipMemset2D ( C++ function ), 181                                                        |
-| hipMemset2DAsync ( C++ function ), 181                                                   | hipMemset2DAsync ( C++ function ), 181                                                   |
-| hipMemset3D ( C++ function ), 181                                                        | hipMemset3D ( C++ function ), 181                                                        |
-| hipMemset3DAsync ( C++ function ), 182                                                   | hipMemset3DAsync ( C++ function ), 182                                                   |
-| hipMemSetAccess ( C++ function ), 255                                                    | hipMemSetAccess ( C++ function ), 255                                                    |
-| hipMemsetAsync ( C++ function ), 180                                                     | hipMemsetAsync ( C++ function ), 180                                                     |
-| hipMemsetD16 ( C++ function ), 180 hipMemsetD16Async ( C++ function ), 180               | hipMemsetD16 ( C++ function ), 180 hipMemsetD16Async ( C++ function ), 180               |
-| hipMemsetD32 ( C++ function ), 180                                                       | hipMemsetD32 ( C++ function ), 180                                                       |
-| hipMemsetD32Async ( C++ function ), 181                                                  | hipMemsetD32Async ( C++ function ), 181                                                  |
-| hipMemsetD8 ( C++ function ), 179                                                        | hipMemsetD8 ( C++ function ), 179                                                        |
-| hipMemsetD8Async ( C++ function ), 179                                                   | hipMemsetD8Async ( C++ function ), 179                                                   |
-| hipMemUnmap ( C++ function ), 256                                                        | hipMemUnmap ( C++ function ), 256                                                        |
-| hipModuleGetGlobal ( C++ function ), 176                                                 | hipModuleGetGlobal ( C++ function ), 176                                                 |
-| ( C++ function ), 165                                                                    | ( C++ function ), 165                                                                    |
-| hipPointerGetAttribute hipPointerGetAttributes ( C++ function ), 165                     | hipPointerGetAttribute hipPointerGetAttributes ( C++ function ), 165                     |
-| hipPointerSetAttribute ( C++ function ), 165                                             | hipPointerSetAttribute ( C++ function ), 165                                             |
-| hipSignalExternalSemaphoresAsync ( C++ func- tion ), 195                                 | hipSignalExternalSemaphoresAsync ( C++ func- tion ), 195                                 |
-| hipStreamAddCallback ( C++ function ), 152 hipStreamAttachMemAsync ( C++ function ), 249 | hipStreamAddCallback ( C++ function ), 152 hipStreamAttachMemAsync ( C++ function ), 249 |
-| hipStreamCallback_t ( C++ type ), 147 ( C++ function ), 147                              | hipStreamCallback_t ( C++ type ), 147 ( C++ function ), 147                              |
-| hipStreamCreate hipStreamCreateWithFlags ( C++ function ), 147                           | hipStreamCreate hipStreamCreateWithFlags ( C++ function ), 147                           |
-| hipStreamCreateWithPriority ( C++ function ), 147 hipStreamDestroy ( C++ function ), 148 | hipStreamCreateWithPriority ( C++ function ), 147 hipStreamDestroy ( C++ function ), 148 |
-| hipStreamGetDevice ( C++ function ), 151                                                 | hipStreamGetDevice ( C++ function ), 151                                                 |
-| hipStreamGetFlags ( C++ function ), 150                                                  | hipStreamGetFlags ( C++ function ), 150                                                  |
-| hipStreamGetPriority ( C++ function ), 150 hipStreamQuery ( C++ function ), 149          | hipStreamGetPriority ( C++ function ), 150 hipStreamQuery ( C++ function ), 149          |
-| hipStreamSynchronize ( C++ function ), 149                                               | hipStreamSynchronize ( C++ function ), 149                                               |
-| hipStreamWaitEvent                                                                       | hipStreamWaitEvent                                                                       |
-| ( C++ function ), 149                                                                    | ( C++ function ), 149                                                                    |
-| hipWaitExternalSemaphoresAsync ( C++ function ), 195                                     | hipWaitExternalSemaphoresAsync ( C++ function ), 195                                     |
-| hsa_amd_vmem_address_free ( C++ function ), 241                                          | hsa_amd_vmem_address_free ( C++ function ), 241                                          |
-| hsa_amd_vmem_address_reserve ( C++function ),                                            |                                                                                          |
-| 241                                                                                      | 241                                                                                      |
-
-| hsa_amd_vmem_export_shareable_handle function ), 244                |                                                                     |
-|---------------------------------------------------------------------|---------------------------------------------------------------------|
-| hsa_amd_vmem_get_access ( C++ function ), 243                       | hsa_amd_vmem_get_access ( C++ function ), 243                       |
-| hsa_amd_vmem_get_alloc_properties_from_handle ( C++ function ), 245 | hsa_amd_vmem_get_alloc_properties_from_handle ( C++ function ), 245 |
-| hsa_amd_vmem_handle_create ( C++ function ), 242                    | hsa_amd_vmem_handle_create ( C++ function ), 242                    |
-| hsa_amd_vmem_handle_release ( C++ function ), 242                   | hsa_amd_vmem_handle_release ( C++ function ), 242                   |
-| hsa_amd_vmem_import_shareable_handle function ), 244                | ( C++                                                               |
-| hsa_amd_vmem_map ( C++ function ), 242                              | hsa_amd_vmem_map ( C++ function ), 242                              |
-| hsa_amd_vmem_retain_alloc_handle ( C++ tion ), 245                  | func-                                                               |
-| hsa_amd_vmem_set_access ( C++ function ), 243                       | hsa_amd_vmem_set_access ( C++ function ), 243                       |
-| hsa_amd_vmem_unmap ( C++ function ), 243                            | hsa_amd_vmem_unmap ( C++ function ), 243                            |
-
-## S
-
-| surf1DLayeredread                             |
-|-----------------------------------------------|
-| surf1DLayeredwrite ( C++ function ), 135      |
-| surf1Dread ( C++ function ), 133              |
-| surf1Dwrite ( C++ function ), 133             |
-| surf2DLayeredread ( C++ function ), 135       |
-| surf2DLayeredwrite ( C++ function ), 135      |
-| surf2Dread ( C++ function ), 134              |
-| surf2Dwrite ( C++ function ), 134             |
-| surf3Dread ( C++ function ), 134              |
-| surf3Dwrite ( C++ function ), 134             |
-| surfCubemapLayeredread ( C++ function ), 136  |
-| surfCubemapLayeredwrite ( C++ function ), 137 |
-| surfCubemapread ( C++ function ), 136         |
-| surfCubemapwrite ( C++ function ), 136        |
-
-## U
-
-USE\_PEER\_NON\_UNIFIED ( C macro ), 164
\ No newline at end of file
diff --git a/kernel-agentic/src/data/build_vector_store.py b/kernel-agentic/src/data/build_vector_store.py
index 851273b..2b39591 100644
--- a/kernel-agentic/src/data/build_vector_store.py
+++ b/kernel-agentic/src/data/build_vector_store.py
@@ -113,7 +113,8 @@ def build(language: str, docs_path: str | None, mode: str) -> None:
     else:  # text
         pdfs = list(docs_dir.glob("*.pdf"))
         texts = [*docs_dir.rglob("*.txt")]
-        files = pdfs + texts
+        mds = [*docs_dir.rglob("*.md")]
+        files = pdfs + texts + mds
 
     if not files:
         print(f"⚠  No source files found for {language.upper()} ({mode})")