[CK_Builder] [testing] Integrate device random generators (#3427)

Implemented device random number generators for ck tensors.
Includes tests and integration to ck builder testing interface.

experimental/builder/include/ck_tile/builder/testing/conv_fwd.hpp

@@ -9,6 +9,7 @@
 #include "ck_tile/builder/testing/testing.hpp"
 #include "ck_tile/builder/testing/extent.hpp"
 #include "ck_tile/builder/testing/tensor_buffer.hpp"
+#include "ck_tile/builder/testing/tensor_initialization.hpp"
 #include "ck/library/utility/convolution_parameter.hpp"
 #include "ck/library/utility/convolution_host_tensor_descriptor_helper.hpp"
 /// This file implements common functionality for invoking/testing grouped
@@ -238,6 +239,20 @@ UniqueInputs<SIGNATURE> alloc_inputs(const Args<SIGNATURE>& args)
     };
 }
 
+/// @brief `init_inputs()` specialization for forward convolution.
+///
+/// @tparam SIGNATURE Forward convolution signature.
+///
+/// @see alloc_inputs()
+template <auto SIGNATURE>
+    requires ValidConvSignature<SIGNATURE> && ConvDirectionIsForward<SIGNATURE> &&
+             ValidUniqueInputs<SIGNATURE>
+void init_inputs(const Args<SIGNATURE>& args, UniqueInputs<SIGNATURE>& inputs)
+{
+    init_tensor_buffer_uniform_fp(inputs.input_buf, args.make_input_descriptor(), -2.0f, 2.0f);
+    init_tensor_buffer_uniform_fp(inputs.weight_buf, args.make_weight_descriptor(), -2.0f, 2.0f);
+}
+
 /// @brief `alloc_outputs()` specialization for forward convolution.
 ///
 /// @tparam SIGNATURE Forward convolution signature.

experimental/builder/include/ck_tile/builder/testing/tensor_initialization.hpp

@@ -0,0 +1,82 @@
+// Copyright (c) Advanced Micro Devices, Inc., or its affiliates.
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <stdexcept>
+#include <memory>
+#include <numeric>
+#include <span>
+#include <concepts>
+#include <hip/hip_runtime.h>
+#include "ck_tile/builder/conv_signature_concepts.hpp"
+#include "ck_tile/builder/factory/helpers/ck/conv_tensor_type.hpp"
+#include "ck_tile/builder/testing/type_traits.hpp"
+#include "ck_tile/host/host_tensor.hpp"
+#include "ck/utility/data_type.hpp"
+
+#include "ck/library/utility/device_tensor_generator.hpp"
+
+namespace ck_tile::builder::test {
+
+template <DataType DT>
+void init_tensor_buffer_uniform_int(const DeviceBuffer& buf,
+                                    const TensorDescriptor<DT>& descriptor,
+                                    int min_val,
+                                    int max_val)
+{
+    size_t size = descriptor.get_element_space_size_in_bytes();
+
+    if(max_val - min_val <= 1)
+    {
+        throw std::runtime_error("Error while filling device tensor with random integer data: max "
+                                 "value must be at least 2 greater than min value, otherwise "
+                                 "tensor will be filled by a constant value (end is exclusive)");
+    }
+
+    using ck_type = factory::internal::DataTypeToCK<DT>::type;
+
+    // we might be asked to generate int values on fp data types that don't have the required
+    // precision
+    if(static_cast<ck_type>(max_val - 1) == static_cast<ck_type>(min_val))
+    {
+        throw std::runtime_error("Error while filling device tensor with random integer data: "
+                                 "insufficient precision in specified range");
+    }
+    size_t packed_size = ck::packed_size_v<ck_type>;
+    fill_tensor_uniform_rand_int_values<<<256, 256>>>(
+        static_cast<ck_type>(buf.get()), min_val, max_val, (size * packed_size) / sizeof(ck_type));
+}
+
+template <DataType DT>
+void init_tensor_buffer_uniform_fp(const DeviceBuffer& buf,
+                                   const TensorDescriptor<DT>& descriptor,
+                                   float min_value,
+                                   float max_value)
+{
+    size_t size = descriptor.get_element_space_size_in_bytes();
+
+    using ck_type = factory::internal::DataTypeToCK<DT>::type;
+
+    size_t packed_size = ck::packed_size_v<ck_type>;
+    fill_tensor_uniform_rand_fp_values<<<256, 256>>>(reinterpret_cast<ck_type*>(buf.get()),
+                                                     min_value,
+                                                     max_value,
+                                                     (size * packed_size) / sizeof(ck_type));
+}
+
+template <DataType DT>
+void init_tensor_buffer_normal_fp(const DeviceBuffer& buf,
+                                  const TensorDescriptor<DT>& descriptor,
+                                  float sigma,
+                                  float mean)
+{
+    size_t size = descriptor.get_element_space_size_in_bytes();
+
+    using ck_type      = factory::internal::DataTypeToCK<DT>::type;
+    size_t packed_size = ck::packed_size_v<ck_type>;
+    fill_tensor_norm_rand_fp_values<<<256, 256>>>(
+        static_cast<ck_type*>(buf.get()), sigma, mean, (size * packed_size) / sizeof(ck_type));
+}
+
+} // namespace ck_tile::builder::test

experimental/builder/include/ck_tile/builder/testing/testing.hpp

@@ -205,6 +205,20 @@ template <auto SIGNATURE>
     requires ValidUniqueInputs<SIGNATURE>
 UniqueInputs<SIGNATURE> alloc_inputs(const Args<SIGNATURE>& args);
 
+/// @brief Allocate inputs corresponding to a signature.
+///
+/// The `init_inputs()` function is used to initialize pseudo-random data
+/// to the tensors specified in the Inputs structure.
+///
+/// @tparam SIGNATURE the signature to specialize the structure for.
+///
+/// @see Inputs
+/// @see UniqueInputs
+/// @see tensor_initialization
+template <auto SIGNATURE>
+    requires ValidUniqueInputs<SIGNATURE>
+void init_inputs(const Args<SIGNATURE>& args, UniqueInputs<SIGNATURE>& inputs);
+
 /// @brief Allocate outputs corresponding to a signature.
 ///
 /// The `alloc_outputs()` function is used to create an instance of