From 65927ea4420a8a3de4fcbed7df236998e330a130 Mon Sep 17 00:00:00 2001 From: Vincent Ouyang Date: Fri, 1 Aug 2025 16:35:24 -0700 Subject: [PATCH 1/2] Add three new HIP related High quality tech reports to replace PDFs --- kernel-agentic/Makefile | 2 +- ...for High-Quality HIP Kernel Development.md | 414 + ...ming Guide_ CDNA3 Architecture Insights.md | 331 + ...0_ Key Differences from NVIDIA AI Chips.md | 433 + kernel-agentic/docs/hip/hip_spec.pdf | Bin 1973528 -> 0 bytes .../hip_spec-with-image-refs-enhanced.html | 8151 ---------- .../hip_spec-with-image-refs-enhanced.md | 12243 ---------------- .../hip_spec_mm/hip_spec-with-image-refs.html | 6706 --------- .../hip_spec_mm/hip_spec-with-image-refs.md | 11189 -------------- ...7216259e5e5c3c192ee9dd1c1c8e76383cd3f6.png | Bin 271478 -> 0 bytes ...a1d732aeb71e35bd879a965fdc6375d5204886.png | Bin 31997 -> 0 bytes ...aa6a54c9646387476d59ddc5eaabf5c6641187.png | Bin 31752 -> 0 bytes ...8e9985a382fa290507dbd9ebd5ecafa7f23bd2.png | Bin 270819 -> 0 bytes ...13faf77041d4148e4ceb04903608a8022e3cbd.png | Bin 190318 -> 0 bytes .../hip_spec-with-images-enhanced.md | 12243 ---------------- .../hip/hip_spec_mm/hip_spec-with-images.md | 11189 -------------- 16 files changed, 1179 insertions(+), 61722 deletions(-) create mode 100644 kernel-agentic/docs/hip/AMD Instinct MI300 CDNA3 Architecture Guide for High-Quality HIP Kernel Development.md create mode 100644 kernel-agentic/docs/hip/AMD MI300 HIP Kernel Programming Guide_ CDNA3 Architecture Insights.md create mode 100644 kernel-agentic/docs/hip/HIP Kernel Programming Guide for MI300_ Key Differences from NVIDIA AI Chips.md delete mode 100644 kernel-agentic/docs/hip/hip_spec.pdf delete mode 100644 kernel-agentic/docs/hip/hip_spec_mm/hip_spec-with-image-refs-enhanced.html delete mode 100644 kernel-agentic/docs/hip/hip_spec_mm/hip_spec-with-image-refs-enhanced.md delete mode 100644 kernel-agentic/docs/hip/hip_spec_mm/hip_spec-with-image-refs.html delete mode 100644 kernel-agentic/docs/hip/hip_spec_mm/hip_spec-with-image-refs.md delete mode 100644 kernel-agentic/docs/hip/hip_spec_mm/hip_spec-with-image-refs_artifacts/image_000000_5208c655dc4611802372524b387216259e5e5c3c192ee9dd1c1c8e76383cd3f6.png delete mode 100644 kernel-agentic/docs/hip/hip_spec_mm/hip_spec-with-image-refs_artifacts/image_000001_bfcf0651eef1f236f619420b33a1d732aeb71e35bd879a965fdc6375d5204886.png delete mode 100644 kernel-agentic/docs/hip/hip_spec_mm/hip_spec-with-image-refs_artifacts/image_000002_cfbddcc77ec59fe03ed26460c2aa6a54c9646387476d59ddc5eaabf5c6641187.png delete mode 100644 kernel-agentic/docs/hip/hip_spec_mm/hip_spec-with-image-refs_artifacts/image_000003_8ba501e7c1e4fd45f649ac07d48e9985a382fa290507dbd9ebd5ecafa7f23bd2.png delete mode 100644 kernel-agentic/docs/hip/hip_spec_mm/hip_spec-with-image-refs_artifacts/image_000004_b494ff70840b694ceb0cb8c49613faf77041d4148e4ceb04903608a8022e3cbd.png delete mode 100644 kernel-agentic/docs/hip/hip_spec_mm/hip_spec-with-images-enhanced.md delete mode 100644 kernel-agentic/docs/hip/hip_spec_mm/hip_spec-with-images.md 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 4a2a6a4cce89cc04207a43d4b9fb01951c5fb9a3..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1973528 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

jP1?Cd+R}* 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

E^K8D9cm4rVpo3g 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 U+rEb}XB|yS>_}a=mL@h)>=ulB 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

#YW(;b&}cg-?>2KQUU95d=5-JI36h?!B z{JQh0<0|$Qj9PAZGX0fG{mfn}iZk(jiWWIT&mS2tF&bUR_Alt-`H4p-Oby1ItTXiI zZ4(9gnCF%AL=YIQ^hF1k+_HNvTd5>&U5i>9qzai&Kj1&aIGJ;1Z-UR4FLFiFC9o-P zJH*X>;jVUQ3|uuy&vNohpt|HC-D)q+u7YKqA4M_U6KZ1E!Tm@Bh{QYNN-_kRvNDXB ztkPay(Im&D?jF(2akc<)u}(I4ex?OGPTDrQA)T0B9a7|R+6)H4^I)#TYmc*u^~kv0a!x-h7k{vj1RpYr>L;0IM~et43s=(yE`BW{2}xEIARX(;YRRa zJPB?=0vI7yWuO4DH_ZZqApAYsfWX6{Fhy?S<#4cC(hGq|@h!pKgy#h9J8*5sNEi(L zqi}mH8q#TBdsFUbJ+J+qM1?tutY`mf1TP88tIV6*xD`+U9+xYliQxtnYv>Klb9%7? z7SglP)E3+z3MI$uo6sS-O$-d0msX;Y2I-WcJS(Z-IK{OQM?}%8n}<7u%*>MUOg1aM ziHJiWn=c@o5TIOY_kv#ry#Q>4E#eEtndrSvg9|DqMPBDYyc6J>s4@h3+(GB?qy+(J zLwzl_@k}mSe-FaXm^6Iy%s-nf&@T_qxKnQ_cNZ}JZkXLr94_df9tb?H>zwWf5FRZ(rh9wa$<(L$h8S|0#_8AfYG^dLfEwp(RT1tnflf}_|{QIi}s|9 z+%uRuZW00m7w6XMp>S@O(4c+OE3LY51s$PEy*#@N3mZ)C{v;9oE!J;ADmD!ZvS51!MQ!(IM4;W%tZbmc{+PB^5(!whf?apd4_ucGe-Y3N9Sz? zMUkaSO!>nX(aZJRdae6Sv6g;~?QYr9VwD2+r|qQ6Y;|sCn@4b}6n10GeXjdb7sr(awI6q(vzLq=hocD1l0)PC}|@fvwgJ*SK6(y#I3;qI6}8#zZORdQtM z<)Vn!pY6f90s$$i8hw~>=EU0ld}8Z@rBj2oBveEO*=rzQzt`+6;Qh=AIfxj3@7tqM zQSx2;6a0(7DB==DHqy^gU?X|QA5^Zd`H#fG`9Fz+k%5i*za|cK+2kBHgr2#&dBniIp=6ifNf1fpDOAK0UcxuQ`ug99VnmX`*<}1T(Vg(c9OEC275RnV zwdGOO)D8udWl@a8gYcJYRr;${bJTEw7zgJX3n8Q=dv!Pb42^)F)`R6Nl%6h4|LR>) zHlw~eyt<6|B*i)+QVFM8carRRJH0taS14C>ka8uclGjJc@*!nd+{U5~nnxJ+kR$*0 zS8~MVb_6NPfS$1lr&|05C|8tZV316d5ep*&^SAjhPzg}3Msj+p49ath;>dEg z&S#M<9{#n8LW|BCL_uvB$V$3x>Vr}z#0X_A<4>QSW||1x7H^0EmZI0i+|k+F_4WC= zS-GAWV_$3Ajcs&+_n)1ab}~-~SLg72LhpXx(K0}Bgu94xG#={hHSHt0Y`poXuDo)h zSg`@320@I%q9~^u@2a)vVo1^g@l@M_gKw;~o`3qQp@!|kbVMdwt_J19iI0~iN?=#c zV3d)(a`ttX@<4)nx~_f1|NWGq*+UZWqNzO??GCL>M2u%V#ve*p_bn3X_i;Hii0Odyg>5LD3C84MRfO-l~=Q zay-c*s!AIxH)e-RHQ>rCt8BQGIgkc)DQ;0EPhe7x?o7<#UWXVFdv}QObX9y2sJisNRq2Tg8y(NU;!BVn{;j4~UgqP-G{-zc->csv@T>FSXHC|tdRkb@dq6EKN_^CJ;os=S#@sj$r9G|#%<=bW_1eXnY zpyCG2n@71)jCcQM6Yq94@WH)Q%nFfp;S{I`Rr26M}8i|t`Yf1vHpYz0C9fyYF4GMSv0)mk>! zHD~ryV39$zcBG0ZliiP>IRkK12@3nh3n3x{#x$(+AJaR8@%;;-hg*DfsDFR_AQmVk z($ED-g&R7)FS20Pet(FP@kbI57mY3gIi|NAFn;~7&%=?Ok)|~*@Q(3h3dozAU=DSn zWGaaV2@1=gF4sFkpALgohtX}y&FFVbrl+y91#z5O3`ZB`k3Z_l>^lLeIF+) zutfUZo!LdyB+9!|f7vhNX1=!_V+>FZZ3eHq>0AdGc6Lysx7FNQ})}C zf9hG3!tAqJjTNtJIr|qw@_)%J8*`947-yZBG_2N5#W#K_|L(2s6l%VjsH<8$ctGcv;9`!5VRCTsmYuRVH70RqH z*o~p37zl!UY^#vw*;{BchUzx#c|)o0ur^@`PS1OwSE?vcsS3UZPC)!+U>RF zO~#0QdIG{r4sPtYLriZ|Qee|)_L24=T5=-lRq@b7W1(xdH-b=1A`J@-Aa>TmwO+MC zpV8m=w9NZtYH$*akH4WQ@~i#%egFOLHem+uEh{GifIu?x8TCv4UD3(IzZnc zKFthc^PQS+w4jA{?~5>%K!jV*jv63F&$EPM^W=lCbX?REQv|AD2e&RI3Quq+@{38y z*~y|viR75*;j2?T4cd8fnAM47aH>ZGyViZ|5vAuct{R5;1GagtUj~92!IP0pvBOFS z`GeYX8(rJaAvM?qs&S#Pe9aqW4}b0Kkw!6KE*Qc>0{!BueodqM7f!STVEvZX(1Bt$ zlv(Up+_jHPcI2H#mebxvvDR52c6xb3cUe?ZN-;bdXy_%`Id3x8)NqTV<6!)>@m*&i@o?l@zIh;ij{p=hD+ zNS>%hVlHm&=I?t(u#XC zeY(%AXD(ktOVPbvjK*Wi zDHyI2j^{VsC7Y3COu=AjA^KN#ra}L!Ld{;Am)^AT5NQY+I>hs+dFLlIXP!bNplD51 zAP7}jEoIf95yrmKAxXH8~tceZM-S4-Rc{Ls?jNrnWeY0ocgx8 zw_^&pjIv`0!NGZO7e+8>*5fR6OX3MiI(cCGBr@8a{M#H!d|U%>J_acnciccVA8{Se zS8vZlSF5)eF*s-~JB>It@;X~a1NsghAF!Btj%;h_suf8IA<+zN*NLit7qYkfZGDvve`q3E4;af(v zJ4llaO@+lv)1|3IV|f<&2`|Lt5>1(i$~SQift?5Tg8cBZO=d9Wk)!ux-$$bls9qD! zDjn(8p6&+SmA$W;xs3$<^_+pn?UXMuJIj2%7V278x(tC;Da$x2T#xJIJ*oC0opYa+ z!@Fsgz~{v=$5UY0xt+l+hiPScpEzreJDq=h`i3|Y6@BC{l#8_6-(1Ul+3mx}w>?J3 zmvjIc9hAv^XZ{eT4~CW~R@w%_KZ#bNH z!j>wIMT4^tUF2a77|R!TgSXK0n@J2~wqSI9qlqOiWpO_4Nh-T-;c&6D<)q1xIw$^} zUSr+2L-{nYF++?5a1rG zFW6hq_7GVU_2MnnJziIBKAcb+;Am<+jDcNR?zrpdeaQ+tPzDyt{ zZ6n+QZyk^WF;d)uRfr>Q?TS;gQf?L3FqKD~=Tw-sM7TP0xV&gMlpG~-)--rZapI&z zRHPI7If}~4RgwZck7^uWI-~P$$^4oHbp9`BtwW57eLlmCnOc7%ZZt>x@O`+tq8X)P zB7W#JGu$P=Xtw7_wvT$Z%`YN*Q8iKG`R;30)5+7NfkO_Y`EIFE!V{PwIpc%$O;il$ zSCQ%c11NlHaBw}CKc;-%I9_t(0Jaz2LLlUIrj;slQbEvQr`RvyZ$pW&Y2VHui_u@G z;cQbj6=?%jwSl2gKGqbjfcPjXh2RVTNFTGzvVt(^xp>u`-w9zE{krRcHNrESS`*vs zZ^yj*S3l7z)#ohO0OUlBH-n?uky9k&8G%V0?ZuLZjHMkyGp`UJ(XO^T{a9Nqq%)NY z#IX*J!-8ny0{6W{2i1E>gM>m{zb0+f=ZIqasvXLZdT;mI;TvceXB?nR5TfoPy8P*@ z3H7)wDGXkiGZrTdVf`AIS%R&aPY$z~U#`%ynGH-ONs7t$cL}e`atdC#D18hH=E9Ws zR+B0d5+_y!JUk55fJFTSSN(b>ghnJGHZ|qGEA5{ouv;MhE;HM<^B2UIaodTx7NHX;Pywy3Xgnf7%wZZO$FPAn|wr{4%&TbHGN3J44=@3AC8RA^AOM`8>nO`YGBa4;AcYI0~j>)xe+!2w?@nVVyVh6yu z!|`d&A9#)K)Xe|DOe}1y{|__${|eGS0ZG}#7K&c(pFqU${|P)!&MpL;ENuTr{$XNb z{jZs7L~AP!dkoR{O#P|&yPj89*B2HI%!D!tlp~FRG5}c+!mZ;-S4;;^7>@S+*1597 zC5?S10*AX_&x(U}XJw_VQf_U&Q(%(fvRidn4@8Y^l6-)|yxR$mU$7$tKP|rIVKvf7 zg>M`=QAI+~PBfJxo`59P_??8BsIh1`iUw@J98hVpa(Wyrc%OeXAWrdkbyG1h-qfLv z!X%U4sCqc&0QpJD1qw}xY(WZSVk!o*_!LJps3pu)jB!LH5$Q*RxR~_Iki4msNwx#J zCjr)M+(DpG5!8aT8jPPU8zwhKyb=AEL?-EE(NxVwspArLhy}IA$U1p&+U9^nBjyhn zCZ_v(q%T9#2yH^65j=c98Jy`i<{W4^B5%w|1aD9XBNJ$1(G^Uz$YdhTBz6^!Hh)k^ z?!)So`Fg8`rXV1n1C;ZSyJ7%K*LHlcK42X%xJ_wSrcdUk$BYP4eq&(RdAtn!G(6Cm1EG}Z{!v?DFdV*;( z&o)NP+XgVr0G4L}ASZ$3jZt#7O{jbOR1nHsbTkEyO8|H8G>}y?k2|InkBG?^(h$c z0?dtzkm(UNYwCb0hABxKEL$Hwi?O#GtKC)TYy9kcnI3T^8H}&kO23~mepDhZBSy$X z25s3g{5WbL4FSJ0B&D*r^$t1Fds5=7R+N19rq=3X&ck3NqgtMa9Q?+={~nCH+k3;o ztMc`Af3?3z;Cs8%ZO(RX+4bqO?zgbyR8}s{=Tx6-f3~AGS8TskeAjpL*WMgdcta7N zt97L&TbSZ(h8i_#N1vT^0VmD)?WF(uT% zZ8DF_b3vHg@)PWHrL!o1ECFZYT*Yqo)(>hHIA5BFZbFqx@(P>(P!t|B+FqzVQCuKF#es%64?(I6$z`yq)4Z}}2{7ax5eJf&0DPHc^h<*S(fgS0^FlSBhr>|cao8r# zQ2^u+pxa20-$6vdxf1#^R#R9zeF{YR2BNgxA4r1B??gF7q17%{K#*9xbZ93AjUD>7 z84<;HFTrPWpCh;0y#KTH7(4cn;DG3(pDXQx>qeCY({+TGrLLWyW4W>|NN<}*L?jb#iV~;`Hsb7e_ioekTBC!9okWM^eIo?AE$~dy|Gg6BTe8+6Jn~AYA6)u z+EwA4|HRlc`_g%J7Eg4ng>za`(WB29SmX&8TvIf4ncx5@72rh&9toW~sw{AwPH#Ay;EP_jKo(cXxFxdtwRgi? z|2!6auS2iCY`@Zu7=QK_qd4e1bc|WR5gy1}rrvP(bu&x=bMoUm_~FdISJXYae=LW{ zAblg;P|^EMGu${e-_p&NAxoZuw~pHpzr`Z34Tc#zaZ!tF4<<4ya~^<8&Q4s!2t{lb zHJs_^m)MhE?_6}6oUzyC?W!OBJ#^tZ6tGEdCN?k?lImY5nx`>uid%&<(p{mu=d3XNPePL}8<-0Kq|Q`RPFO1~-h=!+{aqsezPDSL&iZ4A)~3n~u9>A~ z&VdpmSKq`o7g~LCD00b_+rjpVV?D5Etd5)LwktxDcq*Mg$yAc8nJ#L;AywS~CWjuqesn+l5T5pJw3QPTnwb zZtQvKXC^<0Ti#8Vrzf>t8q_We>UhxYWe8cAu2PR??)^Rq#nkMBEtXY2@r#Ii2rk3l z-_xllTgq;Z=UlU#Dm0&{a2yfjkjk!%H|EMLVkC&!fl!rxR)S=5Lb2zYR7Wz*TJlFW zRwc;^gX~>bKKpVnd2b0n@9XKXj=$Hdu#IY;tM@~Rt!?R;t-xm2o%#cazG&NO9B%Km-!b6mBMx}fA5fm5QsF=F6D#X~c33O@2w<{F1vjS8N*f-)zi-DPAl=gRa7OKPfNZ`U3%|3^PQa!? zyMAOU8lN3~uQ$Od@huX`s-Z(u#0U|z0iVRFVS|p(t4^;^zg7grd#>`zW!|()Csc3q zRMk`R0lstIvbdti=LS56)ad>4v@H58J9>|vgJu{lhYap3LNxly;r?E|bv@{-4D`_y ziT*~WZiq;M(IBv01NvITQfSG(E6plg=fa@0L{B%83236Jm<-}s z0XH@dBsL95fYq2ur}pU#fYq%!l4L!`s>d6=X~6bX+Odz!w+ZQ;g>au%l#0~Kj#v!0 zc_5y`!Zl=Gm-Om_MBOt?Ok4YfZ9~s4(%+TXSg#pK-!ZnL&tO-?))h8gb$h=ypI1w6 z98zAIimU~kG}hP_S^Z0vVT-&#p%L>7NJR98eCx&W^NoR48e69<+FE8=B<(1ETRo^a z{eJQ-WJh9vc1V4=E*c#JmP=VwYn?sXQm2->NdT%0q0QS$hSwz8vBdU|GVFe3zQ^Q? zUhDB-9B|(jk;)4}){=bd%+1hRK-@@0u&PQQFmu8j0UhdU^_`TQuAe z(a>H8pwyhA`A*L2tB^KG%kqNNTDQ(8R8(K3iBn((gBbi_u>sNBx|rewb2w&s`Yz3K zy!djUfq}NT987h+@jp5F8$T84pFdesD~@N!rlv9mn79t{Wc?1pg^bEWcq(&* zwH}w^S8am78q`N#T~pOl%Asb)rdLzdSW{K>4!v+O#01gfei6|sXDTj6+y!tkIeJe7NZ`EnzS1@O5e!pF@ z(odMW4X}3^6w1TPSh)vlG)v5+wAL6`p4o_HmHC^t6F*!?Q=*&x zrHeOkS~WlWt1L9&8DS*(qU=9+(yA#8mVig zl~GAR5q7xusXj^ z`4MrvO5Y`VRkQ{is@?V^Jq^!LY+`1c5HK^tF-Z6woAyU%kqIa7yOPQ_4#`l>D=a~6 zm`M}y|0g|y0Ac9gMv29c##x+^>ejFRf=ok%wrtgY@fwpWFmU3z`EgNt_ zb0R0(Fqo8uM(JkQ+(P^z!w#sMym`ZBp)m(4m=k2sBPhU>S-BvDsqx-4LsqV(tc2;M zbBV=Q#xELKEj;*NqwqPeNoPoKpC<1%3Y}V)pm;cg42*L1DQ(rZ7E*G9yRKkm;$lb# z8DDe{EN6X=4Jzm|Ko(xSt7|hbp?K+PUR&W5-`=%)Q;glMG(&;(Pk~PxJ31aG{(QlZ zj{xzX)7b{A+^w&;hQBFm9-yo~z?ve1MGf{DYY_x+JnNW^8@9b8Iz$mQzedPr#)A2= z2d4@?>22N@nH@Bv^yz;Rni$87SFEbYhH zU;=b9?rN9DoBI)%76NtQiDA&=)j79Aya%c)&Gyqk%#376y+%g_$P`lh=0+OlV}|0? z0gq?ux3z5fYqxs5zjt5PW^^Hv{3tt5og_qI&ShWd>7Cb$*3AMD&j#I+!!xPu3Pw&R zupP2)4(HQ8hX+2ZN*p9Pf-IwRc7Q#It%0K_txUa;7S@3^vcj3RZ57;FIN>(yd~`P3 z#eu9ul_)E-B4-2bH?D?0f+CQaW;@3>Ui-V)=QXwkI$Toz2N|EAL%-~Eq)MS9BmH`z z3T&Rpxd&NJdPaxTIuBqwU=!I8LL)!PV-MANOQ-~M(?5Fls58Z{rPm&+(HB*^y zC0`T=XSxx*7ec|A>VYU^XnZ*`XnyQ4GMV=)6#`sFt}2R3vVVEg>Jwy%V~Igql+PznYP`%>>Y zkrR>3hD%WtDSA<3D6D;UsQ(TJ6WZQp@~_CNqoxIwHnDPyJ~y$WW9$ zYodkj5^I)>VTK>xoE$X@`d`lPSN89Lcbsiu6e*rk!7)ZX^6}C<0>HeK6{NJnU|9vva!ovRF>WD2`8%{^< zsJ^f2cZ!u!8~_an(_1m#xs}r#w&cpGHx($f3$&{eC1NF49Qyg*4GI7vnvI>0A_$iQ zPP0AjB$B;kB%c1yOFJv@w;0k<%?X(@H+V>74=n056CF~X14&(?51tPPM>8&ICsq%o zxwosTOY-JMN-wTkUn9rrlC@KE;X)$e}c}aI(j}nQ5z(}&7}Y-B$+4bQ%fe$px~JJug}CR zwIC7?jvYLtlm?xc>u?gFVjmt1ljfKO$B*+})%Vt_I{n$A=lL?u`YLU?yX@GPVq|O< z!dow8FYH%3cZ8G#661j!knQCqn5H;l$YCxn-85~V$xMP|(rnrP7#Z!Ywu&=jm@Mad zrgin|4yDaZtyoopFK@&{c&l!3wI<(mWE$sB*={ZWu6)`+vDxlC>2l>Vj*|85r)-+B zxjT%yX;1Q)=8SgbqIdLdQ4;#}9aSW?!@YUnzm6&sfxLuy)|#eKrIK$^dEUWKH`wiS zkT5A*mO`y1q5v?3H^HZxZYOezFK@;3$Vcl4QUj_aB8vKTzgxU8Veo69Pd=nLpcWT2 zN`&%YgPzFbj{%I*+Uz)SqaypC0jzA%hcsC2<_C>NfZX8GBA0HKkNRY;yCs zsWR8e86`Lf7zh)?L;>GNJu*r_qIyOMDw|79h%AL8jU>h@m%s-I6=Ak8wD@|>mMFv> zH#JO-e<33u5%@y6ab#%_E?%LQ#X~2d(PXXD3k(}L5ku_An9D>s*vUBXwkYH_8%3n?~nMo%0~<*+9{BPOe*I!Jc)m*h1cGSxxLp#47589BRpBgpzZ&&Z$N`{!ExD>(mkfg;V1e$C=!ZD$t7WI=d z-DbJpg*b}GdkKshOLHVJ>I_0pV9*>$+x%Tt!GE#}K z7$isUg*!Hy#3G-D9S_As>~J}8lX)4qrtf0#CBppk@BxLr{ftc_BUdam?XaF2pTPjirN?$Jv-+^@YDBO3qgr>3P$Me4Bql(P zs}3keBE+I@sWy+{ZC)7`4i-XoR(q;n%qhvg$}<%Kq&OFNK;SeDmfdHP(%p$VZ?Usc;{_uL?M@w9^veFr0I7kGi@CFBJ0a3Fr=XT4mN$U23JP`RZ=_+W zZm%oW!~khe+5~CWk3cg+ChywE(xdhVvaFNs(XFf820rla@3<9Xhjvyu?e^s5_;(w2 zAKh>Nxi#xQqv*cG`Ca@-Snz&bS6JJ(QeARKV%KGF{{XaP99~i|;$7znAZM-X(q6$#m+HG~3>6FTzevEx_Q3%(R86-eYQW|IYPgJV z4d=C8KKJ@c@c_ocmwvODs)?C;X2fs@S0~{@p54Yku}N}iyrh3d+@vnu33zwW4c!TF zs6S+Bf8UB;d@?&IaSCBot(^9V1Q}a?i-2zO2@%Y?=yCiS9&VBD&=R1S!ITWuKY{=< z(^N8OW&rJ59l(VENBaydqJ5NM`hE}RLIAYrK3QFpu zq0}$OG~N&lvy$o?$B~ ztckB>sccqo{{jcZ^oj|kFH@TO8?o%z4tRHcqT80Rh7y>ASe< z@EMM}X}jT)jT9fz!rZ}87=7x4sX9%^k%Z5;`*jBiyH>Y$j_DY4;9eu?+BGxk=eDB1 z+1~Qmxq9~rak>fi&r;fZ8)$!k=X4|u;+xe4PvVyAxc)szPeR-f4ea@}tU#=Y$;0C; z?EUE;@i@Vg&V!(nd*2wbt1cT#WoPFy{3cL3R@1e3^_3m}`0jmq${Ie(=JIvsM&J5o zKI}P(BhCd9<}&+}{rAqF8ivP&^3R4|MH%x%^pQU#sg8s%a{U?YlySf>FoY)z)PDp# zj{gaG%nXdI|1IF1U|A<`w_bmKLyAdBeXd^By5X1_40)`{-#05l3)3mi9z39!J0f!u-K8R7&G!XJ|%&wbTKU!jvY%n;3WPc}J%o+hgk3wX-vcNLf*e z%CRiGPH6!TdFqfVS}>&%l4M=xVrq_n9OFeuIt4_MV2cB3fE#qcK%!M{jw;uu+h!@q>L6Ok^uAmam9p7c1Y_^Vmw*!V54Fz7#gn65-lw>(e z(`@zDu6S|NTB|LlUy;Milu)^8R)oW=b~ONgOHw(6_L)Q$018w!`7ki-3vn^Gx((M* z+!YeKr-pnIQh(|rE*P6>x-OSXef)&bG&0pFTwxzCE%t+-HuTDf3hR;r8%1_kE=&Rr zwUX$sqj1*~&8oAF#0|E{8Y0qAlpf&mnPvJKZ0lwd0v5ZLZ$M;B#zR4tcOa#M^8BAjnz`&V*$JzxqFHQ6uZJw1?rfFa^=GdN;! za=2Nns;apaNGX)GY&eZE(!*O>7`-@c%BG#MG$Mmgnz6wJgNv$ff)42Aky!1#v(R7yvZkAzS1xFI@v@Bk&%FO5!w$o$k=wco`)jj5>_(sVFF+m znsUV~r0tY6beKd2iZIV3AK-lAnQE|=!QJjx2W}nFy^#UfmM9(4GXX{XN`3?{hlh+g z17DC>dch6lV8S(oOu+T-IOPgj4NYTUXY~ z`YUcFHj^6FQ6+`v)Ek$yL0Iw3;M>CJZ5k6XO>isLV*fpEl<;e-%iTz@UvOh8cK!Jn z9Rwbc6M9TS0GUy?q!v)}j6dNBmMPH%<5XWWo8W&TqsmpMed2v1hwY@j4 z2+scA22L;VcR@HwM<1g!ArUg0G4R<}noyP23r|VE$MfZ(%lx;08dT`pIZ*II#znrX zcESxo)KS3ln68TDx7&nI{pN2^i*e<bQ$NHcPsZn-32W zu$|LxSoqG0Uy~(J*cAmbh+F18KRg)gf5GZKm#!I8@eP65TPH54H6L3G2eHW3BR_-<0_lw-LB zn`n>Vo_$)hc(iHf+Jfce(>{4lAJ)5%ui>48rvF~`4x>d)_8NN(U-1t``zgN99}ljD zT!Mqv&5ee6*Bj@Ua&&X?ai#RpMuKHuo`0EY-Y9HlAdB~6P>|{WBaop)CEBe zADs}|&`${X=%L1cx+w%iT&`gt6c|woxM$Q1>Z8#^F%f_smz+|&%C5r6={qijyMij>TOmC zaHt;VR(aT>scoA8S5aOo%?2;iq2i^gm{Qf(YFkBd7bY}Hr3#n*Ar5c8(^}OW2e~0p zW2ELoqES9H)rc3Y&#RF(uX4RF=K9vPI%!j}ZbFkguC*tba>tklJ5xJr!Zh7@cOr+VK&$et7O|aJ6?{$kkj-psfY6KxrA5nZ+ zXuqeP)KI%@$Tf?V;38VzO>-H~uAKH$R&^1{Lghfb!&)Fg&^PC^BG}ZVLSgqLsSj*% z>3uS}2vLGn;O84>J_7@6hcj^x&Q(Z*fy6O>Mig|+Dq`30c8x0CpdIz7D9k^s{#4I- z4dNEL@ECTFeBoF$$(>K8@Kjn(cb_BWOVDzi_jjQZe0{JK;oGjD4gwaEvJcq{_PVwa zMO*`?84U9JX>|NM4KVrz18hdjXZYUyFO7y`F;V4ho^($Upz&c=ESYtW#d<=io>@Wy z-ppWrRwu0Trcr1^R=WIx)b?*$e0P}+bMJ`*UrOi%>O>Ip%5)dUl=g|C74Gi5CmqmI zGeCYN`|$zk6UEF^nK}@Moi+n|mE0>e_c>_Vm~O0fMK~l!t<2`IiF5clc0J(-Sg#v~ zjA*hLCk#rmo20lRfbOd!a&We)N>Zha7uRnrMY48~ls;6``3_Zo#zM(r`ebnsf@&){ zkEsNPL$k+9Uax4ryQXZm?Nl{|TGGDO6E&EN?=u#thNr5Y{hC{bTO0ipV-y^<-I|^` zSob?umk)97`CB=2H!>Z(-?=8?kvRA-kPp^7bLMfnZ{C`2F*Q~+Y%A|tWAMQ$W2Iav zp!n>)BO+9H_vI7>s2MyHh=DLqGZFV<;N&}#;f1Hz0_ET3TdKy^xUS>7y+MTWL(Zi= zlYYIwv7yOy6z<&PW7KpT2+;pjsV8epyT%w!sx_QE9nL)K$+7+~2!g%)gHJf!srb2B z%P8v(klN+?Y4+ns`vRp%xrPh4Or%J?>%&_6lzNmAi~0mcbBQ_tB;|QQOERFF?8<@- z)xHl6P%>^ZD^e`6oTVn09Tm&`fU=NO8^9V+{pEdxk}U)Z)KyrMn4qku1h64z-XjH| z)$PLcemNNp;V)JDED<1tlN}}IlE*0HV8J63#LMpiLNE1@(G1m`+T1I`h3{bY*~A{b zZYOk)W9cZ#BJ>)*YfzGGOK$nzqYVPru*{@pxd!n%r>{py^DILGzw>xDs;%PKyhY=t zkG~OpEY1N5m7hF+=>Et~a!ZbzID+)63cM&^euCa48quO-U8H+k@a()z`+Nesnz@vF zROr1JB3zq+&XhR=>W{akj6${>)koDd@st7-VoRQ%z zMYCp?;(N>3JL;~CT%eW8^eZPS2}xb!F$`s#D`Y?OsGUd8!FrarG%?4MOzAfWsyKad z|3=t8qr24_Z?tkD%0*n%`)>KTMO?yKDSkJD1_=XTUvw>av;`Xb$hxN&6;Q~000yo^S>V7Gdnnr1Tg{tO7AKwGh;%-oV3oee_S4dDY~alpel=;?l+zca$lA5xg? z?TJJ(d$Ry}v@G2;FIhYt{V>0gIt%{#J#%e_U6Sd&gJxWlW!My}%X!|~LGqDXnR10H zi!}F2MEGFvICe7@ed~_yulGhE%h8(**3a>vl*lFOdw&3bkRtHAfT)*YJ{!HE%B`3* zV1Kf$|K&x9mKBv*IzEM-2cfL=P`Y9BP2*y!X{9zZhpevJxe80M#k25HukPlc(0JvD z)SlJH7XUkmn=QE3ZAv+|4W(%*ew4=t{EnIhXa|~aM z*8DYo`E4!i18-aW%QhwnorQjzl{aQ_WSq#QSnuEcQ&?V7stJ*UDVydMM`!8%<&>c!*$jT9o;4tZY@7w3Q z?=rjVw$AO&*}rQdusPD$-TnDTyP=+pz}iocza{uz?*_gK(!;3VRcG2u4#N+ur_hXOelFcimy5L-+72 zH+6wWddt2@2^}o&_mEyQzH8z{{g+L#(9DanqrnhM_C3D#z}v&t9eSHwBRFWbo8G32eyNpz-P0zvi(wvz@J&v zlGe8N0KHv@lDwLI0b-+z0o-mi`}ZXvs>>V?wKE0ML<>6uN4wYDKizmRmI5Faizf|G zXb85666FN&Oc*hk14N=2DKOpwzNOt8FeZuuF?|+efv-XNC$wO}DreY^yivd)cqulU z!Kti~GmMAz?|AjN_SrS_c}KwquQG?^025-w;kAzpeOU73>u_oHTuzBREXm}0grLEG zkX)!#_NsoaD!vQ?;^EuvXhYJi5;`x^&zULRcm(6Jq_JsT&>6Z4{|vtXB@!}}Ab!O* zhAm(x7psN{hnMCBKR3~T?{hfxF!gxc4aiIOLXh6hg`={1$V0j!_k zLF_vyVR(StwuJa+ewV4z8kcbq$+-Iy$Gz{tuSNbAk*JtayrMZOr-2B`aW6eS`R7IE z_LccgoY3PonIRO~-6JKK#zKMPVDvhq*E$091CFS7o8d?jy6W#*fbnUXG2AxF7U5GDCT5mUgN2yNcWFQ zH^|`BeYZqN&%EhM+iJml8p%F#xmfT2V(cAwMC+n%&9d!Nwr$(CZQHhO+qR8Uwr$(4 z>T}b#lTPlN+%MTbU}tCTWUMjAc;?D>H|!MZSzYbf8I|7rEnMl;?Mt2$-Y1pVru&7e z$U-h1Rmx zIWR2Tg`9A{0v^gW!)XYW(JXK~&48l#p1#E%Hpfe6mumS{52kP6f_c9oY`CfPjc1*) zTivf}+H4~xDw^%E>wX)+#swIR3I!<37o6lbo@ryFTa$EqEki+6oc!=^a0ljv zujNB^8B}iR$yL#nQcOl{sa`qtfDjj@uwf0OI5-K2x@F2Gx%dz*5_a+#0u?8R$Ik91 zGPKb{y=NkMd%-BZA1#X{@0{lMXOTCwv!xKbiR*A-1h0TvZ)Pz8LVaYlZ1TaW7`u@SRayIesJ`?8-m80a%MIayQ6Q)B zP5Mjc0uL7&h(>-@X68ExEnH2db)u0C`=#yEO||gDi*5pv2?phEr!-EtpShVONmg#` zm(udqX<7bn)#(Gq`YJrsIEm${o2glL4lOPYt@T_SsdJ7pP;g*b_QD;^7JWNeizsjO zI>M>ZCowbYQ(KCsqzqmjM1%s$Z^V6^Dk8q)Kx+ylH$^;!+`EQpGDBi1jdnmtE4_m3 z4lDaOitW4Ca+*FLf#wnaankPH16FhnHvvIfb%-cP*n72w*&rY1!b%2NIbM2(0N|VS zLnbr+NsMv!LPt(nwH*LKCZs4OijRb63mWvt>JZ@eaCKnmzZo}=jTqc1dr|YcIZ;7L z;W4ZA2z8CmTV3gvGdxlIUZpgW#}anacRTY@r{_GFM-0i61wD7IadO-3Cj473qFHtV zURCesG3R6fr(y$@G?51=_`JHknLcKXT%+hni_~F*n2^m*1G8SU<=3APX{3uhux#Hw z^Uta{u67ogW%dTr*98_Qk4p5AatK(gG_hbOOVf*{ljc8^{7R2jl`=*Y`&xEbVth}H z+!~~lGtCZ@YRdu%&R)&OPd5{NRlGC3tTVPxbT{PFRJTh}vN$DO-OsCXuMQw?_hx-t zc|Uf5>cR-pKlciVO_URSk17arkVR4^$fVh@-tHRO9Y%u@8E9yZnA!>=2b?FUb|*JJ!0%VzW2MdgoA{cG~N9%H{Iz zx(j5t@3Op~>tFaDhS;v8$$X>E`!S}Ba|-2*rS+l_!m{@1`uRQIeOx@J1P28Z{bPlU z61qMNEl=u&C;@zXiM>(EWVgAl49qJ4?fxs%T#Ql;NXP2w0mTi%6NXd~o;TCmi+))k zNm=ThlVcnqHPpFCJC68TdwjhKWvA(q2Y(vI_pHyqYAEf(P;%K&;r8qh5Bj(Jl;^|UL(9@gE0~x`2Hq=+uHbDg#fOmy4%tJx83RS z5Zc=PRsn^^p5{p;eQ@PvX%|;TW@R$ml=eNU8ShL#-2;pJp;*#~!UE_0qByo zpo>RiD00i!EDpJ%dqT27!&D2a>hn-b%%$6{|oR0wtA%J@aTIpQ(R%*xQ4ULR99){Ji zidrnB`#{F+i6m&2y3z1=^HVN^ignOQhl1vdxg(`kP_NXno4_=SI`fa8EnUSWtsZnf zLOG*sYUNk|HF-}n)uXM|<2H`t*e3vWf#C3_ z0m_W5id?XYYY1^Y`Cb0aLJd%Nuwgf~T^pBYDuw=8md?uaPH#ol3Rmm;G{Gh9R%^7O z-iXl?pipW+JjT{Wtn6%4CZ>DdDK)V_izP^H-@HUUK(L|Gz{!occ_C6eO~tCb4EAQb z;_v#Es~_PlYo+#{I;H*ad?F;G;YM)-3iQpDawM3$~NNzYOX=NHalz2OB}BbU(fG1(W{VYWf`hq~fwFDWhKQ zNC=V))L&M14ywgYM8nr0{jyf(V@ntZP^FsmK$Iq|{D8FKjkE3~$H$W?){*SmD=6&e zrLxW^YTBZ(UA(xiE$;rwMw=*Q*&dpvqWtB6jcXu1QSTaH<9*V^!wqoKWks@mquVA( za|7ay2l_@+#0^3$OiSZBVweZZJT)^GSQbpEUvL-9peq6hyyM~oE|YV0SJ?!=1F)ek z$@|$j@PnZU{MR*xziY|Q_RPh>f24K*t$u45MI&dCSA54lctV;8+%C&MTd~19i^iq8 z>8_e#haVl?B{=}jwn=WjhX{@AdcpFS>^sT|YHL2B434%*p&AfWRBZGvx-2JNTG%>La$IRHUNNkH~fJUi}a0wm?Ha^ zGsLC=BC+5q9w+wF>@64Z4=}TaSz1rh0Cajm%%`7Xp}~6Upy3J#He%veb7@7o`gg$P zG9s*!T8JdwDpKd;DaI^L4{Ev4pC05Fe~iF9eC4qLE#o9)K1V;{5^p)mPs!k-C2a;G zzlNG&w>QluSWt~+8Rf0&lJiEX@YcE)=!f&mzPY>aPQJ1=Y$;x?C%HWKC3s;Qte5;xGKyAT@$PbAlKr}^dG0XD{=k&4<&~?Mi%XbhF(<4W@W-7+# zxDo~~=*Y);S3xX4trWeuLbLIUO<~GyGyTiO%Z4V6hwGfby$17m(4{b7V%7BBHtyA| zMV`&~WE)xEMEA!^^U)KS;%|j@*v8jV%otC(^$Yn#oTA}@J7pA&UphhM`6xKa-a%C1 z(LZXg^jcuBZU?IL(PtQe6&AlnM*>7xSy1fB^c33PfBJe@0A=j4s~>RzD>i*-1?8m- zW|FL~m@wdVEA<%&!x^(f&SOfm0^$_HI8us@<%}6tBVew-o4QGONf;qhXx$4r+8v)0 z7rfP#hx!jJLTWuA&@%6OnUxNK$pY$&Ch&;M0C`a|Lj}Q--S5y!#w8 zxK-n6r>|d6)FQ$b_t5$}2xweCNL7j($u*E+$ucu1inHx4T$)o`x7tbh_k!$7vA8K? z<^$5IuL5;;amB#nUBeW?*#;qx3JYixjKpl0?<-aOg~>2T`qdI5v7)Viz-`R zdz5d&DrCN3o^v-196?-ydlv3Bt9{iU>l%MryB1Fnd`pCugRC&?G z?(?aHC@vm1$r%*$9JM?>-XP)V6Ia!a2Rsf`PTbK_hzWCeV*gI z-CIi}dvEbuLi~ELUjEJ{O6j|?^7;UNC@fEbsmc@E12Kc-sTZKS^jL+!7N%9`%7C;2 zLEEaxxcibO=B&OTN}juVWx`s0jbh-XvTv+lP|V_lyhsd7sAF)3Ab1grhX;(s$9=xZ zxj@E4;3PKyXZ5dHqu;5)T`oR8+}mzMepcPbyS$vP{4ZwQlNzYZO=@i#ARt0~r*}jw z2)#9hn6#ln8uC{E$U@Kq@ZKe(YQnpoCh|)?r~c-|h97R^#Dee1Eszz|**xC2LU2|* ztA_jxGU%ddcDH_n5Rn`1=k|B^*)y3{KaDT|-@JFdr*_NzA3fEDuJ*g0=L;fUL7xdQ zpGS#F0lU2BAE_?46db5Mj)h+=UR$3!j%UA=Ft21~uYgv9`=rOaz3Q*)9fNV9l0Xja z4*^63v6ze(nu%-^gNC2Yzw(~~&X;^P-EVGbn1m@ut4t*P(ZZq&KJ~M)Sk;N|aZLxq zG1o=*oZmJl4K}uC2{-oXxl>Ia$tqT*zrea*SpU`GW?}yi*OHave-l3O|L=(2V^tZu zO?sG~PqjO9;HFZ!$xd6HO;oOG8(R^E_Q)hm@q;DV);>PTMx0fV0M>0!3%FDX1@9wh ziljj#@@x@3)A>^+f_{Xgdl*w_1WDu^=s8BR1&H+NeNx`vA0~;8nZu-wo7H2}v|>tH zSCyW3lqa?0O6mgs^I(2I-gU|1NfXU~I+DAaxb)#DqjAg!xIyw4Yu*TC3ph`2W zgn{e|GT3m!jb!1p4zky4gB-#RY+kdg93ZltA{g*_zWL+{`jbcdGkjSOa?(b2+t%EOjh~B+ZBg z&HDR^F5KaC@?Y0yj{m~kGBW332;|ibayAS~9?~x;4Ehpc%s_ zuEgqZR9Y4I^#!dGP{A`g?%MQ(8p^14kz^1MI$^Jm$Q^bKm*Cz5DZ#9sy1@a&(#1=$YR(Fa*bIq`B zh4?J21MGN!<4vo9*=S$zawm`j>C5AO)zhsxS@_z#kdvk9Kxj0i)Bwn)57g}$A+kEx zrj$vUa9qK-_G@I9HDaR?IP%8mqIHth4yb2-4piBa4)h`TnM3K@g$6WPIFdWs%w|v?{0|ccyEjE}QX}&Nkr|^?U~<#&p=|O;v{wOB2IuW|(meaW z<#c+oGqs|9GQLYv?)}0D@1C&823OHO1Bx>iBkLpYRgg10>{-=P7$FQ%B6sSL;F}T5 zrreS_;m~Mvu64AuVn%$jTa#>RNl~js46j>Gh1q>w>^w}0Uce%wgYYa_3{c4!qUguw z)Pl1qixxX4DK`#nHQ}ArRS6K=v+vAwc2mMkip%vnXRQyN^37*QpSN8qY?_6dv}oIc zDzU-f)fbi8<&7i<)+p|@je=mOX}6i^bJ0Qz@MK4@F)}JiyUCW4%2auYF^tI_35Cco zY+zLW2BXLtA#`EMT|xo>Y$#+UHJJob=@cwQh~jjQgBWO|Rh9JJ#vCM?w|^#0 zG^EzZl15l-vX-Y|A5=tlE3M}w^*wGE*$mXV9{ia1RkmaUY2Q`v?zYVS!)6)lOdvwMFg&#!1faHItUZslh;)WAGRC6<3yT_nvq_2}D|uxkL)moFjQt zDo-nwSyZ{hacF*t^;oqu@Oq;|Tav`65g<_n??h1&wDG)eYHGI0g&?8x!91AXuOVuv z!2eXeu0rmQo@)XKs)5Hp57KKSw8#JHw9ZX4WjMiuQ*KgC5oU}=rpE3V2gOW~8Y3S9 zw2aRSwoOXQFmNfGT#8&VU9bA_)AW|nVL0}XwFkn=g-tjBjn@{#-JmVyOr z@T+BJF7V#jKN0id(tSj<1|NLRXzg4klqabYHZY7x98&J-tMge&<%qS6ML-J)D@Hqg z1)V4%v?M`dp(wd#zg?!>yMekK%xJ7{?F2T*Jm1<{3A(9K8IK#WSy)Uud={{LI;y*; zXgoO7@U^qiTld$|!P7yyh_uh}avDQ%%e@H{roPgJVK4#~cGr+Vx%1(`n9GtlKBpQL zc1m?D$Q;vvC_$3On&$G{wY}}iS%90;@O2e&%l7F{D7)gP)ZK6nFmeo2flu8>OjgN+ zBeSw7lj#Qhf_X?X+>rrUm1L)ge$T?@*;^Xe&mau!^S*~nS%B@~a?o8H?G5x|W%vlX zB21(Qhi#=wP6pE2v9|7vr34tGih$RColLb`Oku~=DMS-c0^yV-(x7gZaLf&V3gACn zBe?rYeb%W|J;^qhGc6#iV2rbEEQ4RZQoZR93m}JfObEJ0F4_|Ct+%TgrGkPrF3H)o zAj?WB+C-HN_}tvjVt1%LTY?i?AlH^JK;LMO5iZopC_%s8K%)55+o~Vt*C$$I!Bu~m zpfnWv5N>R3ke3lg_ADN@T!g;C*r$CZz3UgmMO7>z9~jYD5v=(Fg0(+@1ra~9%qa0xR^>`IBy`~I zm}{;QPKhmE8a-ZOQA)?U6+)7yxh00YNvNn_Tgd&$g#Ab%;|Z=Aq3lf`VSahqwW+7^ z%Uy44+OCQgO>wWgTN*%;33+2?CbRz=bkNeecjnv{D~K+4ma|=AVX%lcJLK3ow0FkQ z*Z!OpF&`9nX3P9E+RL{hcEF{e3@sQBtst7Uyx~cR0#Gr+U?drTfFQWe{B*zX3B)2L zcD+8n_u{iBTJCyLb=Q2H zy09cDH9$#o{oG?0WW=($3|>v3MpeuDl1bWIryA$<;)Wr1$<*Q9)sSpoUT{)n9dyI( z8!on9fd}eG5ab&MRn7OjW3@u)CKEgj76^G(Mwci<3+4hDbn5^C0MGJ#Q3x{-hH(9%rRmk*6D|yjIbBvh&l}7VwuL^nt)KXiU%e>n^zRz& zE=oWMnLM3O*v=JWo0qE%yQLPqd-=~diRBVX^;XZ9N2RxS2e<$%cL25NvM8ALH*Zyz zUJRdZHV!1AC51Jr`}hSfrn{FBb$b#n++Y7XW7nl7Ri;PyrJ?K)Kg%nsCuJYr2Uk@0 z0<GFns}Q7_Ju{uE2~xm!eEH%{E%=T2n$7C;TL zw~2=RJKi{3efe=DU;6ZMOmr8zE?-t=9;~*Kh*8Ls%08+lU0w4kI=8*wHiQig&+--P#o~ zakx?+5KCX$vlSdnJ3y0TGQ*9K~sK$Q4+5Y5hXrHBL(#_HF4nj`yt zdYDCY0kGuZ^fa_SKe;N%ju_#6!(}E#wkL}(L`bxsO_MEmGi%2;b;1p?jTdFyrs~0x z&sL4Y8uQ57y&d9k4Qmy5LSRpFX@eIZp*6_M=GLQ@-9o` zZyeV-Y16P$Gp#z^eyUqKQp+6whD`uf+K^eql^~4qYJ3Ef_q=znMh|UlLUJ57Y&Ljb zAvV}AX2G$Gje%7VOT0V;wrzY3LDSEVF#Bj}55^N`|5v`0@opMgG#I5D7(sTyM}{MT zKFw8A@by{vF`wn{5#3Oiv#$&PT0)o>0G=HtCAK=NC=7&XZ4Qx3bpA_4LWnvF$*e@sipDyXI-AoXF zwHD8FCPnMS>j_C4_|9*vix+K`ky6g`mjIPZKHz2DYL)CXz3AuC_jiHG**X8&oxGgx zETLhSidIx%?blTVq5LpsXj9o?9r3CH`i<8&$B$b)xsy8jy_~UYRT?R#S6Qfjb7#Fm z^os{|X%hFEl~KcoiYLJV2fK%>x-RA*_Ahmiq>8wz<)=ea4I7p2T>4*6dX*|gS+(P5 zRPcNB(Yq?Ml(4(YpZzp9h`t}{uZMFGD{OE2IhyinZ(|GCnrqr!NH;q~H4#*^SLb^# zqMWB^6I}q@PF`Xk@`dh=$1Y}x?nPqdQwOcz#bO|KcTUTPc6(1{ru`1TDGZlGm&~en zQ5&=D&WxF@R7m>TEJ|5Z7`W`tG!*C(t-OkOjl~!9#`SJ`qbVnoylE^Il44SK+F<)M zCW&psv@B`I%u6zNXrWi=SdBO69RuklttvMwmur#bpfXYkM1>N zHi2MP5#az>3xy}}6c<^-+{wb;$gd*{)E$x2b5vU#4Fk+;!H=}gR<1Uq%B-s7xsTiC1X%=+~w zcIWQ`OSR-3e^v~w`PGRmI5mRi1kJm!ZRSbjlwCb)zqTv7k$HSP#DqoXI;kk`dHAlX zNj$(|otvFI9R-|CF`S5vALM2!K(_8d=ANh>J=r>og)Yo? zmuA0F9`;Bw$s~{^KK!ys3qOk^&U7^hJ;#uEd{fPF`!lk5y13`x5;lnx5T1fMy>i-i zPf|821&9G|$~ayXm%KHPWUN`yX2jp1ZoSrULhbQCWQ_+Z#LD%9#sVF0S!FL%b$(BQ z;%?P4<6N?5g^@8~45Qd5t=|HI_<32+%E@#NI4ffzwQa0%FY$Ir>I(Pifse0-<7>nm=m6uOz2K-HiG%4}6-zDqaG8 z@>uZ~%7R-z+a=`@Kn8u{r`9QHXjrkdSC}!()!2j%V(_S*xr$XmRR5ZT@|&`Y-~VMT zu5$iTy{_i1A)Zh*5?p*w$NZe74hB%nQr$_{rkk@a+N^|BZ7OUhw>k0+pul8l^^oK3 zUXH2jY9ME$tK{3AB!}Rf8YwnmBe;7ra6$7V zdcaon^Fk8pS0Hn3I1lH6^W@ z_i0*3i=dR+wkVl{E2w>W*;|g;l$$y$9%D>7v+);CvN1phN-M|G^e4$=WGm%XT+rS3 zMV4+i>6B$U0_6&div%k?tj-h1VU<^2a5`P#z_+eq4OuVNXP`syD2Bz_wRC_YHRvK; zw=IBqQ0KEQlzNrd_f#y!+DMJ&F&yj()vZy?x*5Kqw5<^l>ZMG%MDwLv3e4w2xsl*i z{lb~XZecS$tZM;Yo#eCb6zg|WQgjf1#a`g?JGa^Cv*`SH?251cddDH~?i<**13CWJ z^B}Co&nZ3ttT5;^Oza)y22kBY0&?jI{jgJm$nFs`m~A8oL{`ItSRhCqLe4jOcZnoK zgB+B>Y>cq7PtT2C_>D8Dxcx58A@lf78ifpcU674SYJNc2uXMinOBb{wE+Ps!3#~OJ{EQLvKC^(IfzjLz7dh9S^w+CR4xT z1d%z{J(y)gN=t%R@D9?uQO6q_(Pn*t^yrbf8f!}2CnGaG(zcrFewr(PTdJLDWM;J3 zunnzJx7+)9K0+^|L3$#(_?Ogvk=kqP)5b2XNCjum!wEuEaon_uzxr_9m%!t90|^1o z(M@5=!pHo4iHX^nafIUY|trW|S$-ft1t58K&?9t5?8!ZysZuM-LEK^x&BC3^<%oY2% z920M3Gk3|vpqwg*p&KHw0Uu|>z<7w!s1DIx0&UC6IN}|c+R6c_-2r6*B=d`BD}S;7 zdQyC9@Kgo;^K6wAE;JeXH#_L5TB)*d@ZMUJ^SN9KDC$L|0G{Z+f%NUq(f<~1HzW`S zGc*#{B0nvCS3W&rk?y%!m~>LDN$0@Kle_fU5elP1(M^jAO24* z{2v1kCVHm-aes4LYtwO)9qE4oI&4ZLg9k!ZJ=Q2kWf^lDapJBdu2mUR3Mn`b;7BM5 zQRQAP+py4~^3T#sndq{>p+O{`1P=G|0bR>q*Nb*Gi`3Y}_<9frrNogQ=DIrmK|B)3 z(R7bShvkCZn(la|eL1=^XWUWbWUH*(CRV4N(WDnj%U9@BzPafhn`f3q#4+wEWZs_Q zvh?C~cd>mq4E19?r=r-Iuad$=bz3<v|6tO|E_Rdn99RgV( z{Ub^o?ekQIk{Yiy7^sx@5ey!&knAVvl1~ieeT@e>T+wjlg=Y!~PdaIsq;gsJ-b%5O z#W?-2PP&^~tQ%`{cd(mRdrFokJ9|2`0cipQfo6Y2`E1Hd z(g2|%XS5{Lc21VXU!E*G6SY~hr27Uv)<-em^9_3GI0LK~_I`Bqx@dtR9lNXo`BF^7N%4SrIc%IE3!3Ad6RDqARi^lyqyn|fTF18R zsZh;V_3^$0PkJk>3NGWT#PTZAq%5;KQc13|`*vj8He(+lFEH}^z)S5F`lNR;@`c_su$8`qAVmbkvRbzc-)ew&()2{oRUoYAA%t#}( zTojDc35si(YEdM4hfuT^(o9k28J~~#(Ml23Wmg$uno)HTw?#dGxK)#-4Y*+*3z&AqbMBQI zE|FTRGHp}q3%DzovLt>W#F1Q2P#Rq|ct27>sr)f>{MoeFWb_OseS88ZR-+iJW6_0Y z!GFokhMt{EQ|IzG8WT(8eu2V*csd^Tx&7)!sMD)*tRQNdT zlh8x9;9_aM@68gnKS75Y>Sd*boz%B{tlRG(pGL0$;VPe-sfjtbZvIJcIG~&`Qo&(u zT=x9!v@yiIpf6 zbva2PxzzUg47C$ZfmzFuklRJi51DoOCfRND`&7`!|rW7d-6QxSNC4`hMk|zhv8q^3k(3X zM*skmqXQ5+BZP>-%LSoZ;*vm7!bi8_Q7II7s958k|6O_D>DE=_ig0z*B7jBJd=L0a zqV?rpPmfvK?PDBZE5_U~?zqEk+EWq*z30GjZ4wm&u(nVo4eVfn!-a5d{m#t+v*^Lx8;TLQ9tZ<9>hlTp|33r98Secht-lXlIU5t?O8Kz3T$-@ zCU?UC)p6Pnj(_28y+V!)CBS|-t4xC^NREs}*z4iMq~5IkXe2V(3eSuU#J^ax_??hx zvI#zoslO{f)553OXboT&4|V=S9wrDYT(&%utz-_{m2ogbrnBnykuO}8jXDdb$T$N5 zpWAigfJdllfZ^=JBExTdx>^T5nGt13onVc@Ure?)=Y7F$M4V@h(Oh?Kt2Y}qAqze-HZmJ} zKX>qoVjn4}10SOWXk$H=zfaE`!b$&^Hk38?(K*SKT*U9iIwwp#CcOXgz~d-jKdldG z{{G^zFO*Vx^o@OneFa>YG!!`}HtrzU2#ejpJCLBM%|%1x2^sO;J`)8B#2^M6nSC7?Ri>3U zwT<;AWk7qjOKshfP3_33`oG@wQU>&m%$yft#s$}as8F~EXV*+!d%_W`r zzriB|U#4*D_agVMxyX1+ZuRD^`RdFAo8u}eJ3=t%Y%#PPMA_DyiLbW@r@EK+rxBzP zFu?VnVE&}iL;r;820;He7(jjVLm-T4EUW?SLj1>sXQUFdwoVolkE}X|#LC{G^xI2l z6XL>w$3QzY#2c}d)%Jmp15La?K78BVq*7(KhX;0>9{?^)+zvKzF?BYFl*JK)5=nJ; zUDeX7Fr9gR`#(QHHQhC{efy!PBEQ@@kT8XdqIB9BoI}waspT;2W|k{mDKmIyzmX{= zo~T#DZ*<@hm~qHRJW7k~vF#FTmVHO?$}H&p;tEcPFgrx9oP4sg*qb&#!}J19fYHlL z;DEj|TQyPArWmX6qheu^rH$wd8^apQosZi;2N%+1)!rF{f8m`@+OwEmaT*=YtfkBE z@_wEZM-d^HT|Mkc`;(GDWLViA?_t6&tEFy6AEK&eM2`4Kk?)(!8Ai?2mZVS%g&AV8 zNC|Bt6=z(_JIc{KzNLeB)>D9L_4~{`h1cTFlae$-?>4*Lax_Y1p&u$Z4Z}QBH2%ud zs0k_3w(Q_kabxZp7rv!Gz2e17kDuq0_58JCx~Qi{KCjPDeeRd+xQAD=H7+y`kFbX4 z&aYgIQ-%l{$lIcef)Suj2{Fl~J?e<`cCN~zT+!&zDqlaz!mjA|Y!kbJcap4`>eS(K z$>OAmGCfn30fleF)a4=l$0o-|hBb>w62P4Mp$r5Xo0<@W6En!S~Ihre9sq zBeItkr@2vXS;D3s6Zk6_cX$u#*6dQGpI4qJol%wfRWf+Ecgjqfpx?vuc6@ZyfV(Ai zzlg@B)nY?asZ*mQ;qauNaY`JTKlDeqYL?NaG7E3HRQ)-zX47mD##!?;3^m8QS|k?S z8=;BXS6FeIA5Ob>RKn$Kh!~`di`l$C?pN5L z7h(6Gc^k=;6XN?&EP?>E55P$iNW1h4XhQ!5{$G~`hW{v5Fw%4U?+xbv_jJ@X=A`4M z=tFH?e=R(;YR2I}H^7yQ6i0)i!<9Lz-c>Rbm;j;)LNVlAw92qDbx!Slk0&Fl!BJk# z;x;AK<+$>vL{8mg8A#t)By|O&CI%Y)hzB)kpYD(S!`H*np#(s5J34~Fh#;=#`Nh$7 z-BuRx7kC`gAF-X75lxQ?VS2QkJ~?0Bec3TrW5BVo40)3WBH=d{b`e?a#WySRE_T}4-Qj{#l+c{I*mDt&Pv43KpE;v4t^{mSOpAc zut^M+GN~uG?aCDR7H|hMOquI8^rY|Eq#hE7y!#9ZGNN)|>Jk~86VJ6EkMy1<_M**^ zJ@;p^vjt-I;d_b9YQw@)APY=__4xf-2R=^#EPvDL*bQP*&nJ?c9R$alSJ1TkC7BRG z+|!iJw}Sj7NJQZAdz$+qH86(qws!zfx6Et?+l$JBg)Z4!^HIcGqY6#d_}#@~-L4e1 z0a)$sw)<;L&wqP-p>NILXJo7I{~q4?c;Sz+9sIt{i~8A2r^ujp>@SX?gy zjOkuex`vjP988(t&EU|Gcv|ZVtekIxu6Nj&#~aBwUZRR zYZXwPeHt~t6XsB$IRF~BT=XeV1pkInG|Kxood<6*@D8md>V>uiVJG1br)%_~K(ESI z?0xR+-lseP7|(KPEevzf2pGCic9+&1Z23)|=$DZfrA{9^YSV`te4yw|>U}P6Cp#}E z@8=I&Wt>ydaT&7@0x4jaw`1!LYV62owCF^q4HEAW_vi6dvgz4~+jz@n{5P1004S>F z@rubqFX|VLy@o!nRQkB3lJP%m|JWz6TfDa(wTj7NPW$YnoMWsd0R;}BrY+uUs zu0!ZZRLb1`22jb{)`oFM?L}|HR;wEN=*85+v}ryGj+uNcDY|<2pLwnUNvpp$p++p; zqo{pN8NP8D{>@1vh}f?BtSa&LxLcKU8|lreg7K(hBs^Aqey8hpvHIklaiZZ`X<>^t^OHOP8Z$~7Hj&e7SKcXnxD!}_c`0$v!S)LdyT>nas- zTCumq>V3LsgG>3CZs74DCxriYIoG%8Lq*?yx0ND8wa3aIuxQ+9!TNItIpw>^ z3FfDO61%;Zu1Vr1l4BQXoxc*0#HXxCeprhkjY(p{zd%@RMfu9$)i!-SG+8X@76#~= z&YxP`Zg(Ev);wW#$KPeMa)r%sxmj*73a8Byu0fsH*=40}lf&cZ#OvkD;`RLS{2n(8 zzte>ekzu=dlwHlL0#*x+VYAjZD{q1v4)2mNIX5+2 z+H~g9;G2g6Uc+t^4-QroCDtdAtPzl=tzKboEix=3D5NL+N7Ao>O34{5OxGQs06Ox( ztNSiI#K24bYL;WnE6XO5nCEDO#TZ(lYaj9$;xkwPw_wvT7|t!V5Rz9})@AgfuJr^>fig>Sbq54_y>r#*13%J&W`RC7o3 zTijleFmcH9a9o#T@saE|Nl*Dffaxi|?Wc(G@3DKIKA18ZM@TyG4$4dq#7M)=Qt-;Tn)PHUhae>ysOeg(RFcdCZe!%fqi=*zk^rPwJ*^|W zRO&q$tNaOs(-S%?INz_r+jBsbe(``aM=X$Et28Tev%i#0fqOW98Y|@uFXBe~Ezw1* zWXFyH6f@FWpC~1E?|*6#=Kn}rvatT|i1z)fYZAs?P3uf!Yk?Zbflhz73?ZSMOE z7FW~y-w#PajD+M;@4MCOI&?Zax?WxS^cYd<1#AeZ!iw0xk5RLJ^X5R;eWJ;rs;wT=BR(#b7q;oN)Pa2IE3IxL=kIE#t3pQ zIKv=7NmaE8Nd+v`yWuJZK4Jtc*HmMVhB0tzY@GGX9+Zszg_FsJ(pN|dgb_@Xhe0JY z#7CQQmxm>-5-pKQG!dp1XTK8#a{t6sU{MJC6(^%cL*KWZ&_@6#rK-9K{!h``7H(7|_3&@ge{v(;g!Y ze0}F1i6iflmi+T8f$GD9$>XGgs&^>Y4~7z^oA*UN+BOKb23X|4OG=-NqXj-uA{j32 zPM#KxQ98(S1$!hNd_j-}Ml2tf%tb7JrGRX!)KxKxY@F?RhXNzCpu=Mx<>_z3yu@tc zWMigbOJ;MGcO@Nd=8mJ+1;?U*yHrq?s&y{Fe;JRX8D&?e&jqU4d8xStAf^mzarGp`Ll*+T1yu#CxE#c|l02mc zZ2nX7Dp+z=Ek30LEdNu|5*fX}oJ=sf%2xwj6%En}8w#NWt=0%?p#oWL&4Gr@6spJ{ zTg25e<<+Pv1mgY5COfMX)eNN6v(9GSo-bz}PY*WF-V&@+ws-{(?OXZ8 zM>#TH{o#iR=2fL2(f(UQMaz`|Xqj&2`&vner1WWPz~#;KCua8f3yc21V!->VEHzAf z!d1u5K}?Ck843mdInThw>1ouC9}Ji|`h8dsk}>Q61v(@b7`3vjTQV>q^sXcF5=L|| zDcsBq?ha>A1&Lvt!N@{5Wblm3!c|Y)UXW{`!;&ms9v)1dPOo*fs*C{htCA}Q@^?&v zTqdZ4`8E9)!?jn22T$uhI&TlY0Dwu;57!&5@5R%uEf1RT8#m5)PBSqry$>TZsp5NH zG&$Us@Ixf8&0zzHCGoc7>Wq3zsaJ!8A$GNN>nzM@>lf*tv>hmK_T%3$`c5M{(zzh1 zS<0?)`kN0r7K((5syP9~?qCa;1I;7@61&9g{l4sLJgJ~z!*HQhqYHcSYX$X>`nb^` z6l|v?82=Ar@4zc+(}vM)+qP}nwr!nl+qP}n#@V)Q+qTuyrcIjkP5M2*Ve-s1b6>NT zQa?kj6f(=l;YH(3QY=?}!He^#!f2gGss6t52u86|miMpIX=NhXOZ!qbg1 zrCt9=5G*I7X%$E_r(g`7(<%Y)~c56HBr4G!-^)S&8?5wL+g~5 zjYj(Th+~6a4h_C&F&Yno8v*=7M!Af91qSqlzkGCzGKuaTch9;=XPfgMMqK3~@FWB8 z6D(^nb>!Znjyw&z*J@*{zTzypu5SheBp{>%XOBRHT`sI*o+xpP%l6Ue)H%cjJF9?z zZ;wO;@oSn13KG?BBqZsC_3Njkr-4pFnulWfos^b9XIWY71lit@2!UrA+3W&O(d82X!^(`2N9D;sbfxX6$kS3TL3>Enb`l-a!$fV-K^-|2$C4w z@=ook!Phqr*}B)Yoq)kT9h(3SjW?kLo)@d6G(vc+1|j#v&(|do4xHxd}o}BE+IobU-=`GJdpKkN8^;e2MtHxU1Q`E zB3Cu)z=ji&tv0hceclS8uG0HnMVB8SJ~^SEPILTyg8%M<$X8-HU7d#FxaLoV@zI@P z088TuV+Fi_m(;x*1AV1v;|JP$7p~V6MFa7mM82qyJV8zA+M#z>MZsp1JPw=w8CBL9 zT3hWke9E3~B~31&CugIFLp@pir%^q)jbrl*-lfs|1XCZ}d9;p(cBkoh7-={xW&B-3 zn_geyE+kxZH=4=(q0mN0aUz#nukNa>m|=%JK?N#~x}~!#g`OR=W^A2>asf+%oOjVc z%i4W8AF1%E=*&-s1dce2w!e8||G+Bn5J>gXTde2G6(6W-21_eQw#pTRy&^09Yrx^G z+|Fl+#}$jpD!>e9dRcw`u(ds9DoeF=h06mNkS9L?OSmmJzUq= z|5#NW05Nl+8ZVcUjzueIwFseQUp9ko@(-qoxsZbD^JG2?p+1sMlvX@6Gk|Q-ymht4 zE29+NG|#g)o!M*g+@D&3&F4>B0gaOV{U*K$>6{Kf)iZzNEa2dWG|$pn`_BLSQo^00 z5Ku-45Q`Mz3>cbKJRg_@V)*)an!97t{>=nTzek0sx3dRtC;G_5#Cc?+q_u^&%O@8A zBcH_a+tB#4iWJAAr0b4jt+`qErs2q~yII)w2t6|;L^|p8baUg*VR*21GxN88Qt zxT0=;o6u(>LCn)t{11Dy+#kSz8U0yr7=@-Kb&PQobaw2h_Gi zgjHwXlb&A$daSV`ltc>!8~j zHg-#52tU5P14^VO>RYC}Hf<$J1f+nfRKbVBpcG6mWMx`cyy-XaUl>&iI%lN!+#JS2~r^wDj?8A@2GgZ9%wQj zIUwaPyxZ7Rv8PqjTmI;7i+{IkW>hm$m=A;(vmDQ74KJ?KN3B0c_lvL?oM|Mcj|leU zc6$m30X@kBONnHH;Aby$#d8HXpmwG6=FJPnJEM>k1xI28Rl8ocnPO97C7RP29~a3T z+Bek@7Yw}qF~nLjag`VtX{K0B<3KxMMQyy8t^|UGMs~O)VDBDdEaiGB`y;(*~seAxoJwx(%IaQ1;gU|(0D(8 z%jN{lxW{bvFTD~XWNnC>LM`mZNm6~;(xr}6#^G7{0+35XfP#ue(?36NK2cA=j9eZB02$pw$+sb~ZpgDdk9GiVvu z?JNZ*X9St$)k&1lz;Sb@^eY>!QYO&LDNYC9h{`qxeRjN+9uKk*5O9WbXkd67r6Fhw zIdIx3s`cK*DDd^qX;h$$kps(o zsH83jtE(s+Bsy5)=kH5^g!*T|U=@(iEle39d+Hiq_@yQRE zBV_YI*en-FOCt_r+}rx)2m_u5j6Ia9h>&h@nC9d5b#QptoDA#zc>t0=$svQ(;{^Hn z`xw-=zC7Q`Sh2r-l{y!&3w%qmI(9w$XBDi*9+vjy&(T0_?km zAvFdPw>1eC&r*nMd6yiU=Sf9ySS2VdVq5Dvdn`}jupB-br95rV;f-5?0Ck1iuC>~& z3W)Z?@(=ctc(QBED+?}DP$)s7JJp$mlF*@V2%Aw8mG{`6kVlwsoHJTWlVlN?EkP#p zEEb`r+5y-Ux}*TbeK5zi3ZeuNVbEM?L8R+-H6f7wLChPTBp*UbSo!E}U+k|h_bg!f zXnzc?O7ru-`_v&@H3+f7e zBjs0>g8kQ%1xfv20p3X#+?Ulk66pN}5SO{^bd%E+7V^<9q4mz;(f$T~vA7lvaW*l+ zC}(ul~g$3Ax*w#>6<0V6^JxsR=2iZoSKH>u=(b(Ce7Q?)m`-Jk&lSiOuL zpMPB3ZwbN#sU~OvF7@%>-W$KvfJp1DJ~zJ9q9A|3>mI^?EqsE0pQ$G8Jqu1byF+ib z=f9oxqjr6(E;~_sWqbL0myP=DT5uk<4b(pWpLIDFyK8xGcejbXr8>YKUT@uXSUb3a zLxDAz$fx?3ChFO)%h`GH_b&iA)+*zGSJ1|7hx_T>a-v*G$f+|FYjx3ufkHaM>4=>AUk836%HYYTD<|9+oMe(pxl;V(lA{ytESt7NL?qYYa@YhyK4nbW3)y|FvN;{g+gUjp2WmDs5|PJ8ejy{hy-DLB76~xlK1o?Uoi%ptW2_ zYxwx_VkTu2K*TDv_(9T$-|uX-Hjye?0SV>DdS8Iz)Yu-rQ|>fAOXJ(9uWmn!paD>o6Vj;N$(`HwFK zEwM$LVt5jwaATZ>7yQG#x{t%EI(3lTP~L-g6cDE)_7qZ~6~h<{q}lZ(QiE z+2-u(G@E(PdGLEJzu6)-#2UN%DIFH+69U2bB_z=+&`t$11^@FZOoUhd&W&bnm^N4Xi)x9o*7Z7WC<=*Ngt;;VtpPf{jB{_*uFWcKN}2A7 zq4d7+q`l=KAOZyq7d;t?J5a^!)lHKW&jCz;9wjOmh23LxN!3f9ujLpZiv784blu?s z4+&+GyJIQfKnFSMg|G1Rw9j_fJByBPJ+i#A$<623 z`P$Y4PJ#9VTmh|n@;elYl+Uu5(G!)f9Z~%a1ZL;6G09SRG@DrM2+a4y8NpvY(W)nw zPzJBin2jqC$Fk&Q+@ht6XhJYwkAaJz&aj&`4WETySTORG?%@D;w!Sp%oso2G-+Gx+ zZkxBCxb;O&iS}z;2{U1*igO#0_Vb8|3>g3#mp$yJ%YgD}k;|};^a_w?7G0~*vw2|h zz1D1G27qh|StUBfSVlc$&>&U_3oQJ6D5XEjn95@8+lIaB+^$gZy$a#eQ6CO$g5^bwhc$hdQtmlTp zz@8dIXEUd&#(}^kc(m3en6w0OIOYX#Oj^agfCeAJwCxytBw^0>Hej&CQttK+QwBII zIMbFk{etXEQ%VmXEv>+%k`>qCmD(22QiuhGhGeKJ1o#V+=Th1algt%Sb*5yr0L|1k zu-(1C`}YfBfwg!*I5&&nCgvmcU(db&lMZ&wfJDf6?Xb40nB zY;F5X&F>i(=O#)=0U|2Fu)>63+eX4$dX2wb(Qx~>+02~~Gef-#DVe5Hb0WT@j}DY;r4^ zqope01$;7bc}X00(7A@q3O;r_(epY`C``(_-sa$Yz8(A@)%#OyUa*Je4I8`fF z8y&s=uW&PBU2Z1JC%n)IW`@c;PLT|#C0)OBxO{THJ{Yg`20g%)bdNSFeP8g4(~ouI zbd@qb;9{~Dn-o&v&$2Z!C{#%xt(FO5S965@aeVsPpqIc zA^;CxnR!yh_5>S(V~!p&5Yx2{J6PHGa!{TS8p@%J(e-}W1`66cywO$Y$#j(+C`|^K zq1}Mjq@9&6#Zg6Mqcj+#D4*4YIRqLhMhQW&Ah4NOi6G(e$OT5ukG>3lJ4v)S{$6A* zfSFozdT!98O+2*~(Q-7;_oS7sOU_6A(GT(0V(WWN(rE+i*hl8?a z<0zASjmX845jB5< ztu#%1Bfs9uVo}sqci^Iskv=#qo{f1&n~zEB8hA5bxp^fC{{GnbF@11gz3!^I0io;3 zl2hyf(_`@46rOt{)R@hm{ppNSQ}yW|c3MG)vS-q#=vyz*K!chz(FSnJoK(oGz@?Ar z7?J@A7p&0O0DgD>WnKA))Uya34yIcI(53``&p-`VWJhwDHf zD=_+7ynl93dG5f*aP06oZNwFoZ&bcx>71}6E6rk1|6%s)n7%A zt~f2D;twKa`gkd;^Inn$U8qN?)@NU%uHvAkT0-Bj0Or#PthzzA&TmGHt=!q9R{|p{ z3IQD$dfQnsn}BlMneT~z+j)U{V(bPnXDdu!7PkmXqf_*! zOIOtu8(cmIpv3f;7;R$G4NHkY4C4dcrhIxIK>9%N2rfuDhU)2hwe8P92al6dY!I9SvSm;z|)(^vK=AQ`~Ko!gBDlAo%+Z|Qh zLs`$;Hg{VQx#v|Lt@5hU&l1gFiUW` z2?D8bBlOo2On+2fvn4LTC|oZM0RDaYZeIR#;T)31HgGW_6JMY8{fPGp%x9#iNcEv z3-n+YXGfI2q4nM2y-TQb=RERm>$YuC?W=X^ZO1AZ8iDLpDC(SvMHCK3b^nypS1M3MjLchiQ1F}+b-T7KeT0-787YnQ zM7As+Zy&&7Gp4-`Z0ctEySd+w*t44?G?3f&PMw<~H)IdSC*(UPY@6QoJ>9--E!z~W zbeGN)f0pg8`;dI})alE=#n6n|5b8tdFcYXs?>aBG@cE zUiQ(=k_129u){ngyWWe%Qn2}>_qDBe^1d&p=7nPQM+C*f+6%&(gnBFr4iyil?=`l} za`8J(bmWG-`3s$fX%v|Fe3GWYx$SW-xqwTKI>Wj)lHkN*wqfQJC)U{rQkmyln;N#$ zNdvf5UH3F9%FE-&#ndoUthQHHEVP=ncN_H1VpDt2`E_jv`#eQi=g;@=9I90{2P%#| z#=Plw)_9B}%0NHP98aYmf{KD6oy+^{eE$a5@QhkQ&EG2YWWLZ#MDgFYKV{50=%xe+3DHrPqpoKb-x>Sc$v5~mI1xdW+QwJ=B#Z< z6Oe`kG`PCtnYHITFz4Ozq`uW+h87mJTI0`QGjGUP2&Y(}swzE&v0B@Xyy$dt{}a0= z$jyjM>X>!%Nh?snJ4RVO=>F48fM-INb^b*>++wHVJetO4R5{=GT32iQ+u_*+Gg+}= z!|Rdyy^^MZK?JFJ<=9lUpodZQ7ZSM&#X?&-Dpc8=xe1#g&SA{op%HyLGRhRd>k{MMXBe=JCtYAfjsya5`%5lxr zPpyOt8Y9*>Z#GIf!om|7eezeI=q{T!Lxp4f;yDF~N#=q#syQMkmN!s=0S!E5zxEHZWLo{eUZjxIziPfcp)6hfbUt@$w(qzI)ulFU?Wi=ua~z>MuP#ypG7cDll?%cX>H zJyUHP&$2bV@F3wl{*e@$8?eM8Vcrpm|EO+{{y4Gk01jS8f^KDr)l+JTpl3CX$^2Dl zpj^ll4EE!B_pP+Jg2D|aophml?T`!8iHtBM!%y?yF(0@C5yN<>kd-yk=kg+_{jm^5 zD3n)2Y|xd*KG_^Q5cas?0`@}e!(V#us<=0?20oUU6-#(tDg|;5L2rxznGF9T$cf%y zvA%1CtQ+n13mifj!zrwiu_{*KnI(RxaD(Q*dseMIj)E&mqs~yrm;#M0Zs;c*`y)=e zXdd40FG!^GN7tZqlJ`g7pw?j%eY49GkvxVy_RQr*AkNmFD*hDdHvIoJMccy)-pDO&QHlOd8s6DG> zs%FuXFp2#J$}kHsh~+^&?>{_uX04)!7dzwn_`E{{w9FFf69x?+6#%53KZM!1Dg8mD zv5d_;hl6@bkvSzH_)0&w?%cVK)G}eK+^cd@nwU)K8rAh*B4I-&j0=`C*BzH?rD879 zu*i|jY2^vy6l9XuCMF8#MZPdJtZT=^gS~sY*p~O~qro2V1zg&ppS!*9i^W3iIPm=3 z#!nd3M{o+1;;H+)80l6`63bi@OusS~eG#ep;L{NUm zQxx6pAfp8@Dkdt?tCS#2ktRHU3fmp^H`U`h2yP%o^`^uzoZ>j$d?JAy#p91s;t5c( zvawN0%bBozd?w!3@p5o&rQYw`UmjFPNxo?xh{EJRI^SSBEYQBZ1A_n{y7<;#K#;Ha z_mNAtZ~&XspXC?hso7U{#$OM}72zL>fq#R0KoC2{vNsOWsbL5#Gx$Ei{6gv84q1HA zy9BFu9BiJB&kJ%^rU}RExeZuVuEb~oMehz`!Cj@;!?hG~yFr7K+X?eGH5FaLXnA7% zY4Vp}oHMLXZbIp=)AikwY!STrT{Aaw;2-bDGAzH2Un?Kv;?Za!i}Az#4{c+F$}L+0 zuWPjdUbKh%j0Vb3xjJwyHOxS9SQ)Ak{8Zm)cHXxkEJJ z(adY%U?p#Zp;1jJnr7^cEw=nIlk)>ZXcu3foPpQ*}CJX`n>aYg3nt%rMsc_ ze@;H02X2PCo4qvIw#Rq4)Aq+V@*?l`ei2Ij($X^xe%2UDys^k)dwJ5BCdFxlNGOlS zQDO%{BgAK&@B0i9=NJ~QzQ=EPc0b0Ua&CTp@+ns{naJ()^J21)pG4fuZosF&xt@!w zc;sBe%W}W8ni^NYYX920Kk#o=|FFm3GR-`Hueim-kubK=!3pu&SWjR2S`WLYJtZCf z_C~|oA2NUYjy1ji=KG)gKyQBzJ^WW%X8y11+JAt+|2ZvdYNut7Ao}j=_Y*rc$Cn0x zIm_WCs}@(wBTde5dB%VB3EaXV0vppQz3g^YR%LEZO}MgoX7;G9K37qRalpsg@92FW z-(1Ms4a|*y$w(e=ZF3uDze!?oNhW_NqH(#EJobNYUU%mF1DpG7qa7-;56(nwdzWvV zWUlxvwaj?QA|HeMl8BJG@$dS$J+F3F>DL0e%W?!HNf6+?M@VEJxIgck?I+j&EX_x#K=rmf)>Yxxf;e$~e*iL2c~=N^l>n6m#WW4$o2>_q!4s1za(L^J_@a=K zs9%(Yj{bflo(7>q@BegL@~KV(kNa)D7Tx4Yrfa}|(Zs@D4%`c+mmnYd-oa}4>BE9! z;Z`auR_g)84h<;!6GCRHMsgHB;+bzuPd1j#+s|=?Z;PRK+&;pYL%$}lU0UwmOO?D2 zeA6M>Zq5(6K-%P{S ztU1;F+-Fj(LEE$3x#cDXeEOyV0GFepTg33~;XQ#m3ij)=+2RF!>_;8tH(nHI=sU}*ickk7Edtx6WuOI8^(tBBj+ zYhnQp#VpKq%hZ1t3$p-mU$ zX!8|=+(lm%+{$;ZiROQ6QFuBWnL&;kcSVX9X-A7cBIWOSL)&wtJY;8)9s?vJfWA!O z9o{B{r+(noB*i_~vu&A_um8osGT1xSv=noY59#p-)=U4$Xg-^AIaUf(;4DpT65_SG z6`33^p9?LJr+ef!Zy=kkD*}DgwtI%WNtb=`m8}Wo?}oj z>DsXQxWz!`6Io#na`g3%aqE(&gKLUY0mRW|NfDIsVK}-|0O5x#1VGWL^A^k*jRFwK zXj+O!D@*{ymg0iBHgDrEV^=5&GFflRNISyd*ym#oIty5ik(yo=hY5_RUl*nL+$TWm z?fHpJ_>L${eH`qKqYI|SFv%AM1%dcwVt)0r7`;faspxRQZrpq-DFOh5!SrokcseWc zbD(yB-F~%DxppaNKyb5k2=bL)i6y?I+^f}71#4>`Me&v+YZ%YaGxxi?03)FMORLRL zr1;dP$3P69*4Y)8{m|_Km5)HM!|!)s-?OQrLp5znxS0>hw^bcjcy5wcAIOgpc_EHB z9qD4~&b+pY&3nwU} z^}1^DvPe{F!_DnMW%2 zX4;hvJsGX_Ar>*&f~*5&acs8;#xPhN;;0yK6rlr&7ocP45=D;Ej54SV@TzO`vFsx$ z3-N16?MY8@*;4#XF@grHS-%qZlam}VC|==ow}943=gSycNKZhl8XCS;OytM{&)4j* z!5^5JwaA5{$I$6H@LcpZ2(mpBMV*G0Z(-oqD!d2DNIv~q-U);agJrA{A%Hcm!jM+| z#EblPH0;efZq8ncw;SuJd4h&PiX_&vJQar2-nxp+on=)=ls6vT=Dci zc=60vl^82$ppREjhi-=(qtsv%MXm;5SpATcuTRYtexN~6_jp~~px6ar2a;ced-tUS z^!HR=GS*z5nh^aEo$Tc|r)!U_z4o&E&{5MP_gw91;&eLqQcIr3LrQ6vf=wp-=fY@gfT{&5NTvPt7`v85)sk29J8xV z${d-~h`AcO+L&p=Q(C?&znq!2B$co82QLuQ(zK zlkwRIwFby&U^G1-8>>X6OU{cCkTuLRVt}9N)9LW9XW_64F|6rWGpKuV>h4cNP0H7y z!+gWEF85{pQPW&a$D2;G*iFT1J?&`4k4AqJyluAWt-v8iR<_kiv)S~kJb<98*!>n? ze%H4UAWHN_7<-R;m{C@IS?U#4Frnbj;vX05PwmzR4Esf<`;S1x%KHCij;MIp{~@54 zH?mZAwt=FTBVc4;_&+ZY9i5yBIGNd@=>Km%A0r1R%l{gfhBbBVu-lM)R_h4n(oXun zuzbyJnf|Lu^@lng2;i^f=MWhMVbc^j73oBJ^&Ha-cT?vL?rOy z2?~efLG}agu0hGutRZAt11GY5A(}0aInYRHbRxmM4k<+%lcjg%( z_f24&6ObZ!(tZM=u%HzYy*U{cEsY|eGKF}}UnWxr0Z8G6mQ{K)>%0X4jQ>k;W{`T=$g5A%n=MqgTBZ) zJ?@AWYp^|`!$a>YiBciivw5)a=R?v1FGYi0i!j8Z9hLDHw^Ozd-KRu_hPb5}gux2f z1w3*wiWix{GV1O@m*?J(tV1uv5f=L291bJbO zIuH6|3}!s96(vuEK(gVF-rq17FuWH~pHJsLdn+Je@Z&!)rqSGdHO@oILynRL%it+d z(G|Rwoq=DDHN8Q*ckvI%V>RcW3F1jKMY1+Auc?9QDKe@C>mHd~gFp6wX869Q%sAi! z@n95fYwyXW&>IeI&9YN}8}jj3*V|BcS2q0R%Jt3i_I^q(xCWTGz5`D}4vE)-E-^C+ zu*2?u`rL(BRwk5#eCu=-#&m>3*l)u0Do-#03=#KGg1l+o52- z{|BMzJ2)a#I@;7g^Q5%#JfV@HAdX2e0!>W`-Pk&?KF(yJ9ot3Q#0KF#oy!G|)xUT! z9Hv>?gyA~^rj9y;ScH^$;6^W>Rm>DWcJCfL+UdXr{*Z>;3LEZ_KUDW;)#`kv*ONDIHQu$MR@$An zgr?nY%@5m(wN*`J1a2v8v#ONm*Ny3yNx|;o*rkQ$@k0JW{aGzXH~pbc8dp&AvamTj ze_SF?Boau>5}gB38tB5M;3G)kw}O8KNbSRc1&=P%l2X=l*t?~s&_+u`JUz@pRxZ)0 zl6}pvKt(hWxw37Hn9$dAu9%`wFE2M0bLmo%x#IL9=;QEP`{#?pHgoubyu_Al`t3z3 z_9Dac_j6q)hCC{%REw3`g|((`$>q5va|OBuYX)u6vgGPmQ`fJ3KwPr}XF62BQW{2+ zjac9YZTHB$!TmYdmHuRHh=$dY2qlxr{yM$MS?36YI;UZ_sT$s3eFFqA{Fd_{>O`Sq zT&eV&LRMzfq+L^O8F;eDkQu9L^SxM+x(ncRxe>F-;X8b>alhym!;H;;EM!h3X&2s^ zQmS_F1z0v!C+QkAaTrUtH~)xZsf{#bCxHAswJ+%d{3pE=i^L7$OFQ47+nMef+|!Cg z>fl>IO7a4Q3&16jBk8Ge!?eSC`o2k78F^l4I-V|$Wf8epMohJ;ba+-d4C3SAQPoa=rgS*%ank#}!Bg{9wXPS+ zK|SQ^({5Deb(66(sI^G2CixwY$P4pbY!azQvGJUse{w(f<8sr@ZuVCTU1o6o8ItGT zl&M!yJ&DunzC71Y6fbWIeR02>OHeLvV)^gyjPRM9w+vCTZ-5<03FF)ZDM-%Oc1y)g zXw!I?Y)s2;NUVoF@S6(W7Ldna!16742ZXJbyp*;;7D9{8Rmx6o7wj4w!YDsGsEykT z)-LSJuGM=!ZE9n%+(107XwkTuC3c9zP{iGD@8H^#_wdFzD|>*qriJ~=g-h0b^KtL* zw$fa|u(-}`@&Nk`?)xT}6G`HdTDL7Qtx!gbuD_0#h~L)a+;nHzPBr%SfG3y#^H$0; z9C(yXJhYbS>SW9NLqF$tFO>Vp^@61}yH*e+cQe+7#3k4rrB<83${@cJIF35m(z8UD z1M|mK%{KAk6FE;C0vGP49>4tM{&Uvm`*X9_gadQd&m2q|yQ&k@de6(D zS8J^6?H%_z+gOqLiPcKCK-$-htR8lJ{JShunELAMHtqBx_IQdsv=!o{dkVgs@0(<8E5NTMX^2$Pat*GF#yLg6?)Sy? zcpG_Q!j)eLJcksb2$Y%VPi1H)cO?nb#df3wsDX$3&1&DZU?n&b zPs7HViUa{zK;PtoAzryW@p%kPdew_F_15A3aNL+YqP#aEnHKCH6N_;P z5iUKAJ0@QDsxV;PcGr+^+a7H$%P@#UjECFCZp-h(s=4e?4tjp24r(L(M z`w2z_;&b`5l+6-UV)Kh#u3h)#C3GpV!Sm!D>@GCg?wbDDg*o-k!BDC0m+g6$v1P8i z+D;~MvQy0PWSexP;QSde-4aIa!EPH->f_~ojVszeYS{cCo%h1#8XJ$4hX1#_ z9h!FD=gaH+kL#==mQoNkNE$E_)f!@cFy5Sb%w%}sPRV@1u8e z)uPv~X)Q}sSRXYL-&_#gZcibfD95lq8lHwhLmTMpQxm$6a^_g^bzQ5_we6+r1+nZq&ZK{p$sU2C76$f7Ia1Zmf! zHaD|TAM_>Zfn*>p&#idV@&RzPs)&f89t1%0xw*me+FUbNc2Mui`7TCTnno!;a(9cy|~W=3zjKKaNAkHTX)sYFBRP< z!4#q>m+C6kkE;0-v1Va^W~ABXBrWDl!t=(t4CtyPijLa{D$Ut>)&*uNu)jh`ThWX+ zj_Wc73hNSrZ%jW2Y0jV&W+W~hk20`Dt>?Xm{bkhCpMWV?>K%kI$zD{!8bgi>w6_Vw z%F+t6aCzNexg~fNkdrL#yinR{DI=Y&p}R>+@=j8&b{zeD2i=a|@VVYO23=weh1@V5QwBN~x@kj|}Lc+IrWIT)S#uP?gyM zzf1h(sd zaJN5mB!2!S&N1)QhO$k632L2;Bv}mRrt5>{_RYOAzL#hA^cWh5Rh9%O#D$4%t|t_C zbjiEZkliu-3xJEPbt5FbnYERm&r#%C4X_ISZf-$9R08%nW*gE71?+1I1x#S}B)k)3 z`psydy12TRZ_~WABbysnMtS=+g{2^esEG@16^th@nPmkyK^D-?>UZ1bCOD8{x-Z-K7yV_E+1EBM0C#3iN z=WG3a@wf%ppn)Z)qage@AP1Rii_z*$ryK>rh!h{NNn0rh{q7W$N3cp1ZL!@C4CdB4{i6exzRGYzXfxQoD1 znP3VmK+A-y;oU&AQ*!b||k1+~l}nCk`JmPS zkc{~c$PG-9NposqkxjD6Mf7=~$)1HoJUr>J@zGiA_o2SH6ohif(?0qzwH$GA*>spJ zD`mWJm=I_-+$Xg(+sM*4f7BQV(*}MG<(nY#@nbqDTh`b0=HzHCU{`hNhW+Ce-{2j^ z)r`E`9&fJDm*!`g{o11B8qah*BGVPf?3ce}eY%-=Gz0jsm-;d}!uQBw@G5xaTcuST zZs)yEawOPTNHM6J)~|E*>#bO65aj`an;mhTwqAJ#SnK+~7FwXN7-52R%-WCJpRDfh zW;78}dz(GB?;W%ucytyT5ME~3OL8|BYj`2t1;3}v;;=D8PEPArFU|Ph<;U+jEd>5- z4FvlIQ?wy@vCTekMKc+69+4v&i0W7UdV*?j)I`R4;^#AhI`ryjAkky-`))Nc(mg!$ z*n=6pZqJ|RMf%+-p<(#d353-H(GEY?E0Bkd)vdhmV`A3?SI!uf!v^GVSnVS7Y{sBT z+~hla-7iOdwwbV&P$0=B=49U=dE*NIh{U}F4XvV&rvp&pkG*MD5KXP_vMm;Abnx%B z#i~M{ZLJB^Aw2^_e9`bjL92ve z19Dhp$p+aqV1~0ay_L@Tp4t-ru!fF%R#F9n^kvkqqIxipLjIi~&AhF*-JF?QCp!;( z{4ma9^w?PpqDgA14?m|%#K(J{!+X^jEf+}(SsnhHOx8+70xn6Apfpg~-sq)A_ zrh0SoDQUQIE-pt``P0J0OSZRV0i8Hm*GoI^tS+xj<33F-Qb2u17#oY?HnFH>OxWy* zBSP_DiJnz~xy`7a3C&Jyq zR#-o_C6XJxaQH)&Rqw2dB_q-b&kZ*PHi=ki(dg)1`RUZqR{%_yDo-Yw&rj6-6Ku?Y z{txSGTduPwKF>lIF$$F_+}@uZtRvds^w?p^N9Djzl$ZAp_-~Y`L{g;ACiRA&@i)(l zkx=6dauf0UhJBD_e`YXchb^#nBioP>Loh;CLHV?L1;U3dI1JB;qxClRh7+Xp3B5jx zuw?1!9`*uRaD1Qr3S_971G-~kpn$!y95M2H5^==AWWjh&6Ew)H1XSUG7{FGLYwyiZ z%c@ahj-6@$1~iJk(EKN`1cz}aCvd-+=?!v1=)sm(!Y|WvZoRfLG*RI<{nDf1RNO|t z%VzbhJij5%m#+)r$!M3=`%9sQE$M2z9FfY+y?pP=)?&&O~|<>ZZ0rlqE$jhW5W0hO{|Ev7+Hq*~x7JtBHtJ0am|P)E^?^IE zuT@h)IXJvYE6$}o&#)k@J#zjmBJ84WQt$yl)$a%|vX}+}7b++b90D-e9`Z}Z9~u(`x#Po~w3K;+I+}lya%$Y*+qyz2L|OS}Z9c@a zdy+0MBFx4tq3e6?Sdgn0R1C})tq}fo?z9>1G{awrpg@4Hoa0u~-du;EJbQqRd#UxF zigH#bfciM!jz)rZM>Zu(M6r7sDMA$+0Mi;HzZJ#AEyzDDcBK!T6hfE%sNyuk#*eM^ zhckx(6)icvy>P4;eek}%-EV9-`Vnt5XJ=y*y3+ z%)gYrlu}dt;1Yk?H81d%|JMPG<-aD)%>Q&J|6?!nTI<|yQw;6*rZ+I^Tgav6e2XLt z*gn&EQMPVv&1e-CB(s>7h({$MavSY?_w!_rvLwM|{SpnkZ$JAslihB|PHe5+vHtPm zY<+$HlpfOw2t|S_r%5^t65fN)iRXqGkKvTYb!OYI=f{?*B=?q&zDP9}<=KR4t6pyM zV6C}VwvnV7NjV{$Al5;E{C1{?%hSR2X%P|7c8xGrJb*zQ?S2V`#iB%fO3=-EW#*TX%LOfc!GFkbmA&lcST91!N z1G=3b{nVR^!PPIF;VO0Vb-z&u)xkx&P|P+Eh_HEUErY52J!dI=D>Ee72aQG`S)kX@ z0hbQF?3{kwA5tR3E0?K7xfBHkX6R{%eiEb0AMsr6(J^JXR42KGGFTP#r)VM z5>#I+@Djq!u#9S^Lq#u>zNoc_#femWFEILVSwsq=h$5FG8U?P;E(M=03v?;PH^cpX z_;uQ3V`Zt`zyQ>nqfmV(718nOAZiN>9XXD6LU9(FO^OlwYUd!7P4A=Q0LWPtwTnf% zPS(9e&9efv4cc(JlOh)655wE zl6y5(9aT48y|j6p9zndkM3baxQ+;jP`EaG2X%l`!-v#~DVb!puYevZP6&BEdOccLz zV%5#4hZYa7@BcyBJ2r{7MN6AyTf1!Awr$(C?OnEQ+qP}nwq3n%M0bCAPekAT3oBO4 zne!PrGP6S2qe}gKC#Y3H>5Hb#xXU|MiV%sj zTyCAaTy#}w2QR|0P{5lA02P60{iob!9<#+Y%Uh%46c$q27ihCH?Ne@LB(*Vc$IQ(legP7s~u4Dw{vX ziYBrI^{WSG41sDk+7++Nz|>G~hhT{dy&;r1n3$oMejRWn5kav$Rw+bUL1^jTvu#xR ztNZ)-%tUh7YB%N29hGv-kVN4kB-P$<)_%5l5pJrVMHvkchv62_%zJ3?$0l%NWq&Eb zM8!fXQY3}61;bg(&6kcJm(*(K*HPmH@AVgeVbu zII{l^BEG*Jc$5O8SrBMXDQuQTK4{JW+*Q2VN=d({vN^5DYJexBZIorT1qlb;W#Z?!v-4!#CQU?=SZO^qEDeEViX;uZ6gaBPTUD}(~hB$!U0cc?H&8a zbW%m3)Fbdj&Mnmlr5`VZw9!6(M-uCuZ<&;)(lb5y-4{we1jv!={qTrUg(E|9StZck z(evZrIz13Y1y(}8*vWbOlgPl^jr1i%e~*K}*nG0%(BO>E!?35Wt&}Qz#HJ5i%RY;h z8s0jajjku%TA2Cu+}0;RR`2)qFNMO?H{u6+5x$Tb!+Pa}_U$RHlpq+AGr*BO8{pt( zsbAkQU+(W6e=)N41=INIo|0j3}Tywop( zZ2jnUhAZ~R{AP1vTR8U~H}Ty18@~UyCmt!Lu&f7LW@)p)_S;DStX=oT_>Q6$&@;B| z_?wG&knN4)jNg{(Ok`Em&Te~JE{^cjsYQ$}?lmrX$%+e@)&VguIG*QgUiMfPf~2&U zptYo|@8;{czWdnDIzwuxg+Xn__-ON+l4u!M*wN@~D{R1a}Urkzt$t>`$*fywCni-Cqq$UhNC1N9-pCjZpZ` zR*$7WWs4pv%I7Na*f4GO@CLobIhu&A_hT$}TNl;Hu|_9_+3vi!a^Qc~q6gRuw~P{e z7o)fyw&w1DIuGHI8L`aetmi1 z5%9+u#EaP}IwycMr<~<_JI#Wtv7og^z39Naz-uuY|8<2^R`oX@D^4Ec9`H7TgvPEx0sbWZMSSGBO!TxeblC5AvDUfzZU}{qZxf|%(LU--6F1~|jKAZa zBteI~u#E5;^K2D8x<6!?fk-P9b4Y%No`Wq6 z8Q-;EL$8N0#9oLB&=`_T1|_{ukEV8$_Q4E14N4U?NEh>gz4Po?`AW(WC{;I?*J<(GVrW!yw3sNctc zSX!UTMVdX&II#&ypsMsn=~!uA46k??qz$p3rHWm^VnLskWHm1VKCzgb(;LChnkT6| z6h+&CP`6f4U*}3_53uTcY=}sUfFSW)yb`0KvHV}^xTj3lUxbG%vt|K+uwJ`aC2h0Q zNV|aSw(&GL@AF#4mS2|xI+HQ*f2)e?$NR&>^Y8p%;R@V5up@`gAQ%-2XzK! zut1MN0pSq=hzI!8eHAPzo6K-pR?35>#~&CJrrs^6pgO{Bp)z-^Cm^BwzFvst#ck~G zukk~4zny2mfTP7C?Xn5;#_Zi#MSt89E1jtW9+D&V)Q4U1 z1{gD|j8;?8yW?fiD*c?EUM{r;ZBf4>(-sZda5^;(Z;l2dVZ%1-#s1;+YaOuiCzfrW zD5wd9mNv99&sH!ExV7k}J%gO>NB1{(W z?yJixWF{6iKMiB&8DO@x)bdPehU}ArtP!tW(3?4IsCH>Hk2he84hSw#z2q>lmIyp& zwK`zg63wu!0k&#eZ;FAj3HDXayJbuoB#G>0K?1`Yf>g+2hu%EoGOL_bmv|5dwzUgHSiDON9BCdO1+lwjznLod<;W7AgL{)N6wiu(kU7hIPpS1d~-w+ z-b{6Fgv`lI7y-(s(o5hh(+0V7ht(drC!YE?3?YfJgToB>_SYd7+;w05l^Em!QVshB z^e(~4=)*i+K+{1J#TyFc{u-68K1^JDqgVh)R}nb01bWNiubNCQr55R(RGO2a+z;2u z6}pp`<5)x$;xD5A7J~E@B`y5{#RhRvne(E;z%#EO?q6mHqNQK8i2}Vyq{jtINVY_W zKtYf_ZU1SRgBT`0_zZJYa67L*zp4Czn=)brS`gNY2I7CQ*kkg+Db|D&m!TO9j`TJ~ zd1_wjJD3)yob~epk(VwxJo8ZCvoV?U=Y&y6z44ypr!2o5%*E{W=M3W-c>d!Q=tfUR z8%L|}NM~@*OzU+*0-<&?gjzL-W23-xFzpY@EaCBbX(M?rHkd|_1>QEWg@?(KjcGI% z>RoKZ^lzWQueJi%Ve|_azfy-Q;AUl1B=!l4_T&K{p?J`Z#U6d2wsgyOpN7HKq+##R63`W1T3rG3d+T%etk8m1q}!!mBM*W~im&-_i)lKJc$ zWwj3qu;GeHVV$eb4j+IUt9w!b^(5i%VipnD96_676-;z!aB7lG``&0?QN0{7WX5pt zgE|gccU5e?-~wKWM{_@s%^^Ug=QGJFstpoaeT}0m1x7YAc$Zt?BCRJO+b7)$l|WMc`HOZK#~db?)&)31vMM$#DQE*PC1(FXBwQ_^5RAdsnf^w9YrZ{>O}%)8?n$gAjnv&Tzn%pbRE07g?H`% zMhyq;>pHf+!U6K+-87nP%%Qz~!*xKrLuR1;IQU0K`QP>9F}&e1;NR{g#|n`zyW6&_ zA6ZKM6Z~FkJ2*Hv-#Lm>)0&=GnRG6kZIgQhOLky7H|3+CDL`eQOj?#pPAa)w`BvSB zj&p-C9Ey^9(!wq6a8n?)Oy4Z0a5jK%Ll$)NJCm*Ics3}ZYv&KXw-mRV1N6g}Z znRfgw-oV70lY%fzsW_(evx^dORJj`L(-P0uRKUui`AMqE(Ki&I>W2(u$z61vlMm*O zyCFjB!rON+H=)NgO}AF=nZ3Af>;(t?e7Jh=ldiO0_9eaJ9<{R&_N%@eP$fJbZ!`7F z3@odSJYj8tpOJdKax!8}v58o)?dhWiOT=%#E~rvV+BrErN|F-WB*=wMFGdsujzsGn3He;Vg*nvPAARo+4jkJP z6uQ`J8^2Z6wjEKa7i!8XjS70_i)FQB=<+Yydl164e>|TL=NBsrcVoEMWY}|%CG@X4 ze!20YicGt3%E{HaCn@)BjtUIwUXYBG|0g>-2-l+@*p-yHc!u~ zx~nr|)$rUhR$_;tw#J~ZADW7BY*TvFmrOM1RO;Hm8De4C2cC`h$Y!3_w>Wb%JRh+M zn*BrSu{6ge<7S0 zukZeNv;8AVYqCgrPJ4$Qb_hojZ+;KMC-~bC!KpB*w;%TG7I#qYC8Lu_5OkktVld3T zfev7Mli<4H=+=o4qGn;x1AVy!__@%-t8MYHH1Ih!{7K$;f2a%@3%WS^x}lKO+~1zK z)s5-d@+o0P^C>}isOa*_@+!YmzIt~V0}r2m(`m$#*of|d@WGJGxY6vy1Da<(RrW%e z`YTQu!yN}S`T-OCLBE0u7f+>*`9U5CK%&>8Uj5WqK3dGVw$HvI-+|oG9Yejf0iAK^J33gMWhO0Flo<>lnc!D%$bJ{h-wF%Z<;PM47+cwBbkww6DMSn8t_y#PpOGm4c@dHnKPRv zq=cpZ{ur(17?*0tf@~6hDmSUGFKs(7QiXU*Da1L~^sR zxo?Xu;xk1Ci4-#BU>caMU|yAlW4Fd_vF!Xyus`oNa7S%*_t25)xpW)8X;@;4qavs` zIE(+3KN9hT9n)j`te|T7;QTkWFhzS*n6QT=*Bhw`Lo6FJADZeG5l)C3k}MF>q(RL_ z3tQS4#NWQ2AY=+zKr(TceY3Xv_}nKeP5omti>dD0chW*T9mnbLW*tRWCE~5ctc@si z7_G^;dyZ5c@ZOy1sdvIW;$s#kmA4afb^oidb@X8hMtU41_UVd2fDkx*)Io6Hr;X0h z$CQz#zR@yl^UNnRmh@=)1Q?r`;$>qac4$V)AQutu$}y|_HbZ@f!?ag$1X8bm|3!eOG=R@*)?qM^Oq+v!YC#lnGn?E ztB$&&(?T0pYUbpPuBp6WGwLPNl8sSk+00z+EwnNnGp{98u`lBaC7*;#WR(SNV~fG{ z8le;C3|VMVUg2_MV!aZaa7~DWcTQsx4kI8L%o3*03dX~wG}a6bjzCZJ(M_ggjL%ta z(LE1^dE~o05mJ(%%-t@!`NBFWS)ifpA_lGLb2|n$Ll!UNjU^GMs}J_xGJh5>Rxd~Z zE!t~2FEme8uzl<`!!@5jyDr1uzOj~3Sx*yfTPzS>(}zuVpkA$J5eBiVlWk_@XeF(c zD@^xtz#9iN(!%0cf>{T{kReY{%RoAe^g5`38*e@-D@^5z^vaEaxPalXb`2jU6pMeK zG+}40Q>Jk7OH?hr$CfX!r!{s3`Rg7E$Pa03R9zY+Nw_BW>D?%EhoA(#6(#t#iP~Xr z9l)kSH49x0vu-bECnCnslm5+>UIZ`G5`eTN&Po~)ph;%iko(Ntv=5iD=2-ohdAe#i zsd==jAF{` zu2G(K0WRiK@xU2`O9^*XR6ZQnEl?Ny-qJ<2Bm{?g(kih{KGhMcd5b^VP(wQItr79a+h)o`8^99KZw)$bF#nOIg!a{fpZS| zg${HVqw-+5I|-nqD#%_Alq8zaASf^rqV(*RRyw>l063T5x@+V5*D z4^>oAS$=1>4=#=r@tuna?FwFuwZ_p$TuRdBTyg2P@1xfGjYu9}MZF0?b`W^_ES_5q z1i$vsT)Jp3fSY8WNYhq8S|w_Kng472GQn0s=2cU!!P<;rgu zyOKM^02j54v?awUQjn#WpV=p>12a;Q6c{xVtWO8xDsPROc^uu~GoRAAotx6uOMSnV zo(Rcc<8Ja35lJTgo9r`kPmW%~*jU(Iw|-p>+?=t=LITVd*y6fW`&^B;;nIIk`lf70 z5+&KLMvc+NeZ6pwM~dw^32y(wQ&R6w&_nauV#5QibtdZjq)}I{P#Px4?|%8Iw~5g> zr_x>F1{|i$XmgIIa`&ajKXrB@uhbA?ZI+?d%tBfi*NUDbW{hA zDarfoRNNPO@zD6IdA`4^1PHCyk;B%;Yp>z4FHEJ#;|or|ALZ8lFxUUt|AhSuI#o|` z_n(rQ?f*0g|NrU_)6!Df{1;q#s%E}(MY(mJY1`Zh4}!gd927*5nIT!CC}@kNVmuyi zjBaZA`dG~O!H%v7`jrR`cQdL?0|IpML z(v{DdUU0h(o(s?HL}u+75k+S&S2FSfW{#z&`Y@3=XdQb50c@jOSHIqm=R7}`yLbP- z|Dmb+|3g#vzxKXw*D?UU)u4$^yjHR;Sz6l;`&n9O;c4OO3>rEJfw&EYaY(&5h9>e3 z03EuJBJGFT{>^ggBH7)VwQ&ix8Q#Ae)o;C6N3t846FC_$+al23;bST_$i`Z2hB;e2 zVI+4V9E5X1o+sJ{omnFjG>nw>fmgAC+w$^cN9V1h5^Q7Nbjjq^dYznI3m_xe$xC!% zxD;tn+)ftc>UPIP^0m;|1Y3h?@j?q1V+ViyK7?eDBvSWhY?6w@Us%@nTcrArpUf5P zaWZd2Dk=}1OCTjNB_Pov*`bmXGYmSXZoUXY(e@jNKeNd#=qot!%YiAV9pY!p&|V}P zq;0I#!&6JrWS^VKF9pT~FBDJ*m?;{VXIw0heEOoorNc=e>*w2PAvhkYkCcW&H{kTy zGe1{8me-t>P}R{4Yogdkh2RWQrqLZa;uXw%TJoytWG3ouTU23A(G~;F7>zeu2uI}` z5J`kbNZoLh1n}GVg{XiU2Q;{WlV3tdE?A)C=>HKLC-X02)UctP|A%Aw<6RM6Ux z!OC+%a(eUV$(NJBWaItDR69!@^*!z$nnQJ6S*qB%cGaJcSXb}}ZT)`%Uk*b8>=jQY z|9&Su5`oJ~YL6O)CW=6}jks$yqxUw}=-6o23(t5<`t2gY9u?GGWHES0t7N14C8W~^ zhQ%Oe^26i~ub5c+fXZon6Q^>=W<~)x8|pT={JCvn)p+XD>8lv+^!7abp~f6v5~WBo9uxqy@dx@1wWkbi!-^qK^UUvK9fHi;XC z0f%Dq$HEO(a#42iqTdfdSR{$2!9g;x-0IaaZ+f9IJzu(ZhN7+hdYl>f6r3 z`}e&s=UbAJUF!S2uVwSwVH3SSs~X{63x4meztfvr09BdKy}xnGSPFHqQaZ}$Gy4Ge zk8%$&E(O|3DeYzlvQO@Oh(hs%kasT ztovG?=b4AV1z}MNZDZT3n8=-F(1|;)n=upxT$agJQ7s576xiH_LH$^=Vh)uboYew0 zp;%7kBCW$O3D>%>u-6$4?fiXVTw$!%Vi9iv-?Zk5do+?M(;5l)H`3ZzFKZBNH;=8U z7C<2}&Oa4rMyn$wNP&CB!gieXDZx*XSh1iBcRaaO+xkB)JJYK%|gUZqdY$OOCM z{*v1g?ufyHe*I=mprV0U9!TRE7-d@Ai95SbOaaG2^7Uzm>5*d+?rsTzk%VubVPan1*UzTehV1K_(!w0>0bezx=h1+Q(vtT z6%6}F27!abe-EYreG*Fia4uk>kDF6K_ED93xibn`p!`)l+<{)ZDf25K;&?K!dkoXWjUnHM#~Ccf8XTY9OIEp_mqU*VJO;$1K*# zsu!KZ$v@aTe|i4i$1lqIE3j-Gznxe9K! zZ>?VI?&2pC^xl9Auqxet9FabWAlgoXTe{!6Kb^FGzXDpeIxn-y@>{p|5afhi9$SNl z;^}L3{D#et(&#K+j_@FgApC2#CB4JR^xW#j?#98hgY8A`YIKgVkXpU(Xdfk%OVuFn z0ofF0m0{w4$v+cuS{p#Ur2F{3o(Fs8aZ&HBEQAd_0xrsRZz8ZgJ_ybEur9ps>2qQS zD@tocxmyA@juRF^8On?WddxIokho2_J{@lCKfY&Te;@YMx|gwVYUj-o@le-#mZp_n z5Zv8@c0wKz$PrtFP@Swk+$@YF*!Baz3)@wNQFim6%zTnnGYe>M@1YA`KObu~V#T(( z0Rqo`%I)V}HPF?HpEo5_&vr=l+S#`Cn~}{CIAgltw9&c68t0o9w%9pQ70{7*lYGh{~8C^)2rWD;tn5GY{&h=;v1wcx zAVua(V3(GGnG(qXXF?V^j&TG>Z})qF(e*Y2>8u_WXR*o+_sH0;&Be0Dg9u9I>%oW) z`NUgY$`5WugY@ZNx)9ho87yc{w%5HxCHeKkJE?>|poT_c+th}O4Y`f+?cCZR=d@zyVtR|V~u(co*N4Om=Nk_M*}Z0G1mO1XmGy9x@b-svp)LF z>|rYJsPbdBa}v(B`!V%B1pm$=6r3uZ+BzSI0W8RO@2ni-oBz^El!m#As<=7%Gixb$Bdgq7j{)FA(Mj{o;dN~-^`9xFo6ZS9@{5GCy{ z67&<&s03!7j1irqLlA$-Su=t~b9|HR$1N8MMRn7QLE~9DSQiQ(-08goJ9c18SYB(T zTITWx?5Vg>b(&x%_>f7&VpO5BvATH-D`-dL&i9X6RvmMsF58LxrVbt%mCnW<(%MAh{$4IT||&1>^I@4U+)q-YsIkw%OSyz6w!3 zBRZ9H=SLf1|DweZ3N}d^#f>XPgr>SX*bcT)A&M16I`m9>DF|}TM;oIw=!>ncE%-J` zLflz%H=lLuvF)XVJN4@bHFFS?u_&_uByygRry6TLsRFQ9aunxfnlj}DUbPt1=BbGZ zG#`_U&S_@>*58Mn!<`d=6dkv^Y%ZK)0X>AYr*)kvi6`Zj=^4Dz%|{d__GL6uV#>!) z%CUicJsqESXP?K3YQMH_xDL$T$OHEM@{pywdamEWh1Z4(Y*1QNKPcW6pE?Hgl%aB< z@@K5!lW=hdN}U}Tt&W~Lo6BJ|X2+Puq*y~#Vmnq2KF*g5vq}=je{d#Ux|sZAgcI3ZQI|XM+4U@c{X-wx>vN=#g?gzK4HSpWUIFm^l32sBE$#;ZV{yI`eAaY|v6)bQn z(|;Q6Hhn+r_tn72@CD6-GP$9%OplMVTuuY7KKZ?{hWL~@{Tu!b&f zu{R!bTvzV(fgW8KR3H4xXu0Sl`AFxpSo-Ka*KF~s-tBhU9)7)CtZdwyz~hDXRCPQn zX?&iqVYsjHJ;|_CyDDumMtLX%>jGki`Hi#~oSX=5Wb2-ZwUw2K5(+zP z&hB&ELqz!DOkAy%PQLvnjbr@@wGIORrkinep zZ``u5`c<7P>$8giws#WD+wBjf#^oDNKg@Xws+UoIf#&ALn3QCa?QL86Ym4^ z?@sq0PdYlmpC4a>JuJ@wDIz*l1BA(;e{6f_7tIs&&hKdee-`<+KW4*=a(qwAgHP}4 z^5Anb(#|h#VKRt29O?FDMyVa5LEc>g7nCrndvn0+R!nLd0GKl!3ol6^y#5~Gaz9%)T&-qvn+YfHCR zw_4<^SG&59`H{}gqduYjH%pVwwq`frD#iEbWdrKu4jLG6AXFep{4F{BPVvVI~FC1N;8(AR43%V(3r4js0M(i2>(<`G@mKp4K*& zr3_g&zlR`Ra3VGKOydBcLt})Y9|8h8xqh9d6vg)@&f^Do)@BwMLh~XO#zzzFq{7bX zac#b`md@)CVYr7~T;T%v1-aG74vrOcQ_aK=V)46eh#Vs;bo{?0>>bS_0k{owfe#j> z{Z#sCpyZ=}hC#pGr_OhQj>G*qbz|?8jXZo}mu)vWcXVC5UCeH`tnPI-kXs@q=jvOB zn)Sh<+2{>caN!$7yYulY!LyLB77Ls)7lq_!pF0xe6=z{Vk`KIm#Wc$bW}S9As_E#U ze4_1Y6m7xp>(hK;=d-8t)Zjt@qtnZ-CS^~nb2?Vk)byHnh ziG9j|NMr}}d_Wr8K#(t{2Ppc=C+Ty6p}7#`>rPSj>zVbC1S{~N4jF>|@WIQpv)b+< zRH(O``*UXCAlj&*tAqr%kTMutEG({m{i0t}mc(f=LJfoc$*W?POA1R&X+NwiG=t!< zFfxgd-G%Mlk7g*pe2QW~Q+)y8MY4^4|6bcD)j4kq*ri|fS8_yXFm2X5@)=0Xvk^L6 z$qo>`?JMh$i6MFfdTF%_;}-g66{tkF1}VVJu&G1Nu(u|VOV2tCgVNNnp9WvHUx>sJ z2Do-)29AAw4K7blXJ*2$*6#BBo_`F3zkMHDjt>i4MVS6g3~aqU+#ol5G^(h6svPGTHOFdxhM zb-jThlNr$(BM(bFVrr8K4kyT%08H}GpdTfb%EJXBiOoZhNT>%7ChyBs?_kR6GXh2x zlXQq6hOVdK6iKuwiO#B5?QmaY-AZ#8?wp-zz;&;2(dXyBf|)FA)l$M3ThCmnR;x3f zKH0@@-)v!#s;RMLHfM9MW5*qRH)oikIyKGjWan}ns)2zV%Tc#AcOEk8_veHR33n9Q zg>_317T#^1&LMZ^NZzNA9g^UUiV{*<;b8~%%GvsTcj&dC%sG0P1V#7>Iz3@-Vr3^t zh;USR+fkby=|ISX-Zm-@ZifQHHO}99BkB53wez~9^%prH5}5&laN{h3MCe2X3=ANa z%(ry@&cn!v0ENM4vybj!E%!dJq;899CA=E(26qR2jn&> z#n3)OWH#Nrf;SNnDeN{e)Uw0uG!mQzD!BI-i;7PhsZR({W7#ySWlPTgkY#ilU!P1vf~Ju+H*I(;tWg&_ z0eR)vpJj&dNQ}T3Isns23F{MfFp~rPIeUuZltWb35Hg>N8oHWqI4zKeK*P|ZDw(3S7y$5+H{mw()i8~6cio)VBQ5wMB zi3sxi*r@td6`7&r8Xq4;ICh(yk63&Km&@6`TA#0Peh3MC+r<`VJKid*KS*aKtw<`v zpZy%MIeVfWy36Iz)K@lUfDCJN&6y)&Hm9{=D7loWINTrxo${bmE*Ge*?xfLd77az@ zM4l3sa+60e`7IocuUnhn$P|Ap0}BEut5Avx97JE)inDQ7S=JDS31es`Xg!7XV^5S! z46vG}eRoO+6@f&KwSx*4+BiRy?u{c9lpVK{fg@?$f_oWVaZ^aeRw@(hbg?p!RV0JC z$X@~ZG4Fl7atrs|0z6ImoDeiLDCjOwwczQAP(*uT>=E=2^i;THK4wAA(SYBuMo3my zQ?olkm}7;uwm(Y<74XJA`KsJ@A~r|g%!sKk1fAq!fHB=MKxR(Z zwUr(WGBOZK_!Gd7qT#oShLx9}M1232{-+$LcrScyE(TUE7yLj$d#Wdg&lK(Pb)kH# z9q|KN2NP?oIsgixbEH(9TL4fPUo)gct)+L{;|tH3eC)^2q5#qxiH^TE=reo$LC=v! zu`oo_WJawy@;=`tQcZra*d?UC8w=N3krrEvoe_QK5e5e$f@$EK zr)k!FZN`2}qYjcWQY4f)S)O^6w9$!%)-@r8m&sRi z+gzUQSJUfl*B#Zs?W$rs4dQWKy(A{@tl-_D|Ek{JY-s+9520jMP##+C-SKgHKHgro zQ-i`1p&Aa8NfTMObZYx}Uo~$A{mN89xggZz>CgyGmT=;Jt;DPSaX^KP|7KFoV}LqT zUaU~A#)Q!Z*oCvEKt+>4^6F7W5#==Mfs&t4_WfYZ?Ur1;$K`}W<|o`SaO%1CEyX!0 zGEWfXyN+bjlN;;1GIz$kWQI0E=#7DGk#V2ijycNC+%pL>Ls7o1bwN`97;7Fp6K#D- z70)cR!T6Cv5o>*}Z)ARdh0BdNO&+D`or_9+;gk)0T^?!i4S}0TA!~Y3W;HRxfU+s; zm}uF5-Y`dwvY&i{#W!(5!453o?Ae44wCVjrp@ayZl#~O^7hnwXUZoL3xSt?zh2zYn z#nw{Edh9C)%}ejDrh7@Qzm7l*2Y2eDmc8|Yz8eJr2G2PYL^nCzEE$L+hbM!s>Yty| zE9u*$DtZa7yMh!^Q-9nq=WMat`y|bjeJ4UQSheRCi#-5k{jeO|p@{p?_Q-uTm<{E^F-9RmfK(&(4o(m@%pnp)E zoC5lo%L}1?&Qt?4>&1j^4hQrmsR3joS9nf#6tm<$$A32v3w+X0aT4q;c59-?qvR z)HDE!4jqqm*M@uiVDY2e1hl@A7AD3k1^mp9I&&0oY%B)sNkY(tnpH~tam&rNI8lCb z8ZST^0eEOhjWOa5rBP{kn)mrNSfcRmMhnfM(G)VSQvdkPTwUE#i91lgZj$w^eZFi( z0D2xkP4H<8cWXx|Bh|1F*f-wmO4rsigte^%h!Dx(WE{V0o;fW*UUiAFvq|7iae!H8 zgfGr#%W$o;0xitggJemB+5-YG+eti|*9Ff%ypgsLwj%Lw>-k22)+7d1NcMpW)uRM- zk)w`NOVTmuCwrlYcAPYW!*I(}xFM(x0DpJxvu5mAL4O3L6Du3`}*0A2BEt7?L2z(&>MN6m3*n&d$cA(| zCQy86L{<>7cG6)LBnDaM5)wQ80{bswdfs%e#Zsd?g5u>#^wPZ{+?MV<>jtTW-uXxI zq7J_1*%;IU5qbUAm*$A;fv^$Jqb7)VJe9&xK}KI}YhAn9OCOlr#dnc#_+vq;%NtV-B&=7pS`eN9j^$hb zc;R%KxA9xR^`@mG7Eea_e-JJdJ`|X=TFS48XfUe8Hkg3C;o1}l7JG(UUzg{X=@U50 zts3(s9;{964Jp73^~atn*)eBb#VU%VZnd<~sTJ{K6bEBcO z?oURBI=R_`tk}zJK+)8S7x|tFZ9gr8Z|&>8)WqUKJR8V@Uu1nDh0)C`-Di7WXUb#l zHP0kF8DJkPQ!WJjC6#NB$O3MUU^cQi$&c~cZ;W7f>ZdU01yy7e!`sX0DZLoo3T~eu zMSMx5)S)y`2*_AUuCpq3DUyz2fZM>%RwwuzdGkFR3;Vv7Kq*~jx$ zQ=B^XSAV2Q2sLKpMrRsw2OOa2kdW?K-vs@>Qhn1vS3Tu=j%1v5`GIr8DJbDpc#WOH z3S_!}y(F2R1Xf5V2AGxP32{!!Z<@)Ke^*CfuuI8T1f57J^yw~)GMPXLZBt}2nRZpL z1}LWQ#WbZK{JeEa!2eFt+L=~*LX&sVqRewo1A_cD7=|SDo0MSC%;C010p%+1G`>+~ zEd$x?p>1`&OyCEI&HVP5yw8fuX3tc=;?)P8;MSb6i^ANIT_Cxxu(rvvTmV0(;`y%Y zcfA~J(=VM@x_0DqJk>}7-Th4j@$i}qqLnEA(}0oI_u;CCR1b17vMxJ{Wj*SWD>P@n zqUho(L{OBypWI|Ha}5$psc4`|kXm{B3#<&2&5Suw^PQ!1833N4+#H##3{^c7s(68$ zf3qOGU$8`ur_qP}H~ieHYOx`E5W(w}oJ_a^y;!;FmL~DMDFHnzJYz(b|ouz*x;EKYMmGt;C(48O=v8=XbDJPluLdnZq#dMONO2fdVB$GUmc#0p)tKa4Qg#X;?uATE7APnt zMW_+he|`Rar6hN^)jsrK$%VVswFlej=28~3G3Y&Nqw-#x4$^u3DiQYr`I<53l1oVl zg9wsr`1x@kpIg;$&EqI%v(v8d&AU3K%RsqF35}uj;c*fg<*zvgiDhy8s_@^O-2&q= zwJ(|o+6H>MhJ8}d{bWLP9$mVEAq2gtIe$IeP>-By%uY}A-4X6^DwlReZTlJGwgvVm z7g9vmn8;g;rJ|=fgWxAMF^F}}Q>OT@?4?kpO9oISjN&zHiRmbaWC7z7I{A1KgWzBT z!QnU--tJ!3IE=OI>sV%j$ivtj-9j+(q;y;OWH#C3e~pM|Anjwr3@8Rr?cUU&BV}{` zv5=tMEv6~&ur!!$HurzalU2QufI_lpM#$q6#<)J4Oi zkY{6+-b(Gm2Tl+$=w@FgtN2;rIcQxjs!DSbHAX-p%4 z_u$R|^)VZN#Nr~kKxTE3RuXR6P1*U!yTwmbwpLrokyoXCWGNWl#O;?GR9DPY>?xd+ zkpSS~?R6A!zH>M!LvFnE!@?2N;YAH8QA(AutP=1K0t)6e1+;c1t_53)kh5zyhP`}{5$AWFC@&4M|+4i#=O-Y2MN3vd%5u(G5kpH zVSat(Mwi$iy)7JWm0LLA-Jy2d-F1^3HbKsqAoCdG~Jnrq7Eb-`W8j*QWDrRg*YqjrCX zm`>LL9gi$Wf^`=5D@%%RDAbbj49SR3r26z`Dd+uTk$1Mq$O^neKe2ugwY0Rc-BQep zUWMhu&*hFZHj}8WyflZ**@>Ub2jv|#$Mn$Vn~;Gw%D@!btVr4rCx&^F>3u~GrrNM5 z44qD3he`VKsyO`)EFPw%?h%+JRn-!v?htqYISv5oTT6=;`O2j`I(z`NK-7kE%ubTb z1TSd3!j#Kr6W3YPqq?d-EbHcH)YuMiEcJLe#HzrY=8`;!0p8u~Ay z&PxBk?~>4zO59?F`$yF0>N_W7l!%`vrny?!5@i&3+_Nf@vK{M5UYb@sor#-Ae_o*x zmKs@F*mAn16Y(MZiSH2eLcH8?Uw=HFV>c^H>589_Qi2JeY~gcY2+@WYB9*6<3A;C^ zygJ|SPnKQD3fv#NWM_-ZJFaQh&S+~Z$%KEWQAArqI0+up54aIG`Rx2UJRQ8ASCip4 z+D^UV0s13ExE~fCF0OO8CjEaBN7JPZZ+9G%bD)ggXu4L_etQmP7WPx$^~uc$lh~=A zy1~F`!+N8w9(__k0{VvYJ#(38i8R#)K!~V*dooJt2JI_^pwIyRCWaXKcHHphM-^7>gF>(24%E_Aikw7b3+k^!53_33-@8Mv1Rt3w9^)S^eFke8A2#=aGb4YuF z600on{7Q3R{|Z+iwneb|zbJc$C_x&aO}A{@wr$(CZQHhO+tp=TUAAr8o}M{(R`V_X zyUR`P;+%|(7mt6Zv7Tb}oc1_-zG9bUgh-hT<@UV75W%zZj@`Gx;_))BVt#h5z@hS( zD~CE|r`lvIH{^nSJj0UmOP;$|7YQOP|X)4bHmY0Qa2B(XO=tYg*#an zZ}3W9PJdK|ptEsX`0Ohv8-6J0pO#Y;-aQH49=G;D6UKOQ!KY5^7`pm>cnlBE8N>ip z1`yor@TXsdiARL(cZ4Y-6^{i3ZYL1f_uPX0o^8;a!@-9kbD@85)B>%RP*61@E%<=l zOZM4&jXX{iyNCGp;1$DyU(~xj=e2^zc;eys>~wzvZjjxY=(N9kARc+f5W&(55L$>y zsB_+Oa5?cY0xsn+NbuSqz~W^IW5hO$6iE)kc{b($N|R|WuXHkc*}Xm)>?XWmuoJW| zq;?6@2eii>r->XcA_;8)hBvtBR0G*21=ibB1O*s_L4*;ZsDZ~j|Lh0CpgANGYSZD0 zE9;^}Xcj`T)3*ho#RHo_M=c?Uos3gufZ7ZC`ub+i;$X z1)mgFN|P^s(6i9tB1ELp$$BqT9?q+>MHFG1TM8_TX9J%p2KQY+{M~yf%p9Oj2tV1B zh7o+V$>lgB7e3TEJ_{cmAhHY{jYu(unfJKlSm>mwogcXBypoO3AUY;l`}RQO>VQeg=Kd7&c$jr2@KJB>LKZ@xiA zHe|v`T(~DN)&3=h>rf0GK}&mf{N8r7x3_&-X`}RR;om zI23>j1OW0y^7WsBF1MTGUWY!@y%||*_CyLtk>#g-v!(a!6;)*79jRoH0wEKU>kOQ} z@T%QbbeH=WFX_SF$dChpPSseKDEvB)G)OOk#tx2$!30v+d^}g_0cbQ|bve&1Rq^|0ew!ve)_J>f&CSkOON zReB!VFxZ9Qbl-CY+6MsR0)b_8f3x*|=ZpBG_AL zTd)h9!xW2Qp>qTqUnK@rE^lS%a3dUA{uAUn*viWQL&un^tp=WnPRrm&N^S$t* zt(0Yye(_V4p-Z^YIVe++9oC=0JhbA3{1@fGB8`%T;lAvnBAVw@7yY!wXW%p{l(>vY z&QD#7uQJqhFf$6+LO_(e@`&^ipPbe|Y$wr_jgZ||TJptu>-9zZ;mU!>cKsTzaZmkl_KlS71Rn{lq)?|D>K$ovm1kEs$n$=r}c zu8|-6@&de47;A&|oeHXj2Z2rAq1B>d=iQ;?p0N2X)!a)3HWg9g3ZhQt zMUhiWWwOG|Zo^AW)EDr{S{PZE6Z=j(#ni1+c0Ivui4`E2J4ie6uJa z%;H5aMg4^x>uT|^C)P-@NXfG}*YKTJ)asCszf(L4iw~*R@S(^g_7ieA_WqYt6f$Rz zrp>=ny|9qyH~K}DG7XVM7&kY&ADS|}ltvMJd^8HMDJ@?CsSNrd#?#NJVG4sp{y(qk z^8tsiH%Y*|)J*A*yHBfOWa_#n@3l9#jN1eUTkGY^FVM3@ep80>!)@5Un$5gGKU4uu zi6Yc^r1+@*;Z?x2y=j-@_#q|11-t)*cxLc!8R`vORL@3@D0mtiN%ddD9+T)Uhj^G$99Sa@?k>^q`% zn*Ky`j2{LxR^$Z)rC&@?uSZGGFAf*?)CuX3@i@g-8x12q|Nam)N!NDO_@qE0p?&(z zdMO)$K|KHag+bq+uTLO0yaw>^q%DiwwSB@dDTGN!w26ZVU|Y|=opD5OYlg{C63&`2 zaNogqX`8L4_lt9CGMnSFtD(J#>i*c9m|Hi8J|o6cob0(EoUJJV68ephFy-zninRh$(ZY)P9G-V2ui;!^?d%}SNRH@*`f_AQz;vGU0!w% zw$7RrX2&Ogut++;cWBVTn}G$n=?J7{JRgPJ$*->Ylga$2bC#Yu^`E%8{uW{YZ?29H zCtBNt8)>1IOy0hV%<3)EKcZ5m50Q3xMhu(-)P0B-G@uL+B-xQ|Gto1y^Bkc6oDqY* z+>@8y?=IT2TBl{ppZ?jYp=p4^I1}#R`|EeplP*s}1d)b`19Uhs1IRK0FFK+`XYS+E zWgp%~=A*?yqx26B+jn(o`vq_hknW8;Xhgy5?#0jWA`jrZ9>Q{IuwDbU=X={yQff=eBJ4{tL^dXrsVuxDpqOD zs?xk%-5Dd!=%J9%%BR7a$4y7bRl%B*)w6cbrJv{{LtaT^&m?9O?a zKM9X2Grv5a$4Ara5CDMd%lV6o~`4* z=AMLPjYgvA=8qZRWg90W22a;IVgtPzMI|o+0Cs%+)8^$&A=gAfJu~j*ld@_$157-S zbq<)y8C2FXu|+KZ;$t4spmbQu`=Sg0!0|e60#_xIo_~WIi?EYvPl=#bSehyui*{ht zc82W0yj$gvaGOj~4Gf`zHqUV+E`MOER{oA3~!NwCr!knlBmf2iA%j3$G zLEi07{x{kms(v!=UO(HMnl zDzwZa4y)a)0@wnV_(`LO-CpJ7RKd`(ors>|{hrneN}Fnmj;*YXCrwj(qS>Q1A&SG* z-!SCiK{lqBwrdL5Lzp8_f_vwruQJAw6{AVA{48+}*uM|coo2Jg35ek-TtpWE|BwSz zfm9|2_UqZW9?rzCies5^k9M}T;AUvlHlB$ohg2PO|0 zSy9Q2teiW`Htnq3e;Ik{A=22Lz9mR{RG5>;rCbRg1OvBAq0k0wgx zQrdy(nc*^?;Dpt--*OesF}E^6=q7Uml2@EB!Hxs+jTIKEW%TyQCq ztBOW#f2cx2xr{*P$(%(7L8wjU7NIL9NGl|^7Uz+xedz+N3^ z4W&f5ykAC$IW2)!hb0(^42@4e|B;qNLx<;}7e4u~QP{4kCI&g>S-QZ%h@k+8B|1W; zJ~OT^bu1JU2Okttf_hvfzH;2R)sT#+C1_MFJf?yEDS~P|Me~zkVX3IXtvfe%U_Sx^%qpvc{ zx;xFVYeWLS%jWMzvG?l@FfoLRgJwl6G#e3tc>pxmHPf2eWEIK$Gnac}a<`mR**<}% zo;d@I&#t0_06NwAE1a+KfC|3p%>sL5YJL5q{{S%VQA!K(M3F&)S1PgL}smpn!S>J_OfiEZ6H;f-24alQJr~4 z(4gN1$7g|!g2NsfK;)5zXGUr)FBTRomaUE`^MqiyrtIrwQF;JoePRLRD=<>B3V)RW znqOmpEM)U$A`rBcE`Gtkw!S{I_2y)01}cH_GBI!stM%x4NasabW)DHM_i$%vR7Sey z*)iJALC*LQ+NvE@dg-(fuL`QHB4yQ2AjwJPp4AFuf{RzbHn#aNcKrAr6DY(t;QG?Cf2Qg>c zN&e1CS?bmi!(s9uB8V|TL=k%a-u#^(RGexBqjC8Tr#{PoO@ttbi!kCetnM@GK82(S zx3Zf{(Uh)YCbw4#Go{GSA$XN@%hR1^{55Du$86ZQ!RtTy)m}PPwfpxAY=~|vCV(U^ ze@&JQgF?|w9W(W>shiF=;QQ7eW@x~4x4>$ITEoTCN{hX$`hq13p|xEUGi_8CV`29^ z05>4;+INgX8;E6)d@2g=)v6VmwFXeR0^8jDq3-JH>+j=ywzK_Gl{wGN1aQK}>aV29 zZH|@X0PiAb^S1TtfqU``Wwv{2EW#2rl7Uq_h70D3WbszrWby& zGg}p|I`GjVVxGMCOI3?BP)5h7OEXe*WuI(R%7b?8ZX&pb_M%?vxN++kY6J8sUI(C? z?vSPQixf80#6_}38iw=2NwuC?9iEJ-_I7{!gPS!JzCZn425>TQLDq4yGOu>?D(`;z0&r07H`+7nK0>QulsTu{8M2X%R~c0M17igoS67Kx)QO>MVlDB6 z>Lp#Iug~>>2O=5$5A8m;Sii$|0AV|Ul;^-)&^Ck3hU8C#{tm1HBRZo^IFKoi82$ZQ zEDynW)bWBG6tW^DQuP}HAP!R-$$v|heneALkHj&@2e*vpQl6Tr3&$_I)sQyWVsv#N z(xnFUgI#uW7Qf2%B|%6K6|OU7LR82lDTZ$_a{~FcFq7c#CBRb^AVYR2OcNE!!HE?e zf>2t7m^Si0VCad!A_1dtP{GJDfcz(f3oBcR5_kY&uHgT^X)Gx9G?@e7lj9lQBeLlDWUy~%l2VmTfHeSiwq`5_-%nwgNn?<4LWJ9 zztvec^1A8$?!>a6aW7lk9$|px>=R>xFGGt)l!9Gm1h_WZY~k^fe}~K!(|p_&tYMI0f2ida&9X9RzMUUdSg$&!#vh2v8zl zqRLlFxwjJf^eec>8N|RL1TK+A&Y?HlV-M$sxG#jflM=uzhd)svQ7Od|(#OUgddH!! z3(SFHju!#iDRuO|20AXGM^ZdgEoS`SKYlGsIhQHd754&IR@U{s9T%9ReN_I53xJWM zo;J*w*Ez%hV&+!x9@9I*fK%VZD9@JJ+6;!`Uym%lWei1_%r1ZayA$juY52Qa#0YUL zV+bQhyWS3WWbya5_`QZv3?c#R7?1X8QZC~Vq%(DSRxyl*c7O8s#;V5b;`kAW0b*K4 zfj=Cxae#A}gWz`>!Y}{@xN!#swV0w2edEN@8a`Ro;I5kB)+0_}KNQdNzqhRK`r3a> z98C2{3Jc_o2!ltsHVvcsZ@m*xJ~VL42E=V-&iX)u!t^-sSw5>3e;*zWz3VT*#eU%l zLmi9$bDjOKOe!-6%m37)e64-y{Lf$VzdMsxvpWjyXg~MfPDXIw_7 zJusqLJxWDHiw=(ZZs`DeNj4Hq@~zumz>_t2UIIsq?vW*OrNg=EUw?SFykDZ6$w>+y zQkc6P+Mgov9mdcB5eePHh)<`!XZO4Gb{~OXMe*p#$D7ZdOR-Tc`L@}g4oReoM2(=L z7>Fofdv?P2=XWOecglIewkn2jc7p>!?<;SIlY5%rmoNdp{}zUX2RfH(%i@bGtE?XzamGsbDNgiYl{>~uy4$RktK}UNVP>`wvCnekqdoF4 zhq@2tOJA6zy(Cg&6fT;_ge+t=WjXT`vT6ehZ?>(#rx{!+S8l zBtU^Oq6{HX%)7YQUZy>}s4~h;AR5hubR>uQH=80AdRtVwWkIndJ*|qWGOS5_LUhV0 z?|vQrCbbK6U_@l;o(Fp6bn4&BE|#{MrpU<_N1LV@Zm%}NkuI%-PYfmFrQbL!o3i}# zM6=5mvoB30%kzqDn{vt1oX%5-juh2!T2->MQHZiUH&wJ^DLg_8gI!_@fx($cKtH7s zWfqR`$kU^46M=O>pTB5}DUMP+nlMh57dNxyMVcw8&a9oE$2i=TEg!oTR~whlJxLbp{7g7HXXV=XBM3 zA*@d|7TX22{siq{$eLxQ;;`c9^!ESED&F~L7{CnZM9pdXZgA|Xg3jZ$HaRgX11iQ0 z9XS$J4#G~q9|>$Cpdv1@Xj6_NhiCK7gzG6;If0R`g<}l;rSdVQ?gs{a#R9n*p1ue` z<`3cD?kkfbDtQ?4l0l=`{9~rIXoS&9XG*%7C4z0d0Je%Dg~K&h744}|Yxq?@|2X(Q z4rmTVYIpPIq3anTX?^G4-s0^s3=Yd<%_ay^ac0>isja+TOM=m*x(wKcMn4%u0a>Za zi$$@!7eZ=Xn&#WgYNKzP@y}2{`JpvAbk)RSsUI4`jsVse<-UdEd>3Yo358?j}t~>GMFWWlxLFobFs!I8*p(_*%y1)4PYQ^^zr-wF@Y2 z2FqO4_S9uqx%h>Hts^&WYPLwDC?)13*kWGr|V7 zEMGOVVr-dCX?60iq2RdE;Kj${q5b#lQ~rGXJ|ABXCLd29Cv~`{9J+-`OQz0hg1}F= z9(eg8`myn2d;+1r)3fEQ;y{*%5BY2VXA zHZz#vFHAP}#KDVXaV^ko`tY59h8HmP$VaFr_g3uQE`NM;`u7+lOVD@nPuF$yrAs`B zKj|r5uRiQZwQLsVbA7(;nexfj>3sVxqsYN=|7hn+mi9pT$3Rq8`F(U~x5EUY0y>`d z?lZxYdE$yaaOj67^3bgqlw^egNa|J@B>jI={TVcg*O`YsU^?(UWLh8yP50Q|29+N8 z04t}_sAjb;u02G(&xG?r*l*f?1r)60K4=;wH1%Y9S|9y;>rvZZBDKYDRECK0yN@TF zkI*C@m%%G&7LUyo%;AxOW}i>cw2RC1xkz9po9IWLN89KFnUWlFXF@snFBY?c{8bp0Bx~6C6 z1=eFfQcPORA{FDu)H+bD48{X2HLRuM8MLBo`<^I;m1-wwBaPYubf#RbnOc`vZ>F<< zP44v12${or7$LXd2%P)I0xALi>&+}GhG0ZdOSbMQ)RmlXVQ0@u!;GI#y!yffsoP>@ zi*qYC9oi0^{r!KlPVY01>iLT$O z=Md(hG%CV)?hn&mxJDP_gLNNjC4t=rP`9t7NH#!bSD-WPPweY4)?6DMQC_t^m4JG> z#d3C5pz$=XHv*Fnw!-d4Nh4@kI;nnZv=u7;YcLoO9B8qmGJJ||>KsQ*ThWj%(O$O5 zAJ&v^H$mVeaNC3&NQQ2E=lDK5STrF9C?EFR(RHU3n|!*wXWo+^WVMTTA5Pi@NukkQ zd-|b?u*XkpN4)6;@fyi2`Y2B%S-e^x^mv`0SxKFv$6M~cgT>8sc_Dlw95Wn18gm}u zGZQ+RS=u*UnDzsg%r)QUuM-n1K61(ldpSDCdfBJ-%IM9D@;D^~dE2j2F0*b!&{cC$@QC~B!pBsd${!A!d^@p^wf_?j| z@tOZjk#YW4VwaWme|&Jf*4DP)WJB?Ltta3z_|ug^OqrOpVHc3AtxIBg!sVTT4iP3= zI%qTQdc?B*=a)|jT|3DcnN%O_i7-(%n&;H#l$$5KB%~i!V6S-|m&K27p2a{g8u6d{ z%mBgQf_#w%1_p=0w);w_ZEKVu;lyv#V(EM##0u0=m06g?6D;FQ%Cnwek-i-9&ABIRt-WCw8x1BJm@NH~?@yk}OM@Optpp?Au@ z*O32F?wLtOhM5^J7?FlG%up9r&irr=K`F{& zv2VrYSvN)3MFT-)QSvWA&7KDf>2Jk>%s<%AV)j)U%0*177cT zB7MW1*X1wQ_15FQbg6QWz1_WQw*URR;@HmT@pIsuFK^=?I%m$83G%XPz~>kR5a|&m z76ldua-8kSQuhLj9NHLYeS)z5a|9nqJnkxqj46CyAzK8B`k#hmS z;G-18sH9qLsg zZqcFfEQU=accGEWUt7w|+o)|&;EC8fWkKsuxdv|33y?Xvy&3se;ae~M@>r7qrMF%+ zL(s6ly2N2#c(PG}H#jD)4U0m`02Hs=;Z; zEW|9bsx%$!tBnga?FQbx#;`)IXX`RP_KFvBLgAk?BBf%oRqZ-gzu7U5MMM-`kQ;I< zbGETU$@8@K7?kN8DFU$P)|bP1x1pI;GPPcbt^&{N9vxPy`i)$QzgjAsFt^Lk31etq zd^L#4%6YDf(SxUBMcGC!DlaU0dFAY4u>0{tocN*LOfZqotnT>a&AP+=rLd=ShDD@?t!N%azgMG)%)RX(5Yx(k^w43&Y`wk zo-3so1-3&WodI1KWxKlSgRa}#opepn#JpqWhwE*xh7KgW>Vc}cx)`A=RN39Us0BAS z3wbgopfg5Fg=|rut3?yzgZPu=;!CNL;uVOQO$J9Q|0qX=DY$ufH7i#xieIGxs;vyT zX9ZaCDP87p>dT4~E707UkvsQ}8FoI^v|ZAtB4PytFSO)8S|DaDedlyK>9dn`RFbmP z;jNW|W~flfmMPFwV>1iwhNZ_3&tmbZ)|3dSaN&RA_Ae@~Rz9=AZ*eI)K3|T^Wgaai;^Q4BT-Aa7KU3I zEbx5sWVKi@qxk#a_1PN@sAd17@HB>6GAG1VP|9>h`tx>kC8fC>*w1WrCAXFOa;Nv? z@D9fP0)#Ej9sSoCfb&0MCQM8W9RKq(fVcfWRqK~OU+4@F+*`ZJCo*Yc6F7;>vMK$f z(b5ZCr;b4ZrftK_+;h3(x=%Qm}G*uJd2M~ zm}3XR=g|M%_s_fG>;AkraKAi24-Qgd7_9*ZI*P-&)*!YReCfXS5cq!@|8*{nKbDpb z21AW4dN|+S0kCBqMU8DZ|2i`$VmY4>?sujMGaxO^WBsCUdZ36)BG8t?TdlV<=Zz`* zvSm-wwQ%DHd2}$O?8g>KScoarIyXcpWP7W9bM!Uvxn4e$HgYy;v`ZkEInIhM-KQ+C z(4+BOQieO%;8*L$m7y)hIbbx}a+8KTm=a4xJixk#bO<6G#-u?^VWrklaD)nL>u?#L z*IQb^ains57&(ot%%X8@Hl^+^@0;ET;$mO4b$n7d3E)~y?L`D*va}4bxjS()1+@}) z0bMgwv$Yh;_M_~d0Mvhx+o}|%vH1-`6K z5CF@f4b(Swh`gO60__|559S>{`Z<^JqBaDnX#W0mr@EyO!hevNGD4cw8~bBUH0?8C z$^HxB{hnG1=ZY6-Bf<;=y+_kWd^wtU-64qMEO zw5B|7LX{%C{<>aYp9zwQ^;}#*%M4wc%0Pu`4)xSYxn!9w{3c-ZTcX862GI8+oEGFJ9N>kJPWE z3_p%GC zPc>tD6mF}OH*t`%f<_xQD;7CKE8CcbU0J99qts+yd@%0HHL#X`Xon>f9H>>Kn}e&D z`}O$ny!WMF{=GOfV4&VHP!?gR_Y7F_jXrLxPc}49A{=^Tt28q(z1<|Ip#3Tk4t}_T zXQ7B%bGg|ellEueOCWK+6@HMx=G*{yTz2qe6EjQ@A8^=8Cvw=0+udVCrv=;UC7iC0Aq zP+%7<9MOe?UGVDABU6Surky2fV=Kk&y}5j^S7H0z*xxfaJ^YezIH145R}K}_PK#5&Ckes|k0u12HCPy3%`m3zj6`=oOj=pYJFuzW zm5V)ae)F^M@~7WpOJ|5ncP&91+Rng7GO3eEuj-BbImR-Z%S<`lCUmCWB&=CU&KajB zB6@?fSf@_#obnaHQ6z979U2-O=fo3%OGh4AKL4WgT$JmwvWaBnUx0G_oq=&l(U0Hn zm!DHAE1k$gyhV=%D!oAZQ|Q1iy^3X0^b}FWO@7~>L0?RgA=TocqG2I_Ou9fOMH@x* z5-JZzPm#4^f?u1)3Tucdhamlwbd@6}eEjr|fC_;U#ZQ4D{RT!mG@w027+;Fs6G!T~ z?&HF4J)P2!AqJ`S2K!Slr2yWwU;RQkA0=2Q5%13g}# zF9BdGa?#8m+H#*D&xVYvRB($@or4fI@{8NSz={-}TT< z)H?i9u4nTu-_d9wejBdT?U2XQuktV2HrqHP^=+FH+qXd!-qOaHc6re_PLiS3&Eq#L zLua`}*C!j%wH{pldffY0(ym+z};cw^PgM^#;L@=B`bXPP^w zMjv1BZ?E#z)cw+SYy)DGDJyuO11eIZ;reZ7&{6==pOnq+DCG0gDvrc5Qx3(^$`E8r zBsz_Qq$$NJ-8b1Y4}O#7cIhi99aRH`x(#}pDOzGh7#Ctxil_|o$p96xMX=-?bvp;K zLDI5zl2)^Obn%j?0DWi)#S0>K@96|UrTPO=B?0+aK5*i_iHBG2oBQ%HUM+p|KoNRRKTI+VV0gm*;Q*C?7S$5mLl=0MVP-7|V!wp;8rK%RZb1mG565Flj^^2zY zIFdispRqD#)f;kLa<8k{nK&OmI&^4OPAsZ6)o^RKH%CTB^p(H2?+!2Kcku6C-^6O) z&PXAVIrf)%Li<6xqBtVQJrc(~cq8O?Fll6YVaCgOnW^+!Q|dO3CGm;tyAHc;wkI0D zLbE3kQL+4U+TS4v8V*qqh3~ysOV^M$*G|STIS4act-1{mH1EJ?eTWqQvGK4oF#Ny4 zTDJe2tNkA|*^H=4%Wn!G^nR*O&8OWp-ac26rz1dFfnv0wM-fpw3YCz68Ebi+`QO&8 zLOP0&;)(K_{PSHmG4Hl9<3TYOIH34U1%DSJ7(_1X2=jps4g3v}peD%gH+?&QqlxN} z928{j)laJ?i&E8Kd9-Rdeb(%ti0)c|&SD^a`Jr{5#ufVW5|xh9n!K(MB89+xtVltW^OL7I-8edAVj(W%XP zzv#^|(25FM?9}@3XLrSPME%K7e|66-%ixraw5yr+LQZ3-D+%51$s5>>Ya|Z$jMX3) zVFt|7HbS~q7@{qxb=8r+n06b!M+zYygeXd}T82(R*^lA0E1BO0Bo>0|Ek$71NrLGm z>RcG(FVf|1vn#gkzW0yf3UwAJs&&fgy0#d~tA}peKvy1%95C?!7eb08@Q4<2CC5gw z4i#@mlUXqIpbJ_}nJ_NI?6z)dmgAjHyUxnh&=$(v1l`G?5Lev9&$4H2Iv#eS5s9uR zZnlrVe3#YZGdX@LvI&beay$JfrNqB*>O8&t{g=SDDOb5+1i8Gkvz|kvGY*9n^PWEb zO!4(_6wxsn{iCvk>`>*U$zngScpQb_qsWB;E8j$K$%o~~C;RAr9M;3nZmEmj_XEfp z+I1>Be6lXe#r5r$VLBE(6nD6~Um8-)nlI(OnFnUuK%7(?7jYj=MsO0Oag~==`u$xo z9gDEw9hR#Xl}WVG$T!sIjo0-kCpq}sG`5}Gq~SD(@j8$)8kveQIuv|)K&E6E+}HS$ zyqZL@vJhsDsBCzg!ZM7=@mLP751y!Ccu^|J`@282(tEysPZ!6}Wz;wKpHt5A|4um* z1N;A&;&7~WX@B@n-plI~S_J~{itX@;D0124Hpnhpf68KU-G&dp8dNYLMN>=Dk-Q;O zfAYUg5azwUuH7ck+M9D+0jjP*L zG6#IR#gPi?cizd?q#k?rc`KWd7w5mIeuSJj(0E+jXxms}q7W0|Fq2CKpJfA|F zc|J4YNi1HiuQMxOyx&}RH-mJJbl|O9{SzQjl>>=RVgQpqB}f0fRJ^E}FDOq{6w*Z> zyuFBmL!5fZD5%48WyO_Nj6YLWPe(UHKZYzOZhi=<{&Tj;_)pw%)63U46rTNgcXIP{ zjQU3I`8c@v`c&qAgiUqf!gl833M6Y{T7;8v0AtpXY3AuY9?Bsw(8N+FZN(d`r-)YO=C8Snev(xqrRM(iRibsww!$Qq29TIUD$juc&fPc7 ztcj-jFap0N0)UP7+NrL7ObYPRb$`0e#St|Oi^ZOls1&SyAkx!FlQy9qwnL2%#o1Qh z9&a~K+FnOpFKT07^ad_A5TeV-H43N?Tg}?#qLKE+NdMyw$d`38nw7zfkF~o0 z25##Uo!1D(?W9(_?NYNtRV_tSi~A=zTL>wr%j(X9f73XcL}C0Vxhi$zE!va(_RXqgN~Hc0X{E0J!pga=#Z|#Cc8M_s$r{DzfDH*%O`(*gqZZ zoh$YiMyovwM9R6dGxMB7bYo4(Fb(?4pdB}@oTltLy!Kp9Bk&!8nxXTVhLhhC0E*$FA(PM{uVGdB3HhXpCd!^L7ueZ zMgev$P9P=Pk%E$xuv{TIq`6EvT;0PJ0B|x0juuePJT6*N1%ThwM_N?`H7{zjHxq+N z&Klmv0?}IQb?I{@ZKT^vNv<;S8Kj0lHtAcT*x=c(*o^k6ICu{acE^LThPRUmqDPA8KEVo*~ z6JtWoBR^Ztwb6N{*tE-waUk|{#WLC}WO@RWi2}&eC;_|bhJPu#Q&$|g6d@rYz{8I- zD=Fl3a6u7Ec)eey@E3~3Z;T~I03Sn;bqCbl`si{Fnymn3{->P4aB~@?4K$A110bJ= z?kRRr6XJC|Z|xtyCg_fu_1CLGJW*(t%Guk}n#DjD{D%4GvnFA*a}lp!SDYIT{3Ydk zU(hu}ldr2I05dSlPanVZ6Lv$c{KLGyES0(D1BinI9vvE%*EUN$HT^w^CE`n2*O=TJ zfh53OUyFdvK&E$lp85?p-7VTTDz)ci}-h|0KZqh zYiA^rwmNnM$l60L&&^~A+2TUK^%m#?Jc47B)%`yHL%y!3F4IkLPt57LN!(0&TdBC0 zRN~d~kI(zz)CrQ~x~I)HYGIbtBrn{zx6;n{>zt%f_+cIj-lz{rXc=9M03P?b5mMD@ru3VMx(1jB(Q>x?@CIq*l-c3(1! zA7-uW{5D;?RAlh@^2Ok3KIPcqo^B14yyziJw-8p99e^3X_3}ZE>)v4P^$5&U=_5RU zE#9cs`u)WS9SIR!I~JUKJ<-tTiTwNg4xE?>oNcBW3M&epX5(#M1*~F2*P;_f{aKT-yHeRoxU64a7WVr>pgYLR`c)5}OW?cJXDadCh5@GuPad=0CnvGYjTQF=Yz>j2 z|DWr|e-T63SpR>xiLC9nMp3`(^asiUCPljsJ(F#M0B*G0a>!zdDf4lJ3nc19LZs~^ z>Tp{At=75V`O=zQ)}pQ0|18KIIb%JiGgG{e8do}8Yo3lz@lD0#v;UXEUV5lFcF1=C z=saU|+VXilsouo-?DMLLXsafvH+wP&d)fRKANyT0iPSJPBShri2@#mf+xcaC{(gPl zUK|8#5RMVm`N(iKQcb*m*MJ=C-5pMh<}SC5Yjt9OA>8~V=N~RAl zTWZx5mv(}rCRyFoQ8SFX6d)tayA+~K0s+kRLP%b}CubTHZi}HB>iJ|yTWu=CVRxp& zf%@^;Y_vh!My80)CXs`UUR@G{+|)FxuScpF6Y(bX9WAuOvqNHvdAisJnY>{<_aqoh zDw#|1I-gd?2)1?V1fthHoRzK4e0v!trdX1f)Hpk1y= zMHMa6#ka}M3ifersS~QW@y}qX*kBct9UKbl=s{sB?@)&Lb~Nmh!YD60or?AaEq%@3 zgL)*sc61)qU_3+2?Ad7YX!<^u`dn?o(~%g%yQE51O{$hbS+!tclI|a!^_VoT#!Z~^Tk|`xo7c}+m*-Q{|#~G;$!k1g*qJ;25c(+ zK5tyn6*OS4sUngB-1u66kVy|r*H=YfTK|(xo{5OX5&MVsfvvWl%!U9ci^Q)uzG2_( zn)C=xB>A(UvJ*FrsxVNUz5};c%&OC^*jFpF?Wce#Nfs3AS65yW1Ch#OFDC!E)OoW! z8QrSLx{ULj7!p_!1VvI_-gU+v?g%!86(`%K*reGhBlDXlECfL-M^K7DibZZK`2|=o zhIs>-f&8KrL{Jal*X3UAF9P}kbSD;Q+j=LOwjzjXYh;b(pVYlNt}Rw{!5~4qt)n*h z8rtZe+iPtue$F}1g6yg|pm=oKcm_bZZ`hX`I26wUo)!nk;Q@}Sd!!fXXmw%+4^~P+ znmIPe9wmW@>kFjrRTvT&E?*rKnAQv+6LktWOmW#^e12?-Qzn6oeq|6CLwPD5^7TLy zpo9Gc+>G^pIp#itz-5uUwKy+$7yDleQt+f+yNE%ZkPxTr1hQKJAWuQUKK@M#v5>3gw+iNrbf61Ak0TQ+phehc7pe z8l%wPf{BLPfKO*gDWy5^$xZS1Bcgs`zqw{rvgc7GOwl0`&@$z#i7h9Srk&$mMxR`@;4l`2nbFU zdvbXIWE-g-S!QWcZ@Em180z8;QJfl9xf!(6a(;TWvGQ`{T7j=}m6!^8V-5Mgz&FtS zFrGJPSYiK!+GjbqEYy+uH1#@hRQ16n+Phe62d2wNdB225tA79m{a zM!7N#@pP+kaq__)F2~g~;rW^P&58I_AFb|6p;_QHZLV5fW( z6>+-B8V0sh7!q=17FAd&d<`LK<>Q1hCrK{ul3@b}0a{WMcty9lHAgsgC^AZ47jyWE?67NCGTC3|XEGS~O8 zVJG0&Y4z9(PN!MUR+8^018Qo;whL~Sswt*O%jd2}3x+0Zxn8T;snZe_Zd(3N+Cm1Y?7YMC1MqFLc#QoCzlHsgOP37}{%*{E^4a3JX$LAI&+LmMI( zIIaudD@~B6WTO}zlbxd5T8Km?H$*0-wIFY*hIF0bM`ZZbKHUyVeukWt#=&w_9vDeM zk>*)}A%o@c(LsUj*D6f%VX#$&6BakuDWEwXB=5$W<|`tSH_y&EPH1g*;F0f(>RgfA z#F`(lf+Q8SQr#>^zr8@txBYN9tw4@dHR7zgwPWvZkYLz1l+x|tUOGVUS4*anuXMum zuzLtQKo5>iF8hzeyS$~KQNmp-s#K_&t+tSAdTNUmP|e!n1wR{9q1?TUVYbHC>%epK zCbn->TNHl=*)Yi6CjTgy?1|mdj#?CH#uMl#8CK6CY2c!;_Z-HHL+x(%15i*vJpmQB ziMp|wcJZpnQu%TYC&k#7`oMeUDgnRB2oHSQQh=Ryp-Z0Th26>A=7WJ)J$eOvDGX=R zyyHRf1?Mrk8r9u2c=S{gy-tQvgp!-*ug{sYJ!Qgf|K2l{-VKh|jtwoDN4(O-XPy@n za(g>Q_q>*p6i{w5_odps>qg6hy}jE)G~6R+VD0ayefikg8{ry^6WGWp=GJN|k0khJ z%oZaytYLTT)0W{T7H{_y^2bRA5M!jE4Xor<1;R+k9%j7?*T&|=;}=yU5e|GG?IY}( z2G4jMNB6kDXm$G4+1cYMd_*@;+mXr-zaqk}IlP`);>jmu+~{o_wRF-VWrWTpKFvRN zQNk-GKkWT|3t#aicJ&0XhTA#hO64Uh4I!2~rp0mSu!OTgHl4j?4%&8Tv7_5!HPa>O z;cj{LJ~^-6)chxPcn`H7gL?EM8My8L1D&sl4DFob;pbl6zo^8+%RjaAP7h62rp`pU zR^!K$xg#g{?4trJJrI}&@=D*hryt)?I!AlEK{`?_SkES+M^gGhwUEglpAwAiulN$VFGtB|AKy z-qmwbe><;PS=wiFUsDrN3<^5!YtdiZQHhO+qTV9wr$&0r)=A{jnj2I z=}ss8CVhMVfc0r*&$;FtV?3dC(xNX=SuNj@>9B}oh^W-6mG6#-5-1kr=26FVFG0Wt zZ}=?Z*cboRuQD?IzsF;Y9E^hDai!4 zZqxO#Ar5ZDJzoX_J@G*}C_+C%r`PGjm+$3K_p>?l{BnL6i*{KEV|_u*`{K$l=@Jmv zPwsqzQx7#m@ujKBKpr?OU*DMhFCd4w8M8*c-?~+c2 z80urx@)_-cv_6)OI2Kr~@NEfLnN_pPv=glXR_ZSUh8e2|7Tr!5Kr05SZ$GlWQpXfI z4sKTgFqP4`6JX&_!ci{)uzG2^t1K?Y+*~JwVjd%Cg*{Y`>N_RAS0H?huH6JDF~ZP9 zjE_B|=%TI+bEs)5habtr2n2_Qx+Z)$OVzx9`FUU&ggw(f%q_^McDs`x!rivj_GG%S!rUSJa}8819Gu_iM3V?t@h1-phS)?P!UO-c-ZH zhb=4@N~;l7me8rDD;K)%s2#WohM0&6H`Ez;PaAoUzB)86KHii340zA3Uf$Fx{NE!E znHjTQ`9_<_uqp=A)&${ zVNJOM%?oKbOdW*XFvre0_ z1znnx>4)|gt`eBAKaxqI%<(t;5?Bf20vOT4A}!}dnOEs%vDE@lPL_&G*vt9&6jdip=rw5n zZ#CUVE|A)|rAB-)CB%aEu@y4>vcJ$fpzM1mrpCzVU6dVDj*_3&on^6VTIwjF?m8i9 zQ6ht^XhrlK4;674^iWjn%Oi6R2 z`YRNAviBow&`oxLCUi1lu1x9n%}WR{&WuOked?H+Lec6i>uDe%-(D>CCn8#onhxv- zMc>Nn>=~T!7e)!ULCZ>IMVoAM1>EW%IGs=`Tbk`?k1~YS=%C1rw9$3LqEG~zkw_%y zq__}#Y6U*2Wri$Pe(4C*bqA81Zrc%aEn+NhHc&TVrPu(u z^VKSKQ^8dMmKAYpa8rO|@));^Y~wE-JbmiMgq_r&bx>w^Ez}9zAUSE&0*}yIdwyU~ z{#5Zrn4`mSRylMxu73ek*Kt$YYz6PGEQl5?%#q!(cEI_r0FniF3u5P)xLSGTY-5^M z)ehWDb>^gr*1)u@y)*^xf}Bo@s^$CO&T6;8S7i?>(sPl%FC<80hLdcL*a;=#Eks3p>V%+5}a>S=L)Ns+4kw1{9Gc`jZdl3&?x ztq&jTownQ4Km+>=EY9HkY_C)dKK?sKfiJ_`G!*8MwWw3&uwB~@1Y`>=+B`O?KS8h- z$F3`dl>xpT8mT%m3653Abg0Zlv(WPN2E+vOSIv)x0l;;Bz6N~{6T*qK7U2q8@BN)x z*%vfxy-&j+18;A<4aY32i&H>W1BbW_P+YeloVn0mwaVLZLA1VeDsdxv2V=3-98lJr zQ}HP6`~Vu|Z%6!Rk!AbOBKyA=Fzal(Z?IwbpVm2i)(>EzNVb}GrSZnFoOj+-ORp)f z3^~R~_*gM86WOjd{qyYJP{xbaku~npQ+&l1Z&DD|6p}7N|4dyPh7^voeaH`ON?FFr!By{t}i)q zW?iH`D77g3VI(Wl7K8dx+YX$RjzZr82sR&p0_v&P5U1ltJ05kS4e&j(V`H?6c+d;$ zkTs62-7L4Cm(L{~<<@e^N!CM_j(K~C#K zd3Q!#X^;^1Hbg3@bD$WeL*Dc$-qq8Afo8x#=uq%Qo@tx!db1(;#X~OdJ8*xRv%l~D z9A;GYrG+F(yMBffm4}2Cu2yTx;-cw3a61UuWa!9e_J9J!{Hvn$usM0s-FuXzyH~4sg0IqLZed} z-+3qD^~D8}-{X97Mj|25jQ~2vwF(9_Umf_L2iQ_^ zt%sN^dm!c}K0U<1+Y{mNDhN( zI7p->5ifp~In^pI9ichL;5c(b^_hgH@)>JRF-r-LbX++R@i0tBuZoe?^3&JxXTb}h zL47qiv~fUfBk0Bv*)w(ESaNz~Ck z(n8hL^Ynu|qd!p`T=1>eBqzKq+_T7;po*Ke73sWuQktpH!iwoi&bTLEIuU=y5wyzh zxu^FR5s}B5-N6>$6;>`u!0j#~Uz1&ku{W(opwe6q=tNrI|m5qqIR8(=g# z?6rJLJ;n?z*jRh~~#1PhFzXu>rOA zg)~6U0f7^gfw0Ux-TNR#+RO%A1Ld*>WdIo@bM2Ju-$@uR;n0F%DNXX2R2Gh!=IZ|a zWedK0tj|{e;do_+R#;+F9G((HMhi6rU~tM>Ty0G=qWXdx+^_#x38HgnQIond3LpLG zr*2=P$eF_U=9#vt2DzQ3K$}d9HEZad?a)Z=r-(-~`m#MquCszTCrrWPgmja{B#XUj zMj!52voxoKMt0@Sh^MzGy;)4?9EpiDAGU4ZY&ERjr+eVp+k8W;CUMVok56PVX+gFJ z`qS0%_me7D=5&gqvebD5pIvGWRZZG6i2%&RMXbp>BY|E=XjaTW`ecNC6K2Ah zN2*CyGgBu4^(B~vKShzc@_jO}RkJms&r=@$^3#)7Y0IRdiOCh3yJC7L`0Iul+5ex7 zs@cjJ9|ag&v$|LFxsMxbJ48`DXH)eRSJb@kh!C21Fh%w<9OW?jlNET+m)YKmaITxH zc1y0gtOrtaN9ZuFWLlhGRsCB%uMB{ARm4|n^h4EMhbByoF77{-)Ki5I=;r0d58R}K zFmhIT+!mPCRh>Z+$)b(WRICq%@)$(ODV>9qxSNV*4+mq+-EBJW8g90z#*zMtgwCb= zG7QHT;4;Cnecq#&Kh`i#6X>^uZQ!?7A ztPq9va6!u{<$iRdUFBKIJRiCdCmy4oNGrv1i~e7viDlc92+r|AWoWh z2kN)GhMCNt{j>CVw*RBhvN8WZMcgW$4yFY3@3G z>19mq%v~%97};2u|F^H*Wz9{yO)&)DRdt%Vw4(v<)GYKIv}@e2jCTrxtnIW91wR3i)=tVrQB$L?*0(;lUm3HF2BCrXVOA>(P9wOpctwb>4B`6 zLP%XcJ5sY=GN)u{d;8=s2cR)~@)XOYf(XPNzB^p|e66NK1V#FWklxR+XOc}pGDPiRM)6?B6<~aa^mC8~ zujeNw+Mf*EC9fy!g*zEpDIw`K#VM>{gV5V~#;h3Bt{dEC*9?0 z!1CPT$buB|(no5;?OSDqr~g54VGDA}`<+)RF&7`?A`1r7#&kn~u^^wpul$AFcdN&- zR3tvJec_1$x}Om&XcEA1!V4q^!KgEg33%mjgISUNi?qj3{`Vn4U!ww36woFY2TyKE z+A-{^acl#*!0-Fo9k6UjFY*oTG3)a3alFa=6*x8lOXLNphn)!yu+xHsa8s-Q&`K|Q zNVp)bBbh`c&1|CKFa$*Zk~)rED5s-GXv56BSBKCSrzSx|rAJe3*iti^xnQT82kpZ4 zy#h`DxaYf@;@;q+A-f#?kM7JR>T3SqNAine9aZ+pLYL-XNJ%XsnDGIG`fg}@{A)dvT z;jp}yTTG|TTtenK=A+gAqWA7WEAz{q(C2l8O#reB&z5eAv}vmkogSsSWoR7(ZBBDg zsB*ieq;lDENG4&{zsz*B<`pt=rg=Nvbq&QI_f|h;TwFXhAmv4cy_F{yD&I~Ing4Qi zR-TQXdzA7`$mlDLNXwd_HC32fG}QbBmZW;TzQt0UU3qIJRclg@!;#cbOQ_JI-B%ai zN3j*2;ZRZ^QCIZFC%xRhw|5th5ArqCs+Iv6jt9cCJc+%YQC@ap0UCjcldl3GN(xlX zkS%gzBI@+=*|n5PeZ$Lb*{lHP3{@Nv!ce!BG9S*e>)hoQU-r3GGHPu$p}@s1kW=Ceue)Gu zZpDC0a(Yh!&im&G?T#;zU4RcfGS_@{4Oc#OmyEg{cdXE_v2z;RUg(B_5RQc~(-wI_ z!M}{~$1d2%B@y1GM*zHGCMGJHJLTdx5jFE}4Uu`?7kl5mZO{UL4a&ZaasJA9o4d%8 zuJf-uf-aGr)_aV1-?WaN#FT~^I~KV_-yZr;8q%gZI3`25!^4|VGa|A3M``4q!{0*;kb?Lh2Qg!9Bz#Z(_t_XtS$ZG zAK)Xfu`-hPVSDO09p*I; zW6Md6p9qE(jUO3C3WAM(?}<0Eh_Q)uOZcUhu1hr--WP73AE934wpe}4bpkSNqSzXOL# z#Ch_#bMGP{+85(3Rvyi z?%#Q>FCW_Ytr!YLaLzpF2+#+Lvymg(z+dFyNO*5Ep?IurArJeUPI~s=t)jGL z%_EGiJV+kNgrh;=BJaJ2j8e&$m~p#Gl0`h!i`7y_2GR>N2AT1))=aXUwO83?o~jxW z93m1xi|Hp`a;XgJQT>*DWx}VGwTHmTo@5OVkw!R6R1veyOEci$BVgqYg46XQ)+}!A ziXo$s$x6ZEcVv;17#Ct56K)KHpzdh^Tal@|0kr`gE*&NQ*CL1} zQ>+#?!2ZG7RkNgc^@m!F0f-1g%T5xT%xT783{F$KM>YSTU5#=t|g^t-~ILy`$3an4NyCn;#e?_4c8qY z1F7=9Ejn2t=0N}6AQ_i1ADKU)NJ`% z&ALKYny*(yCc#-hWc3aIE-L!v9?h#TTJOrUKoEpdXudW+^2Dyf{rNMtVu{^#(1mo5Xcy^-pe3lm`8MDD zP_MAyN%K5Wl~|D^XAj%*>coM!VWMDJr#PB=QXribh;5EmU$!2I4T?s+o}Z=u1l7U& zW3pi-3eC<2s>5UEXOuv0Owl;G4f7a3SuXjhW%AP_x~F2R`|dOQdazGt z125aMxIXp+PU}@8HXmi?r{+gXE>JVQXs1IzYW!1HSLb9#tl!$v*F)~;#NhU z)~3FA4S-~bvO+wJ#eq_vSW2bY;?l}~;_;*>Ie4|)YHK@Zx?3(}|J9L&6+U(*Pz~*S ztt<)*oPj#lXL>+WAMDjFyQ2E*QfsmNz|R7z9xH?tv82(OlrBGU4!@xQC~9S!7L zaroDabwfcDMPkSNh)uWnBRO#OQS|X`8Kh2M(ZkfdLmqgNc31`3flW}{D==2Pf>j{K zQw`o&;$7x3b4FD>y?jMb1GuCLdJ2ae0zGzn5~Ct<06v%xs&s?e25ctyr!nZ5HYw-t?#9YKy86f>ceT7V zx3eSauyEY$YzQ!&!Roe$o5_U3=Be22H$vPFKe?9>uvs-@uPavfxw1br0ov4Av5GBM zsmBpJv%nNNVU?NwP($VjutpfWNx4}M_}nA+j|TLeqkQ@<(zXscG{X{xS|PwP)w~t) z7z`xS?;p296Y+D;F-^wBc6A_ZXOP=Ng(u{+u_kW>Fh<+=V)>*2xo9VEeB{i|C>?M~ zJb97HCWJC_pLt0|#!V%b9}XNJn2Ig>qC>XGeA0EiCdT)Cmk2jqdM$#}J)$bTp4P^) zJRbqKs#ly*7_sj&&i;v;ZZIc&_Y!jS@HqI}In_$Gu8>w*$>T&OiyCf-HWGGs^x06J zsd7PW_so*3b=VF~J2mNBq$Z`!tbrn5u1XQmDh$q5(lyQ$R~PRJru>3pI~Vgz)8B&@ z-U3gQJOxwGTHA~m*efF1+4{RVdT#o>tdW6v?C9!pGURFCnMl|x-jD1PiS>Vg0CRVm zre301f^9ORV!mAb`v~|H^23i{#^~gfafm0-c zrLZJZM$Bdr19Z*BXh{Re)I~)VjN%wroBSvuvN$7ufWfkVSeGwxNHG0b%fXQlo% z2ziIXMy_zikS1IT;aG$@=+_`0f}L$Ga&-O;CLvX#6K9(-OOOSL9s|3MZX#i>DS^Pp zme9!%m0;$^K<&BMmZ2&HYI$OH(h}?9{1A0wnGQ#=qBBfT%&Qmm(S%BqY{)OgzFk}x z(U|TomPRXCWHV2^%TH)Ko|U7+mswN=aMQ-JY$al-PQ08uS@L^@8fC?wa>B6oLk`W zpO}&WtMg$WcFhkVlmbK=!wKC5Dih7OHj%A zzkjlCV_7?Ij@)(q8LXl1Kfw#`nsbu2^|Pggx4w&wJ zIFQg@brnG5xcEPu)Htxs{p1kqpo-75V79n_5d_)qcXPe(i!l6Z8Bzd>9C`%ys|C1N zUAC;cG3F8%Vq0El^px6#LPOA#dDXEP@O$GQ%}PQwc&0a-H%yX-4g492svOjE;TKu1 z{q%r(k~NyUVxV*vNkLJ1Jm!lvGnN$4qPvBNsQocs{UE0?pHnpjVN@>A1n zMZI4TYMr6KVOe!`;N zG<>vaQ}lG`4fR@|o(_Q30@->s0M?UF=^w5UnL-wp73D*hU*>8qWW7QF`fKh5YA*t0 z;4h=r5Pq8fag2=&(q3ySSX`P^IThW0OMGf6X;4E zLLkT z+9C`&8Ew*pL0N0iK^+5ty07Y^D=L4ijs(q2jIOHHmK za0?Bgmr_T-^uqGyQ60=henXmal!>aaWT)BSTiE!)R3M`rxuE-DW8H$!Fk!2Ce2995 zov+>GZ~9wo8p5gNJEteBwCjJfEx>yD&p7Px8}RGf;v;D;==Fsq?scEupq`wzc}l&h z=a$8?r3cIA)tB6#6&yz(RiAlEXze~xJ-t~c-y0o7`PI(GY(RtUIyhdwohv_fs@LqQ z*mN(!1$^bcca#lT^tuD;3&hR&=b=Jply4@h&EI1EZT7pwuS6hH%*tz_9AxVW*MYZ@ z=V4BGdECFxY!;m+mb|R%PnDlkEs6J4JN{dqdOV(hIWfEzf<7#gk#>Z5q2n1qrm`zW^LmsC*fnlt&eWS5PV4XhdvJ!#ByRixBOE*H-xQ+#!s>*;!mkt*%w+P4LO)i z-wKL@_^92S!icv?am2t(5yU|Lc%pto%>U~a1lt!y2z=uy{?+x#(@qG(4|G+!N3aB0 zln|zdjmv9Ud#_vXdU3WiM8&}EzrcT5pgb#4uLsq3z9A>Yjj4HWsy^-}g!_kL?Pp$h zF7FJ@8Pvv(Nv2w{rGZqB-`HGp@%b0gKX3k}4c^7gNIBCF4n576O7A`|?}Ddy_JWCe zrvY`ah+9e`B0#t1%eZ#S;SHYut*E~}t5~+0nhVPECTAn}bT*LMr`|c~spHji;k2yo z{9zCD7%rBYfY7JpAwK=yZzK)j^Rr||a6UE6#Ncto$Fs<9V3c4M);x3KN@G3c$u!ei-?X8KEb z+(Z6OA@yUb;jlB0uWdIcUOLVgBNlK9p+a9ejmJhy_FTGnaovo5Hf20=k9?F-sxzEtNIXB@)Sm z`URA#ihltosuMt<5fHg<4g{`9U7UYPu%v6&5>ps-!7~7xG{p7`XU)ddAZs~ z8ZmuePZsva@J{q#z!)gQ=i|%I4o7ntYJ4rch+;e3U}+*U4|( zZM3LtnGOdw5XMG)mRPz=Oe8n7yaqBS9+_%AmNX^4Tp$)F(TlZ7cz{{v5%_1>3FE(& zzWh)zis$q69;u1-zOy9x3d>TgbI#IKr9xd+GBf2%{JGCctI<@SUQ2qde(|2Ws(`Fi z6i$!Ug*6LQZ+2m%F42_@m}YzsB*!I=7-j;ynVcxLurC)H1=r6+?3GZud)>kZ>Zy1ICg{O}x_bGs$?(1>7`^Ts zV;T1f;h`iDLMOyM`AzbQr(?>0N5OmsZbxDy0%laQGp?RDI_#gDcAKC$MHqx{@8s6E zKMIVK3E06hh#R96sfQrDgJ4shmlUdDbDe!Zzu#OogvI6=LE0EU*LPC;qbt>Sb4{#5 z6kxG}pF;@3sOy+qXT-kbwpUL}sj!xsvIii^BM`JSV&3|2&*cjZ5l7; zAx3m%io~XZZAJ>t00ExmXUnXWzuQ@=n4jwEG@O*N!4bFHb+%rF#;e`Wo?ZkPQL~oS z1AC)^RpQVwOVLfdflo;I8`pQ5zdvnFEG;i;Z~O9I7nvf2+E8(`OEnzfJRnw4ka~$5 zPdKU2x|q>qPJP&7cAHx`d{QdYuRtbhFXA}LQgZ>zNI8Q?FkwxVs@ZC}WsH%862fPN z{HG+?5jUSJn_?xxyFNpFb{Hg6jE-~(j2S2;gm0Qq+Sw;E$;nwZPH-nk@y1GTLvCU- z{%X3aWLeH@-0Q$`PiUGkeY6?EY~=5n2m}9nLH*A&%#v9p@o79#3q024j6G63 zUpj~=9cfi10FDbLWyGYs`?z5w<7NJfKmnb4AU=JJA3HtetG5x@*|rgb;{Dvuw&`|C z|5!E#U{i3@oX8!Ai#$D@;-Fmk<|yFuKfpWr1(W}3=$ZdRamvKX@xND`>S#J|jv@N3 z)(N~2irQryb^wyd$Mx)ZSSMXsJ)7BA5Fj)v0Ky~Z;~uY;dBbfLN{E(f=$!|qV@}O) zGoSr?EBMebl!|#JIANXhye>$J;Bjj0|_B) zu#4l%k2}^>!B<%T5~BD3y0SH*1nxi+gdg|ka}1Z%CApyh1*s0SO^IfGAbRlNV;K90 zL^X=|iGzn2Bx=Di^gN{;>)RW0U3H7Vcp;2v9y1!6+V_(B$F&nq*bxLWG@Xf zsgFMI4a;$hlCAeOWkGU$#;a9JQzf+eHnw$a?xtR;NiIpGs%&kcn@HZEVEVnw-92sw zRxQc>dHa`S`u3Gi<`}OnmbTh1B#4lO#MjsyaeYV2vAE@(jIlu(M~HzH+3Ow6ElJN_ zOa(c#MUL#0>DSF&U~{ce`gS;$`c*u{5!|-yg`-WtT*Z`a1p0P z@(n2&^I_Cn?4tXS_Ky1{A^tj((@ByrjK+2+dn->)qHB1*XB)}Q(M?9G<;!OE zCfmRQV^Zg|>L|d}VnUhdEAkw1V^Qe7J{4x4rz?cXzjdQ1b=6z-6uAjhS?6=aEw}Hy z3!u86f7-W*sOuY*6SPIFw-k8jI(fLrjD1;jz*q; zZl6NizHxzrSR*|djS7mvwIR-11Mxxvp__15aO7BAhyP88*a5GRkabOlcVc+6du*fw z!K)tx#wH^m5C>VoBt5`<2&7w1r=aRF5K7YoHUkZ_jZ4Lt0)q;u9b9g8b7Hwy_w&NC zb3>yH;4)*~&Yj(T5%>Uk4mkw^_g(Knqkalax`o?U=o6(U{q|`@pqe!Y3jQ+ zPJzESQwmd{npB0TrYxfEyI?kFYUi;Hi_?YZ1Sc`a;X(8G#wk{!df!01$f zXMRinr!K0g1S)cGK8Hhl{7?BCTuU5Oo%LEC64Ncyj6N#+iS%4oTDemm5}Q`au2`&? zx$z)^MbZjRhSp5i9n^PK6a-kuUq!mr~ZT06a zE69|0|2!Am{WtI0qVO)vFqRO1k!ZArUK4%x!!A6?S9k0DePAr#RdJV~^mf!v z88kb;+HZE-1|Mcq_&f?Sp1?u-h&Jh$911U~gUyD)f4jb6_R0p_Y$h^bI*CNDdUd;z z9N(;OOI?uhz4MP8bQpLLR9-&#G*IH*NfbBSRc3Ae6M7Wh}H{M`DB;}@w>O9#cl_~OonvR z?gK4}k2%c+wg#igalOJ~X>S}bZvGT4sRDH{k~6)|SoWa7_TXp1;T-h2&Wz9bu`Col z%UTL=bjyyHaBiJq0|=YgA;iLa%=pIkE^L*#a@@IQQArx*l|S6GRKUXB&OkO6mvwSj zAPEPTZSl7KK zO!;1$aJGfEj<2Y;v|FI}H4p_oq7D7im~In&`GzQBhFq*T%w>MNNOM0X9>PXL96z4l zhjm~_l0=3BvMe;jkzIl-iUd<+QA8F&UODN*yV1BiQF-T9^%zoN7n6V&3Mq68Q8+4I zOoe7D;O!3lkptT4cM;Xug0$yQ7rW36yYGAeffl4?uSvl)Ba-QaegUPHnNSd zt6EKusDBwn3ro*kxz*DLN)YSrhSX+XaZjgJz|V16N$9nByhCO{Qbj4$~NJ1~Pkc`#U-C@V`9=01|B)G}qVjY%&)<4_vmjHh{b#54C#iVdF2A zw-D;!=T_W*?Ue!l7Eeztm=_D}xJk#<$rvCmw*Yin%^1zVUpNJN6K$5a2zs}3bgQR3 z&&Xv(v+W~^aH&lzDx)Faz3t;68J&04P}mh*o~`i(goZeqO>eq`<&1ff<({Ln^3j@4 z9*t!Nc)U&-^CmbXBw%#;c$JB=%6wANyChgvI%%7>3oQ!v*@(x*T@M`u&;n}=CTyLG!ss7dF^T16PB1_cf|qe&0uSj{98PbGIE z)kK;Xs3;+Tw{eK4li*%G&Ed0YP0m`dvS0Orq_li!Y$Rs)*=73i!m*v$EjJr@se zoN9F{2Pj%g!05SgsM%%QsRJOId{77C3pZy=Pr$FGFSH9yp-uzA>CBi=oWvy~_Xx+KbaACm!2wwCX}rYqem1-5Cs}ohwH1hhcfu8O`)lw}yM& zfMmX_HMv3;*Uj!knvj(U^i?4?9}N%&q;{J~vWE`&Y+eq|jxyYU@x&^g^EPzh7q(GA zuEajeMqUWGW;yo60LX)6bX<=!ki}hpw$+w@50@~SA>~f_0Vq};&Th0*kkGkm zD9X+_1^Z046X09n1l%8kYXh=trrH>HDb2#9BRPQu4gOQmK8(pO{Or=%SQ1C{;~In{ z2em~agu;gt%`I>sU0je8_z^x!*TTUwNqwO)k_lAkBso_FwA>MHKmuC`MuJ%Yv)G*L z`}S0jE6i2e1gv}mVx|-u>C;mpdRD6a7^j7gl=3SwQ@!~$Bf#I~&C6KO^PBB+MV2R! zrHPhDsx*RXv_MsT{NS=%Q=rNp5^5z=^LWcsdy-wQZhpxS9!Cg-e zTU3kz6X*E7tHMULp~eWfyB3Fw2wuSZ*VAt)UQ_A&1pTh77R)E`PrBqaYMEdd6d9j0wF+BNiNq_mMjY<;sohx&rZ5eaeb z%9GLJ^&J*~>b6ja6dP7^Icxo|Vi0RV#0IXCbdTtg6yF?W z&nlwX6Kjn77YobBMQO8IS!Drp#o2lyP^?c;K@^yWSbjDrR86E1KzVul0<0~lj|D|f z6KYi+sbGua9%n}+^IZVq6|C%v>(o0{g}5!7DBgwE2E_Jlt0AJ9YPa_n3%R(yg$G{f zv$P(5x8m|NOB&DxLu(gBQw*1s|2WeNRx+6bf8x=<7+`A2P!CNVg?)w07 z+G{jm(C0VD2dqeLaDA7)Q%eZ9mOz)r)GQkLEIhjT>ErPI?4$LCc?^3~+1V!Mu<)Bx zsw=d_B0<2Ragnh5l{oJRd8eR{T|G)uu{(-BH`oxC38c`N@CY{VO;ql6N1Yl;6DIB4 zT&g#ew5a^iM|A|@0tVsoY3gN{?YMLQd@V|8pfMxmC*GakUj}aP`ztNOw|p_UTL|D~ zJxE}Eu))3TAyT_6RbT3H>vw~qRPYqv=Hp}6^a>Re+4=-=_X07zJ2`P64=&4rA1@ou zAJ`s+_MPH;_gAg+d!Var?xecD1q&%Ox4MA+Ak$Ysq)7=s?OBI`hhM+#^53s+FH5AS zN>lbGTP+TywMBX(_&mBlTbU(|>NpkJbhqro^*j5WIZog#5s7rT?e2e`J`a8jv3kji z0H?IpK}g^I(*DAS5ivoSNOL=xZpd*-p=(i{vQYwMii^noP)y>NYl?~l5m7-xLp(cj>O!qC9;3mZ0{Y^l7gKamRr-Fgyr4P2NAJ)zs3>84e>G^-_(ux~3NQ8k!~_)m(6693Q$_hkkH= zVdz3lI==p(`92AI0=}x3I=|KS(>rvyOs!L?j7LEFE=8|HI`|}2Py;=7kL{vfK!3E% z$P3*rhn(Zkvt-_0N0&+*RUEZZ5id;R5{{)ubCR`~agzX7`~&RXAg=hYmY?N60&SU? z*#Fly%WduL{~`JLzv>Tkg=1GD?+f@O*m%Ro5qDjzr&3S$bV)K}i5A+HB9;76VX`dy z_jwJpS9ZLTh&vjGFJb^`;O^f~2Y8jqr4HvB_o5f~^5Z$yft;wocpO8AOXqt4zI87u zATpLSKjnG-Gsl1Fl7Zh|m%8{&B=sPt-kHRsM@A3hi!og!iIx#Xgol_MR{d!9bf{z%6x%+7uuO(?IY;^HP z@>CIy1dWG;3KDm#SeR~4@)Ih>rAy|SU0sA3L0aLRL5E)2EL8-TbQA8;F+*eO6q*dt z>8W**NPC}-Qn2V(sy<^|7bafrT+jd&@z7qBOd`d!wBdRC%WMNgUt+OVErSlnCivYn zC1>)4XOc`kB4F=Re-0AsIH(ajm}^x*ih;P4s0Lo@Z%*@-pRj)m>Coro;Q(+YM{x4R zNj*(Bs~*2Q=$`N4zxK+A%=jW2;Vm&s7Iv~;u%t>*kjI-+ zq+HmzS%X}K$(Wu6buif8gc_)ta7xQ+3;baUf2L8uBAhHGK`5$Zi4#cIy^Re$HQ0aY}hW>MoS>qq_T z0hiUeGdif5z+mmMKS+XU+@)Lc@xmed%QIK*uen zsfZSPnP2lpsua|_pPSKG&^%)ZbqA%YY*hI{Kn`*LG-yA_n?IuXpwHd~ltiFBMz+2h zX(mjoX|SgJ<;$XTMkdWEe3CI3r#1`N>gS+kXTPjEfa~BS&vpG!2^Z(Nb4UCwjPn^$ z1f$YSU5ig^DK~%!!bfKXY>_q3oXioJ&>IGmrf+j0i0fpmm!e#@47-FQs8JHt-$H(5EYKPgb(xp9ufzR(H(y)fAxHrYzk=vp zYhYz~)u_MRuk}MvM*6p$5=9q(DFf=>r=RRHXq@==2kaU3#4=LlI~;TYwk|wvk+n)Lm6)}-a}#SsySpJa*~s_OVeu%}_U_6%(W_`OwY6RmqRF>P&i zaT2I>WOTSFsjXjP@j{&DU!qpXni-2-OyhP_jVz(vrvRMf#a~!6=@5J3aPvBg*Y~)` z7qY1&flzrr7PgZJAB5hPzNISvhR09BS26HxUtflzE=7ixy;QQ&$(8?!SRE~9sa+E5 zgmJ(0nB&LxjAka-mfNYN4^s7F*Pb0C7973kVc*_+kqZ;%_w^d^ z{s#x31JJ+eVBfsmkC7MS#>n{waK9UP zKW(HLe84(x-~guPP?H$H?Hv+47@67k(RZDoPs=wD`)%G&m!Id;waROo+V_dbulq7z zNXs6!uMU2Yz8AeL_|ejL(r)|fUK62pEI`cT!_Ptas|%)hJ2L%P(C<@dj~Z6~&h8C;3xGvG-;16N@Jh~ z2qQM(hjNFEATv{GZMz}%fI(0#@1{O!)dzaOMQ!Nm}FVFN4{I>oi``)Q6 zcPmvh{<@0qFg#EOX&Y%aZkyt6%aqx<0UmC>6lT+|<+*hB?uks^-8H-qOp_WxO}5&| zQ%?Ns8ak%MV)sah!MkxpoMlk>Mn769MJi&G`9T2og}z&`pP0VYIpUYpS#j0!;gP=w z?~ZdOz$dvB?tqL&!%JUIC?xCGqa788<}bmzP6;tgjC0n%6Xv2SsNveKVNP+{8QBu& zapJ@o=O8Hbv>_h7;>LAejSCm?rNm4PNFVdg9Gd(!6EM-;GybyPyy|Wv`5ndRH~edx z(Mx}V^$*izaUi@!xQAd`D%pG<$gkaAbcKNmR?$d42QwoMO=53QWS)uh!xF#^I)O2%n_TSQQ`l$~ND_3jtU{9^Jyho=AHqyHZOP$&O<(xcXg zEpZdO&p90IY$8_c_Pi=jGPy zavJcbM<@aU_)K?BlWP%r-|gh<`+AJYGQ!#y5*Ul(Ah%xy&j|`+9ZB zZ`D_oh0WB`mZ2EDP@mhmZpt9Jb)CF%)X%HHx)*Q~l~99eHe6J_Q$^;lh9SdBGuMp5|Xc{>IP?iv)$?y_`_#x6>#Gy(iNQ#i(HMp;3SPp>rU zZ#7xnJG3H^ilPt#gfi%4w=`Y&84a)}BgGY8ypaP~^VeK=ZZ8!UqivDiMh~Jx^lPhH za?SO)tIci}JjpMkUpHcdQA*XcIR!y>A__4T@*?OUCVc-8@kiz=g-7-JpBQ-w>Do<2 zmOqE`!g1Hnui|Dio`d!7Vz}Rmp!W`9twhL1UBBJ6z4@@L=zuJGz7t!1FE(M9))XDt zhS{Y{s@6?!R==`98?iAog|uRFng_tQc4vjG$jVB0HrdEX=wa-3~(o#$ox7%ktH zF+eDGGD3v{wZLjArta1hO|hscnkg@2B3l2q0zXNgsdR_|Xqe>3sYQr}9@KoqUI5u{ zbby?cVKP!AdV+jb$#c_G)>denZWFQIQnB^B8gMycE>J28JuMZN#Eq{{G7VAz_7ag_ z)Acz?6wT&^42f}L>cJDO@H zM$5|>^_#FEBap2efYH;-j=WvP(^h#ojo6u^EmV5QLw> zzO5pbK>NcS+h{ijL>adzBz`^^_6!0HAr>rOiOb>$j@6$Z0oj;Cq?r{#hVv^hXuG&7 zv-`7IGd4n;!5&LDZ}80YM2kO0eM}j%SmYbfgRWJFg%M?WIw+gg|7(_ht_dx^wsXUB zPD{wRT~3Y48qy6Jl{BixW#No9aQ~dY<@vl;b!fPpIVj=Xf;2o;g$z z90b>f8Z=_IF+YJ0jCe~iOt83{7?%;PFj^w0q)r~5PmcS6>eYJ4Q4_84BV6C3{I)0xGhBy2z#n-nkEP?nF5!R6m2yv zR8_4abpemA6KY^^xC9z+ zSiz8;FO1Ud&66Ai9=3Qa31bHvyQyQ~T+gZ|+~5M-j8%8xeO`lHzxo-$`-d!kMeGO^ zs7iBQw96`@$f|%;9(@*{+}C4f7U{bZ!>}nx+5Ukg%PxQ{!A<7!6Fu!YK|jkwMM^-0-?!ozfR3apE> z4A>>oJoWYRKUec~U=qV`Gj z`zy#u*t+%8E3>p?sCg`1r)80(=WRmr13T%1a>z=$zJg=^)sQmvu!0AEONU_giXuapwS+{0)iDUR2KfI(lAn)e+!+cK)6&VJb^vz z6|ow7$aPNhWuMEs?W7F;jZ?Jv$YIQAk_IY zNRL9#kVn5+PPEzhxbmg)1v5u;SE54GL&5KU<(>c<_CU59q!Gcyjx%f~V*j(^7-}IJO4sf7TQuN*<+~z=(1mWck&^9 z{G9%xw~TwcBTK4H`jiP~!6)jrH0NM3^ral`5w;@m{K<;?0d#mg8kzArJS9VDYsoC5 znqFd9j(A~PIg>HG4ZpW3*$+F8$d^G(dlZSh&v(p*02H=yhMYFTDM&lprOFK}&2szSQ z*PHygvsvd08GwNCalp?)Gt)YY-@!5*bK(%E^Y^Ew%~#xtWb=(P$COeO4adKd7INNTn1ywJ9{ zv|-~$>QvSi`A^9Vkl%>%W7UX-clE;;@m*-&-NQeovp-eTm+>elE?XN{J&-gQOv5yOVXMza$ zT5BF0ZRBf_G;yCdr3>(tIda#Kf)AmUP)I*?;G@xlFVTaH25LC?gcYn03;vqODRAeG z^zIKF->qt*z1^K%mlz*+S~k5Yz6ZBmAe(<=*Ie3yY2kE|pF!`TL9%pdE{x9iWO<*s zUY*S%ZacL1;zZPG5dIQ*COlp~^4aMKna&D%0>c`U_mW4ilQH|HA3!eTAJqRGrvEFf z#>DY|p#N+Ab0E?FHC6Aw5E8ebp}ED+J`rv)+crwDK6`df6l22EEU=QHR3s+TZC&`? z0Rrl}G|a{Ucy&;$iCWy27|p zx_Jc0W4yDD7-BSuis+$UL;n!T?2tQFG(UBK7rF%_Yagk_d|9CzF6q*A>swmqAAj58 z_)fzp2-Iz-&b6mSji>Wt^($>lY8?_tr(#8MteTuX9QU;)u(S2<)ehWPTvM0=3?xC6 z8N_W!VaSEn1IbNr5QbUvq5zJeQ(RG;&co5T!@e6+y7qmxFG+2>>^xlhX0qm)=acrv z+z04KKb<9oVtx$Elz;W1NX_$t>trctCP52@okOZ&DlF^6Dw1MUEO_GZ28DH#A{fv$ zt_P2atfmyx#1{cA8O*o7H)REWc%Wttd~mb1L4=voO;t@!es3CcAV-VgQ2WyyUrE#9 zE0%y3{>yB*zj_r*No~jH=QKQ=A0f7jJu^$vdViNCV;tUj8&EW9_yMDdu}24H{Soeo z4Xm9Kig7bgqBWoE^4Bdbq9w#yG3^5=K;MR zv8e+gxXChRjtN}jKkUf+bP@*r<|dMoQ1I)=xZ;VT2_*+vOj=TD=N3x0ZO2a!VNmw>i@yQW?5&gxlnl?^>OxGId1*apbD4NSXBA_EfzZ)o18 z$JjwyHild$FCKQuv@^)}fsZ(Y=FijE(4Z!S?O>9ZdRJJBUd!OyFN_sS@6(&0Iu%JY z6Y}p?{fkrls6aD#iL3+fKq479&p)S@p|vddYbWNx}uGD+S|(}d5mv=fG#)Pab^jw2=X$45^1_s+~^m zy;xCmH0P_>+({V#vnb~jK4p}Cqq>K+J5S$K(Df_dwWVF2%M`om8RFosLvr?~0`cRz zzEiKqv5=NU+d<9zt35h@G}=S`W^7A=sYL9EejrLytGk~O`vT;?vbgXLN7uxFJA20` zg3aG>fcUcLjH65mT6mnkpG!ZjV<654E|WB2#`BU;OzDAZoU=0B9Lgexc=}!9OlQ zpxH{Gm1DbU8`b=i`mqoxaGzSp}Pz3@I=xAT%BOE6Dl3S`U^V`Y%@`D~MpdxcIslpr;G!%LWm%NoV=? z4>N<5&epC7A644K#M|`ij++i26Wce!_L?}+5@AWY6;s90CGtQN=L@8T$$i(R=nKYu zI1%cp2?=jRUE1MQ>3zeZ8Wm4(HQ!la`IpH%CY`ROGj*GkIxViJM-KfpRPj#T&tm(o z%c#(#iSDJrBEv z*__C0zOw5`|NfNXUO)|+-5OH#fY9lhYe=QWX9A2cK3XhYjK6G~EQ@{yw0{C`Z~qQO z3Yd6p2x$Zk<9I~ch%S^z#FsSL^8>6))^f@=&vJjoQDjDEHW`{VA%VG|TwFqtjdpG; zn~0v4<;^gVMZ>5T+RVP*@p?>WCM3I@w|78A*3c3B{P<+qT@-e+e9my0qC@9; zzv_ACU%0p?oUwbisF&oRjT#=`U;P+qqGJy@VeUCM5o^?&M5&sAv_P2S?kDcXiDvd};?JHb4~p@dS+ z=@fWaJ%=Cq?qI?eC9O)tmkQHRS#V~fnD(Mm!CwL4ecRn#d>+2MN&=%zG%xo*XvK}= zg(;#KQMJgKV{%Kd);5b;U)8bQS3__nceNRT@Wr%a#ilPM(WVFu{roM0I)fd zG!H0f0^wM55$a@ZBf=}hrzYrf>&Yd@=>{||qrW_92D*Hv-zfyalhR6yT=?+fXlgy! ztt&l#dUQi|%+V^C*Qb(A8c2}$qz2T?2FQBZf!m6i*6pY1+#pF zw=}lt$O^c3W8%e?nt_jJhFhWdDV+@+l$vMZ#ld+nwcFTZcyB@j282(r8G|v!rU<0* zdJtNigKWph1YE4o9s82xxN+UH(oGj*#YhS=p;))c1;gBRwu)xDT0}9spt0e`_FQ;! zu46#e!ezMA!gbY{sZLDWi{LsvWF0Jt_8W(3IV z2}DX_f-wGth3IA-gG*RIfy0Ib$#f;_SI|oT1qGrNqr8Wc_ngE^h*Sv{nH);9^Sibn zyMv+ebeit+?)MUdtAz1OMOz|lpDx`_q!Q#}(8u+59xYW>UkSAxPphBBhP)5RXc zkQm*!GP;Q*hX>TQKNyY*bIF#^rmnHhPGX)?-~K2ecbI!`aX5H$UP+LFC#4iQ)ns8f z#-+^o&2m^XGI72HklU|y<_)sTB)PT;_vK^kqqWA<(_!rZO=WNKa$R7CRX5*;6()7x zsW6T7%mq^QD%?htAR{2aft8>iu@9c9Gc(X1E)!S=9&5I!7P%_6sdNcDXr!L zJ9?0j%z5?9| z+4fiqJ=r`}l0^d3hKbyR$$FR=i8{t~)Q(MfM4H5qLPG3UFp=9}{7hOg(}M6fB7aW3 zxN$`XJKGsc&5Dy0W=Ox&`DvK6PR1|z!fv7|H|haKfYv&BzJDf{QEe2#U%FZ$KmUcC z7#FKtDk2F=pp;ZOA>IvdfF(Idh+mr*kctFJ{ooSn@i}cO6U6y(P5F3KQ4@d>HJ26E zp`QBhDBUI)5Ym<*0U^9A`}DSMU>^Nc_amA%ua{^P60#GdSFf^#CD<}xu2mgNY&foJ z88;ZwJ8aZwQH+s)_@Ri8qrM7KP}7YCUO2O9_0lJPpvRv_|(;y*{n z4vJhsdeVJkX5cZciZ=kyUk%RPhU=C^`qBKW>Wz3dIQzz|ax@9z;D82}qv#~nS!hnp9!$-!1_k6WIFhYm9D z&@FDPZH-yZ@ASo}X?@GDRuzAJXjk(J$zPth_Z1e`04eoIC$(Q7&ZD#ctcGFvFEfMw zf6p6i!PrRLV*TsW8yKgYGUD$Kk>KHE=)qkvoY6wo1@B53l8{e0$&G@SA>HfSwICCj z%)I+t`$&K&R)ZUBq_5Dp5S_g5cPZQ)qT_}8^uchnrrUJsH{!56Ukb1Gd zAe1s7S$0no_^S5X{&9PInYAVfs*!9_5!B^VKY2)w>X6TbIYI<^>pBp2|2e`4x!2v@ zv(>Hj<@p-Khg3(@vWPTC-6ResRZ&PCd(nS7Hp9nehxlUY#8xIxc4c0pswa7H%vs`0 z;;)HYWiIl%W4qg-F>?=i&oo6gUbMG z#PnogBNpT-x98;#vgq+VpKf#3>dXo4*6ISE@-IoJw#3#p5+KSIh4S4X&#$V0Z#~qu z8upKwOxN2vmC-)b)Es2be>%k;+Zfyu3nDpS*gx=mLub>hUdjH*s7T~J7~|4jlK@ay zNT_Z)xs6^sli;h(oj!^JDt<<{)X`ZeqVzz!#JzEOjn;6S^63M}d1Lbl#A*nOeyjb= z&tGygO<0#@U^jf`T1%@nnw)iu6sHxW_J_#(UUf-*36*?-Ow&fkgM2&JEUeU&UMbbt zk1^$s^t_^e=XNG=y{!e}u_*8o0v{a4)yHTcGkE5z0+{Np#mB8hWIK7cJ-*!S)%)Ng z`>FoaNA)~}{ELgo-@qO*Wi%zGMr*{oys$!7TpD+#hiG2A!*-uSa&CFI*2`=P41K?3 zQEK7y4IJQAwz_BL!(mR%iewQ22@re}YT4Oo9JUx$&LCKLZuOO9s=2$?R}|mV+dqVv z5x-Hlv^Eoe4N9JCJnjV!1IvG81!r9to2C}OE+%_%p0=02g?!Ju`qWr!1rtSwc#=@( z4K{IJ7obxeQB4ea*n+bzhne#np#D-hom)FioZ{;YoGzR?Cz{F~OC90Hj=0!SeJYfz ztTi5eqyq(QSip=GJ8>E6BOY0R%HFawD@kjRk<}6uVt|klK_;RnEIQ2hk8T`xT{V$F zFbI_>j2Z^Uqs<}uJ%A2`nE=&#c8L>68}#CPLnV@vU;^@j67^myF<}EtlE|mhThu*J zXA}@om5>+6Tho~jZ>kh<@VD>8idM_(_%swbFip4s!>L9;0j+6)E1YBWse~VRF|yG3 zOyypOm>Q{CN)593<6gG9;EbSJX@%s)6I#JXH|k4nl68j@(WwuVXe*_Ghfl1SD;Ifu z`H3FXVZ;cERH%woy=l5WIF@48M+{<*;O~-0{u;yUw{d1Dt0|I^b%us0tZB+!qHkvi zyXRO+YU{HadauCcu9%DWUlcG;077<%vXieO-xyfxcYfhPfNXkk^2LTm9dY0!WGr2Z ztDV9%B6=@mN%USpzz@@G&KL1l3p8|-;f;$4)(&I)Bqmw~nif@|RQ==aHhZ=V21LFF z%^2(4ZAxQ7N;V+iWbf}oTS!g!xeTJG*ErO=akClKvsFwuHGt9Q8k(_; zoAAYnd5Zc6<*Y0E_s>8*XgAi;dSkllm_G~8mCousvJ(akEc|FBV1F4F^=QEy7KPf1 zP)JmHtO5fn`XdTJj0YudAf4f5)U1FXM)92RR55e)n?>Jon*1@aUL@-g%e zo|40(a$(XZOEMr4AZ9a+YXkspXOwTfn6v2>)LKAQA@YQ?v4-GR#<4vNhNR%3qmc_l zzv(%Px#xA|K0O7Ps@WYrzbfDetVT$27+&z`N8KIRRMOBCI1GIY!|15;O)df~$OdKD zu9xtuwbLze<;!6=0pyXSH*g|3`P=AMItke`^{h8fR1j0tFw-kfa)+;1JYg(dIxNr@ zRM+&yAElgwOOv7pokhhFBJZKZ*O+W>Nem3|jbRO-z}pVbeX9m%{ZW2$WTH88_ZJp% zLFLf+2x8hK{gMWo9X4Lp0T_r^cs!R7PN0G|7}Im$iQqh`W9qYgw4!~p?8v)}bro)l zB>lf0K2$HBe(!)!Cb6SbUqXa-oTfH-kfEnq(@p2s9RSLj)4FJ(XE_bdIKfN2O@2si zqx`-ftl8BBOx1FEp(?3AX>n_ithtI{RFEmqW#lBKcy8;RSk4?cZ{cpNI3kns1DStweu+7cQGY$@O)@EAy4K}dD?^O_$Y&PCY!4BIJ_ zCuxN1=FC_zy&OLW5BvDOonB6UuW4-x&f{|)NTgw(VM17ViU~O)c(}JyLt=M#cf0s< z2ALjw%_GWHrrf!Pa*IX?81~sp zd^{-6J7araLXh`)@IM@rO+!fomGDFp`x>~uJ)dhibJCsvbQ|8cQ@U_FB_te=^fmzB z^cYm26W&+>kJ^6TH+hNEfUNR&1A=zDzHIaNF1fIdPklP|N;} z;i{9n@VYFq!CPaxs!2tq@DDCp#S!Kt@5LjPNA(GyILDGUPbdBD!P>+p@(2r^^2Z01 z_m0=15`e~jp{1Sqf-7vmQC&i8tm+OWkmM)x(vL!SflvOqhfOLCxVJ=iku4NtqG4V5 zNi9Mpy;zCsf)~>OvaH2g!$~8q$;+cx<~~YraVNU#3yGi zhLW%fium4Ycbg)yT*ppW{f;TN@PlqQomVwuW+coADx?lK1rU9}s}T#S%!ajaqZJrr zr^wTA5Rw^~BrZn4YY}2NUFJbgmh(je?v9|KMA-ag1uTz5%w%F3oqHi{CbCY<_=5zO z*8DDdrXl)=g8j_o5~*WVuiFT70*-RW%IQ!+cVOWNpb-2(UJMrC{hy!kfzS~4ZZOn$ z=m2>Egk}erbF)JKyEBu&AtwNKvFw%tX`WrR$~l(eHOGhnPqiKd3@n&ZjMAS_KXT>yx5G_50 zGf}OzTcepQvlFHR6E)=qF^DY##Z`h1LC|xvgb>ChzHE)L-!;|fyAD^`_M@FvJj-3O z_qcyS-t1#%J#zvW3(YYv;pyS5PZq{E(_2{=sfN-!YA!00~kYtJ| zk?D%e3K@pQ>U9prcCp(v2elz>2{KUvM^pm=5=0y9fveau4cqk(UZUF^=VKo>(DqA= zYR^Its7;j0%?blx0}KLl5$W20gOlmwc@B9ad7!7WpaU?GflvmP2hWahK-s<8NzRP6 z?%@H#0dAJjMYUc|{XBo|jxSIH@IP8lcPK^%+LbQnIkcmg7@{r%RrUphlkCcV251s#qtqe5mU)}1SVqs| ztWxBLY4*-J0OVF8Z8THAGP#I^(TFbVAV4tykhoObdYI%kmx9RN1|G0yU%X`ndY2G- zjY~e!N8u>x0j<&ihnOb4qg7TJpwt+rpBtaHdHVQ@qXJU_1LKU+OxB_!MR=GNB0d#} z0ek%PbHk^4GpYd&q_LMe*i~@CYP*7(<)otO1H_3Y(F)~MOBAu$5Ct$* z0jG``3NVyK2vTEcU@`Q;r@d84MRQXc>>0*+I?#qFN(mY_mdLM^3zi#Tt(mx}m7@Xw zww_s=ijV$D4FZe^z_!08tqlW=KP*6CfLEu0HH!Pi*T*4aLSSZ`_X3bwsRF20H*ss% z)}IZDe-w6CdjSO(Bf?py1p18W<>*hLx!P2)Lu5jGh>EdZ#tN=K`gsJ6dYpNgzF*x% zP9oVLNZGf!W2^2e&MRP1QW4D`%s3csle>flrNf}bP>rVxBMjqghUMRrn#(A$ZiBf}?>wYb8uUu6ULni`t|oJxkdUT($yArcGCJoh%y>pF-W?@zf%p~YpL^WtfPPiMX8ey=JPN>DjW)e^&0 zC2&=ncGDt27#Oj6v^*s>(#b;h^^f7Q5`B}ZvSKUl7e)0f!z^dh-(NaO)RmRRwUr-} zLx>I~U1YH!dT2TgYX#w)Q(>YPO#%1Ou;A{_@3=5tj8%Fuz*8}8l>zc-tx@p6IY=-p zX-D@p(>P3dELDaUB9(Xp8jb@DGOST**~mwJrya2re-i!FD&BA))09!Icx_CqRT+jx z!Agr`PN-oPTL##942CV)^g2#m=wgVp+>;D0rCNqiMt>FvnX3aG`xQ8{D8Uak>%d^9 z6HeO6vn?u%ayUW zZ>}fo^(33nxKm-C57UC)v3akUK!L*dVWu>`k4onB$%6`?W*mqhWxLLvIFBxZLgI;zG)CB&Lt%opi7Fw^X)4@ z&_SkXe=9@5+}2=bQHM?D=J`!AAcCx^5F9mxW_{dj!AV(;?%EQ$e@08Fc!n^%f2PH< zB+rrf=#^T!?v^z2R+n5G z4rq9*xX7-hl;(iMZS7`TrUf7*+QdpiVpc4>9U|`BXZPmzZ0a4?B}_f}%Q|JO%%8V; zw9F)dXt~W{nqkias;5Yc$9MQ{V_^%nZn#p8fez7`*gT54TwLo$Ou4s+*ek3^R{Bh^ z*OP)H%EMzzRpz31N(MPDA>% z3^NA@-5CZVfVs0$^CoF=F%7$jo?03IG^B*_#NWSWQ4eB7yR;5YK#EQw)N9F3e}cWl z0RgsR?>rN@lexi4BP0j+H2l$CL_5WXfEz$l{W^>s;iIWnsIW5i?{xtllo_>Kce)sd zTHD=vtnP%uT(DtmCXO>pIZwHAgS*5`(K(Z(4J~pZzgjUa2@S-dKIA8;GwySBnnV4q z;#s9we8CrQ@Gm~;`t@)Aydwv!Q0%`6Ssv3?@DKgHp`2+8BF@4+<|XJkq6k<#=kXPC zIfRz?UTp*1JOb%0T!ck^l$!m8w@?J#{7;R+_W!T!7&$oD|F;^W1xvbu-8 zhy#6ffD>@oH5=do@N#|(zQ)j2MXAonue87(X?R8SCu(l)u^ezd zP{j2sHUrnp)0T`f>R>!>ePX8~fr zWNnjRF#+fvprD#lF^58o0)riZicj!%XRL`fz(Xne*&osRA&d@a@#bkqcOdr@ZUE|= zYEVmtu9-D;@vy+|aRKw~xacXtSlI;aX(8HYFO~yHTHPF7Way5#x@CsK>_WycC0@+S zIpJ#Oh!i|5WEiS32{`LX3p!1^dD@QpALVjc*O3^-_H{V29g=58ioaiLP7par;3PLj zYSo3h?*YYIFCeo|kbii&%^SAVl>8PJ4jr4@t5gkXoR6?#mhSn-xS|y~AsdHd!U3!m9D0rZ zIUFDJ8J%pqod}MsLH2k)>>)j38wyzl+2*JMrIdD7QVEo^fo`Wx9u$4{?*1`Lz}4qw zmLLwv`DhR9S~*}cCt=2sh#)lNmilM%*Mrg~aqC{xLo9wMeuE zD^@u9KJOzVY93KvG~&xFK?&zDvWMrM+i29gP44|Bas3O27haRxl1i(Z0zr%&STGaq{C8#mJB9mB-szeme!|{o8P@)4W5oz&@m=&F$xWiA_685xx zaj8-sT+i@$tW~>7@BoQrEdi`^-X!h)x!6O7EzI6q zXt<*Kb>lfVRM`UE8h}GdO8BK`>?-``1cL8+TLH1Pmodz#@P9e5n7urEly%1>jU z98%=afQ9x0?u&kgD0TS{;r%>U3Gv15taQAk7ns4KfHg{p0`0${{?_7yql0ZIPi5<= zi!q+vqClZWs!oovY5hY%Vm1pa65>e29aQ%AwYUN#@VV>7=8)W(q z^*zk-5F;jOpq0XLN*mpz?^mUa4Oqc66q6y$3UW`l7MJTF;SUOvIVsUewl+I!ycb8D zUx!5Ds^&Y@EU0#HymB+#pHG2n76v_cKglx{D>9Mnwt$8d86Lis#_6)E5A7p6PX2X` z=p`*ZM|+So2s$vMxg4;}mL8I!CK`zahe;(;FnJ3h67}Av2O}^9T{q&BZGVZ>gorq|x5L=xM5b?C4cNgLP(Pn%(9MlUCa z&Yf+vbE+m6xAayJtEJC~MP#iq06-@(STq0gTx)*Z!r(5|uDePmZj1W>b>7c-b`@QZ zRO2kJ2p((tCneL>NGyug82?R|^f2=$9(xWPf_tl+6v zNU20jgUCNo6y}R{R`9+iX&AjfiHsL+e%hJ=?oX1I5-5tO7*Wp1I3AGF7+r2Qanipp zWhJSCIgciA@@`~7;k(m=p%3VNKO?E>kHncPp!9D{i=6|+Wh60^BVZ9WxRS#f{~$B< ztGESwpv*iSx0n*^Dgd!=YQq7h{n~@T2!1Wsg5~PXA$-tR7hg8)2#92Z;y8kW;^rBO zZcI8(3EUxPwSc*rhn#DN^D!`HJ95AWSsGFYUdpH{iHpz~NykQyYt!ebT((Slr3vtR zaM7D?)V)kdCa01(oaB$Dtu6Px!W>_t27pc_#6uDSe1YJBD{Yxx`y}<7fp3eAAMD3G zQBS~x`zwJ?LdZQm{uCB;@&^b{55KaBg@AmPoBU7!Z*5}A5cEz zj3?krvle>n1+Qfwf2gq;_jE7RQoX?+zl49|@w%rX9M)W^j&{85qj%d-pYY0~P1 z2#35*Viw-bs%}J2*S-}Rb>EZFco7=uQU#kddUVQz7I zdTum6!6N2Op>6&x+%&6d)SU36NfWlclHzFHnPpiT{3cs}Z3*)ISbBBq!KD+sK%C5~ zT}yDl`-=%-xXSw0Bl$@d)4}qJF|2ChmocaN?I4rskMwiaQ|G-SxAr+oRhEy~6K1B8+%%ir&JEl*gM%*HoBgs&51+8?a#pEt-{Xx- zNu%t8(50tsx$^mqU;FPv@cyy&Y`WJatb0tdJI9^3PRy|3`6+e)o$g#GV-=5G2dL(_ z8D#g`HGkMY)MAkc#`e^JGg7X^0ee$DyV6K&BlP6O9(mYeigfd&m1(13ziHE>wBkm* zjl8V+a0^Rv=rxzp&3NK*bd6~slwQBPjw;A)86w3?O)XZtg7bm6B1pMt6%z93KOPAd zt&W`sN_aSRD|_MzPn#|H8E86@MQOgOz(({j?jDN#!;tEQZpc(~JML!vQ5Aql?q2^$ zAiA7-;+&wJ~ zV1Izaae&=*fjNnD5`x76*^}1r1BO!zcnD}2uAn;F|8P3mXTpt8&BMYi=xgVpoVP@` z@QD!3hY{$r0UwV@EP61#X|$DKZn)c4k_|--V}~kS<$zPM6D_%yT(GG?@CH{^DKc0< zw+26m9wKlmRYlIGnXD~62!~x%;D$ZTcl3#~TUSHHO=-ZfFgy+2*`UW|i^iVySu{33 z9w=cj2g=TCjlys5INhYi;Pc05fz@FisF)9vg0gcybisP|GqZF?bOqXRqr4;5_dA_v z`MtL%{9*UN(ff#bu=E5myorKOyJ=)bu%~~e74s9X{B-STeZ_ErsjW{I%0Wv}JU1H{ z>U3X%OW$Ld;!3|}3pwW2o%R+41+WenCt3l6Ia_j2y{;L`h-ej;JxTO9emZtsp=fM$ z-&ddn2lhI$CMxt6at3|oMOMX%hxxFo87LCDN$*Xg^|M^ev4KttMhDTc`XSYD01W$$ zU?S%EoMPXc+cs}=DBfCx0e~Ymq)fXYk~NJjJer^aWJ9*RG+#-}2Hv3= z$Lw~t=^y1gKsZi~>BE&Y$_X*>BkoCFZq#YAPG`lLQY_zQIcs~YSYtfk`Ea8`uvNA( zFnSS<5LY0WL@v*YhxfLNjOF}72lFIAL;?i?;xS0+Fw^W=?$d_GZT)fLWn+~Xk>pqb zjbfY-jds#7HVB8YcgND)j2w2N_W&}mP=P<_{1dI{%y6S4_9{wfU>HiOK!L`&xGartR**g4wlgkH7!{2u zda=l6o)}ZTb>DHoxik8u2<1Q8Fph+Qh|#wcCdsGqgmDP8Xea7ox$k)6B!<}Qc2P&V zjwp_nrTP;#Qi$eM8!rJ8F1czkNB`+`=QN`Mz15>YSXpN4lPg(94rovh5YiI)v%NXs zblf@9YKNp`1TOSLYuBx_g9InV#Y4UvpGHey(Uka~J;CdR9dJsaI_V1wE)J!BeK^8< zPkTTx08zQ=-v5*>QeEH27IX>Q-ixE}PLfyw(wvVwn>pkDkdxz{bo>7NLeE)8R-_iJ z9KT}6JeZV2tY=+6Q7wn1rX0K&nD&P1gA2-}b{qOoPq(mm0=C1IKaaz~Mfpz;A)T##sU+WbZGsA>hbwGNXtV*aRS^k#U7444UcrKjh& zkkKx_nD~w}c|APEHfCN8A$^BNMEfnfV5uUQhg85s6W2N>(RGWSJT7CO0~tW&7!}3N zaWsS4zEn6GuiW{H$i;1!>(US71)-uLN%L9v>yCLs&KgscAPqbJQ<0ao&NS{) z&%JGV?cA#b?{F<>PQ#KWT7lYUC~kbd7l40G5(u7_16P%m$$YB8mh;d$H<1~hw^ZF$ zHrV^4)2Hi`%=UtvUYQw6`}^NOIHdIC%d<3#tMs9BBthCd>Wr+n$h=Rke5`^D!{d0ib=?*8L+e>lRXf#l9&X5 z5-SU-%?(hNhfDPxXM&9R4`$R)9=`PL3V%AB-Z{3ThmG$+>FY0|pj+ZRr_1Md9^Jd} zfGc1G=OR~ZH8@m&*~E`7r-83}H*ap>t$y-2N59yfEwVG{&0;~8Nytus&|6C4o3gI3zrO9hTeX0yfRRD|2t0&GtSR3Yu14qD5*p0(3~<{iaVX6 znHz++_3#kmjE=cSRLyoPWKRTjt7OBw=sAJs^IsfmI#7I%e+IKKI?=PZ`*PjbDn@$i zzEbZwr3aUyv#GZYF%8qcUJYO3XVdp6NwwgG6>Fx}fD2G*QVT}7Sw4^O2qUe{beV;S z0k4)5)nBIOPE++Al}uHk$1{9IRx4UI?dd1j1tLTLwrPn_#RwkmI#S8{_a?4vr zDbTv_2d5J5G?`uB>(>+lZ=hV(LIt!U=I*#Q#xkcc6XTkm<1TCd<>`n5UXCAr z{QFp8`Nz{(iFQ-dsBuGH*R@}NcP3S}v{Oe7Z_}}&YOg(lqF`nwS|E1v)F9EJ-Vbty zTFW)v@W)s0GeiB{P>|RAIidi{ z-r0z)VG(>Xpdsl;iIaN?j-s=GM*n%)ewlZu8Lw+fp;KeEF=M4_Z}3%%rvL%^x%Tr` z|7J%~aO0WlA6^t!T@CLzR>jz{%cpy3qeLwbT+cUXaNarc$#v`qcV)Q1PThegT|iYQ z{4e#hhi_lo^*@C+%m3eSXJBFe-wk(lskn{*%gB%e*9#^fQ#>sf%FF`*&M%6)5qUALMmdT1s=(uxV(=wpisMeC1TgaG-0J6Uz`Af$I5f zcI$pM==f-s*keV_i#x$nBTYFgvs7ipQLh7jxeOvI9L{weSQ1t^qFVv+%@7 zKt?tMQw5YMV?Nd0g}+{ZwkVSdQpUy&Tx7@=FFw{FBfCg`zi1U^$qcK14!5+_`)xeO zTF<7JUKnH!!3m?obuq2m^XIDQ^`LYHvP+R=9=C{*ONg4sg-mq*Hf7#7I;st zzC)MYRsexlJ@lB<{f-pdI^h* z`xaJV-FFDs&5b*MNdFq|0;>e`l#ndA=htB!k-tzVCJDua^t?TUR8sST)5Klpp?4A% zkkLxn*CKkw7zEJ-;@HLfHc+BFYmUri@Lgwn62`imhDdeac_ zX$gB5Ai7Q2mP%g=xoWcoTp9h-yf06h?l5Bq4j5hE*z;dU`l2Vy+6RW)4eH3SwU`p5Rgz+q?{y)>EFZYn>6=vAg0&pVUutOsDV7=fh0h5l2FZN z;F?VExq2O^aSmrY3=}uI8ttC^g;cy8|Ml!x zJ*Tn|Bcqrwo7d$}=p>ZlpH3*FMxeyz9qsw*JNl_0gPN3nh*tFXcO{!y6j7k6U_-ZI zSwf=)=hlLIYGC{2myD~yuq!O{!gFHg{T1F}!=>JrG0NH-0i|rByQY_|u7#v`G>04G&8(J_h$#wkJ2@(A^?ub3pc$ew~CyXBX?4pgat;?hG)jP1Vki$B>j56usw zTUMKei){@oWR{pAIoqL(HI>K(GnL=3r)ghgkm+) z@IuvFu+DK3Q$t_h?!*{3?VlaAbvk`qEx*=oUs8sJ-&n zyjtKmtK6>5Tkdklzk|S@IE41f#PMplKCuNH2#gKBGY*jpF2613IW5pjZaPHFI!lW0 zgbGuBe1Gpli7(b`?q3W-s_sft0RCon@OdKx$VkW^Ry|1%$QK%{7#c?Mb&1s89r793a;#-ZH-3P@2uw(!?V|I zx5u+_&}DRDc{s$$Z;aV+r7a`KUkFTm9ANS86i12vq2423OAb^BYG%eCvY(em$1S(4d^o_~N?oY23oA zfc;1vP?yj3)O}KRO#yYFRegy`hf)wUf8QP^B$3xSefe0*2x1$_DRpPIn756;XrAkN zhd0qHhzUGtSPjN-fj*2WX$0lh(u+l)rh1pLf?3a`_%%Gi^-d}PM_ZG<+|6pC>BMv& z=xQU2S$|sIlaiX0CC#Lz{`4YPbg!=974ADlx{oSLN+_V;dy^oWqP#tq<-!W_u%f+g zRahDA#N4@;_T=Vt-@=fKDY^aUOZ%_BK1PQBy<$Yu%5GyA@#|Wz4;55$OE}BNK|;3) z5SuT#$>m_(GVpg*joi@$p+r2S82jVK?hn~-lleOi*Pq9qU47)xevcxvY8+Z1chl*kK00u@WAHdx z3@1TkNXqQD`8@&wK+;$U3c^*VD&R{n~@#z{keEL zBvA+s(L{5SLP-=w-CmAL6NvOiY;lZ1T}7hGl0}-#2CH4m;tSN8#`Cej#9xSFZ5gd~ zL=%5TZ0l`?qqwDIs~VVAS|}>@ zi_uG_cTim#%}bvGABxQvHi@W2tPp+L1wXP$V7^=@C5BW}W+QUL(vT9rW?Z@&e1;D-OvQI%wA{|G0`<4Z6@Fj$(3>l?oEGVa^8myn21c0^_mk? zP3l|n_tk6X$goOra`~)SCm1^xA#Pl%iICpH-cg??MV^^4hUYP%4TVNXE7i(%DrM=c z7KFWIm3%VAiAv}9z{H~@z1n>xAFigZZ!^}OC>!o7jZ!Ot!&|L1R1yl>HEfEIu1HDj zZ3TsqoGLjJOgK<8(S;dmGnP+nwWT_06n>U3b2g9XFh6zV#^*&aTte$j)lA@qM}Re) zau@euRYU>VXSaj(sVmd|sV>t2}j;N+@Mm?^@k7nY+5I*Zr-f;fPg=s9~G} zD8nA1T0iOC(Kb9AtAA_+@q?w|Bs=#OL>KA_!Ykx&Se9}j;1|t*w+a#C8}j#^bh%2G zivo>)i_@Z4V3|bnXW~yh+PQ*K!^jCLX%D;WfI%36i+gpzo%Us^{2OS4`MNr z5mnens}$Txhl1xA`&^mX(tgJhRGA*o5r8^>(Y89rgF?`6&+&Ul5% zgI@X3Um927qdZ=oT1l0basCA(#Nl;7mnJcZCI|vFFePqau-MIvgI9VN zu(W-ng_k^teyt2Dr-=vsallF zs|mV}OeT5BpGKz}a;fdq1W~~4pYlT|m`PY1`OP5`9y4a|5x4v&92r{$bU!|_@-&WF z&MGIgox*gi94&%=%_Y>q-(-V1?xy7pF;%UKw3jFt*U$YNo<_R&x0;P-N1p`qBJSe- zP4t*A7x$mX7Qj5NW*KRNAgI|GderuS=%H3gC_!zbo*}dr>Ru^zx}d902Jb zY@EQYd;>SW2}{AL#WyxzFKX3eCqLJaxYvalgH%IT; z3+v0e+r9Ab=Lb>v&<|jl8;t|Y>w#wmeFGP!cf)z?Iz=HUz-FJGd)sy9my9n4OvR7U zkuir=wMU~G5y(XRo8A)sLy-7-M+k)`#RRIJ2pvQmd%31!2%C=W3w2y$$klM;k-6wVlv;`qCIqXy!$wYeO)YFk~3M_>z6z>%tm zy3f%>Y?^%Bf}oj#Mt&UFnCVZ{vz!P!0CY{#%%uC7%9aYQ7=6mO)(XfeqHnEs>^cKC zLIt(HI_igK%NxqlYfyp-1SKDY;yHRhE*U4O|5UE&-#x$I&G{+byBUf#u~gw3nT46y zsMQgj9Q7xJ$OM*@AA?@D4|XV1S(Vm3gi0#f!`&gnv&i_*W_UCrdkg~(PT*xNxff5~ z$hR2M(3p%YKICO8Ka``4#2W>PV$~804hW#xyprcR@+ZY%Pgy>+9jd&fQ`$s6K!QhC${>F_aI|V-%Pu7C69E?qT?S zCmC+d*gILb_XIiOstbOI06l|volFUo_^i~Tr$YGf=O2-<9o* zGK4of>>247lhlgj5@Z=}3^P<500UAV%C5$RCiG{PX)lBGu!{z!h;&Ryc3>jTIT^|e z{-Y|eXW~BrN`J2QmK+iM@#ZHwyQe_g!dM@kGwLtx-LlW=T@3aKdHY4+wUjyt^P3oH zmvB^Bsi^ogrTxo6v_!;|jc>efKmpWp&|RVQYc*}+^9j@}5s09FnwKqK z+LQvhl8m9<}lpRtLlQGxKTlFxE~_*=<9P?`;M1W`phKcYovBPMx~4WWH6oW07g zGpBD;8_}8Te7IS7z>9W3GFfHljpC*GU=&dS=; zLH|1RFi)E*>`10nnS=GRKgXslmqyyg5itNd>2ag>S>w8)>?5n&mwYVia(DS0u+-wC zZ}L2m_Pb4QPP*pGsgH0Qs*yBzttkNVf|ls zEv_^#{vTB5=a<^BG6rsmDS!`{SV%V}qwBgMQCoAhIVqDlCQnRVzenXg==$@1z26u1 zcd`Dc<6<+17oyj&twWs}m9Iv)x>=<9APDUQJc?-eZ+vj~h1Llg>H`oWbq2~U$sR%D zG}1-R*VYSJV;dIrm72-sQK7k+(@gAo6E!Z?d&Q{mA_U8Agb;g40hgEG_dwspLy#Oe zta(wY5hyLhF>!tX$_e<*wh|TKI~*zrwYFwjBGtdvo?zC-X;@$0{Pp>65?FM}hzlm~ zaksyiq_*&KVa*)b^w%A&?8P#QuD%y2zg2t0DaBaH0P|JD)pHqsw;~9lT9| zuyN|~1lPWwF4iu+G7Xa)b5TeWp^7Y?ThF4+<;bmmD-w0+ifwGN3_gAvnJn3z zr=5r57;xAiv8ZU(OZ`(9o3l$nmJSb8Ae7NsXWqfGa)V^664{srYoh) zKpa(r@R5~vyi#Y;B%4mvLf~_Ns$;3bb_My8@X#q~>WkzK$F!|LO7L1=^dGNA zFP35dfpWbK%)zE1KZp$j$Ba-d-Yr>aOKKhkk>In#Zg%GtVB3z0dZd?8Y+(eN1q;ypZH9^wkg}y5%KH|lIWf%B!N0z2Jiz6w=n{uWtEY#S`#g#a@*dfJGkco z4jA$(CynJ<$OMeA>6Y+m23aE2vs+{kRRAj0QL)KSo(U8vQ-(Sw#tX-5ja@zx5Nle) z2@E>@q?e08PQl(0eFXf4E!T#R?nOGfXD^bMz|Y*98{uSNfw8kE6oJ!95p$>(3(kce z&j3|22xNs@h)H8UBE2y=+?2%DBfiF~lDiAAl8;s`(7XqfPnrwn$3WY+O{?WyVOrX) z?mA|enWV9_baW9BC8Br{pqyrgEBm~%nOI%4LhSyNZnkg0qOvOg~ z63vg0@)%OsIk~j+(%_qhO2>wCk)lg>Q@+MH=#yu*;)!w4IFGWjm4IATs5oZqDbBxonum*t$#D6ZY zPHC%^|4EAa8@+C3+U584u#I0Mhh57zc$e#9t0I|}ITO zhw`3>FN)G~++xTDp0Qqk(m+3~t%SaiB1nQa+O8WDq7=ZSrvA->B9v|?JqCXlLI@)w zTpATVTZyQ%f#yfYsgo-cRp2YPcSvqdMw1930=aftdFL9k+Dyk*!7!9e6t(>-zLAdU zm5~#rUDdv=LKZz?IczVB3QkaGLZgW0A)uz`o7y9NO33;>tv}v-fxxTsBq|K6vs_sa zJO`&`3N4uZbFjlMJ$?O5s?yP|2=1wq2lSB)=?(?$B#Oe(r0D?b(iUL4Y+)ReS}E>K zoE*DoTm5PP<@B%Y7%QZWAYH{^ItTSw8xrgCv>#iS3zN74$rl#nWo##xLUZn@mMLJQ z-eWu`o@pHB!Orky@*Gp{vpfIDIuYcMDo_#t41TbLqJ&sSH^O+N+BNUPF{#ck%=^Wcro)(?IYcj@A_ zA|tTxr0kKhRX$Hxc*2jU=BJ2Xt$>K3dmtzWUrDgnKN!&1n|sb5dlzwF)nP53ZXYoj z87Flfz7icoiF~sRP`bp=x~t87%l4;s=)iu-`)Nnh_WKS@*dAaemMd_+v2AAH%ukB? z`fYcWR}NH3&R?Ymcn3h=`9D?IejT&+urHbzUlAn zn=r4hlbVZQ^221VFrtyN*cqTf!4(c{PO%&`x*cb)ML15m2lv#-zvs`LvdUxJ9cG6& z!i0s2>AkH*0&_BRoJb24U%u829xzgJ;`w46dR0enCYZ-gUV->&ZO#I_oOk^RCjxYW8lCZuPs^xH zTz|Eqdo((TPO5=hV0lbjn>X^XX5|O0S6J{wczX*}VM5W%1)6bld6-s;P|C$FDBLoj3JtM$n8w@@QQS`ElZuS4@ZVp1Nciqt$Q)MnP2<^!{ju}!K+VzffgNYK zURLky>-vG|TE-IRX&jiXeqoN%h*{=xwDZ8F*BKY zAH;4Cs7-l?MN22|-@mY&_|ZqQsgQ8&KmyvyLB`D?qF^>?yOeNPTV{e|Fct^-`(94gc1_ytnHU7n!FjtNlae9eBVSBI1KD^~_j` z2l&g5Y$9?Km&jd-o4Y}qRWgHEV4nhq{wE_UBZP};2rI+H@Rg9R3S5N&3Cm%o0N#(> zf-v?k)f1TqpNsWNx&xG&{==j)d1TxAuZ&3g|_4j&yHH2x)#oPlFR z%uQ6{j6%Q3Vl~6QNqD7s7Xv&R3DgS2Nx4|BV^y}GTAQd!eizV0dSA^0D{-DyC_J12 z?y{vnxNYS~qC>u}pKT5bY*)9fw3Q(nr=8HfY*qs-Qq`h8iUd&0tSrr(2^Um>NyV#4 zCfJHrnwIt^A>OJyoy+{irTARMRWu)8 zq9oV4Qp)Wu0XdVRZ35ZCw!{(i zGNmur0ozsuX@Lwnug~*p#<5`+N%Sz}ws%1i__238c=?L;NRC4;5Yq5VE3Ev1;oveK z+%iT~8ge531-iwKP`_CUkvY!tLA`=cdqzx}nsqs_D)pnMaO`iy1bt>6=r_-bIZIV( ziGi0jM3OOLZ9r^9H?>rAfU*{kRhCp$)ev1Cc6JIpV_|`SuP{U8g3p7>b=4c(mL60! zk2rH`TC?MJDtoWt*TAO{Ne|pOAN_rrT^8~ahuazp!5DCl%@_&N8hjOt(`>KJ_u{R7 z7r`yde7Vg_R+yQlWLHWi(<=OQ*~Bf-D(PfH?8a(Nwxj47P}tt0Jre2*?JV(@dc!H@ z-k?1KzJwEzdP}|MlJ>BhP}nX(u%Xyd^bMn!`6uPUdY`_d*j@4otF*mCdi0er!vSlD za5ORP53?{ksFcv^6!aMbIHAa|M+@3 zDe8J!@6~w@&dKe2gPXx5ekk+kRQ|RG21AF2wK>4Bm1nmm#x6;r2H$D^(BCvmNI{iW12x z2@N1sliH1KUuu^a;m)7c-7`ux%rs9M$sEZa%Z+Rasu~3fy9J#Ir8wdv{_AgL6^XedhL8^u&b8Y`N`H5Aw=P-YG}&r`t0O?{Y}M}9J{>~ESLH{9uyleV27 zZ;c?07MDcgeLK25+P<{DIlu+BWY!lL1gs}UhzWdiycwWlRtNYr;g1mC-%Z+ThAxiX z%K$I);=5LuvG^c{MlT7r3MgZSTCTH)a-Sa?CPq+nLWUh%2p7lTXhSFKXMD4#>?OX!@CQ@EO%lHAKF@$qyKp2# z&e!SnfCA(+6bJWbLyC3Q7Zj44?7z5Jyb*ucG<-iS6~|ZD>(0_Kt2*PBi=xT~jznZ& z!0`2p6wBQY4ugvO1~V|-k|*C$_D<@NiFv^ENLJrhbOBhqO$IaEjx^SijOZdtsw_+QOTt|j#v~QeGE3mV;tzy**`(G0-?9i5?J1)kQH8YJ1n7oNHat2iM1}Z&Bv|nW!`v;kmd7 zJy@cgIkx>l<@gamY5t_-RAr}Tn9q$6C-lzFO_dU^F;UlTFDoh)X{BEAJwtMrk41gI zJjUPakFn)K2KdK`+?&%6$n<)!NvFr0{h# zLyWbn2tl1BsS~`+hv2`pNi5cII_VPpG(7*`a%u z%0i_19cHFxap5FU2-^HCF`_->rg#*4H6xP(2laQ}q_g)-FknO=b#GPvLqFCtW^Y3q zsHsnnOh4={y}{~fUDbPqI^gN0GmtPsJJP8Z z`*x6guyR%_%Ua$Eb+G=~Ry)Y1ks{#LBn7h^+jxSsV_*e%HDk7sw2EnwB^u)+8R`Q~ zOULGsQ$5QIq1TFvWv;eM5s%tOX+2XO<06O)FSPM!(#@))f0|*tiGz*1-69K^W|X_2^)zpFo_bZL zH0Oi5fU@sLUZtR`6IDDuKp0~c`w>vKRMwU3VQn$ z^ajvh)K4RUJb=%u6I4`~5{Cpw6!pUfX9$%UJo$>)4x$Bqy`TuEjYAsbvh>RLC117S z?WfB-tuGFcU9OOxYyUvx0^u5H^y_y?fjz?C<9dlC0%WgsDea!Bx*OAfL9OF&XW^GJ zQguGETdVpe5in9&PPeW+gda3YLlq@1qS(Jkb*)LlDuKT`@e|aEfQQ9OY^+hq4AjZ` zBk2XxS3Ya`|6=$R6cH;wUDnu&fN<7;B8c}xb@3b>tHex_#kX2+^~67UfDos)Kh=SN z!>cD|m1EYy4h8m5=N2D$2XP96gjVfstU}9j4gRkGiCKRMxN2*1D|l%2NR$$2dVTj$ zjH2-nu5!SgdsoG^5J0E6Dvn7*736YmB6?}QKm4im<~kZXyf~4d0rOCtaL5h5oJ$CZ zSdi7DD+gOUl%V;}=9aMej;Cc(Ck7sE;T~gv1JctQPvVYWwT^GG1VI9gZ*BMC+{H(8L^U=5PYcnPjRRD{z0{-o0-bJ<9%| zK!tbE>>eb;-_P#8h>f8Ce7U6WWvslk z%5r8A-|lZ~FO^(}?zt^&&sR5W{=H*bbGEr(^f4OXZK-5^#{5He#WKJ9i)+eIsO?y# zR)g6O3F8Ru*>a>9FfxZ+=X~D3>UbD%tKG@P!^WGQj?3%H#>uwnO2+VB!q|q5{i))Y zn7#Uq&DnqK-~xmk2G@V*>={>@IPTDWxECOa7$irpeZigQ|t+$PbX(+spM<}NhgcXKu`bwb~PQHobfqW7$NDTO>E7a&G8vnS^j5xVoO8D z4vP)G>q6~z6?^b#WHO#Q8bCI%2~d-{PAR|I0J))fP}GPb-kA97#Ybq(Ts5(JYW%t& zjQ#NX!2Wn@1hyic8^cTxa@w5~2Ly>7ef+gYnEQ5UP<@A(dx{gENY}ZSG>wyd_(S^wYqQPjm z0wWlIf)Y)g4Y8t=fWGnkSH3QC1!J9n>#9EvnEEs&RgjOVwMH+m(T2J(iV?$Mwq=0X zVO7^YbO1C?LP0vd6abM4f-6EFn5=uVE88JF_)}KlAQg{%IwJK+F>v~jJ#q;qy*>32 zrEW+{xn*&FZiqSv1Q)j%2!uB{&@TCFjji$`&p0fr*{cW|kRA)QWP+N|qDLj6sAZ#K zUc-7muatZ^36%#&B}zLXkt`zzku1uTFTRTrObAFmws>;b$^o+Uz&{A)6uB|PX$FFQ)GCef1c^zAa9G8}OXYPE(*wPi*%G=3%tCF! zv%dqlKhEkJz8XGaK;W;l5g(B+8&p&z@Zia-l~F{r(78-KE-q>&>m1rS_qEK_x>W^d zYleBQzwZi`3IE5930+z|;R%``+RcqI;XYj=hsTfCe4F<8VBu^$JLCAOYNgbJ?W=+D z1h`XiYWwTUA`-0#Zb9GyQB&5es)ST-$#6DXI_)8A$h}=#E$#jC?Xnn1{vWmC4@;v#U*AK>uN3>9Y3t^|Ug_LwjW3T!(NA}Wb~P_ek6q?W9^b~?(_rk$%9Oi}Hxq^qoBOh~*_1JFcblqU=8!pK z&P-_4*{frC*~GDBi#CmI<>sDaJ7z5E!30&O?iO{aznp0iySA?3lHn`7^Q*5X12pX* zU(Oe^#}9Pz;{j;Nm?dbh+7hZgc2Xnk5*cU1+QLs{rpt0k%~^)#S;bj9nlNF@ZdN-Q zIyy5^%LlPnhjWWkkBT@RNx`o=%$c2gqKk9OygBLt?Tq_@k>_7T>`o6`SSP&i!(4am zRYPg!J8B4W326AJA8qPI7q8tyn_32a{2hH` z-dAn~HEf%8SEDB_i3LLw$#5d}GtA?=Fz%4W@ce~wFq=@1dfSb@1t6gx#bnQ>xnaB| z=jeCt3WDWlROhpG^B`pNZ9`>gN!Q-d@#NyTvSpby<2fR*&Dm8?ZY%=VdTCPtvFTuP zwaCmjxibX=@ng$T?Njo^9?QdowMFDM1$sTtW9vU!;05i$M;~hK6Z;VWh*TRdfz%3gIDh);-&4}fc5BW2Skd}hohjWBa!#~z^3}VW1;6LmbKkWl!$V(Q z_-Mi4+EprDEh1_c(3s4W^wpco!3b3e%5^V?W zBE}8{W7p-WUgQt^LeI5cB+sc6&#URhO%9W`@TGM_e$NN=-xw~x53*}O#nRD~Sl0mG z+mYGVgOO96XOeb%Gi#BIOapK~D696*Rt?dYiIIegN~=FMnrAwz$GKN-&$k`wT%Ev} z-9@p4fAA%mzU?mGUK2D5T|3zgq_WF~z{C|uSS~Ql56BO2sa`+Ne*`&B#{a6ZGcq&( zZ)@yT>i>_}?N(V3M4gsOxh9{_rhdaNh*War+7cD4esERz$>FK?;QJkcD{*Cc{fvB6 ztk7I?nj_X;Qd~XcuYfrNdP9ysMi410^j91$f5Irm-{>+~Fs;MGzBcct?Wa#lH@kG3 zQq`>v{oO*}xkU}i9*rVto=^dzBUR?)*Xxm?i?u7`=b7kWB5_W9TFXJ=c(n#VZ1f?a zzZ~W-DOopjH8E4n0nPZg%NeW&LPV0IfWJxtXkHqlQm~N}{T~u7oF!67uLTB~O60_k zQ6H*`mWF;kc=x;D(OmA%D;CpDf1+2;Yp55tLy1O8OSLar#5NW&h3GchaY5G5&+1k2 zBKd0rx~R_gU}aySS#QJe$RdzuQh_UxH6jO{5Oa>MuNa5qf{OUH`}|} z5d|i>41qj*aU!utHnW?Smes7Ais~kFd#e8KW@lK+GjF;Z679PW9$$azI3+mTg=*pG|Jn z#j4tAJ~uj05C|^&7u)#--#~e92L*(WV1?S?#C6>tE)-gBstr2ZzF2!ay<>3XH^X~l z32|2z8k)H3_TC(Y2Q;&Xt&Pt)+=ey#f8*ZHX(k6DBH?69T5P$rvwGLqcj}(a+C<6b z(N{TV@=`z6J4P*oa|aB0XzuKmikOmXsn~{Xf4f|;YS2xmn9Utr+E1Y)$>b)8%k#o6 zi|~^iYA12i@JeN}U#%Rca?U>KTxdbDgeK@7i9wjf9l+rEkoe0sem6uES5t7h>*E^+ zodcnAUvPkwiBqC2E*DD->av6CDrE_3(IzRx zQp~vzFF;U@m@tQin*$icz@aMH3L@7Ol9O}($uQ+)7;9$bVdZ#Ar4YF>A z`%Nf*BGz7>VOQv~MYCXtYr{V<{7g?f0#USdRP1_dKi|bV)dRSX2gMn}8t?IHY3=Iy zx%k?L`^A;OYI@g#Y;X!oh#hfb!0wU!l{u0Ksqze)jOmvwy>pWeg*0XizO_Tmmhsf8 z%6VL_kw%oPA1S9cL8G>|dgJ=!DdRzSSh~(?rnOi>L)ttPND75KHEQmSvxK3tB}e>p zY3=>aerqaeLSPJy$Aj=y04aPMj1P4{a_(;cLU|TeE{r3JAT~5kc66O*zvU>D4H+H+*llxU5Q7U_iU5rsP6WF zvy{6ew6De(A8b>aFap1_40ZB88j!Ux33?V#zV3kdulNuam=rxl|$@UTEoQX|C2r49G%7#BY)hJrS3 zn%3ZQ*-`xuMK)@ZRCd?G*NG#xgjl74PfB}GTwKgg>!+)|U)#$HKDeE!s01)*e?Pn= zqju$s-$!tC^6bw=cq?yW0VJC>A4+$K1$X=EN2f$|p&T}SULPf4-o-<$3AEV z(MscH91)k#qw=HPwPRuUmm8aN5uEsjhsy@iiI(yrd|)C0(n`X7JPe427n;k3G~p^y zk>?S^=()6=H^MY z!jVHCnKNJCdXT}dxvf;>5)@%8B2x`0>)*qhy@=dl=(mQA8esBXa91oTbBZ#x{>&Zx z{9g{fyg$qW*9!~0D#KY&2ERuJ#nX45rlwdNq{Klj(mv%mV_WoAU%j>+qsMy)oM$2y zR+{zqio4u{GxEG^92PctJ(F6Rd^1{_z6_6-pXrW!qA7UcGPRU{!?TPj*3p-yN&(W1 zD*Rc>air&Nqg!qtGj0DUNM$t^X|jdF=RM?pVd{q`kga7EqnpX_`Jk3?&HFG;Wavin z6UIsWvEiy&^BSxT4Ks$FA??6}^;n8tp&q6RdG?nyCEN!_&))1@|A$0-7#H8~6x@g~;}J*}W631?4u+YoTUl~c5F<%LUhfv=7V!|j$J zChWa*A;~j=I7uiI0!~#-z)olnGPbg^2Fs-yTBGAx^|ghc;%oJZm()MR_#}Ks#JV@= zqv5LHoyjv}0v$J!*NC%8t)c#6i?`Mr@f4ZTRkHRgpHPBMict}&feJY`v{R{fIF;qa zJsp8dvyJO#a#Kjv0da-Ya6}{{2PPa9+4(G-FR`Fos-j_Df|WyiCxXzGMX7}fXtt>V z`hv6F3lg=4L;a@gpEBR01E!y`jLu;1quX&d1sje<`;&pQ{8*9)isy6Ue_>`G>agVu zz*)P?N#q&yXqJc+)gtL*oY`6G>Tz;xOwHzx zR5SmRgEF)iXk!*}BUla!PuyDOORDHf4CQ#iRi28O`x+nn$F{unqG^HUO+>snQ`Jip z;dltS;&t(>2eiJ2{Ppni@OALv{_=Q)2ENNvDAE8=mjjBU2K1-&dth-&){s%xKVXvc3 zt~>pDF)9dOW^Z8gWGIftcz7uIIwt6(dAL~noS1X*n`?>LiI5N+;v-q8SX+I`{G$J*DfDriV?Hd1dJc=2Uld6-Mtm(t zg|E(q9^Dxy(x{8QF+ekbxp1JIVXIp@p77`p>c?-9zKY2{@Q?%%$1Jw7o%SO2S9OIb z$*m7{;Vp2?eZ+==d}n4Uy7I&IcNZJLE-;|8;6~FGYhy5tD-qkBe=*O>wBsqJy9dSh za$m2?Xz*JtluMitA?40%H?5bb7;F!5apZk=8g#}ikLeK5P;s%gG`9AHM(59+VUUCW z$(^JBjOE*`V^8?~(0d3HB$Dm8;0^T2qn{`u;%=c*vohx;;%==GEaDD$3DDMLa9f}J zcaZdgO3i4VfC3H1DNlUJVdX&7>%&&7w=2Dp`_cvg52oxMJ#5fgXTk-O2zkfaH~Bdy zn4VsB417#2+cUR>eRC&+-BhiAKDiF6q%6x}udwB3tis_`vNn}+uf{G!+sWW0WXCm- zRRwqI!o%^(N~bU`3lSeMa^i-E1P_T3Ai3UheViaso^RR3w_;)&a`)qe!=rTzYpT5W z-4zY26WdVQ!`71D{HO$Up`51@(vw`C*zv%jIPRdj;=6lz1qxlv16?}!@&CB2rI5)z zBvsQ3lOOf5)%^rnDqD>%hQO&Yht8vnUL8a%!SU_Mw(%3P^)aC1S>!r-N!9wthD=9_8D#P3!WD#`AR1<^^caxLL& zYX=v~?Isc}svdZL1KzeO=23A4)>Gp^mDl`*_#PQ9)$IMrvu!At$J3hfIIYbNTl^;O zk9_hSmDrPC>9D|5L^+vuC1xdgd80Yex}a#ScD=}ofrtIc(^Z*I3$Hul+*qAR@z zQSa>-Ru_PX*s3a-5}DgAoq73l@P2#obW-uA_S5u+awCuj#u0;`@MO0I*?%tlOWHRt z=!ANm-n*dUZNDVypTU^uO&4#56Vr0zZ$S_>IzRjp2X7qgrj2n{N}O`psQP5~q1oIm zb6X+y)D~c^s1{}vbom>c9F-@35>*br^wr~6q6n6ARW)N=ZHct1^8p-n%G>)&JUs5% z=%yhD*8xMTuy^us_$k+vq_K5bJ<+tiSn$*B_7M6X5uhy_=T>iwSG9oI_Ks#+zpOA! zZ2;I9+>)AuW-%KOwf-P&c~(mPWt)aYELB8wyx%3yaY>IAg`lwJ7H+73iJ_ zxuCdb3-Su~8wCR;#N1ap@4#q1RM|A5=u&PLh{5vo-E~@C@V>kP1~oP30`7fAVxP4i zJM^4!ySf)(DJ9lv7m$yDZ_8y7t3&9Nx8R@G=f@gPL1D%eW%EDw$4+1rx%>aPz3ye- zFL^9xZb7q4yD5kYN<@DKjH>}VQm1kf>OY$!hf%`%SYsd{ zo8&b|y@pef#is20=sHAiIV*)r=fztiEgLV{v1`@M4UliFG{ocgz=e$_05M^6!3qd7 zy)-4~_ykE<8^s7{fi5SsoJ)O}Puq1NmuU{JW-YRYO}?je?e{|2S!A0~=_H~6)4*QF+rJg#l-#}{PsK97HDXvwfY2nc znCgHwIC!5+g)Z_5)QTjA?1)Y(%G8C^_cs7Jh=4b!O{ZD=0wG76b@*9${fn+*To@2U z>h}QT#OSqW!ja&CSs-Ba$6}IvQiA9PLFkGOQ4Vd#{IUcX2C8YYmTWG=Kf;BYV1Ugx# znrt-1fmO@{IPV>Xb6iyga0~$7Lqi{h3u&HXfy}|2ETfhtAe3-CBf#53Q#Up(8Uib_dlovML>Fk3*rz*zNjDL zWP8?n)u&z!VJ)|%O#C(fUFu3Qjsy|1WG-uL>LG!qVnW0!PACep9;eJ{TJgd$z|Z|X*@Ph-L=W3ZR&ijJl1FO zr{Gk=P)g%*!KvjUJ<8Q`!di)4Z^f7gNu{W!=uef^h%BDpy2dp323m7$D@HBvahyr8 zNdO)&ua$bfB%3#HA(V*!!>zg*)d$mfTJ>9^ihEKaej}kl2DQ|bZWoMR0d7VsvV*^`b z(q)bvo3A>dF7l;os@=;$4_A zQ;ZBMu2c&J_tFBWU#AEVvt&wOw~UqTx?E-Lx>ICjYTQYWYFPRXq zh8)WMMZ(dh+c8UFmpRERX-lZG_rCF=iU_5&1@d4LEN!g2c z@D*X6z+qVgcS7$v)#rWF~acr}BVC-Kf7JSe)s$ z#>}$Wjl=F{)L5jH`~`{Q8LrLf399Vlebk;1zQuOUNs{edLi8RV4EQW%T4dweB7A7s zORoP+?=g<;UbNB=+1tgj6GQb%o_JjLpg}yF*O$lg=k?JURa02#;lTfd?R{PEfmPEZ z!^)x;N|^Tb=x69uKj9|S(;eS`G1A3cUp{AqQL7xR19|hOl`>oUp>dl$)y?=9c6&9P z8=#fJh$8^Uvp2764w(rM&qDAq4~?Z;iC{u_YF*ntNu}?(r--9nw12RZY&D&Aw^Ig= z<$hO!=zhSVoJQ`5NjVC}q%UkzFu-3B}dR6&8`vatQTRq%Qy`GMwP~pbukzvf<0c#2JZ8|oquTy}(>aBq|7W=6 z`hPWS|DT2|7vuk0Exo0+^FOLRzZZi(fOoDrF&L0g(4-uXtG1ZZNRx`%%Cy}2*er_8 zgRoMhB>9xfdQVq}=B-5{*G84|)te9ydeqSVfU!Wp@pjWl*Bi9^Q3fh7*-J=CQ3<$( z5t8S{)!0N%YYXt(3ciIDiswz`^0JB&oY}Rn`~B6}!qV7*h0rb;ZG`DzRW)xC6uR@C zScGX1VB6}T>#-+OR^;dHENaPy>&^1136B^JR+ZFoQWb)+tkH}ZEJlmZfL5bnjSGP@ ztt!k;JkOk4(cQIy!y;D%U3@%Bv=?p4gB`lnpDBl7nnI=T>&=wf^-{o~Gk5%q6zYpX zBkBf&<`nVEzoY1O`@94gv2u-y8O&J8*9qs+OlfYRp9lDw-#v*dzJHzovcv5c$I_v@L}t9a`N?yXR~~TjRqqaL~RaCU;J!nF9Ij?4_D?%$5CqM?ip6Wn}ETV>WSZWF*f5hMyuL?no?!!?T) zeP(Nv^987lhLwq8TNa3An(-)W2?m+x&Yhm#)kWmFmXMh=I9Sv8RKc)}4SKN-irw*| z5c8@sHh^bFkA7&KF(rR+2H{xC9Pq4AS^V^^P#kc;ZFFcaToOJmYj)!h__l#SsE2}1wU_}gew9A^C5xFh?QOU4--6GNiRQ7h7uxD znK1N#L-!Z9+c#fG?HvOla`UB`C0i;5$z%sljd5$4ReVAQa*{{taM1>U$exqm{!(j6=hXXIwkairB>8|=j4WpRZ9Jf9s(%^dS+{CWvzx&dvB*kfeiNfRj z$=9HsHkQRa+&|+m=;H23?cvVw72x4wf*s@&J z`VJ~=c4gj|weTar8hwHsa(RPjXfx2fF9j*27jgE0^EaU*SRpZKF3W?PD2IERwU0G) z>N)cpgL@B=EXl5CoKo_iO>5NBgU@{*Hw))lA~%iA*d;tkDCmfqiJ5PpZIDo+bvW$l z8=2&*B>*CMU=d$Ck7z+G6x6g$Tc;*J8aMIcUWt$dFC4c(CjAV?$pfGtlJAG~b`%h3 z;rM;If8$>t1OPs%SX=O)`uV1ifuBo*xdqWD4nF#RpV8?a+7$=Y(*LB&ArOmaq$vPZK?9+q4E5ar!pDARc{EU>#vSN^BPNou1Q-tKaW9JjIi z$kRFv8KQ2xsqi+WQN0CQHc{!5koA2v7)ILZMCpm_6&cn`*xxIIeDQ}&pmIt=J^5{!rU( z;qsv4<~FZn%Qk*kKZ`-o+DY{9z#F_p*yHSKD{JlD-DVE z-SP1*yjO6Qu-qgJ_Y$-3^Yp4_H5KTK0+i&uZ8*t>jU)A{-@-Kdk3OE!l<9W_)NS}* zOO?B1xo9%pRl;nH1!6cQ^Nh95+F(rQ#ZD-($gz%CDIK*aV)FMl~*Q(O@qos$)$x&_v>~AQ9c`=_d^sm$SLo*=jr&ztQwEY-w|{?U>^pH z!lCIDFL!6A%icHo+sud~wU*JiNhP1Yisfp_iby%3KQ;dbv)5^}5SW8z-bU}(P=nZW zCA7*hjcTdKm-%rXBx!}9_QlTSr4o-cmZQvAr1L9j!+6;;&6N6ECG9*zp%E;*HkaFC ztc74N*2T#T^|SM1&n}_{8EQ6_s|B|SEor+`*3-(wlay+Wl8Vy$AFsXx2R_M6p#Tq4 zF3HX!jRXt4`3XHCHQ0>MytCp};-CkkHv+ZOSt+qw3H2B8J6bLRS)u9ouF<@MPGCX& za6DvU*TBt^X;ui^?;dDX6OMOA{dDP603vWx1Ivbnk%FnxmF<%K;wR`xDBH}~QUjAc z)FEA)dWX=u`VM7CBGQwU#rT!6-}R_cGa?V^C#(lZj`<*go zv&Rf@mGI2Svr5K_V}iB*=xDa#xS2lH%sq=%w=KGr-Aeh=d4cedRDATWw++od6to?& z;`@TIL=|cj&0&pF8b_nEt$lfAQTH!oPIoD5$;q@d3)XD5(#gw|aoMcjF=bCpgv%O< z{dw}$sV6g~fej=Odntm!<4YHwr;p>s&&EZHH!q0unNDGfRb7jvD0j%Dt!|k2K{#w& z-i7pUgL`A%f`2R$`;=+%uVcB42z`m>vqpO^xZq5sOW^#JyN0pCGE1f1ENtk3$gaT1E`vP)yhd&J3l$U%}DwTJuI!iGGW8SOz5yjs0P{VZK< zUu;(cao9S~1fXtG_8L^ZrQ7Q)a=jBw(Cz<jm_ zWQxrvr9?%Ss{iP)0Rp96Id_UEfEAP;t$iQxi`t9f2hQT-$95Fl@ zmgm{8;fHxAWuEvFb>(UA^8EhkVbRCl=dE8^X>^NGJD_$dv4N;PzvjgzRlT1D*ckXeeN`lcu-~K&KQY2i zlx@~ub*xtowXTL0IxMl|gnu(77%@A}+qGqfznPh*@$N8qSF!zR< zm-hmIa9PtI4k=kS@2p#s^7C?~x?Zuv9~#vkVx=y{>1O{em&Q~`kkDcZUrylF^{(m0 zs>rIi)+T|l7}<*YUW)>a*a>yEUpGo0cAs8Y>{-N)7rWybabLy3A1!NLHj zz-icmJm}hcJz87a6-=hJX05*8h`!RfN&m`D*@kJ-=+S+TTDy+%aKDv#nfh%(VPmNJ zQiNDibh&<<<{;31U$e09A_mIP5NF0La(I!PXZM6-K;ATYi(Qx;!~3^hWB76Arr8uD ziqt8Lw^C(IhHI!+S52M??UPbY)v|xbXxzBkirNShMht{a)dhqtkw4UL&Ory8RlHi( zrSi}Lv7_K*L%Ed>$(3G`9yL`Ubb?e}1NzW|nL?|i{^O<~#y;LIJ=Q?s4U%XLs^iaG z9=+u9#6KVq0?JRr?DcWmk3oQK*0N*z_@GxU7qQU~wS?>yfvHT4^BaFaX+;N)Ya!8f zB3}8hv*pM&2TrDZQptXh48STW}E$%WhQJ!Z9*8L54}{SV9gWfyGD7dsM(nhZG%GO&Bt0`_EVk zsAQQ(cfS%+ z+%^X(EWO-V#-qYM<8I|GPF`F2M-Nf+`?Wycvz+VcB!NO9a<#sng=n=CBhhZaWm?hA zSjlWG?`1q57asT2gXqyiTjTKVwNc=->lDHJz)>Fi(Ex2J(oevL6aQxu&wVB*X4s_f z#oc|e%eL~n>|l=a$jl5wLy#6KxLaw>R%ci^N$u&^90MtT(ickL z6`|BN9mv^OH$#O-p!c~J__(w#TWx1HSQ7opZYmpsR$Wbh)VX6~273wp63@~!$XsG| z-$d|srN@>JShzX%3Hyh{Pl;i<7-%RZS|0nHtw1#q-Ovgxx^#36%anaV^`ZX#{UhVA zqAJPAbv$Xyi$>e?a4c;{WPpFzDc+(#^4&*FmL4o}?3I8^bF*0Dw7B4z-Ee{(SEdU` zzEleoc@}YU<1-#Jhl`(F7nf9}RiTYN*ti{+yjzpYxD#?h?E~i8JB9FJ%q@m`%F!J0 zJ6pwEjRi5tj8hP^;clKLU^OAO-z};3JXCg7$XUbIPxsuv<0zR?WWx{J&IChUeuqW-G z$p6d*|7$vtgZ+O!op_}!qp~51)cruy*yLSXam#q~w^VuwLJ}8c6tr{;G>?)9UcAGL zvpx|M;bWskf&^>KV_;yvHtCQsX1(gVrlaQ!i>YsVuy5MK+3Aci zFU~2gpf##>Br{=_3$JtShZ9%n2;sRtSJp)vPQrK>Ln+x#`|ats;VSK#o ztj;YD*ZMoN-~f(GBnc(P$-n*M(D5+~ESDjK{uhRWyen_&mShMi^qVFp9tR5$)qm-) z!+{i|OHGgIq%v{+T1j}@V`Bc91Q(KX9^lgqw$(c#hk1bCpXp~V{O$E{h?65%;;w_9 z6^Vp=AnF4ZU`k6L_F8rXZFQhIS;bO9G?Jz*M=Vp?_M#J&fy`IT23nFnB9xwJTRPXw z2XP$2p;N&Pgj^B%1F2<603y%?n)QxR*KDF=fH@e&xZ9^7!ZYgncK`~JI9wL48zBwz z^cREZnc2}eHN`KXONO0lmv)e7HQEc0JaIaF;jD0{48`hvD$N=7kV(?`5H_#TV=QX2 z))U&D3*zc`XlZC!TMz23@zVRrny~U|3`kYJgG7^xrbkRtc<&@p;c#i(mh2G7!a#{8 z(jq960m*8x{E${c<0fJao4n;w5I|G5F`zemE*YxDW1T%@-V#D=XcAGS-}oTM05Cn_8V z*$!)nu0;k}AhgYWeI-984GXLahCWq?1aEB4R$T%`8!7OE?yLfV+RVCM2sEi*tY5y_ zsrX@M%1rfCtL|$CeR94kit?*!LnUu~H^wf#Q@=IJDpC=O!dTC6lyY2;@3$>goI92Gi+~Z;Fd16Aznm;IdCZR z;nKw#`^Izw;i5r-V1Xew-XGFnGUp6f_R9HgTl++*RL#LlT&poZ>|cKgBsi8(Oi1nj z7_9eI-Uj!~DIenlA-Okztp?Gi9SSkkWD&#QrTG#&b;y}HI5>Y$^!;mS@Rkn`LCN8)Kx`wim?V88k6 zYfErzv`YG0%rLwm~4k5Foe4Qwmqh-?0-;fIt2&}rG;`a_b3303h z`NXpF!76G`_Tb-!V;0C^0})`Q9yGt5x3QTt1SzY8ND```j_~j~Cd8WMC0wVccyrS) z7E4@o)tE$@E2^M8Yg6`WA`M!b9|;MN^0)JJ-|iC%0a@;|>Iw4CzMyx2l2Vm8Qq_AW zdJ@HK$Ia2g;>5Zzu5oI}2+X)5$jXvvr+iQaM1A6>2<2KdbZfdA7#Z<2)YoPM2((rY zifh%4$2yUVzsv<`QGWprEb8vn2|NQa#ZgJyiynO#fITXSCdDYaV-3(*4 zDxJ<%Kd4@Q2)gzjtkTex>oeIaB0d4nd?IJ0sKyI81EW%~Ig8WO@_7jzjQ1-qb42GShs zah0^9IfWu1{ZXfFA~)U|o||8+ucdDfeYKrZnX@^VlcRgIj%Y#P>bL3$u8--m1N_VB zi!xu!%!ilGeV2zAYyj87;N+@Ii0OiYk^PbSWz)lL_n!Er$$NulM}wQ;Wu?4ESm z2eA17ivPh19ZGWCd#W#0Z(CEa5YvY^wx4zdS}Nh~^EEFUg%Q9XSqmi~I4_J46xwOv zALj98e0m+9arMwNv;L(QLoud=y4sQDx4%9`7|KrjkOw`40b?F!EM0wNxEum@cbV!G zh^jg5VBok22mARro6|j3&PnJ!9A%+d>ju=8J*mA4-PeeC?)UI;=IByjpTV!UVJ_?b zwJXhG?tMNZlq@?TOki%5qt4^oCRH6&4T_p_|HL!h|EZst>$$MB+(4(k*6k<0!Qs1s zf1>pJRLN{`+Eu!Bzj`g^`Fyus1MFP_R^J{Nei6q5AcH9hYh4;L&h$!5PR0LZYQH_g{sOQ6K#scG)~>v|ot)hyXppu@>(1!(WfzSwD8Vqt#B zr%sBjBgBiv1{jrPwra&fVDP=RteNh+9~Xww<~;N2;NnOp3v`L3Bj(mW7J|F;>exn_ zbxzo`y(Y1RnMgxQGbkJ=kjMsC!)VU@2*Vx4HLz1LYBn9EkO6fbM>rJ%TY~O=Y$LA~ zcX(bs-iDWom>n4tS|&m~9G54}#|4ssoQq|B$dGKms{jr?tX{O(mH1ISaejG2#oU+7 zM#&2?*skaVPr2$7L-X{$Sj4isR>#Stc}((nc!X9oiDppxM)MHjnI|lIf|uK;55KdA z4uon51RLL5S#EOB!MLBHfh{5+3k4=A)V#{==RL+krNe8#+C;^8#Scn(GY(hg4t>>` z-rL7ZEOkK;$&+r!wt10+I~E+m@Q2ne^3^jLp{c?Qg4c2HO^X7goCW6}(YA`E%xLpL4#>wq{50Q9vi=Mw8TCdFy_gVoz-dYVM|wI4 zzG-QE4=gA=UiR*n9C@lnKW3CNK7<*&hM#d720LgXqY@iq{)(w0MAOW>jbiC`oBhv)4oO!av@2CW;trFQ5NYZvQAJ%JG!t-7d9tR6?$ z7%Kx}cmJ5}udveyuk3X=HCA5H8y1l|ZyuZFPt|aL96J;?xmEa_>Di}gApycB8O4ur z_$9+pQfGN+J7Ur)3{a82L`482hv*G^z9I|HWp_(Fw+$4N9lN~mwvFNpW;B%fbb1xO zsVHwAqY!2trs1LXDoiq>H7A;9Aq69jXMUVx8m;Tlnc`*fjyk6Ti08~hlX6mf~U(gq;%su|dw{0v`Pos&pi&i+LQ4~`#GZxg( zHr&`rGc)w-fDiPSvPQDtgmn;6@nKN!1!9TD3BgSD^v>7E)*H4P3<+7rHixCD=V|2# z<0iVNIZaXV-LNVK36MM5V|X>idgPvT{A?a}$G&CaYPXi|3SHhmzZ&?Wx%T;Lo>7CM zwbDj+&pBe0cSrs!oQS>{YQap`*bo-NDX_xPyabdr{qzn#4;aIxepP*+-TH}us9+70q+ zPDnm3NZm~qCQ+J{uIl4b1MMkLN1|7f8Q?_JSe0(yTY0n@sA9(h*2V3sFW zfsx(7;2QuO3_88LjTH0BZ{=AubFY6mQwH3b%)})DdbOtFy z34!XOR3DXkUOk-c^}&2K3_Gj7fY9}qS~txi^db`^x1vg$>r8PvU#nl6tJ)dW^xjM1 zJS&h-yGM;WItb*z9Pw-69v8_LqC{)N2=OFio8`6Z#wna_>3LV$jitCq!y{RRJH~KZ z87|q=2qTa0(8V-c3zrrtFM&-#q4{s6S}oezY;Wy<(=3ocy64^Jl!H^fzE0Olh z`RVzsh^x?}Lj2D8eT-kB7DACZ_|$bSbKPPVE}Vn@q37M3875}}>XjR&N>_T5`I3=5 z+!GWd!gDL;hcaYREX>p<52#}vY&3vLNeRc?S!Z~&NRReZ3HZi5=e#}KThA12t8Z-m zIGbHAUVSDBZLN;m5{CGHLyq(sOX&QO%4Ys+rAjl8qj$+mfl2GrH@(N0HAUmgxy+H# zAV1$lKK!S-dd9k2{y6PVWNSMM&Nr}$PEBy_aGUdht%P0s*$%+iVga!u0BBC}y6tWU zg3KlhRvi(V6g`s>OEPR|nwb-gnE{d~AX6?kj1LV4bgU!I8skp}A+h)H;*omM7|>2A zVT4Hsa_f6%jnT{lC6mr19`OjA|Hs|H+E8^c#hEMeua{BViPhS&=`f#}|g_Ysb12N^Fx+XVcgd@2xhW?sa0995Vny1LTOrQLhpV|Y_K^90FU&Zr=EVWNt*PjLtSm`X3 z%)W!~v9f}Bni@zTxQ%oF@0-`_O&Vg(nND{|Fa#xO|FPT{es}Odm&E{YvsrbTFLtHZ z`4!Ifx-TGnH+($CfT;fYi#+q6RA89PvT@@|F86h{eN%Gtf!;0G5T-Fqh@y5v##RS z^crJ30E~Ujj7CQHgtwMT`Y&XGw#@xFGttL|f=qKCJBLoPAo)Nrcrfe27R%QAdqz|p z$8D|qJojbOHXh3{mMLkH{>{9JFi}xjNvrrKW6jFT^hS^0=jNGm(Z)@JA<7!(g^Sq6 zOh4&%Msm(t-qVQNJK%rv8~7`qD_<+$)244rc-UKuTsc62?=zh|aRF>evYG1# z`5lhbMv2n|P~ru?iq`L#%99-*lyDuYPHq}S?%Tg+FFtStpnMZBU@~>0C%x?J4lkRX zBETtRX=uT8u(WVsxv^HLsoAve$*}sG&9o0ammXsGw~OLC&}TGsCi=hmyO{{bD%V`g zt^Bu^Yc=*x2hDG;TrpP*Oi?U8%tq$ZrpPVfh)ND02**;SkXG+JD&{U-i7=fU%IJxZ z+6NaEp4YzTbXgpHTZ0DxnM?n^OPw=Q*MSqpNN=`n;!6w@F?q6kKd0f@qJ`p)Q-(qa zU09Z$CZG^0>NOu|XBoo~1>xi1T$O-#Fo+hp(y{hKsrLf)nEYh2gKrx#c zO7F?@_Fx_l^v0}xk?HG1w$M&ZX23cl86P#8uvn%;gf-o?xxKh1+fsYd9znuyv1S^6 z_@W{cVhMf}ezEHmL+Fb*G#6hSosQ3wptmwNg&q}~i7I*Ew;Yi8s5vO+SU4!794I4W z>0*AAQy}Z1ptD6ETn*jG_$yj?{RXnHf`WK~E#Wk-&C(i&CyeHLHBNN9E%urymhuu| zU?U>5RXH|k>>p%Yxjaf1G$klEgs5&5bh2N8a~#29QnrSPoQ&_Z+yjN&oYH>AoZ1XI z!^?6nr z@d!M5-afeG#M!5WdF*IexGeCZ2z+n%ZU^q__~*TOkgX__B~$58S5siwcqFc>Wy6=J zFUO6c6J@Y;$9I(>QkYfKm~C38bB(Zq-LOPRSRhDrhigHt8E*_b79K_yOJInS%h4*Hg zjthmKtyZZZ5QF(e*QK~Sk^UtZt|1$l#Gf-w4c#4SgCw&Y6I-$#FTe~h$VMOOInygz zzKIpscyy6!ULQ0D8_XBxw=H$h4R>Zv$0he$uaUzZ$hm4TOa=4Lc}uIZKU9ox%;+6y z2Htx-{}-x+ObbZA9927rL)oBBDy{eq^YM|EzcHR0D&7|vXXJs+rH&C5!p1oKJ**16 z$cSDR*mcu=1h{;D2cVtf9;pgtts{9@2Hl`mx0=Tb;AISJ_*s1rB7_tV_#7^iCm$0o z`T9g0U$?gX_4l3~g~|g&LJIlBL1-M!Dco&i>2714*^PW2K1`ZH0z~tDw*liBpK(OO!?ILl=V8gb9t=w#^t^<5G^NiEaTC`UfV01q5xbabMeHLH->LW6(e-h_tFVvubO@pzHR?VO~~lK0*NX zs@q!eOk_|$MJB_6j{vf5?V^jZAZ!x8r$1(k4D^8)jx`D7v<1t9)O3W<`g+anjn3(N za<^89?elhhzv&Y5WmsLOzbyO<27T`YAXO?tay@aq=51&!?rcMa9j3pg9M zEwtPe$Cgw`lu<~ZT;&h&-8mLd=ZxskQEVBqa*^2LK3`U9nJTm^DzL+I?NC{y8%Q?- z#NfJKlz-}cPCzrPQhKjKwg`F}fjfy@nWq$dXIYIY4alTSN1 zM;OwF&#w|y6%$t-EdKjt%|$5bvmPHR)7@XAmmW2jj6XNxBdpo>G_(Vn;BCuGnPLJ5 z;MQ{cX!Dt@flt%6Dj^m?c9{BCrUYpGJ;>Kq-^7tNG0L! zQ7W`?)s7QFI8iPMjkJEBn1Hp814aZHmbjiZ*5-kFg%o~DR{z)i{@8a6OBAqyN8Ken0L&P)CG8E~FE|%>Q{<0^eu-bv>&Bx$g!(*u`VM zsxnF`8#!7oiw|fIA*vkm*~{q#(y3?6UUe*y0f*pZ=^Abx5d9#}_-4C@#QQzDZ4koQ z;rB1>rg`$;p*?{~s8Tb8Yo8d@tpN5F-Za_PKlC@zJavx|*dMzazisfIoh;Xa{(0B^ zOJhz|6_L^l)}UDE^#w{4%cZQHhOoVIP-wr$(CZQFMDJ>UBO zyVe~%gLhJsn$)0nM(oUt2w+z8K-eNS4kqMD-R>*i%k5=gL?9(U{$59pt1b^I3VC@* z!ah47V!#B@I0~o`BfIPG_nX@qIpaN@;eC%9bo15I9rEad;owC0C+S$#4IYRv0wMAE zo9R36(^!L3OK>a^2>n+2KqLu-8Lm|}h^Xi<9{#ur0Ix~WX+UIubJIPgQzP(W(Sn3} z2=OxFffaR8R1^UKVo`a7bLyWccBn%UOqvxBtEq#rOyc{kZ5rfllC93zgJ;Urs1ntJ zY33}AZUtzDeQAG-OzHmE4lwV?c7AFga(d7#a0GiBg}~arD3z5}n0ABYQ9HOY$DpD( z$DDA}lW?Jc`e)cg!rQ($MoAYCl%URSY=OTg1=(B|Iom^B0_h`nspr{#v3=}X_Lr`k zPi(kO^#-*SEuRocBiIRp`f-0ShzI*0b6{fx_w1}XI4I?@Bl0Eslnb{2863B!^)F%d z$iwQ)t%Vt8s-zmS@Gg=sU>az_n2o2C@z`j)BzPh}h zSE!q+VSpy`(hx=_Lnoh&3y`^x-$;McG-gKEy7+HK_#ql)mC;_+Z)IlB1B0;S=>O6N zaIz&62Tp<28v!$bh9nL|%%(Ne8G8&LZB==>b*UGRb4n8_;bdUqORGb+SoU4-gH;u- zyE${7Et0XI7n1E}TF?O3X)X@l`$Wo>rYKuBN^p-^1Lm>M*6EDzox)Mn{tZmdAE6sr z!dLWQI4spBW}8bm(S|$_1WPNyibYqgxp=-Uw1>(_ zqUI&8xGU2L=hK5Va?gxrV^K%3xM5 zVvtehVrW5EobWXt0#xl~WEW~_`K6dOd})A8Mv$QA`&78j7!)mWbigBNsMYHGeT|bB zQOB3T3MV(Z<}jtE)v3Gqk}jr3ia@JlXW{vmNavI;u%?ny$9H?-8Ph4d<^SH(==i!j zecwPX-|)4p-_JhYV$3! zl!13{<>8-Jv7;>{JpSTx^hT!mp1bRn-l8S8tup(9aq5sk^Vo3is^6RAgm^S_QU>Ck zik1kg+tEia&R1R;uz4Ss6rKi1BCPmazgpxBXyubc`6#((Puzs`|+U}rcUC-Qu$ zWKLo5OR5n3=#u@uz{eh2KSN-f#)SpS_3?Oc$0CL?*b5+l=;RVo2fd!yG+jB+vG{V@ zhu+f%>*&!Rdxw=SnlU&pO#Ao56I{M3e8@L!u6@$ER6Bb7S6yTIkGjT4&-g#rwQdb9 z$IX`iyPxe5u^>MH?138ZER4u(r7wQ0S?DFmh7{-{B1b4oRMgDY@^z~Fk&k8|Hh>`TlH5KDGD_}<^ZpIH0#5%%XND;THFqs zgUxPqcE8OI!(T@Fexr!!;+~X?cRy#NpK?!Oye?=5Ws&T7Ty{VDYJ-OVzAQg~Jp6qg z{V;6|9yLHI1$qTRgg)GY7DhSAT1?4R<-Yg*zW(d&{tkW9-ljcEB7^*Ag8WBOg3O9& zTrj-gfjlZZukUH~axzn`GV1-Za+glcKQ8_E1dPn5v#0r>aXcD0-t;63fMjAz!rD__ zhvBSORpFpg1;Kv*Ru$0HXB8Ko2T@l?Z=PREaDGl{zor*_`KhD1D8G4jA`9)^wzekR z;Y`!hp?>%Buh^1zr^+)l2K4!^T8A)yr9E)YZ|V-^q-&)r5QOLoCQ0j)Cy(+_HU5An z8VPaM&e8?w0U!o=R;asSbGNry1kW9G0dvN`h)gK~dXa{{@GV=XUb2U6%D+CF^Q;}j zFcU7le5@TH#M?jl7s~b5gDP>7^#D#DP|Vm$mHuGxA(QdCEl@ScY%Yn}4M-S4H&`C$ z+b=IR=l^VS(y1$Tmb_0~;QN zf>Q`#6s>E+&T5QE)}x}RbHuA6Y&>H-XgNV4L>XUJlUuL>NVqT!2ByCSl0R_5WH?SW#=IP zC8Vk|{CD6*)RtJnEO%O<*048piID5aT*3dGAW%%Aew##kM5*BzOsLAC;GOFoAdG##M0uAn@SVf-aT znIEfN2!%i89<=bMLf0T)Yg^P&V>9vIs-Ve783G#UnmUCds{>erQZC>u9sf)2w8({1 zS$=Yvu{HJ9qM%;=l2`px9R5x#(!X885mIV^ZQ>}>jh>Z#m99eteaP&Z+M(l*2nQfy z9?Zd7T<_nGldK;bnDM9H*%BWmy1C=0EnPY!7l|96qDS|x75Nr+4#;w;tRX@DJLWYH z-xj-x%m25>;<7QbyAH0HkC4};qc&zwSkb$GdPr^S%9#O0btE*<0lm$U)d}fPj`_h` zpx4`s{Laa`@Yk~a_Fu%Myz>bYy2sGRFX zWS?!4Lv3I<)4_CR;|3*yeHs&Fu@2hF3a);}Z0xTg>rN-W!PJQtHD$DnT?1s#CFJPa4EH|(CgeG z4Mb>-#&D4`=R>JeXr$5W14sG6FGh3nbos2fW(#)QX-j}o9?`cVg&T!D?X)qh>KXKd z)#!CwAwn2W^5b(T#eW1#8ASdx$$MuJ%k9I2Oynm!$u>pR=o@6jY|u;2rhehP&3@xRh@#hZU>t8Q ztM*lgNZMjV>ZGyYpO}WN7vff)Wv$O3S}P=rRjQ~nNnEr~%DB}vPiNaeQ6BVT^o#YI zLoO_d#FrCragFdfc|C&9_-qtLlKY2n^Igv$a%)}9XA7n2dY8a)LwgCGs1EkxvtC09 zV=hgC4h!3-5f{El6OYQ4uAOZ>;l3Gun7h4{p5uf&QbiFz_cHPV4$$75nQz~hn`D0= zlki^5IBhSyD6+FZ28jU@oqe8pA85S{8Oh1qKanq18Q`fWaMGYKS@Y5n2~0j(i8QiD zwSQ5H%%Xss-oucf=0*kl36f%%Bm~Mf>K96+pFY(1%1rsoie~VUE$yuok~rsfUr*d= zK`BqgS!gK$-sB%)MjPqX!aVLiX5!>yaFLEL8K^KhhAE_z{7vLDPSDxF>{Fr# zl<3wqdb}H|nTqKjzt!p;U9Je<|8)sOopz+7t}Q^KsI*FMO`S}di#WsIdAY$8ExwsR zW9;gVndYxQwNuq=5w_s6G<~2!!$UEFdy!J)N(#z^hxK|KwiRo`?bv(Hh5<8}?(6w{ zyULz02W1-?5r)#yxE>0xUe9si0nwE0lr8@APoa~?q(f^rm#{(+qx1s(9#Z2o_zy;K%*Cy)m;az%$ z-eYkTmpnS*GS|G}2#oC@aK7u^k z@%?!ll>bho$!fHMF7e{8Rlwx2VLbruRioJA8EwIQXk@RhPS>wy7&%G#31>$~G)!!i zbeOb=Q*#*a$nV?9=XzEq@sC#a?W#y~=Cn%I^+boq=~3!%#aPC`w%I^f5%X~)UTshJ z+voDI96AhV0it6F3B!```^UjyEVHKH*Jc<}Jn4MkvZk0KnVpWvZ^zqy09;lP5!oLS zWsK9KWuy;u7wv9a~JYx5?MtHc^f1mS@9U&*3SZ3PVz} zuRR;p;i$^BbS;i~nR-wD=z_8?eU(!t*+Wm)PA!{At9=>O$euca#&+p;XAB}?$Wq9V zKJhmiWE^XQDe!?wcmzNiPegqtJ;4UBAGTvO6Kct%**~eLCYE<_Arxa15kp_1Lfa^S^XLjy|doH)7CK^`R z#tN+OJ?2;J`zs-MHMMYLN_E@r5U2P)JL%h}uu~uL>XfoDS4Or46b?fvE@#R}C5jjw z1m$;OPb@ErtwdBV8to6>%RbtdhSs@@Z;j|nk%rGR&5wVS?i%_%#2OuIlnB+C z(d(|;8)0ML=e{C4!+B>=i|@g;!*1x^94;u{fOz|48)TbmLsX11>sYi8NuiSV+-?iI0c2`v1BY8Tyjwdp;j60_;X_;E>CN5^EsxMpq;D50^>c7&z7XC9) z)O1qfUo$7&hl&AWFBwz-xb|ctbKNA%gFOXViFjdm47aCY)#A^z0QWZuvqsh3K2M+a z48`N+X7^tQSnPt#(lb2*|S?1+8Kkh zVq5RP&=e}l$JJ@(lTBTpnSLKjrT}p+J77S!_X=is@hoBxqOk3IeNxNRlqRU#^WU7pwaxJ+y3OWFKcnjxWd(r=Vww^oijA zmxGP-Hg|8`6B8u05``~GL8aTDO_;@i9m>4Hrw_mt@Cq^~_FGR#8tnV>jL&S>VUg&9 zrg5;`fg4B;p1A*a*#(2RiAk*U#-R-{PbRRZQ=Y5g%ayNZ^DGnsO|Aj~3L-W3 z@b+nV5-`TWF6Yxug3!QjYeeduj6k=#ZU{&%`hF%k0!!PZ`BR|LjO*#FG~y97Io(35B;wYYA_xvXtWbV zL=QXj43biTrwHbheeI-$!q=8&4n53dn8JF`qs>5tf1pG#Wy0gDL}ds>zOIFHrpjxn zV>5*>MT|Of9Wc_5mF4?33u6Ki7|Ge872hJh^iQdk3T=#f(4lz4sg^LBr&V9X7&8n; z`gK0fS|L!3Ajc7>4GGP}GvZ|iVn&6o`ym*WlwkUsi{5$wtg5QY!5i8H+h?XqIu`+w zeUe5)P{2-)*<{Jx+6l8U>#C$P3$8NWN~8R;ns*(4+L*n_==0siM}=Zg#QDR8vzo4R zvI2k+z?6ai48`uoZjH|IXeEInzYnpj()D=-jHB(!GN#9I&LXPU#4xla^hf@E7ua0LxIu5t(GcW|Y9vO8d=Co1m}UZwYR!Nk83t~A`}rNuT~#)qe_CZH8HxmZf00U-`$J~8|L z#gTja@P3pv+iNfm)S4%aSFH{K;JFd-ovA{7v&Y?$!x;hAE)SHBfc-UkfvP)Pd~z~< ziMmDqx$9%<#dWyZu516`0ct}x6^d7>#xE#k{OLW8q2!ag426B?9qL^>BHJna*_GW4GOnuE8PbjD46X_FG`=M*j4=~{}q{;CmUE%PeuqG=tAF{ zmis;?jh-CYTer=-_s03FM;}jNd+BpODLLMP2T#d!dFk`UqQ`dW^EpwI?yFfhT&6X4 zV6zsDt@!gF{f_vnET~+ieWvAKM&(>ccDCU|?Oez-hmxJNOD*yaAKXLJy00?X7{wpe zQz?6&z}(IZwowinQais=BW#2x0Pp|^HIFvPOCE7E(-@cSZq%7?)zMe2VGbKG_R&O! z8OV)GQF**qFEDPfqdL1m{CidMC=gm%Lfe@x>^S|w4)5(lw3Yf8S(pI&ke zCm|dZ+JKuk_&C2bhwrOizKpL!@}t-($GW7AUio;!AB%MBzk4WOYcP1?CaQ% zM&}>A0JgEB@hHpD2&U>$`1W^wQ)ZOd1oo5oRHE64k5yN6fLzXPA;o3pLN^Bx0sZ<; z^{XGhU^6?!xxKfuTQaeKT2sO>@uGG(*%{z`7>0a^D46glVLL{6UKt;cZx_x((yT7( z#Aia9i*sq215T<))0!Xej8gmL4s;oe_#{!UkIV5{F}@t^Z)DZ@Ehx7x#-L8eM)d-QG zU`+8f)?p8OkNSy|Wz!1suUYL_K%HrbM1#e{b+C+#uo&V5E}h}wR2||%9b%QmydLf1 zdz*p~;rNZrS;|k>j^GUaxwKmuns)Z;+SE-5Nue@CPvohJ#ajEE=~j8=2;nL=1}4OM z3GFGixRV6(#c&@T;!WYyys?&hLY=H)Dl4?9B6(qQ+$jvAc*UCj_YU#7C#pIZ5wd$q z=iuWH>RBW;+S%>K9jnA8gc3~&w9BrUDvbfTc3m5Nh9DLb>B=we8cLuCXa;wdWBRQL zSl6BwQ0$e}sYT8ihgl0o6AOoQ(zWABzkVV~c3AsAn2^0lCnlhmH=@U%M(V+uFD8hH z^E}ra8g?L5u{6^DBuSGoZ5dFU60_H}ROk|#9Hd{Gc#yMcg!xvY_<KD>TvPX7dfuT^m(*hM{t^UmD8on9V0dl{ComM*3&zlFZ)lgD>VgD6LCP{9!s3Q&bH+*^u zX*owu!xCO2?YW3EBLzYY2@-+{#K8JO%+8?Mv6s9n#baYb+V!E^~ zp8o+(3r6WuBM2yZ9RcJLzRSJdQT>O~t*-<8xK$~I1UX<|Nq5}a^kG4n z)sw+y^Dmr*O1%`wYIPo|i7hHmm&?0557UcHd90_RZIZKN|4wUEPC*JO5TBY>%2@uf zN9k2sEQrzV0BK3FaE8VSRFBuM29v?>ey;gBesC`2uKc@x5YFO*8h8(`18>ts{t$?* z7d7|Wnz?B~mYJ%Ygssf}=!4MzJd#zvs=rhR<@^ix;p#6yA@%B+`0c-@ZCnU{2dpt3 zJ_669%{#)3E7qjAGnz*$lYf6n82W2HXob8EcCT9;W0|>ADXA@B7uxfZJGLKnHuZ7^+i%MJXr=(1O5IvajUv@7>@vf zUn~re{^)?iHdwI!G+~y}C^`BwNU(2v{ki=)QG{(AGq`zxA%1QtkUqY!>r%QHxm|Cs zpV-w}-QTw#eG=Q)O-~5B!Gl}w-Av|oJYc>p_YkamfrIyRM&0Evp z(8<0qbCkox?{8b#WMK>q!5({A8qyOJa8VzEbu!VmoQx^^I(ptlZTf8p8E?hqaS|Vn zgrCLr+4#F2t-m0tJBPP%x^RT*JQ~iTOzA+}rWNcP43iEpm7^*+HJR)-FTIR4yR7RI zyKvIgMpz@8gdsVAi*VS1mR=syYH`Nx-5y`)wlL?pp`E&G*dE3SIM&x99Ugc<)6_sJ zS=nm3_e7%YYR!mflckn!t}nvKODu&m?q1C(yS5#d+n6|!Ui+uvX4J^}0&By93jpZq zlwd(wmtak>st-J-NV82PTsX91#b1O~Lu6TD?1(!*mZe^_bipca%O5IjyAg>rV71@G z40|4RC}1u=s1ilBJ8@Xip{8^jyNnq$U;!OWkx+x$e2cwLWV_qZhO>V4KknsJNd-pg zVruh9V}6PJIW|#SiH*c?Tz`pdTNPfgAixx1ee>V;GOl;r29cr&+55zx@?r~uG`5S@x z$mZIt;z$Ir6@-QSc$QdM_0MB!b;xArUp68@Y9S0+uXc$wQ>`+WdVG>4Kq%GhkgSV+ zKc)335L~UdC;y`N`S**#O)cHi9h=LlVS^-9mxrSE9#tc9*ldM%QOy!Vxjph+OO~mM z7Z{hg92u8wM(dS+;R4S#8UO_KLemZAh9FfzEuGFJ*2q5RaF1sxxH8q$hlCIv81#KA z1nZiB+$l;B->XGGq$Ugag}vi#sfPcoC|5>ND>K`cr+TrJJQaqWUuWT;ppbnB6C3=-wv-K@Ef59&85(Z824X-*E zqQRXnq2^`|H#jdiRhX=RPRhfhKcYEUq!!kN;w#brQubUCMP*)c7>dI@B;6CgIhS+bb7{8zzM1qRxcN6YW z6BeZR>y?1n5~ArVWk#uo1f8Q%@%^4kJ<$_j+8j&H^rnyW1|P!q;$}9(aW#&d05^)t zpMsG{9ge7ktgLSiP+Akkzo=S+PjuaTaDWl?yZ5x|ZkmyK zPn{;PRfmjFLb>Mt$#^qU+otV4%% ztYZiD6)Z5F?EirqLdW#okd_0~4(_nE62AqumHgQJ|y&G_{8=Jd9mL0v}?6c_wRC@wW)5GzMZw9oO~QROyM zscV~9y`0Tj%-y&5<6w4?kK;Nvt}k1j7m*4zWZtv)Z_e$B9=2ge4D!f_uRl|^`5&1W z9@*jEG{CG2R=~O@@u5u|_o0!gZ*cspnehLj>1_WYr)8vPWBQ+II@YGcChN<#UcXp9 zR)1T9@Zxs5^`h}&sP*L=&A1r`R0>DFxJuGh8`tM8Pum@(YD1BF%;H~CQiy=l5XWQx zI=08U*Ndyq$;QXjD0ifBKd_zSWOPNkBgBIQ_f)0Z>odMu-}_PKC{elyV;;5l3A{*! zF3HHR^z2^w^av>vTOeVCQFX=N?_)VrKHZ#e7f}GjmoU&Ng)kwy^xSUm*lvoc-y?$| zGfLEHN^1g#^b5Rz(_ToG7ut6Q13D?aOJ@c1f3P&KLpqclOMj` zgrdQ6cV@*s%P`r!FlLrK$>jJ*e(B4{&nho)&@jK@I#YI*3`XQo8qIGO*<_j_Bw;dp z3hlbo5yiN%sxG9{Y8EGh-I^QW13J3~q!DY?n%guej0HPM3VLt;L*(qzk~pHwW%z=^ z4wDnd&6shp;qtCd^B38s!2F;I#AV0XKQ%4mnfPeic$$ov zW(GEZV?sfhuwP7m1)6awiJ9zDrCRt<5f~@0rf;-zF@M`iY-?2Sja#T!B6U8IMDBFm zAog&yi~+zm0b`Nwu zWvY*1{y>W+u-#BbP9nVC6~KnGf#GjS`boz&u-hEwXyH3*c9QWC%@D2Tx? zX+$FWtMD85F~l!siSeNf z3sOZ(#M(IB>?II378m2Bo@>{t8{eca0DTrYMz#6Wi7>BWDcxlRu-30axMv9J_AMz+ zu9)l0o9QL;`)N)saL-&Vg;t3(|HLNWNUNw)%(8Bi=mQI`Z1yTIIv0>0d+-{oZFE_# za;Rvs*(^j%OtfLIG>A1W>)(0vVjNg!%x2MEl>%400r4ZEYl1=$#w+>frZ&s#i}kDu z`e(nj<+}t()%rSzh2pMbS55Tcn?ON4l0)xLIAflCpY&^%n;)*xUT%{*#;#9M8;e62 zlrXg+hanYslfnbP0>C5)y(~%7)0uB8NXV1#=eqZ%o8ZUbC&5Znwrj27Tc02SY;KvL zuKa~+)jvR60lC5G@~c$a0>y$$?1jly+o{DRPejqIeL7aDCTKxu@O@Q*j}YARVv{?>H)^Y~NW)D|;MF9nZ3IM~T-yJBr%}U~YU|6ub#q8fwBMx0#4VkT} zRxwlKZzAh!p}v^WW;VnFM=}6XgE9aVS^#KZQ-Md3%B~PYfb>Ap%w{`$D7`ie{H44~rXBa@sj4Zh2jDxl$hQSkpOv0a==fizh_wW?Fr+jMv!0 z&%8SmnL5eIA~lx#T;-!$iHZPMwsj0@sNyUn=#>#gC$F zc2ke)KaIG_q>7?IHfI<@45D5~IW`nt{PnfPMy#E23+VFoF^o775Upz0N%hy-^si&2 z9hOUNPD+v9yZuaE5i1%FiU!e6}uQU$S2eaYqa@bp!dqNgYt%Qyb(YeNgUbR~zy|&o-&0b+OSWAmz?OuC2 zl9F<_r1H`wi-$AznnP{t*2Ro*XJvf#lWuX7699iS(OBM%-qph~m27pAP|jDa`|02< zN!(XQphG9PViqYoJ(6#GH1ESO56ex+sm)7pbAf2$W)};xh$--Si^MTftZHeYvU>av ze$+<$x`br%Z467w6a6dX7Lsh|17N48xazO{M%+=|i_R_u$CfYCE+5}~D(WMH+1=oT z&F^ZsowI-j8;;yH)^Om5C>iyF$jk5OV?9K^wN2H|CV>OImAk>>4KZQEoC^yDUco7< z6(;v|mW>Xxt21z6`T$K@TQCd5 zlZjl=#P)SbcdLk#ri`;Eq!bE}#YQ&C2{l|vH7gRqQngiv#B|ni+De^8OeMt@P=uD5 zCpMo4Te-qV|6io=z3Dig;b~&@X03da-!x7xiQSRr+K%@Vz2x)o-9_C&obRGV+f8!-Vm5|I%0LBvGIV5s;(U# z`X!YNOZ*r09Inq4D({i&M6R{ou!!O&HO~^yCNB-YN_5g~U)P3hN4Kh5})K3lj@n19xM<^uSPDh{6bC`v-tLhlKVG z?Yso%P|j`<`n5mL24Xbv^S#_i&kpwn{n%wCLX85rt9S%qM*}RYyztzU^oP3=4tv9i z4N}nTJ0eQ@QiumNa%d)2G;pKSuyaP&EzZgNx8w=aL}^x^ThbUQm@oJqIX-qO2fc|L zN$MZ!3$P)tjZVyoSUv*ut5~7Xi?CNNL!gJGMBK2YC}=qRbB3Z63$gYoUIPqi*)0*- zp|p6wBoXOTn>4q6T#>f}*Kh{KHeEw_@#R}mL~l>(^(^a}U>|>PE{xWIUDA++^Z^a& zsY0D>EjTCzDa4k6Z>T6%k`0gp&8MaVn=gD_6hjyONJX6qrUh@U!5!Dl@2i_jlXFMo zP|mVNH02a2PrkAYX84a=u#414ie;F%j}quZS<2)iQCTa?d+KmtN~tg!xHoh;lZSqO zPxp_wHP2A$j69-Xw_ZlL&QD)|79Q3cTVMz=Z#re>F!rrN#wR1xFAnLnp}l-<@o}{X zmA9n~=CYow)6kDjzGa5H7KOWS8aUtLmYT&%Wsq<<(=L@TXV%S-=6$caqK#KKEgOBh zqj%uX3ZZ*bElG{r}@4gak3hf1q@3CuMZaV0UjeN>Mzx#XKlQ)uTj!0>x| z5>57x5(4)bWu6K&I83wCoKv2r)`iU$R)TeD(@c!;DA&O~T;ylwWE`wV=RvVPZKhS6qHa1x z;N4!L-2d%IGA;>lX$JXemQnCsy9PaS>E@lgR-Ea?J0F+DcApBH=KEpmuZeH#zUYm0 zE7p&)g_0)ey~6admMQ7%>dR;&et?i2gu4jg=%cQf!Re<^HDLCC+me;^xTG9IGRZcW zRy8+^kT-!PYeF;76u6M&)rVDvn^hHA&ju5b?+%M(7eBBSVDg2Ek9;JLU7)9=5IM;y zjR9zyBH3Zuwc`Cb_#+aDFXd;_Z z36=R0_5#CI+)+OZ*y>?6Me(AueL36pcjhtF7RJ#Ca>}}}WVk4n1>jU?wW&<3zI1e7j_xz$P5&xx~xuVfg7uSESP3 zhOfs5Y6z;dPa1j{s1*-lGa3X2Pg#Kj zF)w zZKO5o_2U3)2lUWlU+0V?oby2)Q8?Q5&+X*HSz8Okw50*fat8%xSKkJ@`X`X3p8mC? zf3w`699+eO*%DPzXD+35ccYqY6@2NV1}-==U}{#g#c-`p@@Yk($}>x}w91pE{pPFN z&H8VJJQTl*rLVHvbEB9Ra(_}s0t9N>;k-JeHx*FhwTTsy|Gvh-jz|gdm$UFVy;*l0 zZ&j(g7(T)gU%$gt$bX{Ge~3gG*#Gx=)V8LC?WQP7&!rkY4+@gLOh{I+aR#n7mvaKC z-y!=M0VGHWrdANSV!k+*&HV2U8+2+u%4Wj#P#E07lwC@zmn{|~*D0J!447{gT+WX~ z7;-_J=N1Q#qu1=cxu2PM)?)di{oBLxz1h`!{~dj7W$@UU*a<9H(vj}M_DVs+4s z-4S7g{aG|`ZVzr3JB}Aln;n9Sb~l3v?@P8D!`s^*E+q`#YklE?zINqCG`M3xZl%-j zy=?$2!g>*E7cZ2Lwd5g1Btl$}m|Mdk9zCTmNG9x4jdbJWG$0Ka_}K`re62~rC~np+ z@dpbN(E>*fLjCm0GMgBYno+Z}r`+N8$7(e)v4qnMBV7C&q)<y&hG)ze|V zvn8g}Y~TR6^rUt#Y?g(^wz%E>m4e4O_#w9t$Ov-!eG1w%_eDDecr)6I96StMo5_A! zd2|1hLEY(8P2*^%la+-(j|c{8ypUHI^b~|9cw3hkj%WFE!1y6~I0Mb@NsWTSi{q)x zv8R}~TG+Q<*i7^(H@Jz9gtaMJw?X}K?ANIomeE)2b?hmu5HzUR*#gO?0Q!CdtvbZsUycyKckLWAhNAHV2>u$B^vh_Ko1F zv|5*ba<%gfOS*YP2v~3QeUJ7DK%521*TUzb%OMl$FB11Pl7~r;kViJ$C0HHSPLCwadjD%wFvPe9*lLkMl8m7mWM@T~C{Gti(IANa~ABT6}Ua z)kT9Rbd0%V3zsF?9+|$Q7M73z|BSfzpnwu{q7wnF`xgO&oOXt}4?(Pp*Bx&dqa;`t zxxQ;HBqcFD0)5Tp*yu)+gHSu94V|SX1gmfDZOF~jge^6YQu9ubzJfZP=NiFLrwHbqD1zkVd%y@G0Z#ML zh`RD$X0&qgr%@00KP#zoP~B6$kgMC5U`GI$>E#ynE2V^W>RtMEplxbbD&rTRWL2d& zODoZX-#7!7RTLqB6D*RAPrHxpX;Eo(477J-(LL~^E2^X}e(tG?V8OBdaggy{Nl6>| z(!$j-f4jtnwQ*F83AejEv1tnFBr=lJMzCx^0V1&v3i^z%OB)4M(e&Sp&Yw&?eG*Rq zq_!~j4Qj$C9f;bcm&Sj!8O^27GNpCIr6L!ME0RKP5*rH%(|1CU4;$ehu8>KU7dzF3 z#=y9>3-PVjH1J9Qx|f<>cX2O9=I=vIVK-kDUftAJK%P2Rd2IOO@CL-HZN>f+M12}` zmSWj4)$=srB$6m>N@YIv{u#*Tu|HjU<5JO#&7K|A+yn#{J#fw?oWTdRbOk=)A{)<% zPawe~fo)WUJZT|pSE_GA!%24%t9cS#D>_>l8xJW^$oM-ZuEp%|2^I!|?`wrLM@)5F zNy)%bA+cQ|Xp#o6ob=}Jn_4jhAzyr6^zyYG-}2PILeQtKL%LO!o^!@VdJj+ftJ17} zBGR5QR>r8HVEn=^HS{Szvf`Xp4P&Eb#OR)JS%PR3+nyQwxiZ`b?w(GG)oAQqCT-kH z9eE_B5)nxH71^qyN&4}ORn4JuH6vW2rI|}Pp0rI)>!9&G_99rLQ!+rP!3CM8%qF|i zM?|LuX*u@@sno?XyNUx=5YoX6&@H*I1au$zByAvP+KhWW<%DQda83&RqAs zc(GBj2^#f?n@p#NBL}D3!~Q0vYwU*N>rE|pX}xvAS`bTkd3R06 z&B~Dn7TPBcJk0gjF#dVvCFEFL-nDLj>l|kj@~z`?HMj$d(9e_G$a3Kt1AlqeTE{AH z0G%Y+{Hvm+MT8}|K?*G~Q^Q25KA%ueGn2CgX8LT)6T!(oNqDpSS)ZZ8u^n<_%7b%L z2LX2QWnk-`dny`TGf8ICj|j^Ex`x zTOtqNUejI$e{LpCpAQmIZ^mIb=rHueQ;RpIhb(F&JD5KMJe{jbdqh+IUO53~2^{bX zF0RyB`Crib&xo5I-`3CqiklmX?*9$hU}O8=?WHiyZ8uq;I(>s%00X;6U??uEI)QW+ zO2}47cR~qhV8lv{`WucV9U@xJe0L8CqzaaY6|;k z{3uDn;=RY5V+4i^SfjV&vS?2VrN~A1ud!eAdj6EGvgy=%Vt`k2Xc>3+Y~z?1bgd=c z8KKoHOdRzIfM{TR{=NO)6FD8vd(0Q|!(^BUIGp%6PZTx!xS(#?%;Ls zenY-om509?a?$SXGxsRTP)DHA2h5`pRgi54*hiApF2L*y8vx3pQ$VLChWTN0kd0~u z!$`Dsj66*(Yz`hn9`pSkIRUit2Psj^45mhyNAYM}PHf(B@LSU21%gZ(Sza3)tM7+K zS>u00BH>lktT+=h6Rk##SXU*no>|>sIaf2@pr1XVY{UsK0^*=u+Hv&?g48azg$4)f zK!<|?DPyM}t$z!FRBP&m|5eTy(bc`;O8e!^XU!fSSAF}uEUQ^Bz3~GaI(flfry1vr>WqN30{+x zumXpftk-Xj;|u~=RYs7B9TNQ)`38Y!ex^Mm{zEjUf={x^C_6k7y)J@LcN%&QT#QCd zuBAxspAWR2RCnvKWl(nQOstovJ^eg_AB5kIa9bCR`aJRh+A7vty?wo$&tMiH$GECF zlU$Uxg?s6uO3Hfhx>7~;41vf0cvTET5vKnw%xy-U@Rx11JR!7`;l===7Hz$TczeQn z%kr@1<~$SlG@$ADLn`r5I|jl#5`VTp#r8XrboN-?A9nUSB#}Xhz=%Ca+xP8c`LKVH zFIEp8ua_4au2%mc8Yh^2zKC+AnF9uud657-9$psjOmU()5s1$U_fY2b zaaQqgVL@{^9s0#$0DNMGfK~X0qc?jX7ZM zl4#JYQm_-mq#y`+=xA16HbDSt%4aFuqOr!49z1E%#=d)*ybz8SX2J1>%esfgH1XSF zF3~(pot)Af)|ipdtzD5SG4=}Lr?G=w8MQbN{pX!^b%@YOA)`!U9SF^q30y=RN=@?6VaRN^iI_fN-L_6^}I-`zaXnZ z#Jl_7X4qtedQ!s(OM9V4~N3!pzx&m{$nX{22g)1rqz8YtjjJ}Y^hpRTd` zomjOGve$w;Q2~C%Kz$V$`2w`|fQR z6x~xrIUrrK8Vy2I4d&c4(H3IX1_$e5uK2bcG}6+Vi?pDk&n^@ggQA^He)ppK44SRL z&f^6f`PNL`??A)&?;zsv85Ty|BAx z(2s@Z=rRVS8z?0hXag#3b&=|yImIHI37u{oHRnE^7NT|7B!%uCA3rud%B#8$*2%tB zU9`CHCY>I)oF-NI6NfWaX?6FM`iGgMaGx2$+Dtx~B)cJzXXBwv z$s%{35=gVh+sv{|OM96il6Xd#v?TGVK(F)jRB*{!6+u{(4b{D30Q~uN%wJO(c^*ZD z7V}v6tO7BmCN_t5vh7uo%i5Sq6G|gEPPiyLRvG+^DR8OO@o$^?yA_Yc^?t5-OkMNk zoa6j??*y4qstPVLWU^F@HXECJQXWQZhc2|IhJ(Lm*0d~YzfVgod3kFelZzX-;xx#J z1wgd^#30WfF~_cQy#CM<2O@78C*NJV|5|@rRxj4st-b(~|G=RY7hj(y7gu~JZss-0O5!e&#sW%VcZ8s3HQ#dqGqyJZDT%x zPu^z?uy>{kMON_IX2>%~B2Pr^04})9auCKllp>-XA(Q7@dGiBcoV2ho^$)c+12nZswv>t4e;}H zJ0V2K+yCF7R%aSB>gpa4CE)Z&}t2t3Di68;!+3to+gAV zOc*Ni3+?M)Db+WC7LNNVf#e>;bWk12BG`j42%2*ek)Hfv==1HAXN#U#9yqxrG~neF zp_;Whx3)&2&xG+a3LeB})h{^|5TzR;#K9uRlhHH}8bjFS%rkz??3;5U?$5mT7+2eI z|L<7(7#u2per}f8oW8m1ko^9%*ghN8Xd)Y;iSBA%GT6PNwt=D50v6Z7xZu3Jd}!9d z{UV30mAq3(I;pFjrb=+LnI^JN+ZoA~S3}efnA8`-!Rz*NyS;+jj~jbflX8%=CY@#H zi0X7l4^Yd7NHF(67UpN~U~GVCpO$85&H+}Y%PgPpNSEprj)r{{Q(U|k@&L^P91tKo zSB)-msI}1AoDA}r+P_f*qg~@?SEXdiB$)j_l)clktzERVIc?jvZQHhO+s2x>0?f(MCdoT`q_SUoIlm8e50W}G`vR%Go&BXWFfhyi|sj38*#xFS~ zwviz0ywd=q?}jd%9T}!j!q2_>b7^iM)%`PIq2dnspF-*5e0?B`{i@O>WbC6$O90GN zjJ(dp<4eZq617DpRdVAZdxmga z$N95YbEBD%wn^Z;)?hc9rU$Q!ESr`{YK6?Kby|qgq=(BtO!(6VlWK|86a}}4X6Q== zR=i=ms+er0b!T+5?{x*d_s70AG0Im7LHxB0Qs>VudUxrP(S?Hu&Q3;#C?>&3uX>D; z1jhG(w#~uL`@nawa;1>q(I_biD9D<9AHwD_Se2ypr>8=r^VclVJ2)j8)eTzhWU`)3 zuP_ukDKS@jOma8Q1Q$k_OE_aQKMoIT>9}mAOi5XE4YGkHN_b*fb+(J8`c>FEkf24RNZk!gpXD%36%*a` z=Hc!e>MwrP7rE3HR~`g$jl)WuTyw#*qH09bR@8R$!)xBwfHvMfE0tGvtyZ)E7^AcSbIOqhC#jW|@Az#H#t1A*hslQgDr|q08dksX|>I1x!lssQPKL zZ6_E98IAVnREP)3tMEv2tc_&mUt;_ zaP)f_?g5ouvhPawTi(4`uCn$^J%ySwxvYIq^D`#LC|T-ZfHd*%gGArrOpmVltVw#l z##WtmFYEgbL&cT}@6Fms=K81}P{Ry!34dxK^>t%U(4!!ddyk$PRSQ@^)RqI=C1huf{gNFqRj z$hC_b?>09)88VX~XvT|Q|3%L45C_u+MfvOj%dxyZmScfvV8FqJQ_TLeH?J29CL{Kv z)UzRb-G&ik!mlg+WF30f-%uGlZG|1BL<7NSZSVVda;G+}JB}A>1)@NLS%IdG42!gJ zXY=)cWQ>$3Jqu!6Rf(BI1>_awd)a%NxL-Mll0$+)c}tQy63XLV^mMp{le03}V4yi~ z=2&*0%;50;j%phD^(+6OnGNhv(ws+7m`tF%D!em7Y5{)}FzNf>39xbOf|HxrS|2oAo+c)$p%|O2kj`+C3hpaHV6B4!a&KfkZ4%a|&p2J5+;Ab6Ps&)h zL|ZUN)%7 zp9w=z(d}OLQ~y<~D1d@|y3@T3z%0m}48SNkfVv)%&5k(00%S$qZ7u*+44G(8Hb2%c zw$5iNWuIp|?uXzWy^@OO`Tgj*i}x4L{AX8c?k1xw4x?Lm2~>3j0WU!414n%coD2c9 zJFyz8oz0*uV#06sn@MFgy3@xk=CmW$@2@*XyE#;RXL8 zD*S>f2%zDP-FqC<AJh(E3bxf=;3rG}N(B+lG&b>*6VvM^kHYJ)}u2K%RCYb zZ8YD9ERS^6Q=wSF#rdzZW`iuz1Cip-@ie*XPI%;Q)^39P7zBb|5`M*#PKHrvzQ3Pm zdi0G$%bK1CgQ@77M$<(jC}(E38kfAr)9qk)$>1i<)Ed3N&GK5jx&dqJbH<6Mbh&hF zA!&|leRWzCGb342B7=bnuBb65!zc@8S-n6C`e(pI&Zy|aC=J`&cGqC5+jh|vzB;w4 zEA?%wo>CNMiFkY8ES=N*Yl^wH4>)eRSYtl$v)ZnOl|*r)k~(&If*>lhaFQ~!xbm5a zJ3|(n_@mI9seM{?TUsJgx5(9h+dw!PxRcRB4KZX0X9IZ{s&~Lu3fzjCTSuy<1 zD@rs(VRxqh7x8H((Xp2RmRhxxwE6U;i5Vyjl+B}HBis6u?{c==fkG@+&ZR|-=tc7$ z!g)8!-vn2I(}#&DylLU7yu}w{=eF?9DE^xAS6ABbX#SdR`qC(J|JHTin_KlW6j$+@ z@AWG{I#&e)p@heJ?4CVaenC&Dat8dzxy{M&U;TPa|Ie{a@c$1Ui;3^F8)SeHb@v4o zhb&W-DtOk&;$wc!ryVmOvC<-l-5Rp=@2yyd0p&6wfY8&?c|b4(hH$^4YM9hECKxkl z4t;}?3nr$g#Q0;aarYT6K5udQ?y86T*@P{+_+aNV+Zk2CUut^+R}QB}CHY4%$~3z% zYm6_QDhfdbmh614zrs9(VymovUSX2K4O>Yf(aFlj#v)=4W&Y(!nkpEbe};muZH$+S36&k z^gsWv|Ij%mW~To&aJE@<+xd_U&VN=vU)+=IB%y$h+Zo=DZM;Oi)cbv{Gt1UoJT)U- zSzC$Jb8$=GA3$(CwTdK*>=kL803x6d9$%%+`PSj|>(AyXzBo|s7NXn{XTly$e14K` zY|qz74(Xh~6Nhx-oF{`0_9(ouM@`OUp+DZYhx1b_Gi6Q)X+Am^yL)Wj{}c*`M2v#K zXJ-{Z4)bQn0KXnyEl!^=AGK!XO`+{GpNHe!WI*)?tvQ$EnnWNpon9SWojg4uy~oMf zf2f5C4iTOAu1xTz@O6PBrc;tUO734D53diOhmZe@$-Db;{T^Ep0l)IE81%T0lt1w{ zdPlkqx&4arWkgD}X(q^%xcBbcrLcF5Ewa`)uva%kKy0PhsjS#gtKtLm#%?9aw>BS- zrI8$MC5CiLxi9>&EKlW<#x~Vtw^CLyV0Fijs9Wik-%C600m>K-Q!}HWnpCkho&D5q z|D=Y0Teg9N7sSaC%u_7Vs{r~2%pFcA4UDm`6#np&2miS_7XZ3=vq@nf+OBFk#%qJ% z4L>Tbc=m<6Ni@9Tt9sHx)cu|)29cBfVT4J@D(0l6r`go9cPV`I{wSWd+GC5n+R)e@ z#^rs*<#Jl1pf>C#Pi*9V{4rPS0|1?A$SxD4!v9mi`%klLr0NQt$_;0o{$v3^%y!0u*5~0z>y{$b%oOyb2Zp%d|6%1u;0CQx?RYs&e3d4i`ZWYHAQH!uG%NqGhuM z08)tyZ+J+9(T$TNRL$BljT76<`9{m(9a*2b%~TbtLBJQG^IhR(!@_nWCn^I+jD>Qu zM|hX7mfvbsQC_U>$A|-SX&?2Xs>gbqX})bG-T~8Xv8Ax{`jEDoh?2Pp{(8nD0Gdl@ z8(nYgu-Kp!Pkgfo(*)s>Jn&=f=L1{hO+eqLqkw_ z?*&}7H8*e?&3etVtu<(sDNZluu@KiBcBrEMe(li#BWVhCuF5oZhX6c0$T}z7?s_QOckJd){Omnh|y22dFzfUr&dq!6Z#_!rh z4fSI<$^~nlRcXqnBhlR?G!tMO$NrmL+v@=Qa~*E}sy4Uk$1Rr540|m)irTEIa}#G1 z@_pJq`4HWTELuN#UZt;m-N;~g09xBJb#uzMRdqQ7bKw4lXUzO{piBPU2~wPG_yqk^ z8vz+!+Nmw-?6k~i<~~0##Fu$b8y%Rt`3ZA+G>s%nb_~z(`e!FW_DeeV(|thteDVe( zK{PLQVeyD+(Q2;dffa<7|?Fdf!ptbUBlxvfW}zEZ@J8p z=r)#g%C>X<(U?h^@G#gxMCJDd#doULc2jf%pta3_I~69$vFzo#r#kXSytf=qTtj5i z5ge9Zgvi>z*&KpX?A=-JfiqlrjXuYw81TUyTDXUMZuZr|NaoQI>ebna z0;EB_+DE&FI$Xj2I5DR~OsT?`0^u;Da2A_O&$8w|X<|$QM{%SR9iGwzL3K8cJ@%&= z?iQrboq`!VPYE>-`59!MK$A&gGVMO@SRwhH-X|5=FRs>NGo4(nrcK@DJ42Lx*s~12 z`kssn*0GJy?_S13_#y%cCHgKwqD29JgJ%^4!`u2H@dJ9EC0PLQz=24jIsI}o{DwdT zziR}rj$1R#!ZX6Z`j8c0BR@jNIcxi#q9;0gb?;b9A8q(Hj_mU@+^iGuyH3Hi-4a#> z?^=g6+X2^!^qK5|W8BSsa#(1*HU9x7!I-`WJdo)d0J$jqT?r6P%%?=52W0dTbVpAN z{7CC+Bey3Z`S*M1aq3XsBxJ!MqxX|+2vD4c@9fWgq|Or?_F(-?$EmG|rtYS%VG>M@ z&lVC-ctc$gJxUvvE)+!mfC;i)EJS`oKM_Dq{&pC*{x$r9JlK(_b4G?I+w*(8fewSN zaE2?cIZn`~%++Te{RWDU9Y%YS01RsgJqzh$_$PW22A@%6Cb;f6WZ>y)j)vH;+6WHs z!|x~{dq&;I4}q(i5_hBh0_uY9L_P)h`p^s;sBY~wc-`ND_0BRs``hPtFC)H}n;UvD zDf<9O>6sHle|g^RoQ3R9f|Nm2y6Jf$FB$`%nGqy`ddOVmN)+<$l0S!ck>d$gfd5Q|F?{LaK~tSYqiph0*B$MIh z6T~|M1lXdFc}hmqTqvAeQ8XW87ATklE6-RLhS^z-o|sJHncb-85lV1~UL0?wk^%3M z*8*-i@XxYwl~bFHrZ^ z8p(?lw@OL0^bEpeP|TQ7V#kmMH>!?fe+7~XIcl_qV$lAPlrDZD!V(*qa6;wb3<76P z{{-B&1%Xr*Hf{Wb^ma5NB@<>Lkt+yIHvL?@VUYTyLtb|o)!JD8Ln#HPGp;CU0+)Vv zgTyh^QQJauned*q8^WY(D*$nD(_BEcsi7#?h^hKK_-1468T48d>zn-{}fOPYK zF~D2nXk!uM@jXQX9T-r6wP`~uyCvL7W9a%O^EBYvRm#as*F1Gd`apY^k}u`ZCUs0f zqPqGT6Fme}x7Ul!LRU{_9-bWf$rwwmK3@9C_0!`3j{Kd(bNBb_A_~0Rjy(A^^jYo< z+G-|P!%QBFeaY%$R^{UPGn4g_cdz{HjC}4ae-?2#cJv%D%BX^iQ|LOChODNghh?ml zT*b=w`|9o;j)8e4Nba_d4vszA&;-Fnu+Y#Bl*A&^6(q@9P#F#~*Dd$or2RS1R|c1? zY+L5Tn#;lMLf2QHt^V$%Buv_VI5V38gGaPo@1vBb@nuHJhb}3KPxx^xNTb11)?$?tcDD3j8(?y+YVQ1sqm5~n--1h&#VBWf2PN9 z>xys<^6L%O!G=~Ogb7nqJ9%+ZkGKpdx%-HI>1l!k|H2V05C>Ykm^X5&ackxFF6DZC zb>PzQcA87%Fj>Oc@6cX6+n+YZC7rx~UD$Z3F1H_^te&Vo9*nI*H{YT3h|aFi%MY(y z=F=p(3g|C(5C?Ag4ZqE?^iJ*0z_y%@^Pk?@*OaV~U*=IM9bypmlO-!t3nSGJzc-f> z8uAGH7%nYwq?{UEwzHT|aRi9APofo-$|IbXZFiJ0<4Q$E5C+wBGXOYZMGK zHijGY*&X8r?Qmlwuypp$ZZ4O);UUFn+B=Dt&C}(JRYDvt6YRoKRD)4t>J5|Lr|+j5 z)x&W@lzM1;!^H}S@rs&9345}?+wD}pl_t!U?Ae`wD0*4m5^44`k~B1mY?u&4HOkXF zTZlLVbqT+mAXQlml9EsU%WY}de6P&muuFzu0RCa?iKjDEl<5~!-;`GavYk}3lo3%H zUkNw5+fnkv5Nbg&yiO*xJhuJw1u^#Ek!oU}BTeS1A9&BFC1xeL#sqiFjfKRaO&Q{% zT-7pfB-gm)2@YBwkmUaWOdH6NrJde4J#U1=%0+6GMVi?qAiVZuNLnm<)guXR#AL>Ln_Cu z*3w*Ziy|CsOzPgm%mf>k@{i~nl)XF%Ngk)3=$9U$#&5(3S|qsfkMmMD61>&AnYg)) z23M9M6803)`Yh3E`$AD(=i;Ih>Am%`6IvX->S)Qm85^jmb9+{i+!TDdl*C0V=!*;< zrQ{tly>sw~O(2*1ytVqfIms5+m1a`76_C%soT=J4Y5(6%A=oZ&@7q}?)LdHwY z{9ubq!dL%#!OysqLXAH?ZX+2ZGP3RYmidFxhl1+E(U-tAtW$wY$Kz;ZhmzFfJ=8~- za$c3&ATIh>YqB7u2tmeC?UyNkp?uS*XoYC{XGc%BcfEF4*m>>i{v_px z=e&_xz-E^8EPg zLjTjy(er-rbbb7MwDg)vL`Qz21(dz%_6C~NG1b>ggQ1}0euke0!cF_zK9@e|7m&fT z4fQ`{nUnFqonw+anizTM_OaX97lZ<#+(JU$-t=vdq=6JQ+<5!f;)$PxjLi7U{m=+ni~De^_g zRc%OMbg~2O6wP!27Ty+7&z4=3BvH}Hc8`TjQM9AJ45DEuk6+5!w2UH`r!9hJihX(f zFpi-H+GItTHfy`!Ku68aDq8z-gHE@*z3QXUJWL2cd3h-e*0hI^(y-!*y85z8*?9AN znmH_!)bP_A}&1%lXsr4b5>^cy{LOb2uXJ?xy8mq2N< z!i1si(EG^Pq6}cx${%eS$BYe|?l*(8EF|y|;u{r1B1mN1LmO8A^lX_Vl2~px`I^Wr ziF;}*c#DQPel_l7V-#% zzmw@j1H*}}+4BZyW$S~H5;<;PjCW5=!9rl2PS_J@QB84QE}1*;G7ziNdy69n@Ub;HmqT7J=ws~XP;|!h zPS`7LG*37%I!Zku-OVEYX7*j9f%cfb#@HWDH=@^WQ>~hMhr0KuM$;~90x;M|42D4_ zl1#i8h`n>Oi_$*Da?)$Xmpk^n)!R(G7^>wKk)#@h6Ji{0o9=K|8J3DtgS|`Kn$PPD z1c0tQM9^%2-YuLpV>S{2h@AEL;5zOZa#yqOS7rG*){8WDw_#{X0j?IcK6xh4H*^Rm zUrIL8IkA*%fEX7#_mi!vla9DPCI&e~pFGc#R21}QWOSxhcaB$1SJ2K~tzBK^roX2-jq8uH5?2uWVMUHqH5TQPjiEJ7m{}V90TL1tJUrM5>qU=&X83)a&H8qz!d0DC)eY9Erz|5r z*TN4d=gOBF#f=f0Wd3eCq=cE44YdCNpX|9kG(*{i|F!kUG;a(*n4hw>D=G%UCxyE_ zsMvLEh+BMb1hhb`OU=f=`6=cW ze&SMxLP%9#u!oH_X1C~!pfK3ua^tG1VSQo8&KtE`9C$c6sBX75eHpIKP>)epVyZQk z_Al-nmBSTbiQkT%O=LbSGke#N^(|Ifma5&|w9f32EGE>ER5>62JmFviuAH9gHAY%K zcAzl@#3zuA1hQbK(<%s?x*QO&AJpDIa@PfRa>7xnV5p^I*W;exX@BR;U>Xe%S^N?U z77q{EpGA+abO4`C2c|T0LUIUzdR_+x7G~&;M3UGGqK+qd47YlKZ*ian(%^@2Mng#% zk<1PbWT$~7@Duzpfy5Z(y@LD|nU)rl_@?RNM@s!5Kq4F|CN!yjWT^$OAPeu z`Y0RUaV~O8_-QfV`EuGIBeS*|fTM^|oWS3QDE@G@=yd}RkuOv2F0qC{gP$JqfZyLH z&GvI5+*z>rLejIh9Abbp>h8~kFNr>G*^MS%{M?Za(q8As>aGM|C}cZ48x)4wWQ^sA zeFM1|D1mA{D`38^y(n}QHt$cq)->ddr?Y)@ajFIGC@puBo(Fyea1>JnGM&~@Ksu+J ze3Er<5@6!t+}+0kb+K%-igiDto4vt1r)JQuM$whBZzDG1!h*Fh_d#`YzqU6@aJWh^ z)|g<0s;g_p@p@SzUf0b-&QIYSJ0mqN?IHXAfq5`HOgymeXV4b|B8&o6l+t_v5`!`V zVy2M#)AAO8NC^50K{W9_x~K1GRprX~7m6q)c9B*dP5Sk~ZJw4Eyk&E~K-*Qi08jp+ zI&)B>4`f5WAG(=)>ev3o6Z0DfvsL-b4eG135#cLH#CC{#iKnm30DP;TEFy%~DJsiJ z-fN2s=wO9EHbb}z+xZN)Pq}r=;BiOF>_`D?&v@R!nU>*G$SK-?`@-jQA_A+a=zPEL zoF)nI_!#XaLk`l^!4yeKxelfePgxo%gcNE&%TVP*cWz_17pG|>!czHh*h~+k(ReY@ z{rBn$aCn#E2%mszP{$RvQr=Pa--II`|K1bc8|Bq#HEAkX^W)Jr*MC0dKiD!^VR=cU z9oDIe723e01qTe(^3KIkf~c- zKlM7mXxjeaQ$h433hQ$pdjBiJ=25+kp<@yUDTMk&6(+CN{$(id56ZT`C zQHjsXqNE8^1DamhExFoc7bNP68IivzeSOAhtFL9DRGa}Pf=N@!0lr>=%uwcj~|D%DsBDro{Niy@VAwy zC+ClN_;>lfx@JJMACGTRbb zQf36k%kcvwC6IEisH6swAX}9Fc6-BX!eb+4aS#fa;he9yx88PdKO3Gd_0RP0r5*O~ z@D<0#`RqfTdR!>bB|Mc8XN0HA=NyiCa(-REnitknckdVS=u90}Va2>NlqK?Xn(v7_ zVu735fB_*6F}!TgUmlVNkB$bj0|Twq3FDj(jKE0J%NaP&JXf_3 zhJep5c`|zN^`$NxBO?-^5UVRROCgj7(5nTA!`g=sj0G*uW2g;jjo3B> zAa5-oxsA{P1GViRdVsxAxB=n=`&eeiQQ+s2ua^TY8dim+^2ugpYR^nnAu1?fDZtJL zQ?W;(7wgUy=)+on)EDRjvwYWO5$e^O+RHchZCe?LV~1WFTo$CwN^j{a+?^8V~LNu(p7ea2n_TE`xld?Mr7Ha#PJ4QC8LRv)>XQ#g#I*%aOK(f$RYsd4ikdn-J;#J)i5 z;SmI2G+kPDyI#$SYA}rUW#YX)sV+Qd5{~SiX}dlj=p-ynO4p;pV#8IdejPQE&9~JF z#qKAys-ofaOqppi+%ZMsm-;)x*nZ{qk|L=mE`5NHtUAE+puRq@96Fy>XgKu3;H|zS zgxvub#NqB`rQyntJiYC}CQMN}a02x#XTuXW0ygMCIvG*mO%Ezs)F4zT8odUhs z70w|?{&^1BN6Gk19%Era2Sbxe(dtt-f{!8Of}A#qA<9bTpjJ;L+v+epZMve@0?7y> zUni|pHnPRgy%Rd*w4$^pJ2K*un7N-tXYTkyRXLOgQgVJ51?rU>-S7fFb4ZyUFUSyC zsWw1dDhk2qH+SfB-6;SO)Y)K{JlDZVs`Ji%I}PtPWn4{?O1yUI)SDd$>7>t=8Ya0p z#dH5nvE>gD;=CKB%dJorSIb1#%aTjSL|c#rv@3Ln8K0nGUHXo@9??@t_y;@fhE-r? zTKA7&83~f~nK4wEXQ1kv$hC|X?jZGSshX4Dp33SR$snB#X?WQ`49}>8R!NN4mn^{xYxkK# zKe>*;El%-)#~QU8v636C3@7~dME|zme=HoPF!rw>DV>Xhh7xpDh?j&?YyD}_j4x#2 zoV$d`03?zuw(Sy~8ZbCi_hoZqbYqmZ($!)sGDOm!SQXxPDiz*!t>s7rPg^}%&Vrz8 ziRFFu{ENEUi%Q;OFY&E(h9HjT)fWN1q2+_AT*dYEf)9sF<55hMp1&)Qe5+dGrA1mF zO+WPou$J-heA2J(gA1aG*;`(c9qNSRG2dnCPRn>tEE*>HvO6}FGU(D+ckVhSj#k*w zE%P3CSMn~Z!&>sI2yw8S{uW)};PR-P0?XaD)~ys7i)vk+(UEGfy5omzN_Byf2Ye&5 zxLMnjYhK4Dmnr+rxW1R4KmMSS%hX4GHa6;;%_)Okd7=;t#cifZ#@5vy^$Of4Ek4b47^*AHVp zb+9S$JzY0f&69#z-8D!cwwyw+mK2?hH|V32G+mw71Kg|mJK825N%mo_^8?|#Ft?Fj zoBHwlnpNyhe?~NucMK+8t+Bv0x6kU*$Pdf5*LMwHTJ(pw453>l*FM}`wYcT@97k2L zT4$!&?FL*?Rfm=f#@se|&R(CEblJ3CpYAqNgP7IQY)G^}3#)TB?MI!$bR5q+Z!23L zRmE3DL)xl8FAM7peiTwD2BGQF^HAR{^J{NrPdlXM8y_g-mb-PtFfoy2K48A!L66vc z{!@qlgBkaKq{GY%tU<0NuLZt~Zt<=*psupN#A*(TrF@Y!BbBeUAJ7D;*dh2r0c#@W}B^8jmStZU(eBS{7F=05WS_$~b zD$`(Iv=kqg7?x29(pVv}aaFs1)1)0z+@zxpXXcdvc2tGrtq%f$Y;n8-q8s0!J_3Yc zfdRd*d=!k6T>m!G05^HhS^LqmD%(Jj17~dALJq6?o^QrZ;3|iB3~=P+NcXe`CSrV0 zbH>*pXD7G!OO$6O$`m>O41b9nlfy^&xAbe$kQ-Azk_S$lt(Ce8U`r_ss33!v6EIxN z^Y!0SR)U`F>quG$?M~ctn!6!a40%}~Y*YA3(`e$s@USWuUWnzn@d^?Mx>k$Sl9dgx zQ%QUjmeUR4%wC|y*6ql6-LrAsTEX5TD6KkN_~2@~@!-OSiBg?ia&iW(97#9ov#V(PG}2 zo07l;MoJBf{D7d9_af`t3j`9E-w)4jCb`u;NfNL=%R)aD@>b0`GJ*!QJ95cwqgiz* zIr9gX1uwJL8XMV}G;0{RQrv{yDXK{0G1rZk^Af z7B?FEwPd@Y{>bo?n7?d8mgW8VpBFSN3(?;Fd@thSaH)_g9`OocDv}|!!0=0cZ)u8P zdOeD#7a_~iRcNLb^L>`6nwY$K%ZQD9s5|#;b4RO0&ZMOrzF%kU3pmU+vQzlb*Qcip z67VuBTlw(uKg&$js=0Gr6H=Z&5hzvp32P%BZ)<8h3%hnCqPB5%b=ode?;GWU^)wUu zhDOd^5VrG)wbdiSX`2&u} zM>QW9>8khet{)z83fPff(O1QIJb5xow3CL47)EueE%jf$qoUE0iaKIThuL073)xio ztY{5`S-XU3FhSM8mxGp7Izm*Ex3yhjyC#M{ZOL~whu;VNTr3=x@|(%{_%7zYJO{R! ztG(})9NA#bx0oKJ}HMT}$P7F=*x;iK7f3=TT~e3%>q0V!)SS0?wxbU;o(IMG4~YpjB%3qeij zU?`(1p7qec&h45F19n7JlGbVRE2$KLi%vdp#WagfVY6bH!p~{>TA}L!)He@6uQTJY zzA4hoHQWi&S>HFj0!2x&qVG^J&>(;{jebNL`wrLl7@a<&TJNSI$BGD`?WVPk)43}f z0uUWPITSN+NC}F)g=<;^)&t4d=oH~v)85EchoU~zc30kw+?1#72;Lsfw8!vVIBh3q zE1+P`fa0mh3xnOWYypKtYgUk9>*00t*ITOkH0m1|$_!U~}yh({@d%ty`IQ6Na z-a#epG5$&9-iqPc;)&_TgEB^2Sp)8i@}@-*q^iwTwx=C}xxbs~) z*PV4&0giF_j?KF`(_OenM5X4p=)3QINhcbTz7}q^Zoh4;Ug1ik6I}o_{3uw>5vj1N?%*^;7kwFfQ|AS_%%m0a6 z{ND5modpbNTBq7eUIMSJ(CMxM*=8EzZxF?sk|9z_*U*&8hJW84N;i;fM$qynvb-Be z7KuLGc#L*_Muf~n0Ox$q*oWtc`y(8@^_`}3hmXP;(mC)Rv@HQIkvSh=ECf+`4u#Xk8cv@V*i_iqsGl0S&{6+ZixLw?@oQWEoNrOu)6a?p_OT|^* z6Iz7~&w#MyzY{^CWk)OXH^}jbgpZKB1||OL$D2mVZ_CiMjFN-B-y5H z@){okLCT>xh{Lcrq*$TM2AW!4MBi4}JJ@UJ?jN+vZHH57jZfK0z4couNQ`~S)%D(R zPs*vzG#H3#y)P5q?3ePLf(iy-R8mRbp`Hfb7R9W>uI8$;>rAXUbE7kTT&m>Fe5*^l zk~4jxZqyebp^KXLsHPO8oK{k6W9h{g#-~ap73hS}SRxKjQai2Wo-3VXzuXfJ4A@kE zL&Ig*Jb{#mZPwE0=F|Qc3|3hymt7L01_3MwPe_S6J^!2q3)AUm;qd0RSM5lm0xuI# z9b@eMZv?K0aKT62H6rDZM0`%W)pVfMYBfEI*|Z>gLeR0;qRPO@pH*L$P35@`(_Ys} zh3Sz)w1@VsDr`6EX<+2N!m#llWRZ4HF1f}9ifQ584gY@|Xxfc8(C@i*WO!jlJh6#M z9g2A+hdxni-#Xc%`5yjsvj2wgvrdZCjGV}Ny5UyMS+yki7Y?cV;{4tjT{?_d{sd~*+Lm+vof4{t^vg!0E9tSieOj?ys5aJ7DW$j|21vy_yb+Crvf& zD?~ay5INLb#sVWqI?)6&4RL;-K@nv(4Xw#2Z3~E%L6qwZX!%u8M%1U)q8mL^Lu0Jm zcP0fHl`NDgrn4@Af{;hj4t!M^cTzbNZ#3AnvdiqM3SDNsm8L;r_SjNkHQ(nzx3u2!=#)1>`jz;JZIDb97Y3BetCn*yzV3mv z5kKdc6=CpUqbKNY3x6*gtPK_{>Z#RuJ6=10*Qd2{MjJwAtoeM1`hJ|Bm&|?%emg4* zeKqd7W1j;PZqC%aE!~334}Ij6F6=KEfSUq5XggacnoliG86Q#r-f3yH82Pqg!?ANJ z0Hf#3042n`F)FBO1o>#y1KNM`KDvOM>)jkb_ZoWy2#iU0Y{fiY#D_=oabOKdk_E2% zx0!zY%wk{~RpH&_N@JDVoLs^MQ&98;(=Lo{NgP*EZlgt@Z0>=I-;Q@H6vR7uHgeSV zUhL(tG-24vzTL0rzX}}29oRB4o(t~KjqV9(FFJ0KNDmjz4sHv&x|~A$O^7=!>c1ki z^uex2;gO)gvzkQNVXK1zQ>U^y9!3c|WK89$?rOD~nW8|JeR#3c42wNAki(r`Ve8nI zAf<(|mJIfR-02Cos7NyMjG|m)G(x&&WHf(RXQ?YK9bq6aZWd|+5^xF;-~f=IZAalz z$ap6e*@jZ(?=KwnIq|n%9N^Vs-*{x+ov`#c2q%wVZ-9wFD`nb~PX<(3HQMJ~Gc}6M zb-ktpQyGAB1ROOj_T*!3ZyHiDE*?NUwS5PLUnYyaG$Tgy446}A6{Oi+4pvZ=C50srhlhZ z%QgzWq@%!UUf$s@E^8aNm4kB}R+Ceu>E;iX?Vy?+5LHu*PU#wqQr}#`Tva{jZV;;A zTRUDsO6@dveO;A}N&K0!y*QrAj)v)S2G?A3VvYl@ZwGEH%T_coE8P==DqOSCA5!FI z=F0Rja|`}9M=o!(i1Jh^S;dU1_cZNGI(Rd0JLrlfvM{g1Kht9*lIWXY3*F`}qH zfIu%^*&n*D*=1QG_=Nc%+0~aBz9q}FeuXr=<4+O$`wDp!3--mph}3kH`DIZA<%~p_ zZ}_`8wYdK&*Z)DFV`63bKS=m%+i$U<{j0%7_^9I!_QFssDpG9mU6W<2fd+B-x3D6r zjDi($NLY|S*0FX8^ttqiCN%u7)YrNZe?{j-_g}-V(s|UGH zN)r(@)~V<1xHs%HZbH;`x%KJzvVFYlgE%y~K1p@iQekr%<&fIaK{XrkBZf+4iy})j zlJWFSlK$)R{k_g#JIj~rXmI464VOyuVobl8`~8-5do1v~^Ozx#x|5^X{A|(`V!q$a z`?){WD)d2Y=u2-VdF70v78xQsS&Z(SCn_j|)cY#TUpb+cmNOw(HJ4X?X(e5#TYVzP z(YdU;sv+eSi~_pZme657>47jYl*M<6eY;f2j$YQd$f4En2bwm!MpQp|hsbKxyaUMJVZ=iqDESr9x5dwLgl?0h!Oy3#e275PNtbo^3?eK!-y#{V> zP#W)s5l7{(Fuz452FI^|D>_S0VLzC#}z`2@j6fJ zMCFVM4X|S%*(WL(bvg1T8qvif4mf0 zpVB~{1PsA7h4*+*CWGhGNNrxneI>oZOn%@e|wTAlDjR&b(#2n|#{7Tec%Ic_v;9fYYN z&FJ!?KYT|Ggf5+sACc1*xd<@;OO1{YDO^xIsL5DrjpH$4(qR&R7BJB0tNAUK?v8^0 zX39r5ebG6!q1A-G4YB!aYJBRP99*DCsSoW zmBX*UOQouCXT@`2F|Z*`cvPi37-EtX5~s^t`)=L45Q&l7KmJ=193$JM$&H%1E}*f2 z+EmW_x8`b@tNI!(DKC44s;j6|a^!{|!E3ffg%rzcbxkEwXmiw!OQ&OLky)TA%gVAt zOT|GlJX;MFyOcPT_FXRkcls=XrDd;b(USl$;GlEnwyg`>>AsC|sRy{~zt1**aDb1w zZs<@V%(2vUq)}u`!GyHPO@{R;uv^#>n(b1$3tfQ8Hg6{_j6^KbgOtq&^Z^H_IL#^% zdNJpq&64-Uh2>>?43V&`L*q4yXgu}8xACt7W31n5GGUU^ZFDVbtDqBDzh%@alLYsZ z@#tsqEyqHp&WHw%4BdSKZ4d}=hzBm?fnlp&SuCl&9SNHYRXCDu zIiAS~umTM_`{+twa3b%hH)ZSEyD;zf%JO4uTa;*f4NP0AE_(2$8DMaapF5`q3MyU$ zKy}}VZ#~9}EL3+NR83q%0LHl`Z#-fH*Mt%)cFJ>&2`7w? zCWIV9!!x0d7P1Uu@<}JK>a$(3)9J&?oV#-wg{5WU8Cid69o{DmWk+75M#)xbX3{~# zt!v+Yu``SCOl$s7YkeIZ&}lPK#E~1!E{-j@-_26A+faoKsmkxhz6Js;P%EqADaby+nS!KnX0Lp=fgXH;rei1NA10j zwThwh`agH$gUIhh9a|PmEa2en$N?H~`zk_}R95|&Rf6%+C;e3zcqxaL(dv>@CvCxD zLzm~wuoA(DU6|~5^(I>Om~J6-R1Z+8R{S;GwJHm^PJO1S`!-N|*b}fj-UnnL>^`8b zNVvbZnwV9Gzz-wa`tAAWYd~7k4B{-WvCDsZF}`}pCRLEaB#VfzS%o+sXt1w#;-*QE z*H`x6Wp|=&@-l+|T_npcRUC2jk+yqjlwpE|; z0c!EJVQx5b5XKJxb;6H5(1^X-q@(JjO{!CG-=ADkq1}d;V<-3MUC}$4KSb6BL1|x2 zA%?nB1_QS#EiE^bxd)Vqpn&w!Y^nFxSOO2q_pFr@e_RHZ#=1xxx7^ss+eN+I)iqgA zQv%;n1RDJccAdkx>@|P1qcpAWYF?R#k48{|P~SIQQ2P>B8u;a74Z&29zWKC`li%s7 z+1^H4Fka#$aR*SGx#w zVD~ro)ca#6`~m@~vAGA*uIZ|{u4Qi-v%Zo=AIKccsKsdzPT`r5=>l3$&Mq_1f)*Yu z;TMGP6*xo$D!VueMm?ec8;JqfTj%p_Lz855y||tBS?IIGHFL_ z)_RR~9;qL<2Q#LwQrlh%QK+uRR&x4O+V9`sK{`M|pm82TZyQPS2eG=d9WdJ~7C7CV@>f#9lQou?C3W=!_iyxmnOhvc z2y7QlWgQ#O%(6Rcg;A42fddbZG1n?PwsD^?Xj$}@&$)uPUXaI7`;6ydx1IR0 zK2_PM`E)lgEJjD{nERJwO0B%dUKRhO|4luz(LDVG&Q1&yAk;(qrB zOo;sz!n<%Z09+HV7^PTwjXtNlU}@2p{&>B6vzFGd@k|tYQZ-nzo-E`^-e2a2=!GeR z70-f0A{!fBF02ux^2vUCad>bM@xyBkI#Lm~#7FA<)|A!#_OHg=<@8w=2w-h%$9I42v|dIkBhZO(DE94|s7X*)rz0-+wjF#w}Om{*vK zzAEqe!*I$-ZV}E7NuIvbcyN)pYr^Vir4qBkJHkt(R1&9R?oc(A+>bZuLGNbmpBb7S zSk&yK3ZSREz6r8<)mB^x3I#4v%MhC&b#P_@;B1tS6j7PH8!a{?(2G5&B6!^rkmVB> zL-EZr5%x_aigyGJ)PHrr+2?&tO&%{O3I&u^1TtqU&}k&ZNr$NqipN4m zQMLM5y)qAUSHnQyRdv)`{9`==GY#Nlrchk1ds+!-=^<1{yEF;_G&Q9&J0_4$wEdMR z9fYCdm+d-Z$_c~PqFjL{BRI)kMQRXzD}J!gi8HxsdWOf^&9H02YYdR{bW-O-&as2I z*d0PG!N?%+>=%Z(>k=3`*c|Dq^k^8!bESS#Vjq?Tot+bVzPJCe|6oz%3t4g22#HlZ z4@ydwv_NM)tt1Kk=iHTC;|7TOYwG=P@gy6Jn-&*h=R?ja(HbiyhhJAj*=+|Hk7i?} zk{!fI&IIU|Epxee`@wSNS!_y5a9ODQfG&DrodO1^PIrVe#9|2@h00!eV^HyCjU|S8 z-m1PQpC&p9t3|>gh_>>-;%Wrb3Xyv}pE#!m2z{Q$2l3QoiKk){iXhJ{1tcNX<5@5- zT6ji-iLaf*0^yxZh3rH=baDp2ENl_aLF*|eZxC!4ARRurj#tB)*fP;*auXml{&mUK z=>Uhg%kN^%R|0gbWbuPq65mTCv?5;a5&rLKEJ)j4@WT3=#&%?*Nl1o+dL&J5jX+2$ z+=u|{7p5Yad0aL z;nUJ3tCOBJoaX0(tHR^*#baYh=4CSA_&j9hFPP8Tb3|ws+Nn;NLboL{WT-$IBU4bJ z6GBZzje_gYw+b7zo+qbxlyfUg@?|*gtxIn*XJG4*RGe8xA)ct@*?24~r*nVSWfDUW zx*9#9C~+S)mSR(~ZR4{U4p|%|rYQ~A#J_#scoX|jaw(Mp$RJc8vE0(AcyK!jW@+?> z%Ph@S2841t7glSYhrAI18+^$=2E9{Ri0f+Z^q0T8=%0@`!rq?4FC#sG?s;*03cL*T z<|u6S#AF9JwlV_vV9%@452w=e*3nh{*a}94EoBuOT~m6VXk%R57cW1HPIGeklp5`D zV+odw$2dcpC-`kl$3xeawjAuk4E|g$!jbFJ+L!804?!oESbG9|E!`+ zX{xC|;Zo^^3;I-OKJ!qFr&cN}@6&;p z(ucT7Y0843b<8h}R>~js#Ddh5E21 z8DsgqcdWGmyaNX2w2^E+P&7K;fdub%&((~dJ5U)M(mwqzo)QQl)W{z(g)tFRNay&> z^r3kLM|*z!H+!PgCl%M0)o*ce?Tz#FI9SC6DF!M(`*(I@yU~YIdn(IR!VaL(Br0x& zQ6(zQ4QNS*AE=2se-p=F3THwsd!p)`d^3)2yqXehCJhWzTlVUU#sZ zVQ=8{uxG+YVo%2mBoy*vTU&QJTiN40Z@ABSxZY3B z<_1ay-2vgh)V9ykF&ycWkmKubWtncGf4&~n3XSkZzug+0IhIU#I1xUJrp=B(H+&0V zvz6DkDf`2Un2!r{|B-IrSI*|>#o*8j@EiTepe;^|7Yf<#*wUBp||`hmnG+fdl00CvELs+@9kqlQs~0=+mLm}JU9DRk&@e(KDvdLv#= zxbo*ciwkQYm`JZDDew}{L~<^O?7Ko-)+O73R3P%Y)ht;*e;Sm(-}Ju(OI^MVNI~>c zJ1Q;%*RTS-UX||xwWx=n(Jn4<{{K&>e@&feJTHjLii<4uEpX4zB1 zga+65R3*5zrH~gI^_BfB2&X=W3xyz9_=#0A%ljrMKkt1whPe9<`UX$aICBlpOW>Jf zRyxeqIw93h(+Mz0C{ehc&m?v%KU-+{57lE98|4;DoDq`V#9J2Hmucw4L^Xri-%8W9bz|P#9N#Lx{ejt`;ZgyfSnY1R6Q6&8X;w>_8LL{G|PDcW?2#*UL&7@Q*q`%MzHdxtJ-L`i z;=)8R&p?qccY1HRWoq3%n``=ck%LOfh5+Z=@Bp+XqlvM<2GG`3g*c@M6b)093Hrp? z{4!AizS=~i)tN}1*GO>1Ih7WC;0{0DpzYVeN*Y3nzM1ff25zUIhJXprKdWLnH+2%T zbnD&?3oQZkxxN~FE6jjEj^D_vLFrcB;bb!%fHxz!qT)@80> zWFBoTC+uhjWe{qdYt(Ry2YLlfWZuo%PJaTTnJn{CEoBgb*(LxqTB;^hJfNW=hkT* zA6c71R-B-6t-tb<#+cTX9H&3> zm9Rez4)~@418ip#KARw)nGuCKQ-)DSaUZvuXuFPBqE1sYQR6rbp-W+SA3` z1iMXqyXQ(Y;ht$}P^j99c$JSp6Af}~){P&|4J3}fsV1h9HFjo*EkeuRBg3cq!bPL% zZjC_W$2?iN7fhKqBHWu>6VyAC;TYaaFjYrPnwegiq_&Z8CrEKBkeQ z7jpPmsX5n}2I*_5*Ie;47ZmQLN7I>)*6Xp(qt!+pD&UK|c1h_>VkHrh#s&N!A3x>( zo2S9V{%Z3X0`=PTpO|J4EwhaNlEY!r&ts1WviX*4oyNk-s~N0;-?JRCfETC+fT0r| zUCV1|EWNM1?L)A%RsQyymb$8Y#)9ehz=7z1aC))43_%v15O(6P-*Bpj!V}Gm&SpPC zx+)Md0aZrEhtzwf=p2KPCFJg6_BXH!TSjPs{^5p*^JkAczEwvd>bVrV4&3kEW{g5S za&#XI4?9eSAH`eF`ueM7NCN~9wenXRBqHS@UW(;-;{AR>!0XSLcr80ZocDb>Oec-X z8bCtL!SQpLP*=xIsM^2w}`$D7~)(v7Nd&sLrQ+j7FQ#o?F zXR2c+r<=jUB*o^Y^1l3(efJ{FTxHJg(AN$*F!NIA`rQ&ivEga*ZkcHzFqpT4_4q64 z@F|ZDoOO+!Kl{i;S0=-7G5zhf)F}a^2kv~GIVWkgP+^1m=)$S)a;Pfkv;2;+_3Txb z_8x_=_+n`fy+ae-%Sc4UEYmo^mmsfxh*arDWBCIvJ+`Iqe(sB_*WI2Mvze_Eos2VN z_EB5^d8wn~)P?*{_tju60@1dd_}#D`nq6V|&L4#?JiLEGnurtC?qtG>iK@1tq#KF+ z#0DzoHhP211=;7~BmBnJQdpadkL;-Gk2xE0LmD@OJt+}VSG}*_9tz)*W+vIGQaVq3 z<8)Uq4c7xV?H~6)`^+D^paTYYjB!DgRzLbf>v{{lF9VZ4)l+5tJGk+#{azl zeubl9w=w#*)f2D^61><<&Xg5soQNh~AKfYDhim&0r-O;c(GaFsM4~X=5&3oVbxb%U z6!Xskl;{&Tik0xNwSv3a?po*M@cc5-NI_5K0)hsm#-55A>WJvU>%x6Zf-Zl;=(>&g z{q}XSH~RG1=jPFrHCBZg^GZmQz|F<>WoJS?5X=nk4`ql6d3~EYK`{O8;PJc{1;l)b zG~#5SAHsdfF?V_SMZX%J{{sn0g8e!z_O(1|&>w1b-o@qR6hd3l<`4LH4d$Lk8HEKO zck44kf(gCCg!vQ25p)0VO1wA_TQCFWvft(4HwUc7t(F=Y;U!AH z=sTO~LU#{@wSv-z1WK$e1Kuh}O+AhvB(jFmKVL@+-dQ#-ImeAz`MyBF;%Rx4vWXQA zWKd8uDH245VDW%tJCz5D0Ztc23bZG0P-T>{*_9<#eC1xH{9QixhELhM6NZF@eiMax z#Y!xyE|CZr!uzl-gxm(77mjA`?JK4vga~e@NqML;>Gs)0T^jo(E?KpB&I9o$yIGmA zFB!u8wG9}XlNm7!nO*rBFhTd*Z-+}(6bMO;(p@=eRx2AD*nT)=;6;G0KY4t(Yq$=V0YU6sr~tF?a5yFw%7B$j`DcST?4Mqg$~=kIo4J(0vN24 z_Gnif5#jr#8e5%1e?j@+e8ke;!pAwSOKeS0Y`CbU9fR$TUw)ouE0`d-7b-I!fDNl2bir)CHpHUV^ z8p~Oen*=Pd^iifpPdysTC-v;FHLfR=ofMiHGWWIrt*5}b2Xh^*|#J7F&vs! zl~8y8M>X7m+FOD6&9cEX=wO-J9|Cj|BWO5j|2KgJr^Vofq-e4WrTw}&F1dyRxQAlu zs8HqZo)FI4jGBqxm&-^%$gv6c;LNxRlFf1O_U-B=!R>NYoU|c9pobpe!U@&DxD4Xp zs`gT<-(1qEj_@ed2=S7i2Iy+qW8=)j_O>Eke`%ruV#>xFylcx#=|gWj>MixD^{uWA zHG(8M*x9N#jN{RM17osX8{!4?97SNA7P;bI$sQ1DWG`X%)77Aj6~)82rU~>9@%uRl z^*ft1>0icAGst`lUEJ^;=|NF&mRAXz&hkoMAA_HtEx(0M8B`jN9uk;D0^~}CpYX%> zaVM+Cn=m0mmggB3RL|1er79;y*zPQ$tVd#*(a!?=O`I}TGKae2_mgRXHY@{i;T25K zp+=V(g_j!8SWf3iSM69>Y&4%GUpbLIoxT?&K2<9$Q22VT`Lsh({p;+c3iz5GW2SZq zf8Fxj(kpaC9pQ&3JGPKV?-yT`y{r}mhW9Z+vB>SZvFHh&u_l_ow|Wbm|@m?Bl z+TYK!=q1gw-)C+(JX_~NptY25Ql0NmGjc>_p_Bf1YBT=kEV)aiExxrrgLYi@c1*y# zD&7PNlNr~=k?#(9IP*CKDx&D(E5xx9^R2nTMfKSSb)vIKXE&XmORC}Xh~*@96PVzNfA=Is!# zE^9!$=bhYY7twO7)YLZ2w|8eCq3OGyVt0Yw7I(yeKjhco3nUHPw8L?bMe{TfVratd z)QH0F1~7ylRiKF1b&xvS?j)U?!H?!6dlHB4hdK8yO*J<8f?W@#aoI59<+Sv9`Oe2X zzy+6U@(FTCy9}NUK2JH$@B$JuJEOeD2=$ z#H8inIQcBwFfjPeE&(w!ZrLDViCER`oi?P4OHMc?C zoEnFnW?!d#28vD8zZk|%hX4`{#s*WKG!&kE0@Z>FTEXX{)zon$non*W=N@j5B|I}s z;%bs?N)2-_-l6QOR^uTWw|3U@WI3hF!Ak`dy1)>w8uCtO(&t)=h&1WfC^cK1V&2W< zSFB`@rc@J#j7_*Tmb=RpJI*q|6)m%)E$l6(@w=mZG=bM!ZDlPNvySi|sGVicm5exz zkS9JYAxei#f2>2=2E~Aa%XE~FQhJ7+2IH0(IF{Y2%4eI=3I zs(awP4k}oU-$GsKGAFo%V$_9VV3T8!V(s>gN*NKYM~bZy7grugf1}gJT0Fnw{kEiy zXhVGXUKcb9jeV4UZD2Qbd9cQy$@TGoZJ;;_T=ucK3s|noztk{zp6bvM-SB?Bsv-E} z1arqrJcRR;@7~Sp{T;fGXU_2ftJvjO|KtRwkUn&_a2@ivlrK!}oqT*|Pp|$WZRi0v zWNSAwITmfWU?J>fLy??Cq-O0?)ZlfB8X`|ID*lB#XHTlmAW!x~DD`JJ>8$%bM=yK0 zOcp|=ROqTkXCW=aS#nEuaSZhfo_Vqyp$%(-$XN6JGS0`@2(fha#mt~21ppmv?ZscW zq7PoT`-5^5Mev_l>i^BS`+wwVj7^xMFAfL=h%p2*EEAb zSZ;=G@eWXb#!5M2Idq>r#pC=WN}FDYFVyO+uuJsU^f zHv*IJpFZUu#MptH@ob=Iz)Zwuq4#>vu8%-XMnCB{)$TR$Bczi=TZX&MKMukqqd=`M zGuov|4(ck@<-6rB36&^#@RFR-+TUkr#H7sV5({*IwS4Wdy%7mK0eMe~+2^~F1#SiVo77q{F8T^Gyw$pX8x zlN646@iS&X{lFbXP*aa|>Cp@nHHsbsl*CF&p=;&8PyW?=DcQ7D3f)(uoZ2Fwm|$XwSmRfNsCs( zIuo7bFb>~UkaOQiZpS0d3gMPM!|zOQ&69|Rh)9|dzQ#t0I#Nzr zoULB2V@-JP2RJ8a;Ojr%$^U|mu>qL=SGUNK=9b-N8?x_lMVizlki$n4I zhgK4BISZ=a_Er26dloyAtYQRzl9ypl`7{-U zK;D_gosng;PynS(a8;etZdpqo%F!9Q+T7x#HD{$-Xq%4E!me)Ic=Ap~xyelbZIc2D zl92Q_+O3mYYPZm4PLk5RM7LDf-NjRY-lC!UTA|jmg#S+ma$~#d`nQ2rZMs&D9qK$# z6(q(?GD`f2e@x^rOS&uL&P)r274wK7nH_Lb5$##2bX6JM1+U?z3mcsii+FOT*IlEh zs4}+;8iDR*5(E`jE#n^XE0E%81)mh)nkZD$ue?-YGjT%Vt2iQxw`b02z;&Ovi+Ip7 z`>((Lft#Cs9s~{t~ zLoSm=v^J39{HmYflR~KL+y)h?ng8r9U__lz2-o4r; zFgGLzG&RWi&Z*r{qTc+=^3!gryp)BC2rXU+4&aEFQLH!O#okE<;P|oYKOlO|=mtgW zCeWwq`7)eMv9P_A2Oe>1HV+{ekfK;t23>G7x_LY%Bf{KJrEE|XfBus9D&Qgj33n0+ zsv5h5AXwFp06Zoux*2V|2hhYFz_~EfxtZvK;N>HF6@=uL(a5d>fx+p%A0~^9!4nij zAYEaw-z7|4k&AZn{o1Bj2{8-zpvP5?Q8RB3B}0kmuugd}#QjKw6GW?a^( zRarhQBaqzrIiL1mRTwi@c01A1zjRXp@LqpJucTv`MMU6QWq5+jr#@J&;jwO#;7vOb zLfDK}oS^^a*)v1CH2B`CWOp+NK_`A3{PRoz;DR58sohga8MU&|l z<37}+>Uk%5s5;TdGgpH?KtzuN2=L@bjC{5Yr}?#-Bc#MVR*j+613^^ai1N7v(B9f z2YIVsc3$n9p?)6M+(65T3i%>$94x`aHFtm!Qt`>utIhxV{wrSk>LpldUUsF?mAQKa zA$Sdo)tNbKvu8B8;1F~Zt$oW{9gB(@EVN8?Sk5`RFy54FTl>{z)9}kJ8SJ!^dm6@; z?q=CR#wn`mOSWZy^MNdHZZ^4+_UU3v!ElPo3gSbw%oiw+b%}|rBfr(>2R6_kLKa^v z1nI{n&b-P2^AD1}Pj~3R4;mpps{G_DA@X|X(_|XxlR}>dJ;ixRXr^AT1ixc$U>!3M z@tL?niwq;m`ul)_aRf#=M7Qy(82wl%fj97yw9vkD#oma}Yk-M{PVpOj_l}ACzID6w zVG{xL8Ba$|eY^5Ol&CZqaMCPg1>~4H+~P>hvGUS7s=+Cuoa8V+o&|5@=_p_|3N7dS zDGsc#2G#I}wLW$fXnzw6>-;X@Fd09cg5UVE@JU**D<)wa4j6j?@r5(-!NGwf9o7l&QjIQ zstkKH-4ktPu-ia?mvcD;#ZN`_5?bz|mPHNRJ_CNc&!<5rS>g!|rG54i;UQC-$}_T* zsA2`C9HG^=U)-JX9GVV5CCCf7z`)Sj15 zKI-fV>qMuXA-sdH+McGsMTMXBk((aB6Q=peX)|-CeDM6hZtH^TiMu&hXt%H_>Kr4m z!N`u}b?fz&f3ZN%)^=)9Lr^-Qn(TVo9|Wr<&C?wejBQxfZfyI6F0Bai`?#C@YO?Mx z=Y(&Q_3D3b$&_k%VIt$XL?dT3Z?H={$8%V*AK9yU$>%k=n5_#p_nOs^I;q=XLusGV zC}z=7HXY$`Q58Tn2a985hc&4>Z)YKw|#;Oim~%0P4@= zix;&ucn*QER}M@}c9T85vz!#o7S2)iB9Fwg`*_YGm?$=H+!n=S+;IQl&+s(P1qG}l zbR5hB1U`jMz(2%w@Uh$D(iw2*@48-t*7knzf9y@RSToL^X0UrLwrVu5F1&-WVMMRZ z-q##b-1=0AZ@~7hU9=JYMM7!Pia_N~^QSu&p?xljBFaA&o8!$hM@whkF*iuJAfk@l zcg4{MPcJn8h4=t;;!jWrlZH2fajI{%#SU9;qIyBfV^0?QGiVni##FKM(uv9`DDWmT%vN4lWL! zfBw3^)fwpg+=tfNo9|2v&6Luk$JWtn`K&CH$!G{leKUSNdY{J@=H7t##^VQ$6*9N{ zFpK8kSMh$>b)4}t44_ zh=(+D=fnKDL3SOA{XnFenVanwNW6eL6?ijL7d1-%fykv`WcshD%laRjGe&lH=KneB zV(U0gd9726i6o1N^esoB}3IlDSNK8Jx49oq}i zbo+tJHgI^p{dQ6X`dK!}2@^c&#%gvbLfA{^S`phJ08ALaJhI=8a_hln6}Kx1jNso^ zU_?66D~{V8?N1sJ6SlKANLv5lz&klo1VB)iEx@4lZo0wNXjewMVfAI`WTBGkR#PkM zX|8}VRJXZzt2;t0giHecSl7`^YP_S2Qty8s)&S6go%v`;ohI;DlR9HCK-!T8!JS9O zHoysYOjJ4w01gIT_g&JHk|Yl;v1!9BF$Pae1twn6x5fzY< zX0|L0H_LT#8V_mqAne2Y`=2S92XiP)BnS+zQ|-@?B?uQM`IX467uFx#TUl|=!*knf z5+pyn(q701S5=)l@p*r=ETXpkS~)+a=E<$hREw1a4FH7(T1W!N?D8ZCrk7^M-Q(}kmMqZpA`$94h1KeR_Ut&;!WMJR%F0WD z@>(rf>PRfFE$>BKX5)xgo7(>w3U2qX9^&Imn>JhV8%YMHYmE=3bD!nYE&>XHr~f`5 zF65WC+bg4a^5*zVYe9;Nifb`qGh2}3h|M}+Ldj8?^l~)yGO>@KDnhKg+RKUWAp-SF zK+y8t{(F^8Jt3pG%bk&)Fu@xKJR|TZfs=Gd?4VtdmJ5w|+QG0vL>pbZd>BYH?n6^= zrr)-K7sAnUPF~&D*FZ(MAAj19cfEiaZnRt^}{#3f@%vrMEBQm7ng@QlWi5YJ{6}svYrY5zsRy3RIta46GlG zkW1CWFjUnkrS11TbITTx);9CCK&c7Z+fp7w8vrCU_&h_1DFESU00hmoj{e;4>=IeJ zaB=|TLL^V*RS>Nb8dn*EkjeNZRs!*R{D;xa&jk{==Iv*!K|}iZ@((&jCHGf0`T=Z1 zl?65A1XVgl3?s)KL;9vmM;;hNLL)0C060}*CjrbT{=>}T1QXg6oHDzga6A)iffX#~ z(0^1!s&F;GUAJ^fLd;i?73{6BdldtkGGf|KUUM~wSTT_S7KjvUFkaE>rQpneqol=r zIc3i#{a2Eg>nLP*Vw|nu#HgL16hCp@t4JO^y<(x;a7fn$A|( zJ!y3!hlqe5VW4Y23(S_?p$I6EU}qb-7sO5AdhIN3{~DXJH=$|#j>?f&ct5iA%p z(=n`}mpFV+7qLMpO@N9nsu&Dam(yR3wO?*tl?V8BL73-2B{50twO2!<2#nCSNCyLG zPz0K}0z7Cm4H}w&ktp$5U?+R*Xy4TA-XYve$fh)Xw!3P3aq*7VYI#urj>Ml@*Tme| zG`%>BF*IBrS*b}@galVvsl;Hu*g23hVcn;>v0FnYuj9Kb?l53fk!QWf21Zq=L~wZW zDqt_MZLqZ-nb>$#CohVw?dIEa<^;REP3z;J{oLX6VLxm62Rzxc{vj%cP2e5w4+RA27u#i|t7d>nZzOZmt~J2fQ4R_Q6TAY-Q;R8Q*6plllaL zLrmh2%mv*ghw0-5Df!EuQ?r9sbRMdE0}pGbBRHeJH2#j)xKE^)>F~ZXRl6yTO2V9l zR>HhnE#Z_u&DkxQ?&+GaN^Hc_QLpmwUj4|ciVTBRlnevvnt}|Y8qzpVU>)lme2H)) zArd{d;E;HC=;XUEA@VV}RKuN}{iguzc>=ImTW3`E>5@?Xhc)x(bH(~7|76?h#isVH zPKKbFW`>T=E;pB_=j(dtY;0;MvS(-e)7!)KnD!m%NIclt?f^gek{X+?5 z>*(&{-Pf>NR#tANrq*tzhs(p$$IIhs|M>a*@^DN}4TH^$fGW~OVD&~Dx3l%{Gfe%L z;g_0}_NRWhRSP8=K&ytcFKovoS>-gb<%<|ghObD}maA<-QU+$~3PXD% zF9LeEeBRxJ;+cq?nUIJ%SER5HLnvrN?lwMMoRWqv49q6GsJ<$_37Nx^X2}=s@0XZu zjzUe-OEhmobFhvr^2j55Hj{Y&E3i`-H_xMg9jsq>XeAxYUa%%yMdZCfMdS(Q={$T~ zpqp@r%E*Tr_QuQ;h+{`5O#K0l&q;QP2NdQaOI`Y}D==mN6A2xIQ9y7Yc*-B~UlYjl zgZCQ6Pc1a6gxIzv5JsIplZ;@?C3S!$Sw3~2!!LR zLVZO+@W{7P`nJjQT9%3vMfvDtC&QAKTzQSZElr;-=n0|NV#})-h5eRB0up8`Xc~4p zVBt_2l$7!m4LiCY%c?EaQjQ|IGFO-o_T?lkzg#iEl#??QG9S?hQuq+m1H!oHumX-y z>te*Euf4%DEElvI%>?;u3hT=4EJ5OeIt%hXP=Us1bZI_v9Hk)m>x)l&sHgidXTV5=U$1iWBgHo=(-}uC0=h@GHGzn}Y}o6rcqf zET9G6K^bQWui%~n4%M{;k>(01iSoQG@bGAeUN>J}Cy{@0kIB=Ly!So*cn0JC73|(9 z$l+t2AWiBovbM`qQ9xvTc3_tpTf6TPNM3CI%}qFNif(dhh!Xn!wwHT|n1kir>lYav zeLu|?C4nCB`n0WBcYeqPKXKX=ZfO5AmH!v@kcr`cms_h#{lhmP{k^H(Enh0o4M8JF zm`#Lba{vW1&+6t7AhNQk1*%qE9uU31;1W`-eS&D-YNL&~G$_Z43EA<+1(eqlwdEL^A_CqAr99#F-0$jJV4^>RcVwZChf>%yhfGLZ~3&$^RJ zA?s@ZlgK&@{eP|N`j1MVHil|1hOPnz%%kj4f_K&D!$e3oXzBO>4ZvSo{bk~Yj&{|q z!snRl0p99edJM77=2Vb*Q6ZYUS{aGhocNUV!>esYg6Bwq1A7|6#ZlVY+Def3Z-sFa z$%ZuUX09LD{c3$?VuCA0Y!koC{NFM`+c4Q>k{SRE4Jd>|Mqo+4nV8eOsb_RE^98qn zLle~l=~yLLpN~n|uEfmG32t8g3Gy{CeW5%(t5DbO=H*)50q3ZHWmD)xeJh(54{+lg zTh?Za4A_OV_vs$yhe-qc#J%E+nn_%0q9l>_pyxl(4|934{Y~QNmt1DE*V!nb&V3qJ z%j_;48*XU_Wt)0jIx3mTvD?<#E7LO^peOM#l=8ocF6H=2xGQh)AwxMOw!KTt8|A z2rq$%`2FhuJ3s5T0d%@Kw=J73PSCu>JVxmm~hy6osS^OAR0jqFl{Pn3%;!b z2SoOG;9&haxUWS`q**Y8MItKH_iMy$p;yV%P7^p9K>-`c zd#vN)^2JFi7=%>Vjxk=PQB60yb#LMJ1xTcslF-p8uWKt_#X(;Q3n(- zzxXQK`0Qs3yMI3WE{{nwg~KD7tp*|iy<^I4QoOq3nsZHC{z-M`oP}|+!eo)z}BNVgQNyNo+BTYy!1NT~XLgxB~o!y4lFd|P$6QXT7TI%j(Da{V!D#3|z$ zik$G!w2koP@qc9Y=S_P?qwAA-;EC3Sx(qC&Z1&DgC-<6@-qo85Diks7Cl}d|pg@5M zi1xLd*HKwD^LKOa+Iu+yb1juwxXOcS5bTuMFcK+IR+jocq(;4tBEH^fD3(2kl&po} z<3;C$g1=x^bCjNI_TgR#82326!1~=ZJ*K~{Og_QKNR(gG_{+E~Z!y&B*cu0aB0f0) zFykXZemfwvx}a>N;kpmAw*1SU8|J=5_$yWlS_Hjff43xXztK9HmaK0u#eP;7Yh{P? zGyCq}M1ybHhmcu5>KD#Sf3`{0D4RU1*S{f%SP;=K>dW+JuD*DxzTd3mC5@HO9&4;h zb@kPS$f7fP$A=m`7SO*q2RjeFwK9ICs~xY4s=f>vGA)LBNSQ(ZdCiuRz&;oAJ@$Mh zqHAD*IN3WCLQL9ae5%Lr6Y^Dfb+T0Ylsqyh zP6#?}RuAFmguVQcqh==Q1z|_rnpe zIuc!mcJCZ!1+#xh2zd{?yrxR>pP%kO2txpN!2b*c?8ee?T3~FJLh^HZ6)Zy)G& z&YY!flFz7{M7YgcxBQpiT7<^F-@lw!9p)D;uvbHu8)$r9@Fv<=Xbzn9&rV)|LrP8b z2U_6?v_{Etkc$In^k_*!zSu&7`)8T156c(ryMS`S0eIe+pBy;2-Q;_*Y>W@-&@N62V>{d9166p*<{DIlO5Z(ZSB~$ZQHhO+qP}ncG9_3-PK*y z=i&T-^*p~dF^0lY=&S&GYfJ1E!mBKoW#aAL_VLmgfNP^**vcdLJ@*vVGlF(VEAQb< zv4z@ztb@8mKkW=fQ@&ayDk~p%!Bal+yY9P1CTm5{G|f`JI zz`A`$s;9qY9)#1`8)_{qB+#ax`#N72)q{T$vxyR%r)9@z(*Vk!F~ADKMNL;R>*A|G zGTX4^%rD?EtzS@Cufm?RnTSmgliGNFyGlC#nZTcJS~63vb3K&LH4vX|e2EUI_#*i_ zE_6c`&Kk+(66+DsWZCROm>vFP16;ZZ=QYy z-;xQc^c1(@pR0iAx(F)TRoqX~@ryAyx)z?@Nw2U4y!_*^W1`h*+?|f8r1kZRH2) z19iazPHa;4m<_EtD8fq%7-mUe{VYjKG(k^HTwWW{%;En+JF%r|$R+z4&9hCu^sqht z5>$lOWD7=z&+O;KkfAyUUR#jGbaMkha8QJBakxl`8D#&3J!?L^bLQ)J|8lyxl5UU- z=eMhKp>9{OOH)Zoo2{g;kvjX856mrL&*U2-K%wm%=fW~cSG||NO*L!k3F4Y<#H6&4 zSzTBO^oIgJ7f|~ePgses2Q8!XrlaQ;@!AQB;xoNC+H{O2ohCING}3MtHkT>In&6WbI!%sl-sHt)3su5d4)w!) z9OR!kZXJnNEQSxc>K*!C0z#`EAycDqt+HgN(B1hZK{7p zN@6o3_1>8=tPc3IIX$PKUD!yb>ZzIRs4=wPF{)EE%o2m#x!jewEynpUv@Ih#cy$Y3 z%uBWE&m3Tu^v!g^1$B)K%cLxOej<^9)D$<>xgJ?o%-vYV#naWhZfHL2sB4jzl`VARE%nLw zx5JT(goc$&jXI!oiSqlz z;hhQ1aOHW?)7I!2)l2H{R&SU4g{QF-`5SEH>m zrJ$n_N>hi6fw3OhRAYNn95h$MXf*pxly+qxB#(fb7X7wrBrrddL;JJ=S0VehxC8dV zAxkL$GyTTdkG(^pR; zYHr+UsL%`9>CcOJjiNs$r)omDv<(8P6 zL{8Bl&^4-_Zce(O{hGMyu{CSw`wU1mTM5FBp1FH@Y#3t7-%`UPb;;J7)CV-vyA}}e zxIC)dAnilP$97sI;z(l_%7w}}@fOAkBU;6CM|EP8+%Vv!_BS0NLKfTvs>i?amk%fH zWy?7oBpqEzQwcHm+PQ-j7eD4oja5|E_Dne+qJ}Q0lGAN}@N(8BR8Ex|bFVJi=UL}5 zzfRQ3VD3&-dZw{aL7E+aop`7Y!0f|8M5*YU??I|W=bMmta@|UqLqX?N#R}YRCjM1z zbEK(fs4(l-D35`askmT?U$Xzzz^4-4UDLh6$6vnQ^&oEKMeKb@ZBTF17<}~u#{zx; z(!eGDIiJ-vTBGRT$wf{9kr@STs=RxqphoibXF_Yv^0fqyB-=HQ+XIUFd;R>W6OuTF z>_6m(y05}i0y)_W=92gO5R_F!Vh12Ru4%Oe>}51@rdLcwsV%#6!w~4T*F;@j<6q#T zP=oq~7gm|e9)i-tP;3E9nZ%%#)srL1RHP^7D6vxcnPJfyCmp%9J-0Y$>1q1YmWXNc zd-5MriXZ|`@*q{{G-Ytd>6-24Q_4IW9qS^<7f%Tm>ZlzfH<>O!@^|2M$d9}VHUI7Q zGRX6&z`-Fh)l=&?yj@ZT;wMNzNO(2&$eY?~<~0fz0EpH!`!GL@HIzc1;(8-Q3IsEFK-`uer{>)jlq>gLehZ42Br1>0R@iHXPR-pb z0hl;?YzXOm6&}@ho;i&Lu;PFVAzK1^yWG-GM{L}2XNg$qjMH#>_TmLwBnv=k#~|=F zTPIA$n+75f!5Mu$&ELGuQ)`n2aXR#5PqAI+L{G!u0kwQnRl~qn&H2?2RBOSOLo;Mn z?giI}uxF7D1ju}OV5|=1vgX0lr!;1Katr^ysw5KURKo=#&mpV%gR$b?vO}?{2*y0> z;qcni;HB3Ae|xoz<$CucWD&)=l*8(x**e9i@rSxU2z^i(JO4Dmtg4Ve5-NL31L*9b069sV2Gh`RvIOSSW@@C)@y{+*gja z+fl=!XT_=*v5GwG2Y1S+P3?_`3EBqU?;joQ{mbtad-PKBr1!3A?VmuAYd%8UtXfSj zrVzN+4wNzpe}Hh2?rinAZ3(ggntmsfg4(S%mc*W(d1Xq^Ezb+Sk=?^ zWRiu<@k!fWpmmTNEFxoGFM{LZH0dS^^$vc;J@Y-!RE`ZkRTa3Ue?)fdK_G z3JV4xyGy8={@e6X7A>%I=YNnU`}jkjL+Rc(^b&2?l~idb^4P`?IIdkpwr)~t zii`RB;1?02ZMHd=ahg%-eP}0j_|{0Eh%5sq_0Bn0QzeBH)-dPI@W!+Qkz<2a5pqfJ z8cpwSvoqo*7d8!}a|uTq6$Lli^(M`Loc}Wf-?<9tXK5aiL5umW*nmN-v7DpoF{&`76?ravT>w%n08)KpI2>E~*c%IcNp zL=Poc;R&9Wd3Qc-pSPygYD^GikSN>2xplEy>q1rBoSv^u>ed0jLXvF1nAEm1l$Iz$ z5nriQY^J|GNK_T*lh~k15hdeV#epM>Y=dwU25*AU(hsh9M1F?B7KT`YBe(g3tJ;;p{Zh#dqX$Z31zT+>~SK)~Sn^N>M@}d>sw+Ax0 zg=rAWl$k+}7Sr<@_0|f|@px23X5YvzH1mrQif1OAJW`vAK%U}jBbVU%_B$OBxSRgy zZ$)c14Gj$rMK+;RO&yW-WP+RWyWkn@AdZdz7rJB0LSDk0Y(a z1NIIF!51%;pbA?N6^F?pl(4cps!X#3tygl;kwafF+3`#FDNR=Pxqp)@vUMqVAT?U1 ziFq$2W+9?d>;G6!?hUsq$McaYt+~#2rjq;N*^?6gauFXQc0)D7qP11zV{TyM7zyv* zKvC7IkFQWN!~{*AP*zb54!SwjcxR@D0&}ym2OS0!Vm1`EGN+m}grOaKml3@1-#22< zSYq#mW=o2NP9aeYj_WGcp}T0FOwG&3gkA-M5`~B@B$m;*j$`c0wbkbS!lgcKq$!)E zn!t2HpB#HwQK3F*CRRJLt!yj2dWdUQ)ZNBu(NgVi4f|kE9Amf`mZ8lIAKkRigCI6&^)&WiPs+se8!4=Zah3szlf>G{Z_$SN3zz9;@O#$D=s6vqP1$lu!;28D|AX{tx*GRO&8AQzsO?`=dJ1g$F zEHiCsS!k(Lr7JsY7mF3jAeIF}>_qDb?XJD-2pLiClr zNO|Z+X!Qd1!%@`mo-I~XXKt|f`Bmsb53k90*et|x)}6RNNqQILGEAO_o-SS_1IZg> zzEu$=8Po{>Uz*Z}mT`}LscV%vT2uZ~^Qb3>#4G3D_Bx|b!6{^sVQVTRbU#sSUJY*3 z=9zOdre6pwc63}mwUa}pTPC-T${Q)g%%~(o6F7zlQXW?YOzfBd9bMHl6;mBR07J!% zdp8$WkNaHe+9I9ql2rh+jolwl3!-tqj>nwhr&vud%uKtgTus5PT8Sug?Oht@v);^F(Y*V*?I0>#8gpa2NtGX*C z%*DRhKh%_KibYg{f`64N$%IqH!2rsw!1y=Uylco{3o5IO+ZY86bt zHSMlJ1<#dJF>Ae}9ni#+97{*Zx_dRfLOx z*qHxg?=*+=f;mlmkPiO6qba|U#xivV|FzYZuHoH=nRJ58#w@VI4{*rLPIw9{swS_Z z@vIu^oak@d=mEG*8Y-`bPZ$i9fpYzqUano(caac`5!{Q)ZZVBs)Ht#m@$-8AE?=nAV zaDBVX&Ib;m+6Pk;89Uaw_es)cc%)Y3|9oey}smcNkD^i!vMS6EsO0uiz^r2C8H zAO6CSX5^c$Z=M~36_MNm4oDbi>=D*PGT>nLDDSaU$T{mj3!vEnBKhD~U=?o64FwH!OSEpS6EMxfrZ z#HkH^&*fX5!v@8sWMQ)%O2q5o)_QGaf(GDZ*~jlDbR++999Bdt&xM@6n}xdsVEwQ6Xq(iuQZ||q zymoZ@S`>b_3lNEjd5&7w*S7{`G&Pzx3{HNl8)c?kVLzM=OHVgrDxk3W8VgU8j&iRq z0JJfv3r%Z($3x)D{&`JDMafLj<2~KX{^Z7%`^BmTX$IX`Q43{P%=eCsc8$Ml*IiA9 zKHGV_4oF#z`@*8E*tdv^x>Gub8hTI|yj$nH(aXTnj{L>e*dUgpg{H5=oWvADL>*HSW|rePiK6Y z4RQaDh1LSPDn<#{a(Q_0M{yYk<_%mq>E00q0(RTVh+>T-Ys8?iVh*!LY>~Gt;fBjf z1=UkdTzA=4WR7h6cDJX%zBQS${5h^`OmyLf%iXgPo6?E!s>~4Qp_{KaC@F|M^0Ar3 z_NpM;?4;^zPxWq0ljLjDFw#hzPT9M)oXaVcw0VvYh58b1rLiTB{KDvS$BiysessAc zri#)^Y^kNAXnp&c_##Y+qJuMtgp`-cS*}HJvnoj3Mw4kYsp6WZ|G>EF`wYi+XtJdf z>p$*xis@bwX@%#}{=SZoc9ot0Wz@Ku-4>>tz{J?UscmGfRvCm%nt|DJDKaU-ok&c> z2EJchgJbdB5=@+<3#)rAl%Z;ZR@?O!(Us8M)>3^)8cHsVRu_rZ-Iv+JQtTqr>*uiU zA$iIrwqx`iKpmTFxJL=-&Z+*~RXm&gg<^Z#k6;RHELTK^bg(AhS&1ZS)-AkB#drto zmc=AP3HIGo!I0~=tMs+fBO3Q0LYy2X^qU-`2+|it-tuMD3)W5-w6o@x*EE^f_h>Cc zy1KdlcpF*t6g%Uy$eEkS56=pq47%9=#DNp`;vx*E39XJ3)CBp7_OsH0|0^I$6h|f0 z^;5D(I;O`!sT!E_+@sy@{Xj1ic*Pyn^X&v%N`9gAJw^pg-%GV2Z4^PrwIRiR{}3k3 z=9wu5!5{AzvhKtK{ZQoTEn!1!XhVC2ej=RE>!sioO_`TQ{BBTLS?tZ7R@e?k2Ib%m z3)>=$B;@iTaNzne7L;j2j#sqZ&rphg=e3Dxlp1rIFg}_zRp!;8mku1CZOYYlm>8C> zozlPD7w?DKnf%0vb@(IZuQ~oRk;8E3!i%RICoYz6&z%5Qoz+f>{#MCfK4_B!gZ(v_P09Y?s`C2g>vi9trQuiw~D zk3SiJB<6Tt6H}*9pDn-K;J~^;3n0c9h$b#zTUV=CNdg8UsW|M%oWU%6t`(eOUaZP# zjAa?-Ml~7q4pi(|fMkaHDzb}z6jn;hR;z?EW5`6Ap^YlyvVc)kag6|~!Q5$a5^6dW z0LOMiZ`fJihc~qx4m!h@b1{f|$F;1UnGtMrHgoa{s2z_imM{AazUew@3aSykzhP98 zRv%TewuIbHX`>hmB5I^iY5(rpT%)VZqKx4){|2IyU_xKZ8h#L7DVbgo+smGFtsJ5% z&mn<&!heU`MvjHKCA$1?=F(^owThM?9v;96oyHQzAho+MzJhTh(zgs>8xh31e^1eH zkP%60M4nXBqdr|1%_z=1sGA`xQ7-XX7^nkak!f~gpZ!Eu1Efa~M_E_dt`w7CZAIaP zm<38~IA+2*t*VKeWBAQ(F4e?mhWi+ZkhX=Vk6j-vX-$1O;Qi#MWhGna;1V}Q-AC>a zhmf%BE~Lm)u*JPk?rtlU{B2P`j$>_nRR{Z2Cbh(YQi42Dt?R^@$1nz20zF8zuNuK948il+<*3v*?Jg(CN+W~k7F~l zUqt%!eH^N@-TVimW*XDc#NPGug`m_JQ)?rZ^Oh%dkAlAx9G9*AjkDsBLM*t{ z`3q$4aL8?HBf4aM_$%qE=|^%DMV-QHhP4(jS|@X?#|aZf4()muBJ**1l5gL?@I^K$ zE^{s8oV_u+5lIJfu69Nv*q=ILp=SsZ+Uk34(U+pQp#wAF70-oM9mB*^L)&q5g5ij2A%Hn zi>IImrq;$IqUPiU|1A>M;r=W;6?N={0}Gd@S&K#REQIm7hV#C4)R$Ss`34@nJoZ!<35ffqkxR*ueD}hN`F@*Tz5!5Gej3>3D z=^yiYcnKnoJDOgq2|I1gB5Ks*9!O1uACyZ0>a{M38o7RpK`nOMOQKjU)H$7iSw5c@ zM)p1{i^oxQHwF;t5H8h1Mmrw}66{|Jw>^->W8RGtEwY)nAD6Ri#Vt|61k_=qxbJ4& zavo=ft5t&vKF~@lW0V0^vl)qRwZcc^IfOKY;!t~!jmPW4VL%be<^Z8)(n@Cr&7Q;n z;VzndEq~^T+c>u&^2IsrBb)Rlvk`zKI}`1$2kb!a5)BTy9qtVZCeV`J+V-b{`VL#q zb`h0oVB|k7ZX6_?l}!y&0QR%;r7m0Zc$EYtM_!HPW$DkYToRd>8g!vl3a6fo<lbNBjtg>z5Y778XF`iV#G9UGZlrkEUU80$>65`_YiHdoPPa z81Hcd_<*%;Tr*d<>s$$T7ShDH9BxMxd}5uzd-VUO%=An7{l93pe{Qx$c(k(m=8BG1 zkhC&*^mKHPv?6Bq4vu*2%*>Fq{|8sX#?JcR-X=|{YseCg{7*;Al$>@gFEeu zSf8IrtPO8fj8v^E7H}XRs5!`r`0eGbJPK(z^+^}&h^w+Jt*m-NCFMGOO-_?(I&eSX zj)%+-cT6HS4>3uX@LwW45)!4n6sQiQVLkjeNkW7K#5D3fx2=$3d^i-KeH)L#0gzF` zXn+_6oi9NRhX7M{K>1KiirfuEX)0eFBhNAlupK$EDfrOqr4xvstQw!+8i*1;o<5+T z@b-!c-DZRezUjF5BPzGQax1#M zJoSj;y;_a{K7yQhQmB#{%b*PZA4ej79AtXrJ)3f&B>X-(`zQQDqncoFCeuO%V)!Ct zW-$;bKP1j_D8f=mdFWs-W`_E`SopF-7^FYxwiys2#IB?N7QIzRq|RZXb??eKjRz3y zWYhTg9LMF5p~_rC#UL%jr*FAXL)lX><#T7uIj+MHPLyb<;AP7xi4T!2WkLgL14wNJ zQuE4?;n|<-fqwO1L|J10-qtYE4if6){?SkOg%&FWqsx~tvlbys&zt5~v_Y{JOknDn zM&h%v#jXjBp935Um8s>_5h!8rnNn#JChKKSPzXB^3po|V8cVaN1x&P3n3KyV522%DtXQo^+y}rj3SOWU)OeE z=}29^z_kwfxnRB#g;NO#DPQq2@3x7~2#D#{E-g#3ofoyi;n0mV#Bf7SrB)Ew$b=aS zu<7adFiyV_!4)ZHXVQ_ay?176)V6djNxd43hYxVN_0WTmtTpA(X*P7e8$_@7b~(=V zSR*Ti1CJ)pcR`8J4jK6$Fn$kLbz^bSF{2OEy9dd@^OXi*m-g&Xu) zVK_snDLp#k&^ZTepQzK&%-gbCtp}T2Y4PB@t+@b{#fQo>C{&N6Bv?XNK~=Z$lU4VN zvGkMGjG2+Frfpks{t9cbie+)m`h;AO6kQ3+Zj-TgSV_s>MhKnKikZOkQ;q4uTG@}uE2w9qMr$aq)K$|qKi|E9Ndb+3tv1f&_H4m5);Oxr^rC$r!bd{ z0xSb;73`~m9qfbECsSNOu*j5DA_Lv%#_TwOT8x0TWOSS8^Kd`Ban#b`>e6AF(&jXM z2o|>Qm0k%-kx*3@FiI;f0n6+DaCyAD3r*K{X5Q>n6`QGwXMLfeSD$Bnw93;Dkhog`S>wV}`4pO<0@sin*i0v}f9D(1hdNl!32@g*97u4_>w% zUUr_IY?zAAu{T4OzcGJ{11cUOcxUh@wspER*1r{3*Cx;C{KywsAH)v9I&sZc}VS9RXTtDTZRy1tha}eyItiTkJk9XcI3yK>EhJF{S(HdKpY8%AV6FA%d$BD$r%;-Z5!a?w4_{EgiYPaJ;iOpGsB=LOzZku3o?3K1^=3 zU0=5H2vZERJ`HSo9Se1mw^Zi&Ao^EU7OJLV*AvWnltDOYn^*1!!R+~K7bfl z6JGy+X=kLP`%h=Z4D|o?(#r2JDq(RL)_X^1ujPQ8Vc7X&ToN|zsJED<7e7I+1W)*B zwW|_Jhormq_9kXg!NW2}5X3xTd_q;(rGmJrQ1;5M>LuBNyX#fY=kAtQK(#DE#M|)7 zh6-U=CKH?z7LimesA;B(^|_%UC8G+L^w}r@CaL^milxy=hv~^>(5Fa(m{XYcce%vx zqWJr`7vf{(KYJ}_UilL08Z*i>{+(P} zOvCDJ>Ql@brH%vq6L>I#qXzH1Zj+3Zir@i~*P;o~Bk4yCw zL|p}1bq7pPL#<4^Y4FySG}SQxl41?6su_jNrA0XS#8tB9Fd|3fNxh-R%uZYX zV4x`^oy0s@K-;uMI)Wd+7bgYM<)c(O#1y1uc2b@EDtYx9Yabd1Di8ctN)8C{x~PrS zG;^)TTqfI}ZiayjrRs8u&g4(!K9bm_pam?tccPlAO`znrn2a}QQOlOR(U67;@S4zm zxZpJ;j)9&ju7;CkhLls*GJ%lEvKv2rg%;xA1x;RA8bQhOI(u(Ih)53eI7yr{EgZ;i zW1wThn9KpX3EuyESPXMrhJFDX35NOeu#>Ni<0DE(tK-}izujs`eI22guiW9e9NG!` z4~OLLi(u97up@YnFoShN#((J)V{b!+dFmoPJjF!rqlt%~X$mmafs!+w;EaEsEeF|V z^-M5W{tClY*)|X-N}36Zlr#OG$e2?%_7=A*-GjIg&)8v{OwsJT;L3F{eZ!tK!;3+m z3EOBqTXErCAa#v$IQTdS9vPbND=RUO9J^p~uw*jJIxwx$!u`JHQ$1N(x)%^Ubsuab z8UT>Cdw=_GPLPw_;z*kTbti5ik~fDSM_eX~76Mi)(irmft`)3HKQgCkpDigOEGJ%Z zU0#WKX+RrNDUxL;oyb7#m}~U}9n&8y^1L`{jru``INLv!MBfl=x>l+2*3Pqxg7&)9kTx(BTVqJIodsHMs)F?HN*}CBa4qP^~Drg1KD1 zc2Yn{0%-C?VbjrIhfV`_k5VH^5zR;GIHZ_mt9495s=-6o!5Ob$a9lU|-=OcTEa^G* z@)f?X!h)sa;ZJYog8Kp<>vVnx_19-sRliZ(3UC%|I7_Pe+?XtiX^4#3G3XiikHL4G zp-K1(K|e$C)Vk3wdSZs({$f)pHuAQ|F#8X%!`@f#W&@emimTA0u5~-qX8JTc zbkOqyG6a6yPRskbrjt&9g~x$-5fo%2skC&9?N-%k!QQaM-|@SD7jN_d%bu=Y2JdL7 zeNV02IMW3|?sJb=erW7|Vt5<|q$rg5J~xH&kL<5qd9Pj&0Zm= z(H#`(FQw`Itm7EIF5td#?b>T<@7(J)w0hiME{9}g|L#rU9~uZlCJmZwoXY$u?KIu< z?>G8jykk1wwUh!Nk|Ni;Q(LP~6{iilO(DX@69C4>BZy?@v+WDNiLC+xhJcJsQY`)p zidie33J&u^8 z{-{~$p|3s9rG3a^E8T8Qo%3nLZ46%t;1B#5Mj?IxkJc%c6pvvEr~D9np4Na^Ez?Q2 zobF`PQ5I=CE}iR?PVHz%!v+-g?aDs~%@PyN?vM@;f}ySWz<;U?;vfj`&(&oVTe5&& zFn+9~FX%(uTDJ^booUWg(qIr=#N4@4mhJlKK6{1Fd!WcGy-UG_ zcFW^>WW#rl0T?m?*GM$Y%r`6iU}@xx@fFtHOA_OK-Ur;#6Kk^$iAhMjx37(;jt>#s zRtm{5$;w+ab2#U;ltHn?_2VYEFf!Y-@NzhkO|M*hJ0T>vNaJgIIbQs^e87KtV*T}| zQ>518y?3k;HANhS2PDbTiRR11Z<}A;2@n_BP}`Znf1$Sq712g)iV+ z_)lQesl6-2yST+Gbgg_BHbMJftNmwq{AblNi;TPs*! z_-r|Y%Q_zLwjiYq_gDrOAXM902ig;{vYMp+#_PYxS$0j6VX1AqYaSs zE@SsSd33((A0xryUOkHGey*Q8?{# z|6F|bLnfiP#~ln+J9XDjhy;@6FJYN8fLY$X!a8y8I~ zRB7Ck{bT$1^){D52mu8liD)nbA#7T7G&i9W)b!^aF4=aIt-kuPbpGBSe7yht>~w^% zPvE(TkY8l4w0B6&uMzXKm7fc1F+Tgi-H*XNZ1%1*_Ax$>P>}j)E2U0*+6(^@?V^zI z=^=UCsk_WXVRehcqC1P~kA7HOQxLOC9MVU4Acx;scWs5`G2}-$rgU@JMrQ?{`96_QnDAzYb9JpvNgSsPG!V-msJadh)JHsSl|Jvlk zl}SXrdhLpcz!l&K)4O?A3FFzu#aiG^y*Nca*7H+y!MLzu3KLqEw7)RU`DxH{m2=0M zDdns4h?G3TEXWiYaq1lI2Ng|vVd?FK+U~|fC4+lX27#c;vh`%Y?b^R7YT)=?H%Ry~KAptLU z(Y`%PN+}R}GPu|5N=9Tz^HZ}p`#9DhfW73S{dVH74&YRL)-_Ir5(h%%b?z@Bli8G>cPdd2#*DX|lT93K+j0pT~>_*?}J1fyefM zp~*zDTapw@;oALZ`UJ57Qq$;2TwF9-dWVc2AlHyy^RMk^ zBvo@wU|k~K8y8J*xooz}my0yRtd*afEPC-VcppK!5@8>9cP6DJSov=!P>--){jQd% zr+lyWK)t)?PQ3AAW?kcjq4m>hKzV{!^l zBOE~^raX%4R^xt2whXpu#hDaGUQ@dU;pSdUmB%8{cD7$gg}zpnbG(2ZY|nxj{w3p> zw_Ms;ur{X^DL>Qm(dU)`r+;&n+Y8eFItVS_F&jS{*5!_mxs;3`y@FpAnp%|a4cDS~ z!lbua+6`GJ@pz6xX4W`pmrcfpmuOn>H+vXF^wQGN@xiR>POUmtrCKk;g1)(F3m(4v zOK8WH8K!W^rom9Ier)v8rlMzy!aQ%&P9&W0%CZuo^I64=2jIpe5Sf1CzykvlLty4x zrDLLr3JSEYpk?s@H}wcECpZx1M=dx^}=@Y z-FDMiXzwM%acZSVomHY~)mdhkh&xII)XfA;g@QMqRm{<33e*IkP>eWZ7m>l?30Fv3 zZHY;9yXjzH$*mbPR)-Vj1odr9{nwu`MAUSd*iFaM8_?gHyVHO(Z#7p2G`xNRasBrQXx|8e+6F8@9eFpCA22;$wOlIbcO;PcgWV;nvzeh2}<7!FeWbOrmnu|2zc(-tEe~-LiM^nn!I+5 ziC$ZS9&mku#i)-j8rtIX+sim575Ktsnl@iFe zjaqq-LpX8)rwqcwe`b|Utx|ep{`Sb3R$qx(o$L0pDj1`5wkWQ#yxu?5m)jA^BEEjI zLQ<$?R?t!4cYKcLPgF{kwge6Uv;xdKi$sB%AP@6mwjp4YsM>$n$TFAX41EQtMj6VJ zD&8MgCK~9h5#Qu{LjlBj_74N|=y^c5x=HR`*Ze_Aq_x14gENs`&(HU@Xm7m*_aZ}2 z5QqW!fZEsyLi<7<8O=*1NA|7byJ$S=u-3K1K*==>OS0+R&o`8Cr*PUxxfXwwsTaLD zNi9LPmuo(CYT`s3AXL5`mwnTVzOxCS(Us)6yl^rY3%J;MbkonFSDY2g%OO_vE)bMbqKz6Pk=Tu{(rh6Nd*2s&OG)?Xi zP^F~j=_&)Mo9734)-kzMu#THa+9W-9CMF{H>ivS9tQTv%7ah|OTf=1s(6=FVnQz%Q4PAgQZGA}GOKg0#!g zXz5wgy<2h@XnC?=m0@C~-p6f!u$P|0wisp7C0k|UB12R!biFkBl1g=0v<9ZU%418q z;(3`yAdW7P!atvMojpjlw*Q=trN*+R^jrYH%R$|L{$TSU#2>DPZJMSFr(K@Y2xzjr zNqBp`US;_Uh5&7xlF_g0aZS&h_Ryl>cicXAY;KgoH4Ed{Ks z+G%45M~7=2Skx3=D7oyhJL`mvt`3X@XkD@`r?cC%bspd2xNoeu+@-VmBae3I)X2N= zMQ;EXYwu>vz{ntJVkSP4AEuim(g$h&u6_9O+CG2Ggbwe*MT;;WY!z_Fj@-U{M~If* z_m?3r-RUbm}L-l>{VQ`=&tttHbfe~J6~{(|#`&8Y43BFff% zQo6g`)3^2kgfHtyaQvn$@;XkKSdVsLSl}brJ2R>m7}L?Z*-zwKrV66x(=wV9^2pcsp^3{8QAWlddv<70J;&l_l9kx+MsbC7 z{j@G={D!XoFu6?QTz7K4&g|~qLCrW2puWw!fSN>?0HFqEBbCOMjXHn|p0K`z9JF+G zLkqm9#Ze8P6<$6yVWp_ivlG3FrL30(4+oj}jU2o5C}XPA)gqRvho^|E|EL z(Q=Kv_%VhFa{6%0(h8KJlxRyX8D6>$O7GHFH36Q;El5H7L6`To!1%k3Cs6yI5LKn4 zQibl$Fx_*p1|{@L+~R-d)sj05JCC6nJpEi{@E*>OKGNV>ZbSwt(BYUp;%SKzhM@83QATi z)5+mqH9q;9*P52bW|ZqEF#oIREix$@@5ZI4xrL~pL>9>zu70gIQn5X97%Ge&E&Lon z2b=!0Tk}mH>4;Z#m$mb*ZvMh0&LVu}vyRN@_ISEnnrW9QERn}xwF3+M?jQfz9M45k z1Zt@;ccbZmxg4)KUk0GwUD_T~Z>AtMUH=fZv>;o&0EdIwlFSD_)tZ(VOd8AQNYo0W zu_B>S{4j5T#|Tu+n%w%Tv0YviP30Wu@*Xd$3)QrM_UAIL`#?cArUD;e9iM%2czYPi zG8ty5hea+D(A`u?aOqrwA9Ki4JsolUbmkj<5Oxr+T{bxucz$_x2x-~B2|sW#%M*a@ zlk=$EGuPg$o3^c)zQP8dblS76uB|;ydy-GqnSM0oN{Y(PRFBo;%7+?hRU^KOxXnfK z4?m4f8=|gCp+168-f%Uxth*O&?DY_tq`N=|VWsDgU6Nrlm{JuRJtC%Uu z;tj!s!?{CR(Oax9J^%8aO6pOlx&gr+z5qv>pdpS%`hlZo`tc7?rj<;=@ zF6sQllYk>#9Z~q`Ku)-4qgn#=^n(9S<9hf~B_HF2v3f&)zq#Kbw z@5T>Z9ndUYo#2VS?h%av*G==1DztxssvsYHHx}T}PDE+Y`AvP@aC_=x*M}{6%W1cE zl(m*Fcv?MHZdexjCmC00_8@*y`FN2#Va?BFHedqy4y`PwKA)|ke*vtC9VmR_PJ_Oj zv?y|I%3_&cdi1(*w?Q{HrZp-$Y3AR8S9PxCFE#XZ?A|6P)ei{Xq9Ot}oD?EU>bB}n z62C{JJrmcThqy8_Ri^nRf(k&HCn!mED>%FObQX3_o?hI(JhskpO|@}TRN&8>G`f}> zUpyn+zO)RVoO&Bep4GmvjGubi3cEvlFU6Z=&u_?@4k&q{gV0{#n21S*kxxU?lNShL z`SAq1XC7}DzdodXcoupdqOcJJzHysaV>4qjL zlAfw=GonU5hD+dD4SMYgfX{{oJQTON2l@(G-iQBK&9}_&1;{no`=%4nc7G)o*TS{f zn-RAXwmJcHo>i1i@EU@yg3+u4R}^k{P2(?3+7ig^37zoY_V)sTReHDSIdd`^v}A!g z#I(NKE3ut&5_DzDq_l~Us$@gX|BJDI3hwlY+JE8L_{O$v+qP}nwr$(i#I`-LlSwkM z?LE(1`(N)q_|@LeU3FLYY4<^|wYsnMxrl4w*_ZJ=lXH$LM%`IvJZ2Pbj&Q|qBg6DN zd;v>bCK7_Y4cMn%sypy{`N@nrcN1XleyMW}VEQ1~;=G#DFzApo^1L%unrAe#Ly|}$ zhPI_WhmxFVoR=+3yPk?gKCuZvqFGC6{w}b<`xW5%+d0$Fiag#wa2)*=sy;856hq88 zRKot8{#yc5CbFLJ5q} z0dN(hEk7U?o+Q9KsCXOJO#^;BU<6aP`$^r51QeFT7ZL3O0#{a72>Lx-UShMJ4nvO| z@t(QRHx9_aIp&QEceFJ1M6K3cdpqMQhdH^KP#)pp(ibk9&CS> zc&~m7&`EE-oz+;NJrSYl|9F31zEbJ9?{egR5mrIoXs|c$Zq3zlaH~)Y>lINzXG_m8 zL>39gGI@7oESqJIA7j-A8MBi^mD}l{;34rB!<;OCzH6v{EhbIIWv|*Mqc&sF(_oUf zyY_c;f7KOYxMq+;ExzdPvk}u0ESYF-`x~t%xVQ8ckb>TN$EDy~Uf_xZ9jQ`QIHim) zFZQ@umV3a1=SmIXDTkq>pgKYg)VT&{js^X*1ZbIGp0OjaoV|Q~V9nFWOm9&Q|#CF(`<|iB_})ZYcGb>g0O69Ad`ZY zZ$OEltMp6%*H;MkTo#R^qxmFV^g$(7PSXO?T-@VrEko*z^CI}+K8!!f_5d0{@O(L( z@59&ZhiNn~htOCbDxUli3wa?zLUl`;Z7cc??Hh8BFnNhXflwDBKDUwQ5^4E3KKv8V zUv^hXd|5=K~4bZEoY`tk!vP*Xe-ir9wN*9b@6m$1?W$Un@pnzBE zlHPhtenGK<;66sql`z~EW=iKnYI^Ip|{dBEOdk>8!eReM-^hn(07Tb%k z6nW@w&PQ+Oo<-;N`1T?4@R$28*OW=TwvT%_(NBn-QWE~Im_TAjC4z7=b)(dT<7!V}QoIErbnn(4S z7+sqb?SiXew8t>o?$O`vhx9d5F2wbC_t1oPi+V-(W&C}enZ9XQF! zH!_JgqD4FWXl@#4uSn}F@sT_HHdd+}D|YlxEky1*5I(s{DXteV1$q!hPQmC;W}x{v3%CV8 zS`%<4pS5--@MO;4(+C!-Cp+=3n}FadHJBDA?yhDX`$$)*)ueuNbOg0N8p?Gz*OnbN zPP|x|L6jpU*$B|_+H3InT^@!_UqSL_lS<15Wc2IPf$a4aHq_c;5VpoV=#By_^W}US zMSb^sdWeN!ceqQ#Wk+p|a&0bxj-_H!4lR#KmB~@1&`U`0F3M8#6t+ATeX?~ouL?eV z-9xAK^_Z6K6P7EE`zo&8|C*&J~4JG=9esgY+#!W($}=o9 zOXBY-5_se}^F(Mucq+u^F-k0y%|(Q=>w3~pJNVx7$OXAfxG)6T;R8p8I4 zwsFW}Zd#)p=NnPGwPYzMoBMepx{~4=o&wF8)sXO95H>v6Q73&d;IE;SU!}Yt_cV-XB%AYrHd%`3TE1sh# zAn2C4C&QT09iEnmgb0)<0pp?2DtnA@&|F3}!;^~zj-hz0!I-pTfrx41gmC{D1uYvW zLSiUd1s7U-S&HE5NF>@Qiv?Wbco%uVdK*xiiW9P;=?t(24!WaP^j3Qa3`VBZ!^!3< z4>XrdlhFWPp)w7s{f!CwfDC$$6o9N{LkoILb^h^sj} z*0d^Ctc9SB=_y>WMgF810VsEH-D zsZ``^{bf_7&RngCMrs+M76~xx4h|x z^_ZU~tuT7$HR~h$O4(g0J(d={mTM6O{Fdc)i0wxYjvSxIPgLzweER%~Kj{So$S<1d z=If}+EOrfb+>`0++{nyv7R@tIMjz1cFS;!vemXzR?i~;aTZdhJTmAl@Tl!# zXk?FD_s~tx2M5UNnen0LD zt#Jh@eOKMXV|n(i>$AEX^8N;xxo@#ku$-RiagZDzix|nxMIu;gn=PTDJ9?aSR9Rdym9&vOKl(ZxryF>xb%6 zKGS0(ltJjfQ|miT{=B?O`80B&g$O$AXRAlLak#@GA@jX(FsYacyE5pEEO_yeW3y;S z!!Q4QhxF^j(W(?_`7Bu+0VCh~kNR_5C$5XyV_CY;0T{DuiCnX`v;iWcSgOzR5GsZl z3u-Jo%Rb^>HE^EQF^?siqZF7L7Ocq1_92F-Aw^6&xon!$naYk#AW4|9YTJACNhUhS zkk4ql*1|t`c07`w`pMrlwS>#Qr2;KyUxJ_GduIlpYiKU7XYaJp@qCoqI704h6j%=6 z6wX=bZ(pj+-UZs245mbd4A_CB6D^w6Ve!hDd#In!1*egcaZ>i$%j79HG zIhN;+j;I9J42SwqjwX^g@|8)}6I2S(@NNhQ!VXT+R4JLkeIkO0`|?F*^3#(`s1{4& zJjmRwOb+5za+Bn?DSGdI!l!FMn7FW_tX^V)Rov`Voc=jT?jxM=j~6ifX0q5?Y!&!e zh6~p|6CaAm|4dEl81*b#e#gl+i?eOAZm6XSoR=>yagp>ni~vH2d`-Z>&&S=#?fD`ra49%VlMI<1;fqvKef0YBYksgA?7h8a zKtrqRy;9>!-6(gcS*w@pV@+!yce8>aaB(1`X{f=t>HJ_6`tFG|2g(m^3^{E0Fk}RA zIP?fPih*VJm_We%$sYwg=w;ZQ4)i9U)$z;Opmnc#?mQ?zqOH~+Ms;1C42j>qCS6>t zT_o=MqTF8KcG`QJ*usD>#zX@w4ZI^UCV1sfEcAJIwr8AmJ#qHOS;i z4im-z%(*qGsz5B6|1Ag;j@Wd88FDFiQhkQ-G5mS~18q@hCVV`e@HdxIATH5)QvBxX zM==oIge86Qw0W^F70CmN1ZNtO}=@zZ`}mpz;*vR}6(zOviX=3*3=F@M1`e3#-c9Qdk^o9;A&JB2EHuz-7NrW`jRGjwuq|rx+qOeu(N3x;tI`eFf#0 zG-`fTYR+Fs0)d$##+Fxe7GF}hg3SX1qJnPf@~HYATw3+Un`aAZ5+~~Uyb>Xj^1{j$ z@CbE@7hd(!akWr%yZP03b04*siZ=Bw*Nd~8`l`U!s9`XN&>kqoWSc7c6`P{wbR=UY zGGK7Ng`E3OOMk+rfczn3&Nsh+1tEy&I!>rcY4wQOoZp77TE-NxgocR{z%)SUtcCa{ zS7Jh_$OWPOk8~~jO{%tZJ#Ww}mi8vv_Z}M&_eI*W-_aLNC z!^y9guszV0P;Mn@x=dxKgKxNXG}TRr8sSTG&hUtk9wv5y(K#%fDtg?tPK=M(bAZvI zg~`x$m;q5_^oHDRQ1o!jp8KkGe*8*s*vJ5lOPPgk$nA%cW8y!yhCJsuZ>JOj*3IPMbgAEt5e2o*06>xcI)JRMkNb9ZX z9$wf#^~aOo{sNX+wk=MuLBTXqh6go0bKB)yg=awwBIGq~F&^^Exv?GtiZ;D%sd29j z_5o#srGy3XYg&~$`g#Rv7&*LQm~YtgeRzEuRoM+~SimjtQo?1INvfHL)nFxwb72oc zE`H0n)oo`9kMJEYF<2;0rS`U4$=z=4!$z3(?2(Iz>@UFu2sjKB>5R!E+#nfY+G<7i z9M?_z&TtS~vAwE8M#+b_An5O}zE>vH!rcBL4TfR!R!V~yq)v@@8N?dFoVC#VGb!2R zxw?kM(X=|SmRcJpj`azDfu@1d;s(LS$fJ#^JMKFf(b#BsYCr#mS)GBl%&eLnkG6)R z@)@0VR0I*u7^gh-fdqwQMu}}cMwB9xi<3vVl#VKU=RQNWYEDF9Kw@IB#Ps0CZ5{|^ z|2z3DDUn^XSOrL5$OV=wCQ#FM7}jFm@iwooPjINr=89 z6Z?jty$?LG+;1?Su%)$OA~`rd2M#QQd%**oOWGjMnr*akG4l}ztv zw$QRjm?x$uBNrm$qY5{QsVT>XVN8dWBu-&O^{(}&khH*bc#l&%GU|vCNSV!F%1+!Z zsp4}qpl@PS5mb-V7Te32H)EMy!!DSsgGoa!QUX)SDiM9r=BB;%(vdZhIvN*FDluBG zw7*nD8$Pm2apX3wAIJ?cMYKrEl!; z(m3$qn5kY~pA*jJTWY0Ed}F@Qx?=oy)ZVFd7Zf9WhjE!hF*2U*LyRJFI7(%jQ zeDhl>dcSA@)I5g8q>V-zvl%iq)?s??2yzpL&yusrokDC3fGmD6fHaIaSKGAPdh$bJe>a%~Zm=F9JaJqF&L}L6 zTMC{&=VfUpPcoY1WGsq2m0Wqo7y_MrfAZ!|lRB1qrk!Ztkvk@+gKWy=Qk>`jX|^DT ztLzdtkeOxU#IW=4tP7x9<5ippt90v<7oyvx_{>8h3oh8 z*&)Lw=iTs3u(CxV;Y5r_h5`eDNdoi3vmC$tB=eC*WNYA(hvru6wqEf>bbpy>Ge5(M zGo~9W{-Z*UJp_U&N6YA#)**FHGpHJc$gSym@vjSrc5zsXp=B~?Zo0h1VeKy$bofb6 zDML@7-+J&wGmYhB((%bZoH=DDk_%pr#WfHJE3lGGcjU}(XrFsj1f-UGO4G(y2#^~S{bI(9fe7Kzgl|+U^@NFW#k+Cnz0?3U9$sLi!NQbz z@&fX%Z|Ks;XpksH+WIG{_L>(Uipo$$+?e||8YbSLvrv5-!C6(~@y$8Wer9%aqNN8Z ziZ+|>>o(F=lTrKaKuN+yRO);Iq9ne+U?_(?z*3GhTk3lsItTd-?M%p`JV<5 zozUMH!rVWnK+~f@aX%LZ%(F>fs>F3T$6QCM2q03jpOAwMT=&aSYr4 ztTO(?;e(ll>wnD)*}<~;AK$%hfAIdWwZ%n3;J)lLSKLnb)U%QJI`*X|7L@3bGtR$B z7W||&{e9i*;0dLc67JdlmHd$dAnO>t=ESgsy9jt%ce5Usdza-`X177p!u`^Dn6YtH!tE^N8kt zy*xk8hoD49U*Xyw%@KKjPM?n$N0`8$eJF+Uf80NJJX|!g+qzs13xPanbLUTQ{#(i( z!emeC`#f}Xd?15=6!J6*HB`+`(Mu|{6kY#IsXzA@lbjCiMS$y<*)fc3JgdTSCy~R! z>f_3-IJh0Veg`E#ZW<{4Q$2Q7KDn-Z3`AB2oA)93Pq#73NOE!x@?5(_PbW5zy8@3#|_1U~NmQ@a? zK0A*-;hN&&5c{I)7%?lpKutjvtLx}YQM|k9ozLuBk`UKrdX}us8XP20Y9ZXWehWg9 z+(6f5jyFgR*^zdI4gt~Gk zth<*I#7abmvg{Emz4Z9|z;OIs@|az6GL+`+!CM&`91?@Nt19*yse%za4!SYDs#8%( zV9ef<(4kq)pgHEHM)Bgod$G?3Ay|dNyBSZj@4zk>oEDrbjFmEuS#7}313_Dtjn(Zks$HqqHmaM`F~e`7NWW)u zhMQ_@<$w#hHl6m}Kg=s(f(>lm&BcnaR5wZNjA9Yx3uW>a?vd2t;5KWov_FMj=T+`@VRrM6HA8+Y3hE@H>gHiw#@xg#PkV)Q_Z=q(!Y;~DEe8zDSqKw%jAc9Knms~pFwfr1hCb|XEI1FK6Kt9bx zM)kPjA8-z@s{mtcmX)y>THuG;5(X<2=#7{`F`5K6Mj1OX_o)uR#qF=sScSjg1CuPk z>FTra?Pzkd6%CN$pEn};s@as2ib0mFanjFmM<2$bv(=TvO_cDQc z(_~T4s_0AqqgNvNh5E>1=sAm7AcR+}QpMSkyU1nFNUwZj%BnLfiizP{JeylZ@=(xv*C6q?dp1i0%t#B0(EZKJFL zoXOQSn%+j3*pA@M3$VTfu=HpWJ^LX}Q-&ak^88ugO&Aro7V!xKsQ2cm6%?_K0WDXe zPGHA@&bg}T`%p*}u75=7BceighOSQ%7?Y2GUhc1Q3ve0pSw#_t=VKO$D+9}a46G4? zFhC!GYh=7&LSbY3g!QqW%z#T7cwmjySrrDkMJNvxI!ZGWlY(1WR$!}x5{iWJ|3T~T zN+6Bg;2J<$OHu99Lro#P{FGnVrTGqqG4vSYNR~U#I0S98T9r^G(O~R3450>C+2(PW zAnZTp74wA1aT$!Wf+Ji|*B4rb_a|m!83v-NKz{!v?((1Z^w%MQO=_Q6ruF(Ra>gJJ z{J|fzpxWO`!)1g)qhvs%U0%97LlK1c$UTw)6AZtyWR-!2(k$0-*>x2)bd+x39DbCp zLM!N+^02A%DzR!EXkQtpW_d!A_5WJpfc5R?e>0D+w#uTZ&jP6?)5!Pkjtf2!R%4rZ z!$W;Ki8;cb)IvI;%9^nW_6TA~w3fK9Tt@{)y(9zIK_``Io6*F>?k1E+{lV(< z3+LQ7xb*;%`bpdH_E3PKK#%_zA4%0polM8@^A-{v^t@jMPB-(nCiTm2_dvzNcFpC} zYOdd#r15SK?8$!!fDH%q0GBFEQw7sq``W|f5O*z7;K!Ekg@6*$Ohev&4;`t`-r9(S z0y@IB=hv3lR}26cFe5*N)d(+n(=n2`DIRAb46(??cd^1Z6WJ(JCc2bc~-i1X<)|%Rb6wpjVyAP zVajOG#j=Ob9%lFKx-V@87ll57aEqgsTqSDFJ zrmq#|Nbc8i)03q&tfxqLpEf*MeAZ<@uLbqM3w9F6s&28DOoSzCxk#bWo}5adR!#EblZI2zTZfR1J7Tf=li3t*6{q@g^0951r<`8AR zEK>R}+{ehN!#$WkfRB7;c*g72*dN8+OCN0gEf>}@dKBe8lGn*0XTIZLaJ@5&maabp z}AD`v^3EV&>1kd~|Sn?jfnHayfW@ zlK>+QY~piB#lFR!v*VlyQ!9@mAIIDH^x3+6$E^KUb6oJBMy`az={@>`R)A>2_nGsP zhnlbSJ8sV>;lKxq(7yg<^C5(oVVJOJC}rn{IQ3|`(dqB`V1nBpAYb*D?ToYC9H_Y+ zEd84aT#VvR$m=Xu{r}3%6;4Gt>ecaVv+k_Ap( zxv9n_FgrrJ1$jW>4qZ_HRGCDq6Kx0V={4AncPd^}GMG(>kk*xcy-IC9(R=LjYdU zae6||A!TL>U>rm}X}amnM~Ps;l9;R4 zYIRlx2<7l#lwgq9vt4PE3o6Zh3jV1V35P)#iBL8fJHwF}tz}wDC*~yfg`EUg430IbUBYVbd5dbq!>b=x(%;P5viq zoIdoX=Up*bCh^NU*77?J+r$$#Zn&`uv9-HKTEG*A%(&}{He1}4!B+a9pw2{lK!)FA zYY!uzqhG%z+Is~i;D%-t9Qt_h!9eoG!MN)faoI?sDI5--OU>?&`O@OHJoOdzxg)*P zN_Cg%JmsCW=B0;PY2j|FmTg~k(6C-%IKx(`cK4$mkw0z!mG$A*Gxnu~}~8;684 zYPB)QsK=H3N1ifkwTtM4@%Ib{h)5C)C=bzo_Q1+D^lzz`3N~1iSGFx4Vo_YYP^Wn% zQFkqdCX%v&UpPl~1Mx#X?mZY8LxMxryLA=e9O-3yy?(GKVW1fltFM4YujL)6_m;w+ zEq%y>u)-dP17+DDC;yO)HWoa6x}e+h@>cLo1W60NGFy`& z{xS?=&adx~TAY87Ee+TvIEY&Xg?^mZACG;3f|+Xp@o=sf|v@Edri%Z(_5{>u?_yFSO+C_C9+vIw;n1e=WGPC1TyayHrb z61+8l_G z!=0^CDxG~C*2;gU=274Toy_JcsV&Rf z5|$aW$-B_~_Xt9CpWiVh7L4hsATsZ*%$~w61enJk>d0v=tzZd<4Pj64@qO92u?&E= z=EO&Ygj!?G@vM34&7rrd7+KDpNps)C!^!%nd1Pl(U*&o?$=lQvX=aCC7XrpEIE>syg>YAaw@NJjH2E0z_VF)9EjHXsPA5_wf8bFc zjhO%3z5nQdW%@tpkN?H)>CJY-3<(0l4*c`~q;AH#Z0uaN1;d<;oC#Bhu$N07Uvz6~ zYWm%}>_g=PbS1yHCA&dJ4JV@N;5r&uXM@X5kcM`tclQ>fRjpsbaP-bFT{*i;oM_Ym zh^8*j){H^@oAT!i`pjH_9QOP{_wxj+j~ki+DckWSs|scEni#u*$P>LfcMPrY zB!|$X=2JbaUOu#7Ol#J)(obn-dFCt?D=@0@BW`{IU2>}V`&UzbZH0>sYAH3{I`W5& z9RHt2`*Ulp7o2R6v{wQ)u8um)(UBg#s0rxp^64cXx%VbX)$6BGMy0!xgyVgY zMF#>s1a`>iC1cAZWy3qC#Uwt>B&9|O!&IBaO6sBpiEOYRu7h5uTxzw*|RNshvO?S+Jv2XfG&lo@XI7QnB}Ya>z+aC)nlG4 zTdzr92}XXW5qP0G84}89&_6<6`mY(X*Q3n+Dc~37g!vqoYt?=3I7!)ks~J75AN@WC z-HO>OkUuxSVLx|+^{92ZrbQBy&{ z%S45$6cw#eQ?X#CaKX!j1kWh7y}$9gNyL%@IHNy@m5vJ5#$UH-j%!S}>$Xurc(|wH zM{W6bK9TIxfMQNy6*?$`lf;o?^$U;I1LQ-J+oJmYiAM*=%_MUY_Kniu)}HOvUFQBA zcAxVrIdP;ko;o949^a- z4mW_O-Uvc%LFKS+l(j!fw8@q#My-ZvWLt*W8!BQt;D|`adSTR(X67#iBlU%))g8+6 zBjX1>pyGI4!_tu3f0igfdn%g`7QpV&f2*pv{bl z*+Qj$gwm$%yTj#ZOaN44rc41bH=_(ZEJ6>TR5}n`Ggc@)v&OhM z!3nWSyu#-Tr~?n#PmddfPPg6oBudWRsCc1*v9!s52{z?W@D)qWvFM|o$39Kb79zi= z#`hC3E;A|(&#gS^Cu+?`T_VcJPV5L55W^M`xld$@jV+~Isst|FuoS1~F;j4mh6fP= zq)Hm5Em8}u9PdXdvAIkewk`%oMCmxH(3F5D@OlSY%$jG493<%>NgXJSkXihpuD2g7 z`PBepyqfJt2PG#l%K33_T@(sl1qogQ_Ru5L0anBKw-P;e%xkbOsT1;-HS65g{(-SD z%)y{OWF}{3V+?*$PM|5Vs67m~(V)l*AE48Sskygzo2gH1MdgXY0^q5nd8_OSS7p}oE=ojxDcy9f$6HODQ7n-QpQ7spB z>982FD(L#+Qv_Q$u0Nl_H_PSCRU8W3N5#d%iZdtnH>dAm!2I0mMNCaW_`%ZK`{la` zubv+kLO{Ti8RwVp8!pX9TgTdgroDUfFyrUj+Fp?&rFyZ2v)9+#!{o4_W6+2~uye8H z#3(6XGa3zz7kY#p8Ju_v2%oUX$bkV4QXd?R`(Jd?wQ4=CTEi*M^14yoV4AlP%XMoO#zf>B)7sT*+%wPPLEK!R8)VR-uP{H@v4}3TeFr*YS?U$ymT2fEkQv(B){8c&JH_l} z64?t(i(78>`PLoLNQQy-7>VfdIhA=)h2JT+tL#pBlTZH2uE({xfEhR0vG58g`rWGu zG*kJJfj&iWmTR>Rva?&zijw9EsQ6owdzI2MT>1=CX@TDAybuzS3~ULBEgq6n-&J&W zw@3<7o-aKj_PS>kLGHojE5N+cEwPZDv1?XUS# z2dd3Ep*aFu>1tD7r`2PE>(anfQ#u07i73@GFu0J#nNYFvtTW;-A|}4A$y}_eReE~( zbEFGnJny4;*LgCbKiesUNJ1zpDMUgTIx2_{!DAhe6`WvN7n6zAMTFkWM+T#%kERp- z4vzC<%pAB=&5xp{6K3btgu_&|be6fwu{Nk5Q5i(`%dnQZ=7%FM>`e;ZN%e`^lw zG`F0$*a3bo8n<=JrJ{}pD-QD2oO3Pq*3&Fkq*#cugXk5gRgtQyKYkdRfy7i=a+mQI zvWXp6`Fxz+fG2$3^SlDZk5BKReJQ@bWZN>BWJ!^|zFzlduup$)zd|IW(noh!W3|2i zM<4iDukg+3#lqwDB@e|wqBUdU;C>T^MM7n!pX)Sac{KZXm*VG&H1hMsg1};_W-?;~ zk|iumG?Z!01q8tkX;39GmMPc8%ZV#bt|G&GXwsFPl_efIIr3Iw_VS7fj082C35B#p zz0aEs+B5mRUmisKt6AoOvp*|xLSX4C+6!f>ci`<&KY(^t3jpI;>Z<4vBnzUpa8%?FF)twgi=RFj8KX9I* z66LbibCx(u{i$-L*?DXfLH>Uv)+91PvW#l2NnH<-mN0{cW$m_2=XyTI#M6LAW?J1< zX9WNCreE0?5Dz-7x@o`E;BChzNCCmbja@3~a&a}YD;Cs4(uXxX=k7+AVdhjd5pli? z2sEG04(w@H=5fPSVdJ$OZ6SoJqatOwXsv!ztz#G(Hi%wy54vfm6?Z(vfIeLX?fo2E zdHCKPCEqXl>jEo( zkliW3cBaZ!lRfg7&I{Z=M=EEyS>OO+`X`pAK0~e>Ff*IPdoUF&*@^W|EbvU3TW8by zA@Aqk{YFf>u3>BLt070z&edpLzjmAXqDhBedT=7GCowU#ANm|^(8NZp0I&v$?Z_0? zsGWBi%>r5kOESww$uJ!Agb8=0$H}t^B~`D^EE<_Cy8~H%VR=+hyeyMbrU_N(fJr8w zW~wQ6%IXkIcVxR__~->z@#45EnludUT4!H@A5W7rpgCK&OQn#1){XZF%e{1|E)qX= z1iZGoc{gN}j7Omswz;Ikw0xPQc@^YZ!J${VD>l&5mf7pewL}dRiMTp$-h{QhA+Eb& zZsGR>SqVmIHLJOhbFGbkJz1l9%pilb{{ihl4^6`EzLILQQhmSsJKJu zboopsUXYQZr;faMac^PLk*%aXEn})ZAj0XrUYcl+@k)33nks21`d{QHRev(m$%q&8 z6h*ZqzMN`&&YwO5CO1MJ*k)LA(2fStsn|dW;iSZ~aJ;H%2%BOwOw5hrt)I6q&U2Z_ zoktim@hcnNT^(R}-O8N7&XwPogyO)ECIiejE09hnW%ine6Gs%EC=`U58}L}FyLKeb zpd`m}V_85@ef=XHSgQ-MyJ;D8ofKDV%EW#47F7XrzmrOuDGo1w|21z!O!)UGx>5{! zwg~6EW0`L*td#w`_J)!S4z4s5R6I2@6N_s7!_%$L13Y9)4d!rvmqIyNtGqE5?xKTW zZ~OyQG}YQI(sz2T&`+1Dr^j!_V=<0aZg*wDk}hB){4{gX_YhMTwD1?O*9EV4lY-!2 zM}OEvAiQ35Z*Lxr9@*|LevK9g&!ldSc8aH*B6XT>6fl4No%4tI5k zV75YnMw4P)=qI?@IvRwprh!Mq2UhE&OFgv1LHVEiIeHWPUqjhe4SSjbmVOH1fKPB? zDCZ8W9jd~%UK(mQLPO|ppobk`*qsGE>C+iJeHjGO;T<{v5^-*McB@n+i!U}w(KtcU zg3)}kY@((qPs!|<;e?ZT4CZ;7ePBQLKR(Da5&0X zuHl_&&q;qQWSi4}g&j8b|G4MkWd2_lBeU556Ly|=3O;Qo@IlAb3rH&>V48b5gqo`AW0v`PDt2k*Yb<_`Io&-I~s*YZQ@ttjHy z*Hm%e@2$5NiTU{ie*xpbNbec^%alL}{a;+(A2?6xKtH=BqM}6}cItM#24S}|Jsc7O zcuEqcAEa=WrJ*!I-KY=Jo=uRv7wg8cqRRK-4C2seLB}y-g4JXX2cG!7iq#3CqMV-{zuu=QYE`N1-3vI*oy%LuVrmxr^PJAWuq4A-A>&vX{;= z^^Wu2bytQ}cTXRziykUQ^1hr%6i(?uxbRa3Ri#>R#+fW!Iu~R!S$@sbF|(0z+N7 z%cgB}isDErTlu@**QsCeOpH6sZSUEz*0kjp0~MW@M|y|f2R4@r082ns`opq46sqs) zEfdavgx_a!T8J(jd;?ae4b^Bz=4~(iIcg7++VhPpUp>sijsGVY@GYXJIv@%7)juQl zq&I-!q=@J&(m#Whwkj!XL&|8_T)M7X-kIN#8iPX}2`2&=flwH9Xy@!HgsHj4lSn4u)<$kf?|xeau$oPpeIR99B6Gt<4KM;ph3S_V_wfL66A0d8&gOGsO;m5K* zrpERwUYDY)+BoKJwT=KU|8HKfU}jVvc2R)Urz{JDl1aVnFB=m=K1*xJKZ`~suuxAM zy?lR+N>G%2b$xL#^-wlR2V8 zq0>1L+rUV!TUe^4M)e)e0C)o=26$NY;;4RKvHg`S1d8`HdEu1Y|GkAe6;>ZV8i!Zb zxo9`u#%I_~7gMKVWs?lVH~Hstimno4j>Bc*GgV;uar3HYd!_5WB^3B^NP|2&L_IoD zv_}q=zcu@Am!7nY9JOp9qZfZg0=mjjv?K(EgODLo@Nn5*mOxCYpFj+Y650Z}6e?C~ zw^(S4yLL;lUK&l-6cNN8>lY+$rB+k5o4rw){u63p3%(pz0{J45=I%!e6B2-4dw1`^ z+!3X7uDa?Gn<3oeF9ZTx_LqYlw4z@IwcWEd(pI~AHTtq6D814|;SQ8T>@d|6YE_T| zsf|=?D}v=0H{0eW(K!>-pa_sh(d&fSt2DAyNs%|tm?h`MIdu%IU}Ox$9H(AV5zA3T zOg^EZna1UQxOGj6tJ?*F(}~T|Cq&lbpws)^_bDP2S*-H@?m#G%Qxb-!xE5!c3Zj3essa4~2gb?8+FK!vl9E90SR zR-LR=zSKeJsWwmLn4ktM<;Zi*2`Aa%w%}?Bdam+B!hc!821;{~^c-C$1I15n zntuLO1Z}yq&$Bl;?5zt}AXEIfKfZvj2~C{!T~S!0g&_fWc0ES2Wxx_n|Ij;F;Z_+t zcywDRJHx6dCDi?NgKYG&dl)8Lo#-4~U&|ilt`1L>CWgfDyuEGcPHrq!;R35<)jN8B zzA|}g2!0$*ra(Ih?MzwH9GtT^9Okfp1bOpdn*D?FY87`8u8%X=_4K^twE|mHrv9>$ zhVH+7@dhm1JQ|*ume}aYyNA;YC=#dmBwq6)$L}^qZ^QN+YfRT$Kq&BuU0|7EoMAX{(3pjh1UsoS=wF2g? zEDAp-H=EDT$Km5?^z@HmDapmw0GZrG!KLfKiyFPJ1&-NY63Y4;49idBfk7vS6guL)?{%590ANf4`R@xX-!FV;axgQ8pbP)fYqJzM#(N%Y73XkVp^`P=yX%_*!C#lEfNkJ(q;k^!qX?E6>GHOd zn{c(IE!z-L4Yzrm$v97H4V$P+7Eoewv2LbyTzoJuznXXXc)VQovfkXmi3v~WXGrov zqcv1WZ=kCEzo6q8%?!}JU#^7gOmYZ7Ox!*BpPgz?MR>FDdGe*xln z|4*kSi!9qT{`r}1G0R>RdrJM?-(Y4iUzw)W* zmdSlzOo-UaBk*p3XR28Ex@YvI>kfcxe8I*D@|>W}!2suCB4M1z^!U8&6ZssWh5 z^`aTTsy=3X_&tqcZQr+yR`PN91an@{0YM=SFRv5+_(}b(dUC(LSyVxZy@FtL z*?wgRBQR9q+1Kl(C5k7W>V)w_q3bibpBCUGNPr>$JXFC(<(u=~X#sKooxm17i_3SD z0b6XOmt@p!1K#57C|8_E_iBy{VOKYW{0W)=0^xy(ji&L1d4}vB)e&aoR_m;fCh>4Jw4hg^Eb3%}PeK%KgtPFyIf)+tI$pg}nQxrY8U8LZl7 zZC7?#{4e~K0y&sC&QP8h-2RTTV-g6p_%qfwC*?}A0d^4Obaj#kfpBm{k6}dFZ1dj8 z1F6j$m3tzL;Gv9Wp*V!aVF)5vus>1=>5ncFr7&TAlirP=Qlm`quW3}L`(w0jqW~am z?zHLCsroSoO9>ND@(#VE{L0ZYXX;3*{5 z%%6`Sr|`wa9?b7s3&2>w_G{JRSMn6sT>2|n9FrHa7&Hx@me*nR^-Q;w!l^IA9OFVe z?gqXoqg5B_nvwA*Gv?ywjmO8_W-KXkSL+(*gxRz%*3`wreIGR0gtujmjPm_^i|2yj z?iiWArf$ZMqM<_ym_7u-T$BX6Ob?@zxkz?R#NcAQewMe%k&pAL{9vVGoGW+TDdi;; zTE|r@x0vl_3wB%EKT1o7aCu34eW(6Fr)$Y5z0Z(nyf#ot4pvY}jOrF9lnNxgKi}-q zG!H!4T8@9Ukd%piLcLmjz+6UTQgOQnTHa23bDv4ob8O6HD&_U3uQ%U)R7Kp5>r{)Y zX#_Zn%rH|t)!9%tOG)*|5ceCd0M3F%ejp1;9I_d^V*Pf>g3W0f(Z;)8w%J{bkh=}Yx1_EwJ7Y?=wp*47d2pN?FI#gwr806#CrK%J6Yul zWYL!_cD1N)(*SmNKCi+i#7)o!vVz)wkd+V+6yiTPwkZ1b8Oy_CJP{~a%*{!Y)#O?~ z9r_bX6mPO)G@=H5h6g8;>IuIU_lf?4J0a*cbB#?lf-X}w;blXuQT!u~046dG&`c{} zgVYBOJ;lJ)-~p3#Zpk2~W{y1qNhk@AbWaHS>w_>dOQ$ zZK@u_G>KAmo2VItCBE&0gy!6)Ul(~(;d7^;q60Eu?_+bqflz^zZJnUI~&+&clSy^-0C(DK+-%xxe4Dn6 zLsWl}u(bVqgxV(n9(NmIGQj6$1GUs5QmOg#lEq}R6=~d{8ST9b8jY69nAPUz;Zpdf zJUTuJd&}hk6FZrP5{Y7lx3zvh4gJMe{}gWBI<}lTIMz*TWXBuV;TKsa``W+it^Rc{ z%)_L2le&LKTA}y?EGW;V%RIiXRPSZqm$bo9?VT>}z@<6-^2=Wy6*qn_%GOC*2EeOE z=Wh_=$~8WGe(!z=XSLNRh(edh1ZDj3JX>!NqyC793wZeksr&o@rJ>#t|A}b+%d*D6 z@jo{k3}af@p|C%B`3`$u+D>A{UAKSGl7uKlL<(t^17UfXWnG1Hrf_D^^!D7Y=Qx35 zA(^9!;^EKU_H-?^yOup(9gPoHsOJuQE=H~Wl+o>be z%uKdTtISui??|y(Xz(yy)+(16S5FO*(;+5_S%2Leq$cLl$?;{i`G<4Ww5!MagUMy( zc6o?rgRJ;DQ0yz7ZJqsTC;o>pGUeg(unE~L@pD2c%sV zK<`R`IWxFiQ?**tYB_ZUCNg+NWut6^h7huo8p4}U*~L-{XKGMcvl3V{F|m_2-V%;z znu@k+T7F*Ftp}XNv==e~K|uuN|EpFWI^Gs5Hg2GdvYzg;y{w>mTz{U`{kDByD^AB^ z6XYtxCzc}i$0TL&R5lu%r)d=h#6jo^#SYltLA4LFHH*{SnHCwTudteClPet6pE!gh-2pTrA)b@@>AVO;QH`V>08|F&1en)-oXS^Q8K`k}oj-Gg~GPWQp>$~FD? zW<(WM1&M&-i4W$(5Bbd(61M6Fo|Wk#soQ9CtdAwYt75l3sx?kYwz{ddol*{?{D)y! zqq|ZXq~b_noHGJo9Hi|gN`nn;UdFV0sBqv#T?J$gu!|9^=|qwe60%vz(alA`%v{|7 zA#%_V>)^6k2IbF_r%x4(c?*CBhMQDHTW^Yi=FqK$kpHJEQ@Y^>6*C#t3|QNW zDW>#9y&>n4JJAIyw6Si^&->+h)Tvo&tskGy^WrH2h^Bu#cUHfKBA8+tNvFb)<=wR(LFKlS(2ZHZ3j3 zsQ2`9 z*Ul0t{D5uk#m}S%;-@Kb{bTQq9}1+bttFBoktIt>A|5LcAotd=j*XZ|zqs+qtQKWYyYA zpd+Z7WI829t)^wKaslk=mp(SWLRfp7 zJgG}igy!a`-LsJuq~e5VX0xEyJ$XMid=l=FOJF4yBM*r?gC(!))aMz52QYs+-=vGr zEhJtE2g{H#qM>&9&PLmDO$W{|hvN9=hE@5E!I9l!^Uyqj!9Fl9gh|{}e?!>7s)B{@ z7LL44L*)m@qxM(aeW`R@%mnjd;FhUyR(yVvX42GEV8sQqbisTo_f$xIE!AQ^4Voj^ zAMTfa)}W%D$!uCrr!RAF3puSsQcw|BgEYdbv!g^5ZwGqp8*$`-^e%zf^Fa=uCM?p= z+$PAnOn{cZQf^__Yf(;v05Kh@hf+DefHP>Vu;|!slS%6S*WS%|TPc>6zEsY*Qqf`( z%4m{V^idEP(*`b~vCq2tf(WU0fm<>>-Ywy(>DS?q<9@ib-*EsSEV%wWe8Q_QvWr0d zG>S$NV8=W?=xyt6HgKATKqPl-y|e0J;<-?w(Kz1)MtFDdVkftIAvlh!?tT}QU~*6e zLRt*!UNjG4-_Y#6oI8o+ymD!NEy(DiZPibtu4L150GG|nx3}=e8Y`746av!BXL9}O z4)*LbL}4i37$b0}Fr+ds>WVs-mPPp%z19H|{?>ciC7BLs(EGsCXT93XV7kZ^6a#r# zUGO+Q`bw94v^{SDr~%o1l2$IHoTwRKvPGimDHNQ-D-lk2$|%^Yf60Y(sH*-|=-#-9?$OwU59zvom|`CN_ z>AZE8$1h=}!fGAOvu+F?Ur3jxZdra2$IbcCnPQ^d+eWRp4kVr6q z_3+S4o%1sWTQU3ev?XqTTzDV$jEIC&>-r)%X?3Vu8R0OF1x$1Twpi zM4*4l2%2J~a=ZKZ>g$Y9WRiqNf(b@l+5X+u^_Gdb(e23K&Ss+?{j6@6!Bmt2N%<39 zEiV}mO7Il4d${{h*JS(a@Xz7Fps`fYoL~0rMe#(%xbmAr^3i&`&QF;VYU+gV-*AFh z2NCjJy4~zAUyqkvOhAh@VqF2iv_b&z9cz!5W9*lcy6>66aM64>Ggn$(I^j2&Zh14m z?ERdQw!-oeA`AmGbyB~{$KR{EL-8`gP;W(IQwEtvd9M;b-IiyAcCi$8{)sE0EB6E> zqOVFH`qgS<1)Z`5yS6;X%j3XJ;AoWhK(Jq>A1em6Nv@XN@Hf+pDU@tUH0U=!bn<$( zi$!k!w~i8RQvw|dd1^30gHp+3 zAYBm{VALccDN-ee)DdcZG1bFycC?_?Ov+lJymy#T{nTQtNQ43A_@5A%O0Fh#5Q+m> zx7)+R7k?gvpM$O6ye{z4mEiIg_}tqSfC)(ef9v;vcKd?0^Wvdx5366yt;Z9G)XK?d z?8QG86*WUEEouwfE~jHm@Hq-1Mw_eiXAD3p2V4I~!>`$(j*$vtbHS~o>b$6HL2BuQ3FuCGTO|E`{I zNsTd&no9df#Sb;fe^HxoZW))9w0>zmw&s@D3)SoqH=~a)kezKrEj!^?q$U#l7ot!&$jRNts)Hk7V2IS_U>sN^ z&DyHW+Yt1*M+S7{`xFu!e~M}v_K@l9t>ojjB3ohJ0s>QfRi*LpjfHimTe=}L6liK} ztaE!**5AfO5o1bjFhCxf z{Xm)RyR}0TXD~vJ+$GI)DW34!K_Ikh-@k{|ZBW(lb#3^PNN=OEvQ5VHC4VQY;5I#a z1ziB|ukcz!<~h}>tP?E=kUYtgc(`}@)yJN>`5n~q+0w#16kZ^Fi9D1DXVscW(F+|21UOB#xk+u$lmLe=QGE?xrM$rc)lrP(E3nvL+vrNrH5*76kB!g6ow7fE9MBpt2#3AC zSUv>!rJ@~xB@`(ps38B#h8b0MDwY=0nf@_U)+NOCg#>|2*ZvDN1#Mm2*?5U85*0gC zu{OF?8_nf%MK5Oy1~YH()7ci!b~O7-X1>3*WirWEqpM8 z^m7y*=5%x${5a|Bu1py+xYXL=_>!!H!m4>2j;#|77&#Oev9=Rb(l)Y$W@WzxPBX=Z-s>s+DgVqUP3S%_xHqm6F>@aU zRFi}cU%|E;bb3xNF`+OY9B`kD!;~eFwuD5qF1Juo#0pUS| z%S7o>39dNZN{pGbrQMw?%8m4}vbE(#OmMqpdsBFn;Dlf+`qN(`j2Hbg3>Z#`P~2+R z^MN}Z+f1Y>eb+pB`z$hf(GlIMx^5R%4(B*@mbkW=y}Ck&j}M*$9t^O0{V$QNQID#} z41;**_`Rg7YO1_BMifs7C~n9J+tLug1VGL#`|8;Ro=!q}c}7^_+#Ex!&}^`ibf)Ih zHpbI*zCk!8x2b@ylxB7mZcXYA$YHnVQc6hD4NFunma>wT>S2R*i+wz9=hdSZH~AJ!s?P8@Ef@8XUeSEByd=w=SgCp8`(Iij-IY$5G`?x~ zMzK6-R&KWiX+#s_$Qi4dOFcD>F_%HMnjhWUk6AV9x5_?1-`H8mce{Ia$mfq+HdZ;S zYUNyln+*a_$^uu)0zTljUteLwRIlISVb^}c01$GBgxlzEiRDN0H@*Gt+D~l)80*T9 zektJ?>i@aK|0_nE<<~CpKgMcaW34-Gu|4SM^|u}?%YYE{QP=p?q3V^pXOC@=a~BtI zV8Bk|I5Hin;}t*LZo;z2Gd949Yc)4}B1C}Ap??UlhjF9Bx#{Ba^7DRt7bnRLB+S8Q zFD4_u%M}@xAf0E?Wy9ZGviH*P@JDXrS6cVZn>5}5vD-XUcpL7Mcg$H-UlSMyQqCaz z-EW@Di_^>fij9y2!np^CRA~zx%X-fr(#f}XWpIFXUx*?Fkq+#$J4VWKz|?3L84xmE@8ZWj4MMlSp?i$MG5Gj4 zIfHkez@1gABd;skJnkdHuX-T;GY~dxs;CRz{cz%U?Nw9++tI0w^e`hVd zYbuk6_JLYQtFMOz>V2$uVKUY!Au(JvMXB`IL!vfVw*C71_B6}P9KFq58{adHH3vQO?d$ypePYm%webi z-SaHEfhJ*H!(lrl8!8NFWbWPAbF81|^2}44Cdh_{dPpsj}Pq!!eu@ZPB z5d=f&?!KZC0-N#P&(X~3P6K4>vxp89kJ51Wj5;q}PLHQ zUXsJYtPEWl*hV;HOBMC?zR)Va8~PsSH|>Ki1#KL{aiMY(8hHeiXC9Q;9WXl+1UdAu z3$p?OP06>vFDk$!Nnbs9yztAcES7-W?GRy69--Z(F^J+FK?)FnP<8<3xC1emLNL55 zmJy@w?V7cte$z&bw7rBERH@ZS!c)5I-7~ zz1xQB?k5*Ly(vdTn<6wJ_Jbn+g_xbKF-XxF>9q8uVB^ZlQIZnPNanw}BZcR_d^hc) zzBmgV>qXPAp`Mnl%}_~ASD%EIav^%^#u^H$q(>$@MxBGY4Ie4DPpI)r5|AB3ug4-Fv*-!q;YTDvuV%;I zTC|;}i>06ht0`jTQJx#a1I%glMs>qGD5I|bTs{Hef_AzWJa4QOpFYAYI_=hkp1lUtCn!?WRw#W66M?`*P@pwu-(vf(IT5H~1NGmt#2XHWjiFMTBVXJ8AQp zt-aC=w51>oN9WeXk^qgf^?cyc6MH=GCW6241 z-gVewdS%&s{3se(gH!%Zcq`>achKKv2_XKhpJim?6aW(jCB!)pvnj3m1~d->5qxX_ zwS>lCZ85OM>ZkMB0LHm=Hj~2- zU~`b?Ju4`inLhPbkclRIlAY{o0UCVb41EalX*~!rB;cuHZwOfn-nE9_Ha}ug-a8n= zyUt(n*4PjM$2JQdrsLiMma7)hpC0DhE;cFDa^*tfJ9Y8RLH7{WR;%O`ltg<7G1({@ zyyJN;*QI$(H%_SeWH!MqA2*A*#DfRrOf$>XQZOZQT0EvUAi8?E<1~I45%%3{_~l_N zLMOb_8SnO45lGqkx^zO_004Ie%@63;o>8Hb(vDwgf<7gJv`k@GWt7;v9 zgP%pT8EUNGTeC1yNOcl4$3f1bvFFXRRnkCa+M2&cj$x8+yzX$`No&MQyprzl^x>Ix zIX06s>$GZ4PVNvB^1JLt-UHc?%wZOMil7$FPPf8X7c!uRu^Gt(w2>?Gk!^>pD>Fj9h)nTTcPaZi(5T+4GmPtt zIl%LK%?`=Kz4?R9U5;7AIOD^(d4>*z{3~NwFq4w}FWAQMU(O_s{|6b1#&7?i2+CKE zUVfY-x$aB3c!^0#JdjBV3kew5Myz=KN{m2CG@k6|ZTn|@Rr2zXM;`;Qo}n4(^^Vs~ zyV>l-n%Awt?Pg&unz)|#U>bTMM_xdyx|d8aMRXea1H^rrN7Rznq2KF+HCw5{QEp15 zD{+)58@lg;v5ABA$gBxnqGpC4kO;ykM@gew)NPzDP3$)hQ61JxIJ#0=S|LK%j-}Jn z3GRy$#?Q`R`0!u1>e~%>p71^9SGrhVo&mOnZ)8LW6k;rfXJvsdD7q`yoLfg?97a5a zG*J?cpl2oixYkpCfvnDp*0nyK9!0wh$h@=(%S;H0nipCXO zcq}R^@Kgs*SF^djT&&DGWYj8${7d*6MW%HLn+-EqIuuuaj!>}s>q|0YPDll5>phxN zM8k=KoWNH}$lt8TFyVShF_`PbpwY=8-Kw^~Uaok>H~fZV5bIMK{W?t;c2_lQi-B$9 z5FHM!%-NHXa0&GJ=>Tt~w&V)rE&W(ljJ0Zetx1au2qafg-{dMP2;DxONzx^g_rc5K zNwwKtpZc!1^Q)`p_W^CMmnrWA%7IW6&@@+OAeumjpH<9$AR*9riM`qcAs@&ueuFhT z6SY6QCGJJNB(g?y#;G>UnA{;xA8WM@*X7FV{9&h0#PsarULN`PR%ApWq7Va$R|88) zp?1{ED{2c&^9(*V={HMqZOzEInL{GiV%G(|+R0*qG}A64HuJ{VUOp-%NbMgUb+)n1 zm=yg2K<9Glp3Cx_aMm3*4fbL>fW{z}e$o5kkRsQp-eC-y8-8c@?L%SKTN`OJc0phOUR9sd z(x{Ko?a+k@qtV(=-k-6?Co>a?gs$Y8t!dx@j^Gc4`JfC|mG^Vi<-$5U0sQS6Pw*&R zUJn;b8?f@wr=1H?;%FeOjtfu^D-+Ppp=Ou&)UmZPT{xer!SYwD;|<@s^S|y@zL(@3 zZH*5_#L@lGSC?~T+ezzyujc};yROK7YMu2rc`fTFdDZfn@>&{YkvHtxB6;MVFzBrs zpx6fd`TK=pjJ%uy^^-Vop_iqTq$KrI7sbyFlR1sjM&5}9@$X90k4@am0X;$2f7k$i zd!+tsn=5$9t%ZW&oWu(rnci_e?b9@LK29bgM_E$ucS0RUjGv~zQ*7|;vMr}3;)05$ zmirK6IOqxgWl4A8!&iPWNs*Jp74~*xQj!&xGoa4m@`H}V*f(*stS% z<(Et(TUUG%cn;n_oWb6-!XE`rHPI@H;4SVBd<_2su6|j058EqgzTuOHafSc(Ej2}% zr5;Q@G}2CH!ONxkyj8!j<($%1wNQ1IeJbu1S~f9l9@r57h$3eo3TqZclAH1ZKH2WU zU9Z@*q^Y0c(KbeJ>y=yRqC>xu+kxWe`mvu;fR~bqh;hjXi-3GIAMJkhk<860lf4~m zr)nejs>sN<32M$LR+`|Fsby;NtY9-~`O~+%UEf^eG{DnQlYxlBJEXjNa>n?V^$)$t zy2y$pxm#k6D>FET0XsS#5n=*3$>Y7fn7lFL&F3ZcdN=u7ma(>(#|;(|?N15q#>t7Z zq`$;dyi?(_HgPL5xcC}zFb9Q;c=z;N$?9EfV&w`KmIh1vK>tp9H$6)7{MZZvg;}5Y zXvWXi6#uDNp!hxWstVh?sfs{jgE$+@(M{~hJk0b`xdMbp)~mf652|AT2xj-qx@E7omvEIRJ^mw>s_Jp3>mbLM|(yi&; zNH0BfthxQ&?BplE{~$^hkq{Wah(1duI1k?)yKWqGp!!mwFa|dGKlClfw!r_|(k%aL z>I6H}|DQU+&c^t^k}usFI(Ay@Fg~xfb4J|y9Y~as3kWC@TE^6M2BHgqn}LR7Ve=r; zhXf9xH@mkA5shyn5v=TM!Z_ov;RR#DkzKKWhd|MZRZ<~-(sd+X^mK}%1taN9n*%tY zmcf?)?rlltyV^E;PU_T;msl-H3E~!|Buo;d5U-Wwzla=a^q(Svc z+t_d}2e3+1y3d!D8jdtnT4SRk3jtPDP8{HHt(pq~<`D)&h=vkVfGxa&K+CcBe;Hbe zjb~uOXMhp0KEOmP7?O=NR0a|Q0yncH=2Mn?!|osLpPH(p1P`gkkP^Z_`#ru` zP+Kd@G*FHk6BmjWgaVTshYp4Xzo0y@v>^6S&)eUDqf@Q{lOHGzy{eyMOi4C`tYRseWuBT*~ zP)~%)rtOfB86uO@!h0uR$)kAT?gtTdBk3+3D9tOi8)jdEUkM$s`b#PunEHpj56Y5ux8-Vi6Olo2&7WlTE)^19 z1%*0ubS-F#vi7LzVzk`Rb{jKSJ~u5b+ciO|h~nhSPB{3m*VM+s?(?nd&i$`VTz2m? z-}KH-7yR#@w1fWs(sN^XV9dqG_vB=+P162nDaWGr1jl((EJ-I$IZes<NWZM5Ma2e!9 zpG$t&@<_FjMvSFqUt~Lj2%C+g0W|Psud1R8kHTVXa6B2#$e=DvGmG#k{f&tV@cOT@ z9ezR>-+braMDKDqA4!`EJHBP&UsFxbo zW+%o)&=_r$VKrZ`r2x&He$u zsikETX3&W`Ikc$&}s-|c)E<*Q?Xrj?ibr`+X5we# z>49iS#P?CMwSL*u9oIB`b-TuK&wM2t?i$o{4rx8i_jD=cCZ&^sK@?~ql1BOgw?e(a zc|T$(c%tx(2+)^^II^hucTmAU@x8(zPMCR@N>%~E=zV5^e9_-{eeE30S}Gy z5qlM49B=T(D*aniQ+rBP8``mwF2+^S6O%X;O=tB5RkcE811uU#lBT38SV<&ZIm{GL zntgGtR6H+)dAWHZMsFaaHOYWDcICegV3akU!rmS?8DFUxDsF|znlbzZjvsKL$f z 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

vi%SXyb1HO%1rQhHXQYS}K<`3$%~+ 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 }zU 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

C4H|86h@|Z$|(8q59D>)z2qZ|Z2f#6y;-?HXh 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%0A0q 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 z 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

P(>-I+*f7FM}+rr~aW62FEa~=c=_K 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 b8&7XP@|Jr#h@6xxL{^UO@?~{>4Z8mV*IIWm 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 @@ - - - - -hip_spec - - - - -

-

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 Overview3
Install HIP
25
2.1Prerequisites . . . . . . . . .5
2.2Installation . . .5
2.3. . . . . Verify your installation . . .6
3Build HIP from source7
3.1 Prerequisites. . . . . .
. .7
3.2 Building the HIP runtime 3.3 . ..7
Build HIP tests . . .10
. . . 3.4 Run HIP . . . . . . . . . . .11
4HIP programming model13
4.113
4.2RDNA &CDNAarchitecture summary Heterogeneous Programming . .14
Single instruction multiple threads (SIMT) . . .14
4.3 4.4Inherent thread model . .15
4.5. . . . 4.4.1 Cooperative groups thread16
Memory model . . . . . . . . .16
4.6 Execution model .. . . . .17
4.6.1 Host-side
execution17 17
4.6.2Device-side execution . .
4.6.3Kernel launch .18
5Hardware implementation19
Compute units. . . . . . .19
. . . . .20
5.15.1.1 5.1.2SIMD . . Vector cache . .20
5.1.3. . Local data share . .20
5.1.4Scalar Unit . . . .20
5.2 CDNA architecture .. . . .20
5.3 RDNA architecture . .. . . .21
5.4 Shader engines . .. . . .21
(CLR)
6AMDcommon language runtimes23
6.1 Project organization. . . .23
How to build/install .. . .23
6.26.2.1Prerequisites . . .23
6.2.2Linux . . . . . . .23
6.2.3Test . . . . . . . .24
-

**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.

-
6.2.4Release notes . . . . . . . . . . . . . . . . . . . . .24
HIP programming manual25
7 7.1Host Memory . . . . .. . . . . . . . . . . . . . . . . . . . .25
7.1.1Introduction . . . . . . . . . . . . . . .25
7.1.2. . . . . . . Memory allocation flags . . . . . . . . .25
7.1.3. . . . . . Numa-aware host memory allocation . . . . . . . . .26
7.1.4Coherency Controls . . . . . . . . .26
7.1.5. . . . . . . . . Visibility of Zero-Copy Host Memory . . . . . . . .27
7.1.6hipEventSynchronize . . . . . . . . . . .27
7.1.7. . . . Summary and Recommendations . . . . . . . . . . .27
7.1.8Managed memory allocation . . . . . . . . . . . . .28
7.1.9HIP Stream Memory Operations . . . . . . . . . . .28
7.2Direct Dispatch . . . . . .. . . . . . . . . . . . . . . . . . .28
7.3HIP Runtime Compilation. . . . . . . . . .29
7.4. . . . . . . . . HIP Graph . . . . . . . . . . . . . . . . .. . . . . . . . . .29
7.5Device-Side Malloc . . . . . .. . . . . . . . . . . . .29
7.6. . . Use of Per-thread default stream . . .. . . . . . . . . . . . .29
7.7Use of Long Double Type . . . . .. . . . . . . . . . . . . .30
7.8Use of _Float16 Type . . . . . . .30
7.9. . . . . . . . . . . . . . FMA and contractions . . . . . . . . . . . . . . . . . . . . .30
7.10Math functions with special rounding modes . . . . . . . . . . . . . . . .. . . . .30
7.11Creating Static Libraries . . .. . . . .30
8 HIP porting guide . . . . . . . . . . .33
8.1Porting a New CUDA Project .. . . . .33
General Tips . .
8.1.1. . . . . . . . . . . . . . . . . . .33
8.1.2Scanning existing CUDA code to scope the porting effort 'in-place' . . . . . . . . . .33 34
8.1.3Converting a project . .
8.1.4Library Equivalents . . . . . . . . . . . . . . . . . .35 35
8.2Distinguishing 8.2.1Compiler 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 Device36
8.2.4Compiler Defines: Summary . . . . . . . . . . . . . . .37
8.3Identifying Architecture Features . .. . . . . . . . . . . . .37
8.3.1HIP_ARCH Defines . . . . . . . . . . . . . . .37
8.3.2Device-Architecture Properties . . . . . . . . . . . .38
8.3.3Table of Architecture Properties . . . . . . . . . . . . . . . . . .38
8.4Finding HIP . . . . . . .. . . . . . . . . . . .39 40
8.5 8.6Identifying HIP Runtime . . . . . hipLaunchKernelGGL . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .40
8.7Compiler Options . . . . . . . 8.7.1 Compiler options supported. . . . . . . . . . . . . . . .40
on AMDplatforms . . .40
8.8Linking 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++
. . . . . . . . . . . . . . . . .41
8.9.2HIP 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.10Workarounds . . . . . . . . . . . .. . . . . . . . . . . .43
-

8.10.1

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

43

-

**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.

-
warpSize
8.10.2 Kernel launch with group size > 256 . . . . . . . . . . . . . . . . . . . . .43
8.11memcpyToSymbol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .43
8.12CU_POINTER_ATTRIBUTE_MEMORY_TYPE. . .44
8.13threadfence_system . . .. . . . . . . .45
. . . . . . 8.13.1 Textures and Cache Control . . .. . . . . . . .45
8.14More Tips . . . .. . . . . . . . .46
8.14.1. . . . . . . . . . . HIP Logging . . . . . . . . .. . . . . . . . .46
8.14.2Debugging hipcc. . . . . . . . . . . . . . . .47
8.14.3Editor Highlighting . .. . . . . . . . . . . . .47
9Porting CUDA driver API49
9.1Introduction to the CUDA Driver and Runtime APIs . . . . . . . .49
9.1.1cuModule API . . . . . . . . . . . . . .49
9.1.2. . . . . . . . . cuCtx API . . . . . . . . . . . . . . . . . . . . . . . . .50
9.2HIPModule and Ctx APIs . . . . . . . . . . . . .. . .50
9.2.1hipModule API . . . . . . . . . . . . . . . . . . . . . . . . . . .50
9.2.2. hipCtx API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .51
9.2.3hipify translation of CUDA Driver API . . . . . .51
9.2.3.1Address Spaces . . . . . .51
9.2.3.2. . . . . . Using hipModuleLaunchKernel . .51
9.2.3.3Additional Information51
9.2.4. . . . . . . . . . . hip-clang Implementation Notes . . . . . . . . . .51
9.2.4.1.hip_fatbin . . . . . . . . . . . . .51
9.2.4.2Initialization and Termination Functions52
9.2.4.3Kernel Launching52
9.2.5. . . . . . . . . . . . . . . . . . NVCC Implementation Notes . . . . . . . . . . . . . . . . .52
. . . . 9.2.5.1 Interoperation between HIP and CUDA Driver . . . . . . .52
9.2.5.2 Compilation Options . . .. . . . . .53
9.3HIPModule and Texture Driver API . . . .. . . . . . .55
10Programming for HIP runtime compiler (RTC)57
10.1Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .57
10.2HIPRTCspecific options . . . . . . . .. . . . . . . . .61
10.2.1Bitcode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .62
10.2.2CU Mode vs WGP mode . . . . . .62
10.3LinkerAPIs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .62
10.3.1Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .63 63
10.3.210.3.1.1 Note . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Input Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .64
10.3.3. Backward Compatibility of LLVM Bitcode/IR . . . . . . . . . . . . . .64
10.3.4Link Options . . . . . . . . . .. . . . . . . .64
10.4Error Handling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .65
10.5HIPRTC General APIs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .65
10.6Lowered Names (Mangled Names) . . . . . . . . . . .66
10.6.1 10.6.2Note . . . . . . . . . . . . . . . . . . . . . . . . . . . Example . . . . . . . . . . . . . . . . . . . . . . . . .66 66
10.7. . . . . . . . . . .67
10.8Versioning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . HIP header support . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .68
10.9Deprecation notice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .68
1169
11.1Performance guidelines Parallelexecution. . . . . . . . . . . . . . . . . . . . .69
-

11.1.2

-

Device level

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

69

-

**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.

-
11.1.3Multiprocessor level . . . . . . . . . . . . . .70
11.2Memoryoptimization . . . . . . . . . . . .70
11.2.1Data Transfer . . . . . . . . . . . . .70
11.2.2. . Device Memory Access . . . . . . . . . .71
11.3Optimization for maximum instruction throughput71
11.3.1Arithmetic instructions . . . . . . . . .72
11.3.2. Control flow instructions . . . . . . . . .72
11.3.3Synchronization . . . . . . . . . .72
11.4. . . . Minimizing memory thrashing .. . . . . . . . . .73
12 Debugging with HIP75
12.1Tracing . .. . . . . . . . . . . . . . . . . . . . .75
12.2Debugging . . . . . .. . . . . . . .77
. . . . . . . 12.2.1 Debugging HIP applications. . . . . . .77
12.3Useful environment variables. . . . . . .79
12.3.1. . . . Kernel enqueue serialization . . . . . . .79
12.3.2Making device visible . . . . . . . . . . .79
12.3.3Dump code object . .79
12.3.4. . . . . . . . . . . HSA-related environment variables (Linux)80
12.3.5 HIP environment variable summary . ..80
12.4General debugging tips . . .. . . . . . . . . . . .82
13 Logging HIP activity83
13.1Logging level . . . . . . . .. . . . . . . . . . . .83
13.2Logging mask . . . . .. . .84
13.3. . . . . . . . . . . Logging command . . . . . . . . . . . . . .. . .84
13.4Logging examples . . . . . .. . . . . . . . . . .85
14 Cooperative groups . . . . . . . . . . . .89
14.1Cooperative groups thread model . . .89
14.2Group types . . . . . . . . group. . . . . . . . .90
14.2.1Thread-block . . . . . . . . . . . . .90
14.2.2Grid group . . . . . . . . . . . . . .90
14.2.3. Multi-grid group . . . . . . . . . . . . .90
14.2.4 14.2.5Thread-block tile . . . . . . . . . . . . . Coalesced groups . . . . . . . . . . . . .91 91
14.3Cooperative groups simple example . .. . . . . .92
14.4Synchronization . . . . . .. . . . . . . .94
14.5. . . .. . . .97
Unsupported NVIDIA CUDA features . . .
15 Unified memory99
15.1Unified memory . . .. . . . . . . . . . . . . . .99 99
15.2System requirements . . . . .. . . . . . . . . . .100
15.3Unified memory programming models. . . . . .
15.3.1Checking unified memory management support100
15.3.2 Example for unified memory management101
15.4Using unified memory management (UMM). . .104
15.5Unified memory HIP runtime hints . . . . .for the better performance104
15.5.1Data prefetching . . . . . . . . .105
15.5.2Memory advice . . . . . . . . . . . . . .106 107
15.5.3 15.5.4Memory range attributes . . . . . . . . . Asynchronously attach memory to a stream108
16 Virtual memory management109
-

**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.

-
16.1Memory allocation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16.1.1. . . 109 . . .
Allocate physical memory . . . . . . . . . . . . . . . . . . . . . . . . . . . .109
16.1.2Reserve virtual address range . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . 110
16.1.3Set memory access . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . 110
Free virtual memory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . 110
16.216.1.4 Memory usage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . 111
16.2.1 Dynamically increase allocation size . . . . . . . . . . . . . . . . . . . . . . .. . . 111
17 Frequently asked questions113
17.1What APIs and features does HIP support? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . 113
17.2What is not supported? . . . . . . . . . . . . . . . . . . . . . . . . .. . . 113
17.2.1 Runtime/Driver API features . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . 113
17.2.2 Kernel language features . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . 114
17.3 IsHIP a drop-in replacement for CUDA? . . . . . . . . . . . . . . . . . . . . . . . . .. . . 114
17.4What specific version of CUDA does HIP support? . . . . . . . . . . . . . . . . . . . .. . . 114
17.5What libraries does HIP support? . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . 115
17.6How does HIP compare with OpenCL? . . . . . . . . . . . . . . . . . . . . . . . . . .. . . 115
17.7How does porting CUDA to HIP compare to porting CUDA to OpenCL? . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . 115
17.8What hardware does HIP support? . . . . . . . .. . . 116
17.9Do HIPIFY tools automatically convert all source code? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . 116
17.10What is NVCC? . . . . . . . . . . . . . . . .. . . 116
17.11. . What is HIP-Clang? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . 116
17.12Why use HIP rather than supporting CUDA directly? . . . . . . . . . . . . . . . . . . .. . . 116 117
17.13Can I develop HIP code on an NVIDIA CUDA platform? . . . . . . . . . . . . . . . . Can I develop HIP code on an AMDHIP-Clang platform? . . . . . . . . . . . . . . . .. . . . . . 117
17.14How to use HIP-Clang to build HIP programs? . . . . . . . . . . . . . . . . . . . . . . . . . .. . . 117
17.15. . . . . . . . . . . . . .
17.16 17.17What is AMDclr? . . . . . . . . . . . . . . . . . . . What is hipother? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . 117 . . . 118
17.18Can I get HIP open source repository . . . . . . . . . . . . . . . .. . . 118
17.19for 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.21Can HIP API support C style application? What is the difference between C and C++? . .. . . 118
17.22Can I install both CUDA SDK and HIP-Clang on the same machine? . . . . . . . . .. . . 119
17.23HIP detected my platform (HIP-Clang vs NVCC) incorrectly * what should I do? . . . . . . . . . . . . . . .. . . 119
17.24On CUDA, can I mix CUDA code with HIP code? . . . . . . . . . . . . . .. . . 120
17.25How do I trace HIP application flow? . . . . . . . . . . . . . . . . . . . . . .. . . 120
17.26What are the maximum limits of kernel launch parameters? . . . . . . . . . . . . . . .. . . 120
17.27Are __shfl_*_sync functions supported on HIP platform? . . . . . . . . . . . . . . .. . . 120
17.28How to create a guard for code that is specific to the host or the GPU? . . . . . . . . . .. . . 120
17.29Why _OpenMP is undefined when compiling with -fopenmp ? . . . . . . . . . . . . . .. . . 121
17.30Does the HIP-Clang compiler support extern shared declarations? . . . . . . . . . . . .. . . 121 code
17.31I have multiple HIP enabled devices and I am getting an error hipErrorSharedObjectInitFailed with the message 'Error: shared object initialization failed'? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . 121
17.32How to use per-thread default stream in HIP? . . . . . . . . . . . . . . . . . . . . . . .. . . 122
17.33How 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.35Does HIP support LUID? . . . . . . . . . . .. . . 123
17.36How can I know the version of HIP? . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . 123
18 HIP Runtime 18.1 RelatedAPI Reference Pages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .125 . . . 126
-

18.3

-

Namespaces

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

126

-

**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.

-
18.3.1Namespace List . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.3.2Namespace Members . . . . . . . . . . . . . .126
18.3.2.1 Namespace Members . . . . .126
18.3.2.2 Namespace Members .126
18.4. . . . . Data Structures . . . . . . . . . . . . . . . . . . .126
18.4.1 DataStructures . . . . . . . .. .126
18.4.2. . . Data Structure Index . . . . . . . .126
18.4.3. . . Class Hierarchy . . . . . . . . . . . . . .126
18.4.4. . Data Fields . . . . . . . . . . . . . . . . . .126
18.4.4.1 All . . . . . . . . . . . . . ..126
18.4.4.1.1Data Fields . . . . .126
18.4.4.1.2Data Fields . . . . .126
18.4.4.1.3Data Fields . . . . .126
18.4.4.1.4Data Fields . . . . .126
18.4.4.1.5Data Fields . . . . .126
18.4.4.1.6Data Fields . . . .126
18.4.4.1.7. Data Fields . . . . . .126
18.4.4.1.8Data Fields . . . .126
18.4.4.1.9Data Fields . . . . . . .126
18.4.4.1.10Data Fields . . .126
18.4.4.1.11Data Fields . . . . . . .126
18.4.4.1.12Data Fields . . .126
18.4.4.1.13Data Fields . . . . . Data Fields .126
18.4.4.1.14. . . . Data Fields126
18.4.4.1.15. . . . . .126
18.4.4.1.16Data Fields . . . .126
18.4.4.1.17Data Fields . . . . .126
18.4.4.1.18Data Fields . . . . .126
18.4.4.1.19Data Fields . . . . .126
18.4.4.1.20Data Fields . . . . . .126
18.4.4.1.21Data Fields . . . .126
18.4.4.1.22Data Fields . . . . .126
18.4.4.1.23Data Fields . . . . .126
18.4.4.1.24Data Fields . . . .126
18.4.4.1.25. Data Fields . . . . .126 126
18.4.4.2 Data Fields - Functions . . . . . . . . . . . . . 18.4.4.3 Variables . . . . . . . . . . . . . . . . . . . . .126
18.4.4.3.1Data Fields - Variables126
18.4.4.3.2Data Fields - Variables126
18.4.4.3.3Data Fields - Variables126
18.4.4.3.4Data Fields - Variables126
18.4.4.3.5Data Fields - Variables126
18.4.4.3.6Data Fields - Variables126
18.4.4.3.7Data Fields - Variables126
18.4.4.3.8Data Fields - Variables126
18.4.4.3.9Data Fields - Variables126
18.4.4.3.10Data Fields - Variables126
18.4.4.3.11Data Fields - Variables126
18.4.4.3.12Data Fields - Variables126
18.4.4.3.13Data Fields - Variables126
18.4.4.3.14 18.4.4.3.15Data Fields - Variables Data Fields - Variables126 126
18.4.4.3.16Data Fields - Variables126
-

18.4.4.3.17

-

Data Fields - Variables

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

126

-

**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=" is marked as deprecated, indicating that it is being replaced by "--offload-arch=". -- 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" 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.

-
18.4.4.3.18Data Fields - Variables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.4.4.3.19Data Fields - Variables. . . . . . . . . . . . . . . . . . . . .126
18.4.4.3.20Data Fields -Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.4.4.3.21Data Fields - Variables. . . . . . . . . . . . . . . . . . . . . .126
18.4.4.3.22DataFields - Variables . . . . . . . . . . . . . . . . . . . . .126
18.4.4.3.23Data Fields -. . . . . . Variables . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.4.4.3.24DataFields - Variables . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.4.4.3.25DataFields - Variables . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.518.4.4.4 Data Fields - Related Symbols . .. . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . 126 . . . . . . . . .126
Files 18.5.1File List . . . . .. . . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.5.2Globals . . .. . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.5.2.1 All . .. . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.5.2.1.1Globals . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.5.2.1.2Globals . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.5.2.1.3Globals . . . .. . . . . . . . . . . . . . . . . . . . . . . . .126
18.5.2.1.4Globals . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.5.2.1.5Globals . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.5.2.1.6Globals . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.5.2.1.7Globals . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.5.2.1.8Globals . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.5.2.1.9Globals126
. .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.5.2.2 Functions 18.5.2.2.1. . . . . . . Globals . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.5.2.2.2Globals . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.5.2.2.3Globals . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.5.2.3 Globals. . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.5.2.4 Globals. . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
. . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.5.2.5 GlobalsEnumerator . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.5.2.6 18.5.2.6.1Globals . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.5.2.6.2Globals .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
Globals.. . . .
18.5.2.7. . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
C++ language extensions127
19.1Function-typequalifiers. . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .127 127
19.1.1__device__ . .. . . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .128
19.1.2__global__. . . . . .
19.1.3__host__ . . .. . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .128
19.2 19.3Calling __global__ functions . . . . .. . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .128 129
19.4Kernel 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 . . . . . . . . . . .. .. . . . . . . . .130
19.5.1Coordinate built-ins. . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .130
19.5.2warpSize . . .. . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .131
19.6Vector types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . .131
19.6.1Short vector types. . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .131
19.719.6.2 dim3 . . . . . . . . . . . . . . . . . . Memory fence instructions . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132132
-

19.8

-

Synchronization functions

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

132

-

**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.

-
.. .
19.9Mathfunctions . . . . . . . . . . .132
19.10Texturefunctions . . . . . . . . . . . . .133
19.11Surfacefunctions . . . . . . . . . . . . .133
19.12Timerfunctions . . . . . . . . . . . . . .137
19.13Atomicfunctions138
19.13.1. . . . . . . . . . . . . Unsafe floating-point atomic RMWoperations139
19.14Warp cross-lanefunctions . .140
19.14.1. . . . . . Warp vote and ballot functions .140
19.14.2 Warpmatch functions . . . . .141
19.14.3. Warp shuffle functions . . . . .142
19.15Cooperative groupsfunctions . . . . . .142
19.16Warp matrixfunctions . . . . . . .143
19.17Independent. . . thread scheduling . . . . . .144
19.18ProfilerCounter Function . . . . . . . .144
19.19Assert . . . . .. . . . . . . . . . . . . .144
19.20. . . .printf . . . . . . . . . . . . . .144
19.21Device-Side Dynamic Global Memory Allocation . . . . . . . .145
19.22__launch_bounds__ . .145
19.22.1Compiler Impact . . . . . . . .145
19.22.2CU and EU Definitions . . . . .146 146
19.22.3 19.22.4 maxregcountPorting from CUDA __launch_bounds . . . . . . . . . .146
19.23Asynchronous Functions . . . . . . . . .147
19.23.1Memory stream . . . . . . . . .147
19.23.2Peer to peer . . . . . .163
19.23.3. . . . . Memory management . . .165
19.23.4. . . External Resource Interoperability195
RegisterKeyword . . . . . . . . . . . . .197
19.2419.25 PragmaUnroll . . . . . . . . . . . . .198
19.26In-LineAssembly . . . . . . . . . . . .198
19.27KernelCompilation . . . . . . . . . . .198
19.28
gfx-arch-specific-kernel . . . . . . . . .199
C++ language 20.120.1.1Modern C++ support . . . . . . . . . . . C++11 support . . . . . . . . .201 201
20.1.2C++14 support . . . . . . . . .202
20.1.3C++17 support . . . . . . . . .202
20.1.4C++20 support . . . . . . . . .202
20.2Extensionsand restrictions . . . . . . . .202
20.2.1Global functions . .202
20.2.2. . . . . . Device space memory specifiers . . . .202
20.2.3Exception handling . . . . .203
20.2.4Kernel parameters . . . . . .203
20.2.5Classes . . . .203
20.2.6. . . . . . . . . Polymorphic function wrappers .203
20.2.7Extended lambdas . . . . . . . .203
Inline namespaces
20.2.8. . . . . . .203
.205
21 HIP mathAPI205
21.1Single precision mathematical functions . . . . Double precision mathematical functions . . . Integer . . . .215
21.2intrinsics . . . . . . . . . . . .
21.3225
-

**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.

-
21.4Floating-point Intrinsics . . . . . . . . . . . . . .227
22Tablecomparing syntax for different compute APIs231
22.1Notes . . . . . . . . . . . . . . . . . . . . . . . .232
23HIPCooperative groups API233
23.1Cooperative kernel launches . . . . . . . . . . . .233
23.2Cooperative groups classes . . . . . . . . . . . . .234
23.3Cooperative groups construct functions . . . .237
23.4. . Cooperative groups exposed API functions . . . .238
24HSA runtime API for ROCm241
25HIP managed memory allocation API247
26HIP virtual memory management API251
27HIP deprecatedruntime API functions
257
27.1Context management . . . . . . . . . . . . . . . .257
27.2Memory management . . . . . . . . . . . . . . . . . .258
27.3Profiler control . . . . . . . . . . . . . . . .258
27.4Texture management . . . . . . . . . . . . . . . .258
28SAXPY - Hello, HIP261
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.2Invoking the compiler manually . . . . .266
29Reduction273
29.1 The algorithm . . . 29.2. . . . . . . . . . . . . . . .273
Reduction on GPUs. . . . . . . . . . . . . . . .273
29.2.1 Naive shared reduction. . . . . . . . . .274
29.2.2Reducing thread divergence . . . . . . . .276
29.2.3Resolving bank conflicts . . . . . . . . .276
29.2.4Utilize upper half of the block . . . . . . . . . . . . .277
29.2.5Unroll all loops . . . . . . .281
29.2.6Communicate using warp-collective functions282
29.2.7Prefer warp communication over shared282
29.2.8. Amortize bookkeeping variable overhead284
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
30Cooperative 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 reduction291
function variables . . . 30.3.1.2 2. The reduction of thread block . . . . . . . . . . . .291
-

**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.

-
30.3.1.3 3. The reduction of custom partition . . . . . . . . . . . . . . . . . . . . . . . . . .291
30.3.2Host-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 Conclusion4. Launch the kernel . . . . .293
30.4 .. . . . . . . . . . . . . . . . . . . . . . . . . . . . .293
31 License295
-

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.
    2. -
-

sudo apt-get install ubuntu-drivers-common && sudo ubuntu-drivers autoinstall sudo reboot

-

Alternatively, you can download the latest CUDA Toolkit.

-
    -
  1. Install the hip-runtime-nvidia and hip-dev packages. This installs the CUDA SDK and HIP porting layer.
    2. -
-

**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.
    2. -
-

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.

-
    -
  1. Set the environment variables.
    2. -
  2. Build HIP.
    3. -
-

**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 <ROCM_PATH>/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 <ROCM_PATH>/hip . This can be overridden by setting the HIP_PATH environment variable.
    • -
-

•

-

HSA is in

-

<ROCM_PATH>/hsa

-

. This can be overridden by setting the

-

HSA_PATH

-

environment variable.

-
    -
  • Clang is in <ROCM_PATH>/llvm/bin . This can be overridden by setting the HIP_CLANG_PATH environment variable.
    • -
  • The device library is in <ROCM_PATH>/lib . This can be overridden by setting the DEVICE_LIB_PATH environment variable.
    • -
  • Optionally, you can add <ROCM_PATH>/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.
    2. -
-

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.

-
                                                                                                                                                                                                        |                                                                                                                                                                                                       
-                                                                                                                                                                                                        
-
-

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 & 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.

-
-
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 --

-
-

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 <<<...>>> 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

-
-

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.

-
-

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

-
-

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

-

**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.

-
HIP API Synchronization EffectFenceCoherent Memory ityHost Visibil-Non-Coherent Host Memory Visi- bility
hipStreamSynchronize host waits for all commands in the spec- ified stream to completesystem- scope releaseyesyes
hipDeviceSynchronize host waits for all commands in all streams on the specified device to com- pletesystem- scope releaseyesyes
hipEventSynchronize host waits for the specified event to com- pletedevice- scope releaseyesdepends - see below
hipStreamWaitEvent stream waits for the specified event to completenoneyesno
-

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.

-
    -
  • > 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.
    • -
-

**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.

-
CUDA braryLi-HIP Li- braryROCm Li- braryComment
cuBLAShipBLASrocBLASBasic Linear Algebra Subroutines
cuBLASLthip- BLASLtN/ABasic Linear Algebra Subroutines, lightweight and new flexible API
cuFFThipFFTrocFFTFast Fourier Transfer Library
cuSPARSEhipSPARSErocSPARSESparse BLAS + SPMV
cuSOLVERhip- SOLVERrocSOLVERLapack library
AmgXN/ArocALU- TIONSparse iterative solvers and preconditioners with algebraic multigrid
ThrustN/ArocThrustC++ parallel algorithms library
CUBhipCUBrocPRIMLow Level Optimized Parallel Primitives
cuDNNN/AMIOpenDeep learning Solver Library
cuRANDhipRANDrocRANDRandom Number Generator Library
EIGENEIGENN/AC++ template library for linear algebra: matrices, vectors, numeri- cal solvers,
NCCLN/ARCCLCommunications 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`, 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

-

**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.

-
DefineHIP-ClangNVCCOther (GCC, ICC, Clang, etc.)
HIP-related defines:
__HIP_PLATFORM_AMD__DefinedUndefinedDefined if targetingAMD platform; undefined oth- erwise
__HIP_PLATFORM_NVIDIA__UndefinedDefinedDefined if targeting NVIDIA platform; unde- fined otherwise
__HIP_DEVICE_COMPILE__1 if compiling for device; un- defined if compiling for host1 if compiling for device; undefined if compiling for hostUndefined
__HIPCC__DefinedDefinedUndefined
__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 otherwiseUndefined
__NVCC__ UndefinedDefinedUndefined
__CUDA_ARCH__UndefinedUnsigned representing compute capa- bility (e.g., '130') if in device code; 0 if in host codeUndefined
hip-clang- related defines:
__HIP__ HIP-Clang commonDefinedUndefinedUndefined
defines: __clang__DefinedDefinedUndefined
-

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.

-

**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.

-
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 hasGlobalFloatAtomicExch32-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 hasSharedFloatAtomicExch32-bit integer atomics for shared memory 32-bit float atomic exchange for shared mem- ory
__HIP_ARCH_HAS_FLOAT_ATOMIC_ADD__hasFloatAtomicAdd32-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 hasSharedInt64Atomics64-bit integer atomics for global memory 64-bit integer atomics for shared memory
__HIP_ARCH_HAS_DOUBLES__ Warp cross-lane operations:hasDoublesDouble-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 hasFunnelShiftWarp vote instructions ( any , all ) Warp ballot instructions Warp shuffle operations ( shfl_* ) Funnel shift two input words into one
hasThreadFenceSystem hasSyncThreadsExtthreadfence_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__has3dGridGrids 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 <<< >>>, 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.

-

**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.

-
OptionDescription
--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-rdcGenerate relocatable device code, which allows kernels or device functions calling device functions in different translation units.
-ggdbEquivalent 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-tempsSave the compiler generated intermediate files.
-vShow 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:

-
    -
  • >
    • -
-

**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 (``), 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 > 256

-

Kernel code should use __attribute__((amdgpu_flat_work_group_size(<min>,<max>))) . 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 (`

`), headings (`

`), anchors (``), and bold text (``), 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 (`

`) and an anchor (``) 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
-

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(&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 <<< >>> 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:

-

**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.

-
FormatAPIsNVCCHIP-CLANG
Code Object Fat BinaryhipModuleLoad , 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 <<<>>> syntax, hipLaunchKernelGGL. The latter one is macro which expand to CUDA <<<>>> 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 <<<>>> 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.

-

**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.

-
HIP TypeCU Driver TypeCUDA Runtime Type
hipModule_tCUmodule
hipFunction_tCUfunction
hipCtx_tCUcontext
hipDevice_tCUdevice
hipStream_tCUstreamcudaStream_t
hipEvent_tCUeventcudaEvent_t
hipArrayCUarraycudaArray
-

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.

-
                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        
-                                                                                                                                                                                             
-                                                                                                                                                                                            
-	         
-                                                                                                                                                                                             
-         
-                                                                                                                                                                                              
-                                                                                                                                                                                             
-                                                                                                                                                                                            
-
-          
-                                                                                                                                                                                             
-                                                                                                                                                                                             >
-                                                                                                                                                                                                       
-                                                                                                                                                                                             //
-                                                                                                                                                                                                       
-                                                                                                                                                                                             }
-

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
-#include
-#include
-#include
-#include
-

**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 `

`, ``, `
`, and ``. 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
-#include
-#include
-#include
-#include
-

**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;iargBuffer(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 `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

-
                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        // Code to generate code object
-
-                                                                                                                                                                                                      
-#include "hip/hip_runtime.h"
-                                                                                                                                                                                                      
-extern texture 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 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 <hip/hiprtc.h>

-
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 kernel_binary(codeSize);
-  hiprtcGetCode(prog, kernel_binary.data());

-
After loading the binary, hiprtcProgram can be destroyed. hiprtcDestroyProgram(&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 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 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");
-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.

-
                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        
-                                                                                                                                                                                                       >

-
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 
-        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.

-
                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        

-                                                                                                                                                                                                       

-                                                                                                                                                                                                      

-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        

-                                                                                                                                                                                                     

-
-                                                                                                                                                                                                       
-                                                                                                                                                                                                     
- 	                                                                                                                                                                                                       
-                                                                                                                                                                                                      
-                                                                                                                                                                                                     
-
-                                                                                                                                                                                                      
-                                                                                                                                                                                                      
-                                                                                                                                                                                                     
-		                                                                                                                                                                                                      
-
-	                                                                                                                                                                                                      

-
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.

-
                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        
test, which caused a segmentation fault issue.                                                                                                                                                                                                        
                                                                                                                                                                                                        >
-                                                                                                                                                                                                       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 < 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:

-
**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.

-
Environment variableDe- fault valueUsage
AMD_LOG_LEVEL Enable HIP log on different Level00: 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 Level0x7FFFFFFF 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.00: 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 HIP0,1,2: Depending on the number of devices on the system
GPU_DUMP_CODE_OBJECT Dump code ob- ject00: Disable 1: Enable
AMD_SERIALIZE_KERNEL Serialize kernel enqueue01: Wait for completion before enqueue 2: Wait for completion after enqueue 3: Both
AMD_SERIALIZE_COPY Serialize copies01: Wait for completion before enqueue 2: Wait for completion after enqueue 3: Both
HIP_HOST_COHERENT Coherent mem-00: 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)10: Disable 1: Enable
GPU_MAX_HW_QUEUES The maximum number of hard- ware queues allocated per device4The 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++.

-
                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        

-                                                                                                                                                                                                       
-        Loggging examples                                                                                                                                                                                                        >
-                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       >
-
-                                                                                                                                                                                                       

-                                                                                                                                                                                                      


-                                                                                                                                                                                                     

-
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                       	                                                                                                                                                                                                       
-                                                                                                                                                                                                     
-  
-                                                                                                                                                                                                   

-  
-                                                                                                                                                                                                  

-
(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.

-
                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        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/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.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 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;
-        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.

-
**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.

-
Table 1: Supported Unified Memory Allocators
ArchitecturehipMallocManaged()__managed__malloc()
MI200, MI300 Series1
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.

-
**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.

-
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 
-#include 
-
-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 
-#include 
-
-// 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 
-#include 
-
-// 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
-    #include 
-
-    // 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(&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 
-  #include 
-    
-  // 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 
-        #include 
-        
-        // 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 (`` and ``) 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 ( <<< >>> ) 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 >= 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(&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 <<< >>> 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<<>> (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 <<< >>> 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<<>> (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_<type_name>() . 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. 
-
  2. Modify kernels that use __threadfence_system() as follows:
    3. 
-
  3. Ensure the kernel operates only on fine-grained system memory, which should be allocated with hipHostMalloc() .
    4. 
-
  4. Remove memcpy for all allocated fine-grained system memory regions.
    5. 
-

-
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<typename T , typename std::enable_if<__hip_is_tex_surf_channel_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable_if<__hip_is_tex_surf_channel_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable_if<__hip_is_tex_surf_channel_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable_if<__hip_is_tex_surf_channel_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable_if<__hip_is_tex_surf_channel_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable_if<__hip_is_tex_surf_channel_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable_if<__hip_is_tex_surf_channel_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable_if<__hip_is_tex_surf_channel_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable_if<__hip_is_tex_surf_channel_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable_if<__hip_is_tex_surf_channel_type< T >::value>::type* = nullptr>

-
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<typename T , typename std::enable_if<__hip_is_tex_surf_channel_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable_if<__hip_is_tex_surf_channel_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable_if<__hip_is_tex_surf_channel_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable_if<__hip_is_tex_surf_channel_type< T >::value>::type* = nullptr> 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

-
**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.

-
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)

-
**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.

-
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:

-
**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.

-
Table 2: Cooperative groups functions
FunctionSupported in HIPSupported 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.

-
**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.

-
Table 3: Warp matrix functions
FunctionSup- ported in HIPSupported 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 
-
-    __global__ void run_printf() { printf("Hello World\n"); }
-
-    int main() {
-      run_printf<<>>();
-    }

-
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<class T >

-
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<class T >

-
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<class T >

-
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<typename T > hipError_t hipGetSymbolAddress ( void **devPtr, const T &symbol ) Gets the address of a symbol.

-
Parameters

-
    
-
  • devPtr -[out] - Returns device pointer associated with symbol.
    • 
-
  • symbol -[in] - Device symbol.
    • 
-

-
Returns

-
hipSuccess, hipErrorInvalidValue template<typename T > hipError_t hipGetSymbolSize ( size_t *size, const T &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<typename T >

-
hipError_t hipMemcpyToSymbol ( const T &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<typename T >

-
hipError_t hipMemcpyToSymbolAsync ( const T &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<typename T >

-
hipError_t hipMemcpyFromSymbol ( void *dst, const T &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<typename T >

-
hipError_t hipMemcpyFromSymbolAsync ( void *dst, const T &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<class T >

-
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<class T >

-
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.

-
                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        void                                                                                                                                                                                                        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 <=> ) 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: <<< >>> . 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.

-
**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.

-
Table 1: Single precision mathematical functions
FunctionSupported on HostSupported 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

-
**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.

-
Table1 - 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

-
**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.

-
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

-
**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.

-
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

-
**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`.

-
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

-
**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.

-
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

-
**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.

-
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

-
**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.

-
Table1 - 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

-
**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.

-
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

-
**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.

-
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.

-
21.2 Double precision mathematical functions

-
Following is the list of supported double precision mathematical functions.

-
**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.

-
Table 2: Double precision mathematical functions
FunctionSupported on HostSupported 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

-
**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.

-
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

-
**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.

-
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

-
**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.

-
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

-
**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.

-
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

-
**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.

-
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

-
**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.

-
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

-
**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.

-
Table2 - 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

-
**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.

-
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

-
**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.

-
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 & 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 & 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

-
**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.

-
TermCUDAHIPOpenCL
Deviceint deviceIdint deviceIdcl_device
QueuecudaStream_thipStream_tcl_command_queue
EventcudaEvent_thipEvent_tcl_event
Memoryvoid *void *cl_mem
gridgridNDRange
blockblockwork-group
threadthreadwork-item
warpwarpsub-group
Thread-indexthreadIdx.xthreadIdx.xget_local_id(0)
Block-indexblockIdx.xblockIdx.xget_group_id(0)
Block-dimblockDim.xblockDim.xget_local_size(0)
Grid-dimgridDim.xgridDim.xget_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__syncthreadsbarrier(CLK_LOCAL
Atomic BuiltinsatomicAddatomicAddatomic_add
Precise Mathcos(f)cos(f)cos(f)
Fast Math__cos(f)__cos(f)native_cos(f)
Vectorfloat4float4float4

-
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.

-
**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.

-
Warning:doxygenfunction:Cannotfind function'hipLaunchCooperativeKernel' Documentation'
indoxygenxmloutputfor project'HIP6.1.40092fromdirectory:
/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-
6.1.2/docs/doxygen/xml

-
**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.

-
Warning:doxygenfunction: projectCannotfind function'hipLaunchCooperativeKernel'
indoxygenxmloutputfor'HIP6.1.40092Documentation'from
/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-
6.1.2/docs/doxygen/xml

-
**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.

-
Warning:doxygenfunction:Cannotfindfunction'hipLaunchCooperativeKernelMultiDe-
vice'indoxygenxmloutput forproject'HIP6.1.40092Documentation'fromdirectory:
/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-
6.1.2/docs/doxygen/xml

-
**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.

-
Warning: indoxygenfunction: 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-
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<unsigned int size , class ParentCGTy >

-
class thread_block_tile : public cooperative_groups::impl::thread_block_tile_internal< size , ParentCGTy > 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<class T >

-
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<class T >

-
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<class T >

-
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<class T >

-
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<typename T >

-
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<typename T > unsigned long long match_all ( T value, int &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.

-
**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.

-
Warning:doxygenfunction:Cannot findfunction'cooperative_groups::this_multi_grid'
indoxygenxmloutputforproject'HIP6.1.40092Documentation'fromdirectory:
/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-
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

-
**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.

-
Warning:doxygenfunction:Cannotfindfunction'cooperative_groups::coalesced_threads'
indoxygenxmloutputforproject'HIP6.1.40092Documentation'fromdirectory:

-
/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs6.1.2/docs/doxygen/xml

-
**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.

-
Warning:doxygenfunction:Cannot findfunction'cooperative_groups::tiled_partition'
indoxygenxmloutputforproject'HIP6.1.40092Documentation'fromdirectory:
/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-
6.1.2/docs/doxygen/xml

-
**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.

-
Warning:doxygenfunction:Cannotfindfunction 'cooperative_groups::tiled_partition' 6.1.40092
indoxygenxmloutputforproject'HIPDocumentation'fromdirectory:
/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-
6.1.2/docs/doxygen/xml

-
**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.

-
Warning:doxygenfunction:Cannot findfunction'cooperative_groups::binary_partition'
indoxygenxmloutputforproject'HIP6.1.40092Documentation'from
/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-
6.1.2/docs/doxygen/xml

-
**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.

-
Warning:doxygenfunction:Cannot findfunction 'cooperative_groups::binary_partition' 6.1.40092
indoxygenxmloutputforproject'HIPDocumentation'fromdirectory:
/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-
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.

-
**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.

-
Warning:doxygenfunction: projectCannot findfunction'cooperative_groups::group_size'
indoxygenxmloutputfor'HIP6.1.40092Documentation'fromdirectory:
/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-
6.1.2/docs/doxygen/xml

-
**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.

-
Warning:doxygenfunction: Cannotfind 'HIPfunction 'cooperative_groups::thread_rank'
indoxygenxmloutputforproject6.1.40092Documentation'fromdirectory:
/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-
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<class T >

-
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<<>>(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.

-
                                                                                                                                                                                                        |                                                                                                                                                                                                       
-                                                                                                                                                                                                        -                                                                                                                                                                                                        --                                                                                                                                                                                                        \                                                                                                                                                                                                        +                                                                                                                                                                                                        <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        }                                                                                                                                                                                                        

-
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 `

-
  cuobjdump --list-ptx./saxpy
-
-  Which will print something like:

-
**Following code does:** The provided code snippet appears to be a series of `` and `` 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                                                                                                                                                        |                                               
-     |                                                                                                                                                                                                   |                                          
-     |                                                                                                                                                       
-     |                                                                                                                                                   |                                                    
-     |                                                                                                                                             
-     |                                                    
-     |                                                                                                                                        
-     |                                                         
-     |

-
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.

-
                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        

-
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. <major>.<minor> compute capability is passed to nvcc on the command-line as sm_<major><minor> , 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                                                                                                                                                                                                      

-
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. <major>. <minor> compute capability is passed to nvcc on the command-line as sm_<major><minor> , 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.

-
                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                                                                                                                                                                                                                                //                                                                                                                                                                                                       	                                                                                                                                                                                                      
-//                                                                                                                                                                                                        +                                                                                                                                                                                                        -                                                                                                                                                                                                        *                                                                                                                                                                                                        /                                                                                                                                                                                                        */
-                                                                                                                                                                                                       +
-                                                                                                                                                                                                       *
-                                                                                                                                                                                                       -
-                                                                                                                                                                                                       */

-
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>                                                                                                                                                                                                                                                                                                                                                                                                           
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             
-   
-                                                                                                                                                                                                    

-
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 < 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.

-
                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        

-
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(warp_size, [&]
-  {
-      hipLaunchKernelGGL(kernel,...);
-  });

-
**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
-        +template
-        __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, tmp::divide<2>>([&]()
-        +{
-        +     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                                                                                                                                                                                                     
- 
-                                                                                                                                                                                                      

-
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
-        __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< WarpCount, tmp::not_equal<0>, tmp::select< tmp::not_equal<1>, tmp::divide_ceil<WarpSize>, tmp::constant<0>>>([&]< uint32_t ActiveWarps>() { if (wid < ActiveWarps) { // Warp reduction tmp::static_for<WarpSize / 2, tmp::not_equal<0>, tmp::divide<2>>([&]< int Delta>() { 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 <size_t I> auto get<I>(...) 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<> 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` <reading-items>`and processing ``ItemsPerThread` <processing-items>`.

-
**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
-        {
-            return  [&](std::integer_sequence)
-            {
-                if(i + ItemsPerThread < front_size)
-                        return hip::static_array{
-                              front[i + I]...
-                        };
-                else
-                        return hip::static_array{
-                              (i + I < front_size? front[i + I] : zero_elem)...
-                        };
-            }(std::make_integer_sequence());
-        };
-
-        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 > gid) , or the more portable [[assume]](gid + 4 > 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 ref_reduced(const unsigned int          partition_size,
-                                                   std::vector input)
-    {
-        const unsigned int          input_size  = input.size();
-        const unsigned int          result_size = input_size / partition_size;
-        std::vector 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.
    2. 
-

-
(continued from previous page)

-
    
-
  1. The reduction of thread block and store the results in global memory.
    2. 
-
  2. The reduction of custom partition and store the results in global memory.
    3. 
-

-
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 custom_partition
-           = tiled_partition(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. 
-
  2. Initialize the cooperative group configuration.
    3. 
-
  3. Allocate and copy input to global memory.
    4. 
-
  4. Launch the cooperative kernel.
    5. 
-
  5. Save the results from global memory.
    6. 
-
  6. Free the global memory.
    7. 
-

-
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,

-
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

-
**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.

-
ChipArrayCreate ( C++ function ), 183
cooperative_groups::coalesced_group class ), 237C++ hipArrayDestroy ( C++ function ), 183 hipArrayGetDescriptor ( C++ function ), 185 ( C++ function ), 185(
cooperative_groups::grid_group ( C++ class ), 234hipArrayGetInfo 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 234hipDestroyExternalSemaphore hipDestroySurfaceObject ( C++ function ), 133 C++ function
cooperative_groups::thread_block_tile ( C++ class ), 234hipDeviceCanAccessPeer ( ), 163 hipDeviceDisablePeerAccess ( C++ function ), 164 ( C++ function ), 163
cooperative_groups::thread_block_tile::all ( C++ function ), 236 cooperative_groups::thread_block_tile::anyhipDeviceEnablePeerAccess hipDeviceGetStreamPriorityRange ( C++ function ), 148
( C++ function ), 236hipDrvMemcpy3D ( C++ function ), 192
cooperative_groups::thread_block_tile::ballothipDrvMemcpy3DAsync ( C++ function ), 192
hipDrvPointerGetAttributes ( C++ function ), 166
( C++ function ), 236
cooperative_groups::thread_block_tile::match_allhipExternalMemoryGetMappedBuffer ( C++ func- tion ), 196
( C++ function ), 237 cooperative_groups::thread_block_tile::match_anyhipExternalMemoryGetMappedMipmappedArray ( C++ function ), 197 hipExtMallocWithFlags ( C++ function ), 167236( ),C++function
cooperative_groups::thread_block_tile::meta_group_rank ( C++ function ), 235hipExtStreamCreateWithCUMask ( 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 ), 235hipFreeAsync
cooperative_groups::thread_block_tile::shfl ( C++ function ), 235
( C++ function ), 154
cooperative_groups::thread_block_tile::shfl_down
( C++ function ), 235hipFreeHost ( C++ function ), 172 hipGetProcAddress ( C++ function ), 176
cooperative_groups::thread_block_tile::shfl_uphipGetSymbolAddress ( C++ function ), 176, 193 ( C++ function ), 176, 193
( C++ function ), 235hipHostAlloc ( C++ function ), 168 hipHostFree ( C++ function ), 172
( C++ function ), 236( C++ function ),
cooperative_groups::thread_block_tile::sync ( C++ function ), 235169 ( 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 ),
234196 ( C++ function ),
( C++ function ), 166, 194
HhipMalloc hipMalloc3D
( C++ function ), 184
hipArray3DCreate ( C++ function ), 183
185hipMalloc3DArray ( 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

-
**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.

-
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

-
**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.

-
hipMemPoolExportPointer hipMemPoolExportToShareableHandle ( C++func-
tion ), 160
hipMemPoolGetAccess ( C++ function ), 158 hipMemPoolGetAttribute ( C++ function ), 156
hipMemPoolImportFromShareableHandle function ), 161( C++
hipMemPoolImportPointer ( C++ function ), 162 hipMemPoolSetAccess ( C++ function ), 157
hipMemPoolSetAttribute ( C++ function ), 156
hipMemPoolTrimTo ( C++ function ), 155
hipMemPrefetchAsync ( C++ function ), 247
hipMemPtrGetInfo ( C++ function ), 182
hipMemRangeGetAttribute ( C++ function ), 248
hipMemRangeGetAttributes ( C++ function ), 248
hipMemRelease ( C++ function ), 255
hipMemRetainAllocationHandle ( C++function ), 255
hipMemset ( C++ function ), 179
hipMemset2D ( C++ function ), 181
hipMemset2DAsync ( C++ function ), 181
hipMemset3D ( C++ function ), 181
hipMemset3DAsync ( C++ function ), 182
hipMemSetAccess ( C++ function ), 255
hipMemsetAsync ( C++ function ), 180
hipMemsetD16 ( C++ function ), 180 hipMemsetD16Async ( C++ function ), 180
hipMemsetD32 ( C++ function ), 180
hipMemsetD32Async ( C++ function ), 181
hipMemsetD8 ( C++ function ), 179
hipMemsetD8Async ( C++ function ), 179
hipMemUnmap ( C++ function ), 256
hipModuleGetGlobal ( C++ function ), 176
( C++ function ), 165
hipPointerGetAttribute hipPointerGetAttributes ( C++ function ), 165
hipPointerSetAttribute ( C++ function ), 165
hipSignalExternalSemaphoresAsync ( C++ func- tion ), 195
hipStreamAddCallback ( C++ function ), 152 hipStreamAttachMemAsync ( C++ function ), 249
hipStreamCallback_t ( C++ type ), 147 ( C++ function ), 147
hipStreamCreate hipStreamCreateWithFlags ( C++ function ), 147
hipStreamCreateWithPriority ( C++ function ), 147 hipStreamDestroy ( C++ function ), 148
hipStreamGetDevice ( C++ function ), 151
hipStreamGetFlags ( C++ function ), 150
hipStreamGetPriority ( C++ function ), 150 hipStreamQuery ( C++ function ), 149
hipStreamSynchronize ( C++ function ), 149
hipStreamWaitEvent
( C++ function ), 149
hipWaitExternalSemaphoresAsync ( C++ function ), 195
hsa_amd_vmem_address_free ( C++ function ), 241
hsa_amd_vmem_address_reserve ( C++function ),
241

-
**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.

-
hsa_amd_vmem_export_shareable_handle function ), 244
hsa_amd_vmem_get_access ( C++ function ), 243
hsa_amd_vmem_get_alloc_properties_from_handle ( C++ function ), 245
hsa_amd_vmem_handle_create ( 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_retain_alloc_handle ( C++ tion ), 245func-
hsa_amd_vmem_set_access ( C++ function ), 243
hsa_amd_vmem_unmap ( C++ function ), 243

-
S

-
**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.

-
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-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 && 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 <ROCM\_PATH>/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 <ROCM\_PATH>/hip . This can be overridden by setting the HIP\_PATH environment variable. - -• - -HSA is in - -<ROCM\_PATH>/hsa - -. This can be overridden by setting the - -HSA\_PATH - -environment variable. - -- Clang is in <ROCM\_PATH>/llvm/bin . This can be overridden by setting the HIP\_CLANG\_PATH environment variable. -- The device library is in <ROCM\_PATH>/lib . This can be overridden by setting the DEVICE\_LIB\_PATH environment variable. -- Optionally, you can add <ROCM\_PATH>/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. - - -``` - | - - -``` - -## 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 & 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 <<<...>>> 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. - -- > 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`, 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 <<< >>>, 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= [DEPRECATED] This option is being replaced by --offload-arch= . 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= Generate code to support up to the specified number of threads per block. | -| -O | Specify the optimization level. | -| | -offload-arch= 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: - -- > -**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 (``), 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 > 256 - -Kernel code should use \_\_attribute\_\_((amdgpu\_flat\_work\_group\_size(<min>,<max>))) . 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 (`

`), headings (`

`), anchors (``), and bold text (``), 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 (`

`) and an anchor (``) 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(&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 <<< >>> 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 <<<>>> syntax, hipLaunchKernelGGL. The latter one is macro which expand to CUDA <<<>>> 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 <<<>>> 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. - - -``` - - - - - - - - - - - - - - - - - - > - - // - - } -``` - -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 -#include -#include -#include -#include -``` -**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 `

`, ``, `
`, and ``. 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 -#include -#include -#include -#include -``` -**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;iargBuffer(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 `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 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 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 <hip/hiprtc.h> - -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 kernel_binary(codeSize); - hiprtcGetCode(prog, kernel_binary.data()); -``` - -After loading the binary, hiprtcProgram can be destroyed. hiprtcDestroyProgram(&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 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 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"); -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. - - -``` - - - - - > -``` - -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 - 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. - - -``` - - - -

-

-

- -

-

- - - - - - - - - - - - - -``` - -## 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. - - -``` - - - -

test, which caused a segmentation fault issue.

> - 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 < 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. - - -``` - - - - - <& & - - - - Loggging examples > - - - > - -
-

-
- - - - - -
- -
-``` - -(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. - - -``` - - - - 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/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.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 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; - 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 -#include - -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 -#include - -// 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 -#include - -// 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 - #include - - // 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(&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 - #include - - // 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 - #include - - // 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 (`` and ``) 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 ( <<< >>> ) 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 >= 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(&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 <<< >>> 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<<>> (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 <<< >>> 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<<>> (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\_<type\_name>() . 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> - -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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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 - - __global__ void run_printf() { printf("Hello World\n"); } - - int main() { - run_printf<<>>(); - } -``` - -## 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<class T > - -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<class T > - -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<class T > - -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<typename T > hipError\_t hipGetSymbolAddress ( void **devPtr, const T &symbol ) Gets the address of a symbol. - -## Parameters - -- devPtr -[out] - Returns device pointer associated with symbol. -- symbol -[in] - Device symbol. - -## Returns - -hipSuccess, hipErrorInvalidValue template<typename T > hipError\_t hipGetSymbolSize ( size\_t *size, const T &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<typename T > - -hipError\_t hipMemcpyToSymbol ( const T &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<typename T > - -hipError\_t hipMemcpyToSymbolAsync ( const T &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<typename T > - -hipError\_t hipMemcpyFromSymbol ( void *dst, const T &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<typename T > - -hipError\_t hipMemcpyFromSymbolAsync ( void *dst, const T &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<class T > - -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<class T > - -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. - - -``` - - - - void 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 <=> ) 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: <<< >>> . 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 & 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 & 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<unsigned int size , class ParentCGTy > - -class thread\_block\_tile : public cooperative\_groups::impl::thread\_block\_tile\_internal< size , ParentCGTy > 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<class T > - -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<class T > - -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<class T > - -## 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<class T > - -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<typename T > - -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<typename T > unsigned long long match\_all ( T value, int &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<class T > - -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<<>>(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. - - -``` - | - <---------------------------------------------------------------------------------------------------------------------- ---------------------------------------------------------------------------------------------------------------------- | - | - - - - - - - " -``` -**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. - - -``` - | - - -- \ + <---------------------------------------------------------------------------------------------------------------------- } ` and `` 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 | - | | - | - | | - | - | - | - | - | -``` - -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. - - -``` - - - - & ) ] - - : ; . " -``` - -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. <major>.<minor> compute capability is passed to nvcc on the command-line as sm\_<major><minor> , 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 ()`, 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. <major>. <minor> compute capability is passed to nvcc on the command-line as sm\_<major><minor> , 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. - - -``` - - - - // -// + - * / */ - + - * - - - */ -``` - -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> - - - -``` - -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 < 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. - - -``` - - - - - - -``` - -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(warp_size, [&] - { - hipLaunchKernelGGL(kernel,...); - }); -``` -**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 - +template - __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, tmp::divide<2>>([&]() - +{ - + 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 - - ` 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 - __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< WarpCount, tmp::not\_equal<0>, tmp::select< tmp::not\_equal<1>, tmp::divide\_ceil<WarpSize>, tmp::constant<0>>>([&]< uint32\_t ActiveWarps>() { if (wid < ActiveWarps) { // Warp reduction tmp::static\_for<WarpSize / 2, tmp::not\_equal<0>, tmp::divide<2>>([&]< int Delta>() { 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 <size\_t I> auto get<I>(...) 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<> 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` <reading-items>`and processing ``ItemsPerThread` <processing-items>`. -**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 - { - return [&](std::integer_sequence) - { - if(i + ItemsPerThread < front_size) - return hip::static_array{ - front[i + I]... - }; - else - return hip::static_array{ - (i + I < front_size? front[i + I] : zero_elem)... - }; - }(std::make_integer_sequence()); - }; - - 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 > gid) , or the more portable [[assume]](gid + 4 > 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 ref_reduced(const unsigned int partition_size, - std::vector input) - { - const unsigned int input_size = input.size(); - const unsigned int result_size = input_size / partition_size; - std::vector 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 custom_partition - = tiled_partition(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, -``` - -## 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 @@ - - - - -hip_spec - - - - - - - \ 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 && 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 <ROCM\_PATH>/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 <ROCM\_PATH>/hip . This can be overridden by setting the HIP\_PATH environment variable. - -• - -HSA is in - -<ROCM\_PATH>/hsa - -. This can be overridden by setting the - -HSA\_PATH - -environment variable. - -- Clang is in <ROCM\_PATH>/llvm/bin . This can be overridden by setting the HIP\_CLANG\_PATH environment variable. -- The device library is in <ROCM\_PATH>/lib . This can be overridden by setting the DEVICE\_LIB\_PATH environment variable. -- Optionally, you can add <ROCM\_PATH>/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_> -``` - -``` - | - - -``` - -## 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 & 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 <<<...>>> 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. - -- > 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 <<< >>>, 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= [DEPRECATED] This option is being replaced by --offload-arch= . 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= Generate code to support up to the specified number of threads per block. | -| -O | Specify the optimization level. | -| | -offload-arch= 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: - -- > - -``` -|> 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 > 256 - -Kernel code should use \_\_attribute\_\_((amdgpu\_flat\_work\_group\_size(<min>,<max>))) . 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(&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 <<< >>> 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 <<<>>> syntax, hipLaunchKernelGGL. The latter one is macro which expand to CUDA <<<>>> 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 <<<>>> 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: - -``` - - - - - - - - - - - - - - - - - - > - - // - - } -``` - -The below sample shows how to use hipModuleGetFunction . - -``` -#include -#include -#include -#include -#include -``` - -``` -#include -#include -#include -#include -#include -``` - -``` -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;iargBuffer(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 tex; - - __global__ void tex2dKernel(hipLaunchParm lp, float* outputData, - // -``` - -``` - } - - // Host code: - - texture 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 <hip/hiprtc.h> - -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 kernel_binary(codeSize); - hiprtcGetCode(prog, kernel_binary.data()); -``` - -After loading the binary, hiprtcProgram can be destroyed. hiprtcDestroyProgram(&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 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 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"); -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: - -``` - - - - - > -``` - -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 - 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. - -``` - - - -

-

-

- -

-

- - - - - - - - - - - - - -``` - -## 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. - -``` - - - -

test, which caused a segmentation fault issue.

> - 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 < 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: - -``` - - - - - <& & - - - - Loggging examples > - - - > - -
-

-
- - - - - -
- -
-``` - -(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. - -``` - - - - 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/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.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 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; - 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 -#include - -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 -#include - -// 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 -#include - -// 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 - #include - - // 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(&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 - #include - - // 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 - #include - - // 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 ( <<< >>> ) 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 >= 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(&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 <<< >>> 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<<>> (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 <<< >>> 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<<>> (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\_<type\_name>() . 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> - -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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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 - - __global__ void run_printf() { printf("Hello World\n"); } - - int main() { - run_printf<<>>(); - } -``` - -## 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<class T > - -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<class T > - -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<class T > - -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<typename T > hipError\_t hipGetSymbolAddress ( void **devPtr, const T &symbol ) Gets the address of a symbol. - -## Parameters - -- devPtr -[out] - Returns device pointer associated with symbol. -- symbol -[in] - Device symbol. - -## Returns - -hipSuccess, hipErrorInvalidValue template<typename T > hipError\_t hipGetSymbolSize ( size\_t *size, const T &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<typename T > - -hipError\_t hipMemcpyToSymbol ( const T &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<typename T > - -hipError\_t hipMemcpyToSymbolAsync ( const T &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<typename T > - -hipError\_t hipMemcpyFromSymbol ( void *dst, const T &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<typename T > - -hipError\_t hipMemcpyFromSymbolAsync ( void *dst, const T &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<class T > - -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<class T > - -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: - -``` - - - - void 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 <=> ) 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: <<< >>> . 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 & 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 & 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<unsigned int size , class ParentCGTy > - -class thread\_block\_tile : public cooperative\_groups::impl::thread\_block\_tile\_internal< size , ParentCGTy > 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<class T > - -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<class T > - -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<class T > - -## 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<class T > - -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<typename T > - -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<typename T > unsigned long long match\_all ( T value, int &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<class T > - -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<<>>(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 - -``` - | - <---------------------------------------------------------------------------------------------------------------------- ---------------------------------------------------------------------------------------------------------------------- | - | - - - - - - - " -``` - -``` -<_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. - -``` - | - - -- \ + <---------------------------------------------------------------------------------------------------------------------- } -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - | 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: - -``` - - - - & ) ] - - : ; . " -``` - -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. <major>.<minor> compute capability is passed to nvcc on the command-line as sm\_<major><minor> , for eg. 8.6 is sm\_86 . - -Because it's not included as a binary, compile the matching example from ROCm. - -``` - | - <.02 .00 <.00 -``` - -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. <major>. <minor> compute capability is passed to nvcc on the command-line as sm\_<major><minor> , 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. - -``` - - - - // -// + - * / */ - + - * - - - */ -``` - -For threads that don't have unique inputs, feed zero\_elem instances to threads. The backing of double-buffering is allocated as such: - -``` - - - - - - - - - - - - " >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 < 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. - -``` - - - - - - -``` - -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(warp_size, [&] - { - hipLaunchKernelGGL(kernel,...); - }); -``` - -``` - -t WarpSize>() -``` - -``` - - HIP Documentation, Release 6.1.40092 - - - - -template - +template - __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, tmp::divide<2>>([&]() - +{ - + 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 - - - __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< WarpCount, tmp::not\_equal<0>, tmp::select< tmp::not\_equal<1>, tmp::divide\_ceil<WarpSize>, tmp::constant<0>>>([&]< uint32\_t ActiveWarps>() { if (wid < ActiveWarps) { // Warp reduction tmp::static\_for<WarpSize / 2, tmp::not\_equal<0>, tmp::divide<2>>([&]< int Delta>() { 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 <size\_t I> auto get<I>(...) 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<> 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` <reading-items>`and processing ``ItemsPerThread` <processing-items>`. - -``` -<_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 - { - return [&](std::integer_sequence) - { - if(i + ItemsPerThread < front_size) - return hip::static_array{ - front[i + I]... - }; - else - return hip::static_array{ - (i + I < front_size? front[i + I] : zero_elem)... - }; - }(std::make_integer_sequence()); - }; - - 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 > gid) , or the more portable [[assume]](gid + 4 > 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 ref_reduced(const unsigned int partition_size, - std::vector input) - { - const unsigned int input_size = input.size(); - const unsigned int result_size = input_size / partition_size; - std::vector 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 custom_partition - = tiled_partition(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, -``` - -## 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 f8ff16e8b8770c409209ff8e9c44bcf6544d2d1c..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 271478 zcmZTvcRbX8{6G6by0drgj3{JpGEO0saUnA^a>CiE$T}-2;W$L*DMEHa_D*)^>^&!C~`5Go@0c?U`fzBgaP zltCyU5Pg)Ec@Sai>}XG-$NwUf|CJSb;>p?3sbS#Ta~ELL_w=CqzO1_XRkGjoGG3D> zv(91K2cOD5a8y*#e*5|kAz9R&RmVp(R>uQEkED3^!4pbzyZT zETliIsA?US&{69{M8&VdzusaOoRBO`4(#Lc-o?k?xHqM8kvXtO*;FJ z%<_llsgi6A3?fjllyqSK+J#H|K1pG9`urQ7p%b^9sH=k~*ZoQ-j6%;=H*bE_=!&r$ zR(CsFCFi{_pK-c&O=a$e>bnao6-- zzB*vOV*hxO3*iXOo!#Zo4ae;rhbm+qZ}F3-ydwWjctIX|MdgGN9-=opn>9RxA{!b8 zlOA_F(fzrb)l6DJjr~-5XY$4R*Pn@poGgGsrkg3x%Yet*Anq`5n5KMVg)_U zNF@2B{J}RxLiekoHH1fSR@0-G^1*Er>Z9}3sSAzE&u*w*n-5ZPTJ-PSJK3)GYiFrB z_*;H0K{2#L$2s=GU3k*Y@3&Q9ip;3l*PXjdjItJJ7gr3aVQh(yAH7q)*Dzs)pYU)! zG`n_ShA7y-(){ZR@>ldV2Ukc?RyG=aKBnzBR3m4|zI2GEES{7>Z16h$EWC~2S;%d^ zgO=w`L@jM>cszcN`Y72r>#djNW%-}495!rQX)@|ZS+?2v0!VqzkZSXNeMYQV$8 zgYpXw=F*;=p6*w+x3lZyyzzF}PX&|VD#tBd6*xm8VfQ~0i9dsECJsCmNZ-H5NoQwe z;im=%nUL8zIgRgwA3s*lGFDVj2x*#GUUnG_mgDZ=yecV48`0_@Whu@+vhF9v$rz)v zE5)BQu(h#qxwEdK!ervWPer27SBY1_NEUC{x#(k+s*%0Dy-nB~8$(;Az8x-h&)D4D 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

$DQ+}KgZ5O4qHvDMkpLrdqNGXAkr1P? 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 M07*qoM6N<$f@Ra~Y5)KL 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 48edb1d34f300f5ff6badda40f5aa58f42f54599..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 190318 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 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 && 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 <ROCM\_PATH>/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 <ROCM\_PATH>/hip . This can be overridden by setting the HIP\_PATH environment variable. - -• - -HSA is in - -<ROCM\_PATH>/hsa - -. This can be overridden by setting the - -HSA\_PATH - -environment variable. - -- Clang is in <ROCM\_PATH>/llvm/bin . This can be overridden by setting the HIP\_CLANG\_PATH environment variable. -- The device library is in <ROCM\_PATH>/lib . This can be overridden by setting the DEVICE\_LIB\_PATH environment variable. -- Optionally, you can add <ROCM\_PATH>/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. - - -``` - | - - -``` - -## 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 & 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 <<<...>>> 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,iVBORw0KGgoAAAANSUhEUgAAA6kAAATICAIAAABxshSVAAEAAElEQVR4nOz9d5QdR3ogesYX6a/3t255b+C9IUAQ9J5sq7bqlhnZ0ezTm7ezM2fnnXlv3nmrs2P2nZ0daWak0UitVrfUUjuaJrvpCRAgQHiPqgLKe3O9TRexf9wqoADCkexG3Vv1/U43D+q6jMyIjPwyMgxwzglCCCGEEEKrgEgIIYwtdzIQQgghhBD61WKcizZjB/uGLY7hL0IIIYQQWrk4cUiCaNjsf33no7xhUoDlThFCCCGEEEK/Eozz7pBPZJxPZgtZXcfYFyGEEEIIrVSM84CmiOV/2ZzgkDeEEEIIIbRSMU44L491IwQIwVZfhBBCCCG0UpVjXbrMqUAIIYQQQuh+EW/3BueEYD8IhBBCCCFUjeDWQ9luHftKlAYciiwIv9IkIYQQQggh9EsHhOQNM1HUP96Oe4vYl3Hu1+Qn2htq3U6c/AEhhBBCCFUXAHJhOvHm1bGiZd8UzN4u9lWf7WzaVBMSKcV+DwghhBBCqIoIFF7tHTo8OlWwLLhxQodb93kAAAGoSEGkgLEvQgghhBCqIgIFAeCWPX5vP9Ztyf8QQgghhBCqFneIYHGOM4QQQgghtFpg7IsQQgghhFYLjH0RQgghhNBqgbEvQgghhBBaLTD2RQghhBBCqwXGvgghhBBCaLXA2BchhBBCCK0WGPsihBBCCKHVAmNfhBBCCCG0WmDsixBCCCGEVguMfRFCCCGE0GqBsS9CCCGEEFotMPZFCCGEEEKrBca+CCGEEEJotcDYFyGEEEIIrRYY+yKEEEIIodUCY1+EEEIIIbRaYOyLEEIIIYRWC4x9EUIIIYTQaoGxL0IIIYQQWi0w9kUIIYQQQqsFxr4IIYQQQmi1wNgXIYQQQgitFhj7IoQQQgih1QJjX4QQQgghtFpg7IsQQgghhFYLjH0RQgghhNBqgbEvQgghhBBaLTD2RQghhBBCqwXGvgghhBBCaLXA2BchhBBCCK0WGPsihBBCCKHVAmNfhBBCCCG0WmDsixBCCCGEVgtxuRNwa5xzzvlyp+KzAgAAuPNnVsaeoju4l2KA0FKMseVOAvpVKdcG91InYDFY2Si9e+NjtUcIFXv5q9DYlxBimEYulzMMg5BKPHB3wwUqBIJBSbzTEQaAQqGQSqfvW7LQ/ed0Oh2aJknSnT9m23Y+nzdN8/6kCi0LWZFdTtddLwamaeYL+VJJvz+pQvcTACiK7PV4BUG48ydLeimbzdo2RsArDnAK1OV0aZp252LAOCvkC7lCnrOqjIAppW6Xy+l0LndCblapsS8Qy7JS6XQul6vMm4Y745zLsuz1emVJuvNNW7FUmpufu28JQ/cfY0yR5TvHvgBg23Y6nc7lc1V9l4/uzOPxuJyuu37Mtu10JpPJZO5DktB9BgBul8vtcouieOeTXdf1ZDKpG8Z9Sxu6PzjnoihSEBRVvfMNEOe8UCzOz89X6UMASqkgCBj7optVX1yPfjU44TazLctiGPuuXJZtL3cSEEJVBaOEXwEc64YQQgghhFYLjH0RQgghhNBqgbEvQgghhBBaLTD2RQghhBBCqwXGvgghhBBCaLXA2BchhBBCCK0WGPsihBBCCKHVAmNfhBBCCCG0WqzAtS0AKFAKhHNmL64CCFSgAIQwxjghQOn1JaY5Z5xxXv4I4Zxzxhgvf4oCJYQt/F25ACgAKe/KHRN6fWltzvnCivJ3/NLCL3+aJcVvtYz3bX8HAAgA3G0795qcxW3fsG/XX7zTtxc+dddDWbkWj/pdc+xWCybe+cjc9TO/nG0tLaN3/8W7Jec2x+NeNnLPh7IS3fu5u1h/EMI5h4Wq5PbfuuXZdc+J+nitcPsfKn/6Lntw7Sfvlp5bH5DrlecdtlL1tcK959knvUZ8hkvEba4RdywMd9uDz3SJuLeydC0hn2KP769yTEMIvxbCAABQAQgv7yAAvZ4FnJdfXQiPOGd8IV4CSikQwhmr+F3+BFZe7MuMQjafy5tUdbh9mkQocML0bCpXKHHR6XRoAi/m8kXDtMuFQZAdLpcqMD2fzhuECrLT69Zkkdp6Lp3PlmzJ4fS4VbFil1bhhJmlgm7YRJAURZGE2yaUc9Mo6rplcyIqIuXE1i0iSbKmiLdcN5pzZpRyhslA0lRZEuhiRXgvpZ+ZJUM3DHvpZ6mkqrIkfjyFzDIswzC5IEiyKt3mWQRntqnnSxYDSdFkqXxW3wrYhm7oJQsEWXHI4uKumUZR1w0OkqyoknirHSacMcvUddMGSVXkWyS04nFuW6ZlM6CiJFC47TEihDDLsi2LlW8VCbMYByqK4u2OK7MM27Y5EaggiXdehfNjaeLMNKwbV6MHKgjirY4w58y2GbM5CKJAb7ugObdMw7Y5EURBEO5U5pllmjYjIEiiQOliLc+YaS3uMaW33gjnlmXajFNBFIVqe0DGuannSoZNREmR71wrMEsvlgyLESLKMrVt27aJJMuycuszkVmGoZdMGyTFoUiUAhC4x0qBc8solgzLXlIWgIqyqsnCLYIg29RN07SprMiSeLuizEzD0HWTE0FWNenjP3Pt14hVyummyUVVUa7tGuemkSsZNqF3qDyZbVqGbjIiKpos3Ka0VDRm6oaum1wQZVWV71ArcF4uDDYHURIEIKZhE1FSVfmWGcA5N0s5wzSJqCqKItJysHyPpcE2dKOkm0s/C6KiKvIt8oHbpmEaJiOidMv3Fz7FTD1fMhkRFFW5fZlZOCAlkwuSosniYr2wpCxpmkzhFhd9zpll6IZuEUmTZVGs2HoBOLeMbDJVNEFweF0ORaKccNMoFrLpki2qTo9DJnoxXyzqFuOcE0JFWXO6NShl8yXDZILqdLpcDokws5TLZIqWILs9TlUWYYVEvyst9gVamj772qv/8OoV9/YHv/ZPn2xX3KLOMhfe/uufvnXCbnv2mUd3aYkDP3vz+NhUzuSEUNnfte/FF3ZGsmde+bNXLhJXqPPJ3/r1R9c2e9NDH/z4pR8fS7Xuf+Y3vrEjQlWhAm95gHCb5McuHjl1fgwi67bs2NoUXKwY+LWlEDnnAMQqZscuHT99aTRelBq2NnsNNnlmjDS1bn1yS72oyeTmvQOjmL56+s2zV+Lu9se2r+us8Vq2xQmU7wJvbnS7oa2Ac7s43Xv6zNnLk6XyC4RQQtwdu/et76wPq9e3xDknnBdnh/p7zw+ZkYauzTua3dd/+HrjHgErGx8+f+jIcEJr3blvfVvMozBy/TK0JHNoaujq+XMHx8S67i2Pb6rXZIFzm5D5wWPHz53PyD2btjzYXa+IlN94lAgBs5gb7z16rn/O2bNnU1dzxLHwoxWY87cEYGRTMyP90wXRVbuuKeJ0KUtu1MtNaOV/c7MYn5icmpnKgtPjj4RIfCxRpP66tvqagFO6IVsX/p2bGZ6YmsxJsUh9W4NfoORaBl1rKbwhJYvfA2DFQmL86tB8TrcWF6Tn1BmJ1jW2RR03NcACM/X0/NR0PEV8Da01flWmS34YoLxVTkhhbnhgajZPw0219bVhbXGjNyYEwCjlZkZ6p1OmM7qmqSboVhknAKyQiY8PDCdtMdTaXuf3auLNRwk4t0qFmcmhiTzzh5vaY25ChHu+qi83oKyYn7l86IMLk6yuZ+fGDe1hR/kdzsnSUxcAjGxi6OKpsxfHc5IcW7/WNzs9OTkjd63fsHFrk2vhgF7/DiE0Hx89f/L9wbjWtOXZba1+TbFsmwNQuuSuafEwLW04B2BmMXHlwyPnR6bSJgXghHMmat66dQ/u64m5HOKSaoEQZpZSw+cv9g/OezZsW9feElIY4zdWC5wQQkqzw2dOHestSI3r9u7tiDpkgS8JWa593tbZ5NlDJ64MsNrtmzdtbQ1QAEJtMz9z5YODFye4a+3OzRs6ah3840eJFhMzV84fHUiK9Vse3dToViVCeBVVCoSz0mzf2VOneovBxnV79rT7HDK9aT8X6m2rlBk/e+pk//Cc7mrvrvFI9tULU2J9++696+vcDrFcWy+pda2SPXHqwMnBYd7wwPaNm5t9NrNsG4AuuUTc+hpBKC3FR8+fOXpmOE9sQgjhhAjE0bzpgU3rOyKOJXdHnDNCSqnJ3v5zIymxrm3nlg6/RIHffI0AsIvZ6fPvHrmSMqLb9m7qaAkp7OOFgRACkJvqvXj6SH8u1Lr9qc1NbrfCOOdQmh06ffJ4X1FqXP/g3vaoQ6Gckxv32NbzM1ePnTkzSlv3r1vb3uhlN/12ZQBK7Xx64Mjf/JdfXGHRx3/vC49s7vQzrs+OHn/zu3/5YTL24Iu/ua9ZP334tYPH+uM5TjgnWk3b7qe+tE86+fevHr40kfWvf+LZz33xiR45P3v2rb/47qG54Pqv/fbT21trVZtV1L5+Wist9uVccTkUypOX+q4ovRMPNTW6qVkcu3yx7/y5TEtdfnb2+OW/f+3kPGlYv21drU+zsqWAX1N4YTo+OTQyQshshh7ZvKY24GGl9Ozk0OC8ui5jfiwurCCc6LNXTx566xTtkhvWbKz3U8IZJ3Tx8VD5qkSL2dmLH/zgb18/N5UU1ciOCPMlc6dfO0N3mi2Pr4sx2bRtcu3BBgEQBMk2ilN9hz84MBSyetqa64XEpfOXpgwhtmZPd8ShCIv9QigFzpltlXuTCAKlhHBuJocuH3vr5xdKitPjUSmAQCCitG1qa+W2ZS6cPEAFKgBh2aEjB994+7S85zFf1+Y6FQgQgVIAYlsW4+WWSWoVslO9H713ZNRr12/oaKn1cGbbnHFO+GI6oPyj+fHR8wdfP6VuEBof3lBHSDn4Tk9eOP7hz6adZrB5d0dMBGbfeJQEUdaT6SsHXn79YrLF0dne0hxSLMvmhFLhdk2DlQWA6onRi299580RZ/vz/+LzXqdLshkBKAeNjDEClFJi6+b0yTde/sXbJ0byPNjY0b3rAcfpV0/OaJuf+bonENAEm/PykzDGGCEAAgBPXfnggzffueJ55KEXGmOOUn52bCrFpEhdLOhxCosXoWuPEdliWEyBsmxm5KPX/vbQQNoARRQoEM7Utt0PPBZsiTgosW22kHgAoPrU0Mm3vv/jy2bnY1/7ps+tiMCvtSVxxsobsTnLjHz08zcPjcu7v/Dkc7Vhrdy6zBZ+aeExHgDVs/MXP/j+G2dyLY/+8RcfCnk0wgkBOzc9eOyn/3Cy6N3969/yenwqtTlZepQEgZvm0MmfvfzaoULw0Se/1B5zlftC3fqhfYUBQpippwZPvff2ObZZaGjtaQ/als34Ql8wzstnDACY8wPH3//R3/3iUjrvrPGtCfhCFy6cOXfJTbS6ni0Nls0JAQrEXugWRkVBKGWm+06/eXjYtz26rytqT/efu9xf8jW2d25p9pHyzSRQoZzNts1tTihdeGjKzOzY6aMHjl2aEz0up0MmzFa8UT20eVebzRRiXa8WRInrmekLv/jZ24PZbl9DQ0Ojl1qcUEopIYzZjHGgAnAORmK878SBtxPq1sCGHS1Rh8Rt+/oP0fKGgTCTJPtOHXn/sL7RW9u5tS1ACCGE2Xpq4vTBQ+dYRG5s7W6LytbSo8SBCpTSzNDVk2/944fFpocaHlxbRyRilZ8MU3qn5yqVxEyOXD72xlvJ9m2BLdub3arArHLlt1DdU0qpQPLZ2bNv/u0/vHthMi0oLUzuCEi599+8pGwWurZ1RR0Kt9n1GpOAIAnMZPG+E0cOH+dba5o6ur3ZoctnBpNqoGvX2lqnU17sYbj0GlHuSghAqJmdvnL23deOZVTR7XGKACARP4n2dHVzZlkWv56HhEJ+8tT77718KtH6hNK9ttFNREKoQCkQZtvlaoEKglXKJQePfXhwvNBT09XR2hbitm3bi4/7yyUegACB0vzwlSOvvTnf8mDD/jUNHk/5RspMTvSdOPB2UtsWXL+9KaQIjPElRwkEQbIKqdGPXnn93ZHA4921re0Nbsu2ypeP2z+IXAacc1ESNJ/bnpkaHjx/ddem9q6Ay0rNTPaf+mh80hUTxPmzH7z35huHp8WmzjUbWrxWlosOn6bwTHJidGh0PD+WPFbTsHZN+xqPmU+MD49MFmqyhsEraCc/o5UW+xIieWsamlqbtYH8ZN9g/JFaj2TODg3E02lHU33UL2UHegcztGX/E8++uKU1pNn5Ajg8Af3KuCBQIIyXsqPHP7q0s7MmKgqiIIpiZZXpmwHhhJnFbCo+TzMFyyym50au9k0Tb33Ey/JzEzNZKVjf3hgWJi++/96Bo5euJiRvR1AqTs2XklnDpfo0hRp6fGR4eCKj1Ue9nKWnJ5NcjbT09IQ4iLLD4XCqcn5y6OSFU28cODnBnc1jpfHaoF8plSytpqetqb7OlZsfH+69NG/66js2NEddqkAIt4q51GyK16zZ+NRTa70OWeDEEetwCZmBS+fH55L5EpUdgbr29pYaj2gV5uZmp8bJyJXzJw7FqaV5w61d7TXu4ti5gdGcGKn1eDQhFy8RUXE4HQ5ZEICwQmZiaHhkajJripov2NzZU+dzyALnBJhezKVScS1dtDgnUK7XuCgoiuZyqIpMSum50YGr08RTF/HyhaNU297dpehmbm58ej4fKJq2nhwZujI4kdUa6ls728JqJReDRcCMXGrqyuCQx5XRS8X0fHouzVxur9NhpxOpkqn4asIeyEyOnTt69OjRc9Ou5p61Ub+kJ9MF3bAUzoiZjU/Gkwa4/T4nLyaTGV10R2r8LoVwxmyLMcssJcb7+k6/886ZaTGy46GtPXUhkXMiqx5fuMavcrOYmJpLFWw1HAz4fE4K3DJz82NDY2Ni575ntnbHPBJjUqCxPiqb+WQ2nUzlTZsJDn844Pf4WCEzO9p38QoX10yODihpTVQCwYDPp5q5ZHwuZUluf0AtFblRMmzGbJsRToAz0yikE3OJnG5zxeMPBvwuVaSEALeK6dmBwasZdUveYOVmzHKzIuc2sxnnzEjNT+RS9g1HqTbmJiw3Nzp4ZbCkr88ZZiGXnJ9N6UTxRaI+tybTCr4bJoQAcG4Vs8l43MoXdFtPjs0Ojk4UHTUNATE1OzmTIqG21taQlhk4fej9g8d7R4o+v1fRSuOj05mMKTk1ReG5xMjIlbEChBtiSiY5PTtvuGLtHa0NlIqy4nI4FMJn+k6OnD38/ul+I9q5dl1hQ62iiJmcpcY6N7WGfY7iTF/f8HCGRFtaepqjDpFwbpcy6cRc3v3Atr07dzc5OBdkR6A+yAvT/SPj43PZkkFUb01TS1tryDZKqamJqamM88r5YyzfK5BAbUNra6OHJYcvXJnWtboWT9FWhFRJUh0OTVEkSritJ+cHBq5OJtI6VwN1Dc3NHVEXIYRwzq1CJpVM69mCWb5FKh8pKioOzck0SWTpscGBkYmis6bBL6ZmJ2dTJNje2lrfZOVyqZmpGeYtGIaemRy6NDBbIuHOjpaGGo9Q2QVhAbeK+Uw8ngrndFMvzg33Dgzl3bEaj2IlJifTtivW3NHoL105c/D9g8cv9aelQJMfCvF4ycpwp6ypIjfz42f7J/PMFw67eH56erYo+pp6umtESZBVzeHkihEfvDhz7u33P7yS9dasz0+11Nb5ciXdlMI9TS3NdUo6PTFwZiBpuBvXd9dHvKoA3NYLmfmkLq9b+9CzW2KqKgBRIi0x2ZweuDw4MZPKmyBr/qa2rrqoxy4mZuYmR6flq72nD5V6QdZCzd1t9UExM3R5aKwoBEL+sCMTzwIomsNBFFGkwErZubGBofHpRAEkV6ipo7sh7NJEToBwq5hPJ+Jxf15fmoGCKKkOh0NVKSvNjwyOjufdsRqPbCYmp9K2s6Z5TU/AMIqJyenZeVowLDM91Xf56mCWB+ra1rXWuGSBVEpp4BwkzVvf3VNzYObM0Nh0IlWg7tL83OTwiOlyNnY1+YsX3hwYn3D2PP3Q8197pFNlJduyJdXJL1FBFAkhPDPYf/ns+dGmPQIVJLHcHa4KroH3bMXFvpyL/ki0rrHBOjY50DuW2RoR4kNXppJzrqb1jQ21WuqyLqiqr6m1oa6uzifZnBMAcfIKIZzLsuD1+vMzlw+e7e/YHr5jb8mKAgCUAlDKC/Gpcz9/6f152+lygJGNJ0sQ6npo77YueeLywHTOtgWP0+t38FRmfno6aXCHxWyjOHvpg1ffuZRTHQ4CxWQiz7Sm7Xs/99yDfouZpqFbdmZmKnH13KX+objg1NWLQqal1j5zeiBXn//8s776usmRk2/+3c8nPds/X9/VSF2LiSIgeyL1m/c/+nDMrwmMMKs02fvOm2//4qPepGkRQhwNHVue+PznNsmCIFBqjV++8N7cjGIb3BXtevCZLz+iXTjw3vsXJklQ1SI1NXVru0qGaRimbZuF2XNHj7753pG+VNrkaqipbX+gKexxKYK92AJJbuorCozZlmHqks3twnz5KFkLRylVgmDnvude2FOrECoIAiU2SV89fvrt148k/Dufea61s3pOegAqCIJAgdvpq6cOv/fRQB4cimhlMllTCNSv2ffMWuvkiaNn+mcKILi5lZydTE0OJCZTReK0Gc9NnTl56sNLo9zjksx8JlsgruCah596dLOL2LZpmnYpMzNw7vxLbxw8O5CRfPHE8NS2DilPJuf1pp2Pfu2xFjZ/9eBP3z6T9u56cf+egH8xUSCoarhn+2PPPrqmRrMZI4SkR0dOvf33716cSpQ4lZy+2u5dD+9fpwIVRVJIjh762d+eUwVRcgbbdjz2yOaw1X/o5bf6Cg5XQKOODXvdadM2DLAYWJn41bMH3zp8cXQmpXPQOnY8/fjDezrDNx2PxRxcGPxhmYZpmpZlJAdOHj/y0UCeOBRp8Site+yFPc1cFASBCFS0c1OXjr/x+uFJpX7vF54M+D3aMuTrJ7fYO4mCOX/l0uHXX71g+EIuKGQzySz4e3Y993C3Mjk2PDqdo1RVPW63j8VnpuOzyQKvYcxIzfYf+cUrF+YUn08sFbKpjKnW7Hzh6Sd7Ysy2DNMQSmZydLj34oUrg3MsC4TWagW3Vjz3wUCp/UnP13ZtJJPnD7z+8xNG7SMvxroarycKqKO2a83ux5/Z7OWcEMJKqekLh1969YOrIynL5iC52jY8+MQTD9XYIFBm5ns/fH/uzEfEtpW6NXueevrx1uL5t189MFrQwprubN8YpaalG6ZgMyM/f/X4z99+79ylqZLBibNjz97Hwgux7+K2bxp1yTljpmHqzLRZaa7/6oev/eyC5Q05oZDJpHLg69n13IvPNlIASiihdjE/fuLAT14/OR/e8FysuR0qJtS5q/IlggLlZm6y7/2Xfn7FkFyaxAuJeN52dazfu/+RjvmBK6OzJZNJXqfbp9jZ9NzcdFanTtsyipmBD9556/Kw4fA5QE8mM7ocXrPvmRf2b7KYZRgGt/PxsbHpsxcvD4+b7qx4QdQZCfVf6huajzz11HM1NYHpwRM/++nBOef2bzS21Ncs3HgQApLTV79mzxOPd7k8ImeMcXv0wjuH3/jR4au6adqcuxo69jz14sMxQgVBsBNjFw6/NnmKW0wMN+18+gtPt1gXDr7/9sVx0asFayRX615/XjdNw2bMnBk8fvIXPztwcT6dY4rb37r3K7WBgNshXhv1RejN4wkYsy3DMETL0rOTw++//NYVQ3KpEiskEnnb2bb+EfLMVoFRKggEiJ0bO3X46I/fGfA07fti05rKGxEkKc769mbXkd6Bq+OT8TkzYMxNjl4pOeSOdZ1hl8GKnJFgbaS+ua02uvCUoxSfK9/W+wNeZuX7Lp0+sb57O7Grppx/Aisu9iWcK6FgTV1zqDCc6L86muiwhgfHs3Fo2Vzf1BjMZygQvvBE64aRmpxx2els3rAh03tm+NjZ/pru3NK+oFUACBBbLybGhgaH01pLT3eLT51J9H90+lSwpuXR+q7G4ImReMkbbeta1xmzLn8Qv3JqPJ7IlpgtpGdGhi+PsZqeno6QW56/cPasyNq3bdmWy83NzsyQLN3WWl/XEHL052VHrHP9xtY69/iFdz4cmO0d2LQpoU6M9J7snRE3O30OURQIX+gDBWAXM/HBC+d8ky5F4sQZqJfBFa5r6wRGSjNXzx89cTjh7nmgo4NTIARkT6CuvdWdGT790YUPrejW7Z2z0zOj/WfmPf56rbHNQY2J+MzMjJHJF2cGzxx+741zk8HuTdvbI75QTcgpCXDHNhirkIzPzc+WkgXDKtnJsaHB4ZTWuqa72avOJPo/OnO6obsjupYAAeB2cf7Sh+ePnuxNdT0eaYh55WoqB4SQci+/4vzopTOHPhyj0abWeg8kBy9d6BtS19ZuUD1elyJRCrLm8QeDTJ+fuTw7lReS+VIxPd57+cjBE3a4tqk+5iqMnjl7fkhr7G7uLiRTM7NTVrrIlTqf16VIkiA7PIFgJObNnr3Sd/DyrBTb90BYG7l85Njh0/L2jTZoEiGLZYEzpmdSM1OTHku1GSguF2MEgCgej1e25nvPf3jmiu6JhLd4F3r0gqg4vfro2ZPnLuX9seCm0OTVUwffn6Kyt2ntA21FITU3NzEppQuFzOzomTd/9sbJGVfL+raIT9OUOw/HAOC2XkxPT07mjGyxlE8tHqXm1no3JAcvne8bca/vCJTHTVEoxSd6hw6/e6xP2tz0lFNTRFrJfaBuUi64RiY9c7Wvr+grru1uCnkSV/ouzp5s6arf21DXWBs6OVRS/bGO9etjcuHS1NjQ7Ewimy0ZpezcaP+VERrqXNdR60pP918+dLK9rjsatrKJyZkZT6Phrm1piAbdg3NmKNyybsPGBpbsvTQ9MJy9NPhIT6M+3N9/8WKiLqx5PTJQKHfrJASIkZwc6z13ijkYE2XNH4zKWqCmvkNyGTw3euHcmQNHqLdh3fMBRgCo6AjWtja7830XT314Qgw2rmsIJ6ZGBvsmUhP1PTs6NMmeT8xMzblSmVx6aPjt9987kvVs2trdFvRH66Nu5U7HBghnViExMzfNxaxulDLpmYHevpKvuKa7KexJXO27OHeyZfOWgAqEECBmbn705JkPT19JN62LRMMBh8CrJ/gtAyDMKmWmhkcuzloNazvb/a7UTN+p0yWhftP6tvq2Ov+xgbgdiDR3r9vsz18+ET97YVpsyemmmZ2eHOu9mAy3remp8+jZy6cunZQaNm/rFLOp+Zk5nrKcnbGG5pj74nzJFW5dt2FTeyeZuXRs9tLMldaNs9vp9NCFM8Nj6oaHvYqi0Os9b5leiI/1njmb1xwicDVQXwuaJ1rb0qUqdmFu4MSRY4cKoe7ufUEKwKng8EeaWmph8uzBC8dykbWbPf7U7Oxg79mSx9/m27VDsYqJ2dnpUk1RTwz0nTzw84+G5fa1uzfWuRzhGq8i3fESAdwsZuIzU3FXqmCYYnpqeOTijNWwtqt8lE6f0dXuzes6baBACDfnh89OXPiwfyq4d3trXUATBaikTr+cEUGV/C2t9ZrnytDo+MzUpIdPjw+kPErrms46p3MSFnqtX4+ErneIJuHOVo9OR8eHLpw629hm2rx6Wn/u1cqLfQnhrlC0obXL/eZHk5cujGxOXx5IZfMNm2MNtWHxyo2jm5Z+ixOiOX0929dZ82+cPn/svKWkjHIH0vuc/s8EAAiVtOim577yjcdqLv+XH6ZHz5hEdDeveWDtiR+fGLNq2rfufXhft+manTj73tS1xjBBpp72B7/wrS91xT/4h/j5YyyXLXBW7uUPxN/U2eWZqT/4zqzqbd++d3+XS780UPP20NnBqcmR89Lk6FDC6Vzf1R7TFOna5QAArOTEwKGf/mOfLFGFQNtDv/7kzr2f/+oeQsXsxJk3/2HgfxzITc4kjTqDEMK1li27vvgbXwr1vVU8+feXZ2aTZqNBKSVq0/YHXvzKl/e5smdGBE6AEs7i83P5ZCHa8vATX/mfnu8WiLj4IPsO2bWk2QeAEJAc0U3PfuUbj0XLR8kuFXROCAFuGvMDHx0eGp2XmnZt372jPSzThY4TVQaAUibWtm57/jdfaDRO/OD//PHQfKrgbNq9Tps8e6F3nrRtee43f3szS51/aeryfF/56AEAA3/j5oe/+cKDoYGf/Ovvn4gnMnqpVG4jYbKnrmfLBnvm/PnJkrfnoS99/clNkVHzHwYOHh+funx5fEu07+qsnQ90N9WFok7OrYWUEG6a85eOv8WmTzkEm3mat6zbvHP99i/94XZZ5YXcib/8k//x1tHZ+Zm5pIczLrp9HY99+Xcf2px89U/+4o0P4slEMhMiACA7o+u2P/35Z7fFJq4CIwCUGtlEZmxgVvbVPvT13/+1bc0uYgClAi93CLr9oVno+weElI9S2/bnf/P5Bv3ED/5fPx6am08ZugeAADGz45fOmdOXjdqWfU/v6Q76NeDV1gzCCQAQ0Vfb+ci3/skjkdSrV//yndFCibrreqLFzvo3Pkq6Y927Hnm0y5VWLl3s7ZvmpNwtkghud+O+z/+TF7fk3vxv30lMZEulYolI5QY7Ranp2iqNHDt8prfY2LRx997dtfO9+nATuTzUPzg23zh9dTqeVmJbm5tjrus9YwEIKY6cPfGL2amjArNdvtiWJ377kfWP/Fb3wxzAHH73O38781enS7NTs8RjcZBV3+anPvfVR5rGfvA3U5dOWvHZBA8yIoiq0vLAE1/94jNriyd/dJoCBTANY3ZqkptW247nvvr5J9fV2feUT9fKQbkrqOir7Xz0W//kkUjylSt/+fZYUTcMQwUAYuWSI+cP9V2YExt2PbJjU3vUBbxKB/0AEUDwdz/8pa9/rqn4+ve+f/lcqmjTUMv6je0fvHps2Kxv2bT3sWdqk67c5MEP44unEQii1rrrya9/e4907K3/cer1RCFX4MxdrlLBU7umXcu3B1+7kvY1bXpw/56gJx1vPXjqo+OT00O9A875gUFTVHu6WgMep0Cu3QeBlUsMHHvt78dcoiRKvGHn55948MGdzzTveFaE1EzfG9bF7x2fmonnCyohnCvR9t3P/tYLG63D3zn13Y/m5lPFkgoUANwNm/d97stf3eaYeeMXQnmevvhcIhVP+lt37/vyH31js0wXur7dMHLtFodmsWIghAAFwd/z8Je+/rmm/Gt/+/3e89l8vrgYH2ZGT51Iz0+XWtZufvDhdWGHWHlXCC7Kck1rd8x/dmhweOzqWe4YH5lQ3aGurnqXrNy525ZU37bO6XG89drQ2YNHpLBRbVXePViBsS/n3BOONrR2uj+4MHbx4rnMxelcMbC2tjYWUng59r3e730hFFr8pqi5Y2t2bbw49Hr/2UuKblugVVfoSwghBASquF1uVV4YzntP3wGiup1uh6Yl7zYBJCEgi2ptW6fPe3Voauzs2VR+eNLpaO3uqFVVGa61hZRH8wqSrMiKJMgEZIlyuxCfmUtmCpnp4dkUsxgxDHNhjNJCOm4YS8Q5IZGW9u61a2vcE/mlrzNCCAUqULEcnn/ie24qUMXjct18lABs3Z69eEHPF5w79jd3ttXI9M4NypWMc6JGfDUNDTXuSVG8VQR/y7FbstsTrW+s9ZFR6VYT/dzwfUI8oZra2kbxcmH47KWx5stjtql1tdWF/F7G7MVvA2G2kZoeGzYSMuUspDY2WkAp4dnEfDZl5JnNBabrum4SQhbKjUwlQViY05NxQhiXfL7mXY/s29BRW5gTSfk+1rYty9Qp1RRFkQUqKiJht0/urY8S4WrEF21orHGPi8LSo0RJZnIkn5zMKP49W3f1RB2KyPgn/fmKwAmVZM3rcsk0c69Xac6pKGgej0eW9LtVg0AI11yeSEtXUByb7h+8EigMxRNKrK2xpd5Nl5xCnBAQyrWCwGxFlmWJcCM7l5pPZovm5GQiYxKbmYa5pJXixlqBc05l2bdmQ2dbQ61j4PTSBDNCiAACgADAPlmtUA6NqCw5vC6XRNM37V4xkR67cLrIS/Ub17TWRLxClRYEQgghQIjicrodmqrfc8wGALLT4XJpDuvuv04opd6Gxpg/Yg7Gr54+p7ArSYfU0dMWUV0y5/b1WoUClWVFkUVRlIgsi5Qb+UR8LpHVk3OjsznT5pZlMWbfpjAQwjlXIrUta9e1BbW5uYUu/QTKz3QpAUpFgIXhi5/kGBFCrx2l4k27x8l876U5U6ftj9b3dDaqRKjA0JdzUZJr2rtjvsuXR0Yunp7zzU0Sd1tTR7NPFgW22PUDKAVgBMj1ab4JIdTT0NOjTZ3sP91/5GjGLOmkarqA3qMVGPsSQognFGhs7RaOn+4/cTgxPZt1rGuoq6/x0DgIVOTMNnLZXKFQUGRm20SUrl0suaA6atr37D5ydvzYmXGDEEcTqbKG3zK4/cyot//OPXyFc27blk2o6mnu7ggeGbnQe/qkyDJCINS1ttkrq0ufNjMmh5rXPPPbv/1AxKsKnIiynJ8+9+67P//w4mReZ9nZOd1wLN1meX4p27YJWXJzLoiiJEkf72df7rxCOOGwMA73Vnu0OLT3dnt8fbakRVQAZzBS4nPFdCadTOssqFbzAx+glIq3n+ryljO0l78jgH23sl9uHwlEaxqaWuyTV8+dPJjtSxlaT09rTchLOFs8eTijilq394XfefaBjrBqMyo7VDGfGjl/4ujFq7M5O943kSgR39LSc6viCJRKiqrKoli86T2AxSVrgALcYmL6JWXhVrkJFKgo3mIwByNEJCBCubjd+WhUtvKuf7KSvKQV7E77Xq4WGFPdgYaOtb73DoxeOnQyPTVrt65tbG0KUXo9YznhxNmx56HPP/viOjfnlAqSLOZGj77xi3dODqVYqTA7M0eI+8Y0EMYZs9nCH+UXqSRLN88QDQCLs4/x8vz9H68V4AYf3+PbVYSKqvhDNWRuJDOfyBYKNnfRqi4Pn2bCknv5Die8PEc0laMNbbGamtO9V06fTDnGZUfruq4Gp6ry6zcNnEme6NqHv/H7j7Y63SJhguISs2PnDvzi9Q8uzpWYnZ7IFPWl1e+SSwS/nhYQRFGSbjx9oRykcs4Xnu1fq4w+tkcLu3XLeuF2Vw93MAiFbDKfSSVTRbvGKVRkmCBJSn1bW9Bz5krv5VNc4SVnNLqmI6JIukUpJUD0YqmQzRaLlDEOIFjlRxmcEALOxo7Yhm0Xzlw61DfIQfVWZSB0BxU7NfNnwbno9wQbOltMXhocGitmWXtDfTgaIJrT7Q9FxFJ27Mg7Bw9/cOjo0cPvvH/s7MBUgTBOCLNtBoLqad/5YE9d1E0YJ9WxkMkNXZdv6MZ8Qy+emzo4l9/it/qBG94gnBOy0N/HKJUSsxMz8Ryj7o51zf4AjI+MDI8Vvd6WzhaftLQrJOecEyopLl8gEAwGg8GgW9XHew8dfu/wWFKKdnQ1RzSBEnZtO8zUjWI8nZ5NJLjNHQ6VipRzvrCczPU9YISArKiCSArFfDo1l0ln0smsYdvXK0POOWGWpRfz+Vw2l8vnCrpuM7Z4XbzNUSqnhIEshjbt3t3RGhi6fP7EiUtxw66umV1uzORyc9bNb9z0x40h8NLOXze8fi13y1OZmUaxkC/qOglHaps6m9LZ2WNHTmWzZlNbk8/vhaXtYpxTKjndgVA4EolEIqGAl6QGz/78v3//1beO9s/NZwybMXItlYwx2ygWiolMTjcMQgVBFMj1Yrq4U5xzUp7ET+C2bRQLhUKhUCjpxuIMlHBtd2yjVLz+vsVuzv+FiTxvOhLcJv6G1nU7djUY6ZHDB09PZ4pW1dwH3bFW+Ngf/OPf+tgPLC0TfHHIEOGEFDLpudnJ+XRBdTvb16xxUnHgcv9MPNPQGGusi1JOr4fOnHMOsurwlCuFQMAvkdLQuTcPfHRk2gw1N3fUhzSyOI8zZ4wxvVQszCQSyUyWUEHVZLIwyxa7KZ0AIKsqAZLNJjPpeCqVyWYL5o0HhBHb0IuFXC6Xy+Zy+aJhs6V7edujxG0iBfzN2/bt9LusE4ePXb46nufVFAvw2+/aksrvDoXh5mNz8yWCk/LdFbGMUmJ+fGouXbSE2paOutpwemaiv3dIUD2d7Y0OZelM8pxxAlTRPOVLRCDocTiyA33HD752YjKuxHp6GkOKSO1ruWzbll5KZzJTibhpm5oqS6JYTta1a8RiMrmsSpIMeknPpGYz6XQqmSma5vUaiRNOmF2+RORyuVwuXyoZ9i12+JYXRUJ8a3ZsXdfdMHP+6rEjJ6Ztg90ydF5enINE1YbWZk/AMTE3Mzk+H3AF2trrRUkVwBupcWra2LlLR959/fBHRw+/d+TQeydGC3mDcM4I5wzEUOuatZs2NwBjxLbsKhrlcE9WZrsv57LHX9O+vs0zPmIWVXXN2rbaUA21IdTWsfPxL40VD12+cPDVoWOyKICj9YHnQ9v8gqxoDocmC1RUlPDOHduODc/Mnpp2qIokVlyZvhGAIEmyTEURAABESZYX10GikigLkiRRIASoKMuyLC0s4gaCKImyIIm0PJ+mJMvlNb2oIEqyLMsiBaCiJMuSJFIg7mAoWtdCzs2deun7+uQTX39xd3Nba0Mwem4wUVQjvrrO1qC8dJUbEEVJlmVRBMIYYww44VxWZFHU7GxidvQKg5QtCA5ZAKCCLCuqPX7y8PfH+4TM7Ixbq9u+rsXlT4uiKEqLa42VkyNLkijG6jvrm5qvXrz0xnf/5KTbH6vf+eI397aE3dReeKSqSKXpiUPf/w9XXxWASmp4/RNdRSYrQvnI3PIoiQIAUFGSFIcn3PZAo5RLT5y4fPH4hY2te7t9UpUM6gagoiCKtNzCKVxbtwwAqCgK5Vk9CQAVRJHQa61owuIcNgCUXp/ZD0AUyz8GQKlABAEIkUXJH4o55KG5cz/7q3Ri7rlH9z4YrWtqjdGz/QXd6enpaA55fML15h0AKoiCsLBAOCtPNMwt0yjm0vkidRhEXZxOEIAKkiIUE0Pv/fSvzjtywyNx2rSlri7qh2T5R64nWRBFAUDz+H2NHcEjF2Y++Pv/Pva2V2lc+9iDu3d1LMzzQCiVOGUDR37y3fEP3IptqfXrOptCAqOStHDGlH+Jlns/gSCKIls4EoJAZGdDz9odDYVLr5w789aHO3uCLkdEJVXQ0bNcxG1RpECACpIsl5+eAAFRlmSZieWdFMvVgnDtFJNkudzXpFwRSAIl5epCFmRxaa0AVKChuoZAMDDSe+HN0veNxx/7wqMd7rbuDtdHE4m0ITQ11jfV10j8eicUoJIky7Io0IW14gEoENA0DQQ5Ozdy1ZbzWSaVG/GopEiU5869+oPZ9+X8zARvrW9at6aBWlckUZK5SOlikmVZlERNc8baN4RD06NnXv3rySNOV8PmrXsf/8LWyOKzckmSJHHswoc/+tPht1XOJW9N+8aHOnSqKIotXdsxeelRUohIASgVJUmWfLGmtWulq/2vnz9x7Py69rZYd1SqjkqhnH0LNTkAlWRZ5qIAUH5HkmWpfPKLoizLZOExESxcCiQRYCHjyjVmuZSUG1pBlCRZ5CIl3OHx1zQ1S6PJvje/91eTj3/9yzs2NbQ0x2IxMjpsOEPu5s4WhyIvSRQVRVmWpIXCwBhnnFBZlWXVYeQK08N9BssAFVRJpFQQFUXjyYHDL/2XXqcZHwcltHVNS8gnLPxI+dqzcC2URAqR+sbGlu6jJ8cOfe8/DLzmctdtef4r+9bWhtTyMr2CpKikmDjz0/9r9l1ZEjj4N+/d5jUkWZYlWaQAIEiyLLPyUaJieY8FCkAEWZJlh79tY31ETvS9NXzp0LErPU+1Rx1SxXV84CBK3sbOtpr6ocGreYg01vZ0tilEFBSlbutjT48X7GP9lw6+OnFaJpYSatz8WFMYRE1zqqosUUI9Tc1rtj+07aPURdN2KLde269qrdDYlxHJ19j9+O/8fkeqaAtSuG1do0+0GZN8kY4Hnv96eO1kOlOyGCcgasH69mjMEdj3lX/eXNJinUGXwkRH50Nf/FrzzodSojtc3+oFcenqUpWEE0qUSPu2fU8EobYz6HYqtGPfo3ZObosFNKrUbdi4zw5pG1t8qqrVr3/sUbceaY+6ZMYg0r7uwWdc0NkZUpxC65b9j/j0uraIU1DDzRv2PecTg51hj8fRtW8/63Z21vlUh7dnzzNfl+v75k010hRyqpLkad3c09E3cLXXG4i1ddRIorjQXEMIyP6WtTufpKXatpgqC+UnkISqDWv3P/0FV9NwlopOh7YxVyShjqgzTHc++ITiH0kUdc5FpXNHY1PHhk1NXj2/fcejvkJtW72LcVDdsZ7dj0tdzs6mUE1D7KnPizWdV+fmcobgidYGHOLCPA+cOWub1+97DmYJZzbjhBNB9mtqMLxxlygk5Y0NIWeA33iUNu2zw46NLRGv27Xl0UdrjWh7Q1tdzaNAg+NmRLJKFue3XgW5wjCqeoJNa7uos96vqA5PtKl9re1pDDtEQXWGGnt6KKv3ORVRcNY0tK/NksYapwjAJFe0ubtbUGIBl8Mdbmhck/U2RT2SIBF/bXdXV6Eh4lYdtL62Y03BXRdSqeqqWbPv+X381KUJSxMIFYgaqG1sX9vtH+g3lNquthqvW1mMDzmRZHdNa3eX2xf1qeJiJjEl2NC553NPGb1juivQ2LrZF6sT6yKBcCi0ZveDmasp3SqV8nLLpkc71+/atb5BmJur71xri40Bp0SBSJ7a1ra1qhTzuv11tdue/0IucLpvLJ1LxlmkZDFuEyISwqjkCNZ1d/XUFA1Sys3rOWZrrmyhsb4u1t7TbXiibqeDR5vb19mexrBDEFRnqKm7WyL1fpfmMBpaO9cYkebmtg7NtX+q2GslZ+YyhWBQUyq6BzgnjMiyv3Xrw49HWFNXzOVwNbVvfuzpek9Lg1tVlUD3/j00yZubQorgjLSvf/SZsNrS4pclCo7Y+q0PSjWOnvZIIODeuO/JGj3UHHIosq9t8+5HJb1xXSzokbq2PkObnK11bqemrt/3bMnZeHW65Kipi3gFSZUjbTu3tV7OzA27WxvrGhtURsr9QzlQyV2/+YGHvQl/R4tPXGzaFRRH46Znv2A2Dk7kJKdToltzhqupI+Zt8D31nNg6Nl80LQJqz6aazq616zpDUqJj9347bTXWhR2Uib66np2PWDm5tSEaqm948tdo9Er/RDKvczUcCrnLM7RwTiXwd2zbY3pac7DQZCy6/B6nIxTc9vC+OubqqgmFfGTz40/Xe1rq3aqqBLv376VJ3twYDCrqmr3PyqR2bXuss+vx52lsGvwaN3WLSJ9ode9lwQkhkq+5Z+dTLBdpqXE6XJHG7Q8/WsNqW0JuwSG0b37g2Wipvj2kqqqvecv+J4J2fXetS2SCFm5b98gzfrmlPerxalt37gu3ursa3FRm9e07n32kWNtU71GVru0Pgo+1tIZkJdK24fFvfiVwdSorOJrCHocCaqxrXeeGC30jo35PS1e7V1QXn/QxJrlqOjc/9ky9q6PJK0oLTf3EdrV0PfDs14XG8QIVHe6t65IlXtsRrYn6HxLsYGyuqNscpI71Dze1rN/cU6OlO7bueDJSauiocQJIWqB19779XUZdQyTcGNjz/Dfkhv7puWQRVG8s4JKl8oNEwpVgS8fu559qMFn5cSAhxOPU3KFoz45HrJzaVhfyanzb/seirLYl5Kblo1SjN7TVeAJ8zcOPCEl3V0tHmxiUClKv5VZ13eI2J5VWGjjnVHQE1z/9BW3dzkRJ8ESjTW0eCoRT0VPXs/d5rXbT5HyuZHNCQHT5a1uiYWH/r/1m1yNirKPVZxPV17L18d/446Zp26beup6wX7xFd7IqBTndWPMf/yarG9f6yliMrYsG/49HdmyOBUV676Olfpk44fl8fnpmJpfLffJeSWULvbgJIQtPzRcf1wK9aeREeXoAoAAL0RJZHA238DD+E7fycM5lWW5tbtE07Q5RMwDE4/GxifFPvHNLtkTsYjadzelEcro9DmrnM+mSDYrX51LBSOeyeUNwOt1uTShm43mdi6rf49IUVsjkMxkdVNXldUA+ly2WmOz2uRyCVcpm0waImtOnsWIqXzAFNeBxOVTRLJXymUzBFlS3y6UpIk2e+dvvfffHb8yte/irv/n7z7U5gcDiEyJLz+WyuQKTVafH5xQFWHyH6YVMJlfkIMkqNYomld1ep0TsQjpX1A2LgyDLTrfHpUnA9WwiVyjZstfpdLslwyjlkpmSDZrH79JUgRTy+Vw+q9sgyg6316WJIgAnBIx8LpdLF6+PyAAQZLdGTcMs2OBwOV0iFDKZkk1uOkoOh2LnkgWTiU6/x0nNTC6X04mmOT1ep/hpyyEJBoKhYFBV1Tt8BgBKemlqaiqbzX762gXAzKfik0OzBdFV0xbVCumZmdmc5IlG60OCPj81NFdgrlhbjUfR58enZzPEG66pq3UTMz8/MhovCt5ovV/Kzydm04YzGq0Lukh6+up0xnb4W2pd5lxqdi4rhkI1jTUuwkrpmcnJeJaJgWg07A878iMfvf53//GvPmRrHv2j/+nLu9trtXLXMQC7WMzMjoylddlf2xDxu5SFZeCIbRYzc+MTcwUm+j1yvqhzxRcJBqXi3Ox8PGfYjICg+aI1kaDHRYvp+ZmxqQL1ROobAi7ZSo2NzcaLNFAbqYl4BL2YnJmajud0myveYE006vcoAgcwS7nE1MBUyrQXxspwTp0Bv8/j0Gemskz219e5zezc/MJRCgp6fGporshd0eaoYMzOzcSZEqmpjSnW/NTQbJ44Is31IY/j069t4fV6mxoa71qWCoXCzNxsJpP5dFsBZltGPpXKG0R2et0amKVcJmsJitPn1aiZi2eLFlF8HrdKzXwukzOo4vD4nDJlhVQmXzSo0+mQFV5IZU0uOrx+h2wW0tl8kSkut6pRI5MsWYLiCnk1gYKRy2VyBUtUnG6XQ5Xs9Py5H/6nP/v5SXPrN/7wGy8+2OKyFwb1c2ab+XQ6X7JEt9vlcKmLoQLnxC7lMtmcTmRFpMQqWYLq8juobhQyed2yGKGS5nC5XZpMmannEumizRWPz6lp1Mjns5k8A9Xp8zlkyu18Jp0rlSwiqU6Hy+lShPK2STGbyBWKJrvWSZSKiupSoZgtGURwehwStwqZ3E1HSfV5FGB6LlkissPtc0pWPp4tWEx2u11Op/Jpoh0AcLtc9XX1sizfuU0lmUrOzMzohvEptrIEt0r5fDabZ5Lq9Lhlu5RN53UiuX0uJ2X5bDZjcllz+52yXcgk8zqRHR6XyynaxUIulTVAUd1u1crmCoYpOjxut0JK+UyyaEuK0+emhUy+WOSqx+NyO0Rm6oV0JmcQ2e1xORRJsOeP/u2P/u5HP5tf++i3/+B39jd7Fm8bAWw9n8um86agOrw+l3xtKhBgVknPpzNFAFlVWb5ki7LHrUnMyuZyBcPmBERZc3tdDkkEu5BJ53M6V1xOj1ujzMglMkWrfCnTJGKU8rlspmhSkFW3x63JCx3EzVKukM3kjSUHX1CdTokyPZ9nVHW4XYKZzRRuPkoOp1ch+VSuaFFHwOMSeTGTS+u2rDl9XodEhXu+RHDORVGMhCL+gF8S79QEadlWPJGYnZ1dOiT8k1kYCUHKwc716wsAhaV9pBcW7AMKcO2D18OoG797zyilNdGacCj0KRP/2QgUXrk89G/fOzGbL17bVcb5xmhwBce+y+n+xb6Lv7O42Wt/XPs3LIz7uPFTiyM6bvHWkj/KQwAWJg9bsqHyB8250z97492TQ57t+5548qGmm2K7Gz97qzfIkvcXtgRksaffYhqvp//mHV2cr4yQJd+4xRaWjtu/eY8/dpSWbuHmrX9K9y/2Lf8SLU9hvbAAMC33cyw/XV6swhaWFiXXK7jF9/hiwWCLHwMChDNGFhYL4fx6nXjtBQL2/MjJd3783XfGIg9/8VtPbm0OKEsf/y38Pv9Y3Qk31L2LvYvptRFpi33uFhYTpku3T2/+czE91zqCljdB6Q3j2xZ67sH1HSa3PkqEUFg8RtdG+Xx8Fz6Z+xP7EkJuPFluPBlvd7qTpacOvzZO7I4nCbnhTCeU66n5s6/94zv98dj+Fx/fubleu6Hp4J5rhSXJBrIweczid26z/Rv+LJ/1N2xlcUDTwscW6o0lvcJvf5Ruri5utQf37L7HvuSm435z/l+v5G5/ZG8+NnTx+C4WjI8XBs4JGJPHXn3/vRPDrh0Pv/j0tlpNBnKL0vCxo3Cra8TiazdV+DeVqNuVzZu3csPF4+NuLuWLR+kWp8UtStrd3dfYd1lVbOy7Mvs8rDY3nHdL/yg/4bnVp65XVnf6Ac75DZXD0rcIYXJs0wNP9+zxRYLRj88hf9vK4JZvLGyJf/xVfvOnbvrrdj92/a9b/ft2R+m2R69acM7sJTvD7SVvLN03xuwbvnTrwrD0mQe7+eBf/yCACYqnsfuZL2xsWLcu6tZumvr0thHjrd+41Wv8hp0pf/N2e3DjF2/92ObGjL71UWJLX/9sN0DL4OaifOt37vzWjW/c6iS58U/gnCpS7bYnPrdZ8tVFgh+78/8UtcKtq4W7/XnbOubaTlx//dY/dLvjV3UFgZA7ZTm/w77d7hJBlk7VcGMtedPnbEfD1h3Prt/lC0diH18V5hOVhsXXPkVhuO0W7pSTtz1Ktz16qJpg7Is+HSBE9kQaXSECFKpn+Wf0q8CZ4gu1b32khRNBlARaBUPB0K8C51SQvbFWd025YR4jg9UMCNE8kUZ3iBBKKYU7LreI0H2FsS/61BZmDqjOhhD0SwWUSoIiESwNqx0AQHkZFSwICCgVAa8RqPJg7Is+C6zS0CIsC2gBFgV0DRYGVIlW5NoWCCGEEEII3QLGvgghhBBCaLXA2BchhBBCCK0WGPsihBBCCKHVotLHulVpP/kbJj+9hw//ShODEKpGWDMgnEJ2RfpEEcKn+HzlqNhkV2rsywkFKkuypmnLnZRPg3MuSdK9rEhHBeHOK36haieK97AeMudAQBAEURQrtrJAnxEnRBDuaRVcAJAkCWuGFamcufdydRCoIMsKAXw8uwIJVBDEu6+CDACiIKiKyni1rut2j5XefVapsS8hkiz7/X6P17vcCfl0OCVwL3GMpmk1NbH7kya0LGRJEu+4aiUpR0VUcLs9siRX4WJy6F6p6j3dzEuS5Pf5XS73rzo96P4DQkRRoPTuK38oqhIKhXClmBWJEiLLMqV3ubEBAi6nSxSlKi0FFIgsy5xwIJW1AFaFxr4AIIqiy+Go0vwuu+udPedclqQ7L+eNqh3cSwsPIVSgHrebOZ2VVkegXyKg91QcRFGkgqDhE4CVCgi9h9ZcWZIlScJ74ZUK4O61AaVUlmVJku5Pkn75gACBCryoVW7UBYQQuvKXyr2X0o9Wg3JJqMzHQ+iX5d47tFAAgjXD6gYAQCowbED3FQYJvwqVG/sitAphZ1+EEELoVwo70SOEEEIIodUCY1+EEEIIIbRaYOyLEEIIIYRWC4x9EUIIIYTQaoGxL0IIIYQQWi0w9kUIIYQQQqsFxr4IIYQQQmi1wNgXIYQQQgitFhW6tgXnXDf0fD5vmuZyp+VTEqjg9/vFO65XDAD5Qj6Tydy3VCGEEEJo2VFKfV6fLMt3+IzN7GKxmM/nq3fZI6fT6XK4oMJW6a3Q2JcAsSwrlU4XC4XlTsqnwTmXZdntdkuSdOciWyrp8/Pz9y1hCCGEEFp2oig6HE5FUe4QJHDOC4VCPB5njN3PtP1yOR3OSlubu1JjX0IIIZxzy7arcSVrzrl9jyX13j+JEEIIoRUBGCP30JrLCbEZq97Yl7NKbLHG/r4IIYQQQmi1wNgXIYQQQgitFhj7IoQQQgih1QJjX4QQQgghtFpg7IsQQgghhFYLjH0RQgghhNBqUdFznCGE0K8SAAUghHN+53m4AWBxskXO+cI/OWe3/dLCF+70kbsl6ga3/aHyh++2A9eSc5f9RAihVQBjX4TQ6mTbVnzk7MDEPA30tDc1h1y3nocSwCpm5sevXh2OF0Hw1Df6S5lEPAnhxtaOlqAqfOzhGdBSdnZ84MxYRo40bmyN+Z0qAaCEMMbuEgoDt43ibH/v8PR8xiaEE0I4B1kLNvSsaQg6FOGGb3PLyM2PDo2OF53NjQ11MY90yx+lZmpmbKRvKEtDTV3dMb8i4vM+hNBqhrEvQmgVAgCbGSOnXvnhW6fEDb/39Rfaoh7gtNwGvNCYyhjjBLieGu19/6c/fPvcnBgKdO5/vH7k7PGPzpHtz36ltjGoKZLAGeMEgAAA54wAzcdHj//iv70+4N31wr8KB72QGx2dThMtUlcf86hAAIBwZjPGOQCllALhjNmMANiWnul/9/WffnhynLjdTk0CwkRnuGe/vykS9DjFxdiXc8a5ZeTmLr790quHkh1f/eJzsaagyDgvp5oAFShwzggBIT8zeuqN7/1wUN36wm83hryaLF5vW+b87hE5QgitKBj7IoRWJ06Ink8m5pNipmgaZj4dT+ZNQXbI1CgVdYuLTo/PKfPUwOmD773xzpkxKdjTrCpmKRWPz84n1XxRN0rZ+cyMYctOhZqmXtJtUXV5/H5um8VcMpVi2WIhMTfYf+yHP32/j8QeePL5x3tiTsXSLUHzBjyaKtnFdCaT0rnq8gQ9mkCAM1ZKp+JzSauxqXnDmphKiaC4a2s81M7Nzc7lC6bNiCCpDpfXp5rF/Gx//+B4wTE9OTY6TFUuaQ63160Su5BKZA1Rc4pcUPVsvpRLJVOOnG4xTrhRSKezuWLJYiCqqsvrdckSrb7lMxFC6NPB2BchtHoBABAAQdBnLh955cfvDWuxrpgyMzo6Hi/4Njz6hQdb+dUP33j31ETJsEgxMTV9Pv2OnU7kVF/E6eTxiZMnX/7ZuWL9hnotkZoYHsm4m7Y//sLz3bKgOLwej0vk8UsH3v/og0Pnh3N0qpAqTtdHa3wjF6eU7ie//eKutdH53vdff+VnY9LmRz7/G4+2ayAAIQQIUK2ue+sTX3xxvU+kBEDgLDt1/OW3P7jQN1MoWZKzbs2Ox57d18o5oQQgc+XwW3938Yhd5IG2tfuff2KTu3j6h997a1Bt3hAwXQ3NvCQ6PB636lAEbuqJwVO/eOuDk0OTOUMIda7d89yLj7RFVBGw8RchtDpg7IsQQsD0bGqq79yp3OWhaDDgFWeHZ/pHP2iok7c11LY0hXqnk0KoY8f+DVEVRj48cHxyKl8yzFIpMzt48dx4/8RAMBhWEzNTfYOmO9zh380MPZvNgckUf1NH7PLxS0NZJVjfvWFrm48nxl//cCB1oX/P2noYHeo9f3yW9ojOkAS03MN3EV8ABAQKAismdFHRQk46PTB6+J1kVvZ8c6+fAxBu5UxSpwjm/NT5g4cMVzS4PzI/Pnz14kzvhEer36V2+oRiLpu3dUsvpIdP/MNrb5zuM2obGyNev5sKxEH4TZtGCKEVDGNfhBAihBDCTa64/euf+/KDDcUjf/7K+33z8SJzt7Svaa/74NSYHmrZtPeBTjecGTl/4dyIadmcEMJsLhF3z94X9+5UL/7wJ28eSiTmUnnmtGzLMi1OXbXddcXL4RNnp7VIx7ate9Z745enYq+NTVwdmcqOZUenpsbtwOba5gafAAJwmxMCBAgvDp088IPU0JsS4Zo7vHHfl3a17vji53psC+jciZ/8/Mcvn5q4NDSzw2kSAuDt3rnv+Uc6Um+89dOfHJ+9Oj63129xxmxLa9745BNP7lamPpoyLUu2DdOYHb5wdXKGxh565Llnd7X7ZNnhdUoCTv+AEFo9MPZFCKEyTlVXoHXdxjWxmUGnJpESoYKkOpyaKgiUSprL6/V5iFuTpCW9Y0GSvU0d69asI4m3HDLJ8OstqECpqDpdDlUWKBUlze1yh/ysrq3Tp8xMDoyOxOzB2Wkz3NzQ2RIUrqeCEEKYZZTy2YwgEm4RtWCAoEXbIxFOgDgnI2EP45lCqcjLU1MowVhtU0eLdsLvJCSvGybnnBAAb9uGzbt3bmyZKpwmhBAAzrleKjLCNV+4trG1o8NjM87ZrSe4QAihlQljX4QQIoRce+rPCbOXTKd7fU7chelxb2oiBUKAEM7YbabgXTqlLucgK5769lbXR8dHLh9x5AfnM8ForKkpKgNc73bACZEj7ev3Pba3zUlBkrRQrWalL7x76NLIRMpMj5y9PE24g/BrEfjCZA3lLS3ORExA9rhcmiLzpbFt+V3OOWO2zRjGvQihVQdjX4QQ+pUCwoGYxUJidnYuFQiovtY1zY4zg71Hz5V0CGzraqqPqTetZgFyoLZl484HNvlFCgTMYrLvw9d+9I/vjmZrWuo8+aJ1w6e5zSwzk83k81kCgiyLi79242IWnAAQWZI5gF4oFQrFYl62GRMcmgwfW00DIYRWKox9EUKrFme2bRGwGeecM9uyLNtmnC++Uf6Dc1Z+a6GJlDPbtixiM87L/7Rsxjlf+I5lM7b4Y5bNCBDV43XITnNk+MyB96NgPvxoR6CtK6YdH5qZ0cEfC9fW1XhoebAZLPy8bVn2YksuJwCcsWJmPpnLgeqLxqKiOUpmbYuxhQRkRi+c+aA0PHGhL+l29bTWhQRpxrIWEkYIWdw3C6jkrWmtcZ29PHnpowO/yA/4PP5Y165NDW5FvLk9GyGEViiMfRFCqxMAOH219Y1xIexRFYl5o03NeV/MK0uCoPpidU1JPexxSiBp3mBDc5Me82mCAEAcgWhdSwuN+pyqysN1Lc3OWp9TkYB7w7VN9XIs5HYoDn+0tSXnDns0hfqaujeu3T6bP5caH7h0uX7Dk131DW0bGmO9E/NTWm2sobk+SIEthL5ARXckVt+Sdwe9Kl1YfoKLklLfs2vtmvzFvumLlxMidzU3hetDHtXJ65ub4zQxeOmDYc6J3LFn64MPb2xyF6ZrGppaWMTrlIGD4vBFG1uKWsTrdgbqdz+xeZh+1H/11JtXTns71jxUs259vRtwogeE0GoBOd1Y8x//Jqsb11aQtxhbFw3+H4/s2BwLipQuS33ICc/n89MzM7lcrhofxnHOZVlubW7RNO0OA6gBIB6Pj02M38+0IYQIIYQwZucTk/F0gTiiYa/KivGZhC4q3miNRzLTk/OpInNFAn6vYiZTs4k8UTyRmFcTSX52Lp7OU5ff53Gw7Ox8gUmecNTjJLm5+VTKVHwBn1coxqdSuujy1wY9msDyqVQinS4wyekNhcMOoZjo//n3/9P33x1p2PHr3/j2V3fU0YW+u5zZRmZmNpkrCp5gIBh0LS5TzG2zmErMpzJFLskiBdPgsjtQ46aFbDKRK1kWJ0SQFafH7/U4JGakZ2ZTJeYIhQIen2Rkk4nphC44/JGoVyV6PpVKZfNFwwLJ5QpEI15JxLUtELq/RFFsamh0u913CBIs24onErOzs4yx+5m2X6JIKByNRildhpXUBQqvXB76t++dmM0Xr4W4jPON0SC2+yKEVicK1BWocwWAlCtFrdbpJ0AIAQAp2NAYWBzHJvsjzX5CCAAlhBB3JOYOk/JcZMTZ7C1PSwaEyNG6QLTcq5Y469qDi+scE3CFos5gmBECQIFw3WLZTEZQIju3r1/fUSNwWLz2AVDZG6vzcsJvvOsHUXaFoo5AhJfX4+D2wtLLmtPtY5xwzglQSikFzhgXA/XNAcLLyycTzRmsaw1wIIRQCsTpizg9YcY4BwJw87TCCCG0wmHsixBapQBueqq05C9YjIgXPnfTx+BWXyq/DB97nZQnWlicYIFwKmt125/5ZqsdaGuq90pLZkUrT8MA5IYtlH+DM3JtDgdOYKEZg7NygLv4xsK8DUDpkqQQWDL7w7XkLDaEYOCLEFpdMPZFCKH7S5Ad0c6NEQKCSClg7IkQQvcTxr4IIXRfAYAglif0xbkVEELofsPYFyGE7j8MexFCaHlg7Lv8qnEiC4QQQgh9anjpX0YY+y43wBMAIYQQWl0opQSv/ssEY9/lxsm1efswCEYIIYRWNr6w3CJ2e1o2GPtWCkqpIsvLMv8zQgghhO4Dy7Z1XV/uVKx2GPtWBADQNC0ajkiSdPdPI4QQQqgK5Qv5mdlZ0zSXOyGrGsa+lUIUBE3TZFnG5yAIIYTQygMAlm3jA95lh7FvBeGLljshCCGEEPrlw0t8JcCbD4QQQgghtFpg7IsQQgghhFYLjH0RQgghhNBqgbEvQgghhBBaLTD2RQghhBBCqwXGvgghhBBCaLXA2BchhBBCCK0WGPsihBBCCKHVAmNfhBBCCCG0WmDsixBCCCGEVguMfRFCCCGE0GohLncC0KfBOeeEcMaWOyEIoXtFKQWAe/88Y4xz/qtLD0LolwgWLXdC0N1h7FuVOOeGaRYLBYbhL0LVQJQkh6ZJknTvXynperFQ+NUlCSH0SwOgKIqmqoIgLHdS0N1h7FudgBimMRefN00TCN5lIlTBgHDGXW6XJIqiKN5jsxBjLJ/LzcXnCSEEG38RqmRAKFC3x10+x/FxTeXD2Ldacc5N0zQMAx+yIFSxyldBzrllW5/0isgYMw1j4TtA8C4XoYqzeFZTSm3bxqi3WmDsW8UAgFIqiaKqaficBaFKU75BLRWLNmOfLnIt39ZKkqSpGhVwaDJClYUxZui6bhjYAlVdMPaterIs+70+TdPwjhOhisI4z+VylmnZhv6pfwQAVEUJBYOSJOE5jlBFsZmdyWSMeHy5E4I+GYx9qx4VBEVRMPZFqNIwxgzDoPTTt9dyQoAQgQqKoiiKguc4QhXFsqyiVCQAeGZWF3yIhhBCCCGEVguMfRFCCCGE0GqBsS9CCCGEEFotsL/vSoYjT6vLTb05Mfuqy7J0xsVCUkXwBK9q2Nt+JcHYd8XinOOqb9WlfC0EAM451rNV5z7PtI2FpBpdKyRYP1cjnE1/xcDYdwUCANu2pqamstkswfnwqwAnBERRDAQCXq+XUprNZhKJRKn06SfGQvcRJ4QIghCL1brd7vsTjwJAqVSanZ0tFAqLs0GgCscVRfH7A16vl3OeyWTi8XnTNAkhmH3VgCuKGo1GVFX7LDO3oAqBse/KVCrpr732+tjYqN/vx8ahymcYhmVZGzdu3L//YY/HMzExefjwoenpaU3Tljtp6O5M08zn85///Oc3b95yf5qFKKXz8/Mvv/xSJpORZYlSXNqm0hWLRVmWt2/f+eCDexljg4MD77//frFYVFV1uZOG7gKAZLM5TXO88MIL7e3tGPuuABj7rkCUUsuyTp8+LYpid3ePbVvLnSJ0JwCQTKauXOm/cuXK7t0PAEAmkxkbGzMMo7GxcblTh+6inF/Hjh3buXPnpk2bKaX34W4TALLZzMWLF2Ox2pqamCRJ5eZnVLGmpqbGx8dDofCePQ8wxuLx+NDQUG1tbSQS5Rw7P1Q0SoV0ur+39/LevXsZY+VuacudKPSZYOy7MnHOAWDPnj3f+ta3DMNY7uSgO6GUTk1NvfnmG9lsttyJE4D4/f7W1tYXXnhxuVP3WdzYO45zxjkBoDd1aAZKYeHNakQpnZmZ7u/vv8+tQZwTj8fz2GOPbt++A5e9qHz9/X1vv/32tdOBUhqLxZ5++umtW7fZtr2sSfssAOgtT3HCGeM3fKh6T3EiiuLBgwdfeeVlQcAHLCsExr4rXJX3zQdK6fW6lXPOmM0JFSgQzmzGCAFOCAAVKOXMZpxVYde5O+RRNecd4baez6Qy2YLOCAFJdfu8bg30VDZvUc3jcasSALctPR9PZZni97ocirTcaf4Ulv0UW/YEfDZABXo9fOKMMc7KJz63bcYX+jIDpRSAM5tVafh0W1WafQv5YhbTqUS2qFuMgKBpbr/HCbyQTuWp5ve4NFkkhFilQjaTMQTN63MpglB9+1rd9TC6JYx9V7iqHgzOrUI2k83kiyYjnBMqKQ6vz6exwmy2SFSX1+2SKQdu64VcKpMX3AGPQ5No1e3tHfKoivPOTM0MXjp5/MyV8UTOBkH21fTsfPCBNeTS6wdOJ5R1Tz75UGdEpHYpPXH8lR9/YLU9/8SDO1rCVvU9/F32U4wvWsY0fFqMmaVUKpUtmjYjnBCqON1ej4vquXS2JHmDHociAifEzCcyuaItefx+h1iF97d3UKV5B4RZ+eTk5VNHT58bjucNGyRHXcumB7etU4onf/7SMW3Tlx/bva4+wAAyY/0H3n5jxLPl+RcfaHI5xerb3epLMbobjH1RpeJ2bvjwKz/40csHL80UmE2I1rB+91d/93d3pd79d39zkO794j/5ynNrvBwK84Pv/eg/f+cXoa//P3/z8QdavRbOHLTMAAgvDLzz0v/44csDrjV7d2+rdTAmcD2nm3pu8OiR96cc0rYHH+QEgJu55NWjb71u5Tdt37arDciKa9ZDtwNAzex873vf/4vvv3thKmkSRkS557Ff+/YXnpbP/uS//f3x7j/8N996aG2t02Zs8tjf//U/HJnv+PV/8ceP1QtQheHTygKUGsnExZf/05/8fa938/bt67pColUQpEI6X5Lneg+98ZpXfnDHlg1AOKXFuYnzh948GXHveWZ7IwDBvEPLD2NfVIGAgGWbo8de+ceXj+eCD/761zbXq4JNVI+vPugUx2aHBwfFzlSRARAO3CymZof7+0vJvG7js6nKwCcvHj3TNyt3PPXMi09s9MqMMZuJLp+jV8/nczmi24vXP24bhWzGKhk2XhFXFaAkPX7+4D/+99cHYju++LnNrUEHWKYWbWlx21cTUwN9A95U0WDlM9rIzE4MD0650zqO6asIYOaT4+eOHOmTN/zR/ic/t6Nd4cxgIDkEe2iulMtmJN1cvI/lllnKZ3NF3caoF1UKjH1RJQJicXv8ytmBebL9sUc+94X9dRJhtm1bVs7IiyAIoijQxTAXgAqiJIkUA9+KAIRzkksn85YYqGtta45FZZFzTgA4MwUCQG/MqfILmHerDEApOzd0+fRgsub5h59+4bE1IZFZlmVzyAwPUipKonC9nAAVBHHpSY+WEwCxTT2bTBZJqLa1qamlNmpZnBCggj45Sm8+owHK3bWXMcUI3QhjX1SZOOeFUolIqsulSdQ2DcYJASoKK6uz38rFy/nEysqxLzbZoUUAxLTNUsGQqM/vFQm1DMPmhIAgUjzHqwMAEFhcoo5xQoBU33ALtDrhFM2o0mFlitBKhp13EUL3F8a+CCGEEEJotcA+D6hicc4XZr+83etAyLV/YeNRRVnIEk5AEARB4JwTIMxmVKCUcWYzTgVBEGxKmG0ySikA3oivQgvn8sdfvuHcX/wXnuQVAwihBDjhnAClgiBwTghQEAAEgXJi2jYQIooi5cBt2yacCiL2ZUGVAmNfVJnK9SZhhmlaNgdKKeOccEYIkWQJmFkqGaZFgHLL0ktFg0uShMusVw6nz++WRmdnJ0cnpz2axDnhVHa5NXeoxieNTY8NXh3udPuk4uTg4FjcCqwJeFwODGxWFwpUkETODcPgpHyOM8Y5A0olWeKsWCyaNgcAXtJLum5TKkkS9gWuDFSSXYGAU5yZH58aH5mWJJvZIMiaQ1R84RqXNDh1ZWR4ICq7eH5o5OpMQXJFIn5BFLATG6oIGPuiyiRQGonUOsmlydGhkYl20UltmzObKC6hvrHVDUf7Lp2/fKWVhozh/gvnLsTlpocbvS4NG4aWH+dAoHbjAxs6h35w5Ad/oV9eG9WYLXFX+xNf2Ne9/oHNXX3f+eD7f5q+uLFJzY+cO9+X8+zZsam5JsRwct/Vg3Pu0Fzh2hoBxvp7x6ebA8TJjZJFFdXl9NW1Nkr8yslj/Ztqvc2O3Plz5wdGjXB7c20MQMQJYpcbZ0x0BWs3PrCn7r8d++lf/cWVw60BycjI/sYN+7+xKbjlgX11Zw794L/+af+BrqA+23fhxJTW8uSOjUFVpRxPclQJMPZFFYhzIlCpZffzL1wtvnPiu//2j3+iUeBytG3DU7/xrT11O1/48tXcz4/+9N//qzc0kZeKpqTu+PqXH+tpCshVu2L8isIJ0Rr2PftbkYbtV2eyBhEEEJye+raIx+F0PvDc7wTrd/VNJAtMEHlNy8bnG1rXbtzQ4ALMvNWEM/A1bdj3pa/1fffwK//xX/5cUwRCafPup178wq91r33wS9++8v0D7/35/3bwrxWBFfOmu/3hz33hwXYVsOGwEnAuugPdT/7Ov4nsGJpIlRhQgdb6a1rbQoo30P7ob/2byM4ro7Mlm3NW27hxd6yzu6e72SUJmHmoMmDsiyoSBwB33dZnvuJs3Tg4ndZtRojoCde3BpyqS93w5JfUhnVXJ+MFi1EqOUOx1vXrO4IeGRsVKgUoofo1OyNNPZlsoWRxECTN7XVpiiA6Yt07g009mWy2aBAqag6/16sKlOCSbqsL51xy17bt+dpvutZenUoVTM4IFYIt3bUu2aM17/61b3l6+scT2ZLNqKT6Y62dazoavQQbfSsDJ4Loqml/4PHadYlsTjcYESRNc3ldkijKNW07Q3Vr0+lcUbdAVJ1ur9epAGEcQ19UITD2RZUKiOCu69zR0LVrcSgML08kybkcad1c07b12hCZhZfxqlhBOCNEUFyBsCtAFtvqOOeEc0aI5PAGHd7F1znnBNehXoUYkRR/88ZHWjbfeCozzkVvw5q9jWvh+rnPOOP4ZKCicM6J4PBGHN5ro43LlTBnRFDcwYibLC5hzLFZAlUUjH1XMkqpIAiCICx3Qj6bpTEtUCrc5vWqHQJTzqabBruXl0Kq+ry75na5U7W5ds0ts+8+b31hJo2qdbtTfOkbABSq+WygH1u9cIWd47c7BVbAem6CIHw8+1BVw9h3xWKM9fZefu+99yzLWu60oDuhlCYSifHxcU3TAAghwDmJx+P5fMHn8y936tBdUErj8fm5uXnG7nfjdaGQP3PmbLFYUhSlqmPf1WBycmJ6erqpqan8p23bMzMzJ06cyOXy97/koE9EEIRz586m02nMqRUDY98ViHMuCEJjY+Po6PCrr76CF8WKB4zZlNJoNCIIIgDxeDyKogwODuRy2eVOG7orME3D4dB8Pt99m2eac65pWjAYunz50sjIMM7uV/ls2xYEIRAIAIAgUI/HQyk9derU1asDOHyvwgFANpv1eDyapmHr78qAse8KxDlXVfWrX/1qJpPGE7VaAICqqg6HgxDS0dHxrW99a35+HmOaqsA5EQTa0NBw3xboYIzV1NR861vfzuVyGDlVC0qp3+8vP0DfuHGT3+8vFotYRVcFzrmqKrFYbbX3L0JlGPuuQJxzURSbm5vxFK0u5QZ7zrkkSQ0NDbW1dcudIvQJ3M8blXK7b2trK+c4xrPKlMuJw+Ho6OjEvKsiAOUFBrE9YiXA2Hdl4pxbloU9fasIAEjSwvlYzjvbZtikVy0AQJbl+zluiTFmGAZ2QKwidGFlOkIIMU3TsizMvioiCIIkSdhMvzJg7LsCUUoLhcLLL7/c23sZH5pXBc650+ncunXrjh07HA7n4ODghx8eHh0dXe50oXvCGHM4nE8//dSaNWvvzyNRSunExMRLL/00Ho/jQ/OqwBiPRqO7d+9ev369bduXL1/64IMPsF9TtWCM1dbWPffcc9FoFLNsBcDYd2UyDOPDDz8khGzdusW27eVODroTAEil0mNjox6PZ8OGjQ6Hc2Zm5sqVK5zz9vb25U4duovyOJijR4+uX79uzZq192ejlNJkMnn69OmOjo5wOILRb+UbHR27evVKJBJZs2ZNeZKHgYGBcDgci8Ww50OFo1To6+v76KOju3fvjkQiy50c9EuAse8KBACcc8Mwdu7c+dWvfs0wjOVO0WcBBMj1ie85WZhH8obLxcdfqSblNry33noLgJZ3gjHm8/m7ujoffviR5U7dZwVwY+59PLOqO/cIpXR2dqavr+8+7wLn3OFwPPTQ/jVr1lR5Q9SSluvbFRIC920OjV+R06dPHz16RNf18p+U0nA4/PDDj2zYsKHKez7c/RSv9nNcFMV333331VdfsW2Lc16+wi53otBngrHvilWeN8DlclVv7AsgUGJblmVajFBKBVGinDPbshkHQRAECoRwxpltMgJUFKtz9nFKqcPhkCRpaQQjiqKqai6XaxkT9tkApcCZZZmWzQkhVJRFSphtMkY4pYIgUFJeqs+2bEZAFITqXJ+EUprP55Zl9DcAiKJYLjzVeTEGoADcNkyLMU4IFURBoJzZzLIJFQRh4YxmzLZtBkCpKFRrlP/xGbLKUwe43e5qfTRXHvhlG6ZlM8ZBEAVRosy2bcvmQEVBoOWQ12aWzQilolCdNTSRJMnhcCiKWp3JR7eAsS+qWKw4NzA8MDw0l9NtAgCqN9LcvqaBDZ0ZSJFIR3dbXVAlYObjE1fO9ye09p1d9V6vgsueVgRgufjYyNX+kZmsYQMhVHWGm3t6gvZY39C84G/tWdfgEahgl1JTfScvxT1NazubYx4FFz5dPQCIWcjODff2j06lSzYnQKgWbe1sCWuZ4YuDGX/PA521TpfEOU9N9fVfnQFv+5qNDW6MPioBALf1zPxgX//odKJgcyBAPcH6ztZmuTR0tj8TaV/f3hh2yRzM9PhQ75VxI9KxozOmylV6l4ZWGIx9UUUCzvX5y2/8t//6j8cv5ZzhoEO0dEdt187ng8/pL/3FX56nD//OH/92Q0jj1JofO/6jP/vPR2p+9y//2fMBv8KqswllRQEgxtyZA9/72+/+7ELaFwk4qA1OZ9O+b//uxtzP/vxvjisbvvkveuo8okiNzMyZl/7Dvzux/mv/y+9/s96Hubd6APDSfO/JH//pv/vxYEl1+5yKAIba+fiLj28O9//g//tXF9f9P773T5/0eGTL5mPnXv/Lv35P6vm9f7mhwUMJBk/LDoAVMqMf/vjf/39eGjRtVyCggVUKtm5/5qkvBGf/8U/+rO+R3/vXvxWNuhUu6FNn3/+bP/9pfN8f/GljSJNljpPXoOWHsS+qQBRY3kydPPDG6XHn3q//4defX+NijFFZc0qEflTMZQuSYTNe7gfMmVkq5vNFgzFOCOC0YMsNgHM2efKtD44Nw9Zv/fM/eHS9U+KcUkX1+5PvF3L5AiuZix0cOTP1Qi5f0u2q7vKIPimgNDU9eOytl88W1v7+P//m3s11DsY4Vd0BGD15uZTL5nSTsYWu/swuFQt5S7cYIXiOVwBKWXpu6tgbPz4ttH/rj776zNZW1eZcUFx+SJ17q5DNFnTDLmcScGYaxUKhoJsY9aKKgbEvqjxAiG3z5PRkIi80N7d1bWhrJYwDAQr5iQQFgBu7XcHHXkHLLT0zOV+0nQ0d3Z3tbarIOSFgMDNHP5ZZmHurFBTy2fnpScv3SHtHR2d7TLEZJwSE9CR8vExgKakkQIipF5PTk4liMNrR3rW+o5GZHAgATWbpx2roW+QnQssLY19UkTjnlm0TIggCcGJZVvmySLFxsEowxjgFQQBglmURzgkBhg+r0RKcc8YYFUVKmG1Zls04AQpYRqoB59xiDEASBc65aVkWJwQEEXMPVYVqHTOLEEIIIYTQJ4WxL0IIIYQQWi2wzwOqVNcWsrjWV2yhx1i52xgAgfL/AQgn2JmssnDO+Y25d3MWlV8GAtgRYvXinJfn+F1STMjCUDYOHMrFhF97DVWQG0/xJTU0AcIJEKAAQOjCJL/Lm1aEboTtvqgiAYDD6RBIKZVIZdIlyzKNkl7M501K3F4PLWWnp2fnM0VdzyXmp8fns7bb7RVlEa+QlULVnAoxs6lEIqebpmkYejFf1G3F6VFUMzU7PTWeLRp6NhsfHp8tWQ6PU1VkvD6uLqIkqZpq5OJz6VyxZJqWWSyWSkUmKy6Xixdnx0fmM9mSUcpOTExNpwxZc7s0jIIrASeECoLDoVGWTMTTmaxuWqZRKhULBVuS3G4nyU1NTcfjOUMvxeOzU5MpE9xuL6UC5h6qDNjuiyoP50SUaaxrXUfjhcuXT37wZqgQVS2diw5ntLOpafPm9iOv9n743i/8wvqAPvjhgWNT0LhrY5fb68SFLSoAJ0CgpnNDR/3IwYGPDr7v0aMOZgMXnU3dTfXrN6w7+daJk2/+tM7aGTTHz//i8LizdtvGzpjPxbm13GlH9wvnzOuPdm7YEuy7cuTDw2ppwi/ToiWFa+tDkbb1W5sPHzr68nvhTKpZSp968/hgybtm3fq2IE5wVhE4lx3ehq4N3fWvDZ08cshnJYOSVeKSJ1Lb5G3btK31wxOnDr4dEZJdjpneAx+dywSbH1jTrsgy5h6qDBj7ogrEOZcEZc2jv/Gb9BfvvXv0H/7sgA2iHGrf8dQXuls7H/jS7xuBXxx4/8gP/st7liS5Qh2f+51nnn601eejDNcFqwCcE+Ld8Mznft2h/fz90z/88yMmoWq4ftuzX2lqWvPA174h1ATfOnzuR39+1BKoM9T89B/89pP7Ntc7MfNWFcaUUNvu539P5z87ePL17xw1OZc8DVsff+HFp3eue+Ib/1IOvnHo1GvfOWIzQQ3X7/v2F596ZEe9BLgqWCXgjKmhwLYv/89/JL/6wan3vnfkDZtIjrZ1D37uc10bGx/53X/F614/dOq97334hikp/sYd3/zaU49ujzklwHMcVQaMfVFlAqBaqGvvk8GuDU+m84ZNQJBdvkjMoWmSa+3+Z6Jrt8yn84ZNRdXpi0ZrAl6F4nWxclC1pnXb019p2PJoqlCyOQiK5ovWBhya4urc/UKgbdeTqUKJgSA7feGaaNCtiXhZXGU4oVo4tunpL8c2P5TMlyzGQXL4w9GoU9VczTuf+7WmbftTBd3iVHF5g+FIyOuQAZsNKwQnouxtXP/Y1yIbHk1kddMmIDq8wViNpjmcrVue/Frt5seSWd1kguTwBmuiEZ9DwjEZqGJg7IsqF8huf5030LA4SIpzxmzGOZHdgTpvcPF1zhlnnGHgW1E4lR3BWFuobmnuMcY5CM5QbVu4/ubcW8a0ouXBCaWqL9Lir2m9Xkg4Y4wTUfVHWwMxLCSVixMQZE9Nk6+2+aZTnIiyL9bsr2tZzD3Oy68jVCkw9l3hqn09Hc4Zt5e+sLA3H3udVO9u3i6Pqj3vbp9LKyn3ljmbbphJoyqtikJCbpP6FZB9jK383KvyPEK3gLHvisU5n5mZ6evrM01zudOC7oRSOjU1lUwmfD7/tRcLhcLExER/f/8yJgzdC0rp/PxcoVC8/5vWdX14eNjhcEiShI89Ktz4+Hg+nw+FwuU/Oef5fH5kZMTlcjOG61VWNEEQxsfHDUPHs2zFwNh3BeKcU0rD4fDo6Ogbb/zCtrFirWgAkMvlEolEbW2tIAiEEFVVOWf9/f35fH65U4fuAgAKhbwgUE3T7ud2VVV1udznzp2bnJwsFxtUydLpVLFY1DSVEAIAmqZZlnXmzJmJiUmMqCocpXRiYrx8k7ncaUG/HBj7rkCcc1mWH3zwwbGxMbwoVgVNU+vq6rq6OhVFIYTEYjWbNm2am5sDwBm4q4CmqdFotL6+niwuyfKrxhgLBAIPPbQ/kYjfh82hz07TNKfT0draSimllNbV1e3YsSOTyVCKVXSlAyAtLa1+vy8QCFJK8V5lBcDYdwUqx76PPvoox9EhVWJxUaSFXmX19Q11dfWYfdWinH2U3r8blXLs++yzT3N+n6Jt9BldKyTlc7ypqbmhofF+3SuhzwpgYQHC5U4I+uXA2HfFsizLtm2sWasFpVQUxXI7PWPMsizGcO6KqkEplWX5foa/nHPTxEJSRYBSKJ/jAMA5N02Tc47ZVxUAgFIqSRKGvysDxr4rEAAYhnH8+LGZmVlRxCyuAowxSZJaW1taW9sURZmenu7v70+n0/czlkKfGmNMEOjWrVvr6urvTygDAOl0+vTpU7lcrvzCfdgo+iwYY6qqtLS0tLd3AMDU1NSlSxfz+Tz2eagKtm253e4tW7b6fD4Mf1cADIxWIADQdf2tt95KJpNNTU04iLjCAUA+n08kEhs3bqypiSmKMjs7e+LE8UQiEQwGlzt16C4AoFgsDA0NezyeWKz2/nQHpJQmEvF33nlHEASXy4X3SJUvl8vpup7L5Vtb2zjnw8NDb731liiKwWAQm34rXHkqHsMwgsGQx+MRBAGzrNph7LsCAQBjbHp6pq2t7emnnzZNa7lT9GnBLZqz+LU2Lr6wxtP1m3Belas+UUpnZ2ePHj2aTqdN0wQA0zQsy2psbNyzZ+9yp+7Tu0vjyMrJPpifn79yZSCbzd63KyIA6LqRy+V27NjR3d0jy3K1XoxvdY5fc22frhWSKt1LQsjIyMjZs2cymXR5pYdCoQAAmzdvXrNmTfVOxXPnc3zFZJ8oCsePnzh69EipVMK2pJUBY98Vi1La1NS0Zcs2w9CXOy2fFgAA0CUVJ+eck/KAsGvLPC18iDBWpV3nyo0KU1OT6XSaLA5+cTgcDQ0NmzdvXu7UfWofm7Z/YeweAAVybZWuxdzjrFp7PlJKZ2am/X7f/W98VRSltbV106ZNiqJU58GDxSFEiy+UCwkABeDXz+jFUUbVvLab0+kYHx+7dj5QSn0+X3d39+bNW2zbvvN3K9XN5/hNp/hC9i05x6s0+0RRzGZzvb2X8QHLioGx70rGGLNtq1orVk7s4szE1b5LV6fmCyYRRGe4aU3P2no2eLovSWKdazvqAzIBKzM/1n+ud07t3NPT4PXKrOoqV865bds3NSeUG4eqNe8IIWAV4+ODly9fHU9kTQ6Sy9+4duPaBmnudP9oUYytW9cZdgkCMzKJwbMn+1l0Y097c9hVhW0q5exbrtCzXEiqc1QrUG7o2ZmBS5f6RuezBuOC5m/sXNcRVZKDF6+k/Ov3dde5nBLjPDFxtvfKNHi71m1ucC93sj+lj+dRueSULVeqPj0AbuvF6YELvX2js9mSxQUlHGvb0NOhsrGLZwblhq09bXU+jQPNTw33912MK80bN7YGFIVW3+MdAKjOUwzdFsa+qCIB5yw5dOT11944cW5OB0UUqOhtzsjuWl/qje//9SVh37f/sLExqHJqJibPvPbd/348/O2ucDjgV5iNFVQFsBJ9Z95942fvXZg2BJEKIPuj67Roc5gc//EPXpvW9v+zuvaQWwJWTI4d/cf/+jfWrv/ld7/ZFnWz6rt1QZ8OANOTI70HXv7h271TBQ6SCJIWTUHApfPTP/nL7/Wu+eONNWGPW2Y2m7z87g++f0js+s3ajQ0eoVqfnK8kQO1ibvLC2z/98TuXpjOWqAggyPWdRigQ1tIHv/ef/9Hz9P/+e5HGgMMGmh65/Nbf/tfToRf+7521Pk0VqrTxF60oGPuiCgTAdTN/7s3vff+lia7Hf+cPvrKnRjVLJiOMy8J0an52TsyWDFbuKWibxdTczIyQtyxGCJDqa1VYaQAIj5/+2cs/+PkJ15Pf/qdffLjWySxbN2yvWxrKJhJz846csdDSxW0zG5+dtlJF08bB06sJCMW5q4df+e/fedv1lT/4vRf2doYkki2YDi+b6S0kZ6dnagu2zYEQQsAsZeJzs1K0ZBOC53gFACDF+dljP/zPf3nA/eIf/OaX9m8NCWbesEVVEebm0/Mz01ZGNxdyi+ml1PzMnJA1efU91kErFMa+qPIAEMtkkyMj8YKrbf36DZtaY8AZ54SSUjzfS8rdBJd+/oZ+pWh5AeGcz44NzRTE2NYt29Y212kSY4xzApSMEULgVtm3XKlFywMAMunk5MioEPnKjvXdHS0xlfEI41TKpfopkJumbcNCUkkAwCjmJkdHk0brzs3r169vjnGbMUaoaM4l6MdOccw+VGkw9kUViXNiGibjgqKqiioKJqNAQKAWKWANWg0s07QIlVRVlUVBECilBIAzC3MPLWKMmaZJJVVTZUkUBZtRAagkYhmpAgtrcxC3qimKIlKDUEEAKjKMcVE1wNgXVapyHcoXJnfgnOP6n1Wk3MzDl1juFKEKBAA3FRIsKVVj6SlOFmvo5U4UQvcEJ+xACCGEEEKrBca+CCGEEEJotcA+D6giUQBVkQmYum5zW5JlxjgBSgyBOpwalHLZgm6CLEtW1iplcznb4XAIgogDwCuFJEkCY6Zu2lSSJLH8QJRZXNU0mZuFbL7IJFkSbaJnM1ld9muyrCx3mtH9JQhUFCW7pJuMUlGSKOOEc6oosqZplpXMZGzCRVnm8XwunzekqEPTCMFzvCJQoKosMV7Udc65JElQXsaCi6LDoQFJZjKGaYmKSktmMZPJA3U4XSBgaxuqDBj7osrDOaESDbR0NgfOT5w6+PMf0asuwmzR4Yu0dDfE1q1rOPBu74Ff/FRKNqnmzIVTH40XYpu7m50+FWeHrQCcAIFgc1dTcPTkufd//pIx6BYZFyVXbfe6pkD7uvbw4OEzb778I2s0RPPTlz86FVe7d7XGgl6c3HcV4Zy7fKGmzm7XpUsH3nw9MxZ1ArcEb0NrWyDY2LG24dDJIz/+mXalLyyXRg4d6C3ILZ1djT4K2Kd0+XHORYc71NLd7nt34NCbr5HpZs22LdUTburodoY713QGX+9/7+ev2lMdPp7sO/DBkBls7WoPy7KA/blRRcDYF1UgzkERvVsefvGRwb9/98Of/MVZlyLahqu2e/fX/9evbd3z7HPnZn74wXs/6D/ioFAqGFrr9he/uL/L55dxrfVKwAmQmi1PPfZYcvIfDr36F2ffViijTmfzY/8kGtq74YnHH5+b+OF7b/zV+cOqbBaKlrvrka88tqsj4mQ4/ecqwpk70rbrqa9cvvi3x1773vG3FUkkpqPnyRd+7VvPde974auXJ1969yd/fVjVwMyVSHDbE08+trtVwbl9KwLn4ArX7Hj215/o/7tjr/3jhXedCrX1cNu2p7/e82T31qe/+dTQ9w+88eO+Aw7Z1otMaNr55Oce2uhTFbxzQZVhlca+QOm1EarLnRZ0K5wQqtXv/e1/vvZz30oXixYDoLLDF6nxeTTqffqf/etd35jPFIsWo6KsOAMBv9frkim2G1YGzglxtm3/8j9rffgbmaxuEgJUUn3RaMijyv5NX/i//e8PfSOTy5cYBRA1v8/vD3hUEZt9VxXOGHU3dj31x//v7clEtmQxToio+kLhiM8purd9+X/794+lkjnDZoyLmtPlCwW9LoVijV0ZOGOSFlr36B//X5sT8VzRsginotPlr4k6NNm57qE//JMNX0lkSrppE0HSHL6w3+fySFW4nDFaoVZj7MsZM4o5kwuipEgSpYBP0SoTSA5/yOkL1DKbcUKAABUo55yI7mDYHQjazOacAKVUoIThfUxlAVn1hOvcoVqbMUIIAKWUcE4IqJ5gzO2PMptxAkCpSIFzjgudrkJUkt3hmDsUsRnnnBAKFAA4IYLqranzRmsY45wTKgjlahoLSSUBQXWFHK5AmDPOytMaUoFwRojiDNS4/BHGysM0BEopcIa5hyrHqot9gQp6erb34I/OFuqauret7Yj6HKJIrq0UtqICKFi03An51DjjhAAVhGuvLMwpyQghlC6+zDi5ea23KnK7PKryvCs/nAYQbsg9Qj6Wq+VLYtXu6vJmU9Wf4+WYly4dAwULbyx9nVd3ISG3SXv1Zx8jQEEgi+c4J9cvpHD9HC+f8lW7m9WdR+hWVl3sSwC4VUgMHvvglPH+gYPRcDTa0Ny9bkNPe2MsqIkE6Aoq4Ywx27Zt217uhKA74Zzbtn3TXRfnvJx9y5UqdI9umX33beP2ohV1174SsXIb9hLlkoNVdOUDoB/PPlTVVl3syzkTHb7mHc8+4hgeHZoYvHr86qUzF8+fbaqvq6mN1Te3d7a1xEJOVaz6uzzG2LvvvpNOp7BirXAAkM1mJyYmmpqaAAgAcE6mpqauXLkyPj6+3KlDdwEAmUx2dHT0Pl8aAUgymXrppZdOnDgpy9L93DT6FOLx+Ozs7JYtWwkhAMS27eHh4R/+8IdHjx7FoKrCUUqHh0fi8TgOpl4xVl3sSxgTNX/LA7/WtDWVnhg5f+boiWPHTp778M2TJlF8tU0da9av3/Lws7u6YxGtWsfecM5lWd6/f/+VK1dSqdRyJwfdk9bW1u7ublXVOCexWGzjxo1DQ0PZbHa504XujjG2Z8/e5ubm8gq992eLwWBo3759IyMjxWJB13He1Eony3J3d3d3dxellBDa2Ni4efPmRCKRyWSWO2no7nw+b0dHezAYvLF/DqpWqy/2BeC2WczOx6emZ2ZnUzpIsqY6HG7JFa6pCzvM7Nj5/rG9PU21UW25k/ppMcZUVX3xxRcty1rutKB7BUAopaqqEsIbGhq+9KUvGYa53IlC9woAFEUBuE/XRcZYOBz+2te+Virp2GpYLQCIKEqCIABAZ2dXY2OjbWM7YtUAAEEQKMXJRlaCVRf7AqFmKTN6/OU33jj+0ZXZPFWcDo+rbuOu7s27d+5eW2sWZyeSctArV3fpBgBNq9rgfbUCgGu1qiwriqIub3pQJQMAUZRcLuztUDXKQ6auPTd3OJzLmx70SS2tolFVW3WxL6FglwpzQ5dHc8TZunPX1i2b1nU0xwJeh6YqiiRwFqitJ5IgVGuHB0IIAFiWNT4+nsmkFwdNowrHRVGKRCI+n49Smkql4vF4qVTCerZKcEEQ6+rqvF7v/dkeABQKhfHxcV0vYRmpCpxzh8MRiUTcbjdjLJlMJhJxXTeWO13oHnFN0+rq6lVVxTkfVoDVF/syJmi+pl1f+eYuj+bw+rxup1NVREEAwoEAFURBvF999n5VAKBYLH7nO3996dIlv99f3TuzCgCQ8iXw4YcfefHFF71e79WrV1555dWxsVFFUZY7deguAIhpmqWS8Tu/8zv79u0ThPuxbCuldHx8/E//9P+XyWRlWf5Vbw59dtls1u/3P/fc848//rht25cvX/rJT36SSqUUpcofMq4C5eHIwWDg93//D7u6upZO24iq1KqLfTnnoqKE6uvt6UQ6NT2RnOKcEMI5qIov0twUdstita89AwC2bU9NTW/duu25554zzWruNgrlhuvrS5nya03ZfPElWDIjaBWilE5PTx89erRYLJa7aBcKRVmW9+zZs2PHzuVO3WcCQK5N17rwn8UWk2uZBR97pbpQSuPx+e9852/y+dx92ygAlEqlUkl/6qmnOzs770/A/SuyWABusVzxiikkhJDe3t7e3supVKq8nmipVFJV9Zlnnunp6anqXr83n+NLLGQWfKzGrjaiKH700dGPPvrINA3OedX3fFiJqxl8Uqsu9gXK9dTkhde/+/qJ8enC4nnLmS3H6jY8/o2v+p2KKKyIAkEpbWlp2b59u2FU6WM1TshCE3x5ovR7e85Ufc+jKKWjo6Ojo6PXkg4AHo+nra1927Zty5u2z6J8V3m73Lvl9aP6Mm/h1mXK5/Pe/8RrmtbZ2bllyxZJkqrvOsYJAc7JwrKatyol5Wj4hpJSjSWkTBTFeHz+WvoppR6Pp6enZ9u27dU4DWW5diYEPmENDddD4eohSVIikTh//kL1Fr+lOGN8aTsEIdV8Yn1Kqy32BaC2WYqPnD15/pIQ3Lq1s97vIJxwxsRAoN7vEFfUguO2bZumWc3tvpaZSczOJ1NFkwiy4g7UBNyanphIlLgrFA54HCIBu1TIzM/ES4KvPuJTVbHqQgBCKbUsizG29FFaed77as474HYpl5yLJ9J5k1BRdQfDAa9kJGYTeXAEwlGvSim1zVJ6diJekn2RsM9djbm3kH3LEnouLSTVF/sSQoBw2yim52bnMnmTEUFz+/xhn2TnE7MJUwk2RryyLHLO8+m5eDwLWiAS81VrL6DyOb70Fc65ZVmmaVZj7EsIIYQTq5Scm4qnC7pNRMXtDdZ4NKsYn0rqjkBN0OtURUKsQio5F89wp6825JMFoTpbf1fG8jEAzCgkJnr7p3Nc8AQ9TlmmhBNORVVz+RwyCAKVZFkQVv5Ebqsp9gWgVBBFQXN4QjUh17DYuvu5z+9f06ReG9ZGBUmk1V++VwbO8xPHf3Hggwv9OSq7VIVzLdjYvWX/xuL7P317BNY/+fxjW1slTq3kzKW3f/j6Fc8jf/T8zvp6t4UZWAlYbuj8kQ/ePXI1RVSPQ+LU6Yx17324IXfoZ+9fFZsfevHLO+spUDMf7zvw/Veu1u/9/FMPbaoTLcy8VQPAyoyNnnrjtQ9H5i1VU2RJAq1u/Y51ddrYBz99Z6Lxxf/52a3hsGhzMn3l0M/fOS82PPm5r+2sWWXtUxWKkv8/e/8dJddxJgi+8UVckze9Ke8NysIUUPAgLEGAVnQSSVGupZZpN6537Ns977y3u+esedO9M2+ne+a1VU9LLTUlSiJFEiRBA0t4b6tQhfLeZaXPvCa+90cCIGhBkerKvJnxO6dPsy5KJyPri4j73bhhjNRc/8l9bxwbCOuy5nJIxPJXtK5d1e2Ye/cnb04s3/vsni1tDgmZPtd39rU3TiSW7/3+Q92Kk9ky9S0MANTMxIYvv/GP7/THdU/I61RVCoQCUxxOl19zqM7Sjs3bVzVXeKh9F/t/NkWU+0JqbnR4sH88lknMjkT0RGau//zJYzg74kKOyKnLXVrf0VbhVSUQ2VOOARDdivWffOnHL5zmwXU7NjWEHEaCOohpZPSpK8cOXpSUru07gQIBnlwcufTe/vcqlv3OrrUAHzNpUFhiAAQjfQfffPEXrw+XrHlgY2OJanEJ0SQ8NnX1vcOntEjzA1/ZQACAp2NTVw68ebKrfMv2rcX21q24UZqOjJ498A8//Onoso33ra0p9ciQtGSw0tG5m+cOvXG5a93v7VpNASyC0alrJ987KK9YuRcJUJtPtiwEQDG9OHPlzR/95Ytj9RvWbawr8TEjLslo6on50YtvvdkDLbu3bQAAQs3YeP/pwwfn2cpvPWABAXuO+xYGJECZwxUoLSlT4ygxYqUTkYWp8cmZcDTDCbg8K5+tXtXaUOlVbDy1/jMpptw3NnL90C/+bt+1qHnrBdPMqZd/fhqAEILcVOvq1j/1z+tCHk0Gq8Cjnu8AiKlbc5fPX5nBpq99+Ts/eLxN5hwJMJqaic5yy+IfmpvCbbwlXcEBgoiTV8/0jmSqtj73vX/xQKciIRICJsHRUW5ZHz4XlHMuWlyxAaCLc+PXz5yOB556/tvf3d5dpZkcCVA5dvnAKfzINAAu2nj+AAAzvjB55dy5hdoH//hb331qXQOYSAgwKXrzWC//6OI9Eb18gMglh3/Zxuf+cGUqHosuhhfmZ8ZuXD2TTiZN7nEFS2pqlteWuVU7zj37TRVR7ouu8vqVWx/GhjhHoLeGmDjniIjIuRQM1Ff7FQbiNpwPkGM6neacqZoqaxQsQoHcDht8ZF5+0U3Uz3t6Jm0QImsOB6WUUsTskYpERE+4zTItI5OhDodDkSSglBK8XTs+tpKIWpJHOOeZdJqg5nDKikqpSZHc3UN/6NdF9PIDApVUzWUlJs5feu/48fOD03Gdyq5A25b13Zu3dLU1VgX9bpUVQRZUTLmvVlbftS3UGIslU0Z2ZBeY7NA0h6pKlBBKZYfTIeb75o3sq7HsuDxm33Ki6D/tBAjAreCJViV8vNv7A9yuJaKJ20Z2r4Dbu2Xd3tZFyG9AqKUnhk+/+vY7V4f5svYN9+/a0d1WUxr0et2aqkhg03Wzv6kiyn0JyAokF/uPvPTS4b5IxuAAsrd+82MP3r9pfb2bEkQsjpgLgiAIglCUkHM9GY0nUjE9Eo2kDeryBAJB563T0YskCSqq3Jcvjlw5d+CVQxfnleqGkKZHxq6dftXp8YVqalZXgBhTtK3iaKuCIAi2YsO9fAsdEs4cnpYdzz+nnX/v7LWRwQMv//XVo2UVVc0da7q7ljdWBpyKVPA7nBVV7guQjs6MDg8lsGbrI8/vavVkZo+9+PLh0ZHhifnk6nIXoSKJyiOQfRXKkSPhd00CpCApEphoWJwDAAHO0TQzRJZlKjZ5yB9AKckOIcDtmZoASCRJpgxMyzQNAAdwRN00EGVZZlScE1psgAAwQm5Nbro9JZRJkiQpiIaRIcgBKOiWaVrIHLIsEyLaeH64FS+OPHvS2a0emlKQJRkyhmlxpAAI3LIMbhJZlsU2PLkGwE09uTgzm5Arq9voBsVXPjo81H9z4PS1S1eu9F670ta146Hdq1sq3XKhT/ktotyXEMPQMynT667uWrd54wqPOZs4eezS1bRhmCZjDBlyq9DjbRuMQbCmOqBeGLhw4cyJGisgm2lOJNlTFqpoqnO+e+rMocOHypU2tzF68u0jfTPQeH+N6nGK8OUBJEBIqLI65Lhx5dqpY6dCVqnDsrjJ5bJaT2lDZemxi5ePHXitjncFrMnLbxy+FmFV9RVBryaiV1zcHl95dWXmxuUTp8+7SYOXkZROPEGfw1teXae91XPk1wcrdsZqpei1t987O2EEt9dVesUwYj5AQmTVGaqq9tML10+fP1OppLxgpCymej1eZ0V9rfzOpWPvHq1xJJrUxf4jh4+PGsrKmhpZUnJd8uIGhFqZ6PDF118+ORyNcUoB0EhmDMvUE6nY4LWZsf45f2t3S0OVRy70h5Siyn0JIQAko0fHh3quEacZGQ3H05nMwsRQzxXFrzjcgYoKnyYxsb9vjiFHqkgly7c8sHPq8PjY2bf3z/kUbireysY1e0M1G/Y8cC15aqr32H5jyGXNDt1MVa1/aO/WNp9fEc8u+QCRQOnyHVu3RaOXh86/+3Y0qCBxqKGmzSXd1Wt3PzCkv9F37ehbmWm/NT/SEynZ+NCejSuqfTLnNj3eSvjNIefuUN2aHY9vmzw3dPn4u+E+pyxxOdSxuntNY8d9D36p95WBy2cPGXNlELvZP+9avmnX9vUNboBimY+Y1zinWqB69QNP7Imcm758+q3FCS/lpitUv7J7R23zlscfu/7mjcEzR9+c7pfDk0Nh1rpzzwOrGzSFiSU1OQUEkRuZ2GIkHElIHk2VJaZ5q5Ytr2oBJsuy01ndVu11sCKIUnHlvohIMgvh2UOv/qjXLXF9ZmB4NmFmjrwau+F1lVd07vjK02vqvYwVftzzHjImVa9/9vcrV14+fenmWCRtSJrLW14RcDi9Hbt/8K9a77t06vLAWCTjalj36J61a9a2VrtlGcUekvlCrd368Lfqmi+cu9I/MZ82mSr5y0s9DjXU+eiXS1csv3j+at/4gq6Vr356++o1Xa1VAU22RPSKCVrMVdW17Xf+Q+Xq8+d7JhaSpkF9IV8g6HOFAlu+9K/q2y6eP98zEU5ZJasf29jZtbqjtszFROabH5DLXm/r3u//28Zz5872ji3EMlzxuLzlpV5naVn3s/+2ouvc+TO9Y4uxTE3Ltu1Pru9aWRdyybTQBxPzHCJnqrd+1WPfrE0axFni82gOiRCgVFZkxeFWGWS3qSuCQaRiyn2Rqp7Syvq6+mnEVDxOCKolFXUhpAxSkSh3e1LmhzfdF3IHCVCtrHrl9tK2zSZHAkCZrCiKxAho5dVdOx7tuM/kCJQxSVEUMVyfbyQtUL98a2XrRtNCAkCprKiyxBC0YMPKrVXtG00L3w+qiF7xQQRZ8dS2bixv6LYsjgQok2RFkYGC7K1r21jRuNayOAKVbjVxMeMhfyACU7TKtvV7Glebt6LHZFWRKSVUq2zfUNK4xuQcKZUkWZFlJhLf3ENkkuwOlQaNqenZ8Hh8gVIgIDu9JRVVlR6gRXRoYhHlvojOilV7nm7c/JDxfnABILuxGYKkODx+t1xgx1gD2HpPeCapkqw679pDEm9fd8oq3No+1uZ7031KgOwcOwJMUj4uenB3VO2/+W/Om1jOC/CFgCQ7ZMVxZ5Pf240ZJFmTFVIgbfxT2Dt8THY4Pz56t6Oavb/aO3o2DtCHAPD04viZl3/86zM35+K6iUgBqKesbcsj33x+e73mkgvlm95LEeW+hFDZ6Qu6/MGP+zcgBAliAQ31460D6zgXo9l576MZ4J3w5apIwmeXPR5y6T/37jZu8+yi8H1KGxfNPM/dPv/V7k0MKNXjscELB4/1jvLKWuf4eIQ7fX41M3zl/BvHNqwpb3criv2/5mdSVLkvKazk9tMAAGPs/PlzmuYwTTPXxRE+DQAsLi4ODQ02NDTeuTI7O3vs2HvRaCS3ZRPuCQAikcj09PQS3zMAIJlMHj58aGDgJmNig7h8NzExOT09VVZWnv0REaenp999993BwUGR++Y5xtjVq1fj8Zjd80KAdCY1NTxq8qr19683jxv9s+Uda6oyPQd7ZgcmFsxlJaAUSVdSZLnvbXdeYdi9Kn8sRJQkadWqVVNTk2NjYwX5HQuMYRiBQKCysjK7g2lpaWlDQ/3MzMzk5GSuiybcm67rbW3tVVVVlNKlaW6I6PV6Ozs7DcOYmpqitAg2o7c5Xc+UlpZWVFRkByZKS8saGhp0XR8fH8910YR7yM5L6ezs9Pl8AHaeEgscMZMxJPCWlQfiHkWeZ5LELEBE5JZtv9bnUHS5L1Cmx2YHz759bcHpq+1oa6kr9ztUeuelRq7L99uAiKqq7t27NxqNEHGujk0wxgKBgKZphJDa2to9e/bGYrFcF0r4TLJPm7W1tUt2X+Scl5aWPv74E6lUsjB6rYKHiIqilJSEGGOI2NjY+NhjX0qlUoUzl7SgIaLL5Swvr7D3cybKjLk9TgOj4XDKSlqR0csnU/1WgoSa2+sDilQ8m1wVXe5LAKx0dPTsqy+dTksVXStXtNZXl1VWVFVWVZaFPE4JCmBiBCIyxpqamkSvai93Jvi63W6PxyPCZy9LOekWETVNa2trW5qPE35bspUEAHw+n9/vF23cXmw+sR45qg5PU9eOLSTVEChL17WGZ60FWXO3ta/dtKkhqEp2HtP+zRRf7otccniql29eGekdmRq68PaFIxnqrWzvXLOqs6WmIhgsLS0LBtyazKidOyXO+dTUZCwWz3VBhM9KkiSfz+f1eiVJSiQS4XA4lUoVTUdke5IklZSUuN3upclmACCdTs/NzYlKYiOyLPt8vux780QiPj+/kMlkcl0o4bNSVSUUCmma075Dv8iZ6q5b9eCXm0ymGouqq7p5FXH4gqVV5WU+SS2m7bOLLvdFziVnsGXXt39/cyI+OXrt4uHjR0+dv370zZ7j7zg8wYr65evu27J71+qGkqDCbbrdGaU0mUzu2/f6yMiI1+sRt8b8ZxgmAFm1atXWrds8Hs/o6MjRo0enpqYcDkeuiybcm2lahqE//PDDq1evkSRpCVocpXR+fv6VV15ZXAxLkiSGD/OfruuKoqxdu3br1m2IZGBg4J133kkmk6qq5rpowj0AQCqVcrlce/fubWlpzc5ayXWhPg8A00jPDV863T+XSnNEjhwJHR8aHC0NNazY1lHuUiWbv/b+rIou9yWEIEFumZZummgBkSRJYTKj6HA4nXJyov/su3LVyrqyspBi47W3pmlevHjR5XK1traapjgpNq9RCgsLC729vf39/evXr/d4PNFobHp6GgCam5flunTCPVAKkUjknXfenZubW7IcFACi0WhPz/Xa2tr6+gZZlm16My4e09NTIyMjIyMj2ffms7OzIyMjDQ0NDQ0Ndh1lKRqM0b6+vqGhoVjM1ls9AAA3UrPDZw4eujEfthgFIFYmFY8lfG3tD9euay51O0iRHEFSdLkvUGrE528c/cmbb125NhGNp1O6qTjr1m1fv27ziuU1PtNILqZdpT7JxrvOZBfc6Lq+evXqPXv26rqe6xJ9bgDwoV05EMmtH9/vg7Kbw9t2mjaldGpqyjCMTCaTvQsiclVVa2vrdu/enevSfQEAcNeu8B+M3vvhA4Db22vbMn6U0pmZ6RMnTlrWkj5kcs6z27l0d69VVdWmf72PqyW3Lt/VogthY57+/r5UKpWtJNmZ/X6/f+3atWvWdC9xzflt+pg2TgiQ7JkWhdLEiSRJTqdzamrK5mvHkXPJ4Wtc+9R36xKGSYAQwmcvHdn/2jvTusPlJpTaNECfQ9HlvgSolY5P95zvHU+b5Z2bVne21VWVlZWVlJaUBX2aTIiZyZgSs//APwA4nU6fz2fj3Bc5tyzT4hyREABKJUmiaJkWJ1SSGL11mpBlmRYnTJaoLd/9ZueoaJpmGMadi4wxTXP4fL4cFuwLQm5ZlnUregQok5hEgZuWhYRJUnZGPSLnpmkRyhiz5xx7Smk6nZKkHGyLSSl1uVw+n8/GuS9y0zTvVBJgTGIU0DJNpJLMbh1jzC3T4pxk/zXHBf68PB7P3dMbAECWZY/H4/P5bJv7InLrruhRSiVJIsSyzA/00NyyLIsDkxilduyhs7mvy77TfN+HwBRPSUNrgHPM5vH1LDx07eLg4uzIRMQsD4AE9uxIflPFl/uiSZjkqepev8MfXNm9pr2xJuBUJQqY3eSMEMnhWIoJe0vB3ocGIerhmz1nTr13cWAylkGm+OtW3LdlW4dxbt+JCVi2acfGjiongczcxLUTbx8Zdm9+buvysnKnZcf3hx+7fNjm57qlw6PXzh87frF/OpwhoAQqlt93//YVjsF9x69EldZdOzc1hBizkgtjF9567QRv3LNtY1dtwLLl981hmOx8rhtQnkpM95197/jZGxMLKQtlT3nn+h3rGrTJcwdOTlfe//Wt7YGAyjmO9xw6eqqfVmy5f+/yEmrPBTkfjdGd2NmxmQMQS0+E+08fPXH22mg4ZaKk1Tav2bllvdu8evCNs9qKx7ata6/wcgKLQ9dPHj046u7a82B3jdNpw7my9mxfHwVAzdTC4MXX958djyV4dvQhPntzdD6leMOxDOcI9h7Z/uyKL/clIDHm1FgsOoMZSXW4PCqzskMOnFsWL5RNfm0OLG6Nn33pRz8/NBoPVNdVuWVCZGIk48n05PHXf3WJ3l/ZuWZ5tQupFZ3tPfLqC8fL/Q+uaKmocNp0BKXQpIaPvfPir/ddirsbGqpdCmEK6ind1BevvrP/5UltT9vaDfUhGbgem7701s9/bG5raOvsrg/a8slF+DyAmbGxS8d+/sOfnDV9NTVlfo8kU2KZemQ2fOnASz+5srL2idXNoaCDEz43dHr/qwfkjvJ1e5aX5LrgAiEEqBFd7H337/765+eTgfKqynI3JQDcSCeTmZmz+174B3+6a3lHZ6UXgSYmB0/s+/mZMrJyx4oql4uJO2zOAHBLj84O9964EV60KBDCU5Hw3JxR1t3a2eRTJFo0sSnC3JcRxEy07/LJ3sVxJPODbSWqxTkyl6ukrq2lzKdKINpmjlHgKWvh8tH9By+kNn/5m995dkNINjOWRQyDyxOZVColmRa/NfcKOddTqVTGyM6MKJap+nkMgPDZyweOHDo/WfvcP/vG0/eVady0dN3UvGqvnk6n0sy4k+MiGpl0ytRF1ltcgNL43PC5Ay8dutnyR//2mce2NPsZSaV02ZUZvmDpqWRKt5Bnmzhwy0inUlzPHjwl2njOUcqT8xMX3nrprbH6333mqWe3rfJSI61bIAEfm9HTqWTmdosGgpalp1MpXUcRt9xC5Ez1VLfvesK1Op1BSgjBcN/5945cSmmeUr+TMopov3cQn0sR5r6EI08bpmSmI+ff+FX/IYfMALml1tauf+oPagMeRxEdbZKngBDT5DOTU3Hd29zW0txa7jM5EgKMpqYjEt619uXW/+DWYgohHwBBJAvTk2FTrWju7GgoDSgSZle5oSVlF8LAB37flnMAhS8qEY/NTs04yh5buayuqiyoWNznByrHJoES8uFVRaKJ5xEgRM+kZqemk7yhrbO5qanMZ5joI0AlfWqSkg83cRG+PIHIZK2ybUt1++1bKE1c96an+t9YuNk3mlzt9jtVe04p+o0VYe6LhDCHu2pZlyOYppTeHjqUy8qqvM4CmMwuCIIgCILwQQDc1OOzQ5MLScNEIIQAn5yIpM14anFqPmrxciBFkgMVXe6LnMvu0uUP/l7jDkM3br9nBcokVdU0lyYz8epVEARBEISCkl3rduPY3//1mzcWwmZ2Yx1LTyYSWl29S5FsudHO51R0uS8hCJQpqpaJzc2NzUVSJgJhrlBJRV1tUJWK5JFHEARBEIRigghUcfnrljVDLM6zr7kBqeqraV+9ZWWFJtOiGfsrvtwXKKYXJi6+/vNfn+ydilu3TkWgztpV3Q995ak1JV5VLEPND7c2783uwQFw60p2J3W8cz37O/jhGcBCHkByd/Sy84AB7mx7n50CiMg53gqtUIxu7awDdzdhgDtHI9yuLx+d5i/k1p3O9/0eOnsdgJBbu4Ld2uBXRC8vIEFJ9dStevArtfGMad3KdJDKDpe/pNTnlItoFWnR5b5AMZOY6z9x4NzVuG/1xtWNpV6Ij189fenSqfecnRvaNzs1WRJLznMLCaEUXC43Y0YqntKThKi3/oEx8AV9UmpmIRyNGxBSjFQiMhdeJP5On6SKg13zhup0KgSTiUTq/U3nAAi4fD4nDEfnFxZSZJkDTSM2N7uYcdd4nJomoldcJFl2aJo1kUhm7t7XWXM6fV4fGtPTU0m9moDE5xbmw9GMs8Hv9QApottz3kJCGJNcTifQeCJm6BlCske7AJFlxefzSXRqfiaeiBPqxnh8cXYuSuV2v59KTIQvl5BQRiWFhwfOnL42upDkBAiAo6yuo3vbtpAmEwmKJT7FlvsCgKGn58aGF7m/a/PDTzy4psaH6aHDYE3vP983NGOsbyy+P0r+QUIVFlq5bm3txWP7f/R/TV6sdzNTV4JVbVufvq9649aVR144/8J//d+uH6hS+dxAX+8odjy0vs0X0Iqk2eY3JECgauWmrobR1w7+3f83fabezTiqSmnX3sc21K3curZ56BdH//Y/J862BVhydrj3UqRk01OrGiv84pGziCByf2nNio1by88d//s/i71XF9IY6lJN96atG5pauu9bffSXr/+nPx1uqg1I6fErF26YofXru5u9IDY4yweI1B2s6Np8X/V/v/Tz//IfLzVVO9HUPeXN63Y+0VyyevO2+r+9+MJ/+Y+X3qjz8sjw5atDct1961eVORxUPODmEgBmYhNX3vrZr/ddHrbcbrfmsOLhqHGyb2rRXf71taV+LXvcQeErtjQPCQIhlDJAnknGo4vhRcRUNJ5Kc0CJ5eBYUuFjIBKZuVo2fOnLc/LxMyOR6ekE45aTetNclkq6dj35laTr1MWZhckpYKYSWL5n887HNjV4PJIdD0gqPIiE+Fu23/9kJv3G6cHw7EyCctDcjrRuEXfTll1PJJLa8b7ozHRGsnS1ctPj6x7Z2V3vV0X0ignnmq92zY7nnp945fxwLDw9HZUIat5k2nSVNG9+6FvTyXd6R2MLUzoxrbKmzau2PbR9dZVMRO6UD5CD6g8t3/381+dePz82HZ6ajgM3La1CN2Wfv+P+57626D15czw2PZ2wDFbZdv+a+x7c0OJWCuXIVJsCoKlUbOjyyd5JZdnG7ZtX1QVUa3bgzJHD1/pOnr758IqAxymJPc4KExJZdZXXLyvV+i4ffY3NXCrxk8jEjWt9cV/FhmXlqixem+cLUMrXfPk7Kx59NpVO6SYBWVI1r1OhFHzbvvEHm76SSKaThkklVXV6XHJ2jpkIXb5AtWb5g99q3f5MKpXWOQHKVKdHUyRGSdsD31y27SvpVCJlAmWy5nGpEqMiesUGLeqsqN/y7X+3/tlYImNYnBBZdWqaU5GIt/PBf9G2KxVLZkyLg6w5NYemiKGJPILIVH/Lxt/5n7qfiSUzumkhVRyq0+OUCEDz2uf/TddTsVRaz5hEUh0Op9shiQn9uQeQMYyFhUWFVq/bvvvh7R0hic9eYeGx3lP9c+GIZVkARZL8Fl/uy4niCrVseWjj1MGrk1PjfbNThJs80Li+a/OOzgqHbMPDxj8NANh5iQEQRXPJmjN7YhsQemtBxV3Xbf4NyafGyObfTFI0t+xwvb8s8fb/kxyaS3U4CyF6JLffAMDmf0MAprp8iuv91au3lk0xSXX5VdedVZH2/YqfAm7LdUE+JwBQXF7FeXst2+1vAgCy5pW1AomezYv/PkRFlnwBP8f5m1cvndcSQRVne3tHpg3JWRJwMlo8c1KKLvclyAlzhVp3PvP9FTsXExmTE0JA1pzeQDDg1iRaSJHnnFuWZVnWvX/VBpAg+ZhvYv+2ioiWZX3oeyBiNny5KtVv2SeEyf7RI4homjwnXyT70dk2XgB/SfJJ9aEgvhvnH64knHPTNAumi/6kKBVA9ACgICZkIXLN4Wnq7K44f/DCmz++/C6jQLiZMdXa1ZtWN5eoCiOkAL7nZ1F8uS8hBA09MT8zOTEdSRnZA+MByMz8bKi6pbXCp8gFk//Oz88PDQ3pup7rggifhlI6Ozu7uBi5PbgAhJB0Oj07Ozc0NJTLkgmfAaV0bm4ulUov/diQYZiTk5NDQ0OqqhZAhlHYpqamE4mkpmnZHxExmUxOTEwMDQ0VRu5bwCRJmp2dNU3T7q0MOSje6q5HvyeVnT7TN72Qsihhaqh+2Zq1m1eXelTKi2bmWdHlvkBJOjx69hd/9fKZqTmdSYwRggS5pVRVr9r7zdoSryrbfR0xIjLGSkpKzp49MzY2hlgkD3L2Bbqe0XVj1apVjDEA4nA4DMM4ceJEX9+NXJdNuCfIZDKZTFpVtSX7SER0OFSHw3Ho0MHTp09RcRh73kulUgDQ0FAPAJRSp9OVSCT27dt35MhRsXVF3oNIJOJwqPZvaByorJUs69xSUtWVzlgIBKjqcnt9AZWyApnZ8ZkUW+4LQA09NTd8tWdgUKvetXVVQ6mbcEKQM6+vstKnMLB/L4SIDofjK1/58uTkVK7LInxWiqJUVVW53W5ErK2te+yxL83Nzdl9mKFooKo62tvbAWBpQsY5Lysrf+aZZxYWFgribWxRcDqddXV1jDFCSEtLy1e/+nw0Gs11oYTPCD0eb2NjoyTZeLMKoFYmPjd08crIYkbH22+qEC3V66lq27CsxKUybttv9xspttwXCUqMuVweTXNXtGx44MH7WiqpxQkhSAhQJjGwf+ARUZKkNWu6u7uL6TnO/jjn2TwmGAyWlJQUzAKLIgCE4J3wLQFE9Hg8GzduXJqPE35b7lSSsrKyysrKbM3JdaGEz8rmE+sBgOux0StvvvBGz8KiRYEQAEYpJaWtLbuCq+oDbgcrkvpYbLkvQZRULVjbXKH2RSdHpyYnAqqTcyQITFI0j8+l0EI42AQRY7GYZZk2bqdFhlJQVYckSQCQyWR0XUcskifwQgAAmuaQJHnJPtEwjFgsWjzz8+wOgEiSpCi33psbhpHJZMSYvV0AIGOSpjntPCSBSChT/VVtXV2ueJwDEJ6aHei/fn0MS+qZE2381X5jxZf7Ek6Ay4qC+vilA6+Q0XMVbuDIuRwMNXTvvr+90qXaPfnNJk/vvffe5OSELC/dzVj43DjnkiS1tbW1t3eoqjoxMXHt2tVwOGz/6WVFAZETAps2bWpqal6aT6SULiwsvPfe0ews0qX5UOGL0HXd5/OtWLGyqamJcz42NnrhwoVEIsHEkUp2kA3ftm3bgsGQfVscWpLmb9n0tdbNty5Y0ZuHXn/xZwenymr9TqBQPMMtRZf7UmomkvMD1wZjcSJr4fmpTIwgIreUyoTWlrYQ7f8OilKq6/q+ffvC4YWWlhYxtJD/4vH43Nzc4mKkvr7B4XCMj48fPnwkFotWVFTkumjCvSWTyd7eG6FQqKGhkbGl2CKcUjo/P/faa696vX6fz0epXW/GxWNycpJzblm8vr6ecz44OLh//35FUUpKSnJdNOEeAGB0dDSTyTQ2Nvn9AVtP+b0DgAJlvrrOtdv2pC5EU4kFiwexWI62KLrcFwjhnKdTSWRKw5onvvbA2voymp3zICkOX8gpF8B8X5L9kun09u07nn/+efvucXavx2u8vaP6B6/YDaV0fHz8rbfeopRlH1RM0ywpKdm8efPOnTtzXbrP77OEz/7RI5TSmZmZP/mT/2ia5lJ+rmlaDof2xBNPrFy50r4348/Uxu/6LZt+TULI5cuXT548ke2Ns7t3V1RU7N69e/XqNXbd4wwIfPphbQXSQxNZlg8cOPD66/sIQXt+A0I+GAjkhp5OJRLJRHwumswYoM/GdIpIxf6+BQqRq6paWlnvloYXw0nKZH/Qwy0kBBiVVRmgAPZ5yAIAl8sVCARsm/siASCcWxbnnCMAAJMYIYicIwKllAIhQDhHzjkhwBi9d2+chyilsVhM07Q7MxwAQJKkbPhyW7YvCLnFLW5hNnqMZp89kWSjBwQQOecckQBl1J7nW1FKM5m0oihLX3rGmNvt9vl8iqLY75aMhAASAgS5aVl4u1EzSpBzjtkWnf2jcm4hR0IolWw7wu31eh0Ox51KAgCyLHs8nkAgYMfcF7P7kAPhlsmtO42aQbaDJgQooxSAYDbRRwJAKbVjB02ILMtut1uSZFv2UFnczOi6gVRiFI1UPDw2cvX8yRPnrg3PhBPptKepetsGRBvG5vMqttyXEAJAFdWpEmvi+us//MvTHpdMkHNLrahcvvvZL6+p96qsUJaPZDsd28554GYmGpmcGJmcC6dNYKozUNFQU+FPjVwdiWJJY1NdeUAhxIxHpwd7h6JK9ermKo9HseWEJcSPGU7Ihi8n5fkt4GY6vjA9MTY9E0laBGSXv7K2tsqZHu0fDVN/TVNLlZdRaqTi0wNXBqPOqmVNNWUexZ5NL4d5Z7bmfPTMMHvgpp4Kz06MjU9HkzonzOkrr66v0DA82jea9DR0N1VoTgURw1M3B4dnmbe+uaPKnetCf06f0sbt2cyRW0Y6Mjc2NjK7mMxYRHYEQtVN5QErPnx9OBGob22oDLoUAnpkcvzm0KQVrF3ZWOGQZRvWVLu2r/cBnb9x9r2jh0alqko/GTp9dWh6NpxIpIlcUte2fc2qjo6m9maPQ7Ll7fNzKcLcF5FKsr92WZsyH+eIRkYnBLlFTd00iyfw+Q4QzcW+t/7uF29cGSaBknKfZmWUYG3b+kc2pw784pd9dOMz3yivDDkQzMWpq2//7CeXA0//z18P+Xwqt0QM84AVvvLeK6+8dGjY8JdVBVQkmlLa/sBjzdHDL/76itL22LebK70SpWZivu/g3//tleZHvvNsWYVP4fYbABM+H6BEn+m/8vaP/vu7Uxl3WYlXUyRDrlyzeVW9e+iNH780sOzby54PudyqZeF035GXXjolNz/znbYqDyuSCYl5DSimoxNnX/3rfzg4zpVgSalHstKe8tb42vtcM/v/5oWh9c/8IFRS4lYJ1ed6T7/y83eja59pqi7R7PiGoiBgJjkzeOXwwBkGJDwxn5KdjRu2PbJpXVdLc011ecDj0hjaPcP/TRRf7oucaf6GjU9/dbllIqW3Huk4YZrDE6rUJFo0sc9jAFbGWLh0+JXXj002dn/p/t2dPtnMEMXtK6Xs2kjv1R6pNpziBAgB1BNzIz2XLldsT2csENtl5gEAgtOX3nrnjaM32KbHd2/vCiiWxVD2VLhxfKT3eo+mbslk53GimQ6PXb10XVoT0XnxvG8TCAEamx08+eY/vnHW9ehz929ZVeNmJGM5yut8qZGZwWvnLymP6zpSQixCkovj/T3XZGlRJ0RsiZsHAKzE3PiZN3766+vanqcf3r16mYuYaaoFqvx8vGfo4oWeqh1xgwMhSHk6PD1w/epc5QOmLce3CwKit2H5jie/UzE0NjY0eEO+cWNmMTI5dP0cLk6M1DY2dbR21teVeOw7peg3VnS5LyKRZMUXDC1OXx+dWkyY6KtrqfK5zMXFOeavLKoN7vIWAEEDw0OD4wm5fsO2PY8/1EotTghQSIyH+wCA0rsCBUBvTf4V8gEQRJwbuTm+iBX373zosd3tMkMkBAxuDF2GW9P+3v/125N/hWICAInIwtjNfiv4jfv37Nm2ptJhcEKASJELY4x+sJKAaON5BQDMVHxhuH8kXf349t17v7S2jhsIBChb7JmRgFIKH+mhRRPPJdSCVZ1bqtrXJucnBm5c7r02ODwxNTk1eO3oxZPUV9a1acuux7+yvsLrlIpky/Ciy30JgJlaHDn10s9e2H9meHExadTtfGZbayB+6VRPyZf+5Q+2tqiaGPrNPUQ0TIMgSAwQDMPIrn2hXIz42AM3TaSESQCGYWYP+gVLvKwW7sI5cm5RhVHkXDdNiyMBCsVx67U7RDRMkxJVYhzRME0TCQFWLLsE2A8ityxCJEewrnNzXedGU48vTA1fv37l+vWeoTEeH5+NGFZZ8TyfFF3uSylPxiavvXfo6pxUtbzVOzquoiZRCvHpxfj4rGE2ADjELVoQBEEQhMKDhICkuEtqOu6rbFl/X2JxIZJKQMCtsOJZ8lRsuS8QyJh6eH7OIv6unQ9UDb17YIQTAoSbBjcyRhFN9RYEQRAEoSgBZRJjkqw4nO7Ara2YiycBKrbclxBklKqaA8h0eCHqSxqWyefCs9p8XIKgyyHOkM0jeOv/gNza+PX2FDIk2R3TAW79k3hkyUPZkMCtOBFCPjDfDwAguz+zmMVSzLItF25VlOx/36oneOf6+7uOFs8rWTu40+3Ch3pocruHpkCyM39RNPO88X6X/P6V98/VRiyOsd9iy30RUVad5U2dda7hgXdfHtJjMQNOzY1QrpTXdLVVKbbcfbAAARBJURhwPZlOJTI6RUQCjHJKnG4XM5LRaCyWzjgB4rF4JJUEl9OVPfki1yUXCCGESIrKKDEyqWRa1wlHJAicUdXhUhyQTkQj4XQmSIx0YiGasNDpciqykusyC0uLMiarDgxnUqlMRtfB4hwJQ5BVzekmZiI6n0iWZxzEjERi8TRX3S6nSoho43kBKJUUhZJMJpFOJ3WdmMgJMERJ0pwumozHovF4JuMgejwWjWYM6nI6KaUiejmGiJaRzpgcP25ePQCTFEVmRbAwsdhyX4KcyO7yZTueeoq+d+ry+GLaIgSZq6yyc+OmbW1lmkSL46EnryESJtOy5uZK99n+U8cO1vvjZQ4jZYHiKGttqO5o87/1xvE39tU6jeV+Y+j4/rd6F9SO1ganzymClweQAIHy+mXV3p4jFw7uf8eRqHKaBprE0dBRXdnaWH300Pl3X/lJILGxzBg7/8qbl+OuFa21ZX6tSBYYC4QQgoheX6h2WRO/dPbtA82QaPQrNJGGUGVFIFDd1BJ49dT+f3jV9cD6Bnnx3CtvnZji9euX1fkoiNUYuYeIsuapaFpW5Xj74pGjBz36yiAz4hZzlVQ0uGpbW9yvn3v316/7jLWtzpmeA28eGqXuHc0NiqyI8d9cAkrNxMLgxTf2nx+LxfiH9k1BDg5n5ZodD6xpr/KqhX4vLa7cF4ACBSq5Qo0bd/nrOzdFE7qFlmGBonhLK0sdEgMu3qvlHiIokm/F7q99Gw5f6x858c6CKhHqLl/W5VveUr/lqe9F/O/1DN088c4kg3QaWh/+9nM797QFfEV0Kk0+QyQksPKRx7/qcp4amD59YL9DJswdaFwdWtZUu/nZ5/XysvNjo2cORBRMJ6X6B373sV3b1tS4QWziUUzQ0kJNWx75/vfx+NjslaPv9MlMUX31q52l9e2r9nz1X+ol5yemLx15p48YUVa29dkHduzeWqflutQCIYQQRHCEKtc+/Yd/6Dw+ONX33puTCgOppKZzc6izsXnXd/44deDM0HjvewvDRE/p1eu+8tCmnevrnDIVTTy3gJvp+bHLJ09dnZsz0NQNCymTFUUi3DJ1S3G1uFo3dLRW+wp+gL6Icl+ATGR8cKh3YDRuWoZuWHjrRHJuZjKpFPd4a1ZsvW9ZmVNhIoHKOQSg/qb7HvPXdly7MToZyyBT3aUNTWWaQ/Mv3/Pl8pb+qzfGpmIZ2Rksb2hva6sJSgTEfJW8IQXbux8IlTf09A/NhHWksjtU31Dqdrjda7Y8Vl3b1tM/PL2oM8VX0dje3lLlF29cig0iqP76jt1f8zf0XL85vZiyUHIHaxuqg063t23t4+WVndd7BmYW0xbzVdc1tbTWlXgUMbU/TyBnDq2ya8+zpQ29V29ORhI6kZ2llc3VIc0XaNzy5NfrOnuuDUxFErrDXVa3bPmyplKXRMSYfW4hIlNcla3bHuUtkUR05OyxC0OZ0mXd67tqlcziyNVjlyZMwyqOMYgiyn0JZGb7jr/zoxf3j+qWZVjM5fE4HTIFRM4t01FT2x1cub6x1E3AKorY5z9k3kBj99am7vevIBLCOfEGm7q3N6+96/LthXFCnkAiOUvru8oaut6/hEgIR+IsbVhd1rj6A5dFTlOEkFBQglUd91V3vn/t1uo3JVjdubVm+QcuizqSRxAJAPVVt22sab/rYrYjpr6ajk21HXdfFrMd8gBypnrqVz3cuJqncfqwOTa6GG/f8Og3vr7BGRs9/suhvv1GsTSyYsp9UdLcwWB5iX92bDpiEdXlKamqrq4sLy0JeRySw+etrAuoUiGdnkApZYwxxu79q3nrQwtS76RIH7xu68wpG6YPbTGSPcnK3rH7cPDuhOmTgmpL2TB9+KsuCQBgt9n4j/gJbbmgagkhH60kd8KXqyL9NhRBB03I7f65UKZDZqPBGCPAY9Hw7PTsvDs1NzuX5KbCGJBi2O2qiHJfRK28fdsDz7u9Rw+8d2FoYiERnRqnrmB5c3Xzqvb6mrIKn4PSwtngDhHD4YWxsTHDMHJdFuHTUEqnpiaj0ajb7b5zMZPJLCwsjI+P57BgwmdBKczOzqZSqaW/v+u6PjMzMz4+LstSofRbBWt6ejqZTAaDt+KEiOl0emZmZnx8zLLEaWh5TZKk+fk509RtnsO/DwlFdyDoc7GLfRcOvuZZcBvjF89Ombg65HeoSuEMAH6iIsp9CQHm9Fd0bNnbsHrLk+GZwasX3zt64vLloz8/e+Tk5m2PPvOvHmoujEXEiEgpdTqdp06dCofDnIuONa8BQCwWm5ubX79+fXb0V5KkSCRy5Mjhvr4buS6dcA8AEI/HFxYWZFleys+VJMk0zddf33fq1Embjx0WhdnZOcuympubCSEAhFIWDof37dt36tSpgsmoChUAjI+Pm6ZRIAcAACHAQGvq6G7rmpw71X/yrTFA3cRQ3fr1HTV+F+NY8ElDUeW+hACTFJdHdbncHrfm9Hp8Hs/+dw+evTgzH46lb699sz1EVBT10UcfmZqaUlU118UR7s2yLMZYS0urpmmIWF1dvX37tkgkInIaW7Asa9WqVa2tbZTSpcljOOdlZWVPPvlkPB6nlOZkxoXwG2lqanK5XG1tbdnJD/X19Q888EAqlZKkIrsL21NDQ4PH4ykrK1+yNv5PBTm3sttJOmrWP/l07cYtC4mMiYTKmq+soqa2xAW8CLa7KrZWh4RbRnpxov/ixXMXrvSNjY+PzxiemtaG1hofFMoRU4ioKNKGDRt0Xbd1Iy0e2XEgh8OhKAoAVFZW+v0+y7JE+OyCMepyue/9e78lnHO/379t23bTNMS2yHbBGNM0jVIKQGtqakKhkGVZuS6U8FlJkuR0Om39nAnAjUx0dnR8IWlYCACUEIfLIzuQEADKzMTsxAyrKvW5nYW+3VUx5b5gxidvXD9z/MTFwfGpien5lOGtb+9+dEdjbW1jfV1tGaNQMHcRAOr1+gDEMTp2gojZCSqqqjocDlt3skWIc76UA0KMMZ/PJyqJvWQrCQBxOBxOpzPXxRE+OyAEl7iN/7YBoWYmNnzxlZ8eGliMWPT2WeIAhGRvPoqrsuvxb+xd53G57PxFP4Miyn0B9MjI5TNv/OqlC4sGIUT2hlRdTydi4cnh2MTAVa+nsmPj+vqQJlObxxwAdF2/ePHi5OSkuDXaAiI6HI66urqGhgZVVaenp/v7+xcWFnJdLuEzQURVVZYvX1FZWbk0MwIBIBKJXLlyeXFxsWCe2AsbIrpc7sbGxvr6OkScnp6+ceNGLBYTXbQtIKLP5+vs7AgGQ7ad9YuEUCpp3rKqat3jzZ7rFp+8eeP6QMxZ3r62PSS73KGgU5GKoEoWUe5LCEemecqWrVitW5lkJJE2kuM3zoz1WnomEYvw6rrNX61fWRVwKczmr5oBIJ1Ov/rqKzMzM3V1dWKtW/5Lp9OxWHzVqlVlZWWqqo6Ojh48eGBubq6kpCTXRRPuLZPJjI9PfP3rckVFBcBSHLFCKZ2dnX3llVc45x6Pl1LxhiffxWIx07Q2b95cU1ONyG/e7N+37zUA8Pl8uS6acA+UwuzsHCHE43H7fH77bimIFnN4m9Z9+QfdSBCQICGLl97+2Y9eOMErNjz9jQdqyl0ykVRVLvwH6iLKfZGrgYbuLU/VdKR1I74wtRBPGxwIIVYqFp6fjbv8LVU+mYH9T5cCAM757OzcsmXLHnvsS2KPszxHKZ2enj5x4kQsFjVNgxCwLFOSpI6Ozi1btuS6dMI9UErn5ub+/u//Pp1OL9kYHgBkMplMJrNhw4b29g5FUWx6My4eg4ODFy5ciEYjiMg56npGUZTu7u6Ojk4xPJHnJImdPXvu5MkTmYy9tzkD4KYenenvn4rqGQQgBHBmLoFWNDk5Po/qMqfHAcVRGYso9yVEcgarG4PVjSR7ENidKoyIBJEApZTSQtrft7Kyavny5bqu57osnxfAndlI5FbQOBJK4QMRBKCQnYtlz9BRSgOBwPDwcDwey34lRCLLcllZWWdn573+1/kLAG6FhpD3o3crWMjf3wT/w1fshVI6PT2laY6lvylKklRTU9PR0aGqql1vyQD0/SZ+p1nDB1v0nTmJdm3jhBBJYsPDQ3fChEg0TWtsbFy+fLl9V7x9TPR4NlwfbOIfvmIzkiTNzc1fvHjB5vNTAJiZXrxx/Cf/9bVrc/Mmo3Br2wf0NDe5FAAgBbPk/16KKve9a1Dm4yfs2PX28Uk+mDraCxCCaCZj0VgskTGzx9DImsvnd5PkQkIH1eNxO2RKAE09EYnEM8wd8jhlCewXwmyMKH0/yQfIXvzIwWj2AcCNVCweicUz2Y37GdM8fr9L0sOJpEU0r9etSgQIN/REeDGOqtfjcql2PKEht63M1m0c0LL0xMJiNJk2s9kf0zxet1O2ErG4KXtDHk2SAJEY6WgsniGy2+vT7HrP+lCY4INyWLDPCYCgacTDkXgypWcfSSTV5fV5FZKORRKg+b0uTWZIwEon4/GoTp0+n1uhNvyqd7cyOxb/DkROmSNU07V5U2k8zm+tdSNU9Va2rly/otIpU7s+nvzG7NqPfFGFluUWHkSenrr4yksvvXv4ykyaICHga+x+4Klv7TZf+79/foNufOZ3vryt3UMgPT145Gd/8Q8XQs/8r1/f1dToNe07MlRIrORYz7uv/erlA5cWdNMiRAqWrHjkd759v/vin//i7Vl1y3d+95nV1TIz47N9+/7b//WiteYH3/jywyuqDEtEr1gA4YmpodOv/ehnh69PRjMECJNLVj/09ENrSgZf/+GLfa3f+z+f31pd6TLRGjj94o9/eUpqfu57f7SrhhbCAUS2B8RMLfSd+9Xfv/jejcGwCQSR1nbe9+TTz1RZB//uv7zi3vWvv/H4fctKOaUz10+/+JMfXg3u/YM/fKzd55NRdNG5gig5PHWr9jzTYnKe3dvBNHRdN0FV3ZJcOMfa3lux5r5CXgMgGSt1+eDPXnqz192666u7OgPUMiRnsLSCyddGblzrkeoWExYAIGA6sTDSe+Vqxc502oKieWOTzwAIhi/v3/fS/tPJlm3PblvlVxFlyVVe51Umpm/29Uw4m2IZRAIErUx8+ubVi2ZJOJGx4+iX8HlRmpoeOPXm3//0SHL9Q196cnmNhxKTemuafemR6YFrl646FowMByCEQGJxvL/3mqyE00iy74RyXfoiBxSS0/NnX/mrF44nVzy899FVyzxgGqqnrL4UIn3jN65c9LdFUgYAIQBGLDx242pP+aq4ZYng5RZSKjncJZqHEELMTGxhcrDn8unTl6ZV2r739/c2B92KjecV/SZE7ivkHwBi6tbMjSvXR9KlX93y0DOPr1QJtzhHMzYb7wPKGLszj5QAAGUfuCLkFBBEnOm72DsWdW7e8fDjj3R7VW5ZlmlYyGfIh4IFQBmTUBxNVmQAaGxh+salc7Pyl7bvfmTvhjoXQdMwOVu8PM4YkxgF8oFKIpp4/gAwU5GJ3ouXRwP3f++BR76yuUXilmVanGRmLg8AZdLdwboTvlwWudil4vG0npHdPg3T82MDfVeuX+kfGp+dmZucmlyIe5d3thbDaW7vE7mvkJcQMZFMce7weFyqahkGR0KAMSZGfewhnUrqwJwet0vihmEgImGMciL24hJuM0wznU7Lbp9Xk4CbhsWRAKUMsrP9c1084RMBIZZlJVNpJD6vV1Vky9BNJASoRIl4QMlDQOPjfWdPHx02vE6Zh4duDvQPjES5q7yirrW7o6qirrlpVaVTYUUz3VfkvkLeyg4E3r0hh2Aft88Kuit6IozCh2WX/4s2bkvvN3ERvfzHuB4b7z95YWBsLp1OZTil3vqV69Zv37ntvpXNFQGFccuy9aF1vyGR+wqCIAiCIBQq5L66ts0Pf1WrPnu5Z2JmfmE+PBtOL4z0XD5N+cJoeXVlRVV9Q4mmSMWy3E3kvoLtICG3xxU/+F+CbcDd07VzWhIh9z6+BnygjohKkrc+MXqih84nzOWvWbmpeuWGhzKpxdHhK+ePHT9zuX+y773+828mjNIV3Y//3v/wUGOJR7H5sbaflch9hbwEAIxSQkzT5IiMMUBEAkiASDIjppHOGCahjCE39XRa54xJAGIyad6glAJy07Q4oYwxRM45R0TGGEVLT2d0TimjgEY6pZtUZpSyXJdZWFrZs08s0zA4AGWMAOdIEChljHIrnU5zJJQxK5nJZHSLqhJjhIg2nheyPTRHwzCQ3GrjiAQJAJMYYiqVNkxOGQNu6qm0gUSSpCJaSpWXACgw6nAFG1s3VdWt3v1EfG525MaFEydOT8mWnimqhiVyXyH/ICFUgtLqmhLvpdnhmzevj/mCzNQ5SFRR1OqWluDxk31XL15aWd3hNkauXLo8GnW3N9drXq04nljzHBJCSKCirsw5fGP0Rs9Aqy+kIUfOqcvvLqlvqfYOXu47f+bqMneNHBu8ePbKnFW3ua4s4C+edRYCIQTdbm9lTa00MNI7MFgfIj6GhkkUt9MTqGlY5j45cP7YtRWSWiMnes5cHlrglcsbq0tE8pQPEImsOsuqq0vcl8b6Bm72lqteMHVOJIfH4apobK7wHOs7f/VKc4laYs1evnzxZsxb1thYKSsyikeXXEIkhACVFU1RXV5fMFBSVlPTsnZbiqMW8GpS8fTBIvcV8hBHUCVf9/1PbB/++bEX/7dTr7lkIMRfv3r3N/74yfadjz7Zu/DykX/4X4686ACSyXBH5covP7u7LRiUi2RrwjyHhED5ugcf6F+Yfe0f//Mf/9pBKUqB0PJHv/u9B7u7H3r4gYX5V/f95f/j7R8xauomV2t3f/nB+1or3Lw4DpIXCCEEOXeXL9v44HNX+1785Z/9jy9JqgSMhboefvq5Z3Ysv//J5wZ/+Nbf/6d/9w+yAjyTwkDn5qce3NqqURA7QOQB5MRVWr7+sW/tGv7lW//5/7X/L5wSElLbft+T3/hnW+o3PPLNh8d/cfyH/5/DP9IUNFKWUrb6gad2dYccDoKikecBRES0CCGUqm5/uScIhCCKtW6CkHMAUmnbrue/W772xshCwkQCoAUqmmvdLk+w66Hfcdbf1z++mDQ5ZaqrpK5xeWdriUOB4nlqzXdq6cpNTzkDrVuHwyndJMgc7vK2hoDTGWhf96XveJs3D87F0wYhkuYtq29f3l5XokERdbwCQaSO4LLVj/3gX9b2js7F05wgUHdVS3uZx+Nfvvmrf+RbcXNsIZHhhMpOf2Vza3tLnUfUkTyBhGnuug2PfM9R2zc2GdU5IoC/tL610uH2uLof/Na/rN04Oh5O6pww1RuqaW5tbypTJCqGffPNnTS4yIjcV8hfaqBl1fa2NXe2REe0LJNzJGUd3ZXL191ZQIGcW8W1P0v+Q6L561ZtaVyz9c5barRMk3MknurODXUrN71/nVuWxUX4ig0iMs1ZsXxL9ar3Tz3g3LIsC4mvds3WhrV3NX3Os5UkR4UVPgSRUMlT2rl9z8q7o2RZJufEE2rZtLNty109tMU5t0T4hLwhct9CBrfluiCfG+cW5x96JgUgyC3zw5ftu2HAJ4XJ5rEjHxsmgI+/bvfw5fbTbfvH+5RKYlmmVTCVhHxCPbF7+D4melB4Tdz+XbHwESL3LViImEgkwuGwYRi5LovwaSil0Wg0nU7zWxNegRBiGEY8Hl9cXMxp0YR7o5RGIhHTNJf+oy3LiscTkUhEURQxbJ7nsm1cVdXbF9A0zVgsHg6HuZjpnt8kSYrFYrfOpxQKgsh9CxMAKIoyODhw6NAh6yOjJ0JeAYBIJDIxMREMBikFAEIpS6VSfX19R44cyXXphHsAgMXFxWQyydiS7tJGKeWc9/T0JJNJSRI9eb6bmJiYnZ0rKSnN/ghAE4nEpUsXI5GIyKjyHKW0t7fXMHQx+lswRI9ZgBBRkqSVK1f09fWfOnVS9Kv5z7IsSZIqK6sURSEEA4FAZWXlwMDAmTNncl004d4sy6qpqQ2FSpbsgFfOucfjaWhomJ2dnZ+fF7fk/Geahtfrra2tpZQSQvz+QDAYGh8fn5mZzXXRhHvT9UxdXZ3f76OUimeVAiBy3wLEOXc4HE899XQymUAk4raY57IxopS5XC6Xy4VIamtrn3rq6XQ6JTrZ/JcNH2PM7w9k05ol+VAsKyt7/vmvZTIZcdiDXUiS7PF4GGOMsfb29qqqKsPQRRed/7LdsKqqPp9viV/vCP9ERO5bmCilpaWlAGUid7IFAJJNc7Mz/1RVLSsrAyiWo9XtLpu78CXcqwIRZVmuqKjIfv7SfKjwRWTb+J03Ay6Xy+12izZuFx8Kn2B3IvctTJZlDg2NRiJRSsV90QYQiSxLJSWlgUBAkqRwODw7O5NKpcWAkC0gEsZYbW2tz+dbmlsjAMTj8eHhYdM0xIQHW+AcXS5XeXm5x+PhnIfD4bm52UxGF9GzBc7R6dQqK6tcLpdocQVA5L4FiFKaTOr79+8fHx/z+wO5Lo5wb7quW5a1Zk33tm3b3G732NjY0aNH5+fnnE5nrosm3JthGPF47Mknn+ruXrs0n0gpnZube+21VxCJLMtL86HCFxGNRt1u99at29atW2dZ1tDQ0KFDB9PptKZpuS6acG/xeNzpdD711FP19Q1i2kMBELlvAQIA0zTPn7/g8bi7u5stKwe7LwmfHQCdn5+7du360NDQxo0bCSELCwvj4+OqqtbX1+e6dMI9AMDiYuTMmTMTExOrV69hjC3B0C8ARKPRnp6eVau6qqtrKKVi1m+e6++/OTY2Njg40N3dzTlfWJgfGRmpr69vaGhEcdBvfqOUXb165dq1a7t370ZEAHG+oO2J3LcwZdvn6tXdTz/9tF3390VCgBCg9Pa24ogcOSJQCtkfbvc+t65wbs/uiFI6OjrKOd6dNgWDwc7Ozj179uS2bF8MAADQD0YPKMAHo5e9YtfoEUrp1NTU+fPnlmyh2x0ul3vz5i2rV6+WZdmWN2MkBAgAfb+SIN7Vxt+vEx+tNrZz8eLFo0eP3JmcnV2SsWPHju7utXbe3/eu6BFEzjlm++OPaeL2jZ4kSV6vd2ZmdunbuPBPROS+hYwxKkmSXTtWRELMTDyyGE2kDBOByQ6P3+t28OhcTCea1+vWVEYIN/RUZD6SoZ4Sn1OWbfgyilLKGPvQ0UEAkF0PnsOCfUHcTCejkWgspVuEMNnh9vq8Co9F4jooLp/fpQAh3DJSkdlIRnb7vC7NjtEjlFJJYjmZAninkizNYPM/AUSup2KRxWhaNzmhsury+D0KycQjcUPxlno1SWKEkHQyEounQPL4gi67TvDItvG7r2TDJ0mSbbdgR9RT0fBiLKkbFjLJoXkDbo2YkXDMcHj8HpcqUUIsPRkPRxPc4Q15ncyWC1AkSfpo+ARbE7lvIbPzulQkqEdHrlw5c+HcwPSCzhlTvTWdG9aub00cefHgGHTuemjH6kY3AX1h6tK7L7814NnxvQfXVla5LduNH35SjGwbO0II4ZmFib5LZ85cujkZTVtA1UBZe/e2LRXR9/YdGZDr73v0ibWVssSM+Nz1d3/02mD15kceuG9FhdOy33NabsOEd8lVGT4nIDyzOD908fSpyz1jkZRJiOIua+ne2lVBh46+emiy5pE/2NNVUuK0OJ/sPbr/8FWp+v5Hn15bQYntviohhHxKG7df7AgB5EZibuTSqROXekYWUhYSWatqXL19ZRuZO/yzd6Y77n985/qWEg0hM9N76s13zibadv3OA11+TbXh6K9NYyR8CjGAL+QhAGJa6YEjP/rzP/+7d68n/I3t7a2NlZVekkpmMlNXjh86cvLGVMQCAgR4cnH00tG33jo3HIubthxUKDxASLL/rZd/+P/7q9euz3nqWttbm+or3JjhZmTi6vHDR05dHItxJAQoT8cmLx986+DFvmkRveIC1IwOn3rrL//3P/vl5Tmlor61rbUp6HUQPbow03/u0BtvXxxPpiwAQghGpq6eOnrw9OWJpEhA8gIANRbnLr/8f/+ff/azM4u8ZFl7W3t9aUAzE6n47OiFt/Yfujq4kLKAAFArOn7zzOGDR3smMqYlNuQT8oMY9xXyDwCxdD51+cz5GwvBRx968OnHOh2EWwiMWTpOphPxpJwxOWa7UW6Z6WQikTI5z04RFrfH3AIgyCeunrzUN6ctf+LRJ3evcCuIBJE7XHN96UQiiWnzVpAQuZlJxBPpjCXCVlSA0sW5sSunjkzgzt/Z++DO1TUacpOD6tJvnjLT8XgiYyLPNnHgZiaVTJi3qo1o47kGQI3Ewtil4yf7HBu+tOvhJ9c3SZZlIpU1fe7C1XQ8lszoVnakFBBNPZVIJDOWGDsV8obIfYW8xDlPRqNpS6mtqKiqKQ1m81pGk5NhRj44M5aQj14QcgoJScaiSZN6yqprKktDioRICBhoRj4peiJ8xUfPZBLRqOQuramsKC0NqRZHAiBFJaAAQEQlyWeWaSRj0TT6S2sqKqtLgoaJhABjkQVKP9LGRfSEfCNyXyGPAQEkyAnn2dwXxHiPjQAhBHkWIiEggid8DETkPFtRkAAVY4P2AfRW+O700FRET7AFMd9XEARBEARBKBYi9xUEYQl9/LiQGC0SPuBjK4SoJYIg/FaIOQ9CvqIA2Y2BACmlBG+dc0EYo8Ti1u091AlByzRQbL+YXwCAcEROCKWUUkRCgCIyKhGGpmVxi1FKCYBpGciZxCiIB/HiAwSyJ54AoxQJEgLAGKVMQjQsE4AwyojBLctCqkrUjhtAFywKgIRzBAKUUoqEAAUAoIwRw8qu0GAUALllWYRSJjZ5EPKGyH2F/IOEUAbuUIlbvj4/Mjx4Y1jVgFuEKqqqyKHqCueRmyO9Pdf7y+pkPtvT0z8blqs3liqaKhYS5wEkQIg7EPIqQxMTg/2DjQ6XjJwQqngDrkBlMADjE33Xzve76508PHD+xliGllaWeF2aCF5xcWhOX0kIhycHBoeqfYYT0eTM5XU63CWllXJqou/8jX5gJSwzce3G8KLlra0o9QIRw7+5h0iYonpCJR42Oj04NNgXBIVbBkgOj6w4Ssor1MjIzZ7e3ipaJRnjPb2Di7qjsrxUkiQRPSE/iNxXyENIqMpKV2/c1H7t7dP7X0iON5c4jSRzl9Ru+eruuk071xwdP/bGi38zda3Oxad7r9yIelc+sanDF9RsuG16YYLKrm1rV44PnNn3j38x0l7qsLhM3Mt2P7Glbt22tZd/9aujP/tvCxfbgzjbf+7GXHDtU+vba4IyR/udbCF8Tsi5r6yua9vu+ksnX3vhHwbOlHtUmuShFes2bVuxbP2OLQf/8fgPfzh3ZlkFjd64fH1Aq9+zad0yN4A9T7YoNCi5Q1Vd23a1/s2pd178yfj5hoCsx9Rg/aptT7U0b9q99sCvzrz43yM9zVXK/HjPtX6yrHv7mhanIqPIfYW8IHJfIQ8hEsbU6vXP/+uS1TduTCxETUKZ5C6t76xyu4Od9//e/9S4o+/G9GJMt+SGltWPNDe3tSyr8WjEdme6FSREQrTa7Y99v3rZff3jc3GdUJA9wbqWSq87VPql5/95Z1fPwNR8wgRa3di1t75pWVtrbUhGEb1igpy5qru3f+//XbplYHAmoVsIsjNQ3dJU4StxbX/835S39Q4OzaZNtLCua3t5U3vHstqQLDLfvIAcmSfY/uAP/pf6Lf1Ds9GMRYDVllQ1LytzlfvXPffv/4/unv7B2aRumvWNy3c/vay9vakupNr0SD6hAIncV8hXIHsq21YGaxti8YTOkTJFdXlcqiJRra7TV97QFIsnMxaVHU6Pz61JgGLQN4+A4itr7PJXNMVjyYxFgMoOt8fpkGXmrGr1l9a0xuLJjAVMcXm8Lk2mn3Dmq1C4kIDi8det3lC6rC2WypicUNmhuVxOVZK0smUbAtXtndFUxkKqut1ul1NlwMXjUb5AQpkWqlm5OdTQEU+lDZNQWdNcHqciSY6K5jUllcs646mMYTFZc3m8bo2iJVq4kDdE7ivkL+SEKC5vidt36+fsqerIOSGKy1fi9t+5LG6K+QY5ElA0X8jpv3XhdvSQgOz0hVz+uy6L6BUlRERgDm9Ie7+JZ2sERyI5fCHNf+f3RBvPP8gRHJ6Q5r314x0WYe9fR0Tk4txGIa+I3LeQMcZkWRaJRZ6jlEqSROkH9jkAgGz4clUq4TPKhi8nm4wAgCRJsiyLZp7/ProTzZ3wfajtC/lGlmXGxDYVBUXkvgXLsqwrV6688cYbpmnmuizCpwGAubnZ4eHhqqqq7BVEnJubPXv2rNi2Lf8BQDi8MDMzs/TZZywWO3Hi+OzsrCSJnjzfDQ8Pz8zMBIOh7I+WZU1OTh47dmx+foFzscgzrzHGzp07l0zGxRNmwRA9ZgFCRMZYY2NjX9+Nl176lWiu+c+yLMYkn8+XTWK8Xq+iyL29PZOTE7kumnBvhmE4nU6v17dkzyqI6HK5yspKL1y40NPTIwYO8182ZH6/DwAopT6fj1J65syZ3t5e0UXnOQBIJBIlJSWqqua6LMJvh8h9CxDnXNO0Z599JhaLiZuiXVBKvV6fpmmEkNbWlm9845uxWEyM+9oCIqEUampqAejS5DGc88rKyu997/vJZHIJPk74rQCAQCCQnSSzalWX3x9Ip1Oii7YFRFQUpbKyktIlauPCPymR+xYmxlhDQyMRi+dtJTsgRAhxudwNDS6xCMwuso8oALBkO/cjosPhaGxsIqKN2woAybZxp9PZ0tJCRPhs4s4whBiPKAziibNgAYDoVW0EAO6E7M5y6VwXSvhM7kRq6UMmKomNAADcPro7O8dXhM8uspESiW/BEOO+BQgAksnkL37xYm9vr1gEYwucc6fT2d29dsuWzS6Xu6+v7/Dhw6OjI+J9qC1wzlVVefTRx1auXLU0d0dK2djY6MsvvzQzM7MEHyd8cZxzv9+/efOW9evXW5Z17drVgwcPLiwsMMZyXTTh3kzTKi8ve/TRx2pr6yRJhMz2RGJUgCilhmGcOnWaENLd3W1ZVq5LJHwaAIhEFkdGRm7c6O3uXuNyucPh8OjoqGEYzc3Lcl064R4ASCwWP3nyeHf32mzuuwSDeZRCJBK5evVqRUVFeXk5peJmnO+mp6dGRkZKS0u7u7s557Ozs0NDQ6WlpZWVVWL0N88xRvv7+y9durRhw8bq6moASYTM7kTuW5gQ0TTNjRs3fu1rX9N1PdfF+WLeH0m71eEAwIdeFn70io1QSicnJ996a7+u69k3oQAkEAjU1dU++OBDuS7dF/WR6H00WLaOHqGUTk9P37hxY4m/AiJqmnbffVvXrFmjKIp9/4DkE5r4RyoJElyq+dT/BHp7ew4dOmQYRvZHSmlZWdn999/f1bXa5nuc3YnenYB9bA9t4xoqSdKRI0f27XvN5pES3idy30KmqqrL5bLt+QgAFBhywzR0kxOglEmqRLhlGRYnwBhjFAhB5NwyOQKVJUrsOB2LUupyuZxOp2XdfeonSpLkcrlyWLAvBIBSQMs0dcNEAkAlWaGUoGlYFhJGKWOUZMNnWhYBiTFKbRi9bPicksSW/t4OAIoiO51OVVXtmFkAAAFK0dB10+KIRJJkyhjhpmlahEoyo9njBDi3LJMDpVRidp0F5Ha7P7pDlsPhcLs9lmXHLdizs5cpmhnDMC0kwCRJlim3uGVaSKjEKFAghCDnlnXrF2zZxIkkSU6nU1EUMd+3YIjcV8hTiFZqqn+gf2hwOpbmAAAOf3lT6/I6PnDuxgIpb+1srStRCZjRhdEbF3rntJYtnXV+vyIOPs0LYMbmxgZ7e4ZmYrpFCaGqs6xlxfJ6efZC31CCVS9f0VbuYYzr0fmbF8728fLVna0NZS4xrFJEAI1EdObm9Z6RicU0JwCEOcubWpvKtOjAlb5IYMX2jhq3W+aI4fFr129M0kDbiu56b66L/Vtnzx4LuJWJzvRd7x2eWkhZnBBKvSV17S0tTj5y+cKgXLtueXN1wIlAk9NjN65fmddqV65uKVFVatMvLBQUkfsKeQiAWFyfvvr6X/3Vry8PWYHKUhczM1rFsnWk3JN87e/++jLd9b1/Ud9QpiGYC+PnXvrrPz9R/r2/+KPSUNDBLZE+5RoASU+fPfDjn77w7pBRXhF0Mk40Z23CWRFUT/zk71+e1B74H/51S5lXBp4Oj7z34//8N9aW//BH32mucHPx6FIsgFrJmWunf/7f/tPrM8znC3gcDHXHsp0PY4ev5x///IfXVv7bVZVlXq/CLRy/tv9Hf3dQ7vi9f7O63sfs/Pa8QACAlYgMHv35n/75W1NMCpaGHGBmAvWrTSVYmTrwwz/5ifex//2fldWFXBbQyODl1/72P50te/p/bKsJag7GRfiEnBO5r5CXMGMtnju0/9yI476nf/cbj3e4OCLImksy8Xh8MRKV07p5qwPlpp6IRSKujMib8gQg8omzbx85NWCtePb3/2jvCrdEkIDs8vud11LRWDRqpY1bTyjIzXQ8smgmdJOL14lFBCiNTA+cfuelC/GVf/Rvv7V9TbUTOQfVHcChU5cSkfBiIsM5ZuuEqadi0aic0MVzbZ6gPD47dfrNX5zl7d/9g68/tr5ZtRCprPkcxs2ziejiIk3p2VEIINzQE7FI1Jk2RdIr5AuR+wr5B4BYJg9PT0WScmN9Q1NHbS1yBAKUJifDFChQetfEKwBKqT3nihYkIARJbG46rKO7pnlZU22dKiEiAYLcpIQCpfSuaXO3wyfiV2QgnUwszEzzwINNTQ0N9RWqxZEAlaJjlH6oRYNo43kFgJh6emFmOqqXVjQ3NrfV11oGAgFgmQlKQTRxId+J3FfIS0iIyTkhlDIgwLnF8VZSJdgC5xwBmASAnHOOiARAhE+4CyJyjsAkShA555wjASLGBm0BES3OgUiMEUIszjkSApSK6Am2YNc1s0Lhu71vTm5LIXwhInrCPYlKYmN23nZOKGIi9xUEQRAEQRCKhZjzIOSrOweoAwABAuTWfxAAQoAAZLcHBaDZi2IyWT5BRLwdPSAkGy7EW+Ej7/8TBRG94pWdC3N3Lcm+7wFCCEK2ugDgB4cXxUBjfvhIE7/dQ2dDhHCnz0bRvIU8I8Z9hbxEKbjcLgnS4fmFxXDSMIxMMpWMxXRAb9DL0pGJ8cmZxUQqFZ2bGR+diXK/zycrirgv5gvN5XKAEVuYm4+mMoaRSacTsbhumi6fz8nS89Njo7PxVDoRC4+PjIWTmsejac5cl1lYWrIsa05Nj8/NLEQTqYxhGMlEMplA1eFyezE1MzIwE44k08nI6Oj4VFh3uHxeUUfyBWOSy+VkGJ6fDS9GUoZhpJPJRCJuMsnl9yo4OzE8PT2byKSjs9OTQ5Nxonj9HpBExiHkBzHuK+QfRMJkWtHetWJZ7+XeMwdecc6GVMsAhzdUu6K5vntD55nXBk8dfNWlt3n1kfOnzoe11vu62zx+TWxzlgeQAIHytrWdTZOHhk6886Y8H3IgSlQLtq5aVtaxvqtleF//kddeksMNcnzw/JEeXrJ+7Yq60oCIXhFB5N5QVUf3purBwWNH38VwrVemBnFWNzSWl7Wu3tR55sjZV97yzUxUy7FrB86OkfKu1V2NQSoWw+UBRJSd/prOtauX7Rs7d/RdR3TMzyxdcpbUNC33Vq7cuK7lpdFjB96QFyfKrOmLx85MO5tXda+odKg5OP1QED6GyH2FPISIMnN03v+Nb0tvvvv2uVd/dMIAyRFatv7hp7taq7Y8/QMj+ObBAxde+dFxQ5a9Za1PfPfRh3Y2+f1U7JqeDxAJ8a94+Imvuxyvv3v2tX84ZxCqltZueDTY0lTZ+cjT3/K733zz2MkXfnSAUilUtemrf/zIA5tbS2RL5L5FhHM11Ljpse+b5NV3Tx188ZzBUfHVrn3g8YqmTcv3fvXfaIF9B08fePGcyZmzon7Ht/Y8uGNdnSIy37yAnDtCoe4v//M/VF85cOrES2cPm0R2Na3Y9mTZyvqG1U/88z92vb7/xMW3fnrOILKnqvnh3929Z0unT5VF6ivkB5H7CvkJANTAss17ypavezKRMTihVHK4/QGX08FcbdsfruzaFE1mLA5Ucbh8voDHKVNx3lP+ALW0fs1DzzdtejSR0S0EKivuQDDgUiRWsWLn07Vdu+Mp3SJAVYfXG/C5HRIV0SsuSMARLFu59yu16/fG0zpHBEl1eQN+t6K4a9c8/Fzj5ocSaYMTkBxOj8/vdTrE/SpvIKGyp6pj11cr1zwcTxkmJ5Q5NE8g4FBVWtG8+alvdeyKJnWTEyprLq/f59FUsT+zkDdEXyLkL5BdnlKPr/zWQqjsHqDIET9wHZHf2UJWyBtIJYc35PSX0DthuhU9qrj85Z5g5Yev57a8wtJDwqjiDlZ4Q7fPPchu88uRMNUTrPSFPlJ5clpe4YOAya5Quae08vZ+lMi5ZXEkVNJ8Ja5A2Qd6aBQ9tJA/RO4r5DHk3OLc+szX7alANzlARLQsTj4SJkSOInwCIZ9aST7+up0VXj1B5JbFrUJv4qQQY1fsRO5bsDjnY2Ojly5dMk0z12URPg0AzM/Pz87OSpKU3SwIkcRisaGh4StXruS6dMI9ZMMXjyeWPglOpzODg4Oa5lRVVQyq5bnh4eGFhYWqqqrsj5zzSCTS19evKCrnPLdlEz4dpWxwcDCdTotWVjBE7luAEJFSWlZWNjk5efDgQdGx5r9UKhUOL9TX11MqEYKapkmSPDY2dvjw4VwXTbi3VColy5KmaUt2a0REVVU9Hs/NmzfD4TBjoifPd5HIYjKZ9Hi8AEApaJpGCLl+/drc3JzIqPIcAExPT6uqKsuSeM9TGESPWYAQUVGU++/fNTIyIhqqLXg8rpqa6vr6Bk1zAEBFRcXGjRvHx8dyXS7hM3G7XTU11XV1dQBLtN4SEYPB4Pbt2+fmZsXDrS14PG6Xy9XW1s4YQ6R1dXX33Xff4uKi6KJtweVq9Pv9ZWVllIpVuYVA5L4FKJv7bt261bLETdE2AIBSyhhDxNLS0m3btqFY22MT2ZkqjDFKl2jvfs653++///77ReJrFx+sJFhTU1tZWYliAZh9AIAkiXHfAiFy34JlWVzM9LURAJBlOfvflmWZpinSGhsBAMbYUn4i59wwDJE62Qil9PbTESBy07REG7eRbAMXuW9hELlvAQIAXddPnTo1MTEuSSLENsA5qqrS0tLS1NSsqurk5GRPT8/iYnjJxhGFL4JzLknyhg3ra2pqlyYZpZTOzc0dO/ZeJqNTsW2qHVgW93q9ra2tDQ0NhJCpqclLly7FYnHGRBu3Acuy/H7/unXr/P6A6JYLgEiMChAAZDKZt956KxqNLFvWLGY+5DkAiMfj8/MLsVissrJKVdWJiYnTp08nk4nS0tJcl064BwBIJpN9fTf8fn9VVfXSDAtlN5c4cOBAaWmJ2+0Ro7/5b25uzrK4ZVl1dXWWZQ0NDR04cMDhcJSUlIjw5TlK6fj4eCaTqamp9fn8uS6O8Fsgct8CBACc85mZmWXLlu3Z86BhGLkukfBpKKVTU5PHjh2PxxOWZRFCspvpNDU1bdiwMdelE+4hOwR7/XpPIpHIbrGyBKlM9t1OKpVqb+9ctmyZGIjKfz09PdeuXY1Go4iIiMlkEgBWrVrV2blczHzIc5IkHT9+/MSJ44ahI+KSLWkV/umI3LdgUUpra2u7urp0Xc91WT4voJRRdvud7q1TgwhljBJuWRZHQggBoExigNy0LFt2SJTSQCAwMDB4J4MBAJfLVVdXv2rVqtyW7QsAyE5vvOtoLsvihEqMIlqWeSd6VGIU34+n3VBKp6en/H7/0s89UFW1vr5+xYoVsizb82YMAEAZo++f62ZZHAlQxgBN07q12hMo+2CjtyHOcXp66s5rAUqp3+9vbW3t6uqyPno6hD0AUMoYu13xkVsW54QwxoBzk1t3Rw+4Zdo1erIsT09PX7x4UUz2LRgi9y1kiLeOCM11QT4nKzk53t93fWBiPmkSJrtKats7OmutwXM3wlDR2tlaE1QQjOjcWO/l63OO1i3tdT6/wu3YvX7skczZ8OWkPL8FYKZmxgZ6rg+ML8YMBNntr2tf1RniQ1f756VA4/KuOi9lzEyEJ3pPXZnzNy5vb67yyvb8vpxzQnJT7e60cRvmvgCY0WPTN69d7xubj+kcmRaobVm+rExdHLjaF/Gv2NZe7XbLnGN49NL1/inwta3oqvXYNPtA/HCM7sTOls0cAK10cqr/Wm/f6GwibSJTSiqbV7Q0yumBc9cjla0rW+rLXAoBfWFo8PqN4XRZ+6a2Kk2RbFhT7dm+hE8jcl8hP3FuLfQd+tWv3zh3JWzKmsSo5KvvYq5K38KrP/yry9LO7/7z2tqQSqgxN37mV3/5306Vf7flD0qCAcWGd5FCZMxePbV/36sHr81yRWUSkYPlK2hpbd30Gz/872cdK57/4xU1XiaBHpu5/Mp/+ZNznc/+qx9U1fpkEb2iAdTKzA5cfecX//j2jVmdSQoD2Vm6HH3OJJ79xz/7u2sr/vXK3yvxehROcOzK/h/9/SGp4wf/elWtlxKRhuQcUCsVGz3/+s9//nbvbBJVjRGm1LZmAg7NGvzFn/7Xvl3f//ffrqhwq8gyU5cP/eSvXpnf+oPlDSVORcYcPSYKwl1E7ivkIQCi89jlAy++/O5M+/3f/vqT60oVM2OBRKkizyZi0ZicMUzMHrLOTSMVj0bdGYsjIZCrATjhDgDC5y+++cavD1z17vn67z12X6nGLWJwK+jNTCRi0ZiV1G/NeCDc0lPRSDSVNkTaW1SA0uTswInXf/SLk4Fnvv87D29s9ksklUFXgMz06MloJJrUOc82cWIa6XgsJid0Toho43kAKEnNTp99+W9fOOd9/LvfeHzLSj8zUyY43MQc6E1EI9FUxsy2aEBL1xOxaDyti7FTIW+I3FfIPwDEMPjk4MB0WK7vWNG1vq0he84DJanZGEP8yMiB2CE+jwBBJDMj/RMRHupes35VS6ND5hyR6ATH2Mft5i+CV4wgFlkYvXnTCnxjfdeK9tZKB+cWRyrHFnuB4IemLolDIPIJANFTiYmhgalYzbquVV3drXWWxTkHJkUGhuiHg0cIiscVIb+I1cFCnkLOOQEmKTKTgNw694xRIhYb2ALnHIFKkizTu6InlooI78tueECZoki31gneWhyZ64IJ94aInCOApCi3FrsBpUCp6KEFWxC5r5DnPjrIK9iIGKwT7kWM6NqZCJ5gRyL3FQRBEARBEIqFyH2FfPVJo0HZ6/D+63MgIMaO8s7HxyM7bRPIXdEDEPO1i9bHxv3W3N4P1BEQU37zzq2FF0AIfOT6x0Zv6YsoCJ9A5L5CXgIAzeEAMDNpkxsSY4xJjDHKGHV5XDSTjsZTGWSSREw9GY3GucvlojITKyryhaSqEqKR0Q3C7gBwO12Kw4wnI4kYYRK10FyMhE1Tc7tUWRE3x+LCGFMUhafTupU9/4AxRimoDtXldFrmwuKiyS0qSRCLReMJXXW4XE4goo3nHhJCKdUcKoFUOsW5dbuHplSSJJfTRRLhaMIwiCTJXE/Fo8kMuFxuACqiJ+QHsc+DkH8QCZVpqKVjWdnlgdPvvOzRmz2Em7I7WLlsVVP1qjWNR9649s6v/9GaqncY09fOHxtL1WxY0ezxaXY816LgICGElDZ3NpWOnDj/1q9/FutxM46S7KtfsbquasXyljNHew798u+0wSanER45d/iGVLV6eXOlXxMzu4sJck+gtLFjpefqlbdffWm2v9wJ3GSBxpaOipKGjtX1x44d+ekv2ZXmkJwZPvbOtZSjuWN5fSDXpRYIIYQgMs1X1ry8Pbi/7+Brv8wMNWjcMhy+yuaWFl/dyu6GQ1dP73tRnW2pUVNj5949F3bW7mpvcChyrgsuCFki9xXyECIozLNi6+MPjv/6xMWz+1+6rkrccJY3r/N0NXZueOCxnsU3zl87vm/8AiWZlCG37Xr6ya3LfD7FlgckFRwkBEpX7L7/wcTi6+cvvDnfq1IEp6tum7+xetW6Rx4cN5MHe07uG7uikEwqxZbtfOaRjZ1VHrDlkXzC54Ocu0IN6x949pHBX1+7dGTqhiIzYmot2zHUuLP1vke/Prj4Tv/pd0avOkBPpHjp5j0P3b++TgYQ787zACI4g2XdD33tsfFXr1068XrfZQW4HqpfTUIrN9ZvfvLZ3tS7/WeOzFzViJFKE//aRx7Y21WryRIX0RPygsh9hfwEhLnrt37nX655aiGSSOqcAFM0b6jE51So75F/9u+3LS5EkwmDU0lxeIIBj1NTKRW5U96g3rYNz/xRxwORaCypEwCQNF9J0Od0SKvv/53WdY9HYvGUjpRKDk/Q73VpqgQiesUFUfI3dD78L/7X+yIL0ZRhIRDJ4fMHgl4n82149v/Z+VBkIZoyOYLidLl9Qa8my0y8GsgPiETRyrv2/qv/Y2N4IZbUTSRUdrp9JQGPIru3PvMfuh9cnI8ldZMzWXN5Qn6PqigURPSEPCFyXyFPASEga86Aw+HliIgAALe3/lSczqDm8PNbayoopSAWu+UbKqueQLnLX8o5kruiB7LDG6xwBzhmr1Mmole0KFXdvhKnO3hreRulNLtGSnJ4/KrLE0JEAhQoUDHim28AmOz0ljjcQeSIBIACpUCQgKS6vCWaO3hr1RulInpCnhG5b4EDAJufJwCUsY+7/OHr9v2anxQj+8eOAFBg9KMragEosLtX2tr4i+Y2THBbrgrwW/AJTfwj123+LT+5jdv7i1H6gaZ8e9MHoLRgomfnsgsfT+S+BQ7FxkB575NiJGJnC7kNE94lV2UQPotPaeMidnlOBKjwiNy3MAGAZVkvv/xSX1+fWP+V5wBIPB6fn59fs6Y7ewUR+/v7L1w4f+zYsdyWTbgnAJJIJPr6+vbu3bvEnzszM/OXf/mXFRUV7OMHToU8Mjc3q+v6zp27sj+aptnT0zM2NlZR8YpIrfIcpTA6OqbrGXEzLRgi9y1AiKgoyq5dO3t6egjB25Nkhfzl8XgqKys7OjpUVSWE1NTUrF27dnh4SMTOFpxO544dO+vrG2CppjUiYmlp6e7du0dHRxlj4p1s/isrKwuFQsuWLQMASZLq6uo3bNg4NzcLIF6p20BdXW1lZaXf71+yNi78kxK5bwHinKuq+uUvf1k8pNqOLCuEkObm5vr6essyc10c4bMDSZKWLImxLKu8vOK73/2eruviuAC7QCSU0uyzSnt7e3NzM6Loom0jm/GKB5XCIHLfwgQADodTjBraCCLh3Mo+rgCAw+EQnayNIBLLMpdyQCg7fKgoypJ9ovAFISLnPNvGGWOyLIs2biOIaFmWGPQtDCL3LUyc86mpsXg8nuuCCJ8VY8zr9fp8fkliyWRycXExmUyKftYuJImVlJS63e6l+TgAyGQyc3OzqVRaVBK7kGXZ7/d7vV5CSCwWXVgIZzKZXBdK+KwcDjUYDGmaJp5YCoDIfQsQpTQej//5n//5hQvnPR6PuDXmP8uyZFneunXrc889FwqV3Lhx44UXXrh+/ZrD4ch10YR7M02TEPKHf/iHO3bsZIwtQYujlI6Ojv7Zn/2X8fFxSqm4Gec/w9A9Ht+jjz7yxBNPIuLZs2d//OMfz83NZaf4C3kulUqVl5d///s/6OrqUhRF3FXtTuS+BSi7ycPMzMyWLfc9+ugj2RuzkLcAYG5u7syZM5lMxjQtQkg6ndY0x44dO7Zv357r0gn3AADz8/M/+tGPksnkUn5oJpM2TfPhhx/p6OhQVXEzznfDw8MXL16MRCLZmQ/pdNrn8+3ataujo0MszMhzjLFz586fOXPaMHTR0AqDyH0LFmOsubl506bNuq7nuizCp6GUTkxMzszMRCIRQggiAhCv19vc3Lxhw8Zcl064B0rp9PTUq6++uuSDr+B0Ojs62jds2KCqqrgl5zmfzzc9PU1vn/TCGAsGgytWrFi3br1lWbktm/DpJElKpzM3bvR+6LwOwb5E7lvIOOemadp53NfQF+cmp+bmkzpIqsNXWl3i19Izo/Mp7imvKPW5JQJWKrE4PT6dkkKNFUHNKdsvBaCUWpb5obGf7OCQnWMHaCWjc9MzM+G4SUDSfKWVZSG3FR6dDaclf2V5mddBKTcyibnx8XnLWVVRGvRo9oseoZSa5pKucrsju/jGNM2lmWjx2weE8ExifmpiOpLQTWQub6ikIqTw6OzEnO4oa67wKw4JkcQWJmfnItRZWl4T0nJd6M/JsqyPtvFs+Oya+yIhVnJucnQ2nEibKGk+f2lNiZvr8xMTi8xbW1Hic6pIIB0Nz05NphRfZXWZW5LsOT1HrHIrMCL3FfISIFqJ8TNvHnrvWn8MZLemINdK6jrWbF+VPPrq28O46sHHd6/1yISakZmegy+91u/b/c8e2+hyKZbooPKBFR+4fPzowRMDi6B6NJlQl6ty+dZdq9jV/W+fnFPXPPnkXq8GgJnI1Pl9P33HbH3msT33+ZymJaJXJACIGR0bOr//9WMj86bDoUqSTJ3VqzasqHSMHPnVO+N1T/zxo92lmmIhnxk8ue/tS1Ltg099NeRkRDTxnANKMsm5m6de3398KKxLDpeDoRWobF23dqMvc+bXLxzVur/5pV1rXA4EGh/rf2/fywP+jV95blezR5GQi/gJuUbv/SuCsNQAuGlFe4/8/O9+uu/CGA9WVVfXlIdCbplYujF1+eiBwyeuT0ZMoECAJxeHLx15c/+ZkVjcpGLNTx4AIGSx5619P/3py8fHM/7y6uqqirKgSwaKuDhw8vihw6d655McCQCayfDNE2/tO3F5dDEltuQrJsDS4aGT+//2L//h6FhSDVbV1FRX+DyaRDLR2f6zB/btvzieTPJsnYhOXjlx5N2TlyaShBAiqknOAWA6PHXx1b/5ry8cupmiJTXVVTVlQZ/GLK4vzvQefeO10z3T0QwFQihk5icuv/fWgTP9YcNAETwhL4hxXyH/ABBL5ws91/rCtOmrjzz7nS+1SohIQGKZ+cQkIn5waiUAiIXu+QMIIs7cuDwwZVZueuL5b9/f6ZAREYFKlJxHJCDCJwBAdH564PKlTOCJp5776vbVVQ6LIwFJSV49fALIh1JcUUnyCQAYyehM75Xr0brdj37luSfXNoDJESiTrbkr0x9p4iJ8Qr4Rua+Ql5BjKpU0LXC4XE6PqlgcCQFGLRCjPraQSaV0RNXlcjtURck+ugDhpoiecJtpmulUEjSnx6lpiqJYHAlQOSPqiA2gZaZTSRNdTo/mdKuKwZAQoJIuclzBDkTuK+Q1IIQgQcwuMxCLDWwFgADJBk9ETvhYH6wjKNq4vdxKc1H00ILNiPm+giAIgiAIQrEQua8gCIIgCIJQLETuK+QrACCEo8WJBbcWSxBCgMiqDAbXsyegAXCL62aaKLIMFAgRr9zyA1BKsu9CIRvJW29HJVmWkJi6YRBCCBDOdT1tSZLMmJiAVWwAACgicryzGgoRmSTJssq5bqSRWwBAMoZhmChJiiITItp4fgAAACQcb+17m23gSAEURSGg6xnOTaBALMvMGBxAUVQi5gILeULcboT8g0iYTIM1NSHHpeHLF8+erDP9kqVzkCR3aUlFU737wOnzR987XOlod5mjpw4cG1hgjfU1Drcdj0YoPEiAQKiytlTrv9Jz9sTpkFWicYubXCmrqwjUNpS5+s6eO/rOAZ9ep8YHT7x7fiJWsaMy5PeJfT+LCCK6Pb7ymmqz/9qpsxc8UO9lJG0QT9Dn8JbX1Lnf7jv22pHKWKyGxa8dPH5x2gq11lV6QTzf5gFElB3OkuqakHSh5+yFc1VK0gNmyqIOb6jMEaivL2fHr7x75GgAV4fM2XPvHbwekUrq6oOyYs8zWITCI3JfIS9RhZWu2vHow5GDQxOn33h13KsgVwM1LWv3ltZuefhLQ/z46I33Xov3a2RhctRo3PbUnl0dgYDKRceaBxAJKVv5wP179PSF4fNvvTHrVQjVtLLWrSXBxpV79j6kJ09OXHr7tWiZkp4dHdXWPPTsni3LytziXItigtxT0rDhgef2hk+PXDq6f+qKJsvEUbZ87fq1zct3PP7s6Ku9V868Gx8P0sTIcMS/duf9e7Y0eUTqmx+QOUqq1z7y3OOZM3OXj78+PeBmhHtLmro21Cwr637ouScTx0eunnpjcdynhycmEzWbH96xo6vM4RDxE/KDyH2FPISIlLLylY98I7is51Lv6FRCJ0z1lNVUhxxOV+OWr363dvX1SzfGphO6XN7Y9dCK5Subq32qIgYO84ZStXbHl8uq2q/0j8xGMgQUT1ldhU9zKJ41O79cWbfi4vXB8fkE0NK29R2dq9rqyr0aEdErJsjBWd6+4al/Fmq/em1gNpK2UHaXlpWX+tx+X/f9v1tRd+3K9YG5SMYq3bRyW3PniraaUg8VZ7rlBURLcrkbt3719yuXX70yMBVJGkRxlVTUVHhlj6/2vi//Yc3KK1f6xuYjGSipW7e7fWVHc1WpKoEY9hXyg8h9hXyFVHZX1XdX1q1Gnj0QIft/BMBd3biuqqEbEQkBAkBv7ZSU6yIL7wPFXdq8ZkdTV3b7o/c3t6dSsLp9c1XbRuTZy+IwvmKFoDqCjZ1bGto3I7mrlgCAFmxacV9j5xYk2bnAopLkHaSS5q5dvrmmY+PtJn47gJKrvGVN2bKuO01f9NBCnhG5byEDAEoppTZe0QiEEErYJ1z/mIs2RCn92GOPsuHLSZF+iz7uC2Rz4I8Jqx3dDl9uPv1OG7fvgBp8wprrT7puU5/Sxu0bu2yUPqmNF0oPfauN57oUwm+TyH0LWSaTSSQSuq7nuiDCp6GUplIpwzDuvgValpVOZxKJRA4LJnwWlNJUKpnddmSJcc6zbdw0TTvnT0Uh28YdDsedK5zzdDqdSCQsKweVR/jsJElKp9Oc81wXRPitEblvYco+pF65cvm1114zTTPXxRE+DQBEIpGBgYFQKHR7cAgWFhbm5uYZK4yx0UJGKV1cDE9PzyzxrREA0un0+fPn5+bmJUkSuW+eGxsbGx4eXrFiJSEEgCDyhYWF48dPTE5OiaQqz1FKe3p6IpGIiFTBELlvAUJESZJWr149OTk5PDwsbor5zzAMj8dbW1urKAoilpSEmpqax8fHx8bGcl004d4Mw+jo6KiurmFsifZwQkSPx93S0qLr+sTEhHghm/9SqWRVVVVTUyNj1LJIIBCsqanNZDIjIyO5LppwDwDAOW9tbQsEAgUwD00gIvctSJxzVVXvv//+hYWFXJdF+KwkSQoGg5qmEULKyyt27NgRDofFc4tdKIrS2Ni4ZB/HOQ8GQw88sCeZTIpKYgsAoGmOiooKSikhUF/fsGePmk6nRfjswuVyVVZW2nx+tnCLyH0LE2Osra1NjAbZC+c8+07N7XaL8NnOnfAtAUR0uVxdXV1L83HCb0u2kjBGSktLKyoqcl0c4TdjWZZIfAuDyH0LEACYpjk2Nra4uJjrsgiflSxLgUAwFAoxxmKx2NzcXCKREP2sTaAkyZWVFV6vb2meWAAgmUxOTEyIgUMbcTgcoVDI7/cTQmKx6MzMTCqVznWhhM/K6dQqKio1TROjEgVA5L4FCAAymcyrr746ODjg9XrFrTH/maZJKe3uXrtz5w632zM0NHTw4MHJyUlNc9z7fyzkmmmahmE88cTja9euX5plZ5TSmZmZn//8Z8lkUlGUf+qPE764dDrt9fq2bNmyadMmRH7z5s0333wzFovdvfODkJ+yj5o+n+/pp7/S2NggliAXAJH7FqDsuO/169e9Xs/atevEPg95jlK6sDDf09M7NTWl6wYhZHFxcX5+3uv1Ll++PNelE+6BUlhcjLz99luLi5ElGxACgHg8Pjw8vGrVqpqaGgCx/ibfDQ8PT05OTE5OIiLnfH5+fnZ2trGxsbGxSewekOcYY9euXR0YGEgm44gIIM6nsz2R+xYmRNR1vampedeuXWJ/3zxHKR0bG49EIoSQbJfKOXe5XC0tLTt27Mh16YR7oJROT0+/997RJX7I5JwzxpYvX7Fy5UpZlsXNOM9dunQpk0lnKwlidqcOz+rVq1evXiNy3zyXfZkzPDwsGlnBELlvwQIAp9Pp9Xptm/sCAMHbbv2cHVjDj5wQhEhsOweLUurxRFTVcffuOZIkuVwur9ebw4J9IXeix7P3i/ej9xF2Dt7tsy0kKQd9KWMsW0nsm/sCACL/aBP/mErx0VZvKx6PR1GUO00AAGRZdrvdPp/PrmdbZNv4x0TvY0Jl6+jJsuxyuShlNu6nhA8SuW8huztxtB+0UnM9V44fP3z+5kRMJ5IaaFi1bfuulcbJXx0ag/bte7aurHUhzcwOXzj42oFB745v37+qotJlcbt93U8Kk41jRwjB+NzA5VOHj57rmw5nCFUDlSu3P7i7Vj+z/71BpXrTg19aXS5JLLM42XPop/sGqzc8uHNzZ7lm2W8ALLdhwrvkqgyfF4CViE5cP3HwyJneyYW0xWVP1Yot929qdI6ffPPIRM3D39+5PBRyWBxHL7/x7rFeVrnzwS91ldo0/fjYANk2doQA4anITO+xg++dvjaymDRQcda3rN+zuVuJnPjlu1MdOx7Z1r0soCFNjV84+c7B8/HWnV/b0enTVBt+W7vGSPhkYpaYkIcAwOLW6PlXXvjJL967ugCeUDDoczllYiRTmZEz776+/9Dl0QUDAACs2MLAqbd//cp7NyIRnYrn8jwAhJDU8MmDv3rhxQPXp4g7GAz6fW4ZM5a1OHL2wJtvHT47FOFIAKiVjgyfef3lN05enYgZVASviAA145OXj//8r//hzSuTGcUbCAUDDpkij89PXX/v9V+9cnIwkTABgBBcGL146K3XD58Zjtv6FUHhAGBGLNp34Cd/++NXz09FJV8oFPI4FQn1RGy6/8Qrv3rz3I25hAkAwIzF4etH39j31oXhtGGBjUd/hUIixn2FvMR1a+7ioTcPXDZ3PvOdHzyzzieZusmJpZtsSs9kdG5xfuslGnK09EzGsMRzeb4AglMX3j546Px04zf+xfee2FTi4BY39ZTqXRw0MpkMez9YiJapZzKm/YbrhS8EgMZmBs+8/csjQyv/5b/7xiObm7wM02lT1lJD57iZyeimhZht4sC5qWcyeKvaACGisuQYtRJzY2ff+OX+qZbf/9pXn926wgVGWkcmp8JXr+npjH5Xi0bL0nXdsCwRNyFviNxXyD8AxDT5/MxswnA2NdTX1Yc8FkckwCA5ExXby+Q5IIgkMjcTMeWSuubm6qBPlRAJIW7ElIiekAWQTCYWZuflYGNrfWVZyKdY3OMGKkfHAAgRr5jzGADR9fTC7FyKVzcuq62tDXgMCz0IVI5EqGjjQv4Tcx6EvAYAt1eHAPmktVJCnroreoQQIGDn9S7CP40PVBIgYk6DrdyK3u0uWkxpEGxC5L6CIAiCIAhCsRC5ryAIgiAIglAsxHxfId/BnZeiH5jycPtl250NJYV89H70PvgyG+4gInrF7q66cKeNI/lQJRHy0N1RIp/YQ+eqdILwicS4r5CXKAWv16dIejwciS0ahmkYhmGaJjAaLAspyfjM9Ox83DDM5OLCzORcmJaGQrJDEWlUvtA8Ho1ganExkjIMwzAM3TDRQr+/xO01wwsTU2Mpw9Bjiejw+LjB/SVBt+YUy5uKi6KoLrebxyLhWCqtZ6uJYZoOlysYDBJ9YmxoMRbTDTM9Oj45u5hx+0JBn3hUyhNMkrwej0Qj0flEPHo7doYlqY5gKCSFx6dnwuGEaZrRhbnpqcW0FAqFGJNE9IT8IMZ9hfyDSKjCAsu7u+suHj/8i79Y7KtzU66r/qqWLY9vrlq/ZeXhn1/99X//z0Onqh3W3M2+nknauXddizfg4GKnrNxDBALlnRtWNI28ceKFv/qTq/UuxomilKza/XB39ZqNq86+enj/3/7J/NFapxmd7L065O58cE1btV9BtN/JFsLnhMi9JVUd67ZUnD/34t/82bl3QhqgKVd1bdiytr65a8uaoy8f+Iv/OvN2bUDKjF853wMl69auafQAiB0gcg8RmStYtnzjlpof97zyN3/ed6DaiZbuKWtau2VvZf3abV3v7j/+0z+fP1dXIacmey/1pMo7H1rRqCmSOCJCyA8i9xXyECKRqbNl89PfzJScuzSWTCaTFDlxI2WKXNq1+9lvSccuXZs1EokEVUob71u3Z8PuLQ1et8RF9pQPkBB/y86HnpMdhy6NptPJJCBFioiElXc98sTXvd7jvTPpVDIJ4G7e+JXHNty/vr3MieLBpZhw7vDXrbv/m99LvXttNGYkkylKECyO4Cldtu1LP8iox26Ox8xU0jA9Ld0Pta/fsb27Us51qQVCCCGIRPWXrHrwd35gHbo6MWfEk0mKlsMEwpwllRu//J3ve0/0TS4aibiOzpru3bvWbtm5otLBGIpxXyEv5HXua9+DBO1b8vwBVAl17H162fYHk6mUwQkwWXW6XapEwbPuiee79saT6bTBQVJUze1SGKWEiOQpf6iVLVufrF/3YCqZ0TmhlCpOj6bKEvWueqCm/b5UMpkxCQBVnR6HKktU7OhabJCDVlqz9qnvrngwnsyehSCpTqfTqTJwL9v6jYYNqVhStzgnkqY5HE5VEvv+5g1EZIq3oeup3+98MJrMGCYnVFIdLo+mAHW2b31+2fpkPJUxTE4lh+Z0a0r2hL5cl9uW7HvwNSEkX4Oer7kvEsaY5nAgoh0nyiMhsiQBFdOpvwgAykB1eVSX58P/wkB1e1W39wNX7ds5FCIAAFl1yqrzo/8kqy5ZdX3oqghf8QEAkGTNG9A+cBkJASbLmhz84HVRR/IKADDGmCfg+HAHTYDJmiegffC6iN7nAACyLDudTuR2facpy/n4uiZPc18AcKiO8rJybtt4AxBJlnPb2jnnlmVZlpXDMnxxd60T/sCf8/3rNu9TEZFz/qEne0SeDV8OC/bbcM/o2Tx4hCCiZXFEsvQHdyBitolTSu38dyz8SkIIybbxOz9mW31BdNGf1BMXTvhy2L4opV6P1+Vy5enwVTkbEAABAABJREFU6WfAGKP5Nw6Yp7kvuf24k+tS2BgATE9P9/T0GIaR67IIn4ZSOj09vbgYDgZD2SsAkE6nJybGe3t7c1s24Z4opfPz86lUaon3cgIA0zRHRkYcDqcsi0VE+W50dCQej5eVld2+AIlEYnh42Ol02XeIp0hIkjQ+Ps55Dh5RgIAkSVIep2o2Jf6gBQgRGWM+n+/IkcNXr14RN8W8B4ahA8DOnTsYY4QQWZbD4fCFCxeOHj2a67IJ9wS6nkmn07IsL9ncNkRUFJkQ8tJLv1IUVeyhmv9SqZTH4+no6CCEUEodDsfCQviFF15wudz5OiVSuAUAotFYMBjIdUGE3xqR+xYgRHQ4HN/85jdnZ2dE4msXquqorKx0uVyEkLa2tm984xuLixGx65ddqKra3LwMYInejXLOq6urf/CD34vFomLU0C5cLld1dY0kSYjY0dHxgx/8IB6P5bpQwmcEXq+3vr6BMSbuqgVA5L4FCBElSVqxYkUeTrIRPgkiQbw1wTcYDJaWlorBPHuxLGvJ0lBEdLs969atE5XERu7M8QWA0tLS8vJyET4bQUTLskTiWxhE7luYEDEajei6Id6m2QRQSp1OTZJkAEilUplMhnMuwmcTQCk4na6lXKJgGEY4HBZvBuwDKGWqqqiqSghJp9PpdMqyRBu3C5Blye3+yJYWgj2J3LcAAUAmkzly5OjExLhYL2gLnHPGWGtr68qVKzXNOTMzc/ny5fn5OTEsZAuISAjed9+25ubmpflESmk4HD569Eg8HgcAMRaV/yzL0jStvb1jxYoVhODY2Oi5c+fi8Xh2ir+Q53Rd93q927ZtF6P1hUHkvgWIUprJZH79618vLCy0tbWKc37zHKUQjUZnZ2enpqaampqcTtfU1NSRI4dnZ2erqqpzXTrhHiiFeDze09MTCpU0NjYuzXRASun8/Nzrr7+uKIrf76eUiuw3z4XD4WQykUymOjo6EPnNmzf37dunKEp5ebnoovMcpTAyMppKJauqakKhkKIo4mnT7kTuW5iyLXPv3r1f/epXbb7H2QeesRHx9pW7Op9bv2LX7ohSOjU1dfDggUwmk93nlxAsLS1ds2bNQw89nOvSfTGfFL2Phs+u0SOU0pmZ6T/90z9d4s/lHL1e7969D65Zs0ZVVdv+/T5USQgiFl4lIYT09/cdPnw4O8MBkVBK6+vrd+/evXr1Glvv7/vR6H1MsGwePkmS3nvvvf3732TM1htpC+8TuW8hc7vdoVAok8nkuiCfFxBiWYZpWpwTQoExWWLALdPiSCVJopQQIMgt0zA5YYosUWrDM08pZel0WtO0u59SGGMulzMQsOuuOgCAyLllmqbFMXtInyxLFE3D5AhMkhgDQgjh3DRNC0GWJMbAftEj/3/2/jvIjuvOFzzP76S93pf33sNbgiAIAvQiRVGU1C3Xvp/ZtzNvYv/ZjYmN2N2Y2NiYFxsb+zZiXs/0tHmv1fIUregBEIT3ruDKe3/repPm/PaPqgIKhhIlUcStW7/PP2Ql6t57bmWezG+ePIZzbhh5VVW/+iehnHOPxx0IBNZq9gUGjAnLNJcOEsa5JCkyoG1bNoKsKBIHhsiEbdm2YFySFQnW4PdkjDGfz6fr+uotqqp6vd5gMGhZ1qMq1R9g6XAXlmValo3IGJdkWZE4Q9s0bZAUWZI4IAO0LcuyECRZkdfm6GtFUbxer6Io1NuhaFD2LWZLiwat2SmQUNjZ9NTY4NjUbMpgsu4KVTZVl/uyI9fHkiJU11BTGlAZWMn4zNCt4YRSubGx3OPVxVrMAPet+bSyEdfsvmOMoZWNz04Mj4/PJ0wGqitU1VBbGbJnro9OZ5SSxobasFvidj4TG7t1a9z2tTZWVwQ8a/Ph70N331f20UvWZPZlwjaTi+PDg2MLibyFsjdYXtVQ6bAXxvrHMu66zY1lTqcqEKPTQyNjs9xT09hW6V6j6ePBfbQ07cMaPkUL287ERof7JucSGQsVZ7ikpqUqiMZE361pKdzRUF3icyJAamF2ZGggpZU0tdb4NW0Nds9Z2kdrs4qRh6PsSwoSCGEuXHvz73/x0a0JJVJW5nOIvBqomtny3K70xz/9+W2289t/9lpZSGNgxaaufPCjf7kceu1/+n7I59PXZnoqOubsuU/eePuN4xMQLq8MaAJ0NbR44MUd0oU3fvHxjOOxv/jLmpAbOOZjE2d/8Xc/tzb/2x+8Wh3yCpt23zoBnOWmr19675/+6dMo+stKAk5VMuWyjbt6qp0D7/7jLwZa/uo/fS/kdmkCceb24Z//8rTS9J2/bqv0wBp8tlN0gGM6NnLmV//lR5/Nyc6SSKlHsXPu0qb0zqfC2eM//l/ede/7P/3gpbKASwBPjd449ON/7A09/e9qS72aLtH+I48eZV9SgDiInFjsPfnBJ2en6jd/7Yn9HT7FyoPq8oW4NDvRd6tPqY9nbQBAQCOzONF//UY6msvbAEBTBj1yAEzM9R7+9JNTg3znS/v2bvBrtgChBEtd2sT84GDfpKs5beBShxUjMzd8s9cqXcxY9DxxHQHgyYWR84deP3zZ9fx3tu3eUOUGzAlnebU3Mzo/dqv3hitmGLh0TGQTU8P9txRH3EDGGNXxRw64nY5OXfr49Q/6tIOvPLZvY5MLrBx3+Mv9LDk/M9B7zd+WyNrAGAOwUvHJgRu30xvTtk07jxSGgs6+a71vDT0i+T0BY7YlFoeGpjJq7fbHD37tmSYQyBhIkJmKDQDnEud3Dw4ALkkSX+uHS9EAhsgWRgan4qxs/xPPPre/VZMRkQFD25pjnEsS53f3FSxvoL23vgAk49GJgUER+e6TBw48vrFctwQyADlxeULiEr/nGIH7jxryKAEwK5taGBkYz1e9uHf/0y9uqREWMgZcyk9eGgaQHnaGpt33e7CFncvm0pn0muzMxxhjzOVwut3uQrs+F2j2RURENAxjbQ4CYIwxzkHTdM4pkv1eENG0DUSQZM4kIazl8VJrtfqvO7ZtCc4kWeK40huVKgK5Bwq0bQsUSQbGbCGEQAZrsDfouoSIlmUxpskyAF85QzM6Q3/JEDGVSc/Nza3VTuGMRUJhl8tVaEGoQLMvAJiGuRBdSGcyhfYn+yIQUZHl0pJSh8PxqMuyhq29HU8I+V1QHS8GFHj/yJZaAx91KYpKgWZfxphAYRhGNptdo9nXUpQ1PWsjIYQQQkjxKdzsyxhDXKtdZuku7csEbGnIxPJd0NJwNlz+B2BLP63FW6T1AWB5PwFbWrVgaZct7dClGe8Ztf+te0vHwnJNX13JAWDpQgBUyQvOykUO7u625V25dAG8p4rT3iOFo6CzL1m/AECSZGCWmTPMvCUAEZEhR850p86NXDqTyVqWxXg+l0tn0+jQHFyS6OlboZBkmTO0TNO0LFsCRIEMOKCq6wqKbDqdNi1L5qaRT6XTpubTFEV51GUmXy3OuSQrwjYNy7IsWxZCIHLgsqLrDmFnUvG8kbdsZifTmUweFbdD1xijOl4QALgkSwwNI2eapiWEjYiMM+BcdziAZdOJXC5jC1Xks5lE1gSuO3Sg4W6kQFD2JYUHkUkqL2/rqA9fu3362AdljrmIZuWQ686y9oaaDT2ln31w6t13yniqw28Onzn0QX/at6m7yR1w0eS+BQAZMChv7qqPDH128aN33mU7yhzCZha4G7oawy09DWX9H5x45yel1r4mLTFw7KMTM2bL7uaKcEjQ7ltHEH3BksbOTuX1Cx98UJ2fq/epLGvK4YrKSLi2tafi45Mf/NOvlCc318qxS+9/eGZBanysvd5HkxgWAkRUXb6Klq4m/4dXjxz6UIl3BiQzg4o7UtPpDnd0t3nfuvTGG7+y57aWGhPnP3r7atbX0tlequoSPRAlBYGyLylAiEyRPO17X/uufbR3YPLiZ3FVAe4qbeoJbVBqtn/th3/qPnFjeOTCsTmJ5bJSy8HvbnpyX5PfK1F6KgSIjPnbDz7/TVU9Mzh/+finNxUmewJ1G0pbWVnb01/7tqafuDHXd/LYpGyms+4t3/jbnU/vbg7rtPfWERTCEajffvCHPzRPjkdvnz02okiK6q/d6C1vaO3c/41/m/NenJi/efrYMDMScunubzy176mdVU6g7FQIUDAtULbxa3/1V8qJoYXhs5/OqpzL4ar2naVKdUn3C3/xb5STvTOzV44fUe181lG//9sb9+zrCOoKrWtBCgNlX1KYALi/ftcLwfqNA6Mz0bTBJNURKKsvc+gOT/tT3yhrHx8YnYlmTVnzBMrq6mpLfSpwui4WDDnYsumpSEXL8Nh0NGUykJ3+8rpyj0N1Nmx8MlzVNjQyMRvLgaT6wrW1DZUhp8Jxrc7hQ34vgmm+2rYnvxtqHhmeiCbzNpOdvpLqmpDL7W7e9OKfV20YGZqMpgwhu8IllTU15QG3Qo/MC4XguqO8e/+3SptGhibnU1kLZT0QrqoNqy53SecT3yprGR4em40lDdA84bLa+qoSr0Oibv2kUFD2JQVM9vqrfVtqOpbPmCtDCJF5AzWdW2s7YWUzW95OCgaC7AxVtYWq21eud4gCkSEy3VvSsKGkcWnoy9Keo7uW9QgZ51qgrClU3ryyZaUucy1Y1hwqb7m7nQ6RAoMMuOwrb+ypaLp7gl4Z4+aIVHVEqu8/QxNSKCj7FjPOuSRJkiQ96oJ8ST5noPBaHz/MOX9wDRQAWNp9j6pUXz6Ah32Ztb73Hr77vspPX6rjxZEtPu/PuOaPEsbWQR0v2r0nSRItU1VkKPsWLSHE9PT07du3TdN81GUhvwnnfHZ2ZmFhYeXcCogsk8lMTk719fU94sKR34ZzPjc3m0wmv/r0aRjG+PhEINCnaVpxZN8iNjw8vLi4WFZWtvSjECKVSo2NjXm9vrW7ZNc6IUnS2NhYOp2mPVU0KPsWJ865z+e7cuVyKpWk6lrgACCbzcTjiba2NkmSAJiqqtls9sKF87OzM4+6dOS3AIBMJpNOp1VV+yo/V5ZlAH78+PHe3l5ZLpq2w6IVjS4aRr6hoXFpYmtFUdLp9KFDhy5dukT3LQWOcz41NWWapizL1PpbHCj7FiEhhKZpL774wuzsLM2aWvgQGWMIAFVVVU6nExGrqqoOHjw4Nzcny1RDCx0iQxTbtm1ra2vj/CsabymEiEQiL774YjKZuLNICClktm07HI6mpqalp+e1tbXPPvtsNpvlXKK9V/ja2tpcLldNTTXnRdK/aJ2jK2sRQkRFUTZv3kK9HdYQAFBVVdM0xlgwGKTdt7Zwzp1O51f2cUIIr9e7c+cO07S+sg8lfyBJkjRN45wzxioqKkOhMD2UW0MkSXI4HJzW5ygKlH2LEwB4PB4AoBvUNQFgeST7UouCLMsej4cW+l1T8Cuei0CSJI/Hyxij42TtuHuQ6LrucDho360V952iyVpH2bcIAUA+nz916tTw8PCjLgv5opxOR1NTc1tbm67rExMTvb3XZmZmaLWHNQERnU7H1q3bamtrl1r1/tg453NzcydOnIjFFulavFYEAoHOzs66ujpEHBsbu3LlSiy2SPF3jcBIpGTbtu2hUJC6GBUByr5FCAAMw/j444/n5marq6spPxW4pbFu6XQ6m83V1dXpuj4+Pn7ixInFxcVwOPKoS0d+CwDI5bITExOhUKi2thbgq1h6jHM+Pz//4YcfOp0OekSwJsRiUUmSJUmqrq4WQoyMjBw9+ikA9/v91JRY4DiH2dlZxqCuri4Q8BfRtHTrF2XfIgQAtm3Pz8+3tbW//PLL1G20wC0NIj5x4kQ2m7VtmzGWy+VUVd20adPu3Y896tKR34JzPjc3/w//8Pf5fP6r/FzTNGzbevzxx5uamuliXPh6e69du3YtkUgwxhDRsgyHw7F9+/aOjk7q9VvgZFk+fvz4sWOfGUYeEb+a+1vyR0XZt5hFIpHGxkbDMB51QX5fwCXOgcPK6kAChRCMcw5M2EIsnX4AOJc44N0tawznXFGU3t7e1QlG1x1lZeUNDQ2PsGB/GIDlVR+WfkQUQghc2nsohL38OAK4tKb3HuOcu1xOXde/4sshIpNluaSktL6+XlGUtXkxBoClSr5ylAghhEC4r0YvHUqrD5u1J5lMjo6OrtoAuq5XVFQ0NjYu3fGuQUvn3rt7b6WOP2zvgRDWWs34iqIMDQ1pmk69HYoGZd9ixjmXZXntNirY+WQsHk+k8hYyxpikOb3+kIfF5xN55vD5vU5NYkyY+fTiXDwneUt9LlWV1t6lcWk33bdu0NKaT2t5jjPLSMeisXgqbwtkDCTZ4QsFHSwTS+a46vEHXQoACMvIRmcW86rH7/M4la+iq+yXbWk3PZKL4p2DRJblNZl90bZyifloIp03bWSMgezy+r0uxUzFEnk1UOZ3yjJnjOXTi/FElqneQNCtrNH0sVTHV28BgKV9t0YTFQrTSM7PJjJZ00ZkDFTd7ff7FJFciBlOX9Dr1mXOmDDSyYV42nZ4S3xO6SvpDv9le/D8TNa6tXtlJV/IGh6XivnZK2/+9Ce//vD8REogAgSbdrzwJ3/7vP3m//yj63zP9/76O/s7fQj5qYEj//L//Yfz4e/+p7842NTkt+y1FvV/wz5aq/uOMcxP3Pj4Vz/96Xtnp7N5C5kaLt308r/5203Ge3//88ta+zf+7X//TL2qSPnF8RP/9f/6/7vc9sq/+f6rj9e5rbW28wqgiq3V4ecAmJ4ePfPG//aP718ci2UFoKSU7nj5T1/aUTr41t/9+Fbbv//PP3yiqspt2aL/9I//4Scn5JYf/Pv/eLBGWpsPnB9a6LW67xgAWLnF/vM//1//28dXbs0ZAgWX67v3/8k3Xw0tvP4//9PAnu//H7/z/OYKN5MyIyfe+t//5f3FnT/4n77/eMTtErjmKvka3EHkt6DsSwoQAMubqYsf//SNQ/3Bnlf/w74Ov2xbktMfKdW03unR4VG5LZkTDBgDNHLxmdHBITNmGILuywsBMIbz53/97puHrvKNz/27vd1+jTFFcgabQnB+ZnRkxBFM5BEZY4B2PjE7PDjsX0gbgppV1hMuZab7T7z7jz87bT324p9v76x0c2Zzb0VDIDt8fmp4YCgQN01cOiRyybnx0WHVl1iz3beKDABLz82dfeO//OyiufnFP/3uhkYPsyzNE6kJw9jw1ED/SMti1hTAGILIJxcnR4bnGhNrt8MKKTqUfUnhAWC2KeYGbtyaMCJP7Hz6lRe7tKUOvlZyLnWbS5IsS3dmGAfgkizLEqfoVBiAMcS5wWt9kynn7r1Pv/D8Jq+KQlhmxsaxK/ftPUZ7b30CgOTi7EDv5QXt5cf2PXNwe7WLoW2ZNo9fHZMkSVp9TCwfJBItK1AYAMDKJqb7rl2fCDz1b558+pWdzTLawhaCxQanJH5vjQa+XMcfaZkJWY2yLylIQmAmmxOoud0ORbVNc6nPqCTRbE5rg5HPWSA53C6HZJumicgYl7ig8ELusCzbyBuK0+vROROWaQtkwLkEDBhj1ERY0ISws9k8A5/XoyqyME1rqVc/Z3QXS9YAuhMjhWpl7PCjLQX5g1A/OfJb0UGyRgGjrrBkjaLsSwghhBBC1gvKvqRQLTUoANw/swwiLm8Gxu78HzU/FJg7e+++rYi4eqcu/R/tvXVq5Wh4yOZVR8mdKk6HSSG570x8z/YHTtBUx0lBoexLChIwpsgyMNswTNsGzjkHYIgMmKoqzDayubxpAwBaRj6bM1BVVViTU0cWKUmWOaJpmCbe3XuIiqJIssjnc7kcAgdEM5vJCiGrqsRpabJ1Znn+cdMwLFxaAAEYQwRJUhQF7WwmY9oIHDCXy+XytiyrivKoy0yWAYAiy4zlDcO2BSxPf4sInKuqgkYmmzctBADLyueyeZspikoT5JKCQWPdSOFBZFzhJZWVQc/F6aGB/hsT/pBkm8g4VzSturkp8NmJm1cuXemu7vQaw9cuXRqOOloO1DrcDmpbKADIGINAWXXYMXhr5NbNwdZg2CFsZgvmCgRKGyorTlwavXz+5LbQJr81ef34udu2UlNfHfJ61uDEn+T3huhye0srq9jtoZsDw/Vh7pXQtFB1udyBqtoGx4m+88d6uxRHrZq6evbSwJxZ1llXGQGgIQCPHiIqmrOkvCLgvDB6a3DgVrnDxyxDMEXXHe7q+ibvkevXLl27Vu1occRuXb7SOy08m+tqVFmlvUcKA2VfUogQNNm75cA3n57+1ekP/vP/+ahTYgy81d1PfuvfP9/65EuvDaV/femt//eVD3Vg+bytle780z850BYMKWt0Wdwig4yxkq3PPzeSSb3/7t//j4f/hQPK/lDbM9/74VOdj7/60gz+6tgv/vP/5V1NQsu0Mbj3O1/ft7E2ALTz1hFE4S5t2vX8dwfG3/jon/6nT36kSYzLwe4DX/vGy491Hnj1h1M/OvzG//7/eOefVcBcxvZv3P+15/c26xR9CwIic5eU7nz5L5+ffefU3/+nU//ikBiDypadL3zrzzfXP/WdPxv60ceH/u7/deSfNG7nc9zd9txrL+2od2oStU6QwkDZlxQgZIwzHmp+/LUflm4emIhmLGQAuq+0vtrp9Pi7D37XWbt7aDqWtRC45gpV1La1NQR1hdHc6YVCC3dse/EHgebdY7GsYTMmOVwlTbUBh9e15fFvBss2Dk7FcoYArrj85Y1tLbWlHolmvl9XUHAt0Nj93J//u+q+iWgmbyNyyVna0BrxeHztO775N/6u4aloJi+Qy05vWV1jc0OVB2hSiMKAyHVX1dZnf+CoGZqaSRq2YMC94armMqcv0PD4y38Vbh6eWkiZNnLZ4S+pbWxpqPIoQDcupEBQ9iWFCQGYGqjv2NXQdaeTGKIQtkAG4ebuktYNd/qOIQohqMm3oCBz+Ko6ttV0bb+7m4QQQiAE67p31W+A+7fT7ltvECXdGWnd9lT7gweJt6JrR1XPvQcJ0kFSQJBx2R1s3bW3He45E9sCmVrSsbusC+gM/ag9ZCTio1+EvTBQ9r3P8oFSLMcGPOzYX0MQBdr3bFn6NojCvnc7W7tf8/P20Rrfd4wxFOJhe+nBvbqG994j3k0Aa76OP/wgecj2tXyUfE7h1/zuWx97b43uI7QyyXginbdXjaPgkurw+L0Oma/zRnjKvqugLYxMIm2YXPe6dE2V1vSxgYipVDIajRqG8ajLQn4TznksFsvlcg6H485G0zQTiUQ0Gn2EBSNfBOd8cXHRNM2v/upoWVYsFotGo4qiFMvtetFKJBKGYd75ERFN04zH4wsLC0LQIM+CJstyIpEwTXOt1DJgZj4x3X/27OX+sdmkYa2UGkFW3CXVzRu2bG6u8OsKrI2v88dA2fcOACaM9FT/6Sv9qUDb9s3tDaUuEIwtPSNYS09sEBEAdF0fGOj/6KMPLev+G3BSUAAgFlucmppqbGxcyk+SJGUymRs3rtNFsfABQDKZyGaz/KudY0+WZUS8ePHi/Py8JNEEcYVuenp6cXGxurqaMQbAOOfpdPrChYtzc/NrJVGtW5Ik3bhxQwh7aSq3Qt9fwMFMLPYfff1ffnUhpvpLAl59OenZ2VhsLnrs9EDG9RfPbamOqOt3iAxl31U4CCs1dfbXb58Tt1Isb3fV6DYyBEnRXH6vU5H5mnnqoShKd3f3zZs3z50796jLQn47IYSuOyoqKlRVZYwFg8FIpGRsbOTSpYuPumjkt7NtUVNTE4lEvrKLohDC6/W2tbXPzEwvLkbX4gPZ9ca2hd/vLysrW7pHCgSCkUhkenp6fn7uUReN/Hamaba2tnq9vjVQ1wDs5OLczXNXFvNSx8vfeGl7T6VjaQB5fvzyxbf+tx9dv3Kpb2ZnS0VJ6P7b9fWzDEmxZ9/faUYcsJHlLQPzqdETb/z9wDGfR2GIQglUtR343rd210Zc0pq4SRJC6Lr+6quv5vP5R10W8kVxzh0Ox1K3h8bGxvLycuqssoZwzt1uN+f8q7luCCFKS0t/8IMf0EGyhkiS5HQ6Oeec846OjtraWsuyHnWhyBelKMpSHX/UBfktgIFp5JPxRSYrdW1dzU0tNSEUyBiXJEdWdDX9vG8slkwapslAvztxCiIKYSEigLy0UsnK+wFfHmVTTIPkijr7LnW3X1ot6AsRAm0TfJGyEgW5yCWTeUBhq2omZ9hra58DQCAQWAN3qGSVpb41jDFN03Rdp923tgghvspLg6IooVDoK/s48qW4c5Douu50Oh91ccjv5iuu438AZAyBgaqqiqxIkg3IGJNkWVZVFdjyCkSrfh/Azufmhm6Ox1LMFfa73LqMDBgDLqm6W1e5JKu6qkhSsVyUijX7AoBh5ONzk4YSCPi9uvLb8y8iqrqvdee3/rw5a9h3p9VCrjm9pWUeja+JRt87qKvo2lVcN9jkjwIR7fsnOyFrBu0+8keCiKqqBXwhzg3DzNpoMgRExjiaQqRNQ+E86PWrinq30Rc4WOnkwPE33rgwErPdDlWROSIDBsAlSQbV6Wvc972DWxprvEUyD3uxZl8GUi4TvfbpPx/ptzRHdUN7V1d7a21l0O2Qlx5KPixaoCwrXr9v8MbVy7cnEjmMtG1qrizNT96eyDmrK0Kg05JChBBCCClcAlzl1Y9992/LE3K4xI2pRAoQZFXTNVdpxbbX/qYs56mtL3Vzwe40kCEDWfGU1tY36kmDAwdm55NT44P9/aMJgzGmejINL+3sgaJZVLxosy9jMpc0lSdmbg4OXbl8rfdyU0N9dUVZWWVVfW1DRYnHrXFgqxcJAmBmLj5w4ddv/uqDa6PxeMaojUrmhqb4+TdveVhrY5nbo8rUGkcIIYSQAoUMNZcWqa6ZOHP54oc3jluCMcYVR7i+qbNna9uep9o5sy179dxVKITscNVvf9rfkU3F56cGh4dGB+O2LUDW/MGahra2ti0dkbCjeBJQsWZfRFt3Bbr3fk+rvH775sj49Nzs9OVPzn+clkoaOtq6Guoqq6obWztry3wOZXlnAohsarr39Mn+OXfXpqbowiiTXJqiyWIxNTk9b1iNAHJx3PEQQgghpCiBGVu8ffgX//yTU3MOb9Dn0TAXm1vI+2v35AMVTze5ZRUeCLGSonqCETt+5er1C+fOXBueSzJvqH77k3vqGjo3bulsrg451CJaeL5Ysy9DBK54InVdrlB5ZfPEWP+Ni1Z8enx8avjGxdRC31nQS3a/8h9e2RdwqkvD2IAxYdvpZIrJevP2zbV9A5nxhEAUtoXCtAu6h/saXXWGkOL2JVZMquOEFKBCrJWci1R0/taFq1G1ZNuLz+9sqvJiauD0kQ+O3u6/cm3qQE0D0xT2QKIBwHx+5trht946cjOm1W3a9eyzBx7vbiv3KcAlzqG4FoIr2uwLIKx8cmFkpH/g8pVTp8/dGJ/LouyraqpobNq0sTw+ND6rcSbE6mnQQJIdHo/MsnPj047FZD6bmp6cEAtRSQ55XJJUoDObCCFM0zQMo5DTOSHrkEBhWV/CWlBCCMM01sCk+oSsM7ZtFdqYRWDMMHLxxUWLBxu6N27c1l7tFFYgPXXzzLWxxYU4sz93GDznkup06brudHjcbl2ys5l4QnG7nE5N4sV1+inW7AtcTsfHTr35/3n97EI8ybgj3L61e9P2zV0tlSU+r0OxDdPimtel35kNAQXKul7S1NnsvXn+449HTMsQOD09IknO0vbutmqXrhbgym6ImM/n5xbm1YRceKUjZF1DRMMwTNP87b/6OZYmms/msnNzc4U/sSgh683SJVgIUTjVE5HJqub1+yR7ZLjv1q1SyPswcfv24ERaUn0hLzy8pIgIqlra9dRLceY5fXXkxvFf3Dz160BJY8+W7Vs2t1aXhQIuTS7UNsDfWbFmX8ZQMMYVf1PPhrrmrqbqSNgf8Pp9HqemcEQGAIAo8G6cBWCgOIMtO7/5fa3y/JXRxaTJGMqOYGXz1m3bOoMetUCHN9q2nUmnMwX45IWQde9Lma7Osu1kKvWllIcQ8uUqvOZQlNyhcPu2DcGxi6df//F1l0NmViYeM8qqt23orOSa/GCHB8bQMjPRubgtl3Zsf7q8OToz3nf56pUbN48MDVz89FBlw86X/vLZ7Q1V7iLp8lu02RctkNDhqQhgpLqhpb2p1C2jQEREW+DDUiwiIgPJGazfstPf0J7OGwIZcsnh8gb8Xl0CeNjhUgCWL62FWThCyB+M5nsmhHxRKFD2Bpr2vvqX/tbbozMpw0bGZKevvLmtva3exR/W15dzMxnr/fC/vntpPJqXJY7CzCUWFuaSqXTeTscWY6ngtsRjBs1xVvjAIcsuNXXl6tFJCJX4vM0VDoZsqXX03usIQGr43MVThz/ryyIDYMA4wMqaJ4i25Cmt2/H80xsqAg5eUBcgWPGoC0II+Y1+vzoKhTmUhhByv4KqqcgkxV3euCNY1p7O5S3BGJNU3ely6Spnn9Nui4xZpm1ZJmq+gN/rUiVW38JkWXW4Q263w1XSVhbWi6TRlxVz9pVQsGxyYmyo9/YsV2K3qyIaE0LIvvKKzp076jyOu5N8gJ2LRyf6rvfGBbv/+EVhy6EENKRNG4vlhocQQgghxQiA5+LxyRsnb8ymDZuvpHIhJHeoqmljT5VHUu6b4wwRZae7cffzr7TG09zlc7kdCgeJy5rT4XT5XZrEuaQoUvE8fyre7MvyQmRMuSwcWkiOXzo1dpExhsLWKrs3uDs3Vrlcmrw0uRlDdJW3b3r6B66e7EPeBgXXvcHqErcKhbbT6UkoIWvC71lPP2cBSkJIoSmkmgrciMVvHvnFj89Px3ISh6XpKAw7UL/tmT9t6S53M4Xf15KHKCuyPxwcH5+anRofRQaITFL9lTVtPT0lmkPhRdbyV7TZF4Wqums69j/ry+QtzoExZMiE4K5Iaa1Lk2H1pA1Ccjj8pbXaw/ctyKrTq8m8uGa3I4QQQkixQZQdjtKWTVulxbTBAYAZ8YmB2/05y5ZVlT2kzy5wsDLpsXMf/+JfPx5IZTM5GwEkrrtKSra95vrB3vaIS/28zhJrU7FmX0ShOnzNW56t6cpkMoZtIwJyrmoOp0NXJA6rWvyBZWduXTn28Wf9OXygXx6ikL1lDbu+9sKW6qCT4u+aBQCre2QVepv5wzpy/+5lXn6XQv+yhHwZ7q00iFhQbXEPAOAPdBFF/F1n0lx6F6ri5C5EWwv6O5/5frO1FFcBzImTv/z5P7/Zn5ybTzPbx5h032sAc8nozdOnR5KsYVtb4tZkUvaVBMOx/osXPr3y5PbagFtViqrTZ7FmX8YA0Mqmpm9eOXOxd2wxaSJjqresoXXzho3NVV55dcdekJlhpOcGB2Yf2t9XCZmuzrwlGPX3XZuQMSaMXC6bzRmWLZBxSVYdDqdDk7/C4QkrF+YvdHUTRjaTyWQNcedRGoCku10OXZO/YJER0TbSmUzWRNXhdDtV/nsOuCJkDUBhG7lsJpc3bYEIXFZ0p0PX1a/wErcSZr9IFUcU+XQsnTftO3UcuSzrbr9TkfgX7F8HKMxcOpE1ketep64oxTL3KvmDAHAznZq4dXZgIWPYSxeexODkopFKZWen54VVyuDeac4AwLTM6MKiDeHObRurh6KpYbmhrbUhtnDu3OxC3LIsBkpR5Z9izb4AYGQWbp346T++dXFywZAkDgyFJU5dvjW08Kd/9WyT7lZhuQUfhaOiZ8fXK+qfXJmCflWLATDGVYcrWOZ3PLgANlkT0MrNTV6/evr0+ZsTC1mbc9kbqd32+POPtZe5nfzO/c6qdpO7K2gtx9W7/7/q15b/7YHJQ5abWlf/DqIwDcMwLJRVXVelldsoePCzGWMI6aGLH3zyycmBhCRJEgfGGPCSLV87sHtTT4W+0gv0/vKsHmoMwMz8/MCn73742bBofeLA1w+0+0DlKzPirS7ivS+l1iOy5gCz88mZgcsnz53t7V/IGoJJeqBh075dO7e1l3DGHlLF79bx1VX83h/u1ApcmqjjzvZ7qs/dl1hGxjBMwXVVUxWO97zF/Z9t5jI3P/uX988OzCZVRZYAhLA9FaUbn/mzfY1hjyaEeOD8c+/7MQZcysWnrr33d4f6TN+OP3t2Z2uD3xYIn3NyuPttqIoXO+BmMjl05v23r84mchLnjDGRTyfzpeFwdWUQ5PsbfRm7u7otKJqmypJkZxcX56ejGZDDDrVwFu740hRp9gXgdio9c/P8pcloYNcLT29tr3Cx1MjFQx98euv2qesTT9TWeVYtaM0d/pAzGKlijDGGws6nMznTFIwxLqua7nYoKEQBrupGfisAtIzFG4ff/tUnh68lNX+woswl4onpgekUs4TE2EOfi97dtPof7//FlZ/vf/3DXpOLDZ45c/TiTbNm5wvPbqh0OSWGD3lLxhgwFMxMzo3cunLhZiZU2VAXcskcGNpCIIpV5X3wxUtPPlcucSIXn+i7eeGaJTdtzcPS/dxveukDfzxC1gDgPDM1c+m9H/3rkdvTlremPODSjPm5hfn51Oce7uxzqtF9v7nqRPDwzXd+ALRz01ffO3rqerriwLZduzaU/obPZgxsYS5O3rh2+cqC1FRXXu5zIqIQTAhkiOyh55+7W3Bl0jzbyM4PXb56OV9S843HzdVp9zd+ZVLcEIXm8zbvfuHrLZm8zfny3RIonkBpdX2ppEn3d91FREVWgsGAIs0vJvLhPPK5G5emhq5zp6dpa1ul5lSK7egp0uzLGFiGmYwuGLK7pnvTtl1balyYLxETV89dm5ybi4v7FrRGRLRtYCIXm7zy0QdHrw/NZwUDhgzUUEXrjv3PbG8K68XV5L9OAJrG9K0LN27csqpe2v/0gSeaFDsvULjKAwpE+65evHKpb3IhL3nLGls39Gxs9OHMtWNHr89pVeVBYS+MjcwzV2ldW5MvNTEwPhpN6vUbd23pKrcmLp05fzNq+UOu9OR8yrZ97Tse29BRmhs5d/pkb1qp27x/d7l79sr7J25OOWrr1ETyyieHz49MiVD//NTFnp3PP1GvL9y8duHm7YkUc5dXt2/aurmuxHH3oSXalgneQOOe517bXONWuWCKN1JiD5x4+8L1uKOiplZd7J+YSuX9rdt2b2itdBqT/f3Xr14fnonnGDIGsuxtaHSkZafLaeqakpuZOHf6SO+cp7YzJOYWxibmRWlN98Ydm+p9mIqNXD579tpINGc7Sps37uxqqy13Pcp9RsjvAMBIzo3fOHl9IqF0vvzyCxsbw7qVNRRfpMSTTU8NXTt/+fpoNGVp/vrO7k0d7TWweP3SqU8Hk+X1zZ7czMTwTMZV0tBUGRCJ8cGRyaxc0rb1sU2NoWjv+yevzgmXR5LTi6NJ2V/dtWtPZzUOnTxy+XY82PH4jq1V+alLJz+6bcqlLZvYuZPHjx69PG0Gp2/0Djy2c+O2rWEYuXT6/MBM0pJ99R3btnW0lAflO5ceFAJtDLfsfPrA/o4y02KyQ3e7pPlLH7x9a0atKA+iHR0bmUV3ddeOx7ZWOfPJkStXe2/2TyUyJnJE4a10hUpDTHW7ZF2ReHrw6pWzF8aZt7w0aI8Pj8azenXP7l2dtUG3NTt87eLFK/1jadRD1e2bdm5uCLv1wpqunnx5UMguZ2X37oqlzjSMAfDY4JUL167fth3llR4VtfunbRCgeUs2vPBtfV6paVBL8z5vuMZ0uyJ1zR0bustXTQlbLIo0+yJDWZacbi+3ZkevnDstJYedkB27ems8LasRn/vOndAqAGhk4wMXP/z4/RMLSllZZdjFs/MzAzd6h2NqXX25pyqoF9dAx3Vg6YFhJpk0TRGsaWnZsHNDvckAGNhGcqL3yK/f/fDU1TiaNijy+ZuTC+aL+1uSfRcOv38x4Q6GXA5jdnoxazki9TUBMxFPzkzOY8k0d7t2eRZunPr4rd6YtySsWVYmNi+uzYKibnfOXj/10btz+o7w5k0+efraZ5981Ot97OkWtzeWiMdTOdWRTqeSyVRu7NzZzw59fHwokROS7lD6p6Ly17++scqvS3ePMcnpCtU1d3W3+h1cIDNzdv/562cO/epqpqS63m1EU/PTUfVqXPW4TXX85Lu/PjmYYKqLxYb7F3J6/a5vlzcCW1rMkOdj0f4z7799hUeuBTXbXhibSesV8zlPmb/FuH78l69/eHFwUVbQ0q7eTsdeOvj0nmrvgwM/CSk8wMAy8+lUQmh6oKmzp2dDa1izkDEQ6bErFz/66RvHBobikmJl8Mr1vsUXv/l8vTLee+rN9/vD1TVeELmZ8QXmjJRH/LqIzyxEF9Pe4Tln4Ps704Onjnx0cVZEQiEpH09lst6xBUn9dv3QlWOHPpmoZvVtGyKZ6evH3j2ccXQ5ampjqWgslcrbjlQyncok5+cGBs6++d6xa7O2xpFd6Z02nnlh31NdQe1u2Tlj7nBVU/umjTV5iwGDXHSud/DcofcuJlzBkMthzs0spK3ymYSn5OXK6TPv/fqjKzPgUTG1MD4Yk5r2bH221I9LC5Yylp0evnL8/cOTUmlFWEomYrNzorwfg15Pc3Di1KHX3/ysfzGpuFS82D+S4996elND0AV0QStKAMw0EtP9vdeG5tJZmwEAxEauXbzcm/D1LS5u7N64r7M86FLF6gcMXHWUtW8N2CCLnE+N1LT2SE6nxxf0ORWZAxbb9aBIsy9DlD3uys4tXaeHTh1958eXjro1SMdjadvTvn/PhkpdlR9owQcQuexc/7Xbcaze89yrj+9sCvDM4LVP3/vFe4NXb04811Ua1FUa7bYWLXUCAESGwrZtZAAsm1u4eerIqVP9WH9g34ZIauDYx2dOH5Mq2yurDCufX5y1/DWtra0l3lunj9waS8vhJzZsavCmP7t463r/yNamJqcw00kj6/I17eyuiJ9792jvqQs3usqbfLZp5g1uCmTIhGXk86YlB5q6On2zg7dm8q76LQde2FvnUXv//tSJ86PSlqeea/bMnv/os5PHSrp2t5R6HBK/U2grvjhy7uivE7ccGmeuqrbWehNtK5+IZ9VyV2dbNZ+IHbp6/Vrf6CY1eeXs8Svz9Xtf/vo2/erh2Y+v5kqqKgPelJlJpqycaQuUhJXOZJNRo35rV20ZnjpzcXDgVv9ghyd14v3Pro+GNh/c16gPHD1y9sjJ0vKurTVuDWU63MnaAHc6+ti2sGzbEsjl1NzotePvnriZb+o8sLtbvnns8JVTh043Nrm6hGUmkjlMY+uGTaGQ9emF3lvjsGn71q7S6tFTv741dPb62Cub3MIyjURGbtneuqXEMXTi7dO3T568uTdi520zn7dsgQxRWEYul1UkV1n3M5vnB26NxbMN23Y997V9JePDZ9755OyIVffEwR3u9MVjnx07fqqsenN3sBTvdNkVjM0PXzr2sTwesizNV1bV0Bi0bePO+ae61Hfj5KHJwTNX+h/PXDt2/vqAsv3bB7aWzB1/d+pE0hloaYjAtWw6ZTpN20YUlplYSMi+uo7NW5oWz3x4ceJs79Cz3Ri9cOro2VmzfdeBXRXJE2+fOffJiU1baipCbueDi9uStQ9AZKIzVz94/ScfXRxNmbA0w6+Zz+WyFou+GxtdUJuqg7571izgYKfSIxc+vjC8kDIB2NICtwwll7+qffeu1hKnXlxNv0WbfYXQnf6W7S+9kPRc7p9LG8gAy2t9DS1bdu1tdunKAze8wBjaIpfNCa6Eq6pqGxrqfMzE+EDEbU9kM3nbFkWzkvV6BwCWacVnZ5JWxtnWuX3/S61zR+euHDuTm5yas8osxmXmbdv+7EuvNs9++uPbn05AcMPz33q1Jn9m+OqtiTnTsm2bIaLs99Q8dvC5LWWDsZMX+sdTmXQ253vIx8muQCCMPrfKFc1bUlFbGTYnFmbSmaxe7nGHQ+6UU81OpWejcdOyGfA7pbTii8NnPn33ls4VkEp3q+FgKTBE5qms3fG17+zTpw/fOHk7njfNZDKWyaSdodLGDTs6JXPcd+Rm0rSBobRqhAIKVJxa05PPv7yzcV6M9V0bs4WVjGeic5PIhTsU8AQdHknFmWR8MZ5kqP6+K/ES8ugBQCqdjs5MKo6a1u0H9z2h+Wd6R28PLS7GEmmZIdM94Z4nX3t1r3px8Vr/7Vhp9xMvfHuXGHpn6MP+qGnaiMgYZ6y0eePjB18uz300cezM9WQ8mbR0676KgUySFE+kyvY7HQoTvkhZVW1YmbgenU0DeIIhn9cp67IcW0gtxBIMIrA0wRQAQ2ALQ5c+S4xe0CzLU7Nxp6N2J2PAZeZp3fbMy99snTua7Tsyw8xszkrEkghabUtz147GidFLAfOmsCxbltndflKMIWqllT37X/teBx6fOXljccGw7MT8YiwZtZxhZ7DE5+JuJuyZuWg+mwNw0RWtCAGAnV2cG7x4eTynVHd3VQZcCmPJ6aH+gaG0q6Zzc2d1QFe5wFUTnQED28zPD/Zevjg6n+UcAKxMdH5+Dt3N+3+wYWtj0aWfYs2+jKEA2Rlseuy5iq2mhcuDAwC4rGqWDbJ8/3UdGeOq4guFnXhx8OrV8x49GZIS/VevDM4qjuaIX1XlorrrWYdWzf4JyJgQNgOUFFlRHaqiKQpDZlliaZQ046qqa5omSwwY56BqDlWx5Xsn5OQSl1VFURRJenAx93smG13+ARgDzjnnYNs2ChYbunj0rWGnSFulJSV+XZZWvwky7nRHmjq31gVVlXNffanHKSFjyGRZ0nSHqijS8gdIqkPXdJGKzYzeGubj0ylhu9y6It9fvYGDpjtUTZOlO+1kTNjCzuVGTh35da8m0pa3NOx3ftGJ1AgpKKuqHGMChbCQM66quqpoqixxLhCFEIwxJnFJ1ZyqymUJACRJUlVVtWSJwz3XBllWFVWXTenBfnKwuo7f+V/gXOISMGQC0chErx75cFLjpsHDVUGPuvpmlDFgzFNS397ZXumzLEe4tsYvKXHGGGPSyvmHA2PAQALd6ZCYsTg1MXKLT89Es6qkOV0qM+/L4VyRVIfDoZjyylq2QgghmLUwffPT96JOkWYOX8jnUCSq48ULuKy6IpUN5Ru/+b3nt9aXaAhTZ957/d0P5iqf/os/21upuuX7JxdC2elu3PP1b3VlDAHAANJj5w4d/vDWjOr3OLl0/zpwa17RZl9gdj41ffvs0XO9U/MZC1ceiMnB2vqtTz/dFfRo/N6mX4Fcd4bat+6sG/is79Q7gxdkzoRp5KVQ05adXVUe/cFuEmSNAGCMGXkzbxgCkaGwbEtwkBgyO29aZs6wTMNgTJGkO4ufL0+asKo/1AP7HxljQgjbtm2BuDRnBGNsqW+Fmc+m0lnLFnebT5emOsvnDXN5/jx3Tee2x3d3hIQtZD1SX+6S+aoPFIo/1Lj7wMu7Gr06R5AVSR8Ty597p3CIwLm/oqGmrEo+fPXIf1u85TJSSknlts2NYb8p7h3T+eDXAsYAGGhq2YY9T3XWhzUjL3kq6ysdSOsYkrUCGAMAIYSVz5vCFohoWzZHwUACgWjkDcvCvGnbggMHuDPO557KgA+r4wwRBQpb2LZgDJdGELDl6bOz2Uwqk199kmCM2aaRz+ctDYExVBye5l1P7qir9ELOcIXr6kOInLHl6xHjyCKNW5989qVN1YYNsqLyfCa9/H53i4MCNV2vbm1zXRi4+sEb8Yte2Uh6uts6OptCvO/BEWv3fREABoDgj9RtPfBspw9tANXfGA7pgnr7FiVEwR0ldTu+8eed3nBFVcghyRIDf0PPk1/z5VwVQUW7M8nmqtcglyRXIFyqG5ZgjAEwrWlopPfyyOL1oQmjJwxOtah6yBRr9gUuEomRU+/9+J0zU2nm0BQZGDIUtlppQuM+SyA8sFQFIiju0ua9r32zdHg6aVjAOUq6N1LR1NRY7V+elIqsKcgYcO4OBF0uZWSk7+aV883ch3nbNrOyxx/0aK6RsbH+6+fyscGJqO6or6wIytLYvZfAe366918MK70wNTKSGJ3J5GxHucPpdHDOZZE3FkZuXo4tnupdiGVYCWOMS7KsaFY2NdF35VKpXR3xBF1OlXHV4QuVReycYTGf1wkyvzOZKDCGtplPJaLRBVPlyCSHJ2TYbClk31M24JrTqesyKLansnVzXVllU21LU0M4dVv8hsIjAgrFoXkCYVWaE6ojEI6UKok4uJ0ut4P6O5A1Q1Yd3kBEE2MLN6/fuB2AlJul0syrpKVgaYUYyo/cvnyzRLo+kUjb4UAg4HWn2D0zfn1+fWcsn16YmejPxqbmEwCK1+VUQAOEfCI6cvl0avrMxTHDDC7VWFnXJInFJm5fv3K+ttZQPQFdWRTc4QlGygLmfM7pcLncq3sSoUBm51OJxPz8gmmjpKkq12zB7pk3EREZcs6dTreqSoJ5S+u7OhorSuubWlsifGHwN1Zxxhhzur1ul5czSdLckbIwyxpJ2e+TFQ3pklacEEHR9VB1hdMGK5lYSDJgzEYlVNUo6U6N8QdDLHBuphI3P/nX9y9PRLMcgDEwEtMzE3Hbn83m8SGtKGtckWZfAIaWnYvNL2TzlXtee2lHT6VbLDWS6R5fSdCl8gem6wVg+Uz05sk33j8+E9760v7HN1R6ECVZ1RyaAozOE2sSIle0iq5dG86Pj148+elPb958XxGmwxvpfuYvd3Vsrbs+cf7ir/91QLcyMSXS0fl4d7kj08vuTIbP2D1dJe6OqWEMOLeiC7fe/Zf/4uSZ6FTS19VSX9faKC+W1DgvnR/45Fc/0YSZMWyuADB0h0orKusD5smRMx+8Ppd46d/teGxD3dzElTOf/GzoomJb7rKaPd+pKw94HdLKSYZL5uz0pTf/aeqQJjEGctmuV79ebwLn7N7iLK18wbmkiHRs4uYFayYUGR0cXsjtqzIEf3jh2crTYVdJScXGJ9svvnn95Ls/vn5Mh5xZv+mZZ0raK1wMOR30pOChEJK/oqJnz85TP/ts4MOf/t05ty4xU67Z/dzujU0bH2u6+NHAiZ/9Uy/Eoyl325PtbY2l6mXGGPv8inGnjgtgU71HfjZ7mRvReUOv7drSXlZt1QX1oN137sP5227IJFBhwBnjnEdqGsLBG9f7Tx3L2vzA3r0tW3aXDn12+4PXZ497FJH1bNr19LN1jUHv8lg3AEDORi++96Ox0y5V2Ja3tnrL/u/VWasePrF76zhwXBy/1WvGpgdDg5PR7PauSktw/hurODjrWzZ09FzsO37ryM/+y2UFQXM07HWXB4N+j2IXU0seWQZcyi1MXXj3v7x7fS6RX+6sAwyFs6xl25PfeXVLiezkeG+rPzBhW8m5idHhwdmMxIExK59OJfOBktaNrZUqze+7RiAyWZd9oRKvOqL6y1s6u7tKNXvpETEyFPZDF6oASeKaYo4OXu9NlwUdqt3oZojIZM3hL68IOVXqBbn2IHDFW7vzwHfDdbsm59N5CwUDpzvc0FZa7z3wHV/tztG5VM4CxREqq2tqqwvqya1P/2m42wi11gUUt9r11J/8hw7uqan2etx61/Pf/vMtaX9bZ2l2+Coid+qRti17m0u9Lk0LN3R1NpR62fYXvuNp3hG3ue52urhIpHPe+rbagMez84k/8Qe3zeW4y1vXWtHoPvCnZTU7J+czhsW47IlUNJS7NWlpnnzmqOza/40/r388K1YWVQHurq0Ol/FdLzh8jznKm0qdXl6+9dU/C8ShrKuuTM/ufeX7jU8YEmTnxieuHTl+dFCU/s3enpe/U7rTLmupKSmRt37tb/1xEemoCrocjl3P/0npJlbe2BgJ+3Y8831P9fBMNG0L5IqzrLq1xodYbEMbSNESTPGFW/e/+tdlGydmo1lbIGOSs7Sxs7U+oof/Wm8bn4llbJQdvtKqluamiMtoe+Lr/119xl/b5vcorP3xV79fnXDWdZY4nKJ6xzf+TUleKa0LuuZtwZB5yxp7Nm+rC4PqClY0dLWUBsVjr/4wtGVmwVJ1t1PjZi7LlcrGgNeptz37yp83bBxfNLSSyua2xvKOkr8u7xlfjOdtBFkL1NW3RLSlCVdRVhyNO771/bL9iTQiCmQMhRbwV1f4y3xP/2l5Zy7YUh9QXFrnk3/yH9qYp6ohFLS6X/pecH8ua1jW7M2Lly8c/jRn+r+/f99f/GAL02urykpsx5Ov/k2D8NXXexWP6Hjmuz/cnHA2tJSXldY+9Y2/rugeW0zlbQTF6a9sqvS5H2z/IcUCEZktBAohBHBg2YXZmZnpTCRXuk3ljD+4IBMTqLh9HU9/7682p/M2AGNgzl47cuzw9UlLUR0cpGK7HhRp9mWIkkv3VtdXwIWhK6eOhcVMiZsJZAi6P1DR2FTiUJUHZuwAtDGfTRt2ZvzGsV9nhy+UOAGFkPxlTY9946Vt1WFFog5Saw4y4Hq4ujtU2WqaS91vgUuqJjNkwa5IRXuPaZr20pAWzoQt1KbN+xoQQZJlibtqep6o7GLAJVkCR93WPdUoQFLT14eEbYPTWb5xz/NPdoTdCldkiQMiq+rYWNHSaaGk6opkmznDFsBlWZI9dT1l1e15CyVFk4HxYE+4vN00TUuAJMmqLi3PxcsAUIvU9gQqu+7teACSzFl5RU0TApdkhTO1Zff+RmCMwcL1k+PDtyfSugq56OzsYiaTdcuKt7yjvWarKZgkyRJ4tz/TgAiSIkvM27E51IYMuCwrsqeyZ19Ze9a0EZHLmiJLnNl0pJM1AxnX3KUN20rrNuSMpaZMLiuyJHPA4Ja9dT15wxYIiq7KHFDYdmXnzpfaEbgsy5zVdu2u6hDAZVmWWKRl97NNDCSL24vCRsH8lR279r2ys3FpZKvMEFllz2MlHbYNsqLIkjDyhi2Aq7IMjoaendXtpi24pMgKB4zsqKjZaNgCESRFlWUJ0F5aYFGStfK2x0qa7217Ay7JXGyKNG9gd84/eyu7gYt8bvrq4Oj4dMZEYRnz89GFjOUWms9f3fV0hwaCyTJnvu5gRScDLisysOqN+yqWT2OyXN26taJpo2nYePfsV1S9N8kqiELz+1qfeMW9MWcJzhgYUzdPfPLhsQWFS4q2+qnm3ZegrDvK27dXrzxGADHni8f7bwzPjE4vWkYE9OKKv8WafYFZhpVOJ3P5zOyV42/N3vQ6dY5C2Gp5R/czP6gMapoiP/BEV4Ckemp3POFoy6ys144oFK/H6ZClolvPeh1BIWzGJFmR7hzwAhljAi0GkqwubcblYKyo6t2Xrn4N46oqM8YYWIGKth0HXkyrTS1lXremqlwgW3mIBFxWVcaYLWwmKaq0UgZkjCuaylYGydkMuKxqS2+P9uqDkUsylz6nct6dvUHimiQDE5bNgYlsLhFN2MhA9bYcfP6x9p0bK8t9igoSrhR+1TveKdbS8lIMJPXOFrSLrm8XKXaIApExebmGLlkagYp3aiGisJEx4NKq45/JyqrXgKJqDAC4BZGGHXsPRuTqruqIqmm4dMJgjDFcqp+MMWGLVVWcoUCQ5OUfl4e/rv4ocbeSA4Asqw/MxMIYYxK/WzYmK5IMHCzb4AzNdHw+biBjPFy7pWFn84btrUG3kysrw924tKqKr/pTLFVxuHOyoTWaihyi4nJWtG0pyyZiyUzOEhBWTMvmo6I2oj9kYS/GGICVSU3dPn97Kp42ARgDnp++MRhN5nMTs/OWWc+guIY8FWn2BQArmVscuDVs5Z019bXlIbfCGGPCVkrCQbfKHzJZHSLKmqem+6C3EVXdoaoyRxRomSYyUANOubhmdiZ/ANRK67c/V7GFqy6HJnH+KC8lyLjES7sff6F56/581rQZ41xSdJdDUySJ1m0i5HeGiBLnVRuefaUTVM2hq4/21I8CJd1Vtf35P+l+ImuYtmCMy6qmOx2qBJyuS+R+AMwykjNDly5e7RudTZoWY4JJWmljQ31VWHvYMQMczExq4NhbPzu50t+X2UYmb6CnodznlKSiO8yKNPsyxkACWdV03Vn1+Nf/+qW9bWFZCLYyAaMkPRhXOOembcyP3+yb97Zv6C4vD6hCpONTw323ptOBVrczoipF1eZPfn+Sqrs0x9JERQVwTgCQuOZyay736q2FUDJC1iQA0Jw+HVjB1CMuKw6P33HPtgIpGik0YMWjfUd+/nc/PR+TFI/LITM7m4iZodppqbKz1qfK8v09XpCBJLsilbX14M0vT2aNQnKW13Q/uaPJ6VKLbeBzkWZfRFRcerCy1m/1jl6+cKnaYVZ4mUDGQHO7w5U1QV1d3Y4LIIxsJjYxPnjuszcP9VdnQAderjE+N3Dikzd/ft0+8Fe1VUG/S6ZhsWRFQV13CqowhBSFwqpVhVUaUrg4t5PR+ZuXbuaclQe+88rj7bU+TN4++uFb718eu9Y79mxdE9OUe8MvCqF5/N3PfK9s80I8k7cEMgYAku71hctKXcoDWXnNK9LsyxiAJcCyhCrlRy689+PbhxWZMSFstby965nvf297iSbf7e8LwLNz/Rc//Ie3z0/23Z5NT7zxk+Gj7zslhpnk3PRU0teAD+seTgghhBBSMIAxy8ynEnETfBW1DXUN9dUuYdmj10v0c5OJxRR76IAOAGbnF0ZOv/nOib7JhA2cCSE5Kzo2H3jphW3VIacExRV+izb7CiGpnoqOp1/xJLL5O1N+I8q+8vKwrkhwXws+Z7bIJ6dn4wnDFCw6P51OSMBQ2OCKtG7du6HW61RoGRxCCCGEFCxEJqua1+fj9tDAtStXfdm4TyT6em+PZGSnN+CFhwzcBw75WOLW0bc/PH12Tqssj4Q8kJqbnDp/7FDSWV37nZ01XldxjR4p1uyLDFXdXdu5x1s5NzO9mM6aqrck5A/osiWpPrcq3bNgK6JQg3Vdz/zFn1df+OzN85Ml2/fsaG0KaQIFgubwldTUhl1Kkd32EEIIIaTIIHeHSzp3bP1s8MTFd14f9Lo0zMcXYlZJ/dYtG8q59mAPBgAzn5kevDGe0Jr3v/bSY211XjTGzx9//703Bi7dnnhlYzm4taLq91Cs2ZcxBiKfmrtx5LMLQ0NzGdOu7nm8pTKeHh+0/Jue2tfiU6RVOxJRcvjCTTv2lFaWejqj/ub21qoKryKQAUMUwrZtQROBE0IIIaSQoUDF463f9fw3sWJgNpoVyBiTZEe4qbm7p9bNpQejLwMUwsznhaT4Kpsa23va/CLvnBs+r+BA3sgjFt28l8WafQEwk5q6fOT1dz6Y1EOu5OxMUq5SzIWRo+9Fnbxje63Lo6n3HADLUz9qmpxZvHH4vUvLzfuIQnIFyzt2bmsMeVReaPEXGaN+yIQUvt9jpBLSvDKErCEF0z6GKKve6q6D32p9PG/ZQjDGuKwqqqrwlZULxOr2PGQoqbq/vNJrjw1++sYv58+XOzE/f7v3SlJ29FREZFUptnNRkWZfAG6msvPDfTPM0bDnybrB0ydzwuF0eT26ORdfTD6s5y5wkc9MX/30lz9698pcTnc5dQmQobCVUF2P2tJZE/QWTJs/MFAV1ef12bZFo/AIKXy6qksPXcrgcwAwXdcDgcAfr0iEkC8LB9B1XZKkRz8fBwCYmcz86I2xWNa0+f0JAZHLSrCmuTIcdMnLUUgIrrrCzTt3b5w/1nvl3McXBAJyWXU3bdv6eGelrkvF9uC7SLPvErSRgeLQNVWSmG2kUkklZXCmKAo8mBcBmJ3PLU4MTqTjUu2W3RvaavyyQIaCOwLlDX6nXED9fQHAoeuVFRWPuiCEkD8KAO73+fw+36MuCCFkbQEpOx+99Pbf//TCdCwnrVrIbWWtWrdv86v//tv7tjX4V9rzECWnp3bniz8M1125MTKXNpCh6g1VNW3saivzSg92k1jrijT7IqLi0CKVVS4xcO3kqYXFibjgV7JZR3zBUbO5NqLI/P49icgkVQlEyn0Oh6io696+e2OFQwiGCLKiu/26UnQLmxBCCCGkuCBXZE+ovKJS8RjS/YsYo+AOl0MRHA3G1Dsdq9C2jbyphmq6tlcIwRggA0lSNJHJW25NhoevhbxmFWn2ZSjA7Qp17tjX3P/JwNBkzgZg8YXZbKiue+uTPaW6Jj2wSgkiqKqrvKIEteGLpw9BfLDEwwWikNzh6g1PPN5e5nNQ/CWEEEJIoUIUejDQ9cKfVe+3bPFgZEXgkuYNBt13+2cAQD6dGjj1/tnB+aTJV3IuCtkVquvZt7ejzFlk8adYsy8wBM1X0/P83wQ3Ti8kTRsZY1zWvcGy8soSWeMPtuADcNMyF+ZnLCOzOHLlxMwNReIMbVuJ1G/ybdjaXOqnoSeEEEIIKVjAmLBEJh6LJvMWPtjBE0FSvKrf55buRhoOIpedunb80xOD0+ml7IsoBLrLmh+PbN7VWgpFFn+KMfvaZj6XzeQNy8plFlMmKpouITIzE4tPTc4uLkbzPRurPbp6/10MCsUR6Nj3l/9DezpnsJV2YUTQPaHqCp9ecJM8EEIIIYSsAjy/GLv1yU/euT6XyN/f5wFRyC5Px9Pfe3n3BvedGCRQ8fo6n/3BX29JZi0ABubMzeOfHj42nwG/18tluciibxFmXwBjbvj8qaNn+hby+VwqlbWWJ3WwcqlkPGpHuje80NBe7nKo8r3dHhBRVl2VrburW628YVqWYIxxSVZUhwK2JexHP3yTEEIIIeTzIZN1PVzf0S0nMtadDgwrs5shSppeEfFoEuLKHKmIKOvOyq5d1cvTQoAVa/AqwM6PuFyKABTFNp1q0WVfYGAn5wYuHHv7yJDNGJNdpXUNTQ3VJV6nzGzLkgLVtRFNlh7egI/55MzQ2VMX+kbnMjYyxoBr4fLG7m072ss9SiHN9EAIIYQQci9EWwv6Wh5/KTI1MjoVTRkWMiY7A5GKyvKgWwEGwJikaMq9XT8RhW0JAQDAgXNPSdOGbTvS2ngmk0XLLra0WFzfhjGGiGqgom3L3oMiMjExPZ3IOZ0uX6iksrqivKKyqjwS9Lh0p648uDQ1AFi55PDlD9/42aHRrMMX8umQj8dihoiMGaHSF7pLfCorqgWtCSGEEFJUgIORSYxfP/7psQu3JpJ5gUzI7mBVz/Zdux7bXuuRgK/+beDAARgiMkArn1lcmJyemp6Zmhkfuz0yl3YHLVswxoqrx2/RZV/GUC1p2PVy9YY9M/1XLp2+cPbG4PTNox+c447y1h3Pvrj/sfIyh/TQfQgim56/denCdMK94eDLe7Y1BaXkQO/xj945ceXMtbG9TQGfqhbVzieEEEJIMQFguejc9Q9//pMPByyN5xNJW3fofPz2yNicFWit3hyQ9bvDnazM4vziQspQ3E4lG52dmZm4fePMhfM3Rmbz3OEKVzdtc6qSxH/jJ65BRZh9GWOMccUZruzcW9K8bffC6NDFY++9f+TsrU9PuIOR+g0tQYk/mGEBmGVZqUTCBld9Z0f3ps2NHrTdEB049dnFZDxlWgKK676HEEIIIcUEAMxUfG7o9jT3NT/zbN3w0TPp2pZGf2Tqs0OxwdvjotvDHOpyfwfg2enrhz9551Q/r67yzl+62j8dNXSX31fWtbt746YNna11FSUBl85pXbe1AdG2jHwul00lF+YmJyZmEjmTa5oqy5/XXxsZ47Ls9noVyEwMDw8OlMsBnhoYHJlalLVyn0eRpa/0GxBCCCGE/I5sy8xlssi94ZJQYEGTs9zhcLgdsojmsrn7um5KusOly5nJvrOjZjq6mM5AadPuJ/Y8trGtqjQc9Ps8Tl1+cJ60Na84s6+wMomp21ePHz166vrg7GIik1fK2nd+fdvexza310vw0NX5AJnscIVauttd5z878ubfn/vEIYOdyyQNHt60qb3K5VCK7caHEEIIIcWFc66qGmfImBAocPba+VifK7YoVXSFA8BXdWBAoYdbn3j+bzq3zk4O3zp37tSFS/0Lg+fen711wheuqmvfuG3H1q6m8pBTkYrrqXfxZV+A7NiNY5/8+tcnro+NTy8Yanlz86aGhtqairKwml+YHjbT4arqkEOVVs/agGjbhhCSp27zK3+pNt0amEplLAEoqa5QRUtHT7PfVYDz2yF7YHU6QgghhHzVoDCaRxGZ6vSEq5orw9MaMgCuZqbHos5gVfeWfft2VEi6tLr9j6uuQNgTDFfW1NQ3tG3c9+z8/ORE/8C13t6+q6dHRyfHFsSffWdXreqWiqrxr+iyLzAw43PD18+f7Z1kjDGF5eKx2fGB5PTQVSFsWy5pbn3itdd8mibLKxP2AjdmR65dOHJ21rnhif0btjxe1tqdyhuC8fT0aP/1c7cvoyvk7yjzOXiBRE0hhGVZ2VxWCPGoy0IIIYSsa8BAUVVd1yX+qMeFoWB6qKTn6VddCbW8VK9xlnc+HrVVV0ldXXNzpQv4A3Oboc0YqK5QdWO4pklY6eSG2Q1btw+Pjk5E08zvlAEKJPp8eYou+yJDtaR+69PfUttjpmkZOcMSAhkyhkYmnUqYuqY90HmFJ6fGLn3y87fH6/XO7W0V4WAo7EbGQI5HR05eO/zGYNhu2tgQ8TukwmlnNQxjYWHBMM0CudckhBBC1icO3OPxyLIsqeqjLgtjtmllYnMLU8mJEc4BGDAwk5ODQ4Yp65trPVx9SDvecgZmDDR3aU1HWW37FiOTSqbz3KNrRRd+iy77MkQ9UrvpqdpNDFGY2VTOWm7eFflUMpnMCN0V9OoKv7tKGzAw8mYunZZBVlWJrzooZFlSNG5hKpURtl1A8zwAs1Hk8nnDMCj7EkIIIY8Q51zTNRQCAB7xGrAAPB9P9H321uvnpxZzEgcmbMsWFvgbtj79WuumKjcw+M3teIiIyLjs9Aacy1u+kqJ/dYov+y4BAAYgaS6fdnejL1By94d79iTnIMnctPPJVMYwDHtpOBzYmXQmkzQAHLJUZAv6EUIIIaT4oKTrobq2TqMkZUrAmBWfGR4amDIt5nTrjBdOK96jU6zZ93e570KGTq87EI4YfdOXTp6qys0EHRyRAVjTl85fG0wp3qZIQFXkR3wzRwghhBDyG6CwHeHghq/9VZu1NDkViJkbn7z31pu3bJcmq4weFbPizb6/G+EtK2vu3tt85ejsqV//6yVVWj420MrlsmpVXffOziqPQymczr6EEEIIIQ8BnGsur37nZ3fnnhf0SMeiWuqxGSDSc2zKvowxFMxd2vbkN/67qq6Bkemkaa/MnYCo6L6S6taWxiq/i5p9CSGEEFL4UKxaw4I7I7Xt/goLuSRzqVAmrHqUKPsyxhhDLjsCJS2bfFUtOXP1Ehacq5rDdWf9P0IIIYSQtQS4ouqqyvB36xFavCj7LkOGDBTd7dcZ3HkcAEtHCR0qhBBCCFmrkILMapR9V1s6Nu5266UjhRBCCCGkmDzqBUgIIYQQQgj5qlD2JYQQQggh6wVlX0IIIYQQsl5Q9iWEEEIIIesFZV9CCCGEELJeUPYlhBBCCCHrBWVfQgghhBCyXlD2JYQQQggh6wVlX0IIIYQQsl5Q9iWEEEIIIesFZV9CCCGEELJeUPYlhBBCCCHrBWVfQgghhBCyXlD2JYQQQggh6wVlX0IIIYQQsl5Q9iWEEEIIIesFZV9CCCGEELJeUPYlhBBCCCHrBWVfQgghhBCyXlD2JYQQQggh6wVlX0IIIYQQsl5Q9iWEEEIIIesFZV9CCCGEELJeUPYlhBBCCCHrBWVfQgghhBCyXlD2JYQQQggh64X8qAtACCGEEEIeDhER8VGXoqhQ9iWEFCoAAGCI7METPwAw9pDtd/916TcYY7/rpQMAGDD2sE/9I/mc7wkA7Pf/Gn9gge78CZZKsfTpX8VnE0JWAAPOJUVR1m7tkyTpURfhISj7EkIKEaKwc5mcYaHs0HVN4ctbl2KYsBERGeccOHBgqy4MgGgZubyRNy0hkDHGuaTqTk2R+Rfo4yWEZeZyhsVkTdNUhcNvf8kfSlh5w8gZNiiaS1P4ykeiMA0zn89bti2QMQAuaw5dVWTpdyoTrATrL55d0Tby+XzeZrKm6zKaWcO0mOzQVFWmXnKEfIU45163W5ELMT5+QZqm8S9y6v1qFXT2hRWPuiC/jzVabEIKAQA3M7HBj/+Xd86M5Ztfff7ZgxtLBWOMMWHnkguL8/NTi8mMwV1+b6i0JOz3OlYSIQo7PXHzxKefnbrWv5hDxhh36eFtz3378c3NEZe4k/7uCYIrtRW4lYgPnvrVz0/cgo6nvr5vT3eZU9wbGu9U7IclyXvbaO/ZiMiW/3HVC5eap5Mj505+9Ppn04Ger/37Z7qCAV0gMmbGJq+ePnH09LnRqI3AmCJpDY994/ldm+tLZcHufNB97/bA56CZz5uGzRRF0xWOq36NsXtfeedFUnb0xolP3zg0pbTue+m5BuPsv3xyfkJ0fvu5fbs6wkIgPOTDl98UYfldH/qXIIT8bgBAVVVFUR51QX5/hZmFCjT7IiLn3OHQEN2sIP9wvwWiLMuc85UnhoSQ3wUACis1efPW1YGsumd3bmkbgJ1NTpx796eHrgzPZQSCrKjB1o7tB158prXCpUrIbNuYvf7Zkfd/+fGg6qrt2lTj4AApC/hSAEPGlqsjrI5+d/4LwjDiYzcuXryquLqfytnwwO/+Rnff/v6tD/0XWPrMfGxqtPfU+fHawB7TFAAMkIn0xNUzh9/41bH5nLdxa1fYJfHMoixJyGS4/z3w/vdc+RMC2tbCjU8OHz466ti87enXdlaBJuPyPzKGK6+87x25lVgYu3Xh9LBH69mXK8sOXbh6aZy7n95jLiXcz/twfOiZjoIvIX+ItdsCWMgKNPsyxmRZ9vsCXo/vURfk96eqKh2yhPzegEuSxCTO7zY0giy7SmraNrsahaykR88cO3v60LG8p2VzQ0TXJI4oEjMDt2/fjvLKp/e/9r2n6hWN2+ms4g8ZU8ffPHvmxmjKsrnqjNS0btv7WGvYkR+7durshd7h+awpnBW1LU09HstGFKnhq4d/sXges2kp1Lhx657H2gN2duL80c+u9E3EcqD66no279y1udqlcAAQZm528MSx05cHJtKCSYqrvKl9x96dNWr69uFPzk5kXF43NxJTcwn0B+u3PXWwrUxOjJ44dLp3ZCIlMnNDw8MMVPluBwtkiYmh/pvX43rPjhf+/Js7vH5VZBPCWRbyZSdvXzpz5mLfZDwvZG+wunP3vm0NkfjwpydO9sbQ7wmL6NhCytTCNTv218VPXDny9q9Pjy4qfb19s70dzbvas2cvjRjOsjDjwbr2xs4q1/TFEyevDs+n86i5y1o379q6pQQQERks/eFRCGRLXUvAiA73nv/s1LWpxQwqnpLWXfu3twdylw+fOT+26Ah4y92G3vRUXb7v4qWrQ7NJQwjuqWzdsnPv9uaQwikGE0IKQ4Fm36UbHYfD8agL8gehZ32EfJkQETQ90r7n+Q7FoarKwiUxM3NpZDA+F8vYAhkAMpbL50wzr/sC5Q0tDZUlTOMIHI3sxMT08MjQwHBO5GJzszFP35ynvGyHf+izI+++9ekwaMFQIAySv7TTzQBsOz5440J63pGIzsczNxYz4frqjmzvB2+9+17vpOrXRUJc7o+anvDXtjb4FACGIh+bGBgZGpww7PT8zEL25mAsUP7tZjZ8+sh7Z4aFt6QkoCQXFudSWLcYaCrdJl0+/P6b7/ZmZH9ZiZJI5xlTV74mMMaYmc8ZOeHy+atbOqorwashAggrs3D13LF3fvb+taTt9Ou5+YSzf1oL/Mnj9sSVEx//8upCpLzBx43c/OiiGo4GX26I5ezlvwzapp1Npkcvf/TusVk7GJJcnU8rQs+IYz97+7PxRTXgN+cXoHcwJ3uf9PCH3bRze2HyxskPfvrmySlbCzrM+dztGUV3b9Fvnz7x9mfXWNBXW+2os8pnbxz66PSlBXc4EvTKbu6rT6L46g4SQgj5bQo0+y6h7EgIuQcASIomMcaEuTi3EIstgFPxRvwuaaXR9M7YLiFsWwgQSycSyV/evffZqh22jovXDr/9346PXjh74/ka74ULtwairp7XnnlmT09E1WThWZgABK6Hq7r2HmiMD1069qv+uYHBgXgweuLTW1NW7bbXXuwyz5798PiNC2evbd9U61U5gqSEarc+9WL7U6gaE6fff/dnF0fOnO0/UF3FZEWxLDNU2vHEJs/04JHXTy32DgzHK/OXL48upCuffPnZp7awM0fe/MlnqQe+KTBEFLYtBBcCkYEQc0PXLlw8Nw31+557ZUe4752ffzx49OjV7U01oCgKouoord23udHofeeda6M3x/hTB3f4EyODE33+jj3f+qtXaqL5K32aLIus5O1obukIwPS1s0duxp2b97x2cFP2xJvvXrh0+nJvXXvkYc+reHxg8Nq5YwMssPO5b+4vHXvjv3566eTlXeXNqKoyCqZ5Szu2NPjiw5dHo2m98dmDz+zuKdE0jy8UlL94vxFCCPljK7jBd4QQ8lsAF6mZoYsnjl0YnHLWN23aWB9UFOnzb5aRce6MNHZ3bdq8ob2tqaG+JijAnluMLkbnzXzeVVrZ0NLV09XW0l4bUiRAJiuh7h1P7Tu4q7U26GIMWD5nLi7M5kVecUiWwdC2pXw6G40lhUDGELjsKm3b1L1xY3d7W0tDdbXfENZCLG5bJmPAPC07djzx/P4NdWV+YEzYQuRyGVvY7khlVXN7Q3VJyM3gt2dDZCyRiKXi6YA/3LJ5T09XT2upIuPMQiyTzQETLFzVuOPpbzyxsaUipEiSQK7qqqopwLikaE6Py6HJnDHkULHtiZe/8439daVSbGHB5XQ1dG/v2ri9u8rrkRdiiVQm/ZB2X4BkLJ1YXFRkoSiQtriSFyIaj2WzWWTIA3Wbn/zGa99+qr2+oswtgbkwNTk+PpM2hOLQBQNqyCCEFIyCbvclhBDGVg33QIYMwUpMXPrgjV++f2xAbt73+PPPbqxwStL96Wr1PDGIwsjGF+Zmoolccnp4ZjFni6VpvwRjDCRJkmVFlm1ZrMwlxGVFVVVFlu+Z1MA2YtfPvjd9Q0XbLKksDXnUpX9GxHx2cWF2djGZS4yPzccMRG3VLAiyoqiaakqrpkzDlQ9WJEn6DVMArZ7tBhiiYIJJkiSrqiKrsgTAhBDLc7xxLiuapiryg1OzcQ58afo0ZMC8vkDA79dynAmbAYAsq6pqyxIACIH4OTF8acKL7Pz0hfd/Nqgxy+OIlIc9upJgyBSH7g/6fV6/aNzxtR2j8qlb/efevHhMKu3Y/61vf/upDRHpC4R7Qgj5KlD2JYQULmQMhW2ZhmEIAGDAwUqlR46++9ah41fjke0v7Tn4WKePKQxRAHC2siCEbVlGLpszDA6cCYbCGDz/+i/e+OjqOCgqZhbnTBbkwACWuk+YhpHPGQbaprXybB5x9ZS4AADAUVID7Xte3r+zvUSzhOwKhqsUCRDANpN9J//lJ28d75+VVdlKRBdtqeyBVSlWT5XGAJEJy7KMTC6XyxvsvukWABgAsy0rn8vmDdkAJmxEjkwCiVmWlc9mskrWMIVARZJWz7z2sHl8bcvIZdNZwxSIDJb7Uyz1IJGYLYSRy+Sy2Zxh20KSPndU+dKCF86S8q0v/OXTLR5VQlD8FfrErz8VuFR6gZLmrNn2wl+07Y2OXnj7X9//9Opw/9Xbk/u6QyBxavslhBQEyr6EkIKFKFhqbvT25VP6hGBcd/p8YXns0x+/8enF4VSos6My7IwN3riRLGtoKHMpCmMAXm8oEAhZQxO9xz8+pDU7Vc7SeXdN+ezw+FjfJAts6d7WlO//+PgQAwaBQMTt9WSmBq+dO+bMljhcTq3cFPeur4YMUciqHIyUe9T++cXo4mI0IcuLJvfq/rqlib6EHZsZGRkdmJUrdm7sKVm4+cm50ZXG2HuyKCIiAkhOb8Cpq7mZof5z76djFy+MMuHAOx/IGHP5g/6IP9c/denQW7WZMp8q5WJ2pCeklUdKwxcHJy9/+jYPDV+ZtMFVX1HicVkCkd33QYwBU3WH5pDS0/1nD70V2FTVmbPvlAjR7w1EqmrMidT1Ux+F0rmzg/GMVFlaEvR4k6sj9NL/I7qD3kAkIvqthdnpeInFjUQ+IIVULi0PzgAGtpGO9Z+7viAztPKCcQk4cC59zvxnhBDyKFD2JYQUKgDGWLTv9JHFvnOKQKWksnnzwdbJEzfHJzMWlyZunfj15Fk90rj94Pcqw05VYYJzZ2XPrl2DE/PHBq6896OJ4zKXnHJg+8vfaS1rrqy+Mj0+PnBLyHmQGONc8dRu2tU1PD19/eSnU9fOhepaNm57vgXFPS2fwAARXO5Izd5nNo6/c/HGoTdGzuoSCzVufzrS3VLlYAiS5KlsbCmrGLo9N9zXnxZZSbrzDve+GQBjoDr9NVu2N1yaunjh+Ie3I6qZZPrqVmIG4K3v2bbriYmFsxdP//KnfU6Fqwi1+31f39a2beuOgemz14/9akixciLcc/CJnsbybB8iY/d+ECADHqxtrq9tvDA83Hf2My9/LFJnr3w7FMJVUte9ff/moY9vXn3/zT4rnXM37Ny9qbNenRnGVcVe7nNh+5qaNu588vrk0f7P3vzRJZWrWumO56u3ePlKpwzOhZGbvXXs8LHRiRjmY3NppbG9pbupVJKowy8hpGBAKm90/Kd/TuaNO5PaWEJ0lYb+7/u3byoPyZzTCeuPBwAWFhbGJsYBwOvxVFZUqqr6RWa3ECiSqdTExIRhGDSFMCk+AGAb2ejAmVtj8WiWMYbIkHGnJ1jZVJLtH5lLZcyltY1RyK5gZUNPZ7VPVQAREURmYWx4aHh8Opm3ERloqru6tafCm58c6RuZTDBJkVXOhOSr7uqudmcWhgaGxuYSho2qP1xR3RTJD92YiPPSxq6Gesfi2MDglTkpXNO6td5rx4dv3hydWkybAkDxRKobGhurww6JcxR2NjF269bgxEwSFE1WgAklWNfR7MsM9A9PZzzNTY31ZfbESN+14Yyron17Q8BKDV7rG5+PGpJDV2UQBjgq2rc3lzgcCiIyhkZmfmJ0YHhoPmkJRCZJSqiuq60uIiXHBwaHp6IZCyWHK1jV0t5Q4s3M3+i7PZBWq+rbN5TJ88PXr01EeVlbT121Jz/V1z8wPJvibn9JRX0gdXtoLuOs626pqQ270ErFp0f6+kbnknmTKQ5feV1zQ23AWhwduNaf0sqb2pr95si5/qkslPW0NdYEcGZy6Fbf2GI6jwiK7q9q7Ch3xEYnBmay/rqGjtYyLb84fPH26EI0g8i44iqpaGhqrA64ZDpPkWLGOff5fCXhiMPh+A0XcQBIJJMTkxP5fF5V1eqqao/bTVNa/ZFIHN66MfR/O3xuNp29E3EF4obSEGXfR4myLyGfD0CSJQ5L47aQMUBEFDaCxFe3pS7NZmaLVZ1pucQ557AyDo0xYVuCAecS53CnZwAK2xYIy5uXVnEQQiBwiQMTwhY2AueSzFEI27IZcC6tfPZSWYQQ4k6PYC5JEtz3/sgkLgGgsG0bGeeSzAGFbQlkwCWJc4C7NV7YlhCrlgnmS5aXKGZL853h0tcDAFj+g9gCkYEkSRKgsG0L2VI5l96PMc4lSeKAKFCIpb8eCste+ihY9aXuvN1S2QDRtm0ELkt86Y8lkPHl9wZ2Zx45tlQeXNoLANLy+63cnNi2Tdd2UuQo+xag35B9qc8DIaQwIdqmZT/kH8TDNq5+obBtYT/wS2iLh7wSH9y86mcUtjDsuz9Yn/vZiMKyHrKGgyXubhS2Zdx969/wZstv+NCv8fAX3rPx3nLeV+p7X4sP/VKr3w1tc/WbiQf/ive8AaJtPXSvEUJ+P2u6haswkz1lX0IIIYSQgoOIQgjrIbfAa4YkSbIk/fbf+2pR9iWEEEIIKThCiFQ6nUqlCrP19LcD5nF7fF7voy7H/Qo0+67V3XyvNf2cghBCCCGPCgAI285kMrFYbK2GImCaoj7qQjxEgWZfxpht26ZlLS27tEbpms5/w3pNhBBCCCGfA1e6PYi1mYVg9WDeQlK42dcwjYVoNJfNsrXYeoooK0pFeYWuaYW54wkhhBBC1qFCzb7AhBC5XC6VTq/FngOIqKoqijV5o0YIIYQQUqwKNfsyxpZXE/rcteUL3BotNiGEEEJIEaPeqIQQQgghZL2g7EsIIYQQQtYLyr6EEEIIIWS9oOxLCCGEEELWC8q+hBBCCCFkvaDsSwghhBBC1gvKvoQQQgghZL2g7EsIIYQQQtYLyr6EEEIIIWS9oOxLCCGEEELWC8q+hBBCCCFkvaDsSwghhBBC1gvKvoQQQgghZL2g7EsIIYQQQtYLyr6EEEIIIWS9oOxLCCGEEELWC8q+hBBCCCFkvaDsSwghhBBC1gvKvoQQQgghZL2g7EsIIYQQQtYLyr6EEEIIIWS9oOxLCCGEEELWC8q+hBBCCCFkvaDsSwghhBBC1gvKvoQQQgghZL2g7EsIIYQQQtYL+VEXgBBCCCGEfLkA4MGNiPjVl6TgUPa9z/KxQkcHIYQQQtYkACZMI2/ZYlWaAeCSoioysPWecCj7roKIwjKFQJBkSeIPuWEihBBCCClgiHY+EZ0eHRmdi2dMsRJmkGu6r6S2tro06NLkhzUKrxuUfe8AEPncwvjQVDLnLKuvDAfd6t3WX2oHJoQQQkiBA87N+YWbh//bP39weXwxh3d7PiAi0yOVPS9+93uPd1d6NbF+gw1l31W4MLITV97+4Mxi7b4/fW7PpioviqV/Ac7hoT1nHi1Y9qjLQQghhKxfwArlSgwA+djMwPmPzvWNW037nthYX+mVEBlwOzl+4/KhT2+fd1/a1VUb8kXUdRt9KfuuAgyFkYlN9d28fjulxYavlHlBMLQ1b2n9lqd6qpxOpVCaf4GBrmqRUEgIwViB1DhCCCFkPQLGNE2VZfnRpwSAfCY1OzZqyOGOXQcOPtVZ72ECGUgsOVjqnrk4dH18ci6byQNo7L7CAgMGj/4bfAWKOvv+TuPWAJhli2w2wyRZmh48d3j8kqxIDG3LXdWxr2x3S7nbpdgFckgAgKqqoWDoUReEEEIIIYx9zsQKXz0hhJG3JMldEg54PU5NswUy4DLzBiKlTvmWkTdR3JdmhGWlYwvJvMF1r9upK0sT4AJIiqYrEgCz7x02t8YVbfYFtC0jlza4w+HUVM5QIP7GEIyIICm+8uZt+7WWrOAcmBCIQghnsKK1RFN5Yd0MUW8HQgghhNwDGedc11UbLdMSiBxAAGMADIVtGqawNU3lfPXqDsC5lUkNn/3o9OBsVg36XS5NZgwAuKRoulNVVT1Y19NYEfBphRWEfm/Fmn0B7FR66tbJK1E1EAmFI+GI3+9zOxWZA8OHp2BEyemu3rL/pcqZ2VgyZ9myNxhwOaV8Mg3eUl2XimOPE0IIIaRYCc0Tru7Z040iwI1sfDGWF8hl3eFC1eEp79zQE+is8brv6ewLzDaN6Oj1yxeH5jOyxIExYWXSiXgikTcZU5z+TT/4f/7l8+GAbhXK4+8/TJFmXwBAMx8duPjBx9dnMyzU2L55w6auptqSiM/r9no9Tl1RGIp7ukMAMCsfH7v28S/e+OTqwGwy79m4f39ns2v81Hmr59t/ebAr5JPu7xxDCCGEEFIgUAjVV9G057VXIn0jk9fOHbrKgEm6J1TV3FBX0fXSf99ic0V3aoq42+0BBcpOT+OeV77Tlszk8plEIh6bmxrov379ZsKW3N5weXVFQNcLoDPzl6VIsy+ikN2emo1PPpNznbl4bXS498jQ9U+57IpUtvVs2baps7Y85PN6XKoqrbT7A4CRTA6eeP/D89cXPR4lnssvZox8HhbGBqf08cXHWwJ+FYplvxNCCCGk6AAHKxEbOP72jw7dWjSZInNA28jZ/vaNB7/5V1/vCSkAQtzb3xdR1h1lzd2+yPzIYO+l3r4r1/sn4hlLD7Y0Nm/ZvWfHxs6mmhJ38XT4LdLsyxCZpgWaNj1V0bz9QCoemx3rPXP44yOnzp8avtV74gO3v7xm8/Pf/PrO7kqPsrw3Aax8bmZ0PCsq9n5nmzh0vS/NZVmSOFpmOpO1hWBMetTfixBCCCHk4QB4dnF64Pzh3imr4qmXnuypi+j56UuHPvngev+5K30HOlweWX9wrBBwLtli7tJ7//rm0WsjKUdF0+YXd+/u7qgt83m8PrdTlzmHoom+RZt9lxb0Y8LMJudGb125cLn3dt/AfFKAMxiobm1V56bnxqajqZwFXuXu4n7AuCRxbnNZ5VzlaKaTqXwizbmiKpwGlhFCCCGkkAEzctnozAIqnW1bt27dUhcGaw6mhy/duJCcn0ug7WbAH9aBE4WdT8xPT81GRaC7rqVnY09nS33IudTm95snC1hzijT7AnArER0+//47J24MDY9MTqXsUKRh+9MHauprqquqK5T43KLtrw85pTu7ExFVXSurqVHOXjjzq0/5ZDxuKcnkKEtZemNVuU9TJVz3S2ATQgghpHAhkyTZ6dSFiE+PjAwHWEYxpsemZxPIS3SnxoA9fOQSgqIE67fu2jxv9U7FBy4ffiPaV1Xd2NbW0dpcGXKrRdX+V6TZlwHYqdzC8O2hpOlr3NTxWEVZXXVDfUNdWdCtKcAYtAJDFHhnjjsARNnlq9v+1NNRfvbK4KLT6QdkEvf3PLn9yd3NAZfCKPoSQgghpICh7o/UdG0qO3fi0ls/mT7l96hmfGp0OhNqbe1o9HGVP/RFtrAZc9dt2P+8o7JlaHR8bHhg4My186fOVjTWNzc2du/Y19NQEtDunxd4jSrW7MsYSooWqGjr9rdv2r2psdyrcYYIKw3397Teo7Bt20YGDByVnU+96K5pHp1PZW1goLoj1Q2tzVVeVS6ini6EEEIIKT4ohOQOV2w8+NxB5eLIQlIwxri/qqO6duOWPe0VCn/IhFUAYGZT41ePX5uIpg3OQHZ4PB5dEano6NT06LXLZ8unne3l5WUhh7DFo/hWX7Zizb7IuMoVXU72DtwKNjVWlQVdElsa1IZ4/whHOz0/PDYwOJZEtrJAMGguJ2OMMZGcHLmRMZo3NUR0TaL0SwghhJCChcidnurtz/3thn2pnGEJZIxJqq47HCpH8dCGWw5WNjV4+r03Tg3MGy6XrskSMIZSpKqxXNEk3eUv8ekKL54WwCLNvsiYKjNNpG9fvDA/zTxKLlEdkAQik3W3N1IZcoIMy10YAFh66uaVQ298PGDhUvRd1a0Fbctd1rTj1bbygFOX7eLZ84QQQggpMgBoZFKx6emYYVpiZRtnTHF4fKGKoBPggV4PAiXdWdmz92CgI62ESwI+jyYxAFBUzeUNexyK4vCVBJ1CFEWjLyva7AvAzLwVX1w0RDZ5+8Qv/tfL7ygyMLQtX+O2x7/9H19s4x51ud8DMslT3t7zJHg2ipVm31VQKK5geYWu82LZ54QQQggpRgDcjI/3ffwP/3B4MpqyJA4Mbcsy82ZZ085nfvA/PN+iyNJ9kzYgouJw1W1+3F09v5DM2wASMC6rDl8oFPJ7NYUDAwZFNOapSLMvQ2RcdoRqerZiTdZaGdYohOWpKPVrjK8et4ZMD9U0estqP2+pPs5lRVPuP1gIIYQQQgoJIpM1R6CqtlbzZW0JGLOiU8PDk9l8hcMXYvCwLAMM0EiNXX7jR++eH53NIWPIAORQa/u+b37/uZZKl1pkq9oWafZFhpLbXbP1wDdbcoa1qsEWFIfbEwRNXjVfGRiJyVt9vbdHUg/ZtYhC9YRqOvZ0VDocRdTZhRBCCCFFBhlKrkjVlhdfbTYtgcAYYLT/6LtvvttvxxbmTRaS4f7hbgCQS8ZufPbJ+RtDWOE3J+OmrLsd2vSVC4eDG3pq/I2au7jyT5FmX4YIquoMRALm6ODAdDSbE4xxzVdaU1seCbkAV0dfJuXnBm8ef/2926Zg989gh8J2V7Tu8W1tKHM5lULp74tYZPNME1LkANhDetn9RgKxyNpaCCliwHmhzIBrGdnFqfHJdN5aOvNk5hM5OxvLzU9OxESjJmn3hl8AbhnZhfGh2Zyn4Yk9dZOnrk8rVW21NdGzP799c3jG2FEDHr2ozkbFmn0Z50Z6vv/s6+8cutg7HMsbgjGuecLNG3Y/+ewLu2pcoKx0XUGmespbup94HlrsO9M8MFj+PxS26i1pqNQ0qYCmtUPEXD6XSCRs235IH2VCSGFBTde9bo+qql/wBQIxlUqlksnCOe0QQj4PcHDoDrfLpSjKIy4JcDs9M3r2Vz85PLGQsiVgjNn5ZGwx7633BvwacHhIihVCZDJ5xj3l1eUleedAFHSny5UFhnnDLMKmtiLNvsC5mUgMnz30ybEbUlV1fUNQ5yIzO9x/4fincrBnY2mzU1VWdj8KV0Xn5squLctzPHC0DGt5HjSQJFlSONp2YbW0AjMta2Fx0cjnoagWWyGkCCGi1+t1aLqiKF+0wiJmMpm5+bnCOesQQj4P59zv9zl0XVXVR5sVEBEUp7e8saXVl8janANjyEDirpqmDVub/Fx5YLECZChx7nTqDOPJtJHPCYyN37gcn8pkFF9bZUhW5ULKP1+GIs2+DFgmkRvrH0K9fN/3//obOzpKZDF16q3/+vf/emXq9kjcrNdBWf38cTnYCisTmxgcGpmaT+VtAYxJsjtUWtPYUO13yQXzOGMFMAYAlH0JKXy/Rz2F3+tVhJCvHgAUyjNYFLKvqvmpv/2PB/id84eVnp+ZnE+CX5M4Bwbi/nkeZNVZ1rSxp2dQ9Xl8kcpq/9SNdD4V2Lhr64EttU6ngkU0xwNjxZt9GQNAzpgtRDYZnZuZtrmYT6RzQrq7fsX9L2CYz87fPvWrf/zV6ekk6E5dxlwqI9zB7hd++MNnNla4dVrajRBCCCGFDIWVTS4uLKbypkBgAJmx8yc/vTgErfu+s7etpLzCrasyrJrtSgjF6W1+4uXgDu5S82VSSXVzD3g8obKqyrKQU+YCsTCC/ZelWLMvou52VjY1aNevHfvlL+fOlnpVc2FksH8Kyvc0VwVliT9kTT8jkxq5ePLC5Lyz+/HHulsrnDh97fLp46euHTnbt7s55HI4iqqvNyGEEEKKCnDMRWd7D7/x5pHe6YzBODAmsovRuXgKe8cWbnY//YPvP95S5ZNX5RkA27Li02NDM4mchbYQAhEW89l0Jpmq6+ysCWgqFFX6KdLsi0IoQV/d7gMH+6MfXem/MNHHAYVQS7u2PfbU3iZVV9gDI9cAzLwxPzltQfmOp/Ye2Npdylg07Danr/96ZnoualgljP1uw7QJIYQQQr4yADy7OH77+K8+uzAbkz1uXVUART6XNy0Lc6l4YmYuYZo2gHK3MQ842Nnk0Mm3Xz8zNJuROGeAwrYsSwvW7fpGaWN5wKGxz1sBYU0q0uzLGDKuequ6D/6pp/3peGZpil8uu0MlFVVhFaWHdXtALnHdpXO2uDCzEJ2POVRcmJuPxTKS7HToEnW8I4QQQkhhE5aRz5iSZ+PBbz+zvSHsQUyPnDrywek+3vn0XzzdEaku8cj39vgVKDs9TXteeq05kbWAMeDZqcvHTx7ujyYlRQf+wJPyta5Ysy8AM4z01Mi1q9fGF1Pm8rS9aFuDkfqF7c9squC6cu+4RRSoOR1VLW2Bkx9fefuXC2c/88qYmp4cj4Jva0ut36HxYhvoSAghhJAigigUV2nt1pdeaq3r2LO5tdzrAMyUy2h566SmnZs31Ekg2eKeR9+IKGmO8q5dZZ3Lm8Gc9ZvZsdGPknPRhG1a9zQTF4Eizb4APBddvHH4l7/44NxIDLksy5wxhpYZaH1MND7TVcYc7IFhi6A6Szv3PP+ydmNoOmFYgqG3tnnn7oauHTvrPI4i/VOtDwAcOOcrk2IgohD3Vf7CAlySOL/nWQMKW4jfqcwAkiRxYL/zCwlZcwA45xxWKs1KFS/cw55LMr9nmh5ERNv+nRZQAuBc5sCYsOxC/q7kK4WyO1Kz6ckAODQVzWTSBmbrZU3bPTWS2y8EMhD3v4SDmYwPnP71qf65hAHAGIC5MDQ4HzPF9HzMNm3GHvG0xV+yYg10AEYmNzfaN5OGip4d7Ust/AyF7SptbA2D8tA2XLRsI500FB7o3LGzrqrELaOiewPhSMDBRUFN70t+R/nM/PzE2OhMNJWzGUi6O1hV01AZdqnKV7ZOIyxFbxS//XqMYETHBkdGJqM5ZCvHHTgrWhqry0u98hcqMSBa6YWB/qGxuAhW17fUhzQmQZFNU0MIY4wxAGHm0gvjE2NTM4mcKZikOgPl9dUVZSHXV9dXDYAD/yJVHAAsMz8zeH5oajGdA7bUnoaq21XWtLE+6FSlL3K1AQArl5oauDiyKLSK7obKoF+jqxRhwACNZHTk/Jn+RCovABhjwDljwh2satpQGnACwH1TlgGAbeSmb104fWpoNsM5MGblUsl4Rgl1NlaFZI3m910jkGkOJRCOONx6x1MvfX/f1mr3SsMXohDiYXPVARP5+PDlD3713mTFE38SCJb4/GDlk3PTuaQ7UOp3LbUdk7UGrezcjfOfHf/46IXhhQwoCkNPuPaxF//yRY9HVzmuaihCgciWGoiXazoALP0LrkylvPRrbOkyxxBxpS15aWTsyvaln1beCqzc4vTs5Nyi7Smtr4m4ZI7IAFYaqRARcfl6CQwFS49e+fjnP3+/N6Y5PR5d4owxqXzPn7ziiZT7Nbach5c+eOVKu/LJSwCYaSwMHX/jX9+8bm/6+nf+piFQwlWJibtf6+6Hrn7pyl+BkLUCuJWOT/Qe/fCjk+duTeaQSTLn7ubdLx54tjTklu42rt6p4ssh9W41unOHebeKIwDnyytgLS3zeU/Vv/88YAuRmR+cmI6arurS8vKww0bB7qnjYtX6SGAZmb4TP/lvH1+dSge8LocqobC81VU7X22u8HudqrDFPecfIZbr6aqGYpBkY2Hhxgd/97NL+dAz/+MPni0JOe2VZbCXTw64skjTqpdSFS92ACIXXxg4e/yzqWjK4hwwG12IRhet+o0HvlW3pyPC4IHH3gJlh7tu+zMvV8XSFgcGkJu+cfbchdmsr7GqRNEUxh5oK17TijT7IqLu1Eorq1Rxduj69WthLeXjAhmirLs9kYqgA+QH2sAQgaOsqoZYPHvkjfTIubBfRRS2I1yz4cD3nmjzeTU6Y6w1AGjkZy9//N57Ry7EK1s6d/XUO+0UMvD73AB2Kja7EI1ncgJUh9cXDARcEmajU7PxvORyaoj5dDLHFIfH51XNdCKdyluyJxgJ+DQ7sxiNJg1UNNlKZy3GFH+kxO/V7dTc/Hzc4s5AacSh5ONTc4mM5HTz1PyVT44cunTTrNn+4vNbW2obKtyKkYgtxOIZCxWHxx8KBpzqneyKtpFNxVMCShq7d9SFNJkz8DZWhKXkzNhUwpAdbreUj6ezllB9obDf45Ixm0zFFhdTGcMCBoxzYGo2lsoZ2Zxl2MLKpheiY/Gc4vZrLJdPZXLM4fIHwgGXzCwzHV2YjybzNkoOXyji9zh1iY50skZwjvGp8XNvv/7+lQWtfuuOlkqf005kPSVutwPtXDy6EI2l86aQNI8/EPR5HGjEY/OzKcvh9qp2Np3K2rLD43WqaKaTyYzFHf5QJOBScvGJ+VieqTIwK5+yuObyl0R8DkzNzMSSpuqLhAJOO7e4MJ0U4PD4rambJ9786Pj1VMWBrbv27WoJRCIOnonOzSezJnLV7Q+FfR5dWX7ajAzNXDqdTMmBjZ1dnRUBy7b1UKDepxjR8cFMFpx3zj+q0x8uCeoc7ex8LBaLpw1LAHDGFLedTeRymXzONG1bmMnFqbmFNKhOXROZZMqwZVcgEvY6VRnz6cXFxWg8ZTFJd/uD4YBLlTk9BSpOiIK7Sqq2fP071TlDIDBmz1858+mRI8NOd2kkyOAhjxUQUXE4azc/WbN55ZYQZ6okmP7FR1MDE4tWWwjU4hrtX6TZlzEUHFDVtFz29kc///uLH7oUCRkKy9+wdder/4fnWrjnvnUHAUCYdj6dYoFghOXtxYXxxCIwtC13TqnJ2jbCg/dKpMABA9u25saG5ucWg5u/s+/VbzzTIFAgoqTodrLv9MlPPjt+c3I+J/nKm3sef/KpHXXOyZNv/fjIoFRXEwFcGOibEo6K5k2d4eTIreH+qUVHy56vfW1/Gxs58tbbn43lQmX+7ORcIp/z9hz4+rP7ms2+j996/eii0v3sX36rxT/yyX/9+Ynb7p6t/px989NPbyzEYSJqpvo3PPXd52utwRNHP7l4YzzFvBW1m/YdfGZbR6lbu3t+EUL2hxp2HXzlsSafzgXjAPL0mdffeOfopFbX0upYuDE6Ek0FNx78+nN7OlypG6dOHDt7dWQmnbczaQM1b+2ex+uyitPtMh2amp0eu/DmP34y6G3aWopzC0P9E2Z5856nX35ua7k1PXT24w8OnxlYNGy9vH3Xs3v3bO6q0mU61slaAAzy6djsWF9UyOHtL7zyjS0tEd0ybVBU2Y7OXDtx6NCpCwOxjCn7WzZv2//Evk3O+LVDr/+3M7PVbV3B3PRY32jcVd7aURdhyeGbfaNJ+P+z99/RciTXgeAdNyJdZXn3qp73Ht77bqABtEF7wybFJkVRZmTHaLSamd2d3TNz9vvGfDM7nzQ6OxxJpCga0bf3Bm3hGt6bh2fwvH+vfFWauPtHPdhGewplEL9zyNMvYSoKNyPzZmTEjapVdz1y78bGyQM/f3p3f8YZcDhSM31x8NSvveeRrSu1s6/9w5v7Jirv+NojuzozF9/+xd98mFOa1t/v2PPB3sMHLib4pVfGBydmN2++c7MvfujN1947M57kkrd12dZ7Nm/oavGxq68PETgJtazedt9Dy2tNmwCjPJMbfP+5n77XC3V1FRRnenvGLGfTxnse3bU8kBg9/PY7B45fnExmMkYuY2Cku3bRssWguZyqQ2E00XNk74uvnMh5G+oi1qXe/sm41rL2gcd2rKjxJS8e2/3G7gNnL6WpI1i/bPO9O9d3VPtUMQeqPCFSze1vWLKs1rJM20YkZlg1s3Pzl1gqFrMxKFP20XVryO1ccj6RMe2FVw6pHAfFNrKD41OWUU9AFWvdih9QmpxL9Z08Np1LgBTgppXlFiFoWznDtG86dI+cU93TfOfX/nTlIzbmXwoTQhCRSorT73bJYrVQqeKcE0JUh8vt8bmcBhIAMLNzZz987lfPf9CbiDT6ZWPy+GuvzMYNxzd3qnNTl/pOjpw+76uKuM1seurMxfPnj/ldbp8zOzQy1/92tKnKXcvnJ/pPn5zUR2vqqoPmTP+pl18IRAJSFZ8bH+yfVCOpnG3x1MzI4MCAr3FFY1NdXU2oZzarhVuWr17dHnINvPWT5955rweqKt1a4sye12bjmr9q16KoR0abELLwmAVAFl5WUsooMis5NzVy+vB4f9+lgNvhyAwMXhqRapqqTevMW08/cwJru7paHYMH3x2eVGtWhb2epJGMJ6xMzjZzudhk37nTqQvDgVDETyYnJntmJGddWxSz+57/0QsfzlF/Y5hOn33nZ2bKVMJPra4kyMTDnlAKEJFzDowpTpfL5XY5FYsjZfbU6RPv/+IHL10gGKirJMMDB569lETds6YuNTtx7vjJvoGBoL/KZ04M91+8ePawJxx0EsiN9U9kM5VN3WGamBgeOtEfjzQ2RHSXOXzmcCbpCtVunJ0eGxkYoktSObRzqdnR/oGUM7BWb13eFL149lLCiLa1r163vJEmT73105++3Zvx1NYryeEDLz4NGeqI3tvixqvTFvJdHIACcKBUppAx4hMDfSeHT533V0bdVjY5fmaOWNHGqpbel599/b1xz7K1jZHYxYPvTUkeR1NrGAbTiYSl5mzbMhLT4z1HzmR6LoS8bheMDcxNjvvaWipN79k3X/7Va2ch6K8KpS8ceGvcUEPBu1fUVUi2uKmVJQBC0MrMDQ8NTM5lDJtYlm/pzt/ZXtVQW63CTRJfoDQzO3vwl3/5q4P9U2lGgRDCjVQiFmdhRstx2K9Mc988IEj14LIdT+5c3l7hyPdyWfcEqkC7yaA/AEFuJFPJJPqbqiMej4Jo57Kx6em5dDrHXarY2qK05ee/ISICECubm+o71zs5bDXfeddjdzXMHnn2Jz/tHTp6fnhLu4mEGlLj+nse2NEUP/nWMz86bEPLPV/f0QDnf/Hj145Pz8VjGcPNbZO49ZrND/3GiuqRN7/z8/cuDo6Nz7grCKJ9ZV4fcm4jyt6ahma9NrL3zLSzsm35upW1LP3W6aGhEaXh/s33L/Nd2v3Ln18cPj88eVdb2KOwheYCNabGTrz0o7886FYUCsFlO3ascQLhlqVEKlY+8PU1ntSxf/j+7qHJ2fmJ0ZmxkUHTtbp726Mb5QPWmUvvzlDFKTMFbdNcKGjBLRNUu2bjrgdWN6Xe/eWzb5yOxebGx2fnzx6dzqSb7nni3k793NNPv3Z+aGBwMr466i6W3ekF4TPDKwiZn5scOH1k3vCs3/nkvevkk8/88PUPzvQODDV5kdumpAc6tnxtxwZP3/M/eO39AU/LxoceWM6mDzz9Pz5Ij0/HTdtDkHDL37xyxwM7K+HgC6PPDk72jUytZDmCtp3v4kgQbdsmkhZuWUQH3t57fDhd1da9ekOn6/iRY6f745Zz1Y6dm93JD557bu/Fwb7RWdLqgoWOBYQDGTr2+k/mz7/hNC1nZduSzTu6TERCDKlx3T3372xKnHzrmR+eTk9MTGecff1zcat+y6qtd9aNvzR3rndEorrDSZCbtmlzRIIEbYP7Kzq2PflAm3ruub9+pWd0KpacHEj0D5ybcfs23vXozqqZN77/wqmzF4YS6zsg4ilssIR/HAA0Nzd1/r2f/uztM2MJEygBAkDVqiXL77jniYgX2E3/FGWaNxSJGHKO0oUzVNKDVZ3r1jU7ncpHU6bSVqa5L3LU3Y7qplbnoRPxlEEk2eXSOSIiU7Wbf2cAwGxy+Oju54/bS3/j7k0ul59jeqz/8O6X9owF7nzq/hWVmgziKbk8AOeYTSYNYqkVkbqmrjb3ZIUHe3ginuLcJsDAUVnX2bW0dXz6kA4aOGs7ly2uTSe9uiwlLi8nIUx3BBpa25qiENBVhVu2ZduE3JAyAgEqOzTdoaoUKFOdLo/LYcykUpbJszOXzhyxHdPjCZvrqUyWo00Iu/IH0bKyificbEkyZSyZNS0nEILE4Q80dC/vVobH3LLEENEwDMvmskP3hMJ+6nNLlCESCgCUXFsnTVLkSHtXd1fz5NnXdQkJIUbWyqSTaBuzfWcOJZWpmYSR06xMNkfQfWtCIQj/GIBA1jQyqbSqVETq2pralHjI7WRjuWw2ayhIiOJw1bQuW9TFcnucDkkNVbV0Llls9/a6Gc1dHuUCQjwV1U1tXdHUJZ8Ow6ZhmsiQXNerCCGUMlV365rEGGGq7nJ7HAytbNrkBo6dPXFQzQ7HUhmPncnkrhtBQ0LMXCoRm4GcbRl6IpUjnBACDBzRuo7upW0TM0eclALaHA3DpABury8YCmecTgUJcm7ne/g1ddJkr6+6bdnKTivxviZLBJFk05mskbMy8ZFzx/cNJ0biWYumM9y0yE2WPAmlD4Aa8Ym+I28eODXuWLR+RVulXzVnzh88dGzPh6xq5eqGTpek3DD0i5zLTnfb5gcDy3Imv3I+gexw+irCAUWh5bbYqUxzX0IIcm7lsqnE9MDbz/24Z5/XISFybnvqlq6+/3e2t1IXu1rrAagZH+k5t+ftQ+dO7dl/iY+y+b6qiM4hO3HpzNHDw/KyrkeM8lrkeHu5vPI5X2eMLJRsQKSQr/sFiACUXF3uTQiB/CLp/LJwQhBtfmMFzYU6C4gfLRuyMEvhavWEa5Z4A5CFCjPIbTOnhCLta+9x+Zvqghq75paKKPuDrZvvfXhJjVOjoAUqI/75vqu/yjkuPIpRd6gqGoqQ06c/+Nn/GITBcxM5s7Y25HTqN7YLCEXC+eXSEJf/KkRiW9wGZ83y1RVq5aLGgCrGfIWSslCwJD9DKN/LyZWeT4Dw/LGFngj52g1IuJ3vwDQ/b+KjRXIBAa+pNHjNLwCllF4eISNXejgsdPGFwmXctk2uBdpXbWoIN3VXuggCLiSrSCghkdZ1O7fe0R4xLEn3B8OSOny5zYgc8x0ViaTIkfo69czwmbde+vFFT+z8iVmvt62qygczN7yNXLgo2R+p6I1oGzao/tYNW7qdNQ1ej1xu2YxwGWRT8fGBS4bStem+Bx5Y1VhB7YkjijH69LHJoaEYtuhE+ehLbEmSdF2NHT1yYmA0ZiASpLKzsrVzVSDkI8DK7SmpfHNfDrIably/VU5mLLxcRYpzt9vpUAiFG2vbZedHeva//M75zGTMhLPvzfcpMkViGyaXXE1rGiIuVYIyi/3tAAkBAElRKCMzc3Mz09OZiIwW8lwio6gaBSk9l0jMT8zGY/EEo26n00HhM2d9iMgtI5tNpTMWt8mVqmec82wyNjUc6xtNpg0SWPgLASzLjM9NTs44NWASZaBWNHWt37E2yi2LU09VSF0oPL1Qiog6nMH61u7F+bVuhNss9pEnMESg4AhGw/6gnDg/eO6CWuutXLdj1Yr1nRF56tPubkgZMFkmCve1Ld24prtKzaSJ5o9GHEjFQhihRDBKZUW1rXRyYno+kUy5dZ4zULZMUHXN5Pb87HQ8Jk0lshlDUxVV0T7HqY1oWUYmk8lmMoRwyhghBJHYtpGaGh2e7hucsbkElycxEEIyibmpyYm412ZMIkzTqhav3tzV6sdkTnFWRP1I6NUhN0DiDNU0ty9ZUmvaBChY8QT9yFgsIsqKEq6q0WXp/GC/Cysroq1bNi9ev6LJw2PwaRmsLEmMMqL7KzvX7lwXJhY3qLPW69HK7S22cAUAMCohN9Px2PzMrMSs+Xg6bQFRmcRuNq4BQO1McvjI7heffu7QeA5Uh0pyqQx31PVMyf4nN7SHdJmU1Wvvcs190WYeb/OWx353TTadyuRMi8iqQ3MoDECSdVCvn+yNqDoDje3rNqxS+o6emsDKxS11Yb/KETlogXDTyo0dQZcCZbXK8XaBwKRAXXNlsOfihYN7XrFpn4dnKZX1+pWR2jqvb6Dv5AevWeeSQ+djTk9rd0tUUfpsy7IXJskicpvbaF/5wbYvbxYFlCeT48f3vjUlD5+bjEGkPRiMBLUxh5vEJwc+3P3yydkzZ6bmsqSac1R1t8vtg+TQxQ/fesVetWpDpLUyMDIyOzLYc8o7a2e5pDeHGmquLC9D5Jzn5mb6D733yvxZTQKkztquRdREbpOFYVtEzm3bJhwRKCMEgEnOULS+saamta5K1yTDNDlfaPDCb7Y5IubnIds22FzzeirrOwKnT8wN9l70wjxNxF3RDld1S0GDJgifGRKUnP5wXVuV/OHQ8XfeCM5dDDtIOuesb/Io1S1d+tmBs/tefjVFz52dyrrqa2qrg65hzollLyz0wiud5Eqfumb4d37k7IH3mJo8PjAPUlVd1OflfpXI6aEL+1/Lnpo9f2LMNCP58rsun9+h0pnzBz54w+1aHg5EG6odk2MTfb0XwHKZM6SyQQ42119tONqWTab6jn6wmwz6LYtrQV9ldSe3EPn11x+wEQkDBhRB1T2R2paW6mhdc6VmZ9Lctq908SvfJP+1bNsmnKNeUVldWe0empm8dP6sdxoNO+ttDtVWluUKJoEQQlBzB2ra2r3Hzn74wtPxExV+1ZjuO3NhSqvsaKr305vtVEDtbHzyzN49ZxNK653bljXX+khq5PSJ/SdOf/DWsY3La3xOX3lli+X1ba4BlCKaqZGenv6B4bmsqda1tUXCem42qYYaO2s81+1xhdx2hJuW3fd71e2Ha949Z7buXLe0ocZlcyQEKDBZUeWbLI0Uih8ilZTK7ju2bDSsI/1Tw0ffHyfIXb7K5ZHV3cu2bpixj56bGuidRwwuX7d4052LKtzzFdXNbZ2p6gqXQiWXv6q5s51GIk5JkjVfbVNbl6827NepDUB4Ojt5/tjBcQdVKxrXLF+3qL2tDtJL1q+cOzyfmhjlamVbt1aZa4iGnN6gt3PxhvUXD4xb8dHR+ax7w7bNU2gfHpg+t/8D4OitbfQtNe3LE/CY01fV1NFuxejomf0TlBAEVrHGH21xR+raW9FbH9Qlienh+rYOoFV+t9NFa1u7u+0ZZkz2n5k89+F7SuvGh++o9Dc0d+Ws2rDT4VBCdR0dxK7xOTVJckVqm7s6SU04HI0E1u7aPkqPz4ycPjhOAVnzsorGHJD8i2FBKHacgztatXznroHs3p65wZMHRigQojVAdNOqzlV37xh8+8LE6IWThHhqV63ZsnJxfZQkK+vbO9y1UZ8sU/BFGlo7lVClT2OMOyvqO9v9apVXkwAJJyQ+0Xf8UMolG+6OJS0rNi+uqrOXLDk9keufjM9MoCPUudxpuj2Vbk1V9PY1S1amMxfm7Jmh0VxTy5I77x9Ovd8/0Xt86hIFDC5zVrUahCiEAAJl3ormpnZrIjnVc3x3H0Xb9tRWLXO1tvhrW9o649VhtwKSy1/V3NUGkYhHdVjhpvbFfCLOE+MnD/Qcen9v7fotd270Rtrb2y1v2Klriq+qoaPTrIm6JSqBr6alNekIhX3ehtZV67eOxz+4MHt+7/uAku5v86wwrfzaAnFXKzvIueypqF25485efmR4buJSfAo4t/XqNctXb15SL1P5I8kMAFimOT8znQN36/odO3YubfWgeSnkTg2cODAxPWubFoGP/rFSBsmc0fVf/j6RM6686rU4XxQJ/vtta5ZXBiVKC/JlkWAqlRqfmEgmk/DZ30FfBZSk5voOPPc/v/9GbyJt5nKe9Ts214RyR9/tC6196s+/slj1qjeM4AMQ20rPjg2OTKUJSFS6vOMWU3RvtKHCI8uf+R8DERVFaWpodDgcn/BiCQBmZmaGRoYBwON2V1dVK8pnWk7JkSeSyZGREcMwvtC/z+0EkaBt5FKJ2Xgym7OQEKZqrkDAryk8l03F5xPpjEkVh8vjdbscEsnFpmeSGVv1Bf0e1UrNz85kiKz7Ix7ZTs/MxLOm4gvA4KFnfvidXw7aXff83rfWNAVcqurx+TxOByPZRDIem0txSXc5FG4m0jnm9Po9XhWyqfj8XDxHFIc/EHDKmEvG5+PJjGGBJDtcPq/X5ZAZEEKQWOnYXGw+keUE+cJsYmCuQFAHMx2fz0kOjz/kBDMxM5000eELSump8cnJhCErkBy5eH7PL186jYu/+q8eWdtUyZK2w+vz6DQ7PxU3UPNW+JyyOT87n0gTh9sXDDjAyiZj8/PJnM05U1xuj9fjcsg3XQosfDGI6PF4IuEKXdc/Y4flnE9NTU1MTpTR7eYfEXLLSCXj8flk1uaIRNJcXr/frTE7nYjHY8msxSWHx+P2uHQVzUR8dippKy5fhUfH9OxMImkwlz/gd6IRn5tM2MzhCLl7nvm3f/PM/mzD44/venBZLZVU3e33eXQZzeTcXCyVQVXTNRmz6ZRNdG/E75TRSCbmY/G0xZwun9+rEzsVn59LZEzOQVbdHq/X5VTzg26cW6m5yflkxrTJwkxhZKrq9IYdZiyWStuqL+h3q1Z6fnYmA7LD5WexoYGpFCHcNLKDh957Z/e+VMuGr/7xNzo5BQrucEDDXDI2l0TF7Qn5NZKenZzLmpInHHC7ZJ5OxmLxRDrHCZVVl8/ndekKo+LW8etDKfV6vRWh8Kfe9OOJxMjoSC6XUxSltqbW7XJ93O8HgFwuNz0zMzMzw/FzLTlC5FY2FY/NJbO2jUjIwvnr0KT81Dxy3YdSyY4PnX/lr/7bM/2Ojd98YtvSNj9P9e95+8Xnnu2reOif/dvHV4QD6hepiAcA0YpIRUXF5/6Tvw6MwvNn+//d24cmU5krKS5HXBoJlum4L1CanE1cPLh/KE1atq2nH56ayuaoIjGam5kZGp+2OitBu34kFwDMVKx/zzPffenQSNyUGMsvGrBtV2Xrxif/9IFlwYAmqiGWIAACkqp7Fc0TuLJTMaVAkIDTpTp0H+b3Is6vfyOav6LKRxZ2BZXdoSpXfoYDJZIcqfQQQoAlRpmi6W4vC0WrGhobgk75yomhebya283zWyMj9+UXywEAdXiCDrefk/yHAzh9Id0byG9WCkApXF1QI+mekMMd/Mg3AUJcHt/lHUslf2VNAAg37UuH973++hvHpyQG3MhmU0TyLm+rj9TUVoSlIAIBAkSL1HoXPguUQFgPLPxLAFVc/rDuCeb/afLLAcvpAV+4DQCVNY9fdXmDV7p4fj9gyeMP54/mdxgniJy6glFngCz0I28o6gkudAzC/NE6HwAY3JIkTdc1RyhaXdPU2MjzZXgJEqK4wxWuIJKFHct5gOPC1sWaOxBx+Ra2NicEFW9IdQcWpkhRuKauAqWSyx91+m/8GgCEhJ1+cu31h1BqJuZ7jr7+q3fOjMUsIGik4gk52tGwpCUaqFJ0aWFBrqo53MHLVwdXuMqZ/2uAAOjesO4JXt7fWEzmL3ec26Zpg6J7vY6FuwoAWEY6YSAhQKmsaQq7+vSDXNKcoeZFTc7ew6//zV99oCmUcCudSuuBluXttYomapyVCrBzVnI+zpVQXUe90XNpjnNCCKGUWLZt3+xNDxArkxntOTU0MiR1bFrW2hxSOSLhXPFWNIUUhZZZ6G8v+VXgQCldKOawMKsWF47mj11z17ya/sGVG8XlFeRIHNXtW77yBx2WGq1v8DjkG2sFAaVX/var+xRf8yvkckkJoGwh5/3INoNAbxiWubzXJL3StoUGyVCxeNPdntplsazBCVAmOz2ByrrGyoBCABhc800WCkyQazNcJHg554Vr/h0EoZTg5UoPFMj1nXzh6JViKwBAgF675Oxqn7rc72RkTWuf+K2Gu+VAc0M1UEav/IVX/sTlz7yuo17JLPHKZ19eA3vDbWehy93wDcjlLPzaXktkh7Nm5d2PVyydSRmcE5BkzR2srKqpUx0yXH1qvu5rXfvX5L8bY/Qm7RDKDAA1YgMXPvjFL/aNz6f5jaP7yEHz1mx49NFNXY1BZWE4D5Ewl7/1zkee0ioPnuqfTeY4ENkdqOlavWbd4rCjvPZ0I6R8c19EWWVur4ubc5d6hlgsnban+3u4MZyR6vxe7+Vk57o/QqjEnC6v4lQ9rUs37bizM0BsTggBKikOTWOiIkzpu/mz602OXrcU8qO/InvCDd3hRsoUBgvLx369TfqkX7nucD7Bdkcbuyrq2i3TXsjxJYVB/q3Wdb/5utqiN/nS4gwXSt1n7OM3lDfFG34rBfDXdPtqKGMU4PP1jM/RsT5LH0dEApLsre1YUd26sEIPKJMkmSLnl2dM3OQPfqSPiw5+2+DcNg0zZ+RyNrsx90WEbCyRMkzrmn2KEYHJ7srWNVsDTUvjGdMmQEBxuH3hkM/BSPm9CizT3BeRa353w7KVNYdfOf36+/Z80lDGJnqZ4gotXbSqzaXJH5nohITIqhKsrtbJmdEj+97MTJ9xSxwRueqNtKzZuazGpVMx5UEghORvPYQQQopkFgxymxBCJfnKAl7xpCYIXwJc6ePFctdHRKBMopdn4qMtas4LN4EEmTtSv+6Jp9pzpo0fndSNlDFXRdQjX1vPHsxMauLiiYHpZNa+XJgeOaeX9GBNR0e1T1UKs/jrH0uZ5r4EkTldNUvv2LWL1g6NJfJL1oF5GttXrF8SoTL9SKk6IIQTwgmRQEpcPLFn6JzEKCFoW+6arjurt3RUuZ3l9+wjCIIgCEI5oYrqDoZlzvEmuS8BKmkuTb5mvwqgYKVT/Qdeef7w4HQ2Pw8YAAhxBGuXb69oqvBqZTbtoRxzX85tzpFwm7oiy+7b1ZbKmraN3MoZpsUVj2KkCeqE3FjiDhFBdoQaV29jrWn7yoZc3Fb9la0VahHO96WUMsZEnQdBKHKI+AX6KVBgjBXbZUcQhI+CIroTg52aGjn6xlunZhPZj8z3JUgUZ7DrzrtWNtf6lctpDRLKmDsYraxGLUcpEDsxdam3t5/HlC6kCDcpCVzayjD3hczM2ODAxfGYkUvGpxNpw7QRkZiZ2NzM1KxUtWj5zm/c2USdDK8b+kVE6nDVrb73N5bmsumsYdtICFBJVjXdoUiSVFTzfZEAIQtbahZPjxME4WPQL3L3AFqgKpOCIHwuCwuhiwAQQuxcZn5seGhiPsMvF3NAgsjzS5lVdzqayFqcXFmljZwrHt+ie3+rfaedXw1tjJ9849lnXzg/Gwp7dHbjpOHSV3a5LwDEB06++cPvvHwubdpAJMmhu5wOTWaA3DJyHlLRmMObT9IEQriVnRsd6L04MpvO2kCo6vRX1bW01FVIxfUvBQQJsSzLNM0i6W+CIHwcRNQ07XP/Kc5N0xS5ryAUP0ppkQyPIaLkqWzc9Bu/vSiVSBuWjfml/Irq0DSJEkKAMt0Xum6+LyEAVNZ0BRYKoRBn19o7M7ZyctbKJtG2yi1bLK9vkydrDt3j1Vg2Z9mgeuqXrFm9tLuuwqNriiJpLp8/QjXpo+kvABip6TPv/uD7Lx4bm0VJoYDcNNEX6bjra797/4pqt+NTd04vEJH+CkLR+rWsrhd9XBCKVpFV0ECQZFlTrPnT544NTCQNiyDTwzUdy5curqnxKBQWhqmvrYa3UMwEOee2mcsZ2Uw8h8AcWi6e5bZFyI2VPEtc2eW+iOhtWn7vt/6sa0v/uaPHjl/om+4/9f7UpUCkpnXp2k1rG2ojfvVmtxEAMNLJgeMHzo5OB9Zu3bykq1LjUyeP7v3gvfN7D1/c3BFy6Y6im+wNhCiy7HDoTBL7cAlCcUFE0zDSmYxt21/m71EURdd1Sstuzp0glDjkmDNymXS60A25BlBIjU8ee/EHP93bMxEzDNMiTJIV9WjvxfEHvvHosrBE2dVsHW3TsEwbgTGwjUx8fmrgwtHjx8/0XpqeTyW4I9ARtkn5bXBfdrkvISi7/NWtvkhNU2tb96qJ0ZGBgTPHDx05/WHPcNLWnKEdQe2mzy8ApmHMjE1aNNS9Yf3mtcsqgcy4pVj/kYHJyam4YVYSR/HdewBkWfZ6vbrDUWRpuSDc7pDzRDJpGOYXzn3z5ZpVRQn6A5Is/3qbJwjCl2Tbdiwey2azxXP/BaDZ+OTAsT09ozyyZjE7fXpcba+ssO2B0+eONfXtWOLz0SvzdwEyE+f2H/3wwqyzvto1c/Lk+aGRsdmJ2RlD9Te0LdrY3d3R2V2pOT66I0KJK8PclxDkSEDSvdFWX6QmGpDtsXNHjfjM1Pzw0PhcluPHPMMgo8yha5zPDPcN9ge8OdWeGBgemclRSXM4KCu+xJcQQghlTFUUTdPK7dwUhBLHOc/mcl9+vJZRpiiKqqqijwtCUbEsSy6y1UAEiJHNzEzMgLqoY20Xnx7OaW1t3Yxn+vYlpqbiaHsISFc2B+VWfHTgyFtvj0pONTUyHjMw2LFu4/1rVizuaGqorgh6dAVu2CSpHBRZzH49ALmRmRsbHrjYNzg6fKm350zPlFLZsqpl9aqOWvfHLFhEjrLuqG7vjBx8/dxbr2TOHQ9oOHtpcHgOKjZ21vscCkUUtcQFQRAEQShqQCgQRVEgx0huqm+wj9nThARVVSXX7JhNEFVf7eKVd2X4hdHx8SFi8rEERTuXjU+NDaCVyWRrqyv8Tk2iH6mVVtrKMPeFzNTQhZMHDh46eeTQyb6Y6QpWRKvbFi/u7u7uboz67Hgi63WqcF0gAQCoJLm8tSu27honh/qGY5aRyRBHRc2KVU3L7ljX7HRKYshFEARBEIQihkRRHb5wRBlFK8OtrB3v2XtpUHU66hdt7GgOUPnaF1Eoe2qXrq9ZsjozPz545syJMxcGxsamRk+9eeSdJGgVLcvW3bH93ju6IrpWrGv9v5iyy30B6Hzvibd/8d3nT6UMTqgnXBOpqq7wQ2LqwsH3eogz3Ni8cvvyaqpdU9+D5mKzk2N9M7avqq5u41efWpEvDAI8G4vNz8W5ZWSJrRFGy27cXxAEQRCEcoHIFXe4YdW29W6oD1SbncuSLDCreCo716zZsrJRpuwji/aRAtN9la1rK5pWbsllZib7+06fOHHifP94dmZgYDK5obUCtPJKf8ou9yUEqeJwByJVNYbNkRNITQycnhoE5JZlGDlf81rSdNeiSuK4st4NgEyfPfbCP/zFHmvzb/75Nzc1REK6myMC2MMDp/b+6PsfkvXf/D+/viEa1sV0O0EQBEEQihUi0fyhjk07q0ykQHZWdmznhBBgmsNFTcSbbIiFJL+VF5NkUB1Vbl+0ftGauzKJuZmpuYxeoSlQbqlP2eW+iDzYte7x2q77DNvOZRLpnJ2vWodGej42O2PpVZURql63aBFSqfj0zGgu60RwEKCI+Z1NQKUgcWsqnh6bnTat0Ef3QS5aiCjy9JJDKeTXYYrwlaJbvLGTOElK0ZWTRISv5BTPzm2fDCg146O97/7kJx+MziZtRgEJEkTESMOyLQ/+7tYWJik3PfkQcWFMEJisMllRHC5vhBMmMVpuJ2vZ5b6EEFlz+XVPkCBy2+JXtlrhlmmZhg0Sk4nErhu+54icc0KQc+T8ykWJc87zy9s4t0urrDPnfGRkOJFIiJqgJQGRSBILBoM+n59SGovFZmZmcrlcKVxpBYJIKIXKyiqv13trPhEAUqnU6OioZZm35hOFLwmRSJIUCASCwSAhGI/HJyenTNMoiXRK4Jw7HI7q6hpVVQvdlk+HaFu5VDKRTCQtRoHnEol4LAnc2U7gs5XqXciNqSSzotu649eiHHNfRI42z5dkAKCXryxM1WRVy/+GGwKpKJrucGYz2aG+3ol2SfEyREKAp4eGhkbGKA04HaVUWJ5SmkqlfvGLX/X29ni93nI8b8uNaRq2zdeuXXPfffd7vd7h4eE33nhjaGhQUZRCN034dKZp5nK5r3/9qbVr1zF2KyphUkqnpiZ//vOfxeNxkTyVhFwu53BomzZt2bFjByKeP3/+hRdeSCQSX2Cza+EWA4B4PO52e5566hsdHe2yLBfzXRU5l1yVjZu+/tvtWdNGQggkzh9+a/fLR8GWFR3g8yxcKuYv+qWUY+77MT42hohKqLKyoa3B2N339t//bW/Ao1KChAAaM4ODg6Yeaets9OsqLZUSdwBgWVZPz4VQKLht2zbLsgrdIuGTANDZ2ZkTJ06MjY3ncrn8kF48HguFQqtWrSp064RPAUDn5uaeeeaZmZnpW/Z2CADS6czY2GhHR2dTU7MkSaX1Yuo2NDw8fOHChfHxMURE5LFYLJFItLe3t7a2ci6qZxY1xtiJEydPnz4Vj8dKIVhIVbe/bkmwfuFnMJoCLr+jaow2uKmB5GMKvd5WbqPc9+MhuKoal9/12ENwbGRuLpdNpy7/gl7VuHpt85INq+pcmlR0Gxp/Mkrp0qXLHnjgQcMwCt0W4ZNQSkdHR23bnp+fJ4QgIgDx+XwtLS27dt1f6NZ9SdcMSi48fQLADU+iHz1SSiil4+Nje/fuufWvhnTdtWrVqrVr14ltL4rf+fPnDMO4PNmXUEojkcjmzZtXrVr9Jbe8LrBr3zt8XB8v7S5OJElyuz2TkxOMsUK35TNC5NecVZK/unvDPZXzOepyMSDiQVnkvnmcuILNq3d+u3XF+FzSsK881iHIDk8gFA7oDKEEzxbbtk3TNM2SnREIAEApXZi4gsiRc44AlFLCOed84UJL80fsq7O7Swml1LKsG+5/iJgPX6Fa9WUBJWjmkrF4PJm1CGGy7vG7dBXTc8m0CQ6Px+2QgSC3jMT8fBpln8elq0rJhq9A9/WFk4TSkt1yFIBSRq9ZAMZtjgQoo4BXezRQSiklyLnNS/N7EsuybhgyRETLskzzi295XWhA0UrGZuLJrMEJkx1Oj9+pcCsVi2dA9XtcmiIRQsxsJhmPmczh9bkVVopbJOQjVapdjBCCoOi+sO4rdDuKiMh98xBBkvVgtCFw49kNQMuuukfJMFPzkyODwxOzKcMGpjgD0fr6Gq853Ts8C/5obVXELRFiZxMT4wPDU0p1S03I7yzqmVi3D8xODfWcPnb84kTSpEwCyemp6VixohX63jt4ak5pu2PLusYgY3YmMXH6ndcO2bXbN61eUhu0iv99ovBrA4DcTEwMDwyPzMUNmxNJ8UdrGyvDGB8fHJl31rfWBN2ahIjpqf6hsTlDr2luDGmfcbWO8I8IgFhmcrL/6OFjfaPzOaSMUeqPtizr7tKMU+++eUJtv2/zitaojxBIjQ8c3PP+qLtr2/aV1U6nhKX6+CKUEZH7XguA3fjaUiRSBYNGrP/A2y+/+tr+nrGkxZnsrluy+eHHH1ky/vr/89132Oav/JOvP7TIh5CJD+574S+/+3L4G//Hb9+zqdVrlegYShkBQtKD77743R/99KBZs2r54qjDtqWRebWmtdo++fKLvxp13N26bE1DEACN+Pixl374XWtLdWvnsvoQEbfF2wZQzM1O9rzz4i9e3nNyctbgCLpn0Z0PfXXb6syBX/73Hx3o/JN/9+1tS2tky8aJYy98/6d7plu/9W/+7O46SqRSWXtRvsCKz5x99a//3XcOys2ti9tbgkouNp8y3aHaUOzQs9//gffhjq6OjkqfDTQ1cvGD5354MPKVrs2LK11OETqhCIjc93oi1S0KAGDZxsiBp7//w/dztVu/9i/uaPVIpk0k2elTyUBsamJSTqRNBCAIxDYz8cnxMZrOWhwIiLlMBQaAyEdO7D91MRXd9K0/+Kd3LXJInBPCFN2pnrYsy7Lsa/sZWpZpWaLn3WYoJbGhE+/94C9+fLLlrq/9/m91Rd1gZYgjXKHyC8nZibGJyoxpLZwVViY+Nzk5Hc5YhKDo44UGlFrJ2dHj+/eNV6/6F7/zzQdWNEqcc8IUXUpfPGRZpmnzhRgBIYjcMi2LI0ExYi8UB5H7CsXJ4vali6dG5qVVO9ds3LCikqHNOdokhxnIT/W9miwhIpbmVN/ylYrNJS2uhytrohVhRUJEAoTbJiXXL44hZKFmfGGaKRQOpBMz/edOTSaqnly/evWG9gDhtm1zpqSHewjyG3o0fuSIUEjcNFLzc2nbHaiKVNZGwpaFhACwbBbgo12ciC4uFBeR+wrFCZFkczmUVLfb5XTI1LIpk0ChdiYrrqGlADF/v0Pbtm1ARAKluF5U+EcCQCzbymUMxjx+r65qMjVtKknAZIOICb1FDwnhBIEA5EsK2DYSIhbHCKVC5L5C0bph78+r+y0KglAWLte+yvfxhf8rdKMEQSh3JbNXmSAIgiAIgiB8SWLcVyg5+WHgayaQ5d+ti/GiIpPfD54yulB9FgA5B0opEs6RMMoos4FybnEKFEpn03Dh1+smU0ER8drjcLX+761tmvBJru5kQSml+TkPQAhjjBPbtoEQRhklgDZHQhhjYi6LUCxE7isUJwAiMYq2ZdsEJFmmC8WvKICmKsQyMlnLBllWkBAzm0pzVVUZZWJWROEhIYS4/UGX1DcycrGnt0n3KdxGmzNP0O0JV3jkvoELp4+drlcrlPTQ8eM9EynfooDH5RSZzW0EkTBKJYlamDNNyqisyJQTRACZSaqmWDyZTiOALMuQMLPZtMmoqjoIEdPGCw6RMFlxBwI6GR6+ONDfG5Y0tA0ESdMV1R2pcJOL/cfPnG32Mg/Gzpw5PpCgzooKryRTUZ1OKAoi9xWKEwVaUVnrZ2fHek4dO+quktAmTHP4AyGlsr4lJH3Yd+rwhwc9zU5jrOfIqQsxb3NjjdetiuypGACByu51yzsHL1344JXnrMlKp80ZUSMr71het2jDikUD5w69+9w/mFNtSqLvwz09NLJh3bL6ioCo7XtbQdXhDdfUudjY+WOnTrpyAZVzW3b5wyGnr7q52cv6ju870qJlI85c78FjfVMk2tRYGQYiHnCLAMrOQM2SDes7f3z2w7dfw8mBkGylmbOiacldjZGlG7Z0nPvw3VdesCeGornhEwf3Tntbt61eElU0JuZzC0VB5L5CEUJEmckta+/bfmL+jX0/+a+nX3ZqxKSBupbtv/MH22pX33v35skXP/jZX5x7zaORZDzJ5a57n7qzszagcpE/FR4iIY6mbQ/9TlXdoaMXhqeHBmdA9UXbWzVF1YJ3Pf5PaltXHzrdPzY5yqhr1a4/+NaKFYtaox7CxaZutxHOma928eaHHj74P9997q9OveXWZOC56KqdDz7xW8s7Ntz/+MG/3f3Kd/7jBx5dMubnU0rtukd3bWhRKYjsqfCQc9kX6H7wn//vtQeOneyfHrl0CRRnte72a5Iv0Lbrj/59/YbDxy+Mzw+PEaVp27d2rVy+uLXJpZbs1ttCuRG5r1CswFG15vHfr15333gsZXIgRNL94fo6n0uXlj3yO9E194zMJrM2p4ypnnC0qqY66JaJyJ6KBCjeiqblWyqaliezORuByarT43Wpkiz567vXBWu7kqmsSUDSdI/H61IlkdLcbpBQZ3Xzlm//64btY1MpgyMik/yR2oaI7JHqN3/zX9ZvG52K5WzCkSlOb6SurjLsBnGWFAckwPRA9ZKNOxq6k2nD5IRKqsPldSuKDGq0c80d1W0rUrmcDZLqcHm8LodMxXi9UDRE7lvmoHT3DQAiuSK1beGqFm7ZnBACwCQJCAEih2taQlUNtmVzJECZLEsEOSLBUqwM+gkxKtXYEUIIAUl1+SPuwMJXQMxvTYCEypo35PCFIX8YryyZKVhTv4yCd7GCN+CLQgKy4q1qWRJtNG2bIyFAGaMMAIniqWxaFG2wLIsjIZRJjDKAUt7c4uNCVLLhI4QQIju8IafvShe/3JcJU12BqDsIC8cXAleqX7OEAyR8DJH7lrlrrkYlCNEmhACVpIU5fgvJE0HbJgQok/PTx7htX/0zhWrsF3Z9BeMbf6kQLfq1+dj2l/oXu0bBuxheVsA2fFG4UNGBMokCASRICL+mM1BJogQIIkG0S/IbXvEJXaE0Y7cgf5G+2fES/lI3+Ljrs1C6RO5bngAAEY8fP/7CCy9YllXo5gifBADm5+cuXLgQCAQA8rGD2dnZ+fl5xkQPLXYAMDc3NzExcetvjalU6sMPP5yampZl+RZ/tPB5DQ8PDQwMdHR0EkIACOd8enp6z549o6NjIqkqcpTSM2dOz87O2vbNE32h5Ig7axlCREmSFi1aNDIyfPLkCXFhLX6WZamqWlNToygKIvp83mi0cnR05MyZ04VumvApACCXMxoaGioqKvLPnLfgQxHR5XI1Nzcnk8kLF86Ld7LFL51O+3y+uro6Siki8fv90Wh0dnY2k8mIS3SRA4BEItHY2Ojz+agoRF4WRO5bhjhHRVHuuefuWCwmboqlglIWCPh1XSeEVFVV7dy5M5GIF7pRwmfFGKurq1/YxeMfH+c8FArdf//9qVS6FOf53IYQUdO0iooKxhgibWho3LVrl2EYhW6X8JkgosPhqKmpvWV9XPhHJXLfsoSSJLW2thW6GcLnc2Xmn8fj8Xq9hW6O8PncyombiOh0OvMv0IUSkj9JACAcDldUVBS6OcLnU+qTs4UrRO5bnhBxbm4uk8kUuiHCZ8UYczgcuq5TSrPZbDqdNgxDXGdLBWPM7Xarqnpr3rQAgGEY8XjcNM1b8HHCr4Usy7qua5pGCMlms8lkUizGKCGKorjdbjG3vjyI3LcMUUpTqdTTTz/d29ubv84KRc62bUVRVqxYsXHjRpfL1d/f//77742MjEiSuM6WANu2AeCBB+5fsmQpY+wWfCKldHx8/Be/+HkikRALIkuCaZqBgH/Dhg0rVqzknJ87d2737t2xWEzkUiXBMHKhUOjhhx+pqakRU37LgLholiEAME3zxInjDodj8eLFYmlqkaMUZmfnent7h4eH8/P/ZmZmRkdHFUURL7WLHwDE47F33nl3amoqX6v1FozWA0A8Hr948WJ3d3c0GgUQN+NiNzAwMD4+Pjg4tGzZctu2Z2dnxsfHampq6+pqxW6URY5Sevbs2bNnz27durWqqooxJt7IlTqR+5YnRMxmc4sWLd6+fbt4K1rkKKXDw8OpVOrKZDLbtnXd2dLSsnXr1kK3TvgUlNKJiYkDBz68xe+vOeeU0kWLFnd3d0uSuJIXu+PHj3/44YeGsXA15py7XK5ly5YtW7aMi928i5skSZIkjYwMi0iVDXHFLFsA4HK5gsFgLpcrdFu+GLjsypH8/kAA9EpB//yWOwAUCPISXYdAKU0mkw6H49pXabIsu91uv99fwIZ9OQAAQK+d/Yqc4w2xAgAClAKWbPQIpdQwcrJcgGspY8zlcvn9fkVRSvKufLnzXtvF82vBKAByvrD1BQGgC6dN6e7s5vf7dd1x5asCgCRJXq8nGAyW6KzffPSuv0Jf7uLX9OiFC8HCzpslGb/8TF9JkkXdpLIhct9yhoic89K82gBBnpk+ffzQseM9EwkTkYCzomHJmi2L6Ln3j01Cw7LVS1oiGoIxO37x2N6DI87l961qCQa10ksBPm5frpJeUwyYmuo9efTDo+enUlmLEOb01C3bsqUeeg6dHGMVi9ZubA0wxozEdP/RNw+MhTvXLF/cGFBKL3oFDlP+00uzm1OwkvGxs/v2HL04FkvbhFDmbli6dlmLP3b2wPGp8LoHVzZ6vSrnONG79/DxSxBavm5Tq69Es4+P6+OlGTtCKNq52OSpvfuO9w3O5SzOCQ3XdKxaucKbO/ve4ZmG5RuWtFd7VEKzU+dPHzp2IV27YufyRpcileB3LdUYCR9P5L5CEQIgNrcmTr/5i3944URfRgv4FEDirrUDDcsaZl/78d8cl3b+QU1ba6WDgDk3duylH/zVnsgfrG2oqQjpnJRe+lSGMmNH9z7/81++czHhDXgkRpjXlwt3r9Qm3/zR9z7Ulv5m07rmgCRRMzl15rW//ssDS54K1re2BBURu9sGUDM9dv7w89//3mtDlqrrTgUo9fFQU7U6f+Tpv/3OyaX/253NNQGfxgmOnt39079/S+7+4/aNrX56i/YPET4eADVTsf59z//9d98YtLnD61EQsTKjNdbWzfW98Fd/cW7nH9fWN9Z6NWS5iTP7fvm3v5q+8483dlW7VQVR9HKh4ETuKxQlzFrzh9569p2T9p3f+Fd/9PW1QckyLI5mOmnuNU3LIvaV2x8ity3Lskv3bWi5ASA4fuiV198+Odfym//iXz22pUJH2zZzGVAm3jBNy5Lta+5+aFumZdsiercXoCw50bvvlZ++Pbr4z/6Pf/bQ5hYvQyNnEDl5fv8h27Qs++oKMETbsiwQJ0nRoDw1Obb/he+/Odf1h//bH3/tzqVeYuVMm0Bi7EifaZqWbV+NFXLLsixbBE8oHiL3FYoPALE4n5meSuVcDdXRcMTBkFONEqryVJzmZ5ld9/uvn3QmFBQQRIzPTMZt5q+sqQnosiQhY5IMiNJC9D4avoI1VyiUdDo1Nz0jB2rqIj6XQ5Y4Z0wiksUIBSBEnCRFC4AYRm56eiZnV1XXhkNhldk2dTBCmQGUfiRYInpCsRGVcYTihMS2OSFUkiVKL8+UE9fPksE5RwJUliS4dlUiEQEULstPdgUmyxIszIcVfbxkIHLOCZFlmVIg4gotlBaR+wrFTUztK2kifMKnEidJCRPBE0qSyH0FQRAEQRCE24WY7yuUnvzLtSs/itdspQeurXNa0JYIRUucIyUMxBX6y0NEAKAUZFkq1QF2AMqKcYy1qHPf0q1vWrotLxaUgtvpZJCen09ms0x1yrZlWdwkDHwBH02Njk5Mx00a1qx0bHJ4Ys7ytfskRcnnxULhOZxOBc1YLJ60mOJSOOeWYdjc5fJqem5mZmxiwuxoclhGYnhoJGs4fR6H6ih0m4VbS5Flh67lhmfn0zZhssLQMg3bkjSH1+OxMiODQ7FcDQuw3ODY2ORMWmv2etyEiD5eFBiTXE4HwZm5+WzOkFSNWpZl2xaTFZ/Xw+cGRyfjSUsKKOnEzPjITAY9Xj+jkoje58QYc7vcsiwXuiFfFBBd0wvdiJso1twXiSRJbpdbluSSXB2DRJIkxlih21GaEAlVWLBjydKWMydOvPP097InvYxbsitc07WqvWbV+iUHnhv44KUf2+P1ujV++uTRea37zlVtHr+Dc3FlLThEQiDUtnJR08g75954+kexsx4FQZF9DctWtdQuW738xBtHDjz7d9qlVpc1fenovomK9nXLO6p8Ds5Lcnsr4YtARHewsmP5+trzF9968WfT56MuBrYUbOzsrq9oWb5+8dHdB3/5jHz2eETK9e3bM8wiy1cua/JRIGJUoeAQkem+aOfKNc3PD+954Rfpiw0uYtu6v7q1e5GvceXm5fv3nnz9Fz+aOl6tJIaO7b9gVy9av7hRU2QUue/nQyl1Op26Xozp42dRtO9sijT3BQBN1aIRrdAN+bLE6O8XgkgUpi/e+tXH4+zFV/f86u/e4Qjgb1p5T3B127L1u74xaf7y9bfe+/lJ06bMGWxZ/9gTT25t9vkYF2XTi0RwyT33P2plf/7Svmd+sMckRA5ULH041Nqwdt1jj2YU/tybHz598l0bqB6qW/vobz6+aXGNxy7BTd2EL4zbjlDTunu/NT/19y99+MpP9tgEmVKxatcTkc57O7Y+9kcp86dvHX75+Ps2UtVfvfSBJx69Z329JFLfooCc6MHQyod//+tzP3798Ns/32txTll91x1PRFduadnytT+ctn/69qG3fvqBZVPZW7do5288/uDKaodCxR3xCynaDLJ0FWnuK9z2kIDkb93x5D/f9EDW5IQgIUxSHC6vroB70QNPNW5/LGfZBIFQKqsOp1NXGIpR3+IhhRo2PvmHyx/4tpmPCqWK7nY7VOZpv+ub/2L9E7n8cWCS6nDqDlUSe5PcZpCjGogse+QPW+7+bZMv9HFFdzqdiuyqX/8bf7z4EcPinBACVFIcuu7QKIiTpEggp7Krpuvhf/FvduYMGwlBQiRZc7p0TSbNK776Z+0P5QwbFy7cmu7UNZmK6AnFQuS+QvFiitOtubxXHnkRF/ZVV1weze37yHFxYS0mTNbdfufNoqd7NOeV6CEiIkeR+d6OgEmq2++47iRBjhyJrHkCuu+G46KPFxUASXEFQm64ti9zmyPIqjvg8FxznIsuLhQXkfsKxQuRo01u8iL8444LRURET/hUiIi2fbOT5GOOC8UEkdv2zQ4j3uy4IBQNkfuWs/HxsbNnz5qmWeiGCJ+EUjoxMT47OxsIBK4cTKfTIyPD586dK2DDhM+CUjozM53JZG7xnDwAYhhGf3+/pmmyLIsh0SI3NDSUTKZCoXD+R0TMZDKXLl3SdRfnIlEsapIkDQ0N5XJZ0cvKhsh9yxAiUkqDweDFixefffYZLpYQFb1MJhOPx6uqqvK1QTRNsyzr1KlTU1NThW6a8OkymSznXNO0W3ZrRERV1ZxO55Ejh/v6eiktxgqawrVisbhtWw6HgxBCKSiKks1mDxw40NPTIzKqIgdAx8fHNE1TFBUARLzKgMh9yxAiapp23333joyMiBWixQ+REIKa5mhsbNQ0jRBSV1d3xx1bpqenC9004dPlw7ds2bLm5hZKb9FCds55RUXFrl33z83N5qfBim5e5BCJy+VsaWlljCHSxsamHTt2xOMJEbjih0gaGur9/kAkEhE31PIgct8yhIiyLG/YsLHQDRE+nytpUzQajUYrxTW2tNzK0SBE9Hq927Ztu2WfKPxaXDlJamtr6+rqCtsY4XMSA77lQ+S+5QkR0+m0mOlbQiiliqLIskwpNU0zl8vZYrlI6aCUOhwOSbp1V1TbtrPZrG1b4n5cKhhjqqrmJ2cbhmGahljPV0IkSVJVlTEmhn7LgMh9yxAAGIZx6NDBiYlJRSnZvRBvJ7ZtMyY1NTW1trZqmjY5OXH+/Pn5+XmxNWBJyGcwq1evqq29RSN5lNL5+fnDhw/F43EAEDfj4mdZlsOht7a2NDe3cI6jo6Nnz57NZjOij5cEy7KcTufy5SvC4bDobmVA5L5lCAByudxLL708OzvT1NQk1roVOQBIJpMzMzNLliytqqrSNG1iYmLv3r1TU1MVFRWFbp3wKQAgnU5fvNjr8birq2sYY7fgzSgATE1NvfTSiwDU5/Pdmg8Vvoy5ublcLhePb2poaOScX7o08Prrr0mSFAgEROyKHKV0bGzMMMxgMBQIBER3KwMi9y1DAMA5j8fjy5evePzxx03TKHSLvjDI/9/lEukECRJy5Zkbr/42IKW71ykAnZyceO+992zbsm2bEDBNS1GU5ctX7NixvdCt+zKAEHLN9gSEfFL4rj1SSgDo9PTUX/7lf89ms7fwQ8E0TURyxx1blixZqqpKyd6Mr+vjeM1Jcf0PeSX6HQkhpLe3d9++fel0ChER0TRNt9u9efPmxYuXlHKNs4/2cZI/gld7NOT/hyUbPsakAwf2v/3227ZtlWxHE65TxLlv6Z9ihX0zAgChUKihocEwSjP3zZ8AyHl+RyAAAKBAgSDnSACAUiCEEMz/HkIZhesuxKUiP9M3GAzGYjFCCCEIQFRVDYWC9fUNhW3bl4GIV6JHCACllAIg57jw08KtEjnnhFBK6dXHnBJCKdU01eVy3vpCY4qiVFRU1NXV3cryar9m154lAHThvEBc6NGEEADIbwlICCwcKkXZbNbjubrXGaVU1/XKysqGhoZSndm/cIG2+UKlEQBKKQBBbnNCKQW6kP1e6eJASvISLUnSpUuXHA4HQAGKCZZq175GEc4SKdLcN78UIB6P50p0zBKRMSkUDCpKIcdjOOeWZVmWVagGfDmIxvz0pYtnLo5MJAwiqc5wQ3dLU4XZe6QnBpUtHS01IZUQMz47fOHk+RmteX1Hnderlt7OmZRS27ZvmJqSzwhKNnaEEJ5LTA71nOsbnIoZBGRXqLGjs7Wajh+9MJiWqrq62io8lNq5xEzfyWO9dnhJZ0t9yMVLLXiXw1eQbp4/SWzbtqxSHI4CIJaZmhntO3e+f2o+a6PkDtY2dzX66Gz/6YsxX9em9mqnS0HEmeHT53vHwdfavaTOU3R30c/moycJIuZjV5K5LwDapjk3cuH82YGJeNpESQ9XNS9qqZXNS6dOXJKrl3c2VfucSEhycvjiudOzWt2ipU1BVS3N+QKF6uOc82QqlUgkSnfU3O10ud3uYqtBXqS5LwFiWmYsHkskk0X4xPCpEFFRFL/PV+iGlC7O+cy513/+8js9Y5IvEHYqiI54TtOD+tx7z//8Al33ZLC2NqwSsOYnzuz+1Q+Ph77SUVHh96klmD2VI3Py2J5XX3/18Dj6whVuhVDndM4RrPRbx1954c0Jx6bfqWkJexjlucTY0Rd/+Atr5R/4w00Vbm6L8N0mgPLs5IUTb/7s6f1ztjsccKuSzKZNyacm+ZlXfvqL3rbfXVpV4XarNvLJ3n0v/nKf1PK1miV1Xijd6U3lA6iVjg8dfvGnz++fIA6/P6QzJLE097s9WvzAs3//onPr/xKuqA04OaHJoZ53n/nhmeDdwfZqv6qxkk3iCoEjz2QzM7MzpbtuhwF1u92FbsWNijX3zQMo3SXMJdrs4gBATHvu7AfPPfvGYN3qJ+7dtjKkWFlOVdUJMDLe39sntySyHAAQ0MzGxvovXMjO5XIcAEp6TmB5ACA4e2b3Gy+/fpBueOzuO9ZHHdxGkzt8KhuZHRzsG9U70mZ+6i83MjODF89Z1bGsJbrMbQSApmYHDu3+yTPvKbu++uSG1Y1eBdI5GgwqyUszI73nL7jjpokUiE0gm5gY7O+VnXETCSGijxccUJ6dHT/2yo9/ulfa/rVHN61Z5AMzzZnucZLE+FT/+fO+7kTOBkIIBSsdnxjo6c2szNi2CN4XUrqJUNEq7txXuD0BENPgkxd7xpJK27qN2+7e2Ew4EgKMZiZi/UgQbvwDACU5V7QsAUHE8f6ekbhUt23bvTvWtyjSws5jaE/hjc+F4rJ+ewKIz81c6uml0W/suGvLxsVR1eZIgMqJE0NsYXXU9b+/9OaJlisAYmYS4709I9nGh7Zs3rpjRa1tISFAJWP8+CVCQHRyobgV1wwMQbhqYXmExEA8oZUe5DZZWN0iCDeFiMhtACo2Cyg9iPnliYzKxTaTUxA+nThnhaImbomCIAjFSVyfhRIlcl9BEARBEAThdiFyX6Hk5KukX7NgoiRr5tw2bjY0dP2mBSJ8wk3gdf8lTpLSggtVva/t4WKUWCgaIvcVihIAKIpCAU3D5ibQyyU/gIHDqbGcmcnmDAQAtIxcOpsiTl1nEhNriIuFpMgMiWWY1pVyLQBAQHXoCnIjmc5wAABuG+lkylY1h6IoIni3F0qpJCncME2OSK8sh1JUxaHrtp1Mxm3bokAhlU5nsraqOB06IaKPFwWgVFUUQkzD4LZ9pX8TiUlOXQdIphOmmQMAyBnZZDpHqe50gpgZLBQJsYpIKD6IhCk01NrR4Dl2bveLv1ASXQHVyoDi9reu7apZsiTy5it7f/UPeqK/2WmPHtv3zvk537LOZqdPF8V9iwASQkhFc3d9sPedvc//5Aezy0KabQOXI0vWdQbbFzcHz7/29s/+zj2xqlpLXTqy791Bq21dS1UoUHrbkghfHKI3UNHY1cmOHXjm557RczUeCdKWXtfSVhesbV1c9coHr3zn+5m1i6po8vwHb3wwIzVv6Gj0iCKGxQARJd0bbuls0V86+tKvfpG42OKhZorqwfqutYFA5+J2/enDP//RD2bPdQbMmVPvvXoyrbd1dYRUjYqXdEJRELmvUIQQicy8net3PTCpnOofP3vccmtoar7q1tqNrGXl9gfvy7xzZnjo1LGEBsnpTHDFPdsf2NTidSucl+AGSWUHCYFQ151b70un3huYPnvyhFcl4FDCUmOO17XdcdeuROzt8/MXTp6cUY2ZaWy884GtW1c1BnWOInq3DUTuCNSt3PaVh8Z2j85eOn98VlUkW650BOu6Gts33ve1vuyh2fGLp+0pnpow9datG+69c1WtQ2xsURQQweGLLN3x5GOz7wzPDp8+lnZK3HBHWvwNSmPV4ru+8tjM2+fmx84fsxxmYpZ7lu248671nV5FBpH7CkVB5L5CcQKgvtYdv/1HKyaGRyam0iZIqu6rqKt2e3Tfssf/pP3O8cHRyZmUKTs8/oq66kqPgwGITcGKBvUt2vR4Q/fmkbHx2YSJVHb6Kmuqwm5F8W38SkP31tGR8fFYBpjiDdbXVAdcDkZtMWp/O0FO5GDL4gf/5f+6fmRodD6RM4nk8oYj1VUet7pkw7f+/aL7hodG55OGzVzhcKSqOuRUxKSmYoFINGfV6of/tHP9yMD4bCJjouQIBKP1laruiKx44J93bBwfHJmOJbOgeoLhmpqoV1MoiPAJRULkvkLxAqrqwdpmf1UDIhAAoJQxCoSA5gjVtQaqmzjmDzJRRrb4MMUZqGrxRfNPJBQoZQyAEJQ0T6TeGapBAoQAlRgDEPfE2xECSLon0twR4khw4SShFAgByemNtrjCHAkSYJRSJqaKFhugVHNHGrpCdfntdilljFIAAkR1BWravFXIkYgrtFCERO5bzq4uMSpVQCSQiSRf/vnKCzOQJHb1eGm/R/u4MJV47AghwGQmkY9Gj4AkszKJXoHDVAZ9HCTGrrkRXdPH5WuOl/hZ8jG73JdB+K6L0rV9XFbYTQ6XpBKPkXATIvctW4iYy+UymYxhGIVui/BJKKXZbNYwDMT88AkQQizLymZzmUymsG0TPhWlNJPJWJZ96+/vnPNsNpvJZDjnJZ5dlL9sNmdZ1pUwIaJt29lsNpNJ2zYvbNuETyZJUi6XtW1bzLkpGyL3LU/5EmG7d+8eGxuzbbGCqKgBQDabicfjjY0NlFIAQikbHx8/efJkT09PoVsnfAoASKWSY2Ojt3hrV0ppOp1+5plnPvhgjyTJ4q5c5FKpVDKZWLlyJSEkP4bY19f34x//ePfut8VzS5GjlI6MjGSzGRGosiFy3zLEOVdVdefOHSMjI6qqiptiKQBJkqLRqKaphJD6+oZt27ZdunRJ1x2Fbpjw6WybNzU1tbS0Atyideyc81AodPfdd09PT1NKqZhNWQJAlqXW1jZKKaVSa2vbzp07k8mkoijiEl30IBQKejyeaDRKqajTVg5E7luGEFFRlDvvvNM0LXFVLSEAoGkOQkhFRfiuu7ZnMhkRvlIBQHVdv2WTAjnnfr9/x44dpmmKO3EJkWWZMUYpraurCwYDlmUVukXCZ0Up0zSNMfbpv1UoeiL3LU8A4PF4xfT80sI5z0/cBABd151OZ6FbJHwOtn1Lp/xKkqQoHtHHS4ttc0SOiJRSr9cvoldCEFFMrC8bIvctQwBgmua5c2enpqYRibi8Frl8jBRFqayMVlZWyrIyOzs7PDw8Px8T477FL38rVFWlubkpGAzdmmQUAOLxeE/PhVQqfQs+Tvi1cLlc1dXVoVAIEWdmZoaGhtLptLhEF798jDweT3Nzs8vlKnRzhF8DkfuWIQDIZrM/+9nP+vv7w+GweE4tcgCQzeY4t9evX3///Q/4fMrFixdfeOGF8fExj8dT6NYJnyIfvkQi/q1vfWvLljtuzXRAxtjo6Oh3v/s9QlDTHCJ5Kn6JRMLt9uzcuXPbtm2WZZ05c/q5557LZrMul0tcooscAMzNzbnd7j/4gz9saWm5xatahX8MIvctQwBg2/b4+MTSpcsefPBB0zQL3SLhk1BKx8fH9u3bl8lk8kU5MpmMpmnr169fv35DoVsnfApK6fT09Pe+971bXJAuXxTvvvvua2pqFjfj4nfq1MnTp0/Pzc3lM13Lsjwez9atWzs6OjkXNc6KmiSxPXv27tnzQSaT5pwzxsTjSqkTuW/ZAoBIJNLW1la69X3z9cTxSmH0W7aK/tailDocjnPnzlN6dRWFw+GoqqpubW0tYMO+nMsv/6/uVQDkciDLaS4HpdTj8ei649afm7IsRyLRlpYWSZJKs2fc0MUBoNS3QfhYqVRqdHT0mt4AqqrW1NS0tbWVbBlKIECAXOnjQODyHKDyIsvy4OCQw+EQ0+vLhsh9yxmlVJKkUh1UQOR2zkglY8lMxuKEMkV1+T26bMVn4gZqXp/HqUmE2EYuFZ9J5CRXhc917VZCJYNSyhi7YesgAMiHr4AN+1LQtsxsKpFMJbMmIUAl1e3zOiUrPh/PEc3t87sUAOCWkY5Nz2dll9/r0pVS/LaUUklihbopAgBjrERzX0TOzWwmlYylspaNhMiqy+11S5iJzyUs1RvxOiWZEkKyybl4PENUtzfgVks0+5Bl+aPD8/k+XqIZFXLbzGVTifl89CjTdI/fpdm52GzcVN0Br0uTGQE7l0zE5tPc4Ql5dakkt6aWJIkxBlCKbRdurhTvNcLngIileFMkQAjPjh955vmX9x0eyoImS9zSoy0rt3/1TvLuj17tg6W7HrlndYuLEHNm+MhLP3nhnP+eP31ofU2ty+al9nU/IUYlGTtCCBCSHTr95msvvHrwUk6SVUBwuurWPfKVbr7v+TcuKE13Pfb19TWyRM3E5KmXvvPzC3V3Pn7/thXVzhLc4KrgXQwvK2AbvghgPDk8cOjFHz1/bDCFMmMMuKNl047NiyMT7//q9UsNT/z5g6siFbrN+fCZN55/9bhUv+uJp9ZXstIcWvyEPl56sSMAYGbnLh765T+8dGx0ypY1mXAzVLd069Z7w6ndP3h+aNmur929qavCiTQ3fmrPcy/uiS++/4/uXxHQNV5637Y0YyR8EpH7CkUIAHNm8sz7v3r65dNK1aqNa5tcYJuKN1LrQeg9vf+9Y5K+ctt2AEDg6djIqf1vvR/t+t27VlEAu4xep5coAMTpk2+8+sxL+2ZqVu5c2eySOJEVf1VAN86e3bfngJ7uuJsjIUDtXGL0zLtv7ltWfce2OyiQEn33K3x+lKWm+z987Yc/e31u0Z0bu1vDDiCWFGqo1DMzA0fef+NEcsM/3bE8f07Exs8d3P+enFyxi5AymzJTmgBIZnbqyEt/9+N359s3rVzRXqujberBuqgzN3P++O63ziqL7rljPRBCqJUY7Tv8wXtTyorfvWepiJ5QHETuKxQfAGIbfPbciTOjZvRru77++4915QcLKEmNzg0RoPmtf6/8dkoZoyX64rD8AEHEyZ5j54dT3s0Pfu13713ilBAJITnbHOgl9CPRY4yJjcluNwAQnxnvOXFk2v3w/U9+c9uqGp1zJEho7OibjF2/Vx0ApVScJEUDAOz0/OT5Y0cnwzv/5CvfeGJds2QhIYTSuXPvnQBK2XVdPN/HRfSE4iFyX6EoccRUOsO5ojsVppimwZEQYLQE35fdnnKZrMmooqsKubz1GHAx4CNcw7LsXC4rOXVNImiZps2RAJXFSVIKbNtOZbJAXE4nY5JpmhYSAkwS0RNKgpi7LQiCIAiCINwuRO4rCIIgCIIg3C5E7isUt+srf133CwQIISA2BC1m10Zvodzv9T8Kwsf28YVz5MqJI96nFx/4+OjlL81QtlV/hVIm5vsKxYpSCgQt07IsvlDECQgCkRQZ0M7lDMPiHLhpGjnTIsrNqmcKBQOUAkFumZaFKCHnSJADUiZThqaRy2UsrjDLMtO5rI1MZiJ6tx0AAEqRm6Zl2xwlRI4cOWGUSRLhuVzasCyO3MrksjkLqSZLjBCRAhcHAEopIZZpWpbNEZEjAnCkIMky2IZhmJaFSCzTzOVsBFmSxQOvUDRE7isUH0TCZBqurHSrRy71XLx4YSIUks2sZRObas7Khhr93QMnjhw90V2zxGf0nTh8sGca6rbUqK4CbK0lfAQSIBCMVPqVC+f7z50Z6AxGdG7ZuZzhDLgqaitC/OSF4wf3rgyuCtojp989cCGF0dpKv9tZcpWZhS8OEZ0udzgaMS5cONVzqbFC9kmYzpqKQ9G9kaoaKdFz4J1TnaqzQYof33/8zIgR2FJb6QdRIqsIIKKiOsKVURc7dvFsb+/iapeHWlnDphJT9araKvmd44cPn1pc4+zQZ84cO3rkkqUuqamRZUVETygOIvcVihKVmX/59scejL1+6uDP/u/zr6kMqKe6c932JzbV3/noV8fZ2+ff/+F/PeaWSCqesVq2fvP+nV2BgGKL3LcIIBISXn7fvffb1p79z/7l2bcVhUjeUMf6+3atr9vy2GNx7aWjb//kL468LGMmE8/V3vvUvVtXNvgkjqK87+0DuauiecOubwzE3j388t+ce1tXqKwG2tbfddfmrqU7n/ytueeOvP/sd469oRMzHsv619+zfdcdLS6R+hYHpHq4avXDv/V47r3zz//wP+9+TqEgVTau2Lrj/pbW7d/87ckX9x/75fcuvOYkRjJpKqse/OqD65ucChOjE0JxELmvUIQQkVEW7drxqOSvfv9wz0gih5Lq9wcDblV1N62+/0lXxYEPjl0cSRhyVUt1+9p1m1e0B1UFsfS2BStTWvWKDbscun/v4fNjsxmkqjcYDDhV2V+1aesjfm/l/qMXxuYMFvGtblu1YePy5qhLFg8utxXkTK9oX3H/b4L/g4NnRqYzFsruUMDr1nVfZOnmr7lcdXsOnh2dzdpS/YqWJas3rO6s9YGYOFoUEG3J6Wxc/8jXldC+A6cG59I5lJz+QMDrdPhDnTue/Ka/at+HZ4fmU4ZW2926ZOO6Nd21XpmK8AlFQuS+QvGSPA1ddzV233X1CCISgsTbtGhn8+KdNxwnIvEtHshld+XSLY8v3XLtQUSCxFO7fGvdiq3XHxbDebcf5KCo4Y71j3Suf+Sao4iEEEdF18ZHuzfeeFgoGoiUad7WTQ+0bXrg2qNICHH427c81LHloRuPixAKxULkvuUMACil5bSI6GPXg5dysQe6sNPZjV8BFlaTlI+PLdlRwtEjhe1i9LKyyQ3L8iQhNyuIkD9STrEr0ys0uen1WShpIvctW4gkm83E43HTNAvdFuGTUEqTyWQul1NV9cpB27bT6XQikShgw4TPglKaSCRtuwBzlW3bTiaT8XhCUeQyyp/KUzqdvuFSbJpmKpWKx+Oci1dWRU2SpEwmw7lYj1A+RO5bhhARAGSZXbjQ89ZbbxXkrix8dgAwOzs7OjpSX98ACyUxIZGInzlzuszGfcsSAMzPx5LJ5C0OFqXUNM1Dhw7Nzs7KsiRS3yI3Ojo6Pz9fWVlFCAEgiDg/P3/kyJH5+XkuKpwUN0rpmTOnLcsUT5hlQ+S+5UmSpMWLFw8NDZ05c1p01+JnWZbL5aqtrZFlmRASCASi0ejk5OS5c2cL3TTh01mW3dDQEAwGb1lfQ0Sv19vV1Z1MJi5e7Lk1Hyp8GaZput3uSKQCABij4XC4urp6fn7+7Nmz4hJd5AAgnU63tLS63W4AEPEqAyL3LUOcc03T7rnn3lgsVui2CJ+VLEuBQMDhcBBC6uvrnc57Uqm0uMiWCkmSotHoLbsvcs5DodBDDz2USqXESVIqVFXx+wOUUkJoY2PTQw89nM1mC90o4bPSdUc0WinexZUHkfuWJ0ppQ0ODmJ5fWjjn+Zl/brfb5/OKXZBKi23bt3Lc1+FwNDc3iz5eWq70ca/XGwgECt0c4XNARM65eNQsDyL3LUMAYFnW8PBwIhEvdFuEz0qS5GAw4PV6GZNisdjMzEw2mxVVgUoCIpFlqbKyyu1235pbIwBkMpmxsTFxkpQKRKIost8fyKe8yWRicnIqlxPjviVD0xyVlZWqqooHzjIgct/ylMvlXn/99bGxUZ/PJ55Ti59hGLZtL1myZOPGTS6Xa3R0dN++vTMzM5qmFbppwqczTTOZTD744INLly67NZ8IADMzM6+88ko2m1EU5dZ8qPBlGIYhSdLSpUs3btyEiP39/W+//bZhGKKPFz8ASCQSmqY9+OCD9fUNjLFCt0j4skTuW4YopZZlHT16VFWV9vZ2y7IK3SLhkwDA3Nz8hQvnFUVZuXKV2+1OJOIjIyO2bdfU1BS6dcKnAIBYLLZ///5Vq1YtXryEsVuxbyulNJGInz9/rrq6OhKJiJtx8ZuamhoeHvZ6vevXb0DkExMTvb29NTU1FRUVosZZkWOMzc7OXrx4cd269TU1tZIkiRGlUidy3/KEiJZlrV279vHHnzAMo9DN+aIA4Pqi6PkrDuRLBC1cfi7XjL96pMRQSsfGxlRVSafTnHNEgohOp7O+vuH+++8vdOu+uJtFDwmh1werHMI3MTF+4sSJW9x8zlFRlDVr1qxatVpV1dL8x/volg9Xu/hNTxJeol+TkJ6eC7t3785XnMx/iXA4fOedd65YsbJ0y1B+ZMOO667Q1/yUP1Kq0ZMk6f3333/xxRfEZIeyIXLfsgUAsiyX7uQkRAJo5rLpZDpn2kgIMEXVdZdKsqm0SRSHQ1MVSgjaVi6dzFhM8+iqxGjpXVwppaqqyrJ8OVIL9wtJYtfudlFiALlpZNPJTNa0kBBgsqo7nRo1U5mcDYquO1QGhHDbzKWSaSK7HA5NYaUXvYXwFWTkFQAURVFVtWRzXyS2mUkn0xnDQkIIlVTdqcvUyqaylqR7HQpllBBi5lKZtAmSQ3eppTrCrSgKY+zK1Ti/o1s+fCWb+yI3MqlUJpuzOCGEyqqm6zojuXQiS1WXw6FJFIHYuVw2nTKp6nRqMqUleDuSJCkfPrH+uGyI3Lec4WWFbsgXgWjEBw4feOf9d45dmswYRFICTSu3b79neXb3917so8vve+yeNU0upLnJwX0v/cPzZ/33/elD6+tqXVbJ1Yn/hDCVaOwIIWjODp/a/+5b7x/tm4kbhKnBqhU7Htq1Wj35dy/tmVVWPPGVXV1RiVnp6d53fvzdl/mi33jonjvbK8zSSwIK28XwGoVqwxcEhGTnZ3oPvvnG+4cvTMwbHBVP9dI7dm1u0Xp3/+LVgYav/psHV1ZU6DbHS8defO7146zu/q98Y30VJSX3VQn5mL5cqrEjBAg3U5P9B996/YPD50biOYtIzobODbu2b3Hn9v7yB2/p63734e2rGoIc6FzP0Vee/+UF75avf2Nbi9stYYleogvdCuHXSeS+QhECANM2Ln7w0x/87MOcd8XqLR0BxbYld9hNbXvy/NEPj0u+1TssoECAZ2Jj5w7v3Rddmtpu5l+MFrr5tzsAgonzu1/+yXNvjPg6N25cE3AgkWWfS2d8ZvDU8UOjjuD2BzgSALQyscET+z+w5G133iGidzuh1JwdOvTG3/8/Px2oXrpu9dJKj8Qs5qtw2cmpoVMH9pzM3pHZySmATTAx1Xf80IdyZvUDSAgRZ0nBAaW5mfmTL33nfzw9GFqxcsXKZg+zbYc3olIrNdt3ZM8HvvDD2zcDEEIhOzfZc3T/wYraXaaJInhCURC5r1CEgNiGPX764METY477t9/91ceW6cw2LQ48m7KHLMuy4erMMSSE25Zli+UiRQMJjp3Zd+TUkL34vnse3bXKp3LOLdOSHOq8bVmWfd0mrty2LbvkhoKELweAxqeHTu7f3ZPa8pVtu3auqXcBGqbF1HTPFOGWaXG8kiUh2rZtUXGSFA0w03NDJ/Z8cAJW/dld9z2xvkNF27RsYHayd9S2LMu+JlaItmXZtoieUDxE7isUHyCE2xifj+W4XldVGYm4NZOjRoBRKTMvdtUpckAIklRsPo2KP1pdHXI5ZAkRCQDhVqnO1hR+/bLZbCKWUHxVtdGg160rNtccQGVgpblC4TYCQGzTjMfiJglX1VRUhF2aYaFGgEpGCqiYFSsUPZH7CsVqYWU3z2+lg0hKefrrbefG6InICTdaKBJw/UkizpSScTV64gotlBoxhiYIgiAIgiDcLkTuKwiCIAiCINwuxJwHoVgBACEckQBhjAESQigAEEqBcG5zJEAZJUDQtm2klBJRJqB4LOxNwAlQdmWrM845UADk3OYcmMSoDWhbtv2REvnCbQM5EqCUMUYACSFAKVCgHPPnBWUMbc65zUGhlBIi+nixoIQgco4AwBhb2MaCAlAKiKZlE0KYJAEStC0bCaVMzAMWioXIfYXig4RQCfzBkEs7Oz8+Nnpp2qdzRGCKShmEa6qc+y6ODAwMjDSDZowPDgxMzqu1ayOqroq7YrFwBcJeeWhicnR4fNrvlBAJMFXXFX+kJqQNDg32XhzsDgZZanSgZ2DaCndHfG63mCt4e9F03R8MweDkyOjERKWkc85B0pyq01MRrVKsoYunh0YdblPODV3sHY1Z/rrKsE8kT8UACZEU1RcMO5WhmZGJ0aEph2IjUqY6HLIWqqryqGdHei5d6qty+sj8pf6e0bjDE60MMVkSjy5CURC5r1CEOFJF8i/fuLnt+POv//1/PPVu1Mlsw1HRuPyBP7y/aeNda98feOvnf/V/7n8urOD86OiU7Vz5tfUdvoDGRRWkwkMEgMplW1Z3Xfrpu9/9/428GXVSm+iO6g1PfnP74qV3rFvU2/P23/2Xf/V2nUfKzo6PTpgNOzeuaI56RfRuI8i5r6J+2eYdTQfe+v7/PfRyxKMxYqrNm3fs2rW2dfXWLe9/783/+v89UR320dzEpcF5X/t9G9e0uCiU5s4WZYZz6gpFV9xxT8t/f/tn/+X/ereyQidWLlCz6M6Hf29N1bI77u088fov/9v/Z8/PIi6eGB8aMwKdD6xfGtRUKL2NLYSyJHJfoTgxUKuXPfh7f1x/7vxY0kCgAA5/ZXulyxls2/TVP/F0XeiZzprIKVDJU9vQvWJllUujiKLKbxFAJM6a9du/4Q4tOj+atJABUs0Zbav06C7vqm1f1wOLzgzHsjZhyKkWrmlZvmpRlUviInq3EeSSs3LJpt/456z94kjMQABKqF7d0RDy+b3r7/4n/2vwxKXRuIWAiFv0YGP3siWdQSYKCRQHJMzla9v2G//S2dE7OpNBAgDgrWhsqtC8vuY7nvxnrvbzQxMZG5ETeoezqr1zyeI6XWZi1FcoDiL3FYoUgOSpW3tH3Yp1Ri5ncgKMyYpDBkRwtW3e3rp2U87IWRyYrKgOlXGbczGkUDxQ8tcs2VLdvd7I5EwkBKiiaRIAIaRy0abKzrVmLpOzCVBZc2rSQp2rQjdauJWQE9UbarvjoZb16axhcSREkhVJVhhBvXrx3TXdRiZrWBxB1lRZUhixxRYoRQMJlfRI85ZHmtalcoZlIqGSLCuajDahkcYN9zeszuQM0+KEyqqmahKxbC6eXIRiIXJfoXghWhYBJmu6vHCE52tIcosTyhRNV/KHLcsuVBuFj4PcRkKY7LgSPZKf68dti+Rn/+aP2baI3m0KkaPNCVM0h3LlIMf8Ajhy3XEu+njRQc5tTpiiOJTLYbIRCMlHlcqKJi8c56ZVsFYKwk2I3LecMcZkWRbP2kWOUipJ0sIa9svya6dlWf64PyUUCUqpLMsFKVMBAJIkybIsunnxu2kfz4fvhuNCsZEkSZIkUYqmnIjct2xxzkdGRk6fPm2aZqHbInwSSunU1NTU1NSVWyAiSaVSw8PDZ86cKWzbhE9FKZ2enkokErc++8xmswMDAy6XW1VVkfsWuYGB/rm5uUgkkv+Rc55IJPr6+nRdt20x0b2oSRIbGBjIZDKil5UNkfuWIURkjIVCoffee/fUqZOFbo7w6SzLopSuXr2aMUYIUVU1mUweOXLk4MGDhW6a8OkMw8hmsw6H45Z9IiIqikIpffrpp1999dX8aSMUs1zO0HVHc3MLAFAKqqpOT0//5Cc/cTqdhW6a8OnS6UwoFBSjv2VD5L5lCBEdDse3vvWt+fm5QrdF+EzyMxx8Pp/b7SaEtLa2fvvbvz0/P0tEMfgSIUlSfX09ANyakSHOeU1NzZ/8yZ/Mzc2JsaiSAACyLIfDYcYYgLR06bJgMJjJZArdLuEzAQBN06LRKKVU9LgyIHLfMpQf921paSZEbHRWSvJbJBFCXC5Xa2urKNhWUm7pU0r++balpRVRLJ4vGflA5fu41+v1+bwidiUEkSCiGPctDyL3LU+IaBgG52JpdMmglMqymr+w5nI52xYLo0sLKIpyK+ce2Lady+XEw20JYUxSFIUQgshzuZxIfEsLpVRRVJH7lgeR+5YhAMhms6+++kpvb68kiRCXAM65qqrLli1fvny5pjkGBwcPHz40MTEh7o4lgXMuy8r27dvb29tvza2RUjoxMf7aa6/Pzc3ego8TvjzTNAOB4Jo1a7q6umzb7u/v//DDD+fm5kQuVRIsywqHw9u378hPeyh0c4QvSyRGZYhSahjGa6+9nk6nly5dIsqnFjkAGovNj46Oco4dHR0Oh2NkZOTQoUOZTLa+vq7QrRM+BQBNJOJHjx5tbGxoa2u7NdMBKaVTU9NvvPF6JBKpqKgAoGIAuMiNjIxeuNCj63p7e7tt28PDw3v37nW73dFopZjdVOQopX19fUePHl28eHFFRQVjYn/Bkidy3/KUn5a0c+fOp556yjCMQjfnSwCAhQlyBBER8Zqfrv091x8pKZTS4eGhV1559UqVVgCoqqru6OjYvn17oVv35QDATaN3TbBKPHoLQ7D/4T/8h1s8gIeIfr//8cefWLp0aWnX973uJCFl2ccJIcePH9+zZ8+VHymltbW199xzz4oVK0t6eOLqFfpq9CghWE7Rk2X5zTfffOGFF0RBlbIhct9yJkkL08tKFFDCTSOXzeVsmxDKZNWhSJQbWZMTpsiKLAEC2pZl5AwOskORmERL7/JKKZVl5YbqOflV4SUcPgCC3DZzuYxhcUIYkxVVkYEbhmkTJiuqwgCA27ZlZHM2yKqiyBKUXvTyswCVgrwGvXKSlGruCwQI2qaRzeYsmxDKJEVRZYqWmTM4U3RFpowiomXmTNMiTFFVpVRfNyuKIknXZU75XVEURSnR3BcACHIzl8kaps0Jk2RZ0SSGtpE1kCmqLEsSEIKWaRo5k0iyqii0JCd45LePEbNTyonIfcsZXlbohnwxVnp6ZLS37+LoXMywqaTowZr25pbK9Ll952axZtGSzrqIRogZn7106tDJaUfb1iXN/qCj9L7ux4WplGNHiJmanxru6+kbnU7kOIDi9lc3d7R7U+ePX5iAcPuylU0BRpmZiQ+efP/EpLd5xeL22oBagt+3sGHCaxSqDV8QEDQz6Zmhvov9lyaSWRtB1n2VTR0NHpg+f+RMwr/0rqX1bo+KiNPDZ06dHWLBruWrm70lmoB8Qh8vvdgRAgStbHJuuP9C/8BkPGtykLRgtKG7vgrnz+w/E492r+puinpUAsbcUM/xU31mVcfmRQ1OVSnBb1uiMRI+gch9haIEnOcmjv3qL374Wv+sv6mlMaBbWeYZTkJwU/ydX/7oNN3yrcqmhqgDwYpNnHrr539zKPzNpbU1wZBDzJwrCtnxfa/+8Je/2jfnamltCWmcK3Qw7Qw1Tb33i58cUbufrFveGJAo2Knpnnd+8NdHOh7z1zXWB1URvdsGAE+Pndj7s//+nQ9Md21zXdilsTSZSgOv1c6/8qMfnuv6Z6sbq71ejROcuvj+sz97T27/duOqZh8lIg0pOAA7Md+7++/+8/f2pgPRxvpan2SmHKOTlG/Qht/82+/2bPmtyrraKq+GzJi5cPDFH704t+HbK9tqXKoigicUAZH7CsUHKPCMPX1s3ztHL7F1dz/0G/d2Oik3iaRpqqIdmpsan5ISGRMJEALENtOxqfFxlrYsBFHRuPAACPLxY+/u/7DXqH34oW9tW+KSbQ6EKaFQanxuamLKUZ228xObkVuZ2MTYZGUia2GJDugJXwRQGp+6dOTtl0/Pdvzubzy+aWmNC9DgsjdIx08emZsYG69O2/bCOWFmYjNTk3I0YxMiqpYXAUrt+Mzokd2vHDabfnPXI/etaFbRNoni9LPcud7ZsdGpeDLH8+WM0UonZ6cmpxMZjiiiJxQHkfsKRYlbGJ8Yn8tKTS0di5Z3NSNHQoBBanROAqCUXjv1CoBSWpoTycpWfGpsLkP8jV1LFne0yRIiIWBya+Bjoiem0t1+IJNKzkyME9/O7u7u7u6oanEkAFJs5jQFCnCTLi5OkuIAhFi5bGxyfM4K1XR2LVrWWWtbSAgwNn++h93Yo0X0hKIjcl+hKCFBm9tAgFLCiW3bHAkBQsWIQYngHJESSgmxbJsCIiHAxYCPcA1EROTAKCDnVr6TAxV9vCQgQZtzIJRSjmjbto2EAAERPaEklOqaWUEQBEEQBEH4vETuKwiCIAiCINwuxJwHoajlF0QtzP3Ll8AHAMIRCSGUAKeEAEcbxYTRIoSEwNWZmwALhfDzRfDplf9GzMe10M0VCgUud+6FfS4AAAlHhPxcUSQLJ4k4R4oKIuanMcHHXaEpIAVCELm4QgtFReS+QlECCppTl8FITM/MTMcqFGJbBCTKAT1Bj5SdGh8bG5uOSRKZnhgdm4sRf7dXUmSxhLhYaLpToRifn56aiVc4ZUTkiKqmuXy6jrHpsZFL05XVOpmb7B+dzhGPz+1QFFG66vYiyYqmO62J+emZ+VhMdyDanEgaqprL44PszEjfxLTHT2huanhsIsG1gM+jAxF9vChQJmlOXSaJ+am52am4l9ncRpBUW5LdXg/EJ8dGJydmAsCs8fGxsYTBPB4vpUxETygOIvcVig8iYQqLdi3trDtz9Nj+159TpiocZobILk/D6q665aub3nv2xBuvPkMTXT7z0qH33xul1RtWtLn9OhfpU+EhAQKVHcs76wZeO/vOyy+Q6SqHbQOXfJ2r2qqXLus6/Or7e57/oT67JmSOnHj9nQG1btPS1qqAA1GU971tIHJfMNqxfJXv7Om33ngjN1nv1WjGVKoam+vDzYtXte1+4/1/eFYZWdYgzR95453TWc+yxYubfCBKZBUBRJScvuqulYurn+3Z8/brdK4ryMw0aP6a5qW+puVrG9/Zt//FF/TEpRZ94sK+3QcT4bpN3S2aqqCInlAURO4rFCFEIlO9betv/qGn7cjh/osHP+hhVPHWdq9vVLTQ6of/5J/W7D12dLDn0H5bplrt9t/atW792ia/G7hInooAIiHujnse/lYovP94X//hvf0Aij/aua6NaLWrn/yG2tx04ORA/+F9/RSllk3feHzV+rVLqh3IxW3xNsK54mtcf+/v/y+uvSfPj506NEJAcUfafHVt7mj3jq/9a3fdh6fOj506PGYjNK786v1rNqxZUqUQsb9WMUBOlEDFskf/+Z+HPzh+fuTcvg8QJL26aXlti15Zv/m3/63Sue/E+dHzB/ZblHnXPvKHqzesWlapl+Sm5UJZErmvUKQAHKG2tZtCTc0Ts7GsRaikugPRiENTJVfXpm3R9vaJ2XjWZIrLE4xGoj7xNrSoUD3auGyrv7pzciaethCY5gpGoh5NU2tbV/vC9YsmZ+IZmzLNG4pGK3wOWezWdbtBIjmCVYvvuqeye9lkPG1ypKrLH46EdVVz1a+821e3dOVUPG1y5vD7wxURv0tl4hwpFgiS7KtdtGVXuG35dCydswlT3N5QZVh16I7mFduC1V0rp2PpnK2o7kBFVTjkUkXiKxQPkfsKxQtBc4br2irqASBfDZRzjoicaHq4rj1//MrhQrdWuA4SqrpCtW3huhuih6C4Q7Xe/PF8iVfkYjTvdoQEiOT0VbYGqvIrofLnAkckRHL6qloD1defJIVusHANJIQQh6+yOVBFbggTLhwX0ROKlch9yxmllDHGGCt0Q76sy5kRUMpucvzGwyUmH6YblkEDQP54oVr16/Np0QMKpfwtbxq+W/zpjLESf3q4cpLccDaUyUlCCPno7oXl18fLNXqMMbH5ZJkRuW/Z4pwPDQ2dOHHcNM1Ct0X4JJTS8fGJ6enpQCCQP4KI8Xi8r6/v5MkThW2b8KkopdPT0/Pz8/yWzzbPZrO9vb2yLDEmiQk/Ra63tzcWiwUCwfyPnPP5+fmLFy8qisq5Xdi2CZ9MkqS+vr50OlXiT5jCVSL3LU+U0lAo1NfX+8ILL9z6W7LwuQBAOp1OJBKVlZWUUkKIw6Fblnn69KlYbL7QrRM+RT58nHNd12/lyJCqKg6H4+jRI/39ffnTRihm8Xjctm2nUyeEAICmaZZlHTx4sL+/X2RURY5SOjIyoiiKLMti9Lc8iNy3DHHOVVXduXPH+Pi4LMuFbo7w6RCRMVZTU6tpGiGkvr5u69at09PTZfE+tPxxzru7u9va2iiltyaP4ZyHQuF77rk3lUqKxLck2LataVpzcwullFLW2Nh41113pdNp0cdLQm1trdvtjkSit6yPC/+oRO5bhhBRluU1a9Zalik6aamgFCRJzj+rhEKhdevWWZYlwlcqKAVV1W7ZTZFz7vV6t2zZwrktTpJSQSmVZTn/rBKNVgYCQRG+UgFAKGX5sQmhDIjctzzl36kRIjpqSWKMMeYodCuEosYY03W90K0QviBJkiRJ3H8FoTBE3ytDAJDL5fbs+WB4eFi8Dy0JiKiqaktLa2dnp6ZpIyMjp06dmpqaFHPLSkL+TcuqVasaG5tuTY+jlM7MzBw4cGB2dka8gS0JiOhw6B0d7R0dXYTgyMjw0aPH4vGYuESXBM7R6/UsX768qqpaTFMpAyL3LUMAYBjGu+++F4/HmptbxFq34pdOp2dnZ1KpVENDg6Zpk5OTx44di8VilZWVhW6a8OkymUx/f18kEmlsbAKAW5CMAsDs7OwHH3wgSczn8zEmruTFLpGIp1IpQrCtrT1fhGf//n2qqgWDwUI3TfgUADA1NZnL5aqrqyORqCRJ4oGz1IkrZhkCANu2JyYm2tpa7777blHjrMhRSicnJ/fv3xePxy3LJARM0yQEGxoaNm/eXOjWCZ8CAGZmZi5cuJDJZG7lh+ZyuWQysWbN2kWLuhVFFTfjIjc4eOnw4cPxeBwRETGdThNCli5d2tXVJYYnihxj7MiRIwcO7DdNq9BtEX49RO5btgCgsrKqq6vLMIxCt+ULA0oppZff+yNyzjkBRoFcs5cbAKWMEm6X6O5ulFKfzzcw0J9IJBAJIUgIqqoajUY6OzsL3bovDoDCx0SPILf5QqyAMkoJlmr0CKV0YmJc1/Vbn30qilJXV9fR0amqJZv7AlBK6ZW5PfkTAyilgLZ15RzJn0jXnDWlhzHa29t75UdKqdvtbmxs6Orqsu1Sre97ffTyWzfmu/S112MAShkQXrLhkyRpenr62LGjYhJa2RC5r1C80IjPTI6PTM4ncxZSSXUHqiqrAzh9aSIF3khlhd8lE2JnkrMTI+MJOdISDTh08TKqOABwIzUzNTY2OZvMWASY6gxW1VYHpETf+IxBfVXVUY8GwK1ccmLo0gS6ayojIZdaovdGQgp1TyzlezEA2nY2NjE6Nj6TzFg2MsUZiFRHPHJqemQyrVe3VfpVlSFicm54bCIGeqS6NqCB2MajGABBbhuxsdGx8el4zrSRyi5fRU1lhYJzI4NTUqC+ssKnK4SQXHx2Ynw0KQVra8NOWRIlwoQiIHJfoSgBop0eP/nWG6/t2XthMokcmBJoWrVj5641iWf/5z+cYxu++u2vbO1UEIzp4QM/+6sfHA197T/+5rbmZq9VqkMo5cVKDp3b99arr+8/N5kxOVAlVLVi52MPr2cHvv+T1ye1Tb/7e19dXqPIdnq67+2//c8/sVf90W8+cf+SGsMWt8XbBADaybFLh9949tUPz40mM5wQxVW17K4H72iUTj/31z+/0P77//9vbK6udlk2Dh578e9/uV9q+frv/9O7aplIfQsPKJqZmb7Dbzz78odnB2dNgkTSGro2Pbhzmyv1xl//t2c9O/7Vtx7e0lrBgc31HHv2h39zInjfH//JQ91+LxWpr1B4IvcVihAAMazMqTd/+MNf9ISWPvzkN1ZUqJaBsq67GIyPDw5cktqSGU6AEEAjE58Y7Os35gyDAxGDQoUHQHD+xEvP//iVvfbSe79699oKB3LgTI846fDMyPClUb0zbebDxM3MzEj/RasunrVICY9hCp8XsMx0774X/+ZvXjDvePTxx1Y2eGXIWVKwSkv0z40N9Pb7YqaJQAghmE1ODQ8OyJ546U7fKi8AkJ6eOvTLv/jO69baRx96ak23n1kGkd0hD8Snpob6Lvqmklkr36GtdGJycOCSMZPlJfteRyg3IvcVig8AsQw+ev5M3xiv2rpq4451nQw45wgkM5u+iIjkxjRJDCUUDyCIOH7xVO9E2rth/R1b1nTrMiLnNgKDCbzxjWc+kiJ+txkAiM9OXjx1Iul8dNOG9euWVzs4tzlSOXH6EiV4bZaUT4Dx8kkinm8LDQBy6djwhVO9ExXb16zftG11I9jc5gjMnDkzkO/hC5fofPBIPnooHm+F4iByX6EoIWIul7NRcbpdulNhJqeMAaM2ZMTVsxQYuZxJmOZ0uzV5oSSQDIRbInrCZbZtGYbBNLdH11RZkmzOCFBZEfVuSwBynssZCG6XW3c4ZGYCZQSoRMRyMKEUiNxXKFYAAASRc+S4MFgoFkmUDACA/MJvXFDoFgnFJ9/Hr54jKPp4Cbncxa/p4SJ6QokQT9iCIAiCIAjC7ULkvkKpyQ8tXPtiDYgYcCgZC3MBr8YvP3pUuAYJxQcJXnuOwMJ/ij5eEvILMq65Quf/W1yihSIi5jwIRQmAyBIjxLYsTrgkSRwJEgqUgqopYJqZnGUTJkkEuZnOZrmqqJRRkUQVCyYxQLRNzoFJkoTIkRC0uayqEtpGJmegJEnUJlYmnTGZJktiW97bDaWUMcZN00agTJKAIyJSSZZUReE8mc4gIUySMJHLZHMWc6iqQojo40UBAGTGEA3TQiSSJBEkSAAYY6qqEJJMpy1uU1mmlp1LZ3KEKKpGqJgLLBQHcbsRig8ioRIL1NRHPKemzp08tKcq6SScU9XpDYa80dbW0Hsf9h4+sKdaa9SM8eMfnhyJ+zqbax1uTYwsFAEkQMBXWR9xXbrQe+zQQV/aJSFSqgWqa4L++pYaT9+Js/vf3+PLBFlq/NT+U5O04Y66sN8rKiDdThB1lzdaU6+c7z9+9IhujekEbaoHIxVOf3Vdi29P79G39tfOz4fl3KU9R/pipHJJU5VPvCQoBogoaXqwuj7qPDJ84tihCMxqNrcVzRuqDDrCjc3Vrvd7D364N4BzPjJ75tChgZS7sqkxoihMjP4KRUHkvkIRQgSVeVfced/6nl8eeO27/+nDgEOyDL2yZfVjf/b4ok333H147Pl9T/+Pk7s9EknOx+1g285H7mj3+dUS3Ra3zCABUrlix9aNU6MvvvyD/7Tfq4NNnM66rd/4vXvXLN2xbfP40Etv/MN/PfiaQzIT8ThG1zy2bW1r1C2idxtB5N5I05qdjx47+avXfvhX73ucikRMrXXbfY985a72zbseOfE3b/38e72vuZ1gzs0llLb1j25b1+wQqW9RQKTOiuiae57ccP7Z93/0Pw+94HOAlQ02rtj5xD+7o2nl3U9uufj0/p999/grPo2nYomcr2vD/VuW+jQVxMQVoSiI3FcoTgCyv3XnH/z5kodHZpIZkxNgmjtYU+/zefzLH/2z2g3jY3OptIlMUlRPRUUkEg04ZCIGDosCIpECS7Z8I9qydWwmnjMJIVRxhuoaol7d4dnw9X/ZtHV0OpbM2RSo7AxWhCsrK9yKiN5tBTlRgm3LH/vz/7R2fDKWNTkCkR2hypo6n1ddvuXb/1frPVOT8ZzNOUq6yxuurooE3EykTsUBOaiumnUP/+v61eMT8xnTRkIlty9SX6d7dH3N/X9at3J8fDZlmhyprLtDVdFoKKQxEOETioPIfYWiBaqnqs4brbIty0ZCgDImUYIIcqCuIVhdY1oWR6CMSTIj+VJohW6ycAXV3BX17aHay9EDJkkUCRLiCte2hqqarIXwSYpMuQjfbQgJVR2B+vZATaNpc0RCKGOUMkCU3RUt3nBDk2lzRGCSxBglnItzpIgAlZ3+ujZ/dYNlc44EKKOSRLmNoHtrWn1VDZZlcwRgTJIkirYIn1A8RO4rFC9E20IAKskL9Ujymz0h4ZZFAJgkM0IIIdyyC9dI4WMgzz+xXI3ewp2P2xa5JnxoifDdthC5bRFgksSuHkFCCLctfu1xbouTpOgg5zYnwJjEroRpocqvbSFQJtH8cbRFHxeKi8h9y1Z+Z7RUKm2aRqHbInwSSmkmkzEM83JyCISAZVnZbC6dThe4ccKnoZSm0xnbtm/9hla2bafT6VQqZdu2WENU5LLZnH1NAo+IhmHkw8c5L2DDhE8lSVIulxNTzcuJyH3LECICgKIox48fVxTZFiMmxQ0A4vH4wMClqqoqAAAglNJEInHkyBHDyBW6dcKnAIB4PDE/P3+Lc1/GqGVZ+/fvHx4ekWVxJS9209Mzo6Oj3d3dhBAAoJTNzs6+++57/f394rmlyFHK+vv7EgnxlFI+xBWzPMmyvGrVqtOnT508ebLQbRE+E6fT2dTUpGkaIgaDwYaGxp6eC2fOnCl0u4RPh4htbW2VldFb9omcc6/Xt2jR4sHBSz09F27Z5wpfGCIGg4HGxkZKKSEkGo02NjZNTk6cPh0vdNOET8c5b2lp9fl8+fAJpU7kvmWIc65p2uOPP/Hwww8Xui3CZwUAsiwrikIIqaur++pXv2pZVqEbJXxWAKBpKqX01ozhcc4rKiqeeuop27bEoGGpoBRkWWGMAUBbW1tDQ71ti3HEksEYUxSFMVGjuByI3Lc8AYCqqgvbIAmlAejlXY8opaqqqqpa2Iyp6pQAAOcdSURBVAYJn8stHhDK93FCxElSMgDgysQYxpimOQrbHuFzuTZ8QqkTuW8ZAgDLskZHRxKJhOirJSG/K2goFPJ6PZSyWCw2MzNrGNlCt0v4TBAJY7Syssrj8dyaTwSAdDo9MjIsXg6UCkR0Op2hUEjXnYiYSCSmpydzOVNcoUsCIjocjpqaWlmWC90W4ddA5L5lCACy2exPf/qzgYH+QCAgXtAUOYCFNeDr12+4++67PR5PX1/fm2++MTEx4XCIkaFiB0AMw0wkEk899dS6detvzegvpXR8fOz73/++ZVniZlwSYrGY2+3evn3Hli1bOLfPnTv7wgsvpNNpp1MXV+giBwDz8/Mul+vb3/52U1Mzu1zSTShdIvctQ/lx34sXL4bD4W3b7hIjQ0WOUpicnDp+/Pj09LRpmoSQRCKRSqUqKyuXLl1W6NYJn4JSmJ2d/dWvnp6dnSWEAMAteNrMj/uOj4+vWbOmvr5B3IyLX09Pz8DAwMTEBCJyjvF4PJlMdnZ2trS0cLGjYXFjjB05cuT06VPJZDJfRkmMKJU6kfuWLcbYkiVL7rvvPsMo5fq+186xQuSI+SPk2m3APnqkpFBKBwcHU6nUlSFDAAgEgosWLdq5c2dh2/YlfWz08Oq9A4ACYMlGb2EIds+ePbd4vi8icblcq1evWb58uSzLJXwzBqBXTxJExJucEwD0+tOm5ESjUUR+pTtQSiORyPr161etWl3SZSg/Q/Q+2ulLjCzLkiQNDw+Lh8yyIXLfcsY5t227ZC+sAJTbqcT8fCJpWITKssPld+uKmZhNmqi5PW5dpQS4kcvE5xMm1UNep6yw0ru8IiLn/Ib7Qv5gycaOEKDAzWwqFo8lMzYBJjs8PrcuWYn5VA4Ul8fnVADAtsx0fCaRk5w+j8uh0NKL3s3Dd8vkT5JbVl/i1wwA0DZSsflYMmMhoarD5fK6JJ6Jzye54g55dEmmiCSXjsUTGaq4PH5XqU7w+IQ+XprdHIAQQDMem4kns4ZNJEXXPQFdtozEXNJWXD6PU5UpITyXSsXiaaI5gx69NCuE/b/s/Xd0HEl6IPrGF5GuvEOh4D1AEAQt6G032d5Pm7GaGZnRaHclrdac+3bf7rnvnPf0zJ57d99bq9VKI2lG0vienva+2U02vTcADUCC8B4obzMzvvdHgbbZZHdPD6uyKn7nSD1IVKGi+GVEfhkZhlIqVvYtMSL3FYoVZub6j585eaF/NqUzJgG1Bxu7unvaU0fePjiJHVvu37is3oGgR+Yu7nv741Hnhm/etyJU5TCtmAOUHkxPX7lw5vipgZmEySRGJKe7rnPdulDi+IdHhlndup0Pr6ySKNVT4cv7f/3haOXqB7au7wzZrJgDCF8MEJ6em718/NCJwfEYJ5QyWXHVLV29JChPHH//0Ez1/d/Zsczv10zE6cFjHx/ql6o373psZYWYG1YMgBi5+OSlo0dODE5GcigxBtRf076mcwmbP/T6/tmWLY9sWdXs15Dm5q+c+ejj05nWTc9vW+a2qZa8SxNKjRXvwYSSB0AMMz105Jf/8y//9td7Ls6nDVNPRRPzE+NzyeTw0XdfffOD0yMLOlAAyhNzlw6//ctffdwfjepUTJouAgCEJIb2vPX3/+uvf/bxmdmUbuiZVGJ6bDqWnhs+9s4bb+4+NBjjnABQno6MHHvlF68dOjue0C3ZJSR8QZQa8bHje374n/7rT/ecHoumdUPPzM7Oz83Nzk707n3t5786dCWRMPI1Ojxy/IO3X919eDiORCxdUwSAEj06d+6dv/k//uuP3z07GNYNw0jOh+cmpuejk5cOvviLN45fmE7pAABMj1zp3fP6K2+eGsnoJhARPaEYlGm/7w1jEMUtaPEBIGbWnD199NiVZNVT3/r2HzzRqSDnhMqymcjtz6bSGTlnXH0EhdzIZVKprGHZEaMlBwlOnD1w+mLEu+b7v/vHu5bZJESClGjq9GQmnc5A1rgaKuRGLp3KZHVDBK+sANDIzEjv/r3T0s7vffv3dqyusZmcE6bas/0HjuXSyVTu+q4d3MxlM2meEydJkQAwEguTpw/uHwls+jff/O5TPc3MRE6Yas9MHruUSSUzun5tAh8aejaTyeQMJCJ+QpEox9wXkRvZjM4plWRZZgwACEGRBhcVzjEZj2VNyVURqAj53KaJQIDSdCoCn1hjHACo6PEtGkAIkkw8nuHEHqio9Hs8ioRICBjEZAC3i55YM74c5XK5VDxOHb5Qhd/v9SgGJwRAJjR/QtxykoiNBYoHEMINPRmP5dDpDforKn0eQ0cgQCWcgsUafcPLRfSEYlN2uS9Qll2YPPP23+4Zs/taelav7GiodLtUmTHGGM1nwUJRyN+MABAkfHGKMIj7E6tARIR8HoxXJ3iL4Am3QIIkv4DD1TpuxemOZSrfJgMQIlpowWrKLvclBAg3UvNDvYcnYsd7T+6rCgRDDW1dXcu72psqA5pEgYjqKwiCIAiCUJLKL/dFU3b6O3d959tN49PjM6MjA4N9/RdPnTx2sLa6qjJU07hk2Yol7XUVTrFXkiDcA+JBqPBp4Jb/CoIgfCnKLvdFRKo6q7t31i3Xs9PDZ46+/1Fuz/5jA33jA31EcfhCLSsvb3vq6ztX1FfZTLHbTuEszgdGggQIBUCyOM6XMImBiRwRKVCkhADnBmGMETFkpYgs5iv5odhA8mu5EsYYMOCcI6cUKAEwuInIGLPmwp/CbwpIvmZTAA5AAAillDEJickNIIRSijnknBNKF3cWEHW8OOTnyeRDCABXW2hgjBGdcySEUcopQeRoErY4tUYQikHZ5b6EUK6nImODo6OzM1MTw5eHxsMGeKtqfVXVVVUVUirHwwsL6VSGgF00soVDKXUFKxxS7+TlywMXhmwOZugcGJNttkBtSN178cKZs2c7K1o1c6L35JmxeaheH1LtqghYsXAHgm55cHik/3x/k+ZTuIkmUk9A81b7PTh0pe/koQv2Do85e/7gmaEkDVYH3HZNDDYqL5rd4asI6CNDF/oHq12Gk2JOJza3qrn8wSo5Pnxm/9kOTqpZ6srJ3v453b2qqsIpkqciwRTVFQg4YHjk4qVL/X6qoZnjoDhkVauoCkl7LvWd6usLQb2cGuo92zerS7WhSsaYuKgKxaHscl+g1EiF+/f+w4vvDg6lZLvL6XI0dnW2LVm5fFVHW5WLG6loilb5NbGNS+EgIlNYZfeGzT1D+8f69rzGpvyakaOOippl961uWLd9/Ynwyd5DbymJFpcxceHMZdqw9sHNHR6fxkVXfeEhEgJVXZvXrp6dGTi5500+F7RxlJmrpmfrivqebZsvxt679PErr0aX+42ZS0cuGi3r71vbVetVOYqtLcoGcu4J1K3Y8sDSoQvH9+/WZ6pcCsuBp3Vp97K6jvX3bT/x+uX3339rfqSGxc4dOx+tWLJlY0+LG8R8jCKAyCW7v27l9p1rf3Xx3MEP6eywTzKzqrumY/mmUOuGBzYf3z16+P03M8MN6tzQuXNT7uXrdqxotSmKWE5JKA5ll/sSINzQM7Ek8dS3r+7ZsmFVV1NVwG1XZUmWJAqIPj9yEPNVCwoJSlRt3Pw7f1zZffJI7/Dk6BiRNK9av9Su2bwrHvuTf9V+4uThc6NT0zOKvWXLt55fvX55R8hpJyL1LRb2ll1P/V5d47Hj565Mj40BVX3VlR2qrAVXfOUbvq6lx06cvzIzOcuk2p3PP9bTs6Kt1quKG5eygiZzN6zd9Yf/Lnjs5Kn+6dmJCMqeao/qcLiC9fc993+pbT92/NSl2flJk9Vte2zXqnWrOxorZJH5FgVElL3+rif/5N82Hjl+/OLk1OgoUZx1LofbZg+FNnzn3wdWHjlx8tLkzFRc9S9/5vtr1/UsqavQmOj1FYpE2eW+yE3FFVr++D+vf0hiNqfLblMViVEgpqlzIskMgIIYeFgUJM3f0rmlun51JmcgAaCK5rBrqgy0or1re13j2kzW5JTKima32VVZPA0tKszuq+veFGhZlc0ZJhIqyZrdblMlCQKNK7YG23oyOR0JZarNbrepjFKR1ZQfZndWLevZ1bx0i26YiMAUTbPbNCaBu3b5Ol/Lsm05wyQgqZrNZtNkJup40UACVHMFO9beX7d0Y84wOaFMUWwOuyJL4Al1bnigoXtLzuDImKzaHCJ6QnEpu9yXEEKJSfTYSN/lqWhG5wQRkSAyj6d26caNLZU2pZT6fK08uwCASrLd7Xd4AIDkw7S4d9v14zccFo/TigpQSbG7NQfcHD0khCl2t1ZC0SuGKmbNaZ4AwBSbS7O7yeJZcq2Kg2xz+fPHrx+28ElyB8Vw/nwBCABEtjl9dhe5VscXH97A9eM3BNWy4bPyZfS2gAABy4bjS1F2uS8FMxkfPfPOT399cGg8bi7GHrmp1df3uJasaQw6CJhWvIx8KmvX22vXwrsft+oXvcOeR1b9SlfdLkqfdtyqX7Xg5b56+hS6HF9UGVTxOwGw9Nf6HNGz9PcsKflVlK7esJTnGPqyy32BAs+lZq5cmpxzNT+4Y2VzhYsjJ4jM5a5uq1Rl4CWS+JqmefDgQQBiGEahyyLcCaV0fn7+4sX+zs7O/BFEnJmZWViYn5mZLmzZhLsCoNFoZHR09N5Pj41EIm+//da5c32Li38JRWxkZHR6etrvD+R/NE1zcnLy7bffPn/+vJhYXeQYY+fOnQuHF6weKaBGJjJ2bs/H52cN4gl6nZpCkRBkqsPpD3lUKmuuQIXXYZNLvkEpp9yXG4Zh5nTCUfFXBjSHFuzctPW+rsYb5tgAlMKoQ0SUZXn58uVjY6NDQ0Pl/WTDAgBINpvz+/0NDQ2qqhJCfD5vdXXV3Nzc6OhooUsn3AUAZLPZtra2UCi0OIzjtw8R3W5PZ2dnOp0eGxsTiyMXv0wmVVUVqqurBQBKqc/nr62ty2TSIyPDooUucgDAOe/s7HQ6Xfesjv8WAFAzlxg7v/vll8/F0q5Kn0tTKSEAkupw+oNuTXNWrdr56LpOh1e6fXd+6Sij3BfScyMXz5+9PJdJR+YWsrHk+NF3XlXGz9Y4ERE587hrlqzraQzYZKuP90VEVVWfeurJWCwuHjJZhSRJgUCFzWYjhDQ2Nj722GOZTKbQhRI+E0QiSaymppZSem+ui5zzUKjy61//eiqVugcfJ/zmEImmqYFARX4jl9bWVo/Hk8vlRBNtCYhE07SqqmprD9zgVLIFG1Zt3hRIJJCBnootTI6PjU8vpHKcEMlbuTa06j6jHLaJKqfcV49OXzq1f/eFsG4QTj2BChLuP3vgUh8QgtxUa2pXutqX1/ntstWDjoiMscbGJmLh2QXl5qa2xuPxejxeq05gKj/5yyEi3rPqhoiapjU3t4iTxCoA4Fp7DAB+v9/v91u5E7G8lESkkHNZ87Zt+OofdcdmZ6bnZifHhi+e4ulkjnlklz9Q1dSxobPBa5dLvdOXlFXui7ZgS8/9z1auziLnmG+JbrhmUbs9UFdhY1ASMeccY7FIJpMudEGEz4pSZrfb7XY7pTSbzSaTyVwuJ9IaS0AkjDG3262q6r3pFgIAXddjsWgup4uTxCoYkxwOh91uR8RsNptIJAxDL3ShhM9KlhWn06koiqW7foHKjGWiA3vefH3v8SsJnapOf3P3zjXrN61d0RTyOzVVYlZ/9P1ZlFPuq3gr6m0OXzQajcZSOkcgkubyeD0umyJRIACUyRKj1o86pTSVSv7yl7/s77+gabZCF0e4O8MwVFVbt27t9u07XC7X5cuXP/xw9+joqCzLhS6acHemaQLAV77yldWr10iSdA/6hyilU1NTL7744uzszB3WCRGKh2EYLpd78+bNW7duRcRz5869++47kUhE1HFLyOVygUDFU0892draplh5fzogxMwmJs8f7j0/kqratmXn9h2r22qDPq/LockUyuZZcRnlvoQykhjt3/fOL9/ti3MGQDgnttadDzy8fefKkGrt9QdvZRh6X1+fw2HfsGGjaYqdYosaAITD4f7+i0NDVzZs2OhyuZLJZDQa9Xq9S5d2Fbp0wl0AQDQa3b37g/n5+XuZgyYSieHh4cbGxoaGesbKqSW3psnJyZGRkbGxUc45IkYi4XA4XF9f39DQWDLXnVJFKe3v7x8eHopGYyUQLCDAZEXRaGaqv++wojG2sUeyqQy5rEiM0bK4kS6jFhPACI9dOLPvw5P9rHXzunpHdvb04f69e33V9cuWVtZJWDIBz49MymazK1as2Llzp66Lx2pFjVI6OTmZTqd0XeecEwKIXNO0urq6++67r9ClE+6CUjozM33w4MF7uf5RfuI5pbSra+nq1WtUVS2BS3JpGxgYSKWSup4jhCAi59zhcKxatWrlylVWXzmr5DHGVFWdnJwogVqGiMzmad3x7e+EBs6cPnH24um9L148vTdYWdPUtnL9hpWdzZUOTaKW/553U0a5LyGZeHhmehYcrfc9+vzjy9yZKX/079+cnp2ZCadIrZvQ0ho3BwAOh8Pn8+VyuUKX5YsCSim9fheKyDnnhDJGCOf86nh8oIxSINzk1hyhTylNp9NOpzMWixFC8qchpVTTNK/XW9Ci/SYAKKX0ho5Q5CbnBBgFQvBa+AAoZZSgybk1LyyU0mw2I8v3YqjDLRijTqfT6/VaNvcFAsBuPEuQmxwJUEYBucEXV1sHoJTCDWeNBXk8bk3Trm1BAgCSJLlcLp/PZ9lHc7fUcUTMT6ahjN7YHgMwxgC5aXJrRi8fKUmSrD64CMDMJedG+s6PRjIZXXYGaurqTLwyPH5u8PyZM2f7+i9ceuyrz23qrvPIFg3VZ1ZWua/JDSOHDi3Q3Nzc0OTUnc1Bj2s6YZqcM0Y5JWjhlvV28KpCF+QLAII8PXv27Ines5dn4jonQB3BpmVrtyyDC/vOzELDyrUrWkIaIXpk6tKpgycmHCse7Wn3+zXrhfAOYbJm7AghhGBitr/39PEzA3OpjIFEcrrrV23dstQxdeDMQEJqWr9hVY2HUjMTmTl/4KPTvG5zz4rOKrdpve9b2CqGNyhUGb4gANATscnzhw+eGZyJpQ1CGHM1rli7osUXuXDkzGzFxifXNLvdCkecvnzg+JkRFli9YWub16JrsH9aBbdk7AgBimYmMt176Ejf8Gg4Y3JCmL+2Y+3a9X64fGx/n9J6X093c4UTAeKjA2dOHJm0L9myZVmlTWPW+7oWjdEnAFAzmxg/v/vlDwbCUc4oUEq4biACEJ6NTlzqOzc89dCaTgDFmrXssyur3JcQQqiZTE6fPfahNKmZ8d7x2VgiO3bhxMfvzXvsrkB9R0elWymD7n4LMLk+fvrNH//ozfPj6An5VUB01Zrexu6m2Td+9D9OsYf/pKajrdqGoM9PnHjlb/7Tvqo/XttQF6ywcQumTyUoNXZkz4u/+NX+ET1Y5VMYYW5PtrJrTcvc4Z/9wy/H7Y9WtC+v9kiUZ8Ij+378X//C2P5/D9Uvq/WYhohemQBqJKd7D/3yr/9y95zk9ridKjDw8EBTtTR/5Od/8T/PrPrft7XU+rwqN3H83Hv/+IP35e5/3ralzStWdSsCAHo8OrD3F3/9gz3TiuzxexWCGEqrTW0dmbndf/effuh5trquoa3SaVIavdL3xt/9lyOhr9etaamw21iJJ1VFDYFKNmegqjrldDNNZYxSQhAJMEmxqZpmq1ze5LNJZRCicst9mYSxxPDeV390XAbk6XgsqZupj18fO8ZsdQ09T/1hvd+lyqV+w1P8KGDaiJz++N3Dl2HH1/7sD7+6xssM3SSAuQwPIxJy06MnAHLLEaGQgBA+c2r33sOXUh3f+tN/+eSmgI2b3DBRsau9HMltwmf1Z4nC5wWUJmauHN/92tFw95/92z96dHOLGzCnc8mWvnT46CdqtDhJigqlPDo3deK9Xx3ILv3+n/7h81uXudDQTQSJpC4vttA3hY+IFroIIOdM8zStefp3WhbCkRxQJskUqOp0ed0+h0KQEGCSxJj1np5+bmWV+1LNV1W/pHuZT8fFQVdV1YQQQhC5qQT8HptcHjMcix0QYhg4NzUVTWmt9XW1DV4nR44IDJJTUUqujZm7/g7RrhYPIARJZGZyIUu8NU3NVT6XJiPnCAS5ychtLoIiemUpmUzMTU0S3yMt9VUVPrdqco4IErD8zewtrxYnSfEAQnK5zNz0dDxbVdNUU1PvcRomRwRKs5n8bcqt7xDhKwpAgQDoc+Pnjx7rn4lkOSVM8de3r167ac2SSo0xIKUxvOOuyij3RW4Pde18snHjA7d9KA5MUuwuu0JLfYi3ZSAhABQAMD/HhRCCAJ+8JgpFCgCAkqvz2nCx86fQpRKKCgAFCovTWDnm+3cJEDGsofghIRRo/qH5tRZa3KQUM6AkG5s4/frf/njP6EzSyOYMpLLMjpw8NzCc+6ff3Rjy28tlSEoZ5b6EUNnmUhxu76f93tKziAVBEARBEG4PAFLpxOC5EzPzrOuhHaTv9Fgs2NThy145OXbm5OW51T6P3VYmty5llfsSRI4WXUxGEARBEAThiwLIGUY0HGOsqrm7OTM3GOEV9c0N2dS5icvzkZTJOYBUHhOeyiv3zUPOjVwWZU2RGCUlsnhJCVoMzCf2a71+nFz/NSKieEpaRBBxcdjKJ44jya/rSmDxv6Q8GlvhE25ofOGW4+T6GFHID4QQTXWRuR6QW4O3GL6rNRxARK9YAACTJEIkxgCApGYunTk1p49kmOR2OihlZdMW00IX4F4DSo1UZPDgSy+/+PNX3jp46vL0QtpEoJSKwfhFAwkBCm6XS6bpSDiaShJJkigBbujIiC/gk9LRyamZcAYBcrGFmfGZCPf7/JJm4V3WSwgSQojd6VKJmYhEolnCGGMA3NBNk7t8Pgdk5qcmJ2OcAM+mZsfG5pNOj9tus4volRdFVh1Opx4PLyRyJlLGGHLT0Jlq83i8ZnZidDicyhKK2cmJydmFtN3l9bjFSOBigIQwJrmdDgYL4XAqnQZJkighpp4DSfH4fTKZmhidC8c4BT26MD06EaWKz++lUontIGU1yFVZCVRW2zzMyHAji4npgb7T56b1yo5NG9oCmlw+853Kr98XKNdTswMHP9h9edqsa+7q6mirq6+qDdXU1ddXBl12hQGW2h4XloOEKSzY3bOu88LR4+/++L/NHXAzbiqe6pbV25Y3btqx9sRLFz761V9HL9XbjJn+C70Rx5oHN3Z6fDYuGtbiAKGujas7pt479/pP/3rsqFNBomnBjvVbukLLt21YNvn6uTd+/JfTpwIsNTPY20cat29a3RLylU2zKxCCyN0VdcvWb2vuv/D2r344dKLSQSlXKztXrllS1bl++9qzb+//yU8yx/ZXSNmR48dGpNr1G9a1+0As7lsMECWHr3r5pq1LXhz+8Jd/P3O63oGm6axo7F6/NVSzeuuO7p+c3/2rH82ebfPyhUunz0y7uzasX1mjqRKi2L+5YBBR0dztax95xJOuqa7L9ug2e31MdoQau1Zt2VDv0sqo+6Hscl/kXLJ7mtY9vpOcvDgciUUGTr1/5KDp8jZ2dS1vba2tqqqsDlVX+pyqQsvnNCg2iERhaseWrzwbU/bs6z318TAHAp765VrbjhX1a3Z99QX9rX2HLhzfN8SBqJ6WnS889tSWRo+LcpE+FQEkhHg673vwGUN/86Mzpw6Mm0AkT6DL3d6zpLl9+0NfMcy3Pjx28dA+gxDq9K56/Iknd65t9MsieuWEc9Xf0LPrm99a+NWe3otHx88DMimw3BZasnpJ25Ynv5cy3zh8/sLhUU6o5Kxc+/SOR+/vqWVW3uqwhCBHze9f+ch3vxV9Zf+FS8cnBhEJq203q5fe19bc9cB3vpN69cPe/rMHxpFQ2Vd/3/P3P7q5w6EoolepsBCZ6qxsX62mOQJZuqpmyQokACDbjGQSFRthUCb3lmWX+xLkTHXVrnrkheU7c/G5oYHjJ/Z8+NHHp8/svXj6oOpyuqs7Nt733DcfWF1XbROtbAEhghJY+ug3Oh58wVjshqeUMklhFDyrnv5O9xPfzC8HCgBUkmTGoFwqrSWAUtW2/Rt/vPlq9AAolZjEGIWGTc9+b+1Tv8s5IoH88DPGGAVR3coLItGC1Wuf/+OVzxg8PxoUKGNMkhh1tWz79p9t+oaxeJJQmj8sxqUVDUSquBpXPvevlz1tmItrGFJKJVmhQOq7Hv0nHQ+aV1voq1W/bMaSFisgYGbjI2ffe+PoSDRuUrq4FjNHT33tql1f29TgtctlMnGm/HJfAsj1XDISCy9Mj/QeP3jw6KkrUznZXlHlq6hpcETjqaHx2UQiS8FWCs9mAD4xV8wiAAghTGKSrFw/ePV2RJJUWSafPG5JnxYjAGuvCA+fFj2QmHbj8dIM3738dOueJ/BpJwNjN5881j5JyKfs7mDx8AEwpkq3ixJj6k3JxdUprtZk5RjdBAC5no6NXxm+vBA2GRBCjGw6Ec0EYrnmXWZ+fW1r17PPquxyX6A0F50989b/fO3gxEQsl83oaGvqfmDl6lWdS+prfUoul8twV3WlzSyBzNc0TV3XdV0vdEGEO6GUGoZxdQOIRYhoGFzErvhRSnVdL0hmhoiGYei6Tim1empY8nTd4Pymq8q18JmmWHqzqOUjZf0qhsglm69j8+/8WWfKMPLfZuHc3rdfef1SNpM1TMt/wc+h/HJfoGYuE5kcifFgzepVq7saaoOVgYpAhd/jtmsMENDUeX5BnUKX9Tc2MzM9MDCQy4n8qahRSufn58LhMGPsal8vpFKpycnJgYFLhS6dcBf58KXTmXvfM2QYxtTU1KVLlxRFKYH2qrQNDQ1FIhGHw3H1AKbT6dHRUafTJQa6FzlJYmNjY+l02uoz9RABJNVRUa2YhABBQiCQaeyt8Z6eDQ9PLBgNfgBaHh2/ZZf7ItGJBPaKjmZS07xt+6ZlDSEbA+SIiGhyJPkdry0NERljoVBoYGDgZz/72S2dDUKxAYBsNpNKpZYuXcqYRAjabBql9MKF8/Pz84UunXAXAJDJZAhBm812z54XIqKqqjab7dix4xcuXKBUzMwtdolEnHNctqw7/wBdUdRcLrd///7e3r5S6GgpaZTC/PyCoiiqqlp68AMwI7Nw6ciLLx8cicZMSgkhkA6PjsybrgrOYXFR9rJQdrkvQZBl2etSo+cHzw2tXNpcW+2gyGFxmEtJzEJFREVRHnrowZGR0UKXRfisVFVtamq02+2IpLq6Ztu2bZOTU+K+xRIQcd26dS0tLYTAvcljEDEQCDz44EPz83NmKYzPKgfocrk7OjoYY5TSpqbmnTt3RaPRQpdK+Eza2ojf76upqWWMWfZeBQghBLlpGoZumJxxIDwRjkQi3FvfvLTFo8isbJYJLb/clzDCiR4fvnzuwsSESab7OiptyDkyj7u6o2d1nU+TqMWDn899t2zZunWrhe9QyxDnmH+mFgwGKysrLd3BUIZuGbH92/4sn8+3a9cD4hyxELyKENLQ0NDU1FToEgmfw43hsyYknKnuxpVP/E5z1uAIhBAe7tv3+qsfjCo2l12lFMpmLY4yzH2JaWIiy51OmzN68fgHAyeBEOSmWlffIzUsrfLa5BKIPiLG47FcLmflilpeGGOaZpNlmVKazWYzmYxhGOXzBMrqKGUOh0OWlXsTMgDQdT2RiIsnAxYiy4rNZpMkCREzmUwmk+FczHKzCpAkZrfbGZOs2yuBCFRy+KpsnsVmCmi1Odl7dH/v7GD/cHy912tXSyD/+SzKMPflVLFXtG/driSS+tUzGLnJvN76ao/KrHpS3wAAcrnc0aNHp6amFEW5+xuEQjNNU5Lk9vb29vZ2VVWnpiYvXLgQjUYZY4UumnB3nHNCcP36DQ0NjffmEwEgHA4fPLg/l9MpLbut6a1I13WPx9PVtayuro5zPjExfu7cuXQ6Leq4JRiG4XQ6165dW1ERtG7uSwDNbHT68tBMUteRACHAZ0Zm4ulkGqfmY4ZpArDySH7LLvdFziW7t3XDEzXLU+msYSzObpNk1Waz2zRVKoH9rPMdh2+88WYkEm5raxM9Q0UOAOLxxPz83MLCQm1traqqY2PjH3/8cTweD4VChS6dcBcAkEqlLl686PF46+rq781wwPziEm+99ZbP53e5XL/tjxN+cxMTk5ybmUy2pqbGNM3h4eH3339fluVAICCezhU5Sun4+Liu6/X19X5/wLJDfoFSMxu9cuKVv/ugPxw2GQABNHOZZDrY2FQXcEpltFZi2eW+hBAAgmZydvDkmQsT80kDAWVndW3H8uVdDTbLLr59C855PB5ftWr1c889J9aILXKU0omJiT17PjJNM3+jouu6w+Hs6lq2devWQpdOuAtK6ezszH//7/8jm83ey8/VdYMQ2Lp1W1dXl+g7LH69vb0nT55Ip9P5MaOmabpcrq1bt3Z3LxfdE0VOkqSPP/74o48+snikEBEke2XT+l33t6bTi8NtAJhqr6hv7lxaaVfKo8+XkDLMfYFSMzE/euiXf//yoXOjsRwnhCClir2pp+exb/zutvqAQ0brd/0SQiilFRUVTU1NuVyu0GX5YhafLJX8jSillFLq9fquPbwGAJvNVllZ2dh4j56hf/ny0Sv54BFCKdU01el03PuxB4qiVFVVNTQ0yLJsxX9pIEDK5CwhJBKJDA5evva4HADsdnt1dXVTU5M197Yoo+jJsjwwMKAoioVHOxBCCEHOZHuoff39DZlkLJ0zTCSEMMXucHu9Lo2RMtnPmJAyzH0JmNnkxMXDRy9NOZc89Nia1qALk5NnPz50rPfUx71j66rcTrlk/lEQkXNu2VtV5Jn56csXz1wcmYpnCdOc1a0rlnTU5PoPnZ+Huq4VnY0VKqF6dHa473jvjG3JfStafF7NksvUfXKJAIvHjhBipCNTQ+d7+4eno1kCiruyddnypd7swOkLM1JF+8qeFj+jkEtFxs7uOzXnbVvV3VHnVa1523kvV3j45EfnWTEDATRyiemRi319gzORtImyK9jQuaLdz+b6T1yIBFbu6m50uRSOODt06uzFcebrWrWu2WPR7OMOddya1RzQzGXnhs+d6708GU7pIDtCtR2r22tJov9wb6Smq2dpS5VLRZqdHxw403clW921bVm9Q1EsmF9ZNkafABTMbHxo/9sfnrw0ldAJAEGk7uolPdsf3bnUL6llsrNF+eW+AKDruejcTBpcy9fc99DjPfVeMzXoji6cHz44Mb1gGgaBUljowdqAgInG/Pn3f/nWnoFJ5vYFHArBmM683mpP+MDbL/fTTY6aluZKG4IRnb247/Wfnar46ur62oBfExOni4I+ffrgu++9c3yaewKVTgVpMgnu2kZ98vBbr5xVO59uXN3kkyRmJsODB1/6WW/7E4H6pga/KqJXNgBIem7g7Hu/+PWRsOEM+FyqJM0lmavKnTH7Pnj5l5eXODY0VXs8Kjf57NDRd187JLerLWubvVS0zwUHQI1UbOT46z9/7cgMqh6v384IyaFa7XaYI3t//pMrG79ZV19f49aQ6guDZz749buRderajmqnKnYgLByg1EzHR3s/fPP9DycMf011hUvjkcnhC+eHY+mqzvptNapdJtbsgPi8yi33JYQwxux2O5izEwOnjx/OjLlJevz80GiGkkqHTUyZLg7Ac/rCmY9e+tW70x3bvvHMY6sDspFBUBQ7hfGpoctXpPZ4hhMgBIieiU0ODQxkotkcBwJiWbCCAyA4e/bdt19774Rt59effnhj0GaaaCDzq/zS1PCVKzZPLIeE5Gcdx2cu9192zid0tGiHnvCFAIvPDx565x9f/Nj7wrd37lzX7JExnaXeSiV8OTwx2D/gjul6fgIGZBPTo0OXZVdcJ4SIOl4EgKfnxo+/+qOfHnY+/jtffXBDlxv0NJfsPtUcjU0MDFxpCaeMfB3nudjC2JXBuaa4yVFEr7AgnU4MnT89nQn0PP78gxvag4o5ee7D117dPXX2xODCukqfXS6TZrjccl9ELiuO6pbuluDg2SOvRi/7nQ5IhmfmI1Lzsp6lNYqsWPHZYYkBIIbB50eGZ1Nq06qejdvXtBHOkQCj6dl4f/4VN7/B6uOwSgkQRJwbG55JSjVrN27fvKpdkRAJAQNwVCHXBnJff4OIXvkBgEQsMjE8IgW3bdm0rmdFlWpyJEDlxNkrFAi5ed6xqOLFBABymeTc6PBMrn79hvUbNq+q5wYSAkyOD04yIlroIgXENHk2lWFQWVVb39jSVEFNLV5V4ZXGY6l0FhGhVOb730255b4EOVccgSXbn31oXtrbN76QjscJkf1tPSt3PPpgd8gu3aM9SYW7QGKaJhImKbKkMGoAEAKMUlIuVdPiuGlwJEySZcYYY4iEAEdTBE+4BjnnpgGUKbIkMcYIIAGgIkmyBETT5IRIkirJCmM6IiHARPCKGhJFlv2VFUAmz584FqLRCrsx2Xd2cCyreWoq3IxZfVPbz67scl9CkICsBZdsfO57yx7NmYubmzBJtTvtJhCG4slrkblhI0lxW2I51t8HVPitwxvOEtH8Ws2NVVxU86KGyO02d+vKLUvOvDtw8p2f9+2mgKaeMZ0tPVvXt3k1iSKWxJy+uyu/3BeA68nwUO+x0/3j4Yy52NTm93VbuWN7e5VdoeJCLQiCIAhCCUFE2RFa8sDvfr/5yuWJcDLHAajirKhqam1v9jpkKJ/cp9xyX6DUTESGTrz+Dy8dHp1KXR2WhNxU6xvXB1ZubAk5AczyOQEsAODqYLGbhowtHhXjyIrb9egRuLFXCK4pVMmEonHDufDJQb7iJClyN8TopkCJFroIIRIqqb6GtpWh2k49/9ybSqqiKioDLKeO+3LLfQkBNI3UwsRkNBnsfuKhde2VbuRICDKHs6KpxiZTS64PW3IAQFM1BjybzubSnDOOiEAQKDjcDpaOx+OJlG56KKZTyXgqTlxtDiZJ5VR3i5usqjKSbCaTMU3OKSISIAQddqdsw1QyFgubvJJncrn5aNQ07C6HKmuFLrNwbzHGFEXDTCad03XOJc45IZQrqupwOLkZjc1lsjXcTsxILJ5IGlqV0+EgRNTxogCUqaoKkMukctmsyZFzggCUypLD4aTxWCKRTuvcSXPpZDyezlCH00kpE9ErKKBGOjx05t0PTk0kU5wCICIBRNMRCnZt/cq6WrdNLpMMqNxyX0RkkuRw+12aw1fXvXnbjqV1ssHzY0m5aZiWXCK+1CASqlBf25Im76n+fe++7Mx2+WQjDYrb37Z2ac3y5dXvv338tV/9JDve7OCTpw59dDkeWL202eG18fJYmrC4IQECwdalDcHBj4++9aufxVb6NZNTVILda1url3Y2Hvn41Pu//Bt6ZanXnOnft/dCNri6szHkU0X0yggiunzBpqVL5TMn33j55bnLtS5G0txR39pe769r765958AHP/qZsa6rmiX6971/JKa0bOtsdFEQo/4LDxEluzvY1tXueLv3vddezgy3uqieos6Kxvblrrqu7tDbZ/f86mcw1VUvx0aOvrt/Rg3e396kKrIFN7YoIQDAjfT8yKn9B8/PLRgSEG7k9FzWpLWrVgdXP24ilM0SdOWW+xKCkmrz17fVKL3j5w4d2M/n6p3IERE0m7eqocHvUhiUR+yLGCKVmXfZtue+lvqobzB8qbfPrqKp+WqlBllqWffI116Q9p0fnr7Ym5RpOgEN219Y9dCOJR63wonYG6HwEAmp6HrwkWcZHBiMXzp/zqlwsNtDarMpta596umYSzs+MTtwjttJMsxqtjz/8IObl9c4oUw6HARCCCFo2gPN6x/69rcS+0ZjE5f6IoosoVbjCDZ1NS+97+k/mFNOzIVHLvQtkPS8FFzzxK6dD65vEM8GigMi2HzVqx/77neNfSOJ2Ytns3YJDU8Igi2O+tatX/vdqXePj4UnLpyNQTphVHY9+sDGB1Y32CQm7lwKCjmTHTWdO54kS1NpDoRgevr8qaMnBpHbXU7KymZXt3LMfYmJPGfqaKSnB/e+lrjo99oBOTfV6uplO7/21R6HKjFRPQsOAai7cctXv905PT41t5A2CFVs3mB9rcNpc3c98p3GtTPjU3PhtM5UpydYXxNy2WVGxUDtokE9HT2P1LSsmZiejSQNQiWbO1RX7Xc45NXbn23t3jI5PRdNGZTZvKGaqqDXoUkgen3LCiKRPI1LHviDf7ZyYnwqmsxxItncFaGaKodD7ex59l+0b50cn4kldZPZAxWVVVV+pyqLXt8igUhUW+XyB3+/acXE6GwkkTZAtnn8lQ1VNrvWuOmFf7ps2+ToTCSZNRTNUxGqrwraFYmW0VSqooSITHXVLXvguS4kSAgAyU6eaAwoH416QoqEhJTJIg+k/HJfAGqkkzMDZ/rjKeoKSAxy6TQS5CZmc/ri85iy6fUvdlSyO0PNHZVNt/5CcriqmpeErh4HAELEYJUiA5LNXdnoCjbcepzZvKEmT2Xj4o8ARESvXFGquPy1Hb6aW38hqR5/vdtXl/9JnCRFiTLJ4att99bcGhdJcvrr2n21i8dFA11UgDIGAADITZ25q5qXb047MjomkXBeNqsMllvuiwSBUiYpmuaoW/mN7z6+oTXEOBJEIkmKzeFQSmmuG6WUMcYYK3RBhDuhlFJKb5kNDQD58BWqVMJnlA9ToSazX6vjIrUocqKOWxdjjFJa6FL8ZrhpIiFMkgC5nk6nEslEPDo/PXr59MmDR87M+z3bm+5fixIQszwaknLLfQmiJGv+mkY/uzgzPDI91VjhcKOJiESRbVRzKHKp3PYgYjwen52dzeVyhS6LcCeU0nA4nE6n7Xb7tYO5XDYajc7OzhawYMJnQSmdm5vPZrP3/qNN04xEIrOzc7Isidy3yEUi0RtPEkTMZrPhcHh2dtY0xTSFoibLcjQatXaYUuH5uYU57vA7SGb6yrm+46dP9g/PJtN6zjCYWhtqqXcrUhnNdSq73JcAQ5NkM4lceubi2z/6wSGnTUbk3FBr61c++t1vr2/12iTrd/3mexTeeuvNgYF+zstnDI9FQTqdSiQS69atv9YzNDw8fOLEiUOHDha2ZMJnkUqlhoaG7vGH5m+Z/v7vfxQIBETfYfFLJpOIpLa2jhACQDjnFy9evHLlSlVVlbhvKXIAdHJyklJi1YspAE2M9O5+5aeHZiRJlXLTswuJJHfXLlm1YfWK5W31VRV+T8DnUKTyWWun/HJf5KC4gl0PPKpGY2meX9IMELns9zd5HRIrgcG+nHNVVZ955pmpqUlZlgtdHOHuELkkKY2NjTabjRDS1tb25JNPzcxMi/BZAud88+bNS5cupZTemzzGNM3q6upvfvObkUjkkw/ThSIEQBRFbW1ty49zWLas+4UXXkgmk6KOW8KKFd0ulzsUCkF+UVxrQUKcwdqW1s6B2RN9F+ZiibTBmMMNdre/qrapuaUqoCnWz3w+l7LLfZGbzOauX/Wgs3l+YS6ezJrM4fW6XIqEVPMGVFYCGxojoqIoW7Zs1nW90GURPisAKkmSoiiEkKqqkM/ny+VyZdYcWRgAzd+33BuI6PV6d+7cpes6ojX7osoPIpFlOT++v7a25uGHHzYMo9CFEj4rSqmqatYc+IvcUdW0+sHnAu0rB4enZycnh4b6L08tDBzZGxu7fKTCX9/atnLT1jafXS2XmQNll/sSQgF1PTZ46sCpi4OzSQMrl2/urPaYU6Pz/pX3ex2qxMD6CQcAuN0e0RtkLZzz/JAySZIURRXhsxbTNO/lI1HGmMvlEieJteRPEkSklHm9vkIXR/gcENE0TaumhiCrnprmFbXNyzfqqbnZ0eH+gcvDY+MzU+ODpz88eHqgRW9c3eB2akzMdStNQFFPTg98/Mqrrw2mNCkbifhppRTX5g58eC5AW1fV+ZyqYvFlYgFA1/WzZ89OT08TgmWzaImFIaLNptXW1tbW1imKMjs7Nzw8HA6HrdrOlhlE1DSto6OjsrLy3iSjABCLxS5evBCNxsRJYhUOh6OhoaGmpoZzPjU1OTQ0lEgkC10o4bNAROLxeDo6Ojwe63YqYX6Mp2QPVi8JVnX0mNlodGro/KlTp6eRVdsVVkYLMJdb7gtA9Uxy6tKZoZTSfN/jTVMHD8+adpvT4ZJTuenZmLVnci4CgHQ6/ZOf/PjSpUvBYLB8zmbryuWypmlu3br1ueeeVxTl8uXLL730q9HRUbfbU+iiCXeXy+Xi8dj3v//9nTt3UnovllyglE5OTvzwhz9MJBKapgFY8TlseUkmEzab7aGHHnrqqadN0+zt7X3xxV+m0xm73VHoogl3AUAikajL5fyjP/ony5cvVxSlBG44KaXU5qto9m5tWrUFMb8Ms/Xn+X9W5Zb7EkKQIDc5ENXpsKuKBFxPp1OQylGQpYKt0vmlAgDOeSwW37p121NPPWX9Ub+LUbmhufnkjEQLz1GklE5PT+/fvz+dThtGPlhYUVHR2dm5efOWAhfuN/fJ6N3mNdaNXn6Ns7m//du/0XX9nj1jAQDDMBVFfeqpXZ2dnbIsW/xifOvuFZacUXRHly5dOnHieDwev/a9qqtrenp6OjuXWnX1gGs+ET0L1+fbkSTpyJEj+/fvy+VyJXNa3ng9pRTKbfORcst9kaAsqf5gSGPDF0+ejMdn4gmprzerxCMO+4oan1Q6awUhYjAYbG9vt/L6vvm1gK7WSQAKQJDzxXvUay1u/kkOpda8caGUOhyOgYH+/CpIebIs+/3+tra2ghbtN4d4NXz5+Cz+nA9l/hVX42nRG09Kqcvl1DTbvb92SBKrrAy2tLSoqmrdKxcQNPm1Kg4A5FqNBiBXb5wQ0cInCSHENI3Bwct4vTEDRVFqa2vb29ut/bgROb+5gV6s8teihYj5xOqGWm8tkiRNTEzYbDZrFv8TbluLPksnRQkpt9yXcE41V7Bz/Ya6s+/0HjqbyeUQ4rPjkrthzfbtK+s0RS6hBe7oVYUuyBcDBDnmUvFEMpU1CZVlzeFzqsxIxBI6Kk6Xw6ZQAtzIZhPRpM7sfrdNkqj1opeP0S17g+VbIMvGLt9vp2eTiUQ8leUEqKy5PS5N4eloIm2C5nS5NIkAcl1PR2MponhcTpvKLNjuXt2WrzCfnl/J+56trfalAgBEzo1MPBLP5AxOiKI5nS4HNdOJWIorTr/LxiggIblMIhFPE8Xh8tituiLYJ/cGQ8R8+CwYO0IIEEA0eSYRSaSzOidUtttdXods6qloLENtHpddkykCmJl0Ih7Tqeb0ulRLZr83XEktWPpbIZqf/qDB0veXn0fZ5b4EkSqemjVPftu+dGQmnuWEECRMdVU1trSHPEoJLHFWItBMjh3++a9fP3xiUpc1hXHDUdW69qFv3o8f/O3rl2H1Uy88sbHDiZCbHT386t//qs/3xL95fmtjg8sonXsXK+OJgePvvPnqWyfGTEXVKAe7s37bc9/Y7jr/ozf2zqnrvvGNp7qrZWom56/s/uH/et1c/p3nH9+5tEovk0nGAiEARnT40sFf/+i13okMUSRJAtPWtu3B7StCk7t/9sZQ6zf/96+srwrZDY7Dp1596Y2TrOnpb/3+1hpKRCNdeED01Oz5Az/5hzfOTodRtclg6oHGVTsffqaBHPzZ373r2PJPn39ofXMFp3Ru4OTrL/3sonfHd37voQ63W0LRRBcKMD01e+nIS68cHI7GOZB8bzwhJP9AFWz22g2PPb2pu96jlvrI3zLLffO3NFyS7BXNy701OYNzQvR0KpNJmQpNJ7JOtwZgwa7DEgNAsmby/MFXX/+gV6las3l9i4tyXfaE6txILl88dvCk5N34iAEABDAVmzh/bN/+6tXJRw2AUhtpZkUABOfOffjB6+8fn6tZ/WBPq0viKMu+2oBNXhg9ffLohKPykWcQCQAa6ejImQN7DPnBh3aWRXeDkAeUpmaHj+3+xct7Fpbt2NzVFrQBmlKwqcaemR/pPbzndO7+9CM8X6PjM5dOHjukZDd+BUnpjSa1IKAkvTB76t0f/+pguH3L6jWdDTZu6vZAQ8jFkyOXT+zb4w298Mh9AIQAZMLTF48fOFzV9LRhoAheAQEQ5EY6Pj89MzkfziTmJudihs1TGapwUZ6Nz04lsKli9c7VS8Fb8mEqp9wXMguX+86dPNsf1k09m9VNzjlHQoxMOpWMmr7Qkm3PPLOy0aWJboUCAyBGzpy7cPrclFn7zSe+/U+fXSpzJEgoTU2Gx4AxSbo+uBeAMkmSmCUfppUiIIg4c/H0xcm0d+tXfuePHuq2y4gcCUHTOE4YuylYAJRJMorwlRugsYXpgTPHFzzPPvX1797XU2vPD/xmsVMfSIxJ7MaTJF/FmUVH9JceACMVmb5w6vRM9cP//OvffW5DKzOQIAGWnTg1CVSSGYNPttAFLbNAEDlT3Y0rHvtmKJbILfS988qHZ1P1PQ8+et8SNT134cBL759Tro6xL3VllPsCZBcGj+79xY/fHkdCqOTwBysr/C5VBuTcNGTJlsyZpd7PbxmImE5nOJc0uyoppmlwFP09VpLNZnQAxaYqwBcXhBfJrXATwzBy2Syz2zQZgJumyZEAFY/dih8Qwk0znckQdNjskqyYZs7MzzcW0StmiEzSAg3LKxp5BqeMvr1HLstVTSs2bNvgiI+y8ff3DBhWX3Pksyqj3JcQ2e6vbexc2grTswsJ0+4NNizpbKmtDlYE/B6Hw+lwB0OaAqLuCsJvDEpiVoggCHeSr+Tiomk1AICKIjOG8fDs2JXLlY7M6Mhk0tTtikqhZFa7uoMyyn2R26qW7Xy8srWz79jhwyfPj8zHBo/vHxusaVm2ZuOWVc31HSEnk2gZbWwiCIIgCEKZ4UCJO1QT8rtOnzv467+bPqaR+dHzs9S3pbbSoZXC1h13U0a5LyHAVKe3tnNlsKFt7UOx+ZGh0wd3v3+499DrF8Yj47kXlj25RDxUFwRBKAaiKRaE3xaQQGlavmXjeDS558L0yCVCkFW0rrl/y7Jan73U9pW5nbLKfQkSQiiTNZdXczhdimzExi9dGhmfnI5EIqkcR8KoaHGLCSLni7Uwf1uCCMAkiXA0ri5RyJEbpomSJIlFHorLDdG7egAJZYwSXBzATQhBNA2DU3rr2qdCmcDru58s/giUAqXIdSOLyAkBohu6bnBQFs8RUceLBt6w9VD+AAECjCLqeo5zkwAQk5s5w0QExsQ4qIJDsrjZCEGiVC5/8JmGDfcncxwJASqpTo/f59RovtqVtjLLfdE008nY9OD500dP9g2NzS7Mz8d51fLta7be110jMqdigYRIMq1ubAy6zgyf6+s71WkPKEbW4EAUt7u+o8V78ODJQwcPNfu6PfqVw/v39y+o7fc32dyO0r9btQAkQEiwvqnKeaV34NSJ8422oA1NntPREwpUNrXVugeOnt73waFq2qzGL328++hUqnZrY9DnL4POBuE6dHl8tY2NuPv88d4LlU7DK2E6a9pcDqevvrnV/vHAvrePNJrYxGJnPjp6dsqsuq+1PlDqV2RrQCSKzVHT0BCwHb94+lxvi496qJ7VkWlOjz3U2lalHTi758jhKgeGjKlDR/b2RuyhHa1VsiqhuMgWEFAzG5saOHbi8lw6g3RxY5z8bhaInBMmu2u7V3fUBzxyibfGZZT7AuQiQ6dP79938PzI6MjIVELzNHZ0btrU1FDX2NhUWymn0jlVk1l5bGpS3DiCwjzL73vy0YX3z5999X+N7FUloK6azvU7n93SsPXJ58b5R/3HXvzLi+9JkIgmcm07vvH4riU+n1RCm/JZGCKBihUPPfBwLnPw9Ls/GD6sysA8/o4Njzy2vmP5I48+rmf29e/7yX/vs0t6PBHXVj/1zYc3Lwk5zDKZYSwQQpBzR0XTuoe+8dj83r7dPx0+ZFeopPjb19+/c2tn9/3P/s7sayePvPsPF/c7iBEJpwLrH3zgoc0tDgCxBGURQA72iqo1T3zrK6mPB9998X8efk8BykKNq+574MmOUM/jv/PVzJ4L+9/4wZl9Np6JJtIN9z39wP0rgpoCYmOLAgIAnktO9u99490L8wsmo4sH889VkXOiOmt75PpgZdCnmKW9z1AZ5b4EcuGhU4fffOnNYSSEgD2opBKx+YmR1OzoheOc+QMtax96YGmNUwFROwsOKaVVXQ+9YKvtO31xbDaZQyY7qxpr/TbV6V37xDf9Lb2nL47PpnKS6g02LutevbTZp8og1qgrFmr1qi1PegKNZy4Mz8V1ArLL31Tts6mqb/nGJ7yBppN9g5PhNGFKILSka/Xy9hqPJqJXVpAze3BJz1N/YGs4fe7KbDRrEskeaKypcDk8vpXbvuWrWHbm/PBsLMclR6i2fdmKrpZqj8h8iwRyZrc3bXr2dz1NZ/oGJ+MZEyU1VFcfdCtOV/26p77rbz7VOzC+kMiB4q5q6FzR3VkfUqy45XxJQaSyPdS2YZfRnExxCoRgfPT8qWNnZtTQyu0bG+wuh7u6weOUS3+ls3LKfRE0X0Nrz33bGw2eSyczusmTkYlkhOfSyWSch2rNxs07OkTdLBZAJFd9x6aGjk3Xjy0+Ffc0LtncuGTzja9GRHFZLCaoOENL1j3Uue6GQ4iEcCL5m1bsaFqxg9z8GxG9coOcKoq/bfWuttU3HCRIkBBbsKPnwY6eG18tTpCigoRKmrup5/6mnvuvH8wHSXLUdG+q6b6x5SZisEPhIXKmOuu6dj679OrTbYyceZ/Mje3TA127nn66vcYlo8mxDGpbGeW+iFqwc9tDjet3moaejMxH09n8M1YzFZufm43L9qqmgCaV0oAHuKrQBfmiPlF0uLoDuWW/0m18WpisHTvyyTBdfV59m69q4aH2hQ1TydVxIIDkdnXc6qMd7lDHrRu+T1bxxSUCPi2s1mTpGN0IKM8mZkfOnhsJZ7KEAiHA5wanU9loZmJoIq43mUQuhe/5GZRR7ksIlVSbU7ERRPT6/TV49dYGkXOOQKikyIyWyoAHREwmk+FwOJfLFboswp1QSqPRaDqd5osPmoAQout6PJ4Ih8OFLZtwV5TSSCSq68a9/2jTNOPxeDgc1jSNl/5TSmuLxWKZTEZV1fyPiJjL5aLRWDgcNk2zsGUT7kyW5Xg8bhiGxbtDAcDMJScvfPTa7kvhqJnfZJob2axc39zSEHCwMtrfoKxyXyCEACzexN2yc0m+U8HiZ/Z1AKCq6uXLl3fv3m0YBbgqC58dAI3HoxMTExUVAUoBgDAmpdPpixcv2u32QpdOuAsAGotFM5mMJN3T5pQxyjn29fXF4wlZlkum7SpVMzMzc3NzFRUVhBAAoJTG4/FTp05FIhFx31LkGGOXLg0YhmHx3l9EpIq9un3747blmSxSAEIIECrbvKHalrYKm2ztZyufR1nlvjf4xIWilCKOiJIkdXcvu3Llypkzp8VFseiBaRqMsVCoWpYVQojP56utrR0autLX11vosgl3BaZp1NXV+nw+RE7IvdgQlHPudLpaW1vn5+cuXDhv8UtyWTAMw+Vy1dbWUkoRsaKiorq6em5uLh6PW3jET7mAbDZTV1fncNitXddQku3Blp6tTZwgIiJybqKeiqeyyUwaUAVCLTw25fMo19y3pCGipmmPPfZ4PB4Tea9VSJLkcrkcDgci1tTUPPLIo4lEQty3WIUkSZWVlZSyexOyfPL0zDPPpFIp0WtoFYqi+Hw+xhghpKWl9fnnX8hkMoUulPBZaZpWUVEhSZIlm+V8pkuAUibLYJqGno6Fp64M9J09e/bCsBH0rnjsjx9xqQqz4pf7AkTuW4IQkVJaX19v7TvUMoOYH3jOCSE2m62hoUGEz0IQCefmPbso5u9vGxsbxUliIVd72jghxOVyeTweET4LycfOkokvIZCcn54LzzNvtYelRs6d6eu7NDw1OzMzOTm5kGTOlqpGr42W0762IvctTaZpDg4OiplSFqIoSihUGQgEGJPC4fD09HQymbRoO1uGFEVubGz0eLz3JmQAkEgkBgcHxUxWqwAgNps9FAr5fD5CSDQanZgYT6fToopbhcvlqKtrsNlsFrxjAYiPXdz//msX0l6HZM4NDY5MRVioua19xX0bq0I11XWNDc3V9nLadk/kviWIUppKpXbv3j01NeH1+sroVs6qIJfLmaa5atWqzZu3OBzS2NjYgQMHIpGw3W4rdNmEu4JcLpdIJJ5++umVK1fdm4+klM7Nzb3zztuUUkVRRB0vfqlU2mazrVu3ft26dZzzkZHhDz7Ynctl7Xa7CF/Rg3g8brNpX/nKc1Z9oKrZHS5ViV08f3ZseiGe5bK9tsEerGvtXr1iSXOlX7NTYli1U/uLELlvCQIAwzBOnDhhs2lLly4zTbHOQ1EDgPn5+QsXLjqdrp6etQ6HY2FhYXR0VFHkpqamQpdOuAsAiEQiBw4cXLNmzfLlKxi7F0N+ASAej58/f37lypXBYKUVr8XlZnh4eGhoKBis7OnpMU1zamrq0qWBxsbGUChURhmHNVHK5ufn+/v777vv/tra2ntTx79UyH2tKx/4ZnVbz5mTJ3r7hydmwwtzE+c+fn16sH9g+bKm9ubm5vbOGqfKymXrPZH7lqZ8zVy1atUzzzyTy+mFLs4XBABAgebXFUdEgpxzJJRSIMg554v7XABlFJCbHBHRelkAY3R0dJRzVBTlWpPq8/mWLFmyc+euwpbtN5FfyGlxVfjFgY43RA8JIl6PHufIEYklwzc9PXX69GlK6b38XER0OBxr165bsWKFJEkWuxYTQggSACDXzpKr03EQCQF6c42m7Fqlt2of6dmzZw4c2H/tR0ppKBTavn376tVrTNOSsxUBCMkHjyy20IgcOSH0hugRAkDhpiPWq+OyLLnd7vn5hXtcx79UTLL5qzrWBZpXbs0lo5PD/b0nT/YOjM2Mn/3o3P7DDXU7vvvvn+6wuVWzVLY4uDOR+5YyRVEdDocsW25EYD4pImhk0slkJJnJmZwAMMXucrlsmIrGckR1upwOhRLCjVw6EY1mJZffaZNlCzZNlFKbzaYoyo2P0iilqqo6HJZc3xcJAcKNXDoVjyUzOYMToJJsc7pdKqZisRyVHS6PTQIAbuqZRDiSle1up8Nhxegthk+S7sXSZrfIL+OdP3ms1hFFEAkQzo1sMh5NpnM6RwJMtjndDpXqyVhSl90VTo1JlBCSS8fi8QxILpfHIeWTLsvRNE2W5RuPMMY0TXM4HNbb2wIRAQhyM5uMxxKprMERgaqaw+20g5mKRHXN6XbYVYkSwvV0Mh5Lc9Xpc2rMksmjLMuqqlo58SWEEAJAZUVTVM3udLr8waaungeSyYWpod5jR4dSKTujlqxYX5DIfUtZvqvNmksgIaKRGDm+75133zx4YTyeJbIWWLL5ySee2Zh95y9eusTWPv31pzZ3uAlkpob2//rvftkbeObfP7+1qcltWPGuNT8B/JMHrRk7QgjhPDLRt++919/e3zcVySLVKhs2Pv6159oz7/3ktQtq28Pf+v3tDYokZcLjx176//79+dYHv/Xco+vqnNbsALtd9O7lR1tz+jkAyUUWLh15+9W3954Zm8+YXPE2rn/4uQc77Zfe+fGrg63f/n88t7GqymFy88rxl3/x+nGp+dlv/8G2WkYsWSvuUMetWM2BcD05N3z4zZff3XPqSjilo+zsWHn/Cw9vV2bf+p+/HF73ld996v7lISfS1Njxd3/+0keRVc/9b89uCDhsHC33bS1Zv27r2klIZdUmq3anx+MPVDV1ZgxDsrttErfi5fMLEbmvUIQAIGekL+z+h7/9xQkeXLfrhaV+hRvMGQxphE9eOX+2V6renjSBEATMJGevnDt5umpTJmOW031rEQNCYr1vvfoPr++eDi7f+exjfg2JIrmDPiXXN3S+96xN6knnn4ainp4fPnvyDF32eIZTIFbr/xK+MKDZhcHDb/71//jFRMu6LY/vrHFJzGTupgrITE1eOnPiLDyazfL8zlOJ8Eh/31kJdojVcIsDUJqZWTj50n/5769O1qzb8MgjrW7GDc1d65aNuZlLp09crNwcz3IghICZnJvsP3t2LnCfbrn+7RKGiPkndLLq9NpcQPJjUgpdrHtG5L5C8QEgZs6cOX/iRN+M/alHH3z+6VV2ZuqmSYxM0hw2TZPT/EgyQgghSJBzY7HagpgzXWgAiHzqwpFT58f5iicffOrxtV6Vm9wwMpI6c56bJr+pcwE5N0qmW0X4rIDS2NxE39G9g+nt39jxyMPrm5zAc7rBlGT/DKJhmIjkahUniCY36OJpI+p4oQGAnoqM9x463AtrH7/v4ec2d6rE1HVOWHxqAbhxQxYFZHHhclHDixMixzK8JxG5r1CUOMdYNKajPVhVGQw6Fd0kKgHGWDpy+3GVosO3uCRjsTQq3srqar9DlRkiAaqgGb5t9ETwylIul03EEoqnpq7S53aqssFVzUYlZITe7pQQZ0kxMQ09FosbNFhdE6wIOJScjqpKGTNnrD4qVigLIvcVilV+5te1UXKI+f8TLOGGifuLQRM9u8In3HKWFG7ctPD53RA8ET3BYsQdmiAIgiAIglAuRO4rWE2+c+GG9cCuLf8rFL38lpmLa/4SQq537xewUEKxWVwX9oZzBAgRo3wtAhEJ3NxAE/HcRyguYsyDUJyAMErzi8sQpJRey5mIJEvENHXDREIpJYimrusoSZIld5osVUABSH6jAkrp4tREJBKTgKJh6IYBVANCiK7nEKkkURA34mUmv3cNcs4xvw8Kye+EQKkkSYg5XV/c5SJj6LrJqSqxAiyiLNxWPmJITM4JyddxsnhXK0kS0XOGgQiUAkHT0E1OJEkSY7aFoiFyX6H4ICGUUq8/YFf1yNT09Fg44OCIwGSFMgjWVtn39o8NDY9Md0habnJs6MrUgly7sVK1q6JvoQggIYQ4vQEXHZqamZycCwcdEiIBSdZUX6DK7zeHpwcHz8/Vttn0hYnzl4Z0UlFT6XY6RPDKi6rZPF4/Ds5OzczOhVU75wiSYlecrmBliGWHL/WNT7l8XM4NDwxOLuQ89dUVPiCi+7fwEAmTFa/Pb5NG5sZnpifCTsVAQpliA9UerKpS9wwPD42NdfqolhkdGRqZzyr1oUpJkkT0hOIgcl+hCCGhKvP2bH9gZf+b+376ny7tD9mZmbMFm1Y+9v3Hmrc+vOPI9Iev/+D/efKtCplHp6bneeW2r25b6g1oYh2dYoCEQM2aXVtOzfzy4x//l//rnkoH42Cz1Wx69lv3tW1+aOuFF1/Z/Vf/r4HXKjUzMT8xE62/72sbuxt8zIKL3gtfFHLTW9W8bucTh3o//Ol//X+/F3JrFHNq89Zdjz26bsnmRx45/vf7/+I/9b9U4WbZ2dGxWGDJw/dtarcDiPExxQCZM1i97sFnVvzlnlf+23849IugDcysr657++PfWdGy9YkHDv38xI//j8EPKv1SZn58Mqp2b39obZtDkVHkvkJRELmvUIQQCaNqzYrHfu+P6i9cnExmCTBCbL6atmqHw9++8bl/4loycGkupXNCgUru+saulauq7SqI3LdY2OvW3/8Np39p/2Tc4BIhYLNXtVa77IHQjsd/N1jbNzSX0BEAQXZVNXetWt7il7FsthQSCCHIJVto2aav/onUfnk8muUEKKG2miWNAbfXve6B3/vX/t7hiaiJwBG32gPNS1cu6wxIIvMtCshRcnhbt7/wp/aOyxPzGU4oAHorm5srHYHA8se+8y9r1g5NhnOccCAbHf6WJcuWtfoVJsInFAmR+wrFCpirfs3muuU9OV03kRBKJVmVgRCwt23c0dyzUddzBlImSYqq0NvuGCoUDDJvddfmUMc6PaebSAihkqJIDIA4GldV1nfrek43Mb/BvMSImApThjgobn/r5oeb12Wz+a0smCRLkkwBbVVdOx/r1PPHgSmyzGQGKO5tiwYiZbZg06bHGtdmdMM0kRAqyYoqASda7dIddUs2ZXTDNDlQWVE0iXERPaGIiNxXKF6I3CRMUiX56s/5thM5N4FJqiSriy8TPYbFB5EToJJquzV6Nx8X9yzlLD8H8uaTBD95HBGJqOTFBwkiSKp6PXp88b83HkfE/Iw4QSgaIvctZZQySZK4aHaKW35eO715OyQAYIxJkqihxS4fvoIsMnLtJJEkSdxBFDnG2C0nybXwiRVqipwkSUysMVJaxJW1ZJmmOTDQv2/fPsMwCl0W4U4ohenpmfHx8VAolD+CiAsLC319fU6ns7BlE+4KABYW5hcWFu59x2QikTh9+nQ6nRb3SMXv0qVLs7OzPp8//6NpmvPz86dPn85mc6J7osgxxs6d68tk0uIOs2SIFrMEISJjLBQKHT16tL//oqiuxc80TU3TGhsb8r0Ldrs9lUp9+OHuo0ePFLpowt3pum6apsPhuGefiIg2m6aq6quvvmKz2USnVPHTdd3v969duw4AKAWbzRaLxV555ZV333230EUT7i6bzdbU1IibzJIhAlmCOOc2m+0P//B7iURCPE2zCsaY0+nM50/d3d2hUCiZFOGzBkSklFVXV1/dxeO3jnPe0ND47/7dv4vFYuSmXQ6F4iVJktfro5QyxlavXlNTU5PL5UTsrEJRFL/ff8/quPBbJXLf0sQYa2hoENvoWMu1R592u72pqUm0sNZyL+OFiKqqNjQ0ivVNLCQfKUQEAJfL5XK5Cl0i4XNARM65uFcpDSL3LWGiilrMtR4Fkc0Id5W/Ehe6FMLnAACIJJ875TPgQpdI+BwWN94WSoLIfUsQpTSVSr300ktnz54tdFmEz8rlcq5evXrbtu1Op3NoaGjPno/6+wdEcmMJiOhyuZ5++qlly7rvTULDGBsfH3/99deGhoY5N8W9khVgIBDYvHnL+vXrCSEXL158//33p6amCl0q4TNBxLq62kceebS5uVkMry8BIvctQQCQy+U++uijSCTc1bXMNM1Cl0i4EwBIJpMXL15kjK1du87lck1NTZ06dWp2dra5uaXQpRPuAgCSycTHH+9duXJFV9eyezMcEAAWFhb27dunKEowGBRrnBW/hYX5iYkJn8+3du1aRD46OnL8+DG73R4KhcTSxUWOUhgbGxseHlq1ak1DQ4OobiVA5L6lCRElSXruuee/853v5HK5QhfniwOA6xN5EJEQzB9EvDoyYPEleP2IxVBKJycn3333nVgslh++SSk0Njbu3LnzqaeeLnTpfhOfiF7+iW/JhW96eurP//zP7/3z0MrKymeeeWbduvWqqlrzH4/croovHsXrG4HBrWeNBfX3X3zvvffyJwkikWW5s7Pz8ccf7+lZa+XuCQD4lOjdpopbNXqSJO3du/eVV16WZZEylQgRyFJm1ZbmKgCCejqZTKV1ToBKis1hU5iRSWYNIts0TZEpIVzX9UwqY4LitKuMWXY41ieDZfHwASGmnk6n0umcSQAkxe6wKRLPJbI5ExSbpskSAHJDz6RSOWR2m6aIC8vnZvGThABwM5tKJLO6yREkRbPZNYp6JpXhTHPalHyNzmaSmYxOJU1zqOIcKRoAlPBMKp5K5wyOVFJVm1NlJs9m0jqRHTZVlhghRM9lsumMQWW7XZMoFYOchSIg2pESZ+F7bWKk5kfHBgb7x+eiOlImO4MNS9o7ahJ9B87N8/oVa7qbQioBI74wdPrw6Rnb0gfXtAX8NuuNfbxDjCwbO4JGMjI9fKl/cHw2lkUKstNfv6Srsw6HD/dejitNa9Ysr/Mw4NnE7IXDB84bVRvWLOuo9prWG99c8CqGVxWwDF8MGunk/NDl/itXpuIZE0G2+2rbuprdZPrCsb6If/Ujq1vcbpUjzo+dO907LFUs79nU7rVo7nTbAFk3dkDQzMRmRq5cHLwyHU0bCEytqG7pbm9kmYFjhweUxq2rlzZVuDjQ5PR476njc47mdRu7QzaNWu/bWjRGwh2I3FcoQgDENHNTx3/xH//2zSuRQEdHa8ChpyTPaJxUbI9/9OI/9tL7bHXtLdU2BDMy3fvBL/7qSOXv9TTVByvspinaqEIDQrIT+9/84U9/tj/iWbJkSdBmcgVGcs5KD5x57eVXJ227Qq3Lar0y5bno5ImX//aHxiZXTUNnrc8UIx/LBVCemjy178f/v/+2N+dt7miudKkshbNp4A22C2/+44/OL/tXm1vrvV6Nmzhz6eNXfrFH7vxe68Z2HwWRhxQaUDCikUvv/+DP/2pfJljb1tzglfX46MQ0UT2VyUMv/tXP3Y/X1De2VLoRaHLs4p4X//Zk5TO1q9qCdhsT4RMKT+S+QlHiWXP21KF9vVO2zY8+/61Hu+xg6sA0m6aqx2Lzc2E5kdXzDShyPRMPz82pGUNkvcUBCOGTp/ceOTEKbc8+/wf3r3ApnBNkjopK10AyHAmHc6ncYgcvcj0dnZ814hmdW7RDT/giAGh0Zvjknnf6k13f//2vb1td60DUUXYHpKkzp2Lzs3PxDOeLCzUa2XgkvCDHs9Z7LFCiwEjMj5/Y814vbf29Z7762JoWFU0dZJvXKY+dTYTnZjGRNTghhADhuWw8MregpnSR9ArFQuS+QvEBINzg8ZnpSE5ublvSvWppK3IkBBgkJ8ISUEopvb6UFACljFGxWGaRAIJIonNT4Sz4m5eu6O7sUCVEJEC4qUuEwk3RIwCUMSrCV24AMsnEwvQM+B5ZtqxraWeVZnIkBKTYfC/NV/EbXnvrEaGQAIiZy0RnpyJmsG7p0q6VSxtMAwkBYJmJSQpwc40GoFRUcaGoiNxXKFYm54QApYQT08xfFgkV/QYWgRwJEKCEcNM0AfMrPIjwCdchIUg4MArI0cxXcqCijlsEco5AKAUkaJqmiYQABRE9wRIsOyteEARBEARBED4nkfsKgiAIgiAI5UKMeRCKFi7uY0GBUkqQEKAUgAAFggQJAKOUAwAlyMnVwWTikVvRQELI4jhNmh/zgNwEAMjvccEopYxSSpAjELg3ewELReVaFadAKV38iVIAoEiQIAWglBIOhCACAaD5dwnFAfli+CilND/mgQKhQBEQEYBQxlh+UxKCFERXm1A0RO4rFCUAUJ0Oleqxufn5mUiFTDhHYIwDcfu9cmZmamJyYjZMJZyfHB+PRMG7zCOpcqGLLVylOZwaw1hkdnY+EnQonCMSqtoUu9dnZ6PhyfGRqbDfo2Smx0emwhlng9tu0wpdZuHekhTV5nSYs+HZuYVIRLMhGpzIGio2l8dHM3Pjl6dm3R6E3MzoxHQcbU0+j63QZRYWUSZpdodKEpGZ+bnZiItyzhGYwpjs8Pk0mJ0ZnpqcrHfZSGpycnguQzWvz0klkf4KxUHkvkLxQSRMpTXdq7sa+o4e+/gND4yHbHoaFae3ZdOKxrXrWj5+6dTbr/7CXOjy5YaOfbx7DGq393S6fQ4uloctPCRAoGZpT1fD0Jtn33/5pdxEjYObwGV/98buyqVru1su/fLEWz/7YXpyiRq9dPCj4wlt1Zqu+mCFiF4ZQc59gZqlPes9fWfffuutxESDV6VJXatvbWsNtq5Yt+SDt3b/6JcwvKpBipx4/8MzaffalStbvTTfiSgUFCLKDl9999qVdS9d2PP+m+ZsV4WkJ0Hz1y3ZXB1csban5h/Pv/HSr7Lja6qyYyc+fvsSVG9c1V2laWJxX6E4iNxXKEKIRGK2th3f/WeuzrOnR2YunpmmVHbXdAY7FbWi5+k/+Rf1R8+cHZ/pPzfJwLv0ye8/u3b9umaPE7hoWIsAIiHOjoee/v1g6MjZ4bmBs3OMKp5gR5CA5Gx76LnvheqOnByYHrrQxwjW9nx15++uX9/T6mPW25JP+OKQy97GDQ/9k3/rPHz+8szwxd4RkB3Btup21RVatutr/9bVcOzC4Oxwfx8SbdnW7zy7euPa5VWqyHyLAiKqvoqVX/nn/yZ0qPfy1Hjv6XGQbNWN/lYq+4LLnvrjf1959GT/SHiwb54T1/JH/3BlT8+qJW6FifgJxUHkvkJxAiC2QNv6LRVt7XPRRNZAKikOTzBo0xTJ2bVpR82SpXPReNagst3pCwYr3Lb8GLNCl1vIo/ZQ04rt/rql8+FExkDCVLuvIujWJMVV173ZW9veE44ms4TKdldFZaXPrjIqoldekDBboHrZ/Q9Xd88uJNO6iVS1e3zBCpuqOhrWPORtWD27kMgYSDWX118R8NpVKsb6FglEIsmeuq5tj4Q6ZxbimZxJmGJ3+UIBWVO16iWbHgq1r56PJtMGkW1ub0XQ77ZJgGIJNKFIiNxXKFZAkGh2f21zRd3iLChEjhwROdHsgevHEXl+u3XRrhYRJFRx+KqdgZobooeIyAnTXJUN7lB+clv+GIrEtwwhAZDs7lCTpwpuqcuE2T1VTd7qqyfJ1cNC0UBCCGieygZf6FoVX6zLhChOX63LXyfCJxQpkfuWsmszcAtdkN/MDY0mwA2bA10/DmDlZQIopbf9AvnwFaRIX6Kbonfjt7wxfFbe8qmwVez6LHtLpxafVpevHbd2FSfkdt8gf8Tysbuxit9Sl0slfPkmutClEL5MIvctWZzzK1euHD16VNf1QpdFuBNK6cLCwvT0tCzLAIQQQCTRaKS/v//YsWOFLp1wF5TS+fm5cDjMOb/HH53NZi9fvixJsizLFs+fSt/o6Ojs7GxdXV3+R855OBw+f/48Irn3Z47wuUiSdPFifzKZFJEqGSL3LUGIyBirrq6enp7avXs3oqiuRQ50PZdIJOrr6yllAMTpdMqyOjo6unfvnkKXTbgLAEil0qqquFwugHs05hwRVVV1uVyDg4Ozs3OUik6pYpdIJHK5nMfjza9nbLfbKaXnzp2bnp4W9y1FDgBmZ+ccDoeqqqIDuDSI3LcE5a+LDz304MTEBGOUEFFXi1x+3w4WClXabBohpK6u7oEHdo2Pj4t21hIQ+fLl3e3tHffs+TUi+v3+nTt3xWLRe/Bxwm8OETVNa2lpZYwhspaW5l27dsXj8RIY11QO6uvrXS53dXW19ceoCISI3LckIaIkST09a1etMgtdFuFzYIzlH167XK7Vq1cvX76i0CUSPiMEoPdy4AHn3OPxbNmyRTyEtRAAkCSJUopIKiurtm8PiCWtLQSAyrIk7lVKg4iiIBSFG2e2IaK4KFoK5Ce5F7oYQlG7NuMLFtf6Ek91rATA6nP2hOtEv28JAoBsNrt3796hoSviJtUqNE3r7OxctmyZptkmJibOnDk9NTVV6EIJn5WiKBs3bmxpaZUk6R4kwZTS2dnZvXv3RCKR3/ZnCV8KRPT5fN3dy9vb2xFxdHTk2LHjkcgCgGiiLYBzXlFRsWnT5srKSnFVLQEi9y1BAJDL5fbu3ZNKpZcsWSKeihY5AEgk4rOzs5xja2ubptkmJydOnjyVyaTr6uoLXTrhLgAglUpduHC+rq6upaX1nn3owsLC/v37KyoqfD6/6IsqfrOzs0NDw6qqtba2mqY5Ojp69OgRp9NZWRkSTwyKHACMj49euHCho2NJMBgsdHGEL4HIfUsQAHDOZ2fnOjrad+7caRhGoUsk3AkATE1NHThwIJ1Om6ZJCEmnMwDQ0tKyefOWQpdOuAsAmJub6+vrzWQy9ywHzd/fplKppUuXdnQsYYzdm88VvrDz58/39p6Nx+OIiIj5s2XZsu7u7m7RPVHkGGOHDh08cOCAYeiIeM+WcxF+e0TuW7IopTU1tcuWLcvlcoUuyxe2uG7/4u5AnHNuckIZA8I554vND1BGKRBumNa8glBKXS5Xf3//tQwGABwOR319w9KlSwtbtt8ILAYPgBCCyLlpIqGUAUHOzWvL3lOJUeSmadERzpTS6ekph8Nx7y+HqqrW1zd2dnZaeH1fAErZTScJRwKUUUDTMPH6iyglxDRNa35LQkgulxsfH7t2d0Qpdbvdra3NXV1d+TteS8o3vvQT0SOc86tzFvIhJtat4kSW5fHxcVU9IR6wlAyR+5Y4tPBekoC5hZmxkStjs5GMSaikeUNNTc2VfHJgNAaB+sa6oFsixEzFZkYvj0aVumWNlU6HzC33de8QI8vGjgDl2djUxPDQ+EwsqSNINleoqbXZg1ND4zHmqmlqDTooBSObXBg9Pxh1VTfV11TYJQteHAtdxfCawpXhiwFKTD25MDk0NDIdSeocmeqqrG+p8ymJqStjcVfLyvoKm03iiNHZSyPjC+Cob26ttFs0+7htgBALfv58UQDIdT08MTg0PBVO50yksreitrW+huUmBoaTgfrW2iqvTUIw4tMTw6MzOV99V0NAvSfD4b9sFiyycBci9xWKEyJPTJ754O1XPvigdzximCCpFUs2P/nkc1viL/7F3/XR7d/9428/1O1FSM+MHPzpf/nBseB3/+v3H/F0eLllu1BKih4fvXjgnVde/fD0WDxjAGiVDRse/9Y32iOv/Pd/PKkte+FP/7fH2lSJ5aKTx1/8D//5xNLn/uT3v3Z/q1tEr3xQbsQmR46+/YuX95wcCidNJIqnfv2jX31oiXrmF//lH853/dlff29Xfb2Lm3z45Gt/9ZN9Usfv/Yt/82gTJSITKTzK9fTc5aNv//LXe05cms1wk0iOtpW7vv7Idjr2sz//X5d2/P6/+vaT6+1uZOnxk+//zd+9Mb/p9//j799f6ZKRiPAJBSdyX6EIAZCckTr77o/+4aXBmrUv/NkTa4OKkUNJUVVFWogtLISlZE5HAoQAMfVsPDw3p6YNE/OLTRW6+OUOgGD41Ksv/+Ttg7D+qT95ZHPIzk3gQKtcfCYaXliwxbP5HBcIN7LxhbmFeEo3xYpPZYXSzPSlfa/+1Q/eIQ9+7ff+cG2LVyEZnXlDSvRyOjY/txDPmovnBBjZRGRhXlk8bUQdLzigJDU7c/QX//mvdsO2r379OxuX+5iR4cwZUNjopej83EIirS/WcTQy6cjCQjiZtd4zOaFkidxXKD4AxMjxyUsXh6d5zQMr129bs1Qi3ORIMB1O9+cHlV1vRjE/Elg0q0UCCCJOD54fnE57Nq/dsnFVt0PhHLmZATrJkHN+0yNE/MQRoQwAQCw8e+V8X8L+zIa1a3vW1NoQDdOkcuLcIEFumjedEotnScGKK9wIAHLp2Pil81dmKh5YvXb9ltUtwLlpImWx4XHg5s2xyq9XLqInFBGR+wpFCRGzmSwnisPptNtlqptUZsCoARmxtKIVGNmsCZLN6XRqcn7KG5E1NMXCmMI1pmnmsjnZ5nY7NEWWqGEqTKJyFsQTgOKHnGezOUJdLpfdbpNpTqeMAZNkMR1MsAKR+wrF6urM78WZIIgoxvlZyCejJx5UC7cCAHLDVD2LTvsqUwBwbaolES20YCmiF0YQBEEQBEEoFyL3FYrcJx6g5TsZrm+rnt9hXfQXFaVbn39eDx5cewWINYTK2ycfkiPi1Qc/+Rdc62K8x0UT7gAJuTFK148j3tA+X22rRfCEYiLGPAhFCQAUSSLE1HMcUJYVjkgIJYyCZlOJnk1ldANkWeZo5lKpFNc0jTImnqsXCyZJlKOpG5zKsry4pqep2zSNSWY6k8pmmOyQgGIyFTdNRdMkSTRGZYYCMMbMXM4glEmyTDkSRKrIkqaqphFPphBAkhWIZ9LptM78qqoRIup4UQAKqsQ4yeZ0QkCWZcjf1UqMaaqKqXg6h0gVhSHqmVQmR1TNBkBF9ITiIC43QvFBQqgE/rrGkOfs7MWzx/fVpdzENKnq8Pj9ruqO9so9hy6fOHyg3tZiy02ePHJmLOZd2lpvc2mia6EIICGE+GoaQs7hi5dOHzsayLgkRMpUb3WtO9TSUH/wzOiJg+93knZHLnx53/HLxNnYVl/hcnK05sZ8wheBaHd5qxqa1ItDp0+cdJhTdoKc2vzBkNNX19zuO3Dx5AeHG6OxkJodPHD8cozUrm6t9Yl5VMUAkUiqI1DbVO04Pnbm1LEqGraZnMuaO+i3u2pbl1R8eKnvyKH9jnijmhw6fPL8AvWvbqpVZJFwCEVCnIpCEeJIVcndc/+TWwd/dfiDH/7HYx5NMnP2qrZ1z/3rZ5dteezR03OvH33lf537yCWRZDSJFcsff25Hp9eniJXOigESgKo1D++6LzLz+rs//j+PuG2Ug8Nev+N3vvfIys1P7hpK/+KjX//1f3jfrZBMPGbYVz792Kbl9V7CRepbPpBzT1Xrxodf6Dv/0gc//Yv9r2mKBLrWsfOxp5/fuWTrE1/tnf7g1z/8zx847USPxVLqkk2P7trUqlIQ86mKAHLqCFatf+xb2wdfPviTH5x8w60RMxNoWvPQ8/9sU9P2r3zl1A93v/c3/+OAx0Wz8WhWbtj+yKNrm+2yFTd1E0qSyH2FooQAsrdt1/f+Zdfj4/PJtIEUqOry1zS4vR7fyqf/9N+sn5oIpzImUiqr7spQdXWV3yYTkTwVBySyr3vLNyqbt07Ox7M6IUAVm7++scrjVdc9/PuN3Q9PhxNZEykw1RUMVddU+e1UXBXLCyeyv23F0//yz3umZqIZgyMhki1QXdfgdWkrtvzO/6155+xsLGsgEmZzeipra0N+JxW5U3FADpqjdt0T//r/s2pqOpo2TARgTm9lfYPT52i7/5v/rvP+6dlYxjA5ZardW11TVVnhkqgY8SAUCZH7CkULFHdNg7uqhpumiQQAKJOAEAKyv77JV1tnmiZHAEolmREulkcqKkg1Z7ChI1BnGibPT3dhDAgAKN6qZk9l42L0gEkyEBRTYcoQEqrafA3tvrpmw8wP6GeMAgVCZGdl65KKptb8JglUkhhQICh2tygmVLZ769u9Nc0m5xwJUEqpRAkn4KpoclfUt5qccwRgTJIocBE9oYiI3FcoXojcJASAXZsGhfn/x9EkBCiT8uuUoCn6e4sPIieEAJWkG1aTQYKEI7kpemKcSvlavGOljNEbji3+gsD14yhOk+KDi1Gi7NqeNTwfPHLzcTStHT1xY156RO5byjKZTDwez+VyhS6IcCeU0mQymcvlVFW9dtAw9FQqFY/HC1gw4bOglCYSScMw7/2GVpzzZDIZj8dlWRaX5yKXTqcNw7j2IyLmcrlEIhGPx03TLGDBhLuSJCmTyYg1KkqJyH1LECICgCzLR44cyWQyomEtcgAQi8UmJyeWLevO508AsLCwsG/fx2NjY4UunXAXAJBIJObn5+5x7ssYzWYz77//3pkzpxljIvUtcjMz0/F4vKamhhACAIyxmZnZd955++zZs2KKbpGjlA4NXUmn01zMxy0VIvctQYgoy/KmTZsuXLgwOzsrtlcvfpxjfX1De3tbvuu3qqqqo6NjdHQ0HF4odNGEu+Mc16xZU1tbS+7V41FE9Pn869atn56eiUSioo4XP8ZYc3NLc3NLPvGtqant7u6em5ubn58vdNGEu0Akdru9paXF6/UCgHjGUgJE7luCENFms33ta18TVdRCrvX4EkLa29vb2tpE+CwEbtyr7rfPNM3q6urvfe8PxUliITeeJEuWLOno6BDhs5B7XMeF3yqR+5YsSsWG1RZz44VQhM9y7n0eI04SyxF13NLEvUrJELlvyRK11NJE+IS7EieJpYnwCUKhiPtOQRAEQRAEoVyI3FcQBEEQBEEoFyL3FQRBEARBEMqFGO9bCsT8U0EoQl9irRR1XBCKkKiVFiVyX8szDSOdSQMViw4KQnFBjrqu5zd3/mKAEIJomEY6nTZM466vFwThXjINU9cNkq+qgnWI3NfaEDGTzS6Ew2LzW0EoNohoGIZu/EY5K0dMZzJz8/OUUXF9FYSigog5Xc/vpVrosgifg8h9LQwREZFznkqlCl0WQRBuBxF/g9Ws8m80TTORTHypxRIE4cuRvxCL1ZqtReS+VgUAkiQh50CBiMEOglC0gCAyxtjnfR+lVJZlJIQQFHVcEIoXAAWglIreX6sQua8lAYBN1apCIc45iIFGglDcEIjEmCzLn/0tAOByuWRFFlmvIFgAEEYpY0xMvLEEkftaEhCQJdnldBW6IIIgfFafa60GAFBURVGU32qRBEH4Eol+X6sQua9lAaEgBhgJQsmiQMVDHUEQhC+dSJ4EQRAEQRCEciFyX0EQBEEQBKFciNxXEARBEARBKBci9xUEQRAEQRDKhch9BUEQBEEQhHIhcl9BEARBEAShXIjcVxAEQRAEQSgXIvcVBEEQBEEQyoXIfQVBEARBEIRyIXJfQRAEQRAEoVyI3FcQBEEQBEEoF1KhCyBcBwAAUOhSCIIgCILw5QMAQsRVvvBE7lssOOe6rgMAIha6LIIgCIIgfOnANA1xlS84kfsWBURMpdNT01OMMSIqhSAIgiCUIt00TNMsdCnKnch9i4VpmolkQjwNEQRBEIRShYii37fgRO5bRDhHInp9BUEQBEEQfmvEOg+CIAiCIAj3FHIkogO4QETuKwiCIAiCcE+heMxbOCL3FQRBEARBEMqFyH0FQRAEQRCEciFyX0EQBEEQBKFciHUeBEEoX1d3UrzrokO323LxTm/6zH/4N/2sxRff5XN+k+IIgiCUFpH7CoJQtripc5MTkCij9A5rayM3TW5yJAQohfz6nEApY7d/EyI3TZMjoVSin3encuSGwflNOSoApey2fyhfMARK6aeUZfFPmpwjoZTSO35PQRCEMiByX0EQyhAAGIY+M3hsYGSGBZZ3NLdUej6lTxSMTHJubKB/YCpFZW9DgycdmZtZgFBTW2dbpSZRuOVtQDOxmZGB48NRpbKpp6PW59CQEPgMfa4AaGRTE+f6rkzNxEy62KELir2iYVl3Y4XDxm78E4BmLjk7Ojx8JWpvaqxvqPPJt/0EmluYGb7SezkmBZuXLqsP2GQqen8FQShjIvcVBKE8mVyf6Pvw7Q9PS12/5/K3V/s4wmKGmu9hRc6RAKZm+k+886tXDg2Fqde95P7H68b7Th47DWseebaxudKuShTzvbQAQAgiAk1FJs7u/ck7g+61jzXVVHpI7HL/8Lxpq2ppbQo4FlNazhERAShQCgSRm5wQ4EYuMXR4z5tHTo3qqipLlCCXnMGuHYGW6gq3kyFCvoyISIxUbLr3nZfePh5vf/4rj9Y1BSXOOXLkSCDfv4uIBJixMNH38SsvD2urHg20VvvtCgUAALL4lzhykQsLglBGRO4rCEJ5QoLp6MT46JhUFctmM5Hp8YkFXXUHXHI6GommDS1QVe1V9ZkLR/fu2b3v5Ah1NNrk2Mz4xOzMQjzj1M1cOjk7PBZOE3elR8mko5FYTnMGgrXVBE09m85kpEw2MTXSN3vmvT2nxtDftW7TuqYKTdF1VDyhhqDHoemx6dmZyTh3+isaqjwyEMLN1OzU2NBYon5la3dnlUqRae7aajfkIhMjkYVoKqujrHkClVVVDj2TnO4/d3Egxa4MnA95IxKxe3yh6oDGs+Hx8bmM6qu0E6rqkbiRy6TSJGtw5ITkknPTM3ORWNoA1empqK702xQGt3ZfC4IglCiR+wqCUL6AUkooUKYvXOn96NW9Q5KvIaBGpqemYzl3x5ZHtzRJ430nTl6cMUFxBYKhEJ0bmYzGDIfP47BBdK7/9Btv9yWCLZVqIjEzMZV2VK/c9tBDnU5Jdfq8XodCE6Pnzh/6aM+RCwty5UJcTzZW+RxjFyageftzj6/vqpgdPPLBWx/NaCu3PVlT5ZLyK+8AUOZoWrX1ud/76mq/RAkhmEsuDB95c/eB85dns1mU7YHWFZvu39QpI6WM0uTQyYNvDp+nOeKu79jwwI7Vfr3v3Rf3DJPKJq9pr2tSDepw+zyaU6M8lxw7c2Tv4WPnJuZjWVrRvnTzo09vaVSZJDZUFwShTIjcVxCEsgfAs9H50TNHDyfgQnVdpYvMDU7MndcrKneurfX6fU6ZMsPmqayrrVRhbPzy7Mis1BFJpZOx8QvHjw5Df6g2FFCio2NTZyPU1ezfZkZmrwyPuKuS2F5R4XPbFEoVm6eyrqk+pKYHXzt/edK7Yn1XHRm93Hf84BWte7nNpxBGr21ximY6HpmeGBtJUMqYbNc0NNPhLOdEVcnccP+5C8NTuv0PdlUQCgR5Km0g6pnZ8f6LY3PgCT5cMz144eyJiUSfL9i+w9PpzM2MXRm1V8eTifkrB1589dXzo7SuobbCoSicoEQIiMxXEISyIXJfQRCE/NoMWUNx16z96ncfbU199H/+9K3eubBBfUu61izrO9Q3mQkt3frII0tc5NTc5UvnJwwTERFN3aC0ctWurz2yw376h//48vvz0UgkyR0mNwzDpJKnaVUzv/zxybNz9tru7dsf7HbP902H9MsjA1cmw62xoYnJcd3XU11f46FACTEJIYQAIZmJC8ffezFyUiHE5gos3fD0ho77fv+7m7hJjPH9P33lpz87MH95dHqHO0cIgG/lA088+3Dn3K9f+9mP90SvjE/rFTnDMHTT0bL64Scf3mab2DdsGIaJuqHPTV8YDYeVpsef+voz25d6gcmaTWFi7TNBEMqHyH0FQRAIIYQgYarNU11XXxmYccgyIyYBYIqiqjIFoEzR7HaHg2iKxG5YJ4wpkquqqi4UAocmM0Ku9t0CIQBAZVVVZIkCUFnRFM3ndtW2dLiVybGB4dEq/fLMZKaytbalIcCALPa95ufCpaPz44MYpgQd3uqKZToHxamSnGFKiqKqCnI9nckuTlJjmt3h9nkzdk0hoHOen3lHWWB5z+q1q5YEx+bptal4pq4TILJmd3q8Pp/X5Fws+isIQnkRua8gCMIiAKASpQQJXhsDgNdSw8XlFW7JFIEApZTe+MKbXDvKOecmyqqzoW2J6+DBoYv77NEr4VhVqK6luUom5OqwAyRIiNawcusTj9/f7qQgyaqnwoXxvg/e3n9mYDqVmLsyPE6I94ZRCohI8ks83PTRks1us6nKbVf0RUTknIu8VxCEsiNyX0EQhBt8+bkgAALRc3oykUwkdZfmbl3a4jh+5cKx89kcVqzvrq+r1QgQXOzyJYQQkNyVte3dK1f7ZUoIySUXzn/8ztsf7JnMNbXWuuyaROCWjyDpXCaTThGgiixd38XtxoQcCQDIikqA5rK6bpgmN03dQFmWPuf+G4IgCBYmcl9BEMoWctM0CeTX2uXcMPLbseV/YRCTcyQEkXPTMIz8bxZ/ZxCT4w2/QUKQc9Mgppn/Y6ZhGIbJCRCX1+tQXPqVC/te/AWd3vbY8yu97Z116pHBqcksCdSE6uqrHTemnvm/bxiGYZqGARSActPMpeYnw+GZpNMtZxOxFNFtJueYf+386XdfSfW6owMDM27bsiVNVZI8k//4/KCI/MtMwwAme+vaamynegf2/fofpo/5ArUNK7Y+sanRozIx2U0QhDIhcl9BEMoTAPVUd3WvolJzyOXQ5KqWNWsVd13IoUjMWdO1bI2Uawr5FdA81Y0r1q7RG2rcsgRAPA3t3es5a6v1uVxqU/faVLy6xu9QgFe1LF2zuqqmucLlsNW2b1irOporXTbmaFi2cdsDhvt81DDTOdOUZK2qedXShguz86NqTVVtQ40LKCFIEAihTPa3dK5I2OyNVa78GGBETmWtunP7/dvUgSsJ2WEPhfxVhrO+sdJT4e7ZuEkanknp8bm4Utu6bXtnz7ZltZ7sfOfKHpm3hPw2QObw1LSvXm9X2yp9rorghkfuj1WcHphJzIxM6Jq3g5uIYqUHQRDKh8h9BUEoQ4goUaVh1WPPNm8He3XIY+fu+79ZlZVt3gqnXZZXP/5k833cUVPhYZpj5aYXalegzVNtd8iMNG584CtLNoE74HfbufOZwBpT9VYG3BLv3vZ4zTJd8wc9Xqli5x+0ZpnLG3SrXGvf+XRwxZa5qCm7A6Eg2ECrbO6ocB7X/B2NLe1NFQBksX8WJM3VtuMR35oUcwcrbIsJKVJJrWzf9XXfstlw0lRtmgy5WAacgSq/8kSobf1CIqtzoIrT5asI+pwyz6SWP/LVujTaK0N+xZSDDSt3fa0my5z+kMtl9+96pnL11rlILJUDzeUJVLlkdusgZkEQhNIlcl9BEMoTpdQTrHdVEAKUAiGO+nYfEgAKFJRgg7OCIFAKQEigpsWPBBY3CvaE6lyVuPgmZ4s3vzMxAAlUNfpDBIASIO76jsXXACKRXb6Q01OZ38IYQEeicxaoaW1ft3xpYwXFq3uqIVCmemvqPZj/uOtDIYASyRmocfjyuxoTzP8xIIpmd/oW357/80iY4gg2tFQsHuDgcAbtrYHr30B1VVQ7A1WLy0HQ286FEwRBKFUi9xUEoWwBlSS4uhQDUGlxjAEhhEr02i8IBQmu/wSUSgA3ven6/4brfwBuWOMBgF49AIQTCfydO56so8H2hjovu2XdCJrPeT+5AsPVP0IIIrlWAgKSdDV5vfoeuOmL5ZevkG78Pb2WV4uFHgRBKDci9xUEoYzdmPrdlAbenBPekiHeuHjCp7zpEznl1QOIVFK9dUtXVCNI+aWCb80+Pz0fvf6bTyv33Ut8t88QBEEobSL3FQRBuLcAmKJJhHzqmsCCIAjCb43IfQVBEO45kfMKgiAUCC10AQRBEARBEAThHhG5ryAIgiAIglAuinrMAxACABbdbBPIZy22Rb+gIAiCIAhfzGe88MNiHiTyhC9Tsea+SCRJdjickiR95jOkqCBjEmPsrq+TFcXj9tyDAgmCIAiCUCQYpZJ0lxyMAtVU1e1yW3eCgGazFboIt1GsuS8hqqJUBoOFLsVvBADufL4iotPhcNjt96xIgiAIgiAUg7smCQDgcrmcTuc9K9JvQxF2Whdp7pv/lyrCf68vnXiWIQiCIAjCJ5VPLnSPiblugiAIgiAIQrkQua8gCIIgCIJQLkTuKwiCIAiCIJQLkfsKgiAIgiAI5ULkvoIgCIIgCEK5ELmvIAiCIAiCUC5E7isIgiAIgiCUC5H7CoIgCIIgCOWiSPe2yLPuJn7CZ/TZl+wWJ0M5+IzngzgZSt5nORPEaSAIxa84N+Yo0twXETnnhmFw5IUui/DbQoEqsgL0LhWDc26apmEa96ZUQqEwyiRJovROD6MQ0TAM0zSRiLynZFGgiqLc4ZKJiPk2QaS/glDkJCbJslzoUtyqSHNfQkgul1sIL2Sy2WK8ZRB+Y0iIqiiVwUpFUe78StM0Y7FYNBa9NwUTCsXpdHm9HoXe6XwwuRmLx+LxuMm5aBlKld3hCAUr7/yabDYbjkay4gIhCMXN7/N7vd5Cl+JWxZr7AjG5mUqnE4lEcXaYC78hRLTZbIHA3fv1ETGTy8Ti8XtQKqGAJFlGdN/5NYiYy+XiiYRhmqJdKFVwx75/crXfN5lMplIpcYEQhKIFAE6Hs9CluI1izX0JIYTAVYUuiPBb8dkjC0ScBqXvc5wPol0oaZ8xtuICIQhFrmirp1jnQRAEQRAEQSgXIvcVBEEQBEEQyoXIfQVBEARBEIRyIXJfQRAEQRAEoVyI3FcQBEEQBEEoFyL3FQRBEARBEMqFyH0FQRAEQRCEciFyX0EQBEEQBKFcFPXeFl8CYIwCEG5yfqeN3wEoUEqBEIKcY369dM4555/yJgBKGSXI+Z3/8G3fSxmjN6/3jMi5edvPAkopUIKc4x0+CCillOb/zB2LA5RRCoTf/OfyRwHv9M8ElFIKBPFTClr0Fr/6XUMG+W8K+VMhv8fUp4bn+h8Gzs07hegun3Xdp0Yhf5IC4fjp5+XVMxM+/c9cL/biOXNTROFqnO/wjQHyhca7fEKxWqy8hHPzzuXP/xMBIYiIiEApIDc54qe8a/H1n16b7/xZ7JbdzO7QKiy2VneujEAZvVtDdvWvffKUuXpu3vlEWjyL7vYRwm/bZ23erp/UN1zq7lbbGQXCufm5Q7zYNN507E7tG6V3v9RdP1m/1AvRYmW5oax4/d/ylnYa8y0w3LWlFIpYCee+QNAwEvNTsUyWOSo8TqdN+pQahTyXSsRjkXiWM0l1OBU9mckidXg8HqfGbven9WQiEZ9LmorDW+HWFIkRAFi8Qt65UByNXHR2IZ7WdSSEIEGCVFZsbr/fod6aEnPTyCZisUQKVa/Paddkevu/bqbC4XgsYap2l9fnkG9tbW78c5GpSCIL9oDb5bLLmP/2Rjo6G05mUHX7XU67wm73IUYmlohG0ly1eYJujdAi3avl0yAxUuHZaDwDqsvt8djkT9ttBnkuFY5Ek+mcAZrHLiNk42mw2T1Bjwa3+dbcNLKR2XAyg5rH73bYFWnxVPgsWSFmE/OxWCyVy58HhBBKQHMHPU6HJt/8fkTMpRYS8YQuuexOj0u9/V8EM5uJRWdjOVTdFR77pwSTEELMVDgSj8UN1e72+uxyPpUiJBufjcTjBnW63QGndrt/JW7mcvFoNJElmtfrsmnSp5yURQrASCfjkfkUp5qn0mtT2G3Lj4SgkY7GovFk2iSqTdMUKRNPmbLN53PZblcTEUk2MhuJJ0zZ6fb4nSqF/B3U3VsFAlxPxxILkYSBHAlBJIQgszndbo/HJn/i5UYmkUrEUjlQ3UGXTbptBBBNPTq7EM/oksvjcbnU2zVkhBACZjYVi87Fc1RxV3rsyuIpw7PpWCwczXHF6Qs4bTKF23xjbqSjsVgiS+0Op9tj+7SPEH7LEEkmPB1NJE3F5fH47Mqn7aWF3Mwlw5FoIqNzsHkcksEzySx1OL0VLvV2rTo3cpl4OJzKgs3rdztsMoP8SX339g0Rs9GZWDyR0snilY5QSm2eoNdhlyW85cU8mwzH4wlT8TqcbqfyKXeXRiaViM4ldGrzVHjsX2Ljk4lOxeKpxaISICCpdpfb49RkBmY2HYvFE+m0biKhVFIdbo9LNjOJeDQNqtPl89klQix2SSx7pZv7AqXZePTMq3/9Rt+gd+v3v3Lf9s5A/v4MkSw2DYhICGBuYeTEwffee//4DKusad60ue7ynlP9KceWp5584r4lXsLyL7zhPVJ4oG/3G395IFm/6bl/9nh3lT0djaV1qjmcTruy2Hez2DoAAAAlBBE5Ekp5KjF04ud/907vzBxXZVmiwFEO1a7Y9cJXN7S4ZQkRAQgiQSRgJBcGjr3++t5e0vHsN+/f0F4rmxwROeK1rTyREELiV/Z+8Pa7uyOt6x5+/psb6zQJ8jsJXsvHEQkA5Zn4wPt//fL+y3TN9x598L61VQYCpWYiObT3xZ/sP5PtePx3Hrl/Tb3r1n8lgmhGhw/vfu3XvZnOVV/5Zw93SC41X8a7X9aLABBuQPTixz9/9b0+2vrgU8890V1nUwCRIEEg1+NKiZlcGDn0+svvnxqK6o6VT6z2R/Vzb54ha9Z95U8e61Q9GnK84T0EiBGPD+75xU8O9BpdT337kR3LA7loNKVT2eFx2xi9fs7gjTHLRxBNc7b3nTfeeOfYhMxkRaJIiAy088E/fHzLmuYKzgkAIGK+bNycPPPm7g8OTFc9uuWhp3Y0kXwAOCLAtZsdoInp8QMv/7d3hzNtj//p0+tX1LvMfBzzmS1e67mB1NDHu9955/355nUPf/XrG2vtDJCYhIyffu3F996bs9332FPf2dppV+nN/0qEgBEdGzr06199PAornv/qzlWdIRsnmD+/i/9UIJTS2Ej/7pd+cDjhWP7Uv3x6VV3Axhfzzav/iohICM9FJ8+89+ZbB3vHsp5lK9pb62zH3z4aDq3+2nceWNdSLXPE/397/x1kyXEmCJ7f56GfVvlSy8rMytISVShoSSiySTabnL7u0WuzO3crxnbHbP84O7O7vT/u7OzWds9mb23XbK5npkd0NzUBChAgBIEqoLTOyqzUL3Xmy6d1KPf746WsyhIgCRCo/H5mBLPeC+Hh4eHxPQ8P99W75OpKdk3Mnv35j997P9v24ht/+henmiSnki/ZoPuDXl2RNpeEehv+RlzMWC2XuPD+v/+7T1JoMUWRGCII3+4TL7/y+gt9cVmGtaytr12cv3Hu3Z+eWwzt++Z//frBSEhxeb0xeqMkMLdaTF/9wX94d2i+4flvv/Hqs72+LdP/rieEscry2Lm3/vffTHm6X/+X3zzR1u53OTBmrkyf/+Xf/nyy0vHsX/6TZ/Y1BrU7swlc28zc/uCXvz4z6nvimZe+9sbewKby/QWcSwIAAMjQqfCZ0z/98UenS92vff1PvneyTZEYwObyKYQAYOCUk+Onf/HmBzfmKxA8/PVj/vnM4IdjxpNPfeefv9TL/CrUb1rrmwY7nRn+4D/93YVR5dj3/vHLp/r9PFuoclnzBgO6tKV6g7XytVYpcae6fOVnP3vn4+vLmqqpMhNCaKpx4JV/9vqpfS1hvnanAyEEuLY5d/nNdz+4UOz93jMvvfJkq13/hm8u1IBSaXby4zf/l/cWvIe+/V9+81hf3MsB1u50dxW89SmvV/eyeh9cTzbA+vHy+Qs/evuDs1eTuiKrMrocPJHeE0+9/vzJLj8sD187/dH5m4lE0WFM0sItB57/zksd2eEP3v35DaX3+Vf+D985HEVU6ttdv6zpEvhye3RjXwDgjlNcnklMTkT3FGqWY1bKVYszWWHCcRyXM0nTdBl4YeLmmQ9//asrExAeaGGSU0nPz0xNlKO7ixXLqpVqjouSIoHrOC4HSVU1zeuUi6m5iami6CtWCisL45++/d7NOc+BJ599+kSnlzHBQZI1Q5MZc8yqaZmcKZpmqDIAcKeSm5+ansjU2vb1tTWHFc7lSDxsqMIyS1bVdhwBiJKsarqH14rJ2WuXb44H9GQ6nY0ZumCyqumKJByratpCkhUmUKoW05mlqakVT3fRFlwI16rVTNvmHJDJqqZrilSvlNxyamZmYlxqLxTt9bsgd2u55ZnpqWo4VzZtq1qqmFtzSdcVVk3OTA1dH5EDbRXhWLVyzbQ4Uw1dXa1lv9QQBLilzOL0xLikH6mYjm2WK6bNZIWhcG2bC6ZouqpIxZWZix/85DfnR8pyT3tYEXY+OZeYTMjNPRXXrpWLlu2iIjEhHNvhTNIMD3Knml2amZm0Ypl8Pj2TuPHue5eX/a2nvv76/ljYh7YjUNY1VVGZa1tWreYISdUNVZYQQNiF1FJibDrb0rb7SGtYKEwRGPHrkjAr5appu1wAMllRdV0FUZgZuj14fal2uDedzwU4MEnRdE1h3CyZlguSzGRZLhXL2cVEIlH1Faq2C8I2qzXLctz6hnRdk1cjcl7JpOcnJpbVjry9HlkBmMWVhZnpBX8yX7Ets1y1t+aSbnhErZCdvn5zJONrKlVtx6oUKzUHFFXTNeUr8DgAwamW07Pjk8VAY9FybLvilE3BZIkBdxyHg6zomo61wtzV07/68MOz81akMaYAr+QWE1OJrNNeMs1atWTVXJAkCYXjOByYYuiSK5u55EJiOiklc5XKyuTs9Q9+fW5Z2vPyy4/v2RVVuBCCqZquq0xwu1Y2bRcUXVdVmQEKu5pbSYxNZ8Lh3fub4z6DCW5Ew14ZbLNcKdkOF4DIJFXXNUUxV6Znhy5eT/YGk9lMBoXOmaqrqsycqmk6LsqqJlvVai23uDgzNW0fKpocBHdtq2ZajisEoKwZmirLDAGQW+Xc/MTUlFfPWxZfvYEjt6qF5OzUTFHKVS1u1YpW1RGyLKFwbccFJmuGCk5leWx0ZHC4cfeBiuNa1VrVclFWDV2R2FegLDwyBIdqZnF2MpHXU0WLO5ZZq9VcSVYYcNdxOEiqqisK5hYnzn34k/cuJSxPf1dM5rXc8uzUVCLYu6/i2rVqoeoISWXgcsdxBZM1wwOuWU7PTycm1c5MLpuavHXx1x/eKDT0PfX6y3siPh0cF2TNo6mKLCzLsqqWYKrm0erVmzDzSwuTEzOVjp7dB5pCQkZV0kJeBexquVC1HCEAmSSruq6D6+QSN4YGb1bUZwdS+axhAlMUXdMk4VRrlo1MYSjJSqVUSS9MTc34mks1ywVum9WaWb88pDvqIMFt0zIt2+EcmayoqqrKknCqZdMSIEtMQgGyoUrIEATUcouLU5NztZ7O3u5mTyk9PXTzk6UEDwRfDlQvvfd3b13N+xrb+ruCaDKo2kKx7Gp2aXZyXDUOlB0QwB2zVqvZLheMyfW7CV0BX2qPdOwLsNZQAgKKizcuvHd6vBjq3BN3pkYnFktG44kXX+oXqcvv/+LXF0YzRdsrJ2cma9llkanUjIDP0Nzk4KXBM5/O6t37m+XlmalE0ml67OSzJ58IyqruCwbAK0pLV9769Mynn9xcLKuTMyOTg52esC+9bLbuef57zw2EPMkrH35w7mym6dCpp75xsn29TRgx0H7wuddfP9nr5RwVTZfVyuTV3567PDqfqjloNHcfevzZ5wYMx3XMimlaI6d/kh/UmaM173ns6RePtpoT195+/2qupfeQtyg1d5ZMjzfgr3h0VRJurTR/7fRHF24m0kVLiQ489sTzTx9r8UjyWn6sNhZv/LhHSTN8Pr9saHJl8fpvrpweK4Q6B+JOYjWXXnrpeK/surYtbBkZrxanL3/67sXbxcaTf/LCiQPtYfzSd3eqt0atNSOY6cT1s29+koi1HohphaWJ8ZQZGTj5wtFuHD39b3768fBCylJ82fTcpd9k3VK56Pe0+TyiXBj++N3zY1bD/jZvpTg9Nl0ItBx66uWnu2RJ8/h9AUu3E598fO3mu+/dWqpqgcnkQlfbnl4zMZNXe1957tTRo7HU1NWzv3x7wuk69cq3jvVGvDLUe2yCp6Hz8Nf+/qv9zKuAAM0TdnKDv/3w9NWxpWJFMnwtAyefeeZEdxAc07JFZurSmR9nhkRZDnfsfvZrz+9tKFz+8YcXlkRrbyQWNYp5HTVfIKB4VAmFk03cOPPx+ZtTyyU0Gnr2vfDqCwMNAU3iG82IILZkE1MMr88IeD2Gk0ncOPfzTzdyacWM7jnx/AtH/A53TMvlXHDkCzff+fiTC0vSgaeefPnJfREZ4ctfFtYeWAiX28u33v3g43Ee6WgOQ3psbK6kd+x55pmnQrMf/+xX718cW66Aoedmbl5fkaFW1mSPX0enNP7BJ2eHl5TGnnajPDk+nea+3c+//GzvLkUzPH6P3ysVJgY/uvqzdy4OzZXlkZXZS7sPdpuWVTIjJ08+/+rJxmrx9gc//HBk3nv46y+fONIdYgAgQHBUjKb9z3/r1UMtUZVz1H1et5q4+P77F24t58tcUoM9x5577vj+TnBtx7bL+aWh9//DX33iImqtJ198+mSXN/Hp2Y/GF4323v3eTDl4wJR8gYDfo6kyimpmYfjcR5/cnEhVHfD3PP3qs8cHeiLr/SnWG6rW2sSQybLh8/vQp0vcnD370zPns1JXZ2OgujA4tcyjHSdefulwjHPLcm1HMMTi0vD53/78ypzWeeJPv3G8M+SXqfX3iyRW+xWgVEmODv32zfPJ1o79YWllfiKRc5oOPPXCvqbK0Af/9q1Pxpezjs7TK7OX3k3buULV52vxGE4mde23v76UkNqONsvp7NT4fC3WcfSplx+Po6x7/YGgolUnPvrNmWsffHQ7aftGppYT7Q1d8dxMinU88b1njg30OBPXzp5584bZfPiFP32uL+qR6vcZ7oK3adfxN/7Bi92oywioGlpu7uOPLlwanS1WhRpq7D325PNP9gUFt03bFunRT377g5lrblmN79r7/ItPdJrT77376agUHwir0WjQcnyyEQj4vR5FAtdOjV46c+birdlUhfmadx986dVndwV9qsSFALeYnLh68fTFoel8TQ01Dpw49eTh3Y329OlffHI5B20t0TZfBfu+cbIz4JG4ABQgOPhb9x5/7S9f68wuXnnrr/7m0tjNibkOZSkxPsKbD5/65n/+J/sMcAXncrApUEi49XZmASgcMzc9/PEHZ27OZ0xPYNehJ5557HBP1PhjlwlyH4987LsKwS4uTQ5/8s4tJ3w1aiCvpRZNnJIi/+BQc8Dj9akgezzRnr2HuwJYmr86v1KrWY5rFZPzY+c+PFO8eivuUZhYns6zmZLqbT6hO45Zq5k1ByXNH1JcELYte/zRxsZwrbYy8emNueWGk8e6jMrk5Stn3xvUX+l+3JA2HkABMtUTijW2drQFOAAilvLzxYXB8flMuSZKK8NDNxLZsqq+2MKBIeeVpcVFtYbl5fTgRN70Bl7qXkpcO/3plHLplpfHTr3amzdds2ZarqhVssPn//YHv7g8k/dFQ15ZyedKpibu1xlJAHcsy6yZlsNrhaXJ4U/eGXQiV2M6urXUYg0TUiQS3C0xRGAoaoXF4ctvffBpotT/vad0j4fBV+sOh4hOJbc0cubT8xIOhkIhpbKQLNWmyoy99ETQG/VrTJblSNvAgf62CJ8dvp2sFU3bsU2zMH7l/JnZ2vVIOKybqVyucCtdVRv/3hO2bVtm1XS45PFqqoamhT7ZH4vHwwFlKnHzyuxiU2N79z5pLnH99LtXVtpiJ97gTIaNIFHSvcHG9rY2ya9yjuhay0uLidmZ6cUqOuWxwRuT80vo+c9fAMYYQimdSmrMYrnU9fFESm+If02ZuzV48crkuUu6t7O3tf1Ab7Vimo7tWObs4Pvvv/XTMyOWFmgIx1Rftiy7gq32f9iGABCubZlWTbVdq5zL3D7z6YV6LqmVheVSbaqMkeCzIQGIyIRj5YbOXPntr9+bazl10BfSvmI93hCAu+WV0atXP57OGdGGoFQrlVLZ8URab/xeoxryarosKr5o+96DBxt4anZiYSbrmrZjm+mpkesfnVuQG1piilWxVparE1mj4R8HQ9yxa5Zp2ULVVcMvmY4QkhEKxxsaPBPXJgYvjMhy1/EjQXdm8MPz5xPmkX02qPJGR1pkshFsaG5p64jrLhfIIDk1mpy+OZFUJbucmrt+ayyHjvzKAURkaNdqqflpNeTmZ5K3Z13JeKGvPDVy8Tfni/5L1xrk+GOxnnLFMmuWwyG3OHr17X/3w9OLFkQbIno+W7Srzn0qf0QhXG6ZplmzHJe7uZmbNy8MTl+IxuIeXirmlt3RBdYQf6NZSAwQEatLEzem3vzl1ZJ6ZN9LmqRJ9ypj5POFiHYpvTD02zM3fcrNcNAvleaSJXfW0dgzhzRf1KegoijRjv2Hu2NeJ3Hz1pJZs2zHrlWWRi5+ci6Dt8JBn1ZNpnPVkZzlbXhjn2XZZq3GbSFFfKokC9OCsBqIx6Newxm5dnlqVDvc1d0eK9++df7tSxOtj+99BUHaXBUoui/c2N7WjroMgK5VSGYmpmZnljOSVU0P3xhdnLP8//T1Ls4QEQoryaTiVJxM+sbUdFYJ/f3u1OiVK6cXy9cNOb7v+N7evbJZq5mybVvVmavv/eKtty9PCU8wGuCeSLaicrHavpQb+eijX/3y55dyLmpBaejW2PRUzv1Hf9Kemx66efZGQvYZDZ3RPd6TR9q83o3hrhRvINrU2d0VUFeaAorMqjWrYlVcm3vDoZau/u5OGbHeV8KqrL8Uyuz84shH3//+z6+OFP1RuWZN3V6s2PbrLz3TRdHvl9dOiX0BhRDcrZQdtSV84Kl9oZXrPz174/bkQvnxg4f27dt17fpUSm06dOrlEy1s6dLczcRMtWq5QkjCrVYdOxAcOHKoWRn6ycc3xubml9LFDte2atWqhXqo8/Bje69eHEtWY70Hn3r6hd781IW5985NzI9OrlQi5vTc8qITO9nY0RbaeBMEgbv52Rsf/Rrnr6ncNaLx3oHj7a17n3slDijh3IU3337/yu2hGwcPxpEDSlKw9fAzLx5RF959+/3zk5O3p1faJMc2zVrJ0fac2Le7J3TzxlS1atmOWa4s3750ZWzG7Dr5+kun+gLBQEtjRGF4vwBVCMeqVqtV2+VCCNdZz6XgyvWfnr0xPLWQLrR6ERGYWyjM3/zk/NSyaDv1xIHe1pAB3P0CTt8fmnCqlsO18Mn9J9tx8MNLn8wuJNLm1w7ufXr/9dNjK9Wm3seeeeF4t3Peyk9cSlmWzQG4YztO3vYfGDix3zt34+y715anxxaKx8OWbVarVVtuGNjdXh29fDWRaWg9/MzzT8cC3Lj5zuXpycTCYnLWWJqbnqyq8abujpCuSiAcAABAhHIycf03fws3QVUU9PccPtoe6j32pNZ9RMHS1IX3fvTJ1PWro8snW12GAL6WPYdeODWAg2d++Nux27cmk0+3WZw7lYzZ1Ltr99EjDd7ytFmrWaZl52dv3xy8PivFnnr6jVf2xHU92ObXpfv8VsHV2NetarbrChBu1XLrudQBgx9c+mRuYWYuWQ74AREcp7Iw9On1wXHTs3f/oSN9TcZXMt7hrmMXyyJ+uOuJ3khm6MxPR5dH5tL6kb4jA90Xh28XY027T77w9T539Jw7eHUub1quEDJ3nVKFxwOdJw7Hy5mzPzy9NJxYLJY117aqTtXknubWPna89/yVZNnfe/TJF08e8QcLizOfnk/OTSdW+vXJ0flyxejpbIpGDOQgJIB6P4PK4uBHb7HJsF8WPNS5Z393R8veE2/4DwQlK3X93f/03rXLt8aOH+5qBCGE4g33nPja073VqZ//+Mzo0GRiT8QruFUs21o4MnDqYFfIuVmrVquWI6qp5clbF24my91PvvqNJ3eH0N/UHvdIQvB7vRQFyLlrm1WzarpcAOO2YxdN796mvUd7YPzG259OJsbmc1bYQQSQRH5p7NbypZmy9/BjTx3tjhoa0rAPfywIArhTtVymRZ86cqKxdv43Fy7OzE8XnGdP7H9q7/VPpnPQOvDE80/3x8un88mJG5OW7XAQ3DVtnmXBw3uP9yvjl878dnhxemqpvFu2LLNa4a7WtGdvNH3rys25amPXsadfPK6JheIH709OjycW0gux9OzsZF41jnR1RvVNnZ+QQWlp/PKv/6Z6RSiyJod3HT4UaTn2zEs9Juj5mQvv/+KX07fPD80911zvjBVoP3j0+aOd5Qsf/+Tc9NBgItXMTMcxM3k8uL/nwLE+w5q0KtWabJpmdurW9Vu3lo3255977dmeBk8g2GqoEgrgAOXF4Ws3Lo4UvE888+KRfuvqW9+/cfvMtYknQ7rg3CwUMdbYsu/Zo60+VbqjZ66oD+NgOxYIl9XHfsD6IzrhchdXu7yL1bxGZE4lOzNy/vLoktT20hvPRmeGTn986fpQ195jz3QZ92xnIH9sOyb2BQAAIdRQ874nvvXdk3im/P7V0aTLJcMT8oQDhsJUxRttaG9vZyLhV1RWW39JQPZGO0++9o3nYjn+wbXxpaoQfL3gy6oWiPnCHl2TJI8/0hRv7gzXlnp3KbdvTQ0nkoHsVC5ttu1ua+9q2JTViIKXlxODl4uzXsbdYOcuaHqs98ChV/sAOBMj1s3rg5em3HyhKAIcJEkJ9R46cfI57fbQhavnZ3m1aoIPUJK1yN5nvv6nbzzWMjl7+1OBgODYbqmQ5wqG+/YePfHE8Xbf+pBMDxiAYvNrMGqoed+T3/ruY3C6/N7VsaTL61tAqK7Mjpx9p5CUwidffHp/R5NP4oL/wU/TF0AASpqn68Rrr77eVrSGpq7MZAWTtECkKeyTJRk9wYaWts5Oayrk04GtP8iXVGg//vQrrz+jnC1NnLm+xFzXhfogOAiyNxQIhHyGxFTNG4s3tTUZZnl/u/fm9OTi4tgNNzkzafsDXXu7I7omi7V8QwZmPjl19bdFj2CKh8Wchl3tHQdOte9BWS4vXLfmPjw7l8nlC26DDQAQ7hg4cOrFYxVn/jcfT+VL5bLrOAAAkb6Tz3z7e9/oXx759aeSAAQQ5WLJdKqe1pb+Y08891i8/gNQPEw7/XpRAEn1dD3+2muvteWtwakrM3ng3EUAFHYtN3ruTH6p4Dnw1PHHHusKbD9ewlcAIno7Dj33wreOBK5WJn8+VuQAWiCshgK6KskeI9TY0tnuFkeDBpMKALB6e1Sb+g49/61vNoydm/7phTTnHOqvtgKApHl84WgkoMqyqQUiTW3xeLi/u7WlpTKSmxoaTYZHphxH39vfEY35mIC1H48onFomcfN8eUpTGfDWx+Ro58ET+57oOSxhtbAkz/7qwsRioVKuVAGFAM0X3nX82cf7U54Lv74+VTVNy1KEEIqvYfepN/702wcN8/RvJCEQEWrVWrmcl4K+1gOPPfHEgQavwvlDXbmb3nEEhNjA40++8Y2DqTcLZ89PV13XWX1vrzZ3/dai62TDHc8+8crBJr92ZzxBvmgCZE+w98mvv/FSaDZzdexmkgtJ1oPRppBXkmXwhpraWjubisN+r7qxDsoatJ96/tWXjprvLd8+N1RAl7vrPWFkXziEQa8uSa7hb4g3d/hcdWBf6MOlxcnFuSFpeXkmFQoe372r2VCljbYWRKiml8Yu/zbj4Sj7tFbW0t91/FTvPmCMzd905q7/Ym4ikys6rg8AAKI9+w89+eLu+fT0++dmrVK1InSOiL7Oo197/TtvPO+5fW6GYb0qK5cLpmt6ezoGjj/53OGIELhavQmAYj5dLOXlxoGB4y8+t68sbv50OJtKZU0zjAigxPtOvvjtb377UFTiHNb7fSEUF8ZufPSmequQGr2+ULaNvoaQp5y8b04jWJZZy6ZMcL0KL5Ut27RF0SrlcqU/+Fklf0A7KvYVAMiQSQwFv9dT3+0qbQQmIa6NPXRP9ZdclYAv1r6rFYYmb9++qC/PFEvR3S1tzU26ALERXSLzNu06curo7ibdFXoo2hFldipxdWY+XSg7CzemV4qAkU3721STrCeUSZKvIRrxGxps6bX5kD80V3/QbvsVQyYhwtZcQgSrXM4uLFTAaGmKRzyail/Ze5wARJQkBvc8q3e9qlsP/xkyAPaAroz1XxKyrDR098eDg9cWJq9cnbPm8mH/rn29cUVXNtYXHPRQc+9jXzvWgpqqgKe9I4yVueHE9GKqUkpNDyYKtgOrHbVh8x/rw3wAAIA/FI7GIjouwZ0F4O7BqbZP8baHhIgS3JVLWH/Jf3mlXBENDcFYJKiIr1aHh00QgEkMGaIQ94gHt3aLXl0N8a6xS7fben3AFa0x3tLUFrkwMXP92sXG23nG+vs644GAzIW70cdW1mM9R58+0hUJyIL72/qa1Eo6MTk1k6yU85mRyVzFhCjeXS1sGZRU1rVgPBbSJMfcrvw+RHrveVCMMQS25bpAAAA3t5IX3NK6uqLxqMGkL3+n7x2AITKUNtUXALC5atjuVocIErJ6ZHm/bSMigqSrgba+Ht+F5cTMzaup7NKSGuvd1dvmk2W2cbMTAoxY68DjXzvYCKqisEBXk8dMj1wdWkjl7fTM9cSK6wrc1Nd8owfQ+j8QwIiEw9GQTzK3uRI3pWt9dcEFCIEIjCEiYzICcs5Xhw9U/b5QLOKX7jrK8vLErdPFBV04jhPqPXD8uf27wremXQ6Ia6NG1I9/81sSq2PxuHZhcfQq+hl4m/o72lvDKpAvsR0V+36OhBCuWatUypWa3xts694Tk8ZHr7xTK5SqvqNt7S0Nvi3VDjAp0Lb31PNff3YgwAUwyS1mxz9681//xw/GK+jTsZTNQjC6sW0hXMc1hWk5NUAdN8bAvzN8RQTGJC6EY9mWbdum7YJAWd468qYQnHPHcRyBjD307BxCgC8W7+zbvXT9xtLtG4mVvo5o3PiKdff9/CFw1zErpVLF9HmN1j17G8Jjo4NXiyhsT9eegb5WQ1EB1mMsIcDT0Lbv2W9/fR/zqUIgutWJKz/7wd/+5NxYTfV7eSlrcd+Wwam4a9mWWTNBcIlJ69XxXTELYwwQHcu1LNu2bSEAZFnespQQgnPuutxxhACOD/ljRgBT9Ej3/qbUxPTi2OTY5MyJ1l0eeq/5TpwLq1Ypl6s11x9rbe/o0a5dG77w7kLKYXt2dzUHvKoAd+M1AKZ6GgdOfe21xzriGueCyebc8Olf/ru/emuw6vV5oZIuVu8Yfd9xHLtWNV3HZauDKdbrhDtLAiJjksu5ZVm249g14coosc1DtAgBgrvcdRzHcUGS6yOaPfAIBQCAr6O/VcfSyFxydPh2dl+wSdYp/H10uY5dq5RKlUhYifceaA8Mnp+4cNmxTNF6rLOvPaxITIj1N0wEB19z16Hnv/2N3ajLgMIxly+9/eO//eHHUwXF8LNyyhXeTaVaCNd1LNOyTAuEkBmD9frtznSs1W+OZVm2tVq/rQ5jo8gySpJj22a1UrMq1ZoQrqLImy+R7X7i6eHWrgPH9zWpqq+xo3/3/r5mX2JSAELNdCqVsu0YTAjXdVHZVL4RkSEDWQu2H3/hud3NMcm01UhjaxSow8OX2KMe+wrOOQdef62b840pZYRY+2LtH3zLV6sjZtanVlr9ZnWdtS+gPpcRomJ4FIbVxfEb5y60a0cO9AeaewYi0sTI0hKX43tampti3i0/uFcTBYCMMRCAaFbM5clb8/ls8MDXnutUh89/cqFY763Aues6ldTs6Mh589bsSkYNtDdE/VgV3N2YH0esHYGkKMFYo5eNZqcnhm5exzmvFgu39HVGmCyvLwjVlZnE7WvX07ZguqGrhu249alq7p1LQgjugPA3Nh16bqAy/P7kxx+cP9zWEN7bIMNXo2df/chw7WDc+gkXd519zjfN9yUE58CxPpgr3ygyYtNKa1nGBUiqpqqam09OXzt7NmA9fqqroWtPT/TMzcGRJYRwU6i3t12X611ucWP7nAtkiIwxLgS4pdT8zPx0xhM7+thTA+7IL98bsV3OV09GJbswd/sKy96eSDOMNMdDqia5br1YbjpOBwB9oUjAE7CSK5OD1y6yBkU1Gvb0tRiGAuuH4FQL6bnRwZt5XWIoGw0dZQu4gPWy4K5nzMYBCyGE66KqNx5+areknr40cvXchUMDTUfjPvkrEf1unLwtF/vq74r1GcrurBXEpuPn3OWwnjHu5pJQzzyUZNXwSE4yPXbt/Cdev3aws6mtta1LO3t5qWSq4YFdnY1+r7bR0Ly27/p7hIwBCMBKJrOQuJlm0t4TLxxhiV99dGXBdddGD7WqpWTi5q3K/OBMuSy1h0MBnzzLubup9PJ6YeaazxsMxZXq4uLIravNPIJacHdbSzweWNs3F45dy82NjNwqFb0OZ6GIt2htOv6Nqm9LVoAQnLuO7d+9a6/fxyZ+PX3+/TPHdr2yuzWo0I/iL9TmM7Tp7gR3lOP1m8/m+m2j8G7Ub3zT5b5aIwqQNE1VVCe7OHn53DmffeJYU8PuA03+28OzKyZ4usLNu9oj8ubQdz1RWG9+BXCFm5mfml+aYW2HTx44okx8/JORnMP52tVTTs/ODF8qT48nsorc1hINSjV03bUrdP06cYExXygW0L21xcWJwWuX7KjqMRr29jcpGmMCgtHmhliDmFocvXYm5Ng3Jx2QelrjHo/kuhuV2h3554Kvte/wi3/2rT0KY0xSFFVh3B8Nh0K+/OzijQu/7cMm5qBjuQ37u6D+Y5G7XFUMb6TJqyyYlbLjuNyxixYGXKZ/gaeffGaPdOyLyFRfMBgKBgxNlmXN6w9FKgGPxpCB6gkGQ8GAR5MZoGr4g+Ga6tNkRERZ8wWDEcnv0VRF0n2hSMjj02XGUNaDgVBQ9emKorpGIBiCoCErqhbpPtjXPjk3uDD26dkzRqDp8HFfV+++mG8qs1Izutvbm+MRJmC9f6ei+UPBMPPrioRrD9YVj9a0a19zLLcwM3Q+p1k1FgoH/bqm6N5QKOirJD791Y8uu6W8aD5+8OjJ/hZ9bNIfCoUCHlViCKjohj8cNn0ePeht2HPyqe7Emflb7/8k8QlG9jz7/Bvt7WEPAgCy+mFPT539OHXjosRdtbm5/8TrR2RvKBxRfbqiKFtySTPWcklRDV8wENIbGlv6Dj792Ejm+tS1ocTx7u54k/GV+HGLquEPhiLMbyiyzDVfJBTS/LosIyqGzx8Oc7+hMmSS5g2FQsrqRFZM1b3BQIj5DZVJ2npZQpA0wx8KV/0+TZZUwxcMRXSvoTBvQ3vXrn09o4OpkU8/duX4/tZIS0/vrnjr4NhiOhCOdA10+5RNc4Ix1eMLBkIBnyELXB1xDNHX2NbetqtxKTE/eCHPTPT7gkGPynRPIBgO8sUb5342ftkulWMdu5598kDcV/P4/MEA9+kaE4CSovtDoZDhNfRA995jew4kztycOP2Tv7rgbeje/0pTW4PmVSVXAKqGEYj63dz8pz/+62syCEnzDjz3D3Y7vmAoUPb6NFVWNV8kFNL9uiwhKobfHw6D39AURTECwRALRGL9jz3trGSXr89ODY0t7on1+TcPX/ElJZiiGIFwiAW8GmOy6g0EImW/oSqIsmr4I6FQyKsxhkIz/MFwyO/TFQREWTMC4aAV8GiKrBj+YCTMfIaCyBTNFwmFPH5dkVTdGwj5q36vyjRfuLnv6O5YbiR56/xv5FhPa+zpptbOrt7A9cW0rIV297QH/J71+BCZohnBSIj7DZmtzUiDwhcNt/QejI5OJIfOf6q6KHtiQZ+uKKrhDUW8S9WJD3+wJFvlmtHw5BMH9/W0zU/5QpFgcLUiY5o/EAyH/IaqNzXv2v/44zd+PTr84Q9mzqtyx7P/6BvBSGNAFgDIVCMQ9WnllYs/+umgokjC8R04caKnX/cFQiHZrysMme4PhIKSV9cYMEX3BMMhzW8okqL5/MFI0B9o79vb7T1x66eTi1euTZ3siAZUeiL0xUEE2fAFQgHh96iMyarmDwVDIZ8mMWT1K1f4dBWRybo3HAoJny4zXK9//D5dZbLuC4ZCZb+uygwV3RsIh9Hv1WRZ8fhDoYjs0VXZ39TT07One3o0O/jpadAaDzQe6BjY3RIbHE3OQkusuae7mW3q94+S5vOHAqGAV5ME1vtNIZOi7T2tbb2zs8lbV88rNTMcCIa9msxUTzAYCS5PXzzzoxvMLFZbene/8MS+Bu+U3x8Iu35DlVEIJiuGPxIO+nxeI9Rx6OSem8nLI7fe/9HsaV/z3oOvt3fGwrqCApTWAycPTixNnp66+ZulUVG1G9qOPXu4NxZM6T5/OGz7dHXruPSy5veHAuFIKBQMBAIyAl+d4qlhz+HjRydnP7yZ+OQn/+a6IlzFE+x6OR7qUT2+QDis+jQ9GGs98PQLNxc+nrz8y18MaQq4vn0vPRvu3tN095yM5MsCS6a193/866JprXddczjf3xj9v79w4khzVGZ/nBdYBIhyuby0vFwqle7d/ez+EN1adWVqaDZXUht3d0U8lZXE1FLN29ja2xXG9MLw7HJJbRzoaolAcWZ6atFi4Za+/gYvVtOjY3MZW2nqbAlhbSUxnZeDrf09UdVeHppKltxgT1eDwbMzt5OOp6FrX2fIg+XF6Zn55VwZAtHm9q7ekJyZuPXzf/s//d2FVPd3/9k/+dY3H2uW67/BkTu1/PLo2EIBjNbu9pZ4UK13w+N2LZ+anp5LFSqgazIHF9VQc0uHwZfm5pdLFdvlgIrhDzY0t7REDSuzODaZNLVoT39rLCgXJufm5xdqgYb27p6oYmbn5uaT6aJpOcwbb2nr6mryygzRtau5meHEcqFkr/ak4MzjDcW7mvjKXDpnBzp6414nszC5VPM2tvV1hSC9MDy7XFYbd3eFpdxKYionxeOdu2J8MTG1lLN9rb2dLQ0B/aE6lN51ioUwDKOjvcPQH/D72LKsVDq1kkr9DntZ2xmHWioxNTufxmBbZ1sMKrO3Z/PM27a3q1Gz5ifm5rN2uK2tpynIMzODM1nHHx/obG7wi+T07PRkBhvibd0Nzsz4fK6oNvV3NsVYZiaRWLS8oebOdjU7O53MOqGOvraWMKsszc/OL6dr6Am2d/U1RTyYH3zzR//+xz+8Htj/9T//7/6L55oVkFZzgFeSUzPTswW1salrT2sA5Hp1LKxyemF+djFZ5KgoGjo2eBp6+4JOMru0uJK3bSFQUoxgvKG5pSWkVReGp5fSdnBXa1tnq5rPLU/fmivxQMeezoiP5xbn55YzpYoFsjfc2N3fGTE0CQSAlZ2en5ufzTqrk70JZEqotT8q5TOpuarS0tHSrNhzt2fz0mouLUzMzmWdcFtzU1DJjk+mHSna09eolhdm5pYqSrytras1pj9EB9h7i0Qi8YYGTb3HfM0AAGA7diqVSmcyjuv+TrtiWMuuLEyNJB0l0r63TSvPJmZXqmpLT3tbSM7PTY+slNVox/72iMjOT8wtFPVIW1tPt1/kVhZHJ5O2EenqiWF6aX4xg9HWzp4WtZyeGZopyr6W3V2e8sLC3ELV19LR2RvX3Epmbmp2qVBz5Xh7b1tzo2KOnH7v+//hf/0o3/j8P/8//9On9rb40BUAgMyupJfnRqcyEGjo6W+JeHRJANSnvEgtTk8vlWyHGTozHdcbbu9oijjl+enZZMXiggNTPKFwY2tL3MDM/Pz0ckGNtfX1xQ3urIyMzefLenN3R1tcq2aXZ+eXs7mKK0CJdPV3NMdCGgIyu7iyPD0ynbGdtcdgXI7EG0NRozI3U+Sepp6+BpYam1vM2KH+tvbGgLk4PzGT5t74rl1Bc35hMVnU2tpbY0FrOTGZLCmhtt5dTUFd/T1uHcFgsLO94z41P+e8VCotJZcrlcrveoN4hHAHCvO3E0tLlr+9q6tVL68khheqhr99T1dMKs+Mzy8VRKyjtSvut5KJW/MFCDbv62oM6u7y5PT0bEFpbGrrCNWmx+YLVaN1T1dDgCenEzPLTqihpbVJSk8n0nmM9vS3NPqhuDA3t5DMmoov2t7V1xBUyrO/+ff/9m/e+ch67LW/9xf/4pv92voY0dwtLY1Pzy6U9daW7v4WP9QnvBBuOTc/N7u4krNlWVFkbguloWNvq16eW5pNpkuOKwRKmhFujDc1Nfqs7NTEXMoy2vtaW+NRN5Namh5aqEnRzr3tId3KLMzPJbOVqg2KP9a0q68jqKmsPiN5OZdaWphL5kqmIyneULyxpbUxBMXExNxi3o12tHW1xY2N+LcwNzy7uFw22lvae9qCm0uUaxbSK4tzS+li2RJCoOQJNHb0tnqr6fm52TQLtLT1doVYKbU4O7eYKZuuAFkPxFtbm5sa/RT7AiI2xRvj8fgfZe8Sw7eGp/6HDy8ly9X1mxMX4lBj9BGOfVeHK3W5EMCYBChEfU7j1bfdOOcCGJMYCsG5KwABmcwQgLuuEAKwPhmaKwQCSgwBBXfXZ0WsRwzIJIkhMiZcl7scJCZJErrV5OilH/4v/+svM+3f+T/+/W+cOtQgb8wmAII7nAMgMsY2z36EDLnjcgGMIQB3XJAkiTEG3F4daYFJsiRJKFy3/hQKAJmEiCjWeikgkyUJGYLrOPVHTYytv3uyad+bswkZAy4EcGQSwtq8t3fkEoIQ9QeyEmNQf9rDgclbD+GznJwvMvaFtRSvPnsD4JxzQCYxCdYyr35ogrucA0qMIUPga/1aGGPguhzq/VQQBV8vTChcLkAgSvXMrvfOBpQUCQUIsXLpr//mP/3irPP41/7iH/7lqbiy8c7j6kNpXi9GG28yIjIQruu6ApgkgetwAUySJIbcddf3KysScC5WO78AqxcnIVxenw+OSUxiDMF1Xdfl9VXY+u8UsdGzZQMyhvUB2+uP3ddziUG9TwxgvTfpWuFnKDgXoj7/siSx3ysO+UJi3/oTfpfXM2TjuKT6Wa3/g0kMgXO3XizWin895xlDEFCfVxwYY/XeQoDIGAouRH2SacYYQ0Th2q4ASZIAGTrpwXd+9Z/+4w/Hml74L//FXzzeETdwo1rg3F2tgyS20Rex/v6s67gCUJLArZ9ZSZZACO44vL6MrMgMULiO6woXBNZLMgrucAH1Y2MSQ0Dgdn1eN0liuD58yXZFoT4rev26YPXTXy8ViABcrH2Bq/0vGDJkKITrugCAsvz7lQSKfT8bIQC463IBDBljWK/EgDEJEWD9ymWMAeeuWL2mcbV+44CM4cY5ltha9YaAKCF36+WMSav1G3dtjkySJeTCKd7++b/66x9eS+/97p/9xTde6Ta2vFnH61PgIGNb6jeGwnVdLhAZQ+64ApnEmMTAqddlAChJsiwB5/UFhai/j8pg88XLmCQBd7jruqt3x83dzOsXpOs4rkCUZFWC9cqyfrlumXitHikIZPXLfTOs3wnc+vWG9esPBHfq9S6yemauX13AJLl+FujBx5c49n20+zwAoLQ6u6IAQFDW/waUZEle+wIlSapP/SUAACRJQdz416a/ZWXT5xsbq9/7JUUGIQQXIEDxBLufePXb+q4ndreH1U3DCSECSookb+xtneACmSTXn32DrCr1nlccUJZXz5MQgrv1+7G06WAAJWkjmfXZy6TVF9w2vc67ad9b9ivEloOU7pFLIEm4vkNZuesV4i83ZJK0nrkAkiTJ6we5KfNWc2jtyBiTNo5a3lJ+lI0io2wuCgIAZFmGtcnlHfR2Dpx6rTl88NBAVLtjvATGNiVknRAcACVZARBCoKxI9f4QAlCSFWltofotCbYeGKIkKfJqeupFASVFkeCO04Vs9bC37lhAvcSv/nVXLt1VRlCSEOWvUllAZKhI0kb6N59VafPBb64GELdccRuLrdYeq+vUB8xY65kogMmrp0ZwEOBt6jj8yncOtB/b3xjQpC3VApPkzRfhqtWtyvX6AmR5vSQArJ5VABBccBCAjMmbEra1jK52qJFlZW27G4+mtykKGyVhPTc2nf0t9QVuyoqNfCVfIESA+mW/uRLbVNdtvnIVvKN+W//npntlvTTWP2d31m8oK6v1mxAIWuPBEy91efYePdTquWMUhnrJurt+W71BAYAQQlaU+gJc1Ft36sus1W9sS/UMWy5ewd36bz8FttzpVveymtb6l+sB/Obc2JRUSZJw+3d9Vwc1Xb/eVne0pd4VQmxcXSCEoMD3y+6Rjn0BYGtFvKVg3/sf917pnhvb/IEQoPgae5/+VjdKiqbI0l3jJt3n5rD+1X139YAk328f23/+ULn0wCR92f2+ZeFei92zKIAAwED3yac6TjBFUbZ9DHzPnNwoT/dO3AOTfN9d3OPzz3rEX8GycO+ifJ9C/pkvkq3/Fuhv2Xv8jYFjTFZ1RcKHrxY2VQoPXPwBZ4aqhUfXwxXqP2j9BoB6y+GXGg+CpCqK8hB1092fP7gueUD1dv9S9/DXwANK7zbfPmxFS76EHv3Y94+BMUnVvTS8H0EASdEN6vZFACRZlWSqFcijAxEVjao38hXEHrwIIYQQQgghjwSKfQkhhBBCyE5BsS8hhBBCCNkpKPYlhBBCCCE7BcW+hBBCCCFkp6DYlxBCCCGE7BRf6jHOhLhzuGryyPhMJ5dKwk7wkKdYrPm800P+WD5TSfi8E0MIefR8WWNfAbIk+zxeSZIQ8MHLk68aAUJVVcYe/OSBMWboRjAQ/AJSRf6IDN144Py0iKhresAfcDmneuFR5fF47r8AIsqy7PP5FEWhGwQhX2aq+mUc1fxLGvsioq7rDQ0N9LP+EYaI0uoMlvcjy3IoGPL7/V9AksgfESI+8LeQxKRAIECF4dH2MD+BPB6Pqqp0gyDkS+6Bl/MfxZc09q2TZZmqtkfYw18STGLIvozXD/kDQsQHXu/1Bj+qFh5tD1kzUEkg5MuPYt/fxZcz18gXj0rCTvCQZ5kKA6mjkkAI+R3QOA+EEEIIIWSnoNiXEEIIIYTsFBT7EkIIIYSQnYJiX0IIIYQQslNQ7EsIIYQQQnYKin0JIYQQQshOQbEvIYQQQgjZKSj2JYQQQgghOwXFvoQQQgghZKeg2JcQQgghhOwUFPsSQgghhJCdgmJfQgghhBCyU1DsSwghhBBCdgqKfQkhhBBCyE5BsS8hhBBCCNkpKPYlhBBCCCE7BcW+hBBCCCFkp6DYlxBCCCGE7BQU+xJCCCGEkJ2CYl9CCCGEELJTUOxLCCGEEEJ2Cop9CSGEEELITkGxLyGEEEII2Sko9iWEEEIIITsFxb6EEEIIIWSnoNiXEEIIIYTsFBT7EkIIIYSQnYJiX0IIIYQQslNQ7EsIIYQQQnYKin0JIYQQQshOQbEvIYQQQgjZKSj2JYQQQgghOwXFvoQQQgghZKeg2JcQQgghhOwUFPsSQgghhJCdgmJfQgghhBCyU1DsSwghhBBCdgqKfQkhhBBCyE5BsS8hhBBCCNkpKPYlhBBCCCE7BcW+hBBCCCFkp6DYlxBCCCGE7BQU+xJCCCGEkJ1CvtcXDIEhMkTxRSaHEEIIIYSQ3w9DRNz+q21iX0Ss2c5EtqBKkswo9iWEEEIIIV8lEuJ8ocw5vzsA3ib2ZQDpSu3NocnTHp3dK2YmhBBCCCHkSwkBFwvlquPCXaHs9u2+Jcu+MJ9EQKDQlxBCCCGEfNUIIVwuHqrdFwAEgM0FCOrvQAghhBBCvoLu0YR7z3fdcPV/hBBCCCGEPCJojDNCCCGEELJTUOxLCCGEEEJ2Cop9CSGEEELITkGxLyGEEEII2Sko9iWEEEIIITsFxb6EEEIIIWSnoNiXEEIIIYTsFBT7EkIIIYSQnYJiX0IIIYQQslNQ7EsIIYQQQnYKin0JIYQQQshOQbEvIYT8cQghhBB/7FQQQsjOIv+xE0AIITuRR5EavB6Hi5Vy1XLdP3ZyCCFkp6DYlxBCPncIAAD1Nl4hRNjQDrY0PNnZUrPdj6bmbiezZctiiOvLU2swIYR8Tij2JYSQL1TI0E51tXz3QP9TXS02561B349vjl1bSFYdFwAYBb6EEPJ5otiXEEI+d/VwFgHChvZ0T9ufH959rDUe0DQB4mu7Oz2KrMjs6nyyYNr8j5xSQgh5xFHsSwghXwQEaPB6nt3V+r2Duw+3xIOaIhAYYJPP80Jvm6ZIuiSfn10q1EyGIAA4Nf8SQsjngGJfQh5NdwRO+KDPP+uK97K5Y+vvuXe8x+f32st9knT3knfs+oEJ+53V9y4Agrp6sqPp7x3avb8p5tVkFwQDrO835DGe6GxxBZRt+9rCSsWy/3D7v6eHyb3759LdCzzMZj+PVbY9X/fa7B/w5BJCvooo9iXkESVW/we45V6PsHlYLRS4NRQQACg2RQ0bXyPAfQfkQti8qfUlEdaDDbGepK2fb032Wu8ABLGxJmyJZBDXUvqgEcIQYO0INxZGvCuk2/6QPxOx8f+IG0lf/VxC0CSpYjuXZpdvLqUkxM5I4LG2pqrtXJlfXi5VTMctmBYAyAzFHdtFEKsbXN+uuPO8ftbUPnhsta2noP6R2HJet80o3HqeN28NAEDAnUVuS+ZvXgPrXwIKcWdxEev/2f581TeJAsTaXhHX+p2I7dNNCNkxKPYl5JEihJBVrbO7++mYL66gAEBuzS8nP51YnuaSEml9rSfc65ERAAFqpfTw3MxHSccSq4FUb0fnsbZ4uyoQgLtWOjP/9lR2seI2trYfb43v97B7t6UJq1YcnZy+XAgd3B3fG9E0AQBo1zITc5PvLXELlH27eo43BKIyCADGrVQm9f7o8pzlOIgIKIzIkc6mJxsNDwAAt8zS7VvTFwu1lDd2vKP5iUbdAAAAx67MJSY/MUNdzfETUfX+VRgKp1wpn5t1u5v9HSFFqv8WcGtzqeTPx1JFxwXGWLT5hY6GY35l9dBcK5OZfTuRny9z9hAxkhBCkZhfVXyaqskSInIQtsMrll007c2Dl1Vs+9ZSaiqd4wCqxJ7obOkOBXO12i+Gp24tpWyXI2LFdmr2xiqI4FFkn6YasiLLgICuEDXbLVlmyXRczvHOHzYPbkMVQjDGets7TrbHW5R7N44iL+Uz1wdnr1pOBRlA6ERf02OtXk89D4E7duX20PTFbGVlLRFCSH4j/PSelj6/quEdWxYghOu6lVrxxvTirVQlDwhCqLq+q7vnqZg3LN2VEiGE4I7jFMq5oYX0zVS5DIggBKqeaMsr3eFd9WKMvJxPD01Ony1ATdR/oaHiCQw0xw/FjIgqKxIyQM5d23Gqljm/sjK8kktUqUMJITsXxb6EPFqEUFS1d2DvP9vbNKADAIBbvnL95lJiZQYUNdbzpyd7Xoup9Vlt7Pzc25cq19PLK/ZqA1lfd/dfPr7nCQ8AADiV0dHalaXCfNltaO34xqkD34vcbzacWmHhrVJyzm565fCh7/V4vfUPc4l3zk1+khScKUf37P3n+5p71Pri9tLsuJRNf3/Ryddb8bzRY3sP/rcHQyEAAFEtLf50OjmZqy17Gx7bf/C/2x8M1Ferps+5i9P55qcP7f9v+nzaA7LDTi/NO7nk4b19L/eFw/UYzS0NjgxPTGeu2K7DWFNH5/ee2PdnMaW+glPLXPx05eJMbvZBc/9wIXyq2hn2d4T87SF/3OvxaYrE0OFQte10pbqYLydy+elMIVezXAFlyylbTr1d1KPIy6WKxV3bFUuFSiJbcPla2y6iECAhxHxGdzjYHQ00+bxBXTdkiTG0XV4wzeViZTpXmM4W5vMl0+HrjbCI8DBzZUiM7e7u+ceP7zniuc9Szsrc1L8bXbxtOSVgGGh69tDh/2p/yLf6reBW5tfl9GK5nLRXW2hdIXuN2BvHj3691fBts0HhOk6lkr84Mv6jaxO/mStkhFA0fd++/f+n3bEOdbskCO44draQuZqY+cmVydMLuWUOXFY8se7vPL7r1aha329mfuT72ZlrJVFxgIHU1tJ6bFfX13tbT8a9DZqkSAwBBHdtxynXzPHpW393tZKYNKn5l5Adi2JfQh5BaxOG1WMDwTeeKm+ZSUzxhne1dhwPpD7MOhWOiCCE4Nsu+uCn5BtLb17vzr83tqGEQ5HneiPvZ5dzFXe1G8NGqsU9NiLWU/hQU6IJAG67+dlLqXhfezhcbzpmasTrO+FhIxUoonbA7+k0pLUV7GIxd3q8mCy5DLcJfevREhdCYqw95H+srelkR1N/Q7jRZ/hUVZUkxoALsF23YjuZSm0slb0ylzw7s5jIFMx6A7dY3ULJtKazhWLNrtq2EKu9CwSAENyvKX2x8KnO5qOt8e5IKGhohiRJEkrIHM5N1y2Z1nyhPLSUPj+7eHk2mapWQax35XioFs3NJ/reiwhRP+8S+Js8sZC2KVRGYHpjs+adZSK9tTvCpqJ3R+ZJsuIPRJ85oGjCShdufZhf3f49TyQyWdFikaYXfb4wCmEP/Wi5JkBs3claOkEAk5VA84tHD/7DPU17vbKyqVUcmaSqkqqqfTFPp5+CXkJ2NIp9CXk03Sew2fhK9nTFG7/TY1y9WSrVQLprsXtt5O5oBVHweji1uSvmXVvY/E/NGxzo7hkYzi1UKpW7FrjXiuvTQ4AQfGtCNp69r3fsFYILbrvViwv5Iz3mQUOTAACVgN97oFXSC1iGaJ8v0KKvhbl2LZVeeq9kJzmye7T6MkRDlTtD/m/t6/32/r7mgEeVJAAQAgQIwYUAlBgAYEfIf7A59rW+zreGJn52a2JwKVUybQ4gABzOE9nij26MmbazkC9xIQAAESRkPlV+orPlOwf7n+5q9etqvaOr63IBguHq4L8tfm9fQ+Txjubnetv/w6Wh307OLRZKpsvh4bo93Gm7Drr1E1r/0SQx3BX1dPnUzVnCmBqNhrzGCoB55/bW/+DcFdwViIgSYwwBAWU9eKgr/vjc1Mc3SmJraQHBXS6c1bAWZQkZICJKmv9oX9vL+eTbybni3XtZ+z9Z0Xv27fl6X/Nh39ZbWz1QRgTgtUq1VKx91hwihDxKKPYlZCdDjy/Y39PdNHp7qbre6fdBBHdtcylfzTt8fTBaZKJSKM5VuCUe+lEyU6Lh2BstxmC+Mmk+oIPBlkQDCLOSzGSHlyxVgGCS4fV2eBRtdcduuVhZKVklBAZ2JlNKOW5qNj2dLOXiWpQBAGqa3tjolcct0MIxvx5YjfqFWS0lFmZXbMtG3LZyRECfqhxvb/zW/t4XejsiHh0ElEw7U60ValbZsl3BJURdkQOaGvXoXlUJe/TvHOzvCAX+7vrIp4mFlUoVBHABS8VyplrlXFguF2uBb0vA+3J/x3cP7t4bj6iSZHNRssxMxSyaVtV2EEBizKvKIUMPezRdkvtjoX/x9JHuaODNW5PDy+mq4/4u/VgFt6xaolCrORtFgDF7JV1cdoUDKIHaY+iN2tYfR8givoaoNq+KmnPX64N13KrOZXJjJVdW9V2N0WZdUhAAwGsEQ/4osvJdK9jpbGE8Uy4IVBS9tSHc4VE8EgKAZAQ6grH9MHcZYLshkAUHyZCCr7eG+73y+meWZa6UannLdQFkWdZVdyFZXcz8DnlECHl0UOxLyI6GqqelofWbscRy2ZpzHnIlXs4nf/j+zXdXivn1eXgRuGvnCw5X7xEHbUPyeAMH+1paZ0szNct98PKre0IEN5P42afLn15hKIQbiOw5fOz/MRBpVuuNnubEraHvX576CBFAOI69UqrWpPmb6dapSjjqYwCgqJ7GaGtYrVRb/fGQXu+aDMJOZXJnh0uF2p3vkK3zqsrR1sY/PzTw7K7WkKFXbHs+Vx5cSt1YWplI55OlquU6CmMRj94dCRxoiu1vinWGA35NPdnRLDH0qcp74zOpclUIcDi3LXd9uAaFsY6g/9U9Xd/a19sfC8uSlKnWJtL5Gwsrt5LpmWwhW7MQwJCl5qCvLxo60Bzb2xht8ntbAr439vQojP1QiKHldH1yuM+G2+nlxP/to9GJfE1ef78PhWPZOcspIVOlWKvHF1EBALgQAkBCBETV4zugap8gJO7Rd9Yxs2dHr/+rmzmPL/SXLz73rVZvRAIAQEmSpe3uPtwcn5r8/52buO5yxeM7dPzEfzvQNOBBAABZjeiePYg37nkYiqLEd/m14GrPbRBWcWRi5F9dmBkp2Q4iQ8nr17RKebEIQJ19CdnBKPYlZIeTff7os/uafpqpzWSsh1yHu/ZSNjeynMuwLUEiF3pM+QxjbzHFaGnpeD00u5Axxz5LooVTTZbMdF6A4I4ta1XXWR/xCkSlVJ5fSg8xXB95jUH1wkphsGAd8+kIALIa9EeOK3IqarR6ldUmZ7u6kE//puAWOW47wgNDaA/5Xu7vONnRFDb0muMML6XfHJq8OLs4ly8VTdt0OBecIaoyu7GY+iSxeLy18dXdXY91NIUN7VhrI0PmcP7e2Ey6agIAIiJgvcNDg8fzyu6uP9nXuzsWUWW2XKp+PDn3m9HpwaVUtlorWbbNOQIwZMZK5vLc8ieJhad7Wr8+0N3XEGkN+F/o7VguVVbK1ZlccZukPyg7bbs6nsoOZSrKxpEjICAiIGPhSDxgBCUAgIpllUynwWdIDJlm9AXlJk1MmtvnmBBOoVKaTOW8NqbM9XO0aQd3rVGtVhezhUnL4V6nkqn+I4evvXOIMkMdALdt2RYgZMai/pAu66sf8WJ+5cbY8Cdz5XlTMAQAlFKSjACf/dcBIeRRQrEvITudrHk6Ojqe8iUXMubDPzFniBJj0pbYV2z7NPq+JK8v+txA5J1sefSzPa1HhighggDBUNoaRCEiY0zaCMeE4CI9nZ3aVUw16w0IgJLHE3yiKVaOe5vXHuVXSrmppbl513Xv0SjoVZXHO5uf6Gxu8BmuEDcXU399efj05FyqXK2PZSYxFvFomiRnqrWVciVdqaZK1blCyXTdZ3rafJpypLVBkVCT5J8PT2aqJtabUYXoDPn/7GD/G3u6+xoiuiwlS5V3RxI/uDEyspIt1CwE8KhKk9+br5mFmlUwecm0V8rVZLlSqJn/+Pi+nmioLeh/pqdtMpOfz5fchxnr4a78lNjqCd36ueAMlbgvEtC8AABuuVJdzNqaRw8yJsuetiY1EkSxfM92VESUGDJ82KcBiFgvWgKxJuCOPhz3OzCGYEiytPGKomma2Wy5JpCtlxDObWrxJWTHe/gudoSQRxRKPn/D0+3eNh/jv0vY9HuRZa2ju31/2NfwOe4aETgWl8fT6ZFKfS9M0f19Ha17Yt5gvQVA2CuZ3FCiYDnbdFiuvykVMYxTHc1dkaDCpMl07me3Jj4cn1kolCzO6xFbe8j/dHfb0ba4V1HqUzKkKtXzM4v/8crw+6PTpZrlU9UjrY1/dqjv8Y5mnyqDEAygOxL41v7e7x7qH4hHVYklS5WfD01+//rItYWVfM0EAEAIGupTXS2nOpsbfUa9Y4fl8qlM/u2RxFu3JhYLJVWW9sZjx1ubDEX+Q8Z2AhhiV0hvMuo9dd1qvrY8U8s6ggMwpkSjYZ/PuM+QG0IIvjqSw0a6XMc0bfNhZib5rKnd+k8UAvGO6Tk+6zYJIY8cavclhKCseffubt0/m6/yhx0iy+XcdrktNgbWepiZILbBZG+o/fn2mRu/Q6vxZ4LFK6nMuWTtZLehAMqK0dLV6voN7+pYx6XJVOZMCqxtx+cSoMpsVyzY1xD2aUqxZp2ZWvjl7alUuVrvrysz1hLwfmNvz8n25ivzyUtzSVjt0gA1x/14aq7mOIBwqqslqGsyY5osIYIsse5w4Fv7er+9v7c3GrI5n84U3h+f+durI7eSKb46NRkwQF2WDrY0xL2eRp/3nZFEslwRIFwBc7nSD66P9sbCEY8R9eq7YqEGr1G1HUeIz3Q2hBC2yy2Xw6b1EFFCVNFzJGC0aAwAQDjFXCmx6MQs0aqDjOj3RWOazwPVbfuKM8mzq6n92weiuid4MKgYq40tPJcvJFPZbWNfIYTLueVywbnGYHOL/hf+u4wQ8mii2JeQHaveIMcYAqISjbY/HZ8b0/mDhn0FAFR0z97u9q8FI8W1R9mMu4VK/uKS9TCj7gIAF4ILITFEQFC8B3fF99mO9HkGv4gwv1Qcns9nO40YA0liwUgA2OpQZtVSbiq1PC64A9uM68tBGLK8Nx4N6ioXMJnJX55fXsyX6umVGe6KBl/q6/jW/l1BTbu+uCKE4FwIFPXw1wW4urCiSiMF024N+D6cnD0/s2g6Tl80/PpA9zf29XRFAjbnM9niu6OJn9wcH01nNo9hjAAgUJWkI63xBq/Bhfhoam42V0QAV4hEtnBpbnlfU3RXNBTU1ZaAd65QBsf5DHMeI/N4g8/1du4qmdLqWgiumSpkbqRchrEurydSn0fCdQpmcdy2u0zhCgBExePv0/RuIca2a1GV9dDR3n1dHYLJWoNf8zIA4Zbyyxcm5i4uVh0Od7ZRIwsFg4e6W1WHM8Pb3+hrUNbnhuY110kKcKnllhDy+6HYl5AdyylbTtlSY14mI6pG8LH+sCvUh4hdmSfQ+N3nG7693kaMqFjFocnBf/jr6fLDNc45tl0yLdnj9UoggRSNtR+JlEry59qyh5hNLS8mx6rxsIcxRFnamNIimc6OzWWde3X1FaBKrDPk96oKAAwn0yPJbD2tqsQ6w4Fv7+/75r5dnWF/qlz1a0qjz1sfU7Zi21Xb5UJUbefi7NJKuRr16MPJTL5mdoWC396/67WB7l3RkBBivlB+Z3T6xzdGb69kLZfXhzMzFNlQZBlZzGt4FNmvKcfbGzVF8mvqm4Pjy5Wq43IXxOByeiZb2BUNeVUl7vNInzU6ZGo03vV/faVzo9EfGS8tf3zr0r/8JFc1ojGvvto67jg5Ozvq2P1Vx+EqSAi6d8CvDehi1Nlmr0xRI4oaWc9E4Ny1FuenfzO+8EkRtsls1Pt6dv2zpg4TUGZqJGiElfo5EsIsLZby10FYANtNGkcIIQ+LYl9Cdiw3nS8nUuaRvkCAIWNyU1NXR9W37eSyWyAyJns2zyaMgKh6ZZk99MwKwqxk06ll3nHAr/oZoB482ohlZAw+x7lmJcwnSitnV8yD7bqyOUI08+PLuQsrsF1fX4D1UQS8hiLJLhfpci1TrQkAhbGucODPDvZ/fU9PW9AnIfOq8rG2Jo+iliyzULPOzyxeX0iVLBsRqrYztpIdZ8g574mE/uxg3xt7ujtCAQSYy5feHJ58c3BiPJWzXQ4AHCCiKYdb48fbmjyqHDK0PY0RTZIkxgYaIn96gDHEN4fG5/NlzkWqXMlVTRBCkyW/rjJkny0TEZms+DaP3ovg2IohMVSZ0eGPeFYHT3DtWr6WX3RxqmpbXICEAGq8UYnHERYe4tQL4XL0BqO7mxp6UouTFevONZjs8/o8q2POIcP14SN4LpsaWlycA3Cozy4h5PdDsS8hO5eZKsyPWP5W7/4A05ikBuL9mvRQkcXdw1Ph9qNc3QuDWqqSfMeMNquy32CAakc0UAWQP8/ABlEspYuXpzLLzU0+aT34FaXs8vDK0rB7v7gKGeqKJDF0OC/bTs1xhRAeRd7XFHuqq6U95FdlSQgwFGWgIdIe8tuuO58vLhbLw8kMt4SCTABYnMuA7UH/P31s3yu7uxr9HgCcyxd/MTz5by4MJssVZ9PsEh5V2ROPvD7QHdBVWWI+VVEkCQBUiXWFAs/0tI6kMplKrWTapu2WLdtyOQIqjP0OM7sB3NlFgjEEAE1m3c2+Js/qMHBVs1woZ3NWYKpqm7weYMuRSCAc8cJC5e5tCu6ajlN1BCDKsmzITJLVeGPnn55QBYr//cps+q7Z5Bje2edEcLdcTp8ZWXx/rGRtfWeOEEJ+BxT7ErJjITr5ZHZlJdPa7VM0CYHpIe3Bq9Xd2a+XP0xH4Q2MiVK5em0hNR31thuqjKjoqgzw2V7R+owQ0S3llxcXp8oNnZqkANTnwliYW5mcz9fqE+neY10hhONywYUkMQlRZigxLNvO6Erm+mKqMeBt9nslZKbDp3O50ZVc0bSz1dp8oWS5HBHrU0KojPXGQn9+ePcru7tagj7OxXQ2/6Ob4z8ZHF0sllebvNfazquOO5UpfDw5Zyhy0FD3NkY7QwGNSVzAUql8cXZ5PJWrOQ5DlBlTZUlmKAB+55E67jihnAtHgM7kg0Ejstbp1rLMWrVWc/wzBau8er7R749G/WFJVNy7Ym67kjk7PvXz6ZKr6J09u7/TFe7UGWNaQ0Pjsx3LQ6Pzbz1Ecs3i8rvXh//15elbZX6fE0QIIQ+JYl9Cdi6G7kqxMDiSfq7BCPlkBsgeZthD4ZZyK29dHDuXrWx6183Jl7KZmqM/bPSMwq6mkpMX0rF9IaVBRmSfYVKM3xUir6QrqZsF61RIXW3MtKujK7XbaY73HqkCARwuUhXTdrlHleM+T8TQFwtlh7vjqdzfXLtdc9zXdnd1hvxl274wu/zm4PhyqeoKUaiZNcepR7OGIu9tjHx7f++r/d2Nfo/j8pGVzNsjUz8bHJ/Jlhq8nvaQP1WuLhVKpssRoFAzz80sDi2nFcbaQv6/ODrQ6PMyxFvJ9C+HJ38xNDmXK7muAMQGrxHz6Iwx23VLlv2Zg1/XSq3M/c+Xp+dK1tq7biDc2mKmZPF4r1f1rd0ovKH21059rcfUtGCoaW1KEGYEOjyBfpgfvmvD3KlMJed+NZKpcKN9JbA/4m3SdQ0AUG8Me/ubgC1uXcGpjM4sDmdFW3/3fp9Un6RaZrxQqM7mq2XGtp/YghBCPguKfQnZwZCZlXJieuLKvlinxxd+2PG+hV0rXhtLvLmweV43RAQE3dAfMoJFBk6xnP9gMvt8ky8aVL6YwcYReJXbGXu9lVqA6+ZMnnMApXuvhWi7fDZXKNt2yKP1N4S6o4GbSylErLnu8FL6pwCO6/7J3l2qIqXLtclMYTFfBgkkgPozfJWxvfHIt/buerW/qyXgFQATmdwvh6fevj2VyBbiPs/XBrqONDeMreR+NTI1lSkIIWzOV8rVZLkqI3MBiqZdtZ1ENv/Tm2Pvjk5PZQpciHpPhf6GUEvQBwBly06Vq5zz7aZMuzfhlouZd25P3toyrxtwKdDd0dDmVTxrn2me4O7O4O47Vlf0Fo8+oMNY9e7OFsJxnZJpFS2mLlfzFl+bUg1lRTI8d41FIezFpcWfj9fCgab/vstbH+RB1v39Md9AAJMlmpGNEPIHQLEvITuaxGvF7MIvpvPHIkbYe+/o7w6IksRUSVK3zuvmfqZByhBqpnl7YvrmnlhfQAl9UQ+z735ujg8RKlZt+9ZyulAzWwPe/obw8bamc4mldKXKAW0hhpYzVcuxXXGsraE+dlt9gjREACEkhvubY39xZOC5XW2tAb8QYjyd/+GNsV8NT05nCgFDe763458c39fi9y60lP268sPrY+Op3HoX6vp/OefXF1Y+mpx9Z3R6sVDmQnAACbEj5D/Z0dwWDABAvmbN5kuOuMcre/fJE0RFYqokbcS+QtiGqrSGGg35QU35WjSkd8QBZ7bvaYyIiMjuatfftruD69izy9nB26l/0KxHFZkBgOLd0xY73Oo/M1py79/ue+f0fgKZEFtnQRbbLEgI2VloXjdCdjRErFn2tYmlibxZ/cJ3zrhtFhc+XCpMV7/UD7MZouW646ncVCZfse2grj3Z2fJCb0dA14QQCOBwPpnJ/+zW+Fu3JhPZvO3yenglBCgyO9gc++7Bvtd2d7cGfK7gE+n8T26OvXlrYipTsDlXJMmnKT5V8ShKbyz0Zwf7v72/t78hVB/7tj5ts+k6t1eyb94af2d0eqFQFkIAAhPQ4DX+ZO+uI61xjyoVauZMtpAsVlz+B+g1LUDoGmuNGSGZbXx0FwAAkAIBXyxm4DZdEgQXwnG5w7kj3TnF2vYQoVKpzMyOluy1QiEHI/E9jfHu+wzeVp8euuTYrlhvWtY9nng0aKBwXW673HY5SJIuSw/dp50Q8miidl9CdjZEcKzaQuL8UuvBiNH7sD0W/mA7r1rV9yaWv9YW3mN41S9xcxwXkCpXzk4v9kSDvdHwwebYnx/ZnTfNi7NLBdOyXe5wMZrKpstVXZXLloOIIETQ0Ppiob9/dM/L/Z0xQ6+57kQ6/9Ob4397fSRZqjBEhrhYKL07koh7Pa8NdHeEfG0B318e3ePVlL+7dnsmW6w5rgBRqJi/GZ3OVWt50xJcIIIqyzG//nR36/cO9XeE/ZbrDiUzF+eWy5b9BzleITCiaI+HDO/a/BO2mZ/NFqfLAkCgJPtDkf6A5pcAADy6P+pvMHDljo0gqhFfcF8jVIQebwrEjY0RlbnLHXvbpl9kUC7U5s+u7D0Z0etlgnlCR+KxFyOzY8vmvX4koeOKdD5TtWugqwAA6As0HNq9/+X81O2S4yAwlHxBXS0WZhcyI9R5gpAdjGJfQnY6BF5z8m9PrZxqDnU36w/d7+EPs29wHDsxebWv8XiDd8+Xu0WuYjsX55b7GyIRjxH1Ggeaov/ZY/tjHv3yfHKxUK7Yjs3dXM1kpoUIXlWOeYwDzbFX+juf7mmLeIyK7dxeyfz81sQvh6cylWq9C4AAQMTZfOmHN0Yczl/b3dUdDca8xqu7O1WJvTc6PZTMlCy7artz+SIXwAAVRfKqcpvff6q75et7e9qDPiFwuVT9ZGr+ynzS/cPM/CsE6H45ute3PhGxKKXG37p0638b48C57PXvPvHk/7Cv8YBXAgCm6c2eQBekk1s7Pch65ImBI+0dDjAl4At0BFRl9Rs7VzTn09tPAsgQi6b98VTmT9sCLWp9cguluTky0BPSlpN3jyZRh2BbPDVaMLO2P1Dfjezd1TXwf2nsKdmcA8iSpKru3OC1vylnRjKf5zjShJAvN4p9CdnpEEE4VmZqfrC36WRcb/6ig19XWJnfLqQPtzf0N2tf6M4/I5eL8VT2nZGpqEc71dkaNLRj7fGIRz/WtnJlPjmZyadKlZrjyhKLeozucHBfY/hwa2N/QzhiaKbj3lpOvXVr8u2RqYV82eUCN3V/tV0+mc7/7NYEF+LrAz3d0WBHKPjGgNITCV1eWB5Zziay+XzNEkIYitwc8PVFQwdbYoeaGzrCAV2WV0qVTyYXfjsxO58v/cGOlum6EWn2SGvjmzn5XHFppbBcZCBccJmdqqQtV3glBABVa/J5Dmnw2609fpmqN8e0RgGAKG0aAdqtFW4nc+fT4OrbBaCI3DTz04sTB5v2B5UgAwA0AuFdDU175OT1e3UqBrfq5H49vfJYk6+lQVcAAFFWtJiixTYWE1LMaIwgZL7UfWwIIZ8rin0JeRQh4uYBGHDrNxt/rkYeCNw2l04nM89Uos1+dvc2VpfetIn7tJltXm/zktsmChEA+ML4ymhLc6Yp3oB3pu2uNG83FBresc8HNOltWhxh2w1uRwAULfvC3DJjTGLsxb4On6ruaYy2h/0nOpoy5VrRtB3uSsg8mhw29AafEdQ0VZaEEMPLqb+7OvLB+OxisVxvmt28UwSwXD6eyv5scNy03b93eHdvLNTk9wQNbSAeXilXc1Wz5jhCCJlJQV2Neo2o1/AosozMEeLDidkfXB8ZXMpY7md4lo/b5e/6oQqfqjX7Yypba6l18lk3l0WJIQqJu2CvmAVLOAAKAIAaCeqdTSjl7zzLEt41foZrzs3PnJmcuW1xYeAdp67eyZkJy6wtXM33P+34g/WZBhVfTzzyeisbXwa+XTFGRNc2p4eGfhU1mj3tx7zb9g5GzePx+nWAL7xzOyHkS4NiX0IeQcJ1bdd1OAoB6LrO+oNwIRzHtTnnAhBd2xWuqD92B9exhsaT19obD/QFfACIwF3XXltRCOG4ruOCAEDh2i6/xxv3QoBwXNfm3BEACLbLnbUlXde1Xe7w1b+dTZNhOKX5K8sNV3Kh5wMyAwDktiuc+iNxIVZXBAAUlus64s6Wv7XjZUIAIreFuE8MKMRaSgQI4Oi6zvbP3rfBuchXa2em5gs1c6FYfqa7tS3oD+pqQFN7IvVhLkQ9nJYQGKLjimSp8snU/C9vT52dXkyXay4IBGAMGzx6XzRscT6WyuaqJgBYLp9MF35wc3SpVP7Gnp7j7Y0+TW32e+N+r8vrk0AIAJTWxkyo2u7tTOadkcQ7I4nRVK5iOw93EPVMEI7D6yeU1U/0piwQIPyG3BXXfQCOywUIdKtzBXuxvDZMhst5Kp8pmcWYEgAQiIquh2IGFsFxXdvhDt5xjoQAbllWrpA9OzL1wej0p8lKSYAXoP4imsNBCEBn41yUrerZRO711lBrRGUCBLJgMHS4t9nIFCzOHde1OJfFalFx678mBHfKqQ8vXc5lMq/3t59s8jVriiYhArrcsWy7VK2NzOWG0p8howghjx6KfQl5pCBDxzJHh279b8uJBgW4ABT20kpq3OVcWObKxPc/TZ33SkwAMjebTN10uVtvQhO8sjL71gUzkTA8UI9v7Ex2ZbHiMsTl2cRPndKQjlDvH1wuXCzWKnc2FyJjbs2a/8Xl2sikqnAARKeaSyyJiosOty4PDf1/l2cisuCAwirPpQpli6814FVuJ8b+tVP42GC42u5XnijUUgykcvL8zWv/r0VNAwAE164uzVYWrLUH6IisUlq8Pfj/SXsCMggBgPbi9MrQPRpzkWElnzt79er/c1KtT50AbvX2fHblIRp/60twAfmaeWF2KVs1x1O5E22NXZFAzOvxKLIsIUMEAY4rao6Tq5qJTP7a4srHk3O3ljNF06ofLAIoDLvCwe8c7Cub9t9cu12omfXfEiZ3Z3PFX92eWiyURlLt+5tineGAV1E0mSmMASIXvOq4ZdtZLpVHktlzM4unp+YWCmWX3zVW7r2OApELMTw18a+ruUYFAIAJJ19Ip2vO+sQWiIxXi2PDg//Tgrr6AiKvjU+nx1Z7aiADx6rMvXnRvDWmrp4XszixXMuUV948f+mmX1Hv2q8Q3HGdUqU4Mp8azVZLyBDBrtUGB2/8q3kjKIMQgNyaWUrOCI4MuWNPT438lZv80CsxAYDAXDOZqVUsy0lOfv+TzFlPvRiLSj47mhVVAQwBgSdXlj8q1+ZXkh+H9LAqKwwRgAvXcXm1VlvMZsbT9vrZJITsQFgyrb3/418XTeuLmFOJEPKFqI8+td6Sh7j+jFhwse3n6+vB5qmJcb17gxB884CsCOyeXQW27AIQEFbj1C2p2vT5tmmGtbThHanC1W4Km/cuhKg3ud6Z7HvnD98uhQ/EEDYGz0UM6lp3ONAdDbQHAzGv7tdVlTGHi6rtpCu1+UJpIpWbyOTS5ZorBALU/4uIuiI9293+L585mqua/++PLl2eTzqcA6w+u0cAGbEx4O2LhrqjwSafN+rRDVVGQMt1S6a9XKpMZnIT6fxMrli1HXHXDNMPdHcJufsWsCWXtstVLsTdJ3rLh3dYHa4Y73nucCMH6l9uKUsb6byrjNVnELn3Aa7vfev2CSE7CxfiUGOU2n0JeQSt3t236xjL7tcZFhFh+0FU67HFQ4UM99zFvVN1/2/vnapNS0gPm7y15X+P8EesDbubq9WuL5rDyYxfV4OG6lMVGZkrRM12CqaVrZoV214PvzRZ8muqIcscQFekmFdXJElTpEa/pz3kdzkHgKrtlCzLcrkjxHy+tFwsX55fDht6yNAUSQIAh/Oa7WSrtXSlVu8HUQ/m7uoG8uAcuM+5WF/m/rnEtvuFse2HD9jLPVNyr7J0/2K8utkHHiAhZGei2JcQQj4zsdZPmoOoOk615CRLlW2XXI3ABAR09XBz/FBzgyShKkntQV/Uq3tV+ZXdnYdb4kJAoVa7urByazltu2Z9dgqHi7xpF017JldcC3PXdl1PRn3bf5hxzQghZEeg2JcQQh7KxsgCa0EnAtbndYOtk+WKTYvVX1ETALbLNVk60hbf3xj1qgpD1GRJgPi6b5fLRcE0L8wuX19KW079tbb1XWwQa5vGtY0TQgj5rCj2JYSQh7K5wfWey9zjbwTI1axL88thjxbU1f2NUUNVYPW9N5YzrdGV7K+GpwaXUpbr1l9Hu9c2V989u+sPQgghD4NiX0II+Ww4AGzqbPCw46MJsVQs/3okYTv8u4f6j7U1elQFhSiY9rnpxf94ZfjCzFK+Zm3e3rZbFltblx8+AYQQQoBiX0II+Ux+54gTAbiAlXLtg4lZi7s113msrcl23I8m5346OHFuZrFoWpuGLrjfLijYJYSQ3xnFvoQQ8gWpjxa3Uq6enpy3XZ4q1Uzb+dXtqSvzyZK5MeisoOiWEEI+NxT7EkLIF6f+GttKufrbibmpdMERfDpbqNoOIG6MHEwIIeRzQ7EvIYR8oeqvseVN68ZSCmB1Qgf4LF2HCSGE/M4o9iWEkD8CmnmBEEL+KNiDFyGEEEIIIeSRQLEvIYQQQgjZKSj2JYQQQgghOwXFvoQQQgghZKeg2JcQQgghhOwUFPsSQgghhJCdgmJfQgghhBCyU1DsSwghhBBCdgqKfQkhhBBCyE5BsS8hhBBCCNkpKPYlhBBCCCE7hSwAKpZdtmyGNLU8IYQQQgh5NHEhqrbz/wd0fSablVYlLgAAAABJRU5ErkJggg==) - -## 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. - -- > 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`, 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 <<< >>>, 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= [DEPRECATED] This option is being replaced by --offload-arch= . 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= Generate code to support up to the specified number of threads per block. | -| -O | Specify the optimization level. | -| | -offload-arch= 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: - -- > -**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 (``), 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 > 256 - -Kernel code should use \_\_attribute\_\_((amdgpu\_flat\_work\_group\_size(<min>,<max>))) . 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 (`

`), headings (`

`), anchors (``), and bold text (``), 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 (`

`) and an anchor (``) 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(&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 <<< >>> 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 <<<>>> syntax, hipLaunchKernelGGL. The latter one is macro which expand to CUDA <<<>>> 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 <<<>>> 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. - - -``` - - - - - - - - - - - - - - - - - - > - - // - - } -``` - -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 -#include -#include -#include -#include -``` -**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 `

`, ``, `
`, and ``. 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 -#include -#include -#include -#include -``` -**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;iargBuffer(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 `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 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 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 <hip/hiprtc.h> - -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 kernel_binary(codeSize); - hiprtcGetCode(prog, kernel_binary.data()); -``` - -After loading the binary, hiprtcProgram can be destroyed. hiprtcDestroyProgram(&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 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 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"); -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. - - -``` - - - - - > -``` - -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 - 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. - - -``` - - - -

-

-

- -

-

- - - - - - - - - - - - - -``` - -## 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. - - -``` - - - -

test, which caused a segmentation fault issue.

> - 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 < 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. - - -``` - - - - - <& & - - - - Loggging examples > - - - > - -
-

-
- - - - - -
- -
-``` - -(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. - - -``` - - - - 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/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.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 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; - 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 -#include - -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 -#include - -// 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 -#include - -// 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 - #include - - // 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(&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 - #include - - // 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 - #include - - // 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 (`` and ``) 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 ( <<< >>> ) 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 >= 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(&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 <<< >>> 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<<>> (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 <<< >>> 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<<>> (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\_<type\_name>() . 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> - -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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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 - - __global__ void run_printf() { printf("Hello World\n"); } - - int main() { - run_printf<<>>(); - } -``` - -## 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<class T > - -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<class T > - -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<class T > - -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<typename T > hipError\_t hipGetSymbolAddress ( void **devPtr, const T &symbol ) Gets the address of a symbol. - -## Parameters - -- devPtr -[out] - Returns device pointer associated with symbol. -- symbol -[in] - Device symbol. - -## Returns - -hipSuccess, hipErrorInvalidValue template<typename T > hipError\_t hipGetSymbolSize ( size\_t *size, const T &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<typename T > - -hipError\_t hipMemcpyToSymbol ( const T &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<typename T > - -hipError\_t hipMemcpyToSymbolAsync ( const T &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<typename T > - -hipError\_t hipMemcpyFromSymbol ( void *dst, const T &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<typename T > - -hipError\_t hipMemcpyFromSymbolAsync ( void *dst, const T &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<class T > - -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<class T > - -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. - - -``` - - - - void 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 <=> ) 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: <<< >>> . 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 & 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 & 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<unsigned int size , class ParentCGTy > - -class thread\_block\_tile : public cooperative\_groups::impl::thread\_block\_tile\_internal< size , ParentCGTy > 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<class T > - -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<class T > - -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<class T > - -## 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<class T > - -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<typename T > - -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<typename T > unsigned long long match\_all ( T value, int &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<class T > - -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<<>>(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. - - -``` - | - <---------------------------------------------------------------------------------------------------------------------- ---------------------------------------------------------------------------------------------------------------------- | - | - - - - - - - " -``` -**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. - - -``` - | - - -- \ + <---------------------------------------------------------------------------------------------------------------------- } ` and `` 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 | - | | - | - | | - | - | - | - | - | -``` - -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. - - -``` - - - - & ) ] - - : ; . " -``` - -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. <major>.<minor> compute capability is passed to nvcc on the command-line as sm\_<major><minor> , 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 ()`, 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. <major>. <minor> compute capability is passed to nvcc on the command-line as sm\_<major><minor> , 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. - - -``` - - - - // -// + - * / */ - + - * - - - */ -``` - -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> - - - -``` - -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 < 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. - - -``` - - - - - - -``` - -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(warp_size, [&] - { - hipLaunchKernelGGL(kernel,...); - }); -``` -**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 - +template - __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, tmp::divide<2>>([&]() - +{ - + 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 - - ` 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 - __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< WarpCount, tmp::not\_equal<0>, tmp::select< tmp::not\_equal<1>, tmp::divide\_ceil<WarpSize>, tmp::constant<0>>>([&]< uint32\_t ActiveWarps>() { if (wid < ActiveWarps) { // Warp reduction tmp::static\_for<WarpSize / 2, tmp::not\_equal<0>, tmp::divide<2>>([&]< int Delta>() { 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 <size\_t I> auto get<I>(...) 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<> 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` <reading-items>`and processing ``ItemsPerThread` <processing-items>`. -**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 - { - return [&](std::integer_sequence) - { - if(i + ItemsPerThread < front_size) - return hip::static_array{ - front[i + I]... - }; - else - return hip::static_array{ - (i + I < front_size? front[i + I] : zero_elem)... - }; - }(std::make_integer_sequence()); - }; - - 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 > gid) , or the more portable [[assume]](gid + 4 > 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 ref_reduced(const unsigned int partition_size, - std::vector input) - { - const unsigned int input_size = input.size(); - const unsigned int result_size = input_size / partition_size; - std::vector 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 custom_partition - = tiled_partition(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, -``` - -## 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 && 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 <ROCM\_PATH>/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 <ROCM\_PATH>/hip . This can be overridden by setting the HIP\_PATH environment variable. - -• - -HSA is in - -<ROCM\_PATH>/hsa - -. This can be overridden by setting the - -HSA\_PATH - -environment variable. - -- Clang is in <ROCM\_PATH>/llvm/bin . This can be overridden by setting the HIP\_CLANG\_PATH environment variable. -- The device library is in <ROCM\_PATH>/lib . This can be overridden by setting the DEVICE\_LIB\_PATH environment variable. -- Optionally, you can add <ROCM\_PATH>/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_> -``` - -``` - | - - -``` - -## 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 & 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,iVBORw0KGgoAAAANSUhEUgAAA6oAAADuCAIAAAC/P22uAAEAAElEQVR4nOz99/MtyXUfCB6TWVXXfv33+0x3owkPEARhSAj0chRFSbMz0kiald3YnQltxM5/M2tiNzZCo5VWnJEoaRRDcSiJQ2oACiIBgrBsEK4Nuvu99/XuuqrKPOfsD+feeveZ7n5oNIjWCtkRHffdb96qNMd+zjmZaGbww/bD9sP2w/bD9sP2w/bD9sP2w/afRgt1Xf+9v/f3FovF+rdEBABmZmaIyMzMbGaqioiqambeBwBU1X9SFEWMMaVU17WZMTMRqar/yh9IRN2j/PkAgIj+TQjBH6KqKSUR6azzro9/9n8+NJnuLd033Wci8r923/uffII+qn6/T0Tz+dxXwwcfQogxIqKI+Nv9/90T/Bt/ODOHEAAgpeSP9V+VZRlCaNs259wNoBvP+mefhS/O+kZ0q9dNfP3n60u0PseHXtE9Z/3n3aKtr95jPz864Ec7rA/msZ2/l/bQTDsKfK1XPDRI3ybf1kcf2BHVOmE8SmkPjeG1duGx9PnYGSFiCKHf7xdFgYjz+Xw2m/nsHt3ZboT+124Ab26Fn3ycb1Xrxr8+bHiEurrOj33IYwf8Wp2/2+ZE1fE4rFHCW/L812+vz4xPwoDrHR5dqNda2+45/r1zSrdHnTjyZ67rgvVHdb/qWMB/6Exnq/boyLshvT4pPnb6j5LNW9VeZ9nhjbbgrR2MP42ZB4NBWZYppclkIiLd+q9r0jecyJPP6CFqeZ29e5I1ecPXPdThtZbiu+WCRzs/4Xg6Y+N1xvP67bV0xBO29f6vP4w3fMVDZIkPWhGP7vijs4A3EkTflcbv5AwzV1VlZm3butXkHR5V7q/zutdZmddqZvZTP/VTIaX0K7/yKyLyhj9gZgB4nZ5VVQ2Hw/l8Pp/PX6vPG66L25qqum77viXtIRviob9WVTUajUTk6upqfY5EtC6733BInW5Y/3I0GhVFMZvN6rp+i2bzw/b/V60sy/F4DAAXFxedj/TD9sP2w/bD1jVEHAwGbdu2bfuDHssP2w/bf9wtpRSco66vr4fDITPPZrONjY2qqq6urlJKGxsbRHR5eRlC2NzczDlfXl7GGEej0XQ6bZpmNBoxs3fe29tz9LSqqvF4XNf1bDbb2tqKMZ6dnZnZzs4OIp6fn7uteX19PZ1ONzY2er3e5eVlznk0GsUYLy4uBoPBYDBYLBbT6XQwGAyHQ+8wHo/N7OrqKsa4sbFR1/V0Oi3LcjgcNk0zmUzG43FZlj6e7e3tnPPV1VVZlqPRqGma6+vr0WhUVdXZ2VlRFD7Iq6urfr+/vb1d1/V8Pt/Y2CiK4vr6WkR8PNfX10Q0Ho/n87kvVL/f9+lvbGwAwMXFRVEUW1tbdV1PJpOqqnxJ27bd3NxkZpdWOzs7i8ViMpn0+/2yLCeTSUppPB6HEC4vL5l5Y2MjpXR5ednv9/v9vuPQbjpfXV2p6vb2NgCcnZ359P0V4/EYEafTqapubm6KiK/JYDCYTqfz+dwHfHl52bbt9va2b0GMcXNzs2may8vL4XDoA04p7ezsiIivz8bGhq/qcDjs9Xqz2Ww+n/t4zs/PEXFnZ6dt26urq6IoNjc3p9PpYrHwKV9cXCDieDx2rMJJYj6fT6fTbjx1XXfj8UVr23Y6nfb7/V6v51vQ7XgIwXfcSXQwGJyenvoKO4Ex8+7u7mKxuLq66vV6w+Hw+vp6sVj4ojndjsfjnPPFxUVZlhsbG5PJpK7rzc1NJ3JfQH9dr9dzIp/NZk4z3mFra0tVz8/P+/3+aDSaTCZN0/h+OYlubm6WZXlycqKq+/v70+nUaabX600mk7ZtO57yTZzNZtfX171ebzweTyYTZt7Z2YkxHh8fA8D29raqnp6e9vt9H/BisXDucEN5f3+/ruvz8/PhcLixsXF1deV71Ov1Li4unIaZ+fLyEhF9fS4uLjY3N71DSmlzcxMRnYbH4/FsNlssFr4F0+nU14eZz8/PmXk8HovIZDJxpnOaGQwGLjHMbHNzM6XkPOU83jSNb8H5+TkAbG5uAsD6hp6fn4/H444C3Q2YTCbOdO40+pSd4Le2tpj5+PjYF7BtWx+PL6AP2EkCAJynrq6uXIy4ZBiPx0Q0nU5FZHt7e7FYzGazsiz7/X5d1850ZVn6Aq7Tz8bGhpOEC8nr6+uc83A4JKKLi4sY49bW1nQ6nUwmGxsbThJN0zhPTSaTEMJ4PHZB1O/3q6qaTqdOEgBwfX3tK5xzns1mvj7OMi6Uzs7OiMin3K2wc4TP6OLigog2NzdV9fLy0ll4Mpl0A768vBQRf910OvX9appmNptVVeUzciGAiGdnZz6Gtm2vr699l50rNzY2nCR8POsr7DTjHa6vr52nXEjGGHd2dnx9xuMxM8/ncxdKRHR6euqaxTdxPB673PPxmJmTqEtyXxMX9U3TuNh3obS1tdW27cXFxXA4XFccPh4AGI1GOefpdBpC2Nramkwm0+l0a2urKIrLy0sz8y24vr52qeU77h3Ozs46KeHj6abf7/cHg8HV1ZWTKCI6zWxubjqPDwaDTmIMh8MQwtXVle+4b4FL0evr605vnp+fm9nW1paIXF5euiKbTqc5Z19hF/sulM7Ozvr9vrPMbDZzGehaZjQaEZFP3wn+6upqNBqNRqOzszMR2dnZSSldXFww89bWVjf90Wg0n8+dnp2niGh7e9un7CyzWCx8x0MI5+fnbiq0bXt5eelS1BXHYDDo9/sd/XQ8NRqNFouFd+j1ej5lh6Jms1mM0fWC03CM0WWg8/jFxYXPyDWvv8LZ1sfjQmljY8MXsKqqjY0N50rXvK5YXSafn5/7GJyGnQI7vZBSmk6nrkR8RsPhsCzL+XzuloBrPZ/+YrG4vr52svQnjEajEMLZ2ZmLstls5ppuPB6fn5+7kOxYeGtra52ofMoulFzmbG9vO5GPx2Mnch9wxwUdiXZCaTabbW5uVlV1enra0bALpeFw6Cvs03ee6uSe87izDDM7BbriMLPLy0sA6DSvy73z83NXzW7buCXgHOGvc5HrutJ1987OjttXTnUu9n3Rrq6ucs67u7s55/Pz816vt7297WKkU4UuJVw1+x651Oqstbqut7a2Qginp6cOLQ+Hw/ux9bZtF4uF84znHoxGI18XJyZflxDCrVu3EDHn7AP1JIcbN2749qvqU089VZblYrHY2dnZ3t6ez+dmdnBwMB6Pr6+v3WxCRBHZ3Nx0YS0iW1tbTjcuJYuiWCwWbqZ4ZxdnHkrb2dkpy9LtvFu3brl22d7e3t3dbZoGAA4ODlzMhRD29vYQcT6f+yuapnFTqdfrtW3rWs01rotXAHC1t7e35/Ll4OAAAJw+bty4kXPOOfvTzCyEsLu7G0JYLBZVVd24cQMAcs47Ozvj8dh32pM62rYty9LtCRdhe3t7OWdVvX37tlv8MUanPBejLvrdlnJO6Pf7N2/e7BZwe3vbkfKtra2NjQ1VdYqPMeacB4PBrVu3VLVt21u3bjk8T0QHBwdFUTiF7e/v+9hcRzZNE2O8efOmi7bBYOCvcBm3u7srIk6vvV6vruuiKJ566qkYo+/4zs5O0zSIuLe3NxgMXNY7ebhd5XvUtu3t27edE3wT+/2+u0Bu8/ns3LFh5tu3bztXjEYjZ5WU0tbW1tbWli/vjRs33Hxh5hs3bni2yc7OjrMuEe3v75dl6YaOT9830bWdiOzu7m5tbTVN021i27bd65yGXVi74vRAZL/f39vbc5bZ3d11i5aI9vb2/BWj0cgpMOe8t7e3u7ubUirL8ubNm56JMRqNbty44QJxPB47iXpnn/JgMNjb2zMzdxjcjyKi3d3dqqqcbZ2PXErevHmzG8/u7m7btsx8cHCAiE3T9Hq9ra0tInKZ4j6MT9nJoNsvVwy7u7se197e3vb9CiEcHByEEFxK+uvcv+31eiLia+JPG4/Hrn58X9wL8vEws8uZvb09d8fH47HbNyJycHDgBDYcDm/evGlmLnPdx3NT0sdTVdXt27d9v/b39/0VTuS9Xi+l1Ov1nMid6XwpRMRXWER8+j74wWCws7PDzK5FRqORL+Dt27djjHVd7+zsOJ3Udb23t+fGR4xxd3e3LEt3h/xL3y8Xa4h469Ytlzm9Xm9nZ8elsK+wR5lu3LixsbHhK+w87k9wg8MNHbcG/Anu97rnk1ICgL29vfF4rKpFURwcHJRl6Qbfzs6OC6W9vb29vb2maVT11q1brr99xz23yjliPp+HEJyn5vN5r9fb3d11Gt7c3HSB6WQwGAxyzmVZugx0BMGJPOfsYt9p+ObNmzlnN3Scv3wB3SgsimJvby+E4CTh1oCLERdKzuMuUkajkcs630Q36Yjo1q1bVVW1besU2NGMW0hOVP6Eqqpu3rxZFIX72G5iOsvs7e2llIqiePrppxHRvxyNRiklp9tOKLmQvL6+3tjYuHHjhuOym5ubrn2ZeW9vz4lqOBz6eFzM3rhxI6XkIsWl1nA4fOqpp5wLfI86se+z8+mLSNM0m5ub+/v7HmP0GTlJ7O/vE5FbQrdv30ZE5wiXYE4eLpQ2NzfdXHAZuLW15XL4qaeecq+s1+s988wzZtY0TUfkvkfddty8edM/+xbUde1k4Lq7qipX0y5zDg4Ocs4pJRcCbku5oHYX0VWhe+nuP7ju7vV67sC4KnRj3bEtl+pVVXVi34ncFYf7CTdv3nS9ORgMdnd3HflzrlRVZ7r1wYcQXGjv7++7bbO3t+fERkRPPfUUM7st9dRTT7nI9T1yqX5wcODj6ff77vj5CruYdcVRVZWqOujmIeWNjQ1/hZuSDqX1+30Xay61nGZ8E0ejkT+hMw+2trb29vY8cL2/v+8kGmN0s8G9dJd1vj7uJSJipxb9aU3TmJlvqIh0Kzyfz508XAi4pnNcb3d3t9/vq+pgMHDbxs1rVz0uBBwLCCE8/fTTMUZ3GNzO8e0oiqJpGl9AJ4lux93eczVdluXOzo4r9+FwePv2bV9Al94556Iobt++3ev1FovFcDjc3d1l5qZp3FqbzWYdy5DLl6IoQgieh+HGzenpqftJ7olub2+voylN05ydnVVVtbe3N5vNzs/PXSCenZ05s3mH4XC4vb19fX3tMq6qqsPDQzPb398HgJOTE7eD67q+vLx0w+vi4sLXJed8enrqsgYAjo6OXN6dnJycn5+7r+ZogVsbvnk+4MVi4W7Q4eGhj0dVr66uqqpyN2ixWDgzHx8fi8itW7dijEdHRzFGVwz+CveTfKfdq3AdcHl5eXl56Ur9+Ph4Mpm4Jjs5OenwqsvLy86RatvWdZKjXy7CfH38y7quDw4OzOzo6AgRb968KSKOFjied3Fxsbu7OxgMzs7O3PPzFe5AR8c4Nzc3T05O2rZ1Jj88PGTmzc3Ni4uL6+trf4LDG7du3XJn163Y2Wx2dHTkM3JHyj0tn5Erb5/ywcHB9fX1ZDLZ39/v9/tHR0du9NR17Xs0Go1OTk7m87lDmGdnZ65Q67o+Pj7u9/sHBwdN0ywWCycJH4/ziT9tb2/PwS1Xw+fn564Pcs6Hh4dOVJeXl+sdOlf1pZdeco3i6+Pjubi4cDTFzByccJlycnLi7OG+tWv68/NzN7tV1V3n3d1dB0TdJbt3717O2VXLycnJYDBw+/vy8tIh1bOzs+l06hLh+PjYjdTZbHZxceHuewdaO5DvVpGv8HA43NzcdKJy1eLYjPv6JycnRVG4j+TSvKqq4+NjX7Sc89HR0XA43NnZubi4uLi4cMjw5OTEV9vhXhdnV1dXh4eHbko6oLW/v59SOj09dR3Qtq0T2N7e3vn5+fX19fb2tqM7Lq1ExGfki3Z2dubTPzo6ct1Q1/WdO3dGo9HW1tbR0ZEDbER0eHjonoZvARHdvn17sVicn5/7fk0mE1Xd29tjZgdLHKJzrtze3nYh4MjB8fGx41W+gB6aODs7m8/njj34Ct+4ccMp0NGC09NTd4ZHo5ELAffzHVHe39+fTCbHx8fub5+dnaWUfH3Wicp32Vf46urKjdG7d++GEFyLuFU0Go1OT0990VJKzuPuQrsU3djYOD09nU6n7iMdHR0529Z1fXZ21sUxZrOZK6qjoyNXgR7a8vXxOI9DYoeHh5PJxKXWnTt3HOKdTCYXFxfb29tlWd67d8+JXEROTk7cHbq+vj49PXWZc3x87EKgwzjdZXV0ZzweX15eXlxcOI8fHh46h7rkdCfcqc69CO/gwUMXAjs7O0dHR/60wWDgPO4G+snJiTsP19fXJycnTj8O17l2Pzo68hV2rKiLDboUBYB79+65lplOp75fLocdYSEiZxl3GO7du8fMzhHn5+du/bz66qsA4B7O+fl5URRugF5eXm5tbTlJiMgzzzzjQsk1y2w2c13QSVE3aO7du+cAStM0LmaHw+G9e/fcOXdc3BVHSsmpbjQaHR4enp+fuz9w584dZ1uP7Lmx7kTuqPbR0VHTNN7BWdhJ1NFBV6C+oS7BXGI4vzuwdefOHTebHEV2u/P6+tojsVtbW1dXV1dXVx1c5/ZWSskjVw4zd5GZTpGZ2d27d6uqcjHrmD0RHR0dqapbhD5gV2ROP1VVnZycuAGUUnKhPRqNnOrcW768vJzP525rdqbCdDq9vLzc2dlxGN5fYWbO1z7lw8PDoig8EOSL6brbFaszXVmWrmVczlRVdefOnaZpdnd367ruAgsXFxfunTpJLBYL9/Pv3bvnCzifz7tFcz3le+Qy0JX+6enpeDx2u8Lph5lfffVVVxzz+dwxaVfuzlODweDevXvOEW3beujP12c2mzlX+uvcz79z545Dim6tuS/XTdlFvRO5xyrddLl7966LuA7U91iT+9tVVbnp4s6MC6WDgwOXooPBYDwen52dNU3jfrXHt10Ou6jf3d29uro6Pj52IMmf0G2Bw94XFxdnZ2fj8djFvptzAHDnzh2PljtJeGc3hLyDW7D7+/vz+bzjKRcj7vR6WBKn0+mHPvQh99VijFdXV44Ixhg9XO6b5wGFg4MDD566TPEoletFR7A7kToej90tdkfKQfJOtXisbTAY+Gp2i7VYLG7fvu0U5orBrVXHmB2IdXTWIy+OZbqacVvKw8Fm5mEa5x/PeVgPnroQdOPPg6f9ft8Jum1brzDw8gL3Mt329ddNJhNP8/CghgMhngDguEIXKuqCpzlnTwDogoNVVXmQxZM0mNl15MbGhgfffQFdMbhS98ClG6adGvZFc1vBwxAOt3uYpksn8EBhF/r0Vzho5DzT6/X6/b5P2eM4LlO2t7fXIy+e8uGRMg8FODY2mUy6bAF3PxDx+vo6hOBM5YEen76zaL/fv3fvnueEeOjKczA8ruROpG+iE5VnLLgl5BhwjNEDuM7DV1dX3tnTG3x9XC+67etybXNz09PTx+Oxe1y+wl0gbGdnx5N8PJTmkRdXVB6Y89l5nKszbbe2tvr9/unpqate1yIeNuq4gJk7ovIOrqjWI0HOdG65emzU/XhnGTf3nSu70JXbu46sOwbvOL3b4iKyv7/vkaCyLB1Preu61+s5BboaNjO3hLoUC18fN7wcnuzSG3yF3eHs5Ox6wN3XxD31q6urdRfaTW23pVyLuPPgocbJZOKmScdT7kJfX1+70+/hTh/DfD53NexZUk6i6zkq7sB0odjxeOyWkBNYl7DhORjOdJ4y1IWnr6+vfcfdTKmqyv1JZ7qiKA4PDz0c7K9wdMf9pS5bwJ0r97fdw3Gk3+VMl0bl0TOnGRcjo9FoPB4fHh4iosevfcCO3DwUnd/c3PSsJPcHurQlh3Z8Rt7BKdDDwY5RueZw28WlqNsKXcC9y5Jyu8rXxMycqHwTHYMYj8fdCvuMfDxdBNxX2B0GV6I+Izd03JT0DAGP+3Vy5qE0qi7S6kznpsC64nBLyFWdR4o6Fu4o0GXyYrFwEeca0PFFF/vrOTw+Iw/m+na46ba5uXl1ddUJSZcYDgZ30V5PaOmkloMULsmdhTvruWMTD9+7XnA95cFcj4A7Ubkic6bz17n76oaOO3jufty6dcvXp9fruZh1ULZLiXEp4ea+52M47OIJCY6Rd1lSPqN1vdn5J64rnSy7+K2rgC6+70LbmW40Gm1ubroYcZfV07rcUF4X++5+OAu7oPaEDU/RcW+wW5/O/fAcDLcvuxwMf0VHok4Sbmt60Nsp0GMC19fXDrT56zrR4UTe5Rv4HvkWuAx0S9FzOz1M0cEKHWznpmSXlLWux13JelbSbDZr29axM0868jy0DjS5vLy8vr52y6RTPU51TsNurXY5V67ofXbrLOxPcDbpMig6BnSmcyJfT6PyLZhMJh4p6vf7TmDj8Xg9h8eNse3tbScqD652uZRdjooTlQsijwN4Do+bCi73hsOhf95YZc+6S9+RwXg8drL0He/G4Gldk8nkb//tv00AwMx+NIFzoKcoudpzCXXv3r2U0vbW1mKxODo64hAclfS1KIri9PTUU+6aprl796677y6AnFY8FXJ7e3s2m7nd6WbB0dGRq+E7d+44MTnK5Za0Y0K+9BcXF64PHNf0vZlOp87Pbiv4E1S1A0FV9ejoiIjcjnFvmIju3r2rqs7kR0dHHvE8Pz/39CAHqv1pbhZ4GPT6+trZw/0hXx9mdjPOEQt3VtxF9rQ2WNUzuU5yyMfp1XPgENHdQUdQ3F1226UzEQ4PDz3DzxECp1cH1Zxn3A52DvQBu925bihfX1+7WeA6u9frXV1fuQQfDocOOnrY7pVXXvEt8ClXVVWW1fn5uRs9LvfdHXJu9BldXV1dXFy6Ne+pqx6md9fIURy3+RwhcJ1U1/XJyUmM0RWVv8JBNecfh3zcTLm6unKMyrFnz3Ntmub4+Nghw/l87viQC2Vnjw5odLZ06eBoqBvKnmvr/OwIgT/h/PzcbQjHejuicn/a/VcHHX08LsHdv3cbwoMbLnROT09ns9n21rbTMABsbW1fXV05Dh1jPD099UiIY2YeEvUNjTEOh8OTkxPPc3Up6Umx8/m80/qXl5fusjvI595pp/WdQ09OTlx8nJ6eumfoGJWnIV5cXDjM7BLKIagY4927d93snk6nR0dHnmvrQGNnCniqg+OsHu48Ojq6vr72KPzx8bHHUlJK3XZcXV0dHR157M9p2EFHB0EdiXSU3Z1wt8vdv/fVns/nlxcXRVG4VnPHxmkGAHZ3lxzhOKIjtQ6q3bt3z20+B/n87JdOpIQQjo+PnekctkREF8ou94jo1Vdf9UAzIjqm6Eksjsd4uMbNFF8Ttxsmk4lzQb/fPzs789Rnh+icbReLha9PWVYeS3El4QTmQOzh4aFbri4lnGaOj49do3j0jIhcszqG58EEj0V6bMfNuA5BcWP0+vraoe579+45DDaZTB3RcAp0G8JljgPnDrEwc6/XOzs7d0MHAY+OjtyOcUTH07p8+ttb2z4ed40Q8fT0NMbCZ+T07JaQOxIOnHvqoQPV4/E4xsIF43A4dLb1tNHpdOo73uv1uk10yUlEN2/edNhpVbEwcyHZ4eJuubricKjbxX6M8eTkxLNfEPHll1/u3HsXIw7Rzedzx+3u3bvneZzz+dyZrt8fHB8fz+dzF/UuZzxn3c1KJ3LnKWc6N0ydZZzpPPJwcHDgMKqbcS7VfUNPTk7Ozs7cTPEZueHlQnJjY8Mlhvsqx8fHTqKuCt3hnM1mJycnm5ubIcbj42P3LV1o++vcEiiKwjfR7XIXI55V6YrDSeLo6MijnW55eCzFSbSj4c6y9/F4Otnh4aHLvYuLCw/+uNB2qe5i1qOL0+n03r17btkfHx97PFDV3Ltw9ed6yhEEh4Rc7Lu3PJvNTk9P/QnunjmRu+nvPrbbNi7JXXI649d1vbUKbrglMLm+Pjo6chj18PDQXSOnYR/PYiW0HfjzpzkLu/flFFgWpQcTJpOJ52Qfn5x4sMWn75L8+PjY3XtfNDNz69B5vLNtPFzsJLq1tdWmpWbxkPXV1dXGxqYjX/P53H2Vw8OlUOp8FceMFnXtDrDbOe7hnJ6cFrFwvemwt8cuOo/99PTUs0C9g2N8d+/edb2wWCw8OuTGumdMue72/fInOMg1nU6dKz2a57mvLvZds7iccVTOmc79yQ5mZmacTqfvfve7Z7NZSsmx5dFo5JT0zDPP+MJdXFx4HufLL79cxHjj5s35bHZ5eTUej0fj0dnZWc7p4OCGR+5E5PbtW4v54vjkZDgcbm1tXV5eTCbTLlIWQrh588Zivjg8OnIM3Geyu7vrUSG3Y9zTGo1Gw+FgMplOp7PxeGl3ppRu3DgAgNPTs5WAvp5Mplubm1tbW3eWq7kHYBcXF4i0s7PtDD8ejzc2xqenp5PJ9MaNG4hwcnLqzuV8Pr+8vNzb2xsM+ldX1x04cXx87E9wcML9trPT0za1W1vbqwSJdOPGTTe7PeXu4uLi/Pxsd3ev1+t1xmhK6ezstNfrO3qxnN1oeHFxmVO7v39ARCenp4F5b2/PBeLG5sagP5jNZpPpdG9vt4jFycmJZ1AsFot79+514WD3jVypxyLu7uy2bXt2fl4WhYeuJpPJxuZmVZWXF5eieuPgwLXseDzuqH9vb68/GJycHNeL+qmnnwazl195ZdDvb29vT6eT6XQ6Hm/0+73j42MR9VxA19kdmuKm9vn5ec55f38PDA4PD2NRbG9vt21zcXHZ7/fH49Hl5dX19WR/f68sy6Oj4xB4Z2f7+nri/tLm5sbV1XVT1zu7u+6JLvGYlE7PTvv9gdvl0+l0c3OjLMrDoyPXQ86NRREPDg7m8/nJyaln/BwdHqacvQLJMUXHoa+vrzY2NquqmkwmTVPv7Oy6iGfmW7duTSbTi4vz3d2dwWB4cnLctu3W1nZZFhcXS69URI6Pj3q9/s7Ozvn5+Ww2v3HjYLkFMe7t7YHZ8elJv9cbjcaz6ex6OhmPhsPh6Pj4OOXkgQ63ffd299w4dqXlkUSPqzjDuyNxenrqwLkjXi6AOtTWiw88ZcoFtKc4O5DfoewhhC7w0kGG7sy4I+HBps6/3d7ePjo68rhSWZZ379711HAPT7sr71LbMWDPI3Ib6/j42FMsXJx5mMIV5/7+vgvB0Wi0s7NzdnZ2eXm5vb09GAzc03jmmWfquj48PPRN9FCjU51bh26D+vQdbZpMJpsbG2VZnp6dIeHNGzddYnr49fr66uzsfHNzY2tr+/j4ZDab3rp1CwCOj49iLFYFIvPNzY2qqo6Pj1LKbvqfnp46kdd1fXp66pmFbtp6guDp2RmY7ezsmOnR0fEKgJxdX1/v7u5sbm56cPnGjYPZzBl/uLW1fXZ2Op3OOkjVtZpXOsYYNzbGs5nHmvaHw4FDDJ6v6UrLc1R8v7a2Ns/Ozuu63t3dUdWzs4ter9zb23dbwVP9ptPpZDLd3NyoqvLk5HQ9+jwajUaj8cXF+Xw+39zcGI1Gh4dHInlvb98Mjo+P+v3+jRs33Apxw8sNi93d3elsdnFxXpXVeLwMBI3HG8Ph8Oz8vKnrza0tJuq2wFFkt7HOzs7qerGxsVlVvbOzUwDPWJidnp56LMXT7W7evNm27enJCYfgZpP7/x5YcKHt3rJbQv4Kf51DYtvb2x6fTSndvn2bCF955dVer9reXmZQdGlLnqRBRGdnp2Z48+aN2Wx6dna2u7vXHwzOTk89hcAhw6Zp9/f3mqY5PT11BK4LUzykyDw1aHNz4/z8wsu2+v3ByclxSsnZ5N7hvY3xhrPJfD7b3NyKMVxeXrm3w0wnJychxLUcjM2dnd179+42TXNwcCOlfHl50dUpnpyeDAfDvb0956mbN28URXl4eOiL5qDSzs7OaDy6vLi8vr7a2tp2K4QId3f3cs4npydVWbn7Op/NDm7cKGI8OT1NKd28edMtEgC4ffu2expehOAeYJch4JvoYqRLiXEEwcWaZyy47+RJNY5hba3K5T2W6x77Q0LAbQnPCVnZVXF7e/fq+mpyfb25uVkWxfnFuaq583B4eLS7u7Mx3ri4vLi8vNzf3x8MBxcXl7Wn6IRw986dsqr2dncn0+nV1eV4NOr1+p6bt7m5qaanJ6eIePv2bZ/ReLyxsTG+uLyYz+cH+wdFUdy9e5eItne2c0qnZ+eDfn80Hk8mk/lstrm1GWM8OT6Osdjd3Z3N5+dnZxubmzvb255MuL29TcxX9/FOOjs7DSFs72zPZvPpZDIajfq9/uHRoZsHonp6dsrM+3v7i/ni/OJ8PB5vb20dHh3Vi8WNmzdzzifHx2VVdbmL21tbZVV11cwhhLPTMyTc3t5Obbq8vByNR1ubm/cO79V1vb2zU8Riib9ub0nK56skqMuLy/l8tru7G4vi/PwCEbc2N0Xk+PRkPB4NB8PZbDabzobDYa/fc8i5i512WSXz+dy1ieuF/f39oigcYrh586Zbro70d8ip77hnannwx2vgPG3pxo0bnkERQtjZ3ZlNZ64Kvd7MfW8PtniFwOnp6S/+4i/idDp9+umn/VkePG2apmman//5n//xH/9xUUuSmSmEYGqaUhkLBqwXdYwFEDYpGykSxBCSZEIKIYhkESHifr/fNHVKuaqqnFNKGRG9di3nhIh+TrCIxBiZg+TcpHbYH6Scm6YOHDxJvG4aIuLuKDgwUEuSYyyKolDVnJKtDh3z/OjAYTafAUBZFAbQti0TlVU1n80Aodfrp9S2TQqRi6IUkbZtiYiJVSWLEFGMUXJOOQ+HIwCbTqdFUcQYcpaUUgiBiDz1uygKVUup8UOCRdRL7pg5i5hKjAUTpZxUl+dxiggixFBk1UVdF0URi9jUDYdQhJBT8lKhEGNKKeUci8hEkrKq9qqe1xCUZenzFVVmIiJRNQAmAkRTBf8M2LZtURSxLGazGRPFGE005wxqVa8nOddtE0KIRZFSMlNkBjNRRcSC2cxEspkxB0QTUSIiYlXxcTJz3TQhcFGUs9kc0aqqJyI5JUCsqgrAmqZlwhALL+EKIRRl2SwWhliEiAQiInL/NGgiJGQ1UbUQAhGn3DJR1est5guv1lKRLIIIRVEQcd0sTKEsSyKcTqbEPBwMmrYRkbIo1cxM/fA9P3WaCIlIRc0ACRGxTclUBv2hSK6bpixLQJAsqsrExKSiBhBjQICmbQGAAyNASpmZCbFtWwPo9/oGVs/nkckQAUkRgYiZcspmWlVVltQ0TawqUWFByxo4hBi8ZoiZvXRMVb1eyg+Q9qJJL9n0Kg3nKS8D8lR+Jw9nDf/Smc4LKz2bwgsjPFnCCyMAwCu0/ATijshns5mXNRCR1154wZBX23h5lhfC+q+8iqsbcAihrmtVdTzPiyF88HVdE5GXyXoRoX9pZmVZeulYr9fzGikzK4rCp+9lMV7rpmYcI4DVs0VVlEUMi0UNhGW/AsTJ5BoNRoOB5lyntiyrELipG1GJsYiBm7YlxBCjijRtS0hlWaSUs+SiKGKIdVOLZObg2wEAVVm2bSuqIURmyjmraFEUoppTG2MRQmhTI9mKIgJCUzcciDmqqqkSM4CZmpkSc+BgYKoamEV1Pp8zU6/qeVVNjEWIQURTal2sLRZzJC7LwskyBDaDlJOZBQ5IfkK5xRjArE0pcIgxZpGcUoghhlDXDSCUZRmY25RUlJnVLKU2hkiETdswhyIWbdu2qS1iUZRl07Zt08QYi6Jsc0qpLcoYY9G0DQD0ijKn1KZUFmUIcbGoBTQUJQLk1KJhESOY1YuaQghVVFFQCcxFWcxn8yzS6/VUpa4bZi5iNLOUcgi8pCWzIkZmTimbStXr+ensZVmpqcr9U9JFBAGQyNTato0xhBhVVFWIyAxSboqiLGLIoim1zKGIoW1bES3KIue8WCxC4F7VR4TFYhGLGEKYzxcIWJQFMzV1owZlWQJYahMR9nq9umlyyv1BX3Ju2pY5EJGZppTAoCiLnHKWXJYlEafUIsBSWYiEwMxsBjklNauqSnLKOceiMLU2NQjYHwxyzvViUfV6zFwvagPr9XoIOJ/PDLDfX4pcROQQTDXlXBalgdaLhgMXRaGiTdsURRFCzKnNIlVVIcBiPmeAqj9Imud1zYGrssytaJYYAhE3baMAVa8HZrPZzGFdFwIhhLIsvbKw3++nlLxGkJm9JrsoCgDwknRm9jizx9+85jjG6EXArk28Yo+IOjkTQvDSKK959ZJZLzoXES88jTFksVY0xIAgmlo0i8RgnLOaoT+tSXWIgcs4rxeSc6/fN7Omrom5LApDUBEEREQ1g9X52UjEhGqW2mQAMQQfsJkhIXNIKZlqr9dz7UZMRVG2TSMq/V5fTefzBZiVVUlIXsZaVVWWnFKuygKJ6roGg7Is0SDVNQD0hr1a2kVb94teMIZk0qReVWHkq3qiAftFpXXWlDlwCEFUJeeiKJnJi6fLsgTEnHMMwctADaCIEQDqpiHEqqpSzs7XZVWqZs/MLMpyNp1myVVViaiKuFRXNVPtxUINp5IMKSKTmJpYxRhBWqFkRSyMY9u2YNkledu2ZlZV1XJ9iLxE1bUMrg5I7qS604lX8oUQ/Feuepw8/LOZeYKNHzwQY2RmMBDJqtbr9dq2yVlU9bd/+7dfeuklZvJg1N179/76X/vrOJlMbt261eXsOzL8zDPP/PRP//R73vNeZMbAqiIqAankAG22VotYEPEitRmUCwaULNnNNVNtmiaEiAg5CxIWMapBahsiDoHNTFSZCBGbpkXCXq8y1cViOT2fv5mFGBFQRJDQnxaImIOoimTXHKJZRKuyBMTFfI5IZVkYwFIKcMg5q0pRFABWN0vthYiLRc1MVa9qm9bFRAjctK2qRg6AmFLr+5FyBoMQAyGl1BpAUUQEbFMCACesnDNxIEIVNVMi9oLNzjxSMwQgopQyIvg25yyAiByyGagFYmKSlE0lhmBIbdsAAIdIjDklAHTF0NQLDkVZhLZNABhiFJWcE4dIIbSpdbGFiCrZzMqiNIS2TRTYzyuQJlUxBgpZUhYlZkBIkomImEWlTYmZA5GkJjADIqwuKwkhqJqqEnOMQbJkSb2qZ6Z105par98ztbZtmAMRigoYEhMCpJwRgEMA06ZNhBiLwk1tIiKknJOaxRhNtU05MocYVDSLEHNZxKZt3dgCgKZeMIdYRMkqKrwkD8kpMQcO1DaNiPV6lRm0bYOIMRYGlnMOzEShbWtELMoSzBZ1TYghBDNwZYlIObciVhbRALKIExWaGRgRI0KbWrAlK+acDJCJzEzVAkIEzCotmhIbgogiQBULBGhSA4Go4LbNnKHi0mmGVlfDuBHsZxR0SmJJVKvjpd1Pc1uz6+BlrK5OQghudKqqm7NdByJy/RRjdPnSnU+y/jR/daec3Ob2L70K2Mfjtq+b1H6yh9u4neBzFehObzcGXF2OEFb3xfiM/OQKf4UXI/shBt4hrKQ5AMSiaMRUpeIYAHLTIkGoykZzNkE0MmQDkEwhGGDOCQFDDGbWphRDABcyCCFEM00pE2GMhYiIcwSRqubsi8l+bEJZ+mntDQDGEAzArWQ3iBExxAJM2zYxk1vtIloUBaLVdes+mxmICBEyBy/D716nKm5CtW0CsBh9nJmIQwht25hBURa0XB+XnNa2voDBXfcYyxB45VCR01LggMut1xgLQmxTa2YhRECUnAGsKIq2Ta5BiyI2Tdu2qSjKEEKSLCpEiIRZMvlVMqsNDRRy1mzAZRSAlFPkUHGQJknORATMCSSrDqtSU86SiZCIc845p9Kdh7Y1taIo1DTlzMwcg4mkdonFpDYREYegpq3TTChMQJa4A7kvHWMUySkl5lBVZc65ruuyWq6kGYTA6DJHNYQIACLZeTyl5K6gmS3VbYxqtrLtyGGOGKN7EWbW7/cQcTqdhRCQUO8rb78ICYqydFfZ/RbnqRgLVz2mWlU9Vc0iCEbEAJZSYgoclmwbY0G0vuOQUmImJJKcfRMRUST7qwEsZyHibk18AZ2omIOqiSQ2Kzlk09YUYkCm3KZg2IslKqScITDFkERS07pk6ESHjwHW4CeXYD5glz9u8JVl6ScPOAt3yFf3NC/B7+SMy711pMlf1zRN91h3712CtaIQK0AwWUSQksmSaYLAlWGQbEDGBRlqk1MGV9MmIoAQQ5ScRaUoy8ihaRr3uFQ1S44hIlHKSVIuqxJckRmEGFRtZaxHVXOJEUKUnIGwiEXOuW0bJCqLsm0aIubAqppzQqQQWA1yToGZOWTJkKUCDIQ15BpT0asCcp62RcPD0DewhTZtKblASBoTlBwMILWtuUPlgAizqaoqIsYQOIT5bIaIZVkaQNs0SBRDEMkpZ+frul4ASFlWBpZTQkIi9v2qqtKNTlUriyIKNElmZYGxoEa4ybHk1LOpzCnrECuGYpYECPplzDl1TkunWVxx2Oruqm6XO5oBANdu7kSJSEdUZsZrd1B0T3DJKSKmWsTCZV1KybPb/+E//IdeAe81oyLyN//m38TJZPLUU095+rOTrx8f9qEPfehDP/pjgWMjSUyAgJBQFJKUIarjlyFSYBMByYiASIQAgA5AOuTT6/fArK4bAHC00iW4A8Arnz74QIkwFMWibSiwqS31H0DOYmCIGJjNQFQCcxljqtuUUlmVIYScsqgw3VeoHFhleUGd+xaAAAZuXhdFEWJo6rptUyxiUZSSMzx4JYcTU9O2Va8KHOq6FtWiiIQkOasZExmAyxFnYARAJjBIKXFgDiE1DSDGGCWLmZpBYHb1AwChKJJok3MRCzJrmiYwl0VJiGmlGxBITLiMBti2jQEWIZhB29Qxxl5/0KSmaVpmChwELKsQUkBUUzAMgVShaZsQQllVWXLbtgEoIoGBuhQgTDkjIgdOWcSkKEszaOtFJOTVVVi+mKrqpImwXFImLDjWiwWsEIKcEyAyB5UsIswBiXJKOed+v4+IfgRJWflME8D9q6FiURBialtAcGdOAZhIzRp3AR24alsRcYeyM8KcXcuyikVsmyanxDHwylP3p+UV25iag74eVDDAEEJb11lyWVVo0KYEYBwCAqoqoP9KzSDGIKJNU4cQy7LMOefVAiKgfy44QBZgS4itLfHmkhjEQCwWIYEupBXTsqgYl2CJ87bbeUVRdCLDzSPXas7b/tmVwUMSwT+4tnCR0dmdbpgy82KxMLN+v+8axfHmFScuTUwfT7f1/ljHkv1Xbto6iuxIjwc3OmnV7bgjuD54Xd0L0+FDbmS47evQTq/X67Bnx4DXtSysbl5UsFqhKqsKKdc1ioWCjXAhCSMTAmRls0iYFbIBEZqZqSEiMccYJ9fXajocDhEppVZE/DCc+XyOgFVV1U1jZkURndJcaZlaFjFzT55UBYldrBMiEhKRS5OiKOpF7evAgetF3abWrXlVBTCmIKoezymKYrGYi2hVlUuFIYLMjCiqCLjcDsePwTwcURTR1LLkEAIimSoSdLcZgi3/c64c9Ad106S0smNyVlXy4IYqLO1gmM/nMcaqrERVJUeOljTnFMtCTFNqmRgIY+CcUts2RVkS4mLeInM5GAjYom2IQxkjG+RFg4CxLFpJjeayrEAFTRBR1VQl50zoKllCiIE5SxZRYkIm32xQAwARzTkNh0M1W9QLJAocTMBUEYiDe4bCHEKMi/lczXpVZWCpFQ5QxJBzyjkjEROnlFzOqAggEjEzA5gX8RDSfLFwTjTTlAWdQxEkZyQmQhFBQFc3ohoCd8TJzIFXdl4RcXXZlbvHjsswc13XKlqUBRGlNhEjApmpAZhZDFHNck5OM4slTFiIqKrEWHhEDgzUFAxcTCGggaU2hbhEZ02tXBJVUhX33iWLmfViRMnztg5VD6tYL+q2SRv9ARukOgFS0a8S6GyxqEJwodRhEGmJNLGzsHNuh8520TwXUPP53FOcO5DY3emugwdOYe22xc7RdbTYocFO5Pp7l/qdQiNAjAEzWWIEy6qKzANRbEWQgINlaSMVZSxFJKXWTaW6aRAxBBZRAAscAEBUzdRnJyKmFkIwsJQSMZexcCxmKX7NsmYEZGJVJUJAv/Z1SR5ElFMOMSBi2yaR7HLG3el+r6dg9aKuQlER1bNpqykMSwokWa2FYLEXe22TWmzjODbQpqQlRlMFQGY2ABVp26YoyhhC3TRt2/Z6VVlWddOY7ziAqCJhURSScsqpKEoOIaWU2oaYq6pMTdukttfrmUJKTVEUpqbggVNigDRbYBllPKpb4VpGFJjtUieJtQLq5QgaFuCh4rapF15K4U54597D2hWbHYq/lFcrGMiRYzcVvKShC2b6E9bRYsdfEJFg6bV2OvTll1/+jd/4DQDwc5k2tzZV9C/+xb8YfBAdzuxZGs8///yzzz4biFHVR2oKigqgFCkzqJgSEpuiIFrgAOpJCUuJm1Jmjr1+AQZNakIoi7JwXAEgeFTBgGNgA1wsGkQsih4gtG1i4ADR0IiRkF1LmRkgBA6qSkCMnLMRx34sAaFpWgAsip7kbOaxCyOKCAYE7FSIwIBqJqpFURlA22ai2O+XZiZZDdx6B5cgYNYmAcBef0hMbdMCkOOIpgbIaGoYAAzMkAIDL4NwhoBADERMwCEAABCyMakIoAEGQAQwRBSBrEbIAGCAzIE5gLpqAwZiDMyUhdBYQBkZEQMFFSljSYiL2RwR+2UPDNrUElHEgICMRKAAAAIquVdUzCE3OaVUxBiAQBUMCBANyFA93UCRAYliAFbTgkJkdq3DyEgIYAJqqOiYPLiYtaZJIRTMQUXbnCKHEAtTRQQkBGDHVEIoFDA3iTmWZQmAbWo5lGCGRGCaRFUBCYmjASAyoKEZIElOMZYc3IS1wEWIuNwwNDAwIzOLRYXITd0CYNUfIGJTN0iEiIjs40UEAAJSIgZEFTUwIkpJALgoC48ZIXJRlm4TACIAIpChIpgaqRlSQAoGZIZEARARCJwFAQHZGBQBEAIjGLIBZsMkDMSZFDBaDIyoqOhK8YH7Zt067ESGf8DVfdqd3e/N3RLXB52F2gkaF0BdXoEbWx20HFZarQNiOz3tffxpuHbdtEODPmaHdbsIJiz9CXPjeD2dwzt0Himt7na21f3qtrqaUUT8OE+32juEYN1BRURCHFSVqTVtE5lj5CypbVoM5LuG6DwKqJ5+ElQlWwYgRMptLsqKiUww5ZaYelWVc24WbQgFGrZtRuDAhECmgsCBAiEJiLtOSEiAhkjodq/R0qlCn9hi1iJTVfbNsG0yU+z3S1VFA0NBA0QmwCIyE6c2m1EMAYzbJoMhYURABEQjJDBAUyQOyCCqHIyIASFDRgimhAQA5NoKDAwQEMwQwEIoEamuWxEti14IoWlqU0QKiERABggAaqhJyrIXQ0wpt21bFiViSNYqkBoQMnNJhMyc2mRGVTVU0WxWVj0A1KSiUmJgCNLknHIRIyO1TYNIvVhKElNBAGIkICLmWCCAmREAApkiKCEAGIOAEwUAgBoR9coiJxWRGMoiFjlL0uSykYAUjAAAqJ7XiFQV0Qyapg0cilDm1KpjKcjMrApOeNmymoGhCgBAVfRUoU0tU/C4eUqZA7trA4CKgEgASKutBwAEJGQRF49gAtkMjBDBlAycIpY9iyKCQVMnglD2Ahg2TUNICIyIuJwI5iRqVhQVAjVNo3mZ8wAGCGAKBgjGiBAoqBqAoaGBmUEMJSK1jZi6z4Z12+LyFUywJBPJAGJVOcAY6yarYL8aqgCIMRVZdTZvlDCEkhibpiXCsizbtnWn2iUAM6+CYPdjO51t6n61O95t27rT3llCunbDsIuULkLVCQp3tl34eOqLv6IDrdAAs4alh6sZzRAyIqBY4AyGpEBKYJCzCaEaK4CKIYQMITIbZzURBVFTRTB2P1KMFMCAESQrC7AhmIYMbBSMIYMasEdzGVAAwBAFDYgjIWnWLLkIQeosqjGEXuhLzqmuGbEMhSwygPWoMLF5ajDGHlem1kwbBQhF1SLNck0RiKltagBhjglAwADADREBCL1eMqtTi0zc77UAdbNAQGQmJlPLaoE5pSSSYywS4bxemFnR64HRtMkIgcqizqpqHPvCIWlSUwQENVWNZanBrhdzRBqWZU6yqBcWoQCKRphN1SxSK0KaHVf1ZAyHY2zVVsDTfWXh2s23vgNluiTPdbHfkZaurmR3HYeIvELoqqryPEA/Yvn555/3msjRaPTqq6/OF/PQPchPzveTMpi5V1XmaY4UCC2BGhiEYGh1SkzIzJpTVokUEoWsikvSXMZDy6JoTOumJuRY8FyTmMQQlMlEgIxDaP1yY0YiUve1QAvitmmIcOkTLAM6IKJgFohEzURaUyqCEqSUFIGZFpoUjAObgYolTYhoCgAZEQ0QTAEAGYx4UdcI0O/3xbRpGiSMscg5mxoGQkTJ2cNnwNA2tZnGomjQRIWZjEnFkJbYWCNNDBGYchbRTEAUqUktiIeosM4tEocyZBFFIyZFNtVsyQKGEFLKhhZ7Mas2bSIiZDITMWUIiJobj/4EBJS2hmUOYkr1ot/vFwRt05JKZBJ1nzcg+ppaJAqEkhttc8kcEEwSA2EgyQYqYBoRzDwyFRghzWeAWBaFqebc5QxZzsJMAKxqhEugMWWxQFSERjTnRJE1hIUm8YxGQLPMEDAyqDVtjYBFVdZgObVIqGQiyogcgmJe5BQoIkPOmQ2IMKtYTsRUFEUSSSnHIuIyviYcWJBUhIJhCIpYp6SSY1EIqCQBAmQQEVQNHJRBxYiMAquBoQGhGZhq1hxiIIQ2t4gYYphLq2oc2MBUZQWsoJkiYyj7otLkNsaAiCkn00TMwKYirWZiSqIKwBQZQJJg1ooDUFhoEiKsekCY2wUvLbWlIejE36VGeb5Ul063zCzP2UERXcW53HK9n5Bd1wDgMUePPzqzd507rJeI3DjuMJjO2O1sX/e8OxvXxY1b0h0o2z3WX9Fl8i0tjGV8NviAV7nyy9iW2+VdWoWHj/wYBweG14Ok67MA5kVbB4DCI5giIQRlTCIqWiCTgaSExEwRVEGNAc1M2mUyvYEt6gUiciBJWSQTIiqYKYIxMQC2zTJf08xS3SBRWG4BGhLqMmEmEKsqiFEIappTzqntDQZEOJ8tmLCqKhXVnDkEBlJVAyVEAMwpgZqnyeamAaQQOGcBVWMCA0nqfpyJGAIjeVZSzlLEiMEhdoqxkOz1AwQImlXViIgDqcevi0gG7aIxsMBBTU3NEAhQVEwVkQqOkkRzjiGa2WQxs8ghxlnbAmHgoGYo2RCISBEFAJnLwJqypCZyIIScagYMTAiqKqBCDCggKTsZ5CwhEBODe1mIFMucUtbMIQSKuU1GQMzLoBO6kgP3aUMI0mYTLTkamIgaGiGKgaaMYDEUHouLxETU1AsV4RAQPMvTCNBUVSEQKZqKqmVEJOLUtoRQxEJEpU1MxECSxQKg77gIEgZPN2yXMf2cEoCHxSV1eeqGklIXokGAECOqpZQBIBbR1FLbAgAxg5vhiATuAGsRIqrVzQINe2VlIh6zNqC2qQMHZm7TMhHFsRsAYCQPRxhAGQtRaRY1Isa4LHgwQjBT0WxakJdwtEkkhkAI2goBcyBDTCpIxIHrxYwQiWJnwdiylAU728VZG1cJnbzaO/ex3Rl24HMd93Xrx0VcJ8o659+xXi8w6EoUOsN3lQwmBXMgNrddiIwxC2YQDgwEqMKkkUCzptwGDiFyShnAqqpUtZxbIib2AJTEogADcT+NwMxEhRiLshKRtq05cKDgqSbMBODlN8iB3F5kJnTjHi0EAhAAI6bAhGgmiggxuuQ0F//ZcgsSy8IotG2yooAQ5ggJzQokMLSMIgEATA0AmcwsaXZIxwhyEjEtOLDXEamURaFOVATEpKZqRiEAY9M2y+iimUgGICQyAwVCBgNs2oRIRGym7mpxRW2ep6yD/jCI5rRAyAWTSYstBi2FWRDFtB+WifUOu3TapMtzcCJxmKML/66DL118wGnGlYVbrf65w0fM7H70EsktZoddmHk+n3eni56enqaUmHhJYSJSlqX/gZmfffbZ/mCQJXt4ixAZyMAUIOeMYJGpQCCiwAzEraEiIBhRUNOMWMYCEOtFXZD1eoWZzed1EULBqAYKSITMlJJUBZdVJSJ1vQDEatjLIgaZCEMgRUUzimBm6N4bIpAaWD9GQMhtWxJWg56ZLRZ1LGKIQUTykpiWsoY5IoIZEiIFyilTwUUsQqC6SSVjUUREzIZA7rejMHEZmEPbtgGk6lUeDy0QQ2BQE0BmJCbJqoZFICDKCKLGRETcalK1kgEAWIECMGEAREQi8EyIIiAGIoJWFQFjgNTmECAGJgQjRANENdQUlAKHgApgrRIzsADn3jCWFUlqRJteryLGNhsZuPRwsISZ27YWyWWvKMuibVvTTCEgOWQPSI4WWGQMBYGBgDJxUWJqISC5ZQBmDm051E8IiIpoTFiVRc5ZpO0Vy2QA01SEEAIKoSoxExGmtg1FKMvSEOezWYFQ9XoqkgFDoBhZA0pGJDazYEgMjlSAYQxBTSQ1BVK/CCqac1uEQAhMZr4vgCI5FhT7QzVtmpoAq37PVDJmJGQmVVAyQgAE50AiMkMBqaqCmVJqkaCqSieqgmMIZIaiSISEqAZmFohD5LYVQq0iEVELogocCA39dYGIyRQsMDKACsSSS46i1mYUxgySRYsuVr7SAR0cQstMYl1Pb+icXe/T2aPrP7S1p7lQcAHkyQ+e4+seeZc0UlWVoyydh+0fOvy1kzv+ZE/McPnShTs7I94FmT/NJZeHPv1WJNeILua6nA1d5Sv7z7vaF0T0gKmDRi4Z/fmqWs9mKlYVhZguFgsK2O/3m5wJDAAIib3mMRBGFFU0QFg6PDFExdymTAX2qkpNXYws48UAfQ+5ppYKYGJizKKGQATIQAQeyQFSMyCfvSIAALljBVWvFyK1bQtRi6oPBO2i5iISg5khgyeNZUkGVvbKEELd1GDW75eiqiQAiISoCmrEyw0FACQwBBNBtFAxErIREYWCLLEj0mAABAhITAamOZfDIsTYNnVrqd/vE7NbbE6ADsbGIqpolhT7sazKelGjaVUWTNQaIFhgyFlVtSpKNW2btl+WHLhpa0Wp+jEGTm0m016v4hBmi7mo9seViOY29fsRA+cEKSshIKmBIRsHJgZDNEEKxr68CESghmaEiMQmWWM/hMCStWkXvaKKVWxTS4xE4OEgAiirPoDVdUMF9nu9lFKzSLGKIZCqyDKbBMEAQIGZACkyGABaSilUVJWVgTWzOvRCWZZt2xAB8hL1ZzNi8rIIVN99QwRm5oAgyETEFJhFEcXjYBAEAZEDNk2LEauqVLO2bixgVZamquYQF/gWl7EMMS4WcyPt9fshhOvra2AIFZtZVqRIxEQIquLk5KE5Zlradn6w6byBCL1eaWaWl1MAMiSLHIoYm9y21oZ+VYRYL+ZFGdEsSaIylly2aGqCTL2ySil5+bLHpt0YVVUvgHM54/52JxwAwK+Ia5YFlEXbtl5vgKt8RZdank7gZkkXjKrr2nN1/Igqz6dyCea2souTMjCImmRDM4JWTIC5iEiIKqWmKrWQUsKYKAoLEbaawAAY2tyoGhMzsQQBACEVEQNjDgCmqmAYYxCWVlKLTcCIgEnaEAIjC4qheRTCo4BmlkVAjZlDDPP5vCzKEOM8zdu2JaSiV8xl4WXEgDCfL5i5rMqszbSZC4ai3zeERbMIBMNeqYuFNIthVaLaom0wRoQAuMxrIuZmMSPAqoiqdVooElYxmLWaExEjE4KaWBkjojTNXFWrskSSxXxuAv3BMOfUNm2vVxHzYjEztVhEJEYwQqAAKjXIol/EHiZt55ib3qBIlCQ1wZA5SoQ5ZzQb4LIIz6tKPI3BN9SREbeDOzepS+111eCpQZ7l6Jqla12swAmsw4AdjulVPUT0mKQfJuhHxPoZsn7ida/fx8lk8vTTT/uxBgDgJ8Mh4ic+8YmPf/wn0DDlTIgcgxGk1JrlQVXZYtFcXJaigxCTaIJVxr2qKxpCypLBrIheM5TBVknKDgsRyf1yQl1VhqEh1ppDEQEw5QQGzKRmKsv8/SwiIgWHKhRtXWvWXlUZQMotETGymKoIIXEMssqk9pgTLFN/zdSWySLZPWb0MweIGQE9hyEwIWJKWURCDIE4i6hZEYIhSM6A6LUyOQsTL5/tUSvEnAUQfDwIRkhq6rVTgaOZpJSJKBYhS045cQghsKipKhMRoIkQYEEMZovUagyhim1OKeUQAzDllBExcjAzE3FL1x27ENgAswoShSJKym3TFDEWschtWpWfg/O2713KLQLGojCwlAQJmVBERcwllGQREWIy30G3CH1GyNGwaWpPXG5Tm7MEZndM1UEdWmIA0Te3bQ0shgBAogJLjA3U/IOlnNkVow+SAyC0KTESM4uKZCEnfRERDYFD8ET7XFZVIF7U9bKmYVlx7yd7aMo5EBlCSnmZSQBoaAAIBmqCgMSoYmbGgZlYVEWFEANzSllMYiiYKKVsqp7XpWpq6t6TeGYSs5oZmKKZGSiAWBVjTlpLjhubOuhPQDJYn5hU/aAMF+Wez+RKpcuuc/bGteSHLsNhvQOskgdoVUXnXnJnJfuvOp3kXvJ6RUKnaTo8WFfpv136QfdkXNYLLq3tdVvcYWD37DtvHlcFc53a8w7+Og+QddPsBGL3hA5VQkQDEJWsSBQKAshiasQIgZJmj0izWBALalmSWCLHv1fxMmZu2trUYrGslkCH9lRVNDBzcPmrvX6fEOt6gX5ShKpkZxP2KvvATERZhZkQUFTAU4Z4lV/LwVNaVTyZuyvpCCm1ZhZXFRtOeGYmOSMgh2CmKSciDiGaqufWeO49Inoxhi0zZ5b4H60SFsmdNoMsGRCKoshZutK6nJIZhBjAIOWEsAxnq6mfIePJiwUHzSIpFSEGYhU1UWb2swswEHEw01ZaZSxikJQwW1FEAWtyQiaKAdRANCAF5iYJuPwXd4SMmEU1Sy6KEgnb1BJgDBG8AyG6fFNDxFhEU01tS0iRQ1bNqhwCIWbJqhZDXGXoosthACc/yJI9uTCGqCaIRIBtTgDARAiYVWC5JpZSQkCO0VRFMofgYkQkhxiJqG0aAIhFKTlnyUX04jNRU+YQY5HcSwwsOZtBh5KmnMpVnb6noS8LFjkge569ETHTUustk/7zskLA7D5IrOZJLveL3hAxi5gaEyGjZEUEYk9QFgfRwSzlxMQFB0kpaYYYMIacsyXphdJjGhBDi9CAciz71SC19wvOfC7O5i5VbFVs4x4ar8pbnZ091sQP1jPZqooXVyUNvFYU65zuT+gkQ/dZVwVSDkYHiqhm2gKrMU5TSkgUC8wyRrtRhG3TPJ/OYkj9viiI5vX3LhO1VcuyRIS2ab08lNfYFmBZ7uxF21mys4xITuLl15xSRjDigLAEMz1HcCkMkbKIrkqVsopXvTtXFhwLjtfz+irntixrAMl5HOLTo2EvNUXTFGAcuJXcmGkocGlWiefhyPIV6EQeQvAztdTMS9jNV8xzjr3KZZk16/ldllUJ0bPwxZQ5gBncz2w1k9rYoChQkBsNABC1xkTZKg0A1SWHb6M2bVvMG8zSaZMumCnrBYtt24EmnTqAVenbukqCteKW9Z7rluTS8wO0VUk3Ih4eHv7mb/6mn+7qBXA5pT/3539pif4uTebVmWqXl5dZhIrQNI2CFrEU0bZuyxiKWJViVyfnL/z+F+DyagSMOSsqIaNj8eD6CVx6EpGoghkxmZlpl9IOHo8DBJVsgMyMACYGoMvEc8leULfUrEhI3ZFVBIhJMwI6S5sKhYDmebOGSEsLBoyIwMDtcliJDOxAtRX12+qYMDMFAx/wMqzDDMtgK7k5bqpe62cKakpItnovkucamkeD3BKitaBzh+cRIgfObdvmXPYqQxQTMCBiU9EsvaIEz1YWCcQcQ93U2bTq90S1bVNgRvQ0X9CcPTUHiYg5e8I2kh/d5aYbAkBWJjLCpOrLgQQxRBFP818me7u/m9oMCDGUZkuIzpNgmQk9YcBTrQmzmpowL3MA3G9xh8MfiwBqutyXzsonFDFPl3Ytbh2pmJJnJpsCGBJ7bceqYiP7UXeeyw+qyEzLLF7nWPDwBRFlyc4zuAzVuV6HZT4TLLP2AFFXNiXiqjYxLAWxmhIyEFhWcz26OgvCK4g9685TL5eRL0JQM0QD86kBAlFoDVrmWx/8wI33v5fLkCKnlHv9AQ0GLvo7sX6fVFan/nVeb2eP2ipZtoNdu+DRuhZZzz3wZ/qa0KqgrbOPO0taVoVu3TOn06mLVL9nEVexTl/bboSdiurGZo+kI3c9YRX97IbRWdIdy6ybvN2vug5KAYFIBc0YSdHERAkm08liNgtGkfj0lVeOv/LVUV0XRAbmJpSjcauaJ3L5RbwkEpcty+Qyg1lgRC9JxGUoUMHdJzAVVV6RgftTpo7e+Suc8dEATM0LhW1lySGhinp6nqktS3gJncgJCWl57ooLTBGj1Wp7+j2Ak64DyWgGiIYrJUErobT+OkRkD4P6qWFMYL5xy1PDDIAJzfmIGQIlySIaiAOx+a+QASFnNSZkzpJDINAEKUWjiEQArUgLSmUEptSmijkYoagoivOXez5gHIKotilVvUpEfBgMgGpmQEwYQ5NaBSODwAwKphqYTTWJAiGsFgoAiAOYGpgbGR1hm8mKnYmIDFwIgNc8IS5tuOVCuedM3J3kQMwIsGR2p9ucwePdYmrKTGDYGfSEJCpeZetfIhICqikAzD1xQoU58Koc3KWTKQDY0rgRdamrairKfF9A0bIu0NPDndnBKbDbWbPVrwglq4GTBAGYihIRA3jgG2IQMBVhoAUQKiBRJpirhGHvqR/7ENzmeRYD9POhPX+3C0l3FnAnMXAF1NkqxZ9WlQO4ypfw/o9at+sNH1SgnWX8wCsAzRBUGQ1BlIyn84vpVOq2Ev2R3d3y5KQ6PysXiy0ii9EMVNXDmc50RLy0FAN7GudK1C9BMSY20yxCQBz9eFAjRA8kmocnVlWqRJ7ThJ7UrubJ+yuDGNERZV05Mz4YQ5yZ7h7szzZHX7++IqQ+8XuGvc07J4tvfmuzTf0YFiZAVgBF44dWyhWQl8LYUjagmyvLVbWOqDqOWOIj6CgygNf0mxoSILpgtFVdFKAJIigSKBZKgNZSroKwUalhoXH7YP/DH3jXt9ppo1pUlcce+/2+hwXW93HdzO3IphP4HdixbvKuq7nO0XJjum3b6XRqgJ6HRquTi/zK3u985zuI6PdOX1xd5pRD51ptbGzs7u76We7b29vD0bDJKaOVRQEAkhIpFBQoJ1Yt6pSPT/TeqSkFFcZlbQKt78PqmIUAj2/cfVhW3gMAoAGb14y85g+9rxJ0hU+09rqHP79+63quPjw8yLWx8aoPP9Tndd+wPgtee4t/ZkRWiGYYqFVxpRVibOsmMgOSiRJiVGADJoacsgnFiGDkR0+ooaNEar1YOpsZAZl56QgSGoDkzMRsACKIZF605qcbAiARiAQPm8GS+FSE3aBHFJFIyCF4BvZDc/Sn2YoRi9dYim6h1vdofX3Wv4fH7Qiv7xc8ZpfXP3fDiK8xDH7kFfzan+//c+3V8XWHQQDLk0HAFMEQ1ECJMlJbRLx1Y6BiSjlp4DAaj/wUC1yVl9kj6wwrWd+1x/Z5tNtr9Xy022N7+qjcOJ7P50Tkl5Z3nR/7nD+eZgCKDAYERgZkoKgKoARtapvZjMwIsbmeTL79YnU9YUR73LBl+TDUFf3Z8ksAgPsZDQAAoMsn4H1Dfu0J3YeHx/kAZWP3fffPvPogaz/U+zSKa4PsfnX/rz6wtcd2T7j/Clvr4JDhQ29cG49lADewBSCjKQEAZAA1D4QCIhmhISlzmwUQJu2iF7BPIdVNwJDVQ2rSBkimBNgamVgwZC5UJIGB+zZMRqQiaApV2dZNCFE91kcMSBnBEJIkCgGImpQJgAwb1eBJt5o91zZGP6WhJSJClmVRNpgbnWjdsugD6/Tw+nSLpmv7JQ99b0v3eW3vHugsy6pZcKi+e7gn6Mrajos50aHcp5P7zV77FQ9SAj745for7nd4aEaqnmcHguiMoYZiSGZIQQlUM26PB0+/o71xQCGYagjBj/12YbWeiQsPctZDvOb/9P6wki3wSFv//tEnPFYMGqICglokQMsKGDihWFAbU+jP25c/+wf1V7+6k3JpCGrdyUUAy5V38A7gQRXnKM59UY+wChUCmCffLyeOrgttmbHTkdpq3R+j2cwM7P6vDFrCaS/e+tk/0fvR94d2UQ2GG0hbbb787B/MPvv50DSZ+BplXhAJ9oUeWjt8rB3zRM0A5fFm0IONDbxihoxaxYxSB5kHCcalxkXoxw++f3xzp2oaDcvqaiJyxOSx2/2E6mMdN3noh471+M3qOeUYQq/X6/IuAMCvtvZLj/1arhDjMgnDLeW6rv3KUL9NSkwpBhPMSQIGDJDaFnLbC1wiDA0p665hQMtmD270ck/fcJJLolnrqQiKy8Ld12sGZECw9tqH6fUJ3rve016j22s/9klf8eCwH/qMGZiYArciydSYFCE3dWEaDaRtCg6QpOqVTUpiwhEFMENLfsJoSoZWxhg4MCKIOAonbvoiGIGimWrZC4FYm+Tn7wqieS4XgB94aU2mWBBCTq2HgGOITOTVIGiCRIhGJAC4DkYCACowAD0BET9m5V9riR7b4ZG/vmnD67Ek+tgHPryVT0YSYEtfDjz5AcwAFEAoIEJGYTIMkFEXORWBO6z3B2v+vpY2Wtc9jvh2cM5jB/DH1mwJdSzhDjVQMAVQ8/AMgSqoBsSCjCkvD2f0YPEasP3Gr3moEbxJyvuPs7EBqXnaNBm4jDZALmItknKNWUJZQUSOJJqTNYPIuW2JCiCxSAoWmPO8LYgjxybXFIgRFQwJRHJWQSZQTWqGydiQoCw5KOTcmhkGLgoSzaKmKCGESCxNBnCRJjEgMTB7gRGaKICs7BUAQCBbkswfc3usqHljeOaPpRl4vZx6/iEgLl13AjBDNTTDbNgatMTIRLLG+4+VA491oV/rn6/Fg9/tT/x8Fz/NovsSAQumEcdhkvLiyg5PRqIlgsLDtpRZRxj3LdUn1C+vMYWHHNTuyfjgXx94RUCaBMgXZz3NIcYFQ5tba7FazOj6aiPPCvdZQzCDqPbQ+L4HgWxL//p1Z7wEKIH8dCsEAFCMiqxoaLlIodb2WoqMyKDmiTFe5ew1JG/a/H3MYPwIJyLrEvNgmUbsRSN+9vx8Pp9Op37d4KuvvkpEG6ONGFcnHBGRXyC5v7/vtxdeXl0VRZFU2rquuChiTKlpU1swCqhoIpCIWogJqgS1B83fx4sXfOTbR75wkOyNFYuBroj9CRbpjd/7XXT7Xl7xSPNCBzJoQazgjJhBWtRyWFWDgeQ8m0yRuc5NL8S6bZFD0avQpMkCoBaQgAUhi0ZkJPA6ZkOEQILWeuA7hka1aXMvRlVpm5aqIoGJaNWrZnUdKGBZtCoBAveqZSTG01ZBIWKIQVWzZUMlYqMHBRMBOJj0xhN+omX5LtqjK/+E7bV+972QwSO/WibcABi6cEVFFUJlbMhmIIvAEqI86Nraqj3mqU8m3d7ybl0SxeuM7QfbcGkIeyYNIC4v90PE4AAjGJDhErUx8ACI2qPq6P4z1z7ZgzIa7QHF8xD+9pBOe8O/rr/x9cfzJv76Jsbz6F+Numiq2wkKyEZ8mWqqylqMB/1yPMrz6fV80sc47g80A8UoDC1ASwAxtmoxMmFMbTY0JBAT8WAVgxogGUdOkqnkDH5UGDaSVBWKICDEodUMCFxQyjm76wgomoEgEIlq3cwQkUNALy5c0oXPxRAMwN6qtX3SlX+EfmDphH2v+/IWjHb5Z8KlRW64TM8BAARGIDBCCGiE9mD7AYZ9HtMMANVP+wP1Iz2RmAksNzUAjQkGjIO2KeFh8MMA7BGD2AXJk735EXP/idXGQ69YIPX6vaJfWuRF3U5yJrU2gBUEwSADgTJgYQoIJemjAMYTvvcxk3jCzUQgMwQNZgQAaAWYIhSGwbQxMVMLKNmyqqcewfdHqemDp+YRUfATIbN0Vyw5lR4cHBweHp6dngHC7u7ubD5rmmZ5u4aZ+W2ovV7Pb58vYpScVSQglhy0FclS9itES6lpICdUZss5Z7Sa8ZFNeHhT4TUI4qFu6JkM9sasK36q7Rtt2JO89LW6PbbnE77iSX6LAGgMGJJBDUgcptIq0+13Pvsnfv5nt27eaifTb371K899+av1xTUKYCiM6Go6j73y45/85Gw+/9KXvhTAxKyIURQQgJCytgqAQMm0VeUQ3//+D1ZF8bUvf6XJWnDkgjKgEOzfuPXBD3zgC1/84tXFhXv6ourBYi+NRzE0C4AUAoGIKlNABLUHBTFagifA7J9sPZ+8PbmIeWx7cyT6pM38t9Y9BFf+dQYTwgRQKyRmitGaVbc1dfL2US2dqvMqE///D3pQ99vjPCC3fkVFmGJARgVQxQ4Y6mh3TYQgPPDPhx/4kPFh6w96+LcPPeRJ/vroPx87njf31zcxnof+qmBKy2l71NjAEoj2SinC7Wff88lf+IWN3e3zi9MvfuZ3X/jqc2KkKQVmQxaw7YMb7/vQj37ja187felOCRrN67X86kRUMzVFYgPIKXMRP/bxj59dXnzz69+gbAEolIWgtal9z4+8Z2tn+7O/91lDQkYAZQ4magZkmNpkZn51synYMmOlc1SWtu9bu7ZPtvJLqPcBjbbyxV5/5d/wr9/7aO8vicHKR8Cl9DJ3fUiNFFBUxR7O7n2bOMMIQB5zW1kQBtiqqbQeoEbJUfMQlAHSE+mOJzdh3+wvH/ltBmtzmksCA0NGKpHRirIOWAeboYHnzJih6kNOOHRpgW+uPWz/P6YZgCCIGa18SDJAAUYo1SrF1oJgJAwACWF5PNF65u5bqNfWkx9slfRvujw8xI+6BwA/zuH09LQsyxsHN+q6vry8zDmHTrGNx+PNzc3z8/P5fH7j4GA8HEmbELAMBahKzn4wVZtrYsgRM1sizaQKuDy28uGhPfLFwzv1uG625Lg3NH+fkOOe6KWv1e1xPZ/0FU/yWwMEilBkMwIEY0mwsbX1Z/7z/3J7c/ypT3/6Xe949s//jb8TBr/2uX/9m03TRA5AvGhlsDv+yE/9zKuHR19+7usppVTXW4Nq0TYBsCROQsBUFr1FahpJAWz/He98+pln/uhr37y8PtvoDZniom0k0PaNWx/+uV947pvfnt47qcqiKvpt02grMQY0VBEmLEPRppY0B79XBpbe9bop4PrliXDYt9Sie82Vf9LfP9kDv4eXiHsHYGwA7toBsmJMVEiorMhSzIFMkmcUrDvKbxPztwtu6qq9fRSet8fpHoNlTSaih1cAAAkxdEkc8N04GH4NTTfnJeXjW+zOvW2bARAadbY+Evj9F4Yq9MxT7/xr/6f/5u7Z6ed+//Mf/eQn/9p/8/f+2X/3f3/lq1/vY2gayaKXeXFra+fjv/jnjs8uj14+WtQCRkVZzJuZGjBzm1MoisBFattWZDwcfewnP/HtF55/7rmvRyQ1zCJtzgtJ73z3ez74kY9+4Ytfubq4iEgFcWrmZYiI1NQtERGzAYmC6dK2ftxs/rip15Z14cvXe3v70A8CLNPavRZ4eVeKY72oBmroSdOIyxJ7/+HbTg7YEkFTA0d/jZBCERBQNFsCaQ0ggz2Z+QtPSCrfm/n7QN+EkAFQQwXFBgSCfpUzMiaFliAhmAEBFkawimOsN7W3WMk+1AwgAShC4dmnfpSxl8coMGAwMqXcZlVjXhYsrh/r+33Sa2bmNXZ+zJwfmuRpx6p6fHxcVdXBwUHTNKdnp1lkMBiEzhhvmubevXsppZ2dHQ5hOp2SQiyCZW2yhjIy03xRZ2xDSVhEJkQ1RSKgQviRDBR4jBH7mETDtb/6NwhrJu7DfwVY+6s53TyAyDy48waAgPYYEfNYpn3Eb3o93r7/l8e/4gmBSTQ0UzYrjaTVymh3c3vv5s0/+PznfufTv/O78bN/6vg0CgrF/Xc/8xN/4hPDfu8bL77w4osvXCk++5GP/e+AkOgrX/jit7/xzdH+/k9/8pO3bt44Pj7+/c9//jt3XnnX+977wQ9+YDgY3nr3e05OTmgw+PB73396597JyfHt976XepWNN/NgdJby+OmnPv6xj9+4efP87OwPv/yVk3tHH/zAB9/3nvdSPf/K7/6H0+PjnBNzIC+T7yTl2srzo7v7+HV7sjAHPLKTD6za+oc3yUtPjtm/aYzZAAgMAMmUwEiBDA1ZgISpp6EPYSGgOREuy127Kua3ie0LK3TH4d71qtu3T0MQAzQEQ3QtjQaG6jeJiKpJLgyjEa4yq5Yq54ndJ4KHeXxlDv/xb9PjrbeHBrf67q0ZHoIt09vMw8EuADAwL5p27+l3VOPN3/nVX/38H/z+l7/63F/45V8ebuxCMTh414889fTTRVE+9+1vZCiwN3rqPe+/vXXTkn7h9z9/fnlx+13v/ZF3v2vUHxydnT333B9ez+fv/bEPP/2OdyDh4PYzV996YeepZ3YHw7svfifEeOv2zfPrq4RhntI05913vOMjP/bjG8PhK9955Vtf+zoEft8H37/THy7Ozl/4+jfm15OqLA0gq/gmIwDpUg89oax6Cxs+rJsAAODh3IcfWDMANE+ds/vfoJERGoFCA0AYgEOIkR48jwW+Gzfy+92WkQq/2hOAABjRQKeaWoOIhMQJsttwj/3tevsuTNi3Dv4VhBK5AkYlEA2toQKQRcW05D7zompxy8MeqLo2ADD0G+BgrWLbtbV7LfSgddV9fnTIKyxymSBjq4coLtWALNUcoKKqZUgAXiVfgZhmS6lZHSvx/bJ6ichPIHEl1Z2zpqp+kr3bvmVZzqazk7OTzc1N9/KCk6+qTiaTEML29nYI4eLiommaIjA65BM5B+KUUSX0IkRUw6LBKrMfiMGIj4PNHzBS7DWhugeDMx2u8ti/rn/5mBDW47vRE7j7Bmvu+Rt0pYdf9JiJuTzRNzTkgSDJIgIVRilJP9DF6fELL37rJ/7Uz1a39l558aXnX3jp3rdeHG5v/cm/+zcyw7e/8tX3/8LPwni4YO7t7SXmd7z3Pbvv/pGX/8E/+MTP/9yNp5/+0pe++OEP/9jPPHvj4l/9+s//Z38hEL3y0nc+eGP/bDqxXvUTf+GXP/3rv35x79Vf+ImP9Xd3vv38C1f1gra3f/ITn3jqHU//wRe/+OEf//Gfffe7fu1X/8Un/8pfeebm7W/8u39XUGQFMmbBvDzcFG3p/Xe79qSUjcv44xs0fSA67VcaP7B6tvr/m7ZNX3vEDz/wzXGtixVcOnjLIBEZIkAEKAACWta2MdHI7NecrkG/b+qd35fWjQdXZw89dMzZD7ahX3WNlhgNiIGCEhsomiZJORfIEbFUK9TIlpjJqn1X6/xAZ3zcl38MzcAePHBiKV7pwU4A8CQn3zx5Ez8b2w8GMHPoR00p8N2XXjy9d/fP/KW/8PQH3//8t7/5W7/9qcWd4w++7wN/6m/8ldPL80r4L37kY//hi58txuMP/OSfOPr8c+/8yI9Nt0Zf+Mxnfuqv/1UxuLx37yOf/GTa3n75+W///F/9a1dXl5PJpHj2nYvi997x4R//6Pve/yv/4B9g4D/1l/7il7/23AR0ata7sf8n/9J/NhwOj+7d/eR/+Z+HWwd3jg7/7H/7f053j1/695/9zte/XRqUCBksgxoBGpBioQBeXvIWrsuTtU5jPdS+x/Stt6oJghGyWFAFACFIBIZIZoUCAURUAHW7SbN0h477mVM/6OHfb0ZogIkgmJFiMCTRLG0dJAHHWtCvO7+P4Nz/6aNQGj7w1649Tqvb6/71DQb9wL+CQpU0qDaFzcQSiAWEwD0FVQhmSiAKCOZ32hJAuYbCKiAhZgBBIMRoZmryoCtMK7PYx+cVYF4lqmsjIkAA9NJRWillz88nswDt8tJswKAkAAaSQBVatGQYDEhleelaRyTfC7W8zjlFy7QHPyGeObWtiBRF4XYwM29tbb3y6isXFxfD4XDQH5yeni4Wi+W5v577e/v2bUS8c+dOr9cbj8d+jB4xCkJSCQBVjA2oH/rDSoUxEmQTerLyo7eY0Z8MbISHT7d57X5PuC9PZJoYwPI8yTfAsU0ILTJpk/oUa4Sz88t/+Sv/+CNHP//uj37sz77nvZGr3/iH/6MA7L77nf/g//bfffOrf/jB518YVtXHPvbxr/3e7/2Tf/JPPvTRj/6lv/M3f+xjH/3Ez/70Cy+9OLdcs73vJz4+revR5sa/+NVf/fbXvxWKYmdrhzhUg0EsCzWrhsNQVVnEVEcbG+/5+MfPz04SqCB88CMf/uIffEGK4rOf+tS/+pV/uAtoILGMirY8B9v4sY7GkyzLk6iepZeJaxz7CPr7kB38Nmw+clojLURgBUQUgxaktrYhkSJgL1j9tp3H49vbyEBHI/WzNVBxCY+47OIQOAY0ADFLSVQEQejtSzNP0jpP8yG4t7OI8TFhtu/5pQDgSX6rVxgYAAVABnn1xRf+x7//93/6l3/pPR94/8/9/M+9/Mqdf/OP/8mHfuKj8x7/o1/5l3Q8ee87nq32t+Yg//rf/a9/9Buf+q/GvZvve+d7pP2RD3/oc5/5zEtnx+/uf/Rn//wvfukPtmea/9Gv/lNVOfiRZ69zU1Vltbc9L6iKkbfGi0j9QdWUfPMD7/vgJ3/yP/zO73zj5Zfe94mf+Mgv/9n5Z/59A+nX/s2vv/y7Xxgt2kFZ1W2tATVQJnXoxcEapSf31v+TaAaQcYmYsgKAZYTMgGgGwIIKqGRKkBDQrwuJER88r/ft0hCUlgqCV6ADAHIRWWl5QjwBGNDDJfZPAKU95p+vDc895q9PkFoLQIYFEJnNIScyZAY0BWOFqLDKIDcCzWaAEHEJD8HKhBWzDGAI5Fe8rb1YaVkiDMvnQGfX6sqAhtUhjy7kBQENFJb1XQYIxriM9y7PRiRgUVlqd1QwTTmrQVjdVdGdFPT9boiYUsvMVVW1bbtYLIqiGA6HKaWT45OdnZ3t7e2Tk5PJbJpzun/yw8bGBjOfnp4WRbG3txdjNPS1dvDUj5MIjTWmYLC6o5pAARLmN1+A/31vj4C132vTJ6BjBEBdhQxex/xFQ1ZsVREByJosT73z6eE7n/7Nf/Nbv/Gbv/X008/+9b/6N//yf/GXP/N7v7tYzCfn56j6/De+sTEYoicjZqlnU6ubva3NjcFwUFXve/adi6vZ1778VWtTO5tPr67bup6eX41iGUOglDRLk5vFfFoMewGsiqEiCjFsbYze9yM/0s6m3/6jr6FmuDi7uHc3SVMHrPqcQVXFSkMEgfxmy0vxyQOy6+jv63R6y+K734dmywF6uRCiGhMgWAuYC5YiaAyJYZFT/w0Oj/7Btw4AflslZjzalr6TmaEhE0a2JO7XZcKWl/LsP962jOQ/VKW9hkV/XzjCgA2C4dqJL0gAZkAG737Xu1OgX/3v/z9Uhvd+7KN/4X//X/3CL/3SzcHo2xfHZxcng0X63Od/78d/7qfyYnZyfDdrWjTTiqqn33E79Mu9g53BsHd+fnx1eb27v3V5dXZxdYaIL7zwTbVc9ocLbTPCRNsU0MpwnZqFCfWKMOjdfOap3mhw7/je+dVEVC7Ozw6PDieL2bjs5ZQoFJklkWVawRCGCJDJ3r4i4wfRPIStBEvnESGRJQJEUEMEUINEoIQZ0a9ZX78J8gc9/DduSBT8TtHlvwHgbQycLJu7FoBECPqYxBnww0YBDdolCktKpEQClkwNFEURyXiZAoSwlA7LW7VXD/I0iXWzxv1DPz26yx1ahU0MwOi1933tHGQjDrbCZeF7g36fvDFz4GVVm2PPbduenZ35pcenp6dXV1dlUfZ6PSdm9EN/Z7OZme3t7aWUrq+vAQGJNBsAEDEamKitqWnzY3pBDeVtLFDsfqzj9Xs9UVNAfbLe1MElrwVVLg/nZ2hEAhEBTk13Ngc/88t/Tg62f+czv3M+ubg4vvN0r385vShNfuQ975pMrn/pz/xZMqhzo2QagauIveLO8eHLx4cvvvrK//Zvf/O97373jYMbL7/88rPvftc73vOuq/ls/PTNuLHZBqRxf+eZ208fv/vWB947W8wtQCNNLXVzcfL8i8//9qf+t3c8++xTN288/8qLP/Mnf8ECFEQcwEBSTqDAgZclQG+ejulJHRLr/veabYnzvdmh/DE09xINlwehe7aGASAQATExAWuWt7MWwdXlTOtX9bx92wpw0WWBixKYEWEZKRA2yy7rztXbd+kf15zgseOOxyVhvPUzQlCAhpfZO/5+BWssW+RnP/j+93/8Y+0/+6fffuGF77z04tm9u1Iv7pye3/jwu569caM/kp/55M/MpKW27QNSakZFVRI//8JL1+9539e+8KXnv/mNd7/v/SYyGPR/7EMfeu9TT09ns4/+6Ic+N7luJpPNjc3NnZ1Yxr2DA0QKiAVxM5lNT0//8Etf/sOvfPXDP/bhtm3qnIcQSoFoACKSMrM7CZ5R5FDD9219/mNuTkW2jM15ZfPSY1+aS0shhogQY1yI5pS6o2B+0MN/g0ZIhiSiqshECpgVwttaa5jq8iZ5yCKikYH54YjrUnYZZPOEh2CBE8JMsxBGjkFFk2SztQupVvflrISkS8LcZWx0ZvHqBAIDYAOFZe4qwurTY1gIPQZlCkTEMZByUlndfnc/U/z73WKMOWURiTH6Xadt2xZFsbGxcX19fXl5ORwOTa0oyvuXHjtKfPPmzcViMZlMYHUTKaJf5Esoq5RERENUNEVDMDB7QuTqBwAQdzk5b0js3y0/vH5ve6L4mkedhJACS9IQOEJ46YUXX/jaH/3in/3Fj3zgg2V/uNMf/6+/+i+//OUv7ezt/uJP/eyf+clPDqv+73z6U/niimbznmJzOWkuJ3e/9eJn6n/7Mz/3M0//5b+2s739la985Ztf+uqH3/nev/Snf/GnfvxjB8++86vPPXf66t3rO/f+9M/+3Ec+8MGNnd0vf/mLOJ+35+dXd+996dOf/hM//dO3/vJf2dre+vpzXwtNky4u0/V1VMFkgBb8VmrrLqt8U9LjCbfDHtPFHvcjWtX0vw1bF0USj5OgkaIfGJ6NMGVdtCHrgCrhwO0TxcV+UG09c+ttlfgLnf9j90nEEJRQATNYNouERmQECBAU4tsk3fLNNjTk5QT86o7VP5aI8DqjvGXbZCu1Jx2CBGAAsSxb1S98/nO3PvTBv/Vf/9fHr7y8eeNgvlj8m9/+bVk0/8UHnv1v/9bfhYXkefO5z/1emi56izzMhpeT3rB356t/ePfW03/+T/7py/d9oDzY/8y//c0//NLv/uhT7/i//K2/s8hpZ3c/XVwd370rfwr+j3/3/wCqrCjXs7Is4Xp+5+vfeuErX/ulT/7cR599786tW7/3qU8dXVymo/M4byvBiinGQiSZgOGyKDIYsoIbdQ+fUv+fdusSRoNYWJpHXk2KQSEoKGAwVAE2ZPTr4d5O6U+v0wyQCNGPgjBYGmGP1yZvl7ZCTxGREFXNAIkeVXTLShFFROTWYJHbFrGJnBAYpDIrFQJhARwsO27FgAAm5jId0cAQkstGMbLOMAYAyAAAwKsrCd3M09X3jxlN55Mb+CUUIAJrxdx/PBZwTjml5BdtdJceb2xsPP/884vF4uDggIhevXNnPpstkx/MbDgc+qkQl5eXo9FoY2PD1NSMOQQkMQDAECOTERng6kZQA1QMT3bY3B9/0GkptYHe+IId+66SJN5gCw1AkZ7gkVYgSpIAwEKUNSJdXkw/9Y//+Stf+Nqz73pXqpv/8K0X7nzr+dLgM7/yP53+6AeevnX701/7oxe/8+3m2ZcX9WJjkvHlo9/7+/9fvHv0h1/5ZvPtV9717LMvnF0899xz2yl/+h//s/MPfajq9b78v/z28dHRxiz/1j/6H9777vcYwAvfeSGn1NbNF++clieXX/n135x/8zu33vH0d5rm87//2ZjtK//8XzVX1zsQUdVMiBgUVGVZpPXoOc9Ptmrq6O/r209rKQ0rTOJ+ewDxtbe0uuctbW6PEQL5ifdoqMBGaFgCJsFKsKechBaW4AnLLn9Abf3Ah7eV7ds1WiWxwWrlAdEQgJECg2ArWZMWQiX+x237oAEvVYgt7d0VdAf3a0QB3tIEYAPL6EUe9y8CUIC0aBTh+Duv/Iv/5//roz/58YNbN199/tvffO7rr37t61Hsf/p///c/9pEPD4W+9sWv3js/nl+cn339m1sQvvapf6/9on718FP/wz9tfuqnNsbjr3/2cy995avzy6t//Sv/5OM/8ROE+Lu/9huvvvTS1eT6X/xf/x8f+NEfbVN7dHz8yiuvDPq9+av34Oz63/7Tf774yU9ujsa//9kvPPfFL4Wy/PT5/2xnk+1QYd0GRDJENsoQqFu31Xq9LWn4B9Uc/1OEQrBQP/PMs7UgCJQKAlAgqEBQ0JyJ2XN/vd7ote6nfNs0I6IYQ8ggZmZG+DZO1YSl7QhgItkMODDh452NAOjGqDHWSZTjzsF+O6qu0iIqbGHgeTu5uq6begDkciGufqtGBMhmyTQDMBGABRC/pMnTpr2uLsIyuYIBCTAv71F8ZNS2qrtAMLCcs5mFGFXEjyR79Mri71MzgKIoYowi0mHA0+l0Np9tb2/3er3j4+Ms2cCCwzlmVpZlzvno6Kiqqp2dHUQUlSIWTCGlBMiR2SyraCyZiPxeGCAQRcJA7lSZghku726lVRaIh03w0RI0R9+XdRWAsCpTexT5e6DDWro9du9FpPsp4Pd/6HfDuee3HOR9CLIzopbfPDiGx8rIZdHkg6We6AeBw5qhoLC6Pvx+mALg/tXKtiyZRCRTUwNgFQOEjWLYKrz41T966WvfJMCgFgwGZVVn/faXvvqtP/gyI/WQjl5+pWmbUajydP7C175WcDGiePebz9/9o2+CaeSiH8N8On3u818ws6TCTKOyf3l09AfHZ4aWc9Mrq9Q0L5+dF6HYgHDnm99++dvfSpoDcYXx6JXvlEZoiCEqsBqomQowcycgbTUtfDKTwpYJeK6ilyvR3RW3drCUgRgiEJE6mKcK7PfLAIBhdzEHmLx2MV1HJI/19df3a3VtzGte2+zuuGPe969tNu0SYbuTgB6dMPg93s4D4FdSmyEWZS8QS1YVYSanl+4CmzdczD/O1h1X7uz8tld4Djb4/4kINRsRAYKAKSDgA7nrD81kiW+uhSCs42tVJEQgAFNHSh66g3qVGWQr4/TxccLHD3rJAt3a2iOnrQEAI8pqTESYs99GjmIKLmCWD0IDF8hLoAdMAeCJb9q1FaCzAqIAUVcizZbob8AQzUoK7fH5p3/tN2JVNDkx86AsMOvhKy/fe+U7lUBQzKBf/9IXR7FE01dfejEXhGbzq4vf+o1fJ6RWEiKOquri+PDf/qtfM1By/Ajx6Dvfufudl0Vz4IgG6eL6+KWX+7Gy88lv/c//ql/22rYOGFPdfufsvAIuAQxViBBJQRUNkPyaHj+vWMHvFVcwQFqdYv6kJ1c9tttKzpinhqCZIvoteeuVYUvoy+HTB86RXn/BY44HdUm1/hldw7pkui+OEb3Lim6Ximxdsi57rU1kGeYmHxUBmKIhgQEagRiKmhEqUlYriUIIIrKa79tOUq3mvx6wQkQwk7fNQXOv1wxA1VQViTiQGgCYqj6kYhGMgA0sg/lZMFsbm+//yZ8c/ui7mmE/AleT+vrrzz/3+587vPtKMDIiQ0Q1tZyRhZAAS8Nqd7vYHR+/+GLWZGYFUwJA0R7HuSQC6AM2gIkQkVvJCQBew3/o1C0uoR9CxOVJCczfv1pJWzX/ZwgcOPilx44B+6XH21vbg/7g6Ogo5TQejgaDwTL3l5n90uPRaDQcDmez2WQy8TuaU5vNIMYQgOu64YL9iLUseZFSL4RMnJEQWcFUAJy9cTl5M1NTQiQgeMT8fxRVWuVXwLrqWdpYRABmaoZGRG4/0vIwpqWie/DeXX+UKaiYIZhfCW1LWej3eS8tVzQIQEvzapXi8bilRk9dXVP/iIimtjppG1cvFSNFAFeWvjmr2Etn9RsCICMGQFAwVABFMSKNbGZopoTEnCAJoZohoRog8FwzBJ5DMgKDUOP9y78RSFBBWgihQTUCY8oITZ5D4OwYWRHnliiQGTQgAJDJMpoyqZlYCgRZxYgU0Ci4Yagedl2j4GWWxxOe+QsGZLZcgeUumC7vn7zPFWqMyEiKJmDIlLNBWG4TmIFpQGa0bCb8yD6tXUe0WnF7jPvcEZWZkqslfa2JmKoBuAnVHZBnnla1fIJ2R/d2fyUDAjQEv5yHCFiNDGrRuUmKKAVbGRgIs9jaCjDz28q+7M4t/0EP5EmbqQoIIYlICEVVUllVmbAmsNXJCEuxA49S730GXRkOhgi2vEkD3PhfMfSDv7Tu57Cyn74LWb8yceC+IMRHNLYtHSQ1JSJBBFN3SlfvW1KhgqmTFS2tX7PXEmsPN+sSQW3ptJMaAyxLXlb/MwBGREAmYipMACgIWWNCEZUAAMUAEBQY2GrJGkAQMikiqhoYCBpzNLBaW4oEaghkAIIO4RMCBI3uH6JqyQFVELAKUSUHDmCQVYAxmalqiNSAIixP+TAEXQsZGRgRiiwrYwBAH7k66/H7ZquZP7pQAEulgMvYNbNfuW3uM6sZPrCnYI62PEJ7jxNU912x+6aw2eoaAVu55ebW/KobLseMti6UHiVK8ytUEQVB0MygJchshhBaiwRCdKUZUKyMVES/KdwPQLw/vLdlw2X6solIytldhbd78gOAk1kMkdVEVt7OI50IdCmamIKG3LSvfueVaTt5/5/+uSbpV774Bb53djS5ll6vv7ffop2en6daBr3xRNpGMgIe9Ed7n/h4eN87XvhHvzKslNL/j73//JLkuvIEwSveM3MRMiO1QmYCiUxIQguSAAUUVbFEV83uTIvt/bI7/8t+2rMf5sxOn7O93dM91d3VRRaLAhQACUIRWiOB1FqEjnBp9t69dz88cw+PzASBYqGIqHP2HZyAp5u7udmzJ3733t/93bLV6/rxRhZpoSjCxMSmiUls91Y7rfrmTfWsMT87F1C5AC7l914/OucJNEiSTOB/Osrc6NiGAcsCAETEOZd2UkScmppaXl6em5sLIUxvmi76/X6/v6b8oKqTk5ObNm1aWFgoyxIRvc9EYpJPQ6RQBO+85RBioaB5rcb1jGuZMUYgNbRKKNBEFZkVBqWXABVgfXU+XMO1qbh4+tYAjqzfQiqsOnDmVl6c6iS2Hiuvs+8MABXFUGCweQ0OrPVUZZEYApKamhkTpzUMrpPiRQCcyuEMboUATKVyL6nIACdFgwiD2NDA7q9K/6XRYGACVskBDC6rKvwxuoECgIEqECISqlRnoNR/A+KJGoAZVd5kQ0SkZH6kHWTN6V31BhkpOANSsAR/wYARkDAqiXlABmeCQ79ohVSRUtYvISAxDJdCXNfzI9v/2tNUDGk5tpEFVG29y1MNiQEwxBjJyLsQpYgh856QTJTMiJwaBBVxdNXCoKYpX3YYFuCq4uJV02atgwnXuXWvagniI6IOAdMIahq+aZWbrYoGgBobeiRRVTR0aIYq6swhOXJZz0MLYs95dY66G5qROpwpuPG4v5D8JQhDPk4CeFQxtESjqGrZLwJjN4O+CREzkaqJKV3j8k/ulrUBn9TrUgCp8oZqGg82MOGGLVUNUFNAdERqlZP4s/RXBSkRYbhU4gB+jjQBA+eYqCxKQK3ltSTwzjgUOKi8zpLYmoBmYlWP/AOc0WoKBoOsRyE1Hq41A5gPVN3csJqwokYwZiTAwhTMoicyEDAjKNS8gQJIEhbACswN44SUzPU1h4iIKSIzI6iBCiMxU1AdotEE9JOkHQKQKQ4kSonQwEzEkJBQxVSFGIlUyMyMaS3Z/erHcS1E+gTHVVpjaRBHVVUiZLYB/DUAiFEQgYjTTmcAjlKs0daf6jpXklyXagpQSS4k5yuuwV+DqiCRMiMgpl2GmZKdhsMuroz2dXabASihofWCZqDEFBn6aEzIRLmxIPVENYMuqdOowDAIBw0LVW7YZqoxRMdGhEZYhWY2cEME5z0RB1UzICJ2xHjt7oSaph1REKmRj/3yyLtvL570B+66dWml88YvfzVp7Gcm73zyqe233ymxd/bkiVPPvnzvQ1++JN1333/nni8/0mj3tt7zpfLQ3p0njm3ftGX+gw+ufHzkwJ23bqtPnDjy8d1PPTqzc+/lIyd7Jz7a/41Hpic3715ceu+538y9d2zbZ1hIUtjIew8AqVxoAqOfu72UxiFV4aK06gsRJUaDqo6NjdVqtaWlpVqttmPHjuWV5aXl5aIsq3LMiJiw79LSUrvd3r59+/T0tKggUaORl2pFv3RqWS0vrIwSN23ecsNDDzTnlsGZeB+9j6IIRsQGoCJU3aciEhOpqaldu3GKCCB651Q1hICIzrlrOSKjEep0knR7QwhFVAFoWD+xAZLksxIjmIlUYGgY0aswdZJ1I4xRzMx7R0QxRqtYOOuuBYzXe3+r3EHnPdiA8uIcgppFGIa60j5andacc8wkUcSMPSfUu5aYbNU+moBVJRwi5tghYoxBVL3zaXMc9qqpqqkjH0WiCDMzsaoEiezcWuGWhPQQaAh/DQxAwApQcgxMWkYUzZAJnQw8+jBEA8SiIjEys/PeRKKIc+5T10EDFQnEwMwxikgkYmYSWffgLCVTGoiZEhgTeo6qTERIECMj5eRMtJRgzl21S0mMSOQcq1qMkQid80mnffRjKRtVVRGAmAFQVK6/6RkwEyBKjGqWij8jIDGBmUQBBCKueAuQ3DsGagzIgCEGQePMOUAoBZXQ1dpIxfQUZnkE0A2HJ39f22jXeu1SigCcTG7V8Xqzzk5b/a2bNm/6yldq0tdQMjvnnarGGK/1wJkpAHrvDCCUAQCcdypqYMmOUlUgYqJrC+UQoiFKjIjVGWKISPhZOq2ywyvv7WAgXbNVJAW3qJo5J6pkYKqE5JAguQcqcpJFlfTTGjW5BhOn8FOvJF1tjBEAnHOEFCVqCnRc3fNDg7B6S8FMIWMGxDIEM/CpUE5ySNqAUZE+PlixcT2vZg3+IsaoSM4zg6qW4ogy5oT/ILG9MVnvYIgKimiGiTNlnp0JSBQkJuIQVVScYyKTBBAHd/RJlIOr7vdadlRaQ9J+5JwDgygRiZh56OkAgBgiETp2apq2AO+9ml13CF21AhFSIlMSkXc+vdaRvko/IdXm5REhbWTOO6gqtNHAWZRsjHX3YQBGTgGxLHMF77l00NNoBnXyXFqvjDLe6E/W67u3h2FMDT/TqP7CGyKyc84ZiwhU/LMNzf2FgQMFDJEZiRJX55qmlWUOwWImUON8krKed6EoKIS8VsNgu289vOXeu17/3Ss9T3c/8pX2UvfI4vzN3/rGl++6rZHX3/7pL8v5uV4tvr88t+fr37Slxe6FM3jjAdeYdItL4w/cd/qDjy5funjLn37/Unf5tV/+/IGvff3wn/5JMfuf9PzlT7+L9UNlOGA+32EzWoZpOGdH6XlpJi4tLTHzxMSEiLRaLUAcb465dDiVx5ibm+v3+5s3b67X62VZqlnuPQJpDM45byhRjBSJiKjdaa9cvhhRwLuIlHy3o5DUzDTBXyZTk+sVi0o1YxLkDTEgouPfC38xcbQro9MqZgUNqOK6nugEg2iPETEYiERMzmbAFDVItqCZAlJidJiZd36IU68X8F3X0VBZ/+qdtwR/wRw7Akv+2OTPTov/8LTsHDOLRBLL0a3B3OrsSgNuhGBVYBCiOucAIRk0CW4OHcmQ9hI1YhdVJUqqAagiKsLODS+92ngIjXAIf6GCv4LOAZPGiEE8sTH1TSsBbQDVCsSrqqik5VhVokiC5r9/pJolnisTs8SY9gxiVomwNivQErUXUQ2CiTnctntXc3z8/PnzoSzTBWfIIBpFEid4tOnAphLV9No5J9dIVCb2sFqCvwSAolV4+KqLBgAiBEQVVbNkPq3BX1EAqBzMg/ltZmCWMi5LCYbAGTMglMrggLMOcNnubt+ypZ6PW9zomehDdAJwrUH4RberrRUAADSokp9E0VSLcuHKLCwsBosaSmJi58AsRsFrluN0m+w4gVcASKYUABBhouUl3u21SJIGvgdEcM4ZgET5jEBhOD4HgwigYlWtuzlhCg5F9aYbbyz75aULF0w1c94NQki4xirSihasMgA9V5/wk7oUERP8ZeeSXyCgKV8daUmLEw487ok9ygrqHADGEMxAXNKIrez5VIOtMlE+Af6unR8xqiCSMIOahuiQomOV6jZ0qNiFaABJj8hSyoBZRg6ixahMTOSCaFTxjogwipiZS85U02tLkl6bCDBgaV39sVH4a2AShB279fA3xLWBNIS/13c5w9VvJ9dfjJGQEqKNUQyNiUfhr4ooWHQ+uUjMwDkHaV8YcfRUS9zITxiAMioiFSEIeE+lg75FA1D0HLEfYrAYPTQBPTtAXrfvbDwG8GgjorSfm4UoEVU2vMQ6iETTFMMkW2N4XzVaLC3ECuodOzWTPiM78N6xZ3LMIHHr3l2NrTPbduxs1wgb9Znde1746c8nlu66+7vf/sn/8r+eOnV2+uBNRb++2O6pQkS3Ukrh8oKynvJSu/fKG+9MroSxHbuby/7mg7fkjQmr5/WJCYFLn3ofhEhYTWdmTqPxn8JqGi4a1d5k4HzF/WVm731RFIg4MzPT6XQWFxfHJ8ab9QYORKyRiFZXV0VkZmYmz/NLly51u91aXhONIQRC52s1F2JZlFxnl9ek1z135szC+++TwzzPIEiVQQA28HQiDIKFADAMkF3V1kifZpoAIq75Pa9uiRWQfAhrIXVbO3z9LyaZgmt7PKUOwNr1EqUoPOEapWkkS2B45jUZ5ypYCaY6Gi01RiIjHKztg88bImmFiREBzYwVXKKHAihVfUagqTy9IkRKUV0DAR78hEKV+5WucI0qYZAogGqGgBXBwtbiU8M7UQQdwF8ewN+AoAyGZGYkxgCGFkgNrWIwQ6UeUxGm01A20CqI/BmGtQIiI2B64OkEaWscfD2dmZBQzfoxWOaa6Md28pl3j3TandwxlkpqZJXg4dUlkU3TQEqUG0BMW9SQQTd08I5c72gq3/rwAcAwUQoHf0aJNCPOrCrPpXIuWNp1KEJUBGBkAI7IQGXEDrl81849Nx5uTM5o0YsC1xuiG6WN7nMbPO8NKyKKIoAjKvt9qjUd0NmTp9rHjk2hWoxoFbjRddOnamkKj2ah4WBR+tSI33A6IOJIhtNnmhnr4O8at2o9NAcIjG0ydm772HSrtXrkzXdMJGfvAMAqFhoAoIGRDrKNcXima3PpPulOhnx3REjxertG4MdUkvFMBgM9MURAIDIEiGpowJzMezRQBCEgA1ZDQNMqM++T4C8gRjBMHgszEOOK12SGaX1N/McKUidWsaZwmllmRAKmxuAMSADUJMWQUjgocQlgZDqPdvW1j+g6vZdI4dXUQDNTUUC8Cv6KKiIQEViqFpFM7uv8xHV3sLTFIKwlwFzr/VXV5NxBAK3eT2N4XZwTrhnzBiCEiuCCZmJIFhkKAgVzAeqUR8BlDfn+nTP79vsJDoNTfYJ7aGM1A1NVSKnbqn8k7dl/TMPBcGImwKiGhMx8bemLDMjAymCiwsbeIDOgaCRVdngZY1vKboyLiyuXy26/H/XEJYiYB9CLczftuWnWf2CR2DWkNFXvLC/awZmnQCzOSpIS6n4sF1q6styaXW6vvE+5a7e7jc+2jKSpnQbJ6IvPq6uu2pJGz5ycdOkCnHPj4+Pnz58vimLTzKZ6rb64uNjpdp2ZhRDMLMuy8fFxZr5y5QoA5HmOiCIGgFnuYwxlGbLMm0fFCIoZ+2ZeFwuuDCxizBFRFMCAkUUNOPlH1KIhoXGCOcPl2CABzZRLhMTVXFVEGMrrJJxhZgPXMqgpKBCTahIHYEvhSLxagWWAUYiQVIDAkBkgJeglVEtDyGNgpkTIVY4IKA3KxNggYQEBINVfseFQrJJKUnVBGGQ7VhAu6Yektd8MwHQQPxwaCUpJVaRSikiS0gzVomIIgavkbUIIa1A/8X4QB1gOB90qydbHVIjaCAhHsrVG4a+QMaCYcSI/EERATUklSIxIagAyEuUaRE7NEgM0hfgBkcmtz9kYhaNrgBMBCRmUEqcQkv9MjMBg8MQr+KvGYp6pRl7NNcxzYXkhHM0DB8OIiAiMxCOXVWFTsuTLMYTq9sEMLRENqfocqhkMPCiiCgZMPAqOh3cCUEVpE81G0ihPehSAzARmUZUqyIPDm1YwJfToNa1ooMSE0XKDDD1GzILWhSYoX8VhvckN3f6JAlj/qDZwnQ+8nkP3JoJB5rIszxn6mUIDOBdT8rHCBOSRRKuer7jgNiSCWxW6A0i0BxvSOonVIEnTj/SDAWDimjtYmw2Mo/I2V7VRIgACAiEpJpZnxSvGqmgrIBiqohoDIJIB55T1S6uVmjFniiIWAE2xqouRRqAqmBEjIqZl7bM+t4EZqNGSkc9XiQxWcstElnreBmsLKmFAMwQ2QoSolYuYEleRQAzAkA0t8bURoRLwAaPEfB7MwkFCs5gRAAGJmKQCvZWgClRKQGbVOkADiQsDUQNFMoZKuh8JWdWI0CQh5LVnfU0PwPopiQDX+oirvkrDQNJ5DMFS8j6YVQWXzAAQxWzgMQEVG3DH16031wHiA5EKs8HYwJRLmzrNjAAAk0vE1hy8KFGHImYD71QizK2LNlkqUwsISmYWVaOYOvCIdaCGQCkSiRqcN9AVqmImMar3MGIYf9I4+sKbmaV913sfna9cQRv3etPjRSIyIo2qZkjsmcurxwWWYAiQeywRVISAPVAuMZO4UgYEq2fuyomTO+64I8/yTWA7ZrZd7p3+6n0PNMC98L//9b2PP/nA4dtD0M3bdt62eXt+cfbwwcNZt3vTTbesHjubl+qKMGnUPn95+eipiazWi7rjwN7WypK0up/FilYzQPDeJ5A5TPX5fNvoIjx8nX6rVqvyIhqNhqqurKxMTk5untl85cqV1XbLTB0AiEi/39+0aZP3fnZ2VkR2797dbDY1miNHhKIxxtIRAnEMQkAZ5c7ICZAGhyBEM7cfxq1bjTMt1CkLm7IZKquRkmGKmumIH83WPBHXRpzXQMhVQGqwKmG11lUsGRs528hJEAhSoc7RdeYT7HpllCjMDIgxxjzLoohjDmVpYN5nIkKEanLVdDfV5K1M/GNmJkARJRzV/U3OecZBArBVSNJSikwiLjMREpooIhVFP8sydNTp9Wp5joApgp9Av6gioYSYgmiqRkQqArSOy1jtIdcsTzp4CAhAg+xlg0Eac1ozFao3cOSpVfDOKiQ57Pl1v/CJ8BcB0Qbu+8EhQoyigOCIxQTEco1n3n0nrKzUOesKdsERIJA1QENRbrv73vHDh8CiM0RJEJ9CDCn+WIbgmDGJiKVthwCQRGIq15H4uzEKO6osE8QYoyNGvDr2muISVbAPqv04xpg2/yjqXJXOkmw5QhIVQnTOlSGmTQsBGbHEaKz1fnnp9feunDxbw6h17LsYKyP1akbNBoKY64HvkAixMRoKMoI5FSFVtEgERh4YgcnlQoga8hiKUPjN0xOHboTp6X4/eOUaur4U4AERSNSTL0WJ2aBizyOmNCPMMh9jVDVVybM89QASVrolA/MLzNi5GKNEqdVyEUVMSXhGgGUoUz4xMZumnGgqy5KdMwUVZfbRaURBM6fEAmoAzkcThjhG1D57fvHsGYxl33PHcyRPYk0SVOm6fPzQLT3lpq+L9IkNMaWvWfIIViZ3NaauP0MHbc1jXcXicLTc8dp3EwS7av4PCQkD4I9V1SjFAeAEsuT5GK7byXgwYoIkZIykosgoIkycGPa59zHE4dRIvwIAiCiqjiiqOO+iCOBAXdyqJMgUihs69hPDO/kPBp4USi5hTHIbZj7L+r1enuciYoBZ5suyHP66mmbOA6BIRWYIITrHWrm0BzsVAgxFP1MMYQ0y4nApvLZv157L2r9GjlZJ4jhcka8B6zayK64dtXU/lJ4wVjEyoyhSz32pBWhZK4rWyVMYzYq+5R48BhAxZXapbUyVxqsaEfnMMVsSDMRKL+6Lvqzf15I1aKrKREAODFIm0lUt8YMzBSEsCNQUrd8s+dLLLy92e/XYbZILH3x83n687667eCy//OZb4dxJlOL06Q8vnT37/oULWyK3zvXjNN2COPvjH++9+/b9m8ZbL7505cQpbK2c/tlP/IULcX7pyI9+cPCh+3bt2d6bPX/x7feyVut6MBYBgBDMVDSSqc+8ASfFXxvRPvscB8xwKiVgTZXk7hrmhlQELsZWqzU2NjY+Pn5l9kqr3apleZ7lFV8zVTnu9XpmlnBwp9NRRe+9SjATlxEHVFNy7IgdeRSjKJ6AABvT0/vuvXu+WV9qB44u46yAECkaKiuSkCAZIq6VCxlZcCsqko3e0xogtkGuBAzXhJHVYS1eCEMcs3aekTPjqEdhcPgqYM2OTSRBJYzRnNcYxHFGbAASo4qkqPxgva5Og6n3McncKSGKKiaZPRg6ocHANAFNG9yOgakwe8+cIYQQRcUxi6hj9qZRIiM3mEANebigksSQ0iwYgJl7/Z53HgDAlIk1FQAfucfRzoXK1bp2VNeOrbmT1/XPsOevei5m1+/537O5pluwkaMpfCmKAMYOTRlxx8RYp7289MEHGmKMTnyujZw8sgnVmjM33VTcsGd+7jKLmEDmc6KKVSJRsJYnPJISnysmOpihJS91VEGAGGPiTyMmn64M75WS3w0q3ggxpy6s1C7VoJ5Vv8WUfIRECIaJy86OEwDy9UZSXaq5PJZFyCz48tCu7dNzy3PnLgJp9BBIC5HKf1N184bbTtbY/Cmb3eyPpmH+6Q3RkECBwMyikAkZGaAiAAmAgOYEHsBAd968f/ODdx/tdjUSBgeGjJEbHEKh/WCU1Wq1IgbVSKlgvRlIZOZSzUyzLDO1KFHVvPcJJHIl56KVKY7kENgMiVGiqiKymbLPsCjAOxpwSJNT0zlPRBKlhj4EKbGMLPVa5oWoNBWE3Buo9jtbNm/asW3z2wuzttBVxjJz5j0BsMYocesNew5+68nLHcmEytBSCsxDL9+nrn6fy9HR99f/brX+jeQc2XW+WzGrABBRJXGbkA05xf1U1p927XpwEHMTFe99r9ev1+shRliLzo9ASMLBlVS7g6iImmMmJomipswOERxzv1+wcymwUxQFIqWkAmZSVVPTKPV6DZFE4iCtuVqK0+BMmHWkTNA/vudHP/ZpPf9ZjyIiAXIRhXIO0p+uZ/nS0tuzs7bazXIPoL3QV8a8XhOFlKc+tIQ34JK1riGCqabgc+WD2cgI2IbBRgRGBSQkILmmjxGIwUiAzRRBwJxBLcT5Dz5um7AogOQlLLz7/vnTJ0kx6xZkcGFxtoxxzKT34fvzxosYLi6fHSuUlzpvz5/P8twtt7tFDzLfmr/gRMcB2ieOvjt3Hhs1bffrhY4rXY+jYwCAVJl0zExopcgw+y3FTj93v0lSoU6aEglh57UaEfX7fURMOLgsyzzPJycnk6TvxPhEsrTdkDxRFIWqbtu2DRHPnj17xx131uo1FQMIzESOnIGKel9JwJqaqQJhiOIQfb1xfnb2xJkrHNlHkBzVm4F6BScoyIoIWCGMz3fifupSAevfv25Ts+QDMIOElkbpaGqqyc+3lkWwdtb0RJPIQBK5C6Fk76ViWQwuZCAgtiZ4bsBEDqnf67PjlKIIZmUIiDg+Pl6WQURqtVq33wMw5zyYpYz1vJaHEFSUHRMzGrTb7bGxMWKOEj/fvv3Dev6Tjl71LMwqYtxwn2zW8k233FJrNEIooVRi733mfCai7V6/kY0h84UrVz4+8kFOlLJ5nXNxoABKTEVRmKr3mQGIBCSuROzMwIAcI8BQND5GATAmHlA8sWIxJL+vqqlleS4SETHP83ar7TOnaEVReO/BoMpirIKbQIhJCInZlUXhwI3Vmr1Ou8xM67r55sPIKKZBRMGY2RNL//fLKH7xbZSZuj7ov1Eajs73wRY3DE8wUV+CMnVjeOfDDxAarmcN5yzDlc5yXvMN9lLE0gyYOGk1IKmIqRIzAKR0osoXaIaEKcGUiA10EAIiFSEmJirLkNT3kjMybQFZ5ssQTIWQXeb7vb73DhFDGTLKQCDWoLQSQLJgdciI876qOoSiS/3dh8bHyxBAKy2+dLNpzNabjULk/aMf9Vd6PhPjaLAuxv3PoSVJHyRmEWVHJkqAGiKmfkYjgJT2ljwLlTkN4JwvywIAfeb7vf7Y2FgRSlOlxMYfrEZ2rY4yQDqFihJTlmWm2u/3nfeJ/ZyKbzUajaIoKqWaGJ33IYSk/iESwTCvZXmet1rtzHs1g/Wp+rqh5bYQAUgBkMUgkor0b9q1/a4d2/NaXswt170nNI2V31f7ZUq/3vjMh9S0yvzY6Nc52ogYmdFQzRDJsb9+qWFAAkuRGTZICQBFp4ScnM+CmGO2qLTcbgC5IMEEib1nTNT7UI7V3NLqqi9gBnhlaaU0qwNOgoWy8ABkkBt4wm6n02m3nQCjU/CfuF0ZICERO+dQoop671OgIGGjz91vkgZhgr8p3R8HmgpJ+MzMarXa5OTk7Ozsamt188zmer1+8eLFbrfnACD5ciYmJmZmZnq9XqvVcs5NTEwQopikbQAg0TY5ptsbboEIiBjEiiCi4PN65j0VoiSGMiDfoiFX2KaqKzEk9EL1YmSh/sOOrnu/6pjqaDLDfz9IQwDnmYhiKKu0DwNCTtlVRJzXfFkUIQbvPSY+F8IAKhkiAzEOskuMmJwH5dHfHbiBK2HfwQ+jAFKeq2oQUdU8y2t5LcbY6ZeqaqCx3yciZKeIIlERfaPR7RdERLkTNTUwg/rkZBRBVaRBVdTPqW//4J6/9qgNqiyNen/NUnwYRKIBGjsxK8sSALzPjJyZqQpzMofXEj4QsV7P1bAo+kTUKwrvnUfK63UEi6KEwL5WyT5QlRmCSGVR5DVfFiUTZfVcRZP3iJEqLmnSwhvwm5HQFNRstdXK8pwdh7I/PjEeokiM0dQ5V5QlAIyPj4eyjCE45iKUPvOMrlv06s16tH5pIaomYx0IgREdkcBnTUj6gtrQdr86x3ajtuSgBkBCqghFZjXyJikx0hFn7FXEQhnIZ+x9r1c4dMSMlWphEsx2QKZqQOhrjRBiP0QTJcekgOzVVFUJiZgNgdkbRFEhZiAl5wwRNQoYO9/v99rdTqPRUGNgXu312LMgSAy1Rh0iGVghpXBy9livjBlkAVANalnWDSEi5vVGb2WFKvyLaSVRwNK0iGVEM8YA1i9LcG4Qk/mivb+f6SgwsxiqKhOqKQQJZfDsOJmvGoioKAMC+KR7A9W3zYA0BtOU4S+Zn++0mZnd1eVjbK3M5Nr1VEI6jjvdjnU6tXoNCXsxqgozI3Moy06rRUwZk4ayDAHLIsbofZZnmSIQU6/oUwjI1CsLqkTQR3y0NuCbbcyeR0Q1E0HnKokEgCiJemoqwBlneS1zWVEGGGAOuybfaAM2RHSJj4iIMKCYXy3YvaEaIpGBgab8RiKkaxXyDKAEK9D6aCUBArBU7Hw2REEAlKCIjDFmEHN0DMjkeiYA7Dx3e0USGM2IPBuKTBCZapbY92oA4JA8WKkKADWCZoZZkH7i4V910WlwJ03ZwQbtvIeRcfJP4TcZPW16URRFnuf1et3MRCTP8zzP2+12u9PesmVLs9GcnZvtFX0irOBvulYRWVpa8t7v3LnTOVeUBSETsUDSQ0DkSpuAKKnKMkAAYlFEYiQfRKUoapSRI8CU65syuhgSjB6kkQEMw+Uj9IbBDf0hR9e9D8OjWuVXfNpSYmoKbCZGCBhV63m90Wy0WqsiamZaSq3WrI9xv9e3SvQgdTipRhFllyFhWQQzJZ8HMaiS59YWmhG1pHRNKGAhBCKe2rRpZmazily+fKnXL5Cdr2djzaZzLKJlWay22zHK+Nh4vdFIDDkiWlldLsuQvEfEXoEwYbjPt2//oJ6/7lGl68BfBDBEU1MENRAiJSJm5xwpS9QoERFE1BMioIoQIjkGtSLGsYmJ2790x5atW8Dw1KmTR48ddYSIKKKOHTunMcKgGAEAKGhtrLn3hr1XLl9ZWV72iMZJ6wMA0XTAzUYgBEIysm6/v3XbtsOHD09NTYnq6VOnPj72URHj7j279+/bH0LwWdbrds+cPXP58pXdu3bt27cvy7yoqcbluZWPP/goApB3RDHpwSAROwZiNROxDV30YiC5nbyeg97Z0BdsYKKCAMTE7BBT+hT0i9hAh+yB2Nfy2O7t2L13z417AHT5yty50+eCgSQyKKCCMjsmEpGiLGou44wthm07txLx7JUriaZvVdIsgYEgKpIxgfNoGExVDbJs+87tO3funJyYOnP2zMmTJ2KM9bHxA4cOT0xOxhiLsr80v3z59PnJscn9B/dgjRwD90U74eL5K/1uV9kSAbkXpEgsneTTTtgXzQgiaCRQol6MCCXWXEwSwABVrH+9gbpGRfi8jo6+Xz2Gf9BRUGQli4psQN7HGBtT0965brdHhN1e1zOPzcyoSrfbhaoD0iUhGGDdi6mYIbt+jLn3grCOLwtoZgMewsj7RIVI5rMd+/aPj4+trrbm5+cBDNFntbr33nvX7fWKoh/NIsDY5GSe58ysor1Op9fpmFmt0QxlcM7FNYKjje47g+jJP67nh9f8ufa8ISInVUcEhypYSuyXJRI75yRGEyYkjUJEnjFlxl+/0vtGagaQPILMKfEGbT3RcmO25JlVVQTy3iOYil61RRiAAgSw0oEAcJUpC54yYxYTyhpAophD5jILIcbAVIC5et4pyiCa1TJXUrcsGMkbO9UIqqAImGgVaZkJYOS4RhhNWGw0n2nkggcWUZI4VFUV8i5DKgdJbwOVlc/ZdTIalkwvsizLsix5dbMsc851u91erzc5MdlsNOfn52OMU+OTWZZXcrDpE61Wa3x8fGJiIn3aO0/IqqURESMqmphjZq701VWVGQ0QiZ2vK64IVBu7pHoTqdokoFZF34b9hiN/4Zr+/MOO4nU/rFWa1/WPDl+gpTwTJJd57zGETVu23nvvvR8f/fjjjz4yAEO8574HXOZfeumlTreTgpnEzARiqAkViEWDmZkt+w8cOH7i2GprFQbalkSEgCrpc1apmgBGkbzevOvuu2+55fC2rdvM7PTpUy+++NKpU6ceuufer371qyLivZcYPz529Lnnntu+Z++TTz1ZlkW308uzrAzFCy+8ePz4iTzPIwAQk4KuA/qfS9/+IT1/3aNVsSZcd7RamxEMnaEJkCrEKKEMDsyMCcm5jIkQgdklig8apDy/R772tVtvveXS5cuTk5N33XfPz3760zfefDOGkOU5IXSKfoqFqykzF0Vhpgd27rjv/vvff//91157rZTovUdEVWHyqgpgaa1UMwOLqjv37vmrv/zLsfHx+fl57/3tX7pj6oWpl15++fYvfemRRx89eeJEKMvNmzd3e92/+W9/c+PNBx9//PGzZ88iYr1Rzyjbunnr715+MaTcLNAihKgSVNWUEZERrpGU2jjNrtc28p6X2iD6AACQEpsAyPmMnEfmfhHY6JbDtz7+J08WVoqWM2MTb7765q9++9t+CIzoHYtACMJsYIacRYV+v5/n+V333q+izzz7TLfX894zc1SNQQFBg5gaM4OYKIQozfHx+7784P0PP7iyvCoqd9x9z3vvvfuLX/xy285d//L/8n/t93sLiwvj4+OhF37+o5/2Wp0//6u/mltZaK0sjHN91+Ydb77+9o9/+ctoYqac1TivK1RFwwlRqKLOR1MjcrUMM1aGpPFrSAYM8M8G/gqSApNzSuB9ZsgHD92ybdvW5194oSxKMdoys+WB+x84ceLYRx9/nNINiJCICUk1WQWU6sTfeOiwRDl/4VyCvAOHBUESPrZk3HK6HhWdntly33333X777Zu3bJ6fn3/3vfdefumlEOO3/+T7u3bu6vV7WeYXFhZefOHF8xcufO2bj9944EARykattrraOnXq1K9++cteERAhhNBoNGIIAx/zPwP4i4YCSpx2DzIEdA6ZkqS6KSQFfwlRRDLnw0BDfYNj39QGiTZrt7+xib8AaElVhpgdegXElC65vqcRwINlBi5ABCCAzJAAeyZdgdqObbc88c369DQYUy1vXzp74o1XJzZNL3fa23dsn788N7+wsGVsEk/M+miNgCSBACOQEHbVDCwCRoRoQgAokmhDJClP+OqHPrDHEw4GpOR0wCQBmTgPFTPh8x4zo9HI9BN5nic2b9rWkw94amqq3+/Pz8/3+/0tW7b0+/0QypT6U5lxExMTiR28srISY6zVahJFFZxzQGYqAOScB1QAM01O1UrqUUxjiMzs8ywWKerMhpWYb1J+MKQ/8rCrsBV8huGOAIRqpgYaY1GWnV5/7/4D6LPjJ04awPj4+O1f+tKJk6e6RZk3xybGxwFgZWWlX5aENDY51Wg02u1OKa09+/c//tSTvR+Xs2+9VavVZmY2A8Dq6mq/36/leV6r5XleFkWn0wFEIHf73Xd//bHH3n333R//7OlGo/HE4098/fEnln/wt+OTU/Wx8V/8/Oerq6t7btj78MMPX5ydy/OMnP/ts79eWFgcG2t+73vf+96f/tm/+3f/rtNpO5eBCaayoRuyrRlA1zwONAMgR6xgDMxIXFEViCGxchUJRCzEkJI6RRQJZrZvO3TL4Zde+d3zv33eZ9n3vvfd7bt25Uc+zGq1mw/ehEhzc3MLCwvseO8NN0xNTXY63VOnThUhNMbHFEDBDuzfv3nzDBJfuHB+eXFlYnJy27btgLC0uLiwuBCj1Jv1x596sj7W/I//+T9duXy51+/96Z99f8/+ffzGa3m9dvrM6f/4n/5jr9vbs3fvv/k3/+bmw4dqzfrC0uJ/+9u/WVxcmpiY+J/+6n+8/Ut3vvraKxYLVfVZpplP5WORUvWwP/Jz+Ac3HNQ6TqvMBnf9QvILpuIjCGnzqEKfQCEqsheLQPTo17++vNr6z//9/yhj/9EHvnxw/8G8+WbsdXbv3DU5OdHr9U6dOi0q27Zt3zwzg0yzly9fmZ2tN8cAoFSdnN60fceOZqPRarXOnj+X+Wx6emp8fKLTbl+6fEkROMtvufW2x77x+M+f+eWbb7xZlsW999133333ffThx7mvtVZav/jlL955553Jicm//It/cffd97zx+htl1Gee+837b7897uuPffUbX/3q1154863Z5TkL1A8i9YpEPOrCMqgkvPpl2SsLcESZD9LHtQCljfyF9W9+vkev+7HPeDSVr2PnuAhlPxYSxTv/wIMPffTx0ZMnTwLR7t17br31tg8+/LAo4tTUZJbnRb/fL/oEpqaNRiPL8k67xc7ff/8DrVbr0uXLvV5vbGysXm/0i36n3TazPK9leU5E3XY7iqnKeLP51Le+fcOevS++/NLJkyfvuOOOr3z5K2WvfOXVV3Zs29Fut5999tmZTTN33Xv3977//f/21/91x/adovaznz6dOX/wppuefOLJxfnF119/vV6vAWK30xsp8FTd4zWeuw3U8wZqJgTGzplZSNEoYud82ulrLveOnPNZlqtZiDEVFNiIEuDDtHIAqMwOE1Hw1eEv5qr+gS1Za955NrIk+7vODBp8DICGu2qSgQBEcJF5bNOm7Xfefnll5fKxUxN5HuaWVgphn7frsu+JJ4q33+VW667Dt776H364MBdxatwrt3vFQn8ZPHmgWl5TgyKGZrPBBK2VZZJYM/AgoiY26l+7+pIwyWBRJV6RUtOGTsDP3XWSlvarticRcc6lghdmNjY2Vq/XW62Wqu7evbvb7V6ZnzU1N4xmjo2NTU1NtVqtVqu1adOmycnJKKIiPvPgrFd0IdpYs94FkyhZMk2cA5JYxAzIDMg5MxNRHphXBgMhrYF98Edm3BgAVg6QT/1kqnhBAKAILsuWW6tHPv7o1ttu3bRly4WLF+84sH9savLDj4/Um83HHn9senraMR89evTll1/evHnz1772tVqtZgDvv//+9u3b9+7bt/eGG06fOXPvvffu37+/VqsdO3bslVdeuWHv3gcefBAR33nnnTdef10BpqamHnjwgTPnzv3k6Z/FEMoQVlqtvXv3BlXO/OzC3LsfvL+4uHhlfvaOL905s3mm1WoVobwyNzs3O+e8m1+c3717T1bLW+2WmBCi2sb1JBoA2TWkoXSookuYiiAbJBk4ZhBL3GZVE9GMKUUvEZGZzLTf76+0Vm+59dYyhLNnz/72+edDCM77Rx555Ia9e1dbrUaj8dxzz01v2nTHnXdcvHTprnv33nTo5ueffz6qBI37bjzw2BNPXLp0affu3ffef99PfvyTWw/f+uSTTx758Mirr7166cplVd0+Obl9x/ZXXnv1+InjjXrdef/qa6/6LEuVsqMKMQsYOQ4SFUEBXJ41x8ejytjYODpebbeRKKqAI0t5liJg5ojYObLrLG0bp43SqpIpf20F6Y3WMFXpS4WyiamqBZ9Kw3MsAxEj0pXZuX23HLjt9jvOXz734UdHjh890e527vjSnY985Svz8/Nbtmx55513Ll648PDDXw6hdM7xvfc+/bOfBYkGMDU9/dRTT6U0xx07dvzoRz9i5u//yZ80ms03Xn99bnEhiHjvbr39tsuXLr316uury8vOuSPvvD9/6crK/OKW6U1ahv5qW4sgRallZGYkF1WbzbGJqalxrtXzWr/XDzGKmUMMMVauFSJLGglWPRhGBgAkMqIIxmZEjMa0US3h6zZVBVRQ8kBBYsZ88vjx1aXlm286eOLY8dz7m2686cL5C5cuXrrt8C13funOPM+Lfv/ll19eXl695dZbbrvtthDKhYWFCxcuHth/oN8v3n37HUS89957JyYmiqJ47bXXrly58sADD+zavbvX6Tz//POz8/MO+cC+/XfdceePfvT3L7zwPABcOnfh0rkLUaIjlhhPHD3+zlvvqEQT+fZ3vrN5ZkZCOH3hwkcfHMm8a62sPvroo9OTU55cLCIRZpwSkNbN6Y08wQ3MKMnkGRHDWkVVGyi8g4iSKiKoKjOzc8lrls6wQXzAlQgyYyqZBgDDdKgs89yPOoQ7G7shIgBGiWJAjrxjDClwPJI+BBAABKF0EAGcViBGwIoouYj1y4/efe/YOx/MmG8utrnu2U+EfgDL8uZktm9f/dbDcuht2TJ18yMPjPtasbC08OpLZa9zy/3379i689KJU71+/4YDB+r1bP7y5Y9efLk3O5sjG4HI9RzApohJ+MyixBgiZpzlOQxEf9PHRizDz6GNhiJxUH48YW5mTnXCnXOdTmdhYQEANm3aFGNcXl52yHktr7i/6bJWV1dXVlY2bdo0MzNjpinszgy90Ek5Ril33jlOchIxRvap2lkK6F/vrq4aa3/kaTKA3p/6s7Y+gJ/qhB09dvSuu+/atXvXpcuXDh0+fOXKlUuXLn31kUcOHrr57374dzfsu+Fr3/jG8urqTTfdOLVp+ue/+MWdd96578D+1dXWpSuXL12+fOedd955552//e1vm83mo48+2ul0Nm/efPvtt//sZz+7ePFirV5vt9tjE+OTk1MvvfxyCGFycnJ6etpn2dLyUogBELZu3frNx74JAFNTU1mWnT1zdmJifM+e3d966ltFUUxMjE9vmn7pxReXl5aq3CRAk2urw2yYZoNg9Pq3EUAHzyjh49FYD44E2daNMYQsyxeXFn/wgx98//vff+yxx8qyPHPmzAsvvOCz7P6HHvr7H/7w1KlTt956q6i2Ou33P/jg2LFj4+Pjhw4deuONN8qy9N6LyJEjR86ePdvtdp988sltW7dt3bq13W4/8+wzly9f9t73iyKv151ziTO0bfv2J554Imrs9XsvvfRSGcKNBw/+5V/9VVmW27dvv3LlygcffHD33Xfv2rXrz/70T4l508zMmROnn33mmVa7ZQxZlksUAmAin1SgVTUKbBgZses2G5E8g8Gi80Vf1Gdsa0MmKWeldH52jgyf/tnTX5FHHnjw/i9nD3mip//+57g4f/9DDy6vrvzdj3506PChrVu3ItPxUyfPnjm9a/fur3z5K9MzM+x9GUp27srs7PkLF2Io/+W/+lcHbrpxdnZ2244dP3v6Z797+XdiWsYwMTkxPj5+7OOjZae3aWLqK1/96t69e5aXlt9+++2y29u2Zeu3n/rWww882Gg06rX6s8/8JoSwdcuWb37zGw89cP/2qc3WLZ9//oX5hXnIGRGYGao6DUBIznlN2aAw4I5jVegxRSJ5UNDxn0urCLNByCxDNtHluYUTR48d2L9/vDnWbDZ379j586d/Pl5v/sl3vzs3N3fkoyOPPvI17/xbb739ja997dLFS+fPnT18+BYt4+rS8mqrVXb73/+zP40hvPba6/fdf99Tjz/5m1//+sF77wshvnz0WCxKCJGc37t7z+ri0rEjH2XkNm/Z0mzUlxYWW63VRl7zSHt27b79lls2bdr08AMPzV26Mn95dqI5vvuu3WP1RrPRzLOst9K6dPacZwKDUJY+z2FQ4XlIfdiwSzIAGIAAGaYHMLhYG+7dCEMGG3KWZdGMRmSRvqjL/ozNeVfLc4AySfcg/bFD0P/gVtUFVEZiYmQGGApNrhtHHsAboFQOvhRFVMSexoylP92881uP7bnjtrwts7997dzi5a0P3LN49MPCtA3QabWmV9urRrff93C+ddtbr79x2+HDh7/33XdfeO6Wp5449fHxs0XxyJNPtVaWX/vwvf27drnJqd7lOUUGSx62T+xExIHyA6GK0iBtmnmgbfX5teHiPvoTSahnqDUBAP1+P8aYQNSFCxfyPB8fHweAquhxKomBiJOTk41G4+LFi8vLK7VajZF6/Y6a1eo1F7noF5Y5xzyssjhYXg0MBuUEB6KzZlilJ+sXuALg4L+r/PUjLKrrXxwinjp16vTp04cOHVpdXd22bduLL77onLv77ruzem3/jQdmZmbI8cFDN+/bt++VV1555913T505M9ZsHj58eGl5eXll+eBN9x0/fvzVV18FgFtvvfXQoUMrKyvvv//+L3/5y263mx4GIznnCLHoF82dzW9+85vbt28HgB/87d92O52pycldO3f1iz6YvfDc88c++uirX30kFGV7dWXT9KYH73/gdy//7uUXXkI1R5yzE1UxBdy4Vc1HHwes7/ZPYhxXb+LA27X2MSyKYmJiQlX//b//99u2bdu6deuXv/zlJ5544vz582VRnDlzZm5u7vnnn/fe33HnHXfdddfhw4fr9XpRFLVajYjKsgwh3HDDDV+680uikozUbrd74sSJC+cvJJUP75ypImK9XmfmsiyPHj168ODBB+6//8iRIyGEot+fn5svQ3nm9JkPPvzg8qVLjz766Ozs7O9eeSWv1b77ve+ttlrnzp9T1eZ4vRu7McZ8iOkBqeIPbfAl+Z9lwxGnNQAQookgWLNeb3fFQJvNsV/8/Bfjb03u3bvrnrvu/vZ3vzP56quNRv3D999f7bR+98orWZZNTU3tv/HGbz7+eJ7nE1OTRqBgxNzqtNrdzj333u191mg2DQCZLl25/N7778/Oz42PjwNiEAGA3Tt3xrK0LPPMoV/cftttsSyPHztW9nrt1db8lVkzu3D+wkdHPt6zb9/y4uL77717+dL5Jx75Zg38h+9/4B0rEhHWa5lIGGQPpyAjoq2ROrEqwJbKGMBAxOSfTUsqMKqaqsYISL+MH314ZP+BA3t27d6ydUu/15+bnd22bevePXsXFxanp6Ylxhv27o1laNQbL77wwvHjx99/970sy6enpzvtdi3PpyYn/+4Hf/f6G693O51/86/+9Q179/a6vXffeefXzzxbr9dTBZNmrQ5qZb8PZocOHnzwwQfzZuPksWPPPvNsDPG2W27ZNDmpZisrK7/97W+XFhdNhBEZ6ZZDh/I8/w//4T98dOQjA8vzvJbXylAyMawBybXw9IZtVUV7MzREQxvkUQ3KhGBVSS7lrGz4jLd1zUBNh8UX6DOSIb/oltIRiRgGNVuuapjgLwArFBURwgAUCMgz5d5ir9UrrsxdrkdecXE+1zJTGM8l41ans7Dc3zy9qezHnYfuKIrVXTM7xsenaSxrTk6trq68+cab77/x7q5bbt+x/4ZNe3YtLyy2uj1EjpJyqT6Fr4eIxIQIZooDWsJQOOifYuTgaKPKeYaDesiIuGXLllOnTs3NzeV5PjMzs7i4WBSlGz3Fpk2bJiYmlpeXh/gglMFM8zxjwsqTzJy4QulnzMxUEAxBEZLKAg9oDjaAwsPbtT9+1mVFwFjHCFo7tPaZYT7B2mFDsPffe/eRRx75ysMP9Xvdox9/lGce0BbmZ1dXlhYX5hbn57rd7u6dOzLHBFrPs+nJCc9EYMxYr+X9Xtd7BgNT8Y5FQln08tyD1Yqih4Crq8sry4sPP/Tge++8PT87+7Of/HjP7t3f/e53JyfGHeGZ06d++pO/b62umlq71QazsUb98vkLL/72+Xa7PXv50t1337P/hr2nTp3yhKHfNzAmvkpyckM1qyyjwT9haCtV1a4VVAcJcjbgGBGmmmvXBFxU9+ze883HHv/Z008fOfLhiWPHd+7Yse+GfRqFDSbGxufn5h944IFt27fdfffdH3300etvvHHPPXffesutmXMgWsvybz3x5PYd23/4w7/bunXrDXv21vO6qYYyeOeIKDkMFhcWL56/8PWvff38uXOXLl68eOFia3V1797dnl0jzy+ePffzp5/u93veeREhwHpeW1lceuO11zq9Xozhu09999LpC6+98nK/3zevmfdgAKImCgYeOc+o29vQe8no2jJ854u9pE9pwzhDVQQREcA7R4RoWpZ9UMxrY3/yve8evXjq17977szZk0tzc//T//lfNhq1ouhPTIxrCNu3bTt06NCBm26cnpp+9tlnJsbHpycnmrW83207n9115x1f+/qjL7300urKyk037kcwzxRD2ajlE2NNM2nU8l6nffTox9945NFbbjt86uSpH//k77dt2/qv//W/ATT23G63nnvu1++//97Y2JiqhW6oZZmG4uOPjnz4/rsrF2b/5f/pX33ryaf+03/9L2UMjrCzspJt2VbVWlQVEREZcIGAbO0/TmyiagX+59QMLdXKFBBk9Lm7cPni4vLiTYduajTqp06fXFhe2H3DbmTo9NtFKM6cO93r91UVHUaLigqOxibHska20hbyXIQiaGiMN6LGIhTkqNPvdPrdvJ6zZ1FR04+Of3zfQ/fvv2n/66+/8d4H7509f/br3/j6nr27gwSfudfffP2FF54HwKWlpW63MzY2HqR86+03/tt/+5sXX77pX/zVX+3YtaPWrIUQokQ1HZgda0btkKO5MdtgYUUEqEpYJ89VVfYb1q7dTGK0AZqp6PUbezUQVRHJvXPOmZmKXp9+t5FalSg/orFDNBRRrZoBlAACUACUBAbgDZwZSKgDNfqxMdc+/pvnjr353oSvl73exE17cofYLxoGE8ARqEmMZY963WJl5cr5c7HXxl7HtYvu4gr0yjrQBy+8NHfh3A037d1xz93lhcuLV2YxloggeB0gh0BDvUhQUVEgSq7SdT6Iz5v8UP36yDmT2OUwS5uI6vU6AKysrjjntm7d2ul0FpeXzMwNu3tsbGxiYmJpaanVau3atWtycrLX6xFSntfAaRmKHLBer3dQzQQAsNL/TXmARmm6JBCcNhxQAEVAMlAgBEC8Wrvuj9AMh4KLv/djdi0z2Rjx/NmzEsPhw4dfevHFpYWFeqN+/OjR3Xt3Ly8tTUxM7N275/nnnz9z5vSNN+6/664vHbz55umpqePHT9Tr+cz09Pz83A037L3zjjvyPNuyZeZ3v/tdo9Fwjot+zzmXZdnq6mp7ZeXVl19+8okn/+LP/+yD9z80k4M3Hghl2e92JsfGNIRuq7WytJR57wnLImgI9cx7wm5r9Y1XXz18+ND/8Jf/4t/9b/9bu90mU1GlpJG5UZshXNvRAJDIZ4CgZoprZNiEgNNye+0zdMwpu+XP/+zP7r7rLmY+cODA66+99sorr9x8883f+ta3zp49e+jQoZMnT4YQJqemNk1Pb9u6rVarpdloqRgj8batW/ft20eITFSv1RGw6PeJuZ7Xi6K/srT07DPP/tmf/9lf/PlfXLp4EZF27dm1tLR08cKFmw8eTCFp0zWaf1kUzDwxPlGUxTtvv33nLXc+/PDDJ49+fGl1lolADc1ADcTIgJE8bej9I7VR4Lvxrza1Ea8DAkAIJZo6phgK55plvzs/P/v1Rx8Zm2kuLM/ffvMtl69ceuedt4pYfun227/znW/t2rW7LEsmzDM/OTExM7NpYmIsqUiGUAJAs9HwjpvNZlbLGo3a3JWi2agBaK/XybLcManG119/dd+ePd/+7nfOnj27urq6e/fuWqN25sK5aGJowOC8J+dABNHIzBF5JkY4f/bMO2+8/o3Hn7rn6Jdefet1CWXupzImUEn242B5vxr7kgIpGFWczi/6IfxDGwJCKqiWXre77dPnTj/22GNzc3NvvP1mr+wvri4ttpajyccnjt5z993o6ezJM3cXvRsP3dSYaD700EOXLl4S0x27dx75+Ag6vPOeL3XK7u133dEL/YtXLt506CZDQ0cK6nIPMZy/cP7Dj448/NWvNJqN8xcvNsYajbHmlfnZMpac8fzi3NkL5/I8T1U5Dc3lWdAIjKfOnH7xxReefPLJCxfPv/vuuwqGDi1p71w1Ra5ShtxgLWVloBISUvL0WnKhrQXbUiHFVDFvFP5ucB0YIsyyzGfgmBFRwTawd6hqiJSgLw5IBtfb/SB5YgNBIEAAJ4AA3qCp2AjmhcZ6trVn4yoALnZ73A95v3SdfqNfdvrd7Zu3HJzaGk6f0c1jq92VAzfd0CCSy5cb4LJ+f3Nee+je++d6Kx8fP7p5x9bxsfqyBkeKxCp61RaOydEAAJWPM8njUioZMQSpn7v3d5SDN4Kzqx9KxS8SVWFubg4Rd+/e3el25ufnvXP1en3N+ysic3NzIYSpqSlE7HTaRFSv1VXKoizZUU5ZjDGieu8cOwMTEXbExGCG1eK7JqtnYCkStxbmrhwS69t6RsIwVQ6rN67/QVjPrAKD6xUOSBpjsFZwEke+fPVVGA6zsipXsQlYu916/513yl7/rbfecI5DWT73m2ef+s53HnvsGwBw8uTJ06dOzs7NPv7449/69rdN9fVXXz9+/NihwzffsHfvb555FiR+45Gv5rXae++889brbxy8+aay6Ofeq6qEUM9rAPbKyy+X/f7DDz/81BOP1+q1dqv97K9+efLYMWdwzmdk4Jk9MxoY0eVLF8cbdYhS8355fuGnP/y7J558atvWrfOzs865eq0q8TAMul2bPDyMxBkMBMeu6Y2hqMea2/6ztJFndlUyFw5oMXp9yxsNLLkZFEEJrFIpr7IXB6wHtCQ7AolpY8y8urz8ox/+3cMPP3zjjTeKyCsv/+61117rdjo//tHfP/zww/v23vDmG2+88sprx44df+jhhw4cuPHtt94+eeJkv1d8+OGRubm5+bn5Bx966ODBm0+dOnX27NnLly93VttmxkiOnITIyOTo3Omz//H/+x8euP+BW2+9FRE/+OiD5194frXVOnr06JkzZ0IIRJTqgY2NjX380cfnz52PITj2Kyutn/z0p4889NXm2Bi35hUUEQ0hsaMYCUxj1I2vRXmV8NkXfTm/v1WjvqqNNkhOiBqTZUiIoBqD/vrXz851lw4cvnHLlunlpcUXX3j5zNlzyyurbHZg374rs7PPPfdcvV77yle+etNNN87Ozv76178+f+5st9sui3D5yuWpqckdO3a0Wq3fPPPs+XPnVlZWf/fyy8tLS7VajYlDCHmeL68s/+f/8p/vv+++gwcPzmzZ3Ol0/vq//vWJkyd37tz5/IsvzC8uZPW8lNKRc86tLC29+rtXuqstBnJEr//uFRTyTI4YotWzXKOYQaop6B2D42RQDZK+kwKEDZY++z0Uvas6a9jw+scqksW1i+xwJxzGlD9LIufVa84a0b+K1xElqWZVtCNHPz506y2XLl08c+FcVs/OXzz/k6d/8tBDD//lnl0+y5751TNnL5x77Y3X773vvna7XZTFG2+8fujwoS9/5aubt2194eWXHrjvvj//i79Apt88/9y5C+fOnjtbFH0iNNMiFIjYK3r//W//5rHHHn/4q1+u1WsEePbMmWd+9UyUeOb82VannWWZShwba5RlKSYnThyfn7tCjEj42huv3bB/3+4b9n7w8UdFp50KMI84ICrGlqQt5pNuf7QThhWCYJDolAbt7+nNq3t8Hfj+1BEw3EDTIksDd7Wti3MbgCJClucxPeXrOd42YEs1HGMMIQQwYGTEf1iuhV3zcgRHXAdSjIzl63D8PktTUzPFRAEyNFEbVPweuRhlQABgBR7ujgAG4JHiyuqVt9+l5aWGiu93aoa9pdbSG+/4+YUr/d+F2flCi9mjx2ohHHnx+d1fe/DJJ7/Zabcv/vbFcGV2buL1ZrdcWl1ZPXps94N37546sHL043PvvYsqDCDVHp6spAFWAksLgSEgEJNLyWca1/YLZk7JNv/AzviUNhqCSAiYiRFQVIZiw/1+n4gmJyY7nc7C4sLY2BimNLaqT806nU6WZTt37mTmy5cv93rFWHMMEXtlDwC8zyhSEQtX85zY7oPnoMBknsFlEXyMwK7wYIQEzosZYCQCoAqqrsepNlimAVI9FkCASCgDUwJHVorha6zmoib5QgJAIwTC9YPRMK3MCmA8gF8wMioryA4QMW0V1cFU0FoJyLNEee/tD08eO7Owuux8A83aC+0f/tcfjm+bQcSV2XktbKm38vc//fmmqZnQ6q4uLPVNfvijn025vH1x4cWfPHtsx45S4uz8fBnKY+8fA0QowRGbWEYcTRDc66+9dfToiYnJSTBYXVntdzoMePromXMnLvT6/YwboSi9p1qtcer46UtnLxb9IqeciM6ePPfX//v/wZnPszoQlVEFDIlpMBnSXVfxUUMY6GNbEmMGI9BBjThwgCoWHPYcAeJYiS6IrgkTrJkbV3GnLT08qMB0KmwxqPOJaMCGNLyeqlbVWocDGKIzBTUlAzRGBRUxIzNEE0JxiGBZYRlkuRFkFkMszGUO86W5lZ/+/dPNRrMoijKUCJhnjUvnr/z9D36SZVmn00Gi40eOnzx2yrHvdNo+ywDg9NHTado8Pfu0qhVFn4kwBcsRM64hYL/fd84hYO6z1lL76R8//dtnfxtVYwxq2qyPffD2ETDLKCdHWmgsBTx9/P7RZOOyr0sOxy5eOPnf/8tY5qNFDlGIeoTiMtXUCUasw0mBA838jbappJQFM0vKDxvt8gBg3daAhoSAlQMAEQGBKQfKumVAAIoRnWtJ/5mXXnj5jVdzw1iW3aKsN+qhH5/71W9fdi8ZQFkUq7r647/98djYWKfTKYoiy/Lzpy8mc+WXP/3VxMR4r9fr9/rOOUC8ePYis6v7ehkCBECkDPJ+q3j+Ny+9/MKreZ53Op2yLGq1+sLlxYXLi1HFkS9DCY4c+ytXZk8/fZ4yGqtNWJT5duenv/6Vz3MEI6B+NxTezGUKyKq5RjUFAbCsZAiYEZJnAAcFITpPSqSf/pjWwyOstvRRNRIDAFRSJYWKm5BWbTQ0x05MTKJnp6qmCsQp/fYT14u09ioAVEHD9MjABus5VuavgdSYWgurP/rBj8pQShmTgsrb77575vz5ibGJdrt76eIlJnr1hVdPHTmdN+vzs7Mr5+Y/Wo2njp3tFUVntXXp+IWpLZvmlpcWzl8igOd/86L1Q14Q1Wpd1EIjRQi94uc/+8Ub27Y0G3Xo9FcuzBZlRIanf/xLVW1YrmVpImImEN787ask4gqEsSyo/d1PftaoN7pF5KwpZqpCyGtlPcEAEBUIUBEADRXJzBmwAgDIgDWYECgLGaCQCVWIwkArWsIACq9X8UVcp6kP1UY3SCm4pnzR1c8l/VUi8WCkJsJgABARSyZGytQ8iAfJyBwRyBp4HIKPjdMQBuFnAABTMzUjM0066/BZnTkAQMhqpqCGqGAEwISIJmI1pKBmmFT2QRBULUv5pogRQM0IQCpbAh0wIquFT/1RA1AwI3AOGQVi6dAyAjIbJfMjmAIZOBuYKAYQAQlIDRevzL377HMhhsywhg4synL79C+fN8SuO2FRO6TvnL3QKLDf6c9dOlPfNrOyuOAWVuvkP3r+5VDGKcMzr7xy7oN3eSwvOm1st30Ej8yGYNGDIECJUBCQmreYzDMzNvYCjJj2C2Rm51xZlkPu77UD5jPuJtcdaaPqe0lXGDDZDzZa/GLz5s1LS0vz8/OTU5ObpjedO3+uKEs3/O1Go5HUgFdWVur1+tTUZBKRQETvM0Aws7xWKxwSIQ3S+QwkIopBDEIxcNEv6tZlJuR6ZBeoZOg7Y1UyMzQySGrsUPllTRCUDMDIjC3Nb1pnzdp1uOoGIGQCRgZsyKoJ0A2HBoAZmiIqKoLRYD0eehEBAA2cVRgwkglV628CaNFQVQGxiKFYWTKioJEV6kZlEc5duABqDaPcCInb7U5ntVOLkCsZ09LKSl90DMBCuHD2TEQCInbcLQoAQ0I1IzAVYTRBc45WO+3l9ooZkFKGTACxVwQrkUFNiCiqmEUyaJcFADgDE0DE1faqESCgqkQEI0BQUEy7kyIIQKTKtmetdh0AFEQFYzMXtdr0oiEiZL7NIob1yD6CepN1HT/6Yu2fCoYDMwNADFgSD6ZKpwBSIIA4cFWgDVwaZqrGzAk2IxIlwoyIAYMCqjqJpIbgA9YCOZUw4ZktKDCIIHKy3wAgFeSWGAlJRHq9Hg2sNQ1SBvHsQBRSzhkRgJX9AgAYU7R4HT+HHSUrPMYAAM67MpRpyjlkCbG6FTVRMVXHnPaGNAA1xKhARCClRMnBoF8CQt+RsDMjQnKenUKaEqOrwIbCl6OgfChdvpGu1ioIgAkLIJohKgKoaVp21SwSRZ9Z7hHNowSLfcbI1C8LVwIhZj6LogZKirEMAOCIgdhEWyurAODZmQgDpgLaZtZeaaX3E9BgZDQIZUCAzHkTBajKdGuIvRAJoJ7VQE0qChmIiiM2VUVVVU+oYqJREcShmEbpezM29XnWB+4DMTBpdFKClioK4KPzljVINHZbZeyZq4ERKOKnQRMbYQenhTGlPVFCD4n9mfwUZmqCVVgcwMgA+qFA5yoNQhUTJaRKo2lw/nTqq1bxYQA6seUSQkype2RgYIoWCQyRBTnGlUuzgObRVMUItIiXz569KMrovc9YQMry0plzPVQGnMkbodu/0u9axgw2d/HSucsXg8MJYkacW56vRWpEDN3SPBADR6ib63X7p06djBgmSpwUx+jA8erKKiDkgs5QRZkJDRbnFpyBZ98VUYDWSqu90hq4WgAT2k33XVkRFZrUKg3cMgMWADWyKtilZAbGSpicq2TiQNCocisYi1GK66EZoIIZEAFVZe3WIWBLy+6ax+kad/O6dTytvKRCoCQcgzMlUQUITEYMImzqQT1pkGBaRbSHVd++6Om/1gbRnoHJCwBgRJTnmfM+RQ0/O1pXAwNmlweI0YJDKsxqiC5V5UYswQgZCMQEHahCZkAAqU4xKphzBkbxH1JoGUEJFREJyRRAcscYEsDhCMhog5CLKjgEdINbMgABQ7UGgPW6OSAABA0IkBm4ftrJCwT0ANbto0EDQJY6trQ4jYgGIMIB8tSNZlZ0dRHqYJwMNwMArYM5sAAQEAoHeQQUcwBmKODNMgE0iIwulQ1OW3CFTa9X9e0fA3+HLa3zACAijl0qSJQEqhuNRq/XW15enpycnNk0Mzc31+l2nXOV8BkzN5tNZl5eXo4x7tmzp1arlWVJxMRsEFWVyCG6bixczTvniCq0KA6CC8GHxmQ21Wl0HRGDQ1eP3AhYMGYe2QDMBCFZscmQVQBDEMIh/CUzp+AiotEQraYBMXy6ULl+LZIJVcnOBEQ6WLIrb0X1MQVEtOSO0CH2GnyODdAgEkRKkzq5JRAQMkqefOSBlwIQnEA9goI5j6jQEMiVIlOHCQ3yCLlgIMgyIlISg1ROHSBlnFZ5BNU1K6TIhYEiRkRBMwCn6A1Zq4IiQigIgmqAzswZBEQA80kel7FkMDCnKGSBAAxRzRmyJhE+TPA3CYCyglNgA0EsGQ2NzPJIyduD/eDyrJ1j7jSo1tCPo1+Gvq4pSeD6F9U/STEzRDOupjgpJZ86AAAqsmF6BEQmlFAvJk8PGaoakia2hSLkuZGDwSIGiKagApJyjzWGceduvunGLTs2d5mCOcNPz2X4x0ywP/C7KQlJ0AMxSIZqMZjGTdu2vP7RSTAFQsq8ORcKGfbndfTdNkwb3eoq8vQIkesLveZUz2t4fcn6MER0jpxjRBTTnvY61r1xz+YHmnePKSO5VS2jd3WhsRIBsHRQEhjCFyGXa8m7uhaxSTOIDAEcgA+6eWy8N7/ch7KOSoBp/qQlzjnHRA3Cae8pBEUqQcVdjxF2TVOofnVNRKKKbg+oCAAGlkqDpzme/BMI0GzWg0lS5S+LstbIat43BjHRYVuXPlW9VUWlhEAGyzGbDXycoGCOAAEbAesBLRHsUBUlGTqqZoqEzOQAMID2UsFpwzyiQ4rOogOnmAVigtJBLmhonPuswLE+IuAkogHWFDK1DmWrGXe899FA0MhlyJwuDwEMnEFtEOZVAiIYB8giZAJXeV/X5sIA8pQEhceYPAIArJApOLEUGHUIkoKYilkgAogEOYNgtaKSmVNlrWqnJpRjgJR+2TB5EgbdbIY6IBIiAP1+PgoCZNGyADHJmmLmTba5rAHm1FKISgAEISIoGDt2ziUhhSGm2SBtFP4CQEobcc4x6yfkj3xisxSaIAazErQ04DzLFIpQepd1NTRrdYqhL9FU646JIRYxByjNAkAdAABKEABwYAbwWTOfDAGcGkVFyDxTbmilxEAciAMhMKiBGTizDOIf3vujEQQAMJDrHr06PJQczzBgIQIbZBVbBhHQGYKCF/SZEyZRGXJwh/Tcqy7kDx5Co3vQ6E7kvVfVREr03vf7/YXFhWazuXnz5rm5uW63m2dZlvm11LfV1dXV1dXp6WkiWlpeWllZcc4xO7MYQRBMVRFiVVdjuKIZsMRMws56tnfLvmLrNqxl0TkLmpfWCNR30PXAhmgmkOAODOPgts76NwBzgrUIruI1pKgQDhltyUuZyu9Zqv2Jg3DQwLsw6MgB3fQaB4gNQLANHm0ysWk993cQq6vOXnWUgjOICG1vqFZX9IKRsc+ABrmAF4gEnQyUrErbqsxzxDWqxsAkByAxUhAE4YT5kQ29IWm1tEUEIYgoAuoUMoWCQQFqMaFYKBwgQCYJxAMaOAVn4DTJ2aAgRIIK/kr1fkQsGIWMzfJoSmYAmZE5XoLQ3zqpxFNzxRj5Vl0j2bA/hg8OR0OZmgS8kNf6faSfEQe3bIE07egDGyBp64CYApEBBAn1LB83OB9jpfxAYJSiA8oMM+PNG7du2bd1+w24RRktXoeGvyHSTAycEZfkkAgUUcUi17P5ovP6agvK0sxCsnCSXDgOxsr/v/0j28D7M9oIsAmQrS7tzdwth2+utQUUJKOSoBahWaIiFA4CgwGw/vFLx1SLHEIV2rYBbQkTlSlGEFso45E866WAK1I1NVQlFv3V5d1TU3/yla/EQkoJUMtLB4pDwpetnyY2ssCtwdXKt1vR0NaxVVO4KMVwyFABDDGolCqUeTVFolqWd67MTUTx19zeVTucDlZ+IRguLgPKVnKVgRKQYj1QHpNnQwFMQSt2GlLSdkMkNRCC4LXvgA3GAghC31kgcwq5YMlQMOQRBLTtpB5gsgDStORTbpgZdD20atDN1Il6gaiKBlmESNDzoIiZWD0gApTO+g7RrBYgF/BadfHo3V51+4Gw5AEfDJO7B1jTjK9Y1VqRAJPaWEX7XVPzMMXBgqsAgjp4gAgD8ucA/qqBJjofWmIG/t7hbFAPXFcuVKIDUjCN05unu0XXxaBgBiiEgSkSMXMipiRi5T+HMpDJIPiDvmomWhqAq9cWIbQAmsy5G+8yL8blmaIcBx9UDFCDltEIyUA9Yh9AzDxAKtoECR1+ejAGoJr4LJQpZoqOwCMCkaBxskBZkcy4euqfW8kk+/388pGPBQBFCACBQNeAQGpYnSctLYg0SD6r1uHrKT/8472/owg4z2ve+U63kwogA0AIYXpqOpTh8uXLIYSZmZl+v9/tdivyQyrj1Gw2a7Vat9tdXVlNVeNSgjERIjNEA4AsywBVYuWKA9Fx0cm+TF1abHXOds9fjFEiQAZEEcuIBUORDVCvVvrsWiFgGwIoA0iVRMRMLYV30CoSDCZqVPUfJJ8leQUvMCQ5VFIt1fkAB96LFAUSqsxuHGDuNeSNFWTMBAZgDBCMNUmPqBAiVG4JQSgYC4a+A1JQBScYGQsGNCgFvIISFAyGwJqcqkkKA1O9r0r9wtJqD2IWQZUwMhoRAkbDqEBaZZ4FAkUIBILmFIJBwQAAEoEhERsAAEQhwVxKrxXFIKWPKkCkgQKzgGk6LRYOhZQMVEzJFKAQiIhxonbT1x7mPOsdOePKYLnGz+BdNeDE8B44PLBacxB1QOs2MEeaqGyjNoCZgRkxK5rG6BoNt3kLxmimRgyI4NEclFZK2Z9Ek6XFt37xi7MXz9cFpkvz683q69qXn32B/ry+awCKFCwFGETJImO2aXx8/27sdFiEktOaEH0GRIm2MTRnN+COMjTfh39HL/ILvebE9RtAXUtrbqqVDWYGCBnRJsWpKyvy5ofHLl3SC4u5IWQcyLJozQCK0PNVDnUW/9iVqBMgUqqkclKGvQFGMEUqJBrz2PT0jp07t5Z2EaAkNGIlUgIFMIsYi6zfldU2dsoaIiBE/PTifAgAWKnjVD+bUCgmeDVI1jAkEDIhhQEdAgwhGmDmlLhUmdm2tVnP33jvSDm3wCP00OqHrppWCm7tCqoeGJrWawcMIlAAwkrCp3JGm1naWCEtLoZkwiC5AzSAYITgGQjNKWRGSQ3OCSBqIwMvAAEFKSIJUS8amgpTmYGRUlQSYEI2yyMwgnoQQi+WpdCbM3XIavUAhlBcO1auWUPIsCZVlEoRpGJFIJqRVeLfKaTZdyAEaJgCgzCgC2oKHFeGhxnEQWZaVfg2LbZDOyH9JUP61OInBn2lElwPVBwZQDDtbdsyvnNLzbRvqkhCCERC5IhjkBhjKjGw0YpfDNclsmodSErSg6o9UIGvzzC7EQzRaoBqthxD4+CebbfcklvmArjMTy0uLL/2Vmz1c8yFNFpBiPUs6/T7hIBAwcQA3GBtUgOxzxRUMkQlEvbmvAKBGjHnmGWR65EawjUwAHUAEayAzw3/fsbTGEDERFgHIVIEgYoeqQBSwSoTNgE1MO/zGGMIIY2Tzx3+jkrvpZOn2m+p6HFyPI+NjY2Pj584caIM5d49e0XkwsWLIlotQarabDanp6c7nU673d6yZcv09HQ6+YBIbsxMyBEHckLDMKiaV+VWt3P6TOvYqcruV7AIEkEciK8g79AdSACkRhUoQgUUgogohADqFVzCbQgAQ9QLAGBUERjIkErIIhiaEkhaUMgq0JtEtAwpqYEYKEMg8ANTRamCv6UDRfACJNAHwGTWMKBBPZhTE7TCmQF4taQoFgADgTKgQlRQBWGQpHkhYJp+H4RYLBGA1rgDVPGTk2MbAZCikYgRGJFS2mYQDUGRAKUKDqJRYgxDWZ2nUscdBtcSpxYRBJOLBEGTEEcVqkudaVYR5pVAHAqZGYiYVB/AfoiyaWLs9psXW+2jv/pt1u5TDT9VPskUERjTQmwAUG2k6R+Kmp6OARil1XvU2QOiaoTsnICGGMc2bao/eL9LpxlEQgXVOUceawywujJ/5KOVc+fRcacIbv3V4fWm02cHM9dOxOvOuet/dxT+GgCSatrgNICVHrNtM82Jug8lmzIhOUfkUQOMYN9rT7Wh2qhLFUZWny+Y/DAKf6ssT0PElKeQLs6DThE1u8XqR8eyC4uZUrQoDkRBAgSG0kPJAJbg0x/Urjswru2Zaz5mljyZhgAJYlJS0zFAnwcJpSPZNL17bLxWOWkICJVICcGMUTmWrfPnjrzxdu/C3GStrkXpQD51u0UArrwBaX2uzFJNAvo4JEagU2Vb8zem/wmgEbVDiEz3fPmhnbfegsdPxfMXwzW1na4aHkPTd5iha4Nk2SH8TT9cEsbkgEixQAMyVTMmAiNRUwUkylQ9KDICWAhqiEZIgGYgBkJgDLEiuYoJqAx8MlylZQuRJo+FmKopmdogjReBCU2tbwldGhKSmmhKGqluNm1wyTE93OxS8xHyQMPEQWEIDhLnyQu65NFGKNnEm6Khoo/IBkoASmYYEBWBrQqKogUEtcpBnPjYhIgDaZzKHSSG8qlOPYOoYEAFQfSshoHJh+7UZN2bFpaiElj9NzJ0N8bcX9eS/7viQa2PAQ12k89qoxtAYeI9Z8aF6c6bD975yDfOvnu8Nb+yefv2g49981Rz8vTPn+lYKWQklAG0Qwy1zKk2o1me9yE2SiGAQGs79We4h0QAUkjDzBJeVAQl04HCrBGkpeIfcOJP+dlB5PbTTpfI6mAKiY3TsIrpEcEMIkIkE1ZhcKli9loI7p8Y/qZfKUPJRFmWIWJZlnmee+/n5+fr9frY+FhZlktLS4CQ+QH5IdVHnp2dTaXhtm3b5pwLIWaZR0Y1iRLNEBBiCFnuvfdEZKrGUJL1PUIzI08OoI4EGnOwGkKWFi0CNkSASEPdK0U1lwQBgBQsIAKjsqkBxqRFkMrYrxEVEmaqFmO1GqBHMLIBgUwULblbQTFNAAKsGzjFDkNAqFm1yqiCAQS0nkJkaCo4w8AACJEgOAA1r5CDRYYiM0NwgiyWaOY1MzZ0hqQGiGIaVQFTgqeSGgAlYjghMlahCjBDRjMTwoAgCAZQA2wYA0CZmNQIiUJQma0AwUARTY0AI6Mh5AFYLTpUMFTLBRWsdIgGKFY6UAIH5gCcAYApmFIVWUuS+GQgCAwYAQgsQ0gUC28cQQm1nhFKaRImiFwIn1omEhWcRqxM7vSAkmPDCEzRhFTIBklhSINHiRULXA2RnZUSy7Icb4QJMUpFrQAATEyjSj8UbOLNahInowBRk9ln8TohpWuEhT4TCxKG8YhP+e5gW7zmk6MfNGBVZ+DQgLA066iyWRPAqYAKKjhiBNRSQdftIhtnOxlto6j3upf6xV32evhbBYANAZiImAlJTQuQDsQSJPN+wuf1funzvGBxUesGgYEYMgbFP1wX/7oDA/HqIXSdjxm4RKsFwMT3MUBVM0JHRFnHk6CJR+GBXxbBKOEe84hOYy5xSpW7nYkQczWKJX/qzDWoNrOEDHAASivvL1ilh0VsQFVgrlJ9AAMzEsSGanA83S/Hozb6pUfNBpITVTjuGoBUgRFdo5wZwCDPIYUSkNQQgNmEDMFIhcw4LfkGRCCqghjRiCAjdaqQmHJezZCAGNNdGSNFBCVENDLwCDlBWhNFQQkNMZgl0O4qOSAUhBRBIEAzU0Kh6tqcmkMEAiFTriCVAQBh+m0b3icAADCDN8uieUNF6BJ0GQMDmtWQnAADCIInMDA1cAYNBTIsMFEHoeNACZ2m2IBwRAIbCkGmWGzVy8mlhJAcKKMy6p80BhiNAQJjAClVS3STTDUEMsHKx1xBYEL03qWcegBIwlIbp6ENHXYVUhhwfyVRfz+7HyTZECHRGIkl8wtz8y88/czy4kpz2/S3Duxu3nFn+dKrUzfM3HDzAa+8emHu+PGjkwd2dBcWVo6dm9mxvVF3+bnZst3qKuQAtYFb/tNuAcgUNYAGz7lnBxpLKyNL4awvqmio4MAECCCl9RjA+r1njZOA6yMruP4S1h1N/LtPOjowLpQtJs+amAFAHSBPft8q5iAIkSw6qik5UY0xIiKPlMC4+pb/0RvH6K7kmJMIaVEUWZbled7tdlMCXKfTmZ+fn5iY2Dm+I8tzBwNJo7IsAWDr1q3OudOnTy8sLOa1nIlVSu+9A6ISTC3lWABUmSVI2GNaznk151WmwrE3I4SoEMyQLRAEQlNwhixYkfehWqMyYo2BKBMzJBCFSECMMYp3XmJQsVqWMaCJOqBYlHmeIWCUqM63UQQQ0FyNyxgAARlDiOydiJhA5nxuLKX2UKNjNGMxM2N05FlCWZgWADWBmjIBClgEpcyjSq7ooyTWf2Ha5CyGEpDAuVCEMfJoJio+4xAFGSUKOALnWIAVyNiCes+swGAesZSABMHMELsSKK9FsxjLnLIsy/pFG8wRswbJnSfkTr/nvI8IkQAMczXzvFr2NqtXlb6QMDozFwWZu6C5c9QvOybRudwRBcmRHXE/9MFRIhyQASe/O5AgRlKsxOYgEihYzKhP2mcr2LTmRCJ/Bp2+tBEDqTCVqkCMiqyGMbJqnjmDAIyqAkaMHgdzK6FbSkQXVQBgxwBV2rKpEDgzYGKXZ+BQTRAkNxsz06i5BhqKD37aFX6WWXTdD1373U90IIzCbkvdIqQA0TKmoIYSGJSxoolYVIjKCqhgunH1dEfVaiohBVWANcLDVZj4j96uhr9VfUpEERGVjAjZFezaNd/OuecwI80cAkgENVQiiASBICCyAcsfmPtWOVGvvrirh+i1HzOo9GfSzXCap4SAGKWM7PqMIed2jXtZqoMKQI6I1RSRTcWL1g3you8RJorCIQgEW8/9HRlghlgR8hJ3AAlDCBm7KApmTIymiZOuagTEFV61FMnBBJUNCDnPXCQRiuYkODVSskrG26rpiVe5wEkTkAXUimeiiEAU1PoaOfMMCCEyUXL55t6X7V7dcQakMRCgIx9j6XyOjCLRzMjUBIXAvIshZggIBGBBFR0hY7ss6p7HBKUM0eelRnJZV4OSFzJUyY2aRlwGJGyTRpMaZ2URyPkgIgTgyGcsUftR6oCs5skFRSQSiaDKnssQkYAQkzCCqPpaXkphBk7RowtRkTDV6wIzTxCKspHVC1Mzw6gIpoJOHQJ2Q+nQgVrLUyCqiYkoOWw6YsEQRUHY+Sgxy/IQYwxlPctEJHMECKUG9e73LysI5kAZANQYKQcSUZJAqKiCycJSxWgeyXsfBBJbcuOZ60gJ69vA5rQhHSKIDJKnB3yRTzkXQAMAgjGAJwOmsT3bb3jk3q394LdM81h25vVj+bYtB775zfbcxcj5jX/ywKmf4t6H7pDl1itn/ubQAw9N1f25Cz8VoETQH8ROPv13nUWSfp2tlkGv23GI3PChhqtcUg07CgzgkaBUZ4im18BfsEFmGlZeJkt+WDW1xMiFqqhc9fHqf1cZSna915aY5pUyNIJZxQMOBG2VfibgxOqszmKMTFlKRBslzl19y4jDDSXNGlVNllX6Sowx5VnCyGaU/o5WlUsIm51LO1SlPaxqZpOTk1euXFlaXpoYn9g8s/nChQudTtul76ePzszM5Hm+tLQUQsgy75wzVSICRlElBPJOXeLUIUCqzaMCqOgFHCixEYsQ0Vo+WxK9U/SCBqiEKdE4mWYWVYNkDZch9RG27LthevcODKUW/c7Cgvb6sYzd1dVYxtx5RqckaCQxesy6ioF9o1Erym6vLJiYCGKItay+Zeu2xeWVXq8P5OrTM+1eL9s1bRle+fhMJjY5Ppk3mwq2e/u2cqbRQR1fLNxca/H0KRQh4tLghj17G1da/dll87Tr8I3tWCx8eKLpahFx0949GbnF0+dRghH2jIR9rZ4RU7vXrjHXiHLByZmtLLq6skBoXiyYoHc9ECUKTBO79mzZv0+ybPboiSvnLk5M5FObd16cm5vcuiVDnj17XkW51ty2Z49qbK0sHdi7b8LXVmPf2sud05e9wJKX6R3btsxsaZ0512t1l7zs3bZr19TmMxfPLCwtqCA7CiGaAbGXinSdBFMQAQmQFayKKlbpLGBARmQMxgBM6MBkxCL8JDsSFbRvAt71WKNzpSoDYZBG5nNV0VJMokb0DpW14hgOsnxSVjmaEoqRGDCzEhIBEZAgaZItTvz/tJ8bK/hongdUi0+zaz/BGoarjuLvPTr8Ln7SUVv/i1h5vlGSYV2FrhLdWiSiWZ0zrLv26jIgbLztZK0NF6ZRBvAoVQNHuBBffDMbKLVVhTfVLAIoOyUGAxRwQCBiA/vJDHGguEKmg5DCZ/GprB293kwZot217+I1300AQwGhYnBVn0AwFmNK0p4kRjqsEIOVlwuBwMQhZaAUg5PoFRgtsEReu4LKEQrVBVbVMAmFXacoPTHVXQQ0hxDUsYAYo6GZoiKwAhqikEYypcr/iwhGGFlLsMJZ8BA9eEAHAIaIaJUXvlrw1zZaxEAIBCopSIVC2AWRej6xbQc4l6Nj0fbCUrNRW1hdUjPnPYgpmKkhc4ya5/WVbjcfGwPmIBGVAaxgWJFyy5bNzay+eGkOkLjZyJvN1W4bZ8bLEDuLbW5k/ZqPjl1zzE82Yy0DsjyIXl7sXV5qEga02Kxv2bKle25WSELNTe7Y0el0equdnorW3Pi2GesHnW+DkYIwuqRTZYap+LmYNmvjWZa1Wm0QlAy7FlyWdXtBGILzvQwbO7fu2rffFtuLZ84vr7Z5fDyiWFls3bK5v9qev7xshP1N09PjE6srq92JfHLL5magUIRue3VxZQEj1qentuzaZYqXLl5aaHeak80du2/2iAsXLswtL+Y+q3EdyoD4+9bGBBiFLGW5MQFpFWdP0yBRcRygU9SoKQR7Vd3jjdDSrIBqKU/u78pPx8zMZGagScDks56QEXLwqKplqDebN+3fl01vmrzj1vdeePZ3r720U/3RD9+BRr5pcnucnNQtmz+8eOXOw7dO3XrL+PZdK2fPrBaaYUZWEKGqXTXtP+FXDdE8gyMFLR1z3Xvs9i0ECJHJMAnGoxEADyrpDgI4lbPG1q05CDCUhbXqF67rhb3+5V3dWTjUH0ZQRDFTgD5Aj6CfUemZGBRNzbzzRG6Y+pbI4p903wm8JhycXmRZlnjb3vuiKGCw0VyVczJ6L2aGgCFEkZh8wCIyMTEBACurK+Nj45s3b15eXm512mZQCZ8BQJ7nzrnl5eWyLLdv3z4xMamiAEBISRCDiDy7ctR/j4BIrOYV64EagVyJDUUkJIBMyEuVrFaLyAqBUDHRnxTQFAGZPbh+kDZKc/fOu777HazXVi5fztWuHD020RzLDV5/6eVWa6mMVMvYkFVII5cIHcA+2szM9lsO3HDq7ddXluadovZ01+7d+288+Nbrr7U6cWzz1G1fe/SV08d2fO3ubbfd/LP/57+7eOr89jsPHbzp5o8+/qh2YN+2O29u7traeetk562PFs6fQ0VjgHq2/7ZbW72ji5cWeGzqrn/xL/q5+8X/4/+1tLA6uWvnff/3/1u4eOnH/8v/B0CCqZixd7tmNu/et+edI+/Pryxxp9wzsXVm185ea+XS8lwNyXMkBe9InWvFctvB/Xd942srEmGsufveu156+hdd0X1333Xi7Tcf/Jf/ChCP/a//65Urczt27Xr8f/63x04cX/zogxu/8Vj/0vwY2k2bJ0698Po7r7x24JGv7L/jlt5qe8cdt//mFz8/8OCdN+7ZJ61w7z13H/31c2c/+HCs1kAxi5LXsyBRoEpiYR2IbxhGRQTLFCJBREQjUMPAWeA8cC1QFpFhNK8B17+o/qlAkbEg6hAc+spDXK+99eprstrdfdPN0+ROfvCOREXvgAgASXFNBA5ADdMsMoJoIIaeQBAMFUxRlVQxmkVLFDetBNOSAYqS1rgqg3FkVgBaVTVp3dHR9weT+/M/ml4oihCoARu4lOyXMgaS882xJ86QBdaC4xuDS3B1Q1y34W18ngYMljXn2LmKqYViXrAWqR6oHqkW1QiNkBQzAVasKhKgGtCgyNk/7ThZO2rgBcigEr8FcApOElnLAKxAoAC1iE7XdP4QKi7pMARScWRTyi1dQ/4dJhsP0GhEaJM19+09eMedZ95998r58zu3bt2+a9fFj4+GJKRt6fpUkQ1AEIRMScGAFBgwJRcoVbQxI8oEaxWDAW3AtcQKA1cztCToeYgInsApAGBgWgjl9LZt9/35d4Got9ouVjqn3//oxnvuGj9+4qPXX9derAEw2ERzPIqutlq+wT1wnVJ27N83NTV2/N13FSxmbsHw4L23z7jGueUX+yHuufnA/ptvXn3vvYOPPui9e+3f/5d+LA4/dFc+NXXy0vmb775j7Iad4Kh14kz7/RMLq6vWCdbM64cP3HT7PR/+4BcBCXfOfOl//rfzZy+8+p/+ZrnX3nbbwTu+/50rL71x8sfPcb+gWlZ2izzL9t5y2COf/vBIVOv2euPT23fvveHE8eMLK8u9SdfKoLXU3eHqzbyxEntbb7/1zsceXewXU1Tbu9p77pe/3H/3HbXJxsfvf3DPX/7F+WMn3vqbHy+125tvvfHOJ5/6zdM/33zjjnseemju/RNbp6aD4xef/snylUv3PPHU1v37uistOHby7Tdev/vLX925Zw+YNS+cf/M3v+l3e1jqWCT6va4BAxDESBbTsdEI1iDfEM2coQOURLUmSsoP161i8EU2HDB/K3J5sg/BOV/5Dke0rD+1BYQSQAEYsRZ15cix1/76v7vxiQf/x/9h8+Q0hmCbJnbfeTgSWQelnodm7fzJ44cP3fal7zwxDXz0yIl2lCmf+VCSWfxsXmcwU4jEpiAaQ05ZHdn141igIDwVNTcUw8RbLVDEKphuAGrAVapqda7qjFZNeRusEtcl733C5VzzDmIEQoAIFEENANG6ZF0A85kYs7CLnHkv7IHW6DFDad6rWozRe++c63a7Sauh3+8nNExEvV4vz/PkfxmtCXXVXrmmNW7GTIguQedEAm61W81mc3pqenV1td1uZz7Ls2xN91dEZmdnnXPT09NjY2OqMoheaYLtKCCqSppkWxOrhpEQNZU7TkRPAjMwQUsiXIIIiYgL4IxSCCCFJshMQ/TkCVHFyGXk/e9efeXkW294QInx0SeeiqqLDLvuv3vnrl29+aUL586t9Hq79+7Zvn1XZH/8+Ils//49335ypbNy5ZU5MGSf1TfNrIosrLZ7BuNZXpucdrUmNhoTe2+499vf+dX/+9/nWWN8cubcqfNHPz5xU69951cefPvnvw7vn2gWEUyjyaatu129sdrqqJIRx6w2sXvHrsO3v/nci3v376Pd2+day/3tmw/u3juxZboj/ZPHjk/fecehrzx48u9tEm2ra+Bce8X5xS7c+MB9nbk563b37dxx4ezp+eVlY7f9xoPNzdt++oO/PX350uOPfmN8ckbL4PIGUObJbdm3f/PeA7MLKzM7d0/t3Gvnzgu6ucvzb/3k5/3W6n2PfvXwV782O79ctHrvvfJWe2HhG9//i903HRzD/O3X3rpy9OR3//W/3XnjjZdOnOqXoUGOPYcQk3pkMjx0bV9HQ8UkY1m5cmiQilKJjSlSHPCofo83ldA5dqtlv7Z9Zv+DDzcmx49eunLuw48nbj68O2+c+PCIacyQy7JkXUsTTqei4dwcUBqTy8lMEm2YDRiQkBBIAaXSSK4qutI1EZzhJF3/pn3C+/9URwel7wgBOeGfVPXFwAjRMWcOGVVC2S8THv49tNovtiW/L6x37l51eRvID2QpZlZd8Hq8PiIggKpJCgWBkQZmFaEBrSlg/pOPk9SwUroCA5U0GZKPKuW32jDfxQbpYanSYsX/pcGGnoqHCUEqdMOD8gtDx5BVFTgTo9ciQI/41nsfvON73zNfP3dl3k3M7Lzjnkunz1uri4gJ6yYF4TgQzMGEhzSJeaMZOq7sh0GVGxs6vUfR1NorhBT/IcNEzEICcsy12kqn/fZ77509cWYqb9Q4u/mGfe1Wa2ly/EsPP7R5anr54qUj77xdb9YPPHh/fdvWlYXFk2dPjz94384tm69c+P+R999Pkl1XmiB4zrniPRehtciI1BoJkRAECYJas6vYVWXVVt09La1nbMb6p/1h/5E1213bsZ3pmS3b3e7pIkuwihqEIpGQCSSQWkREhtau/b137z1nf3jukZGZAFmCVczqPQYLRLp7PH/y3nO/853vW65u73ohVSqVxycam7VMoB1Y+vv7jx5116/2Hjk0feTw8tVbb/7y9fPj4wWya5fvyHbj8W982aP/4MevlOtJESAornPaOzrMhTgL0nKBjNZHDvUUSlAqpz4dO3d66KnHFi5dkd6e2XOPl4b7q7s7C3Pz5eefnRoeWRMXxfGJ0bH61tYqUGt4YOrEkUsrN3SvPXZgKLm22GomQcnsE+cbQH/xX787XOh/5qlno6FhGOyPh/olXijPHhkMqtgzVMu4f/rAyJGjvUMXh8end7d2L/zw5yNR6dlvff3c05++9ItXOcDPvv+jgzMHj517Ynl+cahv+OKrF2q7uy/+d//doTsrt995R1AJPlyTeWCkAs7vfxHcm8M7LHTsLH8AFIhCJGMyAchrv4+eP2W+rMvR384ruVgqh1yBLF8ryl+vX4xAiUAAVohFFp0kJXGbc7c//PM//dz/9D+8+JWvFprNqYPH/ux/+U+DpnTw3DkILl3bXF9e+szv/pOlP/9JurGdq/0WQDlx3H3Cf22IgA+55qEJHhwwggGxKNZxMKBpj20uWY5OStdcwX3S9u9/nQQQ91j3ewuhB5dJct+olZ+8XP1VE5AXcsSBmIC9ZsdBBcuZsm1dSqKCjerIe13dD+Am+yO3qFheXn7//fefeuqpyclJa20cx+12+6233rp+/frk5OTzzz/f19f38HJr/wi/B9BE1gbmNE1zz7lms8mB+/v664369vb21MRUu90GgA75AQBye4zR0VFmXlxcrNfr2hgOHLwjQNIKnTCzVrmHNmLHBSgICwIjMqIX5EA+EDOFXLIgI/IKVUANSCJKJAh76kDISMDsRaEHrqZt11OafexMfyF2SfvmzZspO9bmyKefmTl5cnN5efTQufjE7Pzc3OSZM9s7u7Pnnjg4M1bZrbQ5qXDqjNYgUaHQ29+7vrPThBBKtq0x8UEJNSuNG+9cHB8ce/azX6TtXZNwwamttV2upz0YZRtV3ci0Ai9BRXr8wNRWrbpTrVtTYBM369XqKg+fOFm4Pjd85EhlZ3vbZ8PHj00eOrJR3T505mw0MbazvbORtFxfzzPPPl1uZktvfTQwNbN64+rA7OzBZ85n8wtDWs/fuRMpEwKv37k7efLMC9/83SNzt9fv3N26NXfy5EnDVNRxXGvJ0tr06MRS6fbhyQPVO/NRFgwYTpw0U73VWnr94sjhU/1Dwx+8+tro6NizX/x8j7Wby6vzFz9Ks2xgfISypNaoZSCxUU5EB0aFoaMpygA5RS5Xm2SvhEQQKJB4BCXsWXK7Csa8hxMI9wTlPjEIFHoVWB05djZpuZXK8oFTj928Np+ZYlAxoDUYOHEatKZOn8hexzd3h1fprFKFugt0yhlOCFZpqywCMZBHcoSOyCMygNorxDxiIXkHpmhgABZAImEQBagY0UlIvXPsiwptZNQnDw2PZjy8tw+vyP/BQoDyPkshIQIUUkBaKehM0h24ChEEPaNnckzOC3sVUtNBXwVyYQMkwXyl8g98EPkN45Q4xYKsRAKKZUQRzh9CdIAeIADey4apAyejAHYWqwpSAQ2AQjrkC9cO3twlahPmmTBLClCamLCDI9cvXR2aPRKPTqY6FhUFMIxGAPM2F8X54qyzPs1tCm0AHZAYATECMoF00CgqEHrVyUCkS7h44MZgZMWgu1rpeZZuQZSA7emdnJkp65KrNmqVmgOpF+LDX/zi1IkTrbWNmVOn6j09HMLw+Sc2qpWDTz+1+/7F7XI8XSpHKrYBszSMzEz0aXN9fpGzYEizZ5/5LPO1nZ0lksc+95n1Vr3ZzvqMHWwA3VjXRzdsTIW1KrXayrNHb8q9o5MTy0sr9XbKqKyJ0uU1qdUGD0ythSQql9fv3PEMx54833/sUNWEI08/Vn27lPTYeoHMycOnnntWKrXWjZvFYnEZssnzj/epM963Bjda164sKY9FE23fWZwcOPvVr36zurB25b33t2qVqfOP1VMHyrSWNooZDg6OCZmDB2a3bt4xrYwS36psRrut+ub6XX7p2D/9ZkEVfvrd749NTk69eKy2ulNf3X7l+z9Oa43Tp89EtazY5nLQxmCgvNP7k+88gACIokCERCkmxXkZNF+bCOd6SwRaEWitOC+vy0Nry99y5Jl6XlncA3kQEAlYmIVz1hHzJ1X57wsEJCEG8MAEpHYq7Tu3ManbkLSvX1v4878cHxxZunmlNTj2uU99vpSmamGhuLPDOzu7S4vJ9tbN99+lLLEoGJwmyAI8mFt+8jdr0CRKoVW2kDE1STcL2OjrySamGmkjUaBIMQMgO8hkPzoF+dCcp7bdDDmH7zm/iLkHqtwDhO87e3/Nk6xRFAl5RK9ESyDgNmaZiFHFiEuFgUmPBcKY2dM98sknOqTk6e/q6uprr702Ozs7MzMTQmDmN99884c//OHx48cvXLjQaDS+853vxHHc1bC7lwfv3YF5RcIY40Pw3hcKBQDImb39/f1bW1vVarW/r79YKq5vrDvvNHZZvIVCob+/X0QqlYqIaK33JP2QOhiw0cSKOpwz7Mi1Qq7Hkf8HHpCFghAzAxMy5StLEZIAmBE4DSH3rBBABHaBbEGAXURBSdxTkLhYLvTuRmuUhEJf6ciB2c3l1Zd/+tPHn376mS98/tbS3TvLS0I4XTRqdHBncX5rYW5tazMoCsy2UCgXCgvNRTDaEzqNUIxbKFrJ3YXbVxcqn33uhezmXOYdaKWjSGnddpkHNoRiMDDqnmI81Le4sNQmcRhUpNoFc2tlabqnOHX2VBPRrW2WwLZXdytmk9n1FPoHi7Wli5fXCqX2ZpWb/t2fv1G5vvD09KyP9OtvvfGtf/4vJ2cOvP1//39UqzWrdcHayvLa63/6l1NnT5987LGjJ85+9PIrtVYjVdQCrqfJ7uLC8IHpQ2fOmJ7S2tZmwqGFIRidAEfMXG+GtCVFJSBJs5nWq0K+ONq3O780OjP9xO99u725O3fzRjtp9ZT6KHMh+Egb5lwnrSMZmaP3TNi5DN2bCKQ7YXXU0kWJ6Hu6c3v47/2PCSKLeOaop2/k7GM1xI1m68DJk3bkQps5YWGyxoLPoNOXAHwPHULkDutSmJBFGIQ7ykvQsTNigAASRIQYSDCXO1WeKMeH/ybtvP9wIQCChKKQkTgoJMwNvQFZJOS9PorIaK2gk1x8XEL56AR2Gxc+ds77Lc6CD6e/CIQMiJhrBykiAJE98SBhQObOfygIgfL2dskRsIAS/mFvKoQO/tx9FgSEmYTzlSAGhFw0P3TnqdzUQDqUGunwgphQCJ0ICJIQgtrjOwhIhzaMBEggLMABcfzYCTsxdfWDDz793KcGj55obm544UypVCnFoHKT+xyeBcyfyXzFKTn9TTrnGZBy80ZA7rTcYedL89/vP14xLFog9qg6pGelmJULpf6Bg9rg4Pj2/NL1egIBy73DI/19t67Pvfmzl775zW8+/sLn3/j5K3du3YXI9oxOFodXtzbXV6tJZWNLOdYGx8bGFerWbsWCMlobIGAuRgVx/sOPPhzrHz75uc/wTjXZbXnhXhMJsyIFHJiDNZoh9Az0FMvlS29eqruErNGgWpVadWOjZ2rsQFmjsfXNHQHZblT97vYGuQPHj/WMjezu7LSq1d00aZrop3/5/aK2L7z4+Y3Km+9cfP9b/+Ffrq0tvvv9P6ZmY0gVM4a7Fz+suWR8Zub0E08ePvvkL176CQfRhYK3ttJqNmvVaGSgt2RawPWVpQxEtIoLBc1SJCPNdsgST5ChQGSTVqu3p0fHhe3NnaOHDx/7whcW3n3n5o0rsdFEnOc9v+b2EyRRwp30lxhRCJE6yhL5qocACQIzCOBD8ffxUPxNIxfNgO7M0iU/AEEn/crz9rwwAvtOCj6wme7/UglgIlTksnTl0mVDZNut0SDomos//TmVe4Hl3T/78/GJ6eWtza1mpaFpsq/nwEB/6/Ll9tISuiQWVsHltTOVay39ukABHajIVrP2QfkodpHejMLgl56fevK4Cu22pGx0ANKoRVCTFuDgPQCorhvfHi17L4sLnLe0EmCeCgPSfaod+ZhyH/YL95O0Oi8KMCtmLeSRvBLNXkPwBkIASKTIZe4b3hzqrWghRuqWDffQ2QevmkgIIY5ja20OwhJRHMdbW1tvvfXWyZMn/+iP/ujVV199+eWXX3jhhdnZWeguvfZ+2X8Hcm6n3n0xhAAAedJcq9XKpXJ/f39lt5K6TJHSIpJzjUulkjFmdXXVGHP48KGenp7gvVIaQDF7QFZKIxCHoO7J3hMpImQmDhiko1cH+QGrXMkSBNALUkAKqDgnbQqhCCAwAhiVIafB9xhFlZ2P3n578c1LkYNWu3Xw1BkgrVCjss1mkqUOSR87cWZocOjy5ctJPWEfGBC0SQSbQQCpNDpeycLi6noA0tpKEHbeaF2IStSo33nzvccnDp/6ypcrV681k8QIWdAgoOOii6IGZglDX28fsdra2CFDjTQbKERKdGVxZWx89tNf+9L7773nVmFmbGr2yNGDx45fev/dbKcGgayK+qOyaoaw005322nTA6O2UWCMbBSU5ajASjtUwnD67LmE6JcvvfKjH/3ka//sD488+/Sdixc9CyDpQnzj6rWx8YmnXvjM3M2bGDIwxkYxKwyxraIcOnE8GhhYvViZPH5ie33jp6++9u1jMz0Tk4PH06e+8fVKbff9P/2eqtYGS0XxCSGQVWna0lpj118I8+IQ5tmAkIASEAEWAmBBEWTAIOQFA6FQQERkkY7SswizKEIECMKsJARGDU6wb2ascGC4vr3Zo1RJqZljh0JEaE2KwiBkVBacQdAiRlBEglYJB0WkGBSTMIpCz04YSRQJBoAEOAPIfIhcoCA6d85BDB1qwd9eo+rvO/IkhQRUDrxhB6QWARKwQLE2kbWCknr3q+GZ33rsn+c+SbzmEYouyw0RlVaAnUJtPhnuwaUBkXHPeTtnRTABdnQR/2GPT7oi2QC55QEpAQD2hCQCwIaFO4TbrpoD5iDXHr127+87jzkJMAfQihHZB0WEpJwEFFAgCtCJSGQPHDvaOzg0NTIicXTwibPX33zdGUECEc5IkLAjvCOhWy0FRmQRFLD5rkuuONYRgMHusWBnp/Z+vxe5xW8OSncdfiBCVWR0N+689uprO+sbsWgdF9AxMLDjeqVeaSRbO7UDJ8sHjh4fn5pc2VhnNN5zWk+oP2qK7y1apXBoYKhWb1R2d5k9QYe9kbq2AvbV+oVfXvyD/+HfDz7++PXvv+RFUvZYitMiNbUq6yjzUhM4ceCg8Vzd3FSlCJQWFg96Y21jYnxi/OSJGwtzPf29UVTuP9YzcuxwbXE+Kpa1tlkrU0pzGkK13m4kYrjdbBsTNdpp0vbtZqi2XblQ3mFSfeWjz5y/s7X61nf/bLhv6Nv/5t9OPP64UUZ8nqyoO/Pzs1MTo4MDl1fmepTxSjnPkTY7EBqaj589Dv29XuupY8dvzi/M/+Vf/uH/+D/1HD0ajdRPf+7zl957d/7NtxRoRBaXlh6UJvuYoSZn1AgJizgAv9e63vWcEwEWCbnYXXc82OvE/zve/L/hwC4ACp16FJEyhnJAVEAUoWYIgi63GmA2AhZRASKiZ5czKDyIAnIhZMFbUraRErsYQJMKnJla3TeTbXaa7PriEoIHUkjw7Jc+d/Do0auvvCI7WyoXFCV0IkQoALkEKgFmIEQoIlbQ5ac0r+QgpgKOBUSJx+AAirHXapvbhSPTfccmY/DOtVJrgtJBFAVB0gzinEcE0VqYBXIhTWDoLn6VykWihQg6JFruPpf3yA95qQmgs3jI8zm6nyOBIBA8c8hHU8bgJbASUIQZ2wwLuq+GasUEzzxoDfjcnEz2Tx8fc9G6yXFOV8hly9bX11988cWhoaGDBw/W6/VKpTIzM7P3eewm1vtFSEBAmG2X/JBn0lmWbW9vl8vlgYGBra2tVqtVLpZsZDu6vyJSrVYrlUocx0NDQ61Wu9FsWGuNMWnSCiEYqwlUljnQqEgZbQAREJmFUVL0CTinmAnAAzFoQMWsGDwFDxAUOlCd3uqAWkyOA7IwGeNDsIDFzBWa7f5mWkkzAqWsiYNParXtrY2p06c//cJnjxw9tn7jTiEuIitXbekki9ptlaR9A8MTBw7e2a6IwOiBg6nzaSbEaAQjxypzcYBS0402ZGOrtfz6W7NnToHVGqTHSaHlTcsRSBPYGJOBjAyP9yQoW3WPklrk4AuVZt/qbi2l/uOn/PpaD45LsVYcH2jHUG3uuJCwhCT48tDQ0dkjJYgUK08kgQseP/vM8+25xd2d3bPPfbpZqe9ubSepkyh67Mkn1PDgRqMx0D+wtbAIaWYyX/Rs08DV+naSHTg4uzZ3u39icnBkOKo3R8p9jz31DJx1h8+cWb0zX1nd+upXv1Zvt9d3tpSYRqX52Fe/XBofW7p989SZM35hfmdlFQWEVGDRRoOI6sKpXe5gxzjTeDABUFBAAjATsPKBvEcXKOu0dSIyCBKxsFKaxBPngitBCBw4QPEURmeGd+5evfCXPw21TH3+c6emxgHYt2uE7CRTIKQJNHIrjdm4wGgUGwAhm0lBTAisizb1Io4isEZIUGUaEwS2KjI2CgAsxEyEAoEQiPOH8xEbfwGgy0IDERIQZEfoRBQKCRtB5Rl9UAAs4nMtlK455P6azm9x/x+IfGySfQ5P+T9/BRv4HzA6SE8XicoFERABjTYAHIIXECBiIGIiJkbtiAXRBNYsminVDITETDkl9R/4AKCjtIuCJmhiIOFAwWlBAR3QBBJPDMaR4m49EY3y0IEeci5vvnrVTFZEMafsPRlRhoNYIAHyIEorCqxZEpHycK917Q/+63++denD+tmzT33q6er4gMvqxeA4hGAlEzaaiQOwaNIiqFB3RMop5/mycJZnwhAEAqMwcWcSBcl37cF7IyAKKA8UFKICzqdeDzYTm3Cx5ZJWpigUCiWjMKtVG0ly5tRJY/TJs6dW5m6NjI+0s3RtafHgE+cGlU6IxsZHF6bGtldW+voGDgwML96+zeyYRFng0JbQFki1d8NO5uaWrvz4pef/7b+MirEBZu8RISN0Smc+gFiK4lL/WGttCxp11NpLhhK05/rKxvDQyFT/8MXX3xiOygFU3+zETrXa3NqmJCuTAcGJweGs0dKMBVAFbQzh8NDgidOnNz68USL9qc9/5Y2fveS8R3Tjw0PPnn+iNDJmCVVI2rtbBekbKBR6PJYT75bXS0/P9swc2H3t5dHjR5pIPWiHJqaPfObZ3nLP9JOP3/rgfRvCp778lcnllUY7KvzcpwABAABJREFUaSeJK8Sf/upXbZqh0TPnzlbm5kKlQgGAw37h9rzqvf9iCAAIM4onYAxEui0ck2fxitkyakEI4AOEvEXeMwDkfUV76lR/3w/IXzMQICf9kxAJIpGiXKMmeO/zMgaIkCCAckqcJgmsQGEAA9LRrAIIhBaJg4AwIyoExaJBtxUIiEKKGdqQFQNHmBAyawVaa5e1rly9Obews7oSu4wEgIAZ8h0BFqsUiKAEAQkKI8HIo0cRUAwhEhYCR5ASpARCulwoNRizTABNTXnTTkcCW4xEWcfk2RuUjN0esOK8z+ePvRadPDhwPjSyhC5voNvcuy/9BUQfgrAonYswhL1LvO9jEAQUGo0kPgQWpwlIiRedoaW4FnxDBauUAgg+QAj5FvYLmT1w1fKsd09ZyDlnjIGuFmoIIWdH7Cmd7U9590DuvVY5E1lAzI3ftNb5Fnp7e9vt9tramvNuaGgoTdPgwz3yQ5qm5XJ5eHi40WgkSRICG2O8D4G5UCygAlfPRMTaGJC997lEuoAgi2W0TCYnx4fcqpaIUbNoBk+oBAiwU14X2HNHCAI+81ph0ahsp7J04a2wvNyTNItxlEpoXrvUlrBeq9pW5czkZGt18dIHHxgTP/74E48N9O+8+2ajWU+Xl3cHeqci2hFHzmfrK41KtTekzqWGs1j8wtu/aNfr7XTLtZMxl9ZuXL70x//JFuNSu17grHXt8p1Qw+31YmiTEwvAOxuNrFmuVxmgaJE3llZ/9hNYW2kqdaO61b5+A9eW/MDgdq06cO7cswcnlt/5Ra1aC+sb1etXCtX6+tKiu3unx2Ub77/NaQvT5tU7c75eV6dOFX3Lh0QHN//W69DYnjpyZHpgfP3y+/Nvv2MUbexuqY3Nuy//LF1bbfhwfWfT3bqR7mztxDHs7jT6eqd0LLGqfnTx8oU3Q7N+4/WXD504fqS3cOvnP6usrWY9hbWl+RHw8WDv2opqZS2ldCkqcJDMOaO03HPizpkroHJBcwJiyu2xCBAg5M+EFbSBib1WgAQ+ACvxjlHQKMVpCshKI4agrEnSdFDZ5Obc/OUPy2vVyNPm628Ux0a8cLXWKrcScC42JjBnIXBgQSGCNE2icpxmPihiZvFeeYwUiQIXvHhmECYSRG1NZIzG3Kej8xTm/K1HFv3diw4xi/bKwEKAGolEhIUI47hA3TrU3or2t7e/Hx8fi/ju39tHZwoE6JTafXCBUCltbQQd9B0ROj2UgATACKQkbw3NOej4sIj8P/CuE6AWQFCMIOjzB5YACUhQyZ7wA+772SlT5mKC0EVFQmRU5jKPHBWLus0uzZRVRKi9mMQXNWLg5dd+2VjdLFQqtY+uLLCvJ7uBQe3UiqlDY32SFkgXbRxaGbMkmhyRuFBS1gIz+YDgGSgw+eBRnEJPGLrMS+nQNB68PeQeXxn2cG+tVdKsb9y8Be1WQWulFPpk64N328vLu83m6LPPPDs9unvr6qULF8YmJ86cO3dusLz7y1d3rl+jVkuKdqJYbgfoE5XMLVWu3OpzoK1Nmiktr2+/e7HYaDU+uKIr1XGfLf7yteHeCDYrQ+RUxs0bV+pFLGetMrsyCwi6tZXqztZAUhdEUqZU22z98lW8e2fHJWZttXnlSsZcazSqN6+fOHX8/MTwypuv7ywtNyvVCZf2V2u1t98o7azHxcLme2+OEtHqwpW3Lw719B87cmS0pLd2KpLg6is/LZ5/8jNHZ8W7hffeXHv/fZya1H0DZnV94+1f8vytTcX121f41rWMPNfrm83dQQxPHpzIvL/x2s+uvfkmOLfcVz599rE0LXz0sx+73YpbnKHMPTYxhL3xh/M3dpo7RtOD1Ad8UIMZAFTIRSXFEyCIEkAG5G61EBE0obFo7H62w6NXBUJ8qHzPLCF45twDMrczhJSQRZSgADokRmwHr4gynwGSI2GEXq3S4AxiBhKCj1TUDFmK4AEKRMjSRnFFBUEoA4PE3kciu8srjBQZA4FzJN8LaKQQmFC1kbzkgjOAIFqwApyR8ogadS9TM6SOgBWDAa2RMIDLIjIqVkVFcd3ZWotEIhtZIgSO8MHWl/slz6BLYehcLYBci3Cv3eaB05envJJnkvkK54FsVQADAgEVQKH3TnxqMGgCF8pojGumLEaj9ZGPo7r3qHWevCJinow+EPn04ZzLPxBFURzHWutyuVwsFmu1WhRFlUpFKdXT02OMyU008H6ph5yvq7UmIkISZkSMoig/hHK53NvbOzc312q1pqamAGB5ZTlzmYYu77hYLA4PDzebzd3d3ZGRkf6+Puc8M8dRpAylWVuBFOLYacVd5nt+/oxQgSliMoGCIAIykBcBEWIJjJz7gDBxrl0pwMLYkSMhFAGrCKHVat386CNw6YDmWLIkuN1bV9hoCu7OhbW7Jkoyr7RBVB8szhFSI2sVS7FhfvfP/sQIDmpFHFY+fCfLsjIpbQgllSRZv3apKdJcv61JD2hJXbJx6T1BKDoZsLaxsnBr5WaJVb/WLrggobpwY0ck8pkyxuio1aquflBRWqXO3Vlf1ETtjbWWVknm3715tbe/b7eya41Vmbv6V6uaBV0oCYJStRtX0pDdvHnFikSI8798GURKAANR1Gpsz7/5+url9wNA1mgVAY1S1a118H55a5W0MoALd+/0lAuuurNTb5TLxeurS5AxChOqHqIyyM77b9evXRLENMvKPaWrf/GnhIoIJTAARIWCUirtKrHnT+KeUQHl9V5B7o5iHtEBClJg5oAUUDNaB+SDihAksM9CXBBFWeK980YrUEoJY+IV2QKaUuZrl6+XbGG83JsGl2xX2pWG956ybKTYk6TtyGfamrpIQtQUF1trRRqtNlnVhkAoGj150TEkJmQYOqVTFgYIgQPzX1+r5RGP/dMGIhE+qCa297Hfxt79qsD744HE91FBf+9XtUTEvFv3v5Xb568VDBIkWFSEIARpyKwDqwgQm0lbOY4cKq12t3eT9UopYDEuut367V+82dChpcxIGzh1NrLklQ4MlKnAOrI+si3vrY4oC+LZ67wtDxFIgRKtnVU+t4PCvNFgj5FxX+Sttx3QqaO2LRqhWa3evno1SxMSUUSu1bz1sx+hppCkH22uRNZWq9UIsbax/O7VS8aapJ1kLrPavnvnlnYwJFrt1i+//Cp46CciB9T26dzq3MqGD/724oYB7uUsSdKr3/8LTHgUtSFZvfROU0u/UC9SQbhVT1YvvkVZOpIbJmcprLUWNlZJuLq63LwS9TKvvPVLG8WZcx/evhLEtxstqw07f+nmdQIMPgwqnexu7Gyvaa03stQK7q4tfjh/w4CMgWTey0rz6sKtuVJRR6bebBS8T5qVRWbtZX7hlsrS9e1VMrrUalU+rHuRzTvcunopC4E5NGuNXq2Mwruv/GTl7TeCso12Rqgu3rkZK1LeF4ExTfs5DWIc5UumvVwBHsx7BFRAKwoRiAiQtIgWIqGcP5Crl7LCjqrWQ/HIjFQdilPX+a1bCyJSKu9iIkQCYo/UDtI3Njp97PDtm9erG1sxISMqrTxJFkQh1FwAEGAmQh3HzdRlIEFrsabRThLh0SMHEyPbK+sEmXVeMVtlQCGLsAsalBOPAsCitMqABdEXCgikXNL2iVEADIVyOQWpZ6kB1Ow1YQQAgXNBbUKvQRDRCuh6ZfPD9+++9xHXm0zkkDRD/Ncw6HkYnhARpJyjeh/6KyzMLCD5lNQ1ospz1k5KLYBOBAUKgsQhg5AqYKssaWlnJgOM4x2f0fTY8W98pTw52RbxSeKcy4HkDg9tX+yRIpRSjUbj7bffbrfbIYS+vr6zZ89euHDhzJkz77zzTn9//8jIyP7mk4drj/eG/S6Vgrvu67u7u61Wa2xsTCm1vb0NgISkAUApFUVRFEVJktRqtZ6ennK5nHe8GTKkJMtSEbHWEpJzXmsy1iBRzgclJGKEAD639jLEGgIE7SWQpIocISlgEo+dKnuu/4QAIj6AoEAWPFiVcbBKEaLLUiDJMgciBauTEDjJIqXEe2CvhAB8XxQ16s1SITJEWbON5RIzB8+KlA+BcqsOELQaPWvHinyKSEar/IwI10JiIhtlaKxOfQjApMmDMEihVEqyNMkSbWyaJqSU1so5H0eRBvHtZDAutLI02dkpK83Oa2b2TitDCAQi3lOGFgIIWq2zpF2wFoA5cOYdIUZIodligAKgFVBBNFJkI+ccsxBiSRnFKGk2GBc488hikZAxsIviuJ1m/TbmEASpYGxotYuAAoF9ADSESqFCD+ABGImQoOMK322gIUeYKmIkTZAhOAKngZBcQFZaEFGQhEAw846Yo9hs6ZC6UNa6qCKvsO7aPUL9UbGaJE6hJixEBQK1Vd9pC2tts1YztkYVzUZogfIFpZyrB9apAjSq7dMeW7SKGuBb5BVij0XKnAQJ2rPOXWpyKqaIiIRHnB/7142cQJlzp7TWgLnh4r1Szr5PPiKTCkDXXAd+XbL7W9rnh8gPHcKfQQ0skveFPEqn8+89EJGUTklaIM77mJTXlPnAApG2yjtW4JnBg84ABBIKIXgSKRgNLrQFMIqamSsEMCaq+TQuxiHzWdtra1PnPXDJGgpCDKyMV6qtwbOQBwva5jNrx/YCYI8LtNed3lHYyHHqDgBMiJl3LmmWoygA60COMc1cVLCWtK82vFEmzeI41ko3q7VgjAWMiMCF4DNRkRcxZLLEF0wEAs67QiFKfRDnI63Bp4QghEVtEu8IIeUsECFiHMASOQmJBk3KJ6niIECR0Y5FBJIki6wJiL6VRMaAcxREB3YuDewKpCRt9xSKabtNRBQEsrTXRj5z4BxmThujQdA7RNBEIIJAkTWNyi5pZYhirUOSiA9IKnivgicNkvqCgM68VuhCSDa3lbHIYTiKlXhk5hBcpWbiYh8o51NDWoIL7FrBRURaIZLq6JHujZ65Aw/ur5AjEDhRGWFAAiQn7FGxUoGURxAQD8GDDxhgX5Kx/5d/4Nv7k6LbrYV7zW1KKWMNkRdhDoGBQTANIe0t9X7rhYO/8/Xl//f/d+nPflbwGoBSybw2TOyd10pbpQ2SB0kTFzGi0oF0FoRRYWRGn36uDdny2kvg09hYEg6gmFlYyGgBwECBvY2LmTAySRwfevFzWmj+pVcIOEPAWIXEMyhlYkfiSKzLyp7rGoEz5kyhRAYde5u5AeLFlbs7b12w9ZZVOheAka6v432n4IGQ+38AACB/vNJD/jxyV1u8CxPfvzFGIkHmnAgeWAEbckjcSoVJxaXMp6Xawf7Pv1AhbGQ+7z/bIz88jPLkHxgZGTl06NCtW7fu3r0rIp/+9Ke/9KUv7e7u/vEf/3GhUPjOd74zNDT0K5iB+xJiyUFi51xueZ0kSZIkvb29SqmNjQ2lVH9fn40iLSLOOQBot9vVanVgYKC/v79SqdTr9UKxyD4kSVOUGGvJYZZmoImQsLMQECTMO34RiAVSkSwEJwyaLJERSBE9KmFQwk6H/FSqvZq1CBBxCJmwBs2oPEvdA4pBILbkAThgAOtZrLEh88BglHXBYyZkyqkHBUiFqJ4F75BAR5EVDIG0lxA4kNhEgibFiHUMJJh7hmbCAblEhSDYDoqRWRvmEAIjoWHtAYIPsS44rX1ua6lCcKACKhU1k6BMKfM+cQKI2hSEfCugRlCAAhIcgbXM4hyruHe7nRhtch0WAQyehYUQFeqUmZm1MQKCymbe50xAysgFq0krpTKfhCCRNY5d2mZji4kPLIhEEsQFMtZmzpGyiNqxYPdM5wMd7c1AHe4vOcEUVAAkAJPbvYqA914EGMUjOrFMkbIJehDRJkojpp5yWsvEg0OQgf4sk7QZnEU72FNtt0zb9ZioPDwsBkIIvaIkyTIDGUCvjdJ20qjVrIm0tQ4Yvd+utYy1ENkoKrp6IoxAgdmj5NRkQAJCIgSttTb60Rlk/y6Rr1676usdeVroroD3L2ofqePFfXu4J68I3UEHfst7+7HpLyEQknQTr/9/CwyALa308AA1PbZ8U0GwOiqVpJGyeD/c3/ZJy7XK5cj09jgrwFzWUavdYMTIxFExTputxlZVo0pLhVigJxPXSgGU06CLpSzLCi3WAg4oRWgJB2YJmAZoh46Oidzzh4L9/0cB6tKC91rkCCjvenUCgsjCLCQQpSmaKAafiihtIuc5MNl4IHgfOGg0gVmUybTyIWsmbVLkgYXZe2coCihAKvMetQl5RuSBHaC1de8UkgJi71zAwKC1IWUViygJ3mvWgVkAwcSOgYxhkMwJg2aPAmC1RfbOZ8bqZhKErbYxEAcfAtk0S5TWJi5m3pNSWZYJi7HKBRHPURyzLhlrA7MIKqUYQgBwzMoWMh+AEDW0Mqe0ZlFIRqnIhyR1SGQUoZNg4phQJ2kWm3IIgVCjjsBIKr7NPve535/CCADclzEhABKDYfICAQEQvIhjZkAkEqQ9tihgZ0DeawPYb/34KESH+5tbc0j+AyCvj7Pk8mdBwGsrQ0MzTz1Vq9dGjh673ftuVnVkzdCJ072Hp7Ikuf3eR63NyujRw2OHZ5vgr166vLu+NTY7e/zUySCwubB05/K1tKc/sE/QHnny/Mz0BGfp5SsfNSrVsaGR8ZmZYrF47cMPewYHDs/OJkS3b9zYqu6efuHpGIs33rmoqHjs/Dkd2Y355fXrd7i/NHR05mB/v7t+Y/vGHEk+CwAiEKEC1hJ6NfVKaKWtQQ4lQOdyO/C/0em5l/5+bC0s7w9C6RBb898fAPwFIK/MRgAEEIAThsyDCBRBGYQkraPCCDKdtHyWAaAxJoqinM4LXaXde5esq1l29OjR//gf/2NOt/Del0qlUqn0b//tv11cXJycnBwZGdkzhNu/6NprqrtXkJQOmdh3UA9ExIGBgVartba+ppXu7e2tVqvM3OEF5xppxWKxVCrt7u62220RIUTPLMxRMWLxLnNaKYytAIcQ8vYLFmHmQKhLhXigP4w2ESSlIJqMoAmIRF5RIUMlnGmXr0KVADEQAAsjovO+YEwADswECgIZGyVpCsogoQ/OGKuEmNmiQkFgLpDKODNGe+9CYCAFIIYoBJeKWBslzimlCDDhoIy2gQJ7LpqQZIZJAYhWXnwawJSYtQoKQEEILp8421kWGdtZrYRcPBMVgELCzCOgQkEiDL4YR857AAAWIiXMShvvvALKnDM2CiBMYAlc8CEETdooo1iARQMqzDujGBCD9zqyKrCABA6BkBB9YB3HlCZKBAgNoguOkTRRYMkfk6K17XY7sgY1efaGQECCDwSgtKbOUjhf/nXuayukSDExChgGp8Ahow8CwgWriwUR5MDBM8YaAZutZPDs6ce+8uVbL795/cK7PZPjz/3uN5s3F27/4JWJs6eO/pMvv/ezn2x/dGPq4GzfY0eiI9MYwvbtxcbW7vjZYw3JSmQkyd57650o7pmeObQ6d+fkmbMXf/lmbWvjqc+/uLM4v3H1phdWSgly3gW0t5LLJ1LEj6+7/aOLnMKRN/QzMyEVCgX1cXIKj1T6Cw9Ul+4fffa/8tvZtYfSXwDxwQcPWiltDD1iJ/PvP9B5hN6B09/5tlqrXvrLn1e1P/aVz09OH7j6f3w/KHPwn35zp1ld+uGPeiYnTr74rBwaN9a61a33Pvrw2PmnBorletLSJrr7zkc3b9068Mxjm1evH5k66le2r3146dCTj2tNC+9dNERKkAWDAGkTF0pRT6/vbyZ5C0FnLQfQgd7v0Q07NcD9LwGIMCgipFaaGmMARBhFVAgAURRij0Z7H4L3pBR1pOeZSQFRBhmrQCgSRAGiNsE7RaqZZiYyASB1WRTHiWcmXWAFqfNWJ8hIaJ2oxJPVEukGsHZQEEwlkFGNNNVKCwKhCsx7c2tgJqVCYI/sQqZLGrXKkjS2tukCAGijW2mqiwNpYETUWnsC5gACHpFD0KRSxCwED6BJibDWJs1SUkqEESmHxIzWWZZZY/K0IBWgHmLkTDwioijnGRiwQKknZZQobLabKtKMzOIJQdH96UuXBLGH/iKgycR4hbnpoWgjzvaU0GifZxOAhMoqZZRC/Ji15KMzUmFXZySHuAnBQ+6S3ZWeBfLIzVI0e+6Jdpsu/MmfPPHcc5Onzi289e6pxx47/M0vzVeW+/p7Dw2PVD+YO/y1z69ku6GoD505cvm1N89+5WvLjUbWSk4cO77Z9jWgAGr01Lkz3/zKtbmr5aI9cfboxQtvjj/7zMiRo3PvvdvX/+zYoYO35ub6Zg4ceOLEnVde2RwqRS2xhw+deeGZVIe0UT/+xBPNl14tTw2f/8631t56p7G42NaUMSiySlkB8sygUBstzaB9sFlW8lyUTrubewjC/aQrkUNK+bv0cZ/twMNdEZk8ZcjH1Qc+lotCWgCVa6lKR2KDRCKls+CBgdARiVLKkMp11vIb+GHtM+narjnnRkZGoNvrlie7ExMTY2Nj3vu9djdjTK5X9gBUlLe+3UuCAaIoL6dzsViMomh7Z5uQRkdHkySp1mppktxTfujp6SkUCpubm41GY2pqqq+v3zvHzFEUAUjw3iqKorgF+cNscuV0JmhYbBfgGjQmHj9Snh1XhC0KAUExRAFdN/0lEK+ZqdPykKe/+agozMqYkLNWUYkYpaIky4QQFDGLIspNA3IvJAIkxADB5Z2JHbEP0UoRoXOeFLnMaa0V6ZQ9KowyCRxaJQOZLwWIlfUaG+AjB72iEg0tCV48EmilEDFNU00qh+mYQ+eCCWhSSiSEQFoFZi+stHHBaa3z2yBkzmhFQDogMJBWbe8DiokjFhYQ9kwCWpBYkJkBRSEpzJFPIgrCzKyIHAciBR0UF4jZu0wp0toEZgBw3iGRAGitfQikKATP7Eh1+vQJUZhDCPe0RrpoSy75yyQkYFgyAk+iWBAhU5BO9q+vLOz2GmohskSArXYyMj518PnP1LeTDy5d7Z+YmHjyiSUHu5E9c/pM34kTR3Z3Nq4vzq9uJpw8e2Q2S5IL731w5ujxEBffeucSZtnzn/38+Pmnmzu1vpMnrt2843oHz371q82Nlb7JyTsffAgehcmTDiDGkxXFzHlKw4FDYOdcR9TxH310LgZzQACttH/gjUcy9saa/Uvt3/ZO/aqQnABAmNvpyb2J/x973Ot0xr1F4UPHJogOSOLS8NnHShPZh69cbIXW2HPP9oyOJD9+tXdifPDpJwqcXb1xc215Lbp0faRUGJ2Ymr8yX9toDE0eW7t69dLlD0+cOTN75ny1ESYnD+0srNYUHv3cM+3+eHhsfO3WnAC2kEHrzLNlpRNvtTn2/DOQNTQGhD1teICPaX2TzpC6L1gEAfPRW2mV11YJIwEFgN45IgJErVQIQUSU0jkWg0ReeQ8ZCFttcjVz8UFrnaWptoYFWFhpnQo41mU2BcZUYw0cE5QcxgkHjVlELQwFhyUmh0yRds4ppQABgTrqeXnFEwkAgw8CLMjWGpdmSBjZKG0nRAQiIYTIWuYcxSYHjIjCnOfuPnNKaURkDgpJQlBaB2YgREKXOW0Mh0CApAgBODARcmClVAieFQuAIiMuGNCRtmmSaaM8iBMPFp0EQFHAKvDDD+r+qyEgjJIBay0oaD0FDlFPz2q7tQmp0mQ9mRCsY+skuKC1McZkWfaoDQKdigMCdJl++a2ntdYmP5EKgByGViGafeYpE0ViYhqemH7+uWtLiwNPPbG8uPbKf/7ugenp/oH+maee2mwkF/78h2mkR8fHZ2bODE8dvfKTH+2mydnf+cxktVVFLowOjY2M+OHBhVcWJyfHj33967eW1oMtzc0t//iHPzswe3CrmVbq1SkdPf3Zz7bhlyvX523G4cDE2OnTf/Z/+7/u3p57/lvfGH/ybEDXXlm79H983y8sFrVBpTvuCahFGyHxBGAMKI2kUJgAVM5t/JvIHu3RHfanuPefwPs+DJ3lxH0fE4DcwSNPpkNODSdABBc4ZReIMggaWcfGWqsERZIciN0DgO/bYFfHRrpSvnm/mveeiFqtVhzH+We01jk6eZ/SWTc6qDCCQEf2uMNdVoqIdnZ2gg/jE+NZllUqFa2V2RM+8943Go1c86G/v7+npyfLUh+C1gbAe86U1pY0AACiUmSt6QxtCBlBqsOGpKODJWuVVroQYWBRApEHReQVxQ6RgUi6hpld06+uvKYA6DwnAABULBRhaa9uJpCTQAH5XtuqAjZdx4RcuDPfUIQAACZftwhEKIBccCgoLgLDWHCgBUSBNRg7MQ68xsiI2aeeWYQe6t4h3QkGCKCjlZuX6hA0gCDsX10bQYA8p0TFJICkMGCnrCDdY1cCSiTvPA/YEdhTgIKiut0JGrrKJAAgTCCqu3sKQACiLm9dQLpHDSSIfB9dZ3/i2/1nR58zEBCDZdAEXrEBYg5A7Au6qaVGIWZfRivEYJEdV27P9fX0Dh6Y7ZuYXNvY3Gg0zeSkGRt97Qc/OjkxPXvw+MrlG5tJo7a206o3Npc322OzUXlgeHCC04zEthpZ2xiO4tWtyqs//Mm3/8O/mzh55Of/5f/YWtse8JpDSDWiio1Y7XOtno66yCd5hf9jDOa8uyAnpVkizJIsX8vu4amP4MHux3rv2VY/KpPf/egv5hpioLQi3ZF5f6RKtH+XwDyvBFRKdww4AR8+OBbySGQLrZWtGIvF2QOFZpWYdzY3N2M1enDm+u1btr888eS5awur197+KC2XbaJvvPlhUxgSiNpg26QSBSHVbYi8kYwvvvH64Oz4Y//qn13+7l/cvn694DlDRhIvoajjoqAm6hsd1thHnWE6h2E+hhuT8x7u1WI/7kipM7sjw55TQVegQ+7Vb/MmElG81wO/N7/kP7lLf2GAQOhQlRzFDtoajIVAUM6g7NApaGmIDRQ9FBxnBL6rMtMZg2VvwtpfOpaOMXD3U3Gn+NCd4ASgmyJ0gMl8O13cu7OfCMIg1N1b7FAU9twx9//OwIGYc1s2Qc1IggVAAWGEQOKImURADGPkfw3rXUASy0FloEGLsk6I0ZgoWVhwGpQm9KCCaMeaAZQCrfdTnj42F/ltRZdxA/t0f8EYo7QXCczMELzA4KGZeGocdxrPnHpiICpnp0fNoQs00sc3l4sVz+0NOBLFIyOV1dVsre4UZN4UD5zNMpyZnBkiXFy4u7a9PXh4tk5AcRQXC6dPPWYFKnMr0AqlFOorG+3ddulo+dSZJ1hEsVcOetAMsAbNzYGiyRJba1Kl0ajUCkcmfb2Srq5Hu61YKAHJkFgQQKGOgG3A4FEypTNSmaIUwAIEAAeQQydy/xMk+4oquP/WvL/Y8rd4FzrcXwDp+MJ3UnAEFtEAQYAVMqEnCNTxTM6T0c5y/ZOXTHuUBmstdHPlPC1+QDLiYyule3BAZCOlVJIkSqk8dW61WiGEwcHBdru9tbXV09MTRZHV5p7pcb1eR8TR0dEoitbW1hqNRhRFmK+5FZI2lAGLGK1JdTJLAVGABcYeb6ex2Lp2d+v2IobAlgKIETABMoVOYexQMQXdeX5zCbR8iQYguejsXppGnUHvHqIh3TFib7zoHvNeWol5mTzfHgDkSakIBGRELjgQhFoEmqHgQAmkCtoGCg6KHhIFqX7w2nfZyffSRwIQkP2dlnuqPQ+M4yigfa6rAoy55QHuyS3mpk6UKx+jeNo3e92Dcu5LVwHg/hLWfbu6lyUjo2ZN8nENuvu2JyACPkMWBCVgGRyBI9aCTgL0xAPquXGvwKmonWBELIRKK4btuyvo4OSp01yKVxeXk8wdOHVi9NiR+Z31oYGR9tFj8x9eL5q4GBR4jFCFzJdM6djM0cFDh2pLK9fe+2Di3Clh1kC+lSRZVhoZFaVd4lBsIS7VfRKElajcrEsEmAUFtFbWWKKPf2z+cUWnXpML/WLuqHVfP9mjhqnksX/HHr2dfEj5Ie/yzlfO9Ila6/8NhxBhbJUo2G3UrZ84fihutlrblZYCPTIwfvZk2qyTNtNnT95++YJrJnG51yMFRbpQUIoGh0ef/uJY/+jIy3/8n3dqtTOlQiYhZYcCUU8PE7XTdlGpGCPyTlAyYNTo0tbNN9/Fze3oXs1UhDs+CfftHkqAe37luO8nwF7VFRhE0DPyfRM6fhxuhTki1sES9meN+7YKAYNTXHRQCNBW0DIQCIoZlDwGBS0DbQ0FD7GDjNip+9LffKDfh0l0IRbooNn3RnHKc/97uyEAge7blXvno9ubAbkJCO37DADAvXf3vlgAPHGOfHTE8Dp7AZz71VNH7DfyOvL61/DGRFCzhywDBiLNEET1TYwNDfaNUaHt2jncFxSJVjayWZC8GL3Xq/DoLNfvjaNd5QfIh9wu6iAApOjEuTO8vvn2//xfi2mggf6z/+GfHz9yrN1qlkcH+w5Nzcwempw9UNvdKU2M2BMH+gd6nnzqqXo9qSbV925dbSXJieOnqVIrC6apw1pS19FH77zbPzBwOITtpUU4eJBAYqTHHz83WCz9+ff+5NS5cweOH/fthMSpYpyubrek1X9owrcbY4en17NWYKesAqO8Vi3lUwyolDKWlGZGRo0a2bU8UUoqJTCyz85x38975+H+X/Ch1/8O73YlJAFyKJAEiDt2TgSETDlmBfmLRHuSZHvFw7/BFf11sTcl7TErcsfinPOAiO12GxGHhoY2NjZ2dnbKPeXhoeHl5eV2u91pJyKiXGXNGFOtVtM0LRRiY0zwoaMVks95gL7LyN6bAE0aSg033IaNG0v1Kzc1M2hgEECCAJmGTKE4Mgy5u0knAc6Lkx1/oHuZZ67SgxL2Rs97Z53vX8V2pDpz3yDYG/EQKHcOzQdBRhYMGYsABAMgkAUghkyBV5AFoACpAof3BGXz2O/zC/d97b03Hm6K7LwpEEBIBLtcj/y65+B+7nOUwx9CXYmvT4BA9rYs3TP1q0IolQhBP4T5Prg1RGYlAqAZOKAn8ASJ9wmzGu61p870Z9jKUAcUZgZRCmOgkPna3ZUnnzj/0fVryVptdmjYDEUbt2+panXj7tLw9HTfxNDm9maPF0WELu0txm5u7tXv/+XY5NRzL352dmq6QNqyTA8NPX76dOPy5Wx98TOffeHCnWW3uEEICiFl7jxS+3c471v41cf+jyS0UvmK1nvvg48RrbUPW6k9OunaJ6mbPTp7+GD6e29w6r5Kj1Sy/g8T4l1acNkgqI/m78ycPDHUyK7duDF2/ODTTz9ZKsXt2/OuUR9/4szMkdnrKyuUZhQCsCMTsUuvvfPWwtLC1//ojw4cnU2uX/fNWsmaJ88/M0LR/H/9i6MHDrZOn165+H4/2UggJapx1gTXTlor16+XV7dL3MnvpNM7/uD5z6teTLlacWcWyOWA9s+yCIKQIrr7DqzD99s3HggSWATbkdd+YJ7YG8UFGT2r1LFQAKcgKGAC5yT1EBCchqDABYAAQYHfl9Tt3yJ2vlxyRZ38BQbgDq7TfWS6/GbYw8we2tTe/u1NNA+Pcvhxf9KtgwoBhNz4uiuyvJcEA2DKxrP5dfOGFFli50hYtBKkFnM44QbPlXsd+iyQKNDKa+UI0Yc8hcm7iz62nP3bCumsfjBPf7unUjgwEwPkfXvaRhQBLr31dmN+zvuQLMHkLw4eGu27evH9z3zmc3/4L/4g1fG1ty4s3L71uX/2+7/zR7+nSeZv3Xn/pddKhejFZ57mJMnQ3p2bd4XYRGbtzsKRb3z9O88/D8Viu9Hsa7XD/F1br08ChPmFQlz8vWeew5Hh6sLdnkY9WVk99fTTzY03b7zzzjOfedY8+WQjhBu/uBD1lRsDCQfnQxYRJopBgoBHEKNIIC8NKAElqAKRExYGEqRuOrU/Pimp/Rslyh/77t6/9nLfnMWkBFBAA2ogL6gFtJBCytlK0rWr6Dpo/CbjAeSIiJI0KalioVAAgDRNlVK9vb0iUq/Xe3t7hwaHGo1Go9UUEJ3vWc41jqJoc3NTKXX48OFSqSfLUkK1r+hJiOScN0B5po2AwoKACtGSMiH0oukxSig4lxgRzZAgJChWxAJCvkbtnshOS+a+84uSq9Jix19e9oDdzv18b2gUyEv8+aMuCIIkHTiZOiu/TvlMBFETAECMgACGgAg9gkfQBBYhQwjYgWMfjvvGI0TpEiLwoZvj3iexK+sOgEIghEJ5xivIAgDE3QIeglAXFX7o0nb3gAEDPjiu3/uq7u+MmCpguodH34eu7H+FmUQYwADEgl7QCaE2EYBD0kgMkAGXIuspa/nMmkK6tt7SZv3W3Fj/YP3OHatouNSLkr158Z1bN25u9g+/+MUvjEyPVDaX2yvLTByLa9W3mmulfudr83N3h4dnh4ayVrs5Nzca22KWXH7/3e2s+bmvfvXYsUOXV9aazYqJjCF2ynvFDJz3vQojM/sQ/tuoX7N0KYSUt2LAniLzfmz1t72b9+JhZPoB9Hd/GfS3tpf3B+5VSyTnUv43UTj4G4WECKBfYbaxtjV/e2xqnHdazYWF0sRwYWjg9iuv3nn17YQ8+PTQ8NB2ZNVupTQ61ktQTxpU2e5rtxo3bl7/xevHzpxqrMa6sjNdKE1NHVx49/LVi++f//yLJ48d93PzZrsWC0qkmUQiZYvWGrTWm3Av/YWPu6W5O27vB0EQZN9olpfMWIvoB6HcPfhp74VcRyKvysr9H9+X/iIyMgBoAA0QAxQBWMAAaIWCECN4AY2gcujqk/GGvVwBuxkwYwcx4RzVzs20u1XETnL6cXXqB2adbm794Ov3Xdu8C6Zz0gCB985uFzfPTXbIIbAJ8ivHExSJMi6ARAgeRRBT9kZYBWaXCbNSBom6qLoQ6bwzSURyEvYjMl4h5Ho6ck/0FxERtdFKcV5nEwDjw/xf/NVGo4kRi0XL8NH3v1cY6K80q2/enjs8PVtf215ZvEuE7/4//5eJ2QO1kK0uLvZWmnP/+b8mh2Y00ubd5d7taqtZ9SK8W7m+ujZyYMw7t7S0DLX6xtZOu9Ucayd3f/ITd+VK3+DAysZ6rd00SdKqtdau341XVxYvXWrMTJXLfbX5xWRj15fLd+KIGs2yiHKYihdJQmihOEMWmNE5zawZiDGngHZ6En8tIvb3E13Gj3Ru8txlHYRAqGOULQpyJ4J7vsQ5Lvsb3pOP2SBqbUQkyzIAyM0vtre3e3p6+vv7NzY30jQtl0qFuKChk9pivV5vNBpxHPf394uI906RQiQRJCQggQAiQooA93sogihwSjxygCDCuZObFtYgWjoaZ/kSYG963P/M4z3SQqe4xB2iAXTSTJCuw9y+rxVQgvfSX8kFOjpW87mopBJgEUbs6oAJB0SBDAAAGIQFWMALMKCAKO5yVfKzSntDVv5Lnq13xz2+hxbT/lpcJ6cXR4FzEylGElD5iJabpyMwAxMICgFo6WyhK0+2By7cu7kDoAPsTAn3I9L7HwABUZLtLQzg49LfPAIiE3ZU/TAvDZMAMUoG3mlIlDQolFQAcQIpMFXnbjXXV5v11vUf19JWWyNdnZ8XhKy6M+JctL37wauvNCDrA1l7+z0wMBFFlYW5xbXNoSTbbrVW33qn2FtqtVtbShmlPpi7nVR2xacf/uAHcRyBcsaSxdBwbY+FYPZSKwDoWrw+dJv/YwxmyQUftNZKKUAMfF+K8Kilv3k8nPvi/bS/3+o+P4T+EmG3iox/DeL4g1Sif/yhhCPhysrCBxeazTS59tMfYy3Lms07b3pBaC5tjGWh5lrLL73cUyhYyZKFubtba9CqAqvLP/o+LmxN2mjzygduZ6Ver17bWaM23729srNbpdTf/sVbB0aGo9STBCEd2FMAJSHlzKFDTg2HfCTr6GUhPrAA2eO13ssjZW/cv7fszzcQ8GOefb43qgkCCjFB2t1Mh5b2wDgJnUkGASkoycdhIfAEIZ/RUQTQI0gu58XdvFGgk8/et1FEAcUEogSAO6S9e2VD7iDBeWbQ+W7YX+jM/yld9tregN/N4u8hmPdhK/lf7Z0kgY6qe8fGFgW7hArUGASzX5NyCASUNKKgVRK81ipDSFVwir0SUYCIwgwiSilrTJB7YmePgOjhfbE3GnWHUVSqqwkg3fA+Wd/sVRAJEWNB6UazUW81ipGq3b199e6c9RgDgVG8UlteXWlCKFpTyDht1u9urihA5aVX6er6rorsEEu6vnh7ezEwKxQTKKtsRCAFjUmrtnartqlVM3OiSRFkjVZlaaPATuts5WoNAvcE6qdie7uSCZdAYkQHLOIRnaKgFQsHEImELYthsUFM3goKOSb8t4uPXdj9tV5kAI8CgF4gTwS5+zBKtxVPOvdvByfci4eLnH/H2J/77n1LLrKWcx6stYiYpmkcx9banZ2dWq02NTnlsizLMr23iRBCHMcjIyNJkszNzeWpsPfBO1aWUCN6CczW2HwRlS/+EJGRPULQiEaz4sAd2rmE3NwCAVFIQBi6tNwHA/d+ACMy5GlzB9cUBM4Z1gQeOHR8XSAitAgeJBf3JCDJF3+MJADcrQGR8kCIoIS1IIt4BBYGJAT0KI6AETViCYAJnQTNoFEJgXRPbyDJECyQZgggnK/4BRUpACFmJaJFQMCjyggSDI7ycQ8jUjYQMAYkTwJCFkWJOAwNzUhkPVJgRMxldXTuzYgQGDplBSKHGIBy/FyhaCACZt7zOGXsUJJZg8P8obgfXL/vpgHwgF4ozxBYSUBgDAjcaSW0iq1KURo+i3WICrbNGaXsk7QAWF9eLCprgNpbqSiIhHuNVQD1rc0E0gmyvrIbkEslmyZpVm3HYIYVJbVq2qghh4TZWUPCJnVDkU23tyvgymSZgmdGLV48IHRdgRkBtDbWGCLqzEPddnLOqwDCBNTp+cQOKx0R8xYIFMB8BYrCIkj5vSiInbUVdFdO+ZKagJAZQEBRkFzRGiSv1YKgoAbKZ1nijkSikOTtOIgogAEYALRgvrJ84OSrTlNq8N5xYELMD+0fUfq79wp0F8/wW54CH0p/4b797LzIOeOIA4pCAc4vmQQQzJf0gj7X08pvCOn6keWzKnfKNJ27SBgRmYWoUwTrfAwRpONQiIi8l5uwgCJGQe4UmgRBUEgwgAgJCaNIIAid9SgLdrxJAzKDoACxEHO+vsVOkiSdUjgAAwVBEhJhZIgRnMt2VpY8yNb6Ro8tBu+2mlXJfNFjUdnYmMrS8qYmQmjvblXW02JfORDPf3RpMkQFgcrO5mZzN0lTS7roTZqB01SKLNbrKxubJaNQUYIhESAgy8LBiXgtrKQjIZojP/kccN8V62R89yaEPbrT3m2UgxGeKIDKR9yA5BEzYWYhwbzjXFAExZBY8JoBAR0KdNm3Ihw65mWgAIEBRDmggCICChEZPIkDFiQDpAM4AgYuAChED6wEOj3KIEKoEEkgoDAIMhggEoUIQTgoyrN+ZGGQTHJ3UzJedOfSCyKlyIioBXPangNWgJrBAzMCCSkGjQSImQRHoAC0EAJkwl4Dslgmm/sYdoqRtHdWuwuJTlmcIBDLxxQW7w+P4g15I63EFbQNQF4jGxRNTMQCzAEZchF6zlyWZcxsjCGiXALib/vk/oYDu7MedgjnyCIcmHLzpO5CxgAoB0O5NIBnBEADmfcMSMwaEThImsVIIlIw2qUuYigq3WCPCJFGCK4MkGWZAiHCfKawGpHYuYBEGYtWwChtx1aBBzaMyB45U6TES0wSoVgGkdQgGlIYEhbxAACiFBhrkZSEYBBiUihIjIZBCysQ7rBB8wef96DAztxPiAxKGLv1hwDkAQFAAyoQBBGQ0G1cA0EAAuQcR8xXg4iAQDmtXQFyh1zTWZ0BAO/1p3ZbU6ULRQbCACIspNTfH/d3D4KRrgo1ESmiEAIixnHMzM45rXVvb++tW7faSXtsdKxQKKyur3VMjwGAiPr7+3M14Dzx7e3tBYAQglIKFbI4EYiM8cYwe8gxFUUiAkEsKsWdGpYXTypPRIVyWkK+HgV8QKZj/zC3FyQAEBACSY7fYEBkTSlIplVpeKg0NECkNJGqVLlWRXbtZtN6NCA+hECktAqpIxZA8gqc1WyiEJxNQq9gErIQq56h/rSR+EbGxsQHJtqIteW12LsQEY0MlZo+7NZb4hgRQohABaOSEqm22GaWYCaxHeof3qk02syaUPlQcr4gwCyBdKOgZWK4d2AwErW7udVa3eov9Cobr4amnhoKzQQWt4c8NgALJ6ZrvukbyXDvQLm/ry2+XatXF1e886an2Ds+WtS2srTWbDVVqdw/MFaOS42NrWRrG0WMUuzaSlEnyZdOdSqnOHXHgC7mcf/ohwKRUCyUqRzI7vLSXDCoOBPyCKlYVqB1EzIlAkhWG59kuf+cYY6sQSbPIVIm+BAotYh9iJlreyXaGOe90koUtoNTZAwHRB20cp4RxGidOY/MBaUpzxmVaiMEUNYpkwkBEql9wDt8TC2SwCkJ3ulARlkBZMCAEAIrpSW4iJR4H1kt4l1wAcREseeQcUBSROCSTCtlSBtECewDF01knAiKV5yyi5S2AClzguwNkZcBKXgAx6EMWnl2BEGrzDnrJY6ijLjlPQAU0Ipj/xDvDonyRJ1FtNHGWg33qI37gdW/6Vjw9xd7bhcAkKvPfOwo9tvqgBEgFCERISECBMLQ2T1SpJXutL6JUHfV5EmQRQkEFI+CWiODCFYlgCFipwAFuBjFnPncNJaFGVFEgrAi8kFEWIQNGkQiVMEHhURIDMghgBJFAIKBEUE574gUE2gEcZlGAJUn6uKCE6ONCGdZYiJmUaAJERAMQ0DINEgQBWxYNHcFEQBym9I8Fw4CAErACEZOAkGwJC5LegrGhpB6XygAMrOI0qCAE0gRICYKgAHYA6MhEo5argc1SlAAQ6x9wrGQIoXilCKVl8eBxYRAIAgJixRjQfHeFUVKANgt+OVHlz+3v+J2zt/5BGqsIILymaWo5dkZlRSLdmykNDxigbidJFtbRNLMmmmrVkxDOeWIjAcP2qCIDpD5DEs2EGhCyjyGwOjbSqQYlYolriRSS6Cn0HN8drda4fWGSQINlqLhPrOyDkk7VRIHMI5VrINRqZLIgxLMfKYLUX9PX1qp+0YrMjaI80iBuUDGALZDKB2clsHeiPTu9fmmc+WRfqi2AkA0M9KoVJvruwpJSlE0New3a2W0ODrIkaI0tJbXm9s1Y40vlcpHZrDWai2shySVgd7i4UlpZby4LkmDIHRvg/tOWWf0vwd/qF9b0UBgZMSMi2C1E8toAmqhjl0E5FsBixRCICJrbV5Zzp1sH530F7DLPBEFXgCAmQEhLhRtFCGiB+YgCoAEWt1MLgAoB7YLBdJekTdPmDOvRAKgBK9FBPKScs5shAAAIjqXrgqCAlpAmAkAGBAhEkCGHGgkCAiSMscAnOY4SgAJCnKghh1AAFCISixAqRm0GFMKwQikyjowwGIJQMAJCpAGLCidSkYIDJBJyABTQNIWA/cKFDnEIilAm0yCGJgiwQJkBUAAaQOnwE6QAS0akqAgaMCM0GnNWWZROxLFXFLG+SRSuoCEIXMCRmsMqASAmFBMYAuKAYRZkBiskFXaaKUyRMjt94z5jVNlOiAsc47xi4gPPsY4iqLc0cIYE8dxrVYTkanJKefc0tJS8L5QKGjIIQrmLMtqtVqz2ezt7Z2cnLTWNFutOIoV6SS0WNjaiFC1vdMKjc6hOEGFJKQEiaFLT8iNfqSLgXdvybzS/+seROlQSvY8gZARBSkAZ4SfeuH58cef2FlbF5F08W5teXFwbPzSa683Go1a8JGy7LwhyoDJKNLkQsDIHDpzemNlpbWwHBgY0faWTj391NV3L9V31vsnpx77F/88I3jlf/3j6sJyaXTgmX/3r+DS7Xe+9/0dYRVFGomEemcODJ+YvvbzNwQgJSn1FUcPzmTrW0urqyIhEh8pBCFm1w5ZcWrq5Le+wgF0IqcLhYt/9dN+Khw8dqy2eO2Jf/Yt33bv/l/+t8Z6ozA58dn/8b+//OG7yfzy8+efr9UbTkmpr3z1jbduvH/p1JNPzBw5DIC1ze033/jlsSfPT88ecqlHxusvvbx76zZpslqJ+G4hMXRLiPirmV55UCASIuRcjiefTzUpHxg8Q8YcWNlYG9s7MlytVEKS1FppSUc6sEZi8YnzaRBRFJRiUsF5EFTKQhyZQpymaeYcsCgkUqAQhRQICAOpyGUuCPf3DWZp6pw3oBnEC4qyPvXDtqy4A4eCoHT4Ag/VeRAxsJWgtE2CDwhek1d6bOZA1NOjUNXWN5prm5rIhwAIKKpYjJtp4lFMXMiC19aOjk40dnZds61yYXnQiRMpFTPw9Xaj10TaCwkm4N1wT8/kWG1po77a0OWe4uho1HBZtd4En0U0ODVpqkl9e7etuWd2MnNZslEvWHPvIdi7wznPWIhIEZIwe+f3UyQfQfR3Pyz9AES9l6k/QuhvB2LoAOqk6IHWN+5A/aBYmEAZk6QOhNja8vhYeXpEB9de26ysr7MHFUgHUAhImhmyELS1LZfaYinq65FWu1GrxzYWhoxDIbKpy7QiUuBDppRSRBkTlXvHpsZXFhezRrNcLg5OjNW2tiDNlEgbeWh2qtVsZpWaaN03Nuocu9VdjQAoliXHXnLwtFMMz323kBSSBtKMGTOH4EE4Mg2Q4QNToV6tbW0UlRVPmiEuFNqt1FobArssU8Ym3mtS2mjHHJQuD/bsVqtOEJg0maAERXzmyWoIEhRqG7nAiOCZSSFp20oyRPKknReJjEKtEh8zoRB3lt55bva3XckhIIhCYfGINjLRdpqYyfHnf+/3ovHxrNaEzC++9dbEYM9mY/fCaz/Py36ZF1MoJyRt5yhwMS43fDY4NTY1Pb3wwUfYaJLG1Lup2aNHj564/PKFdiUZPDD92L//NzffeffD7/6YmEcOHjr9e9+a+y/fnXvnnay/wIBklEMcPDhD/T13Ll6CdhYIhss948eOrN6802y1miHB2HgJMWkJnAYYPXXswNe/lhKXUSWPnf/Zj/5q9NmnizuNtZWVZ//Dv5679OE7/5/vaaTBgwc+++/++Yff+8Fgz8ixL79Y293QbZfsVn/x8583KrVnvviFoeOH00br9pvvbS7cPfeFF6PpUY26dfXW7Z/9lBtV+nXMz33iE7/6TENuY4tAWnKIsVvkghy6x/w/VEoDaa1zJVd4xKpVhCC5p2aXRaiU0lrnqmcoQkAATAIImO07Myiwp621H2bJi4oKUPIWw7zo0qld3JOH2p/a7McA8s12H4AO0sqQZ8P7v0j29J4EgARDyj4osgUH7LNUiMBY0ObeeGtsNDrawtDa2C6xYpQaSWl6um9kqIoYGJq12tKdxdlAICB9vaFU3G23eyfHdbFcQOXW1naXluLB3sHpyURpEBUJWZfJzvb62jqPDhYmRqwDRTpYAmYQLGxuttc2HQcgBIGUxSidATgkgKAgX24ACITAyKCUMcagSAghXzVprXMzl99UPDz15ILouW8cIhpjctNj7/3g4GCSJDs7O3E37qmpNZvNZrM5MDBQLper1Wqz2TJGG2O8S4XZ2kiLTtqZGFRKa6MRILAQMnYZS9StZnVWTt3L2rktED3Ar30S76kedtVtAwqTGGvbKKVyubGy8qM//zP2gV1y6viJsdGpllDvkUMzp06IqIV33q/vVmfPnu07PNvO0tUPLveNDD/+7d/58OVX7yxvN53LIj0+Pa1KffW280rXUXBocHRouDg+cWd+8fyxExNPPjW/uFMvlY6e/1TfzHRzc3v53Uu9p0+NvfjM6trOYAb9U6PSqm9X23WG45/69J3bN7DdGhoabiws59PAxIkz0cTMX/2n/1d1ffsLX/5qaXgUMI6mptPtBTMxMVjsKR46tLb90eMnj8czB+L1RbXVpu3WlZ++vNNuHP30M2c/+/mslpV84epP34Jy9OSLn5kYXewvDnz40eW5Wze//m/+/diZU43FuyDB+Uzr3EEPeK/68LFuhg9FThbxBExA9yQsRBDAajCYEbeIDx479sQXn3/ntVdvvvtBb7E3zViU+CAOmBl1uU801V3qgreFkgAzy1PPfko4vP3mBUXGWAPMnHkMTKAJUSlljWXMSoXCkWefW7hxY31xkZQOHEJgDgIUZ6wSF3xgERZRCKiU0h+HMZgAOvG2oIlsC6ke/PiZ48df+Mx2tYJBjnz2+Ys/fWXzo+voXKQptoV6K2sHsMVi20OjnRwcnzn/h3/49l/85cqVq5lArItG6UbI5iFLNPf0l3tSQ402E7X6Sge+9OKxJx679KPXlpd+MTY+fPzbX9144+L6+x/tGClNDZ349rcWX3qzur1J/T2zX3phc2tz8ce/5BDUvcLkQ5cgT+9F8sz+gaN7dGaUvfgk8sNvdac+LvZwRMSPHXEQgDra2xgAU+9BKQ4ydeTw0a99sdpulIBKhdI7f/XDzWu3DAMysoAHXyiVg0uSjJ3ScbHn2S9+8Z3XfrGzvVPU1nmntPIKQgDlXRwZ74VTj1oSNEeeffzM55+XH//82ku/iAd6Dn3zy/MX3t5496OIBWcHz/zOt5Zef/Py8ttRuXTq2edcK/tw/WXvnSVFIlok6/aKBZRA4hSCQlCkkaygZRSB3nJZtNps1/smB8/+3jebq2sf/tWPs5arN5o6spaNE5agnXOZR12IE58hoHhphnDo+MljTz/9k+/+iUvTgi2miS8YA5lvu1RrKzb2iC6w0vbp55+v7+xc/ehD8K6oYwUkSK3MtYOHYBELinXeHbJ36v8u94d0BM+x5TJTKhRMKRgtht756Y837iyoxCXV6tE//KeJFVUojh8+OjYwklZbtz+8AqVS38zk2MCQSrLr16/2n3v87De+srH7P1cv37RedLE8OnUwLvXXmpknHUrl4tj44XOP3/jlB1W3dfTY0dKB6Wyg305PjR6d6SmUpNKYW5g/96nnaWxwaafSp6LRkbGd6s6dag3jwuiJE1fW7kalwmihnK5up0lKveXj3/zmOvsL3/uLYt/A4SeeNOOj0eiY4sgmWWlyelJQ//CVdq1x8vkXisdPZfHPcfrA3K3bH7zys2KAc1//8qHf+eKVH72MRr/xp385+tip6RfPV96QtGDf+OlPi8XSV77xjbVrl+tXKvQbaoiQfRP3w2/tIzujUio3E/6NfO/ff3QUKkB8jmJ3aFG/ctT6W5zTX/0nn/TuJ/4VggDkKDsHl//eqesjsQABktHTX/tcOtxz6X//L7BVAxQcGzj5L35vZGwsY0jEt7L04g9/tvz6uyVSh194SvWWS9tbZ7/wOSoXLSiq1t/7wQ88+CNf+FzvgWld6ss2dqONraU33rlT2Z159rHhs8eHdY/t64nGh1q7u9xI116+cHHrFQ+kWUVeyrbQSByicgpFIAlhQKEFggAKUTGL8yKCXeGz/a5Jf/MT/ImRm8kBQMfVDzF3k8npELkySS6CtrGxsb29bSM7ODi4s7PTbndd3xBRa10oFHp6eprN5u7urnOuVCq7zGVZqiKtlXJtzxyMKSBRYM7B/47nHdwT5e1sUO6lwnuDoOCv6mbNQ7Bbtun+JRM45tRlEhkgjAb7jx09ogTvzN9JWQLy8Inj5557uupS1vbo6PjN9y+NnTld4zBy6GjP2IGVudtNZkHFaFItLc16cHBrp9JuZxSV2qSaWxsm8MjMzI3bt8yB6ZWFuxLHw4+dGXz8zErSOPnZ53v6hlJDzkYwMXbgzJP9GlbevXhg7GB7bmHgwOzzx466Ri1qtdcXV1WhVE3auLI5lMpnvv7tyt2lu3cX127OnT95LlXord3e2QkujD52an1lY/DssZt3blSbSRSo3kqXN3d26tXw0fXpxx4vlQY++MUvR4YnDn/uM1uRqWzVVm78ZEGaM2dO9pWi5e3NAGyM9sFBV28yp9p1ijm/LhDAK0Dp6Lp3y2cSmIEUGu1JMo2+YA6fPUtRaXDigCvcrmt94vHj0xOTm6tr83fmJiYnJqamKtXq1SuXx8bHD544Xq1Wrl+/YaYPeJeWjxw5euiI0fbW9evVnd1nzj/tnK9sbw1NjgeFW5tb7EPvZ59j8KZoT58945y7devWbr361FNPFft6m0qyax/mZK0cwFO53+b+gxNQWpOYNHFeKWZBrcYOHZNSz2s//GEzSZ79zGfrfaW1ovr0F78yMTK5O79w+frVkanxgyeOB4C5uduVdrsxNLTTUyqePvXY2ceUiSo3F24v3Bk7Mz1+8pBbXt/5qwtFtokmGerrP32yXi4Pnzy1+Mb1HYBsdDgzkWNwVjcUheEhLJZQR4E0jQxJcB4IhR9sVIQOo0pyMTdArbW1dk/994Hk8tGJX7E/j8A+P8T93bcjnbe63Li9mT4n1pOAiDgJjDh5/DCOjVz43/8Km+2zzzwv/X3pUN/0kaNjExO1SuXqBx8WRodPHTkCWq0uL29VKm6wv9pTiI8fPn76dBzHW+sb1z66MnVo8tDEuKvX569fd602KITe3p5jM0vaD5w+qt+/vKMgzE4mlwsJETFXRKKDs4XLN8VEmbGFgUGl206ooC1CAAbs8NIhlzbwKA5ZoQAAMZggmllIeefb7KQcTR0/7gaLpaFj8NGVxdsLBx9/7OChQz7L7i7cFeFjB2cpim7cuJ426sdOnrBxfP3WzXb/QDo2lg0NTo1NjA0Pb6+sry0szp49Mjg6srG0HPUU4p5yM8uW1jdGvvzl3tXVO83mWP/g1NDI1vLa8uLyiWPHyqMjpcEBQe0YteB9XIe/Q/4rAJl3NoqD+Hq7yXEMEBTB5Piobqdcby7WKs67wDx76sQzz316e2l95sxIGBvbblSOPnGutrU7PToO42OtovY25mI505FyvtwzUBqemLs132hkysZZFDeXVgza/gMzrVQGjx/eWLy77bPDz3+qNDFSazQPfeaIu/C29A9WtB08c+rp515oL6zA8qIqFVZv3Z55+ulCZaMY2XSzcmX1dTRx5mVpfnHw3JnD55/ZWlv/8OL71VbrpFIt71ve1+bnyYWR2dmlhcX+wcHq3IIjzXG8unb39u2FnkZWKJWe/M43FlO88qc/Kg+PTE9MbrWa67fn0xuLtY2t8efPG0TOUbTf1NpT4OEmKrmPod19USAX0d1Ts3p0lB+gQ00V7EiK5AVCZmZltdJKEDhXo33EQ8AYo5Ry3pOiyEaY1z8FcoHrjhrA2KidHO7BuBSaVZasXJAD08tX7t75xdt1Bae/8sLn/sm3Xru94iv1nrHRWtI+8diTcQt+8d0/56T9zOc+c+jI8avvvPXa938ye+zEY1/60vtvX3SXLrvV9UKhMDEycefD6zfmN0rT4+f/4Nu3b9xeeOUtvV7lQP0T40Njw+1ao764Af09Ui6klaoGH02P+J0K7jaYFFoTEWlmEMaO27TCrg3bb/ZuydcFe6Bv/i3YVZnw3mutS6WSMWZre8saOzgwmCRJrVZL0m76m2fHAwMDu7u7SZIMDQ319vY650IIxlg0kvnUBCgWiwkBM4cQEIAIlVIh8P40d6/cgnsGb3tvfdIC877rjh0a9T4YGUmYA4kilr6+geOHDmXNZGdtHQJ4wr5jh9O48Fd/9mfFgf5/+q//9UJ1+06lUiKjRq09eHj5ow/G79yprW35zBOg7u0tDA2t3ZxPWymAsoWYURbn5oZGRo49c56LxZ31LUyy5Xot2dlqYTja11ucmty4fbt+6861leWTTz3z5quvVW7Pfekr33CCP3v5lX/1f/4/pbXdl//X/82FUEZr4/L2/Mrb3//xiccfP3Lk2JEjRy+X+trVVkBhxDR1tzbu9BWLB0+frPlsaWW1qJQYi4UiRJGkUYrQYu8EnYNMwCGYcrE8NLw8vzjz5NEvfvkLq5c+WL11SymVJandZ4XRXTbkecCvY5h00+W89U3t6asDgkgWXMulwdDgkVmcHHvr7bcmjh4dPHHEII2ePTl3dzEe7p8cfHx4bPT23HzfYO/Rz3xq4uTxlcXF3uNHDw71VzRE5b7HvvylpNlKM3fqsy9sbG6NnT9/9cKbODayrELfxMjMuRPXP/xo2zX9cGlq9vxyvWlK5tCLn+qp7vacOXPn8pWeQpFUp2NFRHLf427FqRsInoUVojbCoFEbLyuXrvUdOPTV3/+jna3Vq3duzS/PP/3NL40ePbl0e3HyzImhiMpDAxsKSn19xw59/urVq85Q2lsenz1Q6SuKl6nPfGqrHJ3+3RczDFfurIqyPpIqudGTJ8HGb71z8fyJJ8tHDu4mtYDKMQQBAA2iBA2h0WSbiXctl7UyCWDQMPgHz35el4ecspozovT+EeGRKiY+HA9jwI8A+eHh2ONmAORdQHsNCHvjEgMFYfCFUjH4kIUwd3f+2Okj57/5te1b80sbq7cW5o4/9fjk44+vLywMPX56shwPDQxAHPnAJx87/cF77zZEkkJ89Nw5VYgbLjv+uRfasZk9eeJgb++VV19rBVeMTOLDxOGD0Fd+66NL56eP9hyema9uZi5tiGTFArlQSzKfpCmptjbMnCEmzBlzURvgQEIiuTEQMICQMObmwN3MJNcVB3DOeZG4r2fk4IGbd26MjY73nT66krQPffZTPsk4y/o1TU5Pp8Fn3g2dPjkz0McKqs3m6S9/YXN7s9auz5x/cnhwKEvSQwcPSn/f1PGTNrIrSbNnbDhBmT54qH57bif4RNH4E0+M9fVuLK1OPXGOhoamjx6DOG6mLW+N17pbvfvboGgPXkUAzntJtdJCrSwl7225dPz4sem+gfbWTlatoHNGqwMnTixWKy/94EdPPPvcoa9+4cqffk9tbMSgeKAvig5u3rqxfuXGzk4FbBSyUCyWi6We2k4tNnFDJCgtDMt3F3v6BsaOqZZIs153cXx5ZeVQTwmtUTMH4NrNpcWlpKATbYIxr73+hs/SZ776ud1r1965+tFX/s0/r9xdfOcX/znJfK+OQePrL700tb0xc+z4wWPH6869/srPMyIVxxlAtZW4RmNsarpU7m00Gs35lo0ibrUKNjbaRuB0KyvpYhHtznZlama2l6w3EAfcWF5+4olnHnvu0x+9/sbO0nLxN+cD9IkTRpdAzA+9+veB5P3dI0fO9qgP0CUeKKVz0dmPy/MfsUAQ7ijZucxRbJRS4IIAMHcktFlEmMGLCqoUbCy6AuKUcV7qd7c237rmo+gmmKF/8Z3eyQMtvWnLfRvvf9QXDfX2zhwZnlmev3PxBy9l7Uao17Nmq9Qkfvz5tVt3a5euRhBmnnp8AGx2ab5yZ5HagVd3d6/cXbl4Y7in//Dpc7PPPyMRobJr71/d3No88/UvXbnwRuSTo+dPL/74pcZuw1or7EKSWiKjDQDk5AcAyM3bfoMFwz0xj/z33C1ZmPMyRQhhLxWu1WpxFI+MjNTr9Wq1aowpFood17ecKlGr1ZIkKZVK/f39SinnnNFGETlOAdBarZQS9kqT0QY7dON94O7+3Xr4iZLOmuxXR/5gIQByh4CODIpQAYoPlGbV69df+6sfpe2k2aiffOJJMgoRfJq6VrsKwBBGZg70YZSsbrFjDxSEtVaQJsYFwdDb1xsVop2NjQISCGiNcWyWVpenx6fPPffM7du3esj0kXni3Dl7eOrGymLWbmrnY9KccgyaWq369pY4x2nKWVqwBtkHAh2ZDCFLk8gWZo8d37bqp9/9bhTb3/2jP5o8fmz7/Q9jY8j5mOHuwmJf3/jTn33hvYtvk+3Tfb1t8klI84aS8tgQlk1TuZmnHl+7Pfez73//M3/0e6Wp0elw+pmvf35tbv7qL96Uer0nBEu5t4l02gmpO+n8dZi/APkYAQAoQNwZNQypjAMKEJHSeuboYdVboLE+Oz00XjlUYGi2Wr987dX+nr4XPv+5ervx2nsXdDH+wte/2jM71ly9G8c6Gh3MsmxgbHhgZOTOtauBhEuRq8Lq2tIb77976NjRgaERr4AKtp62GvWKsaY4OPDyq68U4uhb3/4nphhtrSy//8HFM2dPU852kD3dwIetnsAJI4rWikSJkA7SWt+++vJr46eOD8xOPn3okH/91b4D09fuzr/105/12qKJo4NxFJfigVIx7uszpWIIIRPebNSxWCjbSA/10mCPKRQv/OiHd99+fzyEbc7S3njm/JN9wxMHS1tjE9OTT51df+9NTlIgCloLo2HSWUjSNAkewBpT1KwxgMvdzB/g/uYjF+TSIxSEfcjFqe8LeJQSStm3e3sv7pEfHln0Nyc/dGpOhLBPsLEjTglotEm8F5aoEN9dXFj+8Q8PnDs3cvbkARWpYunUiVOVzcovf/Ly6OhYoVzKUq/7y5Mz0/GB8eRqpEDHGG8sr49OjJcHB0uDI+ViWTv56J0Prr39vmomcVQwxh45c3pg6sDhrD18cLbvseP6/SYJGWMr6DVxVOxRaFKtd4PXTBIV0HpBzYIGlALm3D2Buo64mPduIyGhQlbIgqmEoiZtzeDA4PTsQVxcKNnowIkTrUZa7Ov98Ws/aO5UZqYOHDpy7JevvTx/9+7Js2dPP/v0/NLddr2meorG98T9vbND/Vk7Wbhxs39ywgz177TqNy5er7ebTxyaambtUC6qvr6N7c3q9tbIxPD8yvJrv3j5X/7+Pxs8OL2yu3Hj7kJ5bOjUaF9CodQd6H8T6S9qpZzzKlAcRUnw7H17a+vdN9/cmFvSSdqs1uhTzxgiMHZlaydtNFv1pjL6wIkjkyPjrdXNQMiR0UoVQHGSQeaBZXhsLKnXW9s7BgnEsXMosHZn/sDkgekjh27eulnuLZWKxZnJybGxse12HYziwApEMwhAZXW1urZRLBZIUCHurq1i0bR9u7azPUjKMqti6fD5x2+vr/78e3/aOzT0nX/9L889dlo5p0VKhdhnbm1hYapveHJ0dGllJR4fNszGKGw4CRnFeujwTNKqYV80/Oxjb17/qPIynf/dfyL95dmD50987YsX33v/+utvjGaOfhNneH90lPilU6rtvNi9Ennx1milGB5woX+ERqou+tsZQBGUIq00cwgh7xT8WNfARysEIEf3oyhighCyXCVeQJg7etmICD5wFhIygJYNAihJvSP0yljR2UYtYc2jQ0qjR1Vb3Li8+7r5RnnyD7465ZPKzZvXfviz9m7dmEIQTNup0VYVCi1IeGao2WqarXofUAHIMpQd9ZqSKxWmv/yi7y1fvvDGyPjU1Je+cOtPvre4sPT4t75qldt47+LGbiVBGAhsfdAgqAjvrw0+PIn8XU+USJ7g7pdOUloRkXMOu5ZSaZoCwMDAQJZl9Xo9iqKcTnmP/NBqtdI0HRsbi6Joe3u7Xq9baxWR9xkQxnFsHLrMoVXGGK2UiITASD6HDu9VFPI+N+m0jDJ29MNREPnXP6+5aCECULdNW0SsaCaVeCYgbifNtS2FOBwV4iRV1UY6Nz86Nfn1b3wt06q9tcmV6tDhE29dePuAUr0DvT2e42J0YGpS3VmqtatjA31preoqlX4A5z20WypL2uurVVDHn3r8g5deGmn5gYGxgf7B9Vpj6+YtO3Oo6EOl1po8cig7dKTofRxCO02LzBM9vU8++8zO1cttlzz+5LlLC4sFoVajVojsi1//2thQfzVt9SJvzt0qEnCjVvah3ExkcbXNUfnM47WllaEeU7JxHXlsZuK5r76YSeg/Nrtye2596e4Xv/CVQycPrTR2+4xZ2t38/D/9th0dXJ6fO3X6zC5fbS2tKUBkRgQN4BFyCZwcLvl1Kjedq8QCmItUd9fDSsQiJYha6b6B/unC8MLb71x870KyvXX67BPJzg56PnH00MjIiIJQKpVOHJ4dGBuJhNvbG7XNjfZOpZ22Z2ZnIWnt3F3YWl5u1xtJbx/4YNN0tLd87unzW1urze0dO3WgF8AqFQsU0uzY+EQcxarZziq7pZ5ywYcYMe9qV3nrt1KdtTvvG7kEFKIm47MgCJkwxoWzz39qsV796Q9+kEb6S3/w+6dPnjOVeqve0oR9owOHjx87fu7s3aW71UalOFBGi6C4Z7jvxKmTjVq9Ua34AjoK1E5pfbc3ySKklpHembGRsZHWwupYm93C3ZnHTi6szokEKdmmBifBJ1kIUBweaBso95Z7dKTaWUDxmrTwA3BDt2jYKQZJ6LTG78968RFTfnggHp3Z7hOj67oACPnMQd19lvsW5xJCQKW0VgHg1LlzS+D//HvfjaKe3//9Pzj15OMFG61srDW17Ia0PDR5+PlnmyFrNOqt4IOiAFju7Tty5hQQ1NotJxIEOEvXV5aRsL+/L92pjAxP9x89UtvcGWiEeqU+eur40tycSjjy0mRvrBkBUkmQ3rIUbKmvn6O4Uls1xioAzhzupe8AkCsNCVpGYlRIouj/x91/P0l2JGmCoBIze89J0IzknCCRALIKpAAUindXT/d2D9ne6ZkesrLsRO5fOpGT+21l5eR272ake3q6e6prCkWBAgcSiURyGhmch/P3zFT1fnjukYEELSyqOmtVUiI9PNyf23tuT01N9dPvKxkKgERUmnjAx4+fgpWtjfeudqcnT770zUPHDiVLe/fPTDcb+/fvx+D279vrMze1b7qXBmuttY3t9XyR+53eoX17Uymp3++ury/cvNnZ2Jw+lJft9pnTJ48cOfzuhXeKXt8Z1AAthIzJEx/ctzfUs7LTNUiDopvjRKKEHnGUecMRqPTTpvJD0+jjL0NAMiLTgA6iYFlO+CwrY7m+sTF7b399IkQJSL1+f2Fx4cRT5+2lb5557Fx5997BiQnTePfq5cP79gVHutWqPTl2+vDR2fvLY7Xs8Knjd5cXWsuLdcgaOddMsiS2ujZ16vHs2JH3f/nTfSdOJpHzj5+bu3d37vb1088+UwdLZTpw7PB4a4O7vUYZ901NhaKcGmu89O0X5n/1aubcS9984cbLrxTt7mQjPHP23JFnv3b1rbdCCL7fD9vtbE8mceBj6VJcuHzl4EvfnZocf/OVn790ZP+gKDzY2aeetO72dKN++tlnfv2rX271tr/3L/+77NyRDElaW4cO7PveX/55J1i84Z/55nPbb71j65tf7Z1ou37ucOo9eB4BK8Grh76jR9Ab7MIBjggBoogOmes+KTv3CJkBMakZEWVZKDQhoHNMohUbTEX9IoAWfMpd26JYoaV5IcehQCy9L4p4uFYfxxBFpvfNbKyt9mPRdO7v//f/o/7K/qNPnHruW9/63p//t6/8v/7X9upmM+SBqJTY1oiTWXZ0ZnN+q+hu18AFZgPVWKSUJCN37qTbM/VYezvPm21HGsLbv3jl0J9+t9lw7/8//p/91Y1G3aVSMmPvfYVKIu9DCBVHXoXT/Yon7Yj4rGKWqOTbAEBEsixzzlVAnYmJiaWlpbW1tfHx8ampqcWlpW6vO8xFq2qj0RgfH0fE9fV1VSVi730sShHJ8mCoIomdy7PMQJIkGNIhkVQbq6qhHYa5OsBKf6WKZ4et2PwFJh0aKAJWHI1D4hxQVQfs1JYuXkKiJpJnTv1uubTYR9y8eeMDk/3nzuSml//zjzpbbX567fjBfbC1sfzjW+W92fsX60fE1UE7/V6xvrbWWXNlkQt60K3NtXtvvj6YnV2eW6Z+v3ftVne9N+fmNvqd/c+ce37fwa13LqzPrrWW1yZrYazszb75VlpbzlJ54913CsXORPOtS+8SpnNHjkzmTvvdBsHKW28ypJljB/fsn7r1/nvX3353pj5+u9eW5cWlV1+32fnO/ZW7i2vpxs1o5Wbmep3OLXBczxFw6YOLt954t7e4ctP56afOTO0Zv//6653bN+c/PODmxifzZp1qA/IJIDDHFMlxhWKsCGYREKu2zM+fNcOqcIWAHKbdkwCTRYEktWa2urB08/W366vr7cGH21zbXFk+eOTQd154drvVun754mOPnf1nz7/Y2W5feftitrj50uFjgxivXLvWvX67Y7ecd187fQam0sLs3OrKSr8QXt/a+vDKnumxcXZb12+W8wu276BvtTaXVr7z2NneoLjz9tuxKMZm9kzElKs6Yqh86zBXOuJa37WHRMUM0AEO1Dj4rUF3S8qv/cH3Zp58rNftHgr16+9dbJT63He+NbFnes9YHRFJBt2NlVCveVYnhXa3Gh7GMl5cXUBVJvVSZpvbh4zioKyxjyyHjx3o3Lzx6//4N9srm/tPn/je//CvHzt2zHl/5vvfbB7ZL+3O3Q8vz1784MlvPY8T9anJyaZKb25+YNJDaH7S/Tq6bQHA2HGGiIRVh/IOnfajFv5W4C0cSat/4ib+Ucn+GhIRGVUM5MxcNUOMenCHyS1FMEQmSoYOud8f1EL+vZe+MX3kqPTizPTM7etXk8nxx06f//5Lh48dIefz6bGbr7/hkQ4fO94wTOUgq4eJ6Ymr1692et2jJ45l9RqhIUFE6Sd1GR8+eQLWN372H/+6u7ReP37gB//9X5w6eKTRGD/33e/XHzuDqVh+7Z2Vq9cPP372O//sn+6pNbNm4/69eyYCTFwRcX7UbRKAqzg/AQShQOuTJVIMjpFq0a6+/Ou7717g8VrmWHKeW1l84sxxJzp3d/bO5fePHdp74tj+67N3P3jzlZkjB/eMHY0rm+XK2iCfnVuYO3nixA8ee7y/1bq5tBYTTPT6uLKK65uHwGXbHZ1b0hCO75uZv3nvzN6ZJ777g9b6+q0PP5zevw8GnQZYnQxTaVCJXgDAaLZ/ymTWhybMx3Q3dZjlMkbzTJwUOp3Vd9/HVmeSPQ+KcXRLH17dToO5ubtTIT9xYG9/eeH6zz4sGtnp555+6vjR1tXrvU67c//ujT1TdYnNFDmn7Xs3t9eWawxBxUy7c/fvvPrq4M6dWQG9drm8fa9XpF63fWFr6+CJ46fHJ1ZffbV17RowN2us3dZS63az24Pl1fmLFxUGa4tz1195/cDhQ5N7pjA36idcWbn6v/9/p//wpSOnDhLRvbffvvv2u4fOnkmt7qC1vfVeJkuLixffk4mp7uy9uQsXthZXoNWu03OHDu6NJu+9/F/n33jXxO6+/dbM1x+DUt74xU+xXcxevVE2+fDB/Z7yNpF8ikzpl7AqqVCtAzrMpZiO9uWAaADEhERJRA0r2gccEVo9Is7KKs1rqlQ/CGgHnmGOPXHFfgiGlaTVP/ZwP9OqdoWYkqKF4BksSVJVJlZDrb4vTZgRjWf1TtPF2I/CYK4RpOkbM5MnX3yWpJRWa/zU8dv37mTTY8//sz89denm7fc+2Jh/ex1r577+BGXsyJoGGXvyDKAz09NTjbGltTuFRAdgligPkrGioGnc3FxdX339pz/dP7Vvet/B3vb2Ey88L+ubRQ/PvfDCzY2WdrpmJGiBqIJjuipvNUKKw1e9TOx01FVHrmajilahcEXPNzY2JiLb29tjY2MTExOtdqvT7RDRg+xvrVYjouXlZQA4fvz4+PhYlVUOvsI5GAAycyFCDFSl4yoBDARjAiZwXCkGiBo7U8Iq+wsIRhVF8+cXa3AkmgEjKglAFDNPaEi3rlwlgDpiABSzuL6+uL4OZXnv9dfvvP8usNNeDD5ce/nlvN4ougMYFJjxzV/+sqNuKtKkr63evddvuDpYxsTEm5ubN994E9sDotrtlZVa1PW1rR64vpZry7PqaNDqToLHMl1cngtjja3OlsdIAgs3riOHlfm5lHqK6dbqymS0uqGQddrb13/9ql4IpcVYlhlQp93pLM4j0f31VRYtE9yYna+ZbX14pfCoiB/euEuOBw5SirUIM8EvXL96/97NJjjfiwDpwo9/FNF54CnnZasVVNEBOTYEq0o8MJxtCJ/fXwhWeYYR8cowMEBiUk2Z9xn7+/OLC29f0+XVcbCwsT378i/VbPuDKxNjE+12O/V7d+4sbu6Z3tza6nQ73TtzW9MzMcnm6mpeyw2sjKXdnQez9eVVS3L/7nze7S384pWtfVORrbW5VQwGdze7ptJpdbZv3gaAxcVFQ1z1LtRz7BeVxnNVvxaRmOLHnawRRLRkkswYMSDeeu2N2OtNHD44qbD87vsr77znk9ZU9xzc071+6/qNa4eOHTs2s7e3vjJ7/V65ubFwfXZrYX7x7vKxqalur3f773/UWVz8cHG5PTtfS5FSmqz7NHv/zr1Z3N4eR23Nzl74+x8JcvvOwuSBfaDquoNap1j8xavU7zUnmv31tXd+/cb27TvTeQ1TBPkEqJmIiAohZiE45yQOHooPHrXwd4dRfHeZ6eNZ6n+s8Pdh3t8q8FUkZtohg0ypYgC1UQ+cVlqxTDFFEG34cOfd9zcHxYGTJ9Dx6lsX77/7rmqaWuk80ax3P7gzO3e/2L//QKNB7O7911/05ubv311stdtX11u1ZoNiefdXb2zevxtD0KX1ZmF1s0w5rqzPvvxLv7QxVWp3funKy7+oJbiz/crEvgPjgaIoxvjGz352aPv83n37uTe49JOfrN+fbWpCclixlvJIPGWoJgo8AmMqgBAkgATmnY+D4oMLH/LC+n7KYzvOvvyq5c6KNBgbS4Oi1+qoyGDfvoHGta0tcyQH9nnvtuaWA9Ctq7c7/X66cW+s1ii63bTdWb4z1/Cuvbp+bXEFQ1h87QIIz6XYnZ5c21jdrPk941Mb62v9fm95eS0V3cmzj9UGMSStIoxdWjJQxU8fDTkqcZodxc8dR/SgT2T0OvTOUzKIcSzLO1tbl958E5jqhnkSR3Tt3QuFNyS59vJPMnQoMEipn/F7y4s+GXYHgTA5vPKf56a7MhaoE3sX33ozOZwIgUoxtbi+dvXH/7WWcG1zuyOxzm6rdVUdzd+7u3LlcglCCLjVz/J87d6NRJAnnCil7HfnLmyUAZY/+CAYrHRbiylmamNMedLWysK9v/nr7RqT97XtqP1yqdvCpEB0Z3XJpbR56dK6SM3z7bfe0iIOZu8vXHxXAUyx6A0y53MOC794c+7CJRCw7W4G/r37/5+tDGqKU4X6oodMtuvq7fYXO3n3L/hXgEpf/oHLrdIpD7ZeI0FV73xUq4jPdlzBI+WsYLQT3umFYefYKRIhksGIk/URtsqRqhoiOiZU1SSANKz1AxCAqJbb2wdnnn7mX/5JttkbrKwurc5br3P0a2eyZj42vu/A1PT7L7+80d86O/NU79UFWFrv3Z978vsv7X/miUIGE43a3Ntv43YrY9zqbHQ210O7mCrkJI6Nrwxm51YcQmbGvY6sb9ig1zTzG52NH79y4KUXnnvhxbHxKVrc6NTrXzv/+KWf/CxDOffc+dZ77/c2u+RoyyIWcYiQQawgufDbWSB2T7+qLS2WMR/LK+yvmWVZZmbb29v1en3Pnj0rKyudbqdZb9TrjQfEZ51Op9VqZVk2Pj7uHKeUCJGcs0oZBIFo5IMBacTmhAhgqGhiJqZiJmZKZqoogApJMSKQGgriF6jKK1hVvFcFpwiAiiAIYmLOqZZg5AGliKRCAftSZnkwUevHBKULuUr0Yr6MHBUYhUiTqkhRppw5B2x3B6pYJq0ZT+S+6HRr6HwqoYCxUEtSOoIgqdzcCj7kBt5KU7F+aZKaqEaKAEE1D2691W7WnCD5FFEtltGMQ61RmhadtvOcEUGZyNAjkxmUqjEFx5Y0ONZByeBL03ppmBQDUvABUFRYNHMY+gPqxzBWW+0X6ABV+rFfJ3IhDFIyMLFqSUcyq5pgrAI0fLYNJTGrNlgAAwFERE8OiJPIoN+3UnpbrTGDDJDLpP0yJzfod9sr2428kRtaKpeXb1At1J3jMnVm5zXJGEKNnagOinLjxh0wzUNWy7KNleWx2pj1y60790uQsXqjAT6tbMSydACrm3cazUZD0QhSb9DIa3V2Q2qEoZbfyJ195CQgoRVWsmc2xhSn2A+6g/lfv3nHlIOXGMdqNRK584ufObbAIZPUWtlqI/b6AyJk77YMxojW5tc3nYsqbYsSqKOaRW0gsgqWunblWgHqfWZMEMuFdy4S+zLpXccOqZmgZhhU7v38V5aRF5PNToNDaNR6ZSTih29XImYanQGMGCAeJFOrB48OtdAOvmrYWDBqNfhEX/aPFAF/HPtLtItxDkfV0OqSK1XKOhBNi5RClsUicbL+RuvKK2/ceedCXohLNo7kAFd++aZDipIgxfVb85t56EvqFv2sVivVHPPs7Xu1ZrM36CMCI7ZTrBFNo+NUQlEu37w1IFeLlodASWbffLuGDgexHvIupIGmSV9TsCu/evWmJCewzdjMG7lzUg4I1YEoDvFMlSj5Dr/hQzYYDBhg0O5k3X4WrYmYtgfF+oABuosbpmlmcrrXG3RuzQrankYtFbF96QYijoUaAQxisadW78wtlgYZcZO8qTFHAtvavOvqOSZiI5W0vrrSrNcG2xvLC8vBhRpgp7ueZ567BfWKGnkAENh9sw6lGj/xi/vIbx8LTAygKGLOnpAsqSPKiIrBAJjqPlARA5kBlCKZI+l1M/VoSJkHkf7aljer+3xQDrBULKPHkETUA0TxyjGJR2IxEHAKufOp3xsPoSwHgZ0lQNQ46GaIFMWryaAXKJAk7MXc1Um07PW8+kGMtWatjIUT4VJ4iEUEKwY1zmxQur5k7CEKGJRFP898ZlB2OohY50avLByxFQMm8oNYF3aNehcU290mONkuYky1ep1RW/2BrzF1y6ZR8hLxq+niQgA1JQQFq3rPq/6hag+zw2BXZYKdc06URl321REeEWdlYGqj+7zK6Oy0YVYvMIWhDvdXDJv+LdkoZkKoYKzMNiLQ0pRu/+rXCxsrCMJFkXX6m+tL23/zN+HwQUS3eu32vbWt1bk7drh59a033OrWdD+9/6MfLSzPT5w6ggRLF+6vX7gkrTYSddpbl376cppb2Ed5bWGz/cv30uIKOsQUB8vLv/4P/6G70Z50FLqDxV/8XNfXZs6c2phfmH3zfXDuys9+eu/Dy82MdXM1bm1NkmuZJUZwrqLe2EmWVGf025C9+MivYHmeZ1lWiR7neU5Eg8FgbGwsy7KNjY12uz2zd8bUBv2+2zlEURTe+8nJSVVdWFjodNrMDkZZk2r8qkrBO0cwWhSJAAkNUVEVTMjAVT1LSgwogIzoGJGQ0R7s7T/9ZMAUDQHMQHQIfiBGqQ4uFawYnCcULlGlkRdRcuIMWNB6oCkW41md+2IIJWORYpbVyn4sHVUp0ixrIOAgFZwwkM/UkFnMMudjUbD3pSl5rglRspDnvVhEgixkWsYQuHSWorDaoFfUXJ4YE1QuOCExYUiI6sgTOVMQHSqnYsW1hOxDtJQcMBm7zFLKADIfSi2QyDuHg1hLkBt2u31xHBqBosy40FNSRDMhIgFNDOhZgCpRPVSsMkNShb+ffZ0NUAEMzCkAiEEiNEAV6ydJhD74PM9BrO4yl4oYo/NuO0Vu1A2xUCEiNAhjY6hGAhY1874AELB+WaaUXBbA1MwKE5XSNRolgolO1seK/iAkikWZec/qvHMWDBMScFlGMrOykmPG4dxGdM5lITwc/wIoYUnkwLyidctg0gghGiREkTSQAkvJggsND6opRiKUVBJg7llVWTTLsk6vgwYoyRM3vRfFDMC0zIJHiZqkgZyF0AcrTcfyWt18r9sF72MpHjVEzYASGKvEvubO51mNYrRujxHlY18EAlTBmRqklBTAe//74osfRZzfpxkCAAwZmhC8c4xDcvoqaSoEopDMMJb1UIMIUBrkgaLmKXmAMhUJgZ0biBgDB1YprCgzwIbjVBYRlV3IKDkd1NnKMmbeKyqhJbRIydVZVUlSw1AH3Rp6dejF8jxXUUasGVKvn4VAYEHQIxoaF2UwZsdgYkMsv+06J5BR0xMCsEIQcMwYU+DgQkhMA5cUwVBDs14MipBnaroWu64RkpLzvjXoA2I+0dQkKkZAea3Wj0XIMkckgzKqZOzKGF0jr/l6X2LwzpJl3rOigAbnGUgEgNGHHPKMOFBeSyoBh4veqBkXDPThgB13zmC3fSyNiMA+M0NJwI4UFADzmlc1VHWMqSx8M2egdr/bDFwvmQRX4kAFx9DlCqkoNQAhNvNco5aqpWIj5A5dxwboiAHr5IqiHIiELNOYHJKpsVqjHja1ZNGaoA+hK0WMpTds+BAloSdvnAoZD7XYid4TBWc6SNEy5JiSr/lSRUqtmcuN+zEZYS3PY1GGEFxWU9U0KHKiGJMhBHLEDAC9smeBm865ZH0GyH0nDRoFTjpfRtPgUpKEAF9d0IkGWAFLkVAJAXDXwR/elHweb+6jZtW+nX5/xjzkK/CeiJJJRWGLuCOMCAgAonBzYev2XOQEICia13xcWN5893JmoVli1KLB6sr25uDeRKJGlgHY6hvvrL72Vo0omJKWPlAhht3u/YsXcx+IqNfa3txeSawDBw0BS2VrcR4NSrUMeFrCyjvv3f/g/TbITD6Woi4vL9bRrJdW314fE+0LJMR6lkPmyyGcBiv4NXylnA+faETk2PkQqug0y7KK1IGIxsbGKr6zPTN7xppj9+fmHogeI+Lk5OTY2FiMsWKFyPMcCVWsgt4SIyLtYC+J6AEyHsGIDEkAxKxM0USIQAxEoDAsQCGRCAoOwUqfUZoxNEEDBFYgRarUVlQVAb0XEadG5FJMxtBXQalSoHEQS+edJMidLwcDVBWVaCTepwTCHpNCtMhUljoAESIyjb0yOrFAiKRlElM17Guss/dFwqSl6iBDyFxKKTgsy7IvCRAZXCpjCL7olyWUngzVKgH6Tix7xqQpMyNANSUiAYEobGCMkQAyX5ZlqG5LJI0lszOArWIAYE2BXAnABhltk/nuYNLXsaqBqhRRFSSiqFQ3BJKhFwyKZFCS7WDCPq3sRQZOAQ1KUCEAgwSoiCw6iJFpDIIryqIsBn3DSGY17zI/iAhMyRQUPJNGyZyHmAgQDZKUxua8N6JCjByKgiGpCEDMmjWVBMY9S5i7jqp5BI0hD1bVF0zRMdZqg2IgGbckjurUwy7Xj8deVQ0oKIAogXnPpKSWDIwdxThoZA4tuTIl1dIIglezWMbMeUek0YxATACgVq+JaBGjsgO1DL0KqjNlMtXMmAQckxLFIjGQMzPSYOCRgTRZAsKM0CMapBLBeeMkDKzwcPZXzVSkYuxAYsfsDBEf8P4+UjyasCsb/ZB9vOj56AwbEejhwTwgQ1Ichr/KSMSS1JJwtDp5MoqxYJCkMeRBAHqxDw59yCQmIq35LMXoiNiUwCwWDQQY9Dy6GpHGpCLIZjTatKs6kxoFEYupbNYbsTugJChippONpsVCen0XnEvJAYz5UJQRRJgxqlYCrIZgBmyVP8REVD1PCj5BMFBVr6gpdcpB1MFYHnoSHYLFwjy2NSJXOo+JgzNNljEqFKjksABDEGAuKtBaKl0gDzhAA+97sY+1MCBEK53D4H0ySGXBiGwmJsT5AKzV7x0kjN73VEDFqz4oaIxWjd1fxkhJ9+Nf3EdepgbmeFCKlanhPDpOlsqoCFaUlnHNVPpF33LHwRtCT2Jm7IwBiZFSjMAUOPRTv08oIOw9E0lfvGPyYWDCUYjBO9+GJKgOkL2LKeaA/aIogwVyFmNpZpkTkGAIgL1YuDxz7DkqlKZEJVjq9GfyGmnqmfbBlBiTZEpEnETFzBAsqQloUiUSAwSqwLYuhE63Vw9enHWgECPC4Mn6bCUzENSYeoN+N0nWqAmLmn5uke83MFNQ1KpFXUHV9CNdxjtdcUMKnp0S0Me/sn9cG1V5qlB+19hGI/49CIERAMx2ap6jUaeUhjhXACIgs4ZaJlFEfeb6ceClbCAmZadljiGQR0j9VjFtUGdo9/o+NxCtk8+KSBYLUkZgMBNzQJZSz7QWAhbqmNCUCUpVXwKB1ZgBpK9lRgBSBkLqbGeKdfRSz/plykptAAKiA5JS+iLg+OPZ36/WPr4AIWJZlgjgnEPEGKOZhRC63W5KaWJiotlobmxs9Af9LMuGrW8VZDiltLW1xcyHDx+u1xvFoGDiapFLIjl6dq5IyTmqlFSICZGSptIUspBNTvDMnsxEMCGBM/QC5JCZs4RstBP+foZVskaKxgpekQwr7gglrO5HBGMFh9wj84RejcSYGcE0pZoiApQWlZkdZQoJXHIZIMIgUqIsuEBlRHVAvjDUONXwhQmpBqGIVjjIM2eDWBPyRj2JrsaJgRRcBGdqrEiUJe8imVHdm8eIkOpEJJqMsuAV0aVYU2AmQYiSUM0Ts2ECBYfJoTMlBQYUUxNgQQdQBut5aJTkexoI12sQvTX3IPeh5jiCESKQGRujJVB1iIakmCllEcnAsSX+vKKYgVcgA3YqaACQGAXQJ8zJFfU81vLxQwfPv/h8o1QNVmIqJI0DOERnRGpAGFXNEah5IFLzSKWmRBZNnfeoJmCCQM6lGNEgBF8MiuAyAzBRZjbRyithcEmSIRljXWVsYpz3TJc3pZrQYCYiMcaKaV13SCgNOFkGENinmJRIM4yahEBJAEE1uiQumfMuIkQ1QmTvkxkBknMxlpIkhFwFEMj5UJjW8zq2+xm5gWgfxTlmQRUFQ/RAZilGX6/3sABTlLKEiMEZqYkRWWEqjM7Aq2TkHgjq7fRPD7t3FRFD8ERUloOdWxd2LSePyLqy28U8hPTFEfcZ/KOO9qPYX0QjVIIKpuwcEQFYSrHC/u5AGnWo9Q3BeyiNCc3MJQWPSQUZo0YAyJkBTPuD3LmUSiVUS/1kufNBkkRhZFNgAiQWNfa+TKWIuMypCTAxQuwPMp9lHjvlwJEFNUIsADGWXtRUxcyZOcJ+GQMSmYARoAoOm5J2Ct2KULJWuTmvEBScQUJwyI2JiWOPnyn2ztSyILF0Zk6BgytUlUFErRIRNgBRp0ZICFhxxkSzBoERsqEDNJFAjGBekzka8w7FtIguc0nUM0MUh2xmyK6nVjNsnDi2HYJOTUu3JyK7s78AH8/zfsp3+TDAySIB1kiidpMQO80ytUSAqNiL4OqZOYwOkPNSpMMWlRhZCAdoPq+zmTFIw29BapZZhs6Qg7eoVmYgjjlZVDCEARsj1pR7EplrlHRghTR8GTGw9SEVOWtgEB70Sq3nyTEp+IiIrsi1QKmNNTFR5KLNIrlXgVwpA9dPERWJGD31B4N6c9zQBjGSYxNlACAcMECWFaiGWvgQGbBEl0wJlJmROqVJ3UngUs2LBzAdJTkQhkwnH8uwf9aVfvAyM1NlRjEDJFA2Nazl6pwMuxYNTdGqmTK82XfAD4+ImwKAnf693YbD5tdhsvz3IAI2QGQDFE0IGsgzmqYIoEhIiCP4siYZMIGpan8wruDUgLFjYsFvFZ0J8plpTS0AcEoGOIhFIiyJPIETGweWJD20wiAzArDSU8vEI0nSWiCLkhugACo6NHDcKUtPXAPUKAFJTTN0nW43J8kBc8SiYp6r1FGYqmrGbuzvV5sAfuiAFfZXJDHXRKQoiooOoiiKTqdTq9UajcbGxkZRFM16I4Tgdg7RarV2+B9SSp12u7qxJCYjy/MsqBv0SyMzNQMbCmyYlkCDpLEx9vgPftB4vgSLpRN1hAZesGQsmfKITknp88PfhFp4i2yk0CwxCEREZSAmKxMQ9R2w2hj6QpMBOqnCX0KilCIDiYkxKBETkWI0KwkUgBQyJSFIDErgBTIxM4NApSQUDcACWrKR9ynGurFHjiqRIZl6JCeGgNGBgFFCNjI18GQECsIAlpIYaAhA5MQoJSVUz6UkEq07T6KKUKAmUHaO1EgAAJNHKnSsgF6dNmuwp4/NnkayjrcYcFydlRI9pQrXYIqISiBDdmwkxSAYBNEwke7URj/NzIZSF4mUQFghESTiDLJEbtXS6nTNeT6558hEaxACtzPreCWgemmNgdUNo6c1F/sB0GxcOS8Mkna8tTIQhDHw+UCNoO/RmFABTb3zMUWqAGWEZlZpyqPjUlVQCclMkwg5V7Y7/VgCABhAFBBl4iHnCw7DXxySHRMgGamAmUmF7dKkjhlNiZ2YqCEhMphDQsIUk6rwSBHRzMqU2DMiuqSWUkQ1QkNgIgQqVQiRCLwBIkVQTUWCRIDGROyNSLREIADyzAxgpkagzKaVGPVO3G6IQMyMDhFUk0hUk50I8lFTUYKPYh7MrOongJHg0+6X/eOMDwBGeLgH2F8gMEJkAFQTVBkK8BigQRB0CWlIMoOQBA0thFIlxrICDu8U7HEIiKwKxGwGjj2qqAGzZ2MAYMcAEJOYKRgCIqOrKlkAAMzirEAQBYiRyAmAgAFikkSOEIJoMjAjADXPjokMVQCFzBC8giqqoQCVBCVaDuABAxAiCmIXwTSmejj73HO5gLEOQA05Qw8xDQIJgS+VmTsWo0PHriZgUZQAAiZNooDel6JOjQnFWWaGUSJjaejBBwMEHXhKCEENYnJVDRCgVFDKNG8ueXfsz/7pTKfVREVA3eEwsY/DsT5ttjyE5FNFxUratxQAShkrQi7EgEVKjKSMPRQE8FptzoENBSEhOGaLYqCauRKSF/NKqpYBgWifAT17I1JLkpJDImbRpMLsnEICKRxS0hpQBChJlSgHwqTsWM1AFNSAaB9pQsiCy/rRVDs5IZPrCyEik4gGpaBgREmFnUOGMokjMhVEVMLChL0TSaCiDOrZAUEUr4BIkMxFYedSzoUIGyIqVRpRWvHYogI8WGGr5mYwgEoy5bMMwcyG1QYTq6FXBTfWWCq6PTBFIgUWdSKsykg4ijN2wt9HpfUNh2hTU0NAYqqY2hCrUqkBAA937I809teABEw4EZmLQIkAyVgNSgIQQDBzYADijBBQDSpaLRElQFJTQDOLI+R2BFxzoAenbVD0Wz2vlAGxmbE3h9FhjoH7kgwLE8zreaO52d0ijR5sINoECIqiWgdwACyWDJIZACQVB6aigtAHAFMCDMSJSFSTJOVh/fN3sFmqsuMVaKQsywqqDgAppSzLsizb2t7qdrszMzNlWaaY3M57AGBqaqrRaLRarY2NDVGt1WoiqkLkvQHEmADNeW9gMcayLFWUPNXII2UcobvV7W50jKTnNTlEA6cUiRJTLaLT4f7xs08goRXOIhsaTBRQL6FgjAxoEBQEcbsGrNAsh4sLKTgFgmE3tyAogeJIDMnAEKolZMh1vdOMDIAK1X4QcdQNhkNc4Gi1f4AWqKSVAECGEqSVVRudXZ3LCFW/llMjg5KhYicnBa/mDAhMR0yeaEgCirBdQ6ewv4v9bVupWa/AsYglQ2QwhJaAkA0cGAAbsAINz69KXyEBsoJTRENF1S8ACTMjAFBKXjUTSwQRHVneV+CDe0rwG2ubrbtLk+sdRmjn0AmAYPXSxgvISyvZNuvWDUBm9dKahWWJtmq40gAhmOjDdJ+UrJNTJCCDIMM+XFIDswpxUYW/ilCiGQAjEkBS5eAbYw0XPFXsuIAO0VXbLRrd0DvHQyhUq509AhAiATokUEPgBABuuMerxL8BwA1xSKMkMgI5qhbpjMkkQqDq3nZAAICOhwc3AzALAGgZMBqIASCCmgNXzRWSap4wIotaxUo3kjEEADAVUwVTAFMVMHBMOOrb2gl/H5UVBQAAhtWeXc0uu1O/j0Cw/lBOB0e0MUN1aQBFgiF/k6FX9IIE1Y2MhIAIXSuTg4BEBpW40u7WOWJWAyI/iuXYDJIB4E4XI4IjQEpmQFTNL0QGgCQAzlWsEzUOBqD2ALgZq/gaSAlKACRCAwUFNSSKrAAWUpWCIUVUQkFQUxCrBFQio2XBjTV6ZWqtbPgiClvbkjiXJ64LdD2WZM1IBlY46DpAtbESECA5MIgICsYRvRAHMaVUBAlJ8mQDx4lcHl0tKYC2M4hMIYFXQVBBQeaoiFRr7jvKB/ZzQ7bWN+OwfVmHe6QvP0kUMRlKIiQltEr9CjWpApQOAKJEK9jIKFOuoHOVdzAAABnOD4mANjBAEwJrm1TtJZYegPNNYEihDoCprByNRgWADooBKhig9kzJDEtFMENIZCbJJTCwToxBABD6pbJBHkEIogAChIRBEQwSg6oYGRmSGg3bXSASiIiBkRgh2KDKEmAmgKYg4A0gpTKmxFi1RSAAK5JCNWMTQaIhPpTMnAKBGexCjH7qzWMGhmwJTUVziwgYYiwUFKi6l2i4Npqa2lBSGHc2wI+ABxgaIQGhgZEiMRGxiBZFkQVxYKaGj3bgCwBVwhoQjAUsYYmoRMElFbMSqzUHwFUJlSoTARhHb2ZAiCkHrOArCFgCDZDt1MHzf/nPsdN/53/7j1AMmGotLbcR4lTz2T//096Ve/O/eKMg3zPb/9RTh86eevO1X22Xa5ZKQ3DGCJrMHJIXS6AKIGA4jLwMAQoCNasBDNfZyrFWgdlIIvt3cOEQEWwInq5I0Cryh0ajsbq26tgdPHgQAJZXVvqV6HE1uDzPm81mt9vt9XpjY2P1RgMrXTfnwFlZDqDUPKsJfgRNygD1Mk4UMr3RWbj5/tb1u1lwfZaE5gydUCQUxloEVkhoyp97FUzBEgMYFAXk0QaOSgdomCkoQisAK7QjRNaChzRA1UqiAKkS8h2leciAsFLdABiWbQBgGP5WEdgwxkVUqLREK6pNtF2tejQ6WnXKnzDo0fU3gGo2OAFQqyCGhkZqbOAMCWC3P1KDEq1TIwbr9LAk28pgQ6guqAgRTQnYkExTdVhDBDSDSijMkA0rjmWg4Tbgi4W/QApgqE5jJiaEkZxK6KodeebJ0z948d7dhYWXf91q9xNbyaYEBLYltqLgxdAsEQiZgbUQsgQTA+xkuF0HJYABYJ8MrB0gMjBg0Iq4wdi04oUegnoBFWygAlXkWsFM6/nYN59uZHnlVZkIAVNKOir3PezA8NMf4sef/yTb/Tb82Lt3H+TTnv/4Jwz3Qw9PeKtyw8MaIu1gox5+9yOzosBoqXvIYDTIR2EJHO6JqtzvTha4mmqw+/IijBgYdxzZcEUcqkyOOlW/+Ad/8jOfPClh1yyqzB5+3c4EREAcSViNYATVmxEVQERSBSJHM7VmyGS7c/3Nd+PGps99TyMANCI2Cus7iA5qiQAsEhQMTq0oENAKhqASxMy44BCZvKhh6vkYRHKBvuOELiTXjMKmrYAlU0iYqSBIScmCKxUF8vPf/sGEb156553td95qmMLu8Bc+DsX+YlfXjDUCaiIERVJUQFTsGBlAJDXSiFaSIVAwVxGpVXvSkY+H3agAHOlFf87nAgwFxAAUwejBoap3VysCACiaopENAwGAIdcnGLANkzLDr9VAERKioYJVywGQ4bDKipAIBBHMRpKEgIBso4yMDUGh1QMhAEQWYAM2VINEKEzD8BeUdNcAPvPaG4CaGkMkBCKLKSHtOX5kz9kTDeCBIRAmxug4OWIRQ8ZRP9Ojsfv9qA2pX7DCC1WVd2bn2AGYgvJvcHv/o9gwEWIGqsLGCExEu5eZ3R7sodUHP/IAFaBE3iY+cPbM2LkzgcL4L9/BzZuFUm98Qo5Nd/c3w/Pni9W+x3rt4P4wntVPH6+dOiw3xkVjM88ZTZY3up0eIETEQpV3Iqgdd4q489SDQSI5x+UQXDPEP/zWDbGqT1YrlKpWhPoV0e/evXuTpLW1NZE0VH0zs0pSa3V1tSzL8fHxQ4cOEVJ/MGBkQBARRPDeA6BI8sTe+xACMYkUlhLCwGPhyq7rbmeFI0wAEAyDUEmQGPMS2Syxfe5OFMGqtK4B1CNkAo6x8AiIQQGg2shgHi2SRhre2jvhr448XeW6aBQZP/wpVZS661cjSNXHV/4Ods0jAzSo9MIJwMmDT/wMMwMdSdiNXJyy0Y6GU9W1pgYJ1RdEiHkJHoz6hoBBwQmUZKUDZ5gncwl4uKFCBUtQUfejEu6A64Zr5Oe5dwNQREE0Uq8xiCWikryal5hCa3MfWUvi6vZGvdTI6EHRjACcmgNkNapguzCMHbxiM1IoERMYQLOEsQIVLHiMBGSWS9XSVS3cD3LxFRjTDIywQvUTgic3LkCAoqqg1Uqmqo88aOsL2TBKG65lD5pIqoht5/Ejta7s8J3ttt2jrV72jzjgTwh/d/406oB51KVOfwNDRDBGZAJCAHVADeK8iLzZgvVWVguEkSDVS81KYwZhyITYwNASoTNrlgRmfVcxJSKZ8+xLplo0Mmn4mIvUBErmBM4lDiqI6gMWTF4oEyXQHpWlQ0dcWL8hg2lvob1R39oYEwWAahFSNcQvyY2FBi4lMElEkVEIh4UepaCWmyGYoQiOqkc7C8yn7ZC/WPvTg/B3KI8yrC8M0aMIZEPlEQQwNAFwAE6gZFCEXEAASgdOwBlEgogQEZTA0bAF0wG4ZCzGoyBbCCKaIrJZkIr30xShdFgyChqaZYJZNFIrPSmZE3IGrMNlKxFWuQ8EY8Wd1PLnmAErUoLIgFmIUbqg4zPleNQ8aamqZIkgMibGjLnaY+wI9Dw6bmpkDwIxM2OmkAXnDCsE2yMe+gLsLAswUhYD/PKcCQZQIMaJqenzT7997fbMxMTpH/6TK9fWU5Y//hd/3Dy2r9jX2HP29K2/ez0cP/Xcv/gTySE/c2qjtb7aan/vX/zZE6cf6969e+Hv/stap+PNQKHmmc00fZFYVlUM+SNI8d++jUjSdy2gMcZBf7B3Zm9Fa5Zn+dTkVKPi/a2yvN1uFxGnpqZCCGtrq612C8DYsYqkMvqMHbpYRvRkFW+/iKkhY1GD1TBYolanHmNTo0VAgyQgVq08hqiMaKZs+iBU2ykH265ETBUmmhIIQQlohAOGQcDE5ASdghCaYQkKJgRSHWPnq6DR3N/ZJFmV2HlwcQABdvKjw0KZDd+7O47cvZcZ5gGGCcyPZfT0wQfgaDylg8SIo8NWPGM4FKQBHBHvoyKZOVRAFA9gxmjqUBS4SpY6UEMEZFOyEeChykZglXsYabWPzontU67t6JIYoCAKopICJSRLhCUJgGLuYoht6BR+kPKEBgGJwAQMzQJAQ4wNBC3xsAwWDDJDdGYeiIANmIcN0s6BEqApG7KZoCVSqxLrIyAvIlAVF5smEFAACBVN9M4mkpmrLszPmPW/L4ZE+MAXmJnqo4Kg/TL28SD40TDEB9zkhPh7sex9MbMKtUXkHHoHFaGkJozRl+UUM3qvMakz1OQgsceqHBzAgiIDFIREmLOAGoINnAmRCSUvic1AWcWTZKZ1gwAopgAGTsSpeQI2U8OkpIYeEkd0rIxtP8i428+iugiVwL2pjapvRg+71c9aBYZ/raJVRVNgKx31AioDAqJJnrSe1Kk50wxAQRMQ8Ehf46Gc2IOLN6zVfrJn/EicjBW2Fnalix+sXjZKixgYgDCYASEAAyA4BSBQB4DAWgHwAAiMAAiBRjkz0I9kUggAwQjIwBkEAAPrOxQHwhAJ2AwjOgVmKLwkMmAltaGmFFRJabBh/Xe45bOPS4589MqjYZYwN4wJiLk0MFBKJUkiG3Yni5kAGJF3LopV+bxHaosOw7rKaPP7oM0IETDGxCmZGuGoA+4RNlM1M6qAy0SQ/k+lTvtgE2dOHTpx9uLrv1hb3/rhs99t79+z/8zx6Reeee9HP+k5/fqe6d7k2On/5gfbjfyVH//t1/UPJseamctmvvb05sLinVffaK1tMkATmcCS2BdMRKlakmTmdxcMf+tzxqBS5k4p7c4ojY+PLy4uttqteq0+PT29vLzc6/Ue8P4656rYd2trq9K8CH7ItIpMw5YXAKIqH6wpJTVzTOY55RwzKllKSLkhmxKCQ3BoQihUsWsA0MMilx83EghqBhaBvBkDZIBRtYCKX42CoDPygFhxso026LALorDDe6toCVBJP5of3X2tABAUKnwqAAzDsupPNnISVN1DVSBLABWv+w6KiB7E36N8ABgBIgatJIUpIUQCVUEDNGJAQFMENnCKTgEJnQ4/bqgyacrJMgVHxEDgMKomFQUDImIEALRh8ldHbpoM8PN2igZISIYGpGSKFcSLMUkUNPOWMEaK6qwEceZJoELGoREaJdJohqKqCoQGlBgKky5iNACB0jC6Kj8AEZABAxkBGkEkU1RWM8DEkAAILIghcUIrQUHBsQDZkDrUUE3BrMp7/1/B7CNZyAeV+l32O+gS+I1s90h2j+3jWep/rDE/lP2tECWj+/dRzFB9aUMbkkKCgpoJmgCYikNgUxYBTbEcYFSPSgTmiBlNRCtglCE6EsaSAUCTGYs5ATIZOExgAiYmyeIAjQgFoURIjAAJWQZEEV1CcqagGtGEDSEpu5LTACNmiE4QdFjJQ4QKZP8lw18wroJQQBBM4COxARJmalmqGkt1WAf7CDzhky4dQHX7fTRfMDSD3U8OK4CVX9Xdz9kwG1K1fVSZV2EQAxihFKr0TXJgCJiMADNFrygECVUITIEBvKDTavMPiCAKHpHB0ADVnEDFAUqmPgI48gC1RDVFRUggBZrycG2iIcLEbCe0HsqA2nAr8ulX3hQjIQWKiOrLmCwiJlYhq/QTq08gIDbawXHupPQerXur8gIwdE8AaKopiWeA6lTBiBD10S4F7Wo1thG97Jc2l4W9X3tybO+BF554NnqaPHJ0+vknZbrZK7r337nUi4PDT53105Oy/+D119+9ce1mrdl47smnJkJNVlbnf/36/fcv1wIHxz5ZAOiq2hcbDu7SQ6n2S1/+HH4TU9MK+1tdvapxRVU7nU6j3piYmOh0Ot1+T80cjBg9p6amJiYm5ubmUkpHjx6dmpoys5hKRPPOJSlFLPisI+KJvHe+EkNOmjQ5xZrPukZJMAMmMxRxglyNgSqvYZVLhM90e2TmBUxBnFU7bAYOwfdJxRDVZeYgSjLxAKyECEJDFRdUdAYoVnVBDttXaNjIglWzEw7DDyRUUyBUADH1QGRIBgJVTQurghcxiwiYEVa0iJgQBI0QVQ0NiNBU0ZBoFAqYGWJypGYcxSsBQAJJOft6nYy0V5QxmeNElERqzAKool4hIWhgpwiqyTskYsAoEkE9cgRVh+SdiDhEMmUDVkMAqTrqhrQon5n7rYTR0dDQyMiMVYWJAZi4EHWADqurgclAHDnngPJBKlIZVaEMKFlwAGIaVfwgBaSUh4EnI2SBdlEWZIG8UyudWdIkUicHiKUnUW26LKr0LZpnD1ymGIgxUBELAM0qhIRqBUqTJCnJQzfPrhL8b/de+spNR4kTqBKTFYEuwMcXkkdnXXmI7vfTxE4/bS3cedlv74weCn930CU7i+HQBf3+GxtkhqSmSaKkaOLZixgykKd+GkDqY4aU5SoaTQempAjkUh1z5TxZn6SnKXcOMycEwaShXPRTC2SQB8+IEQeaCk3i2JAGgAVgxs6bFWalpYCZAjskFxCt1EFCEiZiIDYQQ6owuAYIFV/WkLPyo76oqlJVIeUn/BWgajhmQDQzcj73LEVJiD54LJKYmig5NLBkoIRmqKaISIAV9USV8K3CZwKUYanQRj+MiM0UkXRHW9pgp3UOENQQmdRMTQmwKpaCVb2uIGCGUBoKSknogJxZgViSRQAhYo+uVKfoCBFAzBidBYpFGTUF8syc1Cr9bYqplgAQgCkRDkj7NXaKQUw0ioEYdsHEs+ZeNFpROiNWRVMiMgEcNkUTDlFjlezSZ195KFBiDslRhFiqROdrGakn4wq1jWzkjMlAJKkRMTvnfocV7S9sVWP6g3seDIAIszzDkCGRmKrZJzbwPDI27AgRqdQ6tNrOD+dr9Z0OH3ySsx2VtKvHBjC9f+bxs6cW3ntv4cIHzDxV2sGnn1pfnUOQyTwbA9wLYbMo1GJtrN6s1yjLfAgODEyIKDBJSlURRgHcqJr9OWbAzMGFiCjVmfxOGuAQMSXd6TqosL9E1O/3a7Xa3r17V9dWt7e3gw+1Wm0IfmDmVqvV6XREZN++fZOTkxW3g3MewQZlaSDEWZUDDpmrKIVNFdGCUT25rIe1AVMMuSizB2On5hRKAAIctY5+/gqEYImhJOsHQiAr0/T09JPPPOmOH5AshE7K2/Hqh5dv3r3dSDblsoHIQFKpEvLcO4aYnAgbqhkwKnFfEig454N3vW4vsDMVcj5432m3XRaEDIhUVMDIFNAjERCWKZHjp7729YX5ua3NTRDrD/q1Rh08t7udkHnRZGY1n0/v3xNT2trYQAVVMVVz7tDjp8NE49avL4wbI0CH+ORzXz95/oksq63euX/5/YuqduT8uTs3bxw6daY23nz39dfLzTaP1c597yW30d1eXD71neca6GuFrHZbN69e3bi3NNmcfuL8481mc3Fpaf76jdTpeEOvSqAVxqsK9L/IvrbiUDADNvOKXBGrANWIfIG5+SCIUfNG88RL35o4sI8yWim6m7fnl157r35035N/9B1FUwfdspj99QVfwtN/8J0kMYBz3cFb77xdO7L3/PmneL0VPW20tm794vVetx+8E9SxfOL0idM3b15vb62dOf+1/XsP3PrVG82xsQOnjly5f29lcbGBwYCr1YhwiBSwR3u7/sVtJ0SkUQQZY1QVANjpVN3Zuf4jj3VkO4EvjDB/O7IXOyHvp422Chd2v+V3UTMdzhy2nUX+/yqGBs7QKTpAIhKEClfQi4UF10Plmn/uB9+eOXygKKUnePfO3bkr1xv7pk7/8Xfq3uftsozprddeiz6c++6L/Rzqg8FMondfebt+YPrx55+Z3C7HS5lbun/rwjutdpEhC7jG9PTpE4fm79zc2lhv7j9w8PDJ4vLtfCCnn3ny6r2b67OLTW746HJxvgRNyGnEP0WVHLvh53JeftrJgqv87LlvPrv/a09soIFpLnr7/UuzFy+l7c4kZgGgV0TMHAIliVmWF0VZ5Z6Dz1JZmg0xR4agYLEsuRIsRSDjohjUch8lIRITpiRMjISEnEQE7MyZszGle/fulRXbl4AjNiIAE1E1sZDzRD3Ls3JpE2McIAxMk8D0vr2nTp6ef/fDQW/QI7Wa33v88NFzZ/NmfbnVuXbl8uZ2+8mnnlpYWuZG7eQzT196+RdbdxbB0+nvvpjXa9fu3Dj+zJNH6lN5Txa2Npbn55Zv3xuAPv7CM0/tP9haWLn+9jvW6TkKVg5qzhcpEaFWwgg2hEHY52kjG4CSlWQlRkWCmhNVsWRoUiXSqkXczCopI3qEK3HVTomoSkgxk6owU0oJyhJgFDw+2mZgIiIqiOidBxVJogaIOzjNT5GNGb29ApiLmWe/9/ARALj493+3dute1o/xzuw3/u1f9JbWyompb/zht1OMR04cv/X+hfbdpcde/Cb+yQ9nHjuNCAqSJJWWEhiQClghQAAJh6ypn3sSiIiEVd6KiCoOst+28zcw54ZcvymlPM+rx8zcbDbX19e3Nremp6erwQzBD6paFEWe59PT02Z27969drtdr9eLouz1uqHhyTntq5iyZ1Udsp4RIyECszlSh+YQuYIhGZKRKVgkKBm1osMYogngM/K/1aVJZCUYsSNP/SLNL67tOXbw2NeeXnj30sKlu+u9Io6P5Y2xrY3NEq02MxkCdzrd7Y2N8WZjf23csWt1Ohudlq/le/bM6CBub26rpNrk1NS+/Z12u9XpbMZy8sjRrFFb3VhXRELMnKs360Wv2NjeNobpPQd9vVZ/4ZnSwWrZG2uM1Wu1zY2NFJOb2SPO1+sNkdQbFC/9yZ+0u727f/u345MTeZYb2MrG+sljRx8799i9D+/0N7rloHjsW8+f/eEPL12+1N9qff38swcT3F+YP/Dd7y0M+hPf/tbZp87dWFm+98GVA8eOnPrn/7S4dFsuXNz7/HNXf/Vatt49fP7cuSNHXvvbHx14+tnakQOzd2+f/M5LHUlzl64wABk6IAMTVNnpEf+8/C8BEVj1ZSmqAio6AVJ0SmxABpyMeWz8xLe/tXxvbv3S9alzpx77J3/2ymafjkxOfu3JG6+82W+3Hn/h2Zk/mFpbWGo+df7yr34FW91aN5aCT734Qja95/p7P2oe2nfuhRfHB/j+z1+JAoPAT3/zxXKQtg1OfeMbX//TP4a8cfWt91e7/cPTMwenxmZbrS5CYWY7MK6P2u83hhMrXBcgopqJCBiEEHYIIIavetRyKrvS7Tv7+J0Bf/awd165g/3aacv9ygxHfUi7sr+jtPojv9b9hkYGTpGh4oMY4lOVgHxWmpWe907v3/viM521zY0782PHT53/039mvm6Ojj317LVXXw9bg4Pnzz37L/bO3r8//cT5Sxffba1tbK23dSCPfe05PnDg9qVfH/D1ky98K280L/zkZ1Io5tmpJ5/Mx7Plyx9MHT7yzT//lzi978Ld/3V++f7BiYmTTz+3Nv/TXiEJSAQBnADFamxYNTtU9/LnIFA/GfyAKGJCFL3rR2l1y73f/872wtzGxQ8Lc2W92ayNm2inLHiqRlleFmWn240hgyyr5bViUPRjJB/Gm+PO8crKChACWXN6yjm33dpGQGauz8z0+/2iLMAsy/I8z1Ss1x+kJFm9ntXq+89/rdfrfri46Jyv12rFYFAU0WVeRPbNjHf6vS7pmZdenNi398O//rFgn6bG0EG/vQ3Hjkx99zv37iz1+kuQZer47B/+E7X04eUPDn/jG6dn9lx+++2T3/xm99qVfN/ep/7dv11a2bh9f7U+PX7wT/9obGrq8n/4Pw6/9AIubG3eWZ48efrw4+d+LT9pTOSHv/+tlWt3D559/HSoXf7Jy4Fcnjda/S47L4CGFS6vEvnWIRPcZ115INM8GQlUgseq4BM6qWA2gDsEV2CiooAPeYBHZaM+qvJCVaHS4d47xuQYGIGICNA+LXH6yBgCEpFjHpiJJI/kvLdy5G8rcMSnX/Lqm6q6Ys0s3V9Y+uv/PJi9G8ruWEI/e3/tR/+wfv/O9odXTj91Xhiv/ue/Gly+sr66Fdq9PU893rtxfXFuYbC+cePln+rahjMlAxvxplfj+3y3ipiSlLFEHypmhd9Ro6SBY64StRWvfyV6nGXZ9va2iMzMzIQQ1jfWu93OMB4XkfHx8cOHD29tba2vr2dZ5r03GzLXEJGpqGrwQRlhBONAAsSKDZANWJATcSRMDAZKqERQOIiMQyjC8MoNL89HH4xgtAqoQERoomoenHTinWu3Fj1MHT/5/sVLq29dOnL65A/+zb+ZbjZvX3wfGlnz8H5oZssrKxfeeOv57/5BDpTn9c2trdfefu3Uk08e23cwmL/09rtri0vP/+EP905Pb2xtv/arX+2ZGH/ymy/koAvLyxevfHj++ecnJyZqWWh1Oj/+2cvHT518/IknQ+6bR47cvfQenTv15DdeqDcai/fnbr5/6fkXv5k1x1yKyvz+u+/mZ06V/cH442fOnHt8cnrah/Dh1SsyPbGdkqCr+RoI+axOE1NdpJv35/utkpKG+jgqiM81maPswJETs1duHzh2Kis09SX4RqcX333ng3RrYeLG7T/9n/77g+efKiab6w5ni/7xZo32TrfQAjtnCKqGKlUq6CMIZ/zopR4+iYZoSIZC6gxRKBFFIjUSRAESrP5hkYVeMZh75/LSaxfmL9yY/B/+cubrX1+Wjc3NzftvfLB1Z36ax848dW6r0S1TWlxcjXOr9XbRwwhiS7fuvPHr1/edOX723JMzkzO5uV6K+aG9k4+fvvwPP2+D7dsztdLeapRl9H51Y3O+3Tr2jafoypXWVjfC73mY+3k2RKaaAgIx744gfwdQgS9hOyHsTiZ4N/5hJw7++JgrGBaMcGAPRcw79sVX0E/4CBjy6n0E/LDr0AA2wgL+/ptBRaGuplKVCNRMDAyjmvnQVhsAXL91Z+5nF/zEjfP/8788dv7rm7NzaWFr9vUr3VtzZu7EH3xzo1fETrl88TYuLo13Cl9A3rPl+dUP3n5/RXjm6FHedzihI7Z8YvzgU09cevf1biqPzsy0u12fd4oQeuSuLC4+8czXanumt9pt9UEQk0JkigCEaAhIQ+TDR7flO/bZnmr4VRYE3bL44L0Ps2t3Xzx09No7b9/80c+b01OPf//7R0+c6t+7u9Le3HviBJUyKMtLFy/O7N9/6tTpsXp9s9d/5xe/OHDo8KEjh+u1+vidu9eufHjmyXOHDh8igCsffrixtf30iy80fOgPepcuXprav//wieONWq2v9tbLPyfEr3/n21SWjeefv/fqr/DQgWdfeIGRer3+tQ8/3HvkyPFTZ6aBeyqvX3hr7OvnJ44dDu9ePtyYmjxx0MZqc0uLm2Wv36yvqiByHm1yeqq578jyzWvXr9yaW91qToyLMfpcKaC5wfzS8dNn79ffmj50pB7yotOlkJfJPnzlrdVX3/eTzT/7d3956vwzdzYW+kmuzc81HpvI9x/oVFosCOadEQqhItqQxm/3LvNTrzwaZIkayRJYIgIkU80SeqkyIoAVcHaER93Bof0uopnf0EYoMgAYeoER6nQYOD7ace/QDAxx2N+jqgZE/EXzBUNSaAAwIEBQbc/PD+bv1z05swAW2xs33njdQEvV67fvtiz5egb9Igxk6c03b77zpkhyiGy23Wr5IjVU3ZDq/AH2/Qs662p7uYND+JKX4ze0mJJLyXvvnKvEL/I8N7OiKCYnJycmJhYWFrq93lD1rYpxnXOdTmdzczPP85MnT46Pj/f7fWau1etRiyQpsCMiVXGOmRgATA3R2NArcoX0VYQhp5VhRW2o4MSCgBf4Iny0FVwLyVVpJlJ2yZyBd86YK93b2sT46afPv//q6wtLq9PHD967ebN5cO8TTz25tLF15Jlnrr76Wmt+8Rt/+IMzOjj71FN3rt5oLW0ldk9943nfHPvxz3+578CByYOHnv72t5bWli/dvvniD/+wW89PPvP0wu27r732+nf/5E/OPPPsU+cevzl7b2Nz8xuNxtiePefOPbHdbl27fu2lb7yQUX7qzLnbd+9dvX79xR/+4d5DRzrrm6sbm60ytsp45/KVk+ceP/nMM+3OmmW+iNGVsZ7X3r/4weD4gW9851tPf+c7m9fuvf/LX2dZbgDmPfWLjWu39u87NL5n776Z/d17S7LVBWNSrnNuvrm9tMHtwZ7m1MriyrMvvjg5PU15WF9bz9i5EryoU1XSar4D8OfOTQQbtgVVShymrMCoFb8b6/CfU3WeIEPxljLqDDq3FuYbxw7FjbXJx858/8/+1PoydvbE/OUP1zc3Hn/s5A///V9SycUH13/68t9vOHnq29/4VwL1g3so5zt3b7X6HcyyQwcPggv9zQ6U8u7b7+zf3vzWcy/k7GvsF+cWTv7JHxw9emxt60bAzz+L30szwJFcIiFWzINlWT5E/vCoLSo7se9O1Lu76+WLjLbaY+/kgD/xI7788AA/Hv4OlwGzRzzT85uaDqUdTAGgKtMYes5qFFjZYShUU71e1POi4beL1sbiwtf3H98WqD15+sV/88/dan/m+NHZD6+Wq8sHv/2dP/j3/5rW1nhu9cOfvd53duLpJ6fg34+Ja+wZv/Grn21221PZ2P6Dh/zYWG+7XU84f/nGdqd45rvfr4faVrKllZVnavmJk6fvv/V2KgYBKAMsBJwajcS3hkvxlwI/kJkzIMLkudPrOSSRMjEQOVerHXz+uWK9de/2nN87sbS5ub259ey3v300lkdOnVJ277777tM//OHBxcUnnnpyq9O9duNmPQuHzjx29pln33nrzcz7qYOHTz39TH1y8r1XX/3GD35wEnD/iZPQbLz3X3/yzIsvPfedbxcpQa126fLliWeeMR8ef/6F5pGjb/7sZy+++M0XJyf7WTZx5NjVH/308a8//cRzz7V6PVzb6KlRXrtzZ27P6WNnn332g+tXU0yikJE3KbdX127/7OfHv/bkv/pf/u+tXvvt117rt7reGAqwgW7eul9nP3XgwL4TJ8pWe7CxXTeXg/MC2E9Wl/WtlmT1Xqs3vffA9//kz8br41f++m88UU7O+r1mlsVYVv2GCsOGmy8SNFUCVV6GoGFDZMOq9wPho+U2RMcuVrmvj4rgfIkv93djxBxCIJIqnfclJ+Lv1KrYR1Sl8rUmFmP8wqCNYVLfRgSjKmUdwJPvOUyQFBUFSDQgjg+IIQ7MTLThWGM5CXkRoS8Dz1wTLzEFsABGBgIgFfBiR07ms04CKsHhCLAjFPo7MESsFhrnXIU59t6LSLfb3bt3LxHNz8+b2cTYuPfB7byn3W63Wq2JiYnp6el+v9/r9dgxE4uUouock3AxKCSQQ0dUwemHZZUhlziaoWm1+QRFVFZwAhlYlsAZyBeYeiN0txAYGbgkNaUaApVCiAAWmJxzrc31q+9d6M2vnnnyyVptT2qEUB9jcr21zcXbs1sbG1//3g86ncGlSx8eP/vE5FR37fbdiQP778/PXbz84fTC/P5Dh8LkxCSIBTcAKxE67e7szTt3r99+6oXWob2HQPDS2++vba6fPXF6z+TMgaMnumtr3lgFPfvU7S/cuv3+hffPvfjN5vhkv1+0W61eTLWx8cNj42N7ZhJjNOXgHGNgKvr98X0H7t668ca1i4cOHHnp6W8++53vXL16OXku0FIjv3br1lgIT33zhb7E3r37ezCoI0qCCoNYZmN181mD/dnjpy+89vp77771x3/0R+fOPv7OlVtekld1KgpadZiQARp9/vbMUBFoRykPjY3QhA3YlE2dCZtGKftQDuq47koYq03um2yvrw06LZOyX3S7q+vX71+b++DyY888Xa6tvvnKL+Ls+sxWjP2eaoQ4iJ3W3LW12Tu34rX743kYpDjVbLh+IZ1epmiDggEceS5kjEPqF8p+sjHWFmD5fLbK31PbnZyoqkKS0uj5R0vsbceqUT3E/lv96XOD9WGfwEgt+XdHllS1MVWDt0d7if5NzAjMkwUCT+TIEQdwWkQuzBWQetE1M6LQKcs2Fn2LbiIXLR3GIrWXO8vja+3la1fu3b558PSJYnX58oU3e3fvT7SKze3No46jpY3N9XK9d/21udlbV6eazVpBTiEBpK12Y1AaWCg0I0YRz9y1JJ4nDuzzuTM0tASx9CpelSqRrUp65MtWm9nAlQmUfMjqBHvyWqbR5w5SUjDwdOvd9+5dv3li8umDM3sae/fw8SNpbraQcmFu9q2L7z3+rW829kzcunN75tixU994ZvHGzYmxxnJr64133qnl+d6ZmX96/kkM4cCJY5r5kqjf722vr7351psHDx44eep0p9O9fuP6xauXT1+9zJ4OHD+O3u87cgi8o3peJ7p/6eLbb745M7Wn8cTR2fWFskyLq6unDp06uP8Aj9X8zB68EwBdrTYm3FUirmfLq4sX/+5648CBp1948ft//E/eevXXlgRFEHB7fWt7afHo+bMwWbt+7/b+fNJFdWKEhp43i150kHk+dvrU4vz8h6++eebY6f0nTy2+fxG2W14VitJBIkNFVEQb1gENPy9WqfCkBVOBJkSAVComwkQgCILgRx1XAEDEFaa4qgL9zlJ6X9QqtDPCsKEYkIh4yPWw85pRW+yjaQhQqXWYASASgZjKZ4F9P2pG8BDoywjAUnTACQwMx9n1MZWmXmSKeEXVMWGSIFpDJxLHmETFpeQreXYABEg7oohf7GY2UJGUzKoC4FcMePu0DzULIXjvy7I0syzLELHX6+V5rqpb21tlWe7duzeWcdDvD1vfqnh5cnJybGys1Wq12+1+v++8S2WSlJxnJJBSkMizM5GYomkF4ENBS2SRNbIWrEDCDgAUTLgiZMAhHa+NWMk/DfNVpY4ZIcXoUB36zDQXqyMwYmAOAAMRZ4op5YbT+w7uO3ryg0vv2HiG6HLOvFGNfVeQgDxwb6t18Y03nn72+RPnz63cnxs7uPfgqaOHjh3fv29vZ2ttcXV5YXWpA2W37CoIxBiSMfmi2/bN5hNnzt6fmx1rNJbuz/UWFlYWlxbm551Ye2NDDx9BR4YGJhxYPPmJ5lNPf+3U2dO/eOVXVg8zB/dnWdCy0KLApCxy+ty5qefP/8Mvfzp39er23qMTvoYxshigpZpf77VA8/N/+J3XXv5pXN/ad+J0OQCX+z17p/plmnn8jAZeW1h87OvnlzZXsCwG/W6zkSMqoBiqkgqp0FBMuOp9eOjaAnzkygsmRVSs+Bw1EQmKGglBoiQkSqqkSMb1vL53evrI/pkzJw7NTL9z6YOJg83+vXvvvvLLcmmzhFSLNhWtvL+w+NZ7fGelJtmePdlBo9k33nn7//dX2XRTYtzXh3HFVoqDrU0F9ZnHopd5zwBIQAiDXm/s0LTvdrY31oYsySOouA07WKumhZ2fALsZLr6qm+erDpF2rv+Dcxk2wFYRYUKw4PxOWnX4rkcsATwEO32U4OzjPI4PDbt6TYzROcfMFQ5vRwbsc21HtudzgycDQzMyM6r0hglt6HLsQQK4CgZg1A9uBrYzywwADD+iyP75+8cvchK/ge0cb9TWvTPfd54cPpVADFQABBTUCJCMvFKdQoYODdn4yN4DuG9ffmDP3seO3nnnshTtwfLSrV++2ri5ImYbsX/gzNG4vb35xnu9e/M1y/ZJNt6VufeuXPy7l/d1oqaiGQzN8oRuEKko8yQErGYkkT0bqrBG0mhla3tdPFrGBYqwKqlVbdFohDuR05e5XgbGDJ4RNOaijUJcAtcrJ6M1wGG/SINBrVY7/+Lzd9cXZ1eW9j7zNcw9N3LMnXg2Ush8a3tr+YMLp888dvaF5+5eu5bVs/0njjTrzYMH9gtZu7V1f3kxBjcY9KbJer22eKZ6rW+pIAvTE/XpCbd3erC2utnaCiHMry+nzDu1Q0eOWObRc2kxr4W8lk+Pjx09e3r/186tXroCUGvoEXAIRL2yH7XwTqf2jj/+Z39UvvPW3P3Zm3dvPvH8C5yHpJEdujxIipvt7W/90fduzN+5demDg2efzp1zzuXTk1PHD4wfnD705OnZD67kM5MRdH1lcW9z7MRTXzMUgeQyLvtd9lXeFhTF0AjIbIcX9NMvMkJEHDgsEJQQjfqqNQ8lY6SdHumqoquqWvXxw+gO/d1taHcG/OmfqFXC26rQFwFBRWNKzIY4QuA8soHvLmNmZjYASWJAwfuyeMBlAZ95Rw3lIkGr1VUBBiAKoJICMyUNKgOEgqGlUYC6auOi48YFQCH9jLmNJg58IjUpEcyADXpYCUaCHyngfmx9Hj1lAACSNIm4kIUQdnZKv4PZggApJVUNIQzZGkLI83x9fZ0dHzx4sCiK9c31JOJ23jM+Pr5v377l5eXNzc29e/fW6vkgFaoSEBGojAkMm1kuBColVG2IwCwMkITFWNVp8pGkRDRnRqij5vYKkASJKwbIzwp/ydAAkxoQIENi6HlJYK7b6d++Mx5jwZI6m907d1yvVwqnTvfsvoNYywa35nB1u7283l1cGUfq3bwz1o9nj53Ma7kv050bt+7dvfOHP/yj//G/+5dt0TdffbW/svr4M18/sW9/t9NaXVrvNee51R0Xk4XlwerK0sbm8+fPv/TEU/0YW7dnZ7c7T53/2hP7DrU6nZXVtc2FBWt1xpE6C4tFpwN5dvTE8e1eUSyunJ3eNzM2ubWyAZubJWHmswJ6Lgv3r14fO3Py3/3JP5deP/XihTffwV6ve3/BrW+Xd2b9VnuzWN9eXGnfm8sKaddWetubQelPv/t9LFK3Ubv25us3332dsXj+xW88fWxvpyg//OUvIfWEcWBKYEZDwWdVo6Hy5WeFv9Vs9WaAFh0kBATzZj1K3Sy2Qyy8MZDbHsBm99vPvcDHHutlbvbazcVrN46OnZe7K9wptV8E7+rkpN2NyyvTxYADQr9v/R7MLfgiTRBAr++YHGiZkst8t90GYDfeGGxvkBB1y97qRiLsmZw6dBg2t1fnl8m70pECKoKaJdCEIpgEkkA0UDNFNNuB5H91/myEEv1qbDifCSKgOhAFZjBEMxDQKCpJMqUx9DwE0H5O9ncnjYojQfPPfuVXdSI7fGe7sb87H7T7cdVwUIW5/X7/4sWL8/PzRHTy5Mknn3wyxjg7O7t///7p6SkzE9EdhJ4qOMcAEGPpnDPT+fl5VTt48KBzLKLOcYwJAJlJJDFzjEKEzrGYog0DXDQYSskyIINCAgQDqvrXHdKQipsAVB1UfsvYMAiQVf3yo4TY55nCV4arGGaqKnYwNCElUARzCcgAEYXYGAnNmaKqmEaTVOkRqBJhYbGPJZBwUcb5he+eOgtjB8uJ+sVrdy6/8uujBw4X91by9R70S5/n47U6FbF7Z36ip5kFKsF7Lpc2eV33DjQUQszOh86gX4D2e23e2Dx86Nj9+0tGWGNcX5jr9DfFp0NT0yRw/ebNdiwHCLGWpVpQGqp6G5gOtxlfkqAwIfSQymToPQGIYVpt51tFjhSKiLNL+1zWU9XF5aMTYzweYXWLtju9QnGzPUW+3GyXG9tHp/aMHRuDlNZv3r7+1jsvfeP5f/XD/8aSzN+/f+mXrz319DMvnH6CG41bC2u40WkkmkyIG51eYXeWlh7/2vnTf/bnY/uPvH3xyuL2raefffb5x87XJyfvXLrcpbXYLxpAabMV7y+n1ZUj3zhKB4+GdntfvYG1Oi1tTbZjeW+hbhRDbli21rZsu/vH3/7BYFD4scatS9eKe4vuTM9vtgFXXK2+futu8dyzg/l1XNiEyW2/Pcja5R/84I/hqReLgLfvzL398s+PnDzxzT/47v4f/HAyC3NXL6GliKkgx/UQK7LIYW5TFUb8c59pNtwXCiMwoKk4A2fKKqzKZkijMi+iqthwH2Yf3xU/mM+IO7RTsKt8tAOa2nnvF3FTVdWoOhQAVFvoHdtJKyJW4D1zCoaUiCJCCVaCZgBAEIMZWUUQvSuS/Cz70vf3px36oQN+/GVmQEYAviAXzQUNgpjAyCqpAFAwQ0iIrOA+XYC2wjtXtNAGxISmSoAAJqYZcwaqBoTQRKgrmCZGGqgQgCfzzmlMAFjdzdVQh03xBgyQhoMVBPMATsABMFAEEkRUcIpCbBXYb2S/1di3mktlUVZoXiLq9XpEVK/Xe70eIu6Z3oOIVQ9cpYL9oAi7vr7e6/UmJib27t3rs6y06B270spSlQmdEwWL0TtEdoCohl4dk6EZSgJJCWOA5NQyMzKrJG4ISKp+0hEDi+36+dADRRTAqsSiZiVDyjGJ9ZeWb/2XH8dWJ2DsL85d/rutotOPAhf/5j/t2be3XwzW19c1yY3b9+PmhhF/8J/+tkxl98qNfQcPFEVx7+7d7e2td9Zbh48c3lzf2Lh7d5NI7i+MT07O37vXa7Xu3J7vbbXrvd7Kr361vb2dTMp7s0i8sbFWbGzO3rgFK6uTE5Pzs/e31tY/nJsvymJyEO/+9OdEZKblh1fXNzfWxppj4xNX33yv02kTk6ZEyUrGEqVcX3/vP/zVzIF9YxNTG0tLC/MLeV678/c/8jGuL6wXxSAW8fLsXLmxbuhm5xZV9cL9xfGJcTJYXVvb3FiqaTn76k/h/s2JPdMrS4sbi0s1QCRLDkZ0Dzjck+1KYz10d+38imBsmgkqUs+jEfhEWbRNSz2WttMSwavza73L/++/XpyZCc6trqxurK5aUW5euNa6eMN1B3UkiMKEizeubS3e9pvroGI1hxLv/uTngV3OFam6RgapUYm6PXv/xML84RNH19ZXpdvrzy7e3Ox1e+3xqfF9e/e2ZhcHm1tZsyk8bOCriIoUVUkUolgC1IqPEAAJQUxgSGP5yYE+fGyL9dC+efdf9StNDTAgGUaESCAMEcBVn0UQyRIDMENS7RWWtNL4sZHWZbVUPHRA/KjMxM6vn7ECfYlhf9rRdpa0nXa3h7C/RFQUhfe+Yhr/+c9//utf//ro0aPtdvv111//i7/4iwMHDvyn//Sf/sW/+GeHDu0vipLZx6RMzORUFRBjHIQQ8jwY6Kuv/gqA/vIv/20ImYgQESKXZcnsnPOIiJiGqd1R2ndU1wRABGfkcajMgiTGZowJnAAjRjZRCaZOlcQA0BmBVlqMNgJMfOo8wV3p/K/E0JAE0QhYEyUjJbMgkBuCUQFQoJYoIMmJBCCFinZnKGgnqDFYmRkE1Y3NO3/1172Z/cz5Vq9/b2Eu9PoxLt9d/Ae33UHHKCmItm/cvnN/sdxsO+Q+RtE+vPdONG2UEUmBsCxKdE6crbTXDy4vTE1MLmb1Xhy019evvfZq7Peclydm9uvscmdjK89rKVkEHJgi7rRy7jC97zDS/GZmADELZbLM1YtYbBW9+V+80m5tq4fY2rrzo59ImWRz88MfvXz4sVP91vaVN9/v9Xtb3pVFHG9t3//7n2xtby0ZHD9xHIln795NW1tXV1uHDx0qimJ+bi6W8c782tSe6e1Wa3V+vt+87rw7ONClN991IVtYWnCzC5OTk7d/9kq31epsbV2fX9136NB6rzd76/bkxISZ5v1i8fLVjbn7G1sb1xfWVtbWQhZmpva0P2x1uz026BhkrRaVUSxpv7z21/9l49DB0GjGXu/e3TupGFz58U+3NzecC4N6zvMLF/+3/9AvCt7cmGvBdmvrvY2t8YkpVYu97vzCvNvY2mxfu7i2NT1Zn99eW1lcjIOBd5wMEiCR2w3UHf33OUVnNHOmHMvAhAxFGRUoTxJEAhhDVUFRAVNCds4JELONlAU+zf/s5jqEEXniQ0HzFyxzVWHTTtBcHQdHHGc7hyVmAvUJgmLfU2IUAmGo9o3IWGByrDwsr3yhe/cTX/TxEX9xP/C5r0RAMlLBgWIin1MWTSyVNUVSJTMAE0BlVlP36R6+UoY1GLprE2AAiAkBIqgkzStJWtWagoENAMykqriRAqRYHcePDhgMQAABHSACCGhFes0AmVWxLwhQiVySBTWHFJFijEVR7EyGL3ydvoxVx2fHFd63KIoqa9Pr9VJKk5OTALCwsEBMY42xWl4fyl5U2F9VnZqaGhsb297e7nd7GTs2g6TIhMQCVqRY6Z0BaXKW2AKSAw7ovDIWRkKBgovJqVUKvWRkSIKMRpl+fvPbcFEZXadqycmQoC+99qonnKJc2oNyu9cMLqr077cW5+9UinTe+8G6TjgnprqtGVOxuXL75hUkqjHXiQZ3b1y/fdUxzzgnalsfvLeNmGVhyiC1NxvIdbM4f9fFspFnK5feLYrCMzeRgGnjw/dXU0KgMebU2/aIe5h0tV2VsVfn7zK79qK1tGJRq0h/sE7UYAQAix3baK+szC8lCSHsCSG1urIpzSwrYgkpTdYbxZ21CWZETNsJATrL1gEAMEQaI0AgSbp2+c4GzzLRmFK1bxmKPI/ugi+StzKoINrEleiwEQqwIEXw5L2rZZyzuqAu65fde3cX798xNVNtIGVZplurFjUjYmIEgxStpYNtbRABOEvmycNaPwLUKOwONwm1KLtL77195PDhaUhNEN3eTO3tOlFjfMzm762urjb7nXoj1MWyiEEoGClwZi4HF8xl5oJ5FoLSLKExaiVf91UY7rBTfyVHG/Z9IhAkVmMiA1IDRGNK3hU59TLcZulAkXadwmf4iAo+u1tA8tNqSb8NDPEXcV55nlcPNjc333777bNnz/7rf/2vmflv//Zvu90uALRarQsXLszN35+anHruuW+UpV6/fmNhfpGZz517/OixI0tLS9evX2OH165dO3LkeAjhxo0bt27dUtWnnnrqwIEDV69enZubc86dPXv2wIEDSIgyVJV8MNRd/4bi2kZgJGhKqI6iAxZlNeBKBRUVSYCqkv2Qreuzr8ZXO1sAqGo3IjAaSvkIgAoSoQFHhhLN0ByQF1IhL+yFnZADElM0IkVSpELbC6ut2QUASEnGarU9WTZYX1bTCReqeklMCbcG4lw9JUYAVNAirvdBtA4Ygk9mvaIIWTDP3XZ79cr7R8b3HhhvrGz0etvr1iVHNhFqzU575ebtejEQj5MqtUG3aVA80GGnYWJxeIpfwowsBVaSrsOYYtpYGBRlUQ8ZgmwvbJnZRMgGa/evr8xWeuJgauwCwpRK98ZlDwCAc8tzSOSQphDiand2fV5U0SAjWrtzZelGct6RQaezXqvlU96K1fsFcxj0N+72l2NMMdYb9Sbx1uz19dtXao16SGlQbptaAyBu9Ypt8Ah331sVNEVcBQAzZ+ABAzkU86CewAdfbi/fWronKiGEkAXu9Tbu9RWsTFI6NwbQmbvJzteLYmv+hqrMrc075yotD+f8now1tddvbm5AIkRGqiFXaSUEHpHrj671F/YBiqiAyQxMI1AkisQJnSAnIACKoNFAgJz3IKWIEKJz7jM6+nfcRaW5tTv1WwE0qwr1F4GEViytKaXK++04t2qbDQBVQaw6EUOq2AANEQ2dIkdzYBiBE2ACV5Xmv8Bl+eI+9BMn9+cmej/lvcYmHixjElTRAggwKEUhUwbNq6Rr0mRafr4P+qyTiJ/91k8crVWCVFgSJAZFcAaQQA0YIKINvA7IkLW0FFNpnFdAjt17oa/KHjpatTJ675m5At1VDXBFUTSbTTNbXVvN8mxibGJ9Y70oiyHzg4hkWTY1NZXneavVKopCUvJIKIamaEMp4ETGjOrAnCbSiBpNYirrpQT1FfsvAMSkDMgABqRACciAKqFO/lxE3VCU8gF6FQCIEAzBMLBXNS2jI/MqHhKQEYGAqQirseOi6GTe++B6/R4CTNZzEY1l3/mADmIUAiARA+RAgBDLnprVmMkEzEQ1ZzAZINJ4zkURyxRDljFTIiW0qkZgairD+1lEyBGTFUUBZlmeqyZVRUAb1ker8h82gxMy1QKLGIgM1cpUU1VTX3Q9oqaSiEQVAR2zgqmIqaF5AO9CTcqUkjjn0MyS0lDzeFfU+wVWGQNQMiGNhlKpcgKIkiIGTyisXQnqCQLEQc0lU0EAJCQwLLtQQX/EIA0/V43I1whDWZYxpRA8EUlKYPiRbCvCGNH2/N3B0oL0ej7ZWK1RlgMApK6t3bjaaremGLHou7IMSl7IGTllVuJEJOSUHTAagzGgAwTF9JXBFQz8UKT6qzmaU3DJgCAZIFpSc8m8AZlJigOJfUwxJ5AADqt96k5EuxPj7radPMcOI+FOImT3yx7Kr/ymA//4W3aGhPiA8vPjyL+UUghBRPI8DyEcP378woULKaXjx48/++yzx48fX11dXV5eIoLD7UNXr15DJAD+0Y/+65HDR5aWli5d+uB/+b/9T//wDz++d+/OoUP7Z2fvHT164t69e3/1V3/lvTez999//8///M9/8YtfXLp06dvf/vbp06et0pKsBHWNhnTWBoRAqqSGWsGCsRKjFZGkUqpEU4+QGFENrWLPRQFQRAAjg89l9sePYOD+T1uldAuohlUJQgHUrEyJGdEjMzNWOyhgI1AiI1Zyhg4QjJyxJbMEwdVypmhtZ8nVmCjpoPQqRIQqKQkhZIimBiU2gk8xIakD1JhMjYmtLJmwzljErhnlJtuL92FlHfvqQGuEyQSiaJJb778fo1FRMsM4Wuh0G2YJEEeywoSkQyf4Ze5SBFMpGIUi1piBUVK/7kBjFwlzQjOzGHMiQiSDqsNJyh7g8GYhZlMD0+AykdQrCnYMig6BHQGapFTLWaQkJud9UbQQKRClUiY8I0XMwDIvqW8C495j4Bi7DgAVTTWQ0xiTSa1R7/R6jUZNQFMSx8iGKEpSMhAzJdRUDNC07omI1RKUseHQUpcBPKHEgpkI0JkwpbIox+oNdQQmUokZm2ICAwAGMCJjU0spmppj9jxqUdu1CHyRxjQDVEIjVyIYkTpQcspZAkoKZg7MIYDDwOhEVM3ArGqD3Q0CfnBAszRq5wWAKvSJMaaUELFyETttAF+wI6r6oBACIlZMrtWn7/DJmBkQKoIQqaERIhkjOoVMKKBZRJeoihd2QJi7LsLDtR34dFzBQ3XFT7+wH6lJfvbRdg5V7dS9SaYpQiQyYwNKgMlQESwAeDMD6AH0f+dIZqzQNWaVjzIc6vlWl1SxCt6qKtpvvS3yoXh6CH4oS+dcCAEAYowAUK/XmXlzc9N7f/DAwUr0OMbSwSilNDY2NjU1tba21u12Z2Zmms2mRXUKDkgMTE2ZyJNgBDYgSaSCqqiGCBjAeXChRO6bZSGjSu4SSBEFSJHITMW+SPgLO1HV7rMyIO8KUwWlmkeCpNF0KE9ZURwmBAdg3vdEQATZOaaeiIig96mSbwwhqTrmQVFAspBlQmSqWHHsiSohsStTSQQBnHjH3pWqFgWrDlKQELwmiVE9MxElMyQuRNA7ROyqmKp3DolFkooiALEDhG5RBO+BvJmyYzNKZXQhmFk/SZ5nZVEQEXsfK68GgMSVD1FwpaE6p0h9U4fEwRHiA39XRaL4+RGwAZZsgCaIQlB4AkBARMKuxBABwZlyItbcJy4NwVRVq6ZzNjBAQ0NCREYmNuSuoZlhyDDPeympGTrHH3VtimQMxLbRbk80GhZTX8WQiLhblj1JEcCHzKgq6UIV1YtZNI2qCqgA/3/a/jTWuvQqD0XHeLvZz9Wv3XxdVbk6d3FhGxwcmhxs4yIgCMTkhEAMR0JCukdIUX6f++fc34kiJRJJFCkouVE6EWKS0BqbJgkxDmAXZWyXwU0137f3Xv2a/XybcX+8a63vqyoDVm7Osl3ee9dq5pxrvuN9xjOe8QwLZBkzkhuJBn3k/vNWyTf2QADmrTP+l7yd77xGQESOhISho8TyuIOgtaGh0ELgUAG6N7gL/ekPXwQUQpxmT/BHPIPfeDqPNNs+6tXwP/d4c1vbm5/gD4Zz3rZtkiQf/ehHf/3Xf/33f//3f//3fz/Lsh/+4R+ez+eDwfAHfuAH3v3ub/q//+//z9e+9vK73/3N3/aX3n/37mO/93u/96lPfeozn/nsyy+//CM/8iPPPPOkN4r45V/+5T/6oz96/vnnAeDjH//4Zz/72bqun3vuub/+1/96EARaa2st8iPWP/73NGYSHXi/dgagAANCaUhYMo5xpgQDMNa5g1eURSRARpzTn288gkcl3P+qhwN0gL6PDQn8rieEQOSWECxJBwGhIDw+GQ6GOwB+mRDnTogWwEtJNCMlhZ/xKsJQO2eN4aEiIsYZEBltOrAkiHPOCAGBI7MAVlsumOOoDUMhgctGm64tsWc8kBgGFqzTvTGub1opI1KBjBJjAEFYTQbAMAQAcsAQHfufTMMAAAgEcg7M2AOcctqpQKFE7+gphTDWOuscMuDMOYeMOSkADtap3sXWOVf1GhkLwpjIGWMRgTOOgAyl31WUULrT1LssT3utAZ3iote955O0c9ZaTk4JabuOIQopvdpdCeFAmL5Pg0B3GhlEDJEQHXEAJOBEDhxn7KDXJyJHjMg6G0ahNRYABOc9aWctciCtY6VCzp2zEsFYqzhniD7zBQBEbi2RI8ZZpGK/yJ1zZF+nMTncGN9AkYIAHXDtiIADgHOcNDBikqQiKR0PCQPHhSWrNWfMF5f/NCmnj1He8sUYo7X2YYFz7tEqInZdFwSBh8LfyI3AOT9xwM65E7H3aEHMgHMIziuEERBAAjCAgFBZcA4BBIFwXmX5+ouCj/zzkR/o67lE/FmCCHwIZw+vffQLQQCC11W2v87TEAk5gUPdCddziRqtdT2QJSSLQAAcgHtpkfuGMpz/hQ88DkvzPXCAwAgkgQIAAO4gNJAQpB1FDjQeRm/8P1GNfPPDOWeMscceO/+rJ4O3220YhvP5vCiK9XqtpIzC49Bjxljf91dXV13XZVnmRRLkiPlpL95VG8mRc2TRkSfhBTjJAAXXDCrSWnETqNpqi7ynY36AzOJhg+f0DZSp0RGwR9nfY92cOXLaWCmECpTRGgzjGHtRmXOHPJQzj+QACRwdaSpkjpw1RkgplTJaO2tRhg4RnOMhR0BrLRDxgBtjhBBc5l3XaWOkigQXjryAG3utGWMEhBxYlPpZtShDZx0G6Jt+ur6TQiKAcY7J0Af+w9CjCArrOGdA0Ouecy7i1GrrB2xubY9JxoABkZO+eRqP/e9gkREhYxyArHVAxBEZPoIvj/D3G7nRLENGIBk4hEYgAvQAtbUFh2kUqjDSiCV3GMqexUwyjuisdX6AqXNIwBjjiF556QCMlL11DJEzro1FxjljztGjXyIB+DSKDSYbZMidbvswSZx1EHj6jQxZKeOpUoaTYY4IOmc1OsMJpbAMOqCOUyuhZNZYJ4m+sTP+hh7/sxrFP+XdCBHBMdJADNCSk8Y6a6XDCHgGMnUs6EzbdMzRo666nmR989bi9w9PsvqbzRcE33QWD3V1pwaRbxx/fF3291HFxelpp8fp8Mqy9H2+i8XixRdffO655z7wgQ/sdruf/dmf/eQnP/m93/u9eZ5lWSaVHAxzIrq6unrppZdeeeW11157zVhjjGEM0zQdjUaj0ahp+qqq27YtikJK+Rf+wl+4vLx88ODBfD733QyccyGlJYsI6NDrHE/wl3ls6IgRMQIOTDCP9NAA1MZoIB/KfaeWBSQERk79efAXARxA87/wbiF/7GSA7BEeaQQFzBrbkWuVEEgMEBB6RlqQ4aQ5GeYMEHGmObXcmYBpTgTA4xBFvLOaHDHOAQg5HnV8iB6eSnJgkTEHlqxjAhTjDBk4IqDeaAikCMNWd0aIKIzJMsfIoCNwXEYSGbWGM9Uhq5goRTgfzjYOdugMIwBw4Hw94+veVN/gZZEoBeJhqyUgKWpgzjqhUuucMUawABA1EnDhjhvMUbqN1ljGhAiEMYYsCeDMWWQSEZ0lsk5ICQiaeukkcqmF0kZo46yjgDEHgbMOrEWUUkW1tbrSiEpJZZ0D70zPOTJe942SYWM650CCHxRBAhCIBHDjnHUICMiQM+73ZhRYadC9DaNQ95pICBmQc33fcSIplDFaKkmcyJGxFoAJoRDROgeC+f0dnWXIiMiRY5w9yn54lPeNECIInDPWOWKMI1HvqLHGATIhGPPqcgPGgLFIgOywK/0Zak4hhA9NnoTDowmMlNIYE0WR//Ub1P6e1MP+JV5h5fljzrlnmg8nwthBSMSQIzKgQ4IIaJC1yI2QzJIix78BxuHrjof7uqLhr8df0Jv+SK+n5r/+0wywRgjBmQNA5wAMkkPnCLBnvBQy6IwFEsDsgX79cx/f+NL783dSPPyDIRDzpfqHf0QAISyXYJXh0vFvVGH9/8fjzYIKpRTn3I+t8OWCtm2llGmalmW5WC6GgyEiGmsEIvrxGL4zbjqdSimvrq52+72QAg1Za0Eick5AxmgpQAByB9KQtCSs1QCd7azA87fcG02HzBlmnUDw1J1j6I4UjDsQa2+oM/jH4VcCB/6KPvyjpx6B+QFCQACIwDgJJOlxLwJyzo4qA3q0Suv7Hg9p1hEQIKAj5/w3xxDhgBIEF0CkteaCgxfa+4FViMCQHDlrkTGvZIDDdfejPeFYBkI4vpuP+cjYsVbw0GOOMeYOiAd8e6wj8rUh/tBMkY6GTAgMgFkgZ/xcUSGIiBxwzh5JIwEAHwl2f3plhgCBhEXpyCH0nAGANMB655KgP8ubrhlMhm9597tCSxVzDpEx9IN5yR5Gm/ikyAcXx5wRxqG/3IA+DNHxGcevGwGBuNYu4JIBoCUidxgMw1mvDZO8N1qEgZxO+q/8sWGGGHeMnCKQYFEbMiRQZlF6MWHWRI4kwTeyaL+Rh2dKHPt6V+7PrnL9aW8HjBw5BAQnAVVn8uFY5RlxBgCkDWorLSlA9nBqw8NukjdvDFprv53c3NxsNps4jqfT6UluC0cpwunm949TqdHTJ3/u4w2f+2ij2+lfnX49hR4i0lr7MpP/4yc/+cmvfvWrzz//fBiGfu6OEIIIjDGcC61N17Wf+tSndrv9//ET/8enP/0/Xnnl5SxLEeEzn/1MnIQvfemli/Pbl5eX5+fn3/RN3xSG4e/8zu943E9Efkh73/f+YPw6PNn0MyB+zGUQDhbwBsgyZEmczWciUNwacWAyyMFBN0sIzBH/BnIqh0dsAd/YvfFn3kJIKCwKhxbBizaQSBBxYtaQRAykhCyhULVoDXeGG821ZdpwbYFpsB328SR7y194a1DW2PcO0KrYMnG4EwDYYdjKATE45xhngGDBWrKcMcUEOEJHDNE5x7nQVgNDQjSOEAQCswx8B7MAQkNoQaqot64RXM1vrTs3e/KZwDYJkA/byNhhz8dT0D/kwsfQ4LeEAzF2WsvHDRXQCkacI7fOIgLnwhrjHEkpCcgYyxgyxi2Spode93AAZ4e2dYY+aBE6EAimN1xwwbl1jshxxp07FDgtedd0QnC211xwzjmRewSlIGNorSUCzpAR+tPMgQzQkKHfkgTnDBlz5IwNhLSIBsD5ciUCADh3yEiN1ioIdd8rpYgskHVHu35Ezzk5AuJCMO9r4oCQLPaE9gQvfMJLD7HI4Y478pwn4EWn/ztSEggAwqECZhwxKZmhzpj84hLToHZ9BxqBHLPELHDgklvjfE35zzA+8wSttfbLX/7yH/3RHwHAvXv3nnnmGQD4yle+Mh6Pp9PpG4S8r1sOX6+o7R/+JVdXV8aY8XicpqkXejLGuOAEx6HGngPzUR2gB6iQbaWsQ9U6pozjhyvy8PZ7hKV5/Q9v+PPXfTwKZx4BOKdDgSMCed1L8AiJ4eHy0IgLKVygrFBEaLUGRKE4gGx4sAyjzkJAJAC5s8LRI9zxmzCVx0oEAPz1nwpwGIrx6KtOEoZHAdrrz5kIvcEGMYfOooe/JP24FGQWRMd4SVqIoCXWG0NSnCTa/0/QwI++py87ID7Ml3yllIiGw+FXvvKVqqpGw1Ecx9c317rXB/bXORcEwXw+Z4xdX18jYqgUE0wbwxlypRiA1Zo7CICHCKZz0qK0IAyEivdk/vCFzySBEoACiIHjAIiM2KlIhw7QMECOCGidJecAkSHzLZhCcKKDgJ08IgVwh333QO5yIYDIOguADBg5gaDYIbw+vKbIDuzFgfpyBAje+tpDAUD08Z0hssN4aIcIwA6Npc6R76n2R4gIzr/QETJ0jrjgCOCrNng0hSLrHDnGOTsRpQfg62fboo9l7Nih7r85d2hpf+jk4j+OIR7P1yEAY9a5lh+oFGQMnSMih4gOvBCTAx68shlnPmh6v2+vJAY8xhQCAGDOSYuKcUfQggVARYz3jrS82d4vX/pcJsJhBdwxHYUW0fmTxSM9erzn2OFvxrCO0AIC4uFD/bmQIzhaizgHAAEZBtCJAwFFzhjGBQFZ61BwQHB1Xd//6s3Va4I5QGCCiIzgh4YA17frzfLW7TM5maAjYtwB+SMCIjhCtBNoo4N9+ENw+ejiwaNDOAI6JINgkE4g8lFs9yg2hUci8pvf85F3Z4DcIRBZ5VxoMFXRVVevTNsLVqPrODklmJWAp2jzRkr1zav9D//wD3/u536OiPq+f/zxx3/0R380jmMAGAwGu93OP8dXfHy6pZT6L//lvywWi+/+7u9O09TvTP7lB3dJIg9e/9xY8+gR+l/93nOqbEopfSJ99+7d7/7u7/7FX/zFP/mTPyGiNE2///u/P4qiwSAPgsA5N5/NBoPhfH7xm7/5Xz72sV9ommY6nZ6dnX/7t3/7Jz7xid/93d9ZLFZve+s7PvjBD97c3HzsYx8DgNlsdnFxMZ1OoyjyUN45J5VyjMhYeISFYL5hzBEAIUMuuUPQjBVkrsvi/OmnXd+hNYoz8DoSQEIGjDkkZx0CMYYA4KwDhIdNG8cbjAAckeXYO4OIvrnn0evzaIv6cbk87JF/9OY53F0Eipiw6IAcEiIcyBULyJgFJCmNUvf32545xgHIkNVAGp1G5JLDenn1+7//uxFg0hlurUPVst7yAOCwPHxFgDEGCN5FH8E3dTgLjhEILhgA+RE6QIxzYy0BMc4tkLPkmOcvwWtXyVh0yFhrkXUMv/qZzxghZsMoGY96MB6KER6hl++YYb5g5Z3w4eBcQUcPZoYnm2Z2wHNAhiNIzoWfg3VIwgmaQyQEAu90jgjMMU7OAXniAY4hgHw9FBlzSC2QdQ4RuddxHavRp8mLfvdhQNb0AMA5Q/T2xXRItBwBERcCD65uPhSi8XpWIALQR9yBljpAC2jRC0zw6AR3yLMJqAMkiHvGnbUIlnMkRxoBEY2xgMCRef2gMRYAmEDgIaE9xQRyjr7eZIFD78UJJJHPx08X+HAHOuOXCiAybgCIdqx/9eWX1rbUrEOODsEq6pkWRhsD1lof0v+0MOU1CV/84hf/1b/6V554+/jHP/7888+/+93v/vjHP/6t3/qtl5eXSinnXNu2QRAIIXyvkte0ZFlWluXpU3zG6+NVlmXGmC9+8YsPHjz4nu/5Hm+Sc/BEQ2SEAoF7+SkiIGnnHGe9wjaNpt/0jn4USTSWse64MXlUwDwn9egaP3VQHOgqR+ROg4gPK50xcu5kI0FEvlDsx3k655yzACiEIOd6rQU/aPgPSemRX/Nnyjl31jmiiDB769u0CJxjHEigYNaZnsFgRo89UVSlDhWhw15LIo7IGbfO+jc5gVq/khhDhpyIHVsPmSMHj4yi8DCGMUZknfM7uL8G/rz91EafPJN1VjDBSDpHmgwhgW/gIOCAlgCFasC1zsVPvuUBd4qzMAyrstRav/jii+Px+BQGtdZE5M8ajgVGL+b2cPlkMXRqiTl+C3Tqdzydp79Drq+v/X0ihTztcVLKKIr6vt/tdnEcX15evvLKK3XTSCmF/+59t4pz7vr6mjF2eXkZxFHRNAEXQRS05KwlybhCZNqAs2iAA+cofc5gmu5Ln/88A+BA3ANWa4EOFIoDBEA6MDQekTxM0KxziCC4IPD0J0PiXvr5KKhABMa5Fxtwxo11/u6FI9TH15cBEMDTX3gkhx6u1dP7PvJaHwnoAFcPmA7IF06QyJ1yJA80PVdxpJvh6xCQB13ysfbiYw8dj+H40eQcewRSHsP1KVf3LwGGxJzGR3U+x3TfkjvAXwBHFgA5977zh6DgrH146nCkXHxbIjICMggAwB0GxFDJAnVh+5CJgZNkXHvsJzqdIfP07ulICAAtgPG0EPoLQx4tHInDA8UOjiQh81eYnQ6IABAI0Xm5MxJDy5llxiCXAlEQUdcrSyFhsVj+j//6X7+kYmpaB8wFgd8EHiUpHwIMBN+j4bel4zf7CGlyvNqISEDWT1CAAxdLJ/ACRw/rRxLt466Hp58PRYZDCPGFAW6RiJy0LiImga1df1XuQfAoCkhJzZnjwo+rPsGjPw0BJ0nyyiuv/Of//J89uHz11Vd/8Rd/8dOf/vTzzz9fluULL7wghLi8vAzDsG3bBw8eGGPm83kURa+++uqrr77qVbmLxaJt2/PzcyGEd0A8yf19AH1zK/fpSB49Ql/H9PAaAHxdEgB8rDHGfNd3fdczzzzz6quvaq3v3bt369YtrfVHPvKR8/MzhvjBD34wzwd5Pn7s3hPG2PF4bJ2dzSZPP/2W27dvt20dRXGeDweDwUc/+tE/+ZM/sdY+8cQT4/EYADzcBwCllDbGNw6euF6/r1vngDEAZhkAUOcsCL5c7379N38riSKwlowVgh3ACAAgOmDOy3m8GuKRRX5Yoacb43hP9MYgQ8G5ewTg4hFL+XvjsBbgEIvgTUjLP4eTb4Yl37eDfpu1jjNuiRwyFqhtWfb7vXIUMhEhq5xLhZS9tQDVZvfZ3/+9wEHYGu7AMmFZYEAcISjCaQz0IQwf7lvnIzQBAjFEdABAXjCGR66SwBkghw6AGHjQiswR+kY9JjRgbS1J/pWAc7RAFjyj9chaPICwUxA+srLHi4OIHgwfw9shVLNDNfC4sPGRFXf4syPhUMAb2wDevII0UovOh3b2OqXA4XAPUQKAEQFaoDeGTg9bkAC59/Q5npzfKfz7oG/WBvRjWAgImMUTGj2ECuceDjvHw4xo4EgMHtIch3TgWFZzx6tDSHScJ30kEYmQvY6hpIMEiB5+DpHzM9sOfJAvgXJyCI4YAKCwAIAdg60zQsooVrbVxlki3wONnB1GOf4ZWXoQBNbaz33uc1rrn/7pnx4MBr/2a7/28ssvP/PMM/fv33/ppZf8SIKnnnpKSvmVr3zl5ubGWnvnzp3z8/Orq6ubmxvn3BNPPFHX9c3NDQDM5/Pbt28bY373d3/XGPPqq6/e3NycDuCQwwMwQg6cHRwgAJEcWM3ICRHfvf3uH/jeuK+AuwrRBiEi7/qOyEmpAMAYg4wdKBtfPWBojbHWSSkQmbX2iICP+wDD40bPrLNEjiFHhgTkjGWcIeNGazj2//kCLzK01pFznDPGuE8VOD/IGhlwhsqEUaGUtcCZQMfIAePpU9/ybU8++TYGhiR2ZMj0IWMMme41AHi+jIA8ojDGEjnOOWfcGgAE7pNWrZExj8gdkThCScaQc7RknXO+1gue9QPw9SIiYIIDAVmG6B3SHRFxxiTnRNRpzYUyCE3f8yRRt29joJqmYYyNRqOu666uruAIWD3+9qSJz3w8FvUX6tHu7dfv7PBobd/ne/7lXsGbZZmUkiHa40f4b3a9Xvv2ttdee62qqixJxYlBIaK2bdu2RcTpdGqtrevGMiKBrnfGGBmqADk1jbWWRZKHSY+8QmQiIEEIxiuO7cl205MnB0jAAMjLuf0y9v/xC/JAAxMDAOEQkSNxcic0cGRPAblljgQAMERO1jILqB8WGvAQAR7l7A+X74hNT4EVwRNDx4PxiRoCZxwArDNEJDhngF69in6I4iF0+bk35M08nLWOHH699lXyDaaIRzh42IcOxIY7HI2nFh4JW0hISPRwRggAsyAcY4902vhM3QGQt5aHh0NGmWWHhM36uChO+8DpahGiQ7SH/IABkGOkHYBxjPOYheBc50gykGj8kRwOGwj9Zz96qo7IEUMOx9zmtPN5koOMD99owTjwfZEHUQocmu58jdV6ShuR0AGCNAY613PgCgRaCEF2htXbtjYl0xpFoJE7xvzFROazqxOdcyLZyftpAB24HP/zcf97uCGh8+JR9LecPwm/iuj0+/E6nn6EIyryDWnewdcRgQVGaBEIiINrHXGEQjHwPTfAOXDX265u6TjSEv9M8cMpb+77vm3bt7/97ePxOAiCxWLxW7/1W1/84heNMc8999xf/It/8eMf//iXv/xlznkYhn/jb/wNL7a7ubn5jd/4jeVyWdf1Y4899sEPfvDXf/3XX3rppXv37n3Hd3zHeDzuus4n31/3cx89nlMI8/oqH+NOjSyexWGM3b17986dO/5na60Q4qmnniJyxuinn3mGIWtb/fZ3vB18/yNnTVsB4LPPPmttr1RojLOWsiz7pm/6JkT0+8eTTz7JGKuqSkoJAIx5ibXnJQ81agYgpGCSWw2dswIdSC6YQE11W7e7FpwDcpwxX9IB8EPDARBIgAUyziIg46fJc/4ynCQ/gACC0FnDGEPG/G1/SmX9NTpgx1MmfMy1fTw4pOXHbNEiI1/d9ujKX+9D1R6NMY5IBirlEem27UlxxR1jFhVyx8Ay6qyxDpAFyIAToTMC3TGFRjjs649mcECADt0hWh5zUX+IJ/YLEYkcB0eMGDv6U4DvBGbOOWd7yZhEcobAcARxgPp+pT/M/9npGhz0Zifa7BBejgT5wWmfEAG4tk47cowhZ8LbdzBk8OjqIA/ykA4pB9HxLN5wJzMkRQT8YIp6QOCnqo4/Ov81u6+v/2ZEx/BwqFL6Xxgc4S8QkX9bIEfOx0B2CE7OHRR3RMSP2cWjZXbmbbyAOOPI0D10KSA4UA+ekeEIHI74GD0mOLEwx28YHTECIF/j8ncCY16kh0gA1hISECeHxjBkwLivgTOQnCnORW+VYchRagocCs75sR5yyoTffJWISAiRZVlVVb/yK7/y7LPPPv3009/6rd/qg+SnP/3p5XL54MGDD33oQ0888cTP/dzPMcbathVC/NW/+lc/8YlP/O7v/u53fdd3WWv/23/7b17YkOf5D/zAD7zwwgu/+Zu/eXFx8eKLL15cXDzqpIaICIyQMST2MBUmLgVK2TjnApFORxayRteOKRUPjLHUNEqpMAjargOthRSMc2ssEUklyZEzRgJwzpwjdI6zo5zxJHFE5L4vQvcEIIUAwF5rJPL4yuoeAaUQTHDQxq9EtI4IpBSModYGERlDYyxzVspQRsm+19ZpwSUzYI0FAuBBcHEruLzEgFnpFFhjTICcCExdCS7iJNa9ds5xwRHRn4WPTkYbLoQ4YE0jpZBSNm1rrY2i2JHru05KyQXXWltjPClrrAWrpVBCiq5tAdFTG12nBZeCcwJrrBOcCylb3QeIQkoCVEYb50AGvXFN00RRlGVZ13W+8AjHLfVE6iOiUqptWwCIosha65n+k78HHCE4HF3wvFLAv4MncH0zDBEpIf0Wf+pX8aLBMAyLoqiqKs9z58n40/1a13Ucx/P53BizWCy6ro2S2Bldtw2XSkmJne17x4SwQnXIVuReczpDLgiISFvHkHHGfEjz4xb9ZsR8ecs6Zhxnh9mn/nwQwfnRXYd16/EIc/Yh6PRMMTI8KksP5IklY20Hp0hzDENw/B8exRUndvjRNMIXH7y4gQgsOWAIpj/kfNYyaxEOGwYDZIwxQEfOnurUWp8wK9Kb4O9hcdDpMKxzDNABMWSMMWftGxQaRz6UnHN+RfnoyRgKlL545g4w7ajqYUDeMskezo75wu9hi33IkZzodkR05Iyfb8m5dc5oBwwk50SWrOEkgDNtnCMTMFDOgrN0lDW7R9/0aOZCDpEEOzBWx3+HAICCMyIy1iAi4+DQEjhgDwkJZAgO6PA7AeJhcTDBZdAZu3dYAG+YKi1qB60GjQ4tMccFMaMJ2GGFHH0oH24wXnrhMYm1B3E2w0NlgCEjcgeIYy1DJhyJA2hG77UJcLjFHDkC53sNvYbyyOQ5PBLc1vmpe8gZOiK0vgwKgOAANFkEapkwUui2jVpttQ1QWWb5EV8+yry+eV/puu7OnTt/7a/9tX/37/7d3//7fz/P8/e///3f933f91u/9Vu//du//UM/9EMA8NJLL/3Jn/xJ13Uf+tCHtNY/8zM/89a3vtWDVO/88uEPf/jll1/+5Cc/eXl5+YUvfME59/zzz0+nU99J9mfA7ke+9iM1TsQ57/veq6d8Kx5jzCt9tdY+o/aR6yg5RSGYtbZt20AGJ/mg1hpAHkOYs852XUcERMxbhBKR7yI/dcDYo0TS+sKSbzTEQ+XHejgkuONY2b62uu56KYVEZgz0xoJzUjKyBD7OHA3dyKBGL1cC0AdLVXLeG+3hTSUQpSOw4IGEJYsHus4REGecCBxZPJRD/Lo7JLUMmQdeliyRfzL2aI1v3HGEzuMUdEiGrOCSEzd9Z3RLXHbaFXVbWqyBbzvjHGlDFbOakXRYO8YAGRKSZggnmsTfXUf2GtxBVcUQj5QPY4wzZ4/X4ZFoSc7LkYEf7Vf8ay34BcbJkSMHhOgEEDAQR473kE8eJBaAHLgDcnAIhp4UZ4DmEKNOvfYH7sRBh2gInCM6SNEc4UF0BqdqNTGmiQiIIyO/QuHIwLwuLAMn4AwBwVetT7TGcfX5sYLWv/J4Hcj/nQiMMxwZZ8KRJQePpBMPHwwRvMjkkBQ5X93yNy3CYWyEPXwd7JGdAsGBdhoBOBNAh4IeHmfYHiMSIkgO4LldOjDOYOlU1jr+PxEDfMOlJsSODAAIFI7IgHXgLEeDxICsQyDokHoF2vS6MYiq06Qa7Zyv4D3cSeFPeXhQ8uEPfzjLso9//OOf+cxnEPF7v/d7n3322SAI3v72t//QD/3Qv/23//bzn//87du33/nOd966deuFF174xCc+4bsannzyyY985CP/4T/8hxdffPGv/JW/0rbtL/3SLxHR1dXV+973vueff/6f/tN/ut/vT/cnPMyrEBj4PlI8MlvWWMuxJSgJWoat4FLGtaa20UIEPEhKcpUGRKlBoGMOGQB1ljvnHAgllUbodOcchTJ0x/owATlwCMiIgQXCABF6YABgEblgBlCbnkAqpQxg13aCSwQk55lp7HxTlAjJ26RyScwZJpdV0wNxwcmQdpZzhkwQstqYEi0y7phtrUYmQhE642zEhRCGCyO48ywgIAqJiJ49tAzRoeAcGLeSc8Y4cCMCkNgz5hxaGQouEMFy5lAxBowxYkAiAACy4HjAkLckeiSrOOeCMwSSxAkRHYJmQoUBAZmuR2QqDMk6bUwcx5628PwIHXjAh7vMydPDlxQ83vXI1d9mJ3XEaZ7o6bUeBPsNwm9e3npVHt/Kv4MQYjgcfulLXyqK4s6dO5zzl195xeij9hcRkySZTCZ9369Wq9FolA9y64yzRjJUQva9Ru3iJLEMKtINZ5fPvSsIInVQjlnfiwCIvdb+88CBc44jcsbAObKOgXd+AWM1ACop4cg9u4N3mZ9RzuAIV09kiXsUIJIDIMatI+2rgqcsAY9VaQQ4/Z2cO2p8D0z+Q73EI/u5Reh1r7iQStlee3GwJ/84MM45AlhnHQAKxhh3xljnOGPIOb2pXvyQvafXTfx0nt7n3GjtU+RHhTiA6FMZr9r2x8wYk1y5HhFeB3/9YR/monkrajygM+a1Ys45cuwQdk8pB1pnDQHjAgQz1mqrGUOlpNaGESnGAVE7p7mTRIEx7Eis46PV/9dV2RiiOvQBHWlR5z3xkNFRwexjO3IHnih91E326F+DiGQtl9I6sMAsouZ89M539nF667n30raoJDnBGEO0ljMGjnHuC0wopCB36A7037jzjYZHeSs8Qr7BgWRyggsCsNZw5BIRrFfmHQCfdy0VnBtrD092ZJ0VXBzU5M4dNmMAd9yzfTGCAXKAnhwKjmDJ9AhUCySlREXp7VsA3HRGMM6OppB/xo4CAEEQbDab4XD4t//233755Zc/+9nPfuITn9jv923bPv3009/+7d+ulPqWb/mW7XZbVdVLL71UVdVgMPDuYFrr4XA4HA5ffPHF9XrtJ/EMh8OLi4vHH3/cWts0DX09G058/QOOd8JRz+2stXmeHxBtECCiZ5FPZSwPUj0HLITodRuEgbNOGy1lqLVjyAMl66ZG5nyzglKB0dZrQ71+y79hEAR93/tQ2Pd9EATGGHfUS52mEPsdQDvnOJJkIgoff/apnHHunOk74IIf5sYxdAdy7HjbgkXnh0oTkVdbMcYfanmd86tVcI7G4YF2QuMMQ+RMWGcBQApJRNpqBg/1cwBH4cSxRKCNceSUkATQgXXey8U67/qCgjugtm8FslgF6BwYg8B7zspcuvk8BP7Ut3971LseqQ+FlcgMic4vJWLMCcass846IQQgWGMOtyqR928VnHFEbY11jjEuBLfOWWeFEHDgX30DwwH+IoH3Hvayh54sk9y3owGRYII75jQT3lrBWfALHNA6a51hyAUTDpx1lh3WF3HGmGeRj+AVjrwtkXOuk5IxxN5oIBCcE4HzNsbHYarImJOsA3JE/PDFHbdJeh0ARgfSAR5CgQfBD9OD0zjx007h/+if4PXHne6kkFJIH6jfsGDxWBygY60RD5fv8BFeYX9iqk7b/OmjAcBYw9mhVg4AJ6ND/wQCIgvMMiR+iMZHcdpRfHZcAgDo2RZknlVB8O6E0OoOCEIZEtjeGGJEHDUQB4iAA2FLduf6IAhyy0SjtWDqrbdNHPfO0iOh/6TLfEPQYIw1TfPlL3/5rW996/vf//4HDx58/OMf/4//8T9KKbMse/vb3355eTkcDv2Jr1arV1555ebmxl8WKeXl5eV4PN5ut4j4yiuvcM7f/e53Synbtn3rW996fn7+zne+88UXXzx97iEuIRAiHUQ8iAiMITpiDoJQkUNrO2KAQaqdMAYwCFHKyjpjDAtCQOx9o+Qh8SAuFTlXGiul4EkKxjTOofcQB8/ccM8GERw8KD2yYIpr32WkQmddi4iATgbGq1eBhOAAqLUGIsGYcY5zJiR3zllHJGXAGRpjTM8Chpz12pJ1TAkSyjnjtOEoOHHTWOdAyAAdaytvMCeJHDnigjPkXpIhZWCtYeRdMpkzznd/cuSmM0TEmXDmgJo5AllyFhjjgjNrnTVGCsUYd9pyUIyDI+eM10Fx66yzoFQMBFb3SEwCUqOtc0oqqVTbtp6d9YSFv1Anaa9fYuZIOT9K6542GjpiJE+U+LrfqaUbEU8jVLyg3P98wmDekqjv+/nZXAixXC2tNUopcbpZPYLebrdCiNFoFKjAWiM5jwPpAJx1inOhgp6MliSmo7/4/d8TffC7JGcAZJwFBKWUsdR1PeeCc26NIeMkZ4JzZ60jACWNs34RMsHAO8UiAIA2hgEKKZx11mopGWPMGmus5YxxwY2x5JzgghCsNQgopaKjUFpw4ZyzzvpuBmcded0lY97+zGuLPWkkuLDWMMZPNlKMIZfSkOu1DpQSQui2J3KSCyAyxnIEISQRWWOQM+DcK4QI6PUEMxwFH2gPeyh3zhltkKHfUbTRQgjPmcEj82wQUQoBiFprhkeHqYfaDM8WHZCVO0ZYAADuXW+IEIRv+zNeRy+sNf76sINuiYSUDMEYK4hxxJ6sI0AOjDEHZIwJuJAOnLUksJdorVUGFBcAYLR2/oDxRKT7yqYvvglrjCMS/tv3IP7UrAd+Q3BElgvOGDPOGWsYY5wxa50PB+QsEHDGQ8mbpnYEjnPDmB5Etjfff+9tscESelKMcaZ1h4hcciZY3/UAIAPlrDNaI/dqJNDGcMYYZ75gioiWnNdbcy6MtdYYqRQc7T6YEMYa6yxnQgjhnNVaIzKlZN9r66ySko4GfJwLInfw6+D8kMNw5ixZZxCZZBIt9WSYEgwdNS13zgSMMRlVaKRqLqdaSNf2b6izPoo1H31wzl955ZVf/dVf/fCHP/xt3/Zt73rXu4qi+OpXv/rYY48tl0ut9Xq9/uxnP3tzc/MHf/AH73jHO3x79amZ4A//8A//+3//7+9///uzLPvc5z7nw0QURV7C640UHvaRvOl4fKA5Ba/T3wHgS1/6krehOG3qPtH31a7TJWKMlWURBAoAhJR9p/u+R+SAZJ1VgeIcvVMFHRhT7ouM1trr62vn3Pn5uce+D5tFyJ1ktZ7mRwDOGReM0Bs+wHQ2ef6v/SAH13DXGyODkAvR97rv+0CFvrNVcCa4sNZaZx1n6AtRB9KXWWeRMcG4c04bwxgTgvfWHBMG1EZzzgQXxhgCCIKAHPV9xxgTUlhjrbOcCyGEO2rduOB9r621YRAQgLGWISrkYK0xFhG5Ug7IWI1EkpA7x53jqCwPltKKUYp19/b3/aWB45pjEzDNgROGDoHAkLWMhJTGGGOsUhK9byPiYZqn1odarXVEFhEtkfUE4WHCBsGpf9dP53LgtBMOFJdE2BvjODLFLTmnjWBcIneke9fzg1bSAKGQR8CKnB7x2/HtuT4GImNa9+ToIOYGkFIigtWGDAVBgAhd33PGuHfUco4LwZAZo611XHDGhTHWT1Pze6TgAhkeOwuObAciQzRGE4EQHA/vYP2kbq01ICoptTZEIIQf32Ods4xzxpgPcUopIGq7jgvOkFnyeq7DBoCH7hTryHEhGGfWOme1J7e6rgOEQAVEzhw2L26tM9YwRMGFc2QdKaXIOV8CVkr5SIWMCSmIyGkjgcAY6ywTjHNhndPWImeeoThJWHxnCD9OUEI4uIb3uhdcCCn9ZZciAOe0cxwgQQ6EDelWImc8bB2rO5nFm5E0g9Qawd3B8+Hrxij/8IKo3/qt32rb9sd//Mdv3br12GOPvfjiiz7meDxkrS2K4nd+53e++tWvfuQjH3nw4MFXvvIVnx74ak+SJIPB4EMf+lAQBC+88MJ0On3w4MGLL7549+7dP/7jPy6K4lENhscxhMwiCWccIiIxQsV4yIUB5kAoAYy7Bq0llGEguDDWWG24lEIKay16wxggIuAAfg8lIuCCSUkMnTacc+uctUYILrgw1pK13BNwAL5oQ3hoNeNSkjbWOSGFYtxZy9C7uBI5J4IAAJy1KASXEhEdGQdWCYHWoXFhKCESjem1dVGQEmPGWTROEYZcMWQ9ZygZEThyoQgA0VkDyJVgROCMY+SLOsgJGfO5pePIRRAgorEm4FJI4Z31Dpw5wLFgBUDAEKUSPp/jDAHRgQPmBHo1JjkSFsGQ6zvNgEKhBJHVvWSCSWWc87SF727Eo4bNr3HGme4PC9BjHnbsM/Yg2ENbHyX8DgJHqbffVvz+wo7dcgDAvNft0RfP/92rG9IkXS6XfddnaXbgnP0uVRRFURSDwSDP881mc/XgylS9A7je1JaIx3FL+ODm2koGWdC7LulczjnjaK21QEJ6tsMQY0GorDEWQYWKM2aMBgYqjHrmdlXNmYjCwDrbd1oqP56udwJ8gG7bnisIQkHOdc4KxTnnWhvHSYYSgLQ2xEkpBZ4iEfJQP+WcSYmIuu+Zn3p38B0M/OUmAgwFEFhrHLIwCJCxtmlA+iZB0AQiTFoprLE9oApiyUXXtUzJQEptjLVWhBHjrOk7JJBK+WovZ0wGSveagKSUCND32gKFSjEh2rYFIaQKEMFoQyqQQhBBx6wUgkvZdx0xrqRyzjpLKJWSqu+7XuswCAXnbdtqsnEcWuesc5xzzpm21iNpxnlvPPcpgcAazTj3hQzDkCnJGTfGOIZCSGRonUPOY65027edloFSQWCsabtWBUpzSb0GAhEGDbpa21gFgQz6vuvRSSU9b804Yx7jkuOMIwNtjUXHBJMcndOOgZAHZC8k51xorbUmJUPOhCNyzIKQROCNy9Mgtta0jZVcBEo50/VkkyzTzlVGt20dqUjlkdOkZegktrrXwslQIQfnnFMB44wx3vcaIy6lAAcOCEh5ZTX4MZvW9l3PBZdCGOOM6b3vn7VWGxYEyjFsNDoQSkpkzFkLoDyCp/CA/Lq+BxCBChB9g7Ovs4BzNghDIGiamvFASWkJrHWAUirhTE/MJVJhILqmTwBFFF9XOyKkumt0xw4OIuzRovMbNhXfHYKI/+yf/bM/+IM/qOv66urqu7/7u4fD4c///M//83/+z7uu2263l5eX6/U6DEOt9Wq1OhWe1uu1Fw/cv3+/bduTIEEpVRQFAHgE/ObPPR2MtXa5XPZ9PxgMPCoNw3C3233sYx97+umnv+/7vo9zH3e4c67rWsa4lNJrIay1n//8F77whc9/z/c8r2SAiIIra603QSNHSRI1TW2tTZLUWm3QShl88Ysv/cmf/PE3fdO7X3rppa7rbt++7U0tfDrXNHUUxcAZOWKWtLNeEOQcOWs5MVt3qwcLQHmWRCXpghkRxDVCpw1KGc8Ge23auuFMxWHgLBmtuQiAM601MqakdM72veb80EpsnWMsRMTeGA0og8AY2/cdF5H0wKIHIUWglDGm710YhoDYNS0wEQaBI7KHVFcQkdaIjDVSGmPI8FipjkC3PaCUUvZad72ORykD2lW1QJnKwDlsLDSB6J2REmUiHSpSYm+6HlyoZGWx73vgkilJyIzxZIE0RmvOoyAEBG0MCyMpZaF137VRlEkh9mVhnAvCgHGujT50aDhABpxxjsJq65iJVMCR694YoiCJjLVt14gwDqW0va11ycKYKTTaAAZC+MlkRqpIKtXWjTZGSSmVapoGvUSbsQMrAghAXQ9KKSmV0dopIXnAQFijSYkgCJyjtm3iKAJAa4wjJaQEIDIOD230aK1DFQopTgMXHB1akYSUFqntOiGFlEr3vXXStwcZY1wYSCkYsqbtOHKplHOelzpMcIBABcrXN1rDeZzExpreGCkkIpheA0AYhI6clxIFYWjJ9p2WIpKSW2OMEkIKIUTf9YgolbTWGaM5j4UQWhtrnJSKMdY2jWEQxwljvO87hIBx7ikElcSC2bYuGPEwiY01XddxHspA9bonAG8B1mtNwIWSAKCNZkwILqxzxmgpUyGk7vtesygMlQjromLAAylbB9ZYzbmLVVmWseDZYNiTveort+nGLLGNrus6yzIv6H+0GH16+AEC/9v/9pf/2T/72b/39/7edDpdLpff+Z3f+da3vvX3f/8PfHyIoihJksvLy5deeul//I//UZalt00MgiBNU631Bz7wgVdfffU//af/5MPXX/7Lf5kx9su//Mtf+9rXvvjFLz799NP4evGxL8QQkUWGSJyAAfRdt1uvS2OCQFpkve0q04VhIkXftZ0/DGRYVZXgXCpl9LGdF6FrO2QYR3FR123TImIcx8YarTUeWs2A6OBJ1TStEEJKobWx1sZxjIjruiagKIwQsa5rIbiUylrTdX4ymf/2TRxHfd30fU/khJRdXTdlGTAMk2C7qnvrkmTQ025fV4yxQRRp3e2bkqFQUewsdboXnEupet1Z66IoZMiapgUEyYWxRusuCALG0FcCwyiSQhZF4cglcUJEWvdSBowLXxUMlAKCru88guKMtV0LgCpQve616VUgJeems4yBELJzttW9kEJK0eqeOh2pgClVFHvrXBiGztqmbaUQgQo63eu+VypQUmprvDBXeKR07Jz2imGfRJ2e4LNBn795+kNK6SuNJ39fRAyUMtporcMw9P3Zi8UiTdMgDK6ur6SQs9lsv9/rvj/AX7/jZlk2GAz2+31RFL/1G7+5Waz3m+36ZjEcD8M03RW7oiry0ZAY2+02Icrz8aRr2+1mk2V5FIWbzdaRy/MhAGw2mzgKJ+NJ0zaLxSIMw9l8tlwvq6YajyZSyvVmhYDj8aSq6t1uMxgO0iQty6oo9pPpGAE3mzVj/OLivO26Bw8eDAaD4WC42+3KsszzLIii9WLFmciyrO/7uq6jMErSpCjKpqmHg0EYRev12hozPzvzmiGl5Gg4art+v9sGQRAnSds0TdsMhyOGuFpvgijKs7xumrqskiRJ4qgoy6os5/O5VOrB/Qec88lkYmy/225VEERhuC8KrfVwMORCrNerQKk8H2hjdrttGIZpklR13TTNZDKJwvDm5sZYOx6NjDFFUQghsyzte10URZ5nSgWLxcKRm0wmfdft9vsoikbDYd00ZVFmWZak6WK56nU/Go6klNvt1hFlWWqNrdsmCAIVBPv93pl+MBwgwW6/k0oO8oGxdrNaJ2mcJFlVlXXTDLMBZ3y92jLE8XSi+36330spx+PxdrfVbTscDIjhZr8HgrPZvOu65XIZRdFkOtltd/v9fjIZS6U2m42zLs1SRFytFkmWpmnStl1VFmmWxVG83mwY4mg8dJbWm7Xgcj4784lWGMdxFJVlWTfNIM+5ENvNhgim43HXdftilw4SGYXbct9ZMxgNQxGWV4sA2GA81mTuL665kuPxuCmruioH+SAIgv2+MEaPx2NtzH6/j6MoisK6bnrdD4cDzsV6vXLGjadTcm65XEop8ixv2qZp2jAM0zTZ7HbW2iRNnXNVVSmlxuNxsS/2xT7PsyRJDzfYcIiIxb5EBlEYGuuqqgzDMM9zf3az6ZQL8drNjUjiQZabtuuKKpbhZDQq6mq9244HQxkGi+2KEYRB+K6/8NyTTz55Wtg+qbVvmodkrZ1Opz/+4z/+iU98wlcGv+/7vu87v/M7fR786U9/OkmSD37wg7du3To/P7++vh4MBj/xEz9x7949RLxz587l5eV8Pr+6urq4uPibf/Nv3rlzZzqdeiMhdnQF/rp0jsflQojVavULv/ALjz322I/8yI94pO4x9Hq93u12TVPv97u+7zebzXQ6nc3mWuvXXnttu92ORpP5fPapT/3ub//2f3nqqWfOz8+apq6qKgzDNE2zLCOC115b+mt4//79m5ubLMtu3br14osv/Pt//+9Ho+Hdu3e81nq5vPna174Wx/Hjjz/OGF49eKANlVUdKHl+61JIAdYggpRSavr4v/7Y/eub87OzvmnW62UySNIk3Zdl27V5mmb54Obmpmub4XAYqGC9XiNjo9GoruuqLJM0VUqVZdn13Xw2M8budvsgVIM8b9puvV6neTYcjtbr1b7Yn83PENlyuRSc54O873VZFkEQ5Plgt9v2fTcYDAOlbhYLxtnZ/Kzrut1uG4VRnCRN09Z1FQVBHCdNVTVNk+W5kur65kYFcjKZlEVRluVsMg1VeLNaNM6c3bqo2rbcF5EKsiiumnpflnGexlG8XW/qpjk7Oxcotput4DxN067riqJIkjTP8+122/fdZDqNo+jVV19DhOls1rXdarVM0yzL0vV2q7UZDYe97vf7fRgEw9Go77r9bh9H8XAw3O/3+/1+MpkEUbher62xw9GQnNttt4Q0HA/brt0X++l4yoVYrZaIOBwOtdbr1TrP83yQF0VRFuV0NhNCbDYba02e5YCwXm+CQOV53jZtURZpmsVRvNvunTV5PiCgoig45+fn58vlcr/fD4fDPM/3u11d1ePRiHO+2WyAIB/kzrnNZpvnWRAERVkaY9IkEUKsd1tkfDQaGmNubhZpmkynU39GWZYHSpVV2ff9IB0gw7Io/ME3TVsWxWA4EFzsdjtkOBlPrHOrzZoLMRoNu67bbneBUsPhaL/blXU1HA6VkqvVGhEn41HXtvv9Ls/yKI6qqqqrejQaccE3mw0ATCdTQLi6ug6iaDAYFPuiKIssy9M02e32xpjRcGis3e/3UorZZFIWu912641vHzx4YLS5dft23/fL5UIFQZZndVVvd7ssz6IkLoqi6/rxeCSEWC6XSgXj0ajt2u12l2VpluW7Yrfbb+eTqeKy3u17o9Nh3hMttqs0jqeD8Xq5KupyPp8rUMub5e07t3/4h3/Y1zB9KeYNebJz1pj+ve99z9nZ/IUXXnCO5vOzd77znX3ff+/3ft/Z2VnTdO95z7d0XXP37t1bt24tFos7d+4YY0aj0Z07d3xJ6oknnvipn/qpF198seu6d73rXbdv357NZpPJ5JVXXvmO7/iO2Wz2aJBEREaEQM4ax1CARARr4ZO//ZsvffFLxrnpdELarLebOEuTON3vdk3TTkajIAx3u13f92dnZ8aa5WIppZxMJkVRbLfb8WQcR/FqtXLOZVmGiLvdNo6TOI7LsvRpQD7IF4uF7vXZ2dw5ur6+FkJcXlwUZblarXx8q5u62BeTycRau9vtGOPj0ajru/V6Mx6PhsPhcrn05o9CyeV60fXteDRG4DeLdRxnw8FkXxS7YjeaDNIkvL56BcBeTuem7Zar9XCQDYej/b4oin2eZ3GUbHe7pqmn0ykQ3Cxu4ijK8qyqqqqq0iSJ4qSqqqatZ9M5AFxdPUjieH52vt/v9vsiS9M4jne7fVVXg8EgDMLVZs0R4zjWxjRNE4QqjuOqrJqmGY2GSgbXixspxXg81lqXRREGQZ7lm6pZFvssG4RKVWWltZ5MJtaY7W4bSJXleVVVVV1ng9yL+ohoPB77W9Srdauq2mw2eZ5nWebLm6PRCAB2u51SKs9zX/D0or6rqyut9cXFBRBcX10jwnw+909wzm02m+12yxk/Ozsr9sVmtyUiLIri9u3bu91uPB6fnZ0tFgvvgmSNrfclZzxLUgtuU2wZZ8PxcLPZ9l03Go6VkLvN1lo7Go201uvtJk3SNE3bti3LMssyJeW+KKy1o9HQOVquFkkSj8fDzWZTVfV4PAqCYLVaO0d5lnLBt9sdAcxn06qqyqrK0iyKwu1ma4wZjUfWuu1mI5XM87zruqqs4jQNA1WWZdf1eZ4JwbfbPQAMhwOt9W63S5IkTdK6rsqqyfNUSrHfF9bBZDzquna/36dJEifJfrdv2nY4HCoZbdZrY+1wMOBC7HZbRzSdTvu22+13+WCgpNpu18bpyXhsjNlstkEQZFnaNm1R1sNBpgK1L4qu05PxSAqxWC4BYDQaGmN3u10YBt7OsO/7NE2llLvtzlo3mY7J0XK5TrMkzzOvy8zzXCK+p8kAAQAASURBVHBRlAU5ipOYMV6VNeMiSZKu7YqiyNI0SdPVamWNHU/88WyE5MNh3rZN17ZxkvpQ3rTdcJAjYl03DDHL0rppy7JKkkxJVdU1OZcmiZCyKApATJLYaLPbbcMoGo/Gm82ma9t8MBBC7Pd7cm48HrddVxTF4fTbrizLPE+QQVmWh62u19vdTqkgSaK2bdu2S5I4CIK26Y11cRQ5R2VZcs4Hg0HTNPv9Ps2yKAy3m421djwcILltuWdKJnmmu74qymGchpyXVWXIZeOhBtjutoKL4XBQlVVRlGEYZmlijKmaNo5iLrAsC2vcZDLudb/f7qMkjuO42O27rhuOh4KL7WaLjCVpAkT7/V4qlcRx23V13SRJEgaqKEoflJ0z2+2ecz4cDZ2xRVkFUaQkL4uy7/vpdOLIbddboeRoOCyLsqyqJMvCJKmLyjbdOB3GKlxul53Ww+GwtX25L/I8FYh9r7//r33kb/34R+/evev1TL5w82YY6pUJjLGu63yW7AHoqbTk3RVOihoiOkka8JGWUzi2Zhtj/BCmsizloQxC7k8xPuv7/pOf/OQ/+Sf/5C1vectP//RPP/74497xd7fb/d2/+3ff/va3vfs97/7H//gfjUfjvu+DIPzrf/1///KXv/ypT30qjpOmab/ne77nd37nd37pl37l//w//1+vvfbKiy/+4VNPPYWIfd//5E/+ZNu2//Jf/ssPfOADWuuPfexj/uy+5Vu+5dVXX/35n//5H/uxH/Pddc8+++wv/dIvNU3jnHvHO97xnve852d/9p9bQ1yqtmu/56/8lb/0be+3uleMKYCXPv+Fv/v3/t7nvvCFpu/3bT0eDxmj7XqLjI3HQyJaLFYqUHma1k1TVWWe51LK/W5vyaVJAgBVVTPGh6OB0bosKhWqMAyL3d44mkxGRG61WIdxNBoOtpttVdfjySSKgvVq02uT5ylnbLPZCSkGg7xr26IokjSNwrCqql73SZIgYFXXzlKapWRtUZZhGGVZUpRVXTWT6Ygztl6tGeeD4cBZu93uAhVkedo1bdO0URRFSbTZbJ11o/HQGLNeb1Sgsjzru74umizNlRRlWXV9PxwMpRLrzRoBx+Nx13ab7WY4GCqlttvtKVDvih1HPhgMe903Te07ppum6do2z/MgCNabDSLmWd7rvtgXURSFUdjUTa/7OE7iOFqv1lrr+dm87/rdbhfFURiEZVX2fZckWRCopmn6rh8Oh8hYUeydc3mWa9Pvdvs0zaIo2Gx3ztrJeGKdXa3WcRSlaVrXdVmVcZzkebbZbIwxg8FAcLlaLzljw3zY676pqjhOwjAsyqLr+uFgyDgrir0xdjgcWOs2u3UYxkmalmXZtu1wMECGu/2Ocz4cDLU2+/1OSTkYDPf7fd92WZpwznf7gjMcDoba6M12G0VRnuVa631RBFGY5XlVlWVZDYfDQKnr62suxWQ8KYuiKIrReKyUXK9WQDAejow1xX7POR+Nxl3f7ff7OIqTON6XRV3XaZoFUbharzhjk8nUWrvebAKl8sGgbZr9vsiyNI7jxXIBBNPxxFmz2W7jKE7ipKiKtm0Hg4EUcrff6b4fjSeO3Hq75Zzl+aBr26ZpwjCMk9gzF5PJhHG23W4BYDob9V23XW3TKI6TaF+VRV0P5xMm+PJqEXIxzgd9rzdFEcbxN3/zN//UT/3Uc8895wm5RwOFL5U5Z4Vgxjg/A9IYq1TQ9z0i09pwzr11EmMMwLqjmetJE3hSb3vFiA+JnuTjxyEXBxOxo2Lb/+Db3zhnDJAx/MMX/vAf/sN/+JnPfGaY59c3N8boyWRKAKvNignhuaH9fi+kmEwmxXZf1mWaZkrK/W5nyY0nU9P32+02TpM8y+u63hf7QT6I4mi/L7q2HQwHSLjZrGWg8jzv264oyiAKsiyri1IbneUDBNhsd8hxPp0Wu31RloPBMEmT9WrVd30+HArO99stMcjyATna77chY9PhqKjKomyGoxkwsdvtHcFolOu+LfabKFR5HtdNW7U6zXLBebnb9tZNpxOr9WazFUrmWdZ1XV3XURTHUbjZbAy5YT7wfpeOYDqbdk2z2xWDYR4GwXaz0dZkWY7kyrIkxuMoAnJN0zIhoyjou76qm+Egl1JsN2sCMRoNdNftdlsVJXkSF2XRa51nuVJqvy+0MVmeGWvrqgpUkKdpXZV102RZLoXY7rbOkccVq81aKXXK0vM8j+N4uVw652azmTFmtVoxxiaTSdu2dV0rpaIoaprG3/AAsN1ufTGhbuqmqsMgCIKwrmvnXJIkQRCsN2sAuDi/aNt2tVr1Wv/NH/mRg5DCV3UXi0VRFN6auNjvhZKD0ZAYrrcbxth4NGnrzvQ2z0dCBPuyMoj5eExSVrpXSRoN8trofdskw2GUZ+uiaIzOppOeaFMWUZ6n4+GuqWtj4sGAhcFyt+udS8dDUHK936OS+WS0r5tNUao4Vkm8q+vaaJUmJMS+rkUS5dNp2fer/U6lyXA2Lbq2bNtokKNS27qyDAezSefcvm1UkgRZtu/afdMmo6GMom1Va4TBdNRZs9rvZRzLNKn6vnU2ynOZJLumbsnFwyEotS4KUGp6ftFatyr2YZarJF3t9wYxG006on3byCQaTCedtfumiQYpj6NdVbXWjOYTy/BqtQIp8umkJ9rXtYyjdDQq+67suyDLWBisin0PNJhNNMDNZiPjMMqz1X5fa50MhywMt03VOpeORyKO1vs9CZkMh511RduGecbjeLXbGYB8Ommt3TWNSpPhdNo7V/WdSOIgS3ZtU2s9mk1FGO7q2jAM8qzSet80UZ5Hg0FjTWN0PByIOFpsNwYhHQ0N4KYowixPBoPVblf1fToZszDYVJVBTMajHmhbVahUNhk3xu6bOhpkKk12dW0AokHeWLutaxFH6WjQWlt2fTTIojzblNWurtPRSETxuiwsYpTnldbbukpHIxXH+7YxjKXjMeeiLqqAyVE21G2/3xVpFGdx0tYtaZfHOXOs2hXkKMmyuu2KugqTeDSbtEbvqyrJ0zCN9mVlCYbjcWfMZrcP0zTOsqptO2uS4VCocLsvDUA+GnEV7MqKSZkPh1XXlXWT5JmKwl1ZdcYMJmNiuC0qGYaj2bTp+vVuHyZxmqdV12nnstHQMb7dlUzJJM/rvq/7Pk7TPMv7orZVM0kHgZDrzRoJz6ZzdFTv9qkKB0Gii8Y0HRwVt17n5LVN7E0PH/r7vvfsCABIKR+1XGCHEdnOo1s8uoufOF3/HP+EkyTXaxhOHg5v/lz/tr4dYb1e+yTnDSiZc942zfXV9bve9a6PfOQj6/XqhRde+OIXv9h13bvf/e73vOc9YRg+8cQTb3322be97W3b7TYIgu///u+/c+fO/fv3/cluNpvlcvnJT35yNpv95E/+5Hve854syx577LFnnnnm7W9/+2az+drXvvapT33KWvsTP/ETH/7wh//gD/7gc5/73Gq1unP3zt/6sR/J0vSzL3zW90AIIYjzsm1kGHSmb7tmNBoKJbf7gjgOp+PO2OV6E8ThaDqtdV+1bTIYhGladX1rTDoYgBD7ukbBB5NR0/XL1SbKsjjP1pudARpNxw5wtd6FaRKn6b6uW6Pz0TBM4u2+7K0djkciCHZFpaJgPJt2xpRtG8RpEMdV19VdH2c5k2pfNxZgcjYjhG1RhGmSjQZF03Ra5+MBCrnZ7ZmS2XCgnduWpYqjyXjsWlNv9qMoHYVJtdpJC2eDMTS62ZSZjGbJgLW23ZZpEMcqbKvW9XY+nikuN8s1BzYfz/qmq8tqkORZnDZVzYFNhxOwUGz3nPhsPBWI29U6FMF0ODGt7ppuPBwrrjbLDQc2yoaMsNqVkQqzKDWt1m0/TAdpGG9XG9ub2XhKxu03uzzJxvm4rRqn7SgbDZKs2pdt3Z5N55EK1oul03Y6moJxXdVOBuM8TsttiZbG+YgRFpud4iJPMqdtX7ejbDjKBtWuNK0e5yPFZbndKSYnwwk4aooqDqIsyvqm000/HU7yKNlvtrbXs+EYLDX7cpDk09GkqxuwbjocRypsipoDmwzGYKjc7QOhxoNx33S66QZJFsmob3qFfJyNFFe66dMoGaZD05ndepvH6TgfFttdtS/Hg5FiYrfexmE0HU502+u2H6R5GsZt2ZBx42yomOzKVjE1GYx12xe7fRalo3RQl3VftcM0HyRZ3/Sxiqajqe3tdrWJVXg2Peubdr/djYfDOIi2643icjac2M5UuzJWURomXd12VTvOh4mK66J02o4H44DJYlcEQs5GU9LWdiaL03E+6qpWcTkdTZBwvVgxh5fTuav17no1jtJpNuiKGnt7azKPHO82RSaCWT5GTeVuH4VhEASMMS/W9P+E14u1/HJ2RF5/4lFv0zSnXiUiUko65/q+9yomj25P/9aXo51z2mvmjr3Ixpiu67TWp04p/+SHEZIxKblXsjLGkbMojsM4Wm+3DmEwGjMh1tstC2Q+H/ecNtVOZGE2HayLza4t4lEusqAwrVM8n48Np6JvwmGSjPNNW6zqbTodJpN8tVvXus3no57MqtiIJEjGg8p2e9NEoyQYpJtyX+omHKZOwrLYUMiy6XDXFJtqGwxjTOSy3PbMZvOhSINtV3TMJpNhj+Z6t5CROptOu6pqy2o8HAhB290Nk246zwF01xZpqKZ5buq+rPp4PBPpcFN2Ncnh+e2WxM224tkonpwXlu06p/JpMJxte2oxiEdnViXXRWtVMjy7XWpY7FuVj3k2vt41lWVBPjMyXjdOi2R4doeCbF1qiIfp9LzSrOwhnZxbldxsGyvTbHbRgNx2TqTjZHJWWl45HgxmVqUPdnXt2Gh6hsiqslQqiKOoKIqqrgf5IInjrusAcDQeSynXm00QBIPBwJfx0zT1Oj0A8M0knmibzWb+CXmeTyaTruvath2NRr5AR0SDwaDruv1uH0XxIB94gXuWZWEYbjYbxlie5dba1XolpcyzzBv+YJqmaZo2TVMUxWQyiaJouVxqowfDYVEV96/vJ1k6ncz2u/1mvR0PJ0qFy9W6art8NHbIrh484Mhun18Uu91utRkkWaSC5fUiVMHjd+4xR6vFkgObDsfltlheLyMVxkG0vll1VXtxdsEJF9eLUIbjwVjX/Xa1GQ/HeZxtlutqX51NziIV3n/lNbJuNppV+3K/3g2zYRLG919+tdqV48E4CeLtauN6d+v8sq+6zXIT8GCY5sVmV27288ksDePF9RIMTIdT19ndejdI8jzJym25XW/yJIuDaPHgui7Ki9kZB1hcXTOC8WBUFcXi+mqUD4Z5vrq5MX1/NpuTscvrBWnKo6zY7LerbRaneZwtrm50p6fDCXNss1gzYON8ZDu9W20DqYbZYLva7Fbbs8lZrMLV9Yo0XczOSbvF1SJPsul4ul1ty20xHU5CGayul33dz8ezrumuXruOw2QymmyX6+1qnadpGsb7zaZvu2E+AOs2q5VANhtPqn21WqzGg/FsNF08WNT7ajaaBlzdPLixvZ0OJ7rpl9fLLE7H+XB9s6j2xdlkSsZe3X8gGZ9PptWuWF7fpHE8ygd1URX7/XgwlMhXNwvTdcM87+v2wWuvDdLsYn62eHC9uLrOk2yYDq5fuyLtZuOZALG+WYUiOJ/Md+vtfrMbD0aBCK7uX5Ghu7fudk1z/7VXQyEvzs6t1rv1epBkcRCWu31ft6PhEKy7ur5GKacXF/um3hRFMhhEg/xqtWysHZ/NRRi8dnPdWnN2fmk6vbxa5HE2HYzX18t6V80nc+7wwcuvgaHL2YUAvl1usihNw6RY7+pdOc5GIVeL+9fMwWO37pqmv3n1QcDkxfS83lXlej9I8jxKi/Wur9tbZ5do6Pr+tUIxzofler9fbefjaSTD+1971VTdxewsFuHywQ1aGiaDrmrX18s0TNIovb7/oC7L2XTKJL9a3XSuz8bD1vRXqxupgvF0ulivirbOB0M/xgxf7zb1ZvbX63STJPFUh6dvfRMJAHje10NbbwyMx751D3zjOPaWivhwjhF5iOwbC3wa/IYP9bJdv8343cizMidEjseH1vr27cv3vve9Tz/99OXlpbXGm1H8wi987IUXXgiCIIoiRMyyNMuyJ5988rHHHgvDMEkSf+4+6u33+2/+5m9+6qmnfuAHfuA7vuM7oihK03Q0GnkP0fV6/Y53vOO5555729veNh6Pr66ukiR+3/ve9+wzz966dQuJrNZRFPXGEGOg5LYstsU+G2aC0YNXXpXAL2YXuu63i3XA1TAdbG5Wu+U2EioW4eZm1ZfN7fNbCuXmZq1Qzkezelfulpv5ZBYJtb5aoYXpYALaLR/cBFyOs2FXNuubVR5lkQyvX33QV+2t+YUEvrh/zQlH6XC/2m5uVgFXWZjsVttmV51N5pEIFvevmaHzyVlfttW2HKaDQZzvFptmXw3TPFHRbrlhDkfZSDd6e7OOeJCF6Wa5KfbFxfllGEaLxaprusFg1HX9YrGUQk7HE93p/WY3Go7zwfC166t9VQ6n497qq8UNl3Iyna13u+1+H0RRmMTXy2VZ11GSdEbfrJYoxHA8LurqZrU8u7wcT6dXi5vldjMYDoHxB4ubzpoky+uuu1rcRGk6mk7Xu+222A/GIxT86uamN+bs8qKz+sH1dRBHcZZeL242+32UJEzKV6/uG+cms1nTda88uJ9k2fz8oqjK69UyiOI4y25Wy7pr03xgyD1Y3KAQ55eXu7K4WS2z0TBKk9V2U3ft5Z3b/uPKphlNp63uHywWYZrGeX61utmW+8Fk3JP56v1XRBjMLy4ara+XSxbIJMtvVst9WYZxTAxfu37QWzOdzau6uVrcpHk+mc03+91ivRpOJiqOFtt103fjs3kP7uWr14izbDhc7jfL/WY0n4oguL+47q2ZnZ8R4oObm96YbDAsqvJqcc2EUFF0/+Z6Wxaz83PH2dcevAqKD6bjXV1dLRdxmkdZ+mC1WO138TCXUXx/cV02lc+XrhY3Kgzz0eh6ebOvqvFsJoNguVk3fTeezVqrr9cLx1k6yFf77XK/mZydiSD82v1Xe6CL27dB8K/df9UxSPN8W+wXmzVTQgTq/s3Vvi7z0VA7e//miis1GI822916vZ6MJkmcPLi63hXFeDQVXC6ub7qqG2SDuq6v14soSaezeVVVi8WCjkZUPiCckmQfW5RSURSSo1P8SZIky7JTfOu6zvc2+QqSlzE82qd7khT7uHSKiqeYc3LeOHVKcc6lEN683zmHnEmlLLnFcrnabdI8B46vPbgPQJdn56Zq1vevsiAYxXGz3TW7/STPQs72i5Wt6lGeUtcvX7tSiPPhcL9c9fvifDgKAa9ffo1Zdz4eYa/L7SZV8nw6qbfbcrnOpIwEL5arvizPJxNm7fL+dcTZNM1MWZXr9TjPB1G8u7kpV5tpPpAEVy+/Sm1/ez7vy3r94CZTwTBL7q+XrxXbYDzAiF+vrhl300mu+/rq+gFTIp2OXtuuF3U5vTiPeHD9yn3Xm/lkBtptb1ZxEE+yoa7acr3L4yyWwfLqui3qy/k5c7C6uuEWhnFWbneb6+UkH+ZRurp/7dp+Pp5JYOura044G072y/XmZjHKBuMkX18t2qIaZYNEheV6yxwM04Gum91iFclwkA62i1W52Z2Pz2IRrK8X0JnpYNw27Wq1kkJOx+Omada77Wg0CaPowfV1UVWj8bht2wfXV2EQDAaD1Wq13+899l2tVtba8XhsjLm6uvLQtizL9Xo9GAyCIHjw4EFRFMPhUErpW6Lv3btX1/V6vR6Px8PBYLFa7vf76WRqrb26ugKE+WxujHnttdfiKD4/PzfGtG0rACCO41MNVEr52muvxXF87969otgT0p17d8bD8Xqz5Vw89ZanlQpulovxaDyaji3Rarm8dXk5zof7/S5R0cVknmbZcrXMkvh8fk4A++327sWtwWBQlIVk/JnHnwzjqNgXk8F4NB4yxheL9mJ2dnl5ud1uK+ceu3tvMBgsFos4iG6d3wqU3O52t84vZ7NZWRSKicdu3xkOh+vNJpTBY3fuhWH44MH98WA0GU+cszvnbl9cDPJh09aBUGe3Z3k+uLq+GuUDb2m8rOuL+dlkMl2tlqFU57N5GAT7opgOx9PZ3Fm76vv5ZHJxcVFVVe3o1tn5ZDypqioOw9l0Krhoq/ru5a08H2itTafv3r4zGAyWy+U4H57Nz5Dh/fv3Z5Pp2fysrMqmbm5fXKZZVhZFHESXZxf+2x1m+fnZmbG2qerLs/Pzs/OqriIVXMzOoji6ubkZ5YPxaIQMTdedTabnZ2fb7T5S6nw2i8Jos9tkcTyfnRHR9c3V7YvL8XDU9Z2S/Om3PBkotVgtkyg6n59xIW5ubqbjyWw6bZpGc/GWe48NBoP9rhhlg8FgECi1WC6mw9Hl5eVut5eM3bt9O8/y7X6nOH/yscejMLq+uR4Phv4Kb7R9/O69PM13xT6Jwnu37yRxfLO8GQ8H89mZtWa5XN4+vxiORk1dxyq8PDuPo2Sz3Yyy4Xw+d5ZKS5ezM6/sQaLH79zNsvzm5nqY5+PRyFq7Xq/PLi9Gk/G+qZ0S59M7cZ7vFguRJRdn50CwXtzks8nobEbasn3x1L0nkjSpqjJW4fRiKoS4WdxcTOeDwdAYXTfdnfNb0+n0+voqluHd81tSqfV6fT6dTyZjrY1Efufy1nQ82e13gvFn3vJUmqQ3y5s0TMYXt5QM+qp5/NbdwSCvqqrh4om799I0vVksJvlwMpkCwKbaXExno9G4bRrSZnr3sSzNyrLM02wymcpA3SwX4Tibnc2api2b/ezu5dl0vt/uRBo/du+OEJIQvRGe73U97RlveHiZnce1ROSNxvzeoLWuqsp3AwCA93/xHbWnAuVpp/HNBH3fnyzET8Ze7jgp5w0Pb0supXzsscfm8/mJUfYY2u+C3jbhRM/4vzz//PNSqn/xL/6/v/Irv3J+du7Pi4ikPMzIWK1Wm82mruuyLL326/79+7vd7jd/8zebpvF9u77OJYSIoui1117b7XZ+eM+dO3eQYd+3ddMY3euuk1xEYbTtOwBiSoDkdx+7G4fhcnFzPp1OxjNrzF7ry7Pz8Wi83W4jqe685VJJuVqvB3E2Go2klDc3N3fOL6fTaVEUCsVbHnt8PBrff/DaMEnPzy+MMYvl4nw2uzi/3G53sQqmj70ljqLdfjfOht5toy7Ki+nZ+fnZZrMVgE/ceSyK4qLYj9NBnuec85vFzcX0bDqdat2X/fZ8Np+MJ+v1OgnCi9mZknK7246zfDqd9n3vuv722cVkMimqUnfd9OwsSeLFcsGz+HI+N9ZVpr98/PE8z/b7fQcwv3M7ybLlZpOOB+PJhHNRLhfD+Xh2dl5XFUmczy/DMNptdyqLLqd3CWC9Xo8vz8ajsbW2XrbTWxeDwXC7XvNIveXOLSb44mYxuzybzGZlWTVbPbt9ORwOV+sVT8LL2+dhEK6Wy2iQzs7PrTWmrQbz6cXFxWaz5rF64u4l43y72Saj4XQ6ZYwtbm4mF2dJmjVNbTlePn4vDMP9fhcP8/FkYq3ZbLeTi/l4PKmqCiN1MZ9kWbZYLHik5nduCcHX1T6fTSbTSVXVPbqLe7eywaAoimCY5oNBGASr1Sqbj0fjida6b6vp7Yssz5qmEXHw+GN3HbnVcpXPJuPRSBtjaphcng3H46aqSLLLJ+4lcbJY3MSTwWg07vu+62h863w4GNRNLZIoP5sOBoPNaq3SeDafA8H+5mZ0Ph2ORk3dkOK33/J4FEZlVcbDfDgcCiWXNzfD89l4MtVdZ2s8f/zuZDy+XtxQKO7de1JKuV6to/FgOplobazAy8fvDEej3W5Hip+fz8MwvLp6kAzz0WRijNYVze/d9mpDkcfnF7Mky25ubvKzyXgycc41lZ7euTw7m2+2W6fb2088FobBdrePx4PxeGytLXU3vTifTCdd05q6PL99O47j1WoZjLK7s7Pe6MViMb28yPO8blpr+rPH7g2Hw9ViGUXRcDh0rzf5PqXujDHG8OVXXn755a898/Sz5+fnXddZaz772S8YY5599m1CcCG4tdxo25s+iiIfRryJIRwmkDHxeuvWR+EvHA1f35CxE5G1TnDhbV+1Mb3RxtpsOHhy/hQiLler0XRyNpubtgPtbs8vpvPJdrsTJJ587C2BChbLxTgZjIYDR7Rtt4/fup1n2W63zYJoOD+P43SxuBml+cX5GZF78ODqcnY+Hg7rpo25Orscp1m23+1tGE8v7yilFsvF5XR+fn622+/7qn3izuNRFG02m2k2Gt0dI8JutzsfjqezqbO2huruxa3z+Wy13fIgmk7naRJV2+1wPJrPxl3bloV+y5N3ZRTv9oXKsuloHHC5vVmcj/PxZNx13Xqzu3UxmU5mq/WSU//EnfM4SXbb7SgN57O5I2caczkbnZ2dF8VeN/bu5WwwHO52uzQS8+kFMlgty4v5eDQaW23ayo3Pp8PhcL1apQEbnJ35jqNhFs6ms6ZudNPevZynaVoWZRrwyYXfWFfzcXY2nxttlsvi8uxsOplsttsgCJ984i1RHO12++FomOe5bzY9m8/H48m+2EspZ7NZmqbb7dYPoACAm5ub27dvDwaDtm37vn/yySellOv1Os9zvwddXV2NRiOvqDbG3LlzZzAYLBeLNEnzQa6k2u/3s9nMw+uqrrIs84Z6+7KQUolT76RnhlarlW/wevrpp7NhxhhTMnDaWUOKSylF03Vt2yZJGkRB3VRt1w7zDIj2+10QhFEUdX3XtV2cxEDUNA0ylsSxI6qqChHSONHG9H0vlVJKVmWFiFmWOef2+z0gDvLcU9xBEARB0Latcy5NMyK3LwrOWRTFfdd1fR8olSZp13dFUWRZ5hVsABBGIRB0XQcEQRgYa7u2TdMUALqux4NBm22aWkmVJEnbtn2vkyQOVLDZbr1YBBGaumGcxXHcdV3f976LsK5rRxRHEQC0XUdEYRBYY7uuS/MUkdV1bY2N44gxVhYFEcVJ4vfvMAzjOC7KQmsTRxHnvOs7cBAnMRGVZSmEiOO4adu2acIwFFzUTY2I/ozquvHjVbwJv1/8bdtq3ftgVJYlFzxNUo8/lFIIqI02xoRhyBgryhKIvHi66zovcqrq2hgTBoGQsq4rROZthvq+B0DOed93xtgoDLngTdMSuSRJjTXGmEAFnLOu743WcRwLIYqy1H2f57kjKop9oIIgDLqut16fykXdNORcEIZC8KZuHFEUR0brg0Qpjuqq7o1O89QAbasSAiGTSGttuj6WQSyCpq573cdp6hi0RZUAz+O07/u2a5VSSgVN3Rhr/FfQNq21NgwjAlcWZRAGcRx3bdd2bRhG6mRGK4VzrqkbIUUcx32vy6IIoygIlC/0Z2lmjKmqigseBmHf98ZqpcKjqQh5E6WmqRExSVJnbdu2UkkVBvum7J1RSYScNXUNjvI0c8aVRanCOAzDsijH8xkX4gQ9fZR/s/zXU6TeRHO5XAKAH9g2GAz8NuC3EM/H4NFGNIqil19++cUXX/z2b//2NE39jmKM8VAbjyaLp8rjGz7XP9834Q4Gg/e85z3z+fy0M/mXe92wEELJwNdGASBJ0pdffvlLX3ppNjvL8/zJJ58cjye/9Eu//Bu/8cm+75IkVko988wzn/zkJ//Nv/k3vuMhz/Nv/dZv/a//9b8+ePBgtVq9973vPT8/L4ri05/+tNb6/Pz82Wef/ZVf+ZWf+Zmf2Ww2o9HoySef/MIXviCVCAIhpQiDwFm33+2DOAYkJsU3/8X3maaxuuvrZjSaGEtlVTHO4iimQ3u+/8a7qqr9Gm/bxjkaDA5OxozxOI7apm3ad0ZRFIZBWVbGmDRLgKAsSi5EEsdd3/d9H4aBv1BepyiEaNvOORtHsTambRoVKCFEXTdeUA5AVVVZa9Ms82EkDAPOeNf3flVyweuqJqAoin1rM3Em4rAzve57hkxKaawBojg8hBEueBzHuu/LtknTVAhZ1ZWzLk5icuTbz8Mw1Mb2XReGgRCyaRqvIAeArmuRsTRJjLFt20j5UGaXJLGQsixKAPLym6qq0iQNorCuat33YRwpqYqiIHKe6qvrRkqRJGlZFnXdpFnKGa/qioiyJLXOdl2PDL3PZt/rMAwQWde1RBCGIQCUZRlGYRzHTd20bRsESqmgqkqtzXA4lEpu1htkOMjzpm27tg2CUCrZHTaOtO/7qq6VUlma9lqXRXkSDnZ9l8QxIlZVJYRMkrjv+6ZtlZRhFNV1bbRJ0kQKWVWlI0qSxGhT17WUUkjhJ2zFcQSAVVX6PfTQYsEwiiKtddd1SgVBoOqmMcbkWW6MadpGChHFcdu2dVULIZIk7rq+bVtvfVBVJRfCf1zbtkrJMIx8o3aapEEYbLc7IIqT2BjbtI2UUknV9Z3zQ7yc6/teShFFsXW2KitESNNUa6O1DsLg1MURx7Ej6tpOAqZRRERl0wglozCq66pvuizLkOG+qpgSQRrbTne7KgnD8Wh0nLl4EFOdMmdvTPS5Fz/3j/7xP/rBH/zBj/6tj6Zp+vnPf/Ef/IN/MJ1O/6//6/8dRVHXtb7s3PWdlNxa49xBJXySb518Yf0HnQbbepXwo86vJ1jsrENEchY5Q4bOOcb5M2976723PJHEcdM0XdeFQSCEaPal5DJOYq1N17VCCCVl27Zd38dxLIXwJuhpmhpj6roOwjBQqut6rXUUhUKIpmmsdUmSWGd9J1YYhNZarbVUUklVNzVDPM5U6xlDGQRd09ZNHcdxHMVFWRhtBoOBc67YF1LJJEnatmm6XkQJC1TbVmS6PA4ZUrXfc84Ho1HddNt9HScDGYRdW5AufZyxxjqynAsi8jM4wyA01hitgzBUSu33e8ZYnmWOqK4qRJakycE2IIqCICjLUmuTJDEAtG3LOQuCUGvTtk2aJkLIpqm7tkvSlHNWFhUgJXFirGmaNgiCKIyKqnDGxnHMOG+bFizkyRAA9lXJhEjStCwLY61fMm3TMsQgCDwg9IHRFzP9F+2jaJZlAOB5kCiKHvV58GPk/I5WFAUiev1DWZRpkkgpfXNREAS73e6Xf/mXszTz8Losy1CFYRAcuB/vNFGWZRiG0+m0rmpjzFueeEsQhdbYtukCEUkhu6bliIxxzgCs5WIOZLXVJJh8/I5zThvNGGecnVJDwXnfa+dsoC4J4FA55cLf3cxPhLKm77r52VSpwFnrjdABwd/NjDHrLDl3+86lnzjAObfGIkNnLQAqdccRGWPmZ1PGOBBZawCQC0HknHPeztMjQqmk35CUVEccCQDonLXOzs8njDFPSiGic8Q5s86Rdf57InJSHE3QuOBCWGMOrnWIfdcRjKMw9Jfi1u0Lzpgxp4ne0Pf9bD7xx2Os4ZyhHx5G4JeNH56kpHLkrLGH0ZSOrLPIUAp5slrzaAmIhJSIoLV2RFIIo60jJ6X3O/PDO7g9uPc/HMDmfSW10Wd85kfrERD3uMfP07LWv4k2WkrpHHlnyhPoOQAyQELww02tc/Oz6Ym8vHPn8uBzzAXjjPyYPc6InJ8VReSnzzNjLWf8FD2ttU5rcnD38oKFqug7By4UCoztqyaZTOI4qbu27rvg7CJkwmiDCL6dwlrDDkbZQESOnB/Nqo2W3vfNz3PCw1wSwYV1DyduIECvtXP29p1LBDTWzM9mSqm+74jgNLARAA4joIw5EhLkrWofzlxFZARg7AWOeag02rbvpJwHTFltyBJe3AYla23G09kwik8OhXTw2OdvJoAZY4vF4l/8i3+xXC7f//73a61/9Vd/9erq6kd/9Een0+l2u+26bjwec867rjsdbZqm9+/f/8QnPuGt430a1vd9kiRFUSillFLe5gKOVv9v+FwPlz0HfOvWrSRJTkfIOY/j+AMf+MDZ2Xw2m374w9/t2zo/+MEPjseTyWQ6HA5fffW1559//rnnnrPW/diP/Zh15t69e3meWWsff/zxj370oy+88MJ8Pn/f+9537969b/mWbxkMBi+99NI73/nO973vfYyxH/zBH+y67sknn8yy7G1ve1uWZS+++OJjjz32nve8J47jpmlu3boEpPe9971d16dxAoL1ZI1zFmB2NnNNEzMecWkAiq4752dSKWOMs0YFASJofbDv9fe2EIIh8/6sUgjGmDYWiE4DkGezCeMMAJ11/A7nfrQHkR+LaIwBICEkABhjOGcMmTHWG+MTkbPOu4DrvneOGD87ClGcr9sSER5tLI02jPuxkQAEjDHHsHem15oLHkllrdXaCOHjnlO3Lr1DkNfJ+I4hNp2yg1WcE1wAgD0N5TmkN45zzpAbowFAKmmNdY4YR8GFI+r73tvyOWvZfO5tNYlISkGOtDEwngjOHRGBo+nUWqNUcFop1loYjRDRG/H6aRrGaJ/lAQGBs9YJzpEx3feHAa1+YaIfBmTciATn/gqz+RwPL6Q7k4mfvQwInPlVc7D6tc4CEQLz3521FuYkhOi1Zj6cEhmtAX0/qB8oxABJ95pGY2985hyp+RkgaG0YO9ioETmG3lDcGaM5u5BKdn1njVEXARwH/TDOwI+PJuScEfjxFkwI7uyhOEMAfd9xLqQQvdbGmPD2bQIfOfnhUgMxxgHB21JfjsZccPLz+RgDID/ElDF2cJrz434QHRE/Z4CodS+EEFxoo4GAzefedBIRheAcGFhryFlAP0ORw0wx7rQlBii4U7wyvdU2uxOCdb5JwLtKPVovOubt6HVKX/zCF7bb7Xg8/vznP//lL395PB4pJReLxWc+85nlYvnMM8++/R1v/+M//uMHD+7Xdd227Xve856vfOUrV1dXzz333DPPPPPKK6+8+OKLu93u2Weffec73/nyyy9/6Utf8p1Ps9nsne98J2Ps937v94bD4ZNPPgkA3lKX/BQthgAgpLy4uLRkjTHz+ZwzJEfWWHWuAiG1Nn3fByrgQniLbr/BeXNoItCmZ8hVoLyvpR/GYozxa/mwQo25c35HSmWsMdqoQAkh27YhoiAIjLFG9yoIhJBd1x7sgT3FcHbw1O57wy95FIVd55tNQ3CMMWGpZwIAddVWty9vB0FQ7spJKt56L9eNdZZwPifZWmesMYwLKYUjZ7QV3tjbDzTgB/f6WxdzpZTzMz44t9Zy78rvSCnZa+1mkyA4+L5xIZCBNQdbbq01gGNszjjztxpDRGTWGXecRKN7fXE+lUo5Y7XpORMSQ91aZOx2cJeQemOms+kRlRFj6CeyIyJydI48keR9LU9Wvqd5Fh6YnQK1OzjAcp8CnZ+fH+qcQgRSei9h/wQP/M7Pz7fb7Wq96rpuPp+XZdm0rfAywb7vy7JMkmQ2m/lNFAAYw6aprQUpA0vUt7XgQjDu+p4hMNPHxHXfcSRAYcreGq04V0EAzvV9pxhjQK7XYA1jTFpLBNKS4MjI9QcFIe/bFoxRjElE13XGmEgpp7WzTkjBEY3W1lghOXfU970EUIxbAN12nAvO0badMTbkjDNwTgOA9AbkxgD4WZA9dy4WQjJm+560FkKQ1taPhxCcnDVGI0NJ1DcNWqdCRZaMMQxZJIUj0mUhEaWUzBho+4Ch4qCbhhFFXNi2BQDJGGecut4YLRkHp62xijMhBHl5CYB0zJmOORsyjpaM7RCQCxEgmrohgFBIMg0HkICISIfpFo4jd31LRBHjRNbWPWfAOYfOAAH3xu59JwkBEHoNoA8duaT9cgUio40C4pwxo40xnJwg8FGVMcaQ9bpnjCVB4BjTbYPAYiFMVXGAUAq/qMiRChQA6F5zwTnjfd87S4GQSGiNYc4JzhlZa40g4GDBWGsNInLBHm1WcNY5rUPBnemdcYwzAaT7XhkQxHTZU2/J9EJJ0WsylhGPLMOiga6JORcc+r6VjCEgGOOzHURGxhhjOcNASHDW2C7iHE0PAMKDdgCfXQRSdNoao6WQgGiNiRCRcfKTIBAZ49R1oecYjLHHkRlkrDZGMc4Zs8b0WqsDOQF+9Ak5Eg5iYsiYrnWPOgZiznBjQNsgStvelp0JA9UB+llip463N3sv+IcQ4nOf+9yXvvSlv/N3/s773ve+tm3Pz8+/+tWvIuJv/MZvfOYznzHGnJ+fP//885PJ5Nd+7ddeeOEFIcR73/te59xut/vX//pfA8AzzzzzoQ99aL/ff+xjH3vw4MFoNPq2b/u2p556ymfbHjQ/+vDkiu8n83o7H5tOAmIhxAc/+EH7/2PuP58lya47QfCI6+6hns7M91LrLK1RQKFQAApEowmAAElwesg2LnvZtms0a7M16zXrD2s7X/qPaOv+MB+me4Y20ztkk0MQAFGEICFKACitU2v1tI4Id7/3nLMfrnu8eJlZlUU0CNa1tLR4Hh4u7z3id37nHBHV8KUvfSkEAcCnnnoqNiL86le/KqLMrtvtZmn21a9+NS/6zMRMvV6PiB5//PHHHnss2vp5nhPRs88+++yzzw5oyl/+8pehbi+nqk8++eSnPvWpaJGb2Re+8AWvAVQfeeRBRvbBRBQQwZEQ5nneMEsVtNdFpk7CRKhlgbH+vPei0iKHsaOBarQ6fVkksfZnkLLspeycc6EoRULKzjkWH1QkYcZSAQZtKkFVEzDHrHnuvWeixDlVc9Fj9KFC9xXNBw4hc47UyryXECdJYiIxL9450CBBQgPJUYzAhEbWINOiXzYQWsQUwMq+ExlJG1oqqiIA+NKgaCCiIfhcVV3iGMDnebRXSDXmErnEgUGMfhAiwFaVPcuDgbnEWalBckQc4Qpac85pEYIPAOASB140CDI5dhotIUIwCKJQ9pPEAaLkHgBiB5xBm82YxuQcE3F88pw4Ug2hdM6BF98r4ik0eDVjx4hoIcSezEwcQmmmziXEJKE0MHYMFoYmLqgoMSGaFn4AE4Ze0a5c1mBDdU6iRLLYmQMscS50qwdI6lVUVQkxdjEfDDGtdMhm3gweiUi9xo5fTCimoqY6aGuKiABiVuWYWhEkSIfJOdTc+xAcc4LqvReVJAFACWUgInJa2S5ILnUWvIqyYxAJZQCEJElM1EqJ925isSStWdUygySolCGENEuhlK0bd4ICJkAZe7RcAgA0CFlKX/gsS71ot98jDY12O/hSQ1V19ZZEhYE3BYDOuf379yLi1atXZ2ZmZmdv7tmzJ9Z6+sEPfnjx4sV2u3PmzFkfyitXLn/729+67777rl+//oMf/ODEiRNXr169fPny7//+73/zm99cXFxsNBqvvfba7//+71+9evUv//IvH3/8cWZ+/vnnd+zY0el0nnvuuc997nPHjx+PzxMNEFERiMkAVK3whQRJEmeqReFRLeFExG/2y2jmlqW3okAAStIieDN1zhmSD97MjCDv54PmKYgQRB0zIBS+iMANE/X7fSZm4iIvcisIEQmLfm6IRC74UJYe1CxWqVdxzjFx6aOV5lS0u9k1NccJiGnpiTRNSIMWqgk3mNLNjRzMMTooRDZzBESEQsTAEJ0JFkEAjNmVuUgILnFELpSiokQpCJV9UVMEFDUVEB9fIvQ2SwAj4qIX1BQATRQJTQEQgkTLn5BJFUSMmYNq8CUSOpf4oCKBiUDI5wIGhAkoVR2hkcqyKCVQ4gzBlwUiMpEPYqIRTo0OG9QNDmPrEyKK8j+6GXHjIOoYh/c+KiAA6PV6ced+v+9LH4mCg+ZikXSqprt27CKilbVV70sHAN1ut9frNRqN2PR4c3NzbGys0WhIEA0CxEhUlF5EsjRTLyS+u7K8ev1aIkH6XVRIXeqDlyDs2LkkNp4dhEVUo4uZgGEQSRwjUlnHZ63qvA4IBBAxSI6hD2YiYlWpDHniqiGQcxI3EuPWKaLwutVusKoNZN1cd2BnqKlVXoWaSQiEwK7yNpI0MQWRgBhRrqoaKzGDgYiycwhQxvhjmoTK1I44TcXfjzobazBSRIhi7wAlQucSFQnVKcgMVIIBMLtKhgw6ZlZ4SSVbiNDAVGI77Fvi4zj0f/0EDACMiQEhBIkTPdamiYhntCoi9hwtmwruDVWPlrphckRQFMDSJAWA0nvHTEQ+eFWIxeFVYwJvbHhbId/Re66B0phxRUgIWnU9VVMRISR2LD40kBNI+uYLNHE4s2cPsJu7eg28NKI7K5qkCTKXoawb1ICZmSpAfD6VtraYTsG31maPE8yx83X3aTXVuoq7makBAUD1HmPTOFBV2HqhgQApLs5QPYqISBmgqTmDVFFAA5sSICqpUoAEHbjEZ9nUsSM4kRAY213aHQ/UzJkzZ6anp48ePbqysiIin/70pz/1qU/Nzs6+8sorMzMzzrkf/OAHBw4caLVaP/zhD2OhzTfeeGPnzp2bm5uR3P/cc89NTU1duHDh1KlTjz322MmTJ//yL//yT/7kTzqdzl2v4YNGfIYA5r2P0y+EEPVFnvdFLMuaSZIAQre76RxrdDgRo4wbJOFFd39gXsftcekNYg63NOYIEhQFwUTB1Ai4kiaETIxIiZn1+zfOni9W11Os+3+ZUSU9KscvztsIuwYfVMUlCQAGXxJHK03MBImIOLYTZ2LYupK6jbqZAZpta50dS/LHqkzxEsxMJDjnEMn7kup4jorEAFts+Ms1TEgcgz/mVYwxSZKJ8Ykiz1eXVrIsUxE0Y2IVkRBidFi9N5Gq96kEVWUmwNjMBWKfRQkBaj7lkMQwtUpIighS1UUpoqRmJkEAgB1XdrBzsQUMIrlaOINBtFlFBAGRcBDNGHQbxtrDr1uRg0WU3SCG4Ii5QpuYqgaTFcyJIlW1rEG87nay0BCSZ7WtNthIUHWi1Hp90SACYKZEJKqmxswxkh7N7jucogabwWI/YKx6VhMioJrG+4qPcSCpovYBA1GhSsuYSIiQYGw2mWWZqETKPiHFkGAMHUTcLp5jcPtmAFh14bYqoMeDFRTVsYjEhkTDdj8agoIm5AlyFQRIkRMxCOLY9SD0GdxEZ9eRI2XaQHZJzUMYeggwvEhDCHv27N21a/rcuXPj4+MbG5vHjx9n5kuXLj3//PMPPfTQieMnfvCDH77wwgutVmNiYuIP//APX3/99T/7sz979tln5+fn/+qv/uqll16anZ39gz/4g8OHD//pn/7p888/3+l09u7d+4d/+IchhP/4H//j2bNnYwv0I0eOEJH3nqB617EHpAEgAQCkSZI4F/KSFBxgYpijBAfMTkxFBAiZyGMJDgBMMAAiJEZEgigxxId17NSRkAEEYDAyQVH1itJIm4jW73skaLfbQcSX3jknED0NpJS8eEMANsEAELsGg2AQVUSghBEwqLeOQ1JTL3mRMbeSrOzm6qXdaZvZSr4JLUqyhljwJbNLASD4ECu+BUEAxjRTpFJNjYBSJi6ruCIiYhBBACD0IUK5DokEMMY0YoxUpWLBqShzCmClFwNLOPNipoScIFGpKoJgDOS8mpowcgzXOJVWjDX5oKCEAAAa14vEVrkGACoisXUIQLS+Bot6MJ0GcO9wdDRiMbFfYySrtFot770vS8cuHiEyJRqNxmZ3M1YFJqKbN2+KSJpmFfobayj2+/21tbXx8fGRkRERAbE0SQUw9yUwuSTrlbnzftK5/ubGlXfelpWVpmoqkAiaARI6drF/LNTkRVNTi7ZpDPxZNEQkCMb+pHVQvoqUESOCbPVhB1OIHUcZYWCHiUaWPSJWv8XYbHBbuNgA6lqnVAWhNAatiLTCIOsjiCIaMQYRU6sCx1L1rB+YU1HEqBohI4EED0iuvp6BtjNVHDJ/K6mqCrUuBCAm1Ei4RKRo/qqCGcUyigOBUkmX2NEd641RGQ0kvt1m+A46MA8yEhAAotGMFA0ABURGDCJmliSOkIN4USUg5NhBFrR+NUiEUHkr7BgAJARiIqIQ4pVXNRpji1Ssawtw9BlUCLFWOlHuVgovXnH0MZlJgoEIM3vGPgg20h1laLTbi2+9nW/0UiACZMdB1YfAUQPEVpVglVkDplrpm8GR67PWzU8rNVyVyHGOQwhmUDFADAzrp4mgYsSIiBoUEIkxQn2IiEimGjQwMSEZWmw3BwAIhEAlhMBGDIxGXiigQ9cTcTt37Nt/AMw2ypyyFLa3nBhgKrfo2gquq9OfoxQYGxt74IEHiOjKlSuxruHs7Ozk5OQ3vvENAFhbW3v33XcnJia+/vWvt9vthYWFd9555+TJk2VZrq2tbWxseO8XFxdjAoHc1mtjoCNr7Kq6kiHbbstPw/hc69kYF0uWZY1Glud5COKSFKCKvEctPowlR1AwcpEBIqGlUtJRJkb3dfsjMkQAAhQjADQ0RMI440l9gCBhszt3+lzvyo0RQAtiAISAlfGhiEgIGv3hgS9aUxFUBYkQol9nWGGloBaxwPqBgEVjDsBErXI4AczU6p67cd+qm1oU6PGWVQiQmFRNxZCgmrdReqowcZI4A5OgHrRga7c748eP52vrN86dY2IwI8TEJagWfLDI+QFAMKxbgFokHEXjjLBGH0xNYatnexQaAIgDGCIyB+KvKs9QI5aJqmoAXMflwSAGXuP2WoAP7M6tg8eJpKIAhsQUeyCbIBASmoGpVr6CQewtX887MIDoMFetWQmj5DS4db3EnyDSFqAQJdhgbVUquHJMIjXDDCLXJSroiORZZXoPHlFkSgARx+0YcSwwVYnnjG/bKodYbfsCtzpdzGpJFc1kJgLAyN9zSWKmKoIDb1ANa31RG9tbfoWZIQ6JDovKwlQ0ugFxkjumwW1C9cQBDbyjkqEARYMUMPGaKBC7rvleAiP7Z6YnJtPp3SXUknS7gBosYTMofTk+Pn7o0KHYrLHTaU9MTFy5cmVhYX5jY8Mlbn19/fjxY/sP7J+bu7lr166ZmZl2u71v3749e/YAgKouLS3FOt+7du06evToCy+8YGaHDh1qtVpjY2MnTpx46623VPXQoUN79uyxIf+GiLRqAAcIyESOOBSlM2gkqRVBpFQn5kBZzMxQASAAqFStrVXF1JidxRmOFmeHgSkpIQlUmRJxzQKpS10pG2qGKSFiz6+rCiCoDRQ0oKFoBcSomqrEFvKqpqAIgEYIENA8gSA4InSKImlgBmq2mt4XpRQeQ9pp9nVTvGVpSsAA5hIXvX7vAyKQoYqoSlzIhLEvPFi0KGpHTERjKY34zNXAQFHRILqZhhGajK4OSlyKJgoIxA4RzDBhR4iiaqAIaFitcVNVC6JGjhppVqoGU8NotCCYVR4tVCXIsHZTB+pgMLGhjpzEjVhHG2J+ZPzMdT37NE1jXAsRI6F8c3OzyIuJiQkzm5+fT5KkDS0XeWDxx71eL4TQbrdbrdb6+nqRF40kM4AQhBxB4sRUQFJnmcMGSCPvYa83gZgJWqmgwMyE3iqJUhkPBmCmiISAsD1EEoGBqNhquhJUKqcWbYC1MCJCgojtxg9aYypgA2ujUi9Dchw1WsyOK0QBo1pCqEQ+VpANaAUUayWntmCbCpauVBcN0XkHkncgcjQitZVUguo5DE4BuAWKi8ZJqBpfZyVcse7SC7WQjmiEmlb0VINouW7d8oeav3G2Dw41eAUSvKhE/ElVodcnclsPnGufJC4JAKjheUImjhqlsoFUIxRRRnE/eONRMVSUx0qf1QopakUYzF7USFBGUjAfBBxDI2Pz+WbeDsU4tLK8D3kvJQYxJEyY2gaswEP3azUGBwZAlaGhlfrcbv5Gi0cVwIgd+UhGRESqtGFFYqgQo/pOddjsixNowAWEIbQeDBQpMIMJB2MHDsx5cYKpQxINPhBoLxSFBodDD+JOhm8cWZYdOXLkzJkzCwsL9957b57nL7/88gsvvPDggw++/PLLWZZNTEwMZISqxiy0hYWFoihiibHIB42TcNeuXXv37p2amgKA8fHxGMHw3g9qeQ4rtls+DH9Vb6yMv1u+bTQa/X5+/vyFJEl27tw1Ptbu9rrMGN3O6OIP2m1o3e9jdXV1UCZpgMff0TRHRMPKzovQXOUmiqkEUGuya3CaBdVefwSQIl3SwExFhclF/6kWtYhY2Z1bARzCCOltTarK3h1ecRAv1WAAjjoAMJVKkEEdGKikDsYjR4BwCx/VbacgZDM1EChKVSFmYeyLZNTfReRM5/J+wszk2EDzgiAeCMC8YY2dDNZEhURGSwWx8q5rWVKN2LfAkKBCrbSCYAevWg0QKmA1iIBBkjiL5FofH6/Fo9ZWbw27Vu8smpooIhFmrtBcVSKu5V/9pAAqOT+4uMgGGyoIUJu+hNv9VhictPI5AMC4gmBtoAVg8E5qgRnDa5VvPjTpo8MTT2FgVThMJYgSkyOOb5+IYEg0RyuzQh0AaqVfHWRgkkTto6qRvysi4IsB3myVdw+IiIKmZrglzzE6SzGqhoMYRy3HdPAKwMAwDKRb9WxRgRW9g9xBigAGqUIjWGYEGMi8lZJsbnTApJGWQcNQNfGBbBwWDnk/X19bu//++15++eU333zz3/7b//f16zfyPJ+Z2b1v375jR489+eSTb731JgA2Go0Bzre2thZzkFR1amrq0qVL77777u7du0+ePLlv3z7n3PLyMiKOjIw8+eST/+E//IeFhYV//+//fSSnOueoVrpQyfGoVyCI16JsZU2nwORazZYmpafSAAiJOFURkaDmqi4bgmbGzplqEIwenakiMVMCAKJa/ckUDQDnuCwNANI0NbN+njOzY5YBgmamIpA65zhy6LUC4ihiXtUOAMjksSwlOGJqtnqbZZH3EkpLyUOZj482syRrdbKi6IonRhYBBHQui34ONbMKRxBRFWZHhGVRDsxuA3PkAFBNLHVExMRiKsGcS8Fi4D1Bomijx5mHAJClUVjUL5yinHTM7NiXHsgxkpiBKWFqSkFwbWMDmIE57/bBETF5CWhAgAwACmqGiGVZJVxB3bDJbEsCx68Gte0jqyECIoNa9QDQ7/cBIE2S+HOsiRNlWY6Pj5e+nJ+fJ6LJycm5+bngg4NauxRFMTY2FnuixrxRR1wUuaqlrUbftF+WrdSlhqHoS95tgaVobR8A0aekBoYiUsYnbma1xbgljaIM2NKPlYVABMHQlKOqG6Kg1ZJrsH/l09oQwGQGhIMfwPZFCADRFyFSU61PoYOd6w8RJFWoRFq1grZOgVunQCRlMFVCRkRFtQixbH9VFTiwdWG1m25AxgAaLKCxI1KyShYN1Gn9kLaZvypMjLcln91p3KFh2DazxAwRlURMHAoixbswLZxz0WoFqwzHKjdv6OcIvj5aJVAr/22AhG29cbM6H0Uj5gcGCERU8eEqU1IRSEHMqp9SxSMonTNUMRQgQWfswHGEbD0AY+IiMemWOx1o/aHbvoPlZGoVJ48FQBTiKhK1iAjGNAXFOqi3Zf5G63oAZUcXFmVwAVZNbhUAJVAygIBqzowAVT06ZxluWNF3LW1lFXd7O/p7+wUXRfHAAw+8/PLLf/qnf/rlL39ZRP7bf/tvsQvopUuX/uAP/iAqkl6vd/jw4ddee+173/teWZanT5+emZlJ0zQmnsYCDseOHZufn5+amjpz5ky3241Z/zFUdIfJs83M3bZl2EGvL3uwONEMzp07953v/M3S0nJZljMzM1/72m8fPnwIMZq8lbYY1BKOF/nmm2++9tprv/u7vzs9PR25EFGQRWZYNNO3X5wZAkpcd5UXEj87xMSQg6YKOZtHA41dphSROCVBGXroccqamgJhfKFG9Syibdb9wCHYfvsCBuIUzKKcqSb0sF9U/RzjkWtjqH5026Pr8YAqYgTOsZCIWcpsIVefh3yTzGfsCBTBvJSqGlULEBoZOmcak9gYoi0OBoAGoFotWL2NMAYAiGRitV5hA4mWV7UvQqT3AKCJGMaDGJhG57e632h4RSmrW+YvIgASAAIogpl6NTIRQzQLg58MPSysnGWo5WNFSqp2QgKFCmYfxrExEq2iHo0Qg6ptecLVi6gPMzyT0dAQ0Cqkv5LlMco3cCeo9pYwrnYgqzQfwkABIkTfKT6ggX0NtQmOg1Mb1LgdmYGBgIIBA2HkdUGtQ62KL2E0edmxAQQJVRJujNpJpQbq6TcAHKAKQELtlCg4AzICgRjyQwAUQDEGZ6aNhHxKBEJkvi7IAENs6coaqgPWALB798zyytLu3Xvuu+++zc3No0eP5nkxMTFx4MCBT33qUz/96U/ffPOtjfWNL3/lN9vt9szMDBFF9Nc5NzIysnv37scee6woir/5m79JkqQoit/6rd86ffp0nJD9fv/AgQPtdjtJknvvvXdwMaCKA1cCoz+EAAaiKbkESPrl6MjYGDNdn2vkm9ETZkKJpCOKZdSgDpVEUWCuAvUrHiPA1g4xjKwSg58UqY8x9OGIASw6h4OsWQBkJqxeHCAhmKlWSecRfmVCNB8YNhB5ZqacmLy6vtE36PV7O0daB7Jm98K51ubmjn5OxMGxqCECs0MwkQqMg3gXA+qOaH1rBmBELmZLDqS6VSsjQrbGREhkGtEuqvI46xDEQPKLqlZBXbKYzUZoamZqlPQmJvXgMS+6nveCCSK02m1OE1MDVcZIuTAxQ8LBOsWa8zaM40DNERicehBXr/g8zsUsN+99mRdYF0GKxT1brVZVTlhlZmam9GW31xORCv01s9hLY2lpqd/vT09Pt1utIs8JMImVrQgSx2QqGtOHIRHhfsFIRUJ5huOTk6MjHTST4BNmAJCB210BtBDjSFUsjHAQFRyybyvBijFrvl6uCFjTlKplXGOUZmaENahYB4OGRFtc47QVY6/M0CpcBbWZTlTRyioMuF45la1JtUY3M0XiLe5Ure9twJGA7Sy0eAQAJAJC8nVKo4moGRIpAokxACJ6Ag/GAGRAAASkYAIGoCDCRMBkqqDmiBFAh4xsMiBDRdDbLKeIpg9eh5mhVVnVSCiioJI4BkAPuOF9GUIjdSMuJVOpHL4tJJQNFUAQlAjMKvwVUQ2wwuwrSD4WWYhrWzQQIJhitUg01v4ARFR1xKpqokYohKFbrC4slxKMHTJ5sh4Eb9L3xfjk2InDR0Y7HStLAVBGqyEcrFOQsAZaBtDT7aTwwZyBGkDCSIYwiCYvVwyZ28zfWn/RNibHENgTX3u09sERsZJa8KzScMnywtLpc5fyolAyyShkXKC1cfi6avjm9veoeujQoW984xvPPffcn/3ZnxHR9PT0v/gX/yJ2Nn799ddHR0effvrp6enphx9+eG5u7q233hKRp556KnZjjy3iHn744X379j3zzDPf+ta3nnvuuTRNP/OZzzSbzego3xJyGr6q2zdu/3bY8AAAYOa5ufn/+l//q4j+9m9/HZG++c1v/uf//L/8T//T/3d8fDT2mIwlHmP1+9nZWWbeu3ffysrK66+//tnPflZEGo3G+Pi4mW1ubsZecRMTE9t4h4MVi2jx7QEwMgI6Q8fOVCV40lCC2Fhrz+6ZqfGJDNBUpCrJYhHKq6LRarXyq6bJ4MOwuV8DTNuG2WC9D+TQQMHYdgv4VuehsjzqIg/RUQwSiBDEABkSd3Nl+eb1G9Ir0MAYAcE5Bwg9X6RZOjYx1STHZqhmBAHUHKmKiTKzEUqQKIaNAKQOUiFgZRKiATiLZqlpXQuPnBNRUCMCATQARiSLW8hUjRgA8xAKMMeUInIVd7EtX7R+LNVsGfjUleFn0fVFRK1XYtw+hJxXiyJWOsCYRRChaEKtyK4x9rrlm4haDB4SYrSFXV0donZMsEY5bGsOI0rkGUS4ARSBoqdSTboKAybSgZ1bTx8EIkSrhA8CRWdHYTAzqvYQYFah6RFPRyAAVlCpGHtKAGqIRICoWsFuUDF1DVFFzCLchT6EaGYNDDesJiFuwUYA8TEMnLI4KxOFBKgA84TKgICkIN2+9IpQRtSTxMSLz4vcOI2lqaDWdDZkSKmqc+4zn3nmwQcfHB0d/e3f/u1nnnlm586dTzzxxL333js9vesrX/nK/fff3+12pyanjh47uri4EIInouPHj+/Zs2dycrLdbv/rf/2vp6en9+zZc/Xq1V6vt2fPnj179kR2VkXzJZqcnDx27Fise7X1ViqGfWXgGyIxO3QUo7tknUayceZC7/s/2LW6nsbaA2Cg0eagyiCo5yQiMWAeRTkSWGQp1LOrPmn8LKCAQEYD2CpOCjMzNEKqCPRxbW8he1hP/oqOhSaoBaRumTT7xGMTX/g8oG6UOTG00kRvzs999+92zi65MgCEAg0JFSKOU4moatYhGmgJAJGio9FYIATQykaPppmqGQEysmG0pqBQUFCCuqRRFLIEWos5qgWcWUXvqotaRB4D5ALLx46O/u54Mj5abpZi1Gp1JscmXJYAoqkwogNGhWj+VvpyK8izhd1W/NVBDHkIebG6EMSABLy6uroclinGSOquKAAwNzcHBrtndovIyvIKIiZp4uplD4i4vLw86KXR6/eDhUaaoYH3JaVphxMrci/Bp65MEhAicyVTz2DHrn2/+cV/xsEnKqxCEDDyUxENCKHCT4TQas93WGXUvjQAgCIqMSiyV1IbELIMAZiEwKJHH4IhGSFZtBQRosiGKkcMo/kY8QAChRi/j4KjMlmoklqRFYOGyAZkoBifMaAIqAKBEUaiH4mREBFFIkx03q2GCgZHqyUcBLDolCfMKApgakbMhABBUKF0WJJ1PI4ERMSFVBecbwt3lJwhGwhCzxkgND2YqjlCQwqSKTlij+YZFM0pNgKwQp5oyWbDD3hrkdYrzsxZIDWExIDUxJl3qApus9Febra0kTbLYnKzy/2eZE4MQ8RxCEmg6RGY1lJbJ3PIE57SwoszM0UFYiZKVMSjBXamwUzAgMESQABWBEFwBmjYS0DRGt5ILCHHYj3WYiTzhf/Rd76/OLfIYCm7AC4nJnRkMLVrx2OPPNi7OecUzAdDthpF2ZpYNjSlAMBAb8tZGX4et36wyumKrK9t394JWL/zqEhfhGBkqOiEaHLP3s2D+8/MzlLPu0CqaB4sCHQsxsi47m807EFt3YcZMz/22GMHDx5cXV1l5t27d7fbbQD4V//qX0XrMBIe2u32l7/85aeeegrq1pFHjx4dGRlxzn39619HxE6n88d//McrKyutVivqFav5SPEabn1O9RhQFKiu9Fm7BzWrp27gnKbZqVOnZmdn/92/+3cPPPAAM4+Pj77xxhuq4eWXf/Hd7/5NnufM7vd//w8eeuihH/zgBz/+8Y8B8Jlnnmk2W7Ozc3/+53/R7W7u2bP7T/7kT1ZWVr797W9fvnx5bGzs2Weffeqpp1Q1VrQRRTYkMwJTNsGgQGSaikuRAmgXpZkAI5DYxPjk5575LG30Gt3CQqlgzhGZkUKZQCB0aqTbRNLwh22zCuM7vmWl1Uys4b1qgO8Wr2LbFIUKTVVCMHSCCKKsgUGDb4ATSEKzefD++3749z9ZOn8lTTPjhDBjTUSxS9bZu+PZL36x0S9HhcyXAVTYiXMAlgQAtIJNQFGtTAxT54JZCIpqTGzcDJgrlgijyhlAj0ulqPRYiUvDRIzB+oSCkCk2xRKzhKiX9805ztrr6FZaCYO1uxuNihSkMYRShb+GHp1VUOg2LxVqRxRq58EMHAKZiVkU86mxi+wvUQD1bMEhMKJFsB6VTAG3TmGGhhSZ2RY1N6IBVuavRdprdfJahBiYEoFDIBJVNY1oc2Q9AhgqIhgaOQPS+EMVBCFQQmZEqUENIENkQtVQeG9E7BJAMhGqzhUEIZAJW2rcDqxqOWqZcUjQgpKBA0pL4aAERIhAGFjF1IIxoGMHSDFzUyNR1YwUCEARAlYh0JqtU8frKimJAOpUEzWJPGwA8Zp2RuY3Vn/wg7/LVzYzASrAJFFl51KEwTuqJv/ACB5IrZ07d+3cuUtEp6d3z8zs8d5PTU3t3LkzhDAy0n7ssUeZKWJ1u3btjBbtjh07ZmZmYon9qampyGeYnJyM54plv+PnxcXFv/iLvyjL8oknnkiSpNvtxqI0ziUEBggCSqiA0V9hEBOFHnpuQoJla3XJz95wG6sU+XzV47hDECBu5CGsnm5dxFu7xRmH9VlrNG8r5wQBuY6Wbv8twrZrUIQAgE0wPnSQAljQBKDhksyY+mFkdXNkbbGJTk0yMAMUAIlM9OoKlWKEB0DADJCAEYDA4pQTsLh9cJ0VFQEEABVgkA3AgFxfnwKEeuIQ1KBj9BOg5uZXTwBSgHx1rdHb2Ow4n4ISNYzamCA6jwIOyYiMNKIPoHSrIK3x+zrhZKCAbhMUGDVO/JYi8Qig3+9jnUvd6/VEZHp6WlXn5uayLJsYG0+SZKvI0draWqPR2Lt3r/d+bm6uKIpY9LfwPs0y4gTyEsuQNFJhyNXEiDDxZMEgpQaWdvn9M8XSIoecQQ2kNkYJjKNxqFuSZhgr2qZrFKCv5pBb5hLDmIsIBgrgCQIqADqixDDEPDZArujlqGiCaPVRnRlrJAOZAiqaIhqCDt5bJAJCNWkDVMa0xjwHNGfGAIoaUAUBAZ2CU47zWxEiM1xrvAFrsQhAYgJE5khMowdgISTOKWLpPYg2nHNmOUJIXdtbJzcMttKCpRHMCmsXlhqmggawkUFJlgVERE0dAbLXrBAw8GS9BITMKbZLywL0Uymcbs3M25RsXOBsgQzAMgU00lRzpz5QY60zOfH007sPHLn66i+uvf56c33dM2vihMAMyTATTEvTxK22eA01UdxRYFqWhQtA5owQGYnNsAArCImMARGV1VhMBZRIGUkM1NYboEwjuXGwBAkL38tQ9u3Yf+JEo9kkZGdOjRFTI4fKThkMNldXz7/xZra8mYiY46Eb+8ChH91sHYxb0cw7bbnrMaySSmpQoK2urY7cd0wdoZjzBgKJujY4sq0VDh8KtUaPdufOnbt374a6aDcixp6iMRIU6QRpmsakkEiZisR/VY2FxFW13W4PujcNRMkdTx1l0PDl3b4nIqpuk0cAsLCw0Gw2d+/eXZal9/748eOPPPLw4uLCu++9feKeE/fde+9f//W3XnzxhY2Nje9///tf+cpX0rRx5szZHTumRODo0WPT0zv/+q+/+eMf//jmzZsXLlz4nd/5nVdfffUv/uIvdu/efezYsViCDREZEwRBFEHzrGjAigkYAQSwHCxBAABWwFLLjd6NN97lG0sYSkzRNFAQp9BNwTOkAdxAJGx/57btL6gVxFAMfpsaGxhSW98OOE01fLh1LAAwUwUTIjRKBQFUWCRRE9+yLFiCu2Y6Tz3ug3kBAvSGZgiKJuBajcbYGDq+dP4cz62wKDIBJx5A1ZpeCaDXIkRkkXUM5iALRmqQUEFCgUZC0uMkZxzraRZCr+GDUwJE4xKdR24EZbBu5jxgFqztLVM1KTHhQlEbI/ueeHLH7oOXzp668cqbIxrpwYaEdbx1e3EJMES6zUu/85QHgKjjDTFTToFUvDNEhIJCD30wzYwbltiQnK/eBCJFY9eADCMtMZq/8UVQjFlBBE4G7ySmgJAxiJpYxeCMqgPB0BAiqAdQHQ0tkAUEIQMAVnTBQGMmZoxaBnQsTCKoBgkRBAUJSGYMJasnZaPUMyp6Np+QOQZRUyOEplCiBoYmKhBCCobIRg4QBUVFEJVYCQCNYlKEgRLqHU22W0dABAFloNRDMGzvm2kf2mftzK93nSAaMmXICdSNHu94lIFMiEnqUFWAiQ+0gvHMrCyL4Xha9KKj1Bp8GP5t3DnWY41dHg4fPvzEE088+OCDkRyVZVkM2SFsGWJRVIkKFJE0D4GChv6IFIIhqwuDDoO4WzcytPFWn/cDFM0tX21zmz9UNw3ZkdUwMAQdRVADNCajDBnyUlFIcQSxASJoZpYAxsBuzFhhA6rgvCrcaQCKhiYEGM3fQWpRnV9lCBThA4obYUswodnA/EWoYEQCpJpAU69qG4KJjAAYoIUwirACAimBsYpBAE5BwLTyMU3jyrmTXr1ljn3Qn1V8fogREVUk1CaymcVy9WfOntlY3xgZGel0OvPz85vd7hb5IUmS8fHxyC5PkqTVbquoDz4me3nvoSwzIkMU9bFIGxMjW2qYAIReb2NpqT+/0DBpOlQL8SYNEIFRiQDZpC7N8EHmLxBCU80hpVbxdYnImImRwFy8VTVUTOI614onAACKt5IBnAIrRBR5YBwPmb8VSAwGilhuxc4NwAwNTdEUARA1ISQkZxjFSTR/YeiM0bCPPrcBejBjMgQCi2mXourBmNmZEUDKDkrPpQfHZcI9w2ZujVUbyyAxTIKhWuqhIeia3MtABYQhBwW1BjILgFlgCAl4AjEgbxbQ0Jju/GyHnjwoBQFUSAFYUUBzs1Bof70nIxt99tpfXe/PLmT9fkLsEw4MVFrqrRHQFCRj10xGAZrB2p5ZgyReSMEQjCLgwkwJoqGixvowAmJEDAkTIouZGjeRELivmREzad9TotRi1+9vXbdZFZFWSJIkTVMzCD5kZozbSuR+kDJFAL5zId1/3GEAAaNHHqEDA1GTinpuqqjAiC525kC4xb68/YADlzdafsNfDYo2DB6I1rUSowgYCIXBDsN1Hgau9gcxHwaVH275PPgtRl+1rt4Q3fGYSsLMMeUudl1P0+T+++4/c/bsq6++tri4mKaNU6dOHTp06DOf+UynM/qJT3zi+eef37lz5xeefbYz0nnhheevXbv27rvvFkVx8uTJlZWVlZWV2N+Rq1YOVgFiYEiGhGiIFgtA1VQcBDDLiJox86KXW7fvJJAQoTkRUkgQTDARcFopkLu93bjHnQtl/DLDTAGIAM0SQQBDFRWPJqSsZbBml4MkzAoQozEKAAqIhoW6UmCjv3FjHm8stZwjNAtVZTEKgGqSmDNwBo3EwGGjBBQJDJYCG7rCcZIAI/QNxHMmwEIGYJRCQuRcGUglaSdKaKVKUFFDVsrSfj/vU3rwxL2NEGx2zl29mQUFwEgbMwWA2BlhmyyKhXA+VFKBARhpVCBqGkS9EQKDCVerKjAGJmiqywQjCKKARmCVjjQ0xOiFGgpayai4Zf7CkPk7UMRklgIxoNYlQQZMAqiM6QisUCAI8UIq0CQayEhIYGBB1YCICQ1FzbEhqpgZBAVSTQwZTcmQAVkEwVOGAk4sNSAxEFVGdZGKXs1kMPUQIloMMfpBBBU5Egy11oUQzZoP0ALVkzfAQFo68GhkVJSmzqXtltsnCcY6J6ZRrpOJSKzrZzU785eb7B/i4d8+qG50HONLrVbr2WefHaQNROKWiMQihli7mRiFkpqYOkqMOYDFXipxLg5fwR2vBj/g2w+59A865kf5yfA+0U6Nt4CEICBBKuJoDbYpRMb9VhJuHVQZfK6FH1bEG6uJ3/V0jrNCBk+jep02uIxtmM/WTK9XbZ0LsG1UogmBYoWZiBRCRYGNRVGGnv+tkuG/ZyCimDJUlZHiLHXOFUXR7/cj4rOxsdHt9whxC/3tdDpZls3Pz6vq9PR0mqb9vM/ESZrk3uchjCA5dj2fswNmihwRQiYVEmkgtoiIOBN1XhEBCCL5Hg1Qgc2SrTDTh1w9EAIEjwIMhIyKWqrkXhLChJ1DZFEyUDBBGYg2q2tobLlfkdFCEONcikZYkR9q0VrPsMh8QBpANVW8CCuGRLSHTb2ZkXEMi8cwhtaiJGIAZEhgBtSMxWXEQDUW+TACQdTgmYgULe8lgGPOlWDr5j3gCFMTqCkQgjcAdNwAagGoBivUISu5DFFJM7RUTLXqw1YCIFqG0ED8iM6+GEjkhAAaQmrgDBhpPM1SUetuNhHSNG32+wZWWFDAlqNRc03DMkN1mohvCbSF0iBGho5LFYp9JdQERA0EzUDJLAXLjIixJPSqqJbEhWkqqiNBU+CEUdGcqs9z56va8mqgGiufikjQ4IOEmgAEVNcX+nABjwCo/wDawq9kWBQqVLlnCuDQOJbkMmAgR0SAKiqmANkAVIWhiM/t467c3OEf4hC/+Zavhrff/tUdbmf7GP7hwPx1dd/mWMkBEffs2dPr9a5cufLoo4+22+2XXvrZd7/7N1/4wud//OMfOecefviRS5cuEqFzLs/zyO56++23FxYW2612bGdIREmSNJvN2G/5+PHji4uLR48eLYoiGtnOOTUCtdp9iJhSTYEbXCeAeg8+JIYNIEfsKn6kOgE2CAIGlgi6YdDmQx9JfC533e+jjWoaiwEapAIA6gCYiBA7lDgiAZd4xSDAYAzGMd8UnEGm2DFuB2zkmqobwSxoiaCKagapAoF1gBLEhlISRLw2AzCSAYZCnEHTmxMPDjsBOwC5V/UhEQBjAxIG5z2Z9Bz0mbCULFgDIJh66bbF0lbWgLIJ5QhICH7cVzhfNH/NtNLYQ+jYUIUC+CDzFwA098BgzpWIQZUQEiIScyamEf8XTpgomGjkoSmgag39xgVVy3kFCzaI+dZnrJcODMXxnCKBxYpqkbYLgDGDMCoUQgOAQOCp/m2ccmqx3QYgCIiBoXFqSADRHXXskiQxr2yWAKKIhGBMTad9xhJLUmgrdzywF0BUotwgRwmmKMYGCJCwgQIHz8HYgCkBBq+RIAykSIY8KNh1V/NXwRsqEyN7CQVoS6EhxqIMRgSGFiB4E3JMWvEc4lKzu+Rh/wpGPH5s0m5mzrnY1CDP80H/W2a2AU+/tn0BgJiZwVRFhBJkx3QbZf/jNiqrF8wMqsIioM65OkNuy8BVtO1yrhpbKONw3v52cLrKALUtChfWdC4e2g1qm5jq2k+VdQtba9cGW+rNAiCgUucZV0kAcckPrOd/hGFmTAOadaUuy7KcnZ0dHRntdDpra2vr6+uJS1rN1lbhszzP+/1+kiQ7d+7s9/trq2tJmmZJUgTxwadpowHO5z1Dcy5JkjSCzCAagldfgASUkAC0mJ2BiaiYoVi0CxUYgM2GUgdg6F0MaVNThhCbERMZIJY+eAbLOIhHE/ZkQck5AFENAFBZtFDFOwb2b7Q/BDHmiNRchfjyqpmA9U/IyAFHnBatMn8lUnURHRoaSKyQjlVjBRg6L9RTzar/UY3UMDVyRKZaBPFkJYKqtqjBjMErIjMhhUAa7WMMoF6DY1a0TfQFWJ9REyYmV5r3JcXQrAZWTA29iFSBc0sM2JCAcVuk/xb1bABgqKTKAGoSi10nZs40iCfvG4jtJMnU+mUBppYlJUmBlkV83bTHuEFBgzpwhhgSUIY+lHkoHXAWOXLEEClXCSAgS2zSpZKxIDpRiqWT1QTUEYIvgxcDJYKEgCt4piLzE1L0xAKxGcTWo6amNVF1sHqHx7BXTf8U5m+cIZGDbpF6pZGTh4zISBTBCdmi8w9bsbebuQPQZbDn7fvcrooGe37QzoOUgg86wu2XMXzBA/OXiAZFfKNtet999x05cuQ//af/9Lu/+7tLS0vPPffcQw892G63r1279sADDzSbzaWlZUR+6KGH3nnnnf/yX/4LAN24cWNmZvf6+pqBItrGxkaSJE8++eTPfvazGzdunDlzptPpeO9jxLO6r9jwbPjRb7u42qlAdIisBt6jDwxqYITgACIsagaJgdNb18ydB9r2xTVsZAybFx/pW6zT9AUADZ0hAwUzE9AQVEvWJAHMgJJo0VGtJAkZITVIxRJvmVBqzAJlEMCgzowjDVVLNBPggJqAiIoiIAYT0NIRpeAcM5ICBDMgMDJLBFjNUBUoMUC0ICEgI2FGkKgU5hUhS52SiRWqhfd9pADOAOoENdrKwRqK6CDE6sEfav6SQQMVFYKGWFvGmy+DT7wxkSPKHINZkOARJSXAKq5aG6IgVTCvBpwMqH5vETOr/odtL8QQPCNAVUssIm0AQKjxzQ+SAqxWK4ZABqxVnrWZCQFwNEchlk9OXeJLX0geQBwSECZoihZiKI4QQaNXwBhbE4kkVJp2RUpHSJQqkreYGw8ACUODiAVUSvPGrkJwEKv6JwoWIgv2Q8xfQ1ZkRVBmplJEQqCihLJA9QRKsTkvxL7cVTrUP7bJOzwGgitGg5k5Mr6yLEPEsiyt6jAcoM4OhPolMxEziARVcUhMjDQU//2Yjur6h/AGS5KE6tK2BlWlpUGsG+sZfstRBkVb456xmgDVP4Eh6HV4HcJ2E022K9MaFayB5w8wvs1MgojKEN351/HYsW4uM9BNkfJXluXq6ura2lrs71YUxRb5Ic/zJElGR0dFJDaUSpPUTEMQ55LorZoZJwwVX8esKoaHLnXsEExNvIGBBIJAWFGkwDQiMYJ2VxsEYxldppIh1ofDRhIabg1ElNuukXgMufcADaPUqrSnbT6NAVQlEUwrHWUVEQ0QEGirzmX9ohHJ0CnE3AVWiI5kJe3UQMwZMrMym9ZdDerijbHST8yoiOxhQSwzzsl8CamqoeUOysxJ4gAgz8tEsdluFiFsFEWT3Cg6MjSRTdY845YgKYYEixT6omKSIXaY8lAKp+i47PVZsUUuEjwiDYMNEExQtyrBfcAwAITYI8BiaSAyIbOMGTSAegYzCYgAjnpBuJllhD4PXREj3gDrETaamSqv9Us0A3b9pvMtdsh5IUXhoeFaScN8KMGjyghARgRE62xG2HYJeS1V1hnIuVyUicWR91IyZI6UI9UvvlEiplhiWVTidEIARmIE2uZ2fsCkupNo+DUMNIyVk3BgLNVF9mI3kZjKHSsyDlbswLi88zFvLRdwByv5g374IV8NG9O37zmMHw9f6uDD8JXEbINoAU9OTv7RH/3Rt771rZdeegkAnn322a997bdGRkb+6I/+6OzZs9evX3/22Wc7nZF77rnnj//4j1966aV+v/iX//Jfpmm6Z8/eZqNJxF/84hf37t179OjRLMvOnj3b6XSefPLJ8fHxGNuK3eaQXJ31vGXv4i0AelWIQK0u7e3IRTY6GaBZTZkwukOW2h3HLZDHf6f5awAIyLEaAgPGemMJkRI7IzGFOGHMUBUNDFRADBSiKRmUkJxLgkFXvDKg1QgBAgLkBGroGDxRGUuOE3sQBg1eupIvp+l6wxm5wvtAxkYZqIt1ZxgzBgRYh3LDmNgpshfrJliiOrMuSp+hmXLpzLO6KCBJYmUIiD1ztj1VJUDaplXh9jVaAZeifTRxrOy6pEG04zhXQ5AmYAJcxtYdFpOkt8AlRqgbIFR2AgMklQVrERAZUCTr81fcSDGTmB3vqnz6SOOFAfpb2dhmBoKgBmSQGicCYJBbCAaUMIFhEAyGjswCmqVZRmna7+ZWhpCmRKiJw4QUTUUaZbS1rY9QJJCngCl5i7Q3cYEICIgLp4X6RLRD3HCkUJXuihUkwIAMwUjYAuOQmzEYQ0/eIBXIgokEx2wEicbQAjBUYBARMlEsc6u6zQGGj+Aw/3eOeLqB5w91Q5xohTjnYpsqUR3u2B7dQ6u5xYRkFga/+ke94P/OMag+ETGFSG0JIiqxKcG2naMzNuiuccuNDUqh2yDjESo1REO2rwEIQMCqsEVVmBpiPZzqyKTABmjAwxkPtaw0GLLFq4cPsRjcgFH86xmqinX4ND7HLMvGxsbOnTu3ubk5MjLSbDbX19fL2PQ4eheNRiMmZi4sLExMTkxOTviyFAlILpaVplIaSeJJRCQEQQRmUjIJodQQLOa6qYGaBkRFqPNroyuD6OkuzF8EQFIz0IT6bLlqlqYze/eOH9mfj7bUubY3mF+7fObC0tLSiEHT2Ji8qZo650BjHoNZtFyZvJlpSMhFKyTW+2BmA0DCIBIDryHE9pZYgHrAhChVUK+dXRM7904vXb+p692y74MZJIxAKiYqGOem43arXRZFWZaoBmpkBi5p7d8DbN0rs1qoACSTY7vvPbLnyEExvPjeqdmzF6dm9mYjnfWlpZ0HDujyxsr5y+u+q7vGdzzxQO/ijUaA/fcdTxLqmy6uLF19+1S5UUzs3rfr6P6ska1curZy9jIrkDGqUqx7qgBggqaoA/fxjl4/gVW1aGONTdP4T1GRUE2DlEamYOnOHfc+9amk2ZayXFxaWj5/eXFpderB44eOHmgZaeln52YXLl3pjI8df/QebiRMzt9cunn56siBPTt37eZ+ubK5unz96vqZi0UQTN2as8mpqTak/ZuLXV+0Dux2jrvnboyNjo5OjN2cnd3wuSVcAoqZVqKratFXc7bQ1FQUzQiBPtq6GqQd/ZpHXcAOrM6iJYSqMqIBICXMrq5peos1efvRovS/xUi93SCOH/5B3IbB+CBmBdYtnW75PHzBURXFr2LnNu/9/v37/82/+Tex187k5CQimOlnP/vZT3/602aQJEksDPDII4/cc889ziVZlqnYvffcZ6YG+rWvfS2WbPvGN77R7XbTNB3QiLHqPm2A1QrYGkON4aBC40DBDJGYKGF0ZKBBpcqOABuoDgMYRKk+dMQaRrcAwMMfbjnI3b6NMSeKxFU1UAEN4hGBGAlYTFUFVGJOQkSHNBILiMSsVO2pd03efeLo1MwUmN8oelevX12eXRwdH9933/HxtJ15WM57Z8+dC4oHT9zTGm83QMPaxvy5S83xztTxg1OYcrc3O3tt5crlIvcZJmJMzeboaLu3trTaXbXxztjkVLm0gaWf2L9jYW2pt7QpaZoD5AbKbOzUFBBiDTCteztsm1F1qaYPf8QEwI4tYWmmE/sPjOya7ncyNWjnsnTt2o2b18t+cAZIrCGQVNWXCJCIRYJBFO8+tgkiYlFl5FC3Dw0qSBQ0IDl2LCEAgKkxIlOCKGaAQKMTk6q6vr5WtUFGQoNYrlU1eLSSoNEZceiK5U0CBoLSMDjIRtoj4+MbV68birHra5g4sG/3/fdlrfb8/MKFM2c3vN89Pb2+uZF1mq3x0YULV3Spq2iNIwcajebG6lLn4PTEyJgzWs17S5cvb95Y8uSm9u05sHtqc3N98eKV9c1uAGBCJGdEtb6N9S9JUeVuBB0EI1RH4EXiOzEyIGOmKgBvRgAJckLcF62DnAYfzMX61Q6sKRZxvccu0FHCxBQIVRXVhDkW0IqCKa59UQXVJHEhZstXy/1jZP7e7mwP8s+QkJmdEhlp3WqEiKjKzazKNzCAq93xUEmWWBoRwTAhjKzhomLwoBlkgKhVmDjUvxUEi1ULIcZuAJACmplRzSMC04FGG7YuBICt+hBT3xip5pkgbbXBIrjVE/5VDkQUCYTJoAxRkiTMHPubxrJ6S0tLm72uq/oSmRFRs9lU1aWlpSRJdu3chUhlWaZpAuxyFRFjYiKQUDYanKUJOweIBmZM6igQCpqSGSA6Ao0wRRV3GnS5uYX9ALepAlQyhNygTFIwyoMGctzuTJ44tuPQkYXX3+mu+NJleaPZdOlGnpemSWek1FCWPkVKogQEKMQHRgEYSTuutLJfmGmz1TaV2MrYq3DSAKK+Lwsv7azpHfecbah3apyHRrs5efjgvV/90g//r2+ubF4e64z4hDetjAxmZibmtY21qR1Tn3z2C1cuXHj9Fy83snRsZHSz2y1UH3/0MXHw9vUfOgf9snf4/keO/ubnLl+/nLRHHjty76t//d3xmT07nnz89ef/7uCf/N/DlZun/8P/vKj5wYfuefzf/skb3/l+Z604/PTTV159LR0befiLn9eJH9949d37v/ybZYpFkR+774EXZ/8rbeapmgFRlXQBEY6yCmz8QCUcoydWJV2iEaqhAAbTgKoEyiRopfr08P4jf/B7S1fn/NrmvTNTN06e+tF3n7v/S5/f88gD86fOc0rHp58t/+6ne8Ynj33u6cvnz5WGjWyUe8UDv/W1QiG/Prd3on2PhJf/1//f6o0bOcpG5j7x5JPpwubp2dUdJw4/9H/7xvq1qz86+b+Pt0aOffJTi6+8vHHtSjNpACfkGHkQS4w9VBmIKQJjAAiIVQHCuyyJuLD/SUasyYVV5fzKGkOMpFZKElcy+tKndQUxAIjrFj4UAL7rlg/5+YePDzG7sW69dktZchiqSR4v/pbybWma7tu3DyCyLCQK0kajAXUFpci8GBkZAUBVJSYEUtOYMhX1HBENalYAQMR74jAgNCMzI6PY8oEIQoSLYtKRiqghCoFHDagE6sGUABGEARXNgRGYwSAZ+a5P6pd4vB94MKjAE0FAACEAACFTBjQrQ1AkDwYJAUBiRgZMSI6BSCHKXoQ06YJNTI3e87tf4Va6trgwtWtq58bqT777tzo6+sAf/ovla7Nhozy8b3f3jddWFhbv+cbvzi0v+PnFrCeytL7vqUf3fu5Ti6cujhjtG3n61ee+e/W1t1Kk0vDeB+7fP73j5Rf+jhuT93/pn+06fuLn/9v/uXZj8f6HH20tzr3zo19gwyGljjIWMg9JiCYLE1XuxR3m7EdiAKIQdi14pN379k8//FDngRPrq2v52etLvWJpdjZDaTkXTNilrTQJGpspYjPNzKDX66eYeLNGIwPCvPABBIiSdktUe2WhxEmaiGlelml8mCKNdkO9d94IEJmSLDv+6Cc0yE9++hMAarVbZVEEHwgBFdJmJ4ewZMXDn/zE1MSuV//yOw3lLM3WoVyR7tGD+49/8Ysv/S//m1/fDAQ4Mnrsd76mY6PLi/MnPvOkvfveG6+++rmvffWNt9+a2Lfnk1/5ze/9z//l6k9eEaaH/vB/mN616+q3/68nv/FbsJ73ZlenJscPLy7+9Nt/o+OjR/75F/srq/uy5tXxd9/96fMI1GByaBJT6SM5JpIHDd0t1KA7DDOTwllg9Kjs2KsF0AiKAFjsigyiZEDbG8/Cr9EChtrmjm0p4+eBHOBYNLfKdEWmqqUuEsb9QxBmSNOE6CNiJv9kI0aCcMB9AFDVZpolaYKxYXJlelb+YyQAVzWfmUuV2ILUIZcaEmIyjI2akQkclWINRCiVYpM2QiMSCazAhA6ZDRwkhQkY5aKG5hDJMDFzgAgxqycm64KLlC2MZd0qhwkx1r4VH4KicoJsH5jQ8qt8dDU1PIQQcRMiKoqi1+tNTEx0Op2FhYU8z1uNZtZoOABARFXd2NjY2Nhot9s7duyYnZ2dm5s9cewoMwVVYGTHEEAksOOqznAQFQUGIFQCJdAY6bWai13VYdwCep3eXSWToQMqREGwkTQt+LkL19+/en330vIjfXnx737aOz976MSJZz7/rPP+6qXz2ejIyMyOQHDx4sXu6vr99z/UUsRGeurs6dml+XsffWR6ZDwsrb//+puAcM+Tn0ySZHlp6fT7J3funt5/6GAoyzNnzviyPPrkJ0jNs1xeW7x08vSDB49N797d3Det01MrI63Wg/feu/+oT+n9yxfW5xc/8dhjrVbbEC5dviQJd57+ZGdqbDTf3Ld//8TYmAZ58623NkwmshGAxIqShUfHp9D4lTfeXl1YfvjY/V4ZMAPIck7X1temd+2ynTtls7/v4LERdWDsMVk7f/MXf/nDvNt94MufP/HYo+uzqzw1cebCmY2N9U996umy0cBecGYYK75jhWA5ALK7BG8r5jxWb6c2hQFiEARBCAQxEAK7lQvXXvqv31y+eO3gM594/PPPHD5yggK887c/+sV3f9hn+c3/1/9z5sCR0X558+U3v/WdbxV5MeZp566Z9dX1n/7lN6+/fXLPQ/f89v/jX+/be2Dtyk0F2HPwyNTeA++98kNnybHjD3RGp+b6F9mS5YW1XoBjDzx86dpNn2tVfA4gdpRhlzh2t0yeuobeRxJlw6GZX9vAQc2H+hri1kHR3H5ZShCIDdhvS1n7+IxB8HF4wHbg+UOu+fZmxVZ1MB78hOrdqnCcWVUffriQxUe+XCBEJkYENVWLLYsQGIVMsPoXa7ZEitZWVkClMz/KbLk90vjLj8HZYlGCSGBVNEFAxIBmYIoqCADGWoWkDUzRDDCAcpYYU8mWN5yQvPWzF8/87NX2yMjn//Bf3vvoJ9cXF1fmlv/mz/9q/crsp7/0hfue+tTZk6cWbs7/zfe+489f2lmilTDxzCfffuOtH/+vf3Z4bPxL/+M3Djz82LU33su9ZmPjRx566Mr776ysbj74yU8cOnqiaI0gNzY3+teuL+w9eGC8fWa91AakSQktTftKrLGxEdTdLyqgfJCiPuAd3v3BGAJwXoTXf/rSlTMXH2v+/rtvvnHxBz9PmtnhRx7fs2PG5hZurizuu+9EO3GLC0vnz5yZGJ/Yv3fvSGd0pdd79YUXjj38wJEjRxTg8oULly9d3Hvk8NH77/X93lvvvLNZ5IdOHJ/ctWt+Ye7dN9/at2/fnpk9o52RMi/effU1Unvw0cdao53OsaOn3nizv3Py3vvu2blj1+ry8qn3T+7YtWvn9PTYSLtI8efvvOYevGdk/5HkvVMdbh0+clTa9NaV08sO/FhHpya1HygvR6fGmjv3n/7FS8///GcH77tvx/QuStrAzSTrGDiibP/BY5f5nV0H9060R1SUkmaxlp/5/guXf/LKyMyu3/yjf3nskU8uF6sbDK+8+vrjJx6c2nuokb3BhScJEFt8VVOXYwVpioWrbqtFfUv0NZB6thC5HGgh1iGmQYCjtiqBiEhFozsaq+1GasGvaiH8CsaA6YHRiMTYbCLLMnBFUZYutsr6GI94cWrgvXchNp6qWtPFTLK4U1ADgAYnJqE0yyJzHzFHYufArBRtcloEj4biiNKkMA2iznDdhxYmjl0pJTrXQzDm1EsGLlZPAwAG9GKMrABi0nBJI4Az60NhGJstOAUrTR1xAlRqCWAJkAEEMxMjoizLEvUhEhcjaPCPmfoGADHxOiaHRDtYVcfHx3u9XrR9d+3a1e12t7q+RQu43W5PTk72er1er9dqtbIsNY3db2MqugEAU3SrqpoyAwlWmxcVhWtQSDHGvAyQFJOPkH6ECimSMBXeQH07MAH1y5B6cKVxrqnQzun9e0/c+9aLz/eSbHL/vgtLN488cP8DB/a//ebbu5/+9Ps/+LuZqckHP/vZ7PqlvY8+cu7d99qdzA7tOXHixAbS7M2bew/snkzx+JNPXDx7tjEy+ujv/tY7J0/ueOTBS6+/hWn64Oc+u+bD8We+cOq1N3h9NWvfkx05+NjxBzfPXlkJ/Xs+/7n3Xn/z8Bd+48zLL3uVx7/ylZ//4mfz66vn5mdt5w63e/rU1WuPPPHEkfFRLnNToFJbljizC++ccof2/sZXf7vo9hbfPX/l+sKB6YMkkLrm5vJa6frTx45j38bT0ZWLc2HTj1BGPRvboLGu2zh53T38aNbu3Fhe/sSznwsmMrvYFe+w8vQRFCr9TWzGcpfZZWCKKEMl+6wi8cSCUWCIiqiAxilSyl2h1eLqO6cfeOChvTt2O9e859Cx9gMrMNLYTe1L586PjU7s+sTjX/96okVx5aU3ekUx1mh/5rEn1zvTI0f2wsLq7JmLtJl3Os37T9zvXLY8u9Tuy9sv/vxwAx1xkxqS6/rcyv57j452xjNwKBVIHd33KpVjMEmG/tWz764T6+67/CMM3PYxxo5iFJ4ACJGQnUvJBvyBYUrDP8H1fsAYEB5i3smg8Nngq9spGR/xwHf6gFtbPurB4iqoL6Xi/lLU5vEao9Sq01ojQ3T4+AN6OAKAfjRk8lc4ang0+rGxdVlllwNEimqdkIuGVWv2GFqr8mBMofClIHV9WTrMRaAnq4tzN98+t3fvnoAbY+3Jpx94wqbXZ/Ye619fdOvFrubYlz71DB5/UK/Onn7zfVY8uvcQPf3ZXWlrxDXXLp5OPKSc7tqzNxufWFtacQKXT55dVTj86CNOucnNG9dm73vo4cN7Dr55+jQJOq9OACr6dFWKB6L7VCmCW+76LgMBwWuz2SjJpCiL5Q0NxOZkIx/tjD302S+0vZ2/Orfn8JGi3by+uXLPFz59s8mHj59otFrn3z/5wOefPprR0aNHl1ZXl5eX3KHdrQwf/PwXLl65LGg77runo2Hm3nsuXrp09BOP+3Znev/+kcnJ955/8ZEnnzzcTHyQ5uFDZ8+cbe+dnj/tpp96fOrEiTPvv3/vow8cnBxt79y1a/eeiy++eOLYg0cb4FNezLurzcbho/fM5QVnjSe+9pX3Tr3XJ1zJi5ZgWx2vF+tvvn/vvY/uOnBsZX7u9Pnz1vNjSZtzwBwX3zk7gtnY+OT0wcO+m+fzK2OadUpqr8nYqqqsLp+91hmZOn390vHxyWe/+vUxal586cUiL8codaJNl3jxsdxZbMpBVYp2FKPbnrvV8ef4QYG0qpYRox9RBVQavFYNFHvbYF3e+2MorLbEB2Jl/YKZKTMjgwDGXn4f89Q3BEAEtAooISBWtthQepjSxtA3UJGmYUpODTxiD61MnTH7siREohQJTIMZeeYCKIA1iLhPhbE38+yM3BopMTWAyyCpYZPT0gK6pADwDLl4E/RgTYAmUKAkQBCVhBIALE0YKVd1lJhpME3AxcpOVLHkqljcr0cNl75k5CRJnHPR9m02m1mWXbt2rSzL6elpIlpbX9+W+tZut3fv3r2ysrK5uXngwIGqwSAiEwmhAjKhw6TQUpUQiR1HkwQNUQkVq38GVZm3+GVcihBZRHdnYKKBlgW3stSR60tTlBVbZA2gBnFiqIBocuXChbd/8WpnbHxi18zh3Qd3ju8s+/mYa65fvPHWi68mj9sjn3ri9Ga5sbJx6P4Hls9d4NHRySNH3njxxVd+8fLYSOfpZz43cfhogYSOm41G6+aNcnn1+hvvpdMTB+89fv/+o+XcyrsvvJIcmZ48cujAgaM7Dx1vrYSxhmvunlq7PFssrJ994z0BPf7kp/O1vHt5du3q3Mra6uF9hw7vPZi2xhqTWF67VPhAIuxhvNFeW9/83re/M3ri0L3H733gySexr2Amwcyg9P7yjWsjU6O7jx/qS1i7fFFMA5qxlk3yPen2Nix10zt37ZqaevetN6/fvPkbDz92370nLr3wCllGqEAqER8iIAWyuy5uQiCMca2B6QBQpzFTFHsAaA7LBFbBdxMhlFKDpYloPjoxeezwwazReOMXr777yquHv/Y7Wbcv80sM0MwDGjZdenDXbu1Bn/H9H/6gf/3GuNF6UXaaTStLBkuJ5+duTvc2J8cmEkAE6G+uc5a2ms3EkKp07a3CZ0G04v7aNtytLmN3l/HRMOJf5cDtja6GUXY1Daapo7SR+cSFvIAhNu2vJ5j4Dxr4AWO48dsvpQL/sczfmm8FRJQgUkzZEa0ElNV5CWaEWpXjUCAA0uE2YHe9+O02xbYsBvsHf1t/OWyTR3b+dmu8QoK1LkuOqqgGQRxQK80URFW8SLffb2UtTjlrZQEsaWSHDhzIRntLK6s/+/lLe44eTtsZFf1yaSntFy3DTGx6ZGzsyLFWHpbeP331Z6+MKPV8maaJZ+qvrzZE+4vLNr6QpZkDSInyvGeOpw4egtOnAMUlDKRKGkyREDSWgayBkqH18BEnCyoyKPqSyY0mjUQA+0XqbYSSlkvZ7PQrr77/5puHP/Hw1MzE1O692YGDrQuX0mbr8pWrL/7i5UMPPNzsdK7ML+x74P7G4sSZt9+emJ7ZWNt44bkfFiY7du386v/wjbTTGc0WWq3xsfZYU93q1bk3nv/5vh0zh/YfLkzff//kj378o90HDkyMjI3PzKQjndHJHWl7ZHJ6OmuPzF++8tbzPz80MnFo/8zZ9c2iXF64sbC58+CuyR2t6V1J1um4ZprLJDXUNtRhT8s3f/5ia+76jsMHDj143+iBfa/+7OdeFBAtzS5dvsqb3b33HEknOxfnrk9iKhKUsBAPqVsOm12WbHxk3+EDhS9OvvnG/XuPTO3ZM94Z0bVNEJ8mhCqCpsAKBkYAJKSBdJskumUCxqlnynWzQ66Qj1hAmBRIicRIkBRQzCK6BnUdho+P7Qsx4EZIdcVcIjQDIk7TdNN3lULaan8MBewto5IECBFrQEUAcM4xx8wKAoiNwNC1mg2XhfUuKhYqBaF2OjDWhDTLFGSjv7C2MdlsQeGpkbR2jM0vLaSNdPf+A2OuOX/hysrK4tiOnUXq0gb31RtRg5Jio7u0stFI253pHd1Q9px4sGaa+WCykW8srLNIghwQ+yYZOaJ0U40BkRyoqqkABgCtavoFRYtG/K+J++slaSRpmhZFoaqNRiPP85WVlbIsZ2ZmAGBubk5UsizbQn8BYGFhod/v79y5k53r9XqVyCKMJfmJgQxBqihIVDaVjgFwRqyIhmyxflhk0W1pMgOIncM+/OoZjR0FKYpgjjgFguCJApoQmktdSUgMXkuRcOTo8cNPPf3G3/9tyLI909MUlPNiJG00kJoulcKfefedkdGxR574RHNsQrrdRpqNjY7u23+g2WzmKyvn33+/1+/O7Nmz0d2UKcB+2TByYlL6bKI9NTqGnZGs0VieXezfnJu9eHkh9NuLk5tLK5gXmaFxCpSgQTvNdo1PHn3ooVaWXTx5cnJmDxdl1m7o5gYxRmvn8S9+/hx2f/CL5y9euvD1r/ze5L4ZWdvUTkago4bvX7625/CJPY8/+tb7b7c6extpCqLFeLY0we2Jnfc8/YkAmvd6nVb7wgsn5+Zudg8enmh3Fl3qSiGIWTIGsZoQsn405YJVOBIBkADJMOZiVy+37h0jidrOZlJM7HvknsmdkxffeL1xaOIX77xy89s/zXp+QbuUuCyUK6dP//Tb3yLn0vmNvceOr6+vvP3ct9feOZt3qCj692YNK7qZc5AYNJgYRYuEXdpIjMxr6SVkIw1sJd3Qi/UnByau1oWEfskFAQDwUTPkfuXjlgD5gINhdduCoJoH3/6nScz7ZcbHXHPEMQQCETMw1gXI6+qVHBM1Yn8sAwZjw1j+bJD1/NHGr6ieXmUjbl051anZde71NnO79gGrUo0OsIEuU7R+2Ww3U26MjI6OTk20s9bOIwcuz8/lZW99cfbH3/kruLaETOv55szU+NrVK6/83Q/DtZujfc24lYKdfPP19/78O82NTQv9FrgMQIjIvGmJ4lsMJOYIXMKGXtRTxkXIvRXeaReLIgklloCequzbWNDNttn3wzd9NzmFiEnier5IO2nwPgGXtJqigUJAE4+qDrPR5qFH7+9mfOPqlel+QWrBB1PIkNOskZK7eO7c6uzcgYMHn3zmc7MXLzKSS9z42NSx48faaWN5aensqTP9bk/65e6xyf5mv0mu6bIGp+trK2mSTHVGGQgVuPT9haVLZ87lqxuIuO/wYSs8lIVf22we3ut0o502Dh85cuihh+fOngvLK3v3T6XkqAhJLt081yaP7Z448vnPvfTyz3723TfuffTRT37xS62JUSazUIoPE53OlZvnnvrcZ0/NXz137tQn73kkoPB408YbMp7t2L9n1z0Hlq7O7d65a/Hajbdff1VW15/55FNZK9WeJUz9fJNjlXuoA02xqjvKnVH3LdfcElUKse0tskESc/zrGWdAAVEIQiyMXPu6Vlf//QcQk37tA6P9EikQBOz445b6dvuwWI8JoL7OyKalQa3sOPrBTtx7/NCBw2/+6Pn1xRVlJ83sid/+ramnnlzNu1z6dmlnXnz51Is/S9Tuvf/B9t4d+bWLT3zxi9BoUinHOTv1k5/2ffnAbzyTjHeSHeN+bZ1zf+XVN975+58ef/jhI099IneAo6105ySUweZXlt89+/YP/r63UVhZZolrNFplUAegoiralzJBytiVprlKAND6+uGXxEf+4Y/OLMuyLMticcxmsxnbYqvq6Oioqs4vzDcajXa7TTTU9qLX6zHz1NQUM8/evNk/cY9LEjALsY49MwaVoM45IlAzkWAmAEQAZBi1CBqxGVWtv4A0doUERVS0gHfhpAKAQyNST2KMBhYwJAknjL7s5kW39P3ScgUfQp9SchZgeT5x1BhpLq8vm8+lu14U3Y2N1V5vfXSkffDQnsX5+fWlueUbV7ti9x85vHtiLGk0Tp08lTqcHu0kOyYV9frGuvQ2mQzN592NKxfPT45Nfebzn4G9k82xzutXL03mMjo+atyShPK8632eF13XSGFplrXwUuw7tKdPAFaOjLbGx5rLG4vd/oYLubJaAr3QX1yef/A3nhw9sMMXYbTTfPtnL092RrLuGm52R1b6jatL1FmFyd3Xz507vmOc1zaZeMeRA1/6V7/XStI0y1798fNLp88fmtn5+See2FhfYe8vnD6ZmGcDBEFTAov9LkKdD/YhAwHY0FW9WKqyxwTEgKTIsVUeGAH6fj7WTJ75wmdwI+/snLx28fzN06d2PnZEepvQ69JKf0fTWcKW50aUmFooE4SUzLqb6MtQ5iBJp5HKpmdSszC/OLd/105qJv31DWqkvX7PJSzOAkI20g4+7+bdRtaBKt3NAI0ZHTvHPLDqsbIMbJulcguaNny3sFUaBm/ZB2/b3W7Z74PHhxOsAWLDpQHnoXIooltIpGZBBBDSNEHeKqowIBV8hCv49Y0Pgn6Hq9/DR7rsYfR+sPNgxuLQK4nVTO7+HAwI1WL6GxGgxRZYBBC5vwCxdDQiWUxqBzbgrWicYbUdqYryfsC7vXUrwQeV0P8Hq1dDUMUKe64KhlRCNV5P7LpVdWaoKRwAZhQXfAgpoBODXgHd/JFj99zbmGi1O2VZnH3t1U6nrWur3M9lc8M5ns6SMTHe6HaKshcCqAAWurmmpFD0E5EsydrO+TxHCPnGWhbysdH2xnWfpZkDLVaXCKyQstnJhMK1K+d8Cj0Km1h6FFJLQoX7Us0Yv2VeRPLJ3c1fAxEFtqBlWRYjWQuWFpwvmY3JrL+xujJvCVIjCb2NzAfc3BhB1PV13NzIvA8L880Q7t23D9IEfNldmL9y7uy+p5/++u/9jiH0895rr/3i8PFjR48f3jExcfHMuSLfDHlXgi831tZvwOzc7H2PPjrTGdu3d/97135+5srVex96+PC+A3t27py/dt0vLLqe39ka9Xnfr61ubqwfOn5PeWh/Kt4g5L6XF70y7xfNghk5JY9+cWXhxI7xf/5bv3n1xo0d07tXz5zp3byZLy5lhW+srWdimzfnpCx7K6v5/ALv3WRfqs8f/NRja5M7J4/vX+lvvvuTn+w+ceTEk49lzz47Mj5+7dqlle5qEvJGkggER2yIUjvYAISmidw19S0W5keJKUuAFDVC7NUEVMV0iYyImE3jC63a3EQj+B863f9RhgGBKdaoXZV8S6bqvU+co3Sr9/LHeVCsWmGm1aMmJlYvIqIDJAihNEh27mocPuRffFnJCWJoZM1jh9dXFl78/vdbmNz/4KMHv/D5m7Nzy6cv8MyuVbBDDz7EM9N/+3/8H7bZ/9RvfnXngw+89L3vzv7tc6MH9zz8m//8xmtvrb9/rlxeawjtOXysf+XGu6feS6fG7v/dr82ePLP0ylu6uGGFTE3PNCZGmGjp5mxR+H0z08vzCz7P9+zYq/1idXnJIbJLFIyYsjRLzJfBJMRcMICBdPzoqvYfMgb+WKPRYGbvPRGNjY31er25ubkkSSbGJ5aWlvq9/ramx7t27RKR+fl551zWaMTthGRMMaM2I0IHcRUAoCqgmYCCA0tAyYwMDVAqk59iz2pABoUKxrgb+QGhNAV0DXSE0AcpUMhx/8b8qed/xhvdjqPZk+/jtWa7tzn/7pvJ5vLMWGfl73+0sb7he/3rly6PFb3y2qX3v79+c2EuXN49NjU+d/7c5XPnCRGOHE0Sd2Vhcf7aNbt28cChQ0J0+fLlzc2NK9du2OpiN3TP/O1muH7z/PX5fQcP9q9fPPX8jzcvXD7fOHVi/1Flu3z9Urm2dmF1ERevU5ae/e5fFzeuvT9/bWxifH1jfWxsPGN+66/+2/rGZl72W+gS7w0IWC6+9NLGymxjxwRRcu7mG8vvn6EdO2T2Ji0tXVrddFevzS2sdk+dg/NXVgvvCr8OyBvryrAqsrG6dv2d99Lg3/rOX+8+coBTPn/1+tr1q21AnyBiTH8ZQESCH6EULgAaMpkxxM70oJCIMoo1TDLJWQMSbV66dvq/fafdaJPCtfdOXj55GlfXZ3/6i35RpEXZSBiRNjY2z/38F4bcygWZO41WWFg+9+3v928utdJMzZnXfgitZkegvP7uuaOH79+9f++Z2fmM0svvvp86V4YwNjU5Pjpx4d3TXELSSiMIwWZc9RK1yjKxYRDMyACVlGKPzypoXYe2EaCqf6UAQKpbX21D0QCgdgQgWhjDI5pht8xa3IJGPiioXRspd1jbhhiBdiBEci5Dptgf8ZdnEfzjDqy5GQAQC+7ecp3DmeB3PdjQ/7cP27bXRz1g/BffdkyAJiSHyNEgp1g8U4ENDEGowk0NzccW3YIKaECekCySCWzoUmsouYqN1LhrZWTcYWw1UooNcj7CXRiiAAhi7JpuVVEjqucTKUZvANNAGmJ5ciA1Bi01BAoh0SRF2Fi//P2/nxwfs1LXHV++fLF37Wpzx45L/Z+kKxuJS5jQ94uNixcvbW7QwnrLuNVsWIAbr72dM7bFEiD10gvBJU0y3Zhb7l6dm5ne3z99EbzZ/PLlF36eL86lqR6b2hnmllfm5jJyTXJkxuwQEhrkECoCGFisAD98u4ood/USIvffJQ3vLYXEinD575/Pe92M0NY3L3/vR7a0kqx3T//t383sm9mV96//n3++urTYyxpFP9/Z3bz6/e/l/b6q7Tly2Dm+dOnS2s25N+fm9hw6VJbFxQsXV1ZX0tn5yR2T3ZvzS+++589dcIAzAAtvv7MCbvbmzbHlzWazde3MpbUrl1dXVueXNnfM7F69/O7CpYvFyKjPC7fRmz15Nr9xdd0X126udRfXLyfnm532xs3+2++83V1bE6T+0lKCyMrdpfWTf/YXe44daTYay7NLF06dzVfX3+4WvpdrcnlNrVxYePev/nqlu5ZsrF7t/7y7sf523pvqjLGH8y9cvXrlUv/6wo25uWxpdWzXrt6VhQtvvNnoQ4Oa4oVc2yBOmkGQwyjSxT+czVPV1lEhVDAVL+QEVCRQEArCrEwEgMyRWIS3FH752Igsq1k2WwI+ul5MBElipCKSwEcm3/wTjWGzEBESl7AoBGWKbQciaxvMkRArgFLCxioG7EI7vXL+zNw7ZyZzeP/szU/8f/7N2FP3L64tt3ftXLh8BTFlzGbuPbF6/fqr3/vORNrI11Y3bt5c6q4ffuTR7uUrC6++nrFr75rg0eT0i+/ffP9UNjF6+DeeuXj5wuob77GH9Ojee770G1maIqfji0uX3nrnwOc/M7Iwd/nixROPfXL+Jy+uLy02AUvQDCnlxBGRktZltm2QMQIYi6kp1Iy1X+JBbe+8HedhbI6dpikAlGXpnGu322VZdrvdTqfT6XTW19dX19cwor/xN41Gg4hiec49e/a02i0wIyYmlyMAGFZhDlHUmPrCjMbkvfRCUagPZEQQgsRy2TDIpKpYv8Nd3z7kxaMgmyHnagA+1qBTgcXVjYXVBiACyfycztsOBFhZuL44W3WXRkTETbNJcjJ7ffHmtRbixtzsCqigjTIDwI3FXxgAIe4g0itXLly6BABENAK4OruYYQr93ub8QofIL6+ev3JFzBRsmhhs6fz5SwbADB1ni0vzHSbdtNmFuYyonL05a4qAfa1tUESGxBu1kBGEERv9/sqrb4sqGBDiFJFeu7J69bIjWr5+s0UEa6tr167MONIz572agZ07f75KlEacZGSyMHvz0s0bAEZILSRkKyu0sk4wtCjv7g49BeQAmKABBkNVRFEOimTWUM++j+YNQBZXrn3/eahbhiZEDaTeW6cQqQUIBCqhDbhw4aICjVGCPqAFX+RLqytMlCBoIQCm7DbNAJP+pbn1d8+MZo1Gu5kw+dnF3KCZuKmREbfRu/bm+1lf3ShiUDZwAKimJhpiXXuo5lOd1UAGbCRqRoAIA9ZHzZVERJCKcoBQw8bDMHCsez8wf+OOCNsctUFJuWjeRusk8kMsEoCwAtHjn/EoWE/2bS+jqnpW10eJBGzRgRb5eJq/UAuaAdJzC1D9D2REfPgN/hJxyWE7dQsdJWImJjJEMoteHgqCoBkaqRmYZ1UE0soz8kRYofaVDjKoRXPdvMwgNjKz2IVicNHbwg+2dUFQT5gPYf4CWOTba+zPvmXTV6moBihAgohAzkgUGZARCYyMjABS7FrfyDdCMf+zX6wgBmSPhkS7iPTG3PK12YSIEUEsQewvLW8uLqZEQCjiEXDl4kUAalZ0XQKX9IMaQn9l/dpbJw/sntmxc8/K3Lwsb6yvbUCK4xMjB1ojSxeuQtenTJ3gUnUEbOxABInAYJClfttLxduYQXd8sQjMoNAEBiQry+Uz54FwxJH2e2vvn0bEDkJ++vzlU6fYJK7jPgAh7SDcOPlefHGXL50HAySaYs5Pnz536hSCJeSmEdZeeWVFDQA6zDI7K4hTSN1zZ9h4HN3NF1+Mb4uIdyCuvfbGqr0OCAlxb3YWEEcQu7M3ZQ5GEBYvXCfEwsAIFara8D2ABicMBmpNTv2Vmxcu34i94Jh4EnDz7BkCjM2uOwRLJ08iwU7EzdVzCcLqzbk1MwI0wIRgBzEU/dlXX5sLwEYd4oqLaAxYd8HeWhFmKHcvMYdgaEoYCAOTegiMgmAgaOLUHBqDqEqsUBiL7w4qHn68Kj/E+pJbfwEAELFLEoFCVSn5eJGV7zhi2wuq2q3EOjkhZXaOo0CIvr6YGZAmDQ/csYagzeXBh2J0fHzCkj290C2Wet1lPjBFM+Mtx5vX5s4tnJTRkcefeNKeeXp9dfntv/ymlvk4UIOylJK09CMgJjq1Zwe78sbsFSuKhhijYSPpQIqNdM8XP6vHD73wvR/NTM489OnPnLk+98byylOffWbqkYfXrs5evDnLag5EQNgUVCUERSVOHDpiB0TGW6kaFLmXv6z5C7UmGsxGRESmWHkz5r3FXtmxnEOr1VpZXcnzvNVsNhrNLfLD5uZmv99n5rGxMRHp9XqAmKWZF1WRxKUZguS9iMtH2yLCIQlzK0uzJEnTRJzr9XNkViIxU0QD0C0o7iPhIIzmtoKehoYMlmzpkpiZip4wIJPjgeqrzZQKMjEAB8BalzOAoeKT1bIYmnAEFh3cegMDksUCTDhAcxDMwRDeVyVg130LYpMiMwSgGEOC2PEPGSCh2DQ5Cv1B02xzRFVbFkTDEFWggWY8cBYMAMgYIa1+E+9gq9xvpVqtatxyF/Q3+hgIZKgE0UBEQEKXILuYFETEiOzQt9KqnDWAVa28AeL/lXVeiXutUOdoiVcvpM69jcAhQCj8yZd+0mw2Olxa6TvkvC8RUVZmz7+yKfPzTdFmGMWQmwpEDgTEIjsJ3irHTRCUNKJiulVdunq0VR1vAI0FSIaRWdhugNzx8y1w1a0mS91kqmbA15ZwDQ7GJoADq2dw5trVNTOratkI1l7o8GL+GI7brfOPpS4ZApi30g+q69TbQPlBpwCsZdqdIfut7Rj7LFYzHbbNjMoRxQqKUqwaI2HN47uj+bt1aKtVgQ0uu2b3IACAZ+hnGDLsZ1gmLEyqmHBiYiiQYZKZa2GWEngKQvWCRYCKPVTV4kOKlyGKlWCsTCnDmPsaG58lLtFQLl48bWvLeVEKMyIQiRoUIu++9153eaP06pIGGBFxsFBCP4dAVXfhDyE4fITycqYIilAOYjIJwEDMUP1MXRTwSFDX8zADVUPk+NBoIOvNXCzwBQaq1bON1fmtRi+iQLMgWAx+V5Xuq/8cSFhTYAA3CARU4QAc1AdERJSieugKiODqcpOgEuNIkeuCAKbmEGt9Ut/e8KLTWvAmUZuG+sxb82RwaVW39bvKEoNY2deXCg0GwiDm1RRYmcCRIQQ0DyJgKTNBVfhl+B7vdo5f78AB3m2xdoKIKJnLOHJ/P7YCNg6CLcNXRRVVRIGo9r4B4oJWcJ4sQM8sazSKvJ9ikuRApZUCm6ZZs5O1JnTh6sTefUWh+c2lyZkd7z//0rkXXhrbv+OeTz/6+B/+i5//5/+99/7Vdh+yrjojS9M8yNjhQ8urq6Hw7VYnpVRK5YCqmDSS0enp9syOY4/e38RGsblasP7spZ8+/Pmndj10398999yNjcW9zWzVFwWgNjioGAAhERIBO+eQa01Xm781L/iXN3+HPyNirJHqvce6LXae5yMjI6q6tra2ubm5Y8eO2HlqW+EzZp6YmFDVK1euPPTgg4lzsYIx12WiHbM6JNLY91tVQQx9yDwkHrTnzRthQsQAqsN2hCECCg5tuSVMvPVSlUF4S7zgNiVWoSJR/ZAS317kYPhxxEaUFGJG11a5OdqyhqLIitTkW6VxnbM8dHADVLyltILdLmNqVBWHVFvsrTy8X63chizY6nYNY8POreMRaRbpjHVWO9b1NCE6CVFXCIIMOQ+3icWoGkgRCNAwQExyAEJgUwxeLaDDhJRRgY3ZPNk2e3pws1uGnSJXlm5dYxIBwBArHK22haFDkC8vUZI6UwghSxqJiJrpxvr62nrTMCNqSMioIj8ZGHPiXEK3VQ2JxAdF0zoiHdnABIBYm6dYxVwgbre6cEQ9BqFlrV06GEalbGsj1reGAEqmULVzwa07rv6ESuvH321jxSFAdVdQleNi4igRBgSD4WjOx2cMKzkcGlBLj3863LpydwnIiIgMLRY2wYHsiDRAqBzL+mdQ0WpZgQbdD3FAE68x33oqVBZyJTC2jgAAw+sfYZv5HasLD1WaurP5G/1oUrDYld2qg+Owzw6giIGsz+qdlQwBQRC1coYJ0XkFDNBwqVio5umtY6tWSvyfJeITdYPuqoQ4KqITcQ7JYd7dnMu9mcuQGlkDQdB8KGVhbpE8NtN2D9i8sRAoECIxUE37rZ7bLcMQIIW7ZSkAKEEgkNv3Gy6jZGCKzjCJMaJo5COg3pbkhKSuWvTbZeP23QTNeOAXfeCI88fp9rdZObfx5qpVgVX3WLRBrKlynil2r6znEireqhlvf4cGFkjhFoE46MtV/w0V+5rv6mYkCiSgJiRpqcoAjaTB5AxIEAJZQLDEUeYUwbTipNan/djIq1iPAgf2FA7SxQiRqCYvfeys9VuHQm18mMXGtIklaPEuqvQ3A0jYoSMZycrdY/MgjeAoa2CrrXk37Bzpjer+Rx4FTi68d/LA+M5iczMRffyZp7sMr37zO9feOykNe+JrX2m4pBDTMoQ0DUnSQ+Sxkdb45IVL50Pfp+IgKEHSsXRVVHxBvf7azdl33nwVCtu//1B/c+3hB+9PxffnZg89eN/Ge++HskTHefD9UE46ds4RCGjdmQ85zhYyJKuyLehWatRHHQOtNEB/iSof2Dk3UEnOuWazefny5RDCjqkdjawxvzCf5/kW+jsyMjIxMdHv93u9XrvdHhsbZ+fKslBATtMyaAjSzhoFltUPsJplbOgCuIDmrSg8GEhRRvzTBvsZGkCgYSAMt3+oNSugq6ON1e8NaJuFCAigCAWZp3D7Y9vmDSiwsgtM288ylDE1UG7mTW4hZ9htCosUnRIOVRJAqE3oIcViEOFkuFV83uZz4kDNVpcxDCFsHQ2VnNbGc31KMIOqvWvchIoQFIzu/GyHNkbdoZkKggoqgKGRKgVGIAfo1NALFIaifItnpnrbbWw/zZZc3L5dASQou0ZeBJSQEPdCyczkkl7ugwGlWeGVSzHAxCWMhDGiQRhCsNvqhlS4EBoBxgQNGsaHUevKqQPVPnjmW67PsAsyjB4P9hy6pcGvDOrA9+Bd2fZXV93xLQoeAaxeq4iOGJxLYItZ+7FFf4dt38GH4Wv+WOoUHJ6DNkBUB3/UTlEE57SaCYjAWzjekIkUTZvaADaonZtbvUwDGOojU8+TrS+H/6w2GqABQ3VJg17ZW2t9aE/ZYgIBKqCAAAQgSdMuYhcVshRz7yD2wB06yx1WrkZaBg5gb6ufFYJXpDIgsXLiY3kYhTL3gj44xJRBIJjmm70iycCYIEVMe14p6MD8he0yub4UrDquf+iogjd4p6aNtvXwAVBBFRUNNXoO0T8hwKHOM5WUNB3qxVRP5u0GnIJ6DbpdFNwBRzVgqApNbjM8DYbLnNaes4sbtL4xq7IZakfZAOqOJ1sn2HakoRM4sPrt1tPPVG/rLV3VGP+wgQaJWKoWCAw09yFnLESVCJ1TJq8W0IwBE9IIiVmV8fZxQ1Irw7dGf2sHGNkxkyr4WAf8Y879HUwnImR2SWIJOPLbSzoZeJO1vHvk+IGn/9Xv2Vq/U8LJn7/aW1k++MSjMNLayenIzt0vPf/j4ub8ocPHZ996K+9vzC/NHfji5z7ZTrr52qHjB5Zef4dvLLXUIEMrN4qiH9B27Z7uIOU3FhvqoAhJw7LV/kgv9NC6RXfhtTce+mefeeDEPUbZjkZr4/LlR5/85LXX37h68dKXfutr+OQTb3z/h02HwCyIgMjEhBX1H8Hqns3/KOZv9MTE1AE0Gg1VjdzfNE03NjbKshwfH280GisrK7HSgxs+iqqurKw0Go2ZmZksS1WVKVpcRkykCLH3UqyPgkhIQJg3+EYq69PtyU8/VKytZwYavBKAIwAERY5lXBE84V0XigFGBz4KLdxu/g7v6NALhW3YG1rdnCYeKuJAjOBiHdktO8zUhsqyIgCgNjHU0M2w1Ts8Bpw8GpjmwxdWyTWEiMbWKnL7IQbbBs7B0M0PzK9h8zeeiO/YNARjTcABV9Xwjme9bRgCmqYSCEVIAQjV+ZIanVZ5fPeVEdjYP0m9w2UZyvqtDZwAq+XxYPuWczKw/hGgQtm3IWQ++GazAaImQR0H7wkQifPSQ5IoUkBuTIyvthpFCMQERmaqH2BxG4DGLvdqaOQUBxqxYrvUDQIwdsMdyknahgIOLnIraLZ9emyzg43grnhKlaZ3x8vG2nm8dft2VPVjNaow7nZ793ZT+J9iIMAA7Bl8uE3H1YH9geNbta232ioadnMjcaketxiyEPm4BlxvGLao49/VT+KxPoJ9ULtklZM2mJPD6G/cjRUawSxAUzAIpAKkiI77wfssGz18ACcmGkTel2VCUuHYWyt3cEdxY6Q5VBVKbIvVBhG3BguigIDMFsW9GqoCiqIEwganVJoV2B4d7e6f3GhI9+AMrT3EQXDINvrgqXGXJ2MRiMWtPwfO6pY3W70CJACz6l7ilLBtFmt89WjEt8Rk7oCvgiIZDVm8w8rAhh6pEASoLmNwl7XEqDQzGEROH9TJuLX5u5UXuaWbYPvf1QTAbRtB0TyaDNz26L/QFvxbXeDtkMEdhkEwVSJjMgT20iTCmem1jttk9YwZIKqiDxQEEX0dpPo4+uq1mKqeKsbOCxW1pPrmY1/4rMqKrjyNagyL3fhqd2ISTl068+ffodEmEvv1gmbnbn73R/n1eY9yvZ/L4k9nX3vzQKtV/Oyt9QvnUtI3f/j92bkrRx96aMKH1R88f/nnr7il9THgcn119kfP++s3UaS3uXHp1dfza7MdMST2/e6Nv//R2sJiBgDMl15/Xcvu9OGjnMnZH7+Q9v3CT148e/K9sNF9d61nvd4YEngPiimYhqqaSDRME+YavB6I6xpGvZsn/EEjHiOWeohnicWSY02S+K2I5Hk+NjqWJMni4qKItFvt5oD7S0TdbrfX642NjbVareWVlbW1NWYm56QsVTXNmhlaKPqcUEwlATMzUaOcYQnLsKNz/J5DVPoEEUC9qhECxErAyIpm4FkHq3igZm4xpASxxETQRdEfgZCBgIvTFivhnKMNoOg68DykhGtUABXpNnl36+xn06SKOVR6aFhyIkYVZrEVsFacVoS6UEDtwsfkFQNDtATM1eRXGBD/BlVLBlHy+CywktfbPP1akINZQAwDw3jLqsKKYFExGk0S3QrGDT3b2kypjykICJZqQAiGZkCoTsUVjeZcoovSax7ft2d6R1pS6RK9tbrTbeavWUTRDEHNANEIre4tSbHdiQHGEngmjohU4luJdWgUCZMkFw2GzWZz5eLFlfWNOIlEhIkajYyItjfPtcj0joyURMAZEpgYWAVYm9t611olZMKWdXKLgWsAt9dquH3P+BYo0rijggOo6M01+3Dr+dyyqKu3iwigZqKGcZXWsqB+qx8v8/fD6X0DFfhPdNl3NH+x9jJut4OH6OG1a421GVJxzbcsDohbAQAR66TrLal1qwcIAMPEUACIJmb0pmpbdmuNR+ijggBR6ynzIc+RDRoCqNBSDEapUQLkAdf7fW0kBx65r62UGHiEzSTxjod/O7DztsxfA8ItO29g/qqqgSUu8SHEFC4ic2SZCJkZW4lSqiTgUnFkSd8lS62k38Tpxx7aue/IiEKsYKFRVNwucFEASsBbu2HfNjCgiw0XYFDRtkokjKkAFt8gWSCU4fNs1wbVUCSPiQEPhFi1c22pxpfGgCzDmY31Y6swhlp2I5QOJHIXbMgCtiH/NuaPAFIE9y0yroY5GtFINYzGMQ6dKWoGGKK5VRuNVenuNpwBBqvs8w8bYqoJqiMTzYTAkBrZxfnZtTJn0wQ4MwSxVI1cGhTs49fwohqD1V7LASIkI1VVMJcSM6vW0/Ij4ET/JCMaIgoQWxzblojbGgyQanBXr1y/ermfMjC5InSMCOnKG29voBhTE+iwcGO1u37zpiOG1I0GWnj5lc133tkRJOv1mNiRJYjlytr8629lUrZVegsLN+aXslwzZEDKC7/0/kkIkigaWdb31199Y/XNkxZECmll6c2Ll0bECHTjF28g6QgDGPbFijIgIBHRYC3UrUPhV43+xkBEtKXTJP3/s/enXXIcWZYgeN97Iqpm5jsAh2MHd4IE9zUikhkZGZmVlXtW9tTU6Zo5UzP9l+bLfOueLz3dVd1dVblVRUZkbBkRZHDfSZBYiM3hcHf4aquqiLw3H0TN4FgiwMjKzmD1aTk8oMNgbqYqKsuT++67l4mqqhIR5xyAGOOBAwdW6pWtra061EsHl4aDwTCTH/LuFWOcn59fWFjY3t7u9XrEXHhXVZWqtdptZQ5x5Iicc04saVLNdkTWrm2ulzrrg6ufvtvb3PTMZsmIlQFjGYe/gCYOtif8RUYH99y3AUpUoVQINYsa2GCmROycq2MdVMUJzBxF1mCa8rEfZkZZ355u/UBLMIWJODPTlIiZic0sC2RkcjOSeSMBxZi8c4DFlJoid0CcM7UYowoFZ5GUDJ4lVHWrLDUlAwzGIgrUMRCxozYnAUhYiBBV88G0rmsRYSIRUbOU0vhgyt67lFJKKsygvHU0pz5FMI4s0JSg5sXlCUIsk/BXCWRWRHPjE//N9X0SV417viaGoVBlhEn4S1T2xIdD8w88d3prd7NY2e2gZA5Kt2yidx2GbEYEdrLb67XabfGujoGJkbTwXmMUYhgCkpoRmRjYtDmXiESzACqct6jSsVYiTTHGUHjHLMxse9hme7/Y54JntZJYIEmjmhG7PG6E2WLK6ioTEbQmcDFjNGdr530+QerkK/aA9Kqalx9Ty2u+E1/VI8C89/mUaWZQK0of6hrjE63B9NZzVPPZTDlQVlUvUjpPt7Z79Pavo4lISomIRCTX1U4ulfbIov062l3DX2bOAY0ROM84Q64pGtu7mDXnTYWZkXgwhxC8dznbQGpOmIlCHUBgEWqCJm1iaOKUEqVM9crA0i1kcGByRjNhiZpY2DQHOuqYo6ZW0a5DnWIS70JKEKdAo666J4HUhNcGMhNiGpvUqCqTU9M6JmMajEYWTVIyY0ZR4l4zFyBNDGKmlJJ4F0MUcTm7LVy5PLbNiJIgFSmxqbGxmCfz5lygglsp6dKRg97NfvTm29gcDiONA0rNZp93zAH9kuEvuVYVLZo654yQLAHEzMJMCg3RswBmqRJOk7Bxsu7drD8jAhABZXGujCnGFL14NVVVlhzDQpOmFFu+5RPhNjZcFlaw8eJgpmQ1U9yz54wfEwlTczFmSROZiUgeVy4rJ8DMjIl94eu61qTOuYTMoWcby9OKyOT4MFkDhZmS0R0psbtMQYqGe3Yy1BSOApsBhUrQNHd4aar0M+RjImckRmD24pTZUtLxgTB371eF+4sm/M1TI78QU1LloijASDaIMbqb7NmvaJusHHn7FxbnHKpwk2+NfKhUhk3BJMSQfa7BULSgICRNhaIAA1obkrOkgVXmwDoaqBoL9S2aoylEDkkid6AtQjckSnEaUpgNrCqEJdRtICKFoFMOpMlXBjMhodFIGsEAJVhSzQwrB5TkXI52Ke91SiwiwpTwjxT+5jYhL+RFP6boWESk1WqllFR1amqq1Wr1+r2Y4tLSEhNv7ezEGByAlJKZLSwsLCwsrK2tjUajhYWF6anpLBfcbhcj1RDiNEvL+4pis7ezEJGptiPmh2iv966899mNK1cFZpq40SUHj8NfQjIOE37sXlBt70g0IJEzGuvPA2yZq0DiBcTBUtAEghiV4ggIMQIkzBMA/Ga3NDBuSjp2vskWHswxBGLSpOKcmTJEI6BWlKVqCiEwN0h9StpUJYAgVKNmTxaTENXDaqrdFpakWoeQoGBGtjBQKtQR82g0AlAUBRFCHZxzeZsOde2KogEKzOq6NkNZFCxcjSoRKX2hKYUYCGRCIwpEYCJWCMjUAGPiveEvAJeB2HFnNnDUnmmTfwrslVyhSRASqYFJvSbpeTf3+EMzx05eeu/sxjsfdRLC7ZV+d2tqGqNzQsxVCpYZyQImFpCFlL1SiDg1CWMTMzJjaDa3UOYaUOeiYd/S0sKRg1OtVt0bATBYUr0r95dBloxBbS4ooA41RFyr3Q3DyNYufF0NXVJxTiew7QT/bg5FYilVdZVLJPYeyCZdZjnZxASmZFBTZmIRBsWoZuadA1GKMcYk7EGIKWoyErk7jmemqo6oKLw4qdP4q/bS1r9KWUW6o/2it31FrrmJQggiIk6Y+KZc/PgNe++BxQ1DnQpfTHWICDFUo5EQwxTJisIjM273NDMLFolIhHJAlkMWutMII0vxsJhldQEmYY1mICapRnVSdeLUKJkxmyn3h4PpdsuJq6i+bZtOQM0wQc2oG6UXOGbvXNjtn/voo9HKmktaGpcRcm/HA0BViIk5aUJOzojLQoNsTfWXoWETFapkaqRBLDFcYhe55aYG4g6/+Mxsa3rj9XeHV1en4jhd0KRtgdtmAtkelPwXNsowsSqY2Wc7XlXAVJkYyaAqaEpQVez2bxmnj/feLZOCckEUmVkIAeP4vCxbzFSHWqOV8HzrsT8HpinFm3lVZpVbIuRxcpJUU4yJmZ0IiwAa65HByrLUmJioDoGJjBBDLFst1ZQMmpJCvff5BBJjzHReZslAZj7oGeVeuPPh3jb7bodBfkGzBDXHNakSiXGV0v4HTh578vFpuKGSoKkYZiIFMqhGe9R/7/EU/wkbjdlrTS4VyABk5kAYizRP/qsIMUxavjgeK3nlk1I2PSa+WdmjQIIxUBjUzBghK6sCLnvxEqKpIwiTxDQD6mlg79vRnNBAjR2cGIXIhoLdNNNuHLVYwDaoY5vEA4GsNu0oHKxgABACNBrITDmrWiGjApZgaby65keQUoJn55yzMQ78j0p+2Cu913gQJmXn82kzj9WU0vLyspkdO3ZsOBiurq+qpna7k0FEA5BS2tnZqaoq8x/qqjKzoiiCWoqR2XnxKQYjpcyuGFNohLl0zoM8qAVuEQkLsphpA1dAAILx3dirtw9EU2CUGQQT/gMRzCiMVBmRTImkKFJlHE3YpWTE5IiS7VV3yJ8GUhVT4ZsLmVYpy8kyU0oqpppUvDfveoNREZOZGTkCNCbvnI37l5k1RQMcKNapJQVLK/VrTcrMrizMrI55l1S2RGlQeK/eoKaxImYjc5RGVSXCZuZSMLNoWnhvzkJd+1xxwUyAjfoYM36MfE2SVAUkSkgq1kDdTfjLTVX7XVX2b+tkAypDMhRqjLELgGk0CjHOMM865+uAfr9Q7fBNQuwvbGpk0EqDpqlWoUCdovfOFCKkVSzEpTowE7zEzNRoJIqhGQ3zRTAbVhaMFnR21pmM4TRYrgCQO6+DM/yQjDLXhxwVrZHjkTkqqBIq1BcOqarNSc4vTtKLhPwrVpRFXVVmcCJ7ldtuprYFRqSmRARitdSva8Q03ZnSFDRpBIUQnUjSVBY+hDoLITDJbRecMRMzM1Nmds6BWUOYVCtOntRXdoGeIL570d/JK7+WK7oT/UWzEozXKh7XP912gUTi3Gg4Kpi5VYxUQ4oxRQe40guxRoVGNW3Sd2N6LAhGFg3OS8qK9FkNaiJEuOf4RORC0mFdFUXBRKqWUhJxdQwizmAmQr4IqYbjSPBeEqCEaJage6VciZAYA0dW8NDTyKMWi1BVLZlnwcXuwDa7c1y0yFyq3V1Yrbc0AywpESc1MJKm3FfMWVE4p+DMgEAusXcKtmQwEiQGJbjIllRF2jHOEDpad6w3ZTEDcTl1e5f1Q/Me7e68pL2NTcsUSzINWlVRmSBsZJTX8xCdOCSFGorWKJLddvYY50NNUy4fKDgVXIeqMmvYeUQsnINRdjTSpCKsRKpVIyd+85rHJCVHDWtNlQL21hfmIuIcsxIzQBYtVZFgReEcIwwHqgY15x2pOe/7aVDEqDASVlMQyKLWmkdddpnRWIUURVic06RVqOG9yT2Tcpn/Vdwz/I2kliCkysxQmJVqTtWpiRpTzqVxHhfONUove2H1r0jLc2TCe8kdKMhnFHLiHPu7ZiO+Us0a7TOIMFNjGy7iWPawu5vEUhNrOoPmSImggIydI2NOWJnNKYidOzQfQOXq1jSoJkitBYGMioWFkaE3GDK7AMC5ffMHqq1uN8S6kNnEVoWYMdoxA6wmUwKblWPiWA3UhEQQy8GhJTNVJYgXJ0qUfTL/8cgPACY69AAy69eJlEVpsBhjzlXmHzqdjibd3NwsymJmZoaIHMYhc6/XY+YDBw60Wq1erzcajZwvYKjr2pelK1oYhRBqdiLMQE6AKDEFtT5Cn2PFKVIyA5kyg4HUYCxkRtmY9/abvFmI0jRqlG6Ubw5lmJkSec9VltF1XOnAF20Kmqz2hTfTmKrM/b+9d8ScMROllChL0OUhJVyH0CpKYoLDMFQJsTPTqkPIRxRNCkFizVm2MTdMLSUn7AtHSSUbl7hMuOagSmkcQZH6glkwGgyFWbyLcZRMYU4KEFvhfK/fYxETDGNVFCUxokVxBIspKQnyCUZTSlBFmcwAEmKCCnFWiFRr5gATlKB8p5rQXUqWmRQUs3SScVMHWIhAY7RaESIquFQCFEb3JJk18AKTF1bUiYktEbSOIQXrlC2KlXBiIGnOHFouaqOMTDPnlEkBaEqUBqaVmmkeM8Qizhf+tnWWAAIzEUxDVGJGUfRgXY2xUwatfYxzzFKFdlFWsEgNiJURMWYKMcaQuN0h5yypkdHEM2QvVExkZKNQE7F45wufYMQ0ggWzZFaKGFEUTonUUhUji3jvjThnxu9oRMQGqCa2sVg33YwjJ2/65d3+T9Ym+9yd17Y3CP7qhL8TqGyyvMgYSJkQNHNusYqxNT1V90fJRD0nsqgWTTmaI26L91zEGNlUmhrQZlAoUQ3VLBcOJUsFOxaxdJtKICLMHCv7JDJKkRkkToE6kRCc9yGEkIIxTLiKMSnanbJKKSBqsQcyGJ/JlEwJKqSCxMji8oVZhzCdtBMxT0phBFfzvSXAc+JICu+UUhxVRVmoKpnlPYkNku8XhTWQRNZaMYU5FudFNSZLEAOnkPrEI5aYn0YmDmGMid5M+ykDxT3zz2zqLXpL0ZKnZE5UOFpqShMlkTNDYiFIIOXboHeDMYiIlZSyGakFs7rd4pRUNYkIyDQGYfWeiZJpJBLONRV7qHQEZGkFAzLCQEzCJAn50JwPV7koVvPJnlkNSaO0HIMMdZU0aei020gaQ2Uw58R5U6pjSt77jIhrXuUtU18MBPIoCjLVpCNitDocLCrfi9TbDJhbCIF3NjK0ok7VFqCJDcQ9s7lgU9GKZJUB2UqUkYhZWKOmlDAmXGIcgnwVGk1G2p6llIhYhDmqmeq9vQa/Ik2z4zfgxAmcxZxe0tsKhPJRmW9VCJgk1SOggFcKwM5U8ej/48+pM3Xu//3/G2xvSllUTjZDJUXrid/8zUE9uviz10q1bZhbmHvyj//48g9/Prh6ZVvqOoRFkpaYQjlZ9ilIjODABgmNEFYgBIESoOAEKBPgvXfOVcFS0pwlYxbA/hHJDzQ2IGx2Is56d5xfjDF675eWlrrd7vLysnPu4OLBnZ2d0WjoJr+cbZE7nc76+joRTc9MEyHG6JynoshRfFmWaZzObUg/xOqpLhBKtlKoZAqJYpJGhxxN0jlLX+5xaZg8oNtCMyIGeVg+WDQ1XlG1tpSAkSIKm3C0NEXmKJiaCMHISIUln5j3fBxisqjGRFQIDGaqpnU9arVa3C6GaoNBryxLKiQAwarucKcoyla7TQ7MklIKGvLyT0JSiMHv1JUYNMSZ9pT3rRjrFLUeDeBYSp/IqhhSChzNodDCa1I2861WXQfnXFEW/V7fm6ZWK5lG04RUaHTehTqWrvAig8HQknaKQgqJMdZqFUUuXAE2kDifQhJVcZyPgPls0UCbN1ONd+/kvH0xlMkIamQGAqvlzVLMJCWJiUMyErlb8HtrPs2MTEEs0bSu40ijL0snoi6lOmaGTSFigFok5uzK1Ug3GdQQQlTvxDvKt5NR7yxLdfvl33y6SZMxRHwMIHYD1R1LdaecPXJQUtVfXfV1LIUTUfZVs3EEnAdV0W61mGNVMwiElHRvunPv+4PGstP2ZbHb64EcvANRr45Fu6Uh1CKAxBizu8bUvn0hhlEMBcZaRzfHY6bkEOfcnBkBTmSSHd4bVn5FiAS4IxCnO9qd7/n1tr2lhDauQ2p0FfZENDk8qFOMKRat9khDEvadUszSqDJwrbGuY0s8cwYybTKbiOHLYhSiAwrvNFlIwdmeLJ6hYc6I9KuaiGsoexdCEFIiQatUYJRS0SqrOoBgUG4VGpIpBSj5RlpqfL0Zi0URKSk5JUdEZKZGbIaoYcSxLmEzBCVUgN4bHySI7/eHzsEYrtM2oeFo4J0TIjLLQE5ewvO0JVOQERsxUlTOLEImSFJOlouNSUFMuTwtMwKanMrNrwUSEH55ZGawYNFSgndUlAE6iHWwKFIYzHlXpcSOBDCtmT1u5bmaakL2ZiRmJNWAFJmTcxExGTJHMJEAGIagltqtVq2aNBE78E3mNWWaGjej34CoKSZTIi8ENMuvEZQIjCqGqAmwYOqIW97Xo+CcsHNro9H89Cycwmx9OEpqrXYZYhwZSLxqakBfbrgZeSNPKamNBdoUnse+JZOhdssqSQ2GSAmI9wh/gVJtKliCBjZlS2ZFMp9MTHNCVokSsRJJrpGYpEPHHOWvRmuGGe1JSeVbn3Bd8onobizpr1CjycklXzCzkLNQW6bk5/cQMRkMAYgEZygMMp5UiZD1TRQwEHOxZupPPTT93JOt1szGMx9e/uHPELU/VUw9fJ9JC48+nDY3t4tWIa48tBj3z9GTp+tPLtbDAVpWKg+ur1XDfisTtADsAZImkubNjkkgIw9iIyZ2zlFePM0m8ssYL8lj2OcfTn6YVF1PNiBVDSE457z3mTPZarWqqup2u+Lk8OHDg8FgY2tTVV1+t6rOzMxMT09vb29XVZUxYE3qfVE430+xTtoS9iTRauJceMBoqtc1abKkrMmlVBpKA8dklhIjcVbTJDLmRvr7ZvALytTXPROXOFphIFJiA8GMYMwRGh3PL+6X+ZlhqIiItzZbgyEZ+v2eGYrCqyZuwt+G9KMAuSIS1SEV3pkipLooWrP79nd3toUAJ/vvO7G7s6sxCMCM++67r9/tj/o98YVqrTEyUVm2Ykp1XauDOkqF37ewf2dja5g0MteafFlCGSIDS1HT/OEjM0uHB4PR1S8uCPPU3JQID0ajqQNz1XDQq6pUeHFy8MjhlZWVmdmZuX37+4MBzAYbG4OqKsy76ZmZ2Vky29nerrVqTbWn56cA9Da3BoNqxpellCHEhpUMUyajzKIFjxHH8aJINMmtj19M0di00AjExKrEaohRvXBhyau2QaUxRWCS3JgMuHyktvF3NN8kVYjqy9PfeGlzY/3ihfMwf+yBR8JguHblqmhp7IkIGnKpMxnyTtFoqMNIClJPMRDaQuWeIW1qKcV0Z8ZK1YxFhPNWNojp6JOPHf/mN3iuXSKsnvn8/E9+Otzup1AbkwoDlGC5PlxNj5984MSJE++9+dbOxmZZFDGkTILMZe9j4z5Lar7deeKbr8wtLv78u99dvbb8+NPPnDhx8vWf/qw/GBLx/Q888OBDD/381de2NjdmZ2eefOnlLy5evHTuHIvI3SJ3U02aCiLvHAmnOt4VPvnqBJR7lR/uivvi13m1d0F/MV5iG/LDmD+Xf+Ems4VAjJRi2W4PU2jPzz7zW99s7T8gg2Fvbf3chx9uLl9vOx9SSmZOSFUVuYgVxfT0g08/efbzs1trN8iXCgspluwF41rtTGEyG6R49NSpBx577PxHH539/PPFAwdOP/30F59/vrq2yizG/MJvvnL14sVLF84S7ImnTsfe6Non54hMiPQ2qxyDT5iqgMo6EXVEkYwB54QcKcMcatTDGMTM4BsVWRpP/LxY7Jm/SojRlbOzJx89tXLpi53d7amp6YMHj++sraVQMzWkTzITwJs6VYZaJi8xHFhMzShCJAQXYgu+CEWRXB4Qe6sObm2ZqHVv/JLhIhzBG6RXj6Jvt2engxoTyrLsbu+0ipKAsL3d0UiTSHX8iJMqAO+ciCSzAJ+43B2FTmeuM1MOh8M6RiObmpqykAbDQeByFKpWq+CYLMY9cBpRcw6AAUzkmVnI1CpNAFl2qIOBGEwVSTk7PbVvX4z1zo3N3ZjanVkWX9e1m6ahQTU68RX7uf37todd5dTqTEOIDHU1rENgE+/ETfugGqoabL5wvijULA1HPtZeE90j/M1qIvdWfqjEbhRSkSU2A4ZqVmqrSEOHMLaMGqceLGtL5ck2+eGeX/FP0whj8gMoqwaKiKOmVNeJCNx/Qey7JzN417/fDVj+B3xZfpycs/lEagrVnMffa//EYAZFRi3gCAeUQD0Of23saKXgPvtuu3zq6RfO/eSj7f7oxNPPdt/5hEL1+O9+a+mJx+IoLpx6fPnnr6Wlg1/7Z7+LTquaKspDB3tT7af++I/nHzmhX1y5/N0fjM5egAajwIA3C4qkYIM07FY4Q0wQUKlUgipjJk4p5XJOl6//H1X5AWMcdjIOWQRjPDdzHpxzu7u7GxsbzrmFhYW6rre2tpioVbZu6v5m7m9d14uLi61Wq9/vE8N7HzTFGFkcmwuhNgHAzC6PMzNlRiGZCZ9MgynBEmch9ey62CAitGcs2OTKb4bCABogkwBx1hAnE6gi9FTnl5ae+bM/Me/Dzq7Brn/wzgFLSPbJp59UoyqmFGMqisKgqsbMMcVktHjfUZqdu/7B5zSIiW3ksPjAiYcfeOidH/20t7t74MSJp/6vf/7ZRx9+/JOfYDB44vlnn/zD3z/7g7//6Cc/Q6nBUrR4oDVz4L6TXcT18+cRaw1YOnz40H0P7uL86srqLDkpyl6sSydMVBMfP/XYQ9/4DZ2ZE5LZs599+uYbSw8/evjA4udnzz3ze7976bNPXv3BD4t2676HHnrqj/4gfP/7czMzTz39ws7Gpivd7sb6G6+9lrrDJ5574dChQ704/Pzs2c2r1x55/vl9h/ZZrLeXl8++/V4cDB1gGsiJNRnMbLiMgsBjjaCbXX3H+ZzADHZmRqYZyzGwMDsCQbOpWQIiZYbM+NFpdplq1hYABjYzo8jSFV44eeL4/+Vf7rt85ez/8P/txvqxU6f9xs7WpXXK5CvLNY2A5USyo+xYLAYyNnEjCtGZ+UQ3WYtNTJN5znRTAMLM8vmSjCKikVJbjr/wrBb8o7/8jw889siDDz106cxnG93hI/c94Jzb2tra6fen981Nz84Y4/r163rkyP5nn+2f+TyxzB8+HOs0WNuq6zB/ZIkcj7a36+sbpdEQcfrE4sIrX2sdWpq7dOnyxRXZvzR76lH6+bs6GsSCigMHDpx+zL/7gdi2n5rZ9+TjF4d9nDnXhkz8TZtLbohYmXou4r0RxZj2aj/szeN8RdqdOPTkzH3bn7+Odmf422xwdDO1lc/RICUzKFmicfJBc6TKyfTU88/PnT792l//p/ly6vFnnzs4iJeX12eXjizMz3dvrHe73aLw8wcPSOFurF4PM52lZ567sLVdjeqDR4959jsbmzd2evPt1sLsHI3qjWvLpbEBdVEunH5y37PPbYU0PH8pTs8fePr53e3e1SsrzrNMTx1+8aWB6Zlzn7nCHXzkEQyqK2e+KJJZTMoAkRI4QbSxpJCsVAH2RqxkjBBSrJMy4IUcaVQWaWSvDVFgMDE4IwDBlImcQskq5r4vHn7xa0/80R/iO9/54offLw8cuP/lr332198bDDajJwJYFaZEeanI6zo5tSzyp5YSIYFN4dR1UDhz+Z0gkknF4W0JBNNbp8YvbMZEYI4EBVPR2X/g0Ve+Nrd/IXUHPuqlz86256b7qf7s7TdSHYqgpFqUZQRqJGauQjLC4uL8vum5nZX11K+Tipot3ffg0tHDn7z30fb6jYP3n3jsd791+fz5M2+8MxqGAw8+cvo3Xr78k1dXz52vBR7sFImxcPDA9ML8yqXLo26PmOfn544eOXJjdW1ja9O8qCVJVoDYqErx+KlH73/hOZmZ45QuXrjw6bsfHnz48TQY7fR2X/iDf3b5zNlPvv/3HrT/wUcf/71vf/zqq/v3L5165JHB9oZrtTd3N994+426O3jssSeOHT3WRbq0fPHC52cfeuTxk4eOBKGN9dWVN9/Cbu+XT7pG5/ou2jO3t4oxKDCkpvZ3oGh7qgSBc0CsuUyZYSBMZF4mYcdXKE81CX+J8vxmZoBTSuyZXMF2Lz7QLW0PLjf+2W4eJPPicYuW/B1efE1oOHnDl74Rmlh3mFlSKyRjjjefeaOIZsRmZKTj3EdWA5x8UmLpsbQPH547dvzK+x/uDofPPPvc1MMnO7Uee/yJ9z76cGtj++WlwxXT0WeecUeP/uCv/2ruvqP7Tj2qXvYfPjTsDz569dW4ujonkjQQO7EEM6coIjA5VAMMeCWApEGCyYxUYWbMEGecExkkaEjAYkSNPeI/FP2dHMOAxoxbRIqimNAeiGg0GonI3NxcSunGjRudTmd6evqm7QWAbrdbFMXBgwfLstzc3BxVw7IsVUMdQlGUYK+jxMbCRCAhTqbEBFGoTmDaTDyNrEkTjd2UuDFAszujMNrzZ24GMtRk7BIKJQNVTEF46NPsQocfOfnzf/vvNs590aGiHnQPvvJyUZQbn53Zf/zYgYOLo2p05fKVYVXd/+ADCwv7er3u1dXVmd948fDjj9vuv68+Ol/7tF2Aj8wP0yiNakTC9FT76ccOL879/PNP4gbzk6fcS0/XH30a5xdmHj4+Ozu1vbIau+H4b//Wjfni7H/4i31JZsrCeb9aV6O52QNLh9bPXNg33T58YG5nZWXUG/B054lv/+6m2s/+3b9bOHbood/+TVw9ZycOlQeWZOP63FMPHtzvR+/9PNTx+MtPd15+ovfRazMHl+ph74Pvf28423rxz/7g6f2d5Z++O7Nv32uv/2z/Uw+f/NYL/e//dPrY4Vc/ePfg4v5v/9a31q9eu/H52QLkxchSYzlknCeameLe9S5kEDUXc3qRLZIZITFGsJooMUdwyvpCjRpy9nowY0tNgiN/HzgBRj3T0b7p6WdPXV652C5aMyfvX16+WO2fbe9UbXUV1crJLMJDzdhc1tonGEgrlxKhndCplcjX0JrGbm/EADGzc2PPyia3xaZwYI4WKYrjEYfKzNJwam7pxLFjG1eWbyxfXx9Vp37n248+dIpUuv3Bxx+9f/Sh+6TTWji46M6e2wlhy7frQ0ceuO/+Vru1b3ZhtHzjwhdfvPSv/7Tubn/2w5/urHdbg5jK4sDpU1eHm9ufXFt66unWa58FV/ZaBbicRnvTUt1uDVkRwIEDUZwuu6wtdTMjHjgojwO0DDhaQ4BSTTEEVnPOgSaBGk8YdV+dls/rt6WZaFz0TePEIn5NLMAJWGJMzGhEwRyBTDU1BUxEYiwQgNSQyHJ5QSk+KWKtQ7OKnBUtWTq6/sXyz3/6Zre7O3/qySd+59sznU5/e+vTjz5aXDywdN99cDy7tnr2/Nm+FN3O1Mlv/taJBx9mX+wfDN/62asHnnjymQce3Hjvg/XvbIVhX1k6R+8rDp947+yFA/c9XB76qAsXuUyR2FwhJVjAZI6i9ypO2yUgw2jtxI55RCHCAHKJTKGE2nPwHB2CYyIxkBKzcgsuGeoYWlm0DUmJScFAZASxdrBcuZcQM8kskvYcdxcW2o89sD7Ynjn1ED7+YOvAtCxMt02qiFFhAsvWE0aW2BTEYDYmU1JNbMnLiLlPXDtPKCkwAOU8VBpsBrdHv0CjFH6PPc+AGnXL+XKQmPzISd+7zpOnPv70k83PL85VFnZ2v/7is1fRX/nsnQfmDx+aXaw2t65evhwKN3fk6OLSwd1B/+L1q8dfePr08y+/9T//5ejcFQqRPM0eX2od2Ncd9ojJ5qbnf/+bwzOL731xvrq8fv8TD+//na9f/PxMvXJ59qFjc0Unbfeurq8d+q0X24cXL/zHzanFuZmFheGgN5wpw6A9P3X04o3lmdmpWXay3a0Gg6lWceobL3Q7rVf/5q8Xjh578PkXZ7Z2O6cftc3u1uqV+d9/ZXh8Mb373qjbf+IbLyz+y9/jtUvFsUe7xGc+PTM9P3P/b718chbnX3tn/4mjF85/UZw8ePK3X9oo9dipxy6/81Gvw8//ye9trV0efLzt7jXdyMD3CixykOWSOEb2W3CqbEwKzvVueQzAmMl7zyHlgpSJ69tX56xOADEYTd4C2aLZErLyKcVQR/erwdW3L8U0flHHqREAblzGZI0GfxPx5glIY98BxS9wTL3b9yZDjJEa7m+kxj3SxkkI5HyoN5MIhiVglNMUMHcz68IKjMD3P/zA4hOPPVowyPY/fuLgM4/PrO0m1Y/feXd7c2vxwRPFdHvx+JHNC5e+OPP51PWVJx4+1UZqDboXP3jv6vvvLbGvYmgTFeBKQ76pYhxohKanGoUBBWrYiDEDbrVajutRHUI0okTEwt4y+gsyypAY4R8a/mIP/jJWqqWsZpbPZiklEdm/f//FSxd3d3anpqYWFhaur14fTkyPiagsy8XFRefc8vJyURQz07MYy21EkWTGTEVR1lzfHANZVmYsHm9GRqyElMddHhzEZAIjgvGXULpJhEgQs0QNgJ+EgmhwVLEijA4fOVyMAkbpYtXfLktxzj/yyGPf+Fq9s3NyYd4++3xnd/fU889dWV5+8IVn5zY368XFuaPH5uYWNoxZtdOeas/OLJ9bjlWNBJGivnZ9uijmlg73zZWz89sXrwjcY8+8OPXwsd1Yn37+69sfnptZOroxK4sPPPLyS6+49evXL1+cOnS4urr84KnHV04cOzQ9047xteWVChDinZ2d6fvue+jFlzZXr7/2ve8vX7v+4FPPs2vFWre+uMSej97/YPf62v59i7qxKc5z0OHu9ubK2qUvdjr3HX3lN795+e9ee/873wsz7UMnTo40bK5vvPmdvzu7dWPm6y+bOVJpccmhElhW61JQDhMNpCCTe40kA4zFxtaquXrHmIw9UCR2yfnERXKsmNiXZax3Utve+AXkahiGQt1Ueez5J89+eOa+mcUHXnz+w5ULgWDChkRsRGoWs8MDk5I16SkgY0rGBq9Ui9YM5azqQIaG75803RkUiriksU6Bp9ohBXJy9s3Xj2p45TdfSa32e2+8ReJPPf/c5x9+ev3c5UPHToB4tze4sXr9/lZr6aGHti5fSclcUW73+/211XiCTzx4sqX1YLr9zs9+tHzh7IKjAQWenz30/JMf19srmxv3v/CtYunAoJCaMYo11SE5ghcliqrR1IjrlEiYQJqS3VrabgYWziJ9KSVN5pi8kwm08NXZSPa2CSw9aV+567wJcY0TwaYAWGjMYlU1Q7PO5i2MYIh17aRkEjY988kZ3bfvld/9XeuPzp+/sP7GG8+9/FJdyH/8zl8tHTs2bHFR0tqlc7Nzsw+/9MJnm2vDUAdwZXbu6mUqWs+/8NLRtbWZE8fPX7l85q03SUhTZO8eeOJxv7jv8oXPjj1y/4EnHtm8dDlRGhYS2i5SJHZ1QQNSahd1VRlzSCnEyFTAklneSrnJ56Ipb1Umy8XhYCBrEzYMp0lAxAYliwCb+WQgRCQHnmIXY0xi5ChW1YFDS/7A/Psfvf/SqdMH7zuyZqOkoemdjPHd0s9oLBrABJAlBRJbxIQhlU/jY2TjJsJ7G4GKI+4s0r29KRAkK2lSwRKERoxA2E6hB7NRNeh2K9JePZp5+P7nX/n2TCza7OKPf7Sj4alXXg4xPHRgf/rwvcHsbPHow73p6R6oBSmmWnJo8Yvzl8Jg6OCHGtL62sL09MKB/cOhzezfv33t2q7Fw88//ehvvDjY3p2bmq3eessfPzKa6yw8c/qZp56dUjn78YfBLDp+/LHT7QsX9s1PDfrb59/7sE6jDtDtjdyRQ/TAkc+2t7dff7N7Y/v+xBrMJ+pfvCK9wdGlo+tx5ejioe1zFwS+HOnVyxfPnTkXRr0uxyd+77euvv3xWz/++5bxo089sr65vbu5/dqPfrx57tLi4w8qmJjz/nqPDiRE0N38Qvc+DHBCq6aCNOW4RtGOKBO8grUZUkYANyLoPBb/xq3MqK9Co3GeOTNhkiaQL4tyFEcp1U5KM9N7IUS5ZUgpAYGQ8Txn8GNAN2atAza9uzFtExrbHuTvS8a+NjnSM7OIc86RQ2w4zWP6Q9Ytx8TTazzVjHDLAw+W3Ezr2KOnts+c6334abceVXX98KOPXNl4o2q5qYXZ1O3NuUKr6FCVU1OFpv1lq1O2XUoFtFBzIUJAhKRawDGaVPNttzx5pbnrBuzNfqvWPJSsyzxOzRFZQ1f7x2h5n0oxqqpzLkfDIjI1NZVSurF+Y9++fQsLC2vrazu7u8i6M3n4ttttM9vc3CSiI0eOdDrtGGNTkWOGnLXNpPGJrEjzrIhVWL2ol+SEIEnN1Ma1opnum3mU94SGEjVc4cSIIAPFzOfQuhpU1Jl+7NTpsHCou7W7srMdxAfwfU89MyjbP/zZ3973wP1PPPXUBx9++NHlq1VVnZhb8CTLyyvLrc615eUClMym2lOzremVrR0YCZNjGdzY7iLdf+L+nXLeXGdnbddxZ3u41Vvd7qb65BMv2tm15fNX1jsYDpVH6b1X3xzF4cvPPbN+5tP60oXf/Jd/gkvLb/73/+Oo22tNTynJd/72b46+8PxTjz/z8DMvXLx+pbvzd7GmEIi52F3v1iU/8MBj/da+7o1usdBrWcHB2NjBz7Zm0k7fDWs22rqx9cDJEzOtaa0HBfn1lbXnXnzuxdPPnHvnw83lVRd0quhoXUPHCLtJNo1XVr0nApePqLm4ECzZFk/FTEqiMoqProi+SCJmiaI1vGIAaJz76OZAz0NIYMcOLe2bnTl14ngnyqjdOTA7i1GVEGsKMCU2EjZTMXIpD5xmxorloj3LHiXN2XrPtnvX7J2BEixA4aROMcS4sLTYmZ1+7yc/ee/11w89+uiLzz5/eP9+GtWXzl9YPnuuu7154L5jS8cP+X4nhME02r7gKg5cKUuHF6Pug6NtGwyKOOjuXvn0zGB704noHC+dOjF9/PCR1bhQdGb3z93/yrM7w51gKbYklBY8b21vJRad9sOC2i0XkcRL5THCbZWYICCpZv8I531ReGLRGNyeN32l9pJJyyHvJPadtL0sCPzaLj6DLeNrwpgCPLY85TuEzwhERkTsHMUQPHHbubJsXTnz2btvvr144uhzL770/DdfXtx/4OLlS+eunF/vb07PzR175L75dkcYiqosGZbahZvptA8fOz6sg0uxCAGrqxfff29jfXWBaHq6pUV56PGHpg7NP/XUqZml+QefP716/dKghZ6EXQqwVIp306W1XG/Qm21NkSur/ma7KEU5pQA1HldWNUTDL0UZAAFOrWIKDk5NEgI3yEInISgGbGaY8+UTjz12YH6umpv1czMPPvH4zodvJqIkMCSX9TRJs80zkA0V8+UooGQqBjbeq+pjYJvkbSd1t7cODB0bVf7ypjBzHGIMwiZUQeGkPTvz4te+Pjqx0dmtXv/Of44htMrWqdNPdRN+9v0fnHr0iYf/6E9e+/7ffnZ1pd/rPT2/f+nBR69evnTls/PrWzvOF2q1n53ys1Pb21sWtfLa8hJ7vd3VjWNLh/quU5bF1voGd6bXtrboi6tG2PfY6fblq1cvLttcO3Wmy7l9P/i3/7EejZ751m9cWL3x2fXVb/63/7eti2c//Ju/vNYfLpRTw9pe/9mbJxlf/93fHyUbXFx/98ZPzSBgi7G7tZ1G9aGjRzuuGPZ6OxcuhmpUp9SZmTZmI65u7MxLp5TWtesXnj395MGlY7tb13dWNra2uo+ffPClV3577YNPd1ZuePa/vANz16d77QYEK0ynokZoZAKTmpVRC4VTsNkkFstYSCOetAdy++osWYScU6AJ+issTpyIkLET50QCvmwcyuPqMUx2qyaKawBdxk3b18mGmDNlez/HbtISvlSNF00iSGugn5SSI/kH9bMp4eDxw4v7Ft77/o+u/v1rvTRaOn/x6H/7rwbQ0Nv45m9/M11eO3r8wasffnj1+vln/vRP/uSf/15rfq491eG6irvdVojzZavVFHRpsolz1D2/WFNMGQNiFufIOc8imIAQk6q3/+IBNBmNmf7rnMt+bwBy/eiNGzf27ds3Ozu7vr7e7XZbRdlut2+6vo1Go6qqzGxubi7GuNvtumydnFREmJxTJbUmmB9nQMnglIokReQych24RfBJ1EjZoiB79WZJKbnDPPdut9EkC8TgFAo4mE9WpNRKplV8/Qc/2jl3yZOvuz3Xt/mFWW3PrK9s91a21qldPPXy0X1H9h1c3NncohEIpVVhtNvtDrrTFhPZkaXFqhrt9nYdGTkxMkd24dy5U6eerPYPPzl/6eiTp4PS/OEjcw8cW93eAKRfx47SsDsYjuJg+frqmXOLxw/SsBp0d0ch+oWFwacXRivrc3DD7mBqf/vRp59788L5T9758PDhk3/wr//V2sNXEhjeG3g0qHY2+keOHuPO/KVLlxZOHtegYUq0kMQYVdX0oUM7qvDF3Ilj5y9dWP1ueOkPfm9+6eC+fYsvf/3r17+4+Ob3f9AOqZSiqqPL4llketO6lVj5y5AfIpmKZm6gNaccBpgtGxZTw02HJtLGXbR53DfDiEz3MSBqmm13Tj/y6Kc/e/X86+8stOee+61vvvjU6TIGs4iCOUXSlEgBY2tYjDED/AS2/DormbJmfmajLc/E3IzmO+eIwhSWzMR7R1ZXo2efe/5gCB+8+lq92+WUdq+vuuOtY/efhNOHn3x86dGHteAzP/jgsdOPVy3t+hBn3eJjJ2dOHP277/zn4ydOHj50EtcutUEH4a9XUTs8ZFt64Piljz589e++HxJ6L1w/9vhj8eLnfn568elH+vvnCg3bw91ewYdffqZf4IGvv8jTrfXN9aoj/WHyardLm47JkEwkTtCoj95EWCcz+atDgZiksPfksm9pk3d+VcJfZmIBTLMOPBMTY+wQDoxzlgATm0XTOD3VefSRR8sHH/jRD763uXKt7m2XZLu7G/OLC/ffd/zU6ccPHT0yf/jIWz/9aav0h48fddCSsTg3+9hzz3701rvdja3jR09OJW2Fuk3EGhOon6oHTz06M9P58V/95db62rFL55985evH7z9RsB44dmhxa50Jw0Gvf/36/qNHFg8dOrJvsdPuXNvc9EyhrsWRYzZNZDd9be6hYjVubGDN+oZghWiWoWQksxBLJ0ONGuzg4oH21My7P/zRuQ8+2F2+9tSzT+0ePiqjoSIQqU8ZqcnUT0y+eYxoGNv4PyigIE1kkSmMi+8naj93kB8aqaZ73AVIQyKDd45BFGIRNWxsvf/ue9c/ObcvcNrp+2gd2NSBg8uXrl/95MK0TT3w8isnDh7vLB2sWztTsQgsM7Fwu8kPkIaxG/vHTj42rHv93q45HnGaa7va4sVz55YW5mfm5nb7u2lAHOmhow8d2HekW/VdMdPRVqpGQ4tpWI2ubW9/tjw/NzcTCnejXr92kf/NQmhN7VxeXxr4QoH5mdlDRz5/59NPfv7xgYOHvvX7fxhfHCWXYql1i7pptHZj+fix/Z3Fmcu7a27x0KjEqIN6EG7ooF3I4tFjcbdPaov3n3zn7Keb36Vn//QP9x8+4mYHT33rN65t3vjJ9787tb29z/E9BdnJwHqPAUNGbCmLtxvlymQlGmuP5pQiEaEx8ciA1sSU7quk/ABC9uYwIiIDEznnhF2IQbxw4ZHwJaFfA+pxOFsaWgkAFIhATTA0wrptA7K87gT+3IME7w2dc6rzy4S/dzxVItBNdUwimtSRfInGZMOtG+e+973Bp5/vS+lwMTVavv7pX/xFtx6sXP38wfsfOOmmt7//o+6li1vbG++P+o898ED/2sqH777XXb3+6Y2N0da2N0NSU/UkhF9hY2o2i0aLjMaFb4Zx71ljVfdfCv/mfSd/vHcu+zzY2I8wxjg1NeWcu7FxY9AfHFo6NBgMUoo3A+QY4/T09MzMTIzx0qVL1WjkiyLF2GA8v/y7s8qhwRmckVeCIkKNco0TZcMAuYn+0p7z0jhZOf6H/J9oJrSSM3IJU6B5djKqR2sbu8vXHLvaUsFkdVi9unz/Y48+8+RTxx96kIGlEyfqFD/94P35/fscWYvo8KHFlYPzo/VN3y7n5mdvrK9Vo4FzRuwM0eJo8/py+fyL0wuLa2/+7Mjjj+5f2n/syLGzVy+c+/zM/U892WoXVar3HTm4eXVZCPOtosNC0Y7MLzzyzFM3fvLTBXOPPXX60htviRrHeOrBB2cfvO/1t9/zZaGjfhz0pmZnrRpOtUvn+JPX3zj53z0+NS83Xn+V7fmCzLdk9tDxo888fnzfzOmnn3j/jTe04G/863/5zk9+OH18kazuzE+9+M//iAaD1d3Ng/cdT1ev8XAYhiN2LqkpT6rajQwORjaZY7f07aTnFaSsSYxIxdTIWDlTTRRIRIktMGpGMFMyB8tGbgyINaLWiZvF0QhK5lIaXF3e2V7rX1wOsn6mXU5NTY16q8NBT0mLhgrPaWx0HIE4ztdmb788o1OWVtpzyU1ceNejk5l4Z9AYU+Fcb3vn6jvvPfrN3zz8L/7c2p218xc+fu31I1euPf31bzx18sT67vYXf/+zE6dPvXDifq6Vd/qdnX7v7Bfd1bXD7ZlvPPioK8v+tevFTrd+/5PFQSQqNweD+cML+7z74udv159fTpUtj+TE0uH97IpoL37rt0VlZ2X5nb/77tnv/fDUSy8/ct/96vnTN97bOXtxpkmB3Hq9QK5/VdUYoyb14rwH6b2NSf/P9qu1JuDK1ZFj8Yf8LzfjOIvJ2kXLRjrqD7746OPTR47+2R/9aSIdxfC9/+1/Kwr/W//8n/+r3/+jIezMu++0usPTS4dDNRour7huv7+y0rt2beOzzx+cnZX5A9XGZrHbi6Nat7ZdjL7wTnw5N7P55lvLP/jRbjXsXbywn7AkjEHvsaefeujhh0J/+NO//pvX/+o7X/vTP/lv/vX/XTRt3Fi/duELNrDjhLCXPXCvMOYujQEZZ1oACBHDYlJxXsCmWrBce/PtS5cvxV7vOj6asZB2trZubKcwIjKvN7dzaq5hTwfn4MBMLHvdJSAZKVmjnk3jzCEwTkhP1nmD2D2lu6BAi1ljSjGGOjjmtvO+P0jXV+vla91haotMFa3haHvlwhenHnli9Oyzjzz2ZL25efDkCWP6/KevHj9+shBnvcH0zOzhQ0euXVtplcXJRx66unmjt77WJqtTbJm1nOtfX5l/9vjMyRN/8z//j/c/dvrQwr7TTz974fKlzz755OhvvkIxIdqB44daW+ueuUVcqkkdjx5cPPnYYzdee22qdM8++9zln71Fdei0Wi9/67dXqtF73/meDqvh1g6F4IqWOmgKVMiZD9878sIrx46eeO/H33vk4aXCEcXB/hOH7n/60YVO58izpy9euQxOz//h77zzxhtT++YK1WNHDz31ja+HUH/+3XcWlxZ5VFFveE/lB9f4c9/9X5s5YFDCsLCaLLECNFLUbEGQeJJ2IMksdSKym4fzCf33Vx2Z/1StSQRlwqypxfgrKLXZnm6a0BgyFwKAAN4ge3p/Er1M9qpcjmbjT/tVJzAxO3GF954T4j+wk9vE/dXVzy8v73Ntksgp6mZ/5fXVWria9p+fv7xcqfRHLNzptFfeeHPjg/fVzFIqi+Ly5SseKMDccJ4o05e/zI0QkXOORbK3eVYJ8+P6kH+U8PemKOQeel7OUsFuvui9n52d/eyzz3Z2dg4fOlyW5crKymjC/QXQarUWFhZGo9HOzs7+/fsPLC5m+I2ZFZRHjPc+QXPWsPl6sshauVi7GJzWbAmmmlUDlMZoP+cZmJc74JeEvwBACkNjnJspqWrtQjDqdd99u6wHM6U4cSp+d3d9a/fGF5cuLszIE889VqX099//m9b87BPPPvvkc4+NbLh+feX6lXPHDy0cXtx3tfzCFxh1t7a2riNUIoVpPepuXfrsk+H69fPvvFEuHBqtXts980F/o7/7xdnZk0cfP3lk69K5/vq1baSjR2aPz09fu/BZVXVH29g8e3afd93V6+/9/O0TS0vz0y1IKtV2Bts///HfPfgbv/HtV75mzl/54O3rn3/UprQ96u0sf8EY0s76pTdfa4urb1y79u6bo7VrNNgJi4eeeOm5kcPnH3945q3XO5Wtf/juSy8825Xw3s9f871q1N2SlJ568dnhyvVP1lf62/2CUwQpm45LyGBghplSk564W99OkipMiZEskSWQJpiBFVqDKp+C18rHkY9tVbY84DkwsbFoJv6QNu7FiGIKSnX16auv71I65MqUcPXTzwqRqaAJSaEFi0VNBKVmHhlTYCKYIOMTxgZlS5xrksYgnZlak/65c/arKhmV3oVRxYY2yYX33r9x9RoXpRF3d3s2HF356NN0bW0f+a3V9RHixQ/OuVbR7fWFSKJuh6Apff7mmaJs9eOo5wlRaUjY3J7WWHNMW733vvPD2B0cTY5Yhhevvf9v//2grlvOT0lZGosmXlvdvXD9w0++aHXag9Fwe+PGoagzUjJZfSfSYM1azMzihHNJHN2Cp07m86++IPzv0ia2F3u5v3SHSMWv65otMxnMiI3H3PJ83GJu1Hayi4qyYezmwEZGpJoiUrsoktrGpctv/4e/mN+3T1Po9rq8s2XEb/8v/3F+YX5jY2Nza2v7vY8PLB4cjUa94aCK1ZbjwXA4vLZ28MBSNRgNdrtWR2dUV/0DrbbG2ixeeevNdtE5Fm1ARb3TO/PdvyNx1954e7rVloRUR9nZGQxH7/wP/9PM/Exkvba2Ntzq7bNSmAFhpBxJKlHKlUkTGsQvbTmzQwZRSoyQoxYFGdeOwOzgFbq1tVv1+jNAy2i4tv5Zv5eGo544X6sz9sEgaJxqOFc/ZQyr0VRiBdREwaxGpqwMKzS1ssQ9kY6FSonolrUo1+XTPcJfaqj/tamAqOXFejubn34a11fnBfNTrbrfvfH5JzvOzi9fbs/NvvCbL9Sj8Pp/+l9kfuaJp5988plTvd21zZ3t7c3rN4Zbs4tTGyXNOIdrK/XaNd/rzropD8jq+sab79D11bWPPx5sbdHV64PWVK/Xr+ve/hPHHn7k+NbnH+/cWK6hc8WhToHLn39Y1bvDKi2vfJFacavePPM3rx08cmjuwMLuVHSodX3l3b/+q/t/++vf+LPfJtda/fTzi2+/deyR+/yw8mvr9Udn3PXV1Y8/poWVcOXq1vsd2enbCIsHF3/nG1+LZlvnPv/stTe79XB7+dI3f+9bGFYXX321v3KtH591YfTK117E7vDTlRshdKXRKW96z27pvex7iHEn/8LwF4Ta2cihIiQGg4aqQ2+1s8BITLk+n0iY2MyIJc8rjOOPr4rthYFhxsZgykc1pqTKgvbUdDf2QgwshdzTLQ8AQDA3pucEwMCT3NE4Fsw1XgCg47RMpgtPyLhNv9vEAOHL38rk8dikvpCY6Q5jr3vdBQrV0nzNJAhClJgchVljEHGgUa8vas47Bep+/0CryH5pRCRqlWqLhcxYzRHr2M3xyxGw8hQeF7GP2WjZP+gfPfzFGP3NL3rvJwcz7/329vZgMDi0dMh7v7a2FlIsiqIhP+SdrN/vd7vddru9uLjoRExRlkUE1yGxSEtKismSZTJ2c2tEyduuq4dt6/k4amk/akLKjjWJoVk4gABCIrsngKFoDC/AFrNqHVEuQN1eW/n0+387GowMIWl0iivvvZUMqRp9/L3t1tRUFavdza2+lzfPfybODesqxjhK1TvXri10kwsjDMPyx5/UFGfN2hpVrVpbvTrY5uHw4o//npVadbXy2mvFKFyr6s6BfSpU94euSolt4+KnlMwNRhYH/Z3Rmb//UT3VHqTotgeXry2vTXvjqhBLLFfPfba9cr093VHTne3dVqi23tzpi4shrC9f3B/C2t/9LYlQqM5+f9OIAvjddz/3RoMUNofd6ZSmlC99/8e7H3+6FQc7g17b5P3L16tCxLF1B2lnd8qzB2uKDf6KXCZmlPOPX8ILk0CFotREiGODabIEOJcoqiTlGi5aNAFZiORkQEpEzhcUYYSKUikSqnoIU6ZCUY7ijGmHOIrEUUA18HBRovPCmaNAXCOYFKW4mjAkK0sXh7VLyRGIRYkiGROkWU/NgFzFaXczv2BiSxGGkiUlc8wmMlq7EZOJc6SYEifiRms3tuvEMbS9DK6vRiiDklpJYil6lrrXq4mTMDmimFJNnWBEtr9sdQeh6t2YdmURyEw9o391RRQw6isNUmqzzJIkrev+cEOjAy865020rmskeNk75AnI7qvShGViQIzRS2NmOdFSmPz5a2+THY6IJu7quX1Vtr2b4CLxmFQGIjB57yZ0B8t5kuyHnBV3iH0hKcQ61EaYKoqwubm6vs6mZHagMzUaDuveyo3r6wAWiML1G2vrW4ARi5CpmMQQu8PVtS1RKtiRGjS1yJyXGA3CGFZhczArRdvJ0DDY3DXHgxBHipZ4C6n0hVcMr13fXbtekcK5+VbbjzTGoBTBjZ5LJEvUcAZyKYZw/pdfsA/ldKVjZYlswRKzIKnPKnBEJL4Kwara1VSotsRXpNYdFiFCA1icwhvFEB2LEWq12pRKnxQgkpRKI0cQJkrmC5ezdUkySa5xL7NxVGa3DmbNJhH3LlKwpDVB4dg5Nk7drfWzb79eD4cuRFjVcnb23bcrj1Go3vnPf3WtPW+DamN3E63ijYtnp9kPd7tK2K2G769db/eCj4Ngev7tt3p15cWU6hbQv3L1/a310WAYrl9vk3MxrH30HhTnLp69dmg/BbXe0OpYkXaXz1NS2x3MxEi96vyrPwbTjfff7vW79fqVrXar3d2ZSlyAt858cGPtot83b0r16raNqvWN6y2FpHhta3Om39veeHtYFK0Urv/kda5iBbf15htWeI0xrG37fjVTuvPf/9H6+x/6YRytbYnnj/4//30oeIYL3xvVWxtEqretibfGRoYxZ+aXLySGZGpEEK5jKn0Bg5EokREH1UKYzFJWv2ZmUMbF6A7q/6+/TaZDPu+BmIlZcpQjLI7dvWtjxm1C/CXiBApE0YyYwGDAUhTiRGgza4g5Ai7ZJaDW2AZFGJPAkhBpxjh+RQA3S5hqUlX1rvTs0q9OimNNnYg2YSdUA4EqtUEliFJyg9AGEvPIUoCWIBeCqvkcsas6A8ekyAIgPKaBf7kw3szMVBVqIo45ZeninDf+xyI/5IOBqk6gGRHJemcY71B1XVdVNT8/XxTFxsaGqs5OzxRFeTP8HQwG/X5/fn5+dnZ2a2t7a3tbnDC7WNcgKnyBQHUdyLNIoyyQoR5lCxyDS0PUtehQk1L0DEajuZ6T8sBdQfPbJ46OBUTSmCWuIINZUgL1treY8vBDR826NYE6BN3cqDZvgLEokkZ1GPSiwQuXzB0m9DetQiuZjtSCklCpXKgZaNQbpuFwjhkWJKQWUxwNSwUB9fJVJRRAkUhhdXdHDKymXqOCq6TdYclUJFPE3e1ei4g8OUYnATe2++s3CDpLxMQ6qMzME7wSgxNZJLQZNKiMxEjqajsEVaGFwokXVyknG1y8SkLzjlwKo+6gK8mAtlEbLEZCEFhqeAJEmlXZLYg23m+/bMTAKSShUAU0sRlBszAqgSw5MrHkSZFCSuaMmX3wUU1cjQI0DDU6ZWKIl8pbZdqZbekoOlNyxe5oUDk5cGABvZG1iqGgt7G9ULZU2HWmdnd6jlA50k5rux60maddG3UNg4IURpoLZtTGJCrvnff+tqFCABMBbGqeSAjZD1LAJjlRQ1BDCgwlAbFLDGMwSwauzODYARByCjCjZeaJhWEOAJtqi7hk5tiUOBRZ6IKIQMkRCbGCTB1DmSBezEhVDcogltsehKHh+4OQsyvCWTq+eWbMPAkxvzqbygT93fviV+fyMA5/m0xnk/FsxOQaAJKIOItjNhBwRjCCamalCZGp+rxfQmCwatQihjCsCeMK5/OXGaAGS2hzkTnyYuCYXd4JRhoSE6maKE2xY1VNcIS2IJqROGaIkogjVQHEOxETZoNIla1niZjYsoZYI/iAMaMgs2gm4+QuuxExe9fTsDPqT091jHzXYoK2mafgjd1WGCpooT0lMZLGmmyYQuHLCB2kxKSlkyJBxPuy3K0GrvCmWmk0V6QQF6baYdDXmErnYUbgpGpEkSkK4l32x1tf2eO/+EubCYtj4gQzZaAkqnd2WgQPcprYLA0GJjZfSNje6S2vlyT7p8pQD6sr26NILYgyRBD6V8uaSkLN6G9tg8h5iRq9ktSx3h0ZI0ZogGdWrTtGFXT74k4rYDYSOccF+v2ddkInMRMpYJWxWkKaarEOK+x2DwYUCdk9u39jfbS+7kg67ImYeiNJmDYbjqoFZ7CahqMOoTR4NU7DYXe3JrDRQnIz5gaRurvD7ubFTsRMkkS2u9urnfUCOsmozXozd3sn+jv+B7pZqvGLGgGicFE8xCK1xMWUvApF4kxjoewdlyDsxNVj7fXblBC/Go1u5ddaxhVCCCzM3iPdRcX8FzUjBMAZCaBgAOpcxYbSj6rawbUJnVZ7d1hNScEgJupqdLCCfIIGS45QOF/HCPwK0O/euyEmceLN5dxb2tPtv+QT9zKMBYYUDRCCCYzMollCAZRAAvqqkQAGmUlMY402oLEPg8s8R1MC7EvodzW9ZwZAnLCAxlQCcXIn93ciJ/UPaxnxvSlJRDfxo4ke8L59+0aj0draGoDFxcWdne3G9Bg5iUy0uLg4NTW1sbEBoCgKEQ51pWplq22gEIJ34koPSjEl1Sz2axziVLByFMugFq2gwpPknDzDkAsjFEa59mL8dH4hE4YA3CSPEyzrU1ATSo8Lnw3QibjzHqtRUnCZS7qIGEyJRakN9qwGOMsVGo1ROwgOpAoy9VmiubGTRxzXFficfExNKWkwSSA2KaMXo0o0MrWNVAxEU1GKWmBIREapZUbKiSyRsaKlJKBAFASqEEMl1BdOxFQiO6EFMlcQgQ2ScsLRA8A0IAavVkQTNSIYjJsupbwHY0xLuNeAIVJyal5JKZP1iOAclwRzYGcok5VVbMWsaka90ejIc08vnXzg0x+8vrvV3X/ygQdffvbcW29tX1o+9szp6UdO/OR7fzc1Uz536vTJ04+HTtELw40rK72NrUefeAild93R7vX1995669ihw4+Vs34ALMz99MPX/dz0s089vfnOB/3NjRQSCZPzMM7yiDmQ4T2CA3cbK8gJIp4cl27xvMPYk1EjW2QYZ9GLCTW0+aBcip5rjCqH2uUxShnBIkZkAKZkRojMiSgyAdawQWCJoWRZUXl89iNRltv3/aZwQc0A8t6XpcW6vtcj+7W12/gYX1Hhs7s2A24G7mPod8zPy00BIihpdlZpGBGYlHrZ5JNuawSIgZNxnrgGNsLY1jITjYmYzaKoATVrEATeowm65zqUAKiDcYRTiJGRWkNhABHyUoAvD5OYVXXtlxZOv/Bk0a2++ODTrg4efOn54/uXzn/31ZHqg7/zWwq68Oobi0cWH3vutB6YRemqbu/8hQuHTxyf7nSG/aE3/uKTM5dWV4889Ey6sfHQ/kNrazcuXrly9OTxpdm5lc/OWFJVEpYQYkqqRLVqoon18K1J9j05U05gENk9yA+5ylpU2IhhCcwJLQYAMfLNXqClwRFqQiFeDDEqxERcR1EkJCMxUyLPjYp4aSDFSAhsPrE3o2QjQgG0LDuto4ymgsLLlGI6UFJTpRZzO6JlSARisJHAFJTUEqFgEoIQKJEXajtWAisXOXPF4pTEDEZBLREMxIpS4QwAyAFMkayKxAkjZ7Xj5H2KFCIpwzzgQIkQVDmlO6gjewI7ArIQaT7J3dm3N3+XjVxyhboo4skxXFVrWXMR2YMLEjNKSLnyLRc7/9cx/QEgWzSnoijhEBGSpi95/QpERm1gwJk5mMIVC/uf++ff6hyYV4IkXf38/PK7HxY1hUypggW1JKREmiJTjlZRGzriVdOXjB1p/IRy9YjzzqmmOkWkL1m3t7fF8e1gXLpTJBgwAgAYEAEe+7fhVtG0ySa656x6z2zCzSZOiqJwFFBVKSkTMUsWwN0T/v5qTiS3tb0cvPxYNSVkpu5Y/bfdbjvnNjc3y7I8cOBAr9fb3N5uTI9zy6bHGxsbo9Ho8OHD01PTdQgMlGVZAVVdFSwt3xqhbpw7iMyMARfRCdSqUFoxqKkmmDlLmfBtYiZmrABB5fbwN9uD7p2aYxyDsKfMYozn3KSQ2y17me39TDQUoMYdwYAAqgGZ1E5pBqLz5gjTJqoWIxon7AymSmOaIBEMmncr0wAlkLIENuVhiaTslCtTFSCAIqlx5VShmohAgSnA2CwaiVHNGAFKKBSaOLJAGoF4mCEh2B6ECQA1o4QVXlHnAaqklIPs3G8kgJhpanzz8Au2lPGxnQUsSAmpIkvEBoFRL+k02BI5sE8olOEcmKowmr7/gQf+8PdvrG6/9+OfP/D4o0v/7NvLq9fX1zaPPffMzAunF1eu3vjw7MZ2j9ZWT7z87OjSpYsrK4+ePo35+U/Onlkspx54/NS+G5v7jx4+vHDowusfPvbE4/fJcG5+pjMzt1y/o9Ew9isQkWxdmG9BVWPSbN69d9xbHiF022t779gwTjhlFMPGWkuNVPWEi2PjSU9QQs2T36f8ZhqPzLFakxEgTVbXsvcoA2yZto4ENQI1bi+3XWLzoG+G4F/5lpeVvMT8VxP7ooHD8no1/tvNBQjZIzy7bzPGOgakoCR0zwrtvGHwnrFht4OwRIAR1QRljYQo43oIBSynOcgaq0sDGat5NacGIGaKglkm+1qD/jZCkvdsCoxCKGemHv2TP7JLa+c/OZeKztLXX3ro/oevvnWGmU/9wT8b1mH5s/O90Wir19//+INzS4uf/fS1LuGFl17Y+uLKucuXH3rokUe//e2dn/zk1De+dvbnb2HhwKmHHtb3px565JH1y1eGZtO+iDEasRlIXGJOxkklH/5+2eUp9NaN9q4tAaSIyC6imfXRTEs1qpp3iSk0KDGJEptpQDIjMEWjZCBSssQIRgzSJKxNZYmRpYgM0DgDKSxltQTTpESc+Z4KWDILZgUnIJqZIaoRSDNvP4IY0VDlLUcJRAkUmdnMRSTiwByJSkAN0VARFOZyyYWREgIoMhJZTQCsVgRjZURCBSgoGgz5Y9US6V1A/1tXSIMZFPcYyckAODOqE9Q5ShSMlZ2RMDuAoMpEBlhKDSDx1UJ8f0lrCgDyX5qECr4UAJyXCGcgWAASbCQyvbAw87WvD2+s7ty47sgd+trXZ4498Pa//4tRt++Ep6anq0FvN1StsoQKJyVNROTFpaRNfvVXuvw9784EWv0Vu92ABApsksUJEgQogIpQ54UIiNRkAHL8s/cL7nbBk3DrS3z7WDWPmDj3PhPjttK3L1fN8IvbhO87hmZurit5oIYQ1tfX2+32/Pz8aDTa3t4W5ump6Zu2Fyml69evq+rS0pL3fjQaeue8SKUW6iDOl67UpMkiFz5TK1SNQJ695xJUzOxbGvYjFEkEOSzLN68KBZFpIyG4J2JtRN33BLBjSbgsLJlPrdJsMDnaGG8hSVlveidkiz0g3/qEo0KBUTuuMpZjGeDBxBiNxudiMjA0c1siQ8flAnkDYzU3Dn8djMEJvk6OjGpvhigWiBUMixzUR5KhRKXIAUw0clYxRA2RxGjkMPRQQifAJSrGh1FWo2RmNrYtbkZYYtRiI7ZEWYMoWxRDGZEom4qxmijE0Fx7Hnx7/rw5IpspIYGJTROlkbdEBHOcHGCY31+LUy7MBIpUpdK3yvb0SGPUOH3fSXx8Zvb4UWNskbZPHKGZqY/feuuJR5549Wdn1lbOrl1fnz14+Iufv//FO+8/cuwhKcPw8uaWH7jZE9PWJilqss8unA/7Zk7/yR+FrfW3/v1fYrc3o8JOalCM6hVknKEMAphZhO9ar6A0FqAY32iu9rgDtGs0pzNArhm3ywnrcYfkg29j5AoAlIiUYQArfMoQb1NHLYoyQgwGhPFe75OJGWC1IPHEoueWC6bx1403EFK1FOPd4MWvXLtT/uy/gkaUBw81DrBjBrnlRUaVSYFEKjZ+NWvxjU/id13mG7Y8xsdUGktZZhjPxqdSAEBiRKLE4zVnMvZyMfrkBGbGZl5NGmiwsVocFzeRQejLn5hY0Gr1YP3ezr7ZaTmw4IpUdMq1jfVtRycffPDq5jqX7aNPPnX2b77z8fqrD3gJh458/J2fDqcKqly11quv93rTO8cePH6kXKQhd3uj975473f//F984//1by6/8eYn589yiiXYGcFIxEnhE1BMz3JraHepU72lNa5GX4KEqYkmsfRklea83k9KkQA1oyzTaFaz1Q4CjmycEIG6RGRYAaeUHevGyvtWe2M1oDEoHxTNcwyG4EAFBYehAydTh1TQqIQmSLLECGI+JWeWGJFhICtIA4lR7WhUUi0kalwhMEaeioQQwYaRw9BByXwCVUigJDQqKBDEzMSimgHswMwQjQ4GIjHOurwOqnpnMQTdjfsb+R6DxgwOkqJVUHhhoxrtUafVZ1TMSgSDI4KBUuJsP7/nE7/iS4GIeO9UTVXJs7gvG4ASkJVPlFARDZ30PBXTU4M6/fiHP/3w/XcLx3/6J3/20G/85tb3/m7/waX7Tz85c2Df7u72xQ/fLWamHdvlDz8Sk288+9zmxSvrV5cF5BuppHs0G6MmOW2VYkqaCnGOnfJY/fdL97oSglCR4BttLjigIguU8+pQhtNGwsJuDXl/waXejun8whsxCzGqUyYmkV+0mhL/w89Sk3I3GrfMCstqDRn4SCkVRbFv375ut3tj48a+hX2t0Krr+qbwWa/XK8vy4MGDIrKyslJV1fTUdIghDobOeV+2EBBjZM+TehcCDFSLbDleZZSP3H/g8KHEBCcx116DyMwrnBpgESnPWJ7Eu2OWxmSnIc3Kv5wVYXMoJ414oQGNW2mihr2Xf5nGGxLGp4rxfaEgawvVDhEQY6cQQ8yUWcqKlZhcQTZ3iIJENrEqUZCYudRsdh4KUE2+FheZvBkjCkJLEyuUOFHhSEpKpGk6gIjFGbOJYiqSGIknK0wJ7RpFUrKkRETWpMY0bwxjBDjjxGwlGRucwhsT2IgSUxyzZkjhs0naHh7NLxykBjUBmE2VkveWGKyuTD6qtg7M7BZFl6UPmRHyhlhFmumMLF25fDmV5YknnhgKXb56eVS4w088LgcXtzaXTz3x5Mn7Huh+cJ78lPiWS9Li0rg4evTEb3amDh85fun9Ty5duLT/4RO1c4Fp5caNx48d7le95bXVxZiInEBg0Jgs5oCiGR4i7OTuur/5LHTTWiLD/uNpDGrMOkQbA25qdtAGt+OmkAjgBiaBgRVOASAwKoISGHCKVgQINaPygJkonMHIkiE2o9ScZrAORpaNEO9qBoRxmtIAZhKR9KuntP6J26T6eCL78Ou+ons1G5tSTijBAMaLO425EApSyu4kJmYEEyOvdrNU685HODZzwriEKw/CSTBHCtasjZA/Zax+owaADU4tGwpQDo4ZycxgOTUpzVo+vlqb5H++7K0TEM1GhKLT6a6ue9c59OgjkaphXY+6ozg/c+DpJ670e+3OzOFnn77209e7G9eTEcMV5qMr22Xn8adfOHn6yWJ26r3/6W+2rt+4r+xURDe2tzZ2dxZO3nf5P/3n9d2dI62OVTV7SmYGjtGC2r5TD7XuO3HPGEPxy25nTzqPUlYRauB5iKmYcdZnHKf/2AAjViqUCKaOiI0NZY0yITKSBwtcgh93JgGdRAYLTllNEsQosVVizuBjI7QqjgygZGWEY0KBIICiNbLISN5ciq1kEEBA4DKQT0TELHCewGNzeYaKlQntADGwg3oYoYyYGUEM0REVVJC5lJyaGClISZVIDJIHKCxxPjhRIrM75uAto9yajLX+ctmz/ANT0uRImZ1PIGBqbm4r1juxNmEKoJCKRFPkiPhXLuD6NbeMC1I2LPjyYWPuvVz+xsSexaIFg5+dffCl56vpsl2Wc488snbuPNg/9OzznUOHLl67/NwLz6Hk7VSfevihlbX1Tqd94lvf2vpf/6Ki1Y4zi9W9v3hvAGrIesvc2I/8w3p+QgC3BJIsuGI5uZ3Tzg2CmMbROQF863fdDQO+93qUt29mM002fgr/AN3fvfpCd37FLa2pHW+qaPIvlmW5tLT04Ycf7nZ352bnOp3O2traqLpV+GxpacnMVldXnXOtVjulGGP0zvlWK6iFEDtlK3kFUowh5/UTbASzFNfr4dLMVNkuk2ptSYSJs5pAXupAgKMsrA2DNdUaeX8C8SRRaSCTfOxRGvNwLYupAYQEU7YEykIgkzlsZoKGoC5GBGIlMgWRcQIbM+cVhZSEjIkhRmqilmtJWIkhCZpJGs4gBiULYmyQCDYYaaLsDuGCkyBURiVKAUGislLNSOIVwmYuGaIpk3liMpfAgdjAzpwnEIoApLqiqEJmykYFcY6ZlCCZcwGLILC1VEUhIB7TUcmMhYzJrPGSIGgQ1nz0sIxwkJnuKf5tYjNR50wYFjmpM2Vw4nZyURMVPAxVbQlFoZWRqnmpUpgBD3pdcfjaK9/47MK50KbjJ44fnt03XL8xb+xCvP/0qTc/OQcdIVZGCs+wcOn82TfeevPZr31jerrNZUFMSjR9aPH0C89efevN6U77xVdeufrXP6yqWoHIArAjHkexZlBNFmOM8U5AqcHr9u6jdjP8vQkC2zh1mocZ7V1fxgfprEZs1vit5BeTAtTwpUQBgiMEAwGJjbTZXTKSmAg8joQyjZhxe4bXxqkNM02qxOScK0pU6S6Wzl+dtpf7m6t3v3Lh783Oo72vUSO4PhkTzTnZYEqaYAzlnJcaV9kymPea9d3tBNPIXYOUcj5mIo8KjDHkHJblY7XkxPo4VnMKp5kZY+NqXzPOiSnQ3o9C47ZKhhw95xNall5S0kSqMGPTxjkRKSuxU/m1AAEAAElEQVRbMJTIE7cSXbt+9dhD97cpXvri8rGlIw8+/nA5P+VXt2Rzff7QiUOP3N97ZxNCXPooNor1MFRn33736sbqS7/z7aFoNw2Vkyv8g48/Nr+w79x3v3vk+LHNY8era9cDUDivSYNZHQJBFw4dQMMG+mUtYwlZynhiB9DkAokIZKZ5Y44iSRzI1NTICjVRNVgiCkRsyGNRTQgs0YzMlwxTp+YjuQTHpGLk4PORlS1BGfAxqyIZGVyCTxYF0ZtTKiKMnIDVKLISswQTInUgBzbjyoTgnBXRSrPERAwGlcqczIhYUIh5Ism5I1YRKiPKADEjBy3IgFawqZpELTgyj4TkVVkhBDYyswRjYQaTqRIFKKkJ2IgmFbJGSE0K05o8gZo0VtjQPae1SeffHv6SRSQSEpIyAmrs/PXVlWGqS0dIsJC8oeWL+o6A46u8cAFQ1ZS0LEs4BNQ5caXIjlr5BxPAYAlEgIzLi3gMn+cEY0vZRUVd+05x36MPtRcXjj52euPshR/+p/+1O+h/vnJ1bnfbVKks/LEjV//uhw89+VTnkQeP79t3o99fvrYCWLTkvhxqmpl/CkumKopS2Lz1a1iFVCUkI/hmyWlEnce5qPxAbfLMCcQgaVYMQlP6BDbzSg6wvDo1QMF4tTPk1NNdlr7xVyC/bzyO8jeOT/tGYGMj4XbRamtdx5QCiNgkJ+yNlQSkWYcmF9XdKicyeXwTfDcDure9YVKR0vwJpBQB8t6HEPKve+83Nze73e6+hX0zMzPr6+v94YCJG9NjZp6engZw48YNM8umx3WIwgyRSk2TOScsHFJgx42aMYhgznhGyvvm9/eurPQ3t0ooxeCbwjcxZL/MphuVTQmRk5Fx1s8LyYGFRaMaC4iTEeUIISd8hFJKSkBj2mSaoe6kDs7MVKCMOtXOOUlkBigLhBKQTNu8Q6NklnvQG7uUy1IYjtiIFWbGSmXNxlJZCC0xJB9zNGOhNCUNo9gmUUOfCa4QCFTFlAEIooa+ol2Ww3rEzsPgggpxlzV6TsJaBVYJiSrVipI5FhAlihqSN2n5qq4VIF/aqCbjFNNUUQZNkREAQiJLahaoUWGEcBWTOAeDmoq4mExTNO8U6oxMLReO1CnCiza2pJlNyKJiJoAltsqpMlyCGA9SmDtx6ODBueXMSEtqhOi4QpiJxqs3qt5o8eFTH//s2kwL+xYPoDd47zt/v75ynZ9ZfvihR2aPL2xWPQqVWJA04liHG8Ods59/3Ot+6w/++KFT92O3S644+fjD1HJv/of/8Mijjz3+5LPhg7Or5y8GZhUB1JlRio0beC5aMmiWxLvJa8ieqyy6J+M3nhQNcDZ+b94W8m+PKb6wLMw3hoptHP6isQk1kDmFNNsyKt8kwjLdU7kRPzcCG8HyK80OJI1TXhN4WZMibGqwMg7BRM41IioTSHUi4/IlxSn/adrewoK92opfsTY51DThJ40L9QBWNVOwslMiQ2StWZXVqXo1lxCZUjZJU7J7Qa3U7DzjmtvsBXNzHBqNI7n8d4x30/z3RDm7NKlgMBCRmgH1eFEiBRMiQw05gVZqQ/dySlAIU/RUcWqxwnFFUQxsllSVBVAv1A5VezA8f+Xy4qEj00F3z5xdWFicP37k7DtvnP3g/XrUW/iTf3Hk5NLlM8L9gVWDaKOOtWh3u7988ewbrx9uFY8//bBaP+2uH1mYWTpwaOXs2TMfvP/kyy899/SzH658N2g9YErgAPWFmy789qefym7PN7f+C2OjphIacLnwyzJXLvvUofQ+1TWpQTEUsaJVMI00VJQKIq+WNKl3dVIfrSU+EYUI730KMSLRdFH3+h1yFaM0nlapNVQlh2SeBKIpRTGqVaMplw5JOZnAIqMWM5aUSE2gLEa1JWoXoxDJDIwANUcDRQ7PU2SVYhBqYyay5L2mqEA0zdCXRo0hBSZpFRYRoppZJZZaTmPUYIU6xFSzVS1WoboOGqNn10rmlCqL3CoijOpIZTHgxMlaxmbQlDwYwoEQhVTYVBVJhGJdlUYtIzVO99b5ykeLpCABV0p10rmjRw/vm5sr3DD1jRy85HpfA5jZNezHm/nlr0YzZMkUAKYTtME5EZFaKxC88yMmRUOwSwQFvMEIQzYxuHFxmQOxwZS2GcZcWnKIbdFqc+3dn/zki4/OvPR7v3fswfvJo5p2+59+5MTcoe611WquzbudnfNr1y5dP/bM00da7et//zr1+lOMlFJTZbBn0xmflG/uQQR1MIAUkrykUmunIdhU4VtqCdWQYxRuJ3XAqAkHMTFjtSzhAEQgR9tmmdkFHcOJNUgBl4+YoHFxdqOXPOH/jQmidxyWbqJGkz9vXgAawXEkRg1tJyorm6uLmpjYRWeR1Ks5YwYpO2PjsR9JURQppYnIJgAics41qhEiKSXao785EXyYhL/MPCn2iDFOfmswGMzOzk5PT9+4cWMwHEy1Ozd1f81sZ2dnc3Nzbm5ubm5OVbvdLjOxSEzZ29CxUYrRJGeVb5a/sFoR1Y/C7sUru5cudVJ0qXbMILWGQpf5DETGiTRkYUgyAkSVoyIoGYkrVCgo4DikWBaFOBfrWmMyU+cczPLIZCICC9EgxAQjR8EiexnG6MSTwhmzMtVWuHJoo9qnqXY71iHFRMSWzIuM6jqYFd4xCCIlF8N+rMkqT1aKhQAjhKAFdzmYQwFOARp04Lw5z3XikAriyFBS865fV0PHLFQPq7Z4CkoiabroUxqF4EdasB8pVRpRCoRHo0rBrVZZx1Edk++0hxbraDPwwxg8+zroyFIoxRWtGCq1AE0hpcJ7GKoQpqam6xhTTGXZ6tVV4X0VQmAj4oLEGQ3rADMqfZRcSQOMM/5kQiYMJNKRVyVzin6IA2iHn+g88ZjEaDE5XxjSyIKJbX56hhSj7e6F61v9zz9dXr26u7CQesNw8Wq721t7+72pfo9RT8Vw/c03B9eWZ8l2PvxQhJcM6erylR/9wAFbEYPp1VE12v70U7q6tnaju39lq6Xach6gYObNJEROiYksM9yYnPNFUTCx3soWbPKev+hEfRviccv/755NzifoCddQxh9iPClmH0uaT6roGnYmjXd0ojGTeByQ3YFM5q+h7Eb21dk8/g/Q6OaeAqCp+86btBAzgcSIgSSWzIzMqfkEp4hCyqzKBOiESoW7D669I4vv+urdXpo8fSOkvfsIgDF8nI99ZJDGpAJqMIUzqN48/ZEBRImR2KgRkzYxlFwk9hpNyDqitrp25dXXt1euXx2GWs0uX7vGb2+1yutfnG9tbLi62vjBD6Y7s1Nm4dyFza3tTgrFiNb+9rujy1eWQtp9/4PltZWws3X5zS1R2Vnd+eLcuarbXde3ji8dmiKpI4TMHIuhiFEG/e75L2j5eqlN+IsGa8OtWRAoITBAcAl+LOFjBBMa1iMmlOSmfJFCCsS1YQiTwiliP0YBWHIRjdOEXtBkIJIAKLRGis6mSOoq1mJJnPYTdcrkUEcdhkhmHV/UKRiBC1+nGOvaMbNjzZ7QamJEECixgpyrNbA4FphaVY9cuwwZ4leExF1lmLlWMRiN+tCidJQTrzGyqoCEmMRVhsGgmipb5HmEWLEhmSl2a7Sc69XDqu14ulXVFZI6ha9jyR6ESmOVUqfdNkK01JZypxpVbJ6lrI1AIxgKF0IsxAWE5ECldPv9dgSzTxnkutskwRjJU1MWRFMGi8pQLfUHh557ssVcWTY0QWIYsys8QsqFyF+lwPcXNnGOiFNK7BgsqU40TjfzOD/DkyrqPd3EQAGoscIiWaFakrVVqa7jtWuDM59/0u0f+u/+n//sj//oRz/47jPPPPHJj998++9f/Z1nH2IqfD9d//iz5//Nn7nNreXPznCsiKyg7IhhLlvHjeNdl5M84y8XIOusESRqCvUgxTbBsUm02GVbbRXRuf0aHaPf5M5vtglOYTbBuwzYI98OUtMcQe5FVSegRg4IG9kykVwYhj082rx13dbPambahGdMNILtCFqoydS7FilCHMA5c6KImcQvYCYYi4BFJEehb7755hNPPLG4uJi/13v/7rvvfvTRRwcOHHj55ZcPHjxY1zUzZzJkCOFW4gMzc7vTYeaqqoqiKIoixlhV1czMjKpubm7udncP7D9gZuLkJvc3s4NnZmbqut7a2gohFL4wGJISMQlTyp3bWE9jTK0TIRFia8hvXlzJIKhm2BcECGnW4YQQS5PyUoZB4aUgYVWYk6EmKp2xaR0jJ1Nj0rJwDsRqrEZKOUlNxDFpRUylV9IUUgmuiJNwsOSYPFNUs8KKkR1Qz72YgmbNjYJ8CnHWtbhwdYghBVMVCiwWEF1ZGCVN0TufyFreaUxBNbNvSiNREMQJSSLPTLAqqpG2nK9D3ZKWeRTGbQIF3elW5LHgi07L+TpCzXyrjzSMsSy8B6WqmmZ2LBpNmFtAu1LvnHfeDUZzU1ObCFV/OFW4glsp1M63DQiaZspWGKTSeWXvzBdMFm26NbubRkGT1sH7QlwRU3Tia6jsSfFzM7uJYQrOhSNiIJNoQFBVAo+94lNk0bbj4aVrRUJR66frr43I6t3uiJdtVBNQtn0ajS6++wEUbHZ56yMyLHi/ce4LYW6rmurqx5+J84DrGQEYheGRqc5oa/faBx+V5Io6GJExsfMlk2sOV2Nrzcxn/xUNb77KjSb5X9heZur/2f53aJkmxf9H6GWDkkVYdrcjEOcVSa2EyxX7Bk+kBZPXOm731nfPitm19z9KRC3w6sdnCKp1NSfsXLl97lKfi2mzwcWVwfLqDMFxfeWNd0mxBK/L66sra+bdDhkS+uTaZi3icPX6+avX2bupqIYQxBWmZVSqAmIowCU1mBZoTH+/9axpWc4S8ICMyalJSIXbbU9MoogGA6bYFZoCacfgA2qFFQwjVxlDa89B2CcqSTQmchKAQV3PlkWyGAPaxKrRghZq5Lz33gXlgDoQeUbiWqXTmmZCjFGTee9iimwqWckY1mYaVallDONg1oJrJwlV7ZyLZgBpMiKmkFoiaqy1KmLpCyclkEhNk1pWT2DqEKpRRYSyFACzZclVJVHni3YPujMcqqOWdz6YiipTuyjcECVzcESGTi95VGi72kHBYVAtTi+UdZ0qZThnsMLvxlHyjFanrYxo6d5lBWZMLBxhOfw11dJ5stvB+wzFcVRT/Urmf+7SeJxVExFigSVr1JwalYMmLWMoGm3TCWhhCpiZy3los0Ih3T4uXG73hkc7U+H6+tX/9L1Hvv3b9/vO8ptvnzp5ZOnb39TNnWp1e9pj5eKF0WA4+vTM1tXlI+K9hqhxUvuUwZRJvGsTySkDwWKucTJzaq1E0+RrKlStciUff3DfK9+a2d4u6tpTpmrcwkQjYk0RRE5cTBFm4hwRxZhgyuKIKKUIIAOmjeRUrrFLkYhFOEuGMbOw5FgZIOZGjp+F7kRtmCilpGYiwsBIkxzY7w4vDkseEdeWBsOkzF6ElZkgRI7MEWCIIUCoKIq1tbXvfve7+/fvP378eA7Q33jjjb/8y7+87777fv7zn29tbf35n//59PS0qoYQnHM369D2SBJlyq/3viiK/HO73Z6env7iiy/6g/6hQ4ecuJWVleFweJP7Oz09vX///tFotLm52el0ZmZnWDjFKMKJCETM5ByZJOZbt2s1S5oxilxdTWpExtCEcY2iAY1VIFhVYVlmyJFHQhWCepeYKwAwiWHaOU3RQi1EhqQKZiHLrouAmmniqEXhKk0GnWXPw9Au3C40snpB22QAG3LtStJgMUQvrtNuV3WoQuTSDepa65qLoiJLSB3vfIhsiRCiGVGCkicgJoOZWsGu7f//7P3nsx3JlScInnPcPSKueFo/PIgHrZEAEonUZDKTZJIsFlk91T3Vvd3V1mNtbWv7ab/tH7IfxmzMZnutxc5Ud4mmKLJYTDK1QgJIJBJaPa3l1RHh7ufsh7j3vQeRmaCYLrCtPNOAi+sRcSM83I8f8Tu/owih4RLvYyJDClJnRZgJHDtltCLtvA0U2TgxTOBZhUFokDPCvtQikGUfI8cGmDhV2ijVhtol1rJnogZ7pZUnFGQJqZrGSaisQetSI5IDpUGlJKIVIyVJGqGJQcB5A2A9S5p6klBrEFSCBgmBJE61VkgA2CQ8VgKZA15luDCQrBCGQQPagAfvAUxolUoTF3qXV5g6j86BdUDKawmjkBKXt86knBAIAiGm1mttiIi9BxFInQFAFgRUaITFNWxgdD2NTRgAAKRpwYTCnEpCobIiDsVpHytnqClcmxNa2Hv/ByJvf4OGcH9a1j+232PLLG+llFaExH9AbBVf2gTAkQgKIipAzagFGCikQLHyHhMHmjSwDZooOQmNaaQWCKMoTOIERHJhAN6BiFbo0tSYIKPDNkoLMzJoJBK01hlNjN4LKxMAi2IvAlZJpA1631BeCD17R5CGICEqQiMStMDTG2RzD0xyBlFeEEFzk1/dIzAo61kUAZIDEe8DZWLxTCKarHXasVZN1jiDir23LD40aIWSxAAQEoM3wPW4ppQKSAmCy+uGtxaVaLCW81nCaxiJxlRcmsWHhYFAZQofIaD2wEIQKOVRIFR1n4KVQJnIaG+td05hRtNIljyQOO9RZ3gW0JjFKj0wI4jS6JGZORdp9F7Y6dB4jannchrnFHjvlIpqyEKYYwodk+VIBYzovFeCgVJLaRxGYV8QxUmSAkZeByqAtrCaJK7W6Mp3OIEqpkkS54KAqpYAGDzQQ6V3HjWjWBh9FvEQ1fQ0NeGHzYbNqEWGyzLGAEDmNXzCW0uNo4QTJDAmABbxHjNavZbzFQAC2UQgQEtDRRCTFYsA1iB2cWnixz+pl9bC1BW8L396+fbCQiNtXL91Y35o0LGsv7Ge97oItr9vIJqbXbx+q8gCmJKwBrDYZIxxABbBIQCDAmEAh5AqUALoIQPPeMAAsV0ZRl3xyjpfDgKza+/O7r4uhJCds7EFJq1AwHkHAFo1faJEqLWxzoF4Y0KlyLU0WgR03mceTO9dVhZeRJx3wqxIIZEICwspAsjeuEaEzAeslRYEefDVIyJ69tlZKOCE2wlte75koMbitCTIAqJQGVAaWSEQgQZAQgw1sGTsvPV6nYjCMEySxDn36aefjoyM/Nt/+2/Pnz//ox/9aGFhoaenh5mdcwBgjMkQDk3zBhER0zRtKxYLhUKSJGmaBkEQhmG5VG40Gn29fWEYLi0uxWmCiHrr7cdxXCqVgiAYGhoiUmlqtaKMsi1jz9OETJIpUpvkRyLEopCM0lop5RyCqJYd1Uw0QsRNUilRzdR7BOdZKApzNZRYJOzu0lEQpI28otXlZU06DEyapgTkUp9l1HOWUC9gTGBRKj7JByZgBWmKAImLTVtek07KccK+XjSdXR3ry+W2jo5SEi80SkEQQKhFYdDdEeSiFMGxQwFvPaylISM4x21RrrOdlqpGVN36oL/T2cSW4jp7Jgo6O8u1io0bBR0orRCJjGafpN4FYeisZe/CMCi2d6+ur5XBAWlhiQJSFHnPLoDYIHfkTUebT9Pawlq1WmsrtommeiPp6OtardYk9egkbIt0FNUadcjlivl8KGA8zK8sOYAoyjUq1b7h/pShUq8Dgk/t4PaR1LlkZZG8b49ykFhOXUBk2ZM08T3UIl3yIB6zehpN2JFiZJuqXCiCQCpFqgp05MMQla1VObZtUd5qTEiiYs6mlhKrPYXapOA8IHtvTJjGiQkDHYTA7KxFIk2KANMkYc9BEICIQQ0iJOisNblcElsCVIixcKIoRq/BFzaS6JubqDDzo6oa/QG3LRGbf1R/f9+tCaxDahaXzvxYf/jzB4FRfFbjEbOkFiRBYVCiSAUWVAOxvaMjqZbEeY0kmDl1MMtRU6Scs0ppz5zYNFBKCC1gUCykzqXeJ404bwIFREqJdSQkgkqRZ0ZUCpA1JeLIuwgQotACC4tDSAmFiJAUommFN6SFJHwgV1Ja20MTN4/oEYEUI0loLEsQBloobjQiZYiE2XJG9g4evBACGi0aPHDKnApbcJEweuXQOyWiKWwruFpSqlalo02ZXCNOXc5Y3xiIIkUUI9dtggaDYtECe+QASXtIGwkhpexicF0dBVu35aRuQwrzeamn2umEuY5c2NYbNxKqJBohZjZGgTKJS61L87kcg6RJYrQOg8DZJPWeA+UNknDqPeWDhriSs2FbWxBGkc6tLa2khDZfcGkaxT4X5WppRVLvFS4r25XLg5c0j1LIVQNInWrYtCORRpzUI9XX193W1llbK8ehWg2oUOzRDs38SkS6RuyEtfoK+dKEXrd40LMsasrYlkREJKPhEWoWKiGlMsfbH4Q9KQBIpLWOfQwIxhgQIWZsZb8RQAqAAAGgB7GQQRSaaAQFYhgY2LNoAKhX1ycqQNQWBHkB4+zqxD0wKkJcWpqviwQpJGhG9x7Y963XaisLpVu38yDIXiExQMZhwgLcur5HcADcNP8AASwBZM5gFp25nFOPoNo6u0rAVaN1Z1fCrMSntsFatNIi4rwFwCye77xDaDpxAUQphUCQ5Ri0/iMkFrbWKlImMCJinc1QDVmuSxa7YfYiEpgQEJxzABIEobB49vePclZaUwAy8ikGgAAEwNd9mppQIq2CAAENIwIZBE1AgIpEiAnIeeecQ8Qoipg5w/g2Go2ZmZlnnnkml8vt2rVLRNbX1zPgTRRFmQq6kYuykT+jtQqCQEQyD7ExJo7jRtzo6urK5XKzc7OI2Nvdo7XeVH+r1Wq1Wu3o6IiiqFqt1mq15nWdBwIiRQjeeaCtecnZgwuzZ2/FWfCMWbhBWAAIuMms2kRec8by3uScyoAiijxhOW70H9j31Pe/K7nQxRVs1Gau3yjmi6sLizc/v2pAIqW0B8WgWbRHRbrmoWqwfc+e3rb20sXreSBgNIXCyN79AdPM1duofP+e3buOHrl58fPdZ8868O/8+KfW+xNnn27r6GDPg9tH8kP9VkG6vLp249btv38rZ8F7q3f3DGzfvvz+FeV812Dv3j//k9XZmWv/9Rd16waO7Dv2+nfmP/z46kefWEEBTOKGAhw9crSRJtN376KAYmpra+87dKA6N7syNaaNImEl4EAYpJS6nkP79z73NPZ3aw/p3Mr5v/vV9mOHgiiavTH23Pe+fXXq3o1fvpesV3eeOPTit7796XsfFruLuw/sj2sVHQRr66vn33pnbmbh7A++NbJ7Z9qw41du3J0cO/LMmW1Dwyr1lYnJ2++/Xy7X8mRAONABpixNwx6wydUvjrjFl5yJOVRMinQDgIyBMKx45/LR6DdeGtjee+m//a2fWGikngMVszMVayyTVWlk1rXUjE6ZQ08Gsdjfe/Ts2am7dyfHx0UrEdYECsArYgADGKFCVEmS9m/b1tPXMzk+Zm0tMIF17BhQa+8dgNK6pZmzoAal9EYV739s/9gev0mLYy4r+PUPfTu/r9YMoeJmoBZT5piwrsD0dR/62svx8tLYRx9KnFrrUClhYQ/OOa01MtVrllBAtGPFINtGdgzu3vXpuY9tkqgw7xmtR2AQ1N6DZcbAWHbK0NDu0TSO11eX0rgepy4yoQbdAAErkVVkFbqMpLJVfLFFw/iA93cDwdxEoCIIYc0lub7eU6+/HrW1M6Cv1ScuXe4a6K0sLoxd/lycMCElnEcFCOU08WFgPaSJ6x3Z1hbo5YkxMsoKOISdxw+F+cLUp9dcHjr27965a/f1T6/seuEMp+7qj99gtvueOpovFq23o8eOBl3txM5V6ktXb15+5wMSgELUtX3k8K69cx99VvUrPNj19D/7k/rY3N0fv1mP68WDO/e9/vXxTy4tfXhFJ060Tq1ojYPbRwllYW5O2Hmh3q7+vu7OtbXVpaWlBMkaSVIXoGiFlZS79+w4/c3XgvZOnfjlqen33n135MiBvq6uhet3zrz6yr2xe1O/+ij2zhzaffLZF26ev7R3qOvQ2ZNSahBSbb107RfvVFfXjr/60rY9e1XNX//4k+u3r+z72pkTp04Wq7byydWbH5+rShKgQv6KGiQIIALkRZoZDZKVBNpqLkozrQyN0bFj5/0fhOsXmplC4L1XSpESnzppcSBIE/+AKQIBhoIA7FoEhhZAtwjAxYsghIhKJApMKuLFo3eIlFdalKI0JUIA7I8i5aU6P33lL/9yZW0lWV3tjyKOYyseAQyCB3AAKGBayOOskkWrCGtGoSgImpjEA6dexJMChxx7axEY2aVphGgwUMxiPSDmKCcgPvEgEigDAmw5IIVI3nlhr7RGQO+9CCtlEIEZAwyBRRqMAAYNKcXOs2ellUJynlmAgMSzgIRIACCpVUSaMvHTZDYS8d6D0gqB2DsW0KSNpHGjEbXlvFIWWJMKQIVABKgAm1k7hESEglrrjRS3rFlrM5ahLBkuUwCcc0qpJEm01pk3ukV/spnck3UlSWKMMcZkWnJvb2+5XJ6bnwOB7u7uWr2WWttkfshObGtr6+7uXl9fX19fJ6IwDFxqRUSRAkWceBJRRJgVa4MMVc2EGBqjiVCaiF9gBuCmEdEsfQEZmVdWR61F0AJA6EEa3iUIhd7u9s729z56f2lsIk/KJcnxF/cqxzbKD4/ubm/vLC0sz01NtUf54aFthc7uleXF1crK/pdeGOwbuDq+lNSXEMAq3TEwnKxVEgsWsdjWWdi5K751Vx3ct3PXzvGp+Qvnz5n+ge6RbW/89Ge90/NPf/ebFZdc//BcOrcIQJ5BU5gfHAq6u70KSkm5LYyKJ47RQL/72/crSePIqae6njk9NX6v1J7fuX1nd3fP2uLC8spS1zde7iKc+Zu/yYdhV74IDOtE66g6RneXy+tRgbrDtmR2ySeN9o6uvc9+Tdpzb/zNTwud3c8+9Uxb32B+cLi9o2N+cqn9wKHtO4fvfnwljqXrwIG2p56Sm/fahvvWnbv47vuB0sdefuH0175x6b33u/sHP714uauz68jp0wlhR1fXpc+vFFGfOPvM8uTEzOfX8lFEIo7ZAROStOgQSDK7Uxi8b9IaUFZ6BQBSzwGR09RAMd2d/U+fDLoi09+/PrtmjB4+tF/awoW7E1JJBvsGg662ydLK6tpie0/3yNDw4ux8qdHAPaNJvSwu3jayvVKuzE9PtxWL23aMpvVaUqn1dvQ69tMz0/kTR3cc2H/nx+Wov3NkeKRWrkzOzkU9Xd19PbmOdg4DaCICm0kaLdbGP/DWCps0t3/IahIp3MCgPNltA2L1pJsiuIXIA0AAiZDo/tyWP7yGAIAiyJsg/uyRmNAi1sTVtIzs2d5+4lBbZeTG3VtrSyvd3YPD27c34sb83JyIDO3a5Ww6NztXixs7du7MFfJjExPVoV44fnj15uedHUOD/YPL07OlxZWBnt6erq6V0lqgVVtPd6leW69VRn/wnfri4uTP/27bnl3txfby7OLi0nLY3dU/OFDoG0gArdKuVXc9y0lv5dM86oG2cNM6BIvQ0VaIivnxe7cXZmYjHZarlW2vv1K9E5Vv3xno6+3o7W7MLVUWlkipwrYB3dNVXy1XV5a6zpzc0dVd/ssVmyTMyCRdo/vjJIkb3oEKe/r6R/fdvDo2ePhEz8DAys2Ju7dvdO3c1l4ovvfrN6v1+qFXXg413bt0uTYxn7cYRdFKnPQMbOvdNjrfuCxeSa7Y8/zzHQOzE7/6NG24oeNP9b/y9anFVXd1un94KD/Qu7y4vLa83PHCM0O9fYs//QkKF4LAR7lVwpKNnO6vNcpRLujtytfmV4TRqGjfMy8Ehc5P3n6PTHT0qVO9O0Z7h3d09fdOL60XX362e+fgjXNXVlZW9h86NPTM2Zt3p4eGtwem7cNPznXk8oefPrP3peeufXqxu7/v9tVr3V29u7/+/J1kfd/O3WNXrvty7cSLz+VKS8s3rgeKHPNXZqhlGgQxADbp0giRAGEzZtLMwchSqaTFqPr7m9u/rybwqEXOIoqUoM9cjBmIMiEMgCxzojQABk6YSBR6awXBIRAqDwKeXUa0B6QBUuchoBr7kCRHOhaXJkknYqigW5FPYgWUVtLS7ZLXigjSNM0j1cQLosnyXlBCUJFwAJACJEgkEAAEAFakBgBICBoAhRUoBK1QU8NWyei80gUA49MOUAECKkydJ6JAQZa2g0iaFIg4AYVIhJZRoMkmy4gMpBE9O2FRWrfqLqHWWoF4Fi+iWZDECwOgVmRdhiEmEHRsUYREtZghmm5gBtCCiOiBBFAjhqKqYso68gLOWXISCUVMICQEApJl+wCBONlI18sU3La2tlwuZ63N5/O1Wk1rHcexcy6fzxcKhY3MywzetbElZW/WWpsduUH9G0VRGIalUomFd2zfUS6XV1ZWJXPnZy2fz/f396+tra2vr/f393e0t1vnRDgwgdfKei/ASmuGbN4DISkiIQHPmPG6IyCBQiJukQ0CQLbjA0KLeaqV8ZMZWWJFIDCkdV2sL0ZhW3GgrQur6ez6epIKq9z+k6ePnD1b8XaA1OJbb6liofvo0RT1gfYX3WcXzPAwFNtcR5tbqgB7nW/PFTpm70ylHjgwqIw2EauovLCyhObMC9+Ym1pwTrHFtdnVRrJ44PjTFY5nLt/JJa6LQsdxWCj29g/Pra7VGTwZTbo6v5gwh7t22OUl7O8rV9YWcqrz2VNDB/Z7oP35k/bq5XSo25ggOnnk5Nlndbm6MDnTUejKMT7z9MnJibGOXKGzwZ/P/EJBYBverdQ7hnbsP3CqNDt/+d1zS3PLu06FDozFYHV2Md9T6BocaTSkt2ewMr9ihbyOSitLc7cnZWmt34eHXv/WVf74/F//vLunt3f0aK1u1yfmq+OLU7Mze/fvySDuFiXxVoloQhWGLqsdDiDcpOHwJM16aQJZISQgYGYxJgWpWSuB6d+9q9ZIbl79tH/P3unxue1HDo2cOrLQKLf3dOhK0jc4AkQjtWq4vLD36OGlcmnv4YPjY+MVDXr7tgOH9sXWbmtrh7v3hvsH9xw9duPTTzuY6851DA70r48usRse6c2fPjw00M8NO6BMbXyyf8fI8N7d9yYnSktL1mco8wx+5P2TzYz7mzSRVuZSsxTkE69MQgt/kvHI/EPfy+M1AREgIqONUk/8+D5mE0DBDHWK0ORF9wBeYYN8bEDao6HDe6dmx/P5XOHo/rFLnx37xgvtXV29hH5srFgsdvX1MgvMz8Wp7R4ect7vPLJnfnV5rUDBUwf7d+6yLNsO712/8OnwmbNdnZ0rlz7t2zZQd27XyLZbt2+lI331EAZeeX7H9p1Jqdxz6GB67cbooYOdg0Mr5XIjDGuKQgLnM9suc5F8wYMAZPzeDOAIHIEFEaMkNDoX5tuLjVK1nDS4EM1EVDh78sSzZ9EQV+MLv/xVrljY9/yzMXChraP64YfJ6Eixf6Sze3BxbBLJFLoKPbmOm+M3yGsRFjCKIvCqsVTmjq4XXnttrbpWSeNCPr84PVedXxneu49Ibp6/3FH33SkRsA2DnZ2DjcX1aqlBQagl8LOrxkJxYGgxsR2DQ74WJ8oMnzxx6MypWkRDWn967pN090jc1Z0/fezAkUNaZHpiyttk/d7dYyeeKi0sFFD1pHBt+YNGPUYi2/AWg3xn3/LU7Ae/fGu1Uj5w+oxXYdXopZWVqNhW3LGjijSyY3d9fj1oQOSCyt3FhQu356oxLTX2vv6cmbj34c/eIKV7Xt9ddinXkxs/e3dpcb5j+4D/Vp57isAi4pm+yuYTyLStTEvejCpseOaxZZlThitVWdz4iRfIiIgCQkRG6xhibJZsJgDQOoxJvDIYmJGnjjcWVxr3phs+SZE7osh6n6CQ0shgNHiXeoUpkHPehqYKzoZEgimw2T7U1dXRuH6XXcrAibBTJlDobAygQFMjdhoIc/maTfMOLCIXgkJQCKsNlSQpcF0kQMqh0WxZKVEYsw88EmoPiEHgNNUkAVJ5ozCpFsu19MZdZcG6NNHNl1vfiKPgBrFHK8SymfUggFtJgeFBYqImDm8T8d3MipMt537FkEOzVC5gCGgR1P5d+e5O5wFEAsZAFJOxygGBAKJCZECCDLYRBEG9Xr948WIGfhgcHNy7d+/Vq1fPnz//3nvvtbW17dixI3MGA0DG7AstSgoRyTA5zJJhHjLeX2OMUmplZQURe7t7vfelUkkpykXRpvqrlCqVSuvr6+3t7YVCwbYAFh6wYS2SjqJIUpemaVgwxgREzaLH2XC32G1azl7cGO4tLhiArBTAZhFLJO9ZCIHB2VS3FfYdO5Ib2rE8s7iQ1plIFQv7jx6+OzP19nvvvfytbx09c+bmtevT80vs3cDX9tmOjvHJybTQNra02KPQaN3e3ZOkfn29jFoDgFGBpAwOHdCn5y4c6N1+/PRZHaBi7FBRyDYAkyPp9CrHEAqkSDoX5VSuPH+3Ya0u5CQMy0urNcL+Y4fiqWK53iguLnvGUrU+Pj5JgEMvvNDe0780t5ha20icoPr1W+/myDz7jYPzFy+5e3de+/4fVRaXPvlPf1FzLtJBJa5//vZ7IzY9deYZ80x47969xZ//pJ7YXKfmruLM/HwUtw3s28thLk393Mysj4KadyxAgCGoKPYQJ2kc15bWjo0e2Ds0slhZrddq6WLp6KH9p771WmlyfGlhTgWBZQZCIkmdBd0iqmuxenGTRLlJwMkEikEUOQASjl0ahOHR/ceUUrqzfduhIxdu3xo6sHd2YvrN998rdra/+s1vL80vnnv/Qw70C3/y3fzoztm3392/bah7dEccqMKObd1Dg5+88872zo6B/Xs1qes3r73/8UeHDh0CrXNKFbePTJ//5Ob16zqXRzQ//W9/88yZswcPHkITTN68d+P2ze7ODmiK15a39EkXtb9ByxTejMsis3ef8GfboM7Z8Fw/8TsfwKYCBv+jwB6abtRWLQ9CQiFkAdFEgXbE7T2dO3ZtX1yYyxfzu44eWy/X27v7Pnz//Upprb9/YM/eAx9+9NHE1OTO0dGXXnllcWVlvby2Z//emmcE3PfUSaVo8sbtnSdO7lir1lN37eNzi4vzUW9X3dnhYlEHudWJ6cXFha7h4YmpqU9//e4f/dEPdu3ZV2Dz4a/eMd1dJ0+fDpkAhLOaDM2Kno+eKht1o3mjBjKCZx91dZzsP431ZObu+Afnz6f1OAgL205tn11du/zRR88/9/zRb7xy6/Lnk1MzDeee+Z/OFKamVuYWFuoyX62lDCowhR0jXunlmQUrYglTQYwiVCax6eWLF4ba249957Xq+krD2yAIIhVoEUYgjSBMoNI0Kfb15zp7bn18oaoxDVRkonhpPV6vBDuGOvJBrPTC5FwsuA6e5mYbyC98/WsDC4v15ZXp5bUaS7Bt+6c///nK/NLpp081bt6aW1g+/dLX6qW163/zd3VGpkCUXP/o3OFCfu+RI8eeefbu+NTCr37dcE5by0jxcsk30s7uXq2CdpVbujelmbQ2Nk46JLTi6qUq68DWGmuTs0dPndq2fWRuYdY6Oze3MDIy/OJ3v7t4797UzdvtKiDvWuVSvrg1A7K4wfP6RY2QgijyvikH/gCsdgBFWmuTaW9BYEIHVSQP6AWYaI3d3gNHTv4//u8Ll69+/L/+7y5BK67BLIQWwdu0MyyssktRtNbIiKGpB7jmPQYBKnKkTzz3dHdf32fjs64u695yaCKlfMpWG0tIRCo0pTh1KI1cWIlTyEXDxw/u3bnv5htvpwvrsYZqUSeNuOakL8qvpnHNUOhJe9GoU8CYhbWy3ufDEFySixsyOXH7v/1Nfmk9BLCELfRKU8y1Iutb1F/Y4CSXB/TdlrraXKct1XlrLwBskNc3dVtoHrShZz9w5eb3ljFuK+z8p9/vePaURXSAikUBadSu6UJBAsrqu2QI5mKxePjw4cnJyYWFBe/92bNnX3rppZWVlf/wH/6DiPzJn/zJ4OBgkiSZWzfjIckUZYBNcnpjNBFl30dRBAC1Wq1er/f19QHA1NSUNrqrsysIg031t1Kp1Gq1zs7OQqGwurpar9XCICSiOE0R0RgDFrxzZJQiRYoEIOPUbLJEZ5gV2MIaAi3+VMwoRAgzUE2WQwriAcQ7REUALmkYRFpZ+ejv36hMzZKnRprqfA6Fyei1lZW11dW1hYXjR080tm3v6emtrZe0c5q9S50YKyIQKm/dyNBQWq3WK9UoNHGaKOtU6kKGHKm4tP7xpWvf++E/MZ251YV5ZdMgSbVnhayTJLCIyCnK0LZ+ldrG/JJ3TgwQCtWThcXZfQcOtfV2zk3NSFd3T64YDo2MDA2tLy8Z60NGAKrXY7teieeXFu+ObxsYJgFLMD4/m+RNEqm1yppoEfamLTe4d+fd2zcufHpxeNfuMy+/sPupY8Dei1vjxg4DM7fvbt+3t3v74I1PP99+6oTLazTIIE6jjwgHOoXTsJgrHt334d1rd5P1F//sTweP7I8H109/87XZlYWL77xdX14bKLYpx2i9yGbSbrYKeMNKbOHbueWSZxHrXV6pgNTI0FB7sbhwd6xWX13qmR89st96m2ca0vnurj6wqWfvvB3qGQi1qpRL9UplcXJqcWX54KmniJRdL6Hzs+Pj5GXX9u1JqVQwZv/uvZPTMxgnaaMRIRa1SRqJdtJhQsWAiXfVMsWpL9ewUFCZX7QZtlZK6T8AWfvYjVk2lusfBH3mH2ZrFs6GzCzfYpf/4bZm6TpE2ay3LImLlQYtsn/PHh/HqxOTaam6Y9+R00ePh6jIOuNkoNgh9TgULKigPSroIKqtri/OzKJzSkG7CpRNquVqZXHp9uWr9aWVAsPS3bGR0R2DXX3j0xOSeGkkJrZdQS6IU6o0jPWBgHiul9Yq84v9haKvNUxWcx63jPQjISdNYHBrgwVAZBRB7+LJiUtXr1VW1nwjZeeMgzYKjeDknbHJz2/tHd5+/Nkz7V2dQ5091WqdrAuQysulFUuLjUp7FHgN7aMjqy4uV0o61A6cQ48KQLHK6YXJuYnPLn3zT79PB3bOfHrNaEXOi7CQ8gSsyDJU2O0Y6UdjxqYm0hykGnIIsYfZhfmuPSNt+3euVEvFUBVyed/V3t7XoyqVgDGvw5WFRRWGGNu1+aVbn37e1d5BieVaPHH95tnvfLtSWZ1YmCHbyJM2hXzH9uFLly/OriztHN3z9CuvHnrhNKPVYTEkbHdw+9rtYkexZ2RgYWaaUqkaXqM4VwxqyqbGDwx0gFIGafvBvTdmx6d+9F9e+sH3O/aOuJ62Yy+/PL2+ePGtt1y5IhuZOl+V+ybQ2r6htVO0Ytv3vTQERQp80+W2lSn2t5zN/x1aUzVq1gxmERAJgyiOa47ChqHo6MHV5cVgsLftyP57n15Wgtv27Nm7dzdGZuL6rel7Y9Hw4KmTx5WHxZmFWzdvuPbcydMvFYrFxYnZsfGJtSBq7+xZJVUcHDx58lhQiGZvj09eutq+a2fXzu197T0rV254hYMH91AxNz6/cPXerd2nj/c897LMz6/QrdFDB/ft2ja/OH/nwufWy9DBp3YN93QslyY+vLhUqyOIFxAySpnUcijQYVTg0mB+Nppf6kLjNvStTY/jg+rvFyip8Hi9G6j9xz+3qY7XRfnOjkKStgdmuVFnYCRCJCHFhACgBBSgRiQF3vs0TQcGBv7dv/t31WoVALTWhUKhu7v7z/7sz5aWlgqFwo4dOzKK3jAMM/zDVvbizeIXW6pSAAAiGm36+vpu3brVaDQKhUI+n8/UXb3lYaCjo6NYLJbL5ewHQMTaFBGjIHQM1rnQGDIMAM554VZdegRGYURByWqUczMxWTJJmOURIoBmaqlf0lTJCEmrxFrtuGgCqDbqM3ON8ekcmfZCMVdruEYjaMT7hrfNbhseGRysltf27d8zOzM3OTG268ihdlTe+962joGO9mR+KW+C4Z7usTu3XFzxYUTkDTuVpO0okfgQ/Or09MSlC0f//J9BdUVJHCkJfb0BsdEcMrJzFGD3UG+jtK4bcUGrJE3aAHJAa3fu+tFdw/39Yx98BNuGO6Jg58Cepfm5uYnxA0cPB8Bxtby9q0M6200QGO91muS8729vG9l7ZPLShbxSx585+dkvfpXGFlU0fHhvdz73/ptvoUuK5KVejvImh6LQRehL01Ojh/Z0dHetjN3dc3Bv4Bqh5AdHhlZOHpGQCqcP37kzbpUc/+4ry598kubyMYlvD07/0Q9SE87e+WxkeKjiPFcaPrEGEBGNUr7lgdlk4pCsKDQAZFXAEQkVErFXKNrz9r6+6tTMZz/9RZLWg9W13UcPz41Pbuvqf+2Vr62n9clb13fs2PlHr3/b15P5C58Pju46O7LbpWmlXIOV0vz8XE9nx562DgqjsZu3McyH1XqhnuY99OZyAQCwd5VykSCuVSzAd1/7ugnz9+7e6Onpcy4JCKLQbCw/aO6O+D8C9lcAkUSapiMCaqW15id6/2hFl7Yq60/4DTdb5iOlJo7xf4SGIChOBIUdsgP2wCxeIbhGvYjUo8zYhx9fPXcu19ZexEDrcL1Rfe6Zp1F4bX5+dXn++PFDJ546OjU1ffvTC4W2toP793GazM1Mxd1d43fu7Ny548TevRIVJ6embbnUnYtyRFEubNNK2dSwd/XaQHfX0vTMwf17dgz2YdIYv3m70NdDIWnFKiQrNhKmrOxFFnD6IvdvS0dGABJRDORsDjGIk5Wx8dXFJcPQ3tGdU0qS2FZ5z+iOxTtDg6M7qqXV/Yf2lVdKd25d3/bc6byitjDs7uvKdxdxuRrkg/5tvfP3JpRNAhMYkFCsSuuR8gGk3cXcxbu3b3726dk//+eLN+5hPQl0oIl8qEWj05B4TkPVMdIHpWWX1jAKQDy6VBOsLS109XSM7Nxx51c3i0DdoIcOH1pdXbl9/cqpp44bcLliVAjCfJkiQiNei8tpKobmwLGj5bmpSNyhU8fvvH0uqTfadX7v8cN9AfCFc2laYVePIiVpTaVhwC7Hrjw3vf+5s517R//uL/6PHcPDjSLXChJ15P329v6eXYe+9WJ9fNwQnvzBtz+8cI4DxTnCofbDr56tIV68+D6DhMZY8eSRWnS2XzynAFqMBNBKaLo/863ZMnosZsHNeopPeiAogykrpUjQe+e9ZwHrRKFm0j27Ror7d//iFz8/uHdfz6ljn165Oto1cOD118M0ZuB9fYMSRcPPncm1tWElGT1wbBlp5OjBtsH+2ura0VcOuyufl72qe+37B0dfeSnqKpZWV3d8/ZVYTMeJgwdefL786W27Vul86mjZxt7Ge77zjfn3Au7oSsOg1tU++t1Xh3bsXF9a2n32udzg0JUrV4/8+T+nuFb75S9JeQRPiAiaMCAkAA4DYxwoz3mQdoA8ePfQ4P/eX8ZvJzgFQEHgRSiNrY1TSJ0higLRypEwZVXcUQshCBMjYRAEiDgyMpJxmWW4XmttT0/PyMhIpvhmRGYZU1uWKgetgh0bGjCLZHUxrLXWWmNMLp9DwlK5lM/le3p6yuVyqVL23m+qv21tbb29vUtLS+vr66Ojo51dXalNCTGIclaRTdNAMJfPV129yXEBgIRaa8tOmuCHJup804hsAvAQBEhQe5JmkKtZUSGrIkKeO8LILa+On79YSG0+irRlLRzfvLlWKa2P3x09eOg7Z58traycO39h36Gj20b3BD195dt3y7fuAHO+Z2B3f9/Ywnx7iGsT91anxnPEmrwQ28XZtUuf8uzc6rUrvDhfbDTGPvlY+vNptaRtLfBYvX21oq2SBL14ZoU6rayvrq5i2sixygHYxfm1zy7RwuLCuU9qJhffG1vt7l5eL1V7+3q7uk5u2165fWft1m0rfvTECQdYOnehO7FmZX3xk4sDiZe5hfPXLg12dhzo6esNlEtd7JMb77x58Juv/dG3v4nVdObqteXLl4sjI/HsbG59rXTzVjI+sfD+R9X2tmBtNbl+Xbn6op7q3n/g5P7DqphfHp++9u5HjXJt6db4KydPo5Nbv/hVaWnBHjjgAPf0b4t0YWy1vLRaMQAFEyZJ7C1jEGSTmFrcZwAIopQIozRzFBGQwcVxiCpPdO3qjaVLt9VKuVdx4+rt67PzC0uL6509PW0d0zMzi+XV+vap/v7+1dmF5YmZWt/N/uFtS2srca12b3J2vVZea2/v7elJGkl5dnZ2YtbblJbWP//Lv+4YGpxuVCv1+tr6ytWFJUjtkuftw8Ol9dL4xFTnwEAprkddXZSmwsLMCCxfkbj8h9QEmmpBC0OPpNQ/en//L2rNXIg/DFX9cVvm8QUCj+BQGAVEAsKQoR3o2jvv1yanhpjsevXKG7/2xgREB/aM1kql29evRWG078ABj3Dnxo2adcdPP21MMHvv3uriop2YWlheKqyVB3p77978aH1uoYIURuHywlJUqUZthUsX/6uNk7Kmrq6O9cXF9b7e/oH+ias3F5eWo97u9Wp927Y+4kZkUAko2fT/PlI74i34UoasiB2Egq5aWxmf0EnSFwTaiU5t/ebteGF+pV59/uUX/5d//S/n52bf/+Uvtu/Yvn/fgedOnqjdvpveHof1cjQ4sK2zqzK90tlR9PXKyq3bHY1EyOaND5cW61evheVy9fp1VyoFpdq9Dy+09w3gxPwAa1P3MjFXzYHUY0kcOBV15j24mVs3ijZBhJq3urQeX7+eTkyuIeVqSXp30ido4xTnlw7u2bXz6TNrs3Ort+/Ecbp9127w0LhyrceLrK1VxseHo3wXqAs//duos3Coe1vc1larp8ny8uy5c7u//Y1/+r3vCtDE3btjb761b//etFoLF5dqN28nM9PVq21SLa/fvDEYqLRWro/h6JHia688X4hyycTklZ+/EceN1f1zr3/t1bRSvfnBp8ncQseR49xovHT0qcKOZOyTi5O374BS+qvmv7TAixvgh2YJhgc5npp/ZgkA+OTVZn9kIyKllSJFokgxESKR8xxQtJ7Y7t2jUX+PN3qFecehA+27dhzYczDK5f7+Zz9O1lZ37drTNjyY27HtL//DfzRL1V0jO/P9ff0vvzx19frY3Zln9hzeduTk6spykmLfidMDzz77/sfvlufnXz1wrOPUaWhTayvL7/3V36RJoyev1+vVfKHw4nPPdHb2V29MLKu26dW1g2fO3jj/6fk33j5y/NhTr35tzWiFdOkXb86++VZ3nOaCKAUJSGsI2EGgDZG3HDvPPsMuCiPe54N9dJONV/cV/tsvYcj7jXy/2TdKrBbrbT2RWCKVJj7V4jUJEitSDMqjEQLg1Hsd6jAI6/V6RvdrjAnDsNFoOOfa29vr9bq06h5npBDZpN4gi9iq/iIhAiqlnHMZP4mILC0u5XP53t7eRqOxurZKSPl8vqn+ZlTJc3Nzzrmenh4RqdVqYRRposRz6n1gTKh0nKaenQ5NGBgk9N6jRwHJfL0em4oKtvTfVlXYbB1JK9YlG+PFnpUiTSSES1PTi4sL1jljExbwVu7dvFKzLhG/PDWlTFCvNwLG2796c73nc3Z+vV4x2nCj8cm9uz6JFadJzd64dCGxSRSa1MdIuDI9XpuaY0e33l1C4B6Faa1y9Uc/Ag05Z7Xj6xc/qRdU3ltnHWilAcdvXGuwA7Hae8MYLy/euVhm9vMfrmghtO7Wr98CY0oC06SL+VypWvIiLPzBjdtgHSRpJyou1W69+bYLTAUT4WRpfJLCCEu1wIuJgoXbtz9aWCy0d6DHtFyO4tpaqcpECaezYzNBPR17+90wCLHWGC+/nxqIPa+d+zSwEjKmcZLXGCFM/+TXa7kCE5Zskgujz/7f/1lHoQUfoPfVqgZBAXaOAEgpBuGtSwSBIKtkgwCAItTMbfK5KIQ4Rcerc/Orc3P9RuWZcbVUml8o5INadboRj+WEdgemNDl7Y2IcAftMqJfXZueXQJERseK78rnG+sz0vYnIBJ1Kp6VpdrZPR256bm5iJgXBQPUocKVJ8S5UenJyFoi6tbZzC8Cuo71D+4xiDwk2UsQIQZCFWiRu2Rz6QtfSk9KaVCebkCkRFEHArHCrF85w9v+wd/nl7Q8N+7sR/mv6H1tiRwSEURyK3hTlWdhqI2iYUaAK/PedV5glTWAmJTlLM8mU22xf8SiCAuAxK/lGCBt5k4RofeAB0jRZWzfVpI2Uda6Rrnphh3Dl7lhOm4FANyprk6ufxM7mgjCv9cQH55g5dL4HKblxty+K5j+8sISAXvrDnEKqrZZNaBbPX7LAyBKgYpDVsUkTReuLK6uXriJRu9ZucTWvoECk0kQniWbJKhy11N9HjWSThTQrHiWMQAzFMEzW129euoTWcj02pBXj3V/9uuzZxvFH07PdI/0r8/PJ4tLkxEw8NilIK9MLxSDX8O7TqQlj004WXapce+c9N7fab8Urpwji2+O3xuZctT5VWa0n6XYIGwvrV/+Pv+qIpdcrLTx/6XIpwrZUikARgkvsnUuXca1SSFLjRDurdeX2G79y1cb63OoaX/RxPD+/KqnTgPHdexWwpbV1dD6p1921m+LZxolhByB33nmPEG/cvbtaL2E+hOBeoZKEIHXrFj+7vDoz0dHfA8zL84u63lioVGdTH3i8Or0AtcrM4rIypiuurF/6PE5SuDZ2+aPPIdDQSKVc16kvaHXrR38Xb7+Wxm5ufj5QeGX6v+SjIPQcxrZRKnVDIMwbrD9f1ASAm2kgkNkk3NzKpRnE3dRs0BgTwGax3Kz27O9xIfzeW1a6zHsvKEoppbQAs8ZKHOe6O3YcPhR0dDz/4osURl1DQ/07tsdRWCmXVkqltNFIpyePbB9moyrO2nLZTk3t7uvhtraos3NwZMfyWnl6bi5SSukw6Oymrq62keEoiBZm5xempnpPH1worVrLHR29vXt27Cq2VVfLwMo0JGooXfXd+a5UhSuT8211LN1bsN9p7yx0USmG5bqvp0LiXQreE5J3bFSkyMS2HnqKTGSVjhEK8GAu2mbOWksCbnzY9EtuUQRkq6yEJrJq40ja0otbwDBb37c89OeWK7MygAGxJqLASi0FDwZRslosSARKEFGJMl6aXL9aa6VU5rvNwLtpmmZab2ZxZbMOoEnjmOEfmjeGmKU5IuEGizAANBqNKIqKxWK1Vi2Xy8VCERFBYNP722g0giDo7e1VSi0vL8eNOBfmmT3bWCutglBZ8GmqA6U0SWZ5ZEPBDMCplpr2ToF2EFlyCFYJI5CIZgBgBkm1ZBK9Vf9SBCVbRx7AW2afakVKIQg4drYRk1IRkquUrIgmpVCBS+vL80hELg2inKBvVNdIgEg8inUOlGqycwOy5zitBSYylhUhGPLeRYI+ZaMMR5K4FBqMWksOBRBQ6tWKEGlErxiIiFCSxCCAdaR0TqnEp+ItAniWWqMk7EJjvIhdr2siBejFIgFIbOs1oyTUyM4n3NA6Y9BzHaFJkkayGCMgeR8RiksJKfRObDXUhhg0exNobxtGlEZwlYaQdozofWQCB0LMUit7kWJkfLWkraBLPHorVhHpQHnrG2xRARF68E2YLwATUCbspMk72BR0IKCVIqQ01s7lFEDgE/EFFpVymyh0yF60Csl65SAHEpiI2YcC6HyelAh4REbE1AdMqHMigtaDZ6NC8T5E1ErlCEHEJS7QxrFopAyI4QGdOPQ2UChaJaQUaOMAUIxB0qx8ii4pOAgZSEg8oFKMlhG2rPGtiIkt1umj0YePxi09uMAf89wHD0MEVuBJlBZCISFxGr21IbMymChOFGutdBA+XEPyiWobMGVEzHBX/9B39Mj2oM4q4j0zISpFigDFeUxrgasYT1qixAcEDjFFUSQOQcALem5x1Dxee+C4L1aa7+/ZyoOb2XG+WWsLmREItQiJaAtodAJsNTuTEsSGU0LwABop9Bh6IABNSizXEhvkiqlfc54CFRkAFkEBVIEShIYtoBakgFAYwYn1XiulUYt1edTKY06yDA3R1hNwgZQClTrHWb58Rr5CRmIOlLGMVoQRFBIiBswakbwTZA+yQRwACPBQllRzn0XPW16bFvTWuyQOTICKAMRzGpeXtVI50vHqwuTKTGRMJwqn8fr4PQEMGFy9qhTENWaEQKsktZXJtbxQYjDLavBxo8J1ozTUqiGLQeVT5nJsU05Ip8C1SpVTnVNKAXjyYn11vhYJRoEGwIA0OltbrYak2Fph7ghCWy+hYxaYv72eiFNKKaQiQLq+DCyIoEU8M1gUpLRR7SCQRlJdqwArg6gCzCOm66WFlWUACLWJSPlKDZwnVOVGNTABeG9j7jAmWS/lARRLo7QOWoF1EWqjjEuT0KvJa58TYKRDA+ynSyX2BlWg0DuXD0IWaCbnfMUkFsWoGBEx9cwkIqJFcsI18UhoAY3SqEMk5a313mc8MF955f/eDbOaC019bIN0DxG1UogeQVL2NcOxTrftGuwqFm/8tx+P3R1nphNf//qufQdq0zMwPGR27mxDeuqpEw2bOtL9IzvSsO306TOluF6fnpwZu3PhvfdPnjmL4nMdnSjJ2sx4Y2py5vK18c+uvfL0GbYNYFEiFUj2Hjl5+Mix9994Y352YdfZp1UuECDqLKQ+lXp1eM+u0tzS3pNHQ/Gr07NqcLsymhRpdp6dgEvAUwABObZORJTKGUAFHoisF5Vhh7bsRls12ux7BaAAPIDNRqhV14MB3JbSd1uBsCkgA4YACJICGAANkID4LXyLcP8vboQONrZPyuoPo45Um0lBS6w1oPKKJfJakNiwoCURUihAGzMqS1wDgAwOkanF97GbtQB4TbBvC4PempCYvfusNAYzh2HY1dU1PT1db9Tbim35fH5hcTGOE51dJTu0r68vTdPV1dUoigqFgmfvnVOk0GjP3rMEgXIaAATEIylFWkAMYyDkQRooLMQWlRgr3qJYEiVZQil6Ak/ARFv3AYFNUpZM7wWfZWIhQJMLQzJmasAMjpQzgYCASF4bsQ5BABVk6cMsQAoAwAFAIB4QAA1YQAMKGBoZityLRs0MMQjpHDGkIgiKAMBDgDozqFxWkxCAGAgBlRYQ9qBRbU4ikFCF7FkBKmWyR3LZbBJWmggAvCgKvIBHAIUAAh70ho6GyjffF2hlAMB5AFKOW1k7LAhgUHtAR4ChEu+gmSstBCTOKgHQKOCMoIBmgdQJIEErMLVhcGR3nuVYI0nL+5vRnKNlrsRJD1AImq1fs7FHBASNAIRiuekp0yjiAUkcA2AFBDSIbPkR8YAI0iobqRGEs+HKKmmiIBI2vCNSAsAKE+9ZYSzeGiqBDxUkCCFTwOKEAdmBMxoFUHkvLGJMDQCsR4MbM775p2x51NaHR7igWtPsvnPv+/CbnSsPGuIiJIJiCENPlrHOQpoKhAGigEvBMoEJooDVVvX3CSRC25A7AJARiT9pd9iyQaTFxN6KQCGQJq01AkSAkSASstEMirxoIdbgUBw15dQW02drKA++KKFkyzhIa6psHLZph+GWW8z8zVunWZOLCIGz+pjNE1AxGSSkKCGbEjKy8TZgTyKeRQGGHoyAAJBSQS6XRtGK944Rw8jZmNCrTcuQIdsbBEBRFutBksQ7AmxmqznXpCLD1kgSgHeAIkAiwFt5kRwjkGiyBJUktgw7hB0Lk/KYlVDYeHqAR8P27zNQURB8lhhOYlmRzvJ2TZN2yUVEEQbAAEAMknksEQBIABCQECEmAIAiBABS080fIKWAxAEQZ8qRGETxQkQN8KCAMCAAcWxBHCEB5MUggEMEQEEFHiIVSvYYpJiZAFATiARAIejsHWIW+GzZxkop2bgFBkgE0HgSbsKhUQsVs/IBDMCgQaEiEDSKhAVQoSZhMNASDkTACMqIoDATAghH2iCIgNcghhBICwAIKqWTZmWKx1BSUZgEmRQap9BqcZpIQIsoYCCwQh41ksle69ZkgCcoELR1liGCbNZEMEqhQcE4k90xJ73FYKCr3U9PLb31fnVpVZloVkVnvvGNKyur8erat/6nf6qdra6tfvbrN3Nh7luvf1/i2K2Xrv3iXKfWxw4fGd22Pe/95U/OkbMibvHa5dXtg6+++PXqgaP5Rn3ms0v27kRnR4fSsjI/7ZdXjx86cnhwW1sjCVw6PTW+7+svbBsamLlw8cTzL+zcs7eo9I13316anHD7DqO16EmhDsFxAM4ABQAuVqhIh0aIvDfiM+otyKb/ppBpSkDZ8tYRICsy4VEYJcMmQTOmBA4BBZRkaz7LeyRHYBFDjwySYnY8ewCLoABQYKPoBQBkNVIE7ruNDXkooozKh95HoI1GItbCwIEDYmLRToQBNaGGTf31vrYVYJMxJmWfN6q2ZZOwqRkjpWkKAEEQQMtDnMvl4iSuVCvdXd1tbW3Ly8v1Rh2pVfSYiHK5HDOvrq4i4sDAQKFQYM8ioEgxArMgilLaggdE1YS9o7CQEDmDEgVRd5KLqzZFAGuoEWCqhVgMZ+OFSh7EljwALrqv5+FPD33zOFd7YG0+7Lff2okPHfPAz923p7UaffH6f7SOIPeraRtuks29YIsGl81URFCt22PZep+4dVPO9oGHITwPaWZWMVOTsBmbgAJiIvQOir0QtndtGx1KGEAcsP8qASePk1+8pTWLz2ULVUSIgMAhszBqSvsHpFjIko8VEAEwiBVfdWmoVdWoZS2rhRB627QEofX0wN098mYf9QiPq8M95rkPHiYNw7XAK1RhSuKprDyHJq91Cmi9zxPldBAg1FP7JU7Df2y/Q0MiVIoAAVgiVrky6BJENoJYIwdExrJLiUHEIYAACygBbtZt2GzC0CwRtRkHztSh+9VfyAgm7o8h0H2+XoCHk+pFAIQySx+IgQW8IAmIZxGseogZ85APfRR4s7XeGwB4xDpzWThpi8Ld2/P5NoU6dQlrdF+JzGwSSXz1SDKCQJNmiVoOW4fZuPkwF7r9e1baCqv5YruOlWsp+pv1Ux8RVnlgODft5y3/vM9yf0Cpzs5u2RItlrtMG86GdVMsbn5oWTT+fponaYngTF14WGt8pJ6HGYdO9pxNWQ0ozdJhW79vXoQ2x+ERvRmUc0ORQbjvFjfmWCvpPHt02fiwcVetyrXSOuNLRl4AE8MNw95hQKFFVUXvCbsVOiRuOvzEQAbpRmOMNgYy394TaAk/1IgIBJAYkABRIxYcFGzSuHJ96taYnlse9B4dpJ9+dm1ucXZ9Zf7ate1799ZqtcbaGszNX7t1b/uOUaP16tJiuLpyb3yq+tH5wb6Be4uLq1PjttBWy+UK6yuf/ee/2LlzVy6fm1xecXOz5ZX1EnP7Wqm8snZxZa1voL+8snrtxz9jJ269dHX5fzUi6zOzN66P9fT0TM4vrc7NdZO68u//U2V1uRMUAmdpu0CQJVaFJhDQaO3WGbHV57rRmosUWj46wBjQIjiUjUmCAgzgWkxQSZMJLlMFJCVghIw4yhE4FhJxCJZApLl3f7FiBRuuiM03gKJRaaWIkLjJ5yTNMiqZE+F3mkWbDhpCBMi4fjP4RFb0uFwq53P5rq6uhYWFaq2aC6N8PrepPtfr9Xq9nhXVSNN0bW2dmbXRXoBIaQRiQQAiytaatEq5x6TWozDu6y2EprBjV0dDCqIaIaARpUGxGA8ISELGPyhRvgi4+WCFzC9Qvx5YeL8LDDRT0B/nSHnoqMc3fx9b3Xrwghm9h2w8ojTF/oaiuyFDJdOVH7jgA0FhAE/MSlqbHwEgAzJQBMK9PXO9XcGZ03tOHEPKXLlfdcNb/vyStrFnU0v9BQDxzMBgNCtMhVPgQqFQXVpGpYklgwUCIBIxUqxU1VCwc/uuvm6TuFCMcvg4s+XRW9fjvY/HPPehwyTVvqGd9hilGIAuow939rp6rSHMgJq0ASDr0Tp4jADlP7bfrG2xETNfah2wli+qnTsGujrzu8vtTAIoAadKACQL9QQe1Walq80mD8jz1kUfJfUfOvdLMkq2HtbamailkioWYUFNIYBFUW35tXx+QTwDogCyoAAIskImsoUov3P7gdFd+brznjnQMaL/DQbpsW6R7ld/hcCCsEJHaDoKa4jRmdPBaFn7rZrgl+h6X9oLLUfqQ6P8gG2y5WXcp2Xf74x/oPe+7zGzw1sefdwky71PbXy00Yv8hc8iD+j1v3Pvxj0/4he3TMfNXmnSvn7JyAOAFqWZEw4x8EIBp50DXdyWrxN4IMWgRTSzBlZNQGjzalnA+gnWgJvpUCCQ1YpBRBLs1Ka9LuniSirSDehAwHsfN+zEeJ/WtfXy/NISauUa9X4TkXW1a9cUEbukC4mStLZ+Y+bOXS/S6T0l1gt3siek0ueXK0ohYtFaFceefa82AlC7e9uOjQGLEw51rhchvXGNlc45V6uUrSbvfR4wMkE8c6egjAdhzx7EO59V2EVEzhLdWlG4LFsRCYSbRcY2VF4A2OJUQweYIHAz4b1ZxSKTZxueI0FJMYsmg2oCW+9bAE3R1Jov929XsoEShlbkKPu8cfnMK5DVIWoCHJCEiIBIQHBDHfjtW8v7i0EQZPCJreQk7e3tK6srC4sLjUajv68/TVPvuan+ZowSXV1dhUKhXq+XyuWMMAIRHGdAOBJwLKKIiICFmZmEgZQNTKWYn8mZ8ZjTUIpEoWAtpKqBVIESCDxk8XbapN++32P5qGfZKrBkc/y3jnk2D+T+F/TIcaGHfvERusv9aVRfKCj5/sDlY2h9W+8EHzr3UYLjYYULRTY45CUz6gEBqRU035hoLbfVVnEPW2Lr0hpSn12KAChTfzPaax3Ua2tvXPzYE2oTsHNGhO672iPGpOWWeOC5HjwLAZCBQEiQJAMfIwCzgChkQgfiQdoLhWGjwijaWIOIRDoAZUppSrVavS0fbh+0jXTNgw1Cxvt9XI9SVx8xovC45sjjnvvgcULIJM6kHlIMVKQ48T2RX1NQyAtqcV6SNGAuBkHpyQPR/eG3VtXsbK0oWle0PthV3jOUwlDhAFrGGLgaotUZ7gmQwDtQWzifNtWJpvp7n7tyA6aQHQJf4P1luv9amze3ceYW5XoLZ0JWXlYpRYjepmjU1MLijJao5ZykpmRES5RG4Xi9Mr2wQDXrEBOlnNIMG7/9aAcgfmnv1nOzrDxqSozmakfCxDs0yhNY4CDKYTEf5qIHnc5Nw/1hL9Uj5cnm2Ge7daaPtuop4Ub+5UMD+gip3lL9WudueKPvO7ep/m65FLXeCG6510cUDxDhLY/2hbLxy8f2q0b+UbvE5pDCxmH4kKHVGqsvG3kUIORAPMUcYSACqU9zvd11JbFSDikAUAJaWAMQonjvmVvDBn8I/A/3PT4CiLWKJURwIgqEAfIIln0MqRYVMjQsKzEirNKGA1CE4iFSKM45gBwKO0GEnKLEp7ms0guwE1HsPECEqLwHBE49EnUQWnYskgP0ts7AiCpACSOVJlYzAnggFO9yCMxpyp6yguEAmf/SEHPMRECkMoEgrQkp2Ko11kyxziY8ZcWHLZBHseQIxPBmSb9ssisBEfAADmEjWRUFDANmEE6AgEELEIAWIN4ATtDGYGKL9aslTFq8LpjBN1tiUFiYEVEpDagECRQrVEoQUAn8NlNog3Z6E/ygFAtvFD3OgBBZKbeM0ndocEgptbyybNO0WboQEdvb27u6utbW1lZWVnp6evr7+0xgbJpmYRQWDyJATRMTWwg1FAkYI0t2vTFxb2ZtZS3HhA7qoakH6Ak0Q+Cz8QL3cIxtq2zZfKaHHvI+idVStu4DtD5wtY0L4YNnb/7CfYJGHoDHtjYkfMSJW6XOg0b3Vwia+6+39fr3xek2RFvrSyREraBlQiFnCNrmbwsIyUZg8BE8mw9b5yjcVEABqcnMgZ5FBaEDbjhHWuvApNYB+MdSEh+vYcuzRRk7kkAGaLfegSKP6IX7e7qKI/2oSIChmRoOKKhIh1HRYnBnYWXsxo2VtXVUYYqakR7YMR5SQeS+9OWmVIHH3K4e49zmR2nGxyF710wCxIGDMOE2MjEnqt2cGNlmCu2CBCwEoAm1pv9RaGmftLYZExMRTSYIchPTC5fu3c43QDmxRtUCsgQI4BFQIHCot+hWm7NBNko0bPbhQ0c9NFsAADxtSIitwuF+zXNj+5BWSL65/TGwkLBiPzq8LYcoDEIgLVmKgiLIgBSGC9XqB9euu5qlYj4GAK9Jfo92lWBT5jRX7uaoKHIgVjwqFQUB+oecziJ8/8PDA6N2/0jglmMAWrVrv+Bg2NCUW9CHjRO93AdiaW0GD5WFbQmNZqYg4VaFu3UuSktItyCSzY5HBqAf2R75u1+u/ELTBnhIPrSGFFqHEQA+BJ2U7KG+fORFAASRlYMIjXgWTkfj6uHhQYdaWlSN2SYhIrClUs8T7PdtNYSMNIiIuOU69YQJAotoakL+Y/EEYBCtMKMUjE5sygDOAGn0gqmXvIFE2AtQpKz11kGAglpciwwHIeMrEhFxWfI9CIhYBiucM6rhWGlgBg+eCAHRB1KzThsShlgk0uBZWEAjUtNX2nRaK0VEhH7jtbdMUNl8oQyAQAJkARNAB+QQETlgNoIBgGppFdl8yKARDgCFLIhnAABiCAEUQND6lUxpNtA8zQF5UACCwBv+5tZ0ym4vAwgAAG/ilVrYXMYtghlb6uRvtQNuKL7Z56zuhfec2QxZgmaWP7e2uoaI/f39Rpu5hbk4SYwJNrG/3vvFxUXnXG9vb29vb5raJEkUkSJiIi+slDJaJWAhS1NTChE9M7HPecyjDkBpbTSGQqK0NpqUQIAQICAII7jNPLfNBfhgRnDziAdl3aNizfBIYfIFF3zgy4cURLqvF6nJ97Jh0EBL1jMgUbOMDBGJgAgTKRFBlCztZiMk9JBDULK3ld17VrtPQNh71SSsaNLDIWYqbvN0BkDfrGfCwiysSLEwwcYE2hiDlrzaMnqPmFsoWbYDZoFUyQoDkGc2WocGvYgIKqWBtiRxP1p0f4XS/3AvshAgCpAIZTsSeR0aAajHjYACRcYjIIooBARgAc9sHTkMyAjqtThdqDUCQ8AMAux5I/RJRKTURsxoC1GXbLh5srFthWFUazZttXk2YXfZK2PmTcZrJKUUtHwrzM39npRCaB4JiA3wzlBOhyblqk8s2SIbR8YLsYBWKgxDQYmT+leiq/+x/eZNsj1DK9WUktblmFy1sby4nHfEqfjAVAg9CHnJMsMDD4qBsbmMRASRoBkWb04lZm4y9wigoqwAUGulZ+pBpjA3NypR5IWFRUSyStfMDAjMLCxZCgsppZFEiH0rA69J2CKGUDlrrEtMW3ehWBBtM1WUtmwaDMyog1yuvbuGjcQoUUHgyDQ9z7/xCn2olwVEUFAQM/BSU9hIhrET9rmowCLiGFsJzZvaXosH7SvuAB8kcmqpvwDSvI4ANNPcqJnb1FrNTR+kiCARM4OA2iKsNte1AAAQgohkiq4wexH2TISKyHtmkAxFmF0ZEVmak4EIm1IWQEC8MLUmGBFtMbzhEQ9yvw/8cdVfbDJU3nfprdRyrePx4Qhyk2bxy0YeAJwCpxAJPZKPEyDd0NqR8oiCzWHPmIABRGutN4a6pVA+sQ0BN/gEUCmlSBQ5rRJNqReNqIQNUd2zBiABFWhmrjmvAESBAyEPIkIkdYtIYAhjKwCotMSOjQHLoBFAQBE0WABBEXgGEEEEL4IEgdFxk8IeERE8O++dc7lAJwSJz8BM0AASQEXA3FoyIs55z5wPc8xafMLsM5Mmm3Ybo98yw9AjSaGg2jstAaMYlLxN9XqFGw0EyNYCZSIr2zVFEElIMAisdwgc+I2Qb5M1AgBaNi95VAmCRgIvBoTun8Ow5WBprjUkIq20NoZIUVO8YQv8IC0W8N/q/W5hPcuaCUwYhsxsrQ3DMAiCUqkUJ3FPVw8izs3P5fP5MAg9ew2t2sW1Wo2IBgYGtNYLCwvlcjkKIxFupBaVisKcRsfO6kAFAWXyRYEgohVJNVeVrQZci9CKKEWJwlQjSGYmtJbffeukpVM+NFu3/rVFbjz83Ju9W7/6ggs+esi2fsOcrXH07I0y+XyuUCisrKx45zOzpb3YxgClUglQsXcAYEzQaDQAQSvKNjMRb4wJgiBJU0JkZgAU4QyAkW0KRApErHdGkSCKSJjL79q1s5AviPDM7OzK8jKL9A/0d3V1EZL33lq7uLxUKldGhocLxSIIFIuFarVaKVeWF5cAAZCUImF23hM+OHoPPKwAMqHHVnVSaf4PWd0fzLCF2eoVzVvpzx/48PD3X9bblKHZgtlct1kuh6D3AmIQlWSWnLKIguDAm0DlwzAS5a03FgPUgYq0ipQOfMpI1N/XFwZBkqbra2vOe6W0B6eUAgSfsTYhOueysJFzLtAmCIxNrbVWBwYEvHfZPMhied57IiXMRCgi3rMJgs7OjiAIavVGpVLOdKD2YjEIQu89ItTq9UajQUrlo0IYBNqYaprawNRLNRYUTagUKy2oAVGhYs8sDAQUGNK6aRe1DKRHzNp/oJZxx2xQi2dfMj/xYGUByYqyN91VhAherGiBnEkTFiKviALTUWzXTpI0ieuNQFGmWRAgadWo16MwQMSsTImwKCLPPgyjOI4BwZggTdMgDFLrEJoacxaEzmYUIjlgHQT5fIEUpUlSq9cF0BiTCwL2PsrlkiRx1jrrA6NMmFOkSCvQVG5UrU9JEYGEApo5AlTeJ4RAoANDilBYIaGgWEGPlKGIWCOgYtGeN4fjgdG578uv6M10X09NXQpbPicCQRaNoBSh5wxk5ltq+eZV8NGS6AE5pYicc0SZaici0tnVpZQqr5cyIiQi6OruTuKkXC4bbdgzIgKSePYimhQAOGuNQmMMs3jviJpBVe99Zp167zKPGnvPLForIGRr+/r7BwYG2traqpXK+MREtVZDwuHBobb2IqFyzpbKpeXlFWEZHBxob2sXEKV0uVqpNeorKysiEijFX0C2sLHbPWLHeuiwh3sf8Z7wyw7bcsWmLPmSkW/6CbKcfiTRIB4YNaASIU1NSeVQKNBBFDWsc95viKknTV61nrgprDLBlbkYs/oXntkJWiFC8QAa0AsIogMhAHZeBESaXNTkAbOIDIJw012E2QcAIwAWOAsHEHhopjw2v9lMZBTrvTgJW6ByLYBeDADGPmx51gAyByw6EBH0Ld0MMzwrkHfsndfZ4wBmEdRsV2WAbIMVJFBq6OiRkZdfxCiAYk6SRC0sTb/z/r2rVw2g94yEkTIWfAahYGDLrPK5wYN7p6emymulHEgR0InPDHQrwETOeQRE0qJN3SaFMBSPZK0mJd4/YhK2nAKUVTbNtGCVkctsxf5mkOPfKU6V2eGZAbwxLTd404goq+lWqVby+XxXZ9fM7Ewcx3pjfmit+/v7M9JfZs7l86TIWa+UAq1lg1+NsAV1b60aECFmZK+8VYI+ozKXLFVOs2huZk1vKSryO/kOv6D3cWzpL+8VFFbKhDqq1aoH9+175syZn//dzxcWFpCos9j5+uvfvnP3zvnz5+uVmjEGiVzcCAgBxMcxZbXxTNDf07N79+5Pzn8SNxoImKapIgrCyLN31oZBUCtX24ptWUIiEmwbGv7Od7/T0d5RrlS6u7sqtfobb/zy1o0br7/2zYMHDywuLHrmtva2u+NjP/nJT54+ferUyVMLC/NJkna0Fb3zP/3pT8fHxgITaIXNJXdfWOyRo0eWATd8I1uEbtPX2vIgK360bfcFc/CrD8kSjDKFGreYMCLikUWaiGCGzIMKDsAKA4ACMAIBSMAUOBV4pUSDE41w+tRTL774krUWAW7cvPnmm2/5NNFai3NpmmZxCBCx1nrnvIDzbs/BXYcPH/704qcLiwtpvUZE3nMURcws3oOIAslIkdl5Zg6D4Gtfe/ngoYOBCeIkvnfn7ptvvYlIf/zd73Z1dxORUlQuld9++625ufmvf/2VPXt22zQFHaRKX7l87conF+NyybMoZbzzyJg5v5EQDSkOHgDtPXHbScvHQ632RN3ho5sAIiqtjdFKKUQQ8aRA50wsSYhaQPLF/NdfeWXn8PbOIDc/v/CrX/6isrgcmMBZh0TouRBF1loTmDROiUiYc21tBw4eFObLn18WFhvHhOitJQGjdZzEWXlSBsmFkfc+cWlvb+8LL704ODTU1tZ27969C+cvTE5ObB8a+sarr2ZTDhHH791797338rncd1//XqgCEYh9aoEvfHbx6pXPiooUivI+AjGIgMiIknnmMl5PESNgGLUH4wiUdoJKmB4npfIx3qSAOMjiJxuEY01hg8KtbcBliLhWMOU3k+MAQMJKGIW0VgRYixtHDx4aHd31s5/9bHl5WZEaHBp67Zuvff75lXPnPvY21UrXGo1isWgUGRUkcYO9J6Wd8PHjJ5y1V69e1SElcUJKMXMuMEmSIoJL0yRNOjo6bZqmjYbWetf27X/6p38KCDa1+UJ+bm7+jTd+OT8/953Xvzk6unt+bj6fzzHzxx9/fOHChVe+9vLhw0dmZ6dzUSFfLEzPzvzVX/1VpVr11mqtM5rSBxbIRpz697tj/b52UGBEIWBSQB40oANRIISMxJRBAwWBETLU74aTPnvYJxn7y8KexSgF4L1n5xwIEBAxaWm5zJtGXebpBgAw0EqMgVbsoBl/AMzKJWyxSBjAtv75sE3SMgRFAShBtdHTIlNsvoHWJ266TsUDCIIxRoLAiXjrtY6CIFBKt/RtUuCzXTIzMgXAsROtK6vLdy583H5w79Dxl+69+Q58fmOlVlrLm47Ors58W1qtzc8vdvR0pcSrlXIuyAWIfTt37Pjj75U/eHfisyvU8Mp5y9YEJnbehlrlcnmTq5aqPnW9vX154fLycmTyzpd1hlNmpoemGTYLVXifQTo2dpIHwA+/m/d3AwHcVHyZoUWX5r3XWheLRUVqfX29q7urs6NzdXW1Wq8hQlP9JaJ8Pq+1XllZSZJkZGSkkM9l5PZKKVHkATCrI4cPylPNEjoJnGgGwxB4DD1qhMxVEHgJvfcontBtqlK/je/wq3rliw9+rF5NBELeWwBhn9bK60MDfXtHdy3Mzdo02XnkyL49uy6c/9jZZHTn9t6enlK5Mj42li8U2PsdO7cXi22rKytr6+vPP3Nm1+jo1Pi9memZgcGBvr7+aqUyMzNjWXr6eru7u0BgdW21Ui7nI0NE3/zGK51txZ//7KcT4xPd3d3f/cEf79uze3F6eqCne2ps7G//9m898/6DB5597tndO7f39/UszM/+5X/5L/V6fdvw8P/tX/35M888PTU+huJs4onAUBb3//LRY4RWrnvr663iurnOoVmj5HEcfVvn7xeJaUZgai7UbIlDa+KLSBZkdsIeGREVKgcogizixHl2BKJAlIhmUAxKwKb22JFD33711c8uXx4fGzt48ODpp07Mz0xdvXoVGDrbOgRkdWWFQYlIV3tbYEySJKurq4Gig3v33L5xY6xSaW8vtnd0JHHSqNc1oVKECMViWxwnaZoQoomCV1999ejRo5cufTY3N9vX13/27NlquXT58uXRnTuWlpYuXfoUAU+dPv36t775kx//ZPeuHTaNL5w774G6B4a//erXdZy8+6s3nXY2SYzSzRQiJCTFSjW5y5/gtnUv/4NRf1vyN6sYlMXfvXNZrpJjlwsKL7/40ujuPdc+vZyWKs+/8Nz3vvOtH//Xv6xVaiaISCnvPbMgiHhuK+SNMWvra6X1tb17dovI1SuXE+8K+ZzWut6I0zQhEGGvAh0GQbVW88569kP9ff/kn/5TBrh65YoAHDxw4I+/992/+Iu/aMvn9+/Zc/XKldnZ2ba2tmNHjgDJ+N27u0d33L12a/LeRIpy4szTr3/zWxMTd32t4tlrhSjind9YWpljSUAIhERIxAgEDOgAlBAIZ6TrX6pIwRfTT245XpjE02bBIm65q0gAWjlhKIJA6sFg+2M3zxmlpk0SUIqcq66v79uzZ9vw0NrqinN2z57Rzo72xfnZKDDDw9uGhoemp6emJqdF6yiKtu8eDcNoaXkpTZLnzp6J42R2Znp1bXX79u29Pb3lSnl8bIyIerp78/kcAK6sLCcNGwams7Pzh3/yg1Jp7e23315cWBwaGvrGa6/t3TOaxPWujvbrV6+88ctfdnZ2PXXqqRdeeG5ycry7s2N87O6Pf/xjRWrfgQN/9MMfHrtx/eLFT+O4Ad6plvfpvqn4u2e2/1/aWAhZGBUBgTAIZpK2xXKFiEIZ8gU31tRWw/iJbYhIhForTz7j1daEhinijWQrbOm+hJtrAuALVI2HZzZuwcV+2Z1kvqktC/GLlBgCEMjqASApJYrAeRFBRVrrjNg00/iyelWZAxgBSMAgxi6dm5qcnxlrq6w8c2D0vY8/MLcmBaVj98iR117rzbdX5lfsxUta4a7nTn343lthe/up0f0MoI8dobnJgVyuN4FbH3yo27v2nj45Oz6WO7hv6PAhVUlufPRJ+/D2fbt2R6m9c/ny2CfnTGhq1uZEAsjCQRlSAu/XCDbHNKtRAUBbwQ+/o/c3U7K3qtPZFM2+zDas9dJ6e3t7b0/v6trqemndaBNFraLHWYm5hYUFIuru7g6CIE1SRQoJE+u5hUaF5t/3zXclaBg1o/aoPGpGzZThNgFAiWSi0xE4koc5uZ6QhggCzMyk0LINCrnZlcU7U+MHTxz95LNPkyQ5curEvenJu1MTTz1z+syZZ+qNei7KX7ny+blzn5x97pkTx09kjp/Llz8f2LGtZ2igd3iw2N357LPPirA2wc0bNy9fvvyNb762c+eO1dW19959d35tRaPsHNkxNLr9Jz/+6YUrnxkTVBfiv/qbv1ZaxeDqnK7WKxPzM55ZFaPj/rTKRw45TRtsKGrLx+zqPkWjWJNDRMLUOkP01TmUIkpQ832LvIUv4a3rWLJqqw8y6z58weYYfuVRm4gH3MyjRgABIRJhYfRZNQ4j5IWQEFSm9gI3a9FzE1QPIARhW94U85PzM1fu3Lg+dvvYsWOVtOE1PfPc2ePHj8eN+O7dO5cuXdq+Y8eJ48c7Otprtfqvf/3rukspFybghneNvPzyyx0dHSYwH37w4fjExIsvvDi8bXhtdfWT859MTEyIwPYdOw8cO/L2B++/8cavAEErNb+2TESmEJXj2ue3rv3y7Tc9e0vyre+8HrYX6ml869bNX737Jumgv3fw+PEjPT3dpFEZBBIiUICKARnEi/fg+ElH/m7BT2+Glv6B7+krGwILe+e8Z5XJIlKe2ToWREGFxvT3D1Wrtc8uf74yNb1UXh7Ztd1GFJq251/42tDwcLVae+ftt6vV6vMvvDA8PMyeFxbmf/3rX9e9BRCv6dTpZ3bvHjXa1Or19959V0Cef/75np7esbGxD95/nwFs6o49faqrv/d///f/n7Gxcfb+4ueXTp9+OijmIdCLayu/fvedq9eu5nO5f/O//Jv+7YMTC5PVRvn6rWsfvfdRKiC54Ns/+G7U0bbSqCj0icFEiQVGwdaKFEbx6BmQm9zzTAKawVMWgPtK6rPHVH9bkRoE2MI22vzr/pg+P7jvPXZDEGGF5Ak9+6CQuzNxb3pxfufe3Vdu3Qhz4ejB/bcnxicX5p997uxTT52w1j39wnNv/PKN27dvv/TaK/v3HwCE0vr63Xv3BnZu98519PfsOrD35MmTUZRDhHPnzk1OTr7yyitDw8OLi4u/+LtfxOX1kMzI3tHe4aG/+d/+t3tj90Bg9W5lrVEVdgm4urfTi3O3J8fChdme4f59hw8GhVzdJ/PLi4vrKwKipqMEPYSm7hIymrNKe4/Ktv6q2sP/YC17pVpcK2LvCZjAk7BiUYJZkTBCQiKllWbccLkppZ5wUUBIWX0EQiRttNYooMUH4LN9Ujb+aHKCNZtktbQeofQ+6D0nwMf0YLgmScODfnlp/nRTr/UgCkADWABrLTqPiKS0MDvndMsBzwLZNtJcj1k2OQIJsLMd+SgUUZ7zFLjE5wd6j7z2Wq2t8NnFTw+N7Dv1tVc/+uDtuK3w0r/6F75SXvz8dn21GiyuXJ9fHGrvGunffv38Jc4VRk6cWK838idOwEDfB//1J4O79gyeOHn+o4/yNj396ivSqN755FxOofNAD3I3NIF8SimjjTFMWQYiZrUtkBCEgIDw9wF+gAzb3dJ/N77JPlhrc7lcoVBYWlqq1qp9vX21Wk3EN5kfnHPOOWPMyMiIc252drYRx1Eu55wD50GAsvrynFWZz/7Rul3BpvcBVet/EkBGEeQUEQhSndVy+y2dAv8dGiKysGVfyBfSegMEnLNXrl//3h99r2ew3zk3tGPkZz/7WVjIn3nh+ZnpmQ8//PDkqZNf++arKfDTzz17+bPP3nv//eeefU7nws9vXKvEjYW1lR/88Q/W1td+/OMfHzxw4JVvfGNpfXVw+7ZSrfajv/3p+vp6kM9Za3uHBi3Ier1CQbB91659+/YC4PLy8lqlzESHTxz7o6TR29M7ODy0sLQ0PjV17KkTx0+cHNw+DE7a2tsmJ6fefu9dUdRIk8AEaLR/JLPPg08LmM2/FjP6FudQc2Vm61Lo/iTnR4fUHjdMh7DBKoWSBZwAm8kiAlkoFwURkBxg6tFnigqR0RQoVuKBPTITe2JPLEpdu3Vz763r3/vhD174+st37967evXK1NT0sy+9cObMmcuXPxeR7btHV6vlA/v3Ty/M3bh7++WXv3b05Ilr165Vk4YKzf4dhyzK++c+fv755888/2wlaZw8+7T3/tKVz5fX10ArYd62exRDc+32LZOPenp7to+MWOa15eW6TTAw23btPHLyRD6fP/LU8dnFheXSuiM5dvokawpM2NPVncS1W7eviWIPDlBYfKb5U+uRn3jtd7NJK1/wD6NJK2knk4ksIRotCiyGKnANd+7DT777g+//mz//N7Pj41fHbrzz0Yfep99+7Tv79h06/8nFkZFtr73++u07twe3bbt05fPenp5DR47cmZgArbx37b3dx0+dGp8YX19bf+21V5fWVleWV84899zU1PRKqewQK5Xy0NDQ6L79l65euTM2ViwWuzq7SKkbt24vryz19PeZKDp8/Fh7V2d3d9fA8PDlG59Vklqxq+34yRPthY72zq6RA3tv3rm7Xm+I0da7GjtLSNoQozBSk+WImcSDMDETS1ZADHjLfgpfvkJbmVFftn4z5kq1Va1rxWqxFRfe2rMlFPz4QXggUs5aBh9GuVqtCgJxvXHt5s0jx46GxUJPT09YLNw5d65vaOCFr3/9xs0b58598p3Xv/3MC8+FhfyZ559/9913b964cfLkSQdw487t9fXS7NLSt7//vTu37547d+7ZZ5999qWX6r/+1dCO7QsLi7/89a+X1ldz7e3eu4Ft29Yq5fnlZSdy+MjhnTt3JkmyuDhfm5sLCrkjJ08k7Lu7uw8dPnTt9s3FtRWdz7306tdHRncEJiCl79y6fe3GTS+QemeMUToDy94n/WjTKvhtJOdX9X7l2H5FL2WaHmQgB8foABhFSIQYFJBCIUDCpuMx0xmyshfwZLfMW+eZmZp5oMwO2RH4jUHZmK5buT4y9ZcfYRzed1K2fz6OTMyGmJs7IQAICD5MKioADKJa3iT2HoWRDBEyt7KtRRiABRygR2QSEMg0ZgOQCyO01qc+xxjEaTvoxKp8kO8+dqJWWdu1e19n946g4Rp1+9EHH/zr/9f/c/rG7XNvf7CjZ8Sv1UulRodpJzHiiT3ElVjAhELn331/cnxy/9FnugZHdu3do9MYQ2M6O8vOFwKtCWELUTa2DOUNyDWppsmELdoQQhAiBMpCRo/I2vwN20ZMcsM9u3Wr6ujouH7jeqVcGRgYiKJocWnJWruZ+pbL5Xp6epxz6+vrAJDP50AYmLXWXlETz0+KN90JTa3JI1giS8qBsqRRSIQ8oiMRAhRhgkQDCuTTLcCXJ6wJA6Eymmxim9Lew90795YXlg8fPGytK6+X79y609ffv3PHaNpIX3ju+fb2dpe4ndt2GDL37txbW159/933AeHUyZPeOra+u6v7ow8+nJmaiWuNZ595bqB/oLxWWlxcGr83FkWRMSaNE/ES6CAf5thyR1t7f9/Aju07crno3//7/694QcFQB+X10ti9sUufXV5bXy3kChPjE2+/9fbu0dEXnn/++tXr16/d6O7uzkcFZy2zN1o/TjSKARLCzJvXcu3c11pRzq09W108933YoGB7+AJbz0IA4sxZ1BQ03OIgYhElTUINxagZjaBlQAEv4sRb8Q7BAzOCR7AKLIHWqlat/+wnPzt48ODu3XuOHTm2b8++X/ziF6M7d5dLlQ/f/7BRb0S5KJfLkVCxWMxF+Y62jv7ewZt42zsGxunJ2aRhB/oGAh0ODg72dPamDfv++++99857WpswCFNJUQiBauWaeNg7uvfZZ58dGBqamBj/z//hP4ZBdPzYU33dffl8YXlp6Z033ymtlnJRobe7b9f2XUPbhjp7uv5//+k/fX7zc1IiSkCDc7alLiARadKGHooTPamtiSJ4UmM4DzZEpZRWusl7DxKxCVOVc0azQlbj1+7+ZfkvDh04sG/nzn/5Z//y0u3Lb7/z1tFjxz6/cOXvf/73Q0OD/f0DlUrZxg4BAxUWokJbod1bj0DV9doH775fKBTzUb690B7qUJNJG/ZXv/zVzRs387kcW9FoDBpOWKwUguJLz700OjpqjHnvvfcWl5Z6O3tfOPt86cC60npudv7CuYu5YmCUGeju6z7auXvf/onFhf/y9z9qVBuBVkqHHpRjFEGVqfRNEYwZPImxCS5ylNXDQISsog18hfr7aC7zB9UsJUiMDxf9aUZztwiK+zWGR8gB+IJeZAiUYWax3igtlpHlxrUbJ556at+e/X19fZW18ti9sf3794/uGq2WKj3f6hkeHC6tr28b3lYrVy9fujw5OTEzNaOV3ja8zVnX2dYRqvDm9ZsTYxPFfOHk8ae2DW5bXly5ee3m2J17uVwemZMkieuN0IT5XL5arrTl23u7evft37e8vPgX/+f/aeO0t6d37+693rvPLl56/733HftAmfmZucuXPj/51Mmezs6f/einM+PT7W1toCFNLdtmat19j7ZZXe+LpOgjR+kxe796bL+qF7LKtQLImBlRWXxOFABl1dJAIcAG8dkfjBksAIBaEaMXcE1iFmLf0mC49UHwfl1egDJqsMeIfbrH8OxlA53VpN44Fe/70PI6AUDGRI4YBAa0dpLBWMMwDIRUc30Sega/WWSwmQYASRyIUMMWrQSgcg0bsrRzRHW7NDU/ef5ykptv00F9tTJ07ESjYaN8x56R3WHFK4gKEEYQGQi1E6PzuVxnu85TJbHrsa9YqbnG0vq9S5+Dq9fn5+ZnJgv5KE2tAvmSkDNvpCC3aIBlkxC4SQ/8u+yAD9lgsoFHZ2atdRRF5Uq5Vq319vYWCoWFhQXnHZHSG2fk83ml1NLSklJq27ZtUZRLY6s0aWM8CHnWWiOKF0tERpEocegVgkeyCpVSShBErCaPkBWyy0BgDCoLlzE1o5BPYBNmQVKKkjQ1WmtjnHOVytqde7dOnjzlnL118+ba2kpnZ1ujWpqfn7702aXBgcHpmcm40Th4+EAYau/t7t07oijK50Nma13SaFS6utqNxo6ONmPA2jiXD0lJlAu0JhEfRnpy6t7q6tK+/Xvu3btz/frVO3dvvfjii2eefhqJieTKlc/+24/+GpqEWyLM7O16tXTh/EdXPr8UGPXSS8/Nz01fvXq1rVhUBlEIhL9yImW7p2CTMXATh7A5B1sF7EVg83qbVm+WIdc6PPuwFSHc6sX7zhIBRr1ZmyZb8QKQ0SUCOnYi1IScKdQklEV4vGDqNCCDJhYgTEQsoFL62METmvSHH1/84KMLuSj/r/71vzz73MvsuRG7esMJmLaO3p7unlOnzzrnl5eXrSNSEYtWKpcvdO3cNTI0ODI+MZ5aYNHOobCqlGNFOQRMExbUs1OL+Ix+6qkzb7311vlPLl/5/NYf//H3R7aNtLX1VEvxJx9fvHD+IgDU6/UkSfKFAon58L1zv/zlG8Pbh77/T/5o96FDn9+63ahWFWlhCMlozyiiSYWkc6CtyANm4VaYwZPQtiL8nlC034YvJiMnBwRAQtI6MEplwpZBO6GCxUiCupV8If/UqacnxiZ+9fdv/TJJTjx7+jt/+r25vUsAQbVuUQX12C+vVvbu3fPUU0+tra0ze8fEojwrUtTfP3z27ItpasulUpIKUUgY1Cpxo5baVDikzo6eUqm2ulras/dgf9/w6mrpzTffu3z52g9/+MOOzt7l5dLy0tqv33zz7p07SqlqrbZWXTl6/HCp1HjjV+/cvnHn+RdfPvns0/19Q5Mzs5BYZBWogAGdFcMEjAjKamUJQ48hYMikBR1iGhqDmiyDoi3k9A+7AFvDJvgQYOGRXkaBZuKHAGxUEUOADUbkJhvYFldY81zZjDB9mQ/SiyhCUJC4RhAGAGKtzM1PLSzOnDhxhIgmJibWSyue03qtvLAwc298bHFxW2oT9p6UGINBqPYd2B2aQCnxLhFwSBwExJxGkWFO46QaGIyTqg5IGUBwRDA9PWHM8/v37y6VVi5dPn/12mevv/76jp0jymBq448+fO/Nt98CgCSOASDK5RLbGL859ou//9mVK5f+53/2Zy+//MLc/Oza2louFwm4jA+vNZz3Gx5439jeR7TYGvlWkaaHzv3C9wKPM7Zf1iuIzAQESB4IGJWQEkQBhYpZFIogeUSPSFoZoQ3sLzxhTZp1obJPGXknZoQ/mBHtIiCiv78g4pcoJV+J+8tOfwyMEcB9Vdma7UtHEAGRCIRQPBFqrVGJeABhFGTEzXLqG29aASbCGlUBMGddUK4VnYtBSitzq+fPD+8YrvV3d/UNh4kdWh84ePTo5R/9tKez65lXXrrxzocKkgOjO3lpXbcVjn/jNVWMMCr4aqJrrtfjTL06denjnb0d3Z3t1oUjO3eUr19fTS0KKdAADiADjgOCIDhqFdJtucYEcEPZzdTfrOd3VX83nL4be5NSComstQCgtRaASrXa0dGRy+eWV5Y9+1wYEVEz9Q0Rq9Vqo9HI5XLt7e1JklSr1dCEqLEhnkUibbRgygmTKIUBoZB35BUIk3LgyFqTWHROcoFHpS0Yj5oztumMUYUzyvbWy/oNl6481IvwxeIAHrryV/UqRAAWNkYDgHMpACqtbt26+cJLL0RBx1/91X8lhdVq5fadW0PbhlZWV/bs2W2M+fnP/27f5N6zz57t6Gw/derUvXtji0uLZ7ed7entvnr16uGjR1Kbju7a1YjjmZnpAwf2IyEpyvJvjDELiwvnPv7o1dde6+rqXFhYMIE5dOjQzOxMnMSebUYOCALaKOfFGCXCaZLkcrlGHL/97lu7Rnd+7etfn1+Yr9aqYRAgkUvslsm0daN6YGyzYn5Ne35jgFvsuZn4QLivgnLr3IyfYVPlzdhcto5tUyF+wNhByPbj+4RANiUUESIyEQM6pATZkgdgARTCyOi8CjL3FloGwVRASFkrxY7Ol154qa27++6duz29vVGuePfe3XKp/Oyzz+7efxAAXnzxhXqjMbR951/+5V9Wq9UDh4+A1hQEHrGrr+/0M8++9dbbF85f/PZ3usN83phAaWOCkJRm7wNjrHcTE1MT41Mvvviy87K0uIiI/f0Da6Wyc5wvFJPEzc8vmjAgAOdFKQ1InqXRiO/cunvuw0++/YPvz62tv/vm2zapBWi0R3DCIIzIiOhZe9FNpe0f2+/S8D5JgiBZMU0kBFRaxwgNch3ekrUc6CTCPScOHzx67IM33lyfX2jPFWur1ZXFtdm5hd179227cXPX7t379+7r6e0GgF/+9V/v2bPnwJEjJoocSM6YXXv27ty16z/9x/+YJOnpM6cLhSKpFRMEpDQgemYRSVN7/sKFf/4v/sUf//CHb731VqMRd/f0mjBKrTVBIIDr6+XZuflcLmedVWQ0GlRBzfmlSvmN99/rGd32ne9+d35+bmF6QrHP8AdhLgBUIApJp4FKCZWHQCDwoBykwjUl7ai1Fwu2xSfd/PPR+griQ0Rdj/AyMrFAs5bxVvUX5UFZLQ9LjC299//Kg72ZGoEBWLEAIEqcdXfu3v7hD36wsLD42eWLQaDn52dv3bqRK0TOpf0DPQuLC59durJv/54zZ0+P7t5x/MSJq59fsS45dGj/2PjdpeX502dOtncUT5w4PrcwOzM3fejwwTAySgOzJUIT0MTk2IWLn7z40vPDwwOzs7NtHe179u66d+9eksRIEKdxtVoBRKO1iBhjEEAb1d7etryy/N4H7/7Zn/3ZydNPffjhB2maBJFhFuaMhnzjkXELIu2R47DRpGUqbI7Plpf2m6u/8lAvPnQuo4KMR1qTEDERKBAQB0g6ZSZFKTAyOwBtjPWSkSFu3PGTpQdnadwtZmatdEbHASCkFCnykplomwYKtU78rdtvzXzxoN8Smuo7AqKQsHhOgZnQBEEOkR0nwiCsQACEmwiollnqABqbNBWQrKysvveBXV60mKS19O4bvzjw8ov7h/rqtdXPLn2GBHMfvD918ULZBOGhg5X64tSHbwwPDN+5cumOt+2Dg65aG3/nnZXxMU4bbmm2y9XXr3wyAW5k3x4s5ubPX1wfn6LE5UwEm2RTGel3Nu0EARAxQ1xv6L0PjUGTDOK3HMCHyKeV1kDo2SOhCUJU1IgbhUIhV8gvr6xYa/v6+mq1mudW0WNEzKoc9/b2ViqVUqnkrC0U8o0kidNGIV8ISbtGw4sPcgGBeGsz5nYRRlRGoRbJaxUR1tMUQUhIMWgPgizA2rMAIqtW8Ow3E4vS9A7e18tNToLfk/r7qN4Qw5W50ht/+2Yul1uaWQ+wWC+7N//+vZMnT+3bedg17AcfnF9bqL79yw9Pnzp9eM+JyTvz7791LspF4zunAym8/cv304qMDI7WS+mv/v/s/emzbVd1JwqOZs651t77nNtLVw0SQjSmbwzGNoa0MY1pnGnjfNk5X72IyqoX9QdU96G+1B+Q3yqqIqoqqzKqXlQ5ntOZaRsDxhgMGEwnRCMQSEgCdbdvTrP3XmvNOZr6MNfe59xzzxUXSZjLK03EjXP2WXs1c805mt/4jTH++tMXLlx48KsP9V0XpAEAB9cCkSYPPfjIMPc3vemNp4/fHUL8wbd/9NWvfm1ra+fbX//BYr5L0qgIeiJVQPzWVx9aLhbRJsTp7JOXPv3xz50+fQdJijbDQkUyUzt6XOvZG+XpgSfFdZ+I1TJaP/iBOVp/cqPvHj57vlffbN/bpAzQ7z+4UjBUNMSYAoooYXTeLGSAjkQFVQjDpNHAmJqYGkMMkVJgzf33vvvVe+488oH3vuO3f+stTdP88Ic//OqXPj2UfM/dR/75H77fwR599EcPP/zwJA7ve+/bt7d3tq8+eeXK1qwpF8899uxTDz/4DXzLm+4/fdvEbPvxR78p5eqZpx+R4UrijgIiClgZFvOP/8X/593vfveHPvCb08lksVxubW199Uuf6xcXzj37yLC8wLRogoUQuq5L3Jw/86OdrWcnTWHgHz34rVffd/9rX/6Kh6YPbA0LBHCinmEegFq/2hhOqXBQhuvDyi+N5zuwLltRLaZIFGJEBIUeUx9DF8Oyadqd+ZkvfOGv/sVHP/YH//S9LSEyfPEbX/zON7+wXJ7/4O9+8N/8qw+npv3aV77y9JP47ve852P/7L0xpX5xDn17WFru4Cc/fmLxtle+/72/JqLD4sJi94zmK888/TDB7rQpaCUwO5VHfviNP/vT7sMf+cgf/+uPOsDGbOORR77z/Yf+YXNj89KFx92uxrCMwZl0KL3L1tXLT5putW3Jw6W//8Jf/+Ef/cEbX/ey5aXHqF8QzKUUkXmAkUFvCEqgAGZoANgwTeJyGDwvNj0iOh1su3OIEWYOeFOyEREjAt1Yco6f7zsRrkUB3Gzft/1/BQBPgI99/ycPnv7u1tbWuacuTyezi89e/euP/+3b3vrWt73h15Zbw/cf/OGFZ6988W+/8qY3v+nV95569KEnvvrFB+6///6N3zzW0Oxzn/rCr77j11798tctt/Lnv/DFoet/9P0nrp7b4ZIQkWJQ1VL8M5/4uwvPXHnF/a943avfnEL8+pe+9eC3vgWOjz7044vntxrcEJHAaegHYf/Bd360vb2DkoLRIw898fkTX57ETdIExZESe63tenB+bjDzBxMFEQ+ZWzxklm5Kh+4zpveP2jR3/K4DOEEBFyvEyYmKwAA2oGVQY4AU1IuCUhyLfx8Y153/Fho18h5DAHajYYRuroVgXqDofXElt8MKLB1rwHuIbJAgOwAwE4RYSWgw0gl83XTYHWSEo9wQ5ls7Fx94AHKZgAeg3bMXHv6LT3JKi2U35Hzq6LFLP3jsRB6iwZmzF4HwR0/85Nhsw68snj1z4QkGd2SxSfHLzzzF6LcHtzxc+cpXrnzvu0uEftlH8412gmKgBqtsA4O1z/0LWCrVFK4Xmk6nlaQeY9zY2Lhy5Uop5fTp0zHGc+fOlZJH89fMZrPZHXfcsbu7e/ny5WPHjh07fqxIUdemSQ5QcmHHJjTmgoAMhI5oiAxmqlaYHFVQSkoUAnG24M7oDrV+q7szWcTn6SbdKDn55zybBszhwX/4NiBsbGwul0umcPXc1tf//uuVzLK7uzubTc/+5Nxnzn2WCFVUivZl+Is/+3hKqRT920999tjRo/0wlJxDDN978HtMzBZDYCYehszIJvrD7/7w8Yef2NjY6Pt+uVwSY6D4ra9+CxEaakPLRQSd0eEH3/lhzjlwSBSZ4w++88jj8Qkza0OThzJNG7Wu+03M1eFTesCNX4XnDh51kxN/oJytgzoMABmu0ZBIRNlyACNAtczYJnQUU3NIRMxFpM+DuKuqq3GWNuskS4ic51c//l/+5Jtfveu2227vlstnnnm2Wy5KKZ/48z99xX33cQg/+OEPVWRx5fwdd57e3tpZLOeENF8sti+fvXz58pknf3T//fcP/bC1taWmJedLZ57c2roaPANAGUrbJAhYuq3P/s3HH/rW106fPl1yfurpp3d3d2OMf/e3n1gulxstgnWesWXIy6tf+rtPqwr7QIog9oVPfII2N2IekjlKMc0QUAkKu7UM02ggTj/3tfz/d2MVarPabh5BoTiWwILaRYeE9vgPv/sfn33m3tvu2Gwnu4vtn5x9KmB/5slH//K/XDl25GjfD08//XRK6fLZp06ePHXm7JnFYlFKJmQOPN/d/ZP/4f9xx+23LxaL3d15LnkxX5x75rHFctmwAoBbnjUspg9/94Hzz/749B13TKfTK1euPPP0013fL48e/cynLl65emWWgDwbWGrp7NOP//XHt65e3mpYDfDZnzzyJ//Df2gia5mTdgHz5myTUMiU1aJaUGer1qWZiebOJTcBJ8Q0KMNBzex7ZYB/dmjAA3h8Abr++axvB2BKw87wyT//ayI62h4181kI5548/7nzn5+07ZDzfHe3bSePPPTo2Z+cQ4QigoWffvyZc0//hbv3ff/ZT36u1vGcLxYA8NUvft3UWp4GZkBcDgviQEDf+cZ3H/rm96bTad/1/dBX+uBXv/BVd0/QNKFFR+ZgA3zrq99Wc++hjRNG+soXvjppWyx8tD025GFfVvg1T3KDiTsolq9HUt1ekGi4TqT7AQHu4M6qVMyUkB0MXCJTCOguagJg5M4IEZkO2tm3/Ki0h9Ug/CVoMD++owNbkhBx5CSOVA73618FQvU1lSkZoJa8mZrUFzRogIfdwaC/jSJjyzsdiyJgiyiDBlBkxmF302joOoxkyCQycwIVQQQzVpgh7MyXA0JAbIhdRFQmyFhb2h28l3/s4asmTbXpcc45xjidTnd3d0Xk2LFjbdueOXMm5zyZTPa4vyGEvu+3t7dns9nGxoaZ9X0PgTmEUkpwjiEUz1KEmhRCICAzICIkRCZiKLkrXUdEhGTFar8AAHcyN/ex+9vz4cv7utv6vvGPQEF0hyJ9ZCKifrEN5mqZAJe7W6KCiAxuuSPQft6J6nQ6i+zL+ZyJ+7xMTZPId65eJOa2aYahIyIVcLNcPISAbq7kZhFJ8nLnaoeEAc103RnNsxRqW1Mx9RSj9Bm9rmpFInQrQ2YmHTwg5X4X96CCvUF0nUi9gSd2/ZxeP8l20+L4oOQFc7Q16X19K4ZmiiogrqoAAzXGM4gLd8jKwYMCZCWHrJIcNg2O9LazvaQ29uRG+OxPzv3k0ac5hpp/yhiHhTzy/cfHKIzixbOXz5+5aGpN01T/4VJ/RUQ7HR568GEirG2TA4fF5TMIGGIAAMtj/gEAm8jZp8+fefIcB3Z3xugFLz57ydyLaIqRiMxN1M9snU8xEgVQdcuXL5wZLuDmbBJzbqRNIhPzRr3JOis+G1TmPY5Nm18aP/NYIQ2wjiuNg4CZObCZFhFxR24ckmm0TL2Wpp058s6VxcNnf8gOjuoNAoYu5zNbFy7QxSIymUz6RXn0+48DPE48tvzo+34ymZjauacvnn/6QpESOIbApZRud6gpF8ycs4aAIUTCcPbp81fOb6kbAobAAVK/O+xcmSNgjNHUwZEhdMvuyYtPp9AQBUJWt4tnrgBIg8TQ9gvxIzF4TApRbSLQCjTm0R0QpoGnjjxfhqG0kVhdTf3adpmHaEuoHYR/+uJzEzd5firthchqVwMENVOAwGzulU4ng1zcvtw2LbmUfh4AlvOr7t62LbloGXI/ZyIEFOkvza+0TRsR1axfDDXToDMNgQm0iWyatRR12OkXakpIWBPtAQFc1UKKmpWIAvNiZ8GBI4HlJcWg6jv9PHBYDgsmtuta3QMcbv5ePy0jdRUOfvhCxoFrHHpzLgIorEqqpIKWQy4ThxZxcKMsATQVpSwESNeOWxz9rTcpIuLCDMQEADfqTX0rDFwFZNbtmkVEQBpsANwqt8YNkei6Jgyw0v6ISOBdGWKKfckBOAKAWQssoME8ggkIAGVQAWhjUHVCIPfixRBD4LmVNlLOmQiLKzIwQFZzw0mMDISi4BoRycdcdt/337rmbl0mRIc7hj+PUckWOef6c9d1fd8fPXqUiC5evGhmKSXmVeobM3ddt7Ozc+LEiVOnTm1vb29tbyOTIxYRd48hknruB0xIQDQaZwBIRl5Q4yTd94p7j5QyAOaiDcYGKNQK8+RK5oCkz/Ph9wip14yf+75j5mEYKgygKk3T5lLUxB04hMAsqm7GIRCiuQN4HrLDdDqZqioziwgxidQS1htYG3quGyC7164kACBSmENqGinFAUw1xKgiOefJdOpm5o7gorqm3TVNAoeu7wgJANq2FRGwQ0pTHeo8/NRjbjRuUpVdH3dzR6R4kPtr5mPoBgCQmE5sbLQxgBkSZzMxCDFCiD14ZsMAsxDvP3X7BFlS7FPwwFqkqMSYCMdGL6K1YqOLSDtpVXQdUlLzFEPfD8wUY8p54BCkCDOTu9emx6IhRkQUKQBYpLRNGyIvlx0iNk2jIrUte+UuV4VaJKfUMHEpBRHayJKXRuhEOuTm5NFjRyYbKUbTlqgBjMXToCkr260pin95xrW6bFxeODbzdnBDMAqDUkxHX3n/6y8NvXIwpwZjVEcztcKTuJAekQMFQi4l1+7uTUp5yIBopiFEUWmaxs2kzzFGZiqlmFkMMaYoIjlnDgEcQmBV60u+5+77wa3r+1on1cFNrZ1MpJRScoiJiYoOCN6mlpylqCMLurqq5oYxSr77zjub1Igz0VguCGsjLoAC4q6njxx94333XeqGpCEYKoNdx+k9ZPPe1M53dDrEFb7p8byFtZlhIDevNQfcLMTgZqIWYzRTt7FbeNM0qurgfT9MJpMqM02VmVNK/TCoaIjBrPZPZqvt2YgQ9xDWWiqfQ0CAIeemaRChCodcSoyBkIZhICIOLKLgjohqNp1OF4tFCCFw8Oub7d0A/T3cUj44nr/3cKNpv/aEY4czVABABUfQu08cZTdGT00CQHCkwHADD+pWHghQc8et5mTW9uW/6Lu6ueHr/6+4DW7ubgaHAYJ1GLgDRgoZwMEx8HbEy9O2IeJis9Aslx2qHI2tLHsgG5wFLKEzIIttUCIgQeiKFtA2cSSmGHotbhodGDwCmAgCBveGIrqLlTB2xDv4AKvik2uY4uc+qv1TN3LTNACwWCxms1mM8fLly6p6xx13bG9vL5fLPfKDux8/fvzo0aNXr17t+75NbYyp1wLgTWpQQYo0oaGE4FBEzMCR1IEAh8Vy+/yF4ykePXJkUcSdIhDbuueFKTmA1Z7Yz++RDjF+n/f03PQgIvdQcUHilolF2NEBUVSblIpIfb3VhC1FiGJKaRgyh6RSmCeVyqOiIQQ1AzDmKltL26QhZ6baVaepPbIJG0QSLSHEkjHG6arMH6gagI+Vxn0k2fGJo6paSgkBmrRhIm7XCN8bTdSBKV0nv93ExNxEaeG69w6C/eQ2cQj7r+Irf8DMOTITg8j2xUtXtrfaGBHcWYGCopeAlpp5v9y9evn2UyePTqY9emkbI5JSQgi5ZGZiYuagKg4uokxMTKYuKgBOSDElU60hEkB0txhi13cxRAKQIhUPczcirreoVhuZUjjFokpE7qaqMcZccpOaIuPJzTyEIFKYmUDBswKoA5oxY4rgu/1id8dcDbRmWLZNS/9YbvH/JMeByD2uPlVVMUUmjMEJA5Eseu+G+2+74zYVCxExgFhDoV/MQyAPruREoWRBoKZtS87M7ABVjIcQ3axIMbNpOyFEKQWRVCXEmPMQOIoK1eR9h5CilAKINBpPUVXdvdbcJmJVQaxpDIhkSBiAwNAU1NwjOwERkBt0y2Oxvfz0szlnS6ABMkMhKAQZASBsb21dOnPmKMejp45AbwHYA9gB9NcP37k3Y/4CSiWSPL8X9LwHERmCFEHEGMM4gYgr3DEiojvkkpsUVNHc4omjDl6NnhCCOwTmITsj21hEB2p4R9WQSCSHEMBRTStGhQhuJoIOAG5NMxVVMA4xFBGimatxCACOiLlkN0iJ6ejRCs35df2dxkj2dRNxGLHsOmDiBeQF+MHNASua6LUfKjNGUnJ1bJK5RJeL589sz3cmjAaezSwyRLbDGJ23Vurb/oGgqiISmD24+yCmB/TjLTgqTlOL/CJiCMEwWlYgJwRD9JHTDIdUkkU0JCAUkRSiAN7z628/8uHf9sUyWUjqTz34YBnKBrfDmbMbp0/96Ec/PHH78f7qfPfZ80csdKotBHBS1bDRdl2eKorbgEZATuRg5MamiBQAVbKBBeQarN6P/vphS+UfYfbqG08phRCGYWDmY8eONU1z5coVZr7rrruGYdjd3bWa+lZva3Nz8+TJk1tbWzs7O7efPn3kyKaaAniMgQFzzkG1maRe+6yOHBxZicWtFfSnLj76V5/LxBI5uxMFcERzrsIDzcgRDFGql41rvv74vhBqsxy4gfU1ev71x/oVgFVowNwqp0etFpVdbW9E31dqYlUqwtfc8mvYbettvLoBQnI3cyfiagEBorkTk6hWtM9Mm6YpJddSiGYO7kjoZkhUnxWq8MJ6P+tOZ2BmMUYANzURwWqL4VguoaISbs6BVb0iFgC13wi5m6uZOxJVlVB7r9MY9FgXZKiwxtiq0tzG56r7am8ysRLMajVq3JuSPRr+NcPc930Lb4QHj/PrPk6mA6DVDr/70zvqxDPWXDkEcHVUybuLGTAiJjXuhbLXolbL7e1vfeFLNmkN0FExOLiZO3OosSFmElF3CyG4OTMXKYTMTGquKlS5IOMbNHdlDu5e9V7NaF4tJx/jNbhaIYD1Eu5gZrVAXtWChESMql6TjhnZTMlRMYh75JDBBPNmFr26xeBmwE2yQLkTxxus/Ftm+L5abLeattvPfEBY4b3q6MjMCl4XxoaW8tiPfnDpvMSYES0wIGsukRjMiUC8WG1KZA5AHLj6QkRUrZrAoUobVQWomZnobiqammRqDuBuTGPKGTGbad34DkgEqlbdXUA0FUBgDmZq5swI6C6jxSsGSiDoSBAQgwoX0d35pO9z/bwKM3OO7OZbZ89/+S8/1QempqEMwZBhzSJceQR+GAjpPpL0x50/5o4cYP4CZj+svOl4YBWwa/3mjkSAUE0NHCUQ+voWbiAwYNV6gEYkyX10D2AUGg5qijCKRwMgQiYWkb2sF0RT5cA129zM1IyJiet+d0RcdYYnRFCzVcX88f+iSoRE7O7uRsxuY1lYByAmU9uXAOzgYO7VUzJVRBqfY71VfPVQuPdSVrrhmqXs4IRUQw3ute8l2Fpx3WDq9u+EvRexCoIcfN0rBVjfMiIYMEAiZ1N0ZmMz65sy+HLwohgiAKpoxR4B9hqJV4ztxjf0ix/uToQhhmzFwUMIlZ50y47xxdVdRchEAKBmAUOFdnxcvYcvBAQI4EXF3MyBme975a/Ee17z6Cc/2w6m3WBXs6gOONx776s2XvPKp+a7v/rh9z/20MM/uPjFmJKQE0+Wu7uZoZs2xv2mxsG0C81GM8li/aLj0rMbQ81YMQZgcNsX7PX9Aqf+h+vyDtf7Yy/+qNXMcs4VokLEra0tM7vttttUtf6cUtqr/EBEV69erSjxxmwmqiIltqkQ9H0/AY4p5VIKmCdWhwK1Mg3MjEKx/OxFARREB5SVDK2W3CinofYrGNlUqzdVA8djPimsWivvm6M9js6eHQsjml5NtUrVIiIzXQny6xIK9p14X/hm705wxUZwwGodKeBYb3c8X81OckWGVeNdBOhXFzNExJEXu5IIfu379jVVva6FDHV6qiVZC/aOBqmZK7gDKo7RmwqR6t5tj82+M9K4yrxWNkJ3c3OktRobWURm6iOkDe62V4N6davmtiqMiNWohGvw29Wz4Agj1TP7iE/sA3THz0c/xMFt3VCHFKAGSVZzYuA+thP0On1ExokwZhUz9eDJaDNOEKC4qpStCxeymxExSvLCq1Dj/umu07u/hObYumXf+zBwMAescA+YOuK4qPavv/GFjjGclSZ2cPfMhA5mVs+wf2e7AwGBBwFWoEyUGXqSXmXD3MwEvBAqkRwSK70Vx7q+zPqHW2T4AQt4lDLIzCFGDKzuahJVePvqYvuSIDmxEpqPIH8NkxOjI6gqIPEolKD6NvV582o9XF8nbLl3N27VlSIag35VXPjaHnLASoKqh4+bxMDAPWClNqABFDBFAMKMHtSCaXIKTdoCj9hAYI7JAHrVYOBgy3OXMiIQB6OoHh155f7DDTzZ8Y73VvkoEg5DJWvXqoO7eyWLAPb2e810RkBUtZV7vHfO/Qpgv5z3fS0m1z/AmOsDDjW7HNeyDkav3lf13fadFqE4jALQnYgUQRzcFZGIqh28FyddIR9juSwcW+eNw+rsrNSQXnPba+/CZS3T9p6lnm2kA1fZsnaw1w9+zbuoqgTAaqX3FSRj7rWgJO6BNAe1pK80SxXdh9WLWE/pnuFtFdhHYgouKICSwDD30h8LEYi6kgszcMhSNphdRgAeVx28bt3hoyWkaoBAgBVIQjwwIbfWQAAmUiNTK7mgiKMBgJupqjvUXL5DaOIA5s6A7krAqgruWHT3qfMPf+XBzZ0cka4utu959f2z2UYTZ4hx4/a7Tr3xrc9e2IknbrvrNa+/93W/gn05//hj33jwG/e+/S2vf9Nbp5eXj//gO6965b3TkKaxeerhR5/+ypeO2Njurqpa3ZeeabDCcqo7CitzcM8C/vmOGCPUZtGIbdsCwHw+r/XOROTSpUvT6XRjY2PP/AWAnZ0dRLzrrrtCCGfPnr1y5XIFyURlJFcZZFGPiCFY4PboEd/eCWhMMSiieCBEJgUXNSICGu3FlbmKCEwYEEHU3K06YVU2rYHxaw1H2C9f1AwAmBgQaghsJbyqRCMzdQdmQkA1MzMmwlWfqpWFC/ss2n3mLwIiV4ebiargBljzaMf7cXBTr7V7VdTcquVdA5p7cme/Ztv3LEikUu8ckcjUHexaOViN8BGwXalMWIm8axGZepHRYlxjuugrhKO2SQSw/fMzauXVpIGDqCICE+tKNKzVBlyTNjdeFxFNzdyIiIncXfcwHlg/y+oeqJIHAICYALNDObAFEKmqhKopxX2JoIhSHMxiCkKUEejIJhVliFPxFsECgWuUkpAcxiXBzIh7evR68X+NkepjzGE1J3a9XVcdi7okKnTEzAhQC7vupxkdFKkOAOhIAuROAUNhi6SNCfVDcEtHj+RRBYeXyp69wHGIKiNQ1WEYABAY42QSj51gcHar+QvAo6FGROoOdVcCSpUto9u5MilWluF6FSEAAokpOhATIa53QXWUqp9pK8hwf+CvHkNMiGhaod9KszEGqhRLA1B0Y1J0Nw8OyZHU5gzOCsc2d0yHxHTimAHXMOgGooGBY0CKTmDGwISobqZKzLjnD+7tCcQK4ykiMZF5jZDw/sYWq+7ntG8DjZKqmhfurqqExEzmPoLZgFqZY1QrmOooMQBqtGpfUocDrAIvFe5aFWqt4Sti0kpYQqRV16txJsf4ETiAqSEgB16dASssRZXg6yOOsGf+MoGP+5eYajIGANanOOAF1GVQsy84EELVEQd1ltfHD/UpzN0IqaofHM3fqg6rgj1o/sKqWhlW3HelFm1VTG2f83md+btC2W6Awuw9RzWMiJkQza14QYKI5IKCKAkGUoLBckaOAVDK4JtTbRsIDEXqHrmZjfmLHwjmbiKUyBFLKbf+nfvaDzNT04gYQoACIiKqBKMOeo6BNdTgICJLkNvecP+7//hjJxa2vHL181/6/OavvakNs+HsBc/DTi7znXm33Z1++Wte9dEPP/SdB8rO7q9+5INPsN3zT95x5I57n/yzT81e/arbfvNXv/n5LxyNbPfeKd9tfTvvV/a31HB3EQkh1GQAVU0pnTx58sKFC1evXp3NZidOnHj22WeHYQjrL7Rte/LkSQDY3t5GxNl0FkPocjb0JiXrbci5mTYlWJfLnffe80d//G9o0aELBBAiE0HHEIKDF81AvDJ/V2ajE1hkTohQigD42vxdCYU92XdwVJRXBABCiIAgpQBATd0bhReR6hjyRiQRMVNmRmLfc/iuieEeuAQhiRR3r6lsIgKAldS7X7SJCAUmIhVVEyZGIjNdW0JQPftDlifWFFQzC8xELCprN2D/qGBEBcUr65SJ/TrWHSLWboKIUAnBVT3AXrRhr+4jEdk+i01ViYg5uFspgggcgputpeuacHz9XNXrqigxhRDNtJ7twJF1KjgEcK+uGEcGUHe9ZnIQEclW/gwiiKhEx4BNcRYzhDtf/2pp40cnfxyyTRyxGBJYZFFngcipvhd3CyEiws0IuLUqGtXz6nkPDHdT9RgCEokUMw8xEqGK7EOPFKuG2ycKHADQHFXcEShaUPZCmoo25ga8dWTSnD6548JNhFscRPnlGiuEttpsQ8lHZrPf+/2Pyu+815lBFXEM8Ri4I1Tz193DitEEo4UK+0yKQ+AiRK4SI4RATHVJMHOteDOalW5E5NX3XkVXKi+1pieXIuYaQwQANwtANafYwRXBIguoKwSgCIhFc7A8BUV4xX333bezeOXb35IgeC5YI1/ubkaEyGRqRDzKHFUOAZH25aCszF+iUawRc2BTVZHqRu6bUgQPAAcLn6kqMTOx1m8F3idnGCuUDkDMvk9iuJuI3FBi8JgKDAAcgqkBITObmmghJOZgvifS60uqPb1Uq9CO9QwVgxqxiQog+2iOHxCGiFi5UkXK+LNfB64hIo6oUn13IgLX6axq/oYQEFBEzJWJccT79zTd9Z72/nlYe/KqClX+r/E1rIvz+uy6NSdtj8t36DXqaU0txEDEamLWM3lwBEFD0gYyKbN6ztHQALeZhlMnm9OnsioQhQPL4xYeNUpMzNmzu8WYVkjYLQoAV+BfwQyQmFNKIUZHAkTmMBJszA64Tfu/jgCrlmrIhIHZStat7d2rw875c1A61wKNQkRLeDnPz+1cubi9/fLXvGbyspc1P3701ImTYHT37Xdgl5/6+gMPfuHLd77tdZM3vuae173p3I+fPP/Y42A1CnQrTh8iDsMAACmlCn80TVMLAG9tbR05cuT48eO7u7td17n7Hvo7m81CCOfPnyei+++//+ixoyVnJgxMWgQdU4qAqA5a8ulTJzbueZnu7CJobqhvyEzIIBKDu1gBQqOxxwU6kKM7uRJxQoRYpHr2AAB7mU+GgHhdia76TACgogDAgQHRRAH8evMX3CmMUqOiv0Dkqqug0F408+DiqSVCRcyhksZU1MH5gGiropapXs7MGAkITY0IVwBGJW9dR32o8VDRWruHmEzUVmlz+7ejm1Z73N1dHRCIyVf1xvbOiTgmRAOsihY4j1yItflrKxD3gMQ3IiRmd48iI2RSmQAjJOM+cnwPWWFq5maIxIHN3FSZDiaGj55AYDBPKgA1dxgPYLF1q1otMoSIiGqK0Yg99RKKkUOXh6vL7SOnT05DStmwCBBIoOzI3nBI4KAiXt8+3Lz5i+vJgfGB/YBYMfdKIF4tKg8xjHrdR2hcbQR41iHF8fIoVqtpOjcWjLygxVKmEAw5Hp3qsSNdtvRLl019a44DC9XA3WNKQJQm7am77lgMRdoEpmhOgFh1DAIGMnNzD0i4CgLQteYvABz2lrDGHAIzVvkzkovcwesZqvm7iuSs0Dk3VefACBhVViEFdDcGpJWBKuQSScBdfWX+ekLhFkvJu/MFE5++915V0yIpBHTAmuNO7oFEFYmRsFYpYaZaeebgMxB5bejMSMymamrMB5Jqat3fcGCWTbUKQ1NVq+EgrhUXiBgQbM/8XQHMgd19rLpwrcSom495hIeh1mfwEZo1swowE5PpqiDh2FPDK3vKRAGBQwQAFRmF5J4h6NVuqMIQ9glDRGRmB09FAJEDH/a2ARySjAcg4Oom6/LYoz4cVENISAi2H/2tnScO3/dV8NYevRWSqMj0vjvBQ/K3ajr0KNbM3W9Y4xbRKizN1V1Rs0ykwQMWBCSLWEhchzaEoD70MtnYmG/MnDlLYQwhhHXM9la3g92RKMXYlw4cUkorVOjWHatwsBNi3VCDDi3MOIbgoazA++sNeFxFUFcMb2QOLeDFh37wwP/rT07OpQfFCSYZ2CYuPUb0iDBJPG3MVHZ3r1663JmHc9u7j/349MtOLbfnk77Mnz7z0Kc/Nzt+6v43vOmVd9/z6PkzurvY03T7dN4vfClUWVrd167rmDnG2Pf91tbWdDo9fvx4pfhOp9O2bUfzl4h2dna2t7c3NjaOHTuWc96d75hbiqlHKJZbbiOHeekGlGlMO1vbn/iz//STB7/dtgEQEYjV2SGYA5iB6UHztxoaBismK+zhK0CE7uBmgCMj6tC1OYaEoGZ0ucM1oeeVRBvJv2Nkbi8kBGvu1qjP8ODZV5fYg3pGA/DagSt+6B5NoUqBakJV8Tqanoc9xMpyrfQuO8xWq4U40WFljfpeoYdrz1Z9vKpuofZ3HRP+HFZzUrcJrsxf3ie2Rgu7bhVYVQwEAByVigNcN1OrSR3ZbJXgWClq1x5ZzfXR61iFWa9re77/ta4TE4XA3BrBiUBLsRDsYCkBAlHKEooSwTKCAESMBHRzFu9hr+Ma89cPt/fXT11TbRBqWx1YvfQKuiNe1126UjjNySlZEPaOLaG3hp3Dy3/3Pb9xx8s242ZeZLSXTODnP/axCvZ+cPOSi5kS4VDyP3zmM9/68j/EmEgkmAdABBcwRYdA5u7ujMwOpkZESCO929cZsYe9oOpcEsBKKNUbGnffKEFopMtXaTGya9fG0F48ytGBAELNsAQX8MJoBI5EBsGQjSrYDGZ56NvYAnE2AXRGRFMEd3QjNwQYs7PGsl542FYGqLTjUQLgOjvt4C7w8b+De9xgrJNQ6bhY79zNmQkATRUQxlKPq71WCUVrYXPtVXCPODZOav10Py1svVlGKGAkIuP6WyM6OgpPG41jGFv1rpWFIxP4SnzVaLM7jjd86FJbyQgaMw/hUAm56i+9vudqcNEKga7zcKhHNZo1q6utiW/7BdwNlctKtVVHvpJ5bmBiu49pJ2jgBV2JkodQEJwsYCaxMkwQJs7mvAV4/LWv+f3/5b+b3ntP72Y3CAzeomON5Iy0yRsL+Vtg1LsjQHA09yICUszZq1OjPoYR1sv92u+uQVkcAxGGbm3ko2AzHRxFjCYNp4BUBpYS3F3KK++59/xDj+1uX706LI4ib7zqVctHHyayGEIDcNfdd514x9se/dZ35/Pte155H6eQYbRH9jBgBPDRcMf13fwiRkqJiGqUJsbo7sMwtG07mUyuXLmyvb19++2355xzzmPlh+pYt227ubk5DMOlS5e6bmgmsyJFtbRNA+r90DPjZDKJCEO+fO7pZ66eOzdr2JfDhqeKtZgZujuBA+w3f6sYACw1go+Vl+Ij80H3LCRcFYzZ86UB1lJtlHu1olbNWgIAc61Fg9wU1tG9EWRZicWVbQcrKt61eOuaQIYINAq1GoS8boXZOvC00ifmNV+8ogsA4La2oPdhtQ5uZivJWR+P1jIU1kId0YnEBGts3b1mfTCN7V7GHMsaxoXKHUbUkeTLiGqqbhyCQG2/CQ4AkYsKV8u8GBIqupnXNjjVnjM3JCSo9TTUzYl5pQ/2BO7K40dwl1FjHfCn9yBUH1N8cKWlDoLEXlOF9qW+IZEimaM790UVqIAakwcUcBRzVSKyCGamKx9lLfefK6x47YVtnxE/3iod9t2Vu1Xfj4zrBHzVPNRX+vOa0wMAIBm6ITgpBCEoUUW1GHTg5fVviL0yQeT4S9CJ6BYeuNpge78oIGIzaXCOfd9vAna786uPPXGcmWsyVo05gBkY8Gj+IhI4VgsIV2bWnvN8YKx95ZURvMYaxw1CY4F9WwuStTe59qBWNsRoRjsggI7iyRXc0J0JiUF9zN4BKhDYkVQ9pF4yMHPkQQWkIAISCLi6NchrsxCqb+bX2a8rx3ElCnH/ve0dA+5oMBY+qwJ+9OLVFLD6rlgDzaBGiDWWpyoOwCM1CNxN1oXPca8KDfh69mr1DEDeEyk+ihesdMaqVRDRXEMgdHBVXz3cmrOLTE6oleOLyEDgWLNUjUZRQ6OQB6fRIanPXxuUXKvAcW0vArh6va8RnNgv51f4777phDGk4PvM3xrO3i8qx5fhjky4okCMdYfsGirGXjLIdVpyHX5ycANabYxrnsUNkADWuAmiMmUkg8iFyAgCKiigFlMthbFRCDo7Mem0Ye6KlCJ2MN/jVhmV4O51pVZhYKZSMDAC5iErghEJ4A078f2Chxk4rQA2VgsUgBsYFHJByYRANToxdsdYCZY1HOyOiIwQXLXk5aM/kgtnm7yMpkcTeSn5oe/3obHt3b5fwGNPXPyHb7z++N1PP/nEE3+T/8nb3hCKbv/woeVTjz/zYISrc9Ju58zTt1289+1vfJ1a+f5/+U9bZ89s7vP5cN+/AOMtOYCPee6GlskQbVWQCnC136FCo9cVSH1BQ0oppUynkxgnIlJymbSTzc3N5WLRD8O66fGe+QsAR44cOXbs2Hw+397ePnLkSJPaIiJqDQUmyHlgtTbNsqO6AOIxiurQunrioE7VRvLxMRyuzY4es2D3zM2VCYrXBsNh31/328HX+xHrv65lOl4TDsD91z1w5huMPafw2pu8qfu50cmv/e61sg7qijUEN0RyMHWnyMbULXdDCArO6hvtBIqzuzk4UyQQtyESIgVzTxERUnEm7HMhwCbG3oVTcnNUcwQBtya4MgFF8QmTRepRSxFwC8S1hqWpBWaVWg0+qWoMcex7ksK6pBfssUduwr/zNQBxYJvsP+YarewACQCACACZ0SECB6q53kiE6AzgLUGFmPaQovHnw1Guw64LB5bLTaECh9kQNxpodRESGzhDihiVuUitIu8o2AavJR73q7dbUKmsOIWI13s7v+BBez72vg1HgIBaZJISLDKbb4S4yUzstCcexoDxCsYDHMXIfovk8DX7XONnWSHXfXcP+4sAtjKWV/9AFXToDgERZcIIZIAeyDFwPdwARtB5/ZbWu+MwO/6aX/ejr3s3BYZkCFSdOfCVbIWiQCEUxFzEEWapwSyT1IgUcGxio2ARSN1EpQkTEWFmNTHQJqZSBNyrf2EORAEIh5IxBHElYgJwcyTGWg+nWODIzOCmIE2IoOqk7rUQpluRGFnNFV0Zzd0ByTEYsZMzKNk+u/M5Ncvh4ybk/PUH1/W1VyEDVsbrgeXl1wjMPbR7ZVGsD8YDd/vcz3LtX33/1au8dUM0NEQKBghuCMKABg2EgKEoYkKJLl4RHFwF9G41SYVoNbBDAuoEZipmYZIMNQgSBCNWJL3l7nwcWKuOkCsoEkw5UkjZ0VwT4yzwnMAQwZF8FGUHI+ZuBGDuDbjl/Ow3vmmEsz4zABc8ij5/8DtLR3S0Hz1+h5Tdv/r09zjhYrn79KOPfPPr6K7z5WbOW1/aYrUpqj379GP/+b/G1LhDv5jPuiH5wbV+7Wy6AxiBEAFa8BzUyAoAATAA4HjnKMgEwPBi1r1XVXRgZFMz0diEEMLWlaumdtvJU8x84fx5U53ub3rs7tX2bdv2rrvuatq07Pu2bQPTclgWlUlsInFXSkwUYmyQYpbAjqtwOaxdz+vHngF0rc+w578e+OaNXIuD5732WDx4LMKNz3z4yQ67+s94Pzf88BCzzAEVAQ0SIAKDWxHL5CfuvWfz6FEi3jlzdn5la+JMROqQTWNo3DUd2fB+gOWAMQ2SEQGcPcCA1oaUNErWkGJB71EnGzMMrDtzG0oRa1Naak6bs9D4bDbd3d0tWQCAY9OXDI6BmRABUdRr12uiYK6mysT7TJ+bkCCHvILrj7nWJxi/YLACmlYfjoCK4/7Drv36zyTUDt7bzX33Z7iEO7kD1edwAkBDVAStxBNAF7deirnf7NV/EcNX1KDaK+SWsn0P2ZArXU+1ErajqxJgJCKAawsj4j7bcv31a1/E83gtL0Sz4r57W2MIB2xRdMeDHxPs3erez9c4lfXX697dwZv1Qz50QIfgFeBwAqugUzHjtt3JGVM8/fL7FXH7/EXI6kUISV3ZiTku8pCaGNtGimJKXc5t2yLCVjdvkImJgEIMy/nudDpTdwWeTKbo2nV9qAWEgRwIAh0/fmw+X2RVZkyUFrs7AbFJqZgQMSGCelEHRhUxRw8EgODkI7a+ntTnIcmf+6/XK4t9v+L1P9/g4P1CCfGQD2946ed+Fjz4weonBEdwdANARyOoYJYpute2ia7mnr1k0A1GclpxqeEWNYIdgMZ4CyMSs7obQqSQQgRHco2u4abwm3/84Vr1H4ICCKC4LwFSE0RLVivuQBEhEAhWB/nA9wGgRpYB2N36zADrKgeNA3QFABCAh+EYIAzZAVqABKDLJaxSXL0UqIydAXwYqoraOMSMu9FzgDsxYsOY2Gtp8QNIWI0ovbh532tO7Kq8DA59r6rHjh0rUi5cvNikdPLEyVA739RR22CcOHFic3NzPp/P5/OUEhHmYVCzpklsYRgGJY8QiXjFdLwl188vyXAAq0SIsYuGAzgSveJXXvM7//wPTx4/3oZ49sdPfu6vPvXUDx7NAEo4GMjQz45s/sYH3p93F3//qU/Pl/PpZIpqy1KEQBCWw7DpPI3NfBi6hB3Bq177ml95+f2f/cu/AvPUhF0tHuJON5w4dfJDf/gHX/77L/3wBz9wM5PCHKbTFhCXXQ/mBIpik7YFgJJzzXioCR8vjec3RtlU2ysAulU+4kv76MUeo6AdDQckHJuxvTR+9oFQA1WOK9vYARwRQlio3vayu3/jt3/nVW98ozfNs0898/3Pff6x7z1sbhRjNrOczf3+V77mVa9+9ac++YkhD01qFmrAAO2kZC2lTNroSNhOdkXM/dRdd737Ax/45le/8pPHH2eklFJR3VosTt9197s+9JHvf/e73/vudzamk+2dnWlMgCiAPZG6Wx5mxJGIEJuI2dUcHQHQfa/p0EvjZgeuSwePPDGHyi271ezd1VgjI3UgOAIygFiFI4GB2D15acFuTfPXANTBDQFYPQiEjNQjOkV3HQAFgkMgDwCmN/sEuHJ98RrJOP460rQAYH/K56q06tpHGr9rYyD7uYYDgFMwiI4MiMiOtK6lzSsbmq41pl/EsQ5UmpmZbW5uXrx4cWd7BxFPnTq1WCwWi3mAlesWQjh69OiRI0e2t7cXi0Up0rbt0Pe5lGaamFkWYgYco5nX4nlEVPObbtGtcMsPBGC14IDMgjC4KUN7dOPXPvTh3a3l5/7yU2kyfdcHPvhrv/eh7//kJyh69PixyXTSXd6aox9/2d04yMaddyTGnd1d9cwppo3psaNHhp15ubIL5j3C7OTJyTSdvu++2192LzUNFDTgYgZNyq42nb7sda9L3/v+tunJY8ePHDtahrK9fbUMw2xj1sQ4SdEX87Ls1t197JbvGHmLjzHByNHNEACZQjiYUH/LDsRbWvkdGKZmYzFaHjmXvyR3fqsNR1AEq3zpvZZsIOYc4nt+90P3vva1n/7UJ4vCb73//W/76O+fv3zl2WefnbXtkWPHROTq5ctH7rrzzle/auOO0xsOWzvbWsQB2thsnNpU0X6x3FksmGOzMTl67Mjmbbff/673PPToY/rsWXDohxzayeaJCU43bnvrm5vLF69+55vcpBP33ZcAts+fAwectMXh2KlTjVi5uqVa1LXmEBtVDeuG9suy0W6JMWZrAtUOMoGZuRZSrbxkgHVS3600VvYUAqAjmoN6iKgOJuKiBLWnzPPq3/2PMhCADSIE0JgsoMcIjMUicEONOKMgOTrwgPbTVzTuCyOs/x3f2r5/veblHEzN2ecjjFSZWtbxp17VnYITCmhRVTUHQ6zIGa8ibvxzMH9rxte6FCwippSaprl85XIM8c4775zP5xcvXQTAPfN3Y2NjNptdvHix7/u77777xInjpZQiJcYYY+yHnlWnk42eyLy4GqyqPt1yq/+XbTg4gruTAxigE6eTp7orV3787LOLrn/q0uXTt9+O0437773nt9//vs3bTm6du/gPX/r784v5O9781j/a+O+mt598+Pvf/+Sf/pfjJ45/4EO/d/qOO5ZbOw898K0HvvqVt/7ar737ve/1SEdf/vKnf/KktpN3vfu9T/zgkcuPPvKG171+dvvJp559ZrvkPuDJe+750Ic+dPquu7vd3e9977vf+Po33vk7733b29/RbV194BOf+OEPvp9CnEwmfd977e350kt/AWOvSgQC3fqdk/ZZvfvHL/qmbjz2mJOj/oZVhWz4KdXiXxo3GA6IBzpzowGIedu0sxMnPbUXL28/9vgTT54585pXvfJqzsfuuusP/vkfnbrzrlzyJ//iL6RtTtz/yj/4t//2yMaR737vu3/z6b8h4ne+93ff/Pa3a8nf+srX/v4LX9w8deqDH/7QPffes7tc4qSFzc33fOSj5eLlb33py/e84hWvedvbvv/II8vIuwR0/Nhb3/Pud/7Gb04AH/jC5x948IG3vPPX737Vq06k5off+OY3Pvu5aLbRtgiepQCgExiNuUEvrYCbGT6Wjx/HetfbmDB8KyYqjLlua+bIKisAa4Kfm5uDKTga8K0cwUSA2vk8OCVDMmwdUaxhTEBLR3Oz2kAbf7oN7wDXp1ZfD99Wi/TABnneBYkQkADYCRVc3RRqEvj+2yVfpTq8uNtyHzNnlaYPW1tbk3YynU6Xy+X29jYRTaeTvabHwzCcO3fOzI4dO3bs2DEzE5EYIoLnnN08hOQORUpMxCmu68i+JE+e93AAYVQAVm0ck4dBbLm18/VP//Xv/Jt/+b/6P/4frlzdevib3/3a3/zd8Y3N3/8X//LCYutTf/5f3/ee977qTW+yo0fs2PEH/+qvw7HNt7/rN05//YH3ffD3Tp6+/TMf/8Qb3/Lmf/LH/+IK6Tt+9327O/MHPv+VD/7xv8kpztt4z2+983I33/3+t172ilfc9cZfefyT53tCaZtf/9AH73zta/7643/1hje84Xc++tEnL1x81a+9Y/OOO776xc9f3dqqEYqxINQt6O7/sg13QEJcdePMufwSzegB5XfrDgRirq5apevcMmr6l28gQKMQVuVPjEAIhSi08eJi/rVvfv2fv/mN//P//f/mmcuXv/fgNx/4m8/M57v/6//t/+7YqROf+/TfvOotb/3V973v/BNPlEnz2NNPhxDe9b73P/bss6fvuffN73rXZz71qdO33fZb/+yfnp3vvvqNb7rzja///N/8zf2vf+2pY0d12t7/m7+++8RTD3zt6xv3vvx1H3j/Dy+c7cEWAd70nt/6rd//0Ne/+CXv+t9+3/sKwsvf9Zuve9vbvvqnf/bkuXPctMm8DAMz0KhkAeC6ROiXxo0HroolQQX8zMxMzQMzrVr9/WLv8EZjTGIdie4eiCJxVgX0yCHEBAgAkSCuC5isvrdHDDgkJXFv/Kx/3X/A/r/uP2z/56YgBVEcHMxMvGQiazihl6JDgSIBSgAwb+2miLN4nRV7qAQncLqJw+xgZuwhwwEcvDMkYuZAwQDZ10zf6znwL9JAgFi7kqmuQ9allFLKyZMnd3d3z184f/LkycBBiuxxf5fLJTPfddddiPjkk09ubW2llBC8Wy6NPYQACl3XeQpEY7MJM6+FCV90dYgHAfif7/lvNP4R1DwZMIE7KrhFXBb12P7oBz84/3/5v566++57XvXqj/7BH77iznseeeQRPHLk85/8i698/Wvnn3725MmTv/6B937n7//+777whdP3v/x1b3rDfffff8+rXrk93z1++8nepLC97PWvVvbP/N3nHnnoeydfdvcdr3o5bE66YTmYxTDZ6btpvyyECys0ndz5xtdt9cPR07dJpLAxPXXPXduL3Ue/9Mhn/u5zt4tNQwKAIQ9jh47DpuXQKX1xJ/D6S9z8+X9B33UYSzrUMn9j9pivWlKXUkAFAIhrwayfEpy90XWf9375WXVYTSa4kQX8U6+LP2PC+E0/yGFnQyAmYi45i5TKMKl1tX6qC3czt/fL4QPc3LiZFS7oQmPxQkdwBENHwGkzeeyhH/zH/9P/+WWvfvU9r3vDb//2+1526vZvfPELmydPfPzP/+LLX/rSg9/+9sZ0+sY3v3nr/PlPfupTs9ns7pe97Pa77njjO99OG7OTL7u7nU5h0rzhne94zate9eUvf/nPP/3Xb75w7sQdp7OZhzCYLKT0pp2WhQylDJPZ7C1v/1U+doym7ebRI+2p40fvOO1mjz/66Cc//ely6epxQABfveXV1huf68VXujcpH17Imn8h4utmrlnFVDVZVtPl60QlN3MHs3rI2Pt9PWC1odY3+Rz39nNNmEMAdXcF4hHn51W7aQAMMaKru6tXnJie3wz62I+a3M3Baonea+3BkWa7z6JdPSoSrERQNZzsOgqGAzqigGU0D9phsVByAEAa8pKx12gavVBRlXBd3tihpvf1E339J/UBboYQcjNYrYMXMHED5JAaLEVXRIqbn/b96+Q51swa5fVVgedK0Vmjde5+4sSJ8+fPb29vH9k8sjnbvHT50jVNj2ez2ebmZilld3eXiJqmQUQR8dpRDKDWNiViRJJSzK22Nfp5OIE/b9Vy66guNo9OCjiQQyBBuvPuO9/yrt/6hy//w5e+/el05B92z1/6yEc/em7rssjgZkzUxtSGyO4mEgBCfSkAjLi7s721nC/PypkrF0opr3/Va3opGSwTQAimmlIEpqWJRobIFFhcuYmRaLdbXrx6ebdbbm1vPfn0U29485vEtNoQdbp+4ZyHF3L1X9R3rx+IyEyDuYgWkQQQ415jbR8r88Oq2/ZPv5MX4njcpAbar/CYmZl/JsJG/eL6K/s15c9lILg5ihcpUgoRBY5E5Ndxf28kUm8d+fCPM37q8zqAMCgBXKv8+mE4dfud/+T9v/edR374if/vf5pM//rt7/6Nj/zBR7aeecb6oV8uwXxYLo/MNgLicmuLAF1k6HsELKUshgVG7GV45JGHz186/6a3vAkCOdjO7lZNVutzn0GXqDRtlNERKHAxYSKRHJo4FPnW97771NlnfvXVrxx2toeu59rtzH0klV37ID+nJJsX8bAX/bvPfyCA1SLNQMzVY3e32ukQVsn1655B8Jzy5CZNmef47k8/bL8VWk14N1MtohYYEIdSesmG5mgG8vwWQ207QGgGNpb8B7zeikVEQlq3lFndlxqYgxMgIRmsmvPt5+CCM6FWj4NgYMmUd9mh9LMARwCBjKywSQBHOmhNuh1mX14vrf3g3ti7g+ecl3Xy63MPB3BkYcqInWg3DKpj3+7RObiJ2T+wZm60YNbLY8R6pahqjLFasGaWUgKA3d3dyWRy9OjR+Xy+M98FxD0VO51Om6a5cOGCqt57770bGxulFFMlJsCxs1oIoZiaMSCNKvAGPWVeGjc5NBAweVYuHsHRgLry6je+8b7X/srnPvfZ+bJ75SvuW5y/eO7hh9MbXv/r7/z13cuX//nvf6zb3SWkSTuZAlKWSTvZOnfhqcefOHrq+BNPPnHfK+5/5xve8M0vfhkW3Xve81uLYfGKN722bSepKxtOb3/LW7YvX/qVd/xqmKSgdqSddNs7l37849tvu+3SmbOvfe1r77/35T/+4aMNYlAj95suovvSuKlBRGBupgAeOSBSLqXkUv86doquXalubrwQNsJNXmUNl1aZsj/35fojb3SG5z7gBQFmcBiksPpu0zbMyyEPZgbEN3PCl8aBgQ7RMBmuyXuVyTcJseR+42V3/NN3/3o6duSpM2fuuu9lDnD2Jz+Z3/fy97/nn+Td+a+87a2nbz+9e+HChDiYBoeYGity/qmf3Hb3XQ9+/WttTO//6Ed3rlx+6Nvfeu1rXv3m1732tW9+08lXvEK65e65s6+4+863vu3N9953T0qpYQrTCZr9+Hvf28Q3ffcbD+TF4g//9b9qmySmbTNp3NyECcCUmau1UWvd1dqoL8myFzLMPZcSQtifALB/k/qqQuJzb/P9/76IoyKLTFh5LpXMSkQhBiXsZUhoGtEDMXnA51v4zAGxNlUEAyBQvJ5bUA+DUbyu/8orBBQBCNQB7DpmAgIEg+isAEVxlhoPoUIjbQxpsDzvN3s7rtyAD9fNoeN1T3VY67/rb9hXdaiee9QeFT/V7nOAHnwIYWDq3TyEyXQamAlg7Pp4kKZy2EmuXSfPEXKs5ThXixJ57Oa9V/vsypUrKaU77rjj0qVL2zvbk7adTPZxf7e2tq5evXrkyJEjR47EGLuuq0iPKVQfRdUJzUe/2qolT3v9f18aP/NwAHNzBQIIQKwOUq6cPfO3f/I//sYHf/dDH/qA9yXPu0//j3/65He+97dEv/m+3/l3//rf9Be3HvjaV0/ecxdniV0Oy+6pBx/cPXPmS3/5lx/82D/7d//tvyWHJx783hMPfJN3d9/zoQ/8z/74X5nJ4994oFy4/J2/++I73vXrH/ujf5ZdvvnFr3XnL/z4Ow8tzpz90o8e+9gf/uF//y/+JRI98I0HLjz22MV77r1y5sx0tBdeesEv2lBTNmDiGBOH4OAqysxrs7LivmbGfKvYahW7rTDPMAw/U/WP/TLr54777r+oOSGq2dAPlAcEjCFUAPjnpH3/Jz5WeWM10ksIjk4gebn4zJ/9p9/7b/6bD3/wA/OuoxS+/Fd/9aNvfweWiw//09//V3/0seLw95/5W3SbAYQhg9nOk08uz559+KFv/c4HP/CvPvKRtknPPnPmJ9/+zvaTT330ox/97z72MVG9+I0HFs88+/B8ft+HP/x7v/veru/Pfv1rtr178esPwpmLX3/iay+fbf7x7/9BP9+9+MSPn/rBD+697fQAOHE3cDQhciIUr/15cbz/+sJfMoFvdrivLZVqrpjHGBzI3deGBaws4JuhNl2PAd/kuGnqyIh0Ym2wZ2rgyAQIzsQh6aLvrZSxVejzVGx1SfmKseuHVV9AgHWhwPWF1nLTHWzVBeug+Tv2QGwcXLNhB7y0NoYZz2LX4bxEwWiBnRASjr1v99BUxDW7drXc19SfffxmRES6hoK8aqZ8gMWxPvO+747m7+F/XX9eMOQUpIkeow9QsliRseWQOSAYjw4p3aAk4fXr5Po1s7Z6178SMxHlnImoNj3uui7GuLGxcfXq1StXrpw8dRIBzXSP/FCbHk+n02EYdnZ2KhXYzcwUasv0eiViIizuZmpuceylfjNskJfGwYEAZIAK6OiMGoBiS+g/fvihC2eebqezwLS7vXP50qVpM3nsO985+9RPjh47lq/sXNm68uxTPwmDbTgsz5///F98HLq8LeXP/p//cXb78bzsy/mttstPffehj5+/EI7OdpdLmS+bUr72d3/3+MPfxzbNd3e7ZQfgX/yvf6mmech//h//36dOnFC1Sxcv4nzxwN98VqRsADLclMlyy2ZC3AID6/Tgqlcpjk2kTUUIIKVYjcvqsz43M/Umab4vOnt1fULV0Vi/+Te+XzbdyAJ+IetnBPcqoRoAgYBHMU5EPv7rDnDobb+0dH/qcIRClU5LFb8hcDIns2A8f+rpT/7f/8Pk6NHpxpFLly5evXQxqZ597In/8f/2H06cPNl1/dlnnmln0wtP/mQGCFm+9rnPDjnvLHc++5//7LaTJ131wpnzy93dfPbsX54/f+TI5pCzEy2uXJ4//dR/PncmcBiWnaiVrN2zF5bLBW7vfu5P/uz48WPgevbss7nkBz7zt3nItFy2iNGd0YZcgNEJnRyd0JFGxf0SCHz9WFuxuJJR144qugjBIUtx95xzbeB3o0DQoeOFUCB+6jAAQDJ1sOLkYiJqDjhIGRA1ggfurAyMfWp34uT5oQsIOFIasPKKqyV4kF6wat+3wjlxrBJQZVH93/6WYfu+CMWdKGZPlKZZaAoT9oRLRSHCVprJlcgDxw0guQ6JsMPYD3xdV7WR4n3guzf3Km7mKAfYcZyT7VrusTaWBxNFBTADNScXBKtNba4zf29+nazjpfsDjCq6jlEAADMfO3bsscceWywWJ0+enE1n586d2+P+AsDx48dPnTq1s7Nz4cKFjY2N6XSKiGq2clBqnvrI+Ruv5FCTdRBeNJhq3Ei+Ion46oFeVBXlNwlfvdjXvX4wMSOZmaiISkiJAPqii0uXt+0CIwTiTaDGfRBZnL+wvHRpArgBNOzMLZdNSp5dtXDxzSZtX7g4P3eeEScUg9sstItnz8jTpoRGULsiXX7qKTSPIUb3FILMOzW9fbaZt3Yvnr9cRI5sbLaOw8VLk3aWSwbmFbPmuV7HuMuvcR1f5Kk7+NZGiX1zqMD1b/ymX+4L+e7BlTy2aHdRKaWoWSAKgVRlZ2dnZ2cHVu7sC2yudoMX9ILOtrOzo6ohhGEYnnnmmZuk/9ZGcYi4zvk7dOpeADCMDogG5Gqowk5O7MGznT1zDgCYuW2aQOSmyGNb4IpWHDolhyqGwy57MPL7SzoOfV68/uU6+Ngxb2wSxgAx8rJbhNj2W1e3rlxCDCrSpgjutlzmnJ+6dEldJ6GRnZ0rW1dnkymYb585k9r2ONHywqVLl6/mXFriO5pWci5nz59/5mwIrOApMprtPP1Mqc0mszbU5KtzULkttHLu0oVz5wYrx48eyQZXn3oK1GapQREwwRCIwciNRtsDHckRAPRFfWMHZw8B/JDZ+ymLal8E9Wa/+yLrpj3mJ1TW9HiRFeSP4zXdoVq9Z8+e/fa3vw2rLVDl1XODu2shsD8n6UUs+2iA4sgGpAMmzKjnnj4XNQCRBzSyDJYin37Nq2cf/lAz5OcpbhCryYUjGdrNDpFd7pU4OMqbOpWuRtXeMzOH2j3PV+ytegpDL1y0lE2f+Z0vK8eOEiYvDBm4nfVNuHL7sZ03vqLcc1Idg9EBdqLZIcuMr/f54RAztlYG/KmQuCLcTAOZtuipjWk8OhtcFblbLn/4g0fPn7+IJU9MC/siuBKTUzA7YEGu18Y6GebQYiPrNaaqKSVVvXjxYrdcAo6pSiISY2zbdhiGnPOxY8eOHz9+9uzZRbdsUrNHfgCA7e3tq1evTqfT++67bzablVIIIIRgYEWFgRJHdCMPiFSYF0i9IQKQ6c24BDepfnEtDUbLAd2ff4Hq/XD8/kvs+6UCRetM4ZGO4teTw38uQ8kpYAAn1RJQBxUJgE0QpEpOIhVdmiMYEah3qgEQ28ZQBrdBAYjNpR96QJoQm/kAxoFMS6LopWcIS7AOtGkaEm2BQNzRRd0RgvPWfLcNCYEJLPfFwJhTXwZDLrZyzdaT8Zw0zT2P2Nxv9p3f1MAx73x1CYebT+Q+8AQAhz/FDb+7L67n7mA32UDBHcFBwTw4iEJGD2Zs1hN5Sm3bEmFXejN7/PHHn3zyyQoA38hUvXms9/pPDmUs3LwGdfdSyjAMd999NzNfunRpe3v7+jOsNd/6h8riQMSaMVO13aoS2R7Ofah0w2vDqYdmQriDKaADuwqKsqNTMGbjhZZTd59ipGWWhfvcnVWr+w77+A+HXHd1jO9fdYCA4HU3IN6sC/3LM/bvL7+us6MjggG6ITi7kQOAk0NGHNyzlNhO1NyYQBXUiVHdC4AhAXPJmSgs+sEdYmz6oSADO5WhMBI6dctBRRgphphLAcQ2hk7zUCROWhNFZHMvJsFZRSmQFGubyXY/eJEQ2BF6ETBDRxdVcgUUNQAi82DG7gAg/nPp/lZ7Yo3L+QZ9Mfc0y54Ldt3CvnFPzVXnrn0I0YszHMAN3RDdNQKRq4KpuqmrOZntgk+l1FYAIYRTp0499dRT586dg9VOrDDwfkbEfiEAq8BLNX8rv+u5Dz7w4XNLqpHOBFQMIhJ7geCDi5sfOXY0NDEEH1xKkdhOX/GOt5dffZulsF95+DU6wq8Hb9aGBAKqqQMwEhGZW82M2s+sWQsXXsGFiAQINROXkNTU3BkJEPzAxVGxtWF3Z1OaDtv++MkhhNLZxmQqSXet0K+84k3//R/PQHlZppRwPMXIXDC3GuhaLzMADDS6L3tHwshiGmcYHLw2Fh9l41oarB5rb70Jgu3zWRDWJxs5Jw5ODrMMZHDlzmNzoNCko8eO7e5s992CTZOKkHeJFBEMgxlfK+rrlFZVWNdJNWev0cIAAFADp33ft22bcwaA4ydOTKfTqnpqTFVEFovFsWPH2rY9e/asmR0/eiyltGf+7u7uisjx48dns1ltegzmsUkiIlk4BEy8GAYgZEuFU7zvPu6GWRN0GNgdzEItsbniLIoqIxFTLsXNQkripm4cyB1UlYmR0MwAsa4SN0cEKBZWtOWYEhOpGoCbGRM7uhRhZiIuJRNRTKmUoiIxxvrAZgbuHAM4FFOIDIAixcFDiCbqAMxk7qYaYwIAKyVRsJWGJiJ3IEJVdfPYJDfPeWBmYkYAt8qKGtc5IY2/IjDx2l+p/gcxEdLaZaxbBVdaVlXJKQV2c1EB94AWm0bN3KwJAdVUlIjawKWURBw4ZFM0D8yNlqIakROhEYZ61sBFRXMOcUKmYha1NE1gjlAkOrpZYELEoeQmNRFci5JDS+gAASlGziLuEJkAQUTcnUNY8cEMANaRrzonohpCiMxZBMxqpKxW4KtPLSJ1OZqZg9fKIfvNIwTgEOp7qdQkX+kIdEdCESWiEEIpRdVC4Brddqu1CNHNiNjdHLwWxFhtGGIiUTFVDgEB1BxwjE+NkSyAtVBOMampmjKNl1ARAAghiIiZx8Dubis4U1WJa2LD3iND5OxaMzLQIQE0kbAWz2ZqXn4PEllZEus9L797GIblsosxTiaTYRj6vp9OpwDQ9z0ippTMrJRS56rujhBCSqm2YKyf1xmOMZZSRKRt2yoa3L1pmnoGRGyaRkSGYYgx1sk0s7Zt3X0YhjVlqpRCRPUSADCZTIiobduU0sbGBgB0Xde2bQgh52xmTdNU0lU92N0XiwURVV96GIYQQoxRRESkSjQRqY77Wt6tlWhNs1sul3VOcs6llBBCfQX1W4jYdR0hp5hUcpacmkgUhuXAwKcnLUZkoCVyvvOO9g1vaA0iosO4dQnRAaSUGCMRDcMAiE2K7sDMUkRNOQR3d7UVUVtCjExUZ3KFbZNIIURcuS7ryCauhEAIMQTu+97MUoyOSEim4gAhBFU198gMiEUEAWPgKgGAcB1nrXa7ma5Una/lzFrmrJQSgnsIwc1FlQjrsiQi5iBSwJ1DMDMEUDUDDxyqP1k501WaYV3ghLAqyzeWkrLa+4kCuDmxSozRAUrJKURCKjmr69HJFJHczYaBiUNgMweEFtFczZQpROJKKG+Y1SzGGNxLEQFvIkfEEIKpgxmYgTkjAyJHmpQSOATwwGxmokpQmzG5qQVCRxBTQmYOVpQBA4fsYm6BQ90vVY5V7V0hD18BrqlpRHXo+xhj4KBmtWpVVXB1yyOiiQIhE6mIqIUYCKCIIBHTnthfaVqsUXoHMLUYo5vlUkIMMcQqZsftDCgq1S2UIogQYhw3PgcHN3NmQsQi4utUAfeRZQUA4KrGIRBSzgMixhTBoYggADOrmZYSYsTEnQxMgTmggaoQADOWkilExsjd8sT9rzDAEGJo2hDDvffeW8VLzpmZY4x936tq0zQAUHdHFSPDMDBz0zSVL9E0TY0gAcBaKFW9UJMfam0ZVRWRGsKucq9t267rRCSltJY5MUYAqGdrp1NVl5xTIArcDz04TNupgEiXm4CB4wDkR44pIzVJ1fKQQwyBw5AHImpSyjnnIm2TmHkYsoE3KRFi1/futjHbVLduuSTmtm2LyJBz4EBMOWcc16qamQOklNS9r3IvxFJyibKW6oFDTDHnIlKa1DjAkAcESE2kCL23bhzaqQMNeckcLJYh9+IyOXrqxKnbXcSGPGuniDj0AyCkGHPJUqRK8mXXMVHTtO4mRarkLCJScmrbEGLfdQDetq0bDEOPiClEcBcpABBCVLOSc4yRQ6hSPaUkIiASm0DEdbk2KSFiyQUROQZTzSXHkFJI0g+uOfGEOIXT7GpNSuBuZQAinrQK3vddE1JkzjlXPVXXTFUWpZRKt4sx5pyr1qs7tyoyVS2lVEVWdWXgwER93wNA27bMXI1jALh06dIwDKdPnx6Goeu70fytTS6OHDly9OjRxWJx9erVbtnFwGA2MohDEDMBayhIzhtHj73nDz9WPtBtNM2w2I0BQ2Apxb1uUVWREBiJSxEzjSGGyH0pYtY0yd2Hvk+pSSnmXFQ1xEBIqqKqkQKYASDTWHRCzQmRGKUIMacYRVVEajtTd8ulMHHTpFJEVZhDLaqKRDElcRMpiEjMqqYiMVZNZlWyj6pFoSJQZgYOzKEmTgSOgJ6LIECTkrkPfc8hxBj7rnOH6WRi7v3QxxBjDNXyIOa2bcBgyDmmFJj7vhu9MkAmQkJ0zFLMrG1aNZVSEDCk6OalZOKQUlQVrYsGcMgDgKeYALAUQfTAQUxLFUApmZq7B2YgVBXTytsmd+DADi6lruzg4JILAKUmqqmppxQRqZRs5ilGQCwli0hqGibOORNhTKnkLKKTSUtU5YszB3MV0WpDiAiAx5CIMA8ZEGMKpl6kBOaYUt/3KpqaBsFLEXOLIRJXe4Lapskll5xDiCHEWmcHEYi55FLdDynFTKs9UURKkaZJANAvuxDjpG27oS9FJm1LREUKABBSjEGKqFnTJLO6wbhaALU8SrWrmIhDVBEzDSFwCKamKiEEAB9yIeK2aVRlGIaYIvNqkcdUraJSpIqMXrKAxxjQ0Uqp66eYKUBGnRw/Gpq01IFjnMRpjHFjY7MagtPptAIkpZTZbMYrLj8AzGYzd++6roqzatpWeVe1BRFVc7b+LCL1bNUOrjppbT5Ww6vKFGau5cFr0cOu66rKEZFqd1ZrtZq5iDgMw9GjR6skYubJZFIlVBVb1T6ol64qbWNjo16uyrj1z3Xaq7yrH1Yjvn4+m82qeUdE0+k0xliN4+rfl1I2NjYCsYq48zTOqsaFFlJMMcWu6/pcaDJ950c/8tZfe+eGahOSqRaVUT2bmRsBAaKaIgBzENVScoqRmEUEAWJsVEsRDcwc2NRKkRiZOaiqmcaU6v0wc3WARQQQYghmbqaIjCsbMoQRKuMQADwPmYlT05ipiBJTYBbVkjMxt01TREopbdsiQN/3+/wTcagKA0rJhMyBVYq5p5iQsO97Jg4xiIibh8CIVKQQInNd+YWIq0daKwQhQtd15hAD4wg9WAiRKn5fnV41UWliNAeRjMgxhlLE3VOTECkPA6Cn2ABCyVnU4kpphRCYaciDmjUxIWIpAm4hRGIsRdyhzk8RiTEwjVYRElWExc1DjEWyG+xf8E3bgEPfL5F40rY552HIqYmBq8uqIUaiIKWIlpQacBzyEENomlRXHUAFmUxUYojuIKqEMDb7NRvl/zAAYNs27i5FQmDmUKRU1yiGqKo5DxwCM+UhI1JKSVXUjBA5BACooqZ6X1W7q1kehhQTBy5S6mOqWskrv1FVVZkopqRStX4g4r7vEWEynUpR0QIOITACigkTA6KIMiESu6uqMTFxNda1SQkQu9wbUdNWNVQXdlTVIQ+1LWXOeePI5sm7XyaIfdeJafV7a4WpulVDCNV2qbug/nVtx9SAz7qgarUUq0gBgLqeq9Sq/nY1bSuyUI+sruPax65ipB4wmUxGYEJLSiGEIEUQMDUNMsmQQUrDLSosi+YQmIMNUv1MBFI1ReLQdCLqyKlVoiI6iHFgcRyG7I4xNvMhqwpRoBCWQyki1Tvss5jBZNI4YNfnClgUgyLqSIisomLQTmeDWC6ZkJBYiooYccwOCMCxQURDyn3BsClEBVYYRMTiQyl9SpEwbs87RExxtqXobsBNCNw7ZLfQTnozVcE4jTEO7kUyhybGpCLqnCZHBvfSZXDmGDpFEXWMKcYOMQ8DYIwhiIo7hXaGCKpmFAMzIgm4EbahRcRBAIkyhlKKQ4ghqKg7pclRBdgaegOkNEUnGTKCNZME1VAOHGLUUsxsmtoQgqzWTN3OVRdUKZpSYubFYlHVX1U96wVWV2BdSOOiIiq5VE+sGmOTyaRpmp2dHUQ8ffq0ql65ckVE9tDfI0eOnDp1amtra2tr69SpUydOnGBmLSUE5hjN3dwm0wma910fmvbeV78SRFENgkMidTNT5kBEZchIlFIsRXIemrZNMZV+QPUYA7ir2kjOqIqBiIlqL3EMBExDHkKMbdv2fS8iHCIhAnrdums1zIFNtR+GwCGmYGZjkUJEACySGTgwWxZEaJvGzPq+DzEycSkDc0wp9sNgqqFpBMxXFAhbwewhBHDIJSNik5K7q6iYVg+jSAGk6nVpkenGjJDm811mJiYRJUQOkRBEddM9MNuK1EKIZqNR2DTtCAs1CcBFxA0qwq1WQcdoqjkPKSUiziUzEseQcza11CQEEFFm4hBUZPUzS5EiJaUUUzN0vUhp2xaJKmRISMRkagAeUwKHIQ/MHEfvHEMIK18wYO2kohWlq/x1ZSJErNVwUko5ZylSjeMhD2PV1WoBuAUOHLjvuqqf6sy3VeaKMFEMUd1MFJkQ0dSpZomBqxpU81FkyEPTNpFjkVIt/lo6N+cSYwghDDm7QzO6SZpSMHdVYQoxBB1NagzMqlYRL3MzNUBsUjLzrutiiimmlSlJzBW2LDE2McWh70R0OpuYWt/3TdMSk5tXJcdUiUclcmBHRKTaddMhS2mmE0HfWi4KEoTEMXb9AA4ViC0rMHK/iK8bvmqONXmu7u2NjY39mmNtyvPKn65VD9cgTT24NjOv/nRVM13X1Re9xl+rfOn7PoTg7vVs1a6tqGeVL1UnVaVVPXJErG5zhZnX1nO94ar7qzqshlfOOaVU4cl6kxUTqvqylFKt6jVQvfYN6qUrwLkWiO4+nU5FZD6f13sAgNvvvqu5585g5o7gBqvoMRGFMBpYKSV3H3IGB3ONIQJibXYYQsjD4AhNk0ouVSjX+I2ZOkAM0cwAnJlVbV1j2K2GhlGKVmujGjemDuhM7AAqyoGZOQ8DIE4mE1Xtlh0HrsCSitRQmJmpSExNLcW8DsmOO5GoVtBjZvMxDFJDcKqGiMwkRYpK27Zu3nVdiCFyhNEud+YgajkPMSYciRCE6KpjzBqR+qFHwJRifQUAwCEgoJSCTE3T5CEPw9C0TYxx6HvV0RNzcFOrUGsumZhTinnIRXTSNsycc2EmIqrwZIhRRatPAuvcKwRENPdScopNLVJUXxYSYTUrORBzHnpzb9vG1HLOMSVCzLkwETGriqqHSBXWdbN97FUkRgTMuYTAKaaioiLExBTMtJRR0aqpmcUYTLXrhxhi2zYiAohV1KsIItYXAfW8Y+CwZkFxkQyAbdOoa84FEWMI4CBaK+5z9VuaNgHg0A/E1KRUiohICAwAReQYYoqpxujqBLm5uxERh5Dz4A6z6UTUhq6nwE2qe2rgENq2LaXkrp+2k8hhuVwi4nRjqmpd18W1GAFHpOIuqg7QNA0hVsz1ABC7jhRVOdO27RrirQjcfpCv+nKVtVklVRVx1aOuIPEa5KsGzVrOVEm1HzmupnaVgaIS4+jeE+F0Oq0OXkypBmTMvZpNK7u8rXImxhGLUdXUpGpV15tcyeGQmsZUi+Qxtq66Do5VwKhGAnUUSo2ImlvNpxqGJTOPZyiFmKocBoDUNAhQfz4Agrq7qdY9JaJmnlJ0oL7vmalpGlGrEj7E2HW9A06mUwCQnDlErrivSIwRiMvQq3nTtoQ45IwAMSVHNFUKgYgAEZzDKtAKRE31t0Vi0wDAkAsghBAdoOuHirOamait0eKiFlOKMUopiFgxmurMrCU8IjJRvwL1q4Xm7pPJpCqa6mWt45DVuarIRT3DGiSuZ6jWc41SwooTXLm/qnrixIkU01Pnn8olT9p9hc/M7OLFi13XHTly5M477wyBu64LzEwspYgZjmwBSZOJqHWaUY2BKIVt7fthaNsGXYduSYApJit9zgUREqj3izIMU47JYOgHAEgpln4oOQcOqWnAdRgGd2hjO89LMQ/qsMwiykSJg6lIkRCjaekXOyHydDI102IFE4XAC7eiGYFSirkMWrRpGzOR+byh0KZmmfs8ZERIwJIzmEfmTko2MVMUkIBi6g6B2cBLySFEdui7jpib1Myt9F1HxE2TVItkbZoEDt1yx81iTEsZVFVAGw4I3ltmChGrLyLtpDWTqnZdivmIcBOaLHeRMKYwtzIMAwI0besmuV/GmELg5XLHzVKTyEWG3sxiiiDa556JZ6EppXRD17Ytqw1lUNEIMXES0AIaTGwxiGqKsQfNQ6+iTdsAaO67GCIHHpa77hZjRAAZBlcLMTJKL4M7NOyWbRiGpmnatl0sFlJkOp1xoDxkYI+MV/p5KZJiGkCHfpmHMpnU6FhPxKlJOQ+yEGIKTLtlmUtm5h5ETLLkmCKJ9UMfQmxSU0ou/UBMKTVqlvPQthMtyzJkDqElL8NyGPoxlJY7BGiaZkdKmS9Sk0KM27kbdaG6qIiUFBt26YY+ELXTqciQV+IVEHrJTZN2dRj6TISTQLuaF/0ixRgxlWFR9ZBpGXbnRBhDXMoguRh4i6olVzMuNKHreskyaVMA0yIE0HJE8H4YiDhL6Uou4EyUTT3nSLFNTbVcq5RcLpdrOn81GasVW/VB27ZVYWxubiLizs4OEU0mk67rSinVXV6Hq6rKWXvD1bxGxMpMqD9XpVUP7rquQq2quh8D9pXCqAKonqEiNxVaXoc+195513VVL9YDKkS0llxt264t+6rpR47NKgxa6Vx1HmhE1kvVsrU0TUqp73tXW0NQ6+hYhZzHiETF5BMZWskFCBNHAytSYkwwZHVjIhJ3syyZidu23clZRWJM4CZdh0jMjJKLZERqyEvJuZRqIvSLbSJq20aLDMOAhG3TAECWEgJ7cTNDQrRsvaoqAcUUy9A5+qSdqEk3nxNh27Tz0vVd7+7TMHWTftkHjoHD0C0AvGlas6H0uVK5kKDkgoSTNDHVXoemaUKk+XxpprPZzKzkZQ4hhhhytxTVtmmWVvq+U7FJYoTSdz0ThRhL16nYZNoSWjVTYkoEOMigKgknhLAsXZNSQ3GxXLhZO5m4Sc5DCIER8mIHAEITCoPkrpikFIlgGLqKxpUylCJNm5hoa+hUhUPsXWXoSymTdhIwLGUgogmGwUspOYTAxGqqIkSERHkYUooMIstuGHLbNgFtuZgT82QyMS39YjeEmFLczb2qIHFw1SJFpEmJwAcZALDlpuRu6IeQQtM0NdpLxJFiriwgRMtLNY0ckHzoFzVeDIDL5ZyZm6admxbJmCgEWmjOkgkp4hi3bdvWvfTDUGEOA8tDrsJcco+IIcTtvKwGX4xRytikEBH7bsnITdvsylCyEGHAaLkbhoGJEjYqWjS3zQS9dF1HSE3TAGIug7mllGzIqhJjmueu5ALgKfCO9F3fBeJIcGWxA+5tk8xVu6FoSTH1fVf9hAxWhsFtNEy7oRSA1LQIMAxDNafW8ZwqZ9bmbDXdKudhLXMqyrO2XKvEWNMbKgFpDfjVA2q0qopWd18ul2tBtL5cPWBNq1gLgTVgvEYHq/Vczdw1Eas64fVxKu5QpVaFnOtN5pzrJWKMeRjqt6q9u3rLXv3tyWRiZlWKrqLzufr28/k8xphSqhKp0r1g1eRIRXyV97wurFGF4domrvOzMo77GMN65qtLUK/LnOq0VyFZEY0KnA9DX61DEelXVLe1I1EBi/qkRFQxkTrzVSBgjO6uKkTEKVWgZL+xjojz+XwvSNj3Y8DZff0U9YnqDFcnajqd1smsu2CtROqSyDnXKOju7u7auVq/r2oxVyeh7zstWr2dyu5j5u3t7fl8fscdd+SSn3r6qZTSpJ0QEe7u7t59991VfTLz8ePH61r5X/y7f/exP/jDGMKQczGNTeMIXdcR0yQ2edmTe0RGgB60BE/tRLWUIsSUYioluztzBPAiBQHamNhx6PsxVFSyiqUUq8NNHBBBVR3cmDhGBxv67OAxjnE3YjZTFUf0mnqiZoFjjLzGgRCp0meJuPZ8YccmBDfvh4GRUxOrMVG989GPjNEBei0hxkow9bFqOogoAKYmuGGRPAYNXc2cEJHQ1N2NQ/ARyg0hRRXNw5CaFJiXXefubdMA4IoHjObu4AyEhJUb3bYTGM0jSrExE1UnRnSsdZeZmQjzUM2UKEVyKXU3DrlX0dHrGjIRruMCzIGZcimESMzgoCoAwIErA5uIEFDNwJU5cuCSszm0bePmy26ZYmyath/6kqVpEzPnIQM4Eek6JRPAHc0tMBFxRUBX7LqCiEhk5uB7EXl3qNyGIQ+BQ9M0eWU+MlERBXcmBoKKo1XxoaZEFDhUsJYIKz5XwQkCVNPKglK1IqVpUuC4XC7ccTptVbQfegqhTalGGwjJsXoiTkg1Tk3EHBhqSi8hEw9DRvQUG0eQUhArX7MScJmJ+iEjYeXkqUgFzhFciiSOAdHFwD0QIdIguaiGJhpTMSWiCUbJe7jmOkGkCuUKaVSRUe1O2FcgYg2dVuFSBVCFNKpcq2eoIE0VGev4yX4vvII0a2O0cqqq9NzvcNuqKV21y/cD1VVKrhXDGN9nrprMVt13RmL0KgGubrS1f7++7prXtb6f9XXXYPB4DxzG0OfqiSpi3awCPlUnZdfBCjNVYmuNcqhaKRmQ4kjAHcP0pQggMNWVpoEZmXSkp0dwzyXjKNZBTaHSfM3drBbUdDfEMV6fcyHmSiiXIhwocBQttaKOam0fhcSE4KrmgMwENfhOyEjubmBMwcFEjIkB3dQQIcZIyEPupUisfoIIglftXnnMDi6iAB5DZGJzc3cm0pUmI0RRcYcUEyLmkiveWvF+ZkKiais0qRoTRVRDiJU9h0hWmcoItQ1sTcBAJEA3dWYOXK8LRJX0X0GsRERd3wFA2zRSVE1DYADUkQIeVG2cByI1M9PAkRDF1MyYiIjr2RCxFn5iphRjES2ljOTOYUCEdjIx865bxhia1PTDUDNJKqEFwOtLNFMcOSFqqhXpL6UAQuBYo4NY6dSVhBACx5DzIGKTSYsOXd+veHriIwkb3A0JCcnc3Soez6paY4Bh5P4ah1AFdUWOzUxUmKhpUi5acm4nLY+cB2zbVqQMOQfmEKONLdnQ3dVGzrcbmBtXkrrWPliRkETUAQIz16JUiCGwiIqUGFNMsZS8yrSp4VmPIRDS2iFf7/Fq3Ky38CjJmWuYMawovNUAXR+QUqq073qqirOup0VXWQHrLIUDMPP+CHgN0VSBsPaW68EVMlxDy7ga6zjYmqy8lqJpH5dpzRajVeKK7mOjrk3/xWIRQlizxer9VHlIRNWMw1UWxxreXkutNXC+FpK0L4tjHe+qdt5Kh/pawq/ZYvsZ1XsLbPX4ax2xny2w3/RfRxdhlX/GqxIK9YtrnHUd4lvJGV83WqtSHVeV7Osr2M/NW6uhOplj2G1li+uKzlvdjzXuu3Za6ppZa5b1pJVSADxQ2H85APjxj3/87//9v3/88cd3d3cB4cTxE7u7u+//wPv3Cp+llG6//XZmvnz5srsj4KRtqwBq2xaZxbRpmxCiisZJ06RITiYS8hCZIsZBNXFbUX10S7Gq5CFxW8OIxYTbSYix5hfENoQYa1yPAjsgiKD7ZtOamjtMJk3lExMQhgbAsw5tiE1KwzAUl6aJzEHNEgdKHJhLkQAYU0TArutCbGLTiqupBCKi4ARIVAWNqnA7AQBHDMQbFGu+SETCkAioSInITWrMNReJ3FRel/m4skvJRKFpGwDIJTchhhDcXA3aOEsxuXtIxMSVh+AxmWol4TFX+0kCMTGgkZlNqUkpgUNRb5mZaRiyO81msyoEAxERE2ABamJsQjID9IQRAwc3j8w1H0JRlIyQQYCR2qY1tzwMDbUcyMxFtOUYYxxyVpXpdGOMTVBDRAyhaJli04aWgQkdmqYuzUBYcbuuWyJR9ZFEdTrdQIB+yAFiiIGJDQyopilIsTKdTpCo5CEAc6gxWY1EiBSNGdMkpZRiLoUMOIQxIZLGWH+X+41mSsw5D+4Y4wQASslEkQOrWJHSxmkMnEtG9TbOAqJkm3HLFAIGgRICxRQBQJyIaWzj6QYIjDxYjrFJsRlyb+ohMhGpGGJsUgSkoR+moUkpFRGx0nJgqqwbjCEwUZ8zq7eTCREv8jI0LYUADkZKAMTBzQNzYipulUrBxOQQwthPeG26VSlQoz/VS0wprdkLdWNXLVKR2jVisT99rUqlKj6qFVilJDOvgnGjvVvlQKXwVoFYPeGK7lThqKvclKo/1gTcemTVcDU3riqGSsxY6+kqc9f+fbVim6ZZu+9VklZRXgVljYLVs63zGGKMFW+otD/GMamrCsGqTaseQsQKkBcRNJ9yw8Ti6m6RQuA0lKEJAbBWQaeVrQnkkGICxDwMxLFJTS6DGcQY0bGoMqS6REspDjxpW1HNZeCQaJUPToiMXFRTjJUPA8DUNDDajBRTNLVFv2xj07ZtLkMeSpsmIUaRoqqTsHIYqCpOz8PQUKwvV0ERIYXkDjEyRGBidzVMdc30pa+qbhiGADRpWwDvhzyJKaakKrkUohBCUDMBSk1iDkM/BGpqtq65IWLiBAAFCWPDzG7OAJPQILFKCaGp78UBJm3r5rmUEDkwFxFRQcZRYGpOqWWi5XIZKIQQmIK7MbdEzMAZMnIkYlMTx8AxACmqc6y1540cCZumWSyXwTE1rYNJEaIYUsg5Z8kpptQkFQXDNsYaiWZ0Ygoe1YS4TZTIEVwxNYHY3AxttPjJDS3UBADHkCaElEsG4yYlB8y55xCmaZJzFoNJSiEEAE/MGLBmsMVIHIIDDGoxxBRiLuJu5FihGUUNHMxdDdsQEdHE2QOHQIRlKIlS07ZSJGuexCkTuQIatHHahkbViBoOIQAPaoHaJjUAoKiOjqO/pCEGMxOXlCZIXPJABoFDE6KqKoaaCNHljpuWmN3UHWNMMcZhyMRxNt1Q1aEfKDYbs6SlmIx83+oardlZlZq/tjyq21x3ZbVc67ZdG1v1i9WmPMAxqL79yJlxb9u2SoYqZ9Zybw181gMqUjuZTKrhVUVWFUprb7na4tXOG20bxGqB1Uvsl07153o/FWmqcPKa51AlZ326Kvfq1q4HV6NwfYnK3Fh/WEVrvbH6rXrDdQLXB1RgYm3arsVs/WKdqPUX9yMFNTGxmtez2axa0msmydqUXLNK1mJ/jaxXDGJNwN0fUqsKZa04dJWHLSsKeI0ico3GrM6wNv33T0XFfesEVlO72tn13uo6qag2M1dKQ52r9ZqpQPWaYocOpkZpzy7f3Nhs2/bSpUsbmxunbz99+fLlq1tbiLRHftjY2EgpXbx4UUROnjz56KOP/umf/ilWY9xtKJlCaGfTrutKLhuzGQIMy44QN6cbuRt2tneOHD3SpKbruzzkzc0NdeuWXSCebcyKyNWdbZ5NZpsb8/lcRI4cOeqmOzu7TdtMp9Occ41mbkxnOJRuvmxSmkzarutVdTqbmtlyuZi0kxjTsluq6ObmJiDMd3dV7ciRo4i+tbUdY5hOZyKl74eUUgi8m/vBbbaxgQjLxQIQNzc3pch8MW/bdjJpl8tOihyZzhrina0tdNzYmEkN+xK17aRIKaWkmJh52S3d4eiRTVHtll3TNimmGtWdTifE3Hd9Pwyz6TRE3t2dM9JsY6Mf+q7rZrMNZu67JQCmJlWzIKVmNp3M5/MsZdpOUmq6bpmLpCYRQJ8HRm7bRs36fmjbhon7oReRjeksprSzu6OiJ0+eELXt7a2UUtvU9NgynU6RqOs6ET2yuaHui/m8bZrpbLZcLvpu2NjYiCksFksEnE6nYjrf3a3chr7v+75vUjOZTvtumXOebWwgwHw+TzFtbG4uFvNhyBubG4Q4XyxUbXNzA5EWizkATKezPPT9MEwm0xhC3/emmpqGGLtlF0Jom1ZU+mFoU9NOp/P5Trfsjx0/2jaTq1tX3WxjY2MYStd1TZNSSkVy3w3T6TSm1PedFJltzNxsPp+nptnc2FwsF8OQNzc3CXHZLVVt0raOvtidu8PRY8dUyu58PmknTZPmiwU4/P/ae7MuR3LsTBCArTAYYBvpdPeIysye+TM9etPR6fnxemxVRoSTtN0A2AagHy5p4apU95zprSR12UMcBt2IHd/9cHGXlHNj9mmaoihO4njd91nrOI6jOFrnZV6WOI4Jxv00EowzkW37JqU8dOHGmCSmDqF5mQnGKefbts16Dnwvpsm2b0pqFHt+Eo9SEYJpFLvdLEoHQRgE/r7v6775URRFkVIK2z3jYts2KSVseLhrS5LE8zwwaWCMwaW/7/tJkmzbBg6tSZLUdU0IybIMSoAX5nlelgVAWSm1LEue5845eAEuuSC+BNCjeZ7BO20cR0II5xxu6wghaZqCMcbz2KOBKINiBuQQVAclTBMsg8Q5d1yfGWPmeQYQBEEF/PvQzmqt53nmnAdBoJQCtzawAzlULBBrAnoEJSCEtFK+5ydJssOEhlGWZcMw/EVoC54wsxmtdBzHQRCu27KuaxSGYKlmjYnjxDk7yYnGlHOutFJSQXV61sYYsGeYpsnz/KIs5nlWSoeBH4bRvm/GWhpTY800TWEYcsbXbZmUjMMojOJ1XddljuLII77WCiPM0nTd1lnrmNLAC5ZtWdYlDqMoivWstm3PhHAO9X3ve17C2LKt+7pGMSWEyGnyfT+msbVGKYUs4plADk3TSCmNY9r3/b5vRVkaY8ZhwIQwxpEzUkmMCFh8zssi0hRhrLT2CA6j2DwM62NGk34YrDEMpkBKY03KGCak67vACxhj4IbPOXfOSimDMIjCeN3WeZ7jOGIJ01qPUqaMJTTph37fNsZT5PCsFcaYJnRZlm3d4zgOwmCe51lrzkUQBP3Qw6ZTWkslMyHCMBqnYVs3SpMgDJSS1jgaxxjjScogDBKaSCXXZc3yzCNeP/bI4TRN96fBTBSFWmslVcKSKIqVVtaYlAtn7TgOQRgmNNGzXteFxjQMI6WUdTahiXNomkbieUlCl3nRWqc8jcJIarVvG0sS66zWc+CHlEa7MXKSYRjmeS6VlJNMU+b7/jCOvuelnMMi94gXRdG2rbuxSRwjjKRSBBORZdu6TtMEOLysy7ougmfEI0PfO+eShDnklFQeCNZtk1LGlEYh2KIgzvludq2V7wUsSeZtnbWmEY1oLKXctpWn3Dk3jqPv+yxNt3WZlyWgEY5DqdRuTEKp5/sSrumjaF3WdVuThAZeoKTcljllDLawUopS6nmeUgoarLU2xoB7LlQhhFiWRUoZRRHnXCkFKbjiOAZQEkJgjMdxDMOQMQYvJEkCF/1wnPY873MMGSllHMcPG7x9B90Q8AdKKShfD1ACWAvDsO97gDWttZTy0BociDpNE8YYqoAepWkqpYQSwBLAWgtBb5RSULUxRkpJKWWM9X0PwWU9zzsMIUAxTAgRQnRdZ609LNYQQlACoChYbsCZH7TFzrljMGF8YP0AZZymCV6A6uAzmHaAzzH0KE1Ta+04jlEUUUrneQbbBkDRfd9BJwINhkPLAfXQBjhRAORmWeac6/s+DMM0TWEwAfaHYQg+BdkNw5BSCu2B8wkYRYAYGscR6DWIHrARh/mCc9Q0TZ7ngehRShVFEYZh13XGmKIoYNhBDIEgi6IoiiIp5bZuucgQRtCjJEmut+s//uM/CiHyPO/7fhxHQrAf+Hgcx/f393EcYbycc0IIQsg4jklEBU+l1pOcUsEpY23brttWniqM8ND3HsZZluPdjt0QeoEQvBv6bV3yrCCeV9e3KKansuqHoR96ytM4Ze3Q7esmsiyKor7rzb4XVemca5o6jijnqZzkPE4Fz3zPG8YBIcRTjhDuhjaKaC6E0mqYxkxkNKZt22z7LrjACE9yIgRXZdn3g140oyyO6TiNel+oEJiQcRx84vEs27ZtHHouRBiGfT8YswvOIz8Y2w5ZmzKOEWr7LkkoT8U4DPO6ZEJgjLuu94Mgz7JJTlopxhjnYhrHSUvBeBAE4zRa40Se7ds2TENCk1xkwzBOcmIpYzRp2sbse5blGOO6rYMwPJUnreUwDFmWR1E8DP2yrmVRLOs6dF1MKU/Fvm/9ONCYpiyd5DjPS5qyIAi6ofeIl2f5PM9aqTCKEpr0Q7dvRgju+37TtQijKi+3bRumMQyCTGTDNEo5VeUpDMNh6HezizTzA+/e1L7vZzzTSg1yyjiPwqgdOudcmZfrsvRDH4ZhnuVa63EaKGVCZMPQ61mXZRn6Qd02ztmqqPSsx2HIiiLwg7ZtEUYi5da5fugIxqfqvKxr3dSCc8FFPwxKTXlehmE4jeO6r4ILjHHdNHEUpymbhnHbd5amURTVTU0wyrNi3/dhHIIwyHg2L7OUMo5pmRdd36tZl0WBnLvX9yiK8iwfplFrlYkcY9z3HSEkzwuHHLStzAqz703fsSQRImu7dp51VVYYk77vECEZF/tuJjn6ni8El1JKJcvyFPnBj9uPIAhO5UnPczd0LE7SNFVaP+QBZ/XYbfue5zlyqG+7OAiLoui7XiqZF4Xve8M4WIuqKscY13XteV6e5/M8930vhKCU3u93Y0xVVdbatm0BlJdlmaYpjuMsy7quA2obhuH9fscYQ2CX2+3GOWeMDcMwz3OWZQAfzrk8z7dt67ouSZKiKNq2VUqBt+vxAsYYIvvmea61HseRc04pbZrGWluWJcb4er1GUXQ6ncZxHIYhyzJK6TiOEBQiDMOmaQghZVlO03S80Lbtvu9QBaTSOJ1O67p2XQc9mqYJwjSGYXi9Xn3fL4pCaz1NU5qmlNJpmrTWkJ2nbhpn7bk6WWvv9T2O4+cSHTORgeGXsabMC+Jw27ZREFZVNY2yHzqWpoKL6+1qjDmXJ0Rw17UOoaoo931r+47GNEmScZzmdSmLAll3a+5JTPMsX7a1axvBs5hSOY5qmXORRXF0u94QQWVeEkLarsWEnKpT09Raz1mW+Z43ThPGKBfZvCyjmgIvyPN8miapZJ7nCaVN2y6zLooy8IOmbX3fS1O+reswDjGlaZI2bWutKfLcIdR2LSH4VFaTlMM0ilRkQkilJjmljMVxXNcNcq4oy23ftZZRGCUJ67p2XmaeiigMu77zPO85aFMYBkVRTpNUasqyjMa0G/pZ6+pUOePuTR2FUZqm67KMckyTNGFsGPp93/Mst9b2fR/GUZkXUsmu75KEcZYqpbVWlCYxpX3fbWZ/fXlRSnd9m6acp6LrWj3roijCILjdb74f5HDgVCoMgpSlWutJS8FFGIR91zmMiqJY5qVpaxpTIYRSepxGzlKWpsMw6EW/nF72fe/aNo5pnmVSSxBzPBXX+5VgnGe5w2joe+RQXuTbtvV9l7BUcDEMg55VWZTOoaZpPN8TKd/2HU6nPE211qOayrwIg/B6v/p+cDm/TEo2bZ0mPM/yfuj1rFOWJiyZhlEtGpbE7X6jNBapmOSktRYi832vru+EeGVRWWeatg38oCiKZVm6vmUsrYryXtdKy3N1ts7VzT0IwlNZDeMopUxZGsWRknJe5jwrPN+713ffJ1V52jdTd7VIOWNpU9fbvmeCe77fdb1DDmC269swivKy+GiaeZ7LU+V5Xn2vEXJvr2/LurZNE0ZRlmfLPHdtyxlj6QNS8jxHCAETOohFVVVRFAFKCCGiKKrrGmN8Pp+XZanrmnMO6We11lVVeZ4HKJFlmTEGQACir87zDKDUti1CqKqqdV3HcQyCAIiplFIIEcdx27bbtp3PZ2NMXddCCM5513VSSrDnbJoGYA3ut4GMbts2DAPnPEkSACWA2aZpPM8ry3Jd177vkyThnEMq3NPp5Jxr29bzPCHEPM/TNDHGoLp1XeH0PgwDlIYQut/v8IJSahiGqqqCIKjrGniwc67rOsaYEAICzgoh0jQFRWRRFISQvu89z6uqSko5jmMcx5zzcRwBJGEKoMFa677vi6KI47hpmm3bqqoKw/Dj4wNjDC/XdU0pzfO86zqtNcAswP75fB6GYRzHNE2hy+M4FkXBOb/dbsYYGOGmaaIoyvN8HMcDk2EKTqfTvu/Q5TzPocsQcPc4G4AQARa7bVvTNJTSLMv6vldKwRx1Xef7PoieYRgopVVVQXtgcuu6XtcVFlXXdZRSzvk0TXqeyzzHCPd975zLsgwhdLvdMMZZlq3r2jQNrLS/+7u/+0l/4bb0fD4TQm63WxAGVV72XTdOU57nXhRM0+Ss5UIgjPu+9wgpymJZlmmQaZqGftC2rXWuyHPieW3TRFHMBZ+1HscxjqnIRN/3apLVqfJ9/3a/+8QrymJZ1nEcwyBIebpve9d3PMtC3x+GYTemrEpsUdd3YRRRSqdxXNdNZCIMw6aujXNFlnu+13YtQqgsy0XPwzhmWZZQerverLOnU7Vue9/3YRAILtZtG8aBMRZF0TSO8zwXZeERv+1a3/fKopJKtm3LGMuzTCk9TVKI1Pf9tu2MNa+vb+u63O93wUWWiaau9bKURYExadrW84gQHGMCiMCFkJNUSmWCh1HUdx1CKGFsW1etdRiGjKeznqdxFFmW0KTru3EcT+cTdmgcpzCKGEvkJOdZcyHCIBiGwTmXCkEwhuryJlVJGQAAJA1JREFULN/XtR9HxliSJGM/rNuaCoERGobB9/wsE/u+3253Lvj5/FLfb/04VmWZ0KRuamfd+eWspGzbVmQZS1jX9/OsgeiM46jnuSpLu+/dMFAa81QoJcdxEpkIg6Br2t3ZLMsCP6jvNy/wq+okp6ntuyLLkzQd+gGOy9aYvu/9wM/zXCutZhWHcZIkSj8Odr7nTVKCws9Z2w99FMU85ZOc1mXhXIRh2LWtw06IzDl3v9dhGJRFoZSSSudZFgR+13bG2SzLjLHTNAZBwBhbl3WcxizLgiDs+85ZW5SlNbZu7lEUAzOTk6QU2qPnZaFxFIShnKS1tsiLdVuHvk85pzEdhn7d1jzPCSb9MIBCwlnbtE2SJGnKFz1LrdM0jeOobbtt38tTuS3r1A9xHOcim2etpUoYC8KwbZrN7JfL67ov/dADrg3DAB6oURS1bWuthT1c1zWImWVZ+r4HfQPIgPP5jBBq2xYEg3NuGAbf9xljy7IopTjnYRgCagOVhBIAdECHd8ghqEJrHUVRkiSAuSCHgBBDe7quI4QURQGnc8ZYGIbDMFhri6Kw1nZdFwRBlmUHWQf9B0g1hNA4jqCc2Pe96zrANUBtkCIAYZxza+0wDKBAGsdRaw0ldF2HMc6zjGACbSvLEqRsVVWgkAAQNMbUXZvQtCyLoe+11lEcxzRWk1zWNcuyMAjuTeN7JM8LOU16nnmaen4w9L0xJi9y0PsijMuiWJe1rm9CZEEUSqn2deVCeJ7Xdh2ytjqd9n0fhj4IwiLPtdLDNKYsjSlt29ZZW1XVssx936ecJ5S2Xb9ta5ZlcRQdQiIIwvv9GoZRTJN1mdenVck0TvOyVFXprBvGgRAseGbN3vV9nNCEJtM0retaFIVzrmsa7HlFXiDk+mGI44invO97Pc+c84TS2/Xq+37C+b6sSitKE1CDSTmV1cn3vK7vjDV5ViDkhn4Ig4AmdF6WeZ5ZkmBMxnHwfT/L82VZxnGMwggU55OUPE1Tztu6nue5KCtCcNt2vkdSzq214zAmLImjaJIS7g0Smtzrm3X25fy6rdvtfs2LXKT843rdt/18eUHOdW2LEa5OJ61V3/ck8KqinNU8jSPLeBiEwzja3YiMO4fbpklYklCqlNaLZglLYjpNo3UoYclzBZI0ZYuelVacC8bYOA1az5xzhNA4jBijsqqWee77ngtOaTIMw7qsPOO+54/DQDyPp3zb1nEagyDMsmzWuu3aIi+ShNX13VhbluW6LF3bUsYEF8u6SKlAjTqOw7KunHOP+EPfBlGYslQrpfTMeJrQZOz73RiRCbObcRwQIaeyUkqP0xDHMUuYUmo3O+fc7qbtuyiKMiG2beu6PqJRylIt5SQlFyIKo37oPc/jaTrPyyQlT1kc00mOy7yWRW6d6/seY1zkBcK4rmvf96uqGsZhHMa8yCmNgEzAHgfmkGWZUqrv+zzPfd8HtRxcRg3DAGpCOG8DVVJKSSmzLIvjuK5rhND5fNZaN02T5znn/Hq9wgn5ednicc63bRvHEagbUCXQHAP5E0IYY+CUDgQUDuHAzJZleXl5Af9+4JpSymmakiQBlSoQZaC2QRAURTHPMxBBACKEkBDC87z7/e553ul0stbe73ff9yFkltb6dDoB2TpKANWyEGJd17ZtDzoLbH7bNiAbIG23bcuyDKozxoCauWka3/cvl8s4jocmG04UoEb93P2+74HbgA4CQPtA9XmeYTqAmAJ79n3/fr/v+365XEDtnSQJKMv3fYcRPrTIGOOmaaCEeZ5B7wuSBUzd9n2HSO1ZloHSJM9zxljbtsMwnM/nOI6v1ytC6HK5TNPU9z0sg2EYAPZ93z+kDJwuQIkDgqMoCt/3oTogyvf7Hc4nfd8Pw1CdTkkc1fcGlii0IUmSPM+HYQC1N2Psfr//x7/7f37m7uCcf/36dVmW+/1OKX27vAGEXS6X0+k0K70uy/uXL0mS3H58+IhcXi7bsg7dwHMRZ7yVw4KMuJz2gFzb2mNx9lqpfbm2tyhj6Ut575p1mb+8vcZhMLRt6HmXl7PZtq5tRJp+/fK+L2vbNi8v5+xU3Md2I/b0y9uK7W1soyxNz0Wnx8ks6Uvhp/Q+ti70Lr9+QdT/fvvh0fDlT1+mbWlkn11OAU9ufbP5Ln89O4/0bcvi+PXlsm9b19RVlr9Up75t9nX95cvXJIynYUhYcvryNizTsMj0XKanopunYZmytyoQyX1sEQ0uv32dFnXr6uxSJaesnnppV/FSkSS8tncUe+df3jENfzQfXhq//Pp1nGUre3GpfJHc+nrBJn2pTEi6VSEaiteTstu4TMX7Czvl1/6mtvnt//rVZ7RRQ8Bpdjkpu427DvOUFqKb5bTPtMo8Ftdja3x8/vo+o/1HW6fnIi74fWyVXfjlhGnQqNEEOHs77QGpp1Zcquz1XI9Nr4bz17ekyr53NxNgfqmmfekWGReCX8pm7MZV5q/n9FzUYzdt8+XXLy4gH+2dFjx/u/Sr7JdJvJ6inHez1Ggtv1yiLL2PDUlp/v6q0V6PXfF6Tk75R/Mxu5Wd8t1HjRpIGhdfXjTaG9XTnL/89lXZdZhl+X6JC/6jqzfPlV8uK7aNHOJcFO+XYZHTqov3S5Snt7ExIbn8h19Q5F2bKy3S05/elduGRaXn3Be00eO0z+JSuci/9zWm4enr24bNfWj4uWBVfu1uNiCnP32Zsbn1dchZdjlNZu30SEtx+uWLNMu4qtPX1/RU1kPrQnL60/tCTKdGWmW0Ev2mp33JXl8CwW5DvRF3+uXNRf61uQVpkl3O0q79pmnJQ5G0s1zt9vZ68Rwaui6OotfzeZ5V13XVqcpycb9fEXLvl1dntqapgyCoqgouCouiyPMcFBLv7++MsbqugyB4e3uz1oLOA0jqPM9vb2+gIPE87+3tjRDy8fFBKX19fZVSKqXe3t6EEG3bEkJABgDXvFwugPtCCKgCY/z29nbcReZ5vu+7lPJyuaRpCl63X758AW1KGIa//PILiJzT6QTKAOdcVVWEELgIe3l5ATKaZdnlcgE18+vra5IkgNpFUQCLzbIMLBYAiLMsa5oGY/zbb79B77IsO5/PcFv38vISxzGA8tcvXwI/qJsavBcmObVd+/b+BlpkaI/v+13fJWmav1aNHu9jGxciu5x6NU6rOn1989L4e3cP0vj09X3zXDdLWooo5+3UrcSWX199Tpux3QP88ssXZdZ7X4vLKX2pei2VWZNTiVlUy975uPrT++7jeup8nlR/eh0Wde3u2eUUFfza302AivfL5rlGDUmV00J0i5S7FpdTnPMf3X0ya/WnNxQH327fPRYXXy7SLpNZ4oKHImnkoN1afnmxkVfLzmfx+//9Hzbibl2dnovscmqmfnZb8f5CkrCVvY384v0y4/3a1XHB03NZT103q+rra5yl3+8fKPLLr2+779pFRkUal7xbHnvcS+N6ao2PXn79SpLg2t5Q7KUv5WiWaZuTKotLMazShJ54PWm3tWqkhcjfz9M2t2oq3y/ipbp3t9ntpz99QTRo5IBiP32pNh9d+zrMGS3FsOphVeJyCgT7fv+BAu/ll6/DMtVjk7+d41zc+mb3UfZ62jz3o72txOVfLjPar/09zNK3337tF9WqQbyekiJr5bASm7+dHQ3vYxuKJHs9LcSN+5xdzum5qGUv9yV7e0E0qMfWRkRcygXt3TxGuYhyXk9dp2X5/hJn/N7dUeyffvkizdqpUVzKpMpbPc5455fS50kt+40gcTltvruNbSjS8sulnfpG9sX7JczS+9RuxOWvZxuQemjDjGWXU7/IRg3Z6ympsttQT5suv1xMSK7djbA4u5yHVXXzREtBS9GqHmAtFKzVI2bR+ev7uOpmapMqS6qs06NGGzsVXhrVsvPSqPr6unru1je+SE5f34Z56tVY/fIW5Wkje0yD8surRnu/TFHO4jIbNj1pdXk5ZymfhsFD5E/vX5Cz148fnNGXqlLTuCh1Koqc8/p+9zzvfD7DrgzD8P39HW6rTqfTy8sLGD59/foVYCSOY9Da9n1fVdXlcoHj9K+//go6xSAIXl9f4ewEOWlBj/j29pZlGdDrr1+/AtFJ07Sqqr7vpZQvLy+UUtA0vby8wFmXUgoHYK31y8sLqFGdc1++fAHcY4ydTicp5TAM0OBxHLuuA5i93W5RFL2+vsJlVJ7naZqClcLpdALeyRj7+vXrtm0fHx9Zlr2+voLe9+3tzff9ruugBDgbMMbO57OUsuu619dXQHXn3Pv7O1yVCCGqqgK2ClpSKA161zRNmqZfvnyBBldVBV8SQkC1fL1eKaVfv34FZs85f319hSP0ly9foMG+77++vu77Dpra19dX4OVvb28A+57n/fLLL8CkIfmDUgqUFDAFy7KAUh+u+97f36E95/MZ2gMHGLBYSJLk7e0NqrhcLkVRQLKJ3377Dez0fN9/f39f1xUUw3CYmef5fD6naQoqj7e3N2DzVVUBc53n+XQ6RVHU97219nK5+L5/vV7TNC3LEjT97+/vNI6v17vne6ConqaJUnq5XLq+G8Yhz/Oqqtq2HeXked5P+gteKSD2qqpq2qYfhtPLOab024/vZt9fX17Xefn4/p0lSVVVcprut3schmEc1e1NLUqUAnuubW7ERzznbVd3XZOdypBG9/t1VjLLM+J7t/tt2ZaizPWsrvcPlsYJiz+uP0Y55LmI4uDHtz9bbLOqWLelbWriY5axrmuUHEWW+qHXtPfNrCIX86LuTe1FHmXxKMdhaNKMB5HfdY2UQ15mDtvvP775AckyMU7DOPZZkdEk/rh+N2Yvitxhe29uxmxpmig5tk0dRn4q2Dj1SkteCOzhe3Pb3c44Xfd1nPqEJ4wn49ANQ5sVWRD699uHH+DqXE5yrOtrwlORi/r+ox+aNOeYuOZ+W7c1K7NtX+qPH3EcFFXeNLexa3guEEE/Pr6vZs+qHBPXNLcwDBKejLLv+4YymjB6vX5fZvny9uIHXl1fsU9OL9Uk+7a585wHkd+2tVJSFJnn4+Z+RcicXk5STbfrj5DGcRJ3Xd20d1HmxMcfH9/3beFZat1++/jueTgrxP36IdVj0H58/90iU72U27Zcbz8iTpOUdl0zDG3MkogG9f1jmWV1OTlk7vWVhCQrM62n+/Uj5SyMw6a5G2N4zo1d2/bmiONZKuXU3K9csIhGP779ue8blqXEQ99//8/YRxENlZZynsIkYpz2QyPVkJeCBPh6/U48lFdZ295v1+8xo0VVSD2OQ59maRj5TXvXsypOhbF729aMJ/By27eiyBKeXD++WWeYSJZVdV3tx0Fe5UpP9fV7wmgYB9+//dM49XmVL+v849s/IeKYSJdV920T0TBO4r7vJjXyPEXY3m4/PJ+U57Lv27q+xiKpXsqub/quoSyOk6ht70qN53Nl9u12/aA0zHLR9M0wDdW5NMj807c/b2bjhbDY3po6phT4JcBrHMcfHx/GGKCPv//+exAEIDnquo6iSAgBl1/n8xlsHg4lRF3Xp9NJCHG9XkEpu+/77XaDI+66rvf7HZTEXdcBhAGOwP3aPM8fHx++78P1IvDOIAi+f/8Ol3FSytvtBjqY+/1+v9/hyN51HVhKOOdAowM5dI770I+PD1CQeJ4H6VKFEPu+Q5eB747jCEqjb9++gcbidrtdr1ewDAO9OOhjQGOR5/myrvf2MSYg9ljCwGpi2zbQ6Nzvdz8IirLo+nbo29NL5Yf+x4/f50WdXi/LPl9/fEfOUBZPcqjrK+NJGAVNWy+rEjm3br/++BZEQV5mw9h1QxuyOKbR9fp9WZXImB/g9v5hnKkup82s9f0jisOE0fp+66f+9HrGHmqam7GGcbZsqm5ucRLRNO7HbpwGkQsvwHVzdcjkVbbsy72+Ih+JQoxTP019RMMoDtuuWVadFcI6c7/98EOPpvHtfm36mpd5SMPb7WNdZ55x4uP6/mGRPb2etn3p2pqmNE2TprnPqy7PhXHmfr/uZstOhZyntmsoi+Ikhj2el1kYBffrd2N3JlIph+vtI2JxVohJjePQhXEQJ1FT3401PE+3fW2bOgi9hNOub6QeRZ4iYj+u35VSPOeI2La57W7Pq3zd5ratGWdZnrXtfdZTURWI2Ka5k4AU51Ip2fetH/lhHPZ9PaoxYRQR1zR3hFFWiN2udX0VRcaz9F7fhr5LBAtpcLt/zNvMs9Sgvb5f/YCcLqeua4a+FQX3A1LXt82s5Uu17XNT3xx2RVUsi+67JiuyrOBte1sWVZ6K3W4f129xSotTPqmxbe5+HIQ0auqblGOaMuLj++0HQrZ8KZUa6/s1YZSyqO1qPUuRC5rEfd8oNfGSw3zFnJ4uL5MclBrzMsPEfXz8jjx3upy3fR36jgSEZWwYu3EcEsEiGtb1VWlZvZS72759+ycS4CRNhrHrunsqWJLSaRqUmlLBiIc+vv0eREF5Kpvm1tyvWZmdzmXX3pdtyc+lQ65t691uSZpMU9/3TUhDJljX10qO53PlEfTt+5+R3asiW2bVtXUShRnn66z6puGMijS53W67MZfLBSEEZ2y4hoYLd0rpt2/fjDFw0Q+YI4Q4NHCg+dv3HVSnQLyAHB9XW3VdA20yxvz+++9g+NT3/fV6BasASE0AJpr3+/0w5arrGkynrtfrNE2gZwXLMQAlMAwD9gxKxzAMv3//vm3by8sLQujbt29hGAJqNU0DDQbN8QFroGedpgkMAICNTdMECYCgd2CE8PHxkSQJmFWs61qWpe/7v//+O8a4LMt5noEIZlkGdiDQnrquwRgMrNd83+ecg9Y2z/MgCODlsiydcwCMaZo2TQOqZcbYn//8Z1B7G2NgCqA9t9sNTN1ghGHQbrcbWE0YY9q2PbospQTN8cfHh7X27e3NOdc0TRzHMEfDMMA1Y9u2YMYA/BvYI0gWuCT8/v072ITAFICMgPmilAohbrfbuq6Xy8VaC3LhcrkclwmgWoYuB0EAI/zy8gKCjFIK3QdmD5pj51ye5fu+g+EcVDGNU1VWvu9///5t27YkpjSKfxo/gLfj4awNRk6Qf1VrTaOYUiqV3JYtih422sZaxpgjaBgHz/dYyvZ1V1KylPlhOPUDwohxvm2blirwvZTxWc/LMlMaBwGYXW9pyjHBYAfNErZu27xq4vuBH+zWWGPDMAwCbxomhDDjqTVGShmCz5CU1lqaJMihWWuMEeN8XZZ1WYIgCGm8zsuqZ8ZY4IegmgJjAKmk7/s0puu2aq2jMKJJPE6TdY6lzCEsxykIfZYyKfU6L0EUBkGwzLOzjmd833allO97NEnWdQPnFUrpNA77tqdCOOe0lAjjOEnMts1q9sMg5alSclvWBByM+gFjnIp0mZdFz5QlYRxppRc9JywhvqelctYmaYqQk+MUBH6aZVpprXTCkjAM5TRu2x5GIcZ433ZCCE3ovm2LnoMojClVk9y2jbIEIbToxViTF8UyL1rLmNIwDJd52dYliinxPD1J4hHG+basWsk4SaI40npel9kPQgiI46wLo8AYuy5zGEZhFM163veNJgnGaF1Ws+8iz7Z1A9+CmNJ1XZZ5DsIwDKNZ6X3fU8GttXqSnu9FNDbGbPMSJdQjnlLKOpewBBmrlA4in1K2bZuapoQlfhBO/UAIpmmKEJJg2J6ydV1nqf3AT3mqlV7XNU0Zxt40jpjghCXOIT1J4ntBFG3gW5CwIPCmccIIUZZYA3ksCUu5Vmpft4QlQRhOk7T7TlPmnNNKeb6XsnRelllpmtAwiqZxQA7RlHnEG4fBIcdY6pyT0+R7fib42I/WmMeikhITnKbpvDyc0jzPX+Z5W02WCeecUgoMwsCc6/C9AK/qOI4hM/nh6wD3X3BLdfg6gG8BqBaCIAAfuHmewb9hXddlWRhjh2MEsEa48wLXgeMFKSVYDoCTCqX08JaA6uAzWNGB8wH4xEB1URSB/hXwFxxEwPfiuGJTSq3rKoSw1kJQTHCEhQjTYE0BHiQwPr7vg68DWFfDRSo444J/jOd5YRjuZp/nOQxC+nRXSljiB/44jZgglvJ12xalPD9ggis5LXqJaRzG0ay12U3CmLNWSU0IYoJv86KVTnPhed7YDcQjSZJs+6al8kM/oWzd1lnpKI4SlspJrsvChcAemvoRE4+LdJ6PXRAu82zMnrDUITdLZZHjXOzbpqSKaEQp1Upv6xpGsR/4s1LGmpgyQrCW0g98miRa6mVZuEg94g/DQDwCnpdKKt/30jSFtkU09oNQS2mN4ZnAiPRd54cBY2ye53WZgyAIw1hrZaxJU+YcUpPCBAmRzcuiRhknYB8y7cYkaUqwp5REzoZR7HmemqQfBFEcbtumpU6SJIjCsR8IISxl67YuevZ8P6Z0Xdd1niMaU5rISa7rWpS5tW7qez8IaJrOSq3LkjDm+8E0joTg8BFAavV93/P97ZFPh4ZhqLS2+56kqTG7Vtr3vZgm1phplGEcUEphtDlPgyjq6454mAuhl3mWOo6jhPNpGLdliZKYJokcp31fE8adc0pOYRjShCkpzbbFjCGMtFQYO5ow55wcJUi6dd20VIyxII6mfnDOJimzzmmpfM9jnM/LsmgdhH4YxYuenTExSwgmcpoQRpyLdV1nreMkCaNwHCazbwljYRAM/YAw4jwFLzqQ31LKRc80ZYQQrZQ1lvEUIaSlJISkQmzrpuTEUkY8T44TQigVwjqrhtEPwxi2ybKGURjFkZqUtSZJU4zxNE6eT0qR60mC7y+NqF70uq4sYc45pTXBiDG2Gyul8sIwYYnWWmsN594DBEB9dsDIuq6UUnBQM8bAHgfrBUAGsIsDR6PDx0spBWFbwPkVUAucX+EFgBSgd4c7l9Z6WRZwKQMuAc7BYMFFKZVAFSg9kDNNU9AOgqkx6DsPhzC4iIfSwGHus1cWACMEl4U4u+AEdvicgbMyWC+AShFeAGA8cA8MFeCuH6w7wKuPMQZQDz5n4D0MpsYAjJ9djQ+/N7B/ODybwZKBUpokCdikQXvAigy6DKgODQafRfDqAxdAgFnwrgaTqgP2YTDB9fnwtAYPNrBkQAilabqu6+GsPM/zw7jROYgBB36Bn70eQdLB+gHPZvBN/DwFoAqRUsIcHXIhfiR6XAI/YM9oCkmSBGEwjZPv+wlL1mWd5JTQxFr793//9z/pL0TiPOLhYYwdRsg6hJBHCHLIOousJZhYSGADbxPiY7LvO0aOEGQsZFxD1jmCkUMII+ycQxg5jHbI3UMQIdgY9/jeIoRQ4GPrkHMIWec/kqIjB/nbMDryzVv30FVDAnWHEGQFM9YhhHyPGOsgKz0iyBrrEEYEGYQg0Q402jkX+MQ6Z90j9RNGCCPkOYQRen6HyPNlyDnkHknhEYEE7hgRjK21UOozgxRCCDmHnXMBRJwx9ijKukf+J+ecNY4QjBCCBvseds7t9tmjZ4Ho2U0PY0wwZD6DbzBCj7Tux5sYE4ysc74PgfosIYhgbB3GzkHt1jmMECEYE2QNss4FPjHGWod8gpzDxjmPYELwbiyklMIYOYcQhuRoCGOEMCKPsKPuMS4YY4Ssc56HnEPGIvyMGPr4CbyIEKyKn2NiHSHEI3jbzXN+EHKYQC0e2Xf7mC+LjLWEYI9gs1sozfOwMe7zekA/q4AljJ17hA3ejYFmPFcvwghBqjbnEPGws85Z5xDyA88aC4sKo58/gYUJeacQcshhhB3BGFpDELLIwRLFz2XqMEYEGYccrCSMCCbOWi/wrHX2OaHYPkL5QuQXiM4DYXogNhBEAj7CMT4n/DnIz21LnpmrjpehWPdcJVAFRGeEqECf/+QeQV4fIRs/F+I9wmDv8M3RMIjCc7Qc2va5WGg8fIDQaQA18PnzC1Dg5xCe8PkIuIY+PdBlCDmHHcy+wwgTyC5mLcEERh0hRDBxzhHkfIIhwTlyjnjEWOecQ87BIncIeQQ5hJDDCDn7mFMAGUjE/pxb5w78ecACRhgh82n2iXe00LOP1GXYWeSQIwi5YzOix9bAR9cIQghDLOrH8gP0wghj5Cyyn14mBGGEkMPWucf+f/4J4gZaZz3PM9Y5awlB1mKHHMaAOchYhJwj5LkZMcIAzseaxwgT5Cx6oKNDnoetddYhjzwkBSSlR0/YRwjDPiOA2M9N99wT0BcMw44wtrDRnggDQ+eMswgCLmJnLfq0DRFCvk+sRc45QhAmxOyA9Y8a4U0Pw4A77GFrQdpAIjtEHkLFOYcAajAiCCGHLIat7Fzge+tuYNIgUru1j9oPTIB1aJ3zng3+2UGEMEbEI9Y45xxAEHLIWOvBEnXO98hDDj5B0h5j/mktEYwtcgRjWHSwHh5iGiEQuw6kj4OdhTHB1jpr3TNEOHrOH7IIkZ8jiR/zgx9wulvkrMMEYYQh6jnIC+cAG7F77rsDSbxn9NYjGiP6hFHHc0TmOlDic3DZz5/RE168Zy5uAAGIWQsb/9mrR8auz5hw/AkeKAqq+CNAfYZZuAA/ij1++7lA+O9R8tGLAw/RM675gU7Hm8658JmV8yjtaN4xaPhnsO2fY3X0Dh7zKWWmtRaCFhxR0iDQzVGUewZHgzl6sLtPDf6jcDmaDSMPtRzfB89cJ0dRR2kQau3zwB7wfqwB/AygBm0+GuY9w0s7546IbMdIoqeAwM+AzcfsH4IDlrVPPOjRIwy/MQQTj3i73TFAk0MWuf/3P/2nn3F//6KaY30jhLZ9J5gQgi3C/xxGsDHWIfuA6Ac+PXapOdgSQtYhCyzEw9ba3TjPw9ZhZx1QPWMcEF1MMDDCB9BghBza3XOnwrL7RHcs4BdCCKHNWIwQxHK3u4NkDJtBCINEQY9SHNq2gxoiBKDxFCpH4dYhhBzIP+wQfvI291xVm7Xek3xDg4HMEIIwwuu2H611x8+d2/bjZeeeNe7m83Y9Pv6Uc7tz2Lij18DCnfvZJIIQdg7o6LoZ6K6xyCLnedghbJ3znrDtHHbmUdW6W/x8GYiusc5CIoif4/D4IX4MONl3i5DzCHEYWefwk3hBCmFYG/YpI4BG4Od8PXuEEHIeQs65df9J64FEOkwcQvtmjrYBIhjrPi+P/Tkm6HFiQs8jGyLAV5AjmDiENpBkP7uCCMIOoW23HkYI4W23RyO37cHFf0LdswqLkPecJoLwbp1BjmAEoezt85D1XEXYIbzvFhNEMDLwY4wdxvv62KvAqR1yBD9g9DPUwk58kLwn0KBP8ISePBJw4SCU6BOofWai8MIBxwA6xzcHshwof1RxhIU/kNc9I7p/FhLHDz8j+/HXA84eUAWj+oQa+4zffigVyDN3BgDrZ6Z+/IuA+OLj2Ogwwvj5MsHkASIIY4d26zACAof23QC3ME9scbCFMSKfDmzuuYWfs4cf2V4wcu7ngdw+SzgeY5xDjmDkEWyeJ+dHg/GzUeiBnp/XG6zbB+/5hBIHiflMv4xFQFAeWVqepcEw+R5xBsPiR0/qBEXtu8MEY4ysA7WFe/TCOPupCueQMwgjRJBDGFmEtuem20E58jxtflq4DziFMfE+N+lnX5yHkHWfmMpDpCDn3GYcQQgIn30cIfEjnQPCGDuzW0wIxng31hrjPY+mP7UcCBmHPIwdcvaJro9xdogQbOyDrQJB9zyEEd4Nwgh5BBmH5m3HT4G92c8T+1gJ7hMa7P8cnEHwWYfMbiFEtnGOIEw88uQ+2DoH2HvA7PFb5H6uB/cYRmzcQ0TCOHvPId2fkstahJEjhGzGIoN8GB9r8XPhWfRTxj0xEAHow7bZd/ezh8ghhHyMnEPrbgn5KemOMOSwx4987MfW/gwCnz+454M/Zb0BsIIovEeUcd/3rbWQVQH+egz+Z8qF/vAc1OUATPQEUijkYGPwJ0iaAA9A3OeKjur+opbPVf/F2f6A3M8U/2gtMPh/sYrPCP+ZDX8eQPKMCny8AC8f43McEv74QxjMA8APqP9MKA9CfDQYpA/M7zGYkH3pULUczf7MVo9B/iyGjjH53OZDtQFQDy98PiR8FojmmXzkLxp/CBRgkeixcezxwRiLEUIEO/uzOATW2X9cRn/15ycD/is35G/P356/zoP/8Py1W/Rv6fnD2P1t9P7tPQSTv03bv4Pnb9j13/38Txy6/8+iDuX9/wnPP/zDP/j4mRXpf8MC/W+fov4bb/7XXvvb87fnX9vz+aj6P1jUH8Hojxvh3/fW+O9GjP/ab/+VDNe/uEj+RT3T/2nPX1xxHBqmP775F1/+Kx+6//GF90fF5F/r+f871J9Vv/9rWvRv+DkG51/80+ehO/Sv6J/frYGW9HPaZPTcO/D5uDw8NLKQZ+7zFdzxqz/amP17nTVK6X8BOzT4kfdkOdEAAAAASUVORK5CYII=) - -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 <<<...>>> 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,iVBORw0KGgoAAAANSUhEUgAAA5QAAACcCAIAAACP73PvAAB7z0lEQVR4nOz955MdSZLgCaqaOX2cBCegCSBZdVV118z2kJuumt2Rk7mTO5E7kbtP9+HY33giK7s9s82KdVUlRSZ4AMHjceLczUzvg7948QJB4IFMZAQQ9pOUFESEm6sRNTN1MzU1JCLQaDQajUaj0WjeB9hlZ0Cj0Wg0Go1Go8mLcdkZ+JCRSRSnaULMNK2ibV52ds6HiGQcRokkNFzHNkz9XfO+IZIoSpKUuGVdfX17a6RIkzBIFeOm4zoGY3jZOdJcAYiUiKNISIVmwbFM/nbjFwGoJIrjVBB3LMty9Ayp0VwIUipNwkQIYLZtv3VXfCPXrmsSkUyTRCpC7lgmf5dT33j/xaOXmxtJ+faNu397f2k2E1KkiZCS6Eg8IjJuGqbBEN9dppRIhRRSKSAgAEBAZIybFsqo/fSbx68GqbX4y198NLdQemd5uD6QUmkaSUmAjJmWaRz1YyWlSCOhAJFxy/4xNHG08+zhi5cvRe2j2x/9u1l9e1MmpRCplIqACAABAZlhmKbBf2iOzpCWJokCxk3bNCallmmSipSQG4ZlGucOdv6w9/xPf9gZ2421T3/x85WC+y5yqbmakBJCCCmVytzdEBAQuWFaLPFbLx5+tTeM3ZW//eTOcqP4dgIAxtvPHz/b7qS1T+7dvnN/4QflVkqRiuM9ixumwd/pvKO5jigpRJoIAs5NyzReMyIyVUyzqYib9hkPHNdV5Ib1Froqomj36e+fHwywfu/ze/cXas4PL91pXDvjVcXB9pMvvtn3AnftP35+e7X+dmNcLtIoGA767RTn4/RYHlTaf/XtV68OWqFCAAACQGBWqbZw56OP7zZt+03z8aGn8gXNXCWEt/v0+fbL9shLhSIAQMbd+sL6g0/XGjIcDbrtvipWpFAXea3mLCLP2/juHzd7njIqCx//6v7KQuWwxwX9g43Hv3vVF4bbWPnkb+8vlZ1zbbapc/rZbS7T0PdG/dT0Y5E7i0rEw73Nl893u30/TgmBM9ss1pbX7396cwHxR7cM42H7+aOvH454ceH2332yXnJMAFAHGw9fbH4/tlZv3/75x+tVgLP1WkkRjofDoWs3UqUIclWN5kNAiXS48+LFi71uL0hTIgBkyAu15Vu3P71TSoNRr9UZiXo9VW99kIOAEs8btLs9xeNY/rDshoP27uajrfYgSmMJzOCmWajN3/78ztJc6drNvJp3S9jZevb0q82Qz61+8jf3b1uzSw8k4+He5osnW+1WgMXm6oNffXzbMmb35igZdve2H79qdcMkEQq5YZhusbn2y49W5ssXND6lkuNhq9sbmOaaUO/OlLh2XYhIxf6w2x+Nk3qc/hQ2GgK+PqkSpeF40O+1AnBMw+SMlBJSDkZekCD87N7dhmufOQ1LooNn3+1utxJn9e6t9cVlN2dGKE1GG0+ffPeq242IMcYZAimpUnKDkBNJyqwAPM900FwEJYU/7PT7Q4GDdHt1rVapVBwAAPL80db+3l7XB7OI1VAqdY4DOim5u/Hdq4Ne4KzeXV+9PX96k7uV5up6ytPyci2vTog43H726OuNnZaXSmCcIQApSGRpTtI70QOVJv6o3+4bsRup6WnROBwP+wdDu7j0RoPBdAoLN+9AYJYWSoYJoA42vts52AzsxfW1BzcXilp7P1AoiYYvn339dPNgnBJjjGE2fsVQnks4EU7WjH7oFwwdjoM/7EVhd+fl46+f7e35iURmIAIoYoFwb8RCa6jmx0alkT/s9nzDqodHx/AJIOrsbL18tfWq1e/7UZAaFXP2gSxtf3fzybePt7fHiQBmZLMA+oExF4u3+g78UXrQm7h2xisAILLMdLvEdRpEhoxxt3L71vqdhSoIf9Deevyi02/v7LZvrpVc2z4rqQIadw52N7aicmFlYTm/zCQV7d39/iDE0vKD+yv1hkuKSElmuOU5k7NEB554B2TKBqSCbqsfrjQqjgWg/PG40xqljHHMZuFzIaJxr7W5teNVCnPzZ/oDuPWlW259hQzbzvmtLIRo7+0dtIaRUb91f31xsWKiUkKiVSxX8d1YgYjIGGfsmLMqIst++eY+6RRKK/c/bUpmWK5lcpLe4GB366lXgmrz7rvIsOZqkKZJq3XQ8SIqr316a3mxYhEBKcmMUqXBjMwN6ofyoyl94g339w+2R8KsLX90Z225YKCSiog7jYqjPV00PzqYGTYnxlDl9dvbu622YKZpWhJff4AIxsPWfmurl2B98e6t9fWSyUgKIrTqFefqnp24jsbrOSgZD/a3tjqjceYVa9iV5vLKfKNZYKCS2Ots7nQ6XpwSARp2ef7u6mJRDrd3d9qByLbhuemWaws3VxsVy3jzMGi4c/MrH92cAwj6btza6YQijkJSCsLuzuZBpxOkUhEActOt1BdurlZsb+/Jy+2tQZgy8lrPH6bd3vzSYrPseNub/TBMFQEg45ZbX11fWqi41kzhgMIkJUC73Fy9dXt+/ph9nIYAgECkRLT38kVvl8JQSLBKi4srtxarTMTt7Y3tgRdOtuu4XWgsLc2vNIoUjNs7zzd9tEuNMnkeFFYWFhesqN0+eNUdh6ki5Faxtrh0Y732Bn/GD43DRRwARdLrdPreQn2+aZHvjbrdXnz4tUAARBB2tvYOdntBooAAgJnFSnNlZalujndfvHzRGnqSSb/14kni9ReWlxqLzujF85HP3fkqT0LBqitVNRj2Wy1ZXF5srgixtbHbEWZ17uZHS0U37TzfPNgfq8Li2try/PxELaSiURALRXZlfv327RvrZZxmmxBBJsP2zubBYJQISYjcLNUW1pYW5os8Cb2dzWcHPpYadTMNIqysLs3Vmb+3t7c3CqKUCA23VFteX18sGuYFDAJEiLzh/sbzXmAUqi4mcRhEIiW0y/NriwurdRX6BxvPepFVri+t1KOdza39PV9yGXS3n/0xHszPLd69tVTW668fHIrIT1MCdEpzN9dvrdWs2b+mPgAAIonE39l6PtilcZxKdCpzizfXF8oiHB5sbvZ8P5EKMre/ytLa8nK9aIOI/f721m7bS1OlCON+J4gJDkdHErHX3tve7Qd+qgCYVagtry8tV4uW19vb2X4RYaFYLVPok7t8c7lpm5llGsfCD1Nh2M3m8ud3bs9NDFYiBYAAMhi0W1ut/igWkoAZVqEyf3N9oW4b6B1s7R5s+rxcciskxqwwf2e5KcP+3u5ud+ynUiEz3fri0sL6XPnqWhaaq4LdaCzcuVdYVSIZth5t+qc8EiRJICJuLzQW7350+7abmYVECggo6u9vHxy0vFQqIgBm2OX6wo31+ZrBAeJxu7V90OmHqSQAZhfrC7cXXZ4NvyIe7L36vr8lwjQh7lYX1lZXFwqAlAadvVftXj9MpUI0nMbiyupCo3ZBbdbG6wwiCtub3z9+/Oxg5AlFBMjsUmM8vnf/89tNKxpsP3/01Ua77SUKALlRmGfzzXkz7m9uPHnaT2U243O73BhK4+cPlkp55s9D44ahZRoc8XDTVA4OtjaeP+nFBEQK0HCq82PFP7qh+nu7w2EgJELitVvBKCHHNllx7+XD7aGXSABFwE2nPlSc3VldKU6/8hmgyQ1ESrz+7taOENVipVQo2LNGNhIJv7/5tJskcRikitm1G7FRblbqIunvbjza7g0TAiBF3Co0bkbKdu6UY7+79ezbVsoLzbIaB/Yis1GlvcdPXzzt+bEEIjTc+oqHxqfrS0XzIqbM+40k8kVKRMi5oVTQ73T9+ZVmLfWG7Z4XA3DOJFEqYgAi2T/Y3vj+1SAAIEWEhlOdHyr22XLaOdjtjcNUISXjbscfJ2gWjYrcff5ku6WcRg3TmJVuVG5Ba3fr+0fJ3GfcXnUwGGw/2YrtRTCtxfJg47tHm7tJ7aPS8vop9W+Yjm1MFQEREVGmQWfr8eMnj/f641QRETGzUO17KeN3Fp0k2tt8+rAtnVrNTKPEXSuYSqWtb7/f2B6FkQIgZpYa6yn/5b3lBdfMv9aEkITB3rNHG23mlh1I4sCPpAS0KusR2o26HXi7T797MSgu3bTqLDzYHY7HKTFMg2F3048TcFduLpXe0bKx5vJARNvgCJT4va2dHUqq5VKx6Noz4wkCkfB7zzc6Io79RAq0m6uJWW7eM6PoYPP7l91+KACJCA27spYg3ru1ZvmdnRdffbdx4KUSkHEGigAxM14p9vu7G99893R7EIWSCMh06q1Y8I9vr0Xj7tazr9vSLlZKKoqteViaK9tm5rJDQAQEnJumWWZ0VAgGAMm4t/vkyePHe8NxLBUQoulWl3zAX6wvlKP+wdbzb/ZloeSUlYxLK/fnGjTcePz4+UbbiyQpRG5VV7yYG3fXq1aOzQrNtQUBjMr82r068qiz+6L/FOCUHQoiAiLGDNNwLDz0F0NkgEQ07m5vPPuuEwGQUgTcrDRHieF+vlwxxgcvnz/59lWrH0tCAFZsrLP5udUKIiCoZLy/6e8mURAJAbzY9FOr3lwzYLz37Onj73a6/VgQIXCr0g9DYp+t1ZyLLDpo4/UIEYwOXj5+1goSd+7eQtXhYtBpH/Q2X2wWGk2nER4829jrx05laX2lalqcGaWFimtYRmXt5l1rEThQEvut/d3+YO/l3s2VWuFilXtcpQrVufUbaC0oziDxh53WQae/v7GzsHancfd+EH23uz9SbmNtbXFusVGfK9oW3bjvJJIUkhy29/eH/c2tg4VKfaVYPnylYfDGynylHXS724++Gu68qtTm6/VGvVKv1udrfKKyBCKVpWpjfkGFo363Fw1Ho1agmq5ZX1q/5y6kCkCJYe/goNve3asuLKw/KADjnFESekNWri026yU1eL619bSTWo2VW4slHg12t/utzWfP5ucrtlm9NssFUikvFQoZcwoVEQZBd28Y3Ih4Mu7sjQTndslVg4BSkShS6NbmVm5+7CxJhpD6w15rs9/b3tpZXr61cPOjIHm80R2nTnN9aX5lfq7ZMDBmnBElft8rNRfmFquO6yNjnDPGwCyUmnfv3On1H7/qvvj22dAcdrqpOX/j5v21ublT6/+Ez4hMo/bW86cHw8Cs31ypVVwadFrt3t7GZqlSb95zkDGGFI8GXrU+tzhXtaP25s7myxGVG2sfzztJ0N3aGWw/e95sVivL1eJFVtwRGWcAMolZtbEwt6K83mDU9Ua98WgA88gY55wzZhhmZfHGgySJ0u5BajcXFm8uzzertaK2XD9EDNNszM/Vu+Fef+ubqL+9U23Ua816vV6tNptVa6q/UslCea652IyGnW4vHI96vRBXrNrC2l3eTBQxUF734KA32Nndb1bn5mvj/e3dVgR2bfXmfNE2ovZeuzOKAAAQonF/+9XGxlA41ZVPmgUr6W62RrsbW3NzzUaZIeNMhrE/MsrN5YVm+YyNpde7Vtrf3918tj2MnfrK6lyDxdGgvTloPXtWWqqXHcYY44YKggBYpbG6UCsGo90XG5v9kCo3PmoWiml3q9Xd3dkqlxtz5YUi18quORfTdU0AiZTDteak76Bdqq/euAtz0mKQhl73YK81bG1sdT+qu2J/5+Vuqw+lhZXGUtUGtNxas3YYUodICig0FuYXRNDrdUbRsDfoiWbR23v5eLc3wvLN23M1O+q2Ort72xtuYWG+tmpD/mUObbweEaVpa+SlaJaaN3/xs1s1J3n57V8Cb9ML/MDrl2kcBMjdytKtz//mRrFoAiBjiEgLdwvVlThJFUVej/mtUVeEkSdlarzlNzEBAJtbvVueW4nTREHU3+NRr9UVYRrx4o3bzehgs90Zpk5tee32rbtlQESoPfhlGIZCKSlbFIx8v5MESRoBTI1XblnN27fuxqy0OwzCOAoHu4/3t8iqrNz86JefrlUAAQgZd2s37j+4/dGCt/X9d1/0BkooERGvOIu3HlSjMEqVlOKAR+PRYCiiOA7JBQAg5GZh7t69Bx+v1auDF1tBHKBRLlbqc1XLF/29ri+CcV+JBYBrY7wCAAARMu5UllDuj6Nea9R3AtnrD6VTKJeWCiMvIgIgQODzN26V55eSJFUYd3dYsN8byFgEvHxjvRa1t3f7I+XUllbufL5eRjbsHgAQoOHWVz762f2b63XXe3F0AgoMt9hYu3ur03/W6m5uK2LFuVs315fmKnm7fCpk1/MTQqu2/tmnt9bqfPO7P381ft4JfX8UUuZVy7hdXrp378H91TrtfvPUjwR37WJ5Yb4UDvz27jiKg6EnYwFF6w3iTqk1ozi39uAXtxebwYsvv3s6GCupSEzVhwi5UZq/0Qi7m+3+vrDL80v3HtysITLtM/Ahwi17bv32J6lRbo/HSRwF3c3B/sYLq7J8+9NPP71jT8IOGoX63bv3Pr4x5+9+/xev1yYhREx2rXjj3i/mwzCRkqDP48gfDdIgToNEKT+OkVvV+Vu/+HypVhh+/cfA88JMaJSKYRgq5FahMt+ouEHQ7noDPxykyQgRsnGvNH/3kwefrMxVnXw7DIEXekGQWoWV5fu//NldGHkvvx6M9wf+uCXTBQMRgBR3qgt3P/344+WyGe98EcVCMtupN+rlWhR3e/1WFHmR58P8OwyXo9EgY42lO8X6cpIkEpJR51XY7vRUGHuS5CiOQyF5Ye7G7Qe/ulWjbN0h8cdEQMDM8tKNj352d90ZvPrq2/4gVFIKIeRoHASSwHXrtdpCyU+9YasTxn489GHFvMDFWdp4PYIAhFKAzDAsx7Qs07JNkzOQSiglAIkAgHHTMk2T88koRSL2e+39vc5gGCuZRsNAKPgRgviJ2Ou1WrvtwTBRKvYHgYTsmwSR8Un4gkMHbSCZBKP2/l5nfxwLJePROFaQDa3HXsotZ/Gjny/c+TT0B/1Wu3Pwcmd/p9fb3zvYWlz5uJq9nhcqa8uNRqUQG0cR3kipNBq29w9arXGcSgpHo1jBYZwvyEwJq9J4sN5sFE3oExCiivq7L77YRwBSCvk7C1Z8ZaHJf8zgznKt4qe9V4PdlwAYecJpVqrNhhwzyoxXAhF5g9bOfqfnpVJF3iiSACZOAgBPmxwnR52y1kVuFJvLNxZrRdcA77h0o1BcurW2vN8bhWEEhebyjZW53GEIACDrDoCGYdumbXDTMi3DAEVSqBRgYmAWqku35qt11+gSEAIKv7Pz7B/3EICIkBuMwWkbVW8GGTOLlWatXCgIw2AMT3sLZh+Qh/82GNNnYT5cDLu4/ODzxXtJ6I8G+93W1s7e9kG309rbqi3evGECAgEzCpUbi425UkEwzo/GLxkF/YO9g71RmEhIvIEnAI/PfsgNwzA45/z1o7xIMhkePPtDGwCACIyjeM1EzHIrjbW1uaqd2zdGKpJEwLhp2EVuCzO1DZMhSpUSqMl77WJ9fvnWQh2SMFGESCodd777oocIRES2wU/vEhrNj4pIgkFrf68z6MdKpcE4VIpYNqZnayUGNwzDnppEGQSAVmFueW6u5kqPzfQpUkQAJLz2t992GAIQKJO/hTZfZ+P1RAQrAJgJGgmQBZF87c+vPR62dp9++e3zg8QwbddCEcUkL9IG0zwgKTU93gOytfH4y6eb+7Fp27YJSRTLo8aacaDKUofD1uOv//xdNxWsULBRRnFySiaIAIEAkVmF8rxTaCzWHEOE41dDKZL4lP2CIzlMxmHv0dd/edwJU6PgWJziOBFvWFgmNAuV+ly14DAEIjTscs20rpPGSVKxkETEGasuNhrj8f5+b0ciKHJr1Xq9ybqvgJQSIiIVtl998/DZk37CLbtoUBwn5zX5GyAAAKXSJEmkUkSEMonjJFXknPplpehkaEyaqD9l/nuT4eoNYolZhUptuebyzNhmTrNknnJbGxEpNdUgSUpOg7WeXpgcaOe/DxoiyFSK2cXynFtoLNZtSwbDx5FI0xjo9QOyM32GYq+/+egvX+/5MToF26AkjoQC41T/klMGQmTcKTeXqo41sVrtRsl1yDuR9pSXkSJ5umbO9Kc8Ks64U5pbqDiuiQBE6NRrRQunHooaTQZi5ll9URSRIkXHlJVU0tt69sX3z7YDbjuOhSKOhFTHzq3Q9H9ncOrfmF1aaFTKjjHR5mq1Yl1sCL9OpsQxCFQaRWEYGTQ5PW9IQscwEFQS+17gGSrxwzhVaHDT4BYSY0ik0igIfB/IBGSmZQ6DoN8bxFRbWH/wyQofbj358sUgt/lKMkmiIIpAjEaDcZAAAWdMAQz7435vHFD1wY3bt9f4wcbzR98PX7ejlUjiKI6d1I/77d44EKXm+ic/X7OD3e8ebh10TwgjFY1HKTN4FicMIU2lVArhDcqOCKkUne7ADxKrsf7xJ8ulZP/77zY2x2elYIgICNytzt94sLbAEYgQTavouBfcPn6vUYpiIRQhMM4rK/ONfqW/30sAeHGpWZ9fMOMeIBGJ1FPERqPe2BtT/d7qzb+aZ+3t5395McLjbU5KJEkUJTZ/Q8dFIBWPB9vPtvd8RY5ji6S/93Kz7tSLi5Uj8xUBLIMjQuyPhsN+pQocAKQixk1EtLiBIETs+6EX2MwPw1ggNw3TMADS10RyRIYIaJXqC/cfrGau98gMp+jOen9zzmzTNGSS+uMd3+dgmyRaY38QJcyoOIZtn3x1HkjJNAnjxGE8/xKY5j2ClIh8L+YmZ5OFnFSSJHjT+IUAaSJG3f7QT1hl5d7Pb9VU+9H3r3YCICBAAIZIRDKNgjA0ZRin4nCfCxCBARBypzR//85S2TWIgNAolIrF0XjnbKmcc9PgKFLfH+0E/rJlciAFCsC2mcENzlGKOPYH4RiCsR/HisA0HMQTPRsBOANAZGZx+fat+YUyU4qAGbZTKL6VlaL5cCFSaRyGnjKNLOpxnluyTM4NZsgk9L3u0K8VDQaZHWtb3Bt5/e7Yl+6NtTuf3nD6u8+++W4wmZeyDUEp4ij0g9DIxNnnGrIIaDCGgMwqrdy4daNRYkQEzLTsYjG/ywDAtTVeSUk13vviy9FjixMAESvO3bi1VFmq15xef3zw5B9/v2OhDHxvLJx6uVKqNO1wXClh2+9vPvrDaJObnNu1u391zzYMw+Tgx4OD7WcxBB0vTRWbNl8WdOi0xiQgoqj/9NFX+y8tUGkUeqOUsVKl1jBNkxnMMDiOw+7Brohw3PFSIuvwDgHOGSKkw/3n3/nd4c25ctE0TIQ4GfVebggejUZ+QmC+pkRJHG1+95eXO4FE0+CIQInv+2NhurZbLCOyk7k9+hnRMDgixaPu1quIp97ATwHtE+XMclgrlEp2qTPsH7z61m+7SIqA2XN3fvXJR7Z7vXSOFBASIfDSYnNx3ZNGINGqrTcbi2ayncUVUKAADM4NxjAN+u297wPyBn5MlB15RsBsLzMe7T9/7HmDWyvrzUZW68cXio7aL/GG+y+f7AxDrKzfXzTa27ut/Y2X5YVypbxYOBzJTIPP1ysFaxAN9r7/1+HLhzYDJVNl11dv/+LB/EK1UjgIe90Xf/zzvmtQ4HuesEulaqVWRBjAcW0pl9xa0bEGfm9v449eywKlCKmw+POf370xc92LVXTnlhr1zm67v/WX3/aeWAYn6ftjL8Jys9ms1B0Q/qE+0fGC0fGfJj8ajDFgwutsPftDMFqfX/nlvSW9FvXhkUb+i0d/ftyJBDNNhggqCYOxL82CUyqUkakTSjPtIAzRNDhDkt5g++WrtvD6o0SRBQRkG0bFdbHr9XYe/dNow4B4PPYDBSUCAChYVrNYZL3xsL3x5+jA4qiUku7CLz++d9c4b3x3S06jWix2+qOD57//p/2iyVCmAszK0i9/cbtWrpVLdr/fevn1v3Seo0hCbyDRbVaWTKtAx8pBYBisUSs6xmDktZ9+HW27JlMyYe7C7Tsff7Zq6mvlNIcQQBr0d77/3eAlYwwImWHXbv38o7XlSVy509QVAaqlcr1Q3fdH7Zdf/q79zGKopCBuN+/9m/tVwzAMhiIetfafJizsj1OhDJsAARrFQsky2+P9Z49GrU1ToVNZWPubOw0DZqeiI8EEZBq8USkV+SDw2k8ehzuWyZRMsLCwfuvnnxRMHW3gfJAZJuemTMfjQbZ2SGSUjcby2tr6rU8/ix8/3u+NhgMi5KbdWFm/f2t1teQY1uL9B7fiZwd741E3JuRWkY/i9PZcbXltcRj2olH3QNiG7RYskgbP7gZGbhgmcf76+JL9xTBRhf44zCKvMdOtL6zfvvfRXMHhuDS/sNb3w543GMSpbTLXLYRockTggEtLc63WKNkLRoM0NSvVaqV+Z3Wxv9nvB9291HZs07FtMo5HIyaAhAhkHHqBpyanhLhZnl+4dfvm7SozU2TcMAwy2NSllhuGgRwRbMtaurly0E87/XGnFdtFizuum05EIHLDNJQxKSeCu3TnVijkyyfd8agXjgCRmYVKKY5IXa8bkLKrzNE2TUReWrr1aXXpriRA0y0Ui0m/7hRskxRnDKG4sLDaGfSTfjDu7QnHRLtio+IMARjDxfn5le447EWjUaKMemWu1HSYYRgmHrnoZQ1mEucsGY8ONnYOBmTVl29/trpYrtCf41ev+gcvDxYqlcLhrWxo2pWbHz1I2cbGwWAYDMOAMURkyonj2HKaN+9/FtP3O53BaDgGZNyqzC/fu712s8IhhOPaAry+cuNWOhYbm4Og1w0RgBu2g7VIkpw5pId2pbny0c8jfLjZ6vnDrodAyEyrMr92786NuwsuwhiQGYZhGAafKZiZycpcgDPvRARAYHPzi4u9VtgZ+aO24oViPQAoXCstuxYQQApAMg7GsZzsbSGzSotr6zfvr1cMGmV6oQ5XmRCZYZgmMI5Gwa7dWl1sx+1O1Nvv2K7DbcdJkTNEu1xcurG6Pnq57wX9YWzbxXKxyHiUjWZWpbF898Fn4slWN+j3o0mPhkokpTLY4bh3yroWK8yt37ov4OWT3cHIG3UJOQfGXCP2JS4vrdz8ZJw82u0PRr0QALhTmVu8d//GfMlmo2w4RWMyfKPplNY/uj+mFy8PhuNhOAJERIcqsXibLQrNhwoybpgspcTvp37m8MXNIl+IRRaAczKMcuM1dUWwGms37ylpPdrtDoNh10PGkHFbFiOl5haaC+sLg7AdjPqt1LHMQtEJlMkRGZZX1u/6cfRyvxeOWiECK5DbCFS9zLhhGKZx1BW5YZiGwRHBcksrH/3Mk9/vdjrjYUCAiNzGciqSi5b39M/GDxcl0nHvoO0fXg176GhnutVGs1EzZTDsdMdRJKQCZNxwi7VGpVSyGZBIw3GnPx7HqZxcR1BarNeKLO73e70gEcRMk1sMokQahfpSvcyjfns4Gim7Vq2t1I9OhZKS4bDTHnqBAMDMtxkQuekUa7V6zTU4AoWj3nDY8xOBzDQMzihNlFGsrjartsGiUbc7HI8TQWC4pVq94jrJ4GAQBIKAGbbJlBCC2Y1abb7iHklNvN5gPA6TLNwwISLjtlOsVWu1AlPC6+x3hwlYpaWFulswg0G31+0n5JTrzbm6peJxtz30g1SBYTgGk0IItOv1ubolvEGrHQKzy+vztWzTlmJ/PB52vCiRRATIDcsqVBr1qnOhkPXvN2kc9Nv7gwS5W1tpVlyLv/bneNDeHKfKKi4u1Mum9PuD7jCIFTDDMBmjNFVmsbbcbBgM43G3P+z7sQA07Eq9WigZfmvfj8AqzS3MFU2LQTjsdCf6VmpYot0ZBoq75fmlqm3Jcas77IfKrDSbtUr1yHmDSKb+eNAfh1EqJQEyxtCwi6X6XLVAMh71OsMgzLoD43ahUq9Wqg4XSdTr7A9iMtzmcqPkWgwAZOwPB/1BkCSKIPtKtEv1ZqVsm8e+kqWIg2Fn4AWpkAQEyJhhF8rNarnsGABJFAwO9r0Y7VJzfr5omcmg1R/1fbJrtfl5B4Nha2+ccLfcnJ8vmgaLx4NBd+CHgpBbxUp1oVk58346zfsKSRF5g+EwiGIhhQIAQMYMq1CuVJoVF9PY67daXkpWeWWuVnLMYNjt9PshupXq3EKJqXB40Pf8VBIalsVRiViZ1Vptueak0bjbGYxiKZEZhu1wlaapsurNWq1eIJlG436vHySxVATIGDfsQqNerbJ02O0eRMosVBbnawXOXt/0FHHgDbujMBJSEjDGGDPMQnmuUiqaMhgNuiM/TJXMyuGWmo1qyeQsHnb6w66nrGptbqFWmkSvjYeD/sALY0mKEBkz7UKtUq2X7B/hdLDmAyD1B/1+ZxxPPmgyh2pkhltfalTKDofUHw8H+4ME3VJjqVHjx89PyyT0R92hHwopJSBnjDFulxfr5SJGvf6g58cpMcPkJsc0kTiZ61U4GnWHYz/JLlMynFJ5rl60/P72IEiZ25xv1As2+cNOvzdIjWK5ttooclTxaNAZe14ss1tkOXeKlXK9Xr5QnNdrZ7xqNBqNRqPRaN5ftLu3RqPRaDQajea9QRuvGo1Go9FoNJr3Bm28ajQajUaj0WjeG7TxqtFoNBqNRqN5b9DGq0aj0Wg0Go3mvUEbrxqNRqPRaDSa94breEnB+0sW10xfqaJ5p2g102jOQvcOzXVjGlD1Sql9HuP18GIvyoLpA0J2i/kZTyeh3z/YHSfCat5arBXst7tnnCgdt1v97jC2lhbnG9XKuU+Ho36v2+qn3C4t3F4sH97M80Hhef6f//yFHwT/4d//bfUN9aHRvD1ff/3tw4ff/92v/3dLiwucv13/1Wg+QJRS/8v/+t8Q8W/+5pfNRuOys6PR/BQ8f/7i0aMnCwsLf/3XPzeMq7Li+YZ8EJEMB/3eoOvFsVIAjBl2qVyuNhtVk51qIsaRv7nx6FGPrHl7uVktvN1dN0qo0f7L5682erhYKJffZLz6o/bLF4+2ksrSzeqNhfJVqd0fFSHE9s7OcDj8N3/9C9DGq+ad0W53Hz16/Kt/89f6BhONZhYievlykzH87LNPLjsvGs1PxGAwfLHxUilF9FeXnZcjzjXzlIo6W09fvXrVHg7DJFUEgMisytzqRz+rFmunG69CiP6w3x2Ztbp6+6mPFEXj4WDYH7t1CW98j0yTsTccpHZT0ge46HoIY4wxBldp6V7z4cEYcs6v1A6RRnNFYIwxhrp3aK4PiDixPa4S5xivpJTf3t14tLHToWKzWp9zOQCJRGSOD+d0XsRp337bHo5TLpTiLaVpNBqNRqPRaN4LzjFelVJeazQOBRUXbj746PZHc1yBEkmSpMwtcwMBQInQH/lBmEoFjJtOuVwmIgQAJCAlwvEoSb1YklEol4plhyMAkEwDb+CHsSTkllsoVwqWwQCAhAj9oeenSskUxlEoj7Ytk9Afj0eB4m6hUi+ZCOGg74cxmcVqpeSeyDwpEflj34tSAWjahVKxULINUKkIxx0vVdyZr5hJlKam7brO27k2aDQajUaj0Wh+Ys73DpVERIQGsw276JbMw7MbRIBAFAzbuzvbr1rdYSgkMbu8ePeje6sWASCQirzOy41eFI77YUpOc+3GrQc35oqUBIP9re29re5gHEu0SrXm8u0ba8t110hHrf3N5y8PukEqCAwmhvHECQAB/EHr2dPHu0lxcf2Tv7lb4dR6+XRzqy+rtz//+KZ7bMmVFEXjg4OdzZ32wTiMJbdL9eXltburCw0jjrsvv3vW943K3QUrGAlaXLu77thXazlco9FoNBqNRnM65xiviOg6lmUw8oc7W/tGgc/VbNM0TcuybYOk8HafPfzTi/2+slzTNLiScRSmCCYAAshk1Hr+lw43OJKSiRiGYFebjRXZ2Xj45Z/3goTZBYtJb6/d6Q4Fhwdr1fHuo4ffP+5L03JtA1CmiTzymhVJPBp2W5F05xUBEUXesN9uEyyLFMGayTWpZHzw9MuvX22OpeXYFsjhsNfu+zFY/2aNizjodzsHSWt3CwynebOyopQOd6vRaDQajUbzfnCO8coYKy/PLx4M4+3xYPfZcP8FN81CvbmwvHrzo5WSKVvt4chPoLJ898GNxeWSUswtlgosGgMBABpmsTE3v1jFsNveaY2SMInC0Jet7baXgttcvvPRvO3vP39xMOx02r1FbqTdwSjlVn3t3ucPGsgHG188P9j1L1oiFGm6t9/thikVF27fWF5go43Nrc3RsNXrdlfmCgAIhMCMUm119daduWpZW64ajUaj0Wg07wnnuQ0gt+rrD35VrC3tH+z3Rv0gCKLh7taoN4oE//x+NUwSpcguNuYWlpeXC4oAkaEfAwABt6rL9//2k7Vmafziod/pDlMiIiFVGMZAqBK/uyOZ8ONEqTiOkjRQKhWSM7dYmV9YaiJnLffVhY9gIYJSFMaxUApl3O+1YozGiSKZxmkSArgARMywqjd//lefL87NWR9kTFiNRqPRaDSaD5M3RETldqG2eKPYWLqVCimjzt7Lbx4+avn9dm90t6wAAYBxwzBMZGziEIuQRbZi3HRLxULBTUyDHdqHmRcAKZWMBh0fAUhJYnwmBgMiMoNzAzjHs4JC5QosQEpG407qIZBSEpk5c68CIrPccqnkmh9kRFiNRqPRaDSaD5XzjTdSigiQW07JRoCS9PoFEzEhJafBV4mUlJJUFgX2mFE5uZjrxGuRW+XFu/fvNV2HAxGAWahX49H2/iSRklJmp8VOyRKRElKQVOdHkUVmOOWbn91aWCibBATErWKlwWVyFDRWR2DXaDQajUajec84L86rlOH+1k43kIbj2AbnIIftzjgC5IZpFpDFpoGIsdfb399W0pGKFcuVeZvOuSbAYGhbJgFJIRQiclRJkoBRAW4gMzgnmfiDg63NgJJ2txcLOfsuBCXjYXfz4Xc8Ddt74yRl1msCiACR2YaBAEIISYCMYxolCkziBZDiB1WXRqPRaDQajeYyOcd4lUp0dzafPj0IlWWZnDGSSRx6ieHOV1cWS47NF2uVl9394cHL70f7L5jkheXbdyt3ikREimi6cEo0/Y1bcObWFgrtXa/16vuoZXIkkQpn7tPPjPUFp1Yv7u4Ph3svvh9wSuMoSiTB5DUF0yiblkyjfvvl122VCgKQikyibCn1SKhh8IXFuUbb2xztPH7S27Q4pEnKSyu3WeNOgQgmT777ytVoNBqNRqPR/LicFyqLcXtuYSnE4cCPEqEUGm6pWV+pzy8u32jaDppL63c/Q3enOwpSKcA2bdO1lWGYpUpjAY1y2eUMAQynUGk2IlEtuCZ3i/O3PvokdboHw3GQSmJWuVqr192ybZULq3fuRGK3O0qBm25j3oLID1Kn5pgmQKFSX1u/3cNOKJlVKBRcB+PR2Md6yXQ4cMutVJsLqlotWNy06su3PkmMcqvf85NEoVEol8uNRsVl3OBOqV6vG0alyg+9dDUajUaj0Wg07wnnGK+cG/N3HtRXbvqjYRDGUgEatluqlkuOZSAg8OLizc/rczeGo3EoBDMdt1gvOwbh2u3PqoKZxbprMYBCc+HmZ+4iOOVKGbjl1tYe/PV80BsM/VgSt0uFYqXsWAZHqN+491ljfjBIwHDK1bKRjIZeTG69VALAUn3prlNo9D1luuVyxbWF1+t7qVktVwyA6vzd+9YK2MVygXODFRbvfNxYXRn2vDASaBUKxVKpZFsmpGlj7eNP5wVzqgVbX6yl0Wg0Go1G835x/oEtBDQdt2o7FaLsx9fOZCG3irW5QjXbg0dkiABOfXG1BoSACAholWrzxSplKbMLs7hdmFtwmwQAiAiHr0RmFcrzTgkw+31hzqkCIGSpmGEV6otujTCLNmBV5wqVwz8XKwuFciYjexmi6VSaS2XKfjj8tWkW55YLsw9qNBqNRqPRaN4b8oSKOt/QO/nXzEjFc544552I7FjKEy+e/mpqC2c/vP4wTI3pHL/UaDQajUaj0bwP6NulNBqNRqPRaDTvDdp41Wg0Go1Go9G8N2jjVaPRaDQajUbz3qCNV41Go9FoNBrNe4M2XjUajUaj0Wg07w1XyHjd3t75+ptvwyjSt19pNBqNRqPRaE7lChmvGy9f/e53fxgOhtp41Wg0Go1Go9GcyhUyXr2xd3DQCoJQG68ajUaj0Wg0mlO5QsarRqPRaDQajUZzPtp41Wg0Go1Go9G8N2jjVaPRaDQajUbz3qCNV41Go9FoNBrNe4M2XjUajUaj0Wg07w3aeNVoNBqNRqPRvDdo41Wj0Wg0Go1G896gjVeNRqPRaDQazXuDNl41Go1Go9FoNO8N2njVaDQajUaj0bw3XCHjFRERkTHG2BXK1dWBMTatosvOi+ZDJtM03RM1mtfQg7DmGnI11d4gojRNkySRUl1iPhDR94M4jkejUb8/4AYHusTsXDkQcTAcBkEYhtFgODQti0hXkObHBxE9z5v0xMHAMAzdEzUaAAAEKWUYRozBcDgquAU9CGuuA+PxOIoiPwj6g4Fpmpc+IyBD13EMpdT29s733z8ZjoaIeGm5Qfbw4cPNze1/+Md/bjQajF1aTq4miCwI/IfffR8G0X/77/9QqVSVkpedKc0HCCJ79Pjx5tbWP/3TvzSbTcY4XPpYpdFcCVAp9fjxE8aQc6NWqxFd5oqPRvPTsLm5/fLlRq/XS5LEMIzL/WYjIsdx//Z/+JVBRK1258uvvtrf37/ENWFE3Ns7GAwGX371dbHgXqIZfTVBxDhOWq1Wmgoppeva+qNf8y5AxFar3en2vvzqm1KxoHuiRjOFiLa2thAhiqJCwdWDsOY6MBgMur1Bt9sfjUaX7jmglKpUKp9++sAAACllFEVBEF6u8ZokSZYTBNBT5msgYubdIYSKoohI6XFT8y7IPpOynpg5Ol12jjSaqwIRCSEAMIqi7MfLzpFG886JolgIkSRJGEaXPiMopUzTJEVG9jMeclkZmkq/9JxcTWarRdeP5t2he6JG80Z019BcH67UjDDNwxU6O6bRaDQajUaj0ZyPNl41Go1Go9FoNO8N2njVaDQajUaj0bw3GG/4O9FP5JOOSEoBESlFSsFP61eBiEcSiQDoykUHQgRSQDT5Tym4xLMCCABHNaaUEkK8hZ4wxgzOcfaYYFY6zSWCeKRmpIC0Y99lk41OumtcCQ5b4dIHYQ0cdg2YGCoXmoOymPuXkJaxzGWTiC5qX03TZqJ/OvX76WeE4zbGqbzBeDVc161WDct619WEyELAmKC6vFIsl9hPaLymURSNxyKOAQAYI8cFx/mJrec3g0hxQlFCSUqNJrnOZR50JYAohChARQDZF4dyHOdCrtxSSiGEkNLMRgFEMkwoloDr3YBLBZGEoiimWoNKJdARly+dMIA0BccFy7rsrFx3SBENPQCgRpMK+pKCyyZN0RuDUqbrFptzluvmDEqtlIo9z+t0SCmzUCjNzZm2kzetVNF45Pd6QGQWi6Vm07Ds3GllMByG/T4A2OVyqdHkppk/z+FgGPR7iggME8pl+KnCQxE3KJVULFJz4SeaESY2RojqzFDK5xqviKW5uVv/5t9WFhbedS9FxtjvfqcePb73n/5TY3GRcf5Oxc3S29rc+frrwc4OEJFhqNV1tboOpvmTZSAPiCh8X3KTwlD+7BeiWqWzG/WdoxR79ZJtvoA4BkTGWK1WvXnzlmWZ+fXE94Pd3d3RaDT5GZGqNXnvYyiX9XrGJYKMye++IyL5yc/E3Bzqb4nLhYBtPGP9rly/RQuLl52b6w4ppaIEEMVnPxP1mjZeLxNF2Ovy777mSVyan7//6980btzINS0iijg+ePzo0d//vYjjyuLig9/85+rKSs60aRjufvvN03/4ByVlfXX1/q9/U5qfz5MWEWPf3/riL89/+1sAaN64ce/vfl2o5dUikSSb//rHZ//yzyCJyhX5+c/BdX+auVK+ekXGC9Vois8+Q8N450IRQaS4ucm3X0EYnLWS+IaVV0R0KuVis/muTSVkzC6VTNsq1GrFRoP9BBV0SDgaGtMlDUQyTSqWwbavlgmFjJCBbZNQVCxRqXKpxqskxyGcfIIREedGrVZxnAusB9u21e/3joxXAECEQoFKlatV89cNxsB1wTCpWKRSRS+EXzIEYFoAAKZJpcpl5+a6Q0qRZSNi1ju08XqZKII4mq4+Hm3lvxHEY/vvP1XayZPTtNmrGMs5382kJeCMiiUoFH+auZIKBTItclwqlcEwfwrjNU3AdYGdt4j5Jp/XC7XrD4AxNokhxtiFWvSHg8iOmfaZG81VcxtgeJSxS84hAtJJ6Ywxxlj+0ZwxfoqbwRWs+evGpAkQECdap7lEEGZnu0vNiuZw6Luac8R1g53oEfndQE8+dilpp76kF07702rgkc6zn0JoJogxOFfUm41XjeanQ08Jl860CfQMfdXQbXHJ4LEPCd0cl45ugmuMNl41VwYiEAKE0G4DlwljIMVRW1z2TdaaSZgRpUCIy87KtUcpyILh6JHq0iECIXOedtJ8eGjjVXM1UITjEX/0kPSR6ksFEdnmNnba/NG3fHcLdbSBywYHAwgDtrmB3fZl5+W6Q4rY3jYAcpPxUkn7vF4mBBBHkCSk11+vJdp41VwRCOMId7f1l/Tlgois20dvxHa3eb9z6TdZa7Ldamy3oH1w2Tm57hAR6/cAkHPgjq2N18sGAQAMbcZcR3Sra64a2lq6XPD4v3VzXB10W1wpdHNoNJeGNl41VwNEsmyq1q5ahN3rBiIqYJRKtbikypWfINKI5g2MRhhHVCqBW7jsrFx3SCnlhwCgllaUdhu4XIggjrHfRd0K1xJtvGquBohUKst7n1BFx3m9TJAxxS1KhLz/qWjO60sKLh3+7DF222r9llpevey8XHdIKjXyEEF8/Lmo17Xxepkowl7H8MeY3Y6puWZo41VzZWAMXAcKJW28XiaMgeOAYYDjQrGkow1cPqYFiGCaUChddlauPUpNmsN19Uh1yRBB6APqAeqaoo1XzVWD9JmtS4WO/1u3xdVBt8Xlgrp3XCV05V9rtPGq+RGgCT94JUIPRxrNSfQK35VAt8KVQjfHtUYbr5ofilIqTUUcJ4gXuB5WvBZxnQCEgDSFNNFT9WXCGAgBSoFIIUlA+7xeOkqCoknX0FwuSoEUgKhHqiuBrv9rjDZeNT8Cw+Hw66+/YRfxj1RKJWlylIQIxyPj2y/IsPQn9SWCiHx3F9st45svjGJZX1Jw6aDvQRzzF8/Y3s5l5+W6Q0R8axMQDCWMYlEf2LpkRApxpC+JvZ5o41XzQ2GMGQb3/eCCRidyzoyj+NKEIoVuG/V0cKkgIg76GPjYaTFvrC8puHwQARFGAxz2Lzsr1x0iQm8EgKx9wMaONl4vGQQApGwSwcOe8uZUJx7LfpM/7eyTF017/m/OT66ZQRuvmh8BKSUAXGgoR0QipOORvglQR/6+ZBBpchQF6UJjq+adMTkopNvispke0SJEQv2hffkgIigV9Puv/vjHg+8f5XQkkFIGg75MUyDyu92N3//OLuaMHYFSpF63I6UEpUat1vN/+WfLLeRKiyjSZHxwQFICwHB399k//aNpOznzrJQc7R+QIiAApbTLhDZeNT8UpRQAlEqlC7kNCCHiOBZCWKYJAIhommaxWOCcv6uManKAiGkqojhu1OulUvFCbap5FwRBkKap47i2bV12Xq47SqnhcIQAjUajWCzolddLhZIk9TxfKRWNx7sPH14sNWK2rRSORjvffHNR2dntLUG/H/R6b5fW63a9TucCqQDoMM+g1EWFfnho41XzQ0HEcrl89+4d277AZd++729v74xGo+mVWpZlLSwsuK6rp4RLBBHjOPEDf3FhoVavaeP10jk4OBiNxvV6rV6vX3ZerjtKqXa7A4hLS4uVSkWPVJcIEfm+H4aRlDLbmrjY1h9MtjLeJu3hHggC0MWSwuydhQSU39WODuWiPhQCANp41fxwENGyrHq95jgXcAKzbbvX643H4+xHIkqSZDQaR1H0znKqeTOI6Pt+HCej8RgQtPF66URRlKap53na//jSUUqFUYSIw9FYKaWN10skmzJIKUQ0HafYnLNcN6cxSErFnud1OqSUWSiU5uZM28mbVqpoPPJ7PSAyi8VSs2lYdp60CKCkDIbDsN8HALtcLjWa3DTz5zkcDIN+TxFpDyLQxqvmRwEPuWiS2d8kSbK/v/9jZ01zMRCx2+l6nre3vz8cDrXBdOlkFlKv1+/3B5edl+sOEQ0HQwA0jd3+Rb7VNe8GIkVoGKX5+fu//k3jxg3Ks5+OKOL44PGjR3//9yKOK4uLD37zn6srKznTpmG4++03T//hH5SU9dXV+7/+TWl+Pk9aRIx9f+uLvzz/7W8BoHnjxr2/+3WhVsupRSJJNv/1j8/+5Z+BADjX9qs2XjVXBSJSUl7k8Zn9m3eVBAjoQofIspHoQkKICDHbC3pzqulIl1/EJEm+BIgolSSlpBBSiJxSsv2vw02tHI/D9KxerlLPiLhIxV4syYXq6Viaizc35Cz15OWIuWbWWSkAcAFBb9U13qLs+Yt9WIQLibhgli7c4kSUNYQUQoo0p+16oVLDW6r6BXsTZYdj36I3wTsScTiyXUwL8XBvCBEx5zYRIjI2K+anSTt5cpo2exVjOY9eHUur0car5opARFGSJBdwAUIlUiWVkfsUCxGoNEHOGM+r9qQUKAncyD+gKpECIDNyiyBSacoMExnL48uklAJFyPKOmESkhERE5CxXKRADIROpfKFEKnOWW8Yxcs4MM587FpKSJAUzTMBcpQYAmSZAyC0zV4YAiECmCTOM3J4PqKQgKbl1gXNRMkmQsQs0t5KkIG9bAACRyZABJFJRbhcOApBxwgzOuJGzRZRISQpuOfntGZkkiMjMvC0CREoI5Dyv6ipFUgEiM/Ie4lRCAhFyni8+MSqRklLcNHOaBUQUCoGInlRxIvPULSkFUoJxgTFEpikA8NwVS4pICmYY+XuTEikpupiqX6SPExFJBUTMzNs1lJSgCBnDfBejEBEnKto2n/lV3jP4Jx+7lLRZwreWe73Rxqvm8kEAqWggaLByQxbKuXopY9Tap/GQ3bgD3MiThIhodwtLJaw1c0Y2Ac+DQRcWlyH/1QmtfeAcmvO5HkakOKLOAWsugpMrZooKfAh8ZjtQruQRQCJVrV10ClitYR6rHVnKN0Qs0sV1Xm8AvmkiQQQp1KsXWK7iwlKuY7CI5I1gfwdXb0P+SDE7r0ARW7+V52FAhCSmvR1szkMpn0YhwrBP3hiXVnJqFADQ/g44LtbzaZQS4HsUxVhvQj57lwKv2m9bgTeu1OPFtTxJABHShLZeYnMOqo18ZWfUb9PBPlu7C5adt+xbG2DZuLSad1r1x9RpweIK5gstRIFH4yGYFqvPvdm4RAQhVK8DSmGtjo77ZhGINOjReMCai+AW8pSASCWjALgZrt3FQo7gSpmqd1qwcgMtK1dFEdHuNhgcF1fyZAkQKQphbxuXViF3zCY62KUwZDfv5BQBaapePcfmPNbngN7cx0kIGPUhCHBpFUzzzbkiUsM+xBEWS1jKMbIhUhTard1VkRi5v200HxLaeNVcCQgoBUjq87Ixn2dwBMZUnJAQfDHf4JgtgQz6UJ3D5XzTLTLqdSAOYWEF81mWQERRBIaJy+u5jF1E8n2IIphfwlI5T8HVeAy9NjouLi6/+f2AlCQqjsApsvlFdHLYJcjkeKTaB0mtyRZX8I1Ld9nE1mljrYnLa/mMV0bdNvV7bH4ZiqVczY1I/R4ohcu5DbgwhF6XGvPYzKdRyAg5SgW5NQqIlD/GUjWnRpEQ0O+CN4KF5ZwaRaOhCAPuj1O3mOQvexRBu0X1eVxcydmbiEgNBmxxNa+qA6huB10Xl9dyfjrCsEdjD+cWsVLNlWQ8JuRgWWxpFd64WJvpISLFCc4vsTxfLIhkWmQYuLAMpVKODW4kJeWzJ2BayfxyrlIgo34H4hgWLzKG+B4Y1gXGkPGY+n2cW8JqNefXowp8AuRLq3mj68exOtjFagNXcvVxSlNiHFSHLaxAnmGHlLIcGvWxWmd5vvwRyfcxCtWw9eaHNR8i2njVXBUQkRkmWXbO6RYMgzhnlgVmriUNUgoYA4NjzrUlZGQYwBiYVt4kRMQ5cI6mDXlCmCNSkhDjOBGRo+BmDIaBnKNl53o/ApgmGJzlLAVjyuCADDlnpoVvNOMQARlwAw0DLTuv8WqYxDgzLchZakTFOSCyPKXOciUkIZvkKqcBZ3BgDHNrFBABOyx4Hg1EToYJjKNp5k1i2sg5ZL59+csuiThHw0Q7X4swpgyDMc6s3KoOAJwDN1jOghCBYRJnFyi7nZBhADeYacMbt5KzCzVMk6RCw8yVK0QybTJtMC20nDxGHCkpGUPO8vYmZGRYYBgXG0MME0wDbSufxweSGRE/HENybn0wPtGonMarImAsfx8nmAyeh338zcYr2DYZBhpGLj1HJCHYxN9D76dfR7Txqrli5PQBmj6T323otSQ5Ehz946IiILcn00VFwEwpcr34gqU49sAFk7y7ij09e/mkXEWNetskeXn3ZZ9Ne7Gu8RZJ3pmIyZ1Zb+F3mLOi6LAt3k6pcmXqglk6TVaelx/l6h308dlntA+oJgc6iKNGo9FoNBqN5r1Br7xqriqn7me9cQv7hyf5kUWc5kpHcN5W148j4kctxU/QFlpE/iRvk0orybvJ0uki4Eft4B9uW/zoIjTXBm28aq4qcQxROPVWJAJgDAvFM49pE4E3BpnOhiEk00S3eIZfF0KaYOgfixHNGDjuOU5aGPiURDMikCwLHfdUEUSEaTJbCgAgxtF24IwgNaQUxBEm8dFvEMFywTJPDzBEhGlCcTjriEacg1PAswJZSwlxCGl67DWOC6Z1pog4pCSZEUHEDXCLwPjpVSsEhCEpcVRNmQjbObXUAABRCHE0rXYiQM6gUAJ+xlFiJdH3SR0FBiYAtBxwnDPd+KII43Da3ASAhgmOe6oIIgAlMQpAiKPfIgPLBvt0T0FShGkEUTibJTBMcFw8vRSEQlAUgZwRwRjZDprWec6IpND3aTZjAGBZ4BTOSoVJBNHxsjMOjgunxWMiIiCFYQhiRkkQybTxjOolIoxjiMNjHccwwHbAOD3kE0pFcQhpPO1NhAi2i9ZpZUcEJSGKIYlnRZBhgO3gGSJACoijY6qOSG4RTPP0aiLCKKTjIsAwyC0iY6cf6BICwgBe00O3CPZ5YwgkMc0m4ByKpTMOpSEogb53LNAvImSqfhZRhFEws3OPYJjoOKepOgIpkgKjEGbDbCMD24YznGJJKUhjjI+3heWAbZ81hoAQEB8TQYyB7YJpnh5ETEmIY0oTnK1GyybbyRuTVfNBo41XzdUE+ahfbO8VDw9qKKVCAn/1lqzUTnscMU2dvc1SGhuH1m2SpJ5biu/cP0MCGIFX2nruHI6eRBRK8pbXZeOMEwNEhc5eYTycikgJRpabrN48ba5CkIKNB7XuvkUKD2NOeQq8xjwtnBErIAoLvVbFGx5GJyWJrOdW0vlFOBn9BxGEMAbdyqhrKXloBFBgmMPKHDTmTq+o0Hfbe+U0PpwBiIj65WbUmAPHPTVTVrdV9IbTSiElI8MaLq2rQgngxHSIyOLI3XtVIsEOS52K1GsuRvOrcGoATiKj3y33285Rc0uPWHDzLhVKp5aCJUlh71VRyWkY1zhJx9VGunrzdAMO0Rr1Sq1d+9BcU0RjboXLa1SqnGJnIGAUlfe2C2nEDqf8hGBYqIjVG6fP6CK1Bt1av8UZy9Y5FcCIm8HCClRqp4ggwPGo0m+5aXyoHpQyo1+qybnFMyMeIEIqCrtbRRHzacaSdFwsJzfunv5ph2h4o+L+lmvwTEkIaKQgXFqnU4N8IWIUF1s7xSiYikgJhm4pXV4/1d4FIYxRv9bdN7ODUwAEEDDDm1tStcYpzxNgHFQ6+27oTbuGQOwVq2J+6fSzTWlqdvZroWeQmtq7nmGPanPQaJ4iAgDGo2L3oCIPjVcigWzQXEiqp4UqQwQprPZ+ORhPbVslZWg7w6V1cAuAp6l64Bd2NooM2aTUFKfCW1xLmotnfX3Y7b3ieGAdVqMQ0kMW3XlAp4b3QmBJUtx5WQDF2CQDoZBBrZms3Dj1/QRgj/rl9q5p8EwPJcGIm/HKDSqeCO+FAIrQ86qdPVckU7swIhgVa3Jl9ZRSA4JI7X6nOuwZM4XsO8WwuQjF0zosAB8PyoOOM1V1ooTzfrkhmwtgmq+vUyNiEtvtvUrk8em3DdG4UPaai1AonipCc63Qxut7QjYlzP73oWPL9KOi/bPVpexHIcWLVvfrJBqn6cm46ATAgWqo/nqpOV+rZndWHbS7X3vRDp1+EzQB2KDuOMbH6yuWaRKAkOLxq53vROID4oldPyKCNF1g9Ol8ba5RBwBE7I29f91rHyg5tRyPQFBKFZT6Wa28Vi1N7d2H27vfBl50MkMIQECBv4rqb9YWHNfNRPhx8ttXO7uVCp1qWSrlBN7fzFWXS4UsJitj+KLd/22/k9Yapy60sCReY/JXt1ctzokIiOJU/LYz2gwDcAtH2jX9B5GbJr9sltfrdSICxDSOXw29P4d+6BROiiAApuSKiX+9vOpaRjZX7rfbX8t0J02YffqHQUGmP6uVbi80s1KHUfTtXvuJSGOlTt4yQAAMaMnAXy4uFl03a+6tg9Zf4rR/6tsBCKAI9EnZ+Wh1OWurVIgvtnafp0l8su0AiMhQ8rZrPFhcKBaLmYi9Xv9PA797+ooaUprWQP7HpWapNDFmUqm+3N57HAZptY4nUymFgfdxyb5fm8/sY0TsBsFvDwa9eoPOilFPwAAWTPz54nytVCIiZLjf6vzFSzpnRFUgABvoXsH6ZG05Mx2I1Bevdp6KJDyt7EDEpFyzjc+a85VMBGJ3NP7XzvCAFCGe/IhSShWRftWszNUqnBtARETf7e5/E3jxqcYrEAb+Pdf8eHGVG0ZW9lEY/fNOq11rkuWc3HYnIYpx+B9W52uH97Iiwved/l+8UVpvnLpYy3zvJop/c3d9Wq6+H/xxPN53CmCeEkyUkSokwa/mq0u1aiYiDIInQ+8Lb0y2iyzrEQgwGYSJyFRi1cS/Xl+xTZOIFKmdVucrkbSSmJ+h6iWknzXKNxfniQARR+Px13vtl0DpqXoIwIHWLPb54kKm6gDwfHvnYRIlp74dgKSokPx5o7w618xu4Q7i+E+vtjfT5HQRRFyJ+xXnbqlp21bWFtvd3h8H47FSdDI4NAKk6TyqXy03a4XJYj8R/WFz75k/lqcFKSMAKww+K7t3avOZCY6IXT/4p85oUGue/jmUpk0V/4ebywXTzN6XCvF1d/jQH5M2Xn9KrqrhoY3X9wOVpjIMVByrNJFhqIolxDO2sT4UEMAxeL1UyP6dClG0x/zcIjPAsms3SgVFhIih71tRes7zCGBzViu6tmUBQCpEwbH4eXfzkIFYsq1GuUhEDFFKYZ17/xYCOAarFRzLtogAAQq2xZOzt72ITISyY5WKLiAyRNPgNmd45sljQqCSbdeKhWzVhDN2MByjOvOiXSKyGKsXXcswJsZrkprdERCBUiBSSBJQEpIEkgQcTgCMqGjZ9VIhs2MSg3XDiIkznc8QwGJYLzqubWfTrT92rOi8Q8cMoGibjVKBABDR5qxgm+cPlSZiteBWigVFxBAHI9t8bSf9hAjXMOrFAiAiQJKmrmmwc9vOYlhxncphwf0wtLz4rOcBiAEULbNeLDA2MV4LlsHOCeZDZDNWcW3TsgCAIQqljByBvQyEyqGqM4aB51iRpLNHBARwTF4/VBJSqmCZ55QdAEyGZXfS6AxRiNTi43OeZwCuwesF1zBNIFJERdtiNL0H+JSyW4gV17ZsGwAQERFsziZLw6fBAaqu2yi6amK8YmE4xvAsKw6QlM1YNoZkEhUpcxydqYcEjKjsTCoWABykQhABKSACKSCJQaYgkeII0zRbvrUZqxULjmUCkVRq7DpGet5NVwygYFn10uSLCKWwTeOcKLOYqbrrlDM9BDhwbJ6c41WSiTBqpQJDZIiWwR3DOKe1kcBmvFqwC4VJc4+CwBzH5xgrHKBkmbVSYbpt5ZjnDc9IqpB1Dc4BgCGmSmZfz2elMgBqBbd4OIakSWoPPO3z+lNCRJQkMgpVmqg4VlHEXPeC10i/K66K8YqHRj1eMev+KkBKRfv7gy/+FLdapFRfiupf/cJZXrnAxYzvI9kYNXsTdC7dmFk4ZHj6JvXrKY6tNb65Z2aLL4erL28UQbMiJuU4LwnNJpmIyHGb6MkV0zc+PFO3gEgANBqw/V2+uYG+x149V3HE7txDy54Uefb9b5Ty2jPsTTHg8TDVTNrz01AWxXY2CcNT1sxPzdjkH2/4AiSA10W86coxygqT5X0i4jwZKvOvPRJxlq13hhSYra7sVWclwdmy59HDycthpuzn1i9lfquzffb8Fny97AiMvaH80+aY5A0BzraPYaa5Z39zPq8VIZOiJPXbbPuV0euAaeHDr+jGXbjzEcx22GnaHKPU8THnjePU6x0251XP+ceQUzSK4TmfXXByZDtPBM2uWGci6I0VdWKYuiJm0/VBxfH4yePR99+K0Uj1+wyo8tnnRqmEb7x58d1z+TkAACKSQigpVfYPIfTX1SykVNhusZ2t//pvf/l//He/crrtqNOms5fWNJq3AAHUeFwedf/9nfX/23/9L//xxlKhu09pcs56nkZzTSAlYTRs+qP/+u//7f/j//A/3VZRsvMKAHJ9amg07yMIMomDlxsPKsX/+3/59V+vLcnd7TQMr8ilEFdi5XXU7XZ3dnaePBm2Wi+++trr92988ol16NikASKVJrWC+3/63/8XZPjo8ZP2h2zfH1t6Ovrqfv0BPPV5yL7PgWY+0U+uZeHsK7O1DzolCR5PciwLmK0rvf7OM84XHyY5Kw+vicDDRavjS1cnS4HHSzH5xwkpp/zm2Frw4d+USMu2/e/+5hd//Yuff/nNt9/9//7XUKnZJNkLzhbxer2dtlByasW+tsw3m+7k8/BaRSHQTIo3tN20So8392xBTpYC4RQRMNPcx5aoTlubPlUJZ0sxFXTW83DyNyfKfvKx15QE8bWynquHcErZTxVBs2U5mc1zCpJPb1/PEs6sdZ584KSI08gnYvorIkY0Vyn9l//8nx7cv7f/8uXD7Y51vDfRKaV4Q65OqDocVyqYrdgTBXlj253cwDg1ycy/ThnZXnvt8RIeFeDMbJwxTF3s+dcFn1QqhNe63Jmcuhh/obTHGu2Cac//zfnJf2oQFIFIf/Hzn/1f/y//5//tv//j8//+TySVNl6P6O3tv/rqSycKH6yvJfu7T/f3Fm/etM6JA3ItkUolSYyMKfkBrrkiogsqfvVMHOxkdjnzRnsq+f1wcgJHKdX3Q2KW4+wwxgBRDQcUePzR18A5EKAS0aD93ai7+crNPMP8MAwi4YyCrNsTKeq3MfRx2AMiQoTQ3/OH/+p7hmEQkVKqM/LA7joH+0gEiBT6ajhgj7/NbklVUgy94Xcmbm7vZHkO4zgch1YQmYaZXRIj+11knPkjAFBSsjh8Belwd5cdnqNvjTxUzBmPsnJTGqthn6VRdsJa+d5QxF+2LdO0MuM1EcIbjK2Rnx1GVklMoY+cs34HEEEINR487h/s2dlNiYCIPS8wwoSJFBgnKdRwCAZngw5yAxDJ97pJ8K/DHmcsG4WkUL4f2ZYD4xFwiuJYKGlwzgLffvKQuUUx7D7t8M72VvbFpKQcRDESdw72kHOQUg06GIfoj7KKNeJwGHl/Hg1MPhHh+WGgwHEOmGFOKtYbsqffoWVl9abGg+eMhgf7mc9rmoq2Fxhu3zXtbJ5TvRYoYt99MdEXEfeHvS9GPduyMt/BgecLCfZgmE0JlCY07uOrp9jazTRK+KNXIvKHg6whpFKd4djoDlxnC7LmHo9U4LFHXyPnpBQmcTvxv2rt2badiRj5YRSlztibRDUikv0ODrts0M2+MJMkfMjBse3s8Lkkag09w3RY+wAyDQt9SGIWemiYICV4ox1G6d4uMyanWIIkEV7o+BGZJhBRktjB0GYoBl2clB1AytGo+3W/U3AmGfODMEmVPfazXXsSKY36uKWw15p4EgTjncQXw8HUQ/FgOEar6+7vARAgqvFQBWP++Fs0TVIK0qQXeV/tmQXXyUQEcRz5sTP26fCInuy2wDS4SIBISami4CmKvd3d7IAdEbU9n6HpdDsIQAQUBzTss+ffo+2CUhD4e5TKPWtyYAsgEiIc+c7YJ9MCIkpi5XvIORsPgDFKknQ8+Drou6Y5ObAF0PJDUwDzxwAIJJXvkZToDZhlAwGMBm0Z/z44dNUlitI0ClOn3cmitlEQqDhg/hhMCwFRCTHofj/u7byaLJ2IVHSi2AaDLBsGvZhDGMVxkghFvNtyH/6Fh0EvGP0p9EzOiICIxkGYEHftPWYYgEhhQOMRqm9xGqJk2H3OoX9wkKl6HMcDLzT9CA0Ts77Q7wJjLPQBgBB5GneHvS/GfcuaHF3qj8dScWc0zroCxbEadtnz79F2gEgplfjjpyja+weZc0gqxHAwNkY+s91M1WW3TUlsfP8lACNSGIV7Kk72LGN6eC4IZZTaXkCMASIJobwhbr9koz4AUBIHcfjQxA3bnpqR3cHYNB3e3gcAUoq8MUUBe/INGiYpxcbDVwaMtyextLKjqKkXOp6PhglKqSiiOMRBl7X2AJGi0AvGfx4PrMMxREnVCiKHmdTZB2SUppY/5EREEPT7r/74x4PvH+Vc05FSBoO+TFMg8rvdjd//zj4Zh+F0UIrU63aklKDUqNV6/i//bLmFXGkRRZqMDw5ISgAY7u4++6d/NG0nZ56VkqP9A1IEBKDUT7Z6RUQiFUmcpEKAmniXXAUwTdM//PFP//P//L/s7u69fqoXsb629vH/+D/W19Ypz43Jb8ujP/6x9e03P7t949OPP/7u+0f/25/+8pv/5/+7vrT4ToVO6WxsbPzh950XL4CIHEd+9EDdvndOlL6fHiXF8LuH8R9+++//h18hwJ+++Br/6pflTz7l50TNfIcgKMmeP2FPvmdRCIhKqXK5/Fd/9blzkcVy3w+ePXu2v39g2zYAEFEqRJCmSh2+gYCUPNYKhy5x2ScoAQAdWxNSSoKacf+fuMlO/Bqn3nVTrz0iysYRnEkB7MhJkQiUoqkrFxGRUkB07Lub4WyARqkUAjKGE4lArw80iIhs6ilLRAQwPTpDioDU60HOGUM2WY2gwyqeJlGKQKmjQh2KQMayGAnTBZ1pKZRS7LWWYhwZC32PAdy6eWN1ZXkwHH7z7Xem4ximqRQBqZnz8hNnU5wECIIsCsGxxROiY19Z01WgifEEBMe8hZVSoNSxip20BRyVayZuBBEpKV9fLmPHHEyz/B4lUYpmREyqnXGYeScRHG+77JDZ8bqdiW6b1e9UIUkR0onmPsxV9k5FwA7Xq0gREeGMCEDGOB65aiDajJucJVImh/VJh13jSG8Zw8NPkXPKDjOLeyxTwqniAWQndab5JKWAFM52DnbMS1gRwbHqUofVNVN25MCO8qOAGJxddkBgOI3WlGUJp88TUHamcPaIDzLk0953dKwRZyrqeJyHY6WY+NXPLJyfVHU43MeJg5CU/KvPP5ubm/vTn/683+7MLS5kwxTNtgUiIZuuqWYnkpDO1MOTY8hrbQdESqpjvsYnxhAFwGdGLcp60+yiKjt2ZkAqAgB+9AYAUqBmVB2RIQN2dPJMEUzXcImAgPD1kY0dBmSY/JrgSKOIFEya+7BYk1wdjiGHS/g4GdpBKYl0/DgXYzMnlZFxVrQMk3GaiszP0Vh00au8M9nsJ06L2Q4IIhFRvSn+9j9CXoP7bUFMR6POP/y3m5we3L/36tXW86FX+o//yWnOvdtQu4iQpvjqhfHsMXrj15aclVLVauX/+//5f12JlVcAsCxrYX7+1u2b/cGQG+a5buLXDkRWWFqmz/7qL9lJ5/sfO0vLeDKCyfsMInLGStn5dwAAUERS4aw1jIjGzJmAbKCd7UNCojo+UTGGxmuzwsxsrIgkZ6+J4NlB8WmS49+ZUik5M8QDAGPsmIjJbuPURCOp1BtEzJjgBKCUksc+25BPAofi4fszE3ymFFLNRiM4WVEwU3ACUoqOiwDOOGdoF9woijZfvtx8+RKILM7LtsU5V4qEUsd3xo+VYrbUmTQppTp2CgUNjgxnKwrwyGbImvv1inq9FDOlJiJxvO0AkDPkM22hCBBpmquTFcWQ8ZnoEocBmI5sApGj7WaTSKWkOj7bHhcBxzXqFBFZczOcFpgxDog2kD1jrEj1BlVXADijV6eVHfls9WafH4ctQkRSKXU8Y4wfu5SCiABhtnqFPKYkr4kABKLZsoNUSs2EVkAAxjjnk7JPvxiOPh0BXhNxQg8n7zmqKMKj72EAADA4nzGICQCQHVmGUiml2MmKAoAEKAjDh98+ZIhKqflapWQaJ9ti0oIXGkMQjZmQc1npZ3oTCfkmPTzRm060BeMcZ98Jsx2WSJwYbKcFP0py+IlKRIpAqvOa+7W2OKWDH6+omc+FaUWxE8MUY1NPBQRExhmHzKA7bM2cIEzXMuDCaWdcJehiSQFPVGlOpl/JCPkT/TCIuG2XH3y83261Wn1yivbCilk869Kfn5orYQAxw/DD6Mtvvh2MRts7ewSkr9CYBRmz5+atehPwcFjjOY6fv1copYI0DUxHHQbiZnFoK1k4vImKSAVxMrJMMu1sDU+FASUJL5cnB8CVYrFfMphlGFnfjpN4HCuq1GA64AYemiazJivWmMRWGhQdexL8EigI49g2yXYmw4NIKYnRcSHLFSkzDFwA07QAAAESIUaxUOUyHGabQh+QoeMCACmFaVIkZRvG9HhmEMchMShMwveQkioMmFNAgwMBJYmt0iI3sm0QBJBEXpKkTiG7qYhESkIg52haAAAkMQxLDC0+CT2BAJEUA6GwUARkpCSFEXCOpolZJtPEllHRMo/MDqU8SYlhYKkAJVJxREmKhQLjvA8IRBgGRUT78B4jUjIUKmJ80hak5HiElsXc4mQlQKRWKkvmUamjOPKBS9fJGotEQmHAikf1xqKgAJjdIIAAQkkvikWhCOYkWKb0x0DAS+VDjZGGPy5ZppGtuwBEcTImIHty2xkppXyPue70+iUWB45UrmNPNcqLksRwJyIQKI4pTVnBBWREBEK4MnY5n25JJUKME6lKpWnMAeV7YBiZRikpTJmUEIyjAPjkJ2nMTbLtbGEWRKqkYpYNjAERRWER0DWN6ZQtlBpJKczCpGZE6kjBlYqQSXuiM6ikEQZFzvkkOizEcTJMFR3G+iVSajxmjoOZXABMYkeGhRlfLC8MY9uFrC8gqiikIOCVGjBGRCilJaMCZzyLygmQCjFMhCqWpk2mvBEwzgqFTCVYkhRB2aY5LUuYJiExsg/jE4tUxSG6BeQGAEGSFJBcw5h+gUqS40QKq5iJIJFQkgLjzLYBkKRkUVA1DQNxOnlHQgwVgFvI9FLFMShC255caRaFtpAle3qbHaVSDhVIywJuAIKKIkoT7hYgWwsgxQK/xJnFJ0olpQyFDLM82EUqVaU3RtNithMhRICYJmYSlmzrcECmMIrHjCnrUNXTBOIICkWcqnroFQBsc5IrIdJRlKhKDQyefWgq3wfErGIBAYUwIq9km0eXFMTRSCEVJ+FOSUoKfeYWwDAyQ4wnkUsyiwCIAFKpcRTLYokO+4IKfRKSlytZT6A0cVXiGkfDTizESCqyJxo16eO2M3E8kMJIkiJjsza3lyQx45lGkZKUpCAFKxQAGRBBFBYBnEP1QIBUqYFUynGAcQBScQxSomlORjaRGmlUNo3pFy8pFUgVGQZYNgCAFEYSVxEtwzBdt9ics1w3pzFISsWe53U6pJRZKJTm5kzbyZtWqmg88ns9IDKLxVKzaVh2nrQIoKQMhsOw3wcAu1wuNZrcNPPnORwMg35P0emRy98FzLKKd+8Vb9+d/Hxid+sSuRLGa7XR6MzNb2xvb3SHADB385Z1lXbtrwSIaM401odVOQigCAYS+jdvyUo9K12x1/6Yok+nlxQI8Wzv4KFR9Mp1ZhjAmNrZpH6P3/kUTJMIuExXWjv35irNSjlby9w/aH3ZH7fW78FhbEvaeAbVKptfylY7i6PBg3HrwY217LYbIcSjV9uP3KrfWJj4vA4H0D6AG7fQsrNLCu6M2vcKRqNeBwBE7A/Hf9rZb63ekbaT+avR7iZwE5dWAFClSWE8/MhI1+tV49As+35r96FgwfI6AAAihSHtbePSKhYKQET93kcy+LRRLhTcbGcriJM/bGy1msuqXAUi5Y1hPETHxXoTECFNSq29z5rFpXIp++RjiBvt7u+6Xrp2CwyDkkTtvAK3yBpzaJqAyAfdu/H456tLE4dUoiRNf7ff23fKWK0DALUPaNCFtZssMwSJaq3tTyruWqOWVWwcRa/6oy+lGdYaaBiQpvLpd1hrsNUboBQhWr53x+v8bGXBPvyQ2Nk7eJjCXm2eWTYg0qBHWxvs5gPI3MWIar2DezbenGtkCwxBGH67tfu8vhQXK9najHr+GJRi9z7JVIYn4a32zmerC0eXFOy3vvTT/tJ65vhBcQQvn8HSKlbr2SJho9+6LYM7aytZQySp+OrV9n51Pq7UJ83dbcOwjzfugGEopczQ/zwe36sVs+CXiLjf7f25M+qu3p5czUCktjagUGLzi0Akw2AxGP1NySyXS4wxBBBKfb25u2OVkuYCEpFMYTSEIICFZbQskJK392+47F6jOg3U3/eD3+912vOrYDtARONh7WDbHg2Gzbn45kdZX2BC3O7vfdyoVEqTeMP77c4Xg6C9cpOYAQiUxPD0ESwtY3MhU/XyoLeaDD+eXlKg1Fcbm08L9bAxj0SAjFq7anuT3f4YbYeU4mF4Lxp+UnXLh5cU9IajP+11D1ZukmlnSz/q2fdou3jjNhDJNKl7w88MudioZYE8iejx7v43yg7nFzFb2RoPaXcb129jqQRKsUH3F4b6uFbiWddAHIXh7zf39xfWMq0gb0T9Llg2W1gGxigM653df7u2UHOdwziv8OSgu+WnyfJ6ttWo2vskBTYXWKEIBLy1e19Ff31rLas3IuqPvT8N/INSI7sISnXbNOiyxRUolhAZirSxv/Wz+epStZKJCHz/SW+4wVysN5EbJCW9eoblGs4vZhVrj4d3x52frS/b5iTO69be/tdkdStNblmASMMe7O3C7Y/w0LtxobN7w2Frc81M1YfD4Zebe9vrHwnHnYwhL5+DYeD6LQAgRCsO73Z2Pl2ZuaRga/u7lA1Wbk7GEN+nV89x/TaWykCkhFzweh9zsXx4SUEYxX9+/mpzfi2tVDNVV1svyff4R58CYyQEHw9/CfHdesmxHQJgiDvd3p/7Xn/pZmblQ5LIxw9xcZktLAMQBf5qOLpftmql0nRh/E8vt3fsimjOAxGlKfXaMB6xm3fBskipQnvvToHfrlencV67nv8vB73+/CpYNiipel0KPCxXWa0BiOiPV4ftz9cWXdPMxpA0Tb9pD16BRY05QKTAt3deOrFnm1ian7//6980btzI5WqIKOL44PGjR3//9yKOK4uLD37zn6srKznTpmG4++03T//hH5SU9dXV+7/+TWl+Pk9aRIx9f+uLvzz/7W8BoHnjxr2/+3WhVsu5ciuSZPNf//jsX/4ZCOCsq7/fAcj5sZtoroztcSWM17m1tdrCgjwMMM44tw97qeaID7xCCBCxVMFaY+KdGge2Yo1GPfuzEKIaJQYrYLmOpgmM4aAHYYC1OpgWALAkhkG7VCo1G/XskoJIiAIYWGtM/MmUQtuGYnkiApGBcqRXr9emlxSUBiPDrWGtkQ3xoCQMe1CpoeOCUpAmhvCLJatxeMOW4twah6xaV4cTD/S7YJhYawICxDEDKvC4Xq9ZlpXtHrrDMUsYZtcOIYLpQb+Llepk4klTU7BqpVwulyELMB7FZrvPKjWq1oEIuQFCoONgrQGIEEfMG5Ur1Ua9Mr2koB0lLJBYrYNpQhLjsAdOASs1zBbeRGoZqt6oHbukwEuYU4EsV3EIcQjFMpbKgIyUYuNeqVxsNOqTSwqiqK+ACROrdTRNSFPmFrBUxloDlMq+zg3p12rV6SUFQZw4EWGljo4DiCAlmDZWahO3LSIMvYKLjUY9m9Gd0C15IavWsVjJvvWzJsjqjRBZ6JvBoFqrVovFrLmHUWQaYtLciBgGZJhQKk81iqWhK7BRr2Xbb0mauv0Rq9awmjU3gyiEwMdqDUwLlWKGabK0XClXK5XJoSWprJTh9OoyImzvY6mEtQYQoGlxpspls1GvM86ytSV3MGZWBWtNJAVCkCRQhJUqOi4IgYFvu1CtVrJA/QxRGgYb+KxaI6cARMA4DroAfbSsic4AYhqzoFeulBu1ama8BmlqKYNVG4obgIBRRLYNpQrWmkAKEJlMnUg06vWjSwp6Q144VHXGyB+jZWO1Pqln0zN4Wq6UGrVaJkIyZgUCaw04NF7RdsF1s1xhFHGkkpHW6jXTNImIiNyxz8jGWuPQC5LAsrBSwUoNlGIitVlaqVRs18l6E/Nts++zap0KRSACw4QkBtPCah04B9PjwbBaqzaKheklBW6QICRQrSNjkCYYhxDFWK5iuQIA6A8deTSGABEZhpUyrFShXAUAJlJSEqp1LJURGUtiHLTL5XKjUZ9cUmBbZQkMbKg20DBASuiUsFw5GkNImalXq9Vc28qM13GS2KkBlRraDiCCUjAaQVaxWba9vls0Gs1GplSM89I44rWGnI4hpQMwzOkQwULfCga1arWc3WsA0BqNzQSPxhBugO1gpYbVGiiFQjBKCjytN+rZJrsfxU53wGo1PPxOg/YBpsmkswjBABwKatVaoXh4SYGQLAFWq08Wa+OIWSYWi1hvZE1jcFUq2/V6bepIYPdGzDqsmTSFOIIowkoNHAeUZMG4WDIbjfrUeE0Mg43iw9FVoiJAmAwjiMgYT4NavTZ7SYEbCgQbsqHPsnHYgzSAIz//fBu2iK+FpP1p0uJry5bZqxjLObNf2pLnVTU8roTxapimYVlHjkoAP81RLc2VAxkwDtnd5cgQcbqNpRhjWVef/peFTM/+DZCZLIwxxhhkswJjjPOjBwAyf4Nsx3Y6DE2SAGTvR3aYBzxFRPY854woO1syk6Vs4pmKwOygFZsI4Cxz+DtKkuWHHYrgHJQ6liXEU0Sww3M2hwnxUALOlOIo25O6mpYCYUZEZryy7BjEsZqcpp2cgsfD56dpT7TFsUIdEwHAOENGxx6eZIlPri9iEyE0GdUZ4xxn8z+t2KkIxqbNPa0o5IymLwc80qiZ5s6M15nmPqzYqYgTGjUt+FGWACAzebOC0/HmZgwRWDblsKMHjrUFY9mtClkagEONmj4wzdVUVQCyFswyxhnLbtg6ljGEw7Iw4AzUsRaZGK+zekj0esZmVD0r++t6OPFFwKNGz8o+0wFVplc0U1dni4DDRn9d1XFWFY+9H46sgRk9nP0PYHYMyfLAs7OPR3k4HB8Yn/apWRF8kr2ZXOHsv19PQgCc8SO9mjw806CTfOOx3jRV9ckYwoAx4Gziynq8LQ5V91hfOFGxh8PCzBiCs9meVfWsbomdbG5kjGb6wqGq02yWpsbriWFqNlcEONNhp6rOZh6Yff74yDYZQybae0JXp+Q/AnXysUtJmyV8a7nXmythvGYzqG4ZzUkOXfPzRufAbEo9/H/+JFNZF3r+wiLyPw/ZiYRcSfDiuZo+D/kuIXjt/RcTccHnL1qx+Zv7qGIvqFH5czVtC8wdw/EtCg4XLzvABbL0dhk7pofvTsThk3mrd+axC4vIJeHte9/bjSEXKEXuMeQtcjUVkZ+3H6Zyt4XmmnAljFeN5lQOz8wCAAilFL3hE4eAhFJCqmwfWag3fxIpIqEUlwoIhFDqTQmy4+GpUACAiOK1k8xni0AxCVT0ZhFZKZTKIqPkESGJUqWyVQilQL5JhAISSjGhCAiyA+/nZ4lA0vTIMwqlzhdBAEQglBJicsJdvKnYRyIOK/aNxc7a4lhzv+l5STSpWICstc9Pog5FZItk4k0KRQBCqVQpLgEBsrydX4pMBJNTjcr1GT/RQ6mIiKkcZQdSREIonJw8zJuxo7K/qbYIIKtelIqIFNEb+99R78vXmwhAKJrWKiLmKsXhGAJEeap3qlQAkGYVda7dNFtRUir55rYASZOuMSl1blXPalTSG/JEQFKRkCpzG3gtosUbS8HyqjoJqbKV1zePzkeqjgDA8nRYeG0MeXNbaK4P2njVXFFSgB0vUC+2sh+JVC+Kk7J76oc+AigAL5Xf7be2Rl4WktAPwjGzzloZQMBE0p4Xylc7nPNso7PthfHpEiYBSrpB9HA83PRjAECEME7GUtKpqwJEjLOE843ucOCH7DAS+54XJsXqWaVmptX1xJfbB5YzAEBESKUaEKNZl/ljCVhsu486g93+MCspQ+hEiXAKZxSciBvtWP7p1Q6frLqSUmog2eSo8muJCBAxQvak3W97AWUnvKTsC4qL9qkiEEAhdlL5581dk7FstvHCcGSXzlmkiaV83hkN4jTbKRVCHESJrNBZbaEIulH81daebVlZcw/9IHLKZ02HCBCmcqM38JBlqzmS1EEUSzqzuSXi3sijKLDdQbbXOo6SgFmnPQ4AhNzwJXy713aHXnZbvSLaC2LpcDzV7EMkp7A9asd+wLOD4QiBkAEz6JyrwxGIqB+n3+weuL0hETCEcRj6zCE4fXkKARIht/ujFLcOA2uo/SBKi2dYAojEsO0FX/njQm+UlT1MUp/OyBURch4Be9Lp7wUR45wIgGg/jNJK8aw2J9Pa7vdT3zMOyx4JOaazHfs4D037691WgeMkVjrSQaKkXTor9IoyrAN/+IfDMQSIIiHHYMAZ1asQAzS+b3V3R14mQoq0LQjKpbOURAB2ouQvm7sGZ0QApEZhFBTq55hYQSqftYe9WGSBp+I46Uopz1hZzFS9HcZfbu1ZtpWZe73xODx7DAEEL06ejLrtWAAiIqRC9pJUnSECEJVpbne8OPBNyyRChjCIkpjZZ/YmbowlPdxvuf3RNMzCQSxV8XSLAgGF7WyMh2PfzyqfIXhCBuwoIMlrEONDCX/Z3LPYJOwxKbUvCCqlMwuuuU5o41VzNaG0UtvjRuswKg4BkMOEexSp5/UEnHuLq09FingYdLxSktY59zhQWijuLd44YEfbnMquimIZzjA1gBvD5uI4ibmRrV8BGaCq5jQAzeswLkrlTbm4NXP3rGxUZKF4WnYAAKBY7MPCKA4xc14kIBNF2T6KN/RaEm4k9ebzwGFSwKEbgKpw5RRedwibJiqUurA0FOmMRYXCssEtwqnWK0DUmN+Io1ekpn9UzBBu8UwRjtNrLg9kMn0XWWVhO3BWRQHE9blXtrvFcSLTBFU0hOOebsoQKNPqz6+OSGVuAEBAtbJ0CmfuLhJF1doWZ7vGYVAzAOXWpFs4fT0RUdl2u7ncU3ISBp9AlVHZ7lmlRssKqvXHhjGNREkA0qmraXivEyKoUt1luJ8mUxFkMmE7YJw9MhMRNwZzK56cUfVySdouTT0aT5AWK7vzq/t8EqeVCGiuJgrls9ZSleX0GovDNGXGNGNIlk1ZlKuTReE8KlWeKzXZDkYAAuHUVPFMU4MK5X1S7SSeKTuKqkPm6Z8HaJpRc+FRFKBSU1WXjqncwpkVVat1LLOvxOFvAGxMLQeyCGIn64nxcG7pWRqx6QqfhYoZUDhT1VWh0FlY6yPh4QvJrqZOAc9W9bAx/zIubx6qOhlAVVOd/bw0zc7CWg8OVR1ANUrKPW0MAQAAZCyqNl6a1ibnh2MIqEJdnj6GECJSobhXXTyY0ShVZtJ2ifFTNIoILXNcbT42rKmqA4As2KpQPMs1M63UtkxjR6SHLwFlYmq7YJzxWW47o+bSwzQ+GqYIZMmCgjZeNQDaeNVcWahYFsVKevyXCISnDo5EwLhqLsZ4bG5FONsdnojcQloo0rHnAc5Ogpyr5oJETE+KOC0JIoLlpguF2b+dLwJMS9abAvGUUpyShACR3GLiFl+bis8sOBFYlrLn4pzPQ2Zj1ZITU/05IsiwRGOOTog4ve2mIqp1eK0tiE5fswQCw5Dzy+L4b88rBQCVq6JSS0+ION0aAwDTkgsrIrdGIWNUqiTl6uulOCsJIlmOaDqUt7kP4VzNLcavZ/hcVS+VRbmSU9URAAxDzS3J/GVHBLeQFIoXKbsp7fm8qk4EjFOpEpeOrTge3mdwRsHdonBLJ8eQw0Z/3SYDxqBWT07qLZxxKIeILFcuFE7q4ZmqDqDqTZm/xYnIMMXC8mt/O7ctGFXrSa1xsjed1RZgmGJuMb8IYlyWKuJkWxCc9eVPjps67skx4czmNgyqNU4bps4QoblmaONVc1UhAjh91/jsJAovNKwRAV1UxHnT0qkJ3rmIyfsvmuRdPv92Ii56aJPURSv24m1xYY26uHrAhQsOH0bZ307VL/b8xceQi6r6TzCGvE1z/xQiLtwW8M6HHc21QV9kpdFoNBqNRqN5b9DGq0aj0Wg0Go3mvUG7DWiuEpOwgTn2r6ZPXiCcJh79d9Hn8wcz/EEichc8p4jX3v8ukry1CHhnpf7hIn6i5s6XZDZtfinwFi1yESlwwbJnz791h313evjWLXjR59+pUr1Fc7+1eryTun3bttNcV7TxqrkqIBCLIwoDoBz3qzEGSaykwDBEIfLcPkJKkUghiVkY5LqtBJmKI0hTjELMeQ8KkUpiUIqFQS4nVESKQpUmLAqRG7kKHoWUxAjAwiDX+9ME0gSQsSjE7C6rNyVRcQwixShknJ8VVGj2eRApiBSTGMMAct0PzlQcgRQYhTi5UC1PQVIglavUMKlYkCnGEebWKBVHkCb5NQqIKE0wzqtRJIWKI0gSllujKI5QSQRgIr1A2eP4qOx5WiTrTUrmzxgAUJoCT/KWnYjiCKRgUYimlSeJikJIEiRiYXDWYf8jMj1MYkoTjEJmGHlUneJIpQlGEXIjjx1ESlGaQO4WB2QUR3TRMSRNICt1nnbIxhCZsihEy8rXAVGlCWQalc9SpCRGJTEbPHOIICFUMhlGcg07pCCOKEkwjvKObFGIafrmJzUfKNp41Vw+BIDIykD05BtxRiSsk6goVGnKv/jdWVEeX5dCpAIfey229SKviDRRUcS9Yd6brwFE4CEyvr/15kezXCkpw4D3W8hzdUYlhBIJIDPylYKUoiQGxnB7I2cpVJJQmmC/w84J2PSaDN/HYRf3NnM9D6DSVIU+//pf8az4tSeQvkcAhj/K+TwppQIPgzEzzwxC9LqIKKI0NsaDN5tKh4jAQ27yree5skRKpSmJlLd3MKeeK1kk6TDEzl40HOTMFSmlAh+DMXv1NGcSlcQyCo0v/3ABVffGyJD3DnJliUiJlOKIh+O8qi4FxQkyxnLqVWb2KYX7Wzn1ikRCQmBrL2epJyZ4a+8CFZumlMRs1M9fsTIMAJG3dvKKkEKGgRF6+XuTCHwlhfXnf8n5/KQ3hT7b3sj7fBqDSJk/yjvsiBSEQMM4J8rYayJMkRpWjg9szYeINl41VwKGULItW0hSMm8ai5PFkdL8B1LJtRAAVJI3AScq2ggCcixnTEQ4JgBifhFA5FoIMteSCQAwIssAgAuIsLIpLXcpDCDDApCYM0sAVLAvXLGlAoKE/M3tmnShUgNQwUFQF8iVhWQ5DESehdqJCOdiGkUGgGEiiJwFRwTGOTcNW0l5obIXbaSLtIiBqlRgF1L1ggUXahGDiDsXUHUEci6o6gYCcMivV4zIMhgKULlHEdsAoItULJBhIV2kYu0LlhqJCs6FehM5BoBx8d50EVU3OZjsAoMnJ2Ac8AJ1ixY3zwoTq/nQ0car5kqAiJxznnvlYJLqghH/Lvr824mAd5yrtxBxUS4q4ieo2LdIcgVFvHXbcXi3XeMtknwwqv6uozF9GBV7BdsOAI7uUMDcHtsnH/shvrZv4Tp8zm/OT66ZQRuvmquCYRiFQuGi9qtG82ETRVGaprZtW9ZZN9NqNNcRIVLf95WUQb//6o9/PPj+UU53bSllMOjLNAUiv9vd+P3v7GIpX1qUIvW6HSklKDVqtZ7/yz9bbiGfAzSKNBkfHJCUADDc3X32T/9o2k7OPCslR/sHpAgIQOVwI/7Q0car5kcAEXD2osBcSfC1H23bXl5edF332vdKjeaIg4PWeDxqNhv1ev2y86LRXBWIyPf9zc0tKZNoPN59+PBi6Q8nrHA02vnmm4tKzxx5g34/6PXeLq3X7XqdzgVSAdB0ks3t0PUBo41XzQ9FKTUee69ebVmWSbkNzziOx2PvtfckSYLI9O1/Gs2UNE2lVGmaxnF02XnRaK4KRJQkCU0u7gICyD/7ZEmyjfi3SXu48oLZBWsXma9mj6/R5LbbXNCh3J/A0eW9QBuvmh8Bz/OfPs17/HYKIpqHJ8GJKIqiV6/yHtLXaK4JREREBwcHBwety86LRnOlIKUIGTNtu9ics1w3pzFISsWe53U6pJRZKJTm5kzbyZtWqmg88ns9IDKLxVKzaVh2nrQIoKQMhsOw3wcAu1wuNZrcNPPnORwMg35PTd18rzfaeNX8UAzDKBYLF/v8BAAAxtis8wARkd4N0WhOgqik7hoazSkg56X5+fu//k3jxo1cMwiiiOODx48e/f3fiziuLC4++M1/rq6s5EybhuHut988/Yd/UFLWV1fv//o3pfn5PGkRMfb9rS/+8vy3vwWA5o0b9/7u14VaLefUKZJk81//+Oxf/hkIgHNtv2rjVfNDUUqlacoNjogX2AQhklJyzqf2KzEGpqmD9mk0xxApKAWcQ77wqBrNdUEpSGLMPAcQ80bSRcTj6yY/TdrJkzN35iFjyFjOo1fH0mq08ar54UilGGOLC4uGYeRff03SZNAfJEkyOUONSMWyWrsBOU9uajTXAzzYZcOBmlugxtxl50WjuUKgP2Ybz1GKyc+5L4c75bFLSZslfGu51xttvGp+KAyxWCrdvHnDcez8xqsfhFLKTvvwuCUi2DYtLlO1pnupRjOFBz6EATWbau3mZedFo7kyEGG3zTZfgdCXxF5HtPGq+aFk9ws4ju04Tn7jVUplvhbSFRFMA0xTG68azRHZdiHjkPueW43mw4cIuAF6I/26oo1XzY8DHXKB50/77QW2UTSaa4XuFxrNFCIdM+o6o41XzZUBERiD3A7sGs21YHL/JIOcZ0o0musAke4R1xltvGquBkQQ+Li9ib2eNl41minY70EYYHuf6UByGs0RBN4YpNBn8K8n2njVXA2I0Bvzx9/rj2mN5hhSoFJs8yXsbF92VjSaqwQRiJT0lHEt0car5qqARCAS7cWk0RwDERBQChDizQ9rNNeHbM1Vr7xeS7TxqrkqkGGCbQHj2g1fozkiSVAqMk0w+Jsf1miuCQQgJUbhZedDczlo41VzNWCMqjV5+yMqlbTPq0Yzhb/aYMO+XFlXc/OXnReN5sqgFBv0+ZPvWZpcdlY0l4A2XjVXBs6hVgN9SYFGM0v7AMZDKBSgqW/Y0mgOUUQA+ozEtUUbr5qrRBYSSLsNaDRHTC9D1/O0RnMIo0kUOc21RI+GGo1Go9FoNJr3hhwrr5MQ2R/u980pRdNnGM/ljJpBxB9h0VRXu0ZzKrpraDRTXp9qchsqJx/Lb+S8i7Q5OfnkBzwg5CjaucYrUdDvb/z+97vFb/Jf+/neEY3GXqcz+UEItreDvq89ac4HB30UaaZhUsper/ftt98ZBs+vJmmajsceTnWUCMdj9ug7sG3t86rRTMF+DwKfbb7EXvey86LRXCEwDCBNCCjo93e++Wqws035LvJQUnqdthQCiPxud/vLL7sbG7mMHESVJqODAyUlKTVutV/9+c9uuZwzrUyTwc4OKEVEo729V3/6V7tQzGlcKSX7W///du5mp0EgCOD4DCwfaYk927cz+pKNT6Dx5MEXMKlnowe6LDseaEmjsZbWmID/XzhAwkL42N1hw+yzRRNRfX9Lnx7FZZPtK8307VU2mwO7aNM0d/cPq9Xtev2SfInYzMxinOwN6qhqkuxHUWKRvy4PURFN+m+jEEJd1ye8I865PM/SdDcBkNl2AdDrmmWqBrBPRUS72mFmrihSd3QOj1mMMXgvZmaWFUUyqGzbBu+7dVeWSXrsHHZmFkNom6bbzMpShwyTtSG0u/NOvEHQPgHmsxjjYnFxc331wwNTVT36wUyEqug/u+TzOOeqqvqFA0377xTgHFQN4Buq2nq/DeyGlw3ey0llRTUcHB08rKnrE0vSV5KwBQAAgBEheAUAAMBoELwCAABgNAheAQAAMBrbhC2zLutuuslrAAAAGK0+UHUiMp/NlsvLPMsGzdoAAAAA/A2LcV7N8yL/ALnNxnzglZqqAAAAAElFTkSuQmCC) - -## 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. - -- > 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 <<< >>>, 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= [DEPRECATED] This option is being replaced by --offload-arch= . 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= Generate code to support up to the specified number of threads per block. | -| -O | Specify the optimization level. | -| | -offload-arch= 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: - -- > - -``` -|> 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 > 256 - -Kernel code should use \_\_attribute\_\_((amdgpu\_flat\_work\_group\_size(<min>,<max>))) . 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(&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 <<< >>> 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 <<<>>> syntax, hipLaunchKernelGGL. The latter one is macro which expand to CUDA <<<>>> 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 <<<>>> 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: - -``` - - - - - - - - - - - - - - - - - - > - - // - - } -``` - -The below sample shows how to use hipModuleGetFunction . - -``` -#include -#include -#include -#include -#include -``` - -``` -#include -#include -#include -#include -#include -``` - -``` -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;iargBuffer(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 tex; - - __global__ void tex2dKernel(hipLaunchParm lp, float* outputData, - // -``` - -``` - } - - // Host code: - - texture 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 <hip/hiprtc.h> - -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 kernel_binary(codeSize); - hiprtcGetCode(prog, kernel_binary.data()); -``` - -After loading the binary, hiprtcProgram can be destroyed. hiprtcDestroyProgram(&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 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 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"); -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: - -``` - - - - - > -``` - -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 - 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. - -``` - - - -

-

-

- -

-

- - - - - - - - - - - - - -``` - -## 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. - -``` - - - -

test, which caused a segmentation fault issue.

> - 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 < 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: - -``` - - - - - <& & - - - - Loggging examples > - - - > - -
-

-
- - - - - -
- -
-``` - -(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. - -``` - - - - 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/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.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 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; - 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 -#include - -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 -#include - -// 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 -#include - -// 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 - #include - - // 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(&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 - #include - - // 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 - #include - - // 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 ( <<< >>> ) 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 >= 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(&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 <<< >>> 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<<>> (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 <<< >>> 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<<>> (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\_<type\_name>() . 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> - -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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable\_if<\_\_hip\_is\_tex\_surf\_channel\_type< T >::value>::type* = nullptr> 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 - - __global__ void run_printf() { printf("Hello World\n"); } - - int main() { - run_printf<<>>(); - } -``` - -## 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<class T > - -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<class T > - -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<class T > - -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<typename T > hipError\_t hipGetSymbolAddress ( void **devPtr, const T &symbol ) Gets the address of a symbol. - -## Parameters - -- devPtr -[out] - Returns device pointer associated with symbol. -- symbol -[in] - Device symbol. - -## Returns - -hipSuccess, hipErrorInvalidValue template<typename T > hipError\_t hipGetSymbolSize ( size\_t *size, const T &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<typename T > - -hipError\_t hipMemcpyToSymbol ( const T &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<typename T > - -hipError\_t hipMemcpyToSymbolAsync ( const T &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<typename T > - -hipError\_t hipMemcpyFromSymbol ( void *dst, const T &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<typename T > - -hipError\_t hipMemcpyFromSymbolAsync ( void *dst, const T &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<class T > - -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<class T > - -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: - -``` - - - - void 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 <=> ) 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: <<< >>> . 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 & 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 & 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<unsigned int size , class ParentCGTy > - -class thread\_block\_tile : public cooperative\_groups::impl::thread\_block\_tile\_internal< size , ParentCGTy > 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<class T > - -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<class T > - -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<class T > - -## 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<class T > - -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<typename T > - -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<typename T > unsigned long long match\_all ( T value, int &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<class T > - -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<<>>(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 - -``` - | - <---------------------------------------------------------------------------------------------------------------------- ---------------------------------------------------------------------------------------------------------------------- | - | - - - - - - - " -``` - -``` -<_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. - -``` - | - - -- \ + <---------------------------------------------------------------------------------------------------------------------- } -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - | 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: - -``` - - - - & ) ] - - : ; . " -``` - -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. <major>.<minor> compute capability is passed to nvcc on the command-line as sm\_<major><minor> , for eg. 8.6 is sm\_86 . - -Because it's not included as a binary, compile the matching example from ROCm. - -``` - | - <.02 .00 <.00 -``` - -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. <major>. <minor> compute capability is passed to nvcc on the command-line as sm\_<major><minor> , 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. - -``` - - - - // -// + - * / */ - + - * - - - */ -``` - -For threads that don't have unique inputs, feed zero\_elem instances to threads. The backing of double-buffering is allocated as such: - -``` - - - - - - - - - - - - " >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 < 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. - -``` - - - - - - -``` - -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(warp_size, [&] - { - hipLaunchKernelGGL(kernel,...); - }); -``` - -``` - -t WarpSize>() -``` - -``` - - HIP Documentation, Release 6.1.40092 - - - - -template - +template - __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, tmp::divide<2>>([&]() - +{ - + 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 - - - __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< WarpCount, tmp::not\_equal<0>, tmp::select< tmp::not\_equal<1>, tmp::divide\_ceil<WarpSize>, tmp::constant<0>>>([&]< uint32\_t ActiveWarps>() { if (wid < ActiveWarps) { // Warp reduction tmp::static\_for<WarpSize / 2, tmp::not\_equal<0>, tmp::divide<2>>([&]< int Delta>() { 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 <size\_t I> auto get<I>(...) 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<> 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` <reading-items>`and processing ``ItemsPerThread` <processing-items>`. - -``` -<_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 - { - return [&](std::integer_sequence) - { - if(i + ItemsPerThread < front_size) - return hip::static_array{ - front[i + I]... - }; - else - return hip::static_array{ - (i + I < front_size? front[i + I] : zero_elem)... - }; - }(std::make_integer_sequence()); - }; - - 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 > gid) , or the more portable [[assume]](gid + 4 > 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 ref_reduced(const unsigned int partition_size, - std::vector input) - { - const unsigned int input_size = input.size(); - const unsigned int result_size = input_size / partition_size; - std::vector 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 custom_partition - = tiled_partition(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, -``` - -## 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 From 4f2fa83b87075e5e62108b63030905f89b6e3498 Mon Sep 17 00:00:00 2001 From: Vincent Ouyang Date: Fri, 1 Aug 2025 16:38:21 -0700 Subject: [PATCH 2/2] Fix minor bugs --- kernel-agentic/src/data/build_vector_store.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) 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})")

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 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 e1e135ef77174ecb909c1d101862746ee9c4456e..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 31997 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 HdGP-N^4stG 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 d8b8f39a8dc69ca5e1ffd1435b554351de6297cc..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 31752 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 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 cf1c264734d81bf5fb14c7fd770114b7159ee4bc..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 270819 zcmW(-cRbYpA3r0hj5D%A?#ei1%Lo}~WUq_LN$9M|IwO=7XOnq0WgVTQ2!JO%DxkFq#`0q&}kvCGtFYC7aVF z-aDFsuAZDmKe0SqAAS1>MQUmx*qYlqI629DmC_6!3{TB))waUCpMQUC_E>-#hieJ^ z`|88&-u4B#y&H%ZFSsHuzuyU241t?=2wo4_Vf>vm`!gwD-p&oTdXd7!#+HVoP$l3C^cage9!S}p_E1}@60qO0NeTP=wfLk) zaO3;Zo1&wov7Dv)chy#prt!a%JW|+xJI!7f`8?n2ZYP{*&#m?=^-o^)_0YsMdndjp zlZ6wZBs;@sDDraI3xb(@?9LSb-^0PejN7y0sFT^E-)oboVX7@ zf9IW7N#6a3zkOu8hFnJ)JSQ7wf9T|p2!w8?!G}8MU^TV1bgkp#+<;A3Wp8h?=GC&&_OGHhpW{{`F9&~Vf6mLwMn1>Wj(O!M=~?V@lcJRQ(SawVLC zAFZtUuispLaMcK5BElh`*N>s738tX-7Zx04coad1vF$LpX@wQW{?47fUov|RGC2b)h_ZQa z+p)J7I{t9&{Zi|)MWH4eG>|A%{kSnI?5VW0v{PbKn^4&sTgl%^U}w@o@{ z>Gd^KqsUkUr<~XSJCkM(yfZ6Rwq(W#`$2Dp99~n1oB%3hVA( z^chxgad9cj=sN*qh9j{M%QpR}r{RB!wY%}0i5wD6pP zDW{l;a9oVU<(9LhHF$2217sJ>957G9cGL9GTvZqFEzpAQvCSn zJ_vCbWMt!+jsF0Q_P@2kOdV z{Bs*;oH7qnXjmu)-v8|uCw#0#5tSt_afkPWgV!( z|E_#jTJL;+=MuF<1NiW}bU}BBR8S&vI^(}zKa-Dh8}rx7Tx&l~H0=LsEEY`Zo@rZI z_HDeVjSAD)`!z-SJp0M*>)|JxMjM*BjF$kZZoVr=+QG1= z&Zwew$aU%5>VHe?w&@J;WuPkGK ze;;fngwqK`qKiwnNj&&GFeKYO%-w*yqu>>U5w^LrbF5)6K<#NiT%7=iBck`DYtcmPPI%YmZlbLa$2<>b`v^t7p|>7So^fgJ$;<&S;&a&T~f zt0WM>ZAf}m1oyzeF&!Cj{(pDP&)?t2KG8;@z}eg9%~4}xV}XHzI*jl8PPl%C+8xd| z`m`5ZobBLoO7sDnrPzgRfvtsJy?QkuARrW1P#_>0)#LoSsp$?1#dr^_e})q4S7JA| z-=C*c5Ce>#-D3Q2yYfr3m7z+YYuw>CHbxmi?3^yQE^Z7Rdsbsef?rbLsQda?ZDRLJM}E= z$r1MMe4B&!Vi)sl*hT7Sl%Ff2vom*6;rWm&aLK8k2L}zTZ4|JJjg1ZBUVbIg8T@(n zlg;R;J$me)Va9yq@Qt>6Jx#P8xm{I5?^?Ng$GTO@-1t@)k^XYu)yV-{x$+JJAE|Ou z!W4?=X3YDYpv0k`(Uk@g>DQFsz*DF;BUPVxj5Z@-#%E?Q7}UOK#b0k z9=sJ7UG8xkw$Fe6^70OhUVd_V8q0NX#rE#qKw@*)aRbM1V2z{;O8ILb`gIt+e*SZy z=MP{>ZbsQI00b+$L$3b&XU1yp?g-~xf8oYAYyNKZ2p0NG#Ra}zG)KR)+y}B`5s6&7 zw(Y!T%W8=w!t~)oGbDj9F*6gO--q%;k4f>MH;-w_=77cgGZ)Q!5-Av1eP{E* zLhd)xO5w(-w+Xjw`ias6!utMC6g&2Lp&=n>XbGdI17m z%4O=yy2-V7XBnc}{07ulM1Fqx@&%yWh3nKz!usSq{j%jbh}{)cUdg>%(_=n*Vc+K> zqzw_@e*X?t6RfSRl?Ei&aejMeejWw^FqCDPoRWh6TToO~R8a5>lV4E4HUxb4`wR## zkUIb_011&o3aSOATKeh+`TBlVNa{1WNF)#z7Z<^ea@V$}o8I?>>rS6Oz5VKuZ{(da z7GJv$kI_g|Q`2?w%+!>ciVCT*@$1*GJWLD~6%|rABLtvK+mM37LO@C@NFj&YnU?v6 z$;rv!NZ=$*bMGyaBf%}EDJ(23b|GjxJAMIym;e7M$j^U~0dQq1>c^QtbfAyVyk7gS zU%_KoV3|JwM4@Ar=R>QTn-4UKn*Ocpb8ieg9d(*De-CgyP(LTX= zbe;UtKiuBl4*dx1S`W19Jx#N`t_oL6@as_=%^?< z6qZ*O@Gh8&b#q(LLqiscyUYD~Dl25uXF_+Zli4s;0wp!+JT=My}{wO$<(nW5Ft{V%X_~yAU=hxQO z9P2fviUMrA{PfBy`>08-%JKPNnk z!1bM-o!`Ed?Tz&G#O(x4HpIrp3Ksr1KlSU$_c<-CpIyeZRjt9HT;q&wJl_ymjUJ?M+D9acg9xiulZXX&N z0*iqf6u48Uzmy*XS{&dt;Ij6|Cd2#}FNT;Kp-wW*c>^HQSEAY+)C7ybf*{3dXIetW1a`n4LA-Ohk6}T6gB_&z zECGK6HgAwYI+89a6%9yBN&Tzd-F{T?HrzKfbaNSSXOKT2o&mp_n{&`8+S%SFtb_QG zFNo@YuK`w)da_P_5BA=-MBLb({jkFkP?~Ej@_rHS3kn*Win20jwgH5KHHX(mOp*#Q zYH%eUCa})$Eq=O??{jS+MrLONS+MZHx~qaI0>M~5P~QW$r+gBAfe`$2atw&{t*-Ge z_g_z*MwHdp*OQ51-2+sr-L`QWOlERi{UTm1G43degEG!cZ*xJvxx_sI} zG6O!zy-$4FQs4A6q4VS08CL~WHMJk2(NKVs`IiCO^xex|0$XgUnk&r2H44vZul@Kj zqW--pa3{+W7}S>v0QtR!X*Ai-=#XwQDV}~bCW<4(`-7L62<-Z$#d4`Pbb86gH2ombDxSxF&C>6k< zKoJ4@MD$#7-L+Lv4ov$!CqY|fD#Bso_FfgUe6x7*GdOTbzu>zRS#sJ6EvQ^mKDSbA zRIfbx)M_PU=M?<)qwHgob4v4Xe%t1uBsPe@20Zm3-y>%KWP_(L>kX=qnGhjrhrDa;{Py6gpP_HkDF`TrR14}naY)@BK+4)xL&i4js}E^`peh3|gnf>@ z!viisl!5NS!MtOx&1?|4cu^ed<=;~calH-tBwFU zcqgv6wLkZ=B2O>h?!9uw#UZ z|2W#OZvlCG74iiVof@_Qio471bCi?YtXP#(sy1GrHxgaMjE8Cj&W_&rxTcQ;0j;*Z zJJ&`xdx_OmmFGEO`z-KOQ3^+nbn%@CpmtE%3Vmb+Q=Ae(9W3Jv%mPF~25&sYzOU}f zex6O#f;*c!w`awIESz5n^ za>>K1({6k`1kt=Qe2ylY$14sv^pO{68@3F%5!-8?4~G`t)vc?|g4@uP{ZI7cb5ktJ z0F~tdp2V(lJUmj|9XoVz99T59Hf5L617!)+WLJfCx2~u>6&KN0pn|8!?H_-`YkLI* z@ue6IRnt7;9@$=39wuS8jaMSc8>*)hSy@?IqK4yKJ~n22ou1x*!^?_NA*p6;t8HIi z7XTsz%W*U~yjpY+s4E%I5)=ns_;xIT=w;5fmsT(t-pSr;OfU1`>gEF|qu%#1)-@O7 z=eM`HS>uAYcU{Q`JOgN4-HUY}UMKu385z&o54Q7wLBJ8ScKubc-Jh*k_|c=y!Uxt1rZz0+lt8;0B-Lf+pXDDT> zpe9aUl~T3aR$)Gj9J=w*Q@JSR!u1xVQLBQ7mFXRzdgWPqksE7QiB+fdOwG(dM?Br& zbEl7nPpN34K^;(_(Z!G@%Mq)6epjdh=n1&ileYDBCv~Ryf?A28DTM9uy{Zg@vmT$IxxF%5`uf zHA_Db!rpIp@(0=|#M>%=dbc@&aOcB+TK>_t?`?n;|EyKnbz-W2jXw@=Eb@k@afnK)4e`6O~egAbUWwOmHPN=Tbi5wKTNf~ z8XmUNj{@{@WhUWxfn^6!nnUZu&qmTJ?*=gSf}y^U(J=XyUJc5^xz&wDfzT9wHSbTu zG=0G4E_mQY{TS#jFbzwwy`9}p@2IvpUQ)AdI9YO79QyKkxtQ=CHZw9R^QdkzP(-f zA|oVk4it#z_5jI1q7JY9=t{c4BJhiY|F7Ti%WH2*y@5ce&$@$ifx`ChWaQo$ej1$%#0vp3ed~3 zij>mEznhN?Q6VIt;{^Z)U$@OlUjjec^XB4+K`!7$W26#?wP5R3rTum6d-LV z9WE>^{P^JyWRP!(gzfEZxmb{xjZ=QlydwkEw+SR}WEtnIw99Y%v|vh`?BncGudk#j zzpByGP6aVwcfjAk7V256f9gf!f1Yik_`LE~6PyJJ(#@UUJ#FWsLkMKxe~umXJ2~3V zc$Qx2^p#~W=xcW;j&O8=ba4Ip^;sZ*@CC%qeoJ)e1JZxv{e|L8Itu2XSE9BtGxYJ} z?LvyT@+Rz_eyDCoI|(FzlRN&0W#9P|0NA7z9YE`MwzioW==2o|E~{-WcEw~r?BqcY zHOa53ZKtLiz2tHF+lyI#Um7bFc8)(8Ey*P~N?M;LHEk2duQg$O?oRASc31sALuLEd zf*T*)%K~y15DfBttVUm6s+b2<=O3px0POqw`G6fFcRjcc&|1OPz=5`v#bCuhdhZtj zkZhk(GSTsBxX91n{QJK?DOx+(5Ze3HaV%wddAY5P?)rsD9A@tq(02AOjI|i7zI+%~ zU3+`BBrv(<@dA(^sTTz69WZ95-xZ<~_Rg8*`gnH^d+;we`z-2FJIe~MMHc2+*koRM z5BN6=6(H+ubMW4OzPXm<$0tWYYTFYH#0@a~Ys%cLdf`IauW7V90+GX zS|$>xtfohT|M}^U2lmb5fmHb9KBBXI)xH9|w`>xq{7-19fR+BqRCizIIFKP9FN_@= z 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%0D3mk(A04-pr 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%0D1fLwa={d<1rL0->v{%} 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

-

HIP Documentation Release 6.1.40092

-

Advanced Micro Devices, Inc.

-

Sep 13, 2024

-

INSTALL

-
1 Overview3
Install HIP
25
2.1Prerequisites . . . . . . . . .5
2.2Installation . . .5
2.3. . . . . Verify your installation . . .6
3Build HIP from source7
3.1 Prerequisites. . . . . .
. .7
3.2 Building the HIP runtime 3.3 . ..7
Build HIP tests . . .10
. . . 3.4 Run HIP . . . . . . . . . . .11
4HIP programming model13
4.113
4.2RDNA &CDNAarchitecture summary Heterogeneous Programming . .14
Single instruction multiple threads (SIMT) . . .14
4.3 4.4Inherent thread model . .15
4.5. . . . 4.4.1 Cooperative groups thread16
Memory model . . . . . . . . .16
4.6 Execution model .. . . . .17
4.6.1 Host-side
execution17 17
4.6.2Device-side execution . .
4.6.3Kernel launch .18
5Hardware implementation19
Compute units. . . . . . .19
. . . . .20
5.15.1.1 5.1.2SIMD . . Vector cache . .20
5.1.3. . Local data share . .20
5.1.4Scalar Unit . . . .20
5.2 CDNA architecture .. . . .20
5.3 RDNA architecture . .. . . .21
5.4 Shader engines . .. . . .21
(CLR)
6AMDcommon language runtimes23
6.1 Project organization. . . .23
How to build/install .. . .23
6.26.2.1Prerequisites . . .23
6.2.2Linux . . . . . . .23
6.2.3Test . . . . . . . .24
-
6.2.4Release notes . . . . . . . . . . . . . . . . . . . . .24
HIP programming manual25
7 7.1Host Memory . . . . .. . . . . . . . . . . . . . . . . . . . .25
7.1.1Introduction . . . . . . . . . . . . . . .25
7.1.2. . . . . . . Memory allocation flags . . . . . . . . .25
7.1.3. . . . . . Numa-aware host memory allocation . . . . . . . . .26
7.1.4Coherency Controls . . . . . . . . .26
7.1.5. . . . . . . . . Visibility of Zero-Copy Host Memory . . . . . . . .27
7.1.6hipEventSynchronize . . . . . . . . . . .27
7.1.7. . . . Summary and Recommendations . . . . . . . . . . .27
7.1.8Managed memory allocation . . . . . . . . . . . . .28
7.1.9HIP Stream Memory Operations . . . . . . . . . . .28
7.2Direct Dispatch . . . . . .. . . . . . . . . . . . . . . . . . .28
7.3HIP Runtime Compilation. . . . . . . . . .29
7.4. . . . . . . . . HIP Graph . . . . . . . . . . . . . . . . .. . . . . . . . . .29
7.5Device-Side Malloc . . . . . .. . . . . . . . . . . . .29
7.6. . . Use of Per-thread default stream . . .. . . . . . . . . . . . .29
7.7Use of Long Double Type . . . . .. . . . . . . . . . . . . .30
7.8Use of _Float16 Type . . . . . . .30
7.9. . . . . . . . . . . . . . FMA and contractions . . . . . . . . . . . . . . . . . . . . .30
7.10Math functions with special rounding modes . . . . . . . . . . . . . . . .. . . . .30
7.11Creating Static Libraries . . .. . . . .30
8 HIP porting guide . . . . . . . . . . .33
8.1Porting a New CUDA Project .. . . . .33
General Tips . .
8.1.1. . . . . . . . . . . . . . . . . . .33
8.1.2Scanning existing CUDA code to scope the porting effort 'in-place' . . . . . . . . . .33 34
8.1.3Converting a project . .
8.1.4Library Equivalents . . . . . . . . . . . . . . . . . .35 35
8.2Distinguishing 8.2.1Compiler 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 Device36
8.2.4Compiler Defines: Summary . . . . . . . . . . . . . . .37
8.3Identifying Architecture Features . .. . . . . . . . . . . . .37
8.3.1HIP_ARCH Defines . . . . . . . . . . . . . . .37
8.3.2Device-Architecture Properties . . . . . . . . . . . .38
8.3.3Table of Architecture Properties . . . . . . . . . . . . . . . . . .38
8.4Finding HIP . . . . . . .. . . . . . . . . . . .39 40
8.5 8.6Identifying HIP Runtime . . . . . hipLaunchKernelGGL . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .40
8.7Compiler Options . . . . . . . 8.7.1 Compiler options supported. . . . . . . . . . . . . . . .40
on AMDplatforms . . .40
8.8Linking 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++
. . . . . . . . . . . . . . . . .41
8.9.2HIP 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.10Workarounds . . . . . . . . . . . .. . . . . . . . . . . .43
-

8.10.1

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

43

-
warpSize
8.10.2 Kernel launch with group size > 256 . . . . . . . . . . . . . . . . . . . . .43
8.11memcpyToSymbol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .43
8.12CU_POINTER_ATTRIBUTE_MEMORY_TYPE. . .44
8.13threadfence_system . . .. . . . . . . .45
. . . . . . 8.13.1 Textures and Cache Control . . .. . . . . . . .45
8.14More Tips . . . .. . . . . . . . .46
8.14.1. . . . . . . . . . . HIP Logging . . . . . . . . .. . . . . . . . .46
8.14.2Debugging hipcc. . . . . . . . . . . . . . . .47
8.14.3Editor Highlighting . .. . . . . . . . . . . . .47
9Porting CUDA driver API49
9.1Introduction to the CUDA Driver and Runtime APIs . . . . . . . .49
9.1.1cuModule API . . . . . . . . . . . . . .49
9.1.2. . . . . . . . . cuCtx API . . . . . . . . . . . . . . . . . . . . . . . . .50
9.2HIPModule and Ctx APIs . . . . . . . . . . . . .. . .50
9.2.1hipModule API . . . . . . . . . . . . . . . . . . . . . . . . . . .50
9.2.2. hipCtx API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .51
9.2.3hipify translation of CUDA Driver API . . . . . .51
9.2.3.1Address Spaces . . . . . .51
9.2.3.2. . . . . . Using hipModuleLaunchKernel . .51
9.2.3.3Additional Information51
9.2.4. . . . . . . . . . . hip-clang Implementation Notes . . . . . . . . . .51
9.2.4.1.hip_fatbin . . . . . . . . . . . . .51
9.2.4.2Initialization and Termination Functions52
9.2.4.3Kernel Launching52
9.2.5. . . . . . . . . . . . . . . . . . NVCC Implementation Notes . . . . . . . . . . . . . . . . .52
. . . . 9.2.5.1 Interoperation between HIP and CUDA Driver . . . . . . .52
9.2.5.2 Compilation Options . . .. . . . . .53
9.3HIPModule and Texture Driver API . . . .. . . . . . .55
10Programming for HIP runtime compiler (RTC)57
10.1Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .57
10.2HIPRTCspecific options . . . . . . . .. . . . . . . . .61
10.2.1Bitcode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .62
10.2.2CU Mode vs WGP mode . . . . . .62
10.3LinkerAPIs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .62
10.3.1Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .63 63
10.3.210.3.1.1 Note . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Input Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .64
10.3.3. Backward Compatibility of LLVM Bitcode/IR . . . . . . . . . . . . . .64
10.3.4Link Options . . . . . . . . . .. . . . . . . .64
10.4Error Handling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .65
10.5HIPRTC General APIs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .65
10.6Lowered Names (Mangled Names) . . . . . . . . . . .66
10.6.1 10.6.2Note . . . . . . . . . . . . . . . . . . . . . . . . . . . Example . . . . . . . . . . . . . . . . . . . . . . . . .66 66
10.7. . . . . . . . . . .67
10.8Versioning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . HIP header support . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .68
10.9Deprecation notice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .68
1169
11.1Performance guidelines Parallelexecution. . . . . . . . . . . . . . . . . . . . .69
-

11.1.2

-

Device level

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

69

-
11.1.3Multiprocessor level . . . . . . . . . . . . . .70
11.2Memoryoptimization . . . . . . . . . . . .70
11.2.1Data Transfer . . . . . . . . . . . . .70
11.2.2. . Device Memory Access . . . . . . . . . .71
11.3Optimization for maximum instruction throughput71
11.3.1Arithmetic instructions . . . . . . . . .72
11.3.2. Control flow instructions . . . . . . . . .72
11.3.3Synchronization . . . . . . . . . .72
11.4. . . . Minimizing memory thrashing .. . . . . . . . . .73
12 Debugging with HIP75
12.1Tracing . .. . . . . . . . . . . . . . . . . . . . .75
12.2Debugging . . . . . .. . . . . . . .77
. . . . . . . 12.2.1 Debugging HIP applications. . . . . . .77
12.3Useful environment variables. . . . . . .79
12.3.1. . . . Kernel enqueue serialization . . . . . . .79
12.3.2Making device visible . . . . . . . . . . .79
12.3.3Dump code object . .79
12.3.4. . . . . . . . . . . HSA-related environment variables (Linux)80
12.3.5 HIP environment variable summary . ..80
12.4General debugging tips . . .. . . . . . . . . . . .82
13 Logging HIP activity83
13.1Logging level . . . . . . . .. . . . . . . . . . . .83
13.2Logging mask . . . . .. . .84
13.3. . . . . . . . . . . Logging command . . . . . . . . . . . . . .. . .84
13.4Logging examples . . . . . .. . . . . . . . . . .85
14 Cooperative groups . . . . . . . . . . . .89
14.1Cooperative groups thread model . . .89
14.2Group types . . . . . . . . group. . . . . . . . .90
14.2.1Thread-block . . . . . . . . . . . . .90
14.2.2Grid group . . . . . . . . . . . . . .90
14.2.3. Multi-grid group . . . . . . . . . . . . .90
14.2.4 14.2.5Thread-block tile . . . . . . . . . . . . . Coalesced groups . . . . . . . . . . . . .91 91
14.3Cooperative groups simple example . .. . . . . .92
14.4Synchronization . . . . . .. . . . . . . .94
14.5. . . .. . . .97
Unsupported NVIDIA CUDA features . . .
15 Unified memory99
15.1Unified memory . . .. . . . . . . . . . . . . . .99 99
15.2System requirements . . . . .. . . . . . . . . . .100
15.3Unified memory programming models. . . . . .
15.3.1Checking unified memory management support100
15.3.2 Example for unified memory management101
15.4Using unified memory management (UMM). . .104
15.5Unified memory HIP runtime hints . . . . .for the better performance104
15.5.1Data prefetching . . . . . . . . .105
15.5.2Memory advice . . . . . . . . . . . . . .106 107
15.5.3 15.5.4Memory range attributes . . . . . . . . . Asynchronously attach memory to a stream108
16 Virtual memory management109
-
16.1Memory allocation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16.1.1. . . 109 . . .
Allocate physical memory . . . . . . . . . . . . . . . . . . . . . . . . . . . .109
16.1.2Reserve virtual address range . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . 110
16.1.3Set memory access . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . 110
Free virtual memory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . 110
16.216.1.4 Memory usage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . 111
16.2.1 Dynamically increase allocation size . . . . . . . . . . . . . . . . . . . . . . .. . . 111
17 Frequently asked questions113
17.1What APIs and features does HIP support? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . 113
17.2What is not supported? . . . . . . . . . . . . . . . . . . . . . . . . .. . . 113
17.2.1 Runtime/Driver API features . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . 113
17.2.2 Kernel language features . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . 114
17.3 IsHIP a drop-in replacement for CUDA? . . . . . . . . . . . . . . . . . . . . . . . . .. . . 114
17.4What specific version of CUDA does HIP support? . . . . . . . . . . . . . . . . . . . .. . . 114
17.5What libraries does HIP support? . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . 115
17.6How does HIP compare with OpenCL? . . . . . . . . . . . . . . . . . . . . . . . . . .. . . 115
17.7How does porting CUDA to HIP compare to porting CUDA to OpenCL? . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . 115
17.8What hardware does HIP support? . . . . . . . .. . . 116
17.9Do HIPIFY tools automatically convert all source code? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . 116
17.10What is NVCC? . . . . . . . . . . . . . . . .. . . 116
17.11. . What is HIP-Clang? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . 116
17.12Why use HIP rather than supporting CUDA directly? . . . . . . . . . . . . . . . . . . .. . . 116 117
17.13Can I develop HIP code on an NVIDIA CUDA platform? . . . . . . . . . . . . . . . . Can I develop HIP code on an AMDHIP-Clang platform? . . . . . . . . . . . . . . . .. . . . . . 117
17.14How to use HIP-Clang to build HIP programs? . . . . . . . . . . . . . . . . . . . . . . . . . .. . . 117
17.15. . . . . . . . . . . . . .
17.16 17.17What is AMDclr? . . . . . . . . . . . . . . . . . . . What is hipother? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . 117 . . . 118
17.18Can I get HIP open source repository . . . . . . . . . . . . . . . .. . . 118
17.19for 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.21Can HIP API support C style application? What is the difference between C and C++? . .. . . 118
17.22Can I install both CUDA SDK and HIP-Clang on the same machine? . . . . . . . . .. . . 119
17.23HIP detected my platform (HIP-Clang vs NVCC) incorrectly * what should I do? . . . . . . . . . . . . . . .. . . 119
17.24On CUDA, can I mix CUDA code with HIP code? . . . . . . . . . . . . . .. . . 120
17.25How do I trace HIP application flow? . . . . . . . . . . . . . . . . . . . . . .. . . 120
17.26What are the maximum limits of kernel launch parameters? . . . . . . . . . . . . . . .. . . 120
17.27Are __shfl_*_sync functions supported on HIP platform? . . . . . . . . . . . . . . .. . . 120
17.28How to create a guard for code that is specific to the host or the GPU? . . . . . . . . . .. . . 120
17.29Why _OpenMP is undefined when compiling with -fopenmp ? . . . . . . . . . . . . . .. . . 121
17.30Does the HIP-Clang compiler support extern shared declarations? . . . . . . . . . . . .. . . 121 code
17.31I have multiple HIP enabled devices and I am getting an error hipErrorSharedObjectInitFailed with the message 'Error: shared object initialization failed'? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . 121
17.32How to use per-thread default stream in HIP? . . . . . . . . . . . . . . . . . . . . . . .. . . 122
17.33How 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.35Does HIP support LUID? . . . . . . . . . . .. . . 123
17.36How can I know the version of HIP? . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . 123
18 HIP Runtime 18.1 RelatedAPI Reference Pages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .125 . . . 126
-

18.3

-

Namespaces

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

126

-
18.3.1Namespace List . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.3.2Namespace Members . . . . . . . . . . . . . .126
18.3.2.1 Namespace Members . . . . .126
18.3.2.2 Namespace Members .126
18.4. . . . . Data Structures . . . . . . . . . . . . . . . . . . .126
18.4.1 DataStructures . . . . . . . .. .126
18.4.2. . . Data Structure Index . . . . . . . .126
18.4.3. . . Class Hierarchy . . . . . . . . . . . . . .126
18.4.4. . Data Fields . . . . . . . . . . . . . . . . . .126
18.4.4.1 All . . . . . . . . . . . . . ..126
18.4.4.1.1Data Fields . . . . .126
18.4.4.1.2Data Fields . . . . .126
18.4.4.1.3Data Fields . . . . .126
18.4.4.1.4Data Fields . . . . .126
18.4.4.1.5Data Fields . . . . .126
18.4.4.1.6Data Fields . . . .126
18.4.4.1.7. Data Fields . . . . . .126
18.4.4.1.8Data Fields . . . .126
18.4.4.1.9Data Fields . . . . . . .126
18.4.4.1.10Data Fields . . .126
18.4.4.1.11Data Fields . . . . . . .126
18.4.4.1.12Data Fields . . .126
18.4.4.1.13Data Fields . . . . . Data Fields .126
18.4.4.1.14. . . . Data Fields126
18.4.4.1.15. . . . . .126
18.4.4.1.16Data Fields . . . .126
18.4.4.1.17Data Fields . . . . .126
18.4.4.1.18Data Fields . . . . .126
18.4.4.1.19Data Fields . . . . .126
18.4.4.1.20Data Fields . . . . . .126
18.4.4.1.21Data Fields . . . .126
18.4.4.1.22Data Fields . . . . .126
18.4.4.1.23Data Fields . . . . .126
18.4.4.1.24Data Fields . . . .126
18.4.4.1.25. Data Fields . . . . .126 126
18.4.4.2 Data Fields - Functions . . . . . . . . . . . . . 18.4.4.3 Variables . . . . . . . . . . . . . . . . . . . . .126
18.4.4.3.1Data Fields - Variables126
18.4.4.3.2Data Fields - Variables126
18.4.4.3.3Data Fields - Variables126
18.4.4.3.4Data Fields - Variables126
18.4.4.3.5Data Fields - Variables126
18.4.4.3.6Data Fields - Variables126
18.4.4.3.7Data Fields - Variables126
18.4.4.3.8Data Fields - Variables126
18.4.4.3.9Data Fields - Variables126
18.4.4.3.10Data Fields - Variables126
18.4.4.3.11Data Fields - Variables126
18.4.4.3.12Data Fields - Variables126
18.4.4.3.13Data Fields - Variables126
18.4.4.3.14 18.4.4.3.15Data Fields - Variables Data Fields - Variables126 126
18.4.4.3.16Data Fields - Variables126
-

18.4.4.3.17

-

Data Fields - Variables

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

126

-
18.4.4.3.18Data Fields - Variables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.4.4.3.19Data Fields - Variables. . . . . . . . . . . . . . . . . . . . .126
18.4.4.3.20Data Fields -Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.4.4.3.21Data Fields - Variables. . . . . . . . . . . . . . . . . . . . . .126
18.4.4.3.22DataFields - Variables . . . . . . . . . . . . . . . . . . . . .126
18.4.4.3.23Data Fields -. . . . . . Variables . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.4.4.3.24DataFields - Variables . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.4.4.3.25DataFields - Variables . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.518.4.4.4 Data Fields - Related Symbols . .. . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . 126 . . . . . . . . .126
Files 18.5.1File List . . . . .. . . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.5.2Globals . . .. . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.5.2.1 All . .. . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.5.2.1.1Globals . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.5.2.1.2Globals . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.5.2.1.3Globals . . . .. . . . . . . . . . . . . . . . . . . . . . . . .126
18.5.2.1.4Globals . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.5.2.1.5Globals . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.5.2.1.6Globals . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.5.2.1.7Globals . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.5.2.1.8Globals . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.5.2.1.9Globals126
. .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.5.2.2 Functions 18.5.2.2.1. . . . . . . Globals . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.5.2.2.2Globals . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.5.2.2.3Globals . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.5.2.3 Globals. . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.5.2.4 Globals. . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
. . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.5.2.5 GlobalsEnumerator . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.5.2.6 18.5.2.6.1Globals . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
18.5.2.6.2Globals .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
Globals.. . . .
18.5.2.7. . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
C++ language extensions127
19.1Function-typequalifiers. . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .127 127
19.1.1__device__ . .. . . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .128
19.1.2__global__. . . . . .
19.1.3__host__ . . .. . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .128
19.2 19.3Calling __global__ functions . . . . .. . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .128 129
19.4Kernel 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 . . . . . . . . . . .. .. . . . . . . . .130
19.5.1Coordinate built-ins. . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .130
19.5.2warpSize . . .. . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .131
19.6Vector types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . .131
19.6.1Short vector types. . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .131
19.719.6.2 dim3 . . . . . . . . . . . . . . . . . . Memory fence instructions . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132132
-

19.8

-

Synchronization functions

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

.

-

132

-
.. .
19.9Mathfunctions . . . . . . . . . . .132
19.10Texturefunctions . . . . . . . . . . . . .133
19.11Surfacefunctions . . . . . . . . . . . . .133
19.12Timerfunctions . . . . . . . . . . . . . .137
19.13Atomicfunctions138
19.13.1. . . . . . . . . . . . . Unsafe floating-point atomic RMWoperations139
19.14Warp cross-lanefunctions . .140
19.14.1. . . . . . Warp vote and ballot functions .140
19.14.2 Warpmatch functions . . . . .141
19.14.3. Warp shuffle functions . . . . .142
19.15Cooperative groupsfunctions . . . . . .142
19.16Warp matrixfunctions . . . . . . .143
19.17Independent. . . thread scheduling . . . . . .144
19.18ProfilerCounter Function . . . . . . . .144
19.19Assert . . . . .. . . . . . . . . . . . . .144
19.20. . . .printf . . . . . . . . . . . . . .144
19.21Device-Side Dynamic Global Memory Allocation . . . . . . . .145
19.22__launch_bounds__ . .145
19.22.1Compiler Impact . . . . . . . .145
19.22.2CU and EU Definitions . . . . .146 146
19.22.3 19.22.4 maxregcountPorting from CUDA __launch_bounds . . . . . . . . . .146
19.23Asynchronous Functions . . . . . . . . .147
19.23.1Memory stream . . . . . . . . .147
19.23.2Peer to peer . . . . . .163
19.23.3. . . . . Memory management . . .165
19.23.4. . . External Resource Interoperability195
RegisterKeyword . . . . . . . . . . . . .197
19.2419.25 PragmaUnroll . . . . . . . . . . . . .198
19.26In-LineAssembly . . . . . . . . . . . .198
19.27KernelCompilation . . . . . . . . . . .198
19.28
gfx-arch-specific-kernel . . . . . . . . .199
C++ language 20.120.1.1Modern C++ support . . . . . . . . . . . C++11 support . . . . . . . . .201 201
20.1.2C++14 support . . . . . . . . .202
20.1.3C++17 support . . . . . . . . .202
20.1.4C++20 support . . . . . . . . .202
20.2Extensionsand restrictions . . . . . . . .202
20.2.1Global functions . .202
20.2.2. . . . . . Device space memory specifiers . . . .202
20.2.3Exception handling . . . . .203
20.2.4Kernel parameters . . . . . .203
20.2.5Classes . . . .203
20.2.6. . . . . . . . . Polymorphic function wrappers .203
20.2.7Extended lambdas . . . . . . . .203
Inline namespaces
20.2.8. . . . . . .203
.205
21 HIP mathAPI205
21.1Single precision mathematical functions . . . . Double precision mathematical functions . . . Integer . . . .215
21.2intrinsics . . . . . . . . . . . .
21.3225
-
21.4Floating-point Intrinsics . . . . . . . . . . . . . .227
22Tablecomparing syntax for different compute APIs231
22.1Notes . . . . . . . . . . . . . . . . . . . . . . . .232
23HIPCooperative groups API233
23.1Cooperative kernel launches . . . . . . . . . . . .233
23.2Cooperative groups classes . . . . . . . . . . . . .234
23.3Cooperative groups construct functions . . . .237
23.4. . Cooperative groups exposed API functions . . . .238
24HSA runtime API for ROCm241
25HIP managed memory allocation API247
26HIP virtual memory management API251
27HIP deprecatedruntime API functions
257
27.1Context management . . . . . . . . . . . . . . . .257
27.2Memory management . . . . . . . . . . . . . . . . . .258
27.3Profiler control . . . . . . . . . . . . . . . .258
27.4Texture management . . . . . . . . . . . . . . . .258
28SAXPY - Hello, HIP261
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.2Invoking the compiler manually . . . . .266
29Reduction273
29.1 The algorithm . . . 29.2. . . . . . . . . . . . . . . .273
Reduction on GPUs. . . . . . . . . . . . . . . .273
29.2.1 Naive shared reduction. . . . . . . . . .274
29.2.2Reducing thread divergence . . . . . . . .276
29.2.3Resolving bank conflicts . . . . . . . . .276
29.2.4Utilize upper half of the block . . . . . . . . . . . . .277
29.2.5Unroll all loops . . . . . . .281
29.2.6Communicate using warp-collective functions282
29.2.7Prefer warp communication over shared282
29.2.8. Amortize bookkeeping variable overhead284
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
30Cooperative 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 reduction291
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.2Host-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 Conclusion4. Launch the kernel . . . . .293
30.4 .. . . . . . . . . . . . . . . . . . . . . . . . . . . . .293
31 License295
-

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.
    2. -
-

sudo apt-get install ubuntu-drivers-common && sudo ubuntu-drivers autoinstall sudo reboot

-

Alternatively, you can download the latest CUDA Toolkit.

-
    -
  1. Install the hip-runtime-nvidia and hip-dev packages. This installs the CUDA SDK and HIP porting layer.
    2. -
-
  | 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.
    2. -
-

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.

-
    -
  1. Set the environment variables.
    2. -
  2. Build HIP.
    3. -
-
<_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 <ROCM_PATH>/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 <ROCM_PATH>/hip . This can be overridden by setting the HIP_PATH environment variable.
    • -
-

•

-

HSA is in

-

<ROCM_PATH>/hsa

-

. This can be overridden by setting the

-

HSA_PATH

-

environment variable.

-
    -
  • Clang is in <ROCM_PATH>/llvm/bin . This can be overridden by setting the HIP_CLANG_PATH environment variable.
    • -
  • The device library is in <ROCM_PATH>/lib . This can be overridden by setting the DEVICE_LIB_PATH environment variable.
    • -
  • Optionally, you can add <ROCM_PATH>/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.
    2. -
-

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_>
-
                                                                                                                                                                                                        |                                                                                                                                                                                                       
-                                                                                                                                                                                                        
-
-

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 & 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.
-
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 --
-

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 <<<...>>> 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
-

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.
-

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
-

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 EffectFenceCoherent Memory ityHost Visibil-Non-Coherent Host Memory Visi- bility
hipStreamSynchronize host waits for all commands in the spec- ified stream to completesystem- scope releaseyesyes
hipDeviceSynchronize host waits for all commands in all streams on the specified device to com- pletesystem- scope releaseyesyes
hipEventSynchronize host waits for the specified event to com- pletedevice- scope releaseyesdepends - see below
hipStreamWaitEvent stream waits for the specified event to completenoneyesno
-

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.

-
    -
  • > 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 braryLi-HIP Li- braryROCm Li- braryComment
cuBLAShipBLASrocBLASBasic Linear Algebra Subroutines
cuBLASLthip- BLASLtN/ABasic Linear Algebra Subroutines, lightweight and new flexible API
cuFFThipFFTrocFFTFast Fourier Transfer Library
cuSPARSEhipSPARSErocSPARSESparse BLAS + SPMV
cuSOLVERhip- SOLVERrocSOLVERLapack library
AmgXN/ArocALU- TIONSparse iterative solvers and preconditioners with algebraic multigrid
ThrustN/ArocThrustC++ parallel algorithms library
CUBhipCUBrocPRIMLow Level Optimized Parallel Primitives
cuDNNN/AMIOpenDeep learning Solver Library
cuRANDhipRANDrocRANDRandom Number Generator Library
EIGENEIGENN/AC++ template library for linear algebra: matrices, vectors, numeri- cal solvers,
NCCLN/ARCCLCommunications 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

-
DefineHIP-ClangNVCCOther (GCC, ICC, Clang, etc.)
HIP-related defines:
__HIP_PLATFORM_AMD__DefinedUndefinedDefined if targetingAMD platform; undefined oth- erwise
__HIP_PLATFORM_NVIDIA__UndefinedDefinedDefined if targeting NVIDIA platform; unde- fined otherwise
__HIP_DEVICE_COMPILE__1 if compiling for device; un- defined if compiling for host1 if compiling for device; undefined if compiling for hostUndefined
__HIPCC__DefinedDefinedUndefined
__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 otherwiseUndefined
__NVCC__ UndefinedDefinedUndefined
__CUDA_ARCH__UndefinedUnsigned representing compute capa- bility (e.g., '130') if in device code; 0 if in host codeUndefined
hip-clang- related defines:
__HIP__ HIP-Clang commonDefinedUndefinedUndefined
defines: __clang__DefinedDefinedUndefined
-

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 hasGlobalFloatAtomicExch32-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 hasSharedFloatAtomicExch32-bit integer atomics for shared memory 32-bit float atomic exchange for shared mem- ory
__HIP_ARCH_HAS_FLOAT_ATOMIC_ADD__hasFloatAtomicAdd32-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 hasSharedInt64Atomics64-bit integer atomics for global memory 64-bit integer atomics for shared memory
__HIP_ARCH_HAS_DOUBLES__ Warp cross-lane operations:hasDoublesDouble-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 hasFunnelShiftWarp vote instructions ( any , all ) Warp ballot instructions Warp shuffle operations ( shfl_* ) Funnel shift two input words into one
hasThreadFenceSystem hasSyncThreadsExtthreadfence_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__has3dGridGrids 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 <<< >>>, 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.

-
OptionDescription
--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-rdcGenerate relocatable device code, which allows kernels or device functions calling device functions in different translation units.
-ggdbEquivalent 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-tempsSave the compiler generated intermediate files.
-vShow 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:

-
    -
  • >
    • -
-
|> 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 > 256

-

Kernel code should use __attribute__((amdgpu_flat_work_group_size(<min>,<max>))) . 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
-

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(&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 <<< >>> 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:

-
FormatAPIsNVCCHIP-CLANG
Code Object Fat BinaryhipModuleLoad , 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 <<<>>> syntax, hipLaunchKernelGGL. The latter one is macro which expand to CUDA <<<>>> 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 <<<>>> 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 TypeCU Driver TypeCUDA Runtime Type
hipModule_tCUmodule
hipFunction_tCUfunction
hipCtx_tCUcontext
hipDevice_tCUdevice
hipStream_tCUstreamcudaStream_t
hipEvent_tCUeventcudaEvent_t
hipArrayCUarraycudaArray
-

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:

-
                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        
-                                                                                                                                                                                             
-                                                                                                                                                                                            
-	         
-                                                                                                                                                                                             
-         
-                                                                                                                                                                                              
-                                                                                                                                                                                             
-                                                                                                                                                                                            
-
-          
-                                                                                                                                                                                             
-                                                                                                                                                                                             >
-                                                                                                                                                                                                       
-                                                                                                                                                                                             //
-                                                                                                                                                                                                       
-                                                                                                                                                                                             }
-

The below sample shows how to use hipModuleGetFunction .

-
#include
-#include
-#include
-#include
-#include
-
#include
-#include
-#include
-#include
-#include
-
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;iargBuffer(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 tex;
-
-        __global__ void tex2dKernel(hipLaunchParm lp, float* outputData,
-                                                                                                                                                                                                       //
-
  }
-
-  // Host code:
-
-  texture 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 <hip/hiprtc.h>

-

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 kernel_binary(codeSize);
-  hiprtcGetCode(prog, kernel_binary.data());
-

After loading the binary, hiprtcProgram can be destroyed. hiprtcDestroyProgram(&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 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 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");
-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:

-
                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        
-                                                                                                                                                                                                       >
-

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 
-        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.

-
                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        

-                                                                                                                                                                                                       

-                                                                                                                                                                                                      

-                                                                                                                                                                                                      
-	                                                                                                                                                                                                        

-                                                                                                                                                                                                     

-
-                                                                                                                                                                                                       
-                                                                                                                                                                                                     
- 	                                                                                                                                                                                                       
-                                                                                                                                                                                                      
-                                                                                                                                                                                                     
-
-                                                                                                                                                                                                      
-                                                                                                                                                                                                      
-                                                                                                                                                                                                     
-		                                                                                                                                                                                                      
-
-
-

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.

-
                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        
test, which caused a segmentation fault issue.                                                                                                                                                                                                        
                                                                                                                                                                                                        >
-                                                                                                                                                                                                       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 < 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 variableDe- fault valueUsage
AMD_LOG_LEVEL Enable HIP log on different Level00: 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 Level0x7FFFFFFF 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.00: 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 HIP0,1,2: Depending on the number of devices on the system
GPU_DUMP_CODE_OBJECT Dump code ob- ject00: Disable 1: Enable
AMD_SERIALIZE_KERNEL Serialize kernel enqueue01: Wait for completion before enqueue 2: Wait for completion after enqueue 3: Both
AMD_SERIALIZE_COPY Serialize copies01: Wait for completion before enqueue 2: Wait for completion after enqueue 3: Both
HIP_HOST_COHERENT Coherent mem-00: 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)10: Disable 1: Enable
GPU_MAX_HW_QUEUES The maximum number of hard- ware queues allocated per device4The 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 .

-
                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        

-                                                                                                                                                                                                       
-        Loggging examples                                                                                                                                                                                                        >
-                                                                                                                                                                                                      
-
-                                                                                                                                                                                                       >
-
-                                                                                                                                                                                                       

-                                                                                                                                                                                                      


-                                                                                                                                                                                                     

-
-                                                                                                                                                                                                      
-	                                                                                                                                                                                                       	                                                                                                                                                                                                       
-                                                                                                                                                                                                     
-  
-                                                                                                                                                                                                   

-  
-
-

(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.

-
                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        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/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.amazonaws.com/%3.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 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;
-        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
ArchitecturehipMallocManaged()__managed__malloc()
MI200, MI300 Series1
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 
-#include 
-
-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 
-#include 
-
-// 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 
-#include 
-
-// 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
-    #include 
-
-    // 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(&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 
-  #include 
-    
-  // 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 
-        #include 
-        
-        // 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 ( <<< >>> ) 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 >= 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(&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 <<< >>> 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<<>> (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 <<< >>> 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<<>> (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_<type_name>() . 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. -
  2. Modify kernels that use __threadfence_system() as follows:
    3. -
  3. Ensure the kernel operates only on fine-grained system memory, which should be allocated with hipHostMalloc() .
    4. -
  4. Remove memcpy for all allocated fine-grained system memory regions.
    5. -
-

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<typename T , typename std::enable_if<__hip_is_tex_surf_channel_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable_if<__hip_is_tex_surf_channel_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable_if<__hip_is_tex_surf_channel_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable_if<__hip_is_tex_surf_channel_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable_if<__hip_is_tex_surf_channel_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable_if<__hip_is_tex_surf_channel_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable_if<__hip_is_tex_surf_channel_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable_if<__hip_is_tex_surf_channel_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable_if<__hip_is_tex_surf_channel_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable_if<__hip_is_tex_surf_channel_type< T >::value>::type* = nullptr>

-

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<typename T , typename std::enable_if<__hip_is_tex_surf_channel_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable_if<__hip_is_tex_surf_channel_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable_if<__hip_is_tex_surf_channel_type< T >::value>::type* = nullptr> 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<typename T , typename std::enable_if<__hip_is_tex_surf_channel_type< T >::value>::type* = nullptr> 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
FunctionSupported in HIPSupported 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
FunctionSup- ported in HIPSupported 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 
-
-    __global__ void run_printf() { printf("Hello World\n"); }
-
-    int main() {
-      run_printf<<>>();
-    }
-

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<class T >

-

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<class T >

-

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<class T >

-

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<typename T > hipError_t hipGetSymbolAddress ( void **devPtr, const T &symbol ) Gets the address of a symbol.

-

Parameters

-
    -
  • devPtr -[out] - Returns device pointer associated with symbol.
    • -
  • symbol -[in] - Device symbol.
    • -
-

Returns

-

hipSuccess, hipErrorInvalidValue template<typename T > hipError_t hipGetSymbolSize ( size_t *size, const T &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<typename T >

-

hipError_t hipMemcpyToSymbol ( const T &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<typename T >

-

hipError_t hipMemcpyToSymbolAsync ( const T &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<typename T >

-

hipError_t hipMemcpyFromSymbol ( void *dst, const T &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<typename T >

-

hipError_t hipMemcpyFromSymbolAsync ( void *dst, const T &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<class T >

-

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<class T >

-

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:

-
                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        void                                                                                                                                                                                                        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 <=> ) 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: <<< >>> . 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
FunctionSupported on HostSupported 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

-
Table1 - 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

-
Table1 - 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.
-

21.2 Double precision mathematical functions

-

Following is the list of supported double precision mathematical functions.

-
Table 2: Double precision mathematical functions
FunctionSupported on HostSupported 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

-
Table2 - 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 & 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 & 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

-
TermCUDAHIPOpenCL
Deviceint deviceIdint deviceIdcl_device
QueuecudaStream_thipStream_tcl_command_queue
EventcudaEvent_thipEvent_tcl_event
Memoryvoid *void *cl_mem
gridgridNDRange
blockblockwork-group
threadthreadwork-item
warpwarpsub-group
Thread-indexthreadIdx.xthreadIdx.xget_local_id(0)
Block-indexblockIdx.xblockIdx.xget_group_id(0)
Block-dimblockDim.xblockDim.xget_local_size(0)
Grid-dimgridDim.xgridDim.xget_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__syncthreadsbarrier(CLK_LOCAL
Atomic BuiltinsatomicAddatomicAddatomic_add
Precise Mathcos(f)cos(f)cos(f)
Fast Math__cos(f)__cos(f)native_cos(f)
Vectorfloat4float4float4
-

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:doxygenfunction:Cannotfind function'hipLaunchCooperativeKernel' Documentation'
indoxygenxmloutputfor project'HIP6.1.40092fromdirectory:
/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-
6.1.2/docs/doxygen/xml
-
Warning:doxygenfunction: projectCannotfind function'hipLaunchCooperativeKernel'
indoxygenxmloutputfor'HIP6.1.40092Documentation'from
/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-
6.1.2/docs/doxygen/xml
-
Warning:doxygenfunction:Cannotfindfunction'hipLaunchCooperativeKernelMultiDe-
vice'indoxygenxmloutput forproject'HIP6.1.40092Documentation'fromdirectory:
/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-
6.1.2/docs/doxygen/xml
-
Warning: indoxygenfunction: 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-
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<unsigned int size , class ParentCGTy >

-

class thread_block_tile : public cooperative_groups::impl::thread_block_tile_internal< size , ParentCGTy > 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<class T >

-

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<class T >

-

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<class T >

-

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<class T >

-

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<typename T >

-

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<typename T > unsigned long long match_all ( T value, int &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:doxygenfunction:Cannot findfunction'cooperative_groups::this_multi_grid'
indoxygenxmloutputforproject'HIP6.1.40092Documentation'fromdirectory:
/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-
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:doxygenfunction:Cannotfindfunction'cooperative_groups::coalesced_threads'
indoxygenxmloutputforproject'HIP6.1.40092Documentation'fromdirectory:
-

/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs6.1.2/docs/doxygen/xml

-
Warning:doxygenfunction:Cannot findfunction'cooperative_groups::tiled_partition'
indoxygenxmloutputforproject'HIP6.1.40092Documentation'fromdirectory:
/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-
6.1.2/docs/doxygen/xml
-
Warning:doxygenfunction:Cannotfindfunction 'cooperative_groups::tiled_partition' 6.1.40092
indoxygenxmloutputforproject'HIPDocumentation'fromdirectory:
/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-
6.1.2/docs/doxygen/xml
-
Warning:doxygenfunction:Cannot findfunction'cooperative_groups::binary_partition'
indoxygenxmloutputforproject'HIP6.1.40092Documentation'from
/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-
6.1.2/docs/doxygen/xml
-
Warning:doxygenfunction:Cannot findfunction 'cooperative_groups::binary_partition' 6.1.40092
indoxygenxmloutputforproject'HIPDocumentation'fromdirectory:
/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-
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:doxygenfunction: projectCannot findfunction'cooperative_groups::group_size'
indoxygenxmloutputfor'HIP6.1.40092Documentation'fromdirectory:
/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-
6.1.2/docs/doxygen/xml
-
Warning:doxygenfunction: Cannotfind 'HIPfunction 'cooperative_groups::thread_rank'
indoxygenxmloutputforproject6.1.40092Documentation'fromdirectory:
/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-
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<class T >

-

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<<>>(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.

-
                                                                                                                                                                                                        |                                                                                                                                                                                                       
-                                                                                                                                                                                                        -                                                                                                                                                                                                        --                                                                                                                                                                                                        \                                                                                                                                                                                                        +                                                                                                                                                                                                        <----------------------------------------------------------------------------------------------------------------------                                                                                                                                                                                                        }
-

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                                                                                                                                                        |                                               
-     |                                                                                                                                                                                                   |                                          
-     |                                                                                                                                                       
-     |                                                                                                                                                   |                                                    
-     |                                                                                                                                             
-     |                                                    
-     |                                                                                                                                        
-     |                                                         
-     |
-

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:

-
                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-
-

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. <major>.<minor> compute capability is passed to nvcc on the command-line as sm_<major><minor> , for eg. 8.6 is sm_86 .

-

Because it's not included as a binary, compile the matching example from ROCm.

-
                                                                                                                                                                                                        |                                                                                                                                                                                                       
-                                                                                                                                                                                                        <.02                                                                                                                                                                                                        .00                                                                                                                                                                                                      <.00
-

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. <major>. <minor> compute capability is passed to nvcc on the command-line as sm_<major><minor> , 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.

-
                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                                                                                                                                                                                                                                //                                                                                                                                                                                                       	                                                                                                                                                                                                      
-//                                                                                                                                                                                                        +                                                                                                                                                                                                        -                                                                                                                                                                                                        *                                                                                                                                                                                                        /                                                                                                                                                                                                        */
-                                                                                                                                                                                                       +
-                                                                                                                                                                                                       *
-                                                                                                                                                                                                       -
-                                                                                                                                                                                                       */
-

For threads that don't have unique inputs, feed zero_elem instances to threads. The backing of double-buffering is allocated as such:

-
                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     
- 
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 
-
- 
-                                                                                                                                                                                                     
- 
-
-                                                                                                                                                                                                      "                                                                                                                                                                                                        >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 < 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.

-
                                                                                                                                                                                                       
-                                                                                                                                                                                                       
-
-                                                                                                                                                                                                        
-                                                                                                                                                                                                      
-
-

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(warp_size, [&]
-  {
-      hipLaunchKernelGGL(kernel,...);
-  });
-

-t WarpSize>()
-

-        HIP Documentation, Release 6.1.40092
-
-
-        
-        -template
-        +template
-        __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, tmp::divide<2>>([&]()
-        +{
-        +     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                                                                                                                                                                                                     
- 
-
-

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
-        __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< WarpCount, tmp::not_equal<0>, tmp::select< tmp::not_equal<1>, tmp::divide_ceil<WarpSize>, tmp::constant<0>>>([&]< uint32_t ActiveWarps>() { if (wid < ActiveWarps) { // Warp reduction tmp::static_for<WarpSize / 2, tmp::not_equal<0>, tmp::divide<2>>([&]< int Delta>() { 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 <size_t I> auto get<I>(...) 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<> 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` <reading-items>`and processing ``ItemsPerThread` <processing-items>`.

-
<_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
-        {
-            return  [&](std::integer_sequence)
-            {
-                if(i + ItemsPerThread < front_size)
-                        return hip::static_array{
-                              front[i + I]...
-                        };
-                else
-                        return hip::static_array{
-                              (i + I < front_size? front[i + I] : zero_elem)...
-                        };
-            }(std::make_integer_sequence());
-        };
-
-        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 > gid) , or the more portable [[assume]](gid + 4 > 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 ref_reduced(const unsigned int          partition_size,
-                                                   std::vector input)
-    {
-        const unsigned int          input_size  = input.size();
-        const unsigned int          result_size = input_size / partition_size;
-        std::vector 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.
    2. -
-

(continued from previous page)

-
    -
  1. The reduction of thread block and store the results in global memory.
    2. -
  2. The reduction of custom partition and store the results in global memory.
    3. -
-

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 custom_partition
-           = tiled_partition(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. -
  2. Initialize the cooperative group configuration.
    3. -
  3. Allocate and copy input to global memory.
    4. -
  4. Launch the cooperative kernel.
    5. -
  5. Save the results from global memory.
    6. -
  6. Free the global memory.
    7. -
-

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,
-

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

-
ChipArrayCreate ( C++ function ), 183
cooperative_groups::coalesced_group class ), 237C++ hipArrayDestroy ( C++ function ), 183 hipArrayGetDescriptor ( C++ function ), 185 ( C++ function ), 185(
cooperative_groups::grid_group ( C++ class ), 234hipArrayGetInfo 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 234hipDestroyExternalSemaphore hipDestroySurfaceObject ( C++ function ), 133 C++ function
cooperative_groups::thread_block_tile ( C++ class ), 234hipDeviceCanAccessPeer ( ), 163 hipDeviceDisablePeerAccess ( C++ function ), 164 ( C++ function ), 163
cooperative_groups::thread_block_tile::all ( C++ function ), 236 cooperative_groups::thread_block_tile::anyhipDeviceEnablePeerAccess hipDeviceGetStreamPriorityRange ( C++ function ), 148
( C++ function ), 236hipDrvMemcpy3D ( C++ function ), 192
cooperative_groups::thread_block_tile::ballothipDrvMemcpy3DAsync ( C++ function ), 192
hipDrvPointerGetAttributes ( C++ function ), 166
( C++ function ), 236
cooperative_groups::thread_block_tile::match_allhipExternalMemoryGetMappedBuffer ( C++ func- tion ), 196
( C++ function ), 237 cooperative_groups::thread_block_tile::match_anyhipExternalMemoryGetMappedMipmappedArray ( C++ function ), 197 hipExtMallocWithFlags ( C++ function ), 167236( ),C++function
cooperative_groups::thread_block_tile::meta_group_rank ( C++ function ), 235hipExtStreamCreateWithCUMask ( 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 ), 235hipFreeAsync
cooperative_groups::thread_block_tile::shfl ( C++ function ), 235
( C++ function ), 154
cooperative_groups::thread_block_tile::shfl_down
( C++ function ), 235hipFreeHost ( C++ function ), 172 hipGetProcAddress ( C++ function ), 176
cooperative_groups::thread_block_tile::shfl_uphipGetSymbolAddress ( C++ function ), 176, 193 ( C++ function ), 176, 193
( C++ function ), 235hipHostAlloc ( C++ function ), 168 hipHostFree ( C++ function ), 172
( C++ function ), 236( C++ function ),
cooperative_groups::thread_block_tile::sync ( C++ function ), 235169 ( 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 ),
234196 ( C++ function ),
( C++ function ), 166, 194
HhipMalloc hipMalloc3D
( C++ function ), 184
hipArray3DCreate ( C++ function ), 183
185hipMalloc3DArray ( 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
hipMemPoolGetAccess ( C++ function ), 158 hipMemPoolGetAttribute ( C++ function ), 156
hipMemPoolImportFromShareableHandle function ), 161( C++
hipMemPoolImportPointer ( C++ function ), 162 hipMemPoolSetAccess ( C++ function ), 157
hipMemPoolSetAttribute ( C++ function ), 156
hipMemPoolTrimTo ( C++ function ), 155
hipMemPrefetchAsync ( C++ function ), 247
hipMemPtrGetInfo ( C++ function ), 182
hipMemRangeGetAttribute ( C++ function ), 248
hipMemRangeGetAttributes ( C++ function ), 248
hipMemRelease ( C++ function ), 255
hipMemRetainAllocationHandle ( C++function ), 255
hipMemset ( C++ function ), 179
hipMemset2D ( C++ function ), 181
hipMemset2DAsync ( C++ function ), 181
hipMemset3D ( C++ function ), 181
hipMemset3DAsync ( C++ function ), 182
hipMemSetAccess ( C++ function ), 255
hipMemsetAsync ( C++ function ), 180
hipMemsetD16 ( C++ function ), 180 hipMemsetD16Async ( C++ function ), 180
hipMemsetD32 ( C++ function ), 180
hipMemsetD32Async ( C++ function ), 181
hipMemsetD8 ( C++ function ), 179
hipMemsetD8Async ( C++ function ), 179
hipMemUnmap ( C++ function ), 256
hipModuleGetGlobal ( C++ function ), 176
( C++ function ), 165
hipPointerGetAttribute hipPointerGetAttributes ( C++ function ), 165
hipPointerSetAttribute ( C++ function ), 165
hipSignalExternalSemaphoresAsync ( C++ func- tion ), 195
hipStreamAddCallback ( C++ function ), 152 hipStreamAttachMemAsync ( C++ function ), 249
hipStreamCallback_t ( C++ type ), 147 ( C++ function ), 147
hipStreamCreate hipStreamCreateWithFlags ( C++ function ), 147
hipStreamCreateWithPriority ( C++ function ), 147 hipStreamDestroy ( C++ function ), 148
hipStreamGetDevice ( C++ function ), 151
hipStreamGetFlags ( C++ function ), 150
hipStreamGetPriority ( C++ function ), 150 hipStreamQuery ( C++ function ), 149
hipStreamSynchronize ( C++ function ), 149
hipStreamWaitEvent
( C++ function ), 149
hipWaitExternalSemaphoresAsync ( C++ function ), 195
hsa_amd_vmem_address_free ( C++ function ), 241
hsa_amd_vmem_address_reserve ( C++function ),
241
-
hsa_amd_vmem_export_shareable_handle function ), 244
hsa_amd_vmem_get_access ( C++ function ), 243
hsa_amd_vmem_get_alloc_properties_from_handle ( C++ function ), 245
hsa_amd_vmem_handle_create ( 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_retain_alloc_handle ( C++ tion ), 245func-
hsa_amd_vmem_set_access ( 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

-

^8U 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 z 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