diff --git a/psrdada_cpp/CMakeLists.txt b/psrdada_cpp/CMakeLists.txt index 7e589f209b12d1d7daf01fd8f2e3710e815ae8df..cd1be9cdb7d8439a80024eba6e749dc7a1d4c042 100644 --- a/psrdada_cpp/CMakeLists.txt +++ b/psrdada_cpp/CMakeLists.txt @@ -88,3 +88,4 @@ install(DIRECTORY detail DESTINATION include/psrdada_cpp) add_subdirectory(meerkat) add_subdirectory(effelsberg) +add_subdirectory(cryopaf) diff --git a/psrdada_cpp/cryopaf/Beamformer.cuh b/psrdada_cpp/cryopaf/Beamformer.cuh new file mode 100644 index 0000000000000000000000000000000000000000..98987e391d5ffeb525dfe6b8315a86e0c3457719 --- /dev/null +++ b/psrdada_cpp/cryopaf/Beamformer.cuh @@ -0,0 +1,163 @@ +/* +* Beamformer.cuh +* Author: Niclas Esser <nesser@mpifr-bonn.mpg.de> +* Description: +* This file consists of a single class (Beamformer<ComputeType>). An object of Beamformer +* can be used o either perform a Stokes I detection or raw voltage beamforming +* on a GPU. +* Both beamforming kernels expect the same dataproduct (linear aligned in device memory) +* Input: F-P-T-E +* Weight: F-P-B-E +* Output: F-T-B-P (voltage beams) +* Output: F-T-B (Stokes I beams) +*/ + +#ifndef BEAMFORMER_CUH_ +#define BEAMFORMER_CUH_ + +#include <cuda.h> +#include <cuda_fp16.h> +#include <thrust/device_vector.h> + +#include "psrdada_cpp/cuda_utils.hpp" +#include "psrdada_cpp/multilog.hpp" + +namespace psrdada_cpp{ +namespace cryopaf{ + +// Constants for beamform kernels +#define NTHREAD 1024 +#define TILE_SIZE 32 +#define WARP_SIZE 32 + +/** +* @brief GPU kernel to perform Stokes I detection beamforming +* +* @detail Template type T has to be etiher T=float2 or T=__half2. +* According to T, U has to be either U=float or U=__half +* +* @param T* idata pointer to input memory (format: F-P-T-E) +* @param T* wdata pointer to beam weight memory (format: F-P-B-E) +* @param U* odata pointer to output memory type of U is equal to T::x (format: F-T-B) +* @param int time Width of time dimension (T) +* @param int elem Number of elements (E) +* @param int beam Number of beams (B) +* @param int integrate Integration time, currently limited to 32 and a power of 2 +* +* @TODO: Allow greater integration time +*/ +template<typename T, typename U>__global__ +void beamformer_power_fpte_fpbe_ftb( + const T *idata, + const T* wdata, + U *odata, + int time, + int elem, + int beam, + int integrate); + + +/** +* @brief GPU kernel to perform raw voltage beamforming +* +* @detail Template type T has to be etiher T=float2 or T=__half2 +* +* @param T* idata pointer to input memory (format: F-P-T-E) +* @param T* wdata pointer to beam weight memory (format: F-P-B-E) +* @param T* odata pointer to output memory (format: F-T-B) +* @param int time Width of time dimension (T) +* @param int elem Number of elements (E) +* @param int beam Number of beams (B) +*/ +template<typename T>__global__ +void beamformer_voltage_fpte_fpbe_fptb( + const T *idata, + const T* wdata, + T *odata, + int time, + int elem, + int beam); + + +template<class ComputeType> +class Beamformer{ + +// Internal typedefintions +private: + typedef decltype(ComputeType::x) ResultType; // Just necessary for Stokes I beamformer + +// Public functions +public: + /** + * @brief constructs an object of Beamformer<ComputeType> (ComputeType=float2 or ComputeType=__half2) + * + * @param cudaStream_t& stream Object of cudaStream_t to allow parallel copy + processing (has to be created and destroyed elsewhere) + * @param std::size_t sample Number of samples to process in on kernel launch (no restrictions) + * @param std::size_t channel Number of channels to process in on kernel launch (no restrictions) + * @param std::size_t element Number of elements to process in on kernel launch (no restrictions) + * @param std::size_t beam Number of beams to process in on kernel launch (no restrictions) + * @param std::size_t integration Samples to be integrated, has to be power of 2 and smaller 32 + */ + Beamformer( + cudaStream_t& stream, + std::size_t sample, + std::size_t channel, + std::size_t element, + std::size_t beam, + std::size_t integration = 1); + + /** + * @brief deconstructs an object of Beamformer<ComputeType> (ComputeType=float2 or ComputeType=__half2) + */ + ~Beamformer(); + + /** + * @brief Launches voltage beamforming GPU kernel + * + * @param ComputeType* input pointer to input memory (format: F-P-T-E) + * @param ComputeType* weights pointer to beam weight memory (format: F-P-B-E) + * @param ComputeType* output pointer to output memory (format: F-T-B-P) + */ + void process( + const ComputeType* input, + const ComputeType* weights, + ComputeType* output); + + /** + * @brief Launches Stokes I beamforming GPU kernel + * + * @param ComputeType* input pointer to input memory (format: F-P-T-E) + * @param ComputeType* weights pointer to beam weight memory (format: F-P-B-E) + * @param ResultType* output pointer to output memory (format: F-T-B) + */ + void process( + const ComputeType* input, + const ComputeType* weights, + ResultType* output); + + /** + * @brief Prints the block and grid layout of a kernel (used for debugging purposes) + */ + void print_layout(); + +// Private attributes +private: + cudaStream_t& _stream; + dim3 grid; + dim3 block; + std::size_t _sample; + std::size_t _channel; + std::size_t _element; + std::size_t _beam; + std::size_t _integration; +}; + + +} // namespace cryopaf +} // namespace psrdada_cpp + +#include "psrdada_cpp/cryopaf/details/utils.cu" +#include "psrdada_cpp/cryopaf/details/BeamformerKernels.cu" +#include "psrdada_cpp/cryopaf/src/Beamformer.cu" + +#endif /* BEAMFORMER_CUH_ */ diff --git a/psrdada_cpp/cryopaf/BufferTypes.cuh b/psrdada_cpp/cryopaf/BufferTypes.cuh new file mode 100644 index 0000000000000000000000000000000000000000..242fbc712e1aa511d4c632305bdf7eb6d5b32647 --- /dev/null +++ b/psrdada_cpp/cryopaf/BufferTypes.cuh @@ -0,0 +1,218 @@ +/* +* BufferTypes.cuh +* Author: Niclas Esser <nesser@mpifr-bonn.mpg.de> +* Description: +* This file contains classes for different kinds of buffer representation. +* All implemented classes inherit from DoubleBuffer<thrust::device_vector<T>>. +*/ + +#ifndef BUFFERTYPES_HPP_ +#define BUFFERTYPES_HPP_ + +// boost::interprocess used to upload weights via POSIX shared memory +#include <boost/interprocess/shared_memory_object.hpp> +#include <boost/interprocess/mapped_region.hpp> +#include <boost/interprocess/sync/scoped_lock.hpp> +#include <boost/thread.hpp> + +#include "psrdada_cpp/cuda_utils.hpp" +#include "psrdada_cpp/double_device_buffer.cuh" +#include "psrdada_cpp/double_host_buffer.cuh" +#include "psrdada_cpp/cryopaf/QueueHeader.hpp" + +namespace psrdada_cpp { +namespace cryopaf{ + +/** +* @brief Class providing buffers for raw voltage data +*/ +template<class T> +class RawVoltage : public DoubleBuffer<thrust::device_vector<T>> +{ +public: + typedef T type; +public: + /** + * @brief Instantiates an object of RawVoltage + * + * @param std::size_t Number of items in buffer + * + * @detail Allocates twice the size in device memory as double device buffer + */ + RawVoltage(std::size_t size) + : DoubleBuffer<thrust::device_vector<T>>() + { + this->resize(size); + _bytes = size * sizeof(T); + } + /** + * @brief Destroys an object of RawVoltage + */ + ~RawVoltage(){} + /** + * @brief Returns the number of bytes used for a single buffer + * + * @detail The occupied memory is twice + */ + std::size_t total_bytes(){return _bytes;} +private: + std::size_t _bytes; +}; + + +/** +* @brief Class providing buffers for beam data (is always the Output of the Pipeline) +* @detail An object of BeamOutput also contains an instance of DoublePinnedHostBuffer<T> +* to allow an asynchronous copy to the host memory. +*/ +template<class T> +class BeamOutput : public DoubleBuffer<thrust::device_vector<T>> +{ + +public: + typedef T type; + DoublePinnedHostBuffer<T> host; +public: + /** + * @brief Instantiates an object of BeamOutput + * + * @param std::size_t Number of items in buffer + * + * @detail Allocates twice the size in device memory and in host memory as double buffers + */ + BeamOutput(std::size_t size) + : DoubleBuffer<thrust::device_vector<T>>() + { + this->resize(size); + host.resize(size); + _bytes = size * sizeof(T); + } + /** + * @brief Destroys an object of BeamOutput + */ + ~BeamOutput(){} + + /** + * @brief Asynchronous copy to host memory + * + * @param cudaStream_t& stream Device to host stream + */ + void async_copy(cudaStream_t& stream) + { + CUDA_ERROR_CHECK(cudaMemcpyAsync(host.a_ptr(), this->a_ptr(), _bytes, cudaMemcpyDeviceToHost, stream)); + } + /** + * @brief Returns the number of bytes used for a single buffer + * + * @detail The occupied memory is twice + */ + std::size_t total_bytes(){return _bytes;} +private: + std::size_t _bytes; +}; + +// Define namespace for convinient access to boost::interprocess functionalitys, just used for weights +namespace bip = boost::interprocess; + +/** +* @brief Class providing buffers for beam weights +* @detail An object of Weights as the ability to read out a POSIX shared memory namespace +* to load updated beam weights. +* @note The current state is not final and will change in future. The idea for future is +* to provide an update method which is called by a shared memory instance. +*/ +template<class T> +class Weights : public DoubleBuffer<thrust::device_vector<T>> +{ +public: + typedef T type; +public: + + /** + * @brief Instantiates an object of BeamOutput + * + * @param std::size_t Number of items in buffer + * @param std::string Name of the POSIX shared memory + * + * @detail Allocates twice the size in device memory as double device buffer. + * It also launches a boost::thread to create, read and write from shared + * memory. + */ + Weights(std::size_t size, std::string smem_name="SharedMemoryWeights") + : DoubleBuffer<thrust::device_vector<T>>() + , _smem_name(smem_name) + { + + this->resize(size); + _bytes = size * sizeof(T); + t = new boost::thread(boost::bind(&Weights::run, this)); + } + /** + * @brief Destroys an object of BeamOutput + */ + ~Weights(){} + + /** + * @brief Creates, read, write and removes a POSIX shared memory space + * + * @detail This function is a temporary solution to update beam weights on-the-fly + * while the pipeline is operating. In the future a clean interface will be created + * that provides addtional monitoring informations (e.g. power level) besides the + * beam weight updating mechanism. + */ + void run() + { + + bip::shared_memory_object::remove("SharedMemoryWeights"); + bip::shared_memory_object smem(bip::create_only, "SharedMemoryWeights", bip::read_write); + + // Set size of shared memory including QueueHeader + payload + BOOST_LOG_TRIVIAL(info) << "Size of shared memory for weight uploading (IPC) " << sizeof(QueueHeader) + (this->size()) * sizeof(T); + smem.truncate(sizeof(QueueHeader) + (this->size()) * sizeof(T)); + + // Map shared memory to a addressable region + bip::mapped_region region(smem, bip::read_write); + + void* smem_addr = region.get_address(); // get it's address + + QueueHeader* qheader = static_cast<QueueHeader*>(smem_addr); // Interpret first bytes as QueueHeader + T *ptr = &(static_cast<T*>(smem_addr)[sizeof(QueueHeader)]); // Pointer to address of payload (behind QueueHeader) + qheader->stop = true; + while(qheader->stop){usleep(1000);} + while(!qheader->stop) + { + bip::scoped_lock<bip::interprocess_mutex> lock(qheader->mutex); + if(!qheader->data_in) + { + BOOST_LOG_TRIVIAL(debug) << "Waiting for writing weights to shared memory"; + qheader->ready_to_read.wait(lock); // Wait for read out + } + + BOOST_LOG_TRIVIAL(debug) << "Reading new weights from shared memory"; + CUDA_ERROR_CHECK(cudaMemcpy((void*)this->b_ptr(), (void*)ptr, + _bytes, cudaMemcpyHostToDevice)); + // Swap double buffer, so next batch is calculated with new weights + this->swap(); + //Notify the other process that the buffer is empty + qheader->data_in = false; + qheader->ready_to_write.notify_all(); + + } + bip::shared_memory_object::remove("SharedMemoryWeights"); + BOOST_LOG_TRIVIAL(info) << "Closed shared memory for weights uploading"; + } + + std::size_t total_bytes(){return _bytes;} + +private: + std::size_t _bytes; + std::string _smem_name; + boost::thread *t; +}; + +} +} + + + +#endif /* BUFFERTYPES_HPP_ */ diff --git a/psrdada_cpp/cryopaf/CMakeLists.txt b/psrdada_cpp/cryopaf/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..f04218e42317b10a2283f7d10b906ad7beebb70c --- /dev/null +++ b/psrdada_cpp/cryopaf/CMakeLists.txt @@ -0,0 +1,29 @@ +if(ENABLE_CUDA) +set(PSRDADA_CPP_CRYOPAF_LIBRARIES + ${CMAKE_PROJECT_NAME} + ${CMAKE_PROJECT_NAME}_cryopaf + ${DEPENDENCY_LIBRARIES} + -lboost_system + -lpthread) + +set(psrdada_cpp_cryopaf_src + Unpacker.cuh + Beamformer.cuh + BufferTypes.cuh + Pipeline.cuh + PipelineInterface.cuh) + +cuda_add_library(${CMAKE_PROJECT_NAME}_cryopaf ${psrdada_cpp_cryopaf_src}) + +cuda_add_executable(beamforming src/beamforming_cli.cu) +target_link_libraries(beamforming ${PSRDADA_CPP_CRYOPAF_LIBRARIES}) +install(TARGETS beamforming DESTINATION bin) + +cuda_add_executable(weightupdater src/weightupdater_cli.cu) +target_link_libraries(weightupdater ${PSRDADA_CPP_CRYOPAF_LIBRARIES}) +install(TARGETS weightupdater DESTINATION bin) + +add_subdirectory(profiling) +add_subdirectory(test) + +endif(ENABLE_CUDA) diff --git a/psrdada_cpp/cryopaf/Pipeline.cuh b/psrdada_cpp/cryopaf/Pipeline.cuh new file mode 100644 index 0000000000000000000000000000000000000000..ca99c46ff716fc07b0539e46db5a5742ec525227 --- /dev/null +++ b/psrdada_cpp/cryopaf/Pipeline.cuh @@ -0,0 +1,142 @@ +/* +* Pipeline.cuh +* Author: Niclas Esser <nesser@mpifr-bonn.mpg.de> +* Description: +* This files consists of a single class (Pipeline<HandlerType, ComputeType, ResultType>) +* and a configuration structure (PipelineConfig). +* An object of Pipeline is used to access data from psrdada buffers, unpacks them, +* performs beamforming and writes the results back to another psrdada buffer. +* TODO: +* - We need a packer +* - We need a monitoring interface +*/ +#ifndef PIPELINE_CUH_ +#define PIPELINE_CUH_ + +#include <thrust/device_vector.h> +#include <thrust/copy.h> +#include <cuda.h> + +#include "psrdada_cpp/cuda_utils.hpp" +#include "psrdada_cpp/multilog.hpp" +#include "psrdada_cpp/raw_bytes.hpp" + +#include "psrdada_cpp/cryopaf/Unpacker.cuh" +#include "psrdada_cpp/cryopaf/Beamformer.cuh" +#include "psrdada_cpp/cryopaf/BufferTypes.cuh" + +namespace psrdada_cpp{ +namespace cryopaf{ + +struct PipelineConfig{ + key_t in_key; + key_t out_key; + int device_id; + std::string logname; + std::size_t n_samples; + std::size_t n_channel; + std::size_t n_elements; + std::size_t n_beam; + std::size_t integration; + std::string input_type; + std::string mode; + std::string protocol; + const std::size_t n_pol = 2; + void print() + { + std::cout << "Pipeline configuration" << std::endl; + std::cout << "in_key: " << in_key << std::endl; + std::cout << "out_key: " << out_key << std::endl; + std::cout << "device_id: " << device_id << std::endl; + std::cout << "logname: " << logname << std::endl; + std::cout << "n_samples: " << n_samples << std::endl; + std::cout << "n_channel: " << n_channel << std::endl; + std::cout << "input_type: " << input_type << std::endl; + std::cout << "n_elements: " << n_elements << std::endl; + std::cout << "n_pol: " << n_pol << std::endl; + std::cout << "n_beam: " << n_beam << std::endl; + std::cout << "integration: " << integration << std::endl; + std::cout << "mode: " << mode << std::endl; + } +}; + + +template<class HandlerType, class ComputeType, class ResultType> +class Pipeline{ +// Internal type defintions +private: + typedef RawVoltage<char> RawInputType; // Type for received raw input data (voltage) + typedef RawVoltage<ComputeType> InputType;// Type for unpacked raw input data (voltage) + typedef Weights<ComputeType> WeightType; // Type for beam weights + typedef BeamOutput<ResultType> OutputType;// Type for beamfored output data +public: + + + /** + * @brief Constructs an object of Pipeline + * + * @param PipelineConfig conf Pipeline configuration containing all necessary parameters (declaration can be found in Types.cuh) + * @param MultiLog log Logging instance + * @param HandlerType handler Object for handling output data + * + * @detail Initializes the pipeline enviroment including device memory and processor objects. + */ + Pipeline(PipelineConfig& conf, MultiLog &log, HandlerType &handler); + + + /** + * @brief Deconstructs an object of Pipeline + * + * @detail Destroys all objects and allocated memory + */ + ~Pipeline(); + + + /** + * @brief Initialise the pipeline with a DADA header block + * + * @param header A RawBytes object wrapping the DADA header block + */ + void init(RawBytes &header_block); + + + /** + * @brief Process the data in a DADA data buffer + * + * @param data A RawBytes object wrapping the DADA data block + */ + bool operator()(RawBytes &dada_block); +// Internal attributes +private: + + HandlerType &_handler; + MultiLog &_log; + PipelineConfig& _conf; + // Processors + Unpacker<ComputeType>* unpacker = nullptr; // Object to unpack and transpose received input data on GPU to an expected format + Beamformer<ComputeType>* beamformer = nullptr; // Object to perform beamforming on GPU + // Buffers + RawInputType *_raw_input_buffer = nullptr; // Received input buffer + InputType *_input_buffer = nullptr; // Unpacked and transposed input buffer + WeightType *_weight_buffer = nullptr; // Beam weights, updated through shared memory + OutputType *_output_buffer = nullptr; // Output buffer containing processed beams + + std::size_t _call_cnt = 0; // Internal dada block counter + + cudaStream_t _h2d_stream; // Host to device cuda stream (used for async copys) + cudaStream_t _prc_stream; // Processing stream + cudaStream_t _d2h_stream; // Device to host cuda stream (used for async copys) +#ifdef DEBUG + // Time measurement variables (debugging only) + cudaEvent_t start, stop; + float ms; +#endif +}; + + +} // namespace cryopaf +} // namespace psrdada_cpp + +#include "psrdada_cpp/cryopaf/src/Pipeline.cu" + +#endif /* POWERBEAMFORMER_CUH_ */ diff --git a/psrdada_cpp/cryopaf/PipelineInterface.cuh b/psrdada_cpp/cryopaf/PipelineInterface.cuh new file mode 100644 index 0000000000000000000000000000000000000000..63569ae0a815cb44b4a65faea4afc9e4f2d96ab8 --- /dev/null +++ b/psrdada_cpp/cryopaf/PipelineInterface.cuh @@ -0,0 +1,85 @@ +#ifndef PIPELINE_INTERFACE_HPP +#define PIPELINE_INTERFACE_HPP + +#include <vector> +#include <string> +#include <unistd.h> +#include <random> +#include <cmath> +#include <complex> + +#include <boost/interprocess/shared_memory_object.hpp> +#include <boost/interprocess/mapped_region.hpp> +#include <boost/interprocess/sync/scoped_lock.hpp> +#include <boost/thread.hpp> + +#include "psrdada_cpp/multilog.hpp" +#include "psrdada_cpp/cryopaf/QueueHeader.hpp" + +namespace psrdada_cpp{ +namespace cryopaf{ + +namespace bip = boost::interprocess; + +struct PipelineInterfaceConfig{ + std::string logname; + std::size_t n_channel; + std::size_t n_elements; + std::size_t n_pol; + std::size_t n_beam; + std::string mode; + void print() + { + std::cout << "Pipeline interface configuration" << std::endl; + std::cout << "logname: " << logname << std::endl; + std::cout << "n_channel: " << n_channel << std::endl; + std::cout << "n_elements: " << n_elements << std::endl; + std::cout << "n_pol: " << n_pol << std::endl; + std::cout << "n_beam: " << n_beam << std::endl; + std::cout << "mode: " << mode << std::endl; + } +}; + +template<class T> +class PipelineInterface +{ +public: + PipelineInterface(PipelineInterfaceConfig& config, MultiLog& logger); + ~PipelineInterface(); + void run(); + virtual void update() = 0; + +private: + std::string smem_name = "SharedMemoryWeights"; + + bip::shared_memory_object smem; + bip::mapped_region region; + void* smem_addr = nullptr; + T* smem_weights = nullptr; + QueueHeader *qheader; + +protected: + PipelineInterfaceConfig& conf; + MultiLog& log; + std::vector<T> vect_weights; + bool quit = false; + std::size_t update_cnt = 0; +}; + + +template<class T> +class SimpleWeightGenerator : public PipelineInterface<T> +{ +public: + SimpleWeightGenerator(PipelineInterfaceConfig& config, MultiLog& logger); + ~SimpleWeightGenerator(); + void update(); +private: + void bypass(); + void random(); +}; + +} +} +#include "psrdada_cpp/cryopaf/src/PipelineInterface.cu" +#endif // end PIPELINE_INTERFACE_HPP diff --git a/psrdada_cpp/cryopaf/QueueHeader.hpp b/psrdada_cpp/cryopaf/QueueHeader.hpp new file mode 100644 index 0000000000000000000000000000000000000000..9b7b7a26073f47ee3e67a5e2c1d97fb99e0e300f --- /dev/null +++ b/psrdada_cpp/cryopaf/QueueHeader.hpp @@ -0,0 +1,36 @@ +/* +* QueueHeader.hpp +* Author: Niclas Esser <nesser@mpifr-bonn.mpg.de> +* Description: +* This file contains the structure which is used shared memory IPC +*/ +#ifndef QUEUE_HEADER_HPP_ +#define QUEUE_HEADER_HPP_ + +#include <boost/interprocess/sync/interprocess_mutex.hpp> +#include <boost/interprocess/sync/interprocess_condition.hpp> + +namespace bip = boost::interprocess; + +/** +* @brief Header stored in POSIX shared memory to allow IPC communication +*/ +struct QueueHeader +{ + QueueHeader() + : data_in(false), + stop(true) + {} + // Mutex to protect access to the queue + bip::interprocess_mutex mutex; + // Condition to wait when the queue is empty + bip::interprocess_condition ready_to_read; + // Condition to wait when the queue is full + bip::interprocess_condition ready_to_write; + // Is there any payload? + bool data_in; + // Stop flag, will force the owner to remove the shared memory + bool stop; +}; + +#endif diff --git a/psrdada_cpp/cryopaf/Unpacker.cuh b/psrdada_cpp/cryopaf/Unpacker.cuh new file mode 100644 index 0000000000000000000000000000000000000000..6b00c0ef586f59d71e0c4d93b543f30b65d59147 --- /dev/null +++ b/psrdada_cpp/cryopaf/Unpacker.cuh @@ -0,0 +1,58 @@ +#ifndef UNPACKER_CUH +#define UNPACKER_CUH + +#include <cuda.h> +#include <cuda_fp16.h> +#include <thrust/device_vector.h> + +#include "psrdada_cpp/common.hpp" +#include "psrdada_cpp/multilog.hpp" + +#define NCHAN_CHK 7 +#define NSAMP_DF 128 +#define NPOL_SAMP 2 +#define NSAMP_PER_HEAP 1024 + +namespace psrdada_cpp { +namespace cryopaf { + +template<typename T>__global__ +void unpack_codif_to_fpte(uint64_t const* __restrict__ idata, T* __restrict__ odata); + +template<typename U, typename T>__global__ +void unpack_spead_ttfep_to_fpte(U const* __restrict__ idata, T* __restrict__ odata); + + +template<typename T> +class Unpacker +{ +public: + + Unpacker(cudaStream_t& stream, + std::size_t nsamples, + std::size_t nchannels, + std::size_t nelements, + std::string protocol); + ~Unpacker(); + Unpacker(Unpacker const&) = delete; + + void unpack(char* input, T* output); + + void print_layout(); + + int sample_size(){return _sample_size;} +private: + cudaStream_t& _stream; + int _sample_size = 8; // TODO: dynamic for spead and fixed for codif + std::string _protocol; + dim3 grid; + dim3 block; +}; + +} //namespace cryopaf +} //namespace psrdada_cpp + +#include "psrdada_cpp/cryopaf/details/UnpackerKernels.cu" +#include "psrdada_cpp/cryopaf/src/Unpacker.cu" + +#endif // UNPACKER_CUH diff --git a/psrdada_cpp/cryopaf/details/BeamformerKernels.cu b/psrdada_cpp/cryopaf/details/BeamformerKernels.cu new file mode 100644 index 0000000000000000000000000000000000000000..5ff0de61263c2b3fab5762503d5697931b52471f --- /dev/null +++ b/psrdada_cpp/cryopaf/details/BeamformerKernels.cu @@ -0,0 +1,762 @@ +#ifdef BEAMFORMER_CUH_ + +namespace psrdada_cpp{ +namespace cryopaf{ + +// Function description in Beamformer.cuh +template<typename T>__global__ +void beamformer_voltage_fpte_fpbe_fptb( + const T *idata, + const T* wdata, + T *odata, + int time, int elem, int beam) +{ + const int tidx = threadIdx.x; + const int tidy = threadIdx.y; + const int beam_axis = blockDim.x * blockIdx.x + tidx; + const int time_axis = blockDim.y * blockIdx.y + tidy; + const int freq = blockIdx.z; + + const int size_idata = elem * time; + const int size_wdata = elem * beam; + const int size_odata = time * beam; + + const int idata_offset = freq * 2 * size_idata; + const int wdata_offset = freq * 2 * size_wdata; + const int odata_offset = freq * 2 * size_odata; + + T voltage_x = {0,0}; + T voltage_y = {0,0}; + + __shared__ T s_idata_x[TILE_SIZE][TILE_SIZE]; + __shared__ T s_idata_y[TILE_SIZE][TILE_SIZE]; + __shared__ T s_wdata_x[TILE_SIZE][TILE_SIZE]; + __shared__ T s_wdata_y[TILE_SIZE][TILE_SIZE]; + + s_idata_x[tidy][tidx] = {0,0}; + s_idata_y[tidy][tidx] = {0,0}; + s_wdata_x[tidy][tidx] = {0,0}; + s_wdata_y[tidy][tidx] = {0,0}; + + for( int k = 0; k < elem; k+=TILE_SIZE ) + { + if(time_axis < time && tidx + k < elem) + { + s_idata_x[tidy][tidx] = idata[idata_offset + time_axis * elem + tidx + k]; + s_idata_y[tidy][tidx] = idata[idata_offset + size_idata + time_axis * elem + tidx + k]; + } + else + { + s_idata_x[tidy][tidx] = {0,0}; + s_idata_y[tidy][tidx] = {0,0}; + } + +__syncthreads(); + + if(beam_axis < beam && tidy + k < elem) + { + s_wdata_x[tidy][tidx] = wdata[wdata_offset + beam_axis * elem + tidy + k]; + s_wdata_y[tidy][tidx] = wdata[wdata_offset + size_wdata + beam_axis * elem + tidy + k]; + } + else + { + s_wdata_x[tidy][tidx] = {0,0}; + s_wdata_y[tidy][tidx] = {0,0}; + } + +__syncthreads(); + + for(int j = 0; j < TILE_SIZE; j++) + { + if(j + k == elem) + { + break; + } + voltage_x = cmadd(s_idata_x[tidy][j], s_wdata_x[j][tidx], voltage_x); + voltage_y = cmadd(s_idata_y[tidy][j], s_wdata_y[j][tidx], voltage_y); + } + } + +__syncthreads(); + + if(beam_axis < beam && time_axis < time) + { + const int out_idx_x = odata_offset + (((int)blockIdx.y * TILE_SIZE) + tidy) * beam + beam_axis; + const int out_idx_y = odata_offset + time * beam + (((int)blockIdx.y * TILE_SIZE) + tidy) * beam + beam_axis; + odata[out_idx_x] = voltage_x; + odata[out_idx_y] = voltage_y; + } +} + +/** +* @brief Device function to reduce / integrate the Stokes I power samples +* +* @param T data[32][32] Two dimensional array containing unintegrated power data (has to be in shared memory) +* @param int tidy Thread index in y-dimension +* @param int tidy Thread index in y-dimension +* @param int integrate Integration time / samples to accumulat +*/ +template<typename T> +__device__ void warp_reduce_tile(T data[TILE_SIZE][TILE_SIZE], const int tidy, const int tidx, const int integrate) +{ + if(integrate < 2) return; + if(tidy < 16) + { + data[tidy * 2][tidx] += data[tidy * 2 + 1][tidx]; + } +__syncthreads(); + if(integrate < 4) return; + if(tidy < 8) + { + data[tidy * 4][tidx] += data[tidy * 4 + 2][tidx]; + } +__syncthreads(); + if(integrate < 8) return; + if(tidy < 4) + { + data[tidy * 8][tidx] += data[tidy * 8 + 4][tidx]; + } +__syncthreads(); + if(integrate < 16) return; + if(tidy < 2) + { + data[tidy * 16][tidx] += data[tidy * 16 + 8][tidx]; + } +__syncthreads(); + if(integrate < 32) return; + if(tidy < 1) + { + data[tidy][tidx] += data[tidy + 16][tidx]; + } +__syncthreads(); +} + +// Function description in Beamformer.cuh +template<typename T=float2, typename U=float>__global__ +void beamformer_power_fpte_fpbe_ftb( + const float2 *idata, + const float2* wdata, + float *odata, + int time, int elem, int beam, int integrate) +{ + const int tidx = threadIdx.x; + const int tidy = threadIdx.y; + const int beam_axis = blockDim.x * blockIdx.x + tidx; + const int time_axis = blockDim.y * blockIdx.y + tidy; + const int freq = blockIdx.z; + + const int size_idata = elem * time; + const int size_wdata = elem * beam; + const int size_odata = time / integrate * beam; + + const int idata_offset = freq * 2 * size_idata; + const int wdata_offset = freq * 2 * size_wdata; + const int odata_offset = freq * size_odata; + + float2 voltage_x = {0,0}; + float2 voltage_y = {0,0}; + + __shared__ float2 s_idata_x[TILE_SIZE][TILE_SIZE]; + __shared__ float2 s_idata_y[TILE_SIZE][TILE_SIZE]; + __shared__ float2 s_wdata_x[TILE_SIZE][TILE_SIZE]; + __shared__ float2 s_wdata_y[TILE_SIZE][TILE_SIZE]; + __shared__ float s_odata[TILE_SIZE][TILE_SIZE]; + + s_idata_x[tidy][tidx] = {0,0}; + s_idata_y[tidy][tidx] = {0,0}; + s_wdata_x[tidy][tidx] = {0,0}; + s_wdata_y[tidy][tidx] = {0,0}; + s_odata[tidy][tidx] = {0}; + + for( int k = 0; k < elem; k+=TILE_SIZE ) + { + if(time_axis < time && tidx + k < elem) + { + s_idata_x[tidy][tidx] = idata[idata_offset + time_axis * elem + tidx + k]; + s_idata_y[tidy][tidx] = idata[idata_offset + size_idata + time_axis * elem + tidx + k]; + } + else + { + s_idata_x[tidy][tidx] = {0,0}; + s_idata_y[tidy][tidx] = {0,0}; + } + +__syncthreads(); + + if(beam_axis < beam && tidy + k < elem) + { + s_wdata_x[tidy][tidx] = wdata[wdata_offset + beam_axis * elem + tidy + k]; + s_wdata_y[tidy][tidx] = wdata[wdata_offset + size_wdata + beam_axis * elem + tidy + k]; + } + else + { + s_wdata_x[tidy][tidx] = {0,0}; + s_wdata_y[tidy][tidx] = {0,0}; + } + +__syncthreads(); + + for(int j = 0; j < TILE_SIZE; j++) + { + if(j + k == elem) + { + break; + } + voltage_x = cmadd(s_idata_x[tidy][j], s_wdata_x[j][tidx], voltage_x); + voltage_y = cmadd(s_idata_y[tidy][j], s_wdata_y[j][tidx], voltage_y); + } + } + s_odata[tidy][tidx] = voltage_x.x * voltage_x.x + voltage_x.y * voltage_x.y; + s_odata[tidy][tidx] += voltage_y.x * voltage_y.x + voltage_y.y * voltage_y.y; + +__syncthreads(); + + warp_reduce_tile(s_odata, tidy, tidx, integrate); + + if(beam_axis < beam && tidy < ceil((float)TILE_SIZE / integrate)) + { + const int out_idx = odata_offset + (((int)blockIdx.y * TILE_SIZE / integrate) + tidy) * beam + beam_axis; + odata[out_idx] = s_odata[tidy * integrate][tidx] / integrate; + } +} + +// Function description in Beamformer.cuh +__global__ void beamformer_power_fpte_fpbe_ftb( + const __half2 *idata, + const __half2 *wdata, + __half *odata, + int time, int elem, int beam, int integrate) +{ + const int tidx = threadIdx.x; + const int tidy = threadIdx.y; + const int beam_axis = blockDim.x * blockIdx.x + tidx; + const int time_axis = blockDim.y * blockIdx.y + tidy; + const int freq = blockIdx.z; + + const int size_idata = elem * time; + const int size_wdata = elem * beam; + const int size_odata = time / integrate * beam; + + const int idata_offset = freq * 2 * size_idata; + const int wdata_offset = freq * 2 * size_wdata; + const int odata_offset = freq * size_odata; + + __half2 voltage_x = {0,0}; + __half2 voltage_y = {0,0}; + + __shared__ __half2 s_idata_x[TILE_SIZE][TILE_SIZE]; + __shared__ __half2 s_idata_y[TILE_SIZE][TILE_SIZE]; + __shared__ __half2 s_wdata_x[TILE_SIZE][TILE_SIZE]; + __shared__ __half2 s_wdata_y[TILE_SIZE][TILE_SIZE]; + __shared__ __half s_odata[TILE_SIZE][TILE_SIZE]; + + s_idata_x[tidy][tidx] = {0,0}; + s_idata_y[tidy][tidx] = {0,0}; + s_wdata_x[tidy][tidx] = {0,0}; + s_wdata_y[tidy][tidx] = {0,0}; + s_odata[tidy][tidx] = {0}; + + for( int k = 0; k < elem; k+=TILE_SIZE ) + { + if(time_axis < time && tidx + k < elem) + { + s_idata_x[tidy][tidx] = idata[idata_offset + time_axis * elem + tidx + k]; + s_idata_y[tidy][tidx] = idata[idata_offset + size_idata + time_axis * elem + tidx + k]; + } + else + { + s_idata_x[tidy][tidx] = {0,0}; + s_idata_y[tidy][tidx] = {0,0}; + } + +__syncthreads(); + + if(beam_axis < beam && tidy + k < elem) + { + s_wdata_x[tidy][tidx] = wdata[wdata_offset + beam_axis * elem + tidy + k]; + s_wdata_y[tidy][tidx] = wdata[wdata_offset + size_wdata + beam_axis * elem + tidy + k]; + } + else + { + s_wdata_x[tidy][tidx] = {0,0}; + s_wdata_y[tidy][tidx] = {0,0}; + } + +__syncthreads(); + + for(int j = 0; j < TILE_SIZE; j++) + { + if(j + k == elem) + { + break; + } + voltage_x = cmadd(s_idata_x[tidy][j], s_wdata_x[j][tidx], voltage_x); + voltage_y = cmadd(s_idata_y[tidy][j], s_wdata_y[j][tidx], voltage_y); + } + } + s_odata[tidy][tidx] = voltage_x.x * voltage_x.x + voltage_x.y * voltage_x.y; + s_odata[tidy][tidx] += voltage_y.x * voltage_y.x + voltage_y.y * voltage_y.y; + +__syncthreads(); + + warp_reduce_tile(s_odata, tidy, tidx, integrate); + + if(beam_axis < beam && tidy < ceil((float)TILE_SIZE / integrate)) + { + const int out_idx = odata_offset + (((int)blockIdx.y * TILE_SIZE / integrate) + tidy) * beam + beam_axis; + odata[out_idx] = __hdiv(s_odata[tidy * integrate][tidx], __float2half((float)integrate)); + } +} + + +// ###################################################### +// NOTE: Kernels above are deprecated and not longer used +// ###################################################### + + +// ########################################## +// Optimized Voltage Beamformer (deprecated) +// ########################################## + +/* + +template<typename T=float2>__global__ +void beamformer_voltage_tfap_bftp_bfap(const float2 *idata, float2 *odata, const float2 *weights, const bf_config_t conf) +{ + // Grid layout: x = time; y = beam; z = channel + // Block layout: A block consist of NTHREADS and WARPS. Every warp + // calculates both polarisations of one beam for one channel at one given time step. + // Within a block 32 adjacent time steps for one beam are calculated (same channel). + // Data products are as follow (glob mem): + // idata: TFAP(t) + // odata: BFT + // weights: BFAP + // constraints: + // - n_elements must be a multiple of WARP_SIZE 32 + // - n_samples must be a multiple of WARP_SIZE 32 + + int tidx = threadIdx.x; + int bidx = blockIdx.x; // Time dimension (T) + int bidy = blockIdx.y; // Beam dimension (B) + int bidz = blockIdx.z; // Channel dimension (F) + + int n_elements = conf.n_elements * conf.n_pol; // Number of elements, product of antenna (A) and polarisation (P) + int warp = tidx / WARP_SIZE; // Calculate the current warp + int warp_idx = tidx % WARP_SIZE; // thread index -> warp index + + // Each thread has its own indices for accessing the global memory (idata, odata, weights). + int idata_glob_idx = warp_idx + n_elements * (bidx * WARPS * conf.n_channel + warp * conf.n_channel + bidz); + int weights_glob_idx = warp_idx + n_elements * (bidy * conf.n_channel + bidz); + int output_glob_idx = (bidy * conf.n_samples * conf.n_channel + + bidz * conf.n_samples + bidx * WARPS + warp)*conf.n_pol + warp_idx; // multiplied by two, since two polarisations + + // To enable higher throughput and more efficient data transfer, shared memory + // is required. The size in bytes of shared memory is calculated as follows: + // shared_mem_bytes = sizeof(T) * (A * P * (WARPS + 1) + NTHREADS) + // idata = sizeof(T) * A * P * WARPS <- every warp loads data of all elements at one time step + // weight = sizeof(T) * A * P <- weights are the same for all warps + // odata = sizeof(T) * NTHREADS <- Every thread calculates one output sample + extern __shared__ float2 shared_mem_fp32[]; // dynamically allocated + float2* shared_idata = (&shared_mem_fp32[0]); // idata space comes first + float2* shared_weights = (&shared_mem_fp32[n_elements * WARPS]); // weight space with idata space as offset + + // To prevent overflows when using integer values, the datatype of shared_odata has to be float2 (cuComplex). + float2 __shared__ shared_odata[NTHREAD]; + + shared_odata[tidx] = {0,0}; // intialize output with zeros + + float2 acc = {0,0}; // local register for storing intermediate results + + // Load idata and weights into shared memory for every warp +#pragma unroll + for(int i = 0; i < n_elements; i+=WARP_SIZE) + { + // It is important to access 32 adjacent samples, to increase the hit rate of cached memory + // Here each thread within a warp accesses adjacent samples! + shared_idata[warp * n_elements + i + warp_idx] = idata[idata_glob_idx + i]; + + // Since all warps within a block are using the same weights, only one warp needs to load the weights. + // This may not be the most efficient way, since all other 31 warps are idled until the weights are loaded. + // However, this approach prevents race conditions. + if(warp == 0) + shared_weights[i + warp_idx] = weights[weights_glob_idx + i]; + } + + __syncthreads(); // Synchronize all threads within a block, to ensure all data is loaded. + + // Iterate across all elements. + // Each thread within a warp performs n complex multiplications and 2*n additions (n = n_elements/WARP_SIZE). + // FLOP/thread = n * (6+2) +#pragma unroll + for(int i = 0; i < n_elements; i+=WARP_SIZE) + { + acc = cuCaddf(acc, cuCmulf(shared_idata[warp * n_elements + i + warp_idx], shared_weights[i + warp_idx])); + } + shared_odata[tidx] = acc; + + __syncthreads(); // Synchronize all threads within a block, to ensure all computitations are done. + + // Since odata contains NTHREAD samples which have not been combined to WARPS time steps a reduction is required. + int i = WARP_SIZE / 2; + // This reduction may no be very efficient since many threads within a warp are idled +#pragma unroll + while(i != conf.n_pol - 1) + { + if(warp_idx < i) + shared_odata[tidx] = cuCaddf(shared_odata[tidx], shared_odata[tidx + i]); + __syncthreads(); + i /= 2; + } + // After reduction the first two samples in shared_odata with warp offset contains both polarisations. + // So, if warp_idx is 0 or 1, assign the samples to the global output buffer. In total 64 + // samples are transfered back to the global memory for each block. + if(warp_idx < conf.n_pol) + { + // TODO: In case of integer inputs, conversion is implemented here!!! + odata[output_glob_idx] = shared_odata[tidx]; // Polarisation 0 and 1 + } + +} + + +template<typename T=__half2>__global__ +void beamformer_voltage_tfep_bfep_bftp(const __half2 *idata, __half2 *odata, const __half2 *weights, const bf_config_t conf) +{ + // Grid layout: x = time; y = beam; z = channel + // Block layout: A block consist of 1024 threads and 32 warps. Every warp + // calculates both polarisations of one beam for one channel at one given time step. + // Within a block 32 adjacent time steps for one beam are calculated (same channel). + // Data products are as follow (glob mem): + // idata: TFEP(t) + // odata: BFTP + // weights: BFEP + // constraints: + // - n_elements must be a multiple of WARP_SIZE 32 + // - n_samples must be a multiple of WARP_SIZE 32 + + const int tidx = threadIdx.x; + const int bidx = blockIdx.x; // Time dimension (T) + const int bidy = blockIdx.y; // Beam dimension (B) + const int bidz = blockIdx.z; // Channel dimension (F) +#if __CUDA_ARCH__ >= 530 + const int n_elements = conf.n_elements * conf.n_pol; // Number of elements, product of antenna (A) and polarisation (P) + const int warp = tidx / WARP_SIZE; // Calculate the current warp + const int warp_idx = tidx % WARP_SIZE; // thread index -> warp index + + // Each thread has its own indices for accessing the global memory (idata, odata, weights). + const int idata_glob_idx = warp_idx + n_elements * (bidx * WARPS * conf.n_channel + warp * conf.n_channel + bidz); + const int weights_glob_idx = warp_idx + n_elements * (bidy * conf.n_channel + bidz); + const int output_glob_idx = (bidy * conf.n_samples * conf.n_channel + + bidz * conf.n_samples + bidx * WARPS + warp)*conf.n_pol + warp_idx; // multiplied by two, since two polarisations + + // To enable higher throughput and more efficient data transfer, shared memory + // is required. The size in bytes of shared memory is calculated as follows: + // shared_mem_bytes = sizeof(T) * (A * P * (WARPS + 1) + NTHREADS) + // idata = sizeof(T) * A * P * WARPS <- every warp loads data of all elements at one time step + // weight = sizeof(T) * A * P <- weights are the same for all warps + // odata = sizeof(T) * NTHREADS <- Every thread calculates one output sample + extern __shared__ __half2 shared_mem_fp16[]; // dynamically allocated + __half2* shared_idata = (&shared_mem_fp16[0]); // idata space comes first + __half2* shared_weights = (&shared_mem_fp16[n_elements * WARPS]); // weight space with idata space as offset + + // To prevent overflows when using integer values, the datatype of shared_odata has to be float2 (cuCOmplex). + __half2 __shared__ shared_odata[NTHREAD]; + + shared_odata[tidx] = {0,0}; // intialize output with zeros + + __half2 acc = {0,0}; // local register for storing intermediate results + + // Load idata and weights into shared memory for every warp +#pragma unroll + for(int i = 0; i < n_elements; i+=WARP_SIZE) + { + // It is important to access 32 adjacent samples, to increase the hit rate of cached memory + // Here each thread within a warp accesses adjacent samples! + shared_idata[warp * n_elements + i + warp_idx] = idata[idata_glob_idx + i]; + + // Since all warps within a block are using the same weights, only one warp needs to load the weights. + // This may not be the most efficient way, since all other 31 warps are idled until the weights are loaded. + // However, this approach prevents race conditions. + if(warp == 0) + shared_weights[i + warp_idx] = weights[weights_glob_idx + i]; + } + + __syncthreads(); // Synchronize all threads within a block, to ensure all data is loaded. + + // Iterate across all elements. + // Each thread within a warp performs n complex multiplications and 2*n additions (n = n_elements/WARP_SIZE). + // FLOP/thread = n * (6+2) +#pragma unroll + for(int i = 0; i < n_elements; i+=WARP_SIZE) + { + acc = __hadd2(acc, (__hCmul2(shared_idata[warp * n_elements + i + warp_idx], shared_weights[i + warp_idx]))); + } + shared_odata[tidx] = (acc); + + __syncthreads(); // Synchronize all threads within a block, to ensure all computitations are done. + + // Since odata contains 1024 samples which have not been combined to 32 time steps a reduction is required. + int i = WARP_SIZE / 2; + // This reduction may no be very efficient since many threads within a warp are idled +#pragma unroll + while(i != conf.n_pol - 1) + { + if(warp_idx < i) + shared_odata[tidx] = __hadd2(shared_odata[tidx], shared_odata[tidx + i]); + __syncthreads(); + i /= 2; + } + + // After reduction the first two samples in shared_odata with warp offset contains both polarisations. + // So, if warp_idx is 0 or 1, assign the samples to the global output buffer. In total 64 + // samples are transfered back to the global memory for each block. + if(warp_idx < conf.n_pol) + { + // TODO: In case of integer inputs, conversion is implemented here!!! + odata[output_glob_idx] = (shared_odata[tidx]); // Polarisation 0 and 1 + } + +#else +if(tidx == 0 && bidx==0 && bidy == 0 && bidz == 0) + printf("Warning: CUDA architecture does not support half precisison. Beamforming not executed...\n"); +#endif + +} + +// ########################################## +// Optimized Power Beamformer (deprecated) +// ########################################## + +// Function to reduce voltage values in shared memory to power (called by beamformer_power_tfep_bfep_bft) +template<typename T, typename U> +__device__ void warp_reduce_v2p(T *s_odata, U *s_idata, int warp_idx){ + if(warp_idx < 16) + { + s_idata[warp_idx] = cadd(s_idata[warp_idx], s_idata[warp_idx + 16]); + } +__syncthreads(); + if(warp_idx < 8) + { + s_idata[warp_idx] = cadd(s_idata[warp_idx], s_idata[warp_idx + 8]); + } +__syncthreads(); + if(warp_idx < 4) + { + s_idata[warp_idx] = cadd(s_idata[warp_idx], s_idata[warp_idx + 4]); + } +__syncthreads(); + if(warp_idx < 2) + { + s_idata[warp_idx] = cadd(s_idata[warp_idx], s_idata[warp_idx + 2]); + } +__syncthreads(); + if(warp_idx < 1) + { + T x_power = s_idata[warp_idx].x * s_idata[warp_idx].x + s_idata[warp_idx].y * s_idata[warp_idx].y; + T y_power = s_idata[warp_idx + 1].x * s_idata[warp_idx + 1].x + s_idata[warp_idx + 1].y * s_idata[warp_idx + 1].y; + s_odata[0] += x_power + y_power; + } + __syncthreads(); + +} + +template<typename T=float2, typename U=float>__global__ +void beamformer_power_tfep_bfep_bft(const float2 *idata, const float2* weights, float *odata, const bf_config_t conf) +{ + int tidx = threadIdx.x; + int bidx = blockIdx.x; // Time dimension (T) + int bidy = blockIdx.y; // Channel dimension (F) + + const int n_elements = conf.n_elements * conf.n_pol; + const int n_timestamp = SHARED_IDATA / n_elements; // Number of timestamps loaded into shared memory + const int n_timestamp_iter = NTHREAD / n_elements; // Number of timestamps loaded in one iteration by all active threads + + // WARP grouping + const int warp_idx = tidx % WARP_SIZE; + const int warp = tidx / WARP_SIZE; + const int n_warps_per_grp = WARP_SIZE / n_timestamp_iter; + const int warp_grp = warp / n_warps_per_grp; // Devide all warps into groups to load one timestamp by each group + const int warp_grp_idx = warp_idx + (warp - n_warps_per_grp * warp_grp) * WARP_SIZE; // Index of thread within a warp group + + const int idata_offset = bidx * conf.interval * conf.n_channel * n_elements + bidy * n_elements; + const int odata_offset = bidy * conf.n_samples / conf.interval + bidx; // + + int idata_glob_idx; + T voltage, weight; + + + __shared__ float2 s_idata[SHARED_IDATA]; // Shared memory for input data + + extern __shared__ unsigned char s_mem[]; + U *s_odata = reinterpret_cast<U*>(&s_mem[0]); // Shared memory for power data + T *s_intermediate = reinterpret_cast<T*>(&s_mem[conf.n_beam * sizeof(U)]); // Shared memory for intermediate results + // T *s_weights = reinterpret_cast<T*>(&s_mem[conf.n_beam * sizeof(U) + NTHREAD*sizeof(T)]); + + + // IMPORTANT: s_odata has to be initialized to zero for each element in the array + for(int b = tidx; b < conf.n_beam; b += NTHREAD) + if(b < conf.n_beam) s_odata[b] = 0; + + + for(int t = 0; t < conf.interval; t += n_timestamp) + { + for(int i = 0; i < n_timestamp; i+=n_timestamp_iter) + { + idata_glob_idx = (t + warp_grp + i) * conf.n_channel * n_elements + warp_grp_idx; + s_idata[i/n_timestamp_iter * NTHREAD + tidx] = idata[idata_offset + idata_glob_idx]; + } + + __syncthreads(); + + for(int b = warp; b < conf.n_beam; b += WARPS) + { + for(int i = 0; i < n_timestamp; i++) + { + voltage = {0,0}; + for(int a = warp_idx; a < n_elements; a += WARP_SIZE) + { + weight = weights[b * conf.n_channel * n_elements + bidy * n_elements + a]; + // Complex multiplication: raw voltage * weight = voltage + voltage = cmadd(s_idata[i * n_elements + a], weight, voltage); + } + // Every thread accumulated n_elements/WARP_SIZE + // Load accumulated result to shared memory; Every thread has its own field, otherwise race condition may occur + s_intermediate[tidx] = voltage; + // Reduction + warp_reduce_v2p(&s_odata[b], &s_intermediate[warp * WARP_SIZE], warp_idx); + } + } + } + + for(int b = tidx; b < conf.n_beam; b += NTHREAD) + { + if(b < conf.n_beam) + { + const int odata_glob_idx = b * conf.n_channel * conf.n_samples / conf.interval; + odata[odata_offset + odata_glob_idx] = s_odata[b] / conf.interval; + } + } +} + +//#################### +//## Naive approach ## +//#################### + +template<typename T=float2, typename U=float>__global__ +void simple_bf_tfap_power(const float2 *idata, float *odata, const float2 *weights, const bf_config_t conf) +{ + int tidx = threadIdx.x + blockIdx.x * blockDim.x; // Time dimension + int tidy = blockIdx.y * blockDim.y; // Beam dimension + int tidz = blockIdx.z * blockDim.z; // Channel dimension + float2 acc{.0,.0}; + + int in_offset = tidx * conf.n_elements * conf.n_channel * conf.n_pol + tidz * conf.n_pol; + int out_offset = tidy * conf.n_samples * conf.n_channel + tidx * conf.n_channel; + int weight_offset = tidy * conf.n_elements * conf.n_channel * conf.n_pol + tidz * conf.n_pol; + + if(tidx < conf.n_samples && tidy < conf.n_beam && tidz < conf.n_channel) + { + for(int i = 0; i < conf.n_elements; i++) + { + acc.x = 0; acc.y = 0; + for(int k = 0; k < conf.n_pol; k++) + { + acc = cuCaddf(acc, cuCmulf(idata[in_offset + i * conf.n_channel * conf.n_pol + k], + weights[weight_offset + i * conf.n_channel * conf.n_pol + k])); + } + odata[out_offset + tidz] += (acc.x*acc.x + acc.y*acc.y); + } + } +} + +template<typename T=__half2, typename U=__half>__global__ +void simple_bf_tfap_power(const __half2 *idata, __half *odata, const __half2 *weights, const bf_config_t conf) +{ + int tidx = threadIdx.x + blockIdx.x * blockDim.x; // Time dimension + int tidy = blockIdx.y * blockDim.y; // Beam dimension + int tidz = blockIdx.z * blockDim.z; // Channel dimension + __half2 acc(0,0); + + int in_offset = tidx * conf.n_elements * conf.n_channel * conf.n_pol + tidz * conf.n_pol; + int out_offset = tidy * conf.n_samples * conf.n_channel + tidx * conf.n_channel; + int weight_offset = tidy * conf.n_elements * conf.n_channel * conf.n_pol + tidz * conf.n_pol; + + if(tidx < conf.n_samples && tidy < conf.n_beam && tidz < conf.n_channel) + { + for(int i = 0; i < conf.n_elements; i++) + { + acc.x = 0; acc.y = 0; + for(int k = 0; k < conf.n_pol; k++) + { + acc = __hadd2(acc, __hCmul2(idata[in_offset + i * conf.n_channel * conf.n_pol + k], + weights[weight_offset + i * conf.n_channel * conf.n_pol + k])); + } + odata[out_offset + tidz] += (acc.x*acc.x + acc.y*acc.y); + } + } +} + + + +template<typename T=float2>__global__ +void simple_bf_tafp_voltage(const float2 *idata, float2 *odata, const float2 *weights, const bf_config_t conf) +{ + int tidx = threadIdx.x + blockIdx.x * blockDim.x; // Time dimension + int tidy = blockIdx.y * blockDim.y; // Beam dimension + int tidz = blockIdx.z * blockDim.z; // Channel dimension + + int in_offset = tidx * conf.n_elements * conf.n_channel * conf.n_pol + tidz * conf.n_pol; + int out_offset = tidy * conf.n_samples * conf.n_channel * conf.n_pol + tidx * conf.n_channel * conf.n_pol + tidz * conf.n_pol ; + int weight_offset = tidy * conf.n_elements * conf.n_channel * conf.n_pol + tidz * conf.n_pol; + + float2 acc; + + if(tidx < conf.n_samples && tidy < conf.n_beam && tidz < conf.n_channel) + { + for(int k = 0; k < conf.n_pol; k++) + { + acc = {0,0}; + for(int i = 0; i < conf.n_elements; i++) + { + acc = cuCaddf(acc, cuCmulf(idata[in_offset + i * conf.n_channel * conf.n_pol + k], + weights[weight_offset + i * conf.n_channel * conf.n_pol + k])); + } + odata[out_offset + k] = acc; + } + } +} + +template<typename T=__half2>__global__ +void simple_bf_tafp_voltage(const __half2 *idata, __half2 *odata, const __half2 *weights, const bf_config_t conf) +{ + int tidx = threadIdx.x + blockIdx.x * blockDim.x; // Time dimension + int tidy = blockIdx.y * blockDim.y; // Beam dimension + int tidz = blockIdx.z * blockDim.z; // Channel dimension + + int in_offset = tidx * conf.n_elements * conf.n_channel * conf.n_pol + tidz * conf.n_pol; + int out_offset = tidy * conf.n_samples * conf.n_channel * conf.n_pol + tidx * conf.n_channel * conf.n_pol + tidz * conf.n_pol ; + int weight_offset = tidy * conf.n_elements * conf.n_channel * conf.n_pol + tidz * conf.n_pol; + + __half2 acc; + + if(tidx < conf.n_samples && tidy < conf.n_beam && tidz < conf.n_channel) + { + for(int k = 0; k < conf.n_pol; k++) + { + acc = {0,0}; + for(int i = 0; i < conf.n_elements; i++) + { + acc = __hadd2(acc, __hCmul2(idata[in_offset + i * conf.n_channel * conf.n_pol + k], + weights[weight_offset + i * conf.n_channel * conf.n_pol + k])); + } + odata[out_offset + k] = acc; + } + } +} + +*/ + +} +} + +#endif diff --git a/psrdada_cpp/cryopaf/details/UnpackerKernels.cu b/psrdada_cpp/cryopaf/details/UnpackerKernels.cu new file mode 100644 index 0000000000000000000000000000000000000000..2db7e7a443e20f966083469429308ea1d611090a --- /dev/null +++ b/psrdada_cpp/cryopaf/details/UnpackerKernels.cu @@ -0,0 +1,113 @@ +#ifdef UNPACKER_CUH + +namespace psrdada_cpp { +namespace cryopaf{ + + +__device__ __forceinline__ uint64_t swap64(uint64_t x) +{ + uint64_t result; + uint2 t; + asm("mov.b64 {%0,%1},%2; \n\t" + : "=r"(t.x), "=r"(t.y) : "l"(x)); + t.x = __byte_perm(t.x, 0, 0x0123); + t.y = __byte_perm(t.y, 0, 0x0123); + asm("mov.b64 %0,{%1,%2}; \n\t" + : "=l"(result) : "r"(t.y), "r"(t.x)); + return result; +} + + +template<typename T>__global__ +void unpack_codif_to_fpte(uint64_t const* __restrict__ idata, T* __restrict__ odata) +{ + int time = threadIdx.x + blockIdx.x * blockDim.x; // Time + int elem = threadIdx.y + blockIdx.y * blockDim.y; // Elements + int freq = threadIdx.z + blockIdx.z * blockDim.z; // Frequency + int chan = blockDim.z * gridDim.z; + + int time_in = blockIdx.x * blockDim.x * gridDim.y * chan + threadIdx.x * chan; + int freq_in = freq; + int elem_in = elem * NSAMP_DF * chan ; + + int freq_out = freq * NPOL_SAMP * gridDim.x * blockDim.x * gridDim.y; + int time_out = time * gridDim.y; + + int in_idx = time_in + freq_in + elem_in; + int out_idx_x = freq_out + time_out + elem; + int out_idx_y = freq_out + gridDim.x * blockDim.x * gridDim.y + time_out + elem; + + uint64_t tmp = swap64(idata[in_idx]); + + odata[out_idx_x].x = static_cast<decltype(T::x)>((tmp & 0x000000000000ffffLL)); + odata[out_idx_x].y = static_cast<decltype(T::y)>((tmp & 0x00000000ffff0000LL) >> 16); + + odata[out_idx_y].x = static_cast<decltype(T::x)>((tmp & 0x0000ffff00000000LL) >> 32); + odata[out_idx_y].y = static_cast<decltype(T::y)>((tmp & 0xffff000000000000LL) >> 48); +} + +template<typename U, typename T>__global__ +void unpack_spead_ttfep_to_fpte(U const* __restrict__ idata, T* __restrict__ odata) +{ + int time = threadIdx.x; // Time + int elem = blockIdx.y; // Elements + int freq = blockIdx.z; // Frequency + int heap_idx = blockIdx.x; + + int in_idx = heap_idx * NSAMP_PER_HEAP * gridDim.z * gridDim.y * NPOL_SAMP // Outer time axis + + time * gridDim.z * gridDim.y * NPOL_SAMP // Inner time axis + + freq * gridDim.y * NPOL_SAMP // Frequency axis + + elem * NPOL_SAMP; // Element axis + + int out_idx_x = freq * NPOL_SAMP * gridDim.x * NSAMP_PER_HEAP * gridDim.y // Frequency axis + + (time + blockIdx.x * blockDim.x) * gridDim.y + + elem; + int out_idx_y = freq * NPOL_SAMP * gridDim.x * NSAMP_PER_HEAP * gridDim.y // Frequency axis + + gridDim.x * NSAMP_PER_HEAP * gridDim.y + + (time + blockIdx.x * blockDim.x) * gridDim.y + + elem; + + odata[out_idx_x].x = static_cast<decltype(T::x)>(idata[in_idx].x); + odata[out_idx_x].y = static_cast<decltype(T::y)>(idata[in_idx].y); + + odata[out_idx_y].x = static_cast<decltype(T::x)>(idata[in_idx + 1].x); + odata[out_idx_y].y = static_cast<decltype(T::y)>(idata[in_idx + 1].y); +} + +// ###################################################### +// NOTE: Kernels above are deprecated and not longer used +// ###################################################### +/* +template<typename T>__global__ +void unpack_codif_to_tfep(uint64_t const* __restrict__ idata, T* __restrict__ odata) +{ + + int time = threadIdx.x + blockIdx.x * blockDim.x; // Time + int elem = threadIdx.y + blockIdx.y * blockDim.y; // Elements + int freq = threadIdx.z + blockIdx.z * blockDim.z; // Frequency + int chan = blockDim.z * gridDim.z; + + int time_in = blockIdx.x * blockDim.x * gridDim.y * chan + threadIdx.x * chan; + int freq_in = freq; + int elem_in = elem * NSAMP_DF * chan ; + + int time_out = time * chan * gridDim.y * NPOL_SAMP; + int freq_out = freq * gridDim.y * NPOL_SAMP; + int elem_out = elem * NPOL_SAMP; + + int in_idx = time_in + freq_in + elem_in; + int out_idx = time_out + freq_out + elem_out; + + uint64_t tmp = swap64(idata[in_idx]); + + odata[out_idx].x = static_cast<decltype(T::x)>((tmp & 0x000000000000ffffLL)); + odata[out_idx].y = static_cast<decltype(T::y)>((tmp & 0x00000000ffff0000LL) >> 16); + + odata[out_idx + 1].x = static_cast<decltype(T::x)>((tmp & 0x0000ffff00000000LL) >> 32); + odata[out_idx + 1].y = static_cast<decltype(T::y)>((tmp & 0xffff000000000000LL) >> 48); +} +*/ +} +} + +#endif diff --git a/psrdada_cpp/cryopaf/details/utils.cu b/psrdada_cpp/cryopaf/details/utils.cu new file mode 100644 index 0000000000000000000000000000000000000000..eb96919792ec39e84d49d2f6936f5a2ea7f5e549 --- /dev/null +++ b/psrdada_cpp/cryopaf/details/utils.cu @@ -0,0 +1,47 @@ +#ifndef UTILS_CU +#define UTILS_CU + +/** UTILS **/ +__device__ __half2 __hCmul2(__half2 a, __half2 b) +{ + const __half r = a.x * b.x - a.y * b.y; + const __half i = a.x * b.y + a.y * b.x; + + __half2 val; val.x = r; val.y = i; + return val; +} + +template<typename T> +__host__ __device__ T cmadd(T a, T b, T c) +{ + T val; + val.x = a.x * b.x - a.y * b.y + c.x; + val.y = a.x * b.y + a.y * b.x + c.y; + return val; +} + +template<typename T> +__host__ __device__ T cadd(T a, T b) +{ + T val; + val.x = a.x + b.x; + val.y = a.y + b.y; + return val; +} + +template<typename T> +__host__ __device__ T csub(T a, T b) +{ + T val; + val.x = a.x - b.x; + val.y = a.y - b.y; + return val; +} + +template<typename T> +__host__ __device__ double cabs(T a) +{ + return (double)sqrt((double)(a.x * a.x + a.y * a.y)); +} + +#endif diff --git a/psrdada_cpp/cryopaf/profiling/CMakeLists.txt b/psrdada_cpp/cryopaf/profiling/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..01e4ed2a49e5c66c8e57bf69ba747accfaaf6776 --- /dev/null +++ b/psrdada_cpp/cryopaf/profiling/CMakeLists.txt @@ -0,0 +1,6 @@ +set(profiling_src + KernelStatistics.cuh + profiling.cu +) +cuda_add_executable(profiling ${profiling_src} ) +target_link_libraries(profiling ${PSRDADA_CPP_CRYOPAF_LIBRARIES}) diff --git a/psrdada_cpp/cryopaf/profiling/KernelStatistics.cuh b/psrdada_cpp/cryopaf/profiling/KernelStatistics.cuh new file mode 100644 index 0000000000000000000000000000000000000000..0700835923f3f38d4427cc7bdbc5d590b8377da8 --- /dev/null +++ b/psrdada_cpp/cryopaf/profiling/KernelStatistics.cuh @@ -0,0 +1,83 @@ +#ifndef KERNEL_STATISTICS_CUH +#define KERNEL_STATISTICS_CUH + +#include <fstream> +#include <cuda.h> +#include "psrdada_cpp/cuda_utils.hpp" + + +struct ProfileConfig{ + int device_id; + std::size_t n_samples; + std::size_t n_channel; + std::size_t n_elements; + std::size_t n_beam; + std::size_t integration; + std::string precision; + std::string protocol; + std::string out_dir; + const std::size_t n_pol = 2; + }; + +class KernelProfiler +{ +public: + KernelProfiler(ProfileConfig& config, + cudaStream_t& cuda_stream, + std::string kernel_name, + std::size_t complexity, + std::size_t read_size, + std::size_t write_size, + std::size_t input_size); + ~KernelProfiler(); + void measure_start(); + void measure_stop(); + void update(float time_ms); + void finialize(); + void export_to_csv(std::string filename); + +private: + ProfileConfig& conf; + cudaStream_t& stream; + cudaDeviceProp prop; + + std::string name; + std::string head_line; + + cudaEvent_t start, stop; + std::vector<float> elapsed_time; + std::vector<float> compute_tput; + std::vector<float> memory_bw; + std::vector<float> input_bw; + std::vector<float> output_bw; + float peak_mem_bandwidth; + float ms = 0; + float avg_time = 0; + float min_time = 0; + float max_time = 0; + float avg_tput = 0; + float min_tput = 0; + float max_tput = 0; + float avg_m_bw = 0; + float min_m_bw = 0; + float max_m_bw = 0; + float avg_m_bw_perc = 0; + float min_m_bw_perc = 0; + float max_m_bw_perc = 0; + float avg_i_bw = 0; + float min_i_bw = 0; + float max_i_bw = 0; + float avg_o_bw = 0; + float min_o_bw = 0; + float max_o_bw = 0; + + std::size_t iterations = 0; + std::size_t reads; + std::size_t writes; + std::size_t input_sz; + std::size_t compute_complexity; +}; + +#include "psrdada_cpp/cryopaf/profiling/src/KernelStatistics.cu" + +#endif diff --git a/psrdada_cpp/cryopaf/profiling/Results/2080/power_kernel.csv b/psrdada_cpp/cryopaf/profiling/Results/2080/power_kernel.csv new file mode 100644 index 0000000000000000000000000000000000000000..cadafab915ff988efae41c76f54763f49fe5b037 --- /dev/null +++ b/psrdada_cpp/cryopaf/profiling/Results/2080/power_kernel.csv @@ -0,0 +1,225 @@ +devicename,kernelname,samples,channels,elements,beams,integration,precision,reads,writes,avg_time,min_time,max_time,avg_throughput,min_throughput,max_throughput,avg_bandwidth,min_bandwidth,max_bandwidth,percentage_avg_bandwidth,percentage_min_bandwidth,percentage_max_bandwidth,input_avg_bandwidth,input_min_bandwidth,input_max_bandwidth,output_avg_bandwidth,output_min_bandwidth,output_max_bandwidth +GeForce RTX 2080 Ti,StokesI,4096,32,16,32,1,half,16908288,8388608,0.431379,0.428544,0.450304,3734.09,3576.72,3758.34,58.649,56.1774,59.0299,19.0419,18.2394,19.1655,38.8967,37.2575,39.1493,19.4484,18.6288,19.5747 +GeForce RTX 2080 Ti,StokesI,4096,32,16,64,1,half,17039360,16777216,0.836163,0.833792,0.854784,3852.5,3768.47,3863.34,40.4437,39.5615,40.5576,13.1311,12.8447,13.168,20.0651,19.6274,20.1216,20.0651,19.6274,20.1216 +GeForce RTX 2080 Ti,StokesI,4096,32,16,96,1,half,17170432,25165824,1.23951,1.23632,1.25712,3898.24,3843.58,3908.24,34.1561,33.6772,34.2438,11.0897,10.9341,11.1181,13.5356,13.3458,13.5703,20.3033,20.0186,20.3554 +GeForce RTX 2080 Ti,StokesI,4096,32,16,128,1,half,17301504,33554432,1.64278,1.63978,1.66208,3921.71,3876.14,3928.86,30.9575,30.5978,31.014,10.0511,9.93434,10.0695,10.2128,10.0941,10.2314,20.4256,20.1882,20.4628 +GeForce RTX 2080 Ti,StokesI,4096,32,16,160,1,half,17432576,41943040,2.0486,2.04518,2.06515,3931.03,3899.5,3937.57,28.9837,28.7512,29.0319,9.41028,9.33481,9.42595,8.18965,8.12396,8.20328,20.4741,20.3099,20.5082 +GeForce RTX 2080 Ti,StokesI,4096,32,16,192,1,half,17563648,50331648,2.452,2.44874,2.46918,3941.14,3913.71,3946.39,27.6898,27.4971,27.7267,8.99019,8.92762,9.00217,6.84226,6.79464,6.85138,20.5268,20.3839,20.5541 +GeForce RTX 2080 Ti,StokesI,4096,32,16,224,1,half,17694720,58720256,2.85462,2.8511,2.87197,3949.49,3925.63,3954.36,26.7689,26.6072,26.8019,8.69121,8.6387,8.70191,5.87722,5.84171,5.88446,20.5703,20.446,20.5956 +GeForce RTX 2080 Ti,StokesI,4096,32,16,256,1,half,17825792,67108864,3.25683,3.25379,3.27613,3956.28,3932.97,3959.96,26.079,25.9253,26.1033,8.4672,8.41731,8.47509,5.1514,5.12105,5.1562,20.6056,20.4842,20.6248 +GeForce RTX 2080 Ti,StokesI,4096,32,16,288,1,half,17956864,75497472,3.63883,3.54909,3.68019,3984.17,3938.79,4084.29,25.6864,25.3939,26.3319,8.33975,8.24476,8.54933,4.61131,4.55879,4.72719,20.7509,20.5145,21.2724 +GeForce RTX 2080 Ti,StokesI,4096,32,16,320,1,half,18087936,83886080,4.04522,3.94173,4.08448,3981.99,3943.25,4086.06,25.2115,24.9662,25.8704,8.18555,8.10592,8.39948,4.1479,4.10755,4.25631,20.7395,20.5378,21.2815 +GeForce RTX 2080 Ti,StokesI,4096,32,16,352,1,half,18219008,92274688,4.42537,4.32982,4.48371,4004.23,3951.36,4091.79,24.9731,24.6434,25.5192,8.10816,8.00109,8.28546,3.79189,3.74181,3.8748,20.8554,20.58,21.3114 +GeForce RTX 2080 Ti,StokesI,4096,32,16,384,1,half,18350080,100663296,4.82417,4.72176,4.88384,4007.13,3957.41,4093.25,24.675,24.3688,25.2053,8.01136,7.91195,8.18354,3.47841,3.43525,3.55317,20.8705,20.6115,21.319 +GeForce RTX 2080 Ti,StokesI,4096,32,16,416,1,half,18481152,109051904,5.2092,5.11261,5.28925,4020.29,3958.59,4095.36,24.4876,24.1118,24.9448,7.95051,7.82849,8.09897,3.22139,3.17195,3.28154,20.939,20.6177,21.33 +GeForce RTX 2080 Ti,StokesI,4096,32,16,448,1,half,18612224,117440512,5.60644,5.50384,5.6937,4022.8,3960.27,4096.88,24.2726,23.8953,24.7196,7.88071,7.75822,8.02585,2.99315,2.94663,3.04827,20.9521,20.6264,21.3379 +GeForce RTX 2080 Ti,StokesI,4096,32,16,480,1,half,18743296,125829120,5.99562,5.89062,6.09469,4030.35,3963.98,4101.3,24.1183,23.7211,24.5428,7.8306,7.70164,7.96844,2.79885,2.75276,2.84812,20.9914,20.6457,21.3609 +GeForce RTX 2080 Ti,StokesI,4096,32,16,512,1,half,18874368,134217728,6.37795,6.28365,6.49574,4041.33,3967.18,4101.09,24.0086,23.5681,24.3636,7.79499,7.65197,7.91025,2.63108,2.5828,2.66998,21.0486,20.6624,21.3598 +GeForce RTX 2080 Ti,StokesI,4096,32,16,544,1,half,19005440,142606336,6.76775,6.67149,6.9017,4046.68,3967.2,4104.09,23.8854,23.4162,24.2242,7.75499,7.60268,7.86502,2.47958,2.43088,2.51476,21.0765,20.6625,21.3755 +GeForce RTX 2080 Ti,StokesI,4096,32,16,576,1,half,19136512,150994944,7.1673,7.06413,7.30042,4045.79,3971.15,4103.98,23.7424,23.3044,24.0839,7.70857,7.56635,7.81943,2.34131,2.29812,2.37499,21.0718,20.6831,21.3749 +GeForce RTX 2080 Ti,StokesI,4096,32,16,608,1,half,19267584,159383552,7.54792,7.4528,7.70458,4055.24,3971.88,4106.06,23.6743,23.1877,23.971,7.68646,7.52846,7.7828,2.22327,2.17757,2.25113,21.121,20.6869,21.3857 +GeForce RTX 2080 Ti,StokesI,4096,32,16,640,1,half,19398656,167772160,7.93679,7.84384,8.10518,4059.44,3974.28,4106.69,23.5875,23.0927,23.8621,7.6583,7.49764,7.74745,2.11429,2.06994,2.1389,21.1429,20.6994,21.389 +GeForce RTX 2080 Ti,StokesI,4096,32,16,672,1,half,19529728,176160768,8.3362,8.23075,8.5056,4058.26,3976.54,4109.33,23.4801,23.0073,23.7755,7.6234,7.46989,7.71933,2.01303,1.97249,2.03836,21.1368,20.7112,21.4028 +GeForce RTX 2080 Ti,StokesI,4096,32,16,704,1,half,19660800,184549376,8.7191,8.62323,8.91267,4064.76,3975.63,4109.07,23.426,22.9123,23.6814,7.60586,7.43907,7.68877,1.9246,1.8824,1.94558,21.1706,20.7064,21.4014 +GeForce RTX 2080 Ti,StokesI,4096,32,16,736,1,half,19791872,192937984,9.10998,9.01459,9.30995,4067.1,3978.98,4109.35,23.3558,22.8497,23.5984,7.58305,7.41874,7.66181,1.84198,1.80207,1.86112,21.1828,20.7238,21.4029 +GeForce RTX 2080 Ti,StokesI,4096,32,16,768,1,half,19922944,201326592,9.49502,9.4033,9.72022,4071.87,3976.73,4110.76,23.3063,22.7618,23.5289,7.56698,7.39019,7.63926,1.7673,1.72601,1.78418,21.2076,20.7121,21.4102 +GeForce RTX 2080 Ti,StokesI,4096,32,16,800,1,half,20054016,209715200,9.88771,9.79267,10.119,4073.07,3979.18,4111.78,23.2425,22.7067,23.4634,7.54626,7.3723,7.61798,1.69711,1.65799,1.71324,21.2139,20.7249,21.4155 +GeForce RTX 2080 Ti,StokesI,4096,32,16,832,1,half,20185088,218103808,10.2817,10.184,10.5201,4073.68,3980.58,4111.93,23.1807,22.6509,23.3984,7.5262,7.35419,7.59687,1.63208,1.59478,1.64741,21.2171,20.7322,21.4163 +GeForce RTX 2080 Ti,StokesI,4096,32,16,864,1,half,20316160,226492416,10.6738,10.5728,10.9185,4074.93,3982.83,4113.06,23.1274,22.6046,23.3437,7.50888,7.33917,7.57913,1.57212,1.53659,1.58683,21.2236,20.7439,21.4222 +GeForce RTX 2080 Ti,StokesI,4096,32,16,896,1,half,20447232,234881024,11.0678,10.9628,11.3222,4075.43,3983.06,4113.67,23.074,22.551,23.2905,7.49156,7.32177,7.56186,1.51616,1.48179,1.53038,21.2262,20.7451,21.4254 +GeForce RTX 2080 Ti,StokesI,4096,32,16,928,1,half,20578304,243269632,11.4607,11.3528,11.7247,4076.27,3983.71,4114.22,23.0265,22.5036,23.2408,7.47612,7.30636,7.54573,1.46418,1.43093,1.47781,21.2306,20.7485,21.4282 +GeForce RTX 2080 Ti,StokesI,4096,32,16,960,1,half,20709376,251658240,11.8509,11.744,12.1238,4077.93,3985.41,4114.3,22.987,22.4655,23.1921,7.46333,7.294,7.52989,1.41595,1.38382,1.42858,21.2392,20.7574,21.4287 +GeForce RTX 2080 Ti,StokesI,4096,32,16,992,1,half,20840448,260046848,12.23,12.1301,12.5305,4083.24,3984.6,4116.11,22.9712,22.4163,23.1561,7.45819,7.27802,7.51823,1.37206,1.33891,1.3831,21.2669,20.7531,21.4381 +GeForce RTX 2080 Ti,StokesI,4096,32,16,1024,1,half,20971520,268435456,12.6267,12.5261,12.9372,4082.51,3983.83,4114.56,22.9243,22.3702,23.1042,7.44294,7.26304,7.50137,1.32894,1.29682,1.33938,21.2631,20.7491,21.43 +GeForce RTX 2080 Ti,StokesI,4096,32,32,32,1,half,33816576,8388608,0.749462,0.747232,0.768416,4298.21,4192.03,4310.88,56.316,54.9249,56.482,18.2844,17.8328,18.3383,44.773,43.667,44.905,11.1933,10.9168,11.2262 +GeForce RTX 2080 Ti,StokesI,4096,32,32,64,1,half,34078720,16777216,1.47873,1.47664,1.49795,4356.8,4300.84,4362.91,34.392,33.9503,34.4403,11.1662,11.0228,11.1819,22.6917,22.4002,22.7235,11.3458,11.2001,11.3618 +GeForce RTX 2080 Ti,StokesI,4096,32,32,96,1,half,34340864,25165824,2.20549,2.20288,2.22598,4381.66,4341.31,4386.84,26.9813,26.7328,27.0131,8.76015,8.67947,8.7705,15.2141,15.074,15.2321,11.4106,11.3055,11.4241 +GeForce RTX 2080 Ti,StokesI,4096,32,32,128,1,half,34603008,33554432,2.93347,2.93107,2.95123,4392.39,4365.94,4395.97,23.2345,23.0946,23.2534,7.54366,7.49824,7.54981,11.4385,11.3696,11.4478,11.4385,11.3696,11.4478 +GeForce RTX 2080 Ti,StokesI,4096,32,32,160,1,half,34865152,41943040,3.64692,3.5535,3.68109,4416.89,4375.37,4532.46,21.0636,20.8656,21.6148,6.83884,6.77455,7.01778,9.20186,9.11536,9.44263,11.5023,11.3942,11.8033 +GeForce RTX 2080 Ti,StokesI,4096,32,32,192,1,half,35127296,50331648,4.34623,4.25914,4.40986,4447.84,4382.76,4537.86,19.6668,19.3791,20.0649,6.38534,6.29191,6.51456,7.72195,7.60896,7.87822,11.5829,11.4134,11.8173 +GeForce RTX 2080 Ti,StokesI,4096,32,32,224,1,half,35389440,58720256,5.0684,4.96797,5.14022,4449.78,4386.69,4538.79,18.5718,18.3085,18.9433,6.0298,5.94431,6.15042,6.6217,6.52782,6.75416,11.588,11.4237,11.8198 +GeForce RTX 2080 Ti,StokesI,4096,32,32,256,1,half,35651584,67108864,5.76655,5.6784,5.87021,4469.85,4389.93,4538.22,17.8241,17.5054,18.0967,5.78705,5.68358,5.87556,5.82012,5.71606,5.90913,11.6402,11.4321,11.8183 +GeForce RTX 2080 Ti,StokesI,4096,32,32,288,1,half,35913728,75497472,6.47605,6.38477,6.60592,4477.7,4388.64,4540.66,17.2076,16.8654,17.4495,5.58689,5.47577,5.66543,5.18253,5.07945,5.25539,11.6607,11.4288,11.8246 +GeForce RTX 2080 Ti,StokesI,4096,32,32,320,1,half,36175872,83886080,7.19868,7.09987,7.3359,4475.74,4391.04,4537.02,16.682,16.3663,16.9104,5.41625,5.31375,5.4904,4.66223,4.574,4.72606,11.6556,11.435,11.8152 +GeForce RTX 2080 Ti,StokesI,4096,32,32,352,1,half,36438016,92274688,7.89866,7.80611,8.06925,4486.93,4391.17,4539.2,16.2988,15.951,16.4887,5.29183,5.1789,5.35348,4.24898,4.15831,4.29848,11.6847,11.4354,11.8208 +GeForce RTX 2080 Ti,StokesI,4096,32,32,384,1,half,36700160,100663296,8.62508,8.51981,8.80038,4482.63,4392.39,4537.04,15.9295,15.6088,16.1228,5.17191,5.06779,5.23469,3.89117,3.81284,3.9384,11.6735,11.4385,11.8152 +GeForce RTX 2080 Ti,StokesI,4096,32,32,416,1,half,36962304,109051904,9.32999,9.22867,9.52947,4489.25,4394.36,4537.59,15.6532,15.3224,15.8218,5.08222,4.9748,5.13695,3.59715,3.52112,3.63589,11.6907,11.4436,11.8166 +GeForce RTX 2080 Ti,StokesI,4096,32,32,448,1,half,37224448,117440512,10.0359,9.94093,10.2668,4494.45,4392.53,4536.51,15.4142,15.0646,15.5584,5.00459,4.8911,5.05143,3.34409,3.26825,3.37538,11.7043,11.4389,11.8138 +GeForce RTX 2080 Ti,StokesI,4096,32,32,480,1,half,37486592,125829120,10.7357,10.6341,10.9887,4501.63,4397.08,4543.72,15.2155,14.8621,15.3577,4.94009,4.82536,4.98627,3.12613,3.05353,3.15536,11.723,11.4507,11.8326 +GeForce RTX 2080 Ti,StokesI,4096,32,32,512,1,half,37748736,134217728,11.4541,11.3639,11.7306,4500.4,4393.61,4535.39,15.016,14.6597,15.1327,4.87532,4.75963,4.91323,2.92995,2.86042,2.95273,11.7198,11.4417,11.8109 +GeForce RTX 2080 Ti,StokesI,4096,32,32,544,1,half,38010880,142606336,12.1254,12.0272,12.4319,4517.04,4404.87,4553.07,14.8985,14.5286,15.0174,4.83718,4.71706,4.87576,2.7678,2.69906,2.78987,11.7631,11.471,11.857 +GeForce RTX 2080 Ti,StokesI,4096,32,32,576,1,half,38273024,150994944,12.8814,12.7798,13.1888,4502,4396.3,4536.99,14.6957,14.3506,14.8099,4.77132,4.65929,4.8084,2.60533,2.54415,2.62558,11.724,11.4487,11.8151 +GeForce RTX 2080 Ti,StokesI,4096,32,32,608,1,half,38535168,159383552,13.5904,13.4861,13.9176,4504.19,4397.56,4538.23,14.5656,14.2208,14.6757,4.7291,4.61714,4.76484,2.4694,2.41094,2.48807,11.7297,11.452,11.8183 +GeForce RTX 2080 Ti,StokesI,4096,32,32,640,1,half,38797312,167772160,14.3073,14.2027,14.6558,4503.61,4395.83,4536.08,14.4403,14.0947,14.5444,4.68841,4.57621,4.72221,2.34563,2.2895,2.36254,11.7282,11.4475,11.8127 +GeForce RTX 2080 Ti,StokesI,4096,32,32,672,1,half,39059456,176160768,15.0137,14.9176,15.393,4506.27,4394.59,4534.63,14.3371,13.9817,14.4273,4.65489,4.53952,4.68418,2.23525,2.17986,2.24932,11.7351,11.4442,11.8089 +GeForce RTX 2080 Ti,StokesI,4096,32,32,704,1,half,39321600,184549376,15.7001,15.6019,16.0927,4514.43,4403.67,4542.2,14.2612,13.9113,14.349,4.63027,4.51667,4.65876,2.13751,2.08507,2.15066,11.7563,11.4679,11.8287 +GeForce RTX 2080 Ti,StokesI,4096,32,32,736,1,half,39583744,192937984,16.4163,16.3123,16.8394,4513.75,4399.69,4541.86,14.1662,13.8082,14.2544,4.5994,4.48318,4.62805,2.04427,1.99262,2.057,11.7546,11.4575,11.8278 +GeForce RTX 2080 Ti,StokesI,4096,32,32,768,1,half,39845888,201326592,17.1489,17.0525,17.5976,4508.68,4393.18,4533.6,14.0652,13.7049,14.1429,4.56661,4.44963,4.59185,1.95689,1.90676,1.96771,11.7414,11.4406,11.8062 +GeForce RTX 2080 Ti,StokesI,4096,32,32,800,1,half,40108032,209715200,17.859,17.754,18.3196,4509.84,4395.87,4535.9,13.9905,13.6369,14.0713,4.54237,4.42757,4.56862,1.8791,1.83161,1.88996,11.7444,11.4476,11.8122 +GeForce RTX 2080 Ti,StokesI,4096,32,32,832,1,half,40370176,218103808,18.5743,18.4672,19.0498,4509.59,4396.48,4535.18,13.9174,13.5684,13.9964,4.51865,4.40531,4.54429,1.80673,1.76141,1.81698,11.7437,11.4492,11.8104 +GeForce RTX 2080 Ti,StokesI,4096,32,32,864,1,half,40632320,226492416,19.2423,19.1301,19.7484,4520.49,4404.05,4546.4,13.884,13.5264,13.9636,4.50779,4.39168,4.53364,1.74401,1.69909,1.75401,11.7721,11.4689,11.8396 +GeForce RTX 2080 Ti,StokesI,4096,32,32,896,1,half,40894464,234881024,19.9857,19.8865,20.51,4513.46,4397.57,4535.46,13.8002,13.4459,13.8675,4.48059,4.36555,4.50243,1.67911,1.636,1.6873,11.7538,11.452,11.8111 +GeForce RTX 2080 Ti,StokesI,4096,32,32,928,1,half,41156608,243269632,20.682,20.5755,21.2359,4517.29,4398.94,4540.14,13.754,13.3936,13.8235,4.46557,4.34858,4.48816,1.62259,1.58008,1.6308,11.7638,11.4556,11.8233 +GeForce RTX 2080 Ti,StokesI,4096,32,32,960,1,half,41418752,251658240,21.4049,21.3021,21.9728,4515.23,4398.02,4536.49,13.6936,13.3382,13.7581,4.44599,4.33058,4.46692,1.56779,1.52709,1.57517,11.7584,11.4532,11.8138 +GeForce RTX 2080 Ti,StokesI,4096,32,32,992,1,half,41680896,260046848,22.1234,22.0235,22.7087,4514.15,4397.35,4534.16,13.6398,13.2869,13.7003,4.42851,4.31393,4.44814,1.51685,1.4776,1.52357,11.7556,11.4514,11.8077 +GeForce RTX 2080 Ti,StokesI,4096,32,32,1024,1,half,41943040,268435456,22.833,22.737,23.4344,4514.92,4398.63,4533.55,13.5947,13.2446,13.6508,4.41387,4.30018,4.43208,1.4697,1.43185,1.47576,11.7576,11.4548,11.8061 +GeForce RTX 2080 Ti,StokesI,4096,32,64,32,1,half,67633152,8388608,1.36643,1.36317,1.38307,4714.84,4658.07,4726.09,55.6357,54.9659,55.7684,18.0635,17.8461,18.1066,49.1129,48.5216,49.2301,6.13911,6.0652,6.15376 +GeForce RTX 2080 Ti,StokesI,4096,32,64,64,1,half,68157440,16777216,2.70566,2.70224,2.72592,4762.22,4726.81,4768.23,31.3916,31.1582,31.4312,10.1921,10.1163,10.2049,24.8032,24.6188,24.8345,6.20081,6.1547,6.20863 +GeForce RTX 2080 Ti,StokesI,4096,32,64,96,1,half,68681728,25165824,4.00736,3.91891,4.06291,4823.91,4757.02,4931.82,23.4234,23.0986,23.9473,7.605,7.49954,7.77511,16.7497,16.5174,17.1244,6.28114,6.19404,6.42164 +GeForce RTX 2080 Ti,StokesI,4096,32,64,128,1,half,69206016,33554432,5.31776,5.21974,5.40035,4847.08,4771.88,4936.99,19.3284,19.0285,19.6869,6.27545,6.17808,6.39184,12.6226,12.4268,12.8567,6.31131,6.21338,6.42837 +GeForce RTX 2080 Ti,StokesI,4096,32,64,160,1,half,69730304,41943040,6.60737,6.51558,6.7409,4876.26,4778.63,4943.88,16.905,16.5665,17.1394,5.48864,5.37875,5.56475,10.1589,9.95548,10.2997,6.34929,6.22218,6.43734 +GeForce RTX 2080 Ti,StokesI,4096,32,64,192,1,half,70254592,50331648,7.91888,7.8192,8.07869,4882.41,4784.78,4943.56,15.231,14.9265,15.4218,4.94515,4.84625,5.00708,8.47641,8.3069,8.58257,6.35731,6.23018,6.43693 +GeForce RTX 2080 Ti,StokesI,4096,32,64,224,1,half,70778880,58720256,9.22064,9.11936,9.42381,4891.93,4785.45,4945.21,14.0475,13.7417,14.2005,4.56087,4.46159,4.61054,7.27966,7.1212,7.35894,6.3697,6.23105,6.43908 +GeForce RTX 2080 Ti,StokesI,4096,32,64,256,1,half,71303168,67108864,10.5195,10.4254,10.7654,4900.32,4787.52,4943.65,13.16,12.8571,13.2764,4.27274,4.17439,4.31052,6.38062,6.23375,6.43705,6.38062,6.23375,6.43705 +GeForce RTX 2080 Ti,StokesI,4096,32,64,288,1,half,71827456,75497472,11.8119,11.7162,12.1,4909.66,4791.89,4948.87,12.4748,12.1756,12.5744,4.05026,3.95311,4.08261,5.68248,5.54617,5.72786,6.39279,6.23944,6.44384 +GeForce RTX 2080 Ti,StokesI,4096,32,64,320,1,half,72351744,83886080,13.1245,13.0242,13.4429,4909.53,4792.44,4946.53,11.9062,11.6223,11.996,3.86566,3.77347,3.8948,5.11409,4.99213,5.15263,6.39261,6.24016,6.44079 +GeForce RTX 2080 Ti,StokesI,4096,32,64,352,1,half,72876032,92274688,14.4211,14.3156,14.7686,4914.86,4798.48,4950.35,11.4537,11.1825,11.5365,3.71875,3.63069,3.7456,4.65422,4.54401,4.68783,6.39955,6.24802,6.44577 +GeForce RTX 2080 Ti,StokesI,4096,32,64,384,1,half,73400320,100663296,15.7267,15.6263,16.1211,4916.51,4795.55,4947.39,11.0696,10.7973,11.1391,3.59403,3.5056,3.6166,4.26781,4.1628,4.29461,6.40171,6.2442,6.44191 +GeForce RTX 2080 Ti,StokesI,4096,32,64,416,1,half,73924608,109051904,17.0196,16.9244,17.4583,4921.5,4797.25,4948.59,10.7522,10.4808,10.8114,3.49098,3.40285,3.5102,3.94351,3.84395,3.96522,6.40821,6.24642,6.44348 +GeForce RTX 2080 Ti,StokesI,4096,32,64,448,1,half,74448896,117440512,18.3302,18.2258,18.7958,4921.15,4798.65,4948.71,10.4698,10.2092,10.5284,3.39928,3.31467,3.41832,3.66157,3.57042,3.68208,6.40774,6.24824,6.44363 +GeForce RTX 2080 Ti,StokesI,4096,32,64,480,1,half,74973184,125829120,19.6609,19.5196,20.1428,4915.92,4797.57,4950.76,10.2148,9.96891,10.2872,3.3165,3.23666,3.34001,3.41383,3.33165,3.43803,6.40093,6.24684,6.4463 +GeForce RTX 2080 Ti,StokesI,4096,32,64,512,1,half,75497472,134217728,20.9312,20.8326,21.4816,4925.23,4798.5,4947.97,10.0204,9.76256,10.0667,3.25338,3.16966,3.2684,3.20653,3.12402,3.22133,6.41306,6.24804,6.44267 +GeForce RTX 2080 Ti,StokesI,4096,32,64,544,1,half,76021760,142606336,22.1868,22.081,22.7779,4936.92,4808.25,4960,9.85513,9.59826,9.90121,3.19972,3.11632,3.21468,3.02508,2.94623,3.03922,6.42829,6.26074,6.45834 +GeForce RTX 2080 Ti,StokesI,4096,32,64,576,1,half,76546048,150994944,23.5318,23.4351,24.1571,4928.43,4800.41,4948.31,9.6704,9.41921,9.70941,3.13974,3.05819,3.15241,2.8521,2.77802,2.8636,6.41722,6.25054,6.44311 +GeForce RTX 2080 Ti,StokesI,4096,32,64,608,1,half,77070336,159383552,24.8239,24.73,25.4904,4931.41,4802.07,4949.73,9.52604,9.27621,9.56144,3.09287,3.01175,3.10436,2.70362,2.63271,2.71367,6.4211,6.2527,6.44496 +GeForce RTX 2080 Ti,StokesI,4096,32,64,640,1,half,77594624,167772160,26.1832,25.9422,26.8557,4921.65,4797.83,4966.77,9.37228,9.13649,9.4582,3.04295,2.96639,3.07084,2.56336,2.49887,2.58686,6.40839,6.24718,6.46714 +GeForce RTX 2080 Ti,StokesI,4096,32,64,672,1,half,78118912,176160768,27.3147,27.2317,27.8481,4953.31,4858.19,4968.16,9.30972,9.13094,9.33763,3.02264,2.96459,3.0317,2.457,2.40982,2.46436,6.44962,6.32577,6.46896 +GeForce RTX 2080 Ti,StokesI,4096,32,64,704,1,half,78643200,184549376,28.5962,28.5159,29.1581,4956.61,4860.88,4970.35,9.20418,9.0264,9.22968,2.98837,2.93065,2.99665,2.34688,2.30155,2.35338,6.45393,6.32927,6.47181 +GeForce RTX 2080 Ti,StokesI,4096,32,64,736,1,half,79167488,192937984,29.8704,29.7967,30.4776,4960.86,4861.81,4972.91,9.10993,8.92804,9.13206,2.95777,2.89871,2.96495,2.24677,2.20191,2.25222,6.45945,6.33048,6.47514 +GeForce RTX 2080 Ti,StokesI,4096,32,64,768,1,half,79691776,201326592,31.2057,31.1321,31.833,4955.03,4857.19,4966.54,9.00573,8.8279,9.02664,2.92394,2.8662,2.93073,2.15062,2.10815,2.15561,6.45187,6.32446,6.46684 +GeForce RTX 2080 Ti,StokesI,4096,32,64,800,1,half,80216064,209715200,32.4966,32.4182,33.149,4956.46,4858.7,4968.23,8.92227,8.7463,8.94347,2.89684,2.83971,2.90372,2.06519,2.02446,2.0701,6.45372,6.32644,6.46906 +GeForce RTX 2080 Ti,StokesI,4096,32,64,832,1,half,80740352,218103808,33.7905,33.7117,34.4677,4957.34,4859.73,4968.71,8.84441,8.67027,8.8647,2.87156,2.81502,2.87815,1.98611,1.94701,1.99067,6.45487,6.32778,6.46967 +GeForce RTX 2080 Ti,StokesI,4096,32,64,864,1,half,81264640,226492416,35.063,34.982,35.774,4961.18,4862.37,4972.44,8.77764,8.60282,8.79757,2.84988,2.79312,2.85635,1.91403,1.87591,1.91838,6.45986,6.3312,6.47453 +GeForce RTX 2080 Ti,StokesI,4096,32,64,896,1,half,81788928,234881024,36.3865,36.3016,37.1108,4957.79,4860.81,4969.17,8.70333,8.53308,8.72331,2.82576,2.77048,2.83224,1.84441,1.80834,1.84865,6.45545,6.32917,6.47027 +GeForce RTX 2080 Ti,StokesI,4096,32,64,928,1,half,82313216,243269632,37.6835,37.5962,38.4417,4958.12,4860.12,4969.42,8.64031,8.46953,8.66,2.8053,2.74985,2.81169,1.78093,1.74573,1.78499,6.45588,6.32828,6.47059 +GeForce RTX 2080 Ti,StokesI,4096,32,64,960,1,half,82837504,251658240,38.9884,38.898,39.7677,4957.42,4860.06,4968.73,8.57973,8.41123,8.59931,2.78563,2.73092,2.79199,1.72133,1.68752,1.72525,6.45497,6.3282,6.4697 +GeForce RTX 2080 Ti,StokesI,4096,32,64,992,1,half,83361792,260046848,40.2884,40.193,41.098,4957.38,4859.51,4968.93,8.52413,8.35586,8.544,2.76758,2.71294,2.77403,1.66578,1.6329,1.66967,6.45492,6.32749,6.46996 +GeForce RTX 2080 Ti,StokesI,4096,32,64,1024,1,half,83886080,268435456,41.5805,41.4894,42.4165,4958.24,4860.33,4968.94,8.47355,8.30624,8.49184,2.75115,2.69683,2.75709,1.61401,1.58214,1.61749,6.45604,6.32856,6.46998 +GeForce RTX 2080 Ti,StokesI,4096,32,128,32,1,half,135266304,8388608,2.59544,2.59299,2.61248,4964.44,4932.06,4969.12,55.349,54.9879,55.4012,17.9705,17.8532,17.9874,51.7129,51.3756,51.7617,3.23206,3.21098,3.23511 +GeForce RTX 2080 Ti,StokesI,4096,32,128,64,1,half,136314880,16777216,5.07562,5.00128,5.13818,5077.79,5015.36,5152.64,30.1659,29.795,30.6106,9.79412,9.67371,9.9385,26.4468,26.1217,26.8367,3.30585,3.26521,3.35458 +GeForce RTX 2080 Ti,StokesI,4096,32,128,96,1,half,137363456,25165824,7.56869,7.4975,7.69197,5107.77,5025.33,5155.68,21.4764,21.1297,21.6778,6.97285,6.86031,7.03824,17.7353,17.4491,17.9017,3.32537,3.2717,3.35656 +GeForce RTX 2080 Ti,StokesI,4096,32,128,128,1,half,138412032,33554432,10.0566,9.96813,10.2232,5125.53,5041.44,5170.44,17.1018,16.8212,17.2516,5.55253,5.46143,5.60118,13.3477,13.1287,13.4647,3.33693,3.28218,3.36617 +GeForce RTX 2080 Ti,StokesI,4096,32,128,160,1,half,139460608,41943040,12.5638,12.4874,12.7874,5128.24,5038.14,5159.18,14.4399,14.1862,14.527,4.68827,4.6059,4.71655,10.6838,10.4961,10.7483,3.3387,3.28004,3.35884 +GeForce RTX 2080 Ti,StokesI,4096,32,128,192,1,half,140509184,50331648,15.0565,14.9834,15.3406,5135.01,5039.53,5159.67,12.6759,12.4402,12.7368,4.11557,4.03904,4.13533,8.91495,8.74918,8.95777,3.34311,3.28094,3.35916 +GeForce RTX 2080 Ti,StokesI,4096,32,128,224,1,half,141557760,58720256,17.5504,17.4735,17.8812,5139.49,5044.09,5161.79,11.4123,11.2005,11.4618,3.7053,3.63652,3.72137,7.64805,7.50609,7.68123,3.34602,3.28391,3.36054 +GeForce RTX 2080 Ti,StokesI,4096,32,128,256,1,half,142606336,67108864,20.0468,19.9693,20.4409,5142.25,5042.79,5161.89,10.4619,10.2596,10.5019,3.39673,3.33103,3.4097,6.69564,6.56613,6.72121,3.34782,3.28306,3.36061 +GeForce RTX 2080 Ti,StokesI,4096,32,128,288,1,half,143654912,75497472,22.5525,22.4704,22.9916,5142.28,5043.77,5160.76,9.71802,9.53187,9.75295,3.1552,3.09476,3.16654,5.95171,5.8377,5.9731,3.34784,3.2837,3.35987 +GeForce RTX 2080 Ti,StokesI,4096,32,128,320,1,half,144703488,83886080,25.0506,24.9616,25.5292,5143.87,5047.13,5161.89,9.12568,8.95405,9.15765,2.96288,2.90716,2.97326,5.3582,5.25742,5.37697,3.34887,3.28589,3.36061 +GeForce RTX 2080 Ti,StokesI,4096,32,128,352,1,half,145752064,92274688,27.5412,27.456,28.0804,5146.51,5047.44,5162.23,8.643,8.47662,8.6694,2.80617,2.75215,2.81474,4.87359,4.77977,4.88847,3.35059,3.28609,3.36082 +GeForce RTX 2080 Ti,StokesI,4096,32,128,384,1,half,146800640,100663296,30.0259,29.9507,30.6395,5149.75,5046.39,5162.45,8.24205,8.07663,8.26238,2.67599,2.62228,2.68259,4.47027,4.38054,4.48129,3.3527,3.28541,3.36097 +GeForce RTX 2080 Ti,StokesI,4096,32,128,416,1,half,147849216,109051904,32.5278,32.4458,33.1992,5149.79,5045.42,5162.57,7.89825,7.73818,7.91785,2.56437,2.5124,2.57073,4.12643,4.0428,4.13667,3.35273,3.28478,3.36105 +GeForce RTX 2080 Ti,StokesI,4096,32,128,448,1,half,148897792,117440512,35.024,34.9368,35.7348,5150.66,5047.98,5163.29,7.60479,7.4532,7.62344,2.46909,2.41987,2.47514,3.83233,3.75594,3.84173,3.35329,3.28645,3.36152 +GeForce RTX 2080 Ti,StokesI,4096,32,128,480,1,half,149946368,125829120,37.5242,37.4314,38.2777,5150.85,5049.24,5163.41,7.34958,7.20459,7.3675,2.38623,2.33915,2.39205,3.57698,3.50642,3.5857,3.35342,3.28727,3.3616 +GeForce RTX 2080 Ti,StokesI,4096,32,128,512,1,half,150994944,134217728,40.0276,39.9315,40.8382,5150.63,5048.17,5162.81,7.1257,6.98396,7.14256,2.31354,2.26752,2.31901,3.35327,3.28657,3.3612,3.35327,3.28657,3.3612 +GeForce RTX 2080 Ti,StokesI,4096,32,128,544,1,half,152043520,142606336,42.3714,42.285,43.2837,5169.78,5060.64,5180.16,6.95422,6.80741,6.96818,2.25786,2.2102,2.2624,3.16776,3.10088,3.17412,3.36574,3.29469,3.3725 +GeForce RTX 2080 Ti,StokesI,4096,32,128,576,1,half,153092096,150994944,45.0149,44.916,45.92,5152.43,5050.71,5163.6,6.75549,6.62211,6.77013,2.19334,2.15004,2.19809,2.98173,2.92286,2.98819,3.35445,3.28822,3.36172 +GeForce RTX 2080 Ti,StokesI,4096,32,128,608,1,half,154140672,159383552,47.4941,47.4159,48.4873,5154.73,5049.01,5163.1,6.60149,6.46611,6.61221,2.14334,2.09939,2.14682,2.82606,2.7681,2.83065,3.35594,3.28712,3.36139 +GeForce RTX 2080 Ti,StokesI,4096,32,128,640,1,half,155189248,167772160,50.0085,49.9112,51.0308,5153.23,5049.86,5163.13,6.45832,6.32876,6.47072,2.09686,2.05479,2.10088,2.68398,2.63013,2.68913,3.35497,3.28767,3.36142 +GeForce RTX 2080 Ti,StokesI,4096,32,128,672,1,half,156237824,176160768,52.4799,52.4076,53.5764,5156.06,5050.41,5163.05,6.33398,6.20419,6.34257,2.05649,2.01435,2.05928,2.55757,2.50516,2.56104,3.35681,3.28803,3.36136 +GeForce RTX 2080 Ti,StokesI,4096,32,128,704,1,half,157286400,184549376,55.045,54.8955,56.1126,5149.92,5051.77,5163.78,6.21032,6.09196,6.22703,2.01634,1.97791,2.02176,2.43841,2.39194,2.44497,3.35281,3.28891,3.36183 +GeForce RTX 2080 Ti,StokesI,4096,32,128,736,1,half,158334976,192937984,57.4332,57.3608,58.636,5160.07,5054.11,5166.47,6.11634,5.99074,6.12392,1.98582,1.94505,1.98828,2.33699,2.289,2.33988,3.35942,3.29044,3.36358 +GeForce RTX 2080 Ti,StokesI,4096,32,128,768,1,half,159383552,201326592,59.9671,59.8929,61.2086,5156.91,5052.19,5163.18,6.01527,5.89313,6.02259,1.95301,1.91335,1.95539,2.23824,2.19279,2.24096,3.35736,3.28919,3.36145 +GeForce RTX 2080 Ti,StokesI,4096,32,128,800,1,half,160432128,209715200,62.463,62.3826,63.7858,5157.13,5050.07,5163.66,5.926,5.80297,5.9335,1.92403,1.88408,1.92646,2.14881,2.10419,2.15153,3.35751,3.2878,3.36176 +GeForce RTX 2080 Ti,StokesI,4096,32,128,832,1,half,161480704,218103808,65.0261,64.8792,66.3319,5152.08,5050.47,5163.56,5.83763,5.7225,5.85064,1.89533,1.85795,1.89956,2.06413,2.02343,2.06873,3.35422,3.28807,3.36169 +GeForce RTX 2080 Ti,StokesI,4096,32,128,864,1,half,162529280,226492416,67.4609,67.3763,68.8797,5157.07,5050.72,5163.42,5.76676,5.64784,5.77386,1.87232,1.83371,1.87463,1.98961,1.94858,1.99206,3.35747,3.28823,3.3616 +GeForce RTX 2080 Ti,StokesI,4096,32,128,896,1,half,163577856,234881024,69.9608,69.8735,71.4245,5156.96,5051.17,5163.29,5.69558,5.57874,5.70258,1.84922,1.81128,1.85149,1.91851,1.87915,1.92087,3.3574,3.28852,3.36152 +GeForce RTX 2080 Ti,StokesI,4096,32,128,928,1,half,164626432,243269632,72.4594,72.3677,73.9841,5156.96,5050.57,5163.38,5.62943,5.51329,5.63644,1.82774,1.79003,1.83001,1.85236,1.81414,1.85466,3.3574,3.28813,3.36158 +GeForce RTX 2080 Ti,StokesI,4096,32,128,960,1,half,165675008,251658240,74.9625,74.8679,76.5291,5156.65,5050.98,5163.05,5.56735,5.45326,5.57426,1.80758,1.77054,1.80982,1.7905,1.75381,1.79273,3.3572,3.2884,3.36136 +GeForce RTX 2080 Ti,StokesI,4096,32,128,992,1,half,166723584,260046848,77.4623,77.3632,79.1086,5156.59,5049.16,5163.08,5.50952,5.39474,5.51646,1.78881,1.75154,1.79106,1.73272,1.69663,1.7349,3.35715,3.28721,3.36138 +GeForce RTX 2080 Ti,StokesI,4096,32,128,1024,1,half,167772160,268435456,79.9604,79.8612,81.6235,5156.63,5051.45,5162.92,5.45542,5.34415,5.46207,1.77124,1.73511,1.7734,1.67859,1.64435,1.68064,3.35718,3.2887,3.36128 +GeForce RTX 2080 Ti,StokesI,4096,32,256,32,1,half,270532608,8388608,5.04437,4.98378,5.10195,5109.1,5050.97,5170.74,55.2987,54.6695,55.9658,17.9541,17.7498,18.1707,53.2198,52.6143,53.8619,1.66312,1.6442,1.68318 +GeForce RTX 2080 Ti,StokesI,4096,32,256,64,1,half,272629760,16777216,9.89038,9.81078,10.0798,5211.78,5113.17,5253.36,29.2654,28.7116,29.4989,9.50174,9.32196,9.57755,27.1447,26.6311,27.3613,1.69654,1.66444,1.71008 +GeForce RTX 2080 Ti,StokesI,4096,32,256,96,1,half,274726912,25165824,14.782,14.718,15.0325,5230.29,5142.8,5252.71,20.2889,19.9496,20.3759,6.58732,6.47713,6.61555,18.1607,17.857,18.2386,1.70257,1.67409,1.70987 +GeForce RTX 2080 Ti,StokesI,4096,32,256,128,1,half,276824064,33554432,19.627,19.5561,20.0284,5252.26,5146.65,5270.95,15.8149,15.4969,15.8712,5.13472,5.03146,5.15298,13.6778,13.4027,13.7264,1.70972,1.67534,1.7158 +GeForce RTX 2080 Ti,StokesI,4096,32,256,160,1,half,278921216,41943040,24.5538,24.4709,25.0154,5247.92,5150.78,5265.39,13.0686,12.8267,13.1121,4.24304,4.1645,4.25716,10.9332,10.7308,10.9696,1.70831,1.67669,1.71399 +GeForce RTX 2080 Ti,StokesI,4096,32,256,192,1,half,281018368,50331648,29.4022,29.334,29.9977,5258.97,5154.36,5270.97,11.27,11.0459,11.2958,3.65911,3.58632,3.66745,9.13016,8.94855,9.151,1.71191,1.67785,1.71581 +GeForce RTX 2080 Ti,StokesI,4096,32,256,224,1,half,283115520,58720256,34.2809,34.1946,34.9957,5262.31,5154.6,5275.36,9.97206,9.76794,9.99679,3.23768,3.17141,3.24571,7.83082,7.67053,7.85024,1.71299,1.67793,1.71724 +GeForce RTX 2080 Ti,StokesI,4096,32,256,256,1,half,285212672,67108864,39.1785,39.0854,39.9699,5262.26,5157.85,5274.56,8.99312,8.81468,9.01414,2.91984,2.86191,2.92667,6.8519,6.71595,6.86791,1.71298,1.67899,1.71698 +GeForce RTX 2080 Ti,StokesI,4096,32,256,288,1,half,287309824,75497472,44.0511,43.9624,44.9581,5265.15,5158.76,5275.6,8.23632,8.0699,8.25267,2.67413,2.6201,2.67944,6.09393,5.97079,6.10602,1.71392,1.67928,1.71732 +GeForce RTX 2080 Ti,StokesI,4096,32,256,320,1,half,289406976,83886080,48.9138,48.8339,49.9461,5268.54,5159.52,5277.03,7.63184,7.47392,7.64413,2.47787,2.4266,2.48186,5.48807,5.3745,5.49691,1.71502,1.67953,1.71778 +GeForce RTX 2080 Ti,StokesI,4096,32,256,352,1,half,291504128,92274688,53.7931,53.7236,54.9255,5269.72,5160.95,5276.41,7.13451,6.98726,7.14357,2.3164,2.26859,2.31934,4.99026,4.88726,4.9966,1.7154,1.68,1.71758 +GeForce RTX 2080 Ti,StokesI,4096,32,256,384,1,half,293601280,100663296,58.6548,58.5806,59.9037,5272.29,5162.25,5278.84,6.72194,6.58164,6.73029,2.18245,2.1369,2.18516,4.57664,4.48112,4.58232,1.71624,1.68042,1.71837 +GeForce RTX 2080 Ti,StokesI,4096,32,256,416,1,half,295698432,109051904,63.5555,63.4724,64.8995,5271.22,5161.95,5278.01,6.3686,6.23658,6.3768,2.06773,2.02486,2.07039,4.22373,4.13617,4.22917,1.71589,1.68032,1.7181 +GeForce RTX 2080 Ti,StokesI,4096,32,256,448,1,half,297795584,117440512,68.4302,68.3503,69.874,5272.32,5163.25,5278.36,6.06817,5.94264,6.07512,1.97018,1.92943,1.97244,3.92285,3.8417,3.92735,1.71625,1.68075,1.71821 +GeForce RTX 2080 Ti,StokesI,4096,32,256,480,1,half,299892736,125829120,73.3134,73.2173,74.8612,5272.65,5163.52,5279.45,5.80701,5.68682,5.8145,1.88539,1.84637,1.88782,3.66156,3.58578,3.66629,1.71636,1.68083,1.71857 +GeForce RTX 2080 Ti,StokesI,4096,32,256,512,1,half,301989888,134217728,78.2074,78.1078,79.8371,5272.21,5164.48,5278.82,5.5777,5.46372,5.58468,1.81094,1.77394,1.81321,3.43243,3.36229,3.43673,1.71622,1.68115,1.71836 +GeForce RTX 2080 Ti,StokesI,4096,32,256,544,1,half,304087040,142606336,83.0527,82.9534,84.8,5274.92,5166.12,5281.12,5.37856,5.26761,5.38487,1.74628,1.71026,1.74833,3.23218,3.16551,3.23598,1.7171,1.68168,1.71911 +GeForce RTX 2080 Ti,StokesI,4096,32,256,576,1,half,306184192,150994944,87.9714,87.8581,89.8203,5272.93,5164.27,5279.61,5.19703,5.08993,5.20361,1.68735,1.65257,1.68948,3.05147,2.98858,3.05533,1.71645,1.68108,1.71862 +GeForce RTX 2080 Ti,StokesI,4096,32,256,608,1,half,308281344,159383552,92.8522,92.7416,94.8018,5273.3,5164.74,5279.47,5.03677,4.93308,5.04266,1.63532,1.60165,1.63723,2.89106,2.83155,2.89444,1.71657,1.68123,1.71858 +GeForce RTX 2080 Ti,StokesI,4096,32,256,640,1,half,310378496,167772160,97.7376,97.6105,99.7781,5273.38,5165.42,5280.13,4.8923,4.79214,4.89856,1.58841,1.55589,1.59044,2.74655,2.69032,2.75007,1.7166,1.68145,1.71879 +GeForce RTX 2080 Ti,StokesI,4096,32,256,672,1,half,312475648,176160768,102.624,102.5,104.765,5273.4,5165.51,5279.67,4.76153,4.66411,4.76718,1.54595,1.51432,1.54779,2.61578,2.56226,2.61888,1.7166,1.68148,1.71864 +GeForce RTX 2080 Ti,StokesI,4096,32,256,704,1,half,314572800,184549376,107.489,107.363,109.74,5274.49,5166.17,5280.55,4.64359,4.54822,4.64892,1.50766,1.4767,1.50939,2.49739,2.4461,2.50026,1.71696,1.68169,1.71893 +GeForce RTX 2080 Ti,StokesI,4096,32,256,736,1,half,316669952,192937984,112.381,112.239,114.708,5274.21,5167.06,5280.73,4.53476,4.44264,4.54037,1.47233,1.44242,1.47415,2.38868,2.34016,2.39164,1.71687,1.68199,1.71899 +GeForce RTX 2080 Ti,StokesI,4096,32,256,768,1,half,318767104,201326592,117.271,117.13,119.73,5274.04,5165.59,5280.25,4.43509,4.34389,4.44032,1.43996,1.41035,1.44166,2.28908,2.24201,2.29178,1.71681,1.68151,1.71883 +GeForce RTX 2080 Ti,StokesI,4096,32,256,800,1,half,320864256,209715200,122.148,122.001,124.718,5274.44,5165.61,5280.67,4.34386,4.25423,4.34899,1.41034,1.38124,1.41201,2.19768,2.15234,2.20028,1.71694,1.68151,1.71897 +GeForce RTX 2080 Ti,StokesI,4096,32,256,832,1,half,322961408,218103808,127.024,126.9,129.278,5274.79,5182.76,5279.87,4.25962,4.18529,4.26372,1.38299,1.35886,1.38432,2.1133,2.07643,2.11533,1.71705,1.6871,1.71871 +GeForce RTX 2080 Ti,StokesI,4096,32,256,864,1,half,325058560,226492416,131.955,131.777,134.406,5273.01,5176.76,5280.03,4.17994,4.10363,4.1855,1.35712,1.33235,1.35893,2.03434,1.99721,2.03705,1.71648,1.68514,1.71876 +GeForce RTX 2080 Ti,StokesI,4096,32,256,896,1,half,327155712,234881024,136.808,136.661,139.389,5274.29,5176.56,5279.9,4.10828,4.03215,4.11265,1.33386,1.30914,1.33527,1.96216,1.9258,1.96425,1.71689,1.68508,1.71872 +GeForce RTX 2080 Ti,StokesI,4096,32,256,928,1,half,329252864,243269632,141.667,141.52,144.303,5275.3,5178.85,5280.71,4.04139,3.9675,4.04553,1.31214,1.28815,1.31348,1.89486,1.86022,1.89681,1.71722,1.68582,1.71898 +GeForce RTX 2080 Ti,StokesI,4096,32,256,960,1,half,331350016,251658240,146.535,146.393,148.794,5275.9,5195.72,5280.96,3.97868,3.91822,3.98249,1.29178,1.27215,1.29302,1.83191,1.80407,1.83367,1.71741,1.69132,1.71906 +GeForce RTX 2080 Ti,StokesI,4096,32,256,992,1,half,333447168,260046848,151.432,151.287,154.014,5275.49,5186.96,5280.47,3.91928,3.85351,3.92298,1.27249,1.25114,1.27369,1.77268,1.74293,1.77435,1.71728,1.68846,1.7189 +GeForce RTX 2080 Ti,StokesI,4096,32,256,1024,1,half,335544320,268435456,156.311,156.155,158.946,5275.66,5188.14,5280.85,3.86401,3.79991,3.86781,1.25455,1.23374,1.25578,1.71734,1.68885,1.71903,1.71734,1.68885,1.71903 +GeForce RTX 2080 Ti,StokesI,4096,32,512,32,1,half,541065216,8388608,9.91923,9.85802,10.0728,5196.36,5116.71,5228.19,55.3974,54.5483,55.7368,17.9862,17.7105,18.0963,54.1288,53.2991,54.4603,0.845762,0.832798,0.850943 +GeForce RTX 2080 Ti,StokesI,4096,32,512,64,1,half,545259520,16777216,19.4712,19.3901,19.9196,5294.38,5174.76,5316.08,28.8675,28.2152,28.9858,9.37256,9.16079,9.41097,27.5749,26.9519,27.6879,0.861715,0.842246,0.865247 +GeForce RTX 2080 Ti,StokesI,4096,32,512,96,1,half,549453824,25165824,29.1576,29.0894,29.7047,5303.07,5205.2,5315.3,19.7081,19.3444,19.7536,6.39874,6.28065,6.4135,18.4134,18.0736,18.4559,0.86313,0.8472,0.865121 +GeForce RTX 2080 Ti,StokesI,4096,32,512,128,1,half,553648128,33554432,38.7546,38.6602,39.5681,5319.84,5210.22,5332.57,15.1525,14.8403,15.1888,4.91965,4.81828,4.93143,13.8537,13.5683,13.8869,0.865859,0.848017,0.867932 +GeForce RTX 2080 Ti,StokesI,4096,32,512,160,1,half,557842432,41943040,48.4396,48.3637,49.4418,5320.11,5212.15,5328.33,12.3824,12.1311,12.4016,4.02026,3.93868,4.02648,11.0836,10.8586,11.1007,0.865903,0.848332,0.867241 +GeForce RTX 2080 Ti,StokesI,4096,32,512,192,1,half,562036736,50331648,58.0541,57.9804,59.2916,5326.84,5215.54,5333.48,10.5485,10.3281,10.5616,3.42483,3.35328,3.4291,9.24798,9.05476,9.25952,0.866998,0.848884,0.86808 +GeForce RTX 2080 Ti,StokesI,4096,32,512,224,1,half,566231040,58720256,67.7158,67.6136,69.1462,5327.94,5217.6,5335.87,9.22925,9.03811,9.24298,2.99651,2.93445,3.00097,7.92848,7.76428,7.94028,0.867178,0.849218,0.868468 +GeForce RTX 2080 Ti,StokesI,4096,32,512,256,1,half,570425344,67108864,77.3574,77.2562,79.0135,5330.15,5218.31,5337.01,8.24161,8.06867,8.25221,2.67585,2.6197,2.67929,6.9403,6.79467,6.94923,0.867538,0.849334,0.868653 +GeForce RTX 2080 Ti,StokesI,4096,32,512,288,1,half,574619648,75497472,87.0042,86.8963,88.8557,5331.55,5220.33,5338.05,7.47242,7.31655,7.48153,2.42611,2.3755,2.42907,6.17077,6.04205,6.1783,0.867765,0.849663,0.868823 +GeForce RTX 2080 Ti,StokesI,4096,32,512,320,1,half,578813952,83886080,96.6714,96.5541,98.7006,5331.55,5221.81,5337.9,6.85534,6.71425,6.86351,2.22576,2.17995,2.22841,5.55369,5.43939,5.56031,0.867765,0.849905,0.868799 +GeForce RTX 2080 Ti,StokesI,4096,32,512,352,1,half,583008256,92274688,106.329,106.202,108.578,5332.01,5221.45,5338.26,6.35101,6.21933,6.35846,2.06202,2.01926,2.06443,5.04925,4.94456,5.05517,0.867839,0.849846,0.868858 +GeForce RTX 2080 Ti,StokesI,4096,32,512,384,1,half,587202560,100663296,115.973,115.831,118.353,5333.03,5225.71,5339.46,5.93137,5.81201,5.93853,1.92577,1.88702,1.92809,4.62936,4.5362,4.63495,0.868006,0.850538,0.869053 +GeForce RTX 2080 Ti,StokesI,4096,32,512,416,1,half,591396864,109051904,125.616,125.49,127.86,5333.9,5240.2,5339.17,5.57618,5.47823,5.58169,1.81045,1.77865,1.81224,4.27396,4.19888,4.27818,0.868148,0.852898,0.869006 +GeForce RTX 2080 Ti,StokesI,4096,32,512,448,1,half,595591168,117440512,135.261,135.109,137.865,5334.65,5233.76,5340.55,5.27163,5.17194,5.27747,1.71157,1.6792,1.71346,3.96923,3.89417,3.97363,0.868269,0.851849,0.869231 +GeForce RTX 2080 Ti,StokesI,4096,32,512,480,1,half,599785472,125829120,144.888,144.747,147.391,5335.9,5245.17,5341.02,5.0082,4.92304,5.013,1.62604,1.59839,1.6276,3.70549,3.64248,3.70904,0.868474,0.853707,0.869306 +GeForce RTX 2080 Ti,StokesI,4096,32,512,512,1,half,603979776,134217728,154.536,154.387,156.772,5336.26,5260.07,5341.33,4.77693,4.70872,4.78147,1.55095,1.52881,1.55242,3.47413,3.42453,3.47743,0.868532,0.856132,0.869358 +GeForce RTX 2080 Ti,StokesI,4096,32,512,544,1,half,608174080,142606336,164.153,164.02,166.39,5337.6,5265.77,5341.88,4.57371,4.51216,4.57738,1.48497,1.46499,1.48616,3.27059,3.22657,3.27321,0.868749,0.857059,0.869447 +GeForce RTX 2080 Ti,StokesI,4096,32,512,576,1,half,612368384,150994944,173.85,173.693,176.386,5336.35,5259.55,5341.1,4.39099,4.32779,4.39489,1.42565,1.40513,1.42691,3.08817,3.04372,3.09091,0.868547,0.856047,0.86932 +GeForce RTX 2080 Ti,StokesI,4096,32,512,608,1,half,616562688,159383552,183.455,183.317,185.696,5337.87,5273.42,5341.87,4.22966,4.17858,4.23282,1.37327,1.35668,1.37429,2.92647,2.89113,2.92865,0.868795,0.858303,0.869444 +GeForce RTX 2080 Ti,StokesI,4096,32,512,640,1,half,620756992,167772160,193.243,192.958,195.449,5334.25,5273.96,5342.05,4.08056,4.03444,4.08653,1.32486,1.30988,1.3268,2.77826,2.74686,2.78232,0.868205,0.858392,0.869475 +GeForce RTX 2080 Ti,StokesI,4096,32,512,672,1,half,624951296,176160768,202.767,202.618,205.235,5337.86,5273.63,5341.73,3.95094,3.90339,3.9538,1.28277,1.26734,1.2837,2.64775,2.61589,2.64967,0.868793,0.858338,0.869422 +GeForce RTX 2080 Ti,StokesI,4096,32,512,704,1,half,629145600,184549376,212.441,212.249,215.052,5337.38,5272.56,5342.17,3.83024,3.78372,3.83368,1.24358,1.22848,1.2447,2.52717,2.49648,2.52944,0.868714,0.858164,0.869494 +GeForce RTX 2080 Ti,StokesI,4096,32,512,736,1,half,633339904,192937984,222.046,221.913,224.287,5338.62,5285.25,5341.78,3.72123,3.68403,3.72343,1.20819,1.19611,1.20891,2.41785,2.39368,2.41928,0.868916,0.860229,0.86943 +GeForce RTX 2080 Ti,StokesI,4096,32,512,768,1,half,637534208,201326592,231.7,231.531,234.243,5338.63,5280.64,5342.48,3.62049,3.58116,3.6231,1.17548,1.16271,1.17633,2.31711,2.29194,2.31878,0.868917,0.859479,0.869544 +GeForce RTX 2080 Ti,StokesI,4096,32,512,800,1,half,641728512,209715200,241.348,241.184,243.844,5338.76,5284.08,5342.35,3.52789,3.49176,3.53027,1.14542,1.13369,1.14619,2.22448,2.2017,2.22598,0.868938,0.86004,0.869524 +GeForce RTX 2080 Ti,StokesI,4096,32,512,832,1,half,645922816,218103808,250.983,250.834,253.512,5339.15,5285.87,5342.29,3.44258,3.40823,3.44461,1.11772,1.10657,1.11838,2.13908,2.11773,2.14034,0.869002,0.86033,0.869514 +GeForce RTX 2080 Ti,StokesI,4096,32,512,864,1,half,650117120,226492416,260.636,260.481,263.087,5339.16,5289.38,5342.31,3.36337,3.33201,3.36535,1.092,1.08182,1.09265,2.05986,2.04066,2.06108,0.869003,0.860902,0.869516 +GeForce RTX 2080 Ti,StokesI,4096,32,512,896,1,half,654311424,234881024,270.252,270.104,272.443,5339.88,5296.92,5342.78,3.29024,3.26377,3.29203,1.06826,1.05967,1.06884,1.98656,1.97058,1.98764,0.869121,0.862129,0.869594 +GeForce RTX 2080 Ti,StokesI,4096,32,512,928,1,half,658505728,243269632,279.898,279.727,282.438,5340,5291.95,5343.25,3.22182,3.19283,3.22377,1.04604,1.03663,1.04668,1.9181,1.90085,1.91927,0.869141,0.861321,0.869669 +GeForce RTX 2080 Ti,StokesI,4096,32,512,960,1,half,662700032,251658240,289.545,289.392,291.896,5340.08,5297.06,5342.89,3.15793,3.13248,3.15959,1.0253,1.01704,1.02584,1.85419,1.83926,1.85517,0.869154,0.862151,0.869612 +GeForce RTX 2080 Ti,StokesI,4096,32,512,992,1,half,666894336,260046848,299.223,299.049,301.794,5339.61,5294.09,5342.7,3.09784,3.07143,3.09963,1.00579,0.997218,1.00637,1.79423,1.77893,1.79526,0.869078,0.861669,0.86958 +GeForce RTX 2080 Ti,StokesI,4096,32,512,1024,1,half,671088640,268435456,308.853,308.713,311.177,5340,5300.09,5342.39,3.04199,3.01926,3.04336,0.987659,0.980278,0.988103,1.73828,1.72529,1.73906,0.86914,0.862644,0.86953 +GeForce RTX 2080 Ti,StokesI,4096,32,1024,32,1,half,1082130432,8388608,19.6565,19.5928,19.9938,5244.29,5155.57,5261.07,55.4816,54.543,55.6591,18.0135,17.7088,18.0711,54.628,53.7038,54.8028,0.426781,0.419561,0.428147 +GeForce RTX 2080 Ti,StokesI,4096,32,1024,64,1,half,1090519040,16777216,38.651,38.5435,39.5756,5334.16,5209.23,5348.72,28.6503,27.9793,28.7285,9.30204,9.08417,9.32742,27.7821,27.1314,27.8579,0.434095,0.423928,0.43528 +GeForce RTX 2080 Ti,StokesI,4096,32,1024,96,1,half,1098907648,25165824,57.898,57.8223,59.1044,5341.2,5232.05,5348.07,19.4152,19.0184,19.4401,6.30362,6.17481,6.31174,18.5458,18.1669,18.5697,0.434668,0.425786,0.435227 +GeForce RTX 2080 Ti,StokesI,4096,32,1024,128,1,half,1107296256,33554432,76.95,76.8489,78.6686,5358.38,5241.19,5365.29,14.8263,14.502,14.8454,4.81372,4.70844,4.81993,13.9541,13.6489,13.9721,0.436066,0.426529,0.436629 +GeForce RTX 2080 Ti,StokesI,4096,32,1024,160,1,half,1115684864,41943040,96.2746,96.1377,98.2987,5353.52,5243.16,5361.02,12.0245,11.7766,12.0414,3.90406,3.82358,3.90953,11.1532,10.9233,11.1688,0.435671,0.42669,0.436281 +GeForce RTX 2080 Ti,StokesI,4096,32,1024,192,1,half,1124073472,50331648,115.399,115.27,117.599,5359.56,5259.17,5365.44,10.1771,9.9865,10.1883,3.30426,3.24237,3.30788,9.3048,9.13051,9.315,0.436162,0.427993,0.43664 +GeForce RTX 2080 Ti,StokesI,4096,32,1024,224,1,half,1132462080,58720256,134.615,134.437,137.193,5360.23,5259.43,5367.22,8.84897,8.68256,8.8605,2.87304,2.81901,2.87679,7.97654,7.82653,7.98693,0.436217,0.428013,0.436785 +GeForce RTX 2080 Ti,StokesI,4096,32,1024,256,1,half,1140850688,67108864,153.765,153.596,156.21,5363.01,5279.01,5368.86,7.85597,7.73293,7.86454,2.55064,2.51069,2.55342,6.98308,6.87371,6.9907,0.436443,0.429607,0.436919 +GeForce RTX 2080 Ti,StokesI,4096,32,1024,288,1,half,1149239296,75497472,172.908,172.766,175.325,5365.4,5291.39,5369.75,7.08323,6.98552,7.08897,2.29975,2.26803,2.30161,6.20996,6.12429,6.21499,0.436638,0.430614,0.436992 +GeForce RTX 2080 Ti,StokesI,4096,32,1024,320,1,half,1157627904,83886080,192.097,191.967,194.277,5366.05,5305.78,5369.64,6.46301,6.39042,6.46733,2.09838,2.07481,2.09978,5.58963,5.52685,5.59337,0.43669,0.431785,0.436982 +GeForce RTX 2080 Ti,StokesI,4096,32,1024,352,1,half,1166016512,92274688,211.272,211.121,213.747,5366.93,5304.74,5370.73,5.95584,5.88683,5.96006,1.93372,1.91131,1.93508,5.08232,5.02343,5.08592,0.436762,0.431701,0.437071 +GeForce RTX 2080 Ti,StokesI,4096,32,1024,384,1,half,1174405120,100663296,230.453,230.277,232.83,5367.49,5312.68,5371.58,5.5329,5.47639,5.53711,1.7964,1.77805,1.79776,4.65928,4.6117,4.66283,0.436808,0.432347,0.43714 +GeForce RTX 2080 Ti,StokesI,4096,32,1024,416,1,half,1182793728,109051904,249.629,249.477,251.956,5368.11,5318.51,5371.36,5.17509,5.12727,5.17822,1.68022,1.6647,1.68124,4.30137,4.26163,4.30398,0.436858,0.432822,0.437123 +GeForce RTX 2080 Ti,StokesI,4096,32,1024,448,1,half,1191182336,117440512,268.82,268.649,271.178,5368.34,5321.62,5371.72,4.86805,4.82569,4.87112,1.58054,1.56678,1.58153,3.9943,3.95954,3.99682,0.436877,0.433075,0.437152 +GeForce RTX 2080 Ti,StokesI,4096,32,1024,480,1,half,1199570944,125829120,287.997,287.835,290.296,5368.78,5326.24,5371.79,4.60214,4.56568,4.60472,1.4942,1.48236,1.49504,3.72832,3.69878,3.73041,0.436912,0.43345,0.437157 +GeForce RTX 2080 Ti,StokesI,4096,32,1024,512,1,half,1207959552,134217728,307.145,306.992,309.485,5369.68,5329.07,5372.34,4.36986,4.33681,4.37203,1.41879,1.40806,1.41949,3.49589,3.46945,3.49762,0.436986,0.433681,0.437203 +GeForce RTX 2080 Ti,StokesI,4096,32,1024,544,1,half,1216348160,142606336,326.262,326.106,328.519,5370.99,5334.08,5373.56,4.16523,4.13661,4.16722,1.35235,1.34305,1.35299,3.29105,3.26843,3.29262,0.437092,0.434088,0.437301 +GeForce RTX 2080 Ti,StokesI,4096,32,1024,576,1,half,1224736768,150994944,345.487,345.334,347.777,5370.48,5335.1,5372.85,3.98201,3.95579,3.98377,1.29286,1.28435,1.29343,3.10791,3.08744,3.10929,0.43705,0.434172,0.437244 +GeForce RTX 2080 Ti,StokesI,4096,32,1024,608,1,half,1233125376,159383552,364.622,364.494,366.732,5371.35,5340.43,5373.22,3.81906,3.79708,3.82039,1.23995,1.23282,1.24039,2.94482,2.92787,2.94585,0.437121,0.434606,0.437274 +GeForce RTX 2080 Ti,StokesI,4096,32,1024,640,1,half,1241513984,167772160,383.841,383.662,385.975,5370.94,5341.24,5373.44,3.67154,3.65124,3.67325,1.19206,1.18547,1.19261,2.79737,2.78189,2.79867,0.437089,0.434671,0.437292 +GeForce RTX 2080 Ti,StokesI,4096,32,1024,672,1,half,1249902592,176160768,403.031,402.899,405.139,5370.97,5343.02,5372.72,3.53835,3.51994,3.53951,1.14882,1.14284,1.14919,2.66417,2.65031,2.66504,0.437091,0.434816,0.437233 +GeForce RTX 2080 Ti,StokesI,4096,32,1024,704,1,half,1258291200,184549376,422.285,422.116,424.645,5370.18,5340.33,5372.32,3.41675,3.39776,3.41811,1.10933,1.10317,1.10978,2.5427,2.52857,2.54371,0.437026,0.434597,0.4372 +GeForce RTX 2080 Ti,StokesI,4096,32,1024,736,1,half,1266679808,192937984,441.558,441.348,443.907,5369.22,5340.81,5371.78,3.30561,3.28812,3.30718,1.07325,1.06757,1.07376,2.43171,2.41884,2.43287,0.436948,0.434636,0.437156 +GeForce RTX 2080 Ti,StokesI,4096,32,1024,768,1,half,1275068416,201326592,460.692,460.557,462.804,5369.97,5345.47,5371.54,3.20474,3.19011,3.20567,1.0405,1.03575,1.0408,2.33072,2.32008,2.3314,0.437009,0.435015,0.437137 +GeForce RTX 2080 Ti,StokesI,4096,32,1024,800,1,half,1283457024,209715200,479.897,479.708,482.284,5369.87,5343.29,5371.98,3.11145,3.09604,3.11267,1.01021,1.00521,1.01061,2.23745,2.22637,2.23832,0.437001,0.434838,0.437173 +GeForce RTX 2080 Ti,StokesI,4096,32,1024,832,1,half,1291845632,218103808,499.15,499.002,501.498,5369.25,5344.11,5370.84,3.02504,3.01088,3.02594,0.982157,0.977558,0.982447,2.15114,2.14107,2.15178,0.436951,0.434905,0.43708 +GeForce RTX 2080 Ti,StokesI,4096,32,1024,864,1,half,1300234240,226492416,518.299,518.107,520.43,5369.76,5347.77,5371.75,2.94565,2.93359,2.94674,0.956381,0.952464,0.956735,2.07167,2.06318,2.07243,0.436993,0.435203,0.437154 +GeForce RTX 2080 Ti,StokesI,4096,32,1024,896,1,half,1308622848,234881024,537.61,537.465,540.01,5368.62,5344.75,5370.06,2.87105,2.85829,2.87182,0.93216,0.928015,0.932411,1.99725,1.98837,1.99779,0.436899,0.434957,0.437017 +GeForce RTX 2080 Ti,StokesI,4096,32,1024,928,1,half,1317011456,243269632,556.81,556.583,558.849,5368.62,5349.02,5370.8,2.80218,2.79195,2.80332,0.909799,0.906478,0.910169,1.92838,1.92134,1.92917,0.436899,0.435304,0.437077 +GeForce RTX 2080 Ti,StokesI,4096,32,1024,960,1,half,1325400064,251658240,576.067,575.939,578.151,5368.09,5348.74,5369.27,2.73763,2.72776,2.73824,0.888841,0.885637,0.889038,1.86392,1.8572,1.86433,0.436856,0.435281,0.436953 +GeForce RTX 2080 Ti,StokesI,4096,32,1024,992,1,half,1333788672,260046848,595.183,595.022,597.802,5368.87,5345.34,5370.31,2.67789,2.66616,2.67862,0.869446,0.865636,0.86968,1.80405,1.79615,1.80454,0.43692,0.435005,0.437037 +GeForce RTX 2080 Ti,StokesI,4096,32,1024,1024,1,half,1342177280,268435456,614.466,614.141,616.829,5368.14,5347.56,5370.98,2.62116,2.61112,2.62255,0.851027,0.847765,0.851476,1.74744,1.74074,1.74836,0.43686,0.435186,0.437091 diff --git a/psrdada_cpp/cryopaf/profiling/Results/2080/unpacker_kernel.csv b/psrdada_cpp/cryopaf/profiling/Results/2080/unpacker_kernel.csv new file mode 100644 index 0000000000000000000000000000000000000000..e43718a2a1d47d63db702a7399cbf26be965267c --- /dev/null +++ b/psrdada_cpp/cryopaf/profiling/Results/2080/unpacker_kernel.csv @@ -0,0 +1,225 @@ +devicename,kernelname,samples,channels,elements,beams,integration,precision,reads,writes,avg_time,min_time,max_time,avg_throughput,min_throughput,max_throughput,avg_bandwidth,min_bandwidth,max_bandwidth,percentage_avg_bandwidth,percentage_min_bandwidth,percentage_max_bandwidth,input_avg_bandwidth,input_min_bandwidth,input_max_bandwidth,output_avg_bandwidth,output_min_bandwidth,output_max_bandwidth +GeForce RTX 2080 Ti,Unpacker,4096,32,16,32,1,half,134217728,16777216,0.0020528,0.002016,0.002112,2043.37,1985.94,2080.51,73561.4,71493.8,74898.3,23883.6,23212.3,24317.6,65387.9,63550.1,66576.3,8173.49,7943.76,8322.03 +GeForce RTX 2080 Ti,Unpacker,4096,32,16,64,1,half,134217728,16777216,0.0020704,0.002048,0.002336,2027.64,1795.51,2048,72995,64638.2,73728,23699.7,20986.4,23937.7,64884.5,57456.2,65536,8110.56,7182.03,8192 +GeForce RTX 2080 Ti,Unpacker,4096,32,16,96,1,half,134217728,16777216,0.0021392,0.00208,0.0024,1964.33,1747.63,2016.49,70715.8,62914.6,72593.7,22959.7,20426.8,23569.4,62858.5,55924.1,64527.8,7857.31,6990.51,8065.97 +GeForce RTX 2080 Ti,Unpacker,4096,32,16,128,1,half,134217728,16777216,0.0021744,0.00208,0.002592,1935.21,1618.17,2016.49,69667.5,58254.2,72593.7,22619.3,18913.7,23569.4,61926.6,51781.5,64527.8,7740.83,6472.69,8065.97 +GeForce RTX 2080 Ti,Unpacker,4096,32,16,160,1,half,134217728,16777216,0.0021472,0.00208,0.002624,1959.34,1598.44,2016.49,70536.4,57543.8,72593.7,22901.4,18683.1,23569.4,62699,51150.1,64527.8,7837.37,6393.76,8065.97 +GeForce RTX 2080 Ti,Unpacker,4096,32,16,192,1,half,134217728,16777216,0.0020752,0.002016,0.002272,2022.25,1846.08,2080.51,72800.9,66459,74898.3,23636.7,21577.6,24317.6,64711.9,59074.7,66576.3,8088.99,7384.34,8322.03 +GeForce RTX 2080 Ti,Unpacker,4096,32,16,224,1,half,134217728,16777216,0.0021136,0.00208,0.002144,1984.59,1956.3,2016.49,71445.4,70426.7,72593.7,23196.6,22865.8,23569.4,63507,62601.6,64527.8,7938.38,7825.19,8065.97 +GeForce RTX 2080 Ti,Unpacker,4096,32,16,256,1,half,134217728,16777216,0.0020512,0.002048,0.00208,2044.85,2016.49,2048,73614.6,72593.7,73728,23900.8,23569.4,23937.7,65435.2,64527.8,65536,8179.4,8065.97,8192 +GeForce RTX 2080 Ti,Unpacker,4096,32,16,288,1,half,134217728,16777216,0.0020672,0.002016,0.002208,2029.6,1899.59,2080.51,73065.7,68385.4,74898.3,23722.6,22203,24317.6,64947.3,60787,66576.3,8118.41,7598.38,8322.03 +GeForce RTX 2080 Ti,Unpacker,4096,32,16,320,1,half,134217728,16777216,0.0020512,0.002048,0.00208,2044.85,2016.49,2048,73614.6,72593.7,73728,23900.8,23569.4,23937.7,65435.2,64527.8,65536,8179.4,8065.97,8192 +GeForce RTX 2080 Ti,Unpacker,4096,32,16,352,1,half,134217728,16777216,0.00208,0.002016,0.002272,2018.55,1846.08,2080.51,72667.7,66459,74898.3,23593.4,21577.6,24317.6,64593.5,59074.7,66576.3,8074.19,7384.34,8322.03 +GeForce RTX 2080 Ti,Unpacker,4096,32,16,384,1,half,134217728,16777216,0.0020624,0.002016,0.00224,2034.64,1872.46,2080.51,73247.2,67408.5,74898.3,23781.6,21885.9,24317.6,65108.6,59918.6,66576.3,8138.58,7489.83,8322.03 +GeForce RTX 2080 Ti,Unpacker,4096,32,16,416,1,half,134217728,16777216,0.0020656,0.002048,0.002144,2030.91,1956.3,2048,73112.7,70426.7,73728,23737.9,22865.8,23937.7,64989,62601.6,65536,8123.63,7825.19,8192 +GeForce RTX 2080 Ti,Unpacker,4096,32,16,448,1,half,134217728,16777216,0.0020496,0.002016,0.00208,2046.52,2016.49,2080.51,73674.9,72593.7,74898.3,23920.4,23569.4,24317.6,65488.8,64527.8,66576.3,8186.1,8065.97,8322.03 +GeForce RTX 2080 Ti,Unpacker,4096,32,16,480,1,half,134217728,16777216,0.0020576,0.002016,0.002176,2038.88,1927.53,2080.51,73399.5,69391.1,74898.3,23831,22529.6,24317.6,65244,61680.9,66576.3,8155.5,7710.12,8322.03 +GeForce RTX 2080 Ti,Unpacker,4096,32,16,512,1,half,134217728,16777216,0.0020672,0.002048,0.002272,2030.03,1846.08,2048,73081,66459,73728,23727.6,21577.6,23937.7,64960.9,59074.7,65536,8120.11,7384.34,8192 +GeForce RTX 2080 Ti,Unpacker,4096,32,16,544,1,half,134217728,16777216,0.0020672,0.002016,0.002272,2030.12,1846.08,2080.51,73084.5,66459,74898.3,23728.7,21577.6,24317.6,64964,59074.7,66576.3,8120.5,7384.34,8322.03 +GeForce RTX 2080 Ti,Unpacker,4096,32,16,576,1,half,134217728,16777216,0.0020544,0.002048,0.002112,2041.75,1985.94,2048,73502.9,71493.8,73728,23864.6,23212.3,23937.7,65335.9,63550.1,65536,8166.98,7943.76,8192 +GeForce RTX 2080 Ti,Unpacker,4096,32,16,608,1,half,134217728,16777216,0.002064,0.002048,0.002176,2032.57,1927.53,2048,73172.6,69391.1,73728,23757.3,22529.6,23937.7,65042.3,61680.9,65536,8130.29,7710.12,8192 +GeForce RTX 2080 Ti,Unpacker,4096,32,16,640,1,half,134217728,16777216,0.0020544,0.002016,0.002144,2041.99,1956.3,2080.51,73511.5,70426.7,74898.3,23867.4,22865.8,24317.6,65343.6,62601.6,66576.3,8167.95,7825.19,8322.03 +GeForce RTX 2080 Ti,Unpacker,4096,32,16,672,1,half,134217728,16777216,0.0020672,0.002048,0.002272,2030.08,1846.08,2048,73082.7,66459,73728,23728.2,21577.6,23937.7,64962.4,59074.7,65536,8120.3,7384.34,8192 +GeForce RTX 2080 Ti,Unpacker,4096,32,16,704,1,half,134217728,16777216,0.002096,0.002048,0.002304,2003.83,1820.44,2048,72137.8,65536,73728,23421.4,21277.9,23937.7,64122.5,58254.2,65536,8015.31,7281.78,8192 +GeForce RTX 2080 Ti,Unpacker,4096,32,16,736,1,half,134217728,16777216,0.0020512,0.002016,0.00208,2044.95,2016.49,2080.51,73618.2,72593.7,74898.3,23902,23569.4,24317.6,65438.4,64527.8,66576.3,8179.8,8065.97,8322.03 +GeForce RTX 2080 Ti,Unpacker,4096,32,16,768,1,half,134217728,16777216,0.0020624,0.002016,0.002304,2035.1,1820.44,2080.51,73263.5,65536,74898.3,23786.8,21277.9,24317.6,65123.1,58254.2,66576.3,8140.39,7281.78,8322.03 +GeForce RTX 2080 Ti,Unpacker,4096,32,16,800,1,half,134217728,16777216,0.0020688,0.002016,0.002304,2029.12,1820.44,2080.51,73048.4,65536,74898.3,23717,21277.9,24317.6,64931.9,58254.2,66576.3,8116.49,7281.78,8322.03 +GeForce RTX 2080 Ti,Unpacker,4096,32,16,832,1,half,134217728,16777216,0.0020576,0.002016,0.00208,2038.6,2016.49,2080.51,73389.5,72593.7,74898.3,23827.8,23569.4,24317.6,65235.1,64527.8,66576.3,8154.39,8065.97,8322.03 +GeForce RTX 2080 Ti,Unpacker,4096,32,16,864,1,half,134217728,16777216,0.0020512,0.002048,0.00208,2044.85,2016.49,2048,73614.6,72593.7,73728,23900.8,23569.4,23937.7,65435.2,64527.8,65536,8179.4,8065.97,8192 +GeForce RTX 2080 Ti,Unpacker,4096,32,16,896,1,half,134217728,16777216,0.002064,0.002016,0.002144,2032.58,1956.3,2080.51,73172.8,70426.7,74898.3,23757.4,22865.8,24317.6,65042.5,62601.6,66576.3,8130.31,7825.19,8322.03 +GeForce RTX 2080 Ti,Unpacker,4096,32,16,928,1,half,134217728,16777216,0.0020784,0.002048,0.00224,2019.35,1872.46,2048,72696.5,67408.5,73728,23602.8,21885.9,23937.7,64619.1,59918.6,65536,8077.39,7489.83,8192 +GeForce RTX 2080 Ti,Unpacker,4096,32,16,960,1,half,134217728,16777216,0.00208,0.002016,0.002304,2018.19,1820.44,2080.51,72654.8,65536,74898.3,23589.2,21277.9,24317.6,64582,58254.2,66576.3,8072.76,7281.78,8322.03 +GeForce RTX 2080 Ti,Unpacker,4096,32,16,992,1,half,134217728,16777216,0.0020768,0.002016,0.002272,2021,1846.08,2080.51,72755.9,66459,74898.3,23622.1,21577.6,24317.6,64672,59074.7,66576.3,8083.99,7384.34,8322.03 +GeForce RTX 2080 Ti,Unpacker,4096,32,16,1024,1,half,134217728,16777216,0.002048,0.002016,0.00208,2048.1,2016.49,2080.51,73731.6,72593.7,74898.3,23938.8,23569.4,24317.6,65539.2,64527.8,66576.3,8192.4,8065.97,8322.03 +GeForce RTX 2080 Ti,Unpacker,4096,32,32,32,1,half,268435456,33554432,0.002072,0.002048,0.002208,4049.84,3799.19,4096,145794,136771,147456,47335.8,44406.1,47875.3,129595,121574,131072,16199.4,15196.8,16384 +GeForce RTX 2080 Ti,Unpacker,4096,32,32,64,1,half,268435456,33554432,0.0020608,0.002048,0.002112,4070.89,3971.88,4096,146552,142988,147456,47581.8,46424.6,47875.3,130268,127100,131072,16283.6,15887.5,16384 +GeForce RTX 2080 Ti,Unpacker,4096,32,32,96,1,half,268435456,33554432,0.0020656,0.002016,0.002176,4062,3855.06,4161.02,146232,138782,149797,47477.9,45059.1,48635.3,129984,123362,133153,16248,15420.2,16644.1 +GeForce RTX 2080 Ti,Unpacker,4096,32,32,128,1,half,268435456,33554432,0.0020576,0.002048,0.00208,4077.1,4032.98,4096,146775,145187,147456,47654.4,47138.8,47875.3,130467,129056,131072,16308.4,16131.9,16384 +GeForce RTX 2080 Ti,Unpacker,4096,32,32,160,1,half,268435456,33554432,0.0020512,0.002016,0.00208,4089.8,4032.98,4161.02,147233,145187,149797,47802.8,47138.8,48635.3,130874,129056,133153,16359.2,16131.9,16644.1 +GeForce RTX 2080 Ti,Unpacker,4096,32,32,192,1,half,268435456,33554432,0.002064,0.002016,0.002304,4067.14,3640.89,4161.02,146417,131072,149797,47538,42555.8,48635.3,130149,116508,133153,16268.6,14563.6,16644.1 +GeForce RTX 2080 Ti,Unpacker,4096,32,32,224,1,half,268435456,33554432,0.0020656,0.002048,0.00224,4062.69,3744.91,4096,146257,134817,147456,47486,43771.7,47875.3,130006,119837,131072,16250.8,14979.7,16384 +GeForce RTX 2080 Ti,Unpacker,4096,32,32,256,1,half,268435456,33554432,0.0021024,0.00208,0.002144,3990.39,3912.6,4032.98,143654,140853,145187,46641,45731.6,47138.8,127693,125203,129056,15961.6,15650.4,16131.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,32,288,1,half,268435456,33554432,0.0021296,0.002048,0.0024,3943.78,3495.25,4096,141976,125829,147456,46096.1,40853.6,47875.3,126201,111848,131072,15775.1,13981,16384 +GeForce RTX 2080 Ti,Unpacker,4096,32,32,320,1,half,268435456,33554432,0.0021056,0.00208,0.002272,3985.48,3692.17,4032.98,143477,132918,145187,46583.6,43155.2,47138.8,127535,118149,129056,15941.9,14768.7,16131.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,32,352,1,half,268435456,33554432,0.0021312,0.00208,0.002368,3941.25,3542.49,4032.98,141885,127530,145187,46066.6,41405.7,47138.8,126120,113360,129056,15765,14169.9,16131.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,32,384,1,half,268435456,33554432,0.0021456,0.00208,0.002368,3914.65,3542.49,4032.98,140927,127530,145187,45755.6,41405.7,47138.8,125269,113360,129056,15658.6,14169.9,16131.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,32,416,1,half,268435456,33554432,0.0021008,0.00208,0.002112,3993.27,3971.88,4032.98,143758,142988,145187,46674.5,46424.6,47138.8,127784,127100,129056,15973.1,15887.5,16131.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,32,448,1,half,268435456,33554432,0.0021712,0.00208,0.0024,3873.46,3495.25,4032.98,139445,125829,145187,45274.2,40853.6,47138.8,123951,111848,129056,15493.8,13981,16131.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,32,480,1,half,268435456,33554432,0.0021104,0.00208,0.002208,3975.73,3799.19,4032.98,143126,136771,145187,46469.6,44406.1,47138.8,127224,121574,129056,15902.9,15196.8,16131.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,32,512,1,half,268435456,33554432,0.0021232,0.00208,0.002304,3954.19,3640.89,4032.98,142351,131072,145187,46217.8,42555.8,47138.8,126534,116508,129056,15816.8,14563.6,16131.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,32,544,1,half,268435456,33554432,0.002144,0.00208,0.002368,3917.29,3542.49,4032.98,141023,127530,145187,45786.5,41405.7,47138.8,125353,113360,129056,15669.2,14169.9,16131.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,32,576,1,half,268435456,33554432,0.0021296,0.00208,0.002304,3941.73,3640.89,4032.98,141902,131072,145187,46072.2,42555.8,47138.8,126135,116508,129056,15766.9,14563.6,16131.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,32,608,1,half,268435456,33554432,0.0021488,0.00208,0.002368,3908.78,3542.49,4032.98,140716,127530,145187,45687,41405.7,47138.8,125081,113360,129056,15635.1,14169.9,16131.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,32,640,1,half,268435456,33554432,0.0021184,0.002048,0.002304,3963.01,3640.89,4096,142668,131072,147456,46320.9,42555.8,47875.3,126816,116508,131072,15852,14563.6,16384 +GeForce RTX 2080 Ti,Unpacker,4096,32,32,672,1,half,268435456,33554432,0.0021392,0.00208,0.002624,3930.95,3196.88,4032.98,141514,115088,145187,45946.1,37366.1,47138.8,125790,102300,129056,15723.8,12787.5,16131.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,32,704,1,half,268435456,33554432,0.00212,0.00208,0.0024,3961.65,3495.25,4032.98,142619,125829,145187,46305,40853.6,47138.8,126773,111848,129056,15846.6,13981,16131.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,32,736,1,half,268435456,33554432,0.0021536,0.00208,0.002624,3907.04,3196.88,4032.98,140654,115088,145187,45666.8,37366.1,47138.8,125025,102300,129056,15628.2,12787.5,16131.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,32,768,1,half,268435456,33554432,0.002144,0.00208,0.0024,3920.45,3495.25,4032.98,141136,125829,145187,45823.4,40853.6,47138.8,125454,111848,129056,15681.8,13981,16131.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,32,800,1,half,268435456,33554432,0.0021696,0.002112,0.002432,3871.82,3449.26,3971.88,139385,124173,142988,45255,40316.1,46424.6,123898,110376,127100,15487.3,13797.1,15887.5 +GeForce RTX 2080 Ti,Unpacker,4096,32,32,832,1,half,268435456,33554432,0.0021136,0.00208,0.002272,3970.48,3692.17,4032.98,142937,132918,145187,46408.2,43155.2,47138.8,127055,118149,129056,15881.9,14768.7,16131.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,32,864,1,half,268435456,33554432,0.002152,0.00208,0.002688,3911.24,3120.76,4032.98,140805,112347,145187,45715.8,36476.4,47138.8,125160,99864.4,129056,15645,12483,16131.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,32,896,1,half,268435456,33554432,0.0021856,0.00208,0.002592,3850.61,3236.35,4032.98,138622,116508,145187,45007.1,37827.4,47138.8,123219,103563,129056,15402.4,12945.4,16131.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,32,928,1,half,268435456,33554432,0.002128,0.00208,0.002272,3943.43,3692.17,4032.98,141963,132918,145187,46092,43155.2,47138.8,126190,118149,129056,15773.7,14768.7,16131.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,32,960,1,half,268435456,33554432,0.0021312,0.00208,0.002368,3940.62,3542.49,4032.98,141862,127530,145187,46059.2,41405.7,47138.8,126100,113360,129056,15762.5,14169.9,16131.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,32,992,1,half,268435456,33554432,0.002136,0.00208,0.002368,3931.55,3542.49,4032.98,141536,127530,145187,45953.2,41405.7,47138.8,125810,113360,129056,15726.2,14169.9,16131.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,32,1024,1,half,268435456,33554432,0.0021632,0.002112,0.00256,3885.35,3276.8,3971.88,139873,117965,142988,45413.2,38300.3,46424.6,124331,104858,127100,15541.4,13107.2,15887.5 +GeForce RTX 2080 Ti,Unpacker,4096,32,64,32,1,half,536870912,67108864,0.0021648,0.00208,0.002368,7765.64,7084.97,8065.97,279563,255059,290375,90767.2,82811.4,94277.6,248500,226719,258111,31062.6,28339.9,32263.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,64,64,1,half,536870912,67108864,0.0021792,0.00208,0.002432,7722.32,6898.53,8065.97,278003,248347,290375,90260.9,80632.1,94277.6,247114,220753,258111,30889.3,27594.1,32263.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,64,96,1,half,536870912,67108864,0.0021312,0.00208,0.002368,7880.31,7084.97,8065.97,283691,255059,290375,92107.5,82811.4,94277.6,252170,226719,258111,31521.2,28339.9,32263.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,64,128,1,half,536870912,67108864,0.0021168,0.00208,0.002272,7929.75,7384.34,8065.97,285471,265836,290375,92685.4,86310.4,94277.6,253752,236299,258111,31719,29537.4,32263.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,64,160,1,half,536870912,67108864,0.0021504,0.00208,0.002336,7809.73,7182.03,8065.97,281150,258553,290375,91282.6,83945.8,94277.6,249911,229825,258111,31238.9,28728.1,32263.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,64,192,1,half,536870912,67108864,0.0021184,0.00208,0.0024,7928.43,6990.51,8065.97,285424,251658,290375,92670,81707.2,94277.6,253710,223696,258111,31713.7,27962,32263.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,64,224,1,half,536870912,67108864,0.0021408,0.002112,0.002368,7842.55,7084.97,7943.76,282332,255059,285975,91666.2,82811.4,92849.1,250962,226719,254200,31370.2,28339.9,31775 +GeForce RTX 2080 Ti,Unpacker,4096,32,64,256,1,half,536870912,67108864,0.0021088,0.00208,0.002272,7960.31,7384.34,8065.97,286571,265836,290375,93042.5,86310.4,94277.6,254730,236299,258111,31841.2,29537.4,32263.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,64,288,1,half,536870912,67108864,0.002112,0.00208,0.002208,7945.19,7598.38,8065.97,286027,273542,290375,92865.8,88812.2,94277.6,254246,243148,258111,31780.7,30393.5,32263.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,64,320,1,half,536870912,67108864,0.0021472,0.00208,0.002496,7831.59,6721.64,8065.97,281937,241979,290375,91538.1,78564.6,94277.6,250611,215093,258111,31326.4,26886.6,32263.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,64,352,1,half,536870912,67108864,0.0021104,0.00208,0.002176,7950.59,7710.12,8065.97,286221,277564,290375,92929,90118.3,94277.6,254419,246724,258111,31802.4,30840.5,32263.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,64,384,1,half,536870912,67108864,0.0021136,0.00208,0.002304,7941.58,7281.78,8065.97,285897,262144,290375,92823.6,85111.7,94277.6,254130,233017,258111,31766.3,29127.1,32263.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,64,416,1,half,536870912,67108864,0.0021344,0.00208,0.002336,7870.03,7182.03,8065.97,283321,258553,290375,91987.3,83945.8,94277.6,251841,229825,258111,31480.1,28728.1,32263.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,64,448,1,half,536870912,67108864,0.0021024,0.00208,0.002208,7981.48,7598.38,8065.97,287333,273542,290375,93290.1,88812.2,94277.6,255407,243148,258111,31925.9,30393.5,32263.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,64,480,1,half,536870912,67108864,0.0021632,0.00208,0.002592,7784.14,6472.69,8065.97,280229,233017,290375,90983.4,75654.8,94277.6,249092,207126,258111,31136.5,25890.8,32263.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,64,512,1,half,536870912,67108864,0.0021968,0.00208,0.00272,7674.08,6168.09,8065.97,276267,222051,290375,89697.1,72094.6,94277.6,245571,197379,258111,30696.3,24672.4,32263.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,64,544,1,half,536870912,67108864,0.002184,0.002112,0.00256,7703.3,6553.6,7943.76,277319,235930,285975,90038.5,76600.5,92849.1,246506,209715,254200,30813.2,26214.4,31775 +GeForce RTX 2080 Ti,Unpacker,4096,32,64,576,1,half,536870912,67108864,0.00212,0.00208,0.002368,7919.33,7084.97,8065.97,285096,255059,290375,92563.6,82811.4,94277.6,253419,226719,258111,31677.3,28339.9,32263.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,64,608,1,half,536870912,67108864,0.0021584,0.002112,0.002368,7784.15,7084.97,7943.76,280230,255059,285975,90983.6,82811.4,92849.1,249093,226719,254200,31136.6,28339.9,31775 +GeForce RTX 2080 Ti,Unpacker,4096,32,64,640,1,half,536870912,67108864,0.0021104,0.00208,0.002368,7956,7084.97,8065.97,286416,255059,290375,92992.2,82811.4,94277.6,254592,226719,258111,31824,28339.9,32263.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,64,672,1,half,536870912,67108864,0.0021328,0.00208,0.002368,7874.19,7084.97,8065.97,283471,255059,290375,92036,82811.4,94277.6,251974,226719,258111,31496.8,28339.9,32263.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,64,704,1,half,536870912,67108864,0.0021632,0.00208,0.002624,7780.37,6393.76,8065.97,280093,230175,290375,90939.4,74732.2,94277.6,248972,204600,258111,31121.5,25575,32263.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,64,736,1,half,536870912,67108864,0.0021296,0.00208,0.0024,7885.8,6990.51,8065.97,283889,251658,290375,92171.7,81707.2,94277.6,252346,223696,258111,31543.2,27962,32263.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,64,768,1,half,536870912,67108864,0.0021376,0.00208,0.002272,7850.93,7384.34,8065.97,282634,265836,290375,91764.2,86310.4,94277.6,251230,236299,258111,31403.7,29537.4,32263.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,64,800,1,half,536870912,67108864,0.0021648,0.00208,0.002752,7780.36,6096.37,8065.97,280093,219469,290375,90939.3,71256.3,94277.6,248972,195084,258111,31121.5,24385.5,32263.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,64,832,1,half,536870912,67108864,0.0021648,0.00208,0.002592,7775.8,6472.69,8065.97,279929,233017,290375,90886,75654.8,94277.6,248826,207126,258111,31103.2,25890.8,32263.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,64,864,1,half,536870912,67108864,0.0021264,0.002112,0.002304,7893.39,7281.78,7943.76,284162,262144,285975,92260.4,85111.7,92849.1,252588,233017,254200,31573.6,29127.1,31775 +GeForce RTX 2080 Ti,Unpacker,4096,32,64,896,1,half,536870912,67108864,0.0021216,0.00208,0.002368,7915.33,7084.97,8065.97,284952,255059,290375,92516.9,82811.4,94277.6,253291,226719,258111,31661.3,28339.9,32263.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,64,928,1,half,536870912,67108864,0.002128,0.00208,0.002304,7892.36,7281.78,8065.97,284125,262144,290375,92248.4,85111.7,94277.6,252556,233017,258111,31569.4,29127.1,32263.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,64,960,1,half,536870912,67108864,0.0021376,0.00208,0.0024,7858.37,6990.51,8065.97,282901,251658,290375,91851.1,81707.2,94277.6,251468,223696,258111,31433.5,27962,32263.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,64,992,1,half,536870912,67108864,0.0021888,0.00208,0.002464,7687.23,6808.94,8065.97,276740,245122,290375,89850.8,79585,94277.6,245991,217886,258111,30748.9,27235.7,32263.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,64,1024,1,half,536870912,67108864,0.0021296,0.00208,0.002272,7882.11,7384.34,8065.97,283756,265836,290375,92128.6,86310.4,94277.6,252228,236299,258111,31528.5,29537.4,32263.9 +GeForce RTX 2080 Ti,Unpacker,4096,32,128,32,1,half,1073741824,134217728,0.0021232,0.00208,0.002272,15811,14768.7,16131.9,569196,531672,580750,184804,172621,188555,505952,472598,516222,63243.9,59074.7,64527.8 +GeForce RTX 2080 Ti,Unpacker,4096,32,128,64,1,half,1073741824,134217728,0.0021136,0.00208,0.002368,15890.7,14169.9,16131.9,572064,510118,580750,185735,165623,188555,508502,453438,516222,63562.7,56679.8,64527.8 +GeForce RTX 2080 Ti,Unpacker,4096,32,128,96,1,half,1073741824,134217728,0.0021552,0.002048,0.002624,15634.4,12787.5,16384,562838,460350,589824,182740,149464,191501,500301,409200,524288,62537.6,51150.1,65536 +GeForce RTX 2080 Ti,Unpacker,4096,32,128,128,1,half,1073741824,134217728,0.0021424,0.00208,0.0024,15682.4,13981,16131.9,564568,503316,580750,183301,163414,188555,501838,447392,516222,62729.7,55924.1,64527.8 +GeForce RTX 2080 Ti,Unpacker,4096,32,128,160,1,half,1073741824,134217728,0.002184,0.00208,0.002688,15428.8,12483,16131.9,555437,449390,580750,180337,145906,188555,493722,399458,516222,61715.3,49932.2,64527.8 +GeForce RTX 2080 Ti,Unpacker,4096,32,128,192,1,half,1073741824,134217728,0.0021216,0.00208,0.0024,15829.6,13981,16131.9,569865,503316,580750,185021,163414,188555,506547,447392,516222,63318.3,55924.1,64527.8 +GeForce RTX 2080 Ti,Unpacker,4096,32,128,224,1,half,1073741824,134217728,0.0021248,0.00208,0.002336,15800.2,14364.1,16131.9,568808,517106,580750,184678,167892,188555,505607,459650,516222,63200.9,57456.2,64527.8 +GeForce RTX 2080 Ti,Unpacker,4096,32,128,256,1,half,1073741824,134217728,0.0021424,0.00208,0.002368,15692.7,14169.9,16131.9,564938,510118,580750,183421,165623,188555,502167,453438,516222,62770.9,56679.8,64527.8 +GeForce RTX 2080 Ti,Unpacker,4096,32,128,288,1,half,1073741824,134217728,0.0021248,0.00208,0.002304,15798,14563.6,16131.9,568727,524288,580750,184652,170223,188555,505535,466034,516222,63191.9,58254.2,64527.8 +GeForce RTX 2080 Ti,Unpacker,4096,32,128,320,1,half,1073741824,134217728,0.0021232,0.00208,0.002304,15812.6,14563.6,16131.9,569253,524288,580750,184822,170223,188555,506003,466034,516222,63250.3,58254.2,64527.8 +GeForce RTX 2080 Ti,Unpacker,4096,32,128,352,1,half,1073741824,134217728,0.002128,0.00208,0.002208,15771.7,15196.8,16131.9,567782,547083,580750,184345,177624,188555,504695,486296,516222,63086.9,60787,64527.8 +GeForce RTX 2080 Ti,Unpacker,4096,32,128,384,1,half,1073741824,134217728,0.0021696,0.00208,0.0024,15499.6,13981,16131.9,557986,503316,580750,181164,163414,188555,495987,447392,516222,61998.4,55924.1,64527.8 +GeForce RTX 2080 Ti,Unpacker,4096,32,128,416,1,half,1073741824,134217728,0.002152,0.00208,0.002368,15619.8,14169.9,16131.9,562311,510118,580750,182569,165623,188555,499832,453438,516222,62479,56679.8,64527.8 +GeForce RTX 2080 Ti,Unpacker,4096,32,128,448,1,half,1073741824,134217728,0.002152,0.00208,0.0024,15617.1,13981,16131.9,562216,503316,580750,182538,163414,188555,499748,447392,516222,62468.5,55924.1,64527.8 +GeForce RTX 2080 Ti,Unpacker,4096,32,128,480,1,half,1073741824,134217728,0.0021152,0.00208,0.002176,15864.5,15420.2,16131.9,571123,555128,580750,185429,180237,188555,507664,493448,516222,63458.1,61680.9,64527.8 +GeForce RTX 2080 Ti,Unpacker,4096,32,128,512,1,half,1073741824,134217728,0.0021168,0.00208,0.00224,15854.7,14979.7,16131.9,570770,539268,580750,185315,175087,188555,507351,479349,516222,63418.8,59918.6,64527.8 +GeForce RTX 2080 Ti,Unpacker,4096,32,128,544,1,half,1073741824,134217728,0.002056,0.002048,0.002144,16322.1,15650.4,16384,587596,563414,589824,190778,182927,191501,522308,500812,524288,65288.5,62601.6,65536 +GeForce RTX 2080 Ti,Unpacker,4096,32,128,576,1,half,1073741824,134217728,0.0021136,0.00208,0.002336,15885,14364.1,16131.9,571861,517106,580750,185669,167892,188555,508321,459650,516222,63540.1,57456.2,64527.8 +GeForce RTX 2080 Ti,Unpacker,4096,32,128,608,1,half,1073741824,134217728,0.002136,0.00208,0.0024,15722.5,13981,16131.9,566009,503316,580750,183769,163414,188555,503119,447392,516222,62889.9,55924.1,64527.8 +GeForce RTX 2080 Ti,Unpacker,4096,32,128,640,1,half,1073741824,134217728,0.002136,0.00208,0.002464,15731,13617.9,16131.9,566318,490243,580750,183869,159170,188555,503393,435772,516222,62924.2,54471.5,64527.8 +GeForce RTX 2080 Ti,Unpacker,4096,32,128,672,1,half,1073741824,134217728,0.0021312,0.00208,0.002368,15756.3,14169.9,16131.9,567228,510118,580750,184165,165623,188555,504202,453438,516222,63025.3,56679.8,64527.8 +GeForce RTX 2080 Ti,Unpacker,4096,32,128,704,1,half,1073741824,134217728,0.0021472,0.002112,0.002272,15631.4,14768.7,15887.5,562730,531672,571951,182705,172621,185698,500205,472598,508400,62525.6,59074.7,63550.1 +GeForce RTX 2080 Ti,Unpacker,4096,32,128,736,1,half,1073741824,134217728,0.0021232,0.00208,0.0024,15817,13981,16131.9,569412,503316,580750,184874,163414,188555,506144,447392,516222,63268,55924.1,64527.8 +GeForce RTX 2080 Ti,Unpacker,4096,32,128,768,1,half,1073741824,134217728,0.0021904,0.00208,0.00352,15518.1,9532.51,16131.9,558651,343170,580750,181380,111419,188555,496578,305040,516222,62072.3,38130,64527.8 +GeForce RTX 2080 Ti,Unpacker,4096,32,128,800,1,half,1073741824,134217728,0.0021216,0.00208,0.002304,15821.7,14563.6,16131.9,569581,524288,580750,184929,170223,188555,506294,466034,516222,63286.7,58254.2,64527.8 +GeForce RTX 2080 Ti,Unpacker,4096,32,128,832,1,half,1073741824,134217728,0.0022096,0.002112,0.002656,15248.6,12633.4,15887.5,548951,454804,571951,178231,147664,185698,487956,404270,508400,60994.5,50533.8,63550.1 +GeForce RTX 2080 Ti,Unpacker,4096,32,128,864,1,half,1073741824,134217728,0.002152,0.00208,0.0024,15628.9,13981,16131.9,562640,503316,580750,182675,163414,188555,500125,447392,516222,62515.6,55924.1,64527.8 +GeForce RTX 2080 Ti,Unpacker,4096,32,128,896,1,half,1073741824,134217728,0.0021712,0.00208,0.002592,15514.4,12945.4,16131.9,558520,466034,580750,181338,151310,188555,496462,414252,516222,62057.8,51781.5,64527.8 +GeForce RTX 2080 Ti,Unpacker,4096,32,128,928,1,half,1073741824,134217728,0.0020976,0.00208,0.002144,15998.2,15650.4,16131.9,575936,563414,580750,186992,182927,188555,511944,500812,516222,63992.9,62601.6,64527.8 +GeForce RTX 2080 Ti,Unpacker,4096,32,128,960,1,half,1073741824,134217728,0.002128,0.00208,0.002304,15783.1,14563.6,16131.9,568190,524288,580750,184477,170223,188555,505058,466034,516222,63132.2,58254.2,64527.8 +GeForce RTX 2080 Ti,Unpacker,4096,32,128,992,1,half,1073741824,134217728,0.0021424,0.002112,0.002336,15670.4,14364.1,15887.5,564136,517106,571951,183161,167892,185698,501454,459650,508400,62681.8,57456.2,63550.1 +GeForce RTX 2080 Ti,Unpacker,4096,32,128,1024,1,half,1073741824,134217728,0.0021584,0.00208,0.0024,15574.3,13981,16131.9,560674,503316,580750,182037,163414,188555,498377,447392,516222,62297.1,55924.1,64527.8 +GeForce RTX 2080 Ti,Unpacker,4096,32,256,32,1,half,2147483648,268435456,0.0021152,0.00208,0.002304,31751.5,29127.1,32263.9,1.14305e+06,1.04858e+06,1.1615e+06,371121,340447,377110,1.01605e+06,932068,1.03244e+06,127006,116508,129056 +GeForce RTX 2080 Ti,Unpacker,4096,32,256,64,1,half,2147483648,268435456,0.0022416,0.00208,0.004064,30582.4,16513,32263.9,1.10097e+06,594468,1.1615e+06,357457,193009,377110,978638,528416,1.03244e+06,122330,66052,129056 +GeForce RTX 2080 Ti,Unpacker,4096,32,256,96,1,half,2147483648,268435456,0.0021488,0.00208,0.002496,31297.3,26886.6,32263.9,1.1267e+06,967916,1.1615e+06,365813,314259,377110,1.00151e+06,860370,1.03244e+06,125189,107546,129056 +GeForce RTX 2080 Ti,Unpacker,4096,32,256,128,1,half,2147483648,268435456,0.0021776,0.00208,0.002624,30966.8,25575,32263.9,1.1148e+06,920701,1.1615e+06,361949,298929,377110,990937,818401,1.03244e+06,123867,102300,129056 +GeForce RTX 2080 Ti,Unpacker,4096,32,256,160,1,half,2147483648,268435456,0.0021888,0.002112,0.002656,30793.7,25266.9,31775,1.10857e+06,909608,1.1439e+06,359927,295327,371396,985399,808541,1.0168e+06,123175,101068,127100 +GeForce RTX 2080 Ti,Unpacker,4096,32,256,192,1,half,2147483648,268435456,0.002112,0.00208,0.0024,31805.8,27962,32263.9,1.14501e+06,1.00663e+06,1.1615e+06,371756,326829,377110,1.01779e+06,894785,1.03244e+06,127223,111848,129056 +GeForce RTX 2080 Ti,Unpacker,4096,32,256,224,1,half,2147483648,268435456,0.0021072,0.00208,0.002144,31849.8,31300.8,32263.9,1.14659e+06,1.12683e+06,1.1615e+06,372271,365853,377110,1.01919e+06,1.00162e+06,1.03244e+06,127399,125203,129056 +GeForce RTX 2080 Ti,Unpacker,4096,32,256,256,1,half,2147483648,268435456,0.0022768,0.00208,0.005472,30849.1,12264,32263.9,1.11057e+06,441506,1.1615e+06,360574,143346,377110,987171,392449,1.03244e+06,123396,49056.2,129056 +GeForce RTX 2080 Ti,Unpacker,4096,32,256,288,1,half,2147483648,268435456,0.0024304,0.00208,0.008064,30432.2,8322.03,32263.9,1.09556e+06,299593,1.1615e+06,355701,97270.5,377110,973829,266305,1.03244e+06,121729,33288.1,129056 +GeForce RTX 2080 Ti,Unpacker,4096,32,256,320,1,half,2147483648,268435456,0.0021344,0.002112,0.002464,31476.9,27235.7,31775,1.13317e+06,980487,1.1439e+06,367912,318340,371396,1.00726e+06,871544,1.0168e+06,125908,108943,127100 +GeForce RTX 2080 Ti,Unpacker,4096,32,256,352,1,half,2147483648,268435456,0.0021152,0.00208,0.002368,31750.7,28339.9,32263.9,1.14302e+06,1.02024e+06,1.1615e+06,371112,331245,377110,1.01602e+06,906876,1.03244e+06,127003,113360,129056 +GeForce RTX 2080 Ti,Unpacker,4096,32,256,384,1,half,2147483648,268435456,0.0021376,0.00208,0.002432,31446.1,27594.1,32263.9,1.13206e+06,993388,1.1615e+06,367552,322528,377110,1.00627e+06,883011,1.03244e+06,125784,110376,129056 +GeForce RTX 2080 Ti,Unpacker,4096,32,256,416,1,half,2147483648,268435456,0.00224,0.002112,0.003264,30279.1,20560.3,31775,1.09005e+06,740171,1.1439e+06,353912,240315,371396,968933,657930,1.0168e+06,121117,82241.3,127100 +GeForce RTX 2080 Ti,Unpacker,4096,32,256,448,1,half,2147483648,268435456,0.0021392,0.00208,0.002368,31402.2,28339.9,32263.9,1.13048e+06,1.02024e+06,1.1615e+06,367039,331245,377110,1.00487e+06,906876,1.03244e+06,125609,113360,129056 +GeForce RTX 2080 Ti,Unpacker,4096,32,256,480,1,half,2147483648,268435456,0.002128,0.00208,0.002368,31573.1,28339.9,32263.9,1.13663e+06,1.02024e+06,1.1615e+06,369037,331245,377110,1.01034e+06,906876,1.03244e+06,126293,113360,129056 +GeForce RTX 2080 Ti,Unpacker,4096,32,256,512,1,half,2147483648,268435456,0.0023824,0.002048,0.004064,29445.9,16513,32768,1.06005e+06,594468,1.17965e+06,344173,193009,383003,942270,528416,1.04858e+06,117784,66052,131072 +GeForce RTX 2080 Ti,Unpacker,4096,32,256,544,1,half,2147483648,268435456,0.002152,0.00208,0.002368,31231.8,28339.9,32263.9,1.12435e+06,1.02024e+06,1.1615e+06,365047,331245,377110,999418,906876,1.03244e+06,124927,113360,129056 +GeForce RTX 2080 Ti,Unpacker,4096,32,256,576,1,half,2147483648,268435456,0.0023392,0.002112,0.005184,29905.1,12945.4,31775,1.07658e+06,466034,1.1439e+06,349540,151310,371396,956963,414252,1.0168e+06,119620,51781.5,127100 +GeForce RTX 2080 Ti,Unpacker,4096,32,256,608,1,half,2147483648,268435456,0.00212,0.00208,0.002272,31677.1,29537.4,32263.9,1.14038e+06,1.06334e+06,1.1615e+06,370252,345242,377110,1.01367e+06,945195,1.03244e+06,126708,118149,129056 +GeForce RTX 2080 Ti,Unpacker,4096,32,256,640,1,half,2147483648,268435456,0.0021664,0.002112,0.0024,31020.5,27962,31775,1.11674e+06,1.00663e+06,1.1439e+06,362578,326829,371396,992657,894785,1.0168e+06,124082,111848,127100 +GeForce RTX 2080 Ti,Unpacker,4096,32,256,672,1,half,2147483648,268435456,0.0021888,0.00208,0.002528,30780.5,26546.2,32263.9,1.1081e+06,955664,1.1615e+06,359772,310281,377110,984976,849479,1.03244e+06,123122,106185,129056 +GeForce RTX 2080 Ti,Unpacker,4096,32,256,704,1,half,2147483648,268435456,0.0021216,0.002048,0.002368,31669.4,28339.9,32768,1.1401e+06,1.02024e+06,1.17965e+06,370162,331245,383003,1.01342e+06,906876,1.04858e+06,126678,113360,131072 +GeForce RTX 2080 Ti,Unpacker,4096,32,256,736,1,half,2147483648,268435456,0.0021504,0.00208,0.002432,31275,27594.1,32263.9,1.1259e+06,993388,1.1615e+06,365552,322528,377110,1.0008e+06,883011,1.03244e+06,125100,110376,129056 +GeForce RTX 2080 Ti,Unpacker,4096,32,256,768,1,half,2147483648,268435456,0.0021584,0.00208,0.0024,31152,27962,32263.9,1.12147e+06,1.00663e+06,1.1615e+06,364115,326829,377110,996865,894785,1.03244e+06,124608,111848,129056 +GeForce RTX 2080 Ti,Unpacker,4096,32,256,800,1,half,2147483648,268435456,0.0021632,0.002112,0.002368,31072,28339.9,31775,1.11859e+06,1.02024e+06,1.1439e+06,363180,331245,371396,994305,906876,1.0168e+06,124288,113360,127100 +GeForce RTX 2080 Ti,Unpacker,4096,32,256,832,1,half,2147483648,268435456,0.0021392,0.00208,0.002336,31430,28728.1,32263.9,1.13148e+06,1.03421e+06,1.1615e+06,367364,335783,377110,1.00576e+06,919300,1.03244e+06,125720,114912,129056 +GeForce RTX 2080 Ti,Unpacker,4096,32,256,864,1,half,2147483648,268435456,0.002168,0.00208,0.002656,31065,25266.9,32263.9,1.11834e+06,909608,1.1615e+06,363098,295327,377110,994081,808541,1.03244e+06,124260,101068,129056 +GeForce RTX 2080 Ti,Unpacker,4096,32,256,896,1,half,2147483648,268435456,0.0021056,0.00208,0.002336,31893,28728.1,32263.9,1.14815e+06,1.03421e+06,1.1615e+06,372775,335783,377110,1.02058e+06,919300,1.03244e+06,127572,114912,129056 +GeForce RTX 2080 Ti,Unpacker,4096,32,256,928,1,half,2147483648,268435456,0.0021472,0.00208,0.0024,31308.5,27962,32263.9,1.12711e+06,1.00663e+06,1.1615e+06,365943,326829,377110,1.00187e+06,894785,1.03244e+06,125234,111848,129056 +GeForce RTX 2080 Ti,Unpacker,4096,32,256,960,1,half,2147483648,268435456,0.0021616,0.00208,0.0024,31110.1,27962,32263.9,1.11996e+06,1.00663e+06,1.1615e+06,363625,326829,377110,995524,894785,1.03244e+06,124440,111848,129056 +GeForce RTX 2080 Ti,Unpacker,4096,32,256,992,1,half,2147483648,268435456,0.0021504,0.00208,0.002464,31293.7,27235.7,32263.9,1.12657e+06,980487,1.1615e+06,365771,318340,377110,1.0014e+06,871544,1.03244e+06,125175,108943,129056 +GeForce RTX 2080 Ti,Unpacker,4096,32,256,1024,1,half,2147483648,268435456,0.002168,0.00208,0.002688,31073.3,24966.1,32263.9,1.11864e+06,898779,1.1615e+06,363195,291812,377110,994346,798915,1.03244e+06,124293,99864.4,129056 +GeForce RTX 2080 Ti,Unpacker,4096,32,512,32,1,half,4294967296,536870912,0.0021408,0.002112,0.002368,62768.2,56679.8,63550.1,2.25965e+06,2.04047e+06,2.2878e+06,733654,662491,742793,2.00858e+06,1.81375e+06,2.0336e+06,251073,226719,254200 +GeForce RTX 2080 Ti,Unpacker,4096,32,512,64,1,half,4294967296,536870912,0.0021696,0.00208,0.002592,62049.6,51781.5,64527.8,2.23378e+06,1.86414e+06,2.323e+06,725255,605239,754221,1.98559e+06,1.65701e+06,2.06489e+06,248198,207126,258111 +GeForce RTX 2080 Ti,Unpacker,4096,32,512,96,1,half,4294967296,536870912,0.0021952,0.00208,0.002496,61368,53773.1,64527.8,2.20925e+06,1.93583e+06,2.323e+06,717288,628517,754221,1.96378e+06,1.72074e+06,2.06489e+06,245472,215093,258111 +GeForce RTX 2080 Ti,Unpacker,4096,32,512,128,1,half,4294967296,536870912,0.0021248,0.00208,0.00224,63187.3,59918.6,64527.8,2.27474e+06,2.15707e+06,2.323e+06,738553,700348,754221,2.02199e+06,1.9174e+06,2.06489e+06,252749,239675,258111 +GeForce RTX 2080 Ti,Unpacker,4096,32,512,160,1,half,4294967296,536870912,0.0021824,0.00208,0.002592,61717.7,51781.5,64527.8,2.22184e+06,1.86414e+06,2.323e+06,721376,605239,754221,1.97497e+06,1.65701e+06,2.06489e+06,246871,207126,258111 +GeForce RTX 2080 Ti,Unpacker,4096,32,512,192,1,half,4294967296,536870912,0.002112,0.00208,0.00224,63568.3,59918.6,64527.8,2.28846e+06,2.15707e+06,2.323e+06,743007,700348,754221,2.03419e+06,1.9174e+06,2.06489e+06,254273,239675,258111 +GeForce RTX 2080 Ti,Unpacker,4096,32,512,224,1,half,4294967296,536870912,0.0021296,0.00208,0.0024,63082.4,55924.1,64527.8,2.27097e+06,2.01327e+06,2.323e+06,737327,653658,754221,2.01864e+06,1.78957e+06,2.06489e+06,252330,223696,258111 +GeForce RTX 2080 Ti,Unpacker,4096,32,512,256,1,half,4294967296,536870912,0.002128,0.002112,0.002304,63095.6,58254.2,63550.1,2.27144e+06,2.09715e+06,2.2878e+06,737481,680893,742793,2.01906e+06,1.86414e+06,2.0336e+06,252382,233017,254200 +GeForce RTX 2080 Ti,Unpacker,4096,32,512,288,1,half,4294967296,536870912,0.0022016,0.00208,0.002784,61230.3,48210.4,64527.8,2.20429e+06,1.73557e+06,2.323e+06,715678,563498,754221,1.95937e+06,1.54273e+06,2.06489e+06,244921,192842,258111 +GeForce RTX 2080 Ti,Unpacker,4096,32,512,320,1,half,4294967296,536870912,0.002216,0.00208,0.002784,60934.6,48210.4,64527.8,2.19365e+06,1.73557e+06,2.323e+06,712222,563498,754221,1.94991e+06,1.54273e+06,2.06489e+06,243738,192842,258111 +GeForce RTX 2080 Ti,Unpacker,4096,32,512,352,1,half,4294967296,536870912,0.0021872,0.002048,0.003232,61947.9,41527.8,65536,2.23012e+06,1.495e+06,2.3593e+06,724066,485389,766005,1.98233e+06,1.32889e+06,2.09715e+06,247792,166111,262144 +GeForce RTX 2080 Ti,Unpacker,4096,32,512,384,1,half,4294967296,536870912,0.0021232,0.00208,0.0024,63270.8,55924.1,64527.8,2.27775e+06,2.01327e+06,2.323e+06,739529,653658,754221,2.02467e+06,1.78957e+06,2.06489e+06,253083,223696,258111 +GeForce RTX 2080 Ti,Unpacker,4096,32,512,416,1,half,4294967296,536870912,0.0021696,0.00208,0.00272,62132.8,49344.8,64527.8,2.23678e+06,1.77641e+06,2.323e+06,726227,576757,754221,1.98825e+06,1.57903e+06,2.06489e+06,248531,197379,258111 +GeForce RTX 2080 Ti,Unpacker,4096,32,512,448,1,half,4294967296,536870912,0.0021456,0.00208,0.002368,62668.9,56679.8,64527.8,2.25608e+06,2.04047e+06,2.323e+06,732494,662491,754221,2.00541e+06,1.81375e+06,2.06489e+06,250676,226719,258111 +GeForce RTX 2080 Ti,Unpacker,4096,32,512,480,1,half,4294967296,536870912,0.0021536,0.00208,0.002912,62631.2,46091.2,64527.8,2.25472e+06,1.65929e+06,2.323e+06,732052,538729,754221,2.0042e+06,1.47492e+06,2.06489e+06,250525,184365,258111 +GeForce RTX 2080 Ti,Unpacker,4096,32,512,512,1,half,4294967296,536870912,0.0022208,0.002016,0.004288,62064,31300.8,66576.3,2.2343e+06,1.12683e+06,2.39675e+06,725423,365853,778164,1.98605e+06,1.00162e+06,2.13044e+06,248256,125203,266305 +GeForce RTX 2080 Ti,Unpacker,4096,32,512,544,1,half,4294967296,536870912,0.0021552,0.00208,0.0024,62354.8,55924.1,64527.8,2.24477e+06,2.01327e+06,2.323e+06,728822,653658,754221,1.99535e+06,1.78957e+06,2.06489e+06,249419,223696,258111 +GeForce RTX 2080 Ti,Unpacker,4096,32,512,576,1,half,4294967296,536870912,0.0021248,0.00208,0.002368,63218,56679.8,64527.8,2.27585e+06,2.04047e+06,2.323e+06,738911,662491,754221,2.02297e+06,1.81375e+06,2.06489e+06,252872,226719,258111 +GeForce RTX 2080 Ti,Unpacker,4096,32,512,608,1,half,4294967296,536870912,0.0021616,0.00208,0.0024,62173.6,55924.1,64527.8,2.23825e+06,2.01327e+06,2.323e+06,726705,653658,754221,1.98956e+06,1.78957e+06,2.06489e+06,248695,223696,258111 +GeForce RTX 2080 Ti,Unpacker,4096,32,512,640,1,half,4294967296,536870912,0.0021216,0.00208,0.002368,63332.8,56679.8,64527.8,2.27998e+06,2.04047e+06,2.323e+06,740254,662491,754221,2.02665e+06,1.81375e+06,2.06489e+06,253331,226719,258111 +GeForce RTX 2080 Ti,Unpacker,4096,32,512,672,1,half,4294967296,536870912,0.0021152,0.00208,0.002368,63529.8,56679.8,64527.8,2.28707e+06,2.04047e+06,2.323e+06,742556,662491,754221,2.03295e+06,1.81375e+06,2.06489e+06,254119,226719,258111 +GeForce RTX 2080 Ti,Unpacker,4096,32,512,704,1,half,4294967296,536870912,0.002144,0.002048,0.002368,62725,56679.8,65536,2.2581e+06,2.04047e+06,2.3593e+06,733149,662491,766005,2.0072e+06,1.81375e+06,2.09715e+06,250900,226719,262144 +GeForce RTX 2080 Ti,Unpacker,4096,32,512,736,1,half,4294967296,536870912,0.0021952,0.00208,0.002816,61456.4,47662.5,64527.8,2.21243e+06,1.71585e+06,2.323e+06,718322,557095,754221,1.96661e+06,1.5252e+06,2.06489e+06,245826,190650,258111 +GeForce RTX 2080 Ti,Unpacker,4096,32,512,768,1,half,4294967296,536870912,0.0022672,0.00208,0.00496,61448.6,27060,64527.8,2.21215e+06,974161,2.323e+06,718230,316286,754221,1.96635e+06,865921,2.06489e+06,245794,108240,258111 +GeForce RTX 2080 Ti,Unpacker,4096,32,512,800,1,half,4294967296,536870912,0.0022592,0.002048,0.004352,60999.8,30840.5,65536,2.19599e+06,1.11026e+06,2.3593e+06,712984,360473,766005,1.95199e+06,986895,2.09715e+06,243999,123362,262144 +GeForce RTX 2080 Ti,Unpacker,4096,32,512,832,1,half,4294967296,536870912,0.0021776,0.00208,0.002368,61756.3,56679.8,64527.8,2.22323e+06,2.04047e+06,2.323e+06,721827,662491,754221,1.9762e+06,1.81375e+06,2.06489e+06,247025,226719,258111 +GeForce RTX 2080 Ti,Unpacker,4096,32,512,864,1,half,4294967296,536870912,0.0021184,0.002048,0.002304,63398.8,58254.2,65536,2.28236e+06,2.09715e+06,2.3593e+06,741025,680893,766005,2.02876e+06,1.86414e+06,2.09715e+06,253595,233017,262144 +GeForce RTX 2080 Ti,Unpacker,4096,32,512,896,1,half,4294967296,536870912,0.0022208,0.00208,0.003232,61061.6,41527.8,64527.8,2.19822e+06,1.495e+06,2.323e+06,713708,485389,754221,1.95397e+06,1.32889e+06,2.06489e+06,244247,166111,258111 +GeForce RTX 2080 Ti,Unpacker,4096,32,512,928,1,half,4294967296,536870912,0.0021552,0.00208,0.002368,62402.3,56679.8,64527.8,2.24648e+06,2.04047e+06,2.323e+06,729377,662491,754221,1.99687e+06,1.81375e+06,2.06489e+06,249609,226719,258111 +GeForce RTX 2080 Ti,Unpacker,4096,32,512,960,1,half,4294967296,536870912,0.0022256,0.00208,0.003776,61319.1,35544.9,64527.8,2.20749e+06,1.27962e+06,2.323e+06,716717,415460,754221,1.96221e+06,1.13744e+06,2.06489e+06,245276,142180,258111 +GeForce RTX 2080 Ti,Unpacker,4096,32,512,992,1,half,4294967296,536870912,0.0022096,0.00208,0.00304,61197.4,44150.6,64527.8,2.20311e+06,1.58942e+06,2.323e+06,715295,516046,754221,1.95832e+06,1.41282e+06,2.06489e+06,244790,176602,258111 +GeForce RTX 2080 Ti,Unpacker,4096,32,512,1024,1,half,4294967296,536870912,0.002168,0.00208,0.002624,62117.6,51150.1,64527.8,2.23623e+06,1.8414e+06,2.323e+06,726049,597858,754221,1.98776e+06,1.6368e+06,2.06489e+06,248470,204600,258111 +GeForce RTX 2080 Ti,Unpacker,4096,32,1024,32,1,half,8589934592,1073741824,0.0021648,0.00208,0.002368,124175,113360,129056,4.47031e+06,4.08094e+06,4.646e+06,1.4514e+06,1.32498e+06,1.50844e+06,3.97361e+06,3.62751e+06,4.12978e+06,496701,453438,516222 +GeForce RTX 2080 Ti,Unpacker,4096,32,1024,64,1,half,8589934592,1073741824,0.0021648,0.00208,0.002592,124386,103563,129056,4.47789e+06,3.72827e+06,4.646e+06,1.45386e+06,1.21048e+06,1.50844e+06,3.98034e+06,3.31402e+06,4.12978e+06,497543,414252,516222 +GeForce RTX 2080 Ti,Unpacker,4096,32,1024,96,1,half,8589934592,1073741824,0.0021264,0.00208,0.0024,126340,111848,129056,4.54826e+06,4.02653e+06,4.646e+06,1.47671e+06,1.30732e+06,1.50844e+06,4.04289e+06,3.57914e+06,4.12978e+06,505362,447392,516222 +GeForce RTX 2080 Ti,Unpacker,4096,32,1024,128,1,half,8589934592,1073741824,0.00212,0.00208,0.002336,126740,114912,129056,4.56263e+06,4.13685e+06,4.646e+06,1.48137e+06,1.34313e+06,1.50844e+06,4.05567e+06,3.6772e+06,4.12978e+06,506959,459650,516222 +GeForce RTX 2080 Ti,Unpacker,4096,32,1024,160,1,half,8589934592,1073741824,0.002128,0.00208,0.002272,126242,118149,129056,4.54472e+06,4.25338e+06,4.646e+06,1.47556e+06,1.38097e+06,1.50844e+06,4.03975e+06,3.78078e+06,4.12978e+06,504969,472598,516222 +GeForce RTX 2080 Ti,Unpacker,4096,32,1024,192,1,half,8589934592,1073741824,0.0021184,0.00208,0.002368,126807,113360,129056,4.56506e+06,4.08094e+06,4.646e+06,1.48216e+06,1.32498e+06,1.50844e+06,4.05783e+06,3.62751e+06,4.12978e+06,507228,453438,516222 +GeForce RTX 2080 Ti,Unpacker,4096,32,1024,224,1,half,8589934592,1073741824,0.0021264,0.00208,0.002336,126304,114912,129056,4.54694e+06,4.13685e+06,4.646e+06,1.47628e+06,1.34313e+06,1.50844e+06,4.04173e+06,3.6772e+06,4.12978e+06,505216,459650,516222 +GeForce RTX 2080 Ti,Unpacker,4096,32,1024,256,1,half,8589934592,1073741824,0.002112,0.00208,0.0024,127217,111848,129056,4.57983e+06,4.02653e+06,4.646e+06,1.48696e+06,1.30732e+06,1.50844e+06,4.07096e+06,3.57914e+06,4.12978e+06,508870,447392,516222 +GeForce RTX 2080 Ti,Unpacker,4096,32,1024,288,1,half,8589934592,1073741824,0.0021568,0.00208,0.002688,124934,99864.4,129056,4.49761e+06,3.59512e+06,4.646e+06,1.46026e+06,1.16725e+06,1.50844e+06,3.99788e+06,3.19566e+06,4.12978e+06,499734,399458,516222 +GeForce RTX 2080 Ti,Unpacker,4096,32,1024,320,1,half,8589934592,1073741824,0.002136,0.00208,0.002368,125827,113360,129056,4.52976e+06,4.08094e+06,4.646e+06,1.4707e+06,1.32498e+06,1.50844e+06,4.02645e+06,3.62751e+06,4.12978e+06,503306,453438,516222 +GeForce RTX 2080 Ti,Unpacker,4096,32,1024,352,1,half,8589934592,1073741824,0.0021616,0.00208,0.0024,124437,111848,129056,4.47972e+06,4.02653e+06,4.646e+06,1.45446e+06,1.30732e+06,1.50844e+06,3.98198e+06,3.57914e+06,4.12978e+06,497747,447392,516222 +GeForce RTX 2080 Ti,Unpacker,4096,32,1024,384,1,half,8589934592,1073741824,0.0022048,0.002048,0.00272,122387,98689.5,131072,4.40593e+06,3.55282e+06,4.71859e+06,1.4305e+06,1.15351e+06,1.53201e+06,3.91638e+06,3.15806e+06,4.1943e+06,489548,394758,524288 +GeForce RTX 2080 Ti,Unpacker,4096,32,1024,416,1,half,8589934592,1073741824,0.00216,0.00208,0.002656,124733,101068,129056,4.49039e+06,3.63843e+06,4.646e+06,1.45792e+06,1.18131e+06,1.50844e+06,3.99146e+06,3.23416e+06,4.12978e+06,498933,404270,516222 +GeForce RTX 2080 Ti,Unpacker,4096,32,1024,448,1,half,8589934592,1073741824,0.0021776,0.002112,0.002784,123798,96420.8,127100,4.45674e+06,3.47115e+06,4.5756e+06,1.44699e+06,1.127e+06,1.48559e+06,3.96154e+06,3.08546e+06,4.0672e+06,495193,385683,508400 +GeForce RTX 2080 Ti,Unpacker,4096,32,1024,480,1,half,8589934592,1073741824,0.0021344,0.00208,0.002656,126149,101068,129056,4.54136e+06,3.63843e+06,4.646e+06,1.47447e+06,1.18131e+06,1.50844e+06,4.03676e+06,3.23416e+06,4.12978e+06,504595,404270,516222 +GeForce RTX 2080 Ti,Unpacker,4096,32,1024,512,1,half,8589934592,1073741824,0.0021888,0.002112,0.0024,122945,111848,127100,4.42601e+06,4.02653e+06,4.5756e+06,1.43702e+06,1.30732e+06,1.48559e+06,3.93423e+06,3.57914e+06,4.0672e+06,491779,447392,508400 +GeForce RTX 2080 Ti,Unpacker,4096,32,1024,544,1,half,8589934592,1073741824,0.0021872,0.00208,0.002464,122979,108943,129056,4.42723e+06,3.92195e+06,4.646e+06,1.43741e+06,1.27336e+06,1.50844e+06,3.93531e+06,3.48618e+06,4.12978e+06,491914,435772,516222 +GeForce RTX 2080 Ti,Unpacker,4096,32,1024,576,1,half,8589934592,1073741824,0.002152,0.00208,0.002688,125208,99864.4,129056,4.50748e+06,3.59512e+06,4.646e+06,1.46347e+06,1.16725e+06,1.50844e+06,4.00665e+06,3.19566e+06,4.12978e+06,500831,399458,516222 +GeForce RTX 2080 Ti,Unpacker,4096,32,1024,608,1,half,8589934592,1073741824,0.0021728,0.00208,0.002656,124028,101068,129056,4.465e+06,3.63843e+06,4.646e+06,1.44968e+06,1.18131e+06,1.50844e+06,3.96889e+06,3.23416e+06,4.12978e+06,496111,404270,516222 +GeForce RTX 2080 Ti,Unpacker,4096,32,1024,640,1,half,8589934592,1073741824,0.002224,0.00208,0.002912,121619,92182.5,129056,4.37829e+06,3.31857e+06,4.646e+06,1.42152e+06,1.07746e+06,1.50844e+06,3.89181e+06,2.94984e+06,4.12978e+06,486476,368730,516222 +GeForce RTX 2080 Ti,Unpacker,4096,32,1024,672,1,half,8589934592,1073741824,0.0021168,0.00208,0.002368,126913,113360,129056,4.56889e+06,4.08094e+06,4.646e+06,1.4834e+06,1.32498e+06,1.50844e+06,4.06123e+06,3.62751e+06,4.12978e+06,507654,453438,516222 +GeForce RTX 2080 Ti,Unpacker,4096,32,1024,704,1,half,8589934592,1073741824,0.0021312,0.00208,0.002272,126021,118149,129056,4.53676e+06,4.25338e+06,4.646e+06,1.47297e+06,1.38097e+06,1.50844e+06,4.03268e+06,3.78078e+06,4.12978e+06,504085,472598,516222 +GeForce RTX 2080 Ti,Unpacker,4096,32,1024,736,1,half,8589934592,1073741824,0.0021712,0.00208,0.002784,124270,96420.8,129056,4.47374e+06,3.47115e+06,4.646e+06,1.45251e+06,1.127e+06,1.50844e+06,3.97665e+06,3.08546e+06,4.12978e+06,497082,385683,516222 +GeForce RTX 2080 Ti,Unpacker,4096,32,1024,768,1,half,8589934592,1073741824,0.0021856,0.00208,0.002624,123288,102300,129056,4.43837e+06,3.6828e+06,4.646e+06,1.44103e+06,1.19572e+06,1.50844e+06,3.94522e+06,3.2736e+06,4.12978e+06,493153,409200,516222 +GeForce RTX 2080 Ti,Unpacker,4096,32,1024,800,1,half,8589934592,1073741824,0.0021376,0.00208,0.002368,125714,113360,129056,4.52569e+06,4.08094e+06,4.646e+06,1.46938e+06,1.32498e+06,1.50844e+06,4.02284e+06,3.62751e+06,4.12978e+06,502854,453438,516222 +GeForce RTX 2080 Ti,Unpacker,4096,32,1024,832,1,half,8589934592,1073741824,0.0022064,0.00208,0.003264,122815,82241.3,129056,4.42135e+06,2.96069e+06,4.646e+06,1.4355e+06,961261,1.50844e+06,3.93009e+06,2.63172e+06,4.12978e+06,491261,328965,516222 +GeForce RTX 2080 Ti,Unpacker,4096,32,1024,864,1,half,8589934592,1073741824,0.0021888,0.00208,0.003072,123558,87381.3,129056,4.4481e+06,3.14573e+06,4.646e+06,1.44419e+06,1.02134e+06,1.50844e+06,3.95386e+06,2.7962e+06,4.12978e+06,494233,349525,516222 +GeForce RTX 2080 Ti,Unpacker,4096,32,1024,896,1,half,8589934592,1073741824,0.002168,0.00208,0.002784,124523,96420.8,129056,4.48284e+06,3.47115e+06,4.646e+06,1.45547e+06,1.127e+06,1.50844e+06,3.98474e+06,3.08546e+06,4.12978e+06,498093,385683,516222 +GeForce RTX 2080 Ti,Unpacker,4096,32,1024,928,1,half,8589934592,1073741824,0.0021824,0.00208,0.002784,123545,96420.8,129056,4.44761e+06,3.47115e+06,4.646e+06,1.44403e+06,1.127e+06,1.50844e+06,3.95343e+06,3.08546e+06,4.12978e+06,494179,385683,516222 +GeForce RTX 2080 Ti,Unpacker,4096,32,1024,960,1,half,8589934592,1073741824,0.0022592,0.00208,0.003264,120525,82241.3,129056,4.33891e+06,2.96069e+06,4.646e+06,1.40874e+06,961261,1.50844e+06,3.85681e+06,2.63172e+06,4.12978e+06,482102,328965,516222 +GeForce RTX 2080 Ti,Unpacker,4096,32,1024,992,1,half,8589934592,1073741824,0.0022544,0.002112,0.002848,120046,94254,127100,4.32167e+06,3.39314e+06,4.5756e+06,1.40314e+06,1.10167e+06,1.48559e+06,3.84149e+06,3.01613e+06,4.0672e+06,480186,377016,508400 +GeForce RTX 2080 Ti,Unpacker,4096,32,1024,1024,1,half,8589934592,1073741824,0.0022272,0.002112,0.003232,121680,83055.5,127100,4.38046e+06,2.99e+06,4.5756e+06,1.42223e+06,970779,1.48559e+06,3.89374e+06,2.65778e+06,4.0672e+06,486718,332222,508400 diff --git a/psrdada_cpp/cryopaf/profiling/Results/2080/voltage_kernel.csv b/psrdada_cpp/cryopaf/profiling/Results/2080/voltage_kernel.csv new file mode 100644 index 0000000000000000000000000000000000000000..b606c4db12c200e15e79a0db85b486b80085d7ab --- /dev/null +++ b/psrdada_cpp/cryopaf/profiling/Results/2080/voltage_kernel.csv @@ -0,0 +1,225 @@ +devicename,kernelname,samples,channels,elements,beams,integration,precision,reads,writes,avg_time,min_time,max_time,avg_throughput,min_throughput,max_throughput,avg_bandwidth,min_bandwidth,max_bandwidth,percentage_avg_bandwidth,percentage_min_bandwidth,percentage_max_bandwidth,input_avg_bandwidth,input_min_bandwidth,input_max_bandwidth,output_avg_bandwidth,output_min_bandwidth,output_max_bandwidth +GeForce RTX 2080 Ti,Voltage,4096,32,16,32,1,half,16908288,33554432,0.385661,0.384352,0.39008,2784.19,2752.62,2793.64,130.849,129.365,131.293,42.4834,42.0016,42.6276,43.503,43.0097,43.6507,87.0059,86.0194,87.3013 +GeForce RTX 2080 Ti,Voltage,4096,32,16,64,1,half,17039360,67108864,0.751462,0.749984,0.754624,2857.75,2845.77,2863.37,111.98,111.51,112.2,36.357,36.2046,36.4286,22.3261,22.2325,22.3701,89.3045,88.9302,89.4804 +GeForce RTX 2080 Ti,Voltage,4096,32,16,96,1,half,17170432,100663296,1.12135,1.11955,1.1255,2872.63,2862.03,2877.25,105.082,104.694,105.251,34.1175,33.9916,34.1723,14.9616,14.9064,14.9857,89.7697,89.4384,89.9139 +GeForce RTX 2080 Ti,Voltage,4096,32,16,128,1,half,17301504,134217728,1.47992,1.4784,1.48416,2902.17,2893.87,2905.15,102.384,102.091,102.489,33.2415,33.1464,33.2755,11.3366,11.3042,11.3482,90.6928,90.4335,90.7858 +GeForce RTX 2080 Ti,Voltage,4096,32,16,160,1,half,17432576,167772160,1.85812,1.8561,1.86515,2889.32,2878.43,2892.47,99.6732,99.2974,99.7819,32.3614,32.2394,32.3967,9.02914,8.99509,9.03898,90.2914,89.9509,90.3898 +GeForce RTX 2080 Ti,Voltage,4096,32,16,192,1,half,17563648,201326592,2.22074,2.21923,2.22669,2901.04,2893.29,2903.01,98.5666,98.3031,98.6333,32.0021,31.9166,32.0238,7.5548,7.53461,7.55992,90.6576,90.4153,90.719 +GeForce RTX 2080 Ti,Voltage,4096,32,16,224,1,half,17694720,234881024,2.57851,2.57584,2.584,2914.94,2908.74,2917.96,97.9542,97.746,98.0557,31.8033,31.7357,31.8363,6.50656,6.49273,6.5133,91.0918,90.8982,91.1862 +GeForce RTX 2080 Ti,Voltage,4096,32,16,256,1,half,17825792,268435456,2.93948,2.93741,2.94371,2922.27,2918.06,2924.32,97.3851,97.245,97.4537,31.6186,31.5731,31.6408,5.70755,5.69934,5.71157,91.3209,91.1894,91.3851 +GeForce RTX 2080 Ti,Voltage,4096,32,16,288,1,half,17956864,301989888,3.2909,3.21229,3.32032,2936.94,2910.47,3008.35,97.2366,96.3602,99.6009,31.5703,31.2858,32.338,5.09885,5.05289,5.22282,91.7793,90.952,94.0108 +GeForce RTX 2080 Ti,Voltage,4096,32,16,320,1,half,18087936,335544320,3.6695,3.5767,3.69526,2926.5,2905.72,3002.04,96.383,95.6988,98.871,31.2932,31.071,32.101,4.57265,4.54019,4.69069,91.4531,90.8039,93.8138 +GeForce RTX 2080 Ti,Voltage,4096,32,16,352,1,half,18219008,369098752,3.99563,3.9136,4.0417,2956.6,2922.33,3017.98,96.9544,95.8305,98.9671,31.4787,31.1138,32.1322,4.19972,4.15103,4.2869,92.3937,91.3227,94.3118 +GeForce RTX 2080 Ti,Voltage,4096,32,16,384,1,half,18350080,402653184,4.37116,4.27923,4.41542,2948.26,2918.16,3011.03,96.3317,95.3483,98.3829,31.2765,30.9572,31.9425,3.83887,3.79968,3.92061,92.133,91.1924,94.0947 +GeForce RTX 2080 Ti,Voltage,4096,32,16,416,1,half,18481152,436207616,4.71315,4.62653,4.77635,2962.3,2922.45,3017.09,96.494,95.1958,98.2786,31.3292,30.9077,31.9086,3.56046,3.51256,3.62631,92.5719,91.3265,94.284 +GeForce RTX 2080 Ti,Voltage,4096,32,16,448,1,half,18612224,469762048,5.06536,4.97782,5.13789,2968.37,2925.79,3019.87,96.4367,95.0535,98.11,31.3106,30.8615,31.8539,3.31291,3.26539,3.37039,92.7614,91.431,94.371 +GeForce RTX 2080 Ti,Voltage,4096,32,16,480,1,half,18743296,503316480,5.4388,5.34544,5.52163,2962.04,2916.91,3013.06,96.0107,94.5481,97.6645,31.1723,30.6974,31.7093,3.08546,3.03845,3.1386,92.5637,91.1536,94.1581 +GeForce RTX 2080 Ti,Voltage,4096,32,16,512,1,half,18874368,536870912,5.75983,5.67942,5.86182,2983.37,2930.81,3024.93,96.5081,94.8076,97.8524,31.3338,30.7817,31.7703,2.91345,2.86212,2.95403,93.2305,91.5877,94.5291 +GeForce RTX 2080 Ti,Voltage,4096,32,16,544,1,half,19005440,570425344,6.12259,6.0431,6.2401,2982.04,2925.21,3020.57,96.2935,94.4586,97.5378,31.2641,30.6684,31.6681,2.74084,2.68862,2.77626,93.1886,91.4129,94.3928 +GeForce RTX 2080 Ti,Voltage,4096,32,16,576,1,half,19136512,603979776,6.4949,6.40349,6.6055,2976.44,2925.95,3018.25,95.9609,94.3329,97.3089,31.1561,30.6276,31.5938,2.58372,2.53988,2.62001,93.0139,91.4358,94.3204 +GeForce RTX 2080 Ti,Voltage,4096,32,16,608,1,half,19267584,637534208,6.82885,6.74704,6.96461,2988.11,2929.25,3023.71,96.2005,94.3056,97.3467,31.2339,30.6187,31.6061,2.45733,2.40892,2.4866,93.3784,91.5391,94.491 +GeForce RTX 2080 Ti,Voltage,4096,32,16,640,1,half,19398656,671088640,7.21052,7.12995,7.36243,2978.9,2916.81,3011.92,95.7816,93.7852,96.8432,31.0979,30.4497,31.4426,2.32727,2.27876,2.35306,93.0907,91.1504,94.1225 +GeForce RTX 2080 Ti,Voltage,4096,32,16,672,1,half,19529728,704643072,7.55168,7.46394,7.70896,2986.52,2924.98,3021,95.9156,93.9391,97.0229,31.1414,30.4997,31.5009,2.22212,2.17633,2.24777,93.3289,91.4057,94.4064 +GeForce RTX 2080 Ti,Voltage,4096,32,16,704,1,half,19660800,738197504,7.88669,7.80838,8.05722,2995.77,2931.82,3025.25,96.1111,94.0596,97.057,31.2049,30.5388,31.512,2.12768,2.08226,2.14862,93.6178,91.6194,94.5391 +GeForce RTX 2080 Ti,Voltage,4096,32,16,736,1,half,19791872,771751936,8.24401,8.16246,8.43283,2996.26,2928.56,3025.56,96.0343,93.8645,96.9736,31.18,30.4755,31.4849,2.0355,1.98951,2.05541,93.633,91.5175,94.5489 +GeForce RTX 2080 Ti,Voltage,4096,32,16,768,1,half,19922944,805306368,8.62206,8.54064,8.81914,2989.37,2922.03,3017.32,95.7289,93.5726,96.6238,31.0808,30.3807,31.3714,1.9462,1.90237,1.9644,93.4178,91.3135,94.2911 +GeForce RTX 2080 Ti,Voltage,4096,32,16,800,1,half,20054016,838860800,8.97602,8.89101,9.18074,2991.12,2923.9,3019.18,95.7071,93.5562,96.6049,31.0737,30.3754,31.3652,1.86945,1.82744,1.88699,93.4725,91.3718,94.3493 +GeForce RTX 2080 Ti,Voltage,4096,32,16,832,1,half,20185088,872415232,9.3113,9.23334,9.5281,2998.74,2930,3023.53,95.8787,93.6809,96.6714,31.1294,30.4159,31.3868,1.80212,1.76082,1.81702,93.7105,91.5624,94.4853 +GeForce RTX 2080 Ti,Voltage,4096,32,16,864,1,half,20316160,905969664,9.66793,9.58022,9.89219,2999.23,2930.7,3026.13,95.8279,93.6381,96.6873,31.1129,30.402,31.392,1.73567,1.69601,1.75123,93.7261,91.5843,94.5667 +GeForce RTX 2080 Ti,Voltage,4096,32,16,896,1,half,20447232,939524096,10.0195,9.93574,10.2563,3001.14,2931.36,3025.92,95.8268,93.5986,96.618,31.1126,30.3892,31.3695,1.67475,1.6358,1.68857,93.7857,91.605,94.56 +GeForce RTX 2080 Ti,Voltage,4096,32,16,928,1,half,20578304,973078528,10.3801,10.2914,10.6243,3000.35,2930.89,3025.69,95.7439,93.5272,96.5525,31.0857,30.366,31.3482,1.61657,1.57914,1.63022,93.7611,91.5903,94.553 +GeForce RTX 2080 Ti,Voltage,4096,32,16,960,1,half,20709376,1006632960,10.7641,10.6773,11.0222,2993.08,2922.48,3016.9,95.4582,93.2063,96.2176,30.9929,30.2618,31.2395,1.5589,1.52212,1.5713,93.5339,91.3274,94.278 +GeForce RTX 2080 Ti,Voltage,4096,32,16,992,1,half,20840448,1040187392,11.0784,11.0008,11.359,3005.04,2930.35,3025.78,95.7889,93.4082,96.4501,31.1003,30.3273,31.315,1.51464,1.47699,1.52509,93.9074,91.5735,94.5556 +GeForce RTX 2080 Ti,Voltage,4096,32,16,1024,1,half,20971520,1073741824,11.4386,11.3456,11.7107,3004.34,2934.05,3028.46,95.7195,93.4799,96.4876,31.0778,30.3506,31.3272,1.46697,1.43264,1.47874,93.8858,91.689,94.6392 +GeForce RTX 2080 Ti,Voltage,4096,32,32,32,1,half,33816576,33554432,0.7146,0.713344,0.71808,3005.16,2990.59,3010.45,94.2781,93.821,94.4439,30.6098,30.4614,30.6636,46.9556,46.728,47.0382,46.9556,46.728,47.0382 +GeForce RTX 2080 Ti,Voltage,4096,32,32,64,1,half,34078720,67108864,1.4114,1.40922,1.41584,3043.07,3033.51,3047.77,71.6934,71.4682,71.8042,23.2771,23.204,23.313,23.774,23.6993,23.8107,47.5479,47.3986,47.6214 +GeForce RTX 2080 Ti,Voltage,4096,32,32,96,1,half,34340864,100663296,2.11016,2.10749,2.11571,3053.07,3045.05,3056.93,63.9783,63.8103,64.0593,20.7722,20.7176,20.7985,15.9014,15.8596,15.9215,47.7042,47.5789,47.7646 +GeForce RTX 2080 Ti,Voltage,4096,32,32,128,1,half,34603008,134217728,2.79862,2.79651,2.80358,3069.35,3063.91,3071.66,60.323,60.216,60.3683,19.5854,19.5507,19.6001,11.9897,11.9684,11.9987,47.9586,47.8736,47.9947 +GeForce RTX 2080 Ti,Voltage,4096,32,32,160,1,half,34865152,167772160,3.49179,3.4039,3.51261,3075.4,3056.82,3154.44,58.0392,57.6886,59.5309,18.8439,18.7301,19.3282,9.61063,9.55257,9.85763,48.0532,47.7628,49.2882 +GeForce RTX 2080 Ti,Voltage,4096,32,32,192,1,half,35127296,201326592,4.15772,4.07526,4.20666,3099.67,3062.98,3161.73,56.8828,56.2095,58.0217,18.4684,18.2498,18.8382,8.07206,7.97651,8.23368,48.4324,47.8591,49.4021 +GeForce RTX 2080 Ti,Voltage,4096,32,32,224,1,half,35389440,234881024,4.83772,4.7471,4.89843,3107.95,3068.82,3166.64,55.8784,55.1749,56.9338,18.1423,17.9139,18.485,6.93738,6.85004,7.0684,48.5617,47.9502,49.4788 +GeForce RTX 2080 Ti,Voltage,4096,32,32,256,1,half,35651584,268435456,5.50138,5.42058,5.58954,3123.5,3073.58,3169.38,55.2865,54.4029,56.0987,17.9502,17.6633,18.2138,6.10058,6.00308,6.1902,48.8046,48.0246,49.5216 +GeForce RTX 2080 Ti,Voltage,4096,32,32,288,1,half,35913728,301989888,6.1847,6.10394,6.296,3125.69,3069.78,3166.38,54.647,53.6696,55.3583,17.7425,17.4252,17.9735,5.42655,5.32948,5.49718,48.8389,47.9654,49.4746 +GeForce RTX 2080 Ti,Voltage,4096,32,32,320,1,half,36175872,335544320,6.8844,6.7983,7.01184,3120.03,3062.65,3158.85,54.0065,53.0132,54.6784,17.5346,17.2121,17.7527,4.87505,4.7854,4.93571,48.7505,47.854,49.3571 +GeForce RTX 2080 Ti,Voltage,4096,32,32,352,1,half,36438016,369098752,7.53123,7.45078,7.68122,3137.21,3075.34,3170.45,53.8582,52.7959,54.4287,17.4864,17.1415,17.6717,4.45627,4.36838,4.50348,49.0189,48.0521,49.5382 +GeForce RTX 2080 Ti,Voltage,4096,32,32,384,1,half,36700160,402653184,8.23735,8.14816,8.40291,3129.06,3066.77,3162.65,53.3478,52.2858,53.9206,17.3207,16.9759,17.5067,4.0743,3.99319,4.11804,48.8916,47.9183,49.4165 +GeForce RTX 2080 Ti,Voltage,4096,32,32,416,1,half,36962304,436207616,8.89863,8.81248,9.0881,3137.84,3071.85,3167.93,53.1833,52.0648,53.6932,17.2673,16.9042,17.4328,3.77145,3.69213,3.8076,49.0288,47.9977,49.4988 +GeForce RTX 2080 Ti,Voltage,4096,32,32,448,1,half,37224448,469762048,9.56995,9.49171,9.78947,3142.1,3071.13,3167.48,52.9858,51.789,53.4136,17.2032,16.8146,17.3421,3.50681,3.4276,3.53513,49.0954,47.9865,49.4918 +GeForce RTX 2080 Ti,Voltage,4096,32,32,480,1,half,37486592,503316480,10.258,10.1731,10.5014,3140.74,3067.43,3166.43,52.7291,51.4983,53.1603,17.1198,16.7202,17.2599,3.27161,3.19524,3.29836,49.0741,47.9286,49.4754 +GeForce RTX 2080 Ti,Voltage,4096,32,32,512,1,half,37748736,536870912,10.922,10.8358,11.1772,3146.45,3074.09,3170.94,52.6201,51.4099,53.0297,17.0844,16.6915,17.2174,3.07271,3.00204,3.09662,49.1633,48.0326,49.546 +GeForce RTX 2080 Ti,Voltage,4096,32,32,544,1,half,38010880,570425344,11.5733,11.4929,11.8675,3154.92,3076.24,3176.49,52.5804,51.2692,52.9401,17.0716,16.6458,17.1883,2.89974,2.82743,2.91957,49.2956,48.0662,49.6327 +GeForce RTX 2080 Ti,Voltage,4096,32,32,576,1,half,38273024,603979776,12.29,12.2055,12.5907,3145.69,3070.11,3166.99,52.266,51.0103,52.6199,16.9695,16.5618,17.0844,2.73063,2.66503,2.74912,49.1513,47.9705,49.4842 +GeForce RTX 2080 Ti,Voltage,4096,32,32,608,1,half,38535168,637534208,12.9531,12.8684,13.2744,3150.47,3073.75,3170.72,52.2015,50.9303,52.5371,16.9485,16.5358,17.0575,2.59085,2.52776,2.6075,49.2261,48.0273,49.5426 +GeForce RTX 2080 Ti,Voltage,4096,32,32,640,1,half,38797312,671088640,13.6733,13.5878,14.0104,3141.6,3065.56,3160.91,51.9254,50.6685,52.2445,16.8589,16.4508,16.9625,2.45438,2.39497,2.46946,49.0876,47.8993,49.3891 +GeForce RTX 2080 Ti,Voltage,4096,32,32,672,1,half,39059456,704643072,14.3345,14.2423,14.692,3146.53,3069.5,3166.42,51.8898,50.6196,52.2179,16.8474,16.4349,16.9538,2.34117,2.28386,2.35597,49.1646,47.961,49.4754 +GeForce RTX 2080 Ti,Voltage,4096,32,32,704,1,half,39321600,738197504,14.9559,14.8793,15.3448,3159.3,3078.86,3175.19,51.9935,50.6698,52.255,16.881,16.4512,16.9659,2.24382,2.18669,2.2551,49.364,48.1072,49.6123 +GeForce RTX 2080 Ti,Voltage,4096,32,32,736,1,half,39583744,771751936,15.6455,15.57,16.0625,3157.33,3075,3172.27,51.8636,50.5112,52.1091,16.8388,16.3997,16.9185,2.14493,2.08899,2.15508,49.3333,48.0468,49.5667 +GeForce RTX 2080 Ti,Voltage,4096,32,32,768,1,half,39845888,805306368,16.369,16.2911,16.8064,3148.98,3066.67,3163.66,51.6373,50.2876,51.878,16.7654,16.3272,16.8435,2.05012,1.99653,2.05967,49.2028,47.9167,49.4322 +GeForce RTX 2080 Ti,Voltage,4096,32,32,800,1,half,40108032,838860800,17.0403,16.9583,17.4903,3150.96,3069.53,3165.83,51.5877,50.2546,51.8312,16.7493,16.3164,16.8283,1.96935,1.91846,1.97864,49.2338,47.9615,49.4661 +GeForce RTX 2080 Ti,Voltage,4096,32,32,832,1,half,40370176,872415232,17.7066,17.6228,18.1722,3153.69,3072.53,3168.31,51.5566,50.2298,51.7956,16.7391,16.3084,16.8167,1.89524,1.84647,1.90403,49.2763,48.0083,49.5048 +GeForce RTX 2080 Ti,Voltage,4096,32,32,864,1,half,40632320,905969664,18.358,18.2693,18.8497,3158.78,3076.02,3173.74,51.5696,50.2183,51.8138,16.7434,16.3047,16.8227,1.828,1.7801,1.83666,49.356,48.0627,49.5897 +GeForce RTX 2080 Ti,Voltage,4096,32,32,896,1,half,40894464,939524096,19.0576,18.9657,19.561,3155.52,3073.96,3170.44,51.451,50.1212,51.6943,16.7049,16.2731,16.7839,1.76089,1.71538,1.76922,49.3049,48.0306,49.5381 +GeForce RTX 2080 Ti,Voltage,4096,32,32,928,1,half,41156608,973078528,19.7339,19.6399,20.2583,3156.21,3074.14,3170.95,51.4017,50.0651,51.6416,16.6889,16.2549,16.7668,1.70055,1.65633,1.70849,49.3158,48.0335,49.5461 +GeForce RTX 2080 Ti,Voltage,4096,32,32,960,1,half,41418752,1006632960,20.4335,20.3638,21.0003,3153.15,3067.8,3163.68,51.2952,49.9066,51.4665,16.6543,16.2034,16.7099,1.64227,1.59781,1.64775,49.268,47.9343,49.4325 +GeForce RTX 2080 Ti,Voltage,4096,32,32,992,1,half,41680896,1040187392,21.0739,21.0055,21.6524,3159.24,3074.57,3169.26,51.3411,49.9652,51.504,16.6692,16.2225,16.7221,1.59236,1.54968,1.59741,49.3631,48.0402,49.5198 +GeForce RTX 2080 Ti,Voltage,4096,32,32,1024,1,half,41943040,1073741824,21.7286,21.6596,22.3248,3162.89,3078.17,3172.71,51.3506,49.9751,51.5101,16.6723,16.2257,16.724,1.54438,1.50301,1.54917,49.4201,48.0964,49.5736 +GeForce RTX 2080 Ti,Voltage,4096,32,64,32,1,half,67633152,33554432,1.33803,1.33507,1.34122,3209.92,3202.29,3217.03,75.6243,75.4447,75.7919,24.5533,24.495,24.6077,50.155,50.0358,50.2661,25.0775,25.0179,25.133 +GeForce RTX 2080 Ti,Voltage,4096,32,64,64,1,half,68157440,67108864,2.6494,2.64627,2.65584,3242.22,3234.36,3246.05,51.0555,50.9316,51.1158,16.5765,16.5362,16.596,25.3299,25.2684,25.3598,25.3299,25.2684,25.3598 +GeForce RTX 2080 Ti,Voltage,4096,32,64,96,1,half,68681728,100663296,3.92791,3.84205,3.96813,3281.01,3247.1,3353.65,43.1219,42.6763,44.0768,14.0006,13.8559,14.3106,17.0886,16.912,17.467,25.6329,25.368,26.2004 +GeForce RTX 2080 Ti,Voltage,4096,32,64,128,1,half,69206016,134217728,5.20325,5.10765,5.27472,3302.47,3257.02,3363.56,39.1039,38.5658,39.8273,12.6961,12.5214,12.9309,12.9003,12.7227,13.1389,25.8005,25.4455,26.2778 +GeForce RTX 2080 Ti,Voltage,4096,32,64,160,1,half,69730304,167772160,6.47583,6.39552,6.59606,3316.87,3255.7,3357.79,36.6832,36.0067,37.1358,11.9101,11.6905,12.0571,10.3652,10.1741,10.4931,25.913,25.4352,26.2328 +GeForce RTX 2080 Ti,Voltage,4096,32,64,192,1,half,70254592,201326592,7.75505,7.66848,7.91094,3323.64,3257.49,3360.48,35.027,34.3298,35.4153,11.3724,11.146,11.4985,8.65532,8.48304,8.75126,25.966,25.4491,26.2538 +GeForce RTX 2080 Ti,Voltage,4096,32,64,224,1,half,70778880,234881024,9.02789,8.9343,9.21853,3330.84,3261.34,3365.09,33.8637,33.1571,34.2119,10.9947,10.7653,11.1078,7.43492,7.27978,7.51137,26.0222,25.4792,26.2898 +GeForce RTX 2080 Ti,Voltage,4096,32,64,256,1,half,71303168,268435456,10.2949,10.2143,10.5337,3338.1,3261.89,3363.87,33.0062,32.2526,33.261,10.7163,10.4716,10.799,6.51973,6.37088,6.57007,26.0789,25.4835,26.2803 +GeForce RTX 2080 Ti,Voltage,4096,32,64,288,1,half,71827456,301989888,11.5637,11.4821,11.8468,3343.26,3262.87,3366.52,32.3316,31.5542,32.5566,10.4973,10.2449,10.5703,5.80427,5.6647,5.84466,26.1192,25.4912,26.301 +GeForce RTX 2080 Ti,Voltage,4096,32,64,320,1,half,72351744,335544320,12.8534,12.7699,13.1692,3341.99,3261.38,3363.35,31.7391,30.9735,31.9419,10.3049,10.0563,10.3708,5.22186,5.0959,5.25523,26.1093,25.4795,26.2761 +GeForce RTX 2080 Ti,Voltage,4096,32,64,352,1,half,72876032,369098752,14.1147,14.0258,14.4596,3347.67,3267.36,3368.42,31.3175,30.5662,31.5116,10.168,9.9241,10.2311,4.75521,4.64113,4.78469,26.1536,25.5262,26.3158 +GeForce RTX 2080 Ti,Voltage,4096,32,64,384,1,half,73400320,402653184,15.4131,15.3171,15.7861,3344.35,3264.86,3364.84,30.8906,30.1564,31.0799,10.0294,9.79104,10.0909,4.35462,4.25112,4.38131,26.1277,25.5067,26.2878 +GeForce RTX 2080 Ti,Voltage,4096,32,64,416,1,half,73924608,436207616,16.6618,16.579,17.0988,3351.44,3265.41,3367.79,30.6204,29.8344,30.7698,9.94169,9.68648,9.9902,4.02817,3.92477,4.04783,26.1831,25.511,26.3109 +GeForce RTX 2080 Ti,Voltage,4096,32,64,448,1,half,74448896,469762048,17.9344,17.8443,18.4003,3353.13,3267.85,3369.69,30.348,29.5762,30.4978,9.85324,9.60265,9.90189,3.74233,3.64716,3.76081,26.1963,25.5301,26.3257 +GeForce RTX 2080 Ti,Voltage,4096,32,64,480,1,half,74973184,503316480,19.2766,19.1378,19.741,3342.6,3263.49,3366.34,30.004,29.2938,30.2171,9.74156,9.51099,9.81075,3.48188,3.39947,3.50661,26.1141,25.496,26.2996 +GeForce RTX 2080 Ti,Voltage,4096,32,64,512,1,half,75497472,536870912,20.4728,20.4014,21.0307,3356.89,3267.58,3368.37,29.9137,29.1178,30.016,9.71224,9.45385,9.74545,3.27821,3.191,3.28942,26.2257,25.528,26.3154 +GeForce RTX 2080 Ti,Voltage,4096,32,64,544,1,half,76021760,570425344,21.7171,21.6316,22.316,3362.36,3271.84,3375.36,29.7693,28.9678,29.8844,9.66535,9.40514,9.70271,3.09041,3.0072,3.10235,26.2684,25.5612,26.37 +GeForce RTX 2080 Ti,Voltage,4096,32,64,576,1,half,76546048,603979776,23.0301,22.9537,23.6504,3357.14,3268.84,3368.06,29.5517,28.7743,29.6478,9.59469,9.34232,9.6259,2.91418,2.83753,2.92366,26.2277,25.5378,26.313 +GeForce RTX 2080 Ti,Voltage,4096,32,64,608,1,half,77070336,637534208,24.3064,24.2266,24.9828,3357.59,3266.42,3368.38,29.4022,28.6038,29.4967,9.54617,9.28695,9.57686,2.76118,2.6862,2.77005,26.2312,25.5189,26.3155 +GeForce RTX 2080 Ti,Voltage,4096,32,64,640,1,half,77594624,671088640,25.6527,25.4384,26.3121,3348.88,3264.64,3376.76,29.1883,28.454,29.4313,9.47671,9.23831,9.5556,2.61631,2.5505,2.6381,26.1631,25.505,26.381 +GeForce RTX 2080 Ti,Voltage,4096,32,64,672,1,half,78118912,704643072,26.7498,26.6821,27.281,3371.91,3306.12,3380.32,29.2635,28.6926,29.3365,9.50115,9.31577,9.52485,2.50886,2.45991,2.51512,26.3431,25.8291,26.4088 +GeForce RTX 2080 Ti,Voltage,4096,32,64,704,1,half,78643200,738197504,28.0077,27.9341,28.5634,3373.83,3308.06,3382.57,29.1661,28.5975,29.2417,9.4695,9.2849,9.49405,2.39618,2.34947,2.4024,26.358,25.8442,26.4264 +GeForce RTX 2080 Ti,Voltage,4096,32,64,736,1,half,79167488,771751936,29.2418,29.1777,29.8432,3378.3,3310.11,3385.61,29.1004,28.513,29.1634,9.44818,9.25746,9.46862,2.29504,2.24871,2.30001,26.393,25.8602,26.4501 +GeForce RTX 2080 Ti,Voltage,4096,32,64,768,1,half,79691776,805306368,30.5779,30.5034,31.1969,3371.18,3304.15,3379.27,28.9436,28.3681,29.0131,9.39728,9.21043,9.41983,2.19478,2.15114,2.20004,26.3373,25.8136,26.4005 +GeForce RTX 2080 Ti,Voltage,4096,32,64,800,1,half,80216064,838860800,31.8431,31.7675,32.4778,3372.11,3306.08,3380.01,28.8638,28.2986,28.9314,9.37137,9.18786,9.39331,2.10757,2.0663,2.1125,26.3446,25.8287,26.4063 +GeForce RTX 2080 Ti,Voltage,4096,32,64,832,1,half,80740352,872415232,33.0912,33.0151,33.7552,3374.7,3308.2,3382.36,28.8049,28.2373,28.8703,9.35224,9.16794,9.37346,2.02807,1.9881,2.03267,26.3649,25.8453,26.4247 +GeForce RTX 2080 Ti,Voltage,4096,32,64,864,1,half,81264640,905969664,34.3373,34.277,35.0448,3377.29,3309.02,3383.15,28.7518,28.1706,28.8017,9.33499,9.1463,9.3512,1.95445,1.91494,1.95784,26.3851,25.8517,26.4309 +GeForce RTX 2080 Ti,Voltage,4096,32,64,896,1,half,81788928,939524096,35.6056,35.5544,36.3333,3377.61,3309.88,3382.4,28.6847,28.1095,28.7254,9.31321,9.12647,9.32642,1.88482,1.84703,1.8875,26.3875,25.8585,26.425 +GeForce RTX 2080 Ti,Voltage,4096,32,64,928,1,half,82313216,973078528,36.8926,36.8209,37.6499,3376.21,3308.22,3382.7,28.6078,28.0318,28.6628,9.28825,9.10122,9.30612,1.81908,1.78245,1.82258,26.3766,25.8455,26.4273 +GeForce RTX 2080 Ti,Voltage,4096,32,64,960,1,half,82837504,1006632960,38.185,38.1237,38.9785,3374.41,3305.65,3379.76,28.532,27.9506,28.5773,9.26365,9.07486,9.27833,1.75751,1.72169,1.76029,26.3626,25.8254,26.4044 +GeForce RTX 2080 Ti,Voltage,4096,32,64,992,1,half,83361792,1040187392,39.4314,39.3655,40.2596,3376.68,3307.14,3382.25,28.4945,27.9076,28.5415,9.25145,9.06091,9.26671,1.70196,1.6669,1.70476,26.3803,25.837,26.4238 +GeForce RTX 2080 Ti,Voltage,4096,32,64,1024,1,half,83886080,1073741824,40.6868,40.6247,41.5387,3378.05,3308.7,3383.13,28.4528,27.8686,28.4956,9.23794,9.04826,9.25183,1.64944,1.61557,1.65192,26.391,25.8492,26.4307 +GeForce RTX 2080 Ti,Voltage,4096,32,128,32,1,half,135266304,33554432,2.57754,2.57427,2.58531,3332.61,3322.59,3336.84,65.4968,65.2999,65.58,21.2652,21.2013,21.2922,52.072,51.9155,52.1381,13.018,12.9789,13.0345 +GeForce RTX 2080 Ti,Voltage,4096,32,128,64,1,half,136314880,67108864,5.04763,4.97642,5.10109,3403.98,3367.88,3452.26,40.3059,39.8785,40.8776,13.0863,12.9476,13.2719,26.5936,26.3116,26.9708,13.2968,13.1558,13.4854 +GeForce RTX 2080 Ti,Voltage,4096,32,128,96,1,half,137363456,100663296,7.5234,7.46339,7.63088,3425.64,3377.04,3452.83,31.6414,31.1926,31.8926,10.2732,10.1275,10.3547,17.8419,17.5888,17.9835,13.3814,13.1916,13.4876 +GeForce RTX 2080 Ti,Voltage,4096,32,128,128,1,half,138412032,134217728,9.98579,9.91661,10.1462,3441.22,3386.46,3464.87,27.3046,26.8701,27.4922,8.86514,8.72406,8.92605,13.4423,13.2284,13.5346,13.4423,13.2284,13.5346 +GeForce RTX 2080 Ti,Voltage,4096,32,128,160,1,half,139460608,167772160,12.4799,12.4084,12.6943,3441.78,3383.39,3461.34,24.6202,24.2025,24.7601,7.99356,7.85795,8.03899,10.7556,10.5731,10.8167,13.4445,13.2164,13.5209 +GeForce RTX 2080 Ti,Voltage,4096,32,128,192,1,half,140509184,201326592,14.953,14.8849,15.2168,3447.04,3387.01,3462.54,22.8624,22.4643,22.9653,7.42287,7.29361,7.45626,8.97666,8.82035,9.01704,13.465,13.2305,13.5256 +GeForce RTX 2080 Ti,Voltage,4096,32,128,224,1,half,141557760,234881024,17.4128,17.3515,17.7448,3453.4,3388.57,3465.38,21.6199,21.214,21.6949,7.01944,6.88767,7.04379,7.70848,7.56378,7.73521,13.4898,13.2366,13.5366 +GeForce RTX 2080 Ti,Voltage,4096,32,128,256,1,half,142606336,268435456,19.8909,19.8257,20.2765,3455,3389.12,3466.18,20.6659,20.2719,20.7328,6.7097,6.58177,6.73142,6.74804,6.61938,6.76989,13.4961,13.2388,13.5398 +GeForce RTX 2080 Ti,Voltage,4096,32,128,288,1,half,143654912,301989888,22.3774,22.3057,22.8105,3454.98,3389.2,3465.91,19.916,19.5368,19.979,6.46623,6.34312,6.48669,5.99823,5.88403,6.0172,13.496,13.2391,13.5387 +GeForce RTX 2080 Ti,Voltage,4096,32,128,320,1,half,144703488,335544320,24.846,24.7847,25.3412,3457.42,3389.71,3465.82,19.3298,18.9513,19.3768,6.27591,6.15301,6.29115,5.40222,5.29643,5.41534,13.5055,13.2411,13.5383 +GeForce RTX 2080 Ti,Voltage,4096,32,128,352,1,half,145752064,369098752,27.3079,27.2451,27.8474,3460.29,3393.11,3468.12,18.8543,18.4883,18.897,6.12154,6.00269,6.13539,4.91518,4.81975,4.9263,13.5168,13.2543,13.5473 +GeForce RTX 2080 Ti,Voltage,4096,32,128,384,1,half,146800640,402653184,29.8014,29.7319,30.3952,3459.02,3391.3,3466.95,18.438,18.077,18.4803,5.98636,5.86916,6.00008,4.50393,4.41576,4.51426,13.5118,13.2473,13.5428 +GeForce RTX 2080 Ti,Voltage,4096,32,128,416,1,half,147849216,436207616,32.251,32.1963,32.9216,3462.59,3391.98,3468.39,18.1102,17.7409,18.1405,5.87994,5.76002,5.88977,4.16177,4.07689,4.16873,13.5258,13.2499,13.5484 +GeForce RTX 2080 Ti,Voltage,4096,32,128,448,1,half,148897792,469762048,34.7122,34.6643,35.4337,3464.54,3393.92,3469.25,17.823,17.4596,17.8472,5.78668,5.66872,5.79454,3.86668,3.78786,3.87193,13.5334,13.2575,13.5518 +GeForce RTX 2080 Ti,Voltage,4096,32,128,480,1,half,149946368,503316480,37.2127,37.1553,37.9809,3462.58,3392.47,3467.85,17.5552,17.1998,17.582,5.69976,5.58434,5.70843,3.60686,3.53382,3.61234,13.5257,13.2518,13.5463 +GeForce RTX 2080 Ti,Voltage,4096,32,128,512,1,half,150994944,536870912,39.6577,39.6092,40.497,3465.71,3393.8,3469.88,17.3455,16.9856,17.3663,5.63165,5.5148,5.63842,3.38449,3.31426,3.38855,13.5379,13.257,13.5542 +GeForce RTX 2080 Ti,Voltage,4096,32,128,544,1,half,152043520,570425344,42.0337,41.981,42.9421,3474.18,3400.6,3478.45,17.1883,16.8242,17.2094,5.58061,5.46242,5.58748,3.19318,3.12555,3.19711,13.571,13.2836,13.5877 +GeForce RTX 2080 Ti,Voltage,4096,32,128,576,1,half,153092096,603979776,44.6193,44.5652,45.5484,3465.37,3394.61,3469.49,16.9677,16.6213,16.9879,5.50901,5.39652,5.51557,3.00813,2.94671,3.01171,13.5366,13.2602,13.5527 +GeForce RTX 2080 Ti,Voltage,4096,32,128,608,1,half,154140672,637534208,47.0957,47.0364,48.0895,3465.55,3393.85,3469.84,16.8103,16.4625,16.8311,5.45789,5.34497,5.46464,2.84996,2.791,2.85348,13.5373,13.2572,13.554 +GeForce RTX 2080 Ti,Voltage,4096,32,128,640,1,half,155189248,671088640,49.6015,49.5397,50.6392,3463.65,3392.6,3467.9,16.6587,16.317,16.6791,5.40867,5.29772,5.41529,2.70598,2.65047,2.7093,13.5299,13.2524,13.5465 +GeForce RTX 2080 Ti,Voltage,4096,32,128,672,1,half,156237824,704643072,52.0598,51.9931,53.1607,3465.1,3393.27,3469.47,16.5368,16.1939,16.5576,5.36908,5.25777,5.37584,2.5782,2.52475,2.58145,13.5356,13.255,13.5526 +GeForce RTX 2080 Ti,Voltage,4096,32,128,704,1,half,157286400,738197504,54.5779,54.4531,55.6474,3462.69,3396,3470.48,16.4081,16.0921,16.445,5.32732,5.22471,5.3393,2.4593,2.41193,2.46483,13.5261,13.2656,13.5566 +GeForce RTX 2080 Ti,Voltage,4096,32,128,736,1,half,158334976,771751936,56.966,56.9014,58.1019,3468.25,3400.38,3472.12,16.3274,16.0079,16.3456,5.3011,5.19736,5.30701,2.35615,2.31004,2.35878,13.5479,13.2827,13.563 +GeForce RTX 2080 Ti,Voltage,4096,32,128,768,1,half,159383552,805306368,59.4847,59.4239,60.4934,3465.79,3407.95,3469.29,16.2177,15.947,16.234,5.26548,5.17761,5.27079,2.25637,2.21872,2.25865,13.5382,13.3123,13.5519 +GeForce RTX 2080 Ti,Voltage,4096,32,128,800,1,half,160432128,838860800,61.9693,61.8953,63.2481,3465.47,3395.33,3469.54,16.126,15.7996,16.1449,5.2357,5.12973,5.24185,2.16592,2.12208,2.16846,13.537,13.263,13.5529 +GeForce RTX 2080 Ti,Voltage,4096,32,128,832,1,half,161480704,872415232,64.4899,64.3617,65.6348,3463.26,3402.74,3470.05,16.0324,15.7522,16.0638,5.20533,5.11436,5.21553,2.08129,2.04492,2.08537,13.5284,13.292,13.5549 +GeForce RTX 2080 Ti,Voltage,4096,32,128,864,1,half,162529280,905969664,66.8912,66.837,67.7676,3467.27,3422.4,3470.06,15.9738,15.7671,15.9866,5.18631,5.11919,5.19047,2.00652,1.98056,2.00813,13.544,13.3688,13.5549 +GeForce RTX 2080 Ti,Voltage,4096,32,128,896,1,half,163577856,939524096,69.3532,69.2943,70.2164,3468.04,3425.39,3470.97,15.9057,15.71,15.9191,5.16418,5.10066,5.16854,1.93529,1.91149,1.93692,13.547,13.3804,13.5585 +GeForce RTX 2080 Ti,Voltage,4096,32,128,928,1,half,164626432,973078528,71.8351,71.7832,72.6636,3467.8,3428.24,3470.28,15.8378,15.6572,15.8492,5.14216,5.08349,5.14584,1.86843,1.84711,1.86976,13.5461,13.3916,13.5558 +GeForce RTX 2080 Ti,Voltage,4096,32,128,960,1,half,165675008,1006632960,74.3304,74.2857,75.0053,3466.94,3435.73,3469.01,15.7716,15.6297,15.7811,5.12066,5.07457,5.12372,1.8057,1.78944,1.80678,13.5427,13.4208,13.5508 +GeForce RTX 2080 Ti,Voltage,4096,32,128,992,1,half,166723584,1040187392,76.7902,76.7327,77.8141,3467.77,3422.11,3470.33,15.7171,15.5102,15.7288,5.10297,5.03578,5.10675,1.74787,1.72485,1.74916,13.546,13.3676,13.556 +GeForce RTX 2080 Ti,Voltage,4096,32,128,1024,1,half,167772160,1073741824,79.2286,79.1847,79.8434,3469.44,3442.71,3471.35,15.6701,15.5494,15.6787,5.08769,5.0485,5.09049,1.69406,1.68101,1.695,13.5525,13.4481,13.56 +GeForce RTX 2080 Ti,Voltage,4096,32,256,32,1,half,270532608,33554432,5.04507,4.97971,5.09619,3405.62,3371.12,3449.97,60.2802,59.6695,61.0652,19.5715,19.3732,19.8264,53.2128,52.6737,53.9058,6.65161,6.58422,6.73823 +GeForce RTX 2080 Ti,Voltage,4096,32,256,64,1,half,272629760,67108864,9.8963,9.81882,10.0788,3472.45,3409.12,3499.38,34.3345,33.7083,34.6008,11.1476,10.9443,11.234,27.1285,26.6337,27.3389,6.78213,6.65843,6.83472 +GeForce RTX 2080 Ti,Voltage,4096,32,256,96,1,half,274726912,100663296,14.7801,14.7241,15.0321,3487.28,3428.64,3500.36,25.3997,24.9726,25.495,8.24666,8.108,8.27758,18.1629,17.8575,18.231,6.81109,6.69657,6.83664 +GeForce RTX 2080 Ti,Voltage,4096,32,256,128,1,half,276824064,134217728,19.6183,19.5597,20.0159,3503,3433.24,3513.32,20.953,20.5358,21.0147,6.80292,6.66745,6.82297,13.6836,13.4111,13.7239,6.84179,6.70555,6.86196 +GeForce RTX 2080 Ti,Voltage,4096,32,256,160,1,half,278921216,167772160,24.5355,24.4684,25.0181,3501.17,3433.48,3510.62,18.2068,17.8548,18.2559,5.91129,5.79701,5.92725,10.9412,10.7296,10.9707,6.83822,6.70602,6.85668 +GeForce RTX 2080 Ti,Voltage,4096,32,256,192,1,half,281018368,201326592,29.3982,29.3289,29.9877,3506.46,3437.38,3514.6,16.408,16.0848,16.4461,5.32728,5.22232,5.33964,9.13141,8.95152,9.1526,6.84856,6.71364,6.86445 +GeForce RTX 2080 Ti,Voltage,4096,32,256,224,1,half,283115520,234881024,34.2641,34.1951,34.9753,3509.88,3438.4,3516.85,15.1183,14.8103,15.1483,4.90852,4.80855,4.91826,7.83456,7.67499,7.85011,6.85524,6.71562,6.86884 +GeForce RTX 2080 Ti,Voltage,4096,32,256,256,1,half,285212672,268435456,39.1255,39.0626,39.9516,3512.86,3440.14,3518.43,14.1509,13.858,14.1733,4.59446,4.49935,4.60174,6.86106,6.71902,6.87193,6.86106,6.71902,6.87193 +GeForce RTX 2080 Ti,Voltage,4096,32,256,288,1,half,287309824,301989888,44.0101,43.951,44.9409,3513.34,3440.49,3517.98,13.3904,13.1128,13.4081,4.34753,4.25739,4.35328,6.09954,5.97308,6.10761,6.86198,6.71971,6.87106 +GeForce RTX 2080 Ti,Voltage,4096,32,256,320,1,half,289406976,335544320,48.8924,48.8279,49.9187,3513.89,3441.57,3518.45,12.7825,12.5194,12.7991,4.15015,4.06473,4.15554,5.49046,5.37745,5.49758,6.86307,6.72181,6.87198 +GeForce RTX 2080 Ti,Voltage,4096,32,256,352,1,half,291504128,369098752,53.765,53.6992,54.8996,3514.98,3442.26,3519.2,12.2871,12.0329,12.3019,3.98933,3.9068,3.99413,4.99287,4.88957,4.99887,6.86519,6.72316,6.87345 +GeForce RTX 2080 Ti,Voltage,4096,32,256,384,1,half,293601280,402653184,58.6395,58.5669,59.8577,3515.77,3444.14,3520.05,11.8737,11.6318,11.8882,3.85511,3.77657,3.8598,4.57782,4.48456,4.5834,6.86673,6.72684,6.87509 +GeForce RTX 2080 Ti,Voltage,4096,32,256,416,1,half,295698432,436207616,63.5105,63.45,64.4393,3516.6,3465.87,3519.91,11.5243,11.3581,11.5352,3.74166,3.68768,3.74518,4.22668,4.16571,4.23066,6.86835,6.76928,6.87483 +GeForce RTX 2080 Ti,Voltage,4096,32,256,448,1,half,297795584,469762048,68.3795,68.3172,69.4136,3517.44,3465,3520.61,11.2251,11.0577,11.2352,3.64451,3.59018,3.64779,3.92572,3.86719,3.92925,6.87,6.76758,6.87619 +GeForce RTX 2080 Ti,Voltage,4096,32,256,480,1,half,299892736,503316480,73.2665,73.2085,74.1869,3517.3,3473.63,3520.06,10.9629,10.8268,10.9715,3.5594,3.51521,3.56219,3.66385,3.61837,3.66673,6.86973,6.78444,6.87511 +GeForce RTX 2080 Ti,Voltage,4096,32,256,512,1,half,301989888,536870912,78.1129,78.0485,78.972,3519,3480.7,3521.89,10.7391,10.6223,10.7479,3.48674,3.44879,3.48959,3.43653,3.39912,3.43934,6.87305,6.79825,6.87869 +GeForce RTX 2080 Ti,Voltage,4096,32,256,544,1,half,304087040,570425344,82.968,82.9363,83.5061,3520.13,3497.44,3521.47,10.5404,10.4724,10.5444,3.4222,3.40014,3.4235,3.23542,3.21456,3.23665,6.87526,6.83094,6.87788 +GeForce RTX 2080 Ti,Voltage,4096,32,256,576,1,half,306184192,603979776,87.8708,87.8184,88.5945,3519.24,3490.48,3521.33,10.358,10.2734,10.3642,3.36299,3.33551,3.36499,3.0549,3.02993,3.05671,6.87352,6.81735,6.8776 +GeForce RTX 2080 Ti,Voltage,4096,32,256,608,1,half,308281344,637534208,92.737,92.6971,93.3019,3519.82,3498.51,3521.33,10.1989,10.1371,10.2033,3.31134,3.29128,3.31276,2.89459,2.87706,2.89583,6.87466,6.83302,6.87761 +GeForce RTX 2080 Ti,Voltage,4096,32,256,640,1,half,310378496,671088640,97.6351,97.5907,98.1506,3519.21,3500.72,3520.8,10.0524,9.99961,10.057,3.26377,3.24663,3.26525,2.74938,2.73494,2.75063,6.87345,6.83734,6.87656 +GeForce RTX 2080 Ti,Voltage,4096,32,256,672,1,half,312475648,704643072,102.487,102.45,102.949,3520.22,3504.44,3521.51,9.92436,9.87987,9.92799,3.22219,3.20775,3.22337,2.61921,2.60747,2.62017,6.87543,6.84461,6.87795 +GeForce RTX 2080 Ti,Voltage,4096,32,256,704,1,half,314572800,738197504,107.319,107.301,107.361,3521.8,3520.43,3522.39,9.80971,9.80587,9.81134,3.18497,3.18373,3.1855,2.50128,2.5003,2.5017,6.87852,6.87583,6.87967 +GeForce RTX 2080 Ti,Voltage,4096,32,256,736,1,half,316669952,771751936,112.206,112.179,112.339,3521.52,3517.35,3522.38,9.70017,9.68869,9.70255,3.14941,3.14568,3.15018,2.39234,2.3895,2.39292,6.87797,6.86982,6.87965 +GeForce RTX 2080 Ti,Voltage,4096,32,256,768,1,half,318767104,805306368,117.098,117.082,117.164,3521.14,3519.15,3521.61,9.59946,9.59405,9.60073,3.11671,3.11495,3.11712,2.29241,2.29112,2.29271,6.87722,6.87335,6.87814 +GeForce RTX 2080 Ti,Voltage,4096,32,256,800,1,half,320864256,838860800,121.979,121.962,122.013,3521.06,3520.08,3521.55,9.50755,9.50492,9.50888,3.08687,3.08601,3.0873,2.20066,2.20005,2.20097,6.87707,6.87517,6.87803 +GeForce RTX 2080 Ti,Voltage,4096,32,256,832,1,half,322961408,872415232,126.832,126.819,126.865,3521.81,3520.89,3522.15,9.4249,9.42245,9.42583,3.06003,3.05924,3.06034,2.11647,2.11592,2.11668,6.87853,6.87674,6.8792 +GeForce RTX 2080 Ti,Voltage,4096,32,256,864,1,half,325058560,905969664,131.822,131.726,133.467,3518.84,3475.44,3521.36,9.33863,9.22346,9.34534,3.03202,2.99463,3.0342,2.03636,2.01125,2.03783,6.87273,6.78797,6.87766 +GeForce RTX 2080 Ti,Voltage,4096,32,256,896,1,half,327155712,939524096,136.584,136.566,136.635,3521.9,3520.59,3522.37,9.27398,9.27052,9.27522,3.01103,3.00991,3.01144,1.96535,1.96461,1.96561,6.87872,6.87615,6.87964 +GeForce RTX 2080 Ti,Voltage,4096,32,256,928,1,half,329252864,973078528,141.469,141.439,141.499,3521.73,3520.99,3522.49,9.20577,9.20383,9.20775,2.98889,2.98826,2.98953,1.89749,1.89709,1.89789,6.87838,6.87694,6.87986 +GeForce RTX 2080 Ti,Voltage,4096,32,256,960,1,half,331350016,1006632960,146.36,146.352,146.387,3521.43,3520.78,3521.62,9.14173,9.14004,9.14223,2.96809,2.96755,2.96826,1.83408,1.83374,1.83418,6.87779,6.87652,6.87817 +GeForce RTX 2080 Ti,Voltage,4096,32,256,992,1,half,333447168,1040187392,151.219,151.192,151.244,3521.89,3521.3,3522.52,9.08376,9.08222,9.08538,2.94927,2.94877,2.9498,1.77515,1.77485,1.77546,6.87869,6.87753,6.87992 +GeForce RTX 2080 Ti,Voltage,4096,32,256,1024,1,half,335544320,1073741824,156.071,156.06,156.129,3522.47,3521.16,3522.71,9.02976,9.02642,9.03039,2.93174,2.93066,2.93195,1.71996,1.71932,1.72008,6.87982,6.87727,6.8803 +GeForce RTX 2080 Ti,Voltage,4096,32,512,32,1,half,541065216,33554432,9.96158,9.90275,10.1055,3449.49,3400.11,3469.72,57.6879,56.8622,58.0263,18.7298,18.4618,18.8397,53.8982,53.1268,54.2143,3.36864,3.32042,3.38839 +GeForce RTX 2080 Ti,Voltage,4096,32,512,64,1,half,545259520,67108864,19.5536,19.4749,19.9928,3514.71,3437.21,3528.62,31.3201,30.6294,31.444,10.1688,9.94461,10.2091,27.4587,26.8532,27.5674,3.43233,3.35665,3.44592 +GeForce RTX 2080 Ti,Voltage,4096,32,512,96,1,half,549453824,100663296,29.2753,29.2126,29.8217,3521.17,3456.52,3528.59,22.2079,21.8001,22.2547,7.21035,7.07797,7.22554,18.3394,18.0027,18.3781,3.43864,3.37551,3.44589 +GeForce RTX 2080 Ti,Voltage,4096,32,512,128,1,half,553648128,134217728,38.8592,38.81,39.72,3536.93,3460.2,3541.32,17.7019,17.3179,17.7239,5.74738,5.62269,5.75452,13.8161,13.5164,13.8333,3.45404,3.3791,3.45832 +GeForce RTX 2080 Ti,Voltage,4096,32,512,160,1,half,557842432,167772160,48.6267,48.5656,49.63,3533.09,3461.59,3537.46,14.9225,14.6205,14.9409,4.84496,4.74691,4.85095,11.0409,10.8175,11.0546,3.45029,3.38046,3.45455 +GeForce RTX 2080 Ti,Voltage,4096,32,512,192,1,half,562036736,201326592,58.2724,58.1949,59.4993,3537.92,3464.89,3542.55,13.1002,12.8298,13.1174,4.25332,4.16552,4.25888,9.21334,9.02315,9.22539,3.455,3.38368,3.45952 +GeForce RTX 2080 Ti,Voltage,4096,32,512,224,1,half,566231040,234881024,67.9539,67.8819,68.7612,3539.46,3497.88,3543.19,11.7891,11.6506,11.8016,3.82764,3.78268,3.83168,7.90057,7.80776,7.9089,3.4565,3.4159,3.46014 +GeForce RTX 2080 Ti,Voltage,4096,32,512,256,1,half,570425344,268435456,77.5844,77.5176,78.421,3542.97,3505.16,3546.01,10.8123,10.6969,10.8216,3.51049,3.47302,3.51349,6.91987,6.84601,6.9258,3.45993,3.423,3.4629 +GeForce RTX 2080 Ti,Voltage,4096,32,512,288,1,half,574619648,301989888,87.2742,87.232,87.8552,3543.3,3519.85,3545,10.0443,9.97789,10.0492,3.26115,3.23957,3.26272,6.15156,6.11086,6.15452,3.46025,3.43736,3.46192 +GeForce RTX 2080 Ti,Voltage,4096,32,512,320,1,half,578813952,335544320,96.9401,96.9149,97.1638,3544.43,3536.27,3545.35,9.4322,9.41048,9.43465,3.0624,3.05535,3.0632,5.53818,5.52542,5.53961,3.46136,3.45339,3.46226 +GeForce RTX 2080 Ti,Voltage,4096,32,512,352,1,half,583008256,369098752,106.625,106.593,106.988,3544.73,3532.71,3545.8,8.92949,8.89921,8.93219,2.89918,2.88935,2.90006,5.03513,5.01806,5.03665,3.46165,3.44992,3.4627 +GeForce RTX 2080 Ti,Voltage,4096,32,512,384,1,half,587202560,402653184,116.261,116.237,116.287,3546.49,3545.68,3547.21,8.51412,8.51217,8.51584,2.76432,2.76369,2.76488,4.61783,4.61677,4.61876,3.46337,3.46258,3.46407 +GeForce RTX 2080 Ti,Voltage,4096,32,512,416,1,half,591396864,436207616,125.958,125.944,125.99,3546.23,3545.32,3546.62,8.15829,8.15621,8.15919,2.6488,2.64812,2.64909,4.26229,4.2612,4.26276,3.46311,3.46223,3.46349 +GeForce RTX 2080 Ti,Voltage,4096,32,512,448,1,half,595591168,469762048,135.616,135.603,135.63,3547.05,3546.69,3547.38,7.85567,7.85487,7.85639,2.55054,2.55028,2.55078,3.95876,3.95836,3.95913,3.46392,3.46356,3.46424 +GeForce RTX 2080 Ti,Voltage,4096,32,512,480,1,half,599785472,503316480,145.299,145.276,145.346,3547.15,3546.01,3547.71,7.59196,7.58951,7.59317,2.46492,2.46413,2.46531,3.69495,3.69376,3.69553,3.46401,3.4629,3.46456 +GeForce RTX 2080 Ti,Voltage,4096,32,512,512,1,half,603979776,536870912,154.961,154.94,155.016,3547.71,3546.44,3548.18,7.36219,7.35956,7.36316,2.39032,2.38947,2.39064,3.46456,3.46332,3.46502,3.46456,3.46332,3.46502 +GeForce RTX 2080 Ti,Voltage,4096,32,512,544,1,half,608174080,570425344,164.624,164.607,164.654,3548.19,3547.52,3548.55,7.15935,7.15802,7.16009,2.32446,2.32403,2.3247,3.2612,3.26059,3.26153,3.46502,3.46438,3.46538 +GeForce RTX 2080 Ti,Voltage,4096,32,512,576,1,half,612368384,603979776,174.343,174.306,174.385,3547.46,3546.6,3548.21,6.97675,6.97506,6.97823,2.26518,2.26463,2.26566,3.0794,3.07865,3.08005,3.46432,3.46348,3.46505 +GeForce RTX 2080 Ti,Voltage,4096,32,512,608,1,half,616562688,637534208,183.995,183.984,184.012,3548.11,3547.78,3548.33,6.81592,6.81529,6.81635,2.21296,2.21275,2.2131,2.91785,2.91758,2.91804,3.46495,3.46463,3.46517 +GeForce RTX 2080 Ti,Voltage,4096,32,512,640,1,half,620756992,671088640,193.697,193.667,193.728,3547.78,3547.21,3548.33,6.6694,6.66833,6.67044,2.16539,2.16504,2.16573,2.7717,2.77125,2.77213,3.46462,3.46407,3.46517 +GeForce RTX 2080 Ti,Voltage,4096,32,512,672,1,half,624951296,704643072,203.376,203.355,203.42,3547.89,3547.12,3548.26,6.53763,6.5362,6.53831,2.12261,2.12214,2.12283,2.6398,2.63922,2.64007,3.46474,3.46398,3.4651 +GeForce RTX 2080 Ti,Voltage,4096,32,512,704,1,half,629145600,738197504,213.053,213.023,213.107,3548.02,3547.12,3548.51,6.41786,6.41624,6.41875,2.08372,2.08319,2.08401,2.5199,2.51926,2.52025,3.46486,3.46398,3.46534 +GeForce RTX 2080 Ti,Voltage,4096,32,512,736,1,half,633339904,771751936,222.707,222.679,222.733,3548.49,3548.07,3548.93,6.30915,6.3084,6.30994,2.04842,2.04818,2.04868,2.41066,2.41037,2.41096,3.46532,3.46491,3.46576 +GeForce RTX 2080 Ti,Voltage,4096,32,512,768,1,half,637534208,805306368,232.398,232.379,232.448,3548.37,3547.61,3548.66,6.20849,6.20716,6.209,2.01574,2.01531,2.01591,2.31014,2.30964,2.31032,3.4652,3.46446,3.46549 +GeForce RTX 2080 Ti,Voltage,4096,32,512,800,1,half,641728512,838860800,242.079,242.055,242.131,3548.41,3547.64,3548.75,6.11615,6.11483,6.11675,1.98576,1.98533,1.98596,2.21776,2.21728,2.21797,3.46524,3.46449,3.46558 +GeForce RTX 2080 Ti,Voltage,4096,32,512,832,1,half,645922816,872415232,251.736,251.702,251.76,3548.77,3548.43,3549.25,6.03147,6.03089,6.03229,1.95827,1.95808,1.95854,2.13267,2.13247,2.13297,3.4656,3.46526,3.46607 +GeForce RTX 2080 Ti,Voltage,4096,32,512,864,1,half,650117120,905969664,261.436,261.412,261.471,3548.53,3548.05,3548.85,5.95208,5.95128,5.95262,1.93249,1.93223,1.93267,2.05355,2.05327,2.05373,3.46536,3.4649,3.46568 +GeForce RTX 2080 Ti,Voltage,4096,32,512,896,1,half,654311424,939524096,271.076,271.048,271.106,3549.09,3548.69,3549.45,5.87967,5.87901,5.88027,1.90898,1.90877,1.90918,1.98052,1.9803,1.98072,3.46591,3.46552,3.46626 +GeForce RTX 2080 Ti,Voltage,4096,32,512,928,1,half,658505728,973078528,280.776,280.743,280.812,3548.85,3548.39,3549.27,5.81098,5.81023,5.81166,1.88668,1.88644,1.8869,1.9121,1.91185,1.91232,3.46568,3.46523,3.46608 +GeForce RTX 2080 Ti,Voltage,4096,32,512,960,1,half,662700032,1006632960,290.455,290.434,290.488,3548.89,3548.49,3549.15,5.74731,5.74665,5.74773,1.86601,1.8658,1.86614,1.84838,1.84817,1.84852,3.46571,3.46532,3.46597 +GeForce RTX 2080 Ti,Voltage,4096,32,512,992,1,half,666894336,1040187392,300.155,300.127,300.203,3548.67,3548.11,3549,5.68733,5.68643,5.68786,1.84654,1.84624,1.84671,1.78864,1.78836,1.78881,3.4655,3.46495,3.46582 +GeForce RTX 2080 Ti,Voltage,4096,32,512,1024,1,half,671088640,1073741824,309.781,309.757,309.837,3549.32,3548.67,3549.6,5.63246,5.63144,5.6329,1.82872,1.82839,1.82887,1.73307,1.73275,1.7332,3.46613,3.4655,3.4664 +GeForce RTX 2080 Ti,Voltage,4096,32,1024,32,1,half,1082130432,33554432,19.7754,19.7144,20.1056,3475.17,3417.93,3485.76,56.4206,55.4913,56.5925,18.3184,18.0167,18.3742,54.2995,53.4052,54.4649,1.69686,1.66891,1.70203 +GeForce RTX 2080 Ti,Voltage,4096,32,1024,64,1,half,1090519040,67108864,38.8499,38.7837,39.8309,3537.81,3450.56,3543.73,29.7985,29.0636,29.8483,9.67482,9.43622,9.69102,27.6391,26.9575,27.6854,1.72745,1.68484,1.73034 +GeForce RTX 2080 Ti,Voltage,4096,32,1024,96,1,half,1098907648,100663296,58.2553,58.1814,59.4553,3538.96,3467.45,3543.37,20.5921,20.176,20.6178,6.68574,6.55066,6.69408,18.4321,18.0597,18.4551,1.72801,1.69309,1.73016 +GeForce RTX 2080 Ti,Voltage,4096,32,1024,128,1,half,1107296256,134217728,77.355,77.2918,78.3741,3553.49,3507.25,3556.36,16.0497,15.8409,16.0627,5.21094,5.14314,5.21516,13.8808,13.7002,13.892,1.7351,1.71253,1.73651 +GeForce RTX 2080 Ti,Voltage,4096,32,1024,160,1,half,1115684864,167772160,96.7573,96.7304,96.9017,3551.13,3545.84,3552.11,13.2647,13.2449,13.2684,4.30672,4.30031,4.30792,11.0973,11.0807,11.1004,1.73395,1.73137,1.73443 +GeForce RTX 2080 Ti,Voltage,4096,32,1024,192,1,half,1124073472,201326592,115.967,115.95,116,3555.47,3554.45,3555.98,11.4291,11.4259,11.4308,3.71075,3.70969,3.71129,9.25903,9.25639,9.26037,1.73607,1.73557,1.73632 +GeForce RTX 2080 Ti,Voltage,4096,32,1024,224,1,half,1132462080,234881024,135.28,135.258,135.319,3555.86,3554.82,3556.43,10.1075,10.1046,10.1091,3.28166,3.2807,3.28219,7.93718,7.93487,7.93847,1.73626,1.73575,1.73654 +GeForce RTX 2080 Ti,Voltage,4096,32,1024,256,1,half,1140850688,268435456,154.492,154.474,154.532,3558.47,3557.55,3558.88,9.12204,9.1197,9.12312,2.9617,2.96094,2.96205,6.95013,6.94834,6.95095,1.73753,1.73709,1.73774 +GeForce RTX 2080 Ti,Voltage,4096,32,1024,288,1,half,1149239296,301989888,173.79,173.771,173.834,3558.75,3557.85,3559.13,8.35047,8.34836,8.35137,2.71119,2.71051,2.71148,6.17838,6.17682,6.17905,1.73767,1.73723,1.73786 +GeForce RTX 2080 Ti,Voltage,4096,32,1024,320,1,half,1157627904,335544320,193.09,193.067,193.15,3558.94,3557.83,3559.35,7.73305,7.73063,7.73394,2.51073,2.50995,2.51102,5.56084,5.55911,5.56149,1.73776,1.73722,1.73796 +GeForce RTX 2080 Ti,Voltage,4096,32,1024,352,1,half,1166016512,369098752,212.364,212.328,212.388,3559.52,3559.11,3560.12,7.2287,7.22787,7.22992,2.34698,2.34671,2.34738,5.05614,5.05556,5.05699,1.73805,1.73785,1.73834 +GeForce RTX 2080 Ti,Voltage,4096,32,1024,384,1,half,1174405120,402653184,231.627,231.575,231.701,3560.17,3559.04,3560.98,6.8086,6.80643,6.81014,2.21058,2.20988,2.21108,4.63564,4.63416,4.63669,1.73837,1.73781,1.73876 +GeForce RTX 2080 Ti,Voltage,4096,32,1024,416,1,half,1182793728,436207616,250.929,250.909,250.947,3560.18,3559.93,3560.47,6.45202,6.45157,6.45254,2.09481,2.09467,2.09498,4.27906,4.27876,4.27941,1.73837,1.73825,1.73851 +GeForce RTX 2080 Ti,Voltage,4096,32,1024,448,1,half,1191182336,469762048,270.222,270.189,270.254,3560.3,3559.88,3560.74,6.14658,6.14586,6.14734,1.99564,1.99541,1.99589,3.97355,3.97308,3.97404,1.73843,1.73822,1.73864 +GeForce RTX 2080 Ti,Voltage,4096,32,1024,480,1,half,1199570944,503316480,289.535,289.504,289.59,3560.17,3559.49,3560.54,5.88147,5.88034,5.88208,1.90957,1.9092,1.90977,3.70851,3.7078,3.7089,1.73836,1.73803,1.73855 +GeForce RTX 2080 Ti,Voltage,4096,32,1024,512,1,half,1207959552,536870912,308.775,308.73,308.835,3560.88,3560.19,3561.4,5.65082,5.64972,5.65163,1.83468,1.83432,1.83494,3.47742,3.47675,3.47793,1.73871,1.73838,1.73896 +GeForce RTX 2080 Ti,Voltage,4096,32,1024,544,1,half,1216348160,570425344,328.033,327.98,328.101,3561.33,3560.59,3561.89,5.44694,5.44581,5.44781,1.76849,1.76812,1.76877,3.27328,3.2726,3.2738,1.73893,1.73857,1.73921 +GeForce RTX 2080 Ti,Voltage,4096,32,1024,576,1,half,1224736768,603979776,347.422,347.365,347.485,3560.37,3559.72,3560.96,5.26368,5.26271,5.26455,1.70899,1.70867,1.70927,3.0906,3.09003,3.09111,1.73846,1.73814,1.73875 +GeForce RTX 2080 Ti,Voltage,4096,32,1024,608,1,half,1233125376,637534208,366.712,366.69,366.741,3560.47,3560.2,3560.69,5.10116,5.10077,5.10147,1.65622,1.65609,1.65632,2.92802,2.92779,2.9282,1.73851,1.73838,1.73862 +GeForce RTX 2080 Ti,Voltage,4096,32,1024,640,1,half,1241513984,671088640,386.01,385.979,386.039,3560.5,3560.24,3560.79,4.9548,4.95443,4.95519,1.6087,1.60858,1.60883,2.78164,2.78144,2.78186,1.73852,1.7384,1.73866 +GeForce RTX 2080 Ti,Voltage,4096,32,1024,672,1,half,1249902592,704643072,405.469,405.435,405.519,3559.11,3558.67,3559.41,4.82045,4.81986,4.82086,1.56508,1.56489,1.56521,2.64814,2.64782,2.64837,1.73785,1.73763,1.73799 +GeForce RTX 2080 Ti,Voltage,4096,32,1024,704,1,half,1258291200,738197504,424.668,424.65,424.713,3560.03,3559.65,3560.17,4.70129,4.7008,4.70149,1.52639,1.52623,1.52646,2.52843,2.52816,2.52853,1.73829,1.73811,1.73837 +GeForce RTX 2080 Ti,Voltage,4096,32,1024,736,1,half,1266679808,771751936,444.135,444.057,444.19,3558.71,3558.27,3559.33,4.58966,4.5891,4.59047,1.49015,1.48997,1.49041,2.4176,2.41731,2.41802,1.73765,1.73744,1.73796 +GeForce RTX 2080 Ti,Voltage,4096,32,1024,768,1,half,1275068416,805306368,463.392,463.327,463.464,3559.12,3558.57,3559.62,4.48945,4.48875,4.49008,1.45761,1.45739,1.45782,2.31713,2.31678,2.31746,1.73785,1.73758,1.73809 +GeForce RTX 2080 Ti,Voltage,4096,32,1024,800,1,half,1283457024,838860800,482.745,482.648,482.912,3558.79,3557.56,3559.5,4.39636,4.39483,4.39724,1.42739,1.42689,1.42767,2.22424,2.22347,2.22469,1.73769,1.73709,1.73804 +GeForce RTX 2080 Ti,Voltage,4096,32,1024,832,1,half,1291845632,872415232,502.11,502.082,502.146,3558.4,3558.14,3558.59,4.31033,4.31002,4.31057,1.39946,1.39936,1.39954,2.13846,2.13831,2.13858,1.7375,1.73737,1.73759 +GeForce RTX 2080 Ti,Voltage,4096,32,1024,864,1,half,1300234240,905969664,521.411,521.312,521.586,3558.47,3557.28,3559.15,4.23122,4.2298,4.23202,1.37377,1.37331,1.37403,2.0593,2.05861,2.05969,1.73754,1.73695,1.73786 +GeForce RTX 2080 Ti,Voltage,4096,32,1024,896,1,half,1308622848,939524096,540.844,540.826,540.882,3557.67,3557.42,3557.79,4.15674,4.15644,4.15688,1.34959,1.34949,1.34963,1.98531,1.98517,1.98537,1.73714,1.73702,1.7372 +GeForce RTX 2080 Ti,Voltage,4096,32,1024,928,1,half,1317011456,973078528,560.166,560.043,560.361,3557.64,3556.4,3558.42,4.08824,4.08682,4.08913,1.32735,1.32689,1.32764,1.91683,1.91616,1.91725,1.73713,1.73652,1.73751 +GeForce RTX 2080 Ti,Voltage,4096,32,1024,960,1,half,1325400064,1006632960,579.59,579.53,579.63,3556.97,3556.72,3557.34,4.02359,4.02331,4.02401,1.30636,1.30627,1.3065,1.85259,1.85246,1.85278,1.7368,1.73668,1.73698 +GeForce RTX 2080 Ti,Voltage,4096,32,1024,992,1,half,1333788672,1040187392,598.758,598.735,598.797,3557.87,3557.64,3558.01,3.96483,3.96457,3.96498,1.28728,1.2872,1.28733,1.79328,1.79316,1.79335,1.73724,1.73713,1.73731 +GeForce RTX 2080 Ti,Voltage,4096,32,1024,1024,1,half,1342177280,1073741824,618.096,617.935,618.241,3557.74,3556.9,3558.67,3.90865,3.90773,3.90967,1.26904,1.26874,1.26937,1.73718,1.73677,1.73763,1.73718,1.73677,1.73763 diff --git a/psrdada_cpp/cryopaf/profiling/Results/3090/power_kernel.csv b/psrdada_cpp/cryopaf/profiling/Results/3090/power_kernel.csv new file mode 100644 index 0000000000000000000000000000000000000000..a7ac5f763f33661375e63e297cb85e596710b17b --- /dev/null +++ b/psrdada_cpp/cryopaf/profiling/Results/3090/power_kernel.csv @@ -0,0 +1,225 @@ +devicename,kernelname,samples,channels,elements,beams,integration,precision,reads,writes,avg_time,min_time,max_time,avg_throughput,min_throughput,max_throughput,avg_bandwidth,min_bandwidth,max_bandwidth,percentage_avg_bandwidth,percentage_min_bandwidth,percentage_max_bandwidth,input_avg_bandwidth,input_min_bandwidth,input_max_bandwidth,output_avg_bandwidth,output_min_bandwidth,output_max_bandwidth +GeForce RTX 3090,StokesI,4096,32,16,32,1,half,16908288,8388608,0.256093,0.254496,0.273888,6290.7,5880.55,6328.64,98.8042,92.3622,99.4,21.1098,19.7335,21.2371,65.5281,61.2558,65.9233,32.7641,30.6279,32.9616 +GeForce RTX 3090,StokesI,4096,32,16,64,1,half,17039360,16777216,0.492134,0.485408,0.508736,6546.43,6331.82,6636.12,68.7247,66.4718,69.6663,14.6833,14.2019,14.8844,34.096,32.9782,34.5631,34.096,32.9782,34.5631 +GeForce RTX 3090,StokesI,4096,32,16,96,1,half,17170432,25165824,0.720438,0.718816,0.734208,6706.93,6581.02,6721.94,58.7657,57.6625,58.8972,12.5555,12.3198,12.5836,23.288,22.8508,23.3401,34.9319,34.2761,35.0101 +GeForce RTX 3090,StokesI,4096,32,16,128,1,half,17301504,33554432,0.956077,0.951392,0.98976,6738.9,6509.1,6771.6,53.1961,51.3821,53.4542,11.3655,10.978,11.4207,17.5492,16.9508,17.6344,35.0985,33.9016,35.2688 +GeForce RTX 3090,StokesI,4096,32,16,160,1,half,17432576,41943040,1.18324,1.18138,1.19802,6805.98,6722,6816.68,50.1808,49.5616,50.2597,10.7213,10.589,10.7382,14.1791,14.0042,14.2014,35.4478,35.0104,35.5035 +GeForce RTX 3090,StokesI,4096,32,16,192,1,half,17563648,50331648,1.41641,1.41462,1.43114,6822.69,6752.45,6831.27,47.935,47.4415,47.9953,10.2415,10.136,10.2544,11.8449,11.723,11.8598,35.5348,35.169,35.5795 +GeForce RTX 3090,StokesI,4096,32,16,224,1,half,17694720,58720256,1.66307,1.64659,1.68346,6779.51,6697.11,6847.04,45.9502,45.3917,46.408,9.81741,9.69809,9.91521,10.0885,9.96594,10.1891,35.3099,34.8808,35.6617 +GeForce RTX 3090,StokesI,4096,32,16,256,1,half,17825792,67108864,1.89323,1.87466,1.91878,6806.11,6715.14,6873.21,44.8645,44.2648,45.3068,9.58544,9.45733,9.67995,8.86212,8.74367,8.94949,35.4485,34.9747,35.798 +GeForce RTX 3090,StokesI,4096,32,16,288,1,half,17956864,75497472,2.08734,2.07178,2.09683,6944.66,6913.05,6996.66,44.7731,44.5693,45.1083,9.56591,9.52238,9.63754,8.0378,8.00122,8.09799,36.1701,36.0055,36.4409 +GeForce RTX 3090,StokesI,4096,32,16,320,1,half,18087936,83886080,2.30255,2.30093,2.31741,6994.94,6950.06,6999.84,44.2876,44.0035,44.3186,9.46219,9.40149,9.46883,7.28639,7.23965,7.2915,36.432,36.1982,36.4575 +GeForce RTX 3090,StokesI,4096,32,16,352,1,half,18219008,92274688,2.53121,2.52877,2.54579,6999.34,6959.23,7006.08,43.6526,43.4025,43.6947,9.32653,9.27308,9.33551,6.62816,6.59018,6.63454,36.4549,36.246,36.49 +GeForce RTX 3090,StokesI,4096,32,16,384,1,half,18350080,100663296,2.73608,2.60208,2.77168,7066.83,6973.15,7427.65,43.5159,42.9391,45.7378,9.29732,9.17407,9.77203,6.1344,6.05309,6.44762,36.8064,36.3185,38.6857 +GeForce RTX 3090,StokesI,4096,32,16,416,1,half,18481152,109051904,2.81726,2.81373,2.83184,7432.04,7393.77,7441.36,45.2685,45.0354,45.3253,9.67177,9.62196,9.6839,5.95516,5.92449,5.96263,38.7086,38.5092,38.7571 +GeForce RTX 3090,StokesI,4096,32,16,448,1,half,18612224,117440512,2.88678,2.83872,2.93622,7812.38,7679.45,7943.22,47.1381,46.336,47.9275,10.0712,9.89983,10.2399,5.81279,5.71387,5.91013,40.6895,39.9971,41.3709 +GeForce RTX 3090,StokesI,4096,32,16,480,1,half,18743296,125829120,3.10046,3.04042,3.15779,7793.85,7650.66,7946.02,46.6396,45.7828,47.5502,9.96471,9.78164,10.1593,5.41239,5.31296,5.51807,40.593,39.8472,41.3855 +GeForce RTX 3090,StokesI,4096,32,16,512,1,half,18874368,134217728,3.31061,3.23603,3.36163,7785.52,7665.86,7963.4,46.2518,45.541,47.3086,9.88186,9.72999,10.1076,5.06869,4.99079,5.1845,40.5496,39.9264,41.476 +GeForce RTX 3090,StokesI,4096,32,16,544,1,half,19005440,142606336,3.507,3.44045,3.55981,7808.37,7691.54,7958.39,46.0886,45.399,46.974,9.84697,9.69965,10.0362,4.78454,4.71296,4.87646,40.6686,40.0601,41.4499 +GeForce RTX 3090,StokesI,4096,32,16,576,1,half,19136512,150994944,3.71247,3.63808,3.77843,7810.59,7672.77,7968.77,45.8358,45.027,46.7641,9.79296,9.62017,9.9913,4.52001,4.44026,4.61156,40.6801,39.9623,41.504 +GeForce RTX 3090,StokesI,4096,32,16,608,1,half,19267584,159383552,3.90963,3.8417,3.96499,7828.05,7717.96,7965.66,45.6998,45.0571,46.5032,9.76392,9.6266,9.93556,4.29169,4.23134,4.36714,40.7711,40.1977,41.4878 +GeForce RTX 3090,StokesI,4096,32,16,640,1,half,19398656,167772160,4.12226,4.03914,4.19494,7815.33,7678.83,7975.04,45.4113,44.6182,46.3393,9.70228,9.53282,9.90055,4.07049,3.99939,4.15366,40.7048,39.9939,41.5366 +GeForce RTX 3090,StokesI,4096,32,16,672,1,half,19529728,176160768,4.3177,4.24998,4.36224,7834.19,7753.56,7958.35,45.3266,44.8601,46.045,9.68418,9.58451,9.83767,3.88601,3.84601,3.9476,40.8031,40.3831,41.4497 +GeForce RTX 3090,StokesI,4096,32,16,704,1,half,19660800,184549376,4.53895,4.44512,4.61718,7807.75,7674.26,7971.32,44.9976,44.2283,45.9403,9.61389,9.44952,9.8153,3.69685,3.63365,3.7743,40.6654,39.9701,41.5173 +GeForce RTX 3090,StokesI,4096,32,16,736,1,half,19791872,192937984,4.73994,4.64368,4.82278,7816.36,7681.06,7977.31,44.8863,44.1093,45.8106,9.59011,9.42411,9.78759,3.54002,3.47874,3.61291,40.7102,40.0055,41.5485 +GeForce RTX 3090,StokesI,4096,32,16,768,1,half,19922944,201326592,4.94735,4.84717,5.01578,7813.88,7706.62,7974.7,44.7246,44.1107,45.6451,9.55556,9.4244,9.75223,3.39144,3.34489,3.46124,40.6973,40.1387,41.5349 +GeForce RTX 3090,StokesI,4096,32,16,800,1,half,20054016,209715200,5.14017,5.04838,5.20694,7834.01,7733,7975.88,44.7038,44.1275,45.5134,9.55112,9.42798,9.72409,3.26417,3.22208,3.32328,40.8021,40.2761,41.5411 +GeForce RTX 3090,StokesI,4096,32,16,832,1,half,20185088,218103808,5.39012,5.28979,5.45894,7769.65,7671.07,7916.37,44.2121,43.6511,45.0469,9.44606,9.3262,9.62442,3.11284,3.07334,3.17162,40.4669,39.9535,41.2311 +GeForce RTX 3090,StokesI,4096,32,16,864,1,half,20316160,226492416,5.58482,5.48899,5.63699,7787.01,7714.49,7922.5,44.1953,43.7837,44.9643,9.44248,9.35454,9.60677,3.00425,2.97627,3.05652,40.5574,40.1797,41.263 +GeForce RTX 3090,StokesI,4096,32,16,896,1,half,20447232,234881024,5.80283,5.7057,5.85731,7772,7699.29,7903.88,44.003,43.5914,44.7497,9.40139,9.31344,9.56092,2.89137,2.86432,2.94043,40.4792,40.1005,41.1661 +GeForce RTX 3090,StokesI,4096,32,16,928,1,half,20578304,243269632,6.01501,5.89789,6.12691,7766.03,7623.38,7919.41,43.8696,43.0638,44.736,9.37289,9.20072,9.55799,2.78952,2.73828,2.84461,40.4481,39.7051,41.2469 +GeForce RTX 3090,StokesI,4096,32,16,960,1,half,20709376,251658240,6.228,6.10406,6.34048,7759.11,7620.62,7915.77,43.7376,42.9569,44.6207,9.34468,9.17789,9.53336,2.69414,2.64605,2.74853,40.412,39.6907,41.228 +GeForce RTX 3090,StokesI,4096,32,16,992,1,half,20840448,260046848,6.43057,6.30672,6.55037,7764.92,7622.32,7916.79,43.6834,42.8811,44.5378,9.3331,9.1617,9.51564,2.60918,2.56126,2.66021,40.4423,39.6996,41.2333 +GeForce RTX 3090,StokesI,4096,32,16,1024,1,half,20971520,268435456,6.62548,6.50954,6.73613,7779.65,7651.22,7917.56,43.6846,42.9634,44.4589,9.33335,9.17927,9.4988,2.53244,2.49063,2.57733,40.519,39.8501,41.2373 +GeForce RTX 3090,StokesI,4096,32,32,32,1,half,33816576,8388608,0.362302,0.361184,0.37504,8891.55,8589.02,8918.52,116.499,112.535,116.852,24.8904,24.0435,24.9659,92.6203,89.4689,92.9012,23.1551,22.3672,23.2253 +GeForce RTX 3090,StokesI,4096,32,32,64,1,half,34078720,16777216,0.706554,0.705024,0.717536,9118.26,8978.58,9137.92,71.9784,70.8758,72.1336,15.3784,15.1428,15.4116,47.4909,46.7634,47.5933,23.7455,23.3817,23.7967 +GeForce RTX 3090,StokesI,4096,32,32,96,1,half,34340864,25165824,1.05704,1.05286,1.06947,9142.41,9035.93,9178.47,56.2968,55.6412,56.5189,12.028,11.8879,12.0754,31.7445,31.3748,31.8697,23.8084,23.5311,23.9023 +GeForce RTX 3090,StokesI,4096,32,32,128,1,half,34603008,33554432,1.40605,1.39702,1.42179,9164.18,9062.44,9223.11,48.4759,47.9377,48.7876,10.357,10.242,10.4236,23.8651,23.6001,24.0185,23.8651,23.6001,24.0185 +GeForce RTX 3090,StokesI,4096,32,32,160,1,half,34865152,41943040,1.7673,1.74483,1.78762,9114.28,9009.84,9230.76,43.4649,42.9668,44.0204,9.28642,9.18,9.4051,18.9881,18.7705,19.2308,23.7351,23.4631,24.0384 +GeForce RTX 3090,StokesI,4096,32,32,192,1,half,35127296,50331648,2.12115,2.08768,2.15552,9113.33,8966.45,9257.81,40.296,39.6466,40.9349,8.60938,8.47062,8.74587,15.8217,15.5667,16.0726,23.7326,23.3501,24.1089 +GeForce RTX 3090,StokesI,4096,32,32,224,1,half,35389440,58720256,2.46433,2.4359,2.48381,9150.53,9078.23,9256.76,38.191,37.8893,38.6344,8.15964,8.09517,8.25437,13.6169,13.5093,13.7749,23.8295,23.6412,24.1061 +GeForce RTX 3090,StokesI,4096,32,32,256,1,half,35651584,67108864,2.81549,2.77987,2.84646,9153.53,9053.27,9270.14,36.5009,36.1011,36.9659,7.79854,7.71312,7.89789,11.9187,11.7881,12.0705,23.8373,23.5762,24.141 +GeForce RTX 3090,StokesI,4096,32,32,288,1,half,35913728,75497472,3.16927,3.1263,3.18669,9148.01,9097.54,9273.26,35.1554,34.9614,35.6367,7.51106,7.46963,7.6139,10.588,10.5296,10.7329,23.8229,23.6915,24.1491 +GeForce RTX 3090,StokesI,4096,32,32,320,1,half,36175872,83886080,3.52171,3.47562,3.54525,9147.25,9086.04,9268.07,34.0937,33.8656,34.5441,7.28424,7.2355,7.38046,9.52838,9.46462,9.65424,23.821,23.6616,24.1356 +GeForce RTX 3090,StokesI,4096,32,32,352,1,half,36438016,92274688,3.87461,3.82253,3.89661,9145.58,9093.42,9269.65,33.2215,33.032,33.6721,7.09787,7.05739,7.19416,8.66058,8.61119,8.77807,23.8166,23.6808,24.1397 +GeForce RTX 3090,StokesI,4096,32,32,384,1,half,36700160,100663296,4.24928,4.16925,4.30304,9097.74,8983.12,9271.39,32.3297,31.9224,32.9468,6.90736,6.82033,7.0392,7.89734,7.79784,8.04808,23.692,23.3935,24.1442 +GeForce RTX 3090,StokesI,4096,32,32,416,1,half,36962304,109051904,4.58906,4.51514,4.66019,9126.07,8985.88,9274.57,31.8211,31.3322,32.3388,6.79867,6.69423,6.9093,7.31256,7.20023,7.43154,23.7658,23.4007,24.1525 +GeForce RTX 3090,StokesI,4096,32,32,448,1,half,37224448,117440512,4.94296,4.86528,4.99677,9124.09,9025.27,9269.18,31.2919,30.953,31.7895,6.68562,6.61321,6.79194,6.78876,6.71523,6.89671,23.7606,23.5033,24.1385 +GeForce RTX 3090,StokesI,4096,32,32,480,1,half,37486592,125829120,5.29093,5.20922,5.30989,9132.68,9099.7,9275.56,30.8684,30.7569,31.3513,6.59513,6.57131,6.69831,6.34214,6.31924,6.44136,23.783,23.6971,24.1551 +GeForce RTX 3090,StokesI,4096,32,32,512,1,half,37748736,134217728,5.66176,5.56272,5.73946,9103.72,8979.88,9265.18,30.3754,29.9622,30.9141,6.4898,6.40151,6.6049,5.9269,5.84627,6.03202,23.7076,23.3851,24.1281 +GeForce RTX 3090,StokesI,4096,32,32,544,1,half,38010880,142606336,6.01664,5.90915,6.09648,9102.2,8982.37,9267.12,30.0217,29.6265,30.5657,6.41424,6.32979,6.53046,5.57733,5.5039,5.67838,23.7036,23.3916,24.1331 +GeForce RTX 3090,StokesI,4096,32,32,576,1,half,38273024,150994944,6.37283,6.25574,6.45373,9098.95,8984.27,9268.61,29.7012,29.3269,30.2551,6.34577,6.26579,6.4641,5.2656,5.19923,5.36378,23.6952,23.3965,24.137 +GeForce RTX 3090,StokesI,4096,32,32,608,1,half,38535168,159383552,6.71704,6.60054,6.81264,9112.35,8983.78,9272.46,29.4675,29.0517,29.9852,6.29582,6.20699,6.40644,4.99581,4.92532,5.08359,23.7301,23.3953,24.147 +GeForce RTX 3090,StokesI,4096,32,32,640,1,half,38797312,167772160,7.0842,6.95875,7.14771,9094.67,9013.3,9258.05,29.161,28.9001,29.6848,6.23034,6.1746,6.34227,4.73681,4.69443,4.8219,23.684,23.4721,24.1095 +GeForce RTX 3090,StokesI,4096,32,32,672,1,half,39059456,176160768,7.44673,7.30698,7.54026,9084.5,8971.28,9257.69,28.903,28.5428,29.4541,6.17523,6.09827,6.29296,4.5062,4.45004,4.59211,23.6575,23.3627,24.1086 +GeForce RTX 3090,StokesI,4096,32,32,704,1,half,39321600,184549376,7.79792,7.64912,7.89366,9088.69,8977.7,9264.72,28.7115,28.3608,29.2675,6.1343,6.05939,6.25311,4.30336,4.25081,4.3867,23.6685,23.3794,24.1269 +GeForce RTX 3090,StokesI,4096,32,32,736,1,half,39583744,192937984,8.16827,7.99789,8.27901,9070.86,8948.92,9263.47,28.4684,28.0857,29.0729,6.08237,6.0006,6.21152,4.10818,4.05295,4.19541,23.622,23.3045,24.1236 +GeForce RTX 3090,StokesI,4096,32,32,768,1,half,39845888,201326592,8.52374,8.34102,8.66694,9070.55,8920.03,9268.58,28.2963,27.8267,28.914,6.04559,5.94527,6.17757,3.93687,3.87154,4.02282,23.6212,23.2292,24.1369 +GeForce RTX 3090,StokesI,4096,32,32,800,1,half,40108032,209715200,8.90967,8.77011,8.96976,9038.9,8978.01,9182.4,28.0406,27.8517,28.4858,5.99097,5.95061,6.08607,3.76621,3.74084,3.826,23.5388,23.3802,23.9125 +GeForce RTX 3090,StokesI,4096,32,32,832,1,half,40370176,218103808,9.27528,9.11021,9.33162,9029.9,8975.06,9193.19,27.868,27.6987,28.3719,5.95409,5.91793,6.06175,3.61775,3.59578,3.68317,23.5154,23.3726,23.9406 +GeForce RTX 3090,StokesI,4096,32,32,864,1,half,40632320,226492416,9.60996,9.43866,9.7233,9050.71,8944.82,9214.56,27.7979,27.4727,28.3011,5.93911,5.86962,6.04663,3.49179,3.45093,3.555,23.5696,23.2938,23.9963 +GeForce RTX 3090,StokesI,4096,32,32,896,1,half,40894464,234881024,9.98508,9.83242,10.0189,9033.18,9002.43,9173.16,27.6196,27.5256,28.0476,5.90102,5.88093,5.99246,3.36056,3.34912,3.41263,23.5239,23.4438,23.8884 +GeForce RTX 3090,StokesI,4096,32,32,928,1,half,41156608,243269632,10.3481,10.1702,10.4817,9027.7,8912.25,9185.21,27.487,27.1355,27.9666,5.87269,5.79759,5.97516,3.24271,3.20124,3.29929,23.5096,23.209,23.9198 +GeForce RTX 3090,StokesI,4096,32,32,960,1,half,41418752,251658240,10.69,10.5118,10.7157,9040.2,9018.23,9193.16,27.4168,27.3502,27.8807,5.8577,5.84346,5.95681,3.13896,3.13133,3.19207,23.5422,23.485,23.9405 +GeForce RTX 3090,StokesI,4096,32,32,992,1,half,41680896,260046848,11.0647,10.8797,11.1881,9025.2,8925.35,9178.34,27.2703,26.9686,27.733,5.82638,5.76192,5.92524,3.03266,2.99911,3.08412,23.5031,23.2431,23.9019 +GeForce RTX 3090,StokesI,4096,32,32,1024,1,half,41943040,268435456,11.4256,11.2359,11.4924,9021.92,8969.38,9174.07,27.1656,27.0074,27.6237,5.80402,5.77022,5.9019,2.93682,2.91972,2.98635,23.4946,23.3577,23.8908 +GeForce RTX 3090,StokesI,4096,32,64,32,1,half,67633152,8388608,0.656114,0.65424,0.669856,9819.35,9617.67,9847.23,115.87,113.49,116.199,24.7559,24.2474,24.8262,102.285,100.184,102.575,12.7856,12.523,12.8219 +GeForce RTX 3090,StokesI,4096,32,64,64,1,half,68157440,16777216,1.28906,1.28464,1.3064,9995.9,9862.91,10030,65.891,65.0143,66.1155,14.0778,13.8905,14.1258,52.062,51.3693,52.2394,13.0155,12.8423,13.0599 +GeForce RTX 3090,StokesI,4096,32,64,96,1,half,68681728,25165824,1.94538,1.91645,1.98054,9936.63,9758.61,10085,48.2491,47.3847,48.9695,10.3086,10.1239,10.4625,34.5022,33.8841,35.0173,12.9383,12.7065,13.1315 +GeForce RTX 3090,StokesI,4096,32,64,128,1,half,69206016,33554432,2.60492,2.55347,2.65523,9894.5,9705.29,10092.1,39.4556,38.7011,40.2434,8.42982,8.26862,8.59814,25.7669,25.2742,26.2814,12.8835,12.6371,13.1407 +GeForce RTX 3090,StokesI,4096,32,64,160,1,half,69730304,41943040,3.26639,3.18442,3.31494,9864.01,9717.28,10115.6,34.1965,33.6879,35.0687,7.3062,7.19752,7.49254,20.55,20.2443,21.0742,12.8438,12.6527,13.1713 +GeForce RTX 3090,StokesI,4096,32,64,192,1,half,70254592,50331648,3.90807,3.81821,3.97286,9892.78,9729.68,10123.8,30.8613,30.3525,31.5819,6.59361,6.48491,6.74758,17.175,16.8918,17.576,12.8812,12.6689,13.182 +GeForce RTX 3090,StokesI,4096,32,64,224,1,half,70778880,58720256,4.53537,4.45251,4.62176,9944.72,9757.57,10128.5,28.5569,28.0194,29.0845,6.10126,5.98645,6.214,14.7987,14.5202,15.0721,12.9489,12.7052,13.1881 +GeForce RTX 3090,StokesI,4096,32,64,256,1,half,71303168,67108864,5.18593,5.08762,5.27107,9939.6,9777.82,10130.4,26.6933,26.2588,27.2057,5.7031,5.61028,5.81258,12.9422,12.7315,13.1906,12.9422,12.7315,13.1906 +GeForce RTX 3090,StokesI,4096,32,64,288,1,half,71827456,75497472,5.84913,5.72013,5.9544,9914.25,9737.68,10136.5,25.1908,24.7422,25.7555,5.3821,5.28625,5.50275,11.4748,11.2705,11.7321,12.9092,12.6793,13.1986 +GeForce RTX 3090,StokesI,4096,32,64,320,1,half,72351744,83886080,6.49532,6.35984,6.61834,9919.87,9734.25,10129.9,24.057,23.6068,24.5663,5.13985,5.04367,5.24867,10.3332,10.1398,10.552,12.9165,12.6748,13.19 +GeForce RTX 3090,StokesI,4096,32,64,352,1,half,72876032,92274688,7.14018,6.99245,7.27398,9926.12,9742.52,10134.8,23.1322,22.7043,23.6184,4.94226,4.85085,5.04616,9.39974,9.22587,9.59733,12.9246,12.6856,13.1963 +GeForce RTX 3090,StokesI,4096,32,64,384,1,half,73400320,100663296,7.77259,7.63232,7.87686,9946.85,9814.75,10129.2,22.3955,22.0981,22.8061,4.78488,4.72133,4.8726,8.63442,8.51974,8.79272,12.9516,12.7796,13.1891 +GeForce RTX 3090,StokesI,4096,32,64,416,1,half,73924608,109051904,8.42487,8.26525,8.55821,9941.6,9786.14,10133,21.7199,21.3802,22.1381,4.64052,4.56796,4.72987,7.96603,7.84146,8.1194,12.9448,12.7424,13.194 +GeForce RTX 3090,StokesI,4096,32,64,448,1,half,74448896,117440512,9.06007,8.91619,9.14678,9955.51,9860.77,10115.8,21.1805,20.9789,21.5215,4.52527,4.48221,4.59813,7.40737,7.33688,7.52663,12.9629,12.8395,13.1716 +GeForce RTX 3090,StokesI,4096,32,64,480,1,half,74973184,125829120,9.69521,9.52643,9.8777,9968.06,9783.33,10144.1,20.7127,20.3289,21.0784,4.42534,4.34333,4.50348,6.92227,6.79398,7.04449,12.9792,12.7387,13.2084 +GeForce RTX 3090,StokesI,4096,32,64,512,1,half,75497472,134217728,10.308,10.0782,10.4652,10000.8,9849.76,10227.9,20.3466,20.0394,20.8087,4.34712,4.28148,4.44585,6.51091,6.4126,6.65879,13.0218,12.8252,13.3176 +GeForce RTX 3090,StokesI,4096,32,64,544,1,half,76021760,142606336,10.9269,10.6923,11.1039,10023.8,9863.38,10243,20.0097,19.6894,20.4472,4.27513,4.2067,4.36861,6.14205,6.04374,6.27636,13.0519,12.8429,13.3373 +GeForce RTX 3090,StokesI,4096,32,64,576,1,half,76546048,150994944,11.5672,11.3152,11.7538,10026,9866.13,10248.6,19.6727,19.359,20.1094,4.20313,4.13611,4.29643,5.80207,5.70957,5.93088,13.0547,12.8465,13.3445 +GeForce RTX 3090,StokesI,4096,32,64,608,1,half,77070336,159383552,12.2606,12.0177,12.3715,9984.2,9894.22,10185.5,19.2866,19.1128,19.6754,4.12064,4.0835,4.20372,5.47379,5.42446,5.58416,13.0003,12.8831,13.2624 +GeForce RTX 3090,StokesI,4096,32,64,640,1,half,77594624,167772160,12.8774,12.5901,13.0772,10006.5,9852.96,10234.1,19.0553,18.763,19.4888,4.07123,4.00877,4.16385,5.21171,5.13175,5.33027,13.0293,12.8294,13.3257 +GeForce RTX 3090,StokesI,4096,32,64,672,1,half,78118912,176160768,13.5439,13.2159,13.6038,9989.58,9945.12,10237,18.7754,18.6918,19.2404,4.01142,3.99356,4.11077,4.95515,4.93309,5.07787,13.0073,12.9494,13.3294 +GeForce RTX 3090,StokesI,4096,32,64,704,1,half,78643200,184549376,14.2013,13.8356,14.3812,9981.18,9855.51,10244.2,18.5345,18.3012,19.0229,3.95997,3.91011,4.06431,4.72594,4.66644,4.85047,12.9963,12.8327,13.3388 +GeForce RTX 3090,StokesI,4096,32,64,736,1,half,79167488,192937984,14.8759,14.4771,15.035,9961.3,9855.42,10235.3,18.2926,18.0981,18.7956,3.90826,3.86672,4.01575,4.51146,4.46351,4.63553,12.9704,12.8326,13.3272 +GeForce RTX 3090,StokesI,4096,32,64,768,1,half,79691776,201326592,15.5174,15.1058,15.7836,9965.14,9796.14,10235.7,18.1116,17.8044,18.6034,3.86959,3.80397,3.97467,4.32515,4.2518,4.44259,12.9754,12.7554,13.3278 +GeForce RTX 3090,StokesI,4096,32,64,800,1,half,80216064,209715200,16.1563,15.7316,16.3313,9969.47,9862.12,10238,17.9463,17.7531,18.4298,3.8343,3.79301,3.93759,4.15395,4.10922,4.26585,12.9811,12.8413,13.3308 +GeForce RTX 3090,StokesI,4096,32,64,832,1,half,80740352,218103808,16.8125,16.4531,17.0828,9963.49,9805.39,10180.7,17.7759,17.4938,18.1634,3.79788,3.73762,3.88066,3.99178,3.92844,4.07879,12.9733,12.7674,13.2561 +GeForce RTX 3090,StokesI,4096,32,64,864,1,half,81264640,226492416,17.4127,17.0533,17.4684,9989.92,9957.73,10200.1,17.6748,17.6179,18.0467,3.77629,3.76412,3.85574,3.85414,3.84172,3.93523,13.0077,12.9658,13.2814 +GeForce RTX 3090,StokesI,4096,32,64,896,1,half,81788928,234881024,18.1014,17.6091,18.4362,9966.14,9784.47,10244.1,17.4954,17.1765,17.9833,3.73796,3.66982,3.8422,3.70764,3.64005,3.81104,12.9767,12.7402,13.3386 +GeForce RTX 3090,StokesI,4096,32,64,928,1,half,82313216,243269632,18.7624,18.2424,19.1016,9958.34,9780.9,10241.6,17.354,17.0448,17.8476,3.70774,3.64167,3.8132,3.57699,3.51325,3.67874,12.9666,12.7355,13.3354 +GeForce RTX 3090,StokesI,4096,32,64,960,1,half,82837504,251658240,19.4085,18.9741,19.7588,9958.71,9781.62,10186.2,17.2354,16.9289,17.6291,3.6824,3.61692,3.76651,3.45788,3.3964,3.53687,12.9671,12.7365,13.2633 +GeForce RTX 3090,StokesI,4096,32,64,992,1,half,83361792,260046848,20.0514,19.4918,20.4012,9960.84,9789.42,10246.1,17.1275,16.8328,17.6181,3.65935,3.59637,3.76416,3.34706,3.28945,3.44292,12.9698,12.7466,13.3413 +GeForce RTX 3090,StokesI,4096,32,64,1024,1,half,83886080,268435456,20.7083,20.1276,21.0795,9955.97,9780.04,10242.6,17.0146,16.7139,17.5044,3.63522,3.57099,3.73988,3.24088,3.1836,3.33417,12.9635,12.7344,13.3367 +GeForce RTX 3090,StokesI,4096,32,128,32,1,half,135266304,8388608,1.24936,1.23904,1.2663,10314.1,10175.2,10399.1,114.993,113.444,115.94,24.5686,24.2377,24.7711,107.439,105.992,108.324,6.71491,6.62448,6.77025 +GeForce RTX 3090,StokesI,4096,32,128,64,1,half,136314880,16777216,2.46667,2.41498,2.53098,10451.2,10181.8,10670.8,62.0879,60.4874,63.3928,13.2653,12.9233,13.5441,54.4332,53.03,55.5773,6.80415,6.62875,6.94716 +GeForce RTX 3090,StokesI,4096,32,128,96,1,half,137363456,25165824,3.71172,3.6041,3.77715,10416.9,10233.8,10725.2,43.7993,43.0296,45.0957,9.35787,9.19341,9.63485,36.1698,35.5341,37.2403,6.78183,6.66265,6.98256 +GeForce RTX 3090,StokesI,4096,32,128,128,1,half,138412032,33554432,4.98011,4.82269,5.0649,10352.1,10175.8,10686.9,34.5407,33.9526,35.6578,7.37973,7.25409,7.61841,26.9586,26.4996,27.8305,6.73964,6.6249,6.95762 +GeForce RTX 3090,StokesI,4096,32,128,160,1,half,139460608,41943040,6.15338,5.98595,6.27264,10472.1,10270.7,10762.6,29.4868,28.9198,30.3049,6.29994,6.17882,6.47474,21.8168,21.3973,22.4221,6.81775,6.68666,7.00691 +GeForce RTX 3090,StokesI,4096,32,128,192,1,half,140509184,50331648,7.37182,7.18128,7.4671,10488.3,10353.3,10765.4,25.8907,25.5575,26.5748,5.53164,5.46045,5.67779,18.2089,17.9745,18.6899,6.82833,6.74045,7.00873 +GeForce RTX 3090,StokesI,4096,32,128,224,1,half,141557760,58720256,8.61309,8.37526,8.77459,10473.3,10279,10769.1,23.2561,22.8248,23.913,4.96875,4.87659,5.1091,15.5853,15.2962,16.0255,6.81855,6.69208,7.01115 +GeForce RTX 3090,StokesI,4096,32,128,256,1,half,142606336,67108864,9.9205,9.65046,10.1058,10391.7,10200,10681.3,21.1419,20.7519,21.7311,4.51704,4.43371,4.64292,13.5308,13.2812,13.9079,6.76541,6.64061,6.95395 +GeForce RTX 3090,StokesI,4096,32,128,288,1,half,143654912,75497472,11.1466,10.8311,11.3579,10404.7,10210,10706.6,19.6632,19.2951,20.2337,4.20111,4.12247,4.32299,12.0425,11.8171,12.3919,6.77392,6.64712,6.97045 +GeForce RTX 3090,StokesI,4096,32,128,320,1,half,144703488,83886080,12.3849,12.0521,12.521,10404.5,10290.6,10691,18.4584,18.2565,18.9667,3.94371,3.90055,4.05231,10.838,10.7194,11.1364,6.77374,6.69962,6.96027 +GeForce RTX 3090,StokesI,4096,32,128,352,1,half,145752064,92274688,13.6198,13.247,13.7611,10407.1,10299.6,10699.3,17.4776,17.297,17.9683,3.73415,3.69557,3.83899,9.85521,9.7534,10.1319,6.77546,6.70546,6.96568 +GeForce RTX 3090,StokesI,4096,32,128,384,1,half,146800640,100663296,14.85,14.4548,14.9452,10412.5,10345.7,10696.7,16.665,16.5581,17.1198,3.56054,3.53769,3.6577,9.03867,8.98067,9.28531,6.779,6.7355,6.96398 +GeForce RTX 3090,StokesI,4096,32,128,416,1,half,147849216,109051904,16.0936,15.6507,16.2218,10408.7,10325.8,10702.7,15.9638,15.8368,16.4147,3.41072,3.38358,3.50706,8.34029,8.2739,8.57585,6.77648,6.72254,6.96788 +GeForce RTX 3090,StokesI,4096,32,128,448,1,half,148897792,117440512,17.3402,16.9468,17.7603,10403.7,10156.9,10644.4,15.3608,14.9963,15.7162,3.28188,3.20401,3.35781,7.74085,7.5572,7.91995,6.77325,6.61255,6.92996 +GeForce RTX 3090,StokesI,4096,32,128,480,1,half,149946368,125829120,18.5299,18.0425,18.7464,10430.9,10309.9,10712.1,14.8835,14.7108,15.2847,3.17991,3.14302,3.26564,7.24369,7.15965,7.43896,6.79096,6.71217,6.97403 +GeForce RTX 3090,StokesI,4096,32,128,512,1,half,150994944,134217728,19.7773,19.2475,20.0378,10424.5,10288.5,10710.9,14.4219,14.2338,14.8182,3.0813,3.04109,3.16595,6.7868,6.69824,6.97326,6.7868,6.69824,6.97326 +GeForce RTX 3090,StokesI,4096,32,128,544,1,half,152043520,142606336,21.0634,20.5801,21.5674,10399.8,10156.2,10643.4,13.9895,13.6618,14.3172,2.9889,2.9189,3.05892,6.37244,6.22319,6.52172,6.77072,6.61214,6.92932 +GeForce RTX 3090,StokesI,4096,32,128,576,1,half,153092096,150994944,22.2811,21.6557,22.6213,10409.8,10252.6,10709.8,13.6485,13.4425,14.0419,2.91605,2.87203,3.0001,6.02418,5.93323,6.1978,6.7772,6.67489,6.97252 +GeForce RTX 3090,StokesI,4096,32,128,608,1,half,154140672,159383552,23.5578,22.8304,24.2493,10393,10095.7,10723.1,13.3099,12.9292,13.7327,2.84371,2.76237,2.93404,5.6979,5.53492,5.8789,6.76626,6.57271,6.98119 +GeForce RTX 3090,StokesI,4096,32,128,640,1,half,155189248,167772160,24.8231,24.0496,25.6022,10382.7,10065.5,10715.3,13.0122,12.6146,13.429,2.78009,2.69515,2.86914,5.40766,5.24243,5.58086,6.75957,6.55303,6.97608 +GeForce RTX 3090,StokesI,4096,32,128,672,1,half,156237824,176160768,26.1198,25.2267,27.0345,10361.4,10008.8,10726,12.7285,12.2954,13.1764,2.71948,2.62694,2.81519,5.13957,4.96468,5.32046,6.74568,6.51615,6.9831 +GeForce RTX 3090,StokesI,4096,32,128,704,1,half,157286400,184549376,27.3836,26.4358,28.0925,10353.6,10090.5,10722.9,12.4855,12.1682,12.9308,2.66757,2.59978,2.7627,4.90228,4.7777,5.07711,6.74064,6.56934,6.98103 +GeForce RTX 3090,StokesI,4096,32,128,736,1,half,158334976,192937984,28.6571,27.667,29.4537,10343.4,10061.7,10711.4,12.2602,11.9263,12.6964,2.61943,2.54809,2.71264,4.68449,4.55691,4.85118,6.73396,6.55056,6.97357 +GeForce RTX 3090,StokesI,4096,32,128,768,1,half,159383552,201326592,29.9041,28.8587,30.6514,10343,10088.9,10715.6,12.0646,11.7681,12.4992,2.57765,2.5143,2.6705,4.48917,4.37885,4.65087,6.73375,6.56827,6.9763 +GeForce RTX 3090,StokesI,4096,32,128,800,1,half,160432128,209715200,31.1776,30.1146,32.0138,10333.9,10062,10696.6,11.8746,11.5621,12.2913,2.53705,2.47029,2.62608,4.3058,4.1925,4.4569,6.72782,6.55078,6.96391 +GeForce RTX 3090,StokesI,4096,32,128,832,1,half,161480704,218103808,32.4234,31.3598,33.1783,10334.2,10097.2,10682.7,11.7094,11.4408,12.1042,2.50174,2.44436,2.5861,4.14032,4.04535,4.27993,6.72803,6.57369,6.95489 +GeForce RTX 3090,StokesI,4096,32,128,864,1,half,162529280,226492416,33.6717,32.702,34.4129,10333.6,10109.4,10638.3,11.5553,11.3045,11.896,2.46882,2.41525,2.54161,3.98672,3.90022,4.10427,6.72759,6.58162,6.92596 +GeForce RTX 3090,StokesI,4096,32,128,896,1,half,163577856,234881024,34.9301,33.6498,35.9852,10330.8,10025.7,10721.5,11.4098,11.0728,11.8414,2.43774,2.36575,2.52995,3.84329,3.7298,3.98867,6.72576,6.52715,6.98017 +GeForce RTX 3090,StokesI,4096,32,128,928,1,half,164626432,243269632,36.2121,35.0106,37.1331,10320.7,10062.8,10672.8,11.2662,10.9847,11.6507,2.40706,2.34692,2.4892,3.70713,3.61451,3.83364,6.71918,6.5513,6.94846 +GeForce RTX 3090,StokesI,4096,32,128,960,1,half,165675008,251658240,37.5539,36.4592,38.1309,10294,10137.4,10602.2,11.1138,10.9447,11.4466,2.37451,2.33838,2.4456,3.5743,3.51992,3.68131,6.70181,6.59985,6.90246 +GeForce RTX 3090,StokesI,4096,32,128,992,1,half,166723584,260046848,38.7902,37.6788,39.656,10298.2,10072.4,10601,11.003,10.7618,11.3265,2.35083,2.2993,2.41995,3.46041,3.38455,3.56216,6.70454,6.55757,6.90168 +GeForce RTX 3090,StokesI,4096,32,128,1024,1,half,167772160,268435456,40.0372,38.9145,40.6116,10299.1,10152.7,10595.4,10.8959,10.741,11.2094,2.32794,2.29484,2.39492,3.35257,3.30491,3.44904,6.70515,6.60982,6.89808 +GeForce RTX 3090,StokesI,4096,32,256,32,1,half,270532608,8388608,2.48658,2.40742,2.62093,10374.8,9832.32,10704.3,112.292,106.421,115.859,23.9916,22.7372,24.7536,108.071,102.42,111.503,3.37721,3.20063,3.48447 +GeForce RTX 3090,StokesI,4096,32,256,64,1,half,272629760,16777216,4.93901,4.74122,5.07027,10439.1,10165.1,10870.5,58.6179,57.0792,61.0407,12.5239,12.1952,13.0415,54.3702,52.943,56.6174,3.39814,3.30894,3.53859 +GeForce RTX 3090,StokesI,4096,32,256,96,1,half,274726912,25165824,7.36349,7.10048,7.6496,10502,10106.3,10887.9,40.7386,39.2037,42.2356,8.70394,8.376,9.02377,36.4653,35.0914,37.8053,3.41862,3.28982,3.54424 +GeForce RTX 3090,StokesI,4096,32,256,128,1,half,276824064,33554432,9.73366,9.53437,9.76077,10590.5,10560.6,10811.3,31.8886,31.7986,32.5537,6.81311,6.79387,6.9552,27.5794,27.5015,28.1545,3.44742,3.43768,3.51931 +GeForce RTX 3090,StokesI,4096,32,256,160,1,half,278921216,41943040,12.2208,11.8178,12.6057,10545.3,10221.5,10902.9,26.2604,25.4539,27.1509,5.61061,5.43831,5.80087,21.9695,21.2948,22.7145,3.43273,3.32731,3.54913 +GeForce RTX 3090,StokesI,4096,32,256,192,1,half,281018368,50331648,14.6387,14.1641,15.111,10563.5,10232.2,10916.3,22.6378,21.9277,23.3937,4.83664,4.68493,4.99813,18.3395,17.7642,18.9518,3.43865,3.33079,3.55347 +GeForce RTX 3090,StokesI,4096,32,256,224,1,half,283115520,58720256,17.0598,16.5143,17.6151,10575,10240.6,10923.2,20.0397,19.4059,20.6994,4.28154,4.14613,4.42249,15.7367,15.239,16.2547,3.4424,3.33352,3.55572 +GeForce RTX 3090,StokesI,4096,32,256,256,1,half,285212672,67108864,19.4989,18.8644,19.9231,10573.8,10347.7,10928.4,18.0705,17.6841,18.6765,3.86083,3.77827,3.9903,13.768,13.4736,14.2297,3.44201,3.3684,3.55743 +GeForce RTX 3090,StokesI,4096,32,256,288,1,half,287309824,75497472,21.8896,21.2159,22.3981,10596.2,10354.8,10931.8,16.5757,16.1981,17.1007,3.54145,3.46078,3.65363,12.2641,11.9847,12.6526,3.44927,3.3707,3.55854 +GeForce RTX 3090,StokesI,4096,32,256,320,1,half,289406976,83886080,24.3948,23.5681,24.9445,10565,10330.9,10934.2,15.3041,14.9649,15.8389,3.26976,3.19731,3.38403,11.0052,10.7613,11.3898,3.43911,3.36291,3.5593 +GeForce RTX 3090,StokesI,4096,32,256,352,1,half,291504128,92274688,26.8652,25.9575,27.819,10553.3,10189.7,10920.5,14.2878,13.7956,14.7849,3.05263,2.94747,3.15884,9.99364,9.64935,10.3414,3.43531,3.31697,3.55484 +GeForce RTX 3090,StokesI,4096,32,256,384,1,half,293601280,100663296,29.3372,28.3334,30.0821,10542.7,10279.8,10914.2,13.4414,13.1063,13.9152,2.87181,2.8002,2.97302,9.15162,8.92342,9.47416,3.43186,3.34628,3.55281 +GeForce RTX 3090,StokesI,4096,32,256,416,1,half,295698432,109051904,31.822,30.7226,32.6632,10529.6,10256.4,10904.3,12.7217,12.3916,13.1744,2.71803,2.64751,2.81474,8.43719,8.21828,8.7374,3.42761,3.33868,3.54957 +GeForce RTX 3090,StokesI,4096,32,256,448,1,half,297795584,117440512,34.226,33.0236,35.0436,10542.9,10295.1,10924.8,12.1343,11.8491,12.5739,2.59254,2.5316,2.68646,7.84443,7.66003,8.12861,3.43194,3.35126,3.55627 +GeForce RTX 3090,StokesI,4096,32,256,480,1,half,299892736,125829120,36.6486,35.3116,37.5689,10549.2,10289,10946.7,11.6183,11.3318,12.0561,2.48228,2.42107,2.57583,7.3258,7.14515,7.6019,3.43397,3.34929,3.56339 +GeForce RTX 3090,StokesI,4096,32,256,512,1,half,301989888,134217728,39.0809,37.8935,40.0336,10551.7,10299.3,10880.9,11.1631,10.896,11.5114,2.38504,2.32797,2.45945,6.86962,6.70525,7.08394,3.43481,3.35263,3.54197 +GeForce RTX 3090,StokesI,4096,32,256,544,1,half,304087040,142606336,41.5525,40.4491,42.5613,10544.2,10293.1,10830.6,10.7514,10.4953,11.0433,2.29707,2.24235,2.35945,6.46092,6.30703,6.63637,3.43236,3.35061,3.52557 +GeForce RTX 3090,StokesI,4096,32,256,576,1,half,306184192,150994944,43.9474,42.8519,45.0045,10556.1,10306.9,10824.6,10.4041,10.1585,10.6688,2.22287,2.1704,2.27943,6.10884,5.96463,6.26426,3.43622,3.3551,3.52364 +GeForce RTX 3090,StokesI,4096,32,256,608,1,half,308281344,159383552,46.3555,45.0445,47.4332,10563.6,10322.4,10869.8,10.0898,9.85944,10.3823,2.15571,2.1065,2.21821,5.79143,5.65923,5.95933,3.43866,3.36017,3.53835 +GeForce RTX 3090,StokesI,4096,32,256,640,1,half,310378496,167772160,48.8178,47.7604,49.8699,10558.3,10334.8,10791.3,9.79534,9.58797,10.0114,2.09281,2.0485,2.13898,5.49914,5.38272,5.62046,3.43696,3.3642,3.51279 +GeForce RTX 3090,StokesI,4096,32,256,672,1,half,312475648,176160768,51.3069,49.9328,52.47,10548.9,10313.8,10837.9,9.52494,9.31269,9.78587,2.03504,1.98969,2.09078,5.23259,5.11598,5.37593,3.43388,3.35736,3.52795 +GeForce RTX 3090,StokesI,4096,32,256,704,1,half,314572800,184549376,53.7977,52.3603,54.9253,10539.5,10321.9,10827.6,9.2788,9.08729,9.53246,1.98245,1.94153,2.03664,4.99028,4.88728,5.1267,3.43082,3.36001,3.52461 +GeForce RTX 3090,StokesI,4096,32,256,736,1,half,316669952,192937984,56.2731,54.7942,57.5497,10534.1,10299,10816.9,9.05722,8.8551,9.3004,1.93511,1.89192,1.98706,4.77088,4.66441,4.89898,3.42907,3.35255,3.52114 +GeForce RTX 3090,StokesI,4096,32,256,768,1,half,318767104,201326592,58.7077,57.3027,59.893,10536,10326.3,10793.1,8.86005,8.68372,9.07625,1.89298,1.85531,1.93917,4.57293,4.48192,4.68451,3.4297,3.36144,3.51339 +GeForce RTX 3090,StokesI,4096,32,256,800,1,half,320864256,209715200,61.1579,59.4134,62.4313,10535.3,10319.3,10843.4,8.67655,8.49861,8.9303,1.85377,1.81576,1.90799,4.38972,4.29969,4.5181,3.42947,3.35913,3.52976 +GeForce RTX 3090,StokesI,4096,32,256,832,1,half,322961408,218103808,63.6659,62.7094,65.0117,10525,10306.1,10684.4,8.49942,8.32258,8.62814,1.81593,1.77815,1.84343,4.21677,4.12903,4.28063,3.42612,3.35484,3.47801 +GeForce RTX 3090,StokesI,4096,32,256,864,1,half,325058560,226492416,66.0241,64.3824,67.5066,10539.5,10306.9,10807.1,8.35469,8.17033,8.5668,1.78501,1.74562,1.83033,4.06616,3.97643,4.16939,3.43083,3.35512,3.51793 +GeForce RTX 3090,StokesI,4096,32,256,896,1,half,327155712,234881024,68.4904,67.1969,69.8694,10536,10327.2,10737.9,8.20674,8.0441,8.36402,1.7534,1.71865,1.787,3.91964,3.84196,3.99476,3.42968,3.36171,3.49541 +GeForce RTX 3090,StokesI,4096,32,256,928,1,half,329252864,243269632,70.9339,69.4595,72.4724,10536.4,10311.8,10759.1,8.07187,7.89987,8.24253,1.72458,1.68783,1.76104,3.78461,3.70397,3.86463,3.42981,3.35672,3.50232 +GeForce RTX 3090,StokesI,4096,32,256,960,1,half,331350016,251658240,73.4417,72.5659,74.8203,10527.4,10332.7,10653.7,7.93893,7.79211,8.03419,1.69618,1.66481,1.71653,3.65534,3.58774,3.6992,3.42688,3.3635,3.468 +GeForce RTX 3090,StokesI,4096,32,256,992,1,half,333447168,260046848,75.9168,74.6749,77.3265,10523.9,10331.1,10697.9,7.81841,7.67517,7.9477,1.67043,1.63983,1.69805,3.53624,3.47146,3.59472,3.42574,3.36297,3.48239 +GeForce RTX 3090,StokesI,4096,32,256,1024,1,half,335544320,268435456,78.3489,77.1941,79.8921,10526.1,10321.8,10682.6,7.70958,7.55994,7.82417,1.64718,1.61521,1.67166,3.42648,3.35998,3.47741,3.42648,3.35998,3.47741 +GeForce RTX 3090,StokesI,4096,32,512,32,1,half,541065216,8388608,4.97532,4.74109,5.19024,10365.7,9930.1,10870.8,110.507,105.863,115.892,23.6101,22.618,24.7607,107.976,103.439,113.238,1.68712,1.61623,1.76934 +GeForce RTX 3090,StokesI,4096,32,512,64,1,half,545259520,16777216,9.78138,9.35312,10.2479,10542.6,10058.6,11020.8,57.4833,54.8441,60.0908,12.2815,11.7176,12.8386,54.9094,52.3884,57.4002,1.71592,1.63714,1.79376 +GeForce RTX 3090,StokesI,4096,32,512,96,1,half,549453824,25165824,14.6355,14.0194,15.2754,10567,10122.1,11028.9,39.2708,37.6174,40.9875,8.39033,8.03709,8.75711,36.6909,35.1462,38.2949,1.71989,1.64748,1.79507 +GeForce RTX 3090,StokesI,4096,32,512,128,1,half,553648128,33554432,19.399,18.6407,20.0757,10629.1,10269,11059.6,30.275,29.2494,31.5011,6.46835,6.24922,6.73032,27.68,26.7423,28.801,1.73,1.67139,1.80007 +GeForce RTX 3090,StokesI,4096,32,512,160,1,half,557842432,41943040,24.2813,23.2901,24.8907,10615,10353.2,11064.7,24.7061,24.0968,25.7528,5.27854,5.14836,5.50218,22.1146,21.5691,23.0515,1.7277,1.68509,1.8009 +GeForce RTX 3090,StokesI,4096,32,512,192,1,half,562036736,50331648,29.1646,27.9162,29.905,10606.3,10340.7,11077.4,21.0032,20.4771,21.936,4.48741,4.37501,4.6867,18.4138,17.9526,19.2315,1.72629,1.68305,1.80296 +GeForce RTX 3090,StokesI,4096,32,512,224,1,half,566231040,58720256,34.0007,32.6776,34.7604,10613.1,10379,11040.5,18.3844,17.9789,19.1247,3.9279,3.84124,4.08606,15.7933,15.4449,16.4293,1.7274,1.68929,1.79696 +GeForce RTX 3090,StokesI,4096,32,512,256,1,half,570425344,67108864,38.8289,37.5471,39.6809,10620.3,10390.8,10981.3,16.4214,16.0665,16.9796,3.50849,3.43267,3.62775,13.8286,13.5297,14.2986,1.72857,1.69121,1.78733 +GeForce RTX 3090,StokesI,4096,32,512,288,1,half,574619648,75497472,43.6229,42.1875,44.5614,10635,10409.4,10995.1,14.9055,14.5893,15.4102,3.18461,3.11704,3.29243,12.3091,12.0479,12.7258,1.73096,1.69424,1.78957 +GeForce RTX 3090,StokesI,4096,32,512,320,1,half,578813952,83886080,48.398,46.9529,49.4888,10650.7,10414.4,10976.9,13.6947,13.3909,14.1142,2.92593,2.86101,3.01554,11.0945,10.8483,11.4343,1.73351,1.69505,1.7866 +GeForce RTX 3090,StokesI,4096,32,512,352,1,half,583008256,92274688,53.4183,51.52,54.6709,10615.2,10370,11004.2,12.6438,12.3518,13.1072,2.7014,2.639,2.8004,10.0522,9.82004,10.4206,1.72773,1.68782,1.79105 +GeForce RTX 3090,StokesI,4096,32,512,384,1,half,587202560,100663296,58.4023,56.5436,59.4933,10591.3,10395.7,10938,11.7796,11.5621,12.1652,2.51676,2.47028,2.59914,9.19387,9.02406,9.49482,1.72385,1.69201,1.78028 +GeForce RTX 3090,StokesI,4096,32,512,416,1,half,591396864,109051904,63.2292,61.7101,64.6252,10598.2,10367.7,10857.5,11.0796,10.8386,11.3506,2.3672,2.31571,2.4251,8.49217,8.30746,8.69989,1.72497,1.68745,1.76717 +GeForce RTX 3090,StokesI,4096,32,512,448,1,half,595591168,117440512,68.1283,66.7314,69.4063,10592,10396.1,10812.8,10.4669,10.2733,10.6851,2.2363,2.19492,2.28291,7.88099,7.73519,8.04526,1.72397,1.69207,1.7599 +GeForce RTX 3090,StokesI,4096,32,512,480,1,half,599785472,125829120,72.9564,71.4631,74.4623,10597.7,10382.4,10818.1,9.94682,9.74472,10.1537,2.12517,2.08199,2.16937,7.3595,7.20997,7.51256,1.72488,1.68984,1.76076 +GeForce RTX 3090,StokesI,4096,32,512,512,1,half,603979776,134217728,77.8912,77.2638,79.2562,10587.7,10404.7,10673,9.47796,9.31407,9.55425,2.025,1.98998,2.0413,6.89306,6.77387,6.94855,1.72326,1.69347,1.73714 +GeForce RTX 3090,StokesI,4096,32,512,544,1,half,608174080,142606336,82.7931,81.7661,84.2055,10583.4,10405.2,10715.6,9.06874,8.91605,9.18204,1.93757,1.90494,1.96177,6.48491,6.37572,6.56593,1.72255,1.69355,1.74408 +GeForce RTX 3090,StokesI,4096,32,512,576,1,half,612368384,150994944,87.6862,86.4479,89.1628,10580.8,10404.7,10731.5,8.70631,8.56145,8.83032,1.86013,1.82918,1.88663,6.12312,6.02124,6.21034,1.72213,1.69347,1.74666 +GeForce RTX 3090,StokesI,4096,32,512,608,1,half,616562688,159383552,92.613,91.8036,94.2558,10574.3,10389.3,10666.8,8.37893,8.23235,8.45225,1.79019,1.75887,1.80585,5.79732,5.69589,5.84804,1.72108,1.69097,1.73614 +GeForce RTX 3090,StokesI,4096,32,512,640,1,half,620756992,167772160,97.2714,95.9174,99.1314,10597.9,10398.2,10746.7,8.1071,7.95438,8.22091,1.73211,1.69948,1.75643,5.51973,5.41575,5.59722,1.72492,1.69242,1.74913 +GeForce RTX 3090,StokesI,4096,32,512,672,1,half,624951296,176160768,102.241,101.455,104.211,10586.8,10386,10668.1,7.83604,7.68741,7.89626,1.6742,1.64244,1.68706,5.25138,5.15177,5.29173,1.72311,1.69042,1.73635 +GeForce RTX 3090,StokesI,4096,32,512,704,1,half,629145600,184549376,107.242,106.278,108.989,10573.8,10403.5,10668.9,7.58802,7.46581,7.65628,1.6212,1.5951,1.63579,5.00653,4.9259,5.05156,1.72099,1.69328,1.73648 +GeForce RTX 3090,StokesI,4096,32,512,736,1,half,633339904,192937984,112.103,111.109,114.058,10574.9,10393,10668.9,7.37115,7.24435,7.43664,1.57487,1.54778,1.58886,4.78938,4.70699,4.83193,1.72118,1.69157,1.73647 +GeForce RTX 3090,StokesI,4096,32,512,768,1,half,637534208,201326592,116.975,115.931,119.03,10575.2,10392,10669.7,7.17176,7.0475,7.23584,1.53227,1.50572,1.54596,4.58993,4.5104,4.63094,1.72122,1.6914,1.7366 +GeForce RTX 3090,StokesI,4096,32,512,800,1,half,641728512,209715200,121.727,120.761,124.004,10585.9,10390.7,10669.7,6.99522,6.86628,7.05062,1.49455,1.467,1.50639,4.41078,4.32948,4.44571,1.72296,1.6912,1.73661 +GeForce RTX 3090,StokesI,4096,32,512,832,1,half,645922816,218103808,126.622,125.588,128.771,10583.4,10406.3,10670,6.82399,6.70977,6.87985,1.45797,1.43357,1.4699,4.24015,4.16918,4.27486,1.72256,1.69373,1.73666 +GeForce RTX 3090,StokesI,4096,32,512,864,1,half,650117120,226492416,131.545,130.433,133.405,10579.3,10431.2,10668.8,6.66435,6.57106,6.72076,1.42386,1.40393,1.43591,4.08152,4.02438,4.11606,1.72189,1.69779,1.73646 +GeForce RTX 3090,StokesI,4096,32,512,896,1,half,654311424,234881024,136.561,135.237,138.367,10568.1,10429.6,10671,6.51171,6.42634,6.57507,1.39125,1.37301,1.40478,3.9316,3.88005,3.96985,1.72008,1.69752,1.73681 +GeForce RTX 3090,StokesI,4096,32,512,928,1,half,658505728,243269632,141.475,140.058,143.526,10565.4,10413.8,10671.7,6.37447,6.28303,6.4386,1.36193,1.34239,1.37563,3.79503,3.74059,3.83321,1.71962,1.69496,1.73693 +GeForce RTX 3090,StokesI,4096,32,512,960,1,half,662700032,251658240,146.451,144.895,148.878,10558.3,10385.6,10671.1,6.24377,6.14167,6.31051,1.334,1.31219,1.34826,3.66607,3.60612,3.70525,1.71847,1.69037,1.73684 +GeForce RTX 3090,StokesI,4096,32,512,992,1,half,666894336,260046848,151.249,149.72,154.74,10564.2,10325.2,10671.4,6.12894,5.99032,6.19116,1.30947,1.27985,1.32276,3.5498,3.46951,3.58583,1.71943,1.68054,1.73689 +GeForce RTX 3090,StokesI,4096,32,512,1024,1,half,671088640,268435456,156.202,154.681,158.504,10559,10405.2,10662.4,6.01506,5.92744,6.07394,1.28514,1.26642,1.29772,3.43718,3.38711,3.47082,1.71859,1.69355,1.73541 +GeForce RTX 3090,StokesI,4096,32,1024,32,1,half,1082130432,8388608,9.9434,9.49325,10.3965,10370.4,9914.76,10858.2,109.713,104.892,114.873,23.4405,22.4106,24.543,108.025,103.279,113.106,0.843943,0.806865,0.883639 +GeForce RTX 3090,StokesI,4096,32,1024,64,1,half,1090519040,16777216,19.5015,18.7241,20.099,10572.9,10257.1,11010.3,56.7878,55.092,59.1376,12.1329,11.7706,12.6349,55.067,53.4225,57.3456,0.860422,0.834727,0.896024 +GeForce RTX 3090,StokesI,4096,32,1024,96,1,half,1098907648,25165824,29.4394,28.1102,30.3216,10507.4,10198.6,11000.9,38.1944,37.0717,39.9881,8.16035,7.92049,8.54359,36.4842,35.4118,38.1976,0.855098,0.829964,0.895256 +GeForce RTX 3090,StokesI,4096,32,1024,128,1,half,1107296256,33554432,39.0912,37.6498,39.9783,10549.4,10313.5,10951.4,29.1895,28.5367,30.3017,6.23644,6.09696,6.47405,27.4725,26.8581,28.5192,0.858515,0.839315,0.891226 +GeForce RTX 3090,StokesI,4096,32,1024,160,1,half,1115684864,41943040,48.7667,47.2042,50.3195,10570.4,10242.5,10918.4,23.742,23.0055,24.5238,5.07256,4.91521,5.23959,22.0216,21.3385,22.7467,0.860218,0.833534,0.888544 +GeForce RTX 3090,StokesI,4096,32,1024,192,1,half,1124073472,50331648,58.4261,56.7471,59.6278,10586.7,10372.3,10898.8,20.1028,19.6956,20.6954,4.29502,4.20803,4.42164,18.3797,18.0074,18.9215,0.861547,0.844097,0.886946 +GeForce RTX 3090,StokesI,4096,32,1024,224,1,half,1132462080,58720256,68.1082,66.1434,69.1615,10595,10432.9,10908.9,17.4909,17.2232,18.0091,3.73698,3.67979,3.8477,15.7664,15.5251,16.2335,0.862226,0.849031,0.887772 +GeForce RTX 3090,StokesI,4096,32,1024,256,1,half,1140850688,67108864,77.8979,76.3702,79.4079,10586.9,10384.8,10797.8,15.5081,15.2121,15.8172,3.31336,3.25011,3.37939,13.785,13.5218,14.0597,0.861561,0.845115,0.878731 +GeForce RTX 3090,StokesI,4096,32,1024,288,1,half,1149239296,75497472,87.6126,85.9283,89.3996,10589.7,10377.1,10796.4,13.9801,13.6996,14.253,2.9869,2.92696,3.0452,12.2566,12.0106,12.4958,0.861789,0.844494,0.87861 +GeForce RTX 3090,StokesI,4096,32,1024,320,1,half,1157627904,83886080,97.2095,96.2256,98.8739,10604.3,10425.3,10712.2,12.7721,12.5565,12.9021,2.72879,2.68275,2.75658,11.0461,10.8597,11.1586,0.862977,0.848415,0.871765 +GeForce RTX 3090,StokesI,4096,32,1024,352,1,half,1166016512,92274688,106.981,105.834,108.644,10599.4,10436.6,10713.7,11.7624,11.5818,11.8893,2.51308,2.47449,2.54019,10.0373,9.88312,10.1456,0.862579,0.849331,0.871884 +GeForce RTX 3090,StokesI,4096,32,1024,384,1,half,1174405120,100663296,116.643,115.374,119.079,10605.3,10387.6,10721.2,10.9321,10.7077,11.0516,2.33568,2.28774,2.3612,9.20599,9.01702,9.30658,0.863061,0.845345,0.872492 +GeForce RTX 3090,StokesI,4096,32,1024,416,1,half,1182793728,109051904,126.285,124.937,128.338,10611.6,10441.4,10725.6,10.2301,10.0659,10.3399,2.18569,2.15062,2.20916,8.50291,8.36649,8.59424,0.863577,0.849721,0.872853 +GeForce RTX 3090,StokesI,4096,32,1024,448,1,half,1191182336,117440512,136.066,134.562,137.837,10606.4,10469.7,10724.5,9.61797,9.49398,9.72509,2.05491,2.02842,2.0778,7.89167,7.78993,7.97956,0.863152,0.852023,0.872764 +GeForce RTX 3090,StokesI,4096,32,1024,480,1,half,1199570944,125829120,145.87,144.674,148.71,10600.2,10397.3,10687.4,9.08652,8.91266,9.16128,1.94136,1.90422,1.95734,7.36123,7.22038,7.4218,0.862644,0.846138,0.869742 +GeForce RTX 3090,StokesI,4096,32,1024,512,1,half,1207959552,134217728,155.661,154.063,158.371,10595.6,10413.9,10705.1,8.62276,8.47487,8.71185,1.84228,1.81068,1.86131,6.89821,6.77989,6.96948,0.862276,0.847487,0.871185 +GeForce RTX 3090,StokesI,4096,32,1024,544,1,half,1216348160,142606336,165.288,164.155,167.367,10602,10470.1,10674.9,8.22194,8.11961,8.27848,1.75664,1.73478,1.76872,6.49634,6.4155,6.54102,0.862796,0.852058,0.868729 +GeForce RTX 3090,StokesI,4096,32,1024,576,1,half,1224736768,150994944,174.84,172.824,176.349,10612.5,10521.4,10735.9,7.8688,7.8012,7.9603,1.6812,1.66675,1.70074,6.1415,6.08874,6.21291,0.863649,0.85623,0.873691 +GeForce RTX 3090,StokesI,4096,32,1024,608,1,half,1233125376,159383552,184.756,183.459,186.319,10600.7,10511.6,10675.4,7.53717,7.4738,7.59029,1.61034,1.5968,1.62169,5.81179,5.76293,5.85275,0.862688,0.855435,0.868768 +GeForce RTX 3090,StokesI,4096,32,1024,640,1,half,1241513984,167772160,194.766,193.403,196.824,10585.2,10474.3,10659.5,7.23595,7.16015,7.2868,1.54599,1.52979,1.55685,5.51311,5.45535,5.55185,0.861423,0.852399,0.867476 +GeForce RTX 3090,StokesI,4096,32,1024,672,1,half,1249902592,176160768,205.208,203.075,208.45,10549.1,10384.6,10659.4,6.94966,6.84129,7.02235,1.48482,1.46166,1.50035,5.23268,5.15109,5.28742,0.858487,0.8451,0.867467 +GeForce RTX 3090,StokesI,4096,32,1024,704,1,half,1258291200,184549376,215.518,213.975,219.307,10522.6,10340.5,10598.2,6.69497,6.5791,6.74302,1.4304,1.40565,1.44067,4.98231,4.89608,5.01806,0.856334,0.841513,0.86248 +GeForce RTX 3090,StokesI,4096,32,1024,736,1,half,1266679808,192937984,225.738,223.507,230.646,10503.1,10279.1,10607.4,6.46635,6.3284,6.53052,1.38156,1.35208,1.39527,4.75686,4.65537,4.80406,0.854748,0.836513,0.863229 +GeForce RTX 3090,StokesI,4096,32,1024,768,1,half,1275068416,201326592,235.606,233.133,239.913,10500.7,10311.6,10611.5,6.26672,6.15387,6.33284,1.3389,1.31479,1.35303,4.55761,4.47554,4.6057,0.854552,0.839164,0.863569 +GeForce RTX 3090,StokesI,4096,32,1024,800,1,half,1283457024,209715200,245.384,243.008,249.043,10502.3,10347.5,10604.5,6.0853,5.99564,6.14453,1.30014,1.28099,1.3128,4.37595,4.31147,4.41854,0.854677,0.842084,0.862996 +GeForce RTX 3090,StokesI,4096,32,1024,832,1,half,1291845632,218103808,255.314,252.514,258.471,10497.5,10368.9,10613.5,5.9143,5.84186,5.97966,1.26361,1.24813,1.27757,4.20573,4.15421,4.2522,0.854288,0.843825,0.863729 +GeForce RTX 3090,StokesI,4096,32,1024,864,1,half,1300234240,226492416,265.043,262.97,266.62,10500.8,10438.6,10583.5,5.76037,5.72623,5.80571,1.23072,1.22343,1.24041,4.05125,4.02724,4.08314,0.854561,0.849496,0.861287 +GeForce RTX 3090,StokesI,4096,32,1024,896,1,half,1308622848,234881024,275.196,272.384,276.542,10488,10436.8,10596.1,5.60884,5.58145,5.66665,1.19835,1.19249,1.2107,3.9018,3.88275,3.94202,0.853519,0.849351,0.862316 +GeForce RTX 3090,StokesI,4096,32,1024,928,1,half,1317011456,243269632,285.299,282.24,287.27,10477.9,10405.9,10591.3,5.46901,5.43142,5.52821,1.16847,1.16044,1.18112,3.76362,3.73775,3.80436,0.852695,0.846834,0.861926 +GeForce RTX 3090,StokesI,4096,32,1024,960,1,half,1325400064,251658240,295.109,292.483,297.142,10478.9,10407.1,10572.9,5.34405,5.30743,5.39197,1.14177,1.13395,1.15201,3.6385,3.61357,3.67113,0.852774,0.84693,0.860421 +GeForce RTX 3090,StokesI,4096,32,1024,992,1,half,1333788672,260046848,305.186,302.87,307.293,10470.7,10398.7,10550.6,5.22259,5.1867,5.26244,1.11582,1.10816,1.12434,3.51837,3.4942,3.54522,0.852106,0.846251,0.858609 +GeForce RTX 3090,StokesI,4096,32,1024,1024,1,half,1342177280,268435456,315.05,312.525,318.868,10470.1,10344.5,10554.5,5.11235,5.05103,5.15355,1.09227,1.07917,1.10107,3.40823,3.36735,3.4357,0.852058,0.841839,0.858925 diff --git a/psrdada_cpp/cryopaf/profiling/Results/3090/unpacker_kernel.csv b/psrdada_cpp/cryopaf/profiling/Results/3090/unpacker_kernel.csv new file mode 100644 index 0000000000000000000000000000000000000000..e3d2779b2f3cf79e48f506bab43225bebb8adf4f --- /dev/null +++ b/psrdada_cpp/cryopaf/profiling/Results/3090/unpacker_kernel.csv @@ -0,0 +1,225 @@ +devicename,kernelname,samples,channels,elements,beams,integration,precision,reads,writes,avg_time,min_time,max_time,avg_throughput,min_throughput,max_throughput,avg_bandwidth,min_bandwidth,max_bandwidth,percentage_avg_bandwidth,percentage_min_bandwidth,percentage_max_bandwidth,input_avg_bandwidth,input_min_bandwidth,input_max_bandwidth,output_avg_bandwidth,output_min_bandwidth,output_max_bandwidth +GeForce RTX 3090,Unpacker,4096,32,16,32,1,half,134217728,16777216,0.001592,0.001472,0.002112,2656.71,1985.94,2849.39,95641.4,71493.8,102578,20434.1,15274.9,21916.1,85014.6,63550.1,91180.5,10626.8,7943.76,11397.6 +GeForce RTX 3090,Unpacker,4096,32,16,64,1,half,134217728,16777216,0.0014992,0.001472,0.001728,2804.15,2427.26,2849.39,100949,87381.3,102578,21568.1,18669.3,21916.1,89732.7,77672.3,91180.5,11216.6,9709.04,11397.6 +GeForce RTX 3090,Unpacker,4096,32,16,96,1,half,134217728,16777216,0.0015072,0.00144,0.001728,2790.31,2427.26,2912.71,100451,87381.3,104858,21461.8,18669.3,22403.2,89290,77672.3,93206.8,11161.3,9709.04,11650.8 +GeForce RTX 3090,Unpacker,4096,32,16,128,1,half,134217728,16777216,0.0015856,0.001472,0.001984,2663.94,2114.06,2849.39,95902,76106.3,102578,20489.8,16260.4,21916.1,85246.2,67650.1,91180.5,10655.8,8456.26,11397.6 +GeForce RTX 3090,Unpacker,4096,32,16,160,1,half,134217728,16777216,0.0014944,0.00144,0.001728,2813.78,2427.26,2912.71,101296,87381.3,104858,21642.2,18669.3,22403.2,90040.9,77672.3,93206.8,11255.1,9709.04,11650.8 +GeForce RTX 3090,Unpacker,4096,32,16,192,1,half,134217728,16777216,0.0015088,0.00144,0.001824,2791.3,2299.51,2912.71,100487,82782.3,104858,21469.3,17686.7,22403.2,89321.5,73584.3,93206.8,11165.2,9198.04,11650.8 +GeForce RTX 3090,Unpacker,4096,32,16,224,1,half,134217728,16777216,0.0014976,0.00144,0.001696,2806.83,2473.06,2912.71,101046,89030,104858,21588.8,19021.6,22403.2,89818.5,79137.8,93206.8,11227.3,9892.23,11650.8 +GeForce RTX 3090,Unpacker,4096,32,16,256,1,half,134217728,16777216,0.0014912,0.00144,0.001728,2817.48,2427.26,2912.71,101429,87381.3,104858,21670.7,18669.3,22403.2,90159.5,77672.3,93206.8,11269.9,9709.04,11650.8 +GeForce RTX 3090,Unpacker,4096,32,16,288,1,half,134217728,16777216,0.00148,0.001408,0.00176,2840.19,2383.13,2978.91,102247,85792.6,107241,21845.4,18329.9,22912.3,90886.1,76260.1,95325.1,11360.8,9532.51,11915.6 +GeForce RTX 3090,Unpacker,4096,32,16,320,1,half,134217728,16777216,0.0015168,0.00144,0.001824,2776.55,2299.51,2912.71,99955.7,82782.3,104858,21355.9,17686.7,22403.2,88849.5,73584.3,93206.8,11106.2,9198.04,11650.8 +GeForce RTX 3090,Unpacker,4096,32,16,352,1,half,134217728,16777216,0.0014976,0.001408,0.001728,2813,2427.26,2978.91,101268,87381.3,107241,21636.2,18669.3,22912.3,90015.9,77672.3,95325.1,11252,9709.04,11915.6 +GeForce RTX 3090,Unpacker,4096,32,16,384,1,half,134217728,16777216,0.0015104,0.00144,0.001792,2784.84,2340.57,2912.71,100254,84260.6,104858,21419.6,18002.5,22403.2,89114.8,74898.3,93206.8,11139.3,9362.29,11650.8 +GeForce RTX 3090,Unpacker,4096,32,16,416,1,half,134217728,16777216,0.0014592,0.001408,0.001792,2882.97,2340.57,2978.91,103787,84260.6,107241,22174.4,18002.5,22912.3,92255.1,74898.3,95325.1,11531.9,9362.29,11915.6 +GeForce RTX 3090,Unpacker,4096,32,16,448,1,half,134217728,16777216,0.0014272,0.001344,0.00176,2958.32,2383.13,3120.76,106500,85792.6,112347,22754,18329.9,24003.4,94666.2,76260.1,99864.4,11833.3,9532.51,12483 +GeForce RTX 3090,Unpacker,4096,32,16,480,1,half,134217728,16777216,0.0014592,0.001344,0.001728,2885.98,2427.26,3120.76,103895,87381.3,112347,22197.6,18669.3,24003.4,92351.3,77672.3,99864.4,11543.9,9709.04,12483 +GeForce RTX 3090,Unpacker,4096,32,16,512,1,half,134217728,16777216,0.0014304,0.001376,0.001664,2938.98,2520.62,3048.19,105803,90742.2,109735,22605.2,19387.4,23445.2,94047.4,80659.7,97542,11755.9,10082.5,12192.7 +GeForce RTX 3090,Unpacker,4096,32,16,544,1,half,134217728,16777216,0.0014288,0.001344,0.001696,2942.51,2473.06,3120.76,105930,89030,112347,22632.4,19021.6,24003.4,94160.3,79137.8,99864.4,11770,9892.23,12483 +GeForce RTX 3090,Unpacker,4096,32,16,576,1,half,134217728,16777216,0.001408,0.001344,0.001536,2984.02,2730.67,3120.76,107425,98304,112347,22951.7,21003,24003.4,95488.7,87381.3,99864.4,11936.1,10922.7,12483 +GeForce RTX 3090,Unpacker,4096,32,16,608,1,half,134217728,16777216,0.0014512,0.001376,0.001984,2909.65,2114.06,3048.19,104748,76106.3,109735,22379.7,16260.4,23445.2,93108.9,67650.1,97542,11638.6,8456.26,12192.7 +GeForce RTX 3090,Unpacker,4096,32,16,640,1,half,134217728,16777216,0.0013968,0.001344,0.001568,3009.48,2674.94,3120.76,108341,96297.8,112347,23147.5,20574.3,24003.4,96303.3,85598,99864.4,12037.9,10699.8,12483 +GeForce RTX 3090,Unpacker,4096,32,16,672,1,half,134217728,16777216,0.0014048,0.001376,0.001568,2987.96,2674.94,3048.19,107566,96297.8,109735,22981.9,20574.3,23445.2,95614.6,85598,97542,11951.8,10699.8,12192.7 +GeForce RTX 3090,Unpacker,4096,32,16,704,1,half,134217728,16777216,0.0013952,0.001376,0.001408,3006.62,2978.91,3048.19,108238,107241,109735,23125.5,22912.3,23445.2,96211.8,95325.1,97542,12026.5,11915.6,12192.7 +GeForce RTX 3090,Unpacker,4096,32,16,736,1,half,134217728,16777216,0.0013856,0.001344,0.001664,3036.76,2520.62,3120.76,109323,90742.2,112347,23357.3,19387.4,24003.4,97176.3,80659.7,99864.4,12147,10082.5,12483 +GeForce RTX 3090,Unpacker,4096,32,16,768,1,half,134217728,16777216,0.0014256,0.001344,0.001728,2954.88,2427.26,3120.76,106376,87381.3,112347,22727.5,18669.3,24003.4,94556.2,77672.3,99864.4,11819.5,9709.04,12483 +GeForce RTX 3090,Unpacker,4096,32,16,800,1,half,134217728,16777216,0.0014192,0.001344,0.00176,2968.95,2383.13,3120.76,106882,85792.6,112347,22835.7,18329.9,24003.4,95006.4,76260.1,99864.4,11875.8,9532.51,12483 +GeForce RTX 3090,Unpacker,4096,32,16,832,1,half,134217728,16777216,0.0014384,0.001376,0.00176,2928.25,2383.13,3048.19,105417,85792.6,109735,22522.7,18329.9,23445.2,93704.1,76260.1,97542,11713,9532.51,12192.7 +GeForce RTX 3090,Unpacker,4096,32,16,864,1,half,134217728,16777216,0.001424,0.001344,0.001824,2961.92,2299.51,3120.76,106629,82782.3,112347,22781.7,17686.7,24003.4,94781.6,73584.3,99864.4,11847.7,9198.04,12483 +GeForce RTX 3090,Unpacker,4096,32,16,896,1,half,134217728,16777216,0.001392,0.001344,0.00176,3023.3,2383.13,3120.76,108839,85792.6,112347,23253.8,18329.9,24003.4,96745.7,76260.1,99864.4,12093.2,9532.51,12483 +GeForce RTX 3090,Unpacker,4096,32,16,928,1,half,134217728,16777216,0.0013792,0.001344,0.001472,3042.04,2849.39,3120.76,109513,102578,112347,23397.9,21916.1,24003.4,97345.3,91180.5,99864.4,12168.2,11397.6,12483 +GeForce RTX 3090,Unpacker,4096,32,16,960,1,half,134217728,16777216,0.0014256,0.001344,0.001696,2952.79,2473.06,3120.76,106300,89030,112347,22711.4,19021.6,24003.4,94489.1,79137.8,99864.4,11811.1,9892.23,12483 +GeForce RTX 3090,Unpacker,4096,32,16,992,1,half,134217728,16777216,0.0013936,0.001344,0.0016,3014.53,2621.44,3120.76,108523,94371.8,112347,23186.3,20162.9,24003.4,96464.9,83886.1,99864.4,12058.1,10485.8,12483 +GeForce RTX 3090,Unpacker,4096,32,16,1024,1,half,134217728,16777216,0.0014064,0.001376,0.001472,2983.58,2849.39,3048.19,107409,102578,109735,22948.3,21916.1,23445.2,95474.7,91180.5,97542,11934.3,11397.6,12192.7 +GeForce RTX 3090,Unpacker,4096,32,32,32,1,half,268435456,33554432,0.0014256,0.001344,0.001696,5902.15,4946.11,6241.52,212478,178060,224695,45396.5,38043.1,48006.8,188869,158276,199729,23608.6,19784.5,24966.1 +GeForce RTX 3090,Unpacker,4096,32,32,64,1,half,268435456,33554432,0.0013936,0.001344,0.001728,6045.5,4854.52,6241.52,217638,174763,224695,46499,37338.6,48006.8,193456,155345,199729,24182,19418.1,24966.1 +GeForce RTX 3090,Unpacker,4096,32,32,96,1,half,268435456,33554432,0.0014096,0.001376,0.001536,5959.55,5461.33,6096.37,214544,196608,219469,45838,42005.9,46890.4,190706,174763,195084,23838.2,21845.3,24385.5 +GeForce RTX 3090,Unpacker,4096,32,32,128,1,half,268435456,33554432,0.0013696,0.001344,0.001472,6128.26,5698.78,6241.52,220617,205156,224695,47135.7,43832.3,48006.8,196104,182361,199729,24513.1,22795.1,24966.1 +GeForce RTX 3090,Unpacker,4096,32,32,160,1,half,268435456,33554432,0.001432,0.001376,0.001856,5891.06,4519.72,6096.37,212078,162710,219469,45311.2,34763.5,46890.4,188514,144631,195084,23564.2,18078.9,24385.5 +GeForce RTX 3090,Unpacker,4096,32,32,192,1,half,268435456,33554432,0.0013904,0.001344,0.001632,6045.42,5140.08,6241.52,217635,185043,224695,46498.4,39535,48006.8,193453,164483,199729,24181.7,20560.3,24966.1 +GeForce RTX 3090,Unpacker,4096,32,32,224,1,half,268435456,33554432,0.0014656,0.001376,0.001728,5747,4854.52,6096.37,206892,174763,219469,44203.1,37338.6,46890.4,183904,155345,195084,22988,19418.1,24385.5 +GeForce RTX 3090,Unpacker,4096,32,32,256,1,half,268435456,33554432,0.0014016,0.001344,0.001632,5997.14,5140.08,6241.52,215897,185043,224695,46127.1,39535,48006.8,191909,164483,199729,23988.6,20560.3,24966.1 +GeForce RTX 3090,Unpacker,4096,32,32,288,1,half,268435456,33554432,0.0013696,0.001344,0.001472,6127.96,5698.78,6241.52,220606,205156,224695,47133.3,43832.3,48006.8,196095,182361,199729,24511.8,22795.1,24966.1 +GeForce RTX 3090,Unpacker,4096,32,32,320,1,half,268435456,33554432,0.001472,0.001408,0.00176,5724.23,4766.25,5957.82,206072,171585,214481,44028,36659.7,45824.7,183175,152520,190650,22896.9,19065,23831.3 +GeForce RTX 3090,Unpacker,4096,32,32,352,1,half,268435456,33554432,0.0014128,0.001376,0.001568,5941.89,5349.88,6096.37,213908,192596,219469,45702.2,41148.7,46890.4,190141,171196,195084,23767.6,21399.5,24385.5 +GeForce RTX 3090,Unpacker,4096,32,32,384,1,half,268435456,33554432,0.0014336,0.001376,0.001632,5863.11,5140.08,6096.37,211072,185043,219469,45096.2,39535,46890.4,187620,164483,195084,23452.5,20560.3,24385.5 +GeForce RTX 3090,Unpacker,4096,32,32,416,1,half,268435456,33554432,0.0014256,0.001344,0.001728,5916.38,4854.52,6241.52,212990,174763,224695,45505.9,37338.6,48006.8,189324,155345,199729,23665.5,19418.1,24966.1 +GeForce RTX 3090,Unpacker,4096,32,32,448,1,half,268435456,33554432,0.001464,0.001408,0.001664,5747.21,5041.23,5957.82,206900,181484,214481,44204.8,38774.7,45824.7,183911,161319,190650,22988.8,20164.9,23831.3 +GeForce RTX 3090,Unpacker,4096,32,32,480,1,half,268435456,33554432,0.0014208,0.001376,0.001728,5917.72,4854.52,6096.37,213038,174763,219469,45516.3,37338.6,46890.4,189367,155345,195084,23670.9,19418.1,24385.5 +GeForce RTX 3090,Unpacker,4096,32,32,512,1,half,268435456,33554432,0.0014,0.001344,0.0016,6001.65,5242.88,6241.52,216059,188744,224695,46161.8,40325.7,48006.8,192053,167772,199729,24006.6,20971.5,24966.1 +GeForce RTX 3090,Unpacker,4096,32,32,544,1,half,268435456,33554432,0.0014112,0.001344,0.001632,5962.92,5140.08,6241.52,214665,185043,224695,45863.9,39535,48006.8,190813,164483,199729,23851.7,20560.3,24966.1 +GeForce RTX 3090,Unpacker,4096,32,32,576,1,half,268435456,33554432,0.0014,0.001344,0.001472,5997.35,5698.78,6241.52,215904,205156,224695,46128.7,43832.3,48006.8,191915,182361,199729,23989.4,22795.1,24966.1 +GeForce RTX 3090,Unpacker,4096,32,32,608,1,half,268435456,33554432,0.0014208,0.001344,0.001632,5918.82,5140.08,6241.52,213077,185043,224695,45524.7,39535,48006.8,189402,164483,199729,23675.3,20560.3,24966.1 +GeForce RTX 3090,Unpacker,4096,32,32,640,1,half,268435456,33554432,0.0014256,0.001344,0.001696,5906.79,4946.11,6241.52,212644,178060,224695,45432.2,38043.1,48006.8,189017,158276,199729,23627.2,19784.5,24966.1 +GeForce RTX 3090,Unpacker,4096,32,32,672,1,half,268435456,33554432,0.0014352,0.001376,0.001664,5857.8,5041.23,6096.37,210881,181484,219469,45055.4,38774.7,46890.4,187450,161319,195084,23431.2,20164.9,24385.5 +GeForce RTX 3090,Unpacker,4096,32,32,704,1,half,268435456,33554432,0.001416,0.001344,0.001664,5935.77,5041.23,6241.52,213688,181484,224695,45655.1,38774.7,48006.8,189945,161319,199729,23743.1,20164.9,24966.1 +GeForce RTX 3090,Unpacker,4096,32,32,736,1,half,268435456,33554432,0.0014256,0.001376,0.0016,5893.75,5242.88,6096.37,212175,188744,219469,45331.9,40325.7,46890.4,188600,167772,195084,23575,20971.5,24385.5 +GeForce RTX 3090,Unpacker,4096,32,32,768,1,half,268435456,33554432,0.0013952,0.001344,0.001632,6023.64,5140.08,6241.52,216851,185043,224695,46331,39535,48006.8,192757,164483,199729,24094.6,20560.3,24966.1 +GeForce RTX 3090,Unpacker,4096,32,32,800,1,half,268435456,33554432,0.0014128,0.001376,0.001632,5950.69,5140.08,6096.37,214225,185043,219469,45769.8,39535,46890.4,190422,164483,195084,23802.8,20560.3,24385.5 +GeForce RTX 3090,Unpacker,4096,32,32,832,1,half,268435456,33554432,0.0013856,0.001344,0.001472,6057.27,5698.78,6241.52,218062,205156,224695,46589.6,43832.3,48006.8,193833,182361,199729,24229.1,22795.1,24966.1 +GeForce RTX 3090,Unpacker,4096,32,32,864,1,half,268435456,33554432,0.0014176,0.001376,0.001632,5928.34,5140.08,6096.37,213420,185043,219469,45597.9,39535,46890.4,189707,164483,195084,23713.4,20560.3,24385.5 +GeForce RTX 3090,Unpacker,4096,32,32,896,1,half,268435456,33554432,0.0014144,0.001344,0.001664,5943.64,5041.23,6241.52,213971,181484,224695,45715.6,38774.7,48006.8,190197,161319,199729,23774.6,20164.9,24966.1 +GeForce RTX 3090,Unpacker,4096,32,32,928,1,half,268435456,33554432,0.0014016,0.001344,0.0016,5995.58,5242.88,6241.52,215841,188744,224695,46115.1,40325.7,48006.8,191859,167772,199729,23982.3,20971.5,24966.1 +GeForce RTX 3090,Unpacker,4096,32,32,960,1,half,268435456,33554432,0.0014,0.001344,0.001664,6003.28,5041.23,6241.52,216118,181484,224695,46174.4,38774.7,48006.8,192105,161319,199729,24013.1,20164.9,24966.1 +GeForce RTX 3090,Unpacker,4096,32,32,992,1,half,268435456,33554432,0.0014432,0.001376,0.001696,5832.84,4946.11,6096.37,209982,178060,219469,44863.4,38043.1,46890.4,186651,158276,195084,23331.3,19784.5,24385.5 +GeForce RTX 3090,Unpacker,4096,32,32,1024,1,half,268435456,33554432,0.0013984,0.001344,0.001536,6004.78,5461.33,6241.52,216172,196608,224695,46185.9,42005.9,48006.8,192153,174763,199729,24019.1,21845.3,24966.1 +GeForce RTX 3090,Unpacker,4096,32,64,32,1,half,536870912,67108864,0.0013824,0.001344,0.001632,12159,10280.2,12483,437723,370086,449390,93520.9,79070,96013.6,389087,328965,399458,48635.8,41120.6,49932.2 +GeForce RTX 3090,Unpacker,4096,32,64,64,1,half,536870912,67108864,0.0013872,0.001344,0.001568,12114.6,10699.8,12483,436125,385191,449390,93179.6,82297.4,96013.6,387667,342392,399458,48458.3,42799,49932.2 +GeForce RTX 3090,Unpacker,4096,32,64,96,1,half,536870912,67108864,0.0013648,0.001344,0.001376,12294.4,12192.7,12483,442597,438939,449390,94562.2,93780.7,96013.6,393419,390168,399458,49177.4,48771,49932.2 +GeForce RTX 3090,Unpacker,4096,32,64,128,1,half,536870912,67108864,0.0014448,0.001376,0.001664,11640.1,10082.5,12192.7,419044,362969,438939,89530.2,77549.4,93780.7,372484,322639,390168,46560.5,40329.8,48771 +GeForce RTX 3090,Unpacker,4096,32,64,160,1,half,536870912,67108864,0.0013872,0.001344,0.0016,12110.7,10485.8,12483,435983,377487,449390,93149.3,80651.4,96013.6,387541,335544,399458,48442.6,41943,49932.2 +GeForce RTX 3090,Unpacker,4096,32,64,192,1,half,536870912,67108864,0.0014176,0.001376,0.001568,11858,10699.8,12192.7,426886,385191,438939,91205.7,82297.4,93780.7,379454,342392,390168,47431.8,42799,48771 +GeForce RTX 3090,Unpacker,4096,32,64,224,1,half,536870912,67108864,0.0014656,0.001376,0.001856,11516.3,9039.45,12192.7,414587,325420,438939,88577.8,69527.1,93780.7,368522,289262,390168,46065.2,36157.8,48771 +GeForce RTX 3090,Unpacker,4096,32,64,256,1,half,536870912,67108864,0.0014112,0.001376,0.001632,11914.7,10280.2,12192.7,428929,370086,438939,91642,79070,93780.7,381270,328965,390168,47658.7,41120.6,48771 +GeForce RTX 3090,Unpacker,4096,32,64,288,1,half,536870912,67108864,0.0013968,0.001344,0.0016,12030.9,10485.8,12483,433113,377487,449390,92536.1,80651.4,96013.6,384990,335544,399458,48123.7,41943,49932.2 +GeForce RTX 3090,Unpacker,4096,32,64,320,1,half,536870912,67108864,0.0013968,0.001344,0.0016,12040.3,10485.8,12483,433452,377487,449390,92608.6,80651.4,96013.6,385291,335544,399458,48161.4,41943,49932.2 +GeForce RTX 3090,Unpacker,4096,32,64,352,1,half,536870912,67108864,0.0014048,0.001344,0.001696,11974.2,9892.23,12483,431070,356120,449390,92099.4,76086.2,96013.6,383173,316551,399458,47896.6,39568.9,49932.2 +GeForce RTX 3090,Unpacker,4096,32,64,384,1,half,536870912,67108864,0.0013856,0.001376,0.001472,12112,11397.6,12192.7,436033,410312,438939,93159.9,87664.6,93780.7,387585,364722,390168,48448.1,45590.3,48771 +GeForce RTX 3090,Unpacker,4096,32,64,416,1,half,536870912,67108864,0.001392,0.001344,0.001568,12067.6,10699.8,12483,434434,385191,449390,92818.2,82297.4,96013.6,386163,342392,399458,48270.4,42799,49932.2 +GeForce RTX 3090,Unpacker,4096,32,64,448,1,half,536870912,67108864,0.0014112,0.001344,0.001632,11918.7,10280.2,12483,429073,370086,449390,91672.9,79070,96013.6,381398,328965,399458,47674.8,41120.6,49932.2 +GeForce RTX 3090,Unpacker,4096,32,64,480,1,half,536870912,67108864,0.0013936,0.001376,0.0016,12053.8,10485.8,12192.7,433936,377487,438939,92711.9,80651.4,93780.7,385721,335544,390168,48215.1,41943,48771 +GeForce RTX 3090,Unpacker,4096,32,64,512,1,half,536870912,67108864,0.0013792,0.001344,0.001536,12174.1,10922.7,12483,438268,393216,449390,93637.4,84011.9,96013.6,389571,349525,399458,48696.4,43690.7,49932.2 +GeForce RTX 3090,Unpacker,4096,32,64,544,1,half,536870912,67108864,0.0013872,0.001344,0.001504,12104.4,11155.1,12483,435757,401582,449390,93100.9,85799.4,96013.6,387339,356962,399458,48417.4,44620.3,49932.2 +GeForce RTX 3090,Unpacker,4096,32,64,576,1,half,536870912,67108864,0.0014208,0.001344,0.001824,11866.7,9198.04,12483,427200,331129,449390,91272.8,70746.9,96013.6,379734,294337,399458,47466.7,36792.1,49932.2 +GeForce RTX 3090,Unpacker,4096,32,64,608,1,half,536870912,67108864,0.0013952,0.001344,0.001504,12035.6,11155.1,12483,433280,401582,449390,92571.8,85799.4,96013.6,385138,356962,399458,48142.3,44620.3,49932.2 +GeForce RTX 3090,Unpacker,4096,32,64,640,1,half,536870912,67108864,0.0014096,0.001376,0.001536,11914.6,10922.7,12192.7,428924,393216,438939,91641.1,84011.9,93780.7,381266,349525,390168,47658.2,43690.7,48771 +GeForce RTX 3090,Unpacker,4096,32,64,672,1,half,536870912,67108864,0.001432,0.001344,0.001664,11752.5,10082.5,12483,423091,362969,449390,90394.7,77549.4,96013.6,376080,322639,399458,47010.1,40329.8,49932.2 +GeForce RTX 3090,Unpacker,4096,32,64,704,1,half,536870912,67108864,0.0013936,0.001344,0.001568,12053.2,10699.8,12483,433916,385191,449390,92707.6,82297.4,96013.6,385703,342392,399458,48212.9,42799,49932.2 +GeForce RTX 3090,Unpacker,4096,32,64,736,1,half,536870912,67108864,0.0014192,0.001344,0.001824,11868.4,9198.04,12483,427264,331129,449390,91286.3,70746.9,96013.6,379790,294337,399458,47473.8,36792.1,49932.2 +GeForce RTX 3090,Unpacker,4096,32,64,768,1,half,536870912,67108864,0.0013904,0.001376,0.001472,12073.5,11397.6,12192.7,434645,410312,438939,92863.3,87664.6,93780.7,386351,364722,390168,48293.9,45590.3,48771 +GeForce RTX 3090,Unpacker,4096,32,64,800,1,half,536870912,67108864,0.0014112,0.001344,0.0016,11914.5,10485.8,12483,428921,377487,449390,91640.4,80651.4,96013.6,381263,335544,399458,47657.9,41943,49932.2 +GeForce RTX 3090,Unpacker,4096,32,64,832,1,half,536870912,67108864,0.0013936,0.001344,0.001504,12051.3,11155.1,12483,433846,401582,449390,92692.6,85799.4,96013.6,385641,356962,399458,48205.1,44620.3,49932.2 +GeForce RTX 3090,Unpacker,4096,32,64,864,1,half,536870912,67108864,0.0014192,0.001376,0.001696,11851.7,9892.23,12192.7,426660,356120,438939,91157.4,76086.2,93780.7,379254,316551,390168,47406.7,39568.9,48771 +GeForce RTX 3090,Unpacker,4096,32,64,896,1,half,536870912,67108864,0.0014016,0.001344,0.001696,12001,9892.23,12483,432037,356120,449390,92306.1,76086.2,96013.6,384033,316551,399458,48004.1,39568.9,49932.2 +GeForce RTX 3090,Unpacker,4096,32,64,928,1,half,536870912,67108864,0.001424,0.001344,0.001632,11810.5,10280.2,12483,425177,370086,449390,90840.5,79070,96013.6,377935,328965,399458,47241.9,41120.6,49932.2 +GeForce RTX 3090,Unpacker,4096,32,64,960,1,half,536870912,67108864,0.0014176,0.001344,0.001568,11856.5,10699.8,12483,426834,385191,449390,91194.4,82297.4,96013.6,379408,342392,399458,47426,42799,49932.2 +GeForce RTX 3090,Unpacker,4096,32,64,992,1,half,536870912,67108864,0.0014464,0.001376,0.001728,11651.4,9709.04,12192.7,419450,349525,438939,89617,74677.2,93780.7,372845,310689,390168,46605.6,38836.1,48771 +GeForce RTX 3090,Unpacker,4096,32,64,1024,1,half,536870912,67108864,0.0014192,0.001344,0.001696,11859.1,9892.23,12483,426928,356120,449390,91214.6,76086.2,96013.6,379492,316551,399458,47436.5,39568.9,49932.2 +GeForce RTX 3090,Unpacker,4096,32,128,32,1,half,1073741824,134217728,0.0014288,0.001344,0.001856,23614.2,18078.9,24966.1,850110,650840,898779,181629,139054,192027,755653,578525,798915,94456.6,72315.6,99864.4 +GeForce RTX 3090,Unpacker,4096,32,128,64,1,half,1073741824,134217728,0.0013952,0.001344,0.001504,24087.2,22310.1,24966.1,867139,803165,898779,185267,171599,192027,770790,713924,798915,96348.8,89240.5,99864.4 +GeForce RTX 3090,Unpacker,4096,32,128,96,1,half,1073741824,134217728,0.001392,0.001344,0.001472,24120.5,22795.1,24966.1,868340,820625,898779,185524,175329,192027,771857,729444,798915,96482.2,91180.5,99864.4 +GeForce RTX 3090,Unpacker,4096,32,128,128,1,half,1073741824,134217728,0.001392,0.001376,0.001632,24138.8,20560.3,24385.5,868997,740171,877878,185664,158140,187561,772442,657930,780336,96555.2,82241.3,97542 +GeForce RTX 3090,Unpacker,4096,32,128,160,1,half,1073741824,134217728,0.0013872,0.001344,0.001472,24205.3,22795.1,24966.1,871389,820625,898779,186175,175329,192027,774568,729444,798915,96821,91180.5,99864.4 +GeForce RTX 3090,Unpacker,4096,32,128,192,1,half,1073741824,134217728,0.001392,0.001344,0.001568,24132.8,21399.5,24966.1,868782,770382,898779,185618,164595,192027,772251,684784,798915,96531.3,85598,99864.4 +GeForce RTX 3090,Unpacker,4096,32,128,224,1,half,1073741824,134217728,0.0014416,0.001344,0.001792,23413.8,18724.6,24966.1,842897,674085,898779,180088,144020,192027,749242,599186,798915,93655.2,74898.3,99864.4 +GeForce RTX 3090,Unpacker,4096,32,128,256,1,half,1073741824,134217728,0.001408,0.001376,0.001504,23848,22310.1,24385.5,858529,803165,877878,183428,171599,187561,763137,713924,780336,95392.2,89240.5,97542 +GeForce RTX 3090,Unpacker,4096,32,128,288,1,half,1073741824,134217728,0.0014368,0.001344,0.001696,23460.5,19784.5,24966.1,844578,712240,898779,180447,152172,192027,750736,633102,798915,93842,79137.8,99864.4 +GeForce RTX 3090,Unpacker,4096,32,128,320,1,half,1073741824,134217728,0.0013984,0.001376,0.001664,24047.5,20164.9,24385.5,865708,725937,877878,184961,155099,187561,769518,645278,780336,96189.8,80659.7,97542 +GeForce RTX 3090,Unpacker,4096,32,128,352,1,half,1073741824,134217728,0.0014416,0.001344,0.00176,23384.1,19065,24966.1,841829,686341,898779,179860,146639,192027,748293,610081,798915,93536.6,76260.1,99864.4 +GeForce RTX 3090,Unpacker,4096,32,128,384,1,half,1073741824,134217728,0.0013984,0.001376,0.001472,24007.2,22795.1,24385.5,864260,820625,877878,184652,175329,187561,768231,729444,780336,96028.9,91180.5,97542 +GeForce RTX 3090,Unpacker,4096,32,128,416,1,half,1073741824,134217728,0.0014112,0.001344,0.001696,23864.5,19784.5,24966.1,859123,712240,898779,183554,152172,192027,763665,633102,798915,95458.1,79137.8,99864.4 +GeForce RTX 3090,Unpacker,4096,32,128,448,1,half,1073741824,134217728,0.0013936,0.001344,0.0016,24111.4,20971.5,24966.1,868012,754975,898779,185454,161303,192027,771566,671089,798915,96445.7,83886.1,99864.4 +GeForce RTX 3090,Unpacker,4096,32,128,480,1,half,1073741824,134217728,0.0014144,0.001376,0.00176,23811,19065,24385.5,857195,686341,877878,183143,146639,187561,761951,610081,780336,95243.9,76260.1,97542 +GeForce RTX 3090,Unpacker,4096,32,128,512,1,half,1073741824,134217728,0.0014304,0.001376,0.001696,23546.7,19784.5,24385.5,847680,712240,877878,181110,152172,187561,753493,633102,780336,94186.6,79137.8,97542 +GeForce RTX 3090,Unpacker,4096,32,128,544,1,half,1073741824,134217728,0.0014176,0.001344,0.001696,23726.7,19784.5,24966.1,854161,712240,898779,182494,152172,192027,759254,633102,798915,94906.8,79137.8,99864.4 +GeForce RTX 3090,Unpacker,4096,32,128,576,1,half,1073741824,134217728,0.0014064,0.001376,0.0016,23890.7,20971.5,24385.5,860066,754975,877878,183756,161303,187561,764503,671089,780336,95562.9,83886.1,97542 +GeForce RTX 3090,Unpacker,4096,32,128,608,1,half,1073741824,134217728,0.0014416,0.001376,0.001696,23376,19784.5,24385.5,841537,712240,877878,179797,152172,187561,748033,633102,780336,93504.1,79137.8,97542 +GeForce RTX 3090,Unpacker,4096,32,128,640,1,half,1073741824,134217728,0.0014384,0.001376,0.001632,23398.5,20560.3,24385.5,842348,740171,877878,179970,158140,187561,748754,657930,780336,93594.2,82241.3,97542 +GeForce RTX 3090,Unpacker,4096,32,128,672,1,half,1073741824,134217728,0.0014224,0.001376,0.001728,23689,19418.1,24385.5,852804,699051,877878,182204,149354,187561,758048,621378,780336,94756,77672.3,97542 +GeForce RTX 3090,Unpacker,4096,32,128,704,1,half,1073741824,134217728,0.0014112,0.001376,0.0016,23816.9,20971.5,24385.5,857408,754975,877878,183188,161303,187561,762141,671089,780336,95267.6,83886.1,97542 +GeForce RTX 3090,Unpacker,4096,32,128,736,1,half,1073741824,134217728,0.0014128,0.001376,0.001504,23772.1,22310.1,24385.5,855797,803165,877878,182844,171599,187561,760708,713924,780336,95088.5,89240.5,97542 +GeForce RTX 3090,Unpacker,4096,32,128,768,1,half,1073741824,134217728,0.001408,0.001376,0.001664,23874.5,20164.9,24385.5,859482,725937,877878,183631,155099,187561,763984,645278,780336,95498,80659.7,97542 +GeForce RTX 3090,Unpacker,4096,32,128,800,1,half,1073741824,134217728,0.0014112,0.001376,0.0016,23813.6,20971.5,24385.5,857289,754975,877878,183163,161303,187561,762035,671089,780336,95254.3,83886.1,97542 +GeForce RTX 3090,Unpacker,4096,32,128,832,1,half,1073741824,134217728,0.0014048,0.001376,0.001728,23950.4,19418.1,24385.5,862213,699051,877878,184215,149354,187561,766412,621378,780336,95801.5,77672.3,97542 +GeForce RTX 3090,Unpacker,4096,32,128,864,1,half,1073741824,134217728,0.0014496,0.001344,0.001664,23222.9,20164.9,24966.1,836023,725937,898779,178619,155099,192027,743132,645278,798915,92891.5,80659.7,99864.4 +GeForce RTX 3090,Unpacker,4096,32,128,896,1,half,1073741824,134217728,0.0014144,0.001376,0.001728,23783,19418.1,24385.5,856186,699051,877878,182927,149354,187561,761055,621378,780336,95131.8,77672.3,97542 +GeForce RTX 3090,Unpacker,4096,32,128,928,1,half,1073741824,134217728,0.001416,0.001344,0.001696,23768,19784.5,24966.1,855648,712240,898779,182812,152172,192027,760576,633102,798915,95071.9,79137.8,99864.4 +GeForce RTX 3090,Unpacker,4096,32,128,960,1,half,1073741824,134217728,0.0014288,0.001376,0.001728,23571.9,19418.1,24385.5,848589,699051,877878,181304,149354,187561,754302,621378,780336,94287.7,77672.3,97542 +GeForce RTX 3090,Unpacker,4096,32,128,992,1,half,1073741824,134217728,0.0014304,0.001376,0.001728,23553.5,19418.1,24385.5,847927,699051,877878,181162,149354,187561,753713,621378,780336,94214.1,77672.3,97542 +GeForce RTX 3090,Unpacker,4096,32,128,1024,1,half,1073741824,134217728,0.001416,0.001344,0.001664,23764,20164.9,24966.1,855504,725937,898779,182781,155099,192027,760448,645278,798915,95056,80659.7,99864.4 +GeForce RTX 3090,Unpacker,4096,32,256,32,1,half,2147483648,268435456,0.001464,0.001376,0.001632,45977.6,41120.6,48771,1.65519e+06,1.48034e+06,1.75576e+06,353637,316280,375123,1.47128e+06,1.31586e+06,1.56067e+06,183910,164483,195084 +GeForce RTX 3090,Unpacker,4096,32,256,64,1,half,2147483648,268435456,0.0014944,0.001376,0.001952,45351.5,34379.5,48771,1.63265e+06,1.23766e+06,1.75576e+06,348822,264431,375123,1.45125e+06,1.10015e+06,1.56067e+06,181406,137518,195084 +GeForce RTX 3090,Unpacker,4096,32,256,96,1,half,2147483648,268435456,0.0014832,0.001376,0.001728,45495.6,38836.1,48771,1.63784e+06,1.3981e+06,1.75576e+06,349930,298709,375123,1.45586e+06,1.24276e+06,1.56067e+06,181982,155345,195084 +GeForce RTX 3090,Unpacker,4096,32,256,128,1,half,2147483648,268435456,0.0014224,0.001344,0.001696,47317.4,39568.9,49932.2,1.70343e+06,1.42448e+06,1.79756e+06,363943,304345,384054,1.51416e+06,1.2662e+06,1.59783e+06,189270,158276,199729 +GeForce RTX 3090,Unpacker,4096,32,256,160,1,half,2147483648,268435456,0.0014256,0.001376,0.001856,47282.2,36157.8,48771,1.70216e+06,1.30168e+06,1.75576e+06,363672,278108,375123,1.51303e+06,1.15705e+06,1.56067e+06,189129,144631,195084 +GeForce RTX 3090,Unpacker,4096,32,256,192,1,half,2147483648,268435456,0.0014016,0.001376,0.001472,47905.9,45590.3,48771,1.72461e+06,1.64125e+06,1.75576e+06,368469,350658,375123,1.53299e+06,1.45889e+06,1.56067e+06,191624,182361,195084 +GeForce RTX 3090,Unpacker,4096,32,256,224,1,half,2147483648,268435456,0.0014032,0.001344,0.001664,47922.3,40329.8,49932.2,1.7252e+06,1.45187e+06,1.79756e+06,368596,310198,384054,1.53351e+06,1.29056e+06,1.59783e+06,191689,161319,199729 +GeForce RTX 3090,Unpacker,4096,32,256,256,1,half,2147483648,268435456,0.0014608,0.001376,0.00192,46277.2,34952.5,48771,1.66598e+06,1.25829e+06,1.75576e+06,355942,268838,375123,1.48087e+06,1.11848e+06,1.56067e+06,185109,139810,195084 +GeForce RTX 3090,Unpacker,4096,32,256,288,1,half,2147483648,268435456,0.0014064,0.001376,0.001472,47744.6,45590.3,48771,1.7188e+06,1.64125e+06,1.75576e+06,367228,350658,375123,1.52783e+06,1.45889e+06,1.56067e+06,190978,182361,195084 +GeForce RTX 3090,Unpacker,4096,32,256,320,1,half,2147483648,268435456,0.0014384,0.001376,0.001632,46792.6,41120.6,48771,1.68453e+06,1.48034e+06,1.75576e+06,359906,316280,375123,1.49736e+06,1.31586e+06,1.56067e+06,187170,164483,195084 +GeForce RTX 3090,Unpacker,4096,32,256,352,1,half,2147483648,268435456,0.0014448,0.001376,0.001632,46618.7,41120.6,48771,1.67827e+06,1.48034e+06,1.75576e+06,358568,316280,375123,1.4918e+06,1.31586e+06,1.56067e+06,186475,164483,195084 +GeForce RTX 3090,Unpacker,4096,32,256,384,1,half,2147483648,268435456,0.0014096,0.001376,0.001568,47655.2,42799,48771,1.71559e+06,1.54076e+06,1.75576e+06,366541,329189,375123,1.52497e+06,1.36957e+06,1.56067e+06,190621,171196,195084 +GeForce RTX 3090,Unpacker,4096,32,256,416,1,half,2147483648,268435456,0.0014112,0.001376,0.0016,47614.9,41943,48771,1.71414e+06,1.50995e+06,1.75576e+06,366231,322606,375123,1.52368e+06,1.34218e+06,1.56067e+06,190459,167772,195084 +GeForce RTX 3090,Unpacker,4096,32,256,448,1,half,2147483648,268435456,0.001392,0.001376,0.00144,48219.2,46603.4,48771,1.73589e+06,1.67772e+06,1.75576e+06,370879,358451,375123,1.54302e+06,1.49131e+06,1.56067e+06,192877,186414,195084 +GeForce RTX 3090,Unpacker,4096,32,256,480,1,half,2147483648,268435456,0.001408,0.001376,0.001504,47693.8,44620.3,48771,1.71698e+06,1.60633e+06,1.75576e+06,366838,343198,375123,1.5262e+06,1.42785e+06,1.56067e+06,190775,178481,195084 +GeForce RTX 3090,Unpacker,4096,32,256,512,1,half,2147483648,268435456,0.001424,0.001376,0.001568,47187.5,42799,48771,1.69875e+06,1.54076e+06,1.75576e+06,362943,329189,375123,1.51e+06,1.36957e+06,1.56067e+06,188750,171196,195084 +GeForce RTX 3090,Unpacker,4096,32,256,544,1,half,2147483648,268435456,0.0014016,0.001376,0.001632,47954.8,41120.6,48771,1.72637e+06,1.48034e+06,1.75576e+06,368845,316280,375123,1.53455e+06,1.31586e+06,1.56067e+06,191819,164483,195084 +GeForce RTX 3090,Unpacker,4096,32,256,576,1,half,2147483648,268435456,0.0014224,0.001344,0.001696,47353.9,39568.9,49932.2,1.70474e+06,1.42448e+06,1.79756e+06,364223,304345,384054,1.51532e+06,1.2662e+06,1.59783e+06,189415,158276,199729 +GeForce RTX 3090,Unpacker,4096,32,256,608,1,half,2147483648,268435456,0.0014192,0.001376,0.001728,47435.6,38836.1,48771,1.70768e+06,1.3981e+06,1.75576e+06,364852,298709,375123,1.51794e+06,1.24276e+06,1.56067e+06,189742,155345,195084 +GeForce RTX 3090,Unpacker,4096,32,256,640,1,half,2147483648,268435456,0.0014192,0.001344,0.001632,47378.9,41120.6,49932.2,1.70564e+06,1.48034e+06,1.79756e+06,364415,316280,384054,1.51612e+06,1.31586e+06,1.59783e+06,189515,164483,199729 +GeForce RTX 3090,Unpacker,4096,32,256,672,1,half,2147483648,268435456,0.0014176,0.001376,0.001664,47435.1,40329.8,48771,1.70766e+06,1.45187e+06,1.75576e+06,364848,310198,375123,1.51792e+06,1.29056e+06,1.56067e+06,189740,161319,195084 +GeForce RTX 3090,Unpacker,4096,32,256,704,1,half,2147483648,268435456,0.0014368,0.001376,0.001632,46835.2,41120.6,48771,1.68607e+06,1.48034e+06,1.75576e+06,360234,316280,375123,1.49873e+06,1.31586e+06,1.56067e+06,187341,164483,195084 +GeForce RTX 3090,Unpacker,4096,32,256,736,1,half,2147483648,268435456,0.0014304,0.001376,0.001696,47102.9,39568.9,48771,1.6957e+06,1.42448e+06,1.75576e+06,362293,304345,375123,1.50729e+06,1.2662e+06,1.56067e+06,188412,158276,195084 +GeForce RTX 3090,Unpacker,4096,32,256,768,1,half,2147483648,268435456,0.0014224,0.001376,0.001664,47318.3,40329.8,48771,1.70346e+06,1.45187e+06,1.75576e+06,363949,310198,375123,1.51418e+06,1.29056e+06,1.56067e+06,189273,161319,195084 +GeForce RTX 3090,Unpacker,4096,32,256,800,1,half,2147483648,268435456,0.0014112,0.001376,0.001632,47624.7,41120.6,48771,1.71449e+06,1.48034e+06,1.75576e+06,366306,316280,375123,1.52399e+06,1.31586e+06,1.56067e+06,190499,164483,195084 +GeForce RTX 3090,Unpacker,4096,32,256,832,1,half,2147483648,268435456,0.0014032,0.001344,0.001536,47871.2,43690.7,49932.2,1.72336e+06,1.57286e+06,1.79756e+06,368202,336048,384054,1.53188e+06,1.3981e+06,1.59783e+06,191485,174763,199729 +GeForce RTX 3090,Unpacker,4096,32,256,864,1,half,2147483648,268435456,0.0014432,0.001376,0.00176,46695.8,38130,48771,1.68105e+06,1.37268e+06,1.75576e+06,359161,293278,375123,1.49426e+06,1.22016e+06,1.56067e+06,186783,152520,195084 +GeForce RTX 3090,Unpacker,4096,32,256,896,1,half,2147483648,268435456,0.0014016,0.001376,0.001504,47900.8,44620.3,48771,1.72443e+06,1.60633e+06,1.75576e+06,368430,343198,375123,1.53283e+06,1.42785e+06,1.56067e+06,191603,178481,195084 +GeForce RTX 3090,Unpacker,4096,32,256,928,1,half,2147483648,268435456,0.0014736,0.001376,0.00176,45826.7,38130,48771,1.64976e+06,1.37268e+06,1.75576e+06,352477,293278,375123,1.46645e+06,1.22016e+06,1.56067e+06,183307,152520,195084 +GeForce RTX 3090,Unpacker,4096,32,256,960,1,half,2147483648,268435456,0.0013968,0.001376,0.001472,48062.7,45590.3,48771,1.73026e+06,1.64125e+06,1.75576e+06,369675,350658,375123,1.538e+06,1.45889e+06,1.56067e+06,192251,182361,195084 +GeForce RTX 3090,Unpacker,4096,32,256,992,1,half,2147483648,268435456,0.0014208,0.001376,0.001696,47320.7,39568.9,48771,1.70354e+06,1.42448e+06,1.75576e+06,363968,304345,375123,1.51426e+06,1.2662e+06,1.56067e+06,189283,158276,195084 +GeForce RTX 3090,Unpacker,4096,32,256,1024,1,half,2147483648,268435456,0.0014512,0.001376,0.00176,46493.6,38130,48771,1.67377e+06,1.37268e+06,1.75576e+06,357607,293278,375123,1.4878e+06,1.22016e+06,1.56067e+06,185974,152520,195084 +GeForce RTX 3090,Unpacker,4096,32,512,32,1,half,4294967296,536870912,0.0014416,0.001376,0.001824,93405.2,73584.3,97542,3.36259e+06,2.64903e+06,3.51151e+06,718428,565975,750246,2.98897e+06,2.3547e+06,3.12134e+06,373621,294337,390168 +GeForce RTX 3090,Unpacker,4096,32,512,64,1,half,4294967296,536870912,0.0014352,0.001376,0.001568,93699.3,85598,97542,3.37317e+06,3.08153e+06,3.51151e+06,720690,658379,750246,2.99838e+06,2.73914e+06,3.12134e+06,374797,342392,390168 +GeForce RTX 3090,Unpacker,4096,32,512,96,1,half,4294967296,536870912,0.0014224,0.001376,0.001664,94561.9,80659.7,97542,3.40423e+06,2.90375e+06,3.51151e+06,727325,620396,750246,3.02598e+06,2.58111e+06,3.12134e+06,378248,322639,390168 +GeForce RTX 3090,Unpacker,4096,32,512,128,1,half,4294967296,536870912,0.0014144,0.001376,0.001696,95168,79137.8,97542,3.42605e+06,2.84896e+06,3.51151e+06,731986,608690,750246,3.04538e+06,2.53241e+06,3.12134e+06,380672,316551,390168 +GeForce RTX 3090,Unpacker,4096,32,512,160,1,half,4294967296,536870912,0.0014288,0.001376,0.0016,94113.9,83886.1,97542,3.3881e+06,3.0199e+06,3.51151e+06,723878,645211,750246,3.01164e+06,2.68435e+06,3.12134e+06,376455,335544,390168 +GeForce RTX 3090,Unpacker,4096,32,512,192,1,half,4294967296,536870912,0.001456,0.001344,0.001792,92746.3,74898.3,99864.4,3.33887e+06,2.69634e+06,3.59512e+06,713360,576082,768109,2.96788e+06,2.39674e+06,3.19566e+06,370985,299593,399458 +GeForce RTX 3090,Unpacker,4096,32,512,224,1,half,4294967296,536870912,0.0014128,0.001376,0.001536,95096.6,87381.3,97542,3.42348e+06,3.14573e+06,3.51151e+06,731437,672095,750246,3.04309e+06,2.7962e+06,3.12134e+06,380386,349525,390168 +GeForce RTX 3090,Unpacker,4096,32,512,256,1,half,4294967296,536870912,0.0014336,0.001376,0.001664,93860.3,80659.7,97542,3.37897e+06,2.90375e+06,3.51151e+06,721928,620396,750246,3.00353e+06,2.58111e+06,3.12134e+06,375441,322639,390168 +GeForce RTX 3090,Unpacker,4096,32,512,288,1,half,4294967296,536870912,0.0014112,0.001376,0.001568,95214,85598,97542,3.4277e+06,3.08153e+06,3.51151e+06,732340,658379,750246,3.04685e+06,2.73914e+06,3.12134e+06,380856,342392,390168 +GeForce RTX 3090,Unpacker,4096,32,512,320,1,half,4294967296,536870912,0.0014224,0.001376,0.0016,94491.7,83886.1,97542,3.4017e+06,3.0199e+06,3.51151e+06,726784,645211,750246,3.02373e+06,2.68435e+06,3.12134e+06,377967,335544,390168 +GeForce RTX 3090,Unpacker,4096,32,512,352,1,half,4294967296,536870912,0.0014496,0.001376,0.001728,92903.9,77672.3,97542,3.34454e+06,2.7962e+06,3.51151e+06,714572,597418,750246,2.97292e+06,2.48551e+06,3.12134e+06,371616,310689,390168 +GeForce RTX 3090,Unpacker,4096,32,512,384,1,half,4294967296,536870912,0.0014176,0.001376,0.001728,94919.1,77672.3,97542,3.41709e+06,2.7962e+06,3.51151e+06,730072,597418,750246,3.03741e+06,2.48551e+06,3.12134e+06,379676,310689,390168 +GeForce RTX 3090,Unpacker,4096,32,512,416,1,half,4294967296,536870912,0.0014272,0.001376,0.001728,94278.9,77672.3,97542,3.39404e+06,2.7962e+06,3.51151e+06,725148,597418,750246,3.01693e+06,2.48551e+06,3.12134e+06,377116,310689,390168 +GeForce RTX 3090,Unpacker,4096,32,512,448,1,half,4294967296,536870912,0.0014256,0.001376,0.001568,94254.6,85598,97542,3.39317e+06,3.08153e+06,3.51151e+06,724961,658379,750246,3.01615e+06,2.73914e+06,3.12134e+06,377018,342392,390168 +GeForce RTX 3090,Unpacker,4096,32,512,480,1,half,4294967296,536870912,0.001432,0.001376,0.001696,94043.8,79137.8,97542,3.38558e+06,2.84896e+06,3.51151e+06,723340,608690,750246,3.0094e+06,2.53241e+06,3.12134e+06,376175,316551,390168 +GeForce RTX 3090,Unpacker,4096,32,512,512,1,half,4294967296,536870912,0.0014016,0.001376,0.001472,95797.4,91180.5,97542,3.44871e+06,3.2825e+06,3.51151e+06,736827,701317,750246,3.06552e+06,2.91778e+06,3.12134e+06,383190,364722,390168 +GeForce RTX 3090,Unpacker,4096,32,512,544,1,half,4294967296,536870912,0.0014832,0.001376,0.00176,91069.5,76260.1,97542,3.2785e+06,2.74536e+06,3.51151e+06,700463,586556,750246,2.91422e+06,2.44032e+06,3.12134e+06,364278,305040,390168 +GeForce RTX 3090,Unpacker,4096,32,512,576,1,half,4294967296,536870912,0.001416,0.001376,0.001504,94842.5,89240.5,97542,3.41433e+06,3.21266e+06,3.51151e+06,729483,686395,750246,3.03496e+06,2.8557e+06,3.12134e+06,379370,356962,390168 +GeForce RTX 3090,Unpacker,4096,32,512,608,1,half,4294967296,536870912,0.0014432,0.001376,0.001728,93356.1,77672.3,97542,3.36082e+06,2.7962e+06,3.51151e+06,718050,597418,750246,2.98739e+06,2.48551e+06,3.12134e+06,373424,310689,390168 +GeForce RTX 3090,Unpacker,4096,32,512,640,1,half,4294967296,536870912,0.0014576,0.001376,0.00176,92605.3,76260.1,97542,3.33379e+06,2.74536e+06,3.51151e+06,712275,586556,750246,2.96337e+06,2.44032e+06,3.12134e+06,370421,305040,390168 +GeForce RTX 3090,Unpacker,4096,32,512,672,1,half,4294967296,536870912,0.001424,0.001376,0.0016,94417.3,83886.1,97542,3.39902e+06,3.0199e+06,3.51151e+06,726213,645211,750246,3.02135e+06,2.68435e+06,3.12134e+06,377669,335544,390168 +GeForce RTX 3090,Unpacker,4096,32,512,704,1,half,4294967296,536870912,0.0014112,0.001376,0.001472,95161.2,91180.5,97542,3.4258e+06,3.2825e+06,3.51151e+06,731934,701317,750246,3.04516e+06,2.91778e+06,3.12134e+06,380645,364722,390168 +GeForce RTX 3090,Unpacker,4096,32,512,736,1,half,4294967296,536870912,0.0014352,0.001376,0.001728,93901,77672.3,97542,3.38043e+06,2.7962e+06,3.51151e+06,722241,597418,750246,3.00483e+06,2.48551e+06,3.12134e+06,375604,310689,390168 +GeForce RTX 3090,Unpacker,4096,32,512,768,1,half,4294967296,536870912,0.0014464,0.001376,0.001728,93204,77672.3,97542,3.35534e+06,2.7962e+06,3.51151e+06,716880,597418,750246,2.98253e+06,2.48551e+06,3.12134e+06,372816,310689,390168 +GeForce RTX 3090,Unpacker,4096,32,512,800,1,half,4294967296,536870912,0.0014352,0.001376,0.001728,93844.3,77672.3,97542,3.3784e+06,2.7962e+06,3.51151e+06,721806,597418,750246,3.00302e+06,2.48551e+06,3.12134e+06,375377,310689,390168 +GeForce RTX 3090,Unpacker,4096,32,512,832,1,half,4294967296,536870912,0.0014192,0.001376,0.001728,94789.4,77672.3,97542,3.41242e+06,2.7962e+06,3.51151e+06,729075,597418,750246,3.03326e+06,2.48551e+06,3.12134e+06,379158,310689,390168 +GeForce RTX 3090,Unpacker,4096,32,512,864,1,half,4294967296,536870912,0.001448,0.001376,0.001728,93112.4,77672.3,97542,3.35205e+06,2.7962e+06,3.51151e+06,716176,597418,750246,2.9796e+06,2.48551e+06,3.12134e+06,372450,310689,390168 +GeForce RTX 3090,Unpacker,4096,32,512,896,1,half,4294967296,536870912,0.0014144,0.001376,0.0016,95008.1,83886.1,97542,3.42029e+06,3.0199e+06,3.51151e+06,730756,645211,750246,3.04026e+06,2.68435e+06,3.12134e+06,380032,335544,390168 +GeForce RTX 3090,Unpacker,4096,32,512,928,1,half,4294967296,536870912,0.0014,0.001376,0.00144,95884.2,93206.8,97542,3.45183e+06,3.35544e+06,3.51151e+06,737495,716902,750246,3.0683e+06,2.98262e+06,3.12134e+06,383537,372827,390168 +GeForce RTX 3090,Unpacker,4096,32,512,960,1,half,4294967296,536870912,0.00144,0.001376,0.001728,93449.6,77672.3,97542,3.36418e+06,2.7962e+06,3.51151e+06,718769,597418,750246,2.99039e+06,2.48551e+06,3.12134e+06,373798,310689,390168 +GeForce RTX 3090,Unpacker,4096,32,512,992,1,half,4294967296,536870912,0.0014544,0.001376,0.001728,92782.5,77672.3,97542,3.34017e+06,2.7962e+06,3.51151e+06,713639,597418,750246,2.96904e+06,2.48551e+06,3.12134e+06,371130,310689,390168 +GeForce RTX 3090,Unpacker,4096,32,512,1024,1,half,4294967296,536870912,0.0016656,0.001376,0.003808,84850.1,35246.3,97542,3.0546e+06,1.26887e+06,3.51151e+06,652626,271097,750246,2.7152e+06,1.12788e+06,3.12134e+06,339400,140985,390168 +GeForce RTX 3090,Unpacker,4096,32,1024,32,1,half,8589934592,1073741824,0.0014544,0.001376,0.001824,185324,147169,195084,6.67166e+06,5.29807e+06,7.02302e+06,1.42542e+06,1.13195e+06,1.50049e+06,5.93037e+06,4.70939e+06,6.24268e+06,741296,588674,780336 +GeForce RTX 3090,Unpacker,4096,32,1024,64,1,half,8589934592,1073741824,0.0014704,0.001376,0.001664,183209,161319,195084,6.59552e+06,5.8075e+06,7.02302e+06,1.40916e+06,1.24079e+06,1.50049e+06,5.86269e+06,5.16222e+06,6.24268e+06,732836,645278,780336 +GeForce RTX 3090,Unpacker,4096,32,1024,96,1,half,8589934592,1073741824,0.0014304,0.001376,0.001632,188007,164483,195084,6.76824e+06,5.92137e+06,7.02302e+06,1.44606e+06,1.26512e+06,1.50049e+06,6.01621e+06,5.26344e+06,6.24268e+06,752027,657930,780336 +GeForce RTX 3090,Unpacker,4096,32,1024,128,1,half,8589934592,1073741824,0.0014464,0.001376,0.001696,186152,158276,195084,6.70146e+06,5.69792e+06,7.02302e+06,1.43179e+06,1.21738e+06,1.50049e+06,5.95686e+06,5.06482e+06,6.24268e+06,744607,633102,780336 +GeForce RTX 3090,Unpacker,4096,32,1024,160,1,half,8589934592,1073741824,0.0014256,0.001376,0.0016,188558,167772,195084,6.78808e+06,6.0398e+06,7.02302e+06,1.4503e+06,1.29042e+06,1.50049e+06,6.03385e+06,5.36871e+06,6.24268e+06,754232,671089,780336 +GeForce RTX 3090,Unpacker,4096,32,1024,192,1,half,8589934592,1073741824,0.0014096,0.001376,0.001472,190477,182361,195084,6.85718e+06,6.565e+06,7.02302e+06,1.46506e+06,1.40263e+06,1.50049e+06,6.09527e+06,5.83555e+06,6.24268e+06,761908,729444,780336 +GeForce RTX 3090,Unpacker,4096,32,1024,224,1,half,8589934592,1073741824,0.0014032,0.001376,0.00144,191325,186414,195084,6.8877e+06,6.71089e+06,7.02302e+06,1.47158e+06,1.4338e+06,1.50049e+06,6.1224e+06,5.96523e+06,6.24268e+06,765300,745654,780336 +GeForce RTX 3090,Unpacker,4096,32,1024,256,1,half,8589934592,1073741824,0.0014384,0.001376,0.00176,187122,152520,195084,6.7364e+06,5.49072e+06,7.02302e+06,1.43925e+06,1.17311e+06,1.50049e+06,5.98791e+06,4.88064e+06,6.24268e+06,748489,610081,780336 +GeForce RTX 3090,Unpacker,4096,32,1024,288,1,half,8589934592,1073741824,0.0013984,0.001376,0.001472,192009,182361,195084,6.91233e+06,6.565e+06,7.02302e+06,1.47684e+06,1.40263e+06,1.50049e+06,6.1443e+06,5.83555e+06,6.24268e+06,768037,729444,780336 +GeForce RTX 3090,Unpacker,4096,32,1024,320,1,half,8589934592,1073741824,0.0014352,0.001376,0.001664,187598,161319,195084,6.75352e+06,5.8075e+06,7.02302e+06,1.44291e+06,1.24079e+06,1.50049e+06,6.00312e+06,5.16222e+06,6.24268e+06,750391,645278,780336 +GeForce RTX 3090,Unpacker,4096,32,1024,352,1,half,8589934592,1073741824,0.0016528,0.001376,0.004096,173623,65536,195084,6.25042e+06,2.3593e+06,7.02302e+06,1.33542e+06,504071,1.50049e+06,5.55593e+06,2.09715e+06,6.24268e+06,694492,262144,780336 +GeForce RTX 3090,Unpacker,4096,32,1024,384,1,half,8589934592,1073741824,0.0014384,0.001376,0.001792,187306,149797,195084,6.74301e+06,5.39268e+06,7.02302e+06,1.44067e+06,1.15216e+06,1.50049e+06,5.99379e+06,4.79349e+06,6.24268e+06,749223,599186,780336 +GeForce RTX 3090,Unpacker,4096,32,1024,416,1,half,8589934592,1073741824,0.001424,0.001376,0.001664,188994,161319,195084,6.80377e+06,5.8075e+06,7.02302e+06,1.45365e+06,1.24079e+06,1.50049e+06,6.04779e+06,5.16222e+06,6.24268e+06,755974,645278,780336 +GeForce RTX 3090,Unpacker,4096,32,1024,448,1,half,8589934592,1073741824,0.0014384,0.001376,0.001728,187408,155345,195084,6.7467e+06,5.59241e+06,7.02302e+06,1.44145e+06,1.19484e+06,1.50049e+06,5.99707e+06,4.97103e+06,6.24268e+06,749633,621378,780336 +GeForce RTX 3090,Unpacker,4096,32,1024,480,1,half,8589934592,1073741824,0.0013984,0.001376,0.00144,191990,186414,195084,6.91165e+06,6.71089e+06,7.02302e+06,1.4767e+06,1.4338e+06,1.50049e+06,6.14368e+06,5.96523e+06,6.24268e+06,767961,745654,780336 +GeForce RTX 3090,Unpacker,4096,32,1024,512,1,half,8589934592,1073741824,0.001432,0.001376,0.001696,187852,158276,195084,6.76266e+06,5.69792e+06,7.02302e+06,1.44486e+06,1.21738e+06,1.50049e+06,6.01125e+06,5.06482e+06,6.24268e+06,751406,633102,780336 +GeForce RTX 3090,Unpacker,4096,32,1024,544,1,half,8589934592,1073741824,0.0014336,0.001376,0.001728,187708,155345,195084,6.75749e+06,5.59241e+06,7.02302e+06,1.44376e+06,1.19484e+06,1.50049e+06,6.00666e+06,4.97103e+06,6.24268e+06,750832,621378,780336 +GeForce RTX 3090,Unpacker,4096,32,1024,576,1,half,8589934592,1073741824,0.0014048,0.001376,0.001408,191094,190650,195084,6.87937e+06,6.86341e+06,7.02302e+06,1.4698e+06,1.46639e+06,1.50049e+06,6.11499e+06,6.10081e+06,6.24268e+06,764374,762601,780336 +GeForce RTX 3090,Unpacker,4096,32,1024,608,1,half,8589934592,1073741824,0.0014192,0.001376,0.001664,189425,161319,195084,6.8193e+06,5.8075e+06,7.02302e+06,1.45697e+06,1.24079e+06,1.50049e+06,6.0616e+06,5.16222e+06,6.24268e+06,757700,645278,780336 +GeForce RTX 3090,Unpacker,4096,32,1024,640,1,half,8589934592,1073741824,0.0014416,0.001376,0.001792,187154,149797,195084,6.73755e+06,5.39268e+06,7.02302e+06,1.4395e+06,1.15216e+06,1.50049e+06,5.98894e+06,4.79349e+06,6.24268e+06,748617,599186,780336 +GeForce RTX 3090,Unpacker,4096,32,1024,672,1,half,8589934592,1073741824,0.0014272,0.001376,0.001568,188331,171196,195084,6.77992e+06,6.16306e+06,7.02302e+06,1.44855e+06,1.31676e+06,1.50049e+06,6.0266e+06,5.47828e+06,6.24268e+06,753325,684784,780336 +GeForce RTX 3090,Unpacker,4096,32,1024,704,1,half,8589934592,1073741824,0.0014576,0.001376,0.001824,185115,147169,195084,6.66414e+06,5.29807e+06,7.02302e+06,1.42381e+06,1.13195e+06,1.50049e+06,5.92368e+06,4.70939e+06,6.24268e+06,740460,588674,780336 +GeForce RTX 3090,Unpacker,4096,32,1024,736,1,half,8589934592,1073741824,0.0014144,0.001376,0.001696,190150,158276,195084,6.84539e+06,5.69792e+06,7.02302e+06,1.46254e+06,1.21738e+06,1.50049e+06,6.08479e+06,5.06482e+06,6.24268e+06,760599,633102,780336 +GeForce RTX 3090,Unpacker,4096,32,1024,768,1,half,8589934592,1073741824,0.0014208,0.001376,0.001568,189071,171196,195084,6.80655e+06,6.16306e+06,7.02302e+06,1.45424e+06,1.31676e+06,1.50049e+06,6.05027e+06,5.47828e+06,6.24268e+06,756284,684784,780336 +GeForce RTX 3090,Unpacker,4096,32,1024,800,1,half,8589934592,1073741824,0.0014544,0.001376,0.001728,185331,155345,195084,6.67191e+06,5.59241e+06,7.02302e+06,1.42548e+06,1.19484e+06,1.50049e+06,5.93059e+06,4.97103e+06,6.24268e+06,741324,621378,780336 +GeForce RTX 3090,Unpacker,4096,32,1024,832,1,half,8589934592,1073741824,0.0014144,0.001376,0.001504,189878,178481,195084,6.8356e+06,6.42532e+06,7.02302e+06,1.46045e+06,1.37279e+06,1.50049e+06,6.07609e+06,5.71139e+06,6.24268e+06,759512,713924,780336 +GeForce RTX 3090,Unpacker,4096,32,1024,864,1,half,8589934592,1073741824,0.0014416,0.001376,0.001696,186799,158276,195084,6.72478e+06,5.69792e+06,7.02302e+06,1.43677e+06,1.21738e+06,1.50049e+06,5.97758e+06,5.06482e+06,6.24268e+06,747198,633102,780336 +GeForce RTX 3090,Unpacker,4096,32,1024,896,1,half,8589934592,1073741824,0.0014128,0.001376,0.001728,190437,155345,195084,6.85572e+06,5.59241e+06,7.02302e+06,1.46475e+06,1.19484e+06,1.50049e+06,6.09397e+06,4.97103e+06,6.24268e+06,761747,621378,780336 +GeForce RTX 3090,Unpacker,4096,32,1024,928,1,half,8589934592,1073741824,0.0014528,0.001376,0.001696,185492,158276,195084,6.67773e+06,5.69792e+06,7.02302e+06,1.42672e+06,1.21738e+06,1.50049e+06,5.93576e+06,5.06482e+06,6.24268e+06,741970,633102,780336 +GeForce RTX 3090,Unpacker,4096,32,1024,960,1,half,8589934592,1073741824,0.0014288,0.001376,0.001664,188382,161319,195084,6.78176e+06,5.8075e+06,7.02302e+06,1.44894e+06,1.24079e+06,1.50049e+06,6.02823e+06,5.16222e+06,6.24268e+06,753529,645278,780336 +GeForce RTX 3090,Unpacker,4096,32,1024,992,1,half,8589934592,1073741824,0.0014528,0.001376,0.00176,185736,152520,195084,6.68651e+06,5.49072e+06,7.02302e+06,1.4286e+06,1.17311e+06,1.50049e+06,5.94357e+06,4.88064e+06,6.24268e+06,742946,610081,780336 +GeForce RTX 3090,Unpacker,4096,32,1024,1024,1,half,8589934592,1073741824,0.0014208,0.001376,0.001728,189338,155345,195084,6.81617e+06,5.59241e+06,7.02302e+06,1.4563e+06,1.19484e+06,1.50049e+06,6.05882e+06,4.97103e+06,6.24268e+06,757352,621378,780336 diff --git a/psrdada_cpp/cryopaf/profiling/Results/3090/voltage_kernel.csv b/psrdada_cpp/cryopaf/profiling/Results/3090/voltage_kernel.csv new file mode 100644 index 0000000000000000000000000000000000000000..a7cb07385dfa845f252bf0983afc4d7b32643740 --- /dev/null +++ b/psrdada_cpp/cryopaf/profiling/Results/3090/voltage_kernel.csv @@ -0,0 +1,225 @@ +devicename,kernelname,samples,channels,elements,beams,integration,precision,reads,writes,avg_time,min_time,max_time,avg_throughput,min_throughput,max_throughput,avg_bandwidth,min_bandwidth,max_bandwidth,percentage_avg_bandwidth,percentage_min_bandwidth,percentage_max_bandwidth,input_avg_bandwidth,input_min_bandwidth,input_max_bandwidth,output_avg_bandwidth,output_min_bandwidth,output_max_bandwidth +GeForce RTX 3090,Voltage,4096,32,16,32,1,half,16908288,33554432,0.229893,0.228576,0.231712,4670.68,4633.95,4697.53,219.508,217.782,220.77,46.8987,46.5299,47.1682,72.9794,72.4055,73.3988,145.959,144.811,146.798 +GeForce RTX 3090,Voltage,4096,32,16,64,1,half,17039360,67108864,0.450699,0.446112,0.454336,4764.96,4726.64,4813.78,186.713,185.211,188.626,39.8918,39.571,40.3005,37.2263,36.9269,37.6076,148.905,147.708,150.431 +GeForce RTX 3090,Voltage,4096,32,16,96,1,half,17170432,100663296,0.64975,0.647648,0.65184,4957.65,4941.74,4973.73,181.353,180.771,181.941,38.7466,38.6223,38.8723,25.8211,25.7382,25.9048,154.927,154.429,155.429 +GeForce RTX 3090,Voltage,4096,32,16,128,1,half,17301504,134217728,0.876133,0.872576,0.882592,4902.24,4866.31,4922.17,172.943,171.675,173.646,36.9498,36.679,37.1,19.1494,19.009,19.2272,153.195,152.072,153.818 +GeForce RTX 3090,Voltage,4096,32,16,160,1,half,17432576,167772160,1.06598,1.06134,1.07155,5036.44,5010.22,5058.41,173.742,172.838,174.5,37.1206,36.9274,37.2825,15.7389,15.6569,15.8075,157.389,156.569,158.075 +GeForce RTX 3090,Voltage,4096,32,16,192,1,half,17563648,201326592,1.28827,1.28118,1.29389,5000.9,4979.14,5028.51,169.912,169.172,170.85,36.3022,36.1443,36.5027,13.0232,12.9665,13.0951,156.278,155.598,157.141 +GeForce RTX 3090,Voltage,4096,32,16,224,1,half,17694720,234881024,1.48666,1.47376,1.49622,5055.88,5023.44,5100.01,169.899,168.809,171.382,36.2995,36.0666,36.6163,11.2855,11.213,11.384,157.996,156.983,159.375 +GeForce RTX 3090,Voltage,4096,32,16,256,1,half,17825792,268435456,1.68222,1.66544,1.69296,5106.53,5073.91,5157.76,170.176,169.089,171.883,36.3587,36.1265,36.7234,9.97369,9.90999,10.0737,159.579,158.56,161.18 +GeForce RTX 3090,Voltage,4096,32,16,288,1,half,17956864,301989888,1.85703,1.84266,1.86563,5204,5179.84,5244.43,172.295,171.495,173.633,36.8114,36.6405,37.0974,9.03471,8.99278,9.10491,162.625,161.87,163.888 +GeForce RTX 3090,Voltage,4096,32,16,320,1,half,18087936,335544320,2.05481,2.05306,2.05942,5225.5,5213.8,5229.97,172.1,171.714,172.247,36.7697,36.6873,36.8011,8.16485,8.14656,8.17183,163.297,162.931,163.437 +GeForce RTX 3090,Voltage,4096,32,16,352,1,half,18219008,369098752,2.25514,2.25184,2.25901,5237.45,5228.47,5245.11,171.749,171.455,172.001,36.6948,36.6319,36.7485,7.43956,7.42681,7.45045,163.67,163.39,163.91 +GeForce RTX 3090,Voltage,4096,32,16,384,1,half,18350080,402653184,2.4425,2.32422,2.46845,5277.51,5219.84,5543.74,172.438,170.554,181.137,36.842,36.4394,38.7005,6.87175,6.79667,7.21842,164.922,163.12,173.242 +GeForce RTX 3090,Voltage,4096,32,16,416,1,half,18481152,436207616,2.50832,2.50576,2.51286,5564.93,5554.87,5570.62,181.272,180.944,181.457,38.7294,38.6594,38.769,6.68862,6.67653,6.69546,173.904,173.59,174.082 +GeForce RTX 3090,Voltage,4096,32,16,448,1,half,18612224,469762048,2.58,2.53299,2.62218,5827.46,5732.79,5934.64,189.323,186.248,192.805,40.4496,39.7924,41.1935,6.50387,6.3982,6.62348,182.108,179.15,185.457 +GeForce RTX 3090,Voltage,4096,32,16,480,1,half,18743296,503316480,2.77633,2.72048,2.83091,5802.51,5689.38,5920.33,188.081,184.414,191.9,40.1842,39.4007,41,6.04428,5.92643,6.16701,181.329,177.793,185.01 +GeForce RTX 3090,Voltage,4096,32,16,512,1,half,18874368,536870912,2.94331,2.87648,2.98819,5837.97,5749.25,5972.53,188.85,185.98,193.203,40.3485,39.7353,41.2785,5.70115,5.6145,5.83255,182.437,179.664,186.642 +GeForce RTX 3090,Voltage,4096,32,16,544,1,half,19005440,570425344,3.12956,3.07238,3.17962,5833.37,5740.82,5941.19,188.367,185.378,191.848,40.2451,39.6066,40.989,5.36156,5.27649,5.46065,182.293,179.401,185.662 +GeForce RTX 3090,Voltage,4096,32,16,576,1,half,19136512,603979776,3.30601,3.24138,3.36438,5847.17,5744.69,5962.7,188.513,185.21,192.238,40.2765,39.5706,41.0723,5.07566,4.98671,5.17595,182.724,179.522,186.334 +GeForce RTX 3090,Voltage,4096,32,16,608,1,half,19267584,637534208,3.48317,3.42346,3.52979,5857.62,5779.69,5959.21,188.583,186.074,191.853,40.2913,39.7553,40.9901,4.81712,4.75303,4.90067,183.051,180.615,186.225 +GeForce RTX 3090,Voltage,4096,32,16,640,1,half,19398656,671088640,3.68697,3.61136,3.75139,5825.26,5724.5,5946.47,187.301,184.062,191.199,40.0176,39.3254,40.8502,4.55098,4.47226,4.64568,182.039,178.891,185.827 +GeForce RTX 3090,Voltage,4096,32,16,672,1,half,19529728,704643072,3.85742,3.79533,3.89645,5845.95,5786.96,5941.14,187.749,185.855,190.806,40.1132,39.7085,40.7664,4.34967,4.30577,4.42049,182.686,180.842,185.661 +GeForce RTX 3090,Voltage,4096,32,16,704,1,half,19660800,738197504,4.04293,3.95955,4.11139,5843.76,5745.58,5965.91,187.481,184.331,191.4,40.056,39.383,40.8932,4.1504,4.08067,4.23715,182.618,179.549,186.435 +GeForce RTX 3090,Voltage,4096,32,16,736,1,half,19791872,771751936,4.22623,4.13731,4.29795,5844.23,5746.01,5969.11,187.316,184.168,191.318,40.0206,39.348,40.8758,3.97026,3.90354,4.0551,182.632,179.563,186.535 +GeForce RTX 3090,Voltage,4096,32,16,768,1,half,19922944,805306368,4.41668,4.33117,4.47987,5835.13,5752.35,5949.85,186.859,184.208,190.533,39.9231,39.3567,40.7079,3.79891,3.74502,3.8736,182.348,179.761,185.933 +GeForce RTX 3090,Voltage,4096,32,16,800,1,half,20054016,838860800,4.59325,4.50822,4.64867,5844.47,5774.45,5954.35,187.006,184.766,190.522,39.9544,39.4758,40.7056,3.6528,3.60903,3.72147,182.64,180.452,186.073 +GeForce RTX 3090,Voltage,4096,32,16,832,1,half,20185088,872415232,4.80668,4.71594,4.8655,5808.41,5737.8,5919.78,185.712,183.455,189.273,39.6781,39.1957,40.4388,3.49063,3.4482,3.55756,181.513,179.306,184.993 +GeForce RTX 3090,Voltage,4096,32,16,864,1,half,20316160,905969664,4.96765,4.88301,5.01216,5836.25,5784.14,5937.12,186.473,184.808,189.696,39.8405,39.4848,40.5291,3.37746,3.3473,3.43584,182.383,180.754,185.535 +GeForce RTX 3090,Voltage,4096,32,16,896,1,half,20447232,939524096,5.18476,5.0928,5.23571,5798.95,5742.25,5903.39,185.161,183.351,188.496,39.5603,39.1735,40.2727,3.23602,3.20438,3.2943,181.217,179.445,184.481 +GeForce RTX 3090,Voltage,4096,32,16,928,1,half,20578304,973078528,5.37069,5.26058,5.4647,5798.47,5698.12,5919.22,185.034,181.832,188.887,39.5331,38.849,40.3564,3.12417,3.07011,3.18924,181.202,178.066,184.976 +GeForce RTX 3090,Voltage,4096,32,16,960,1,half,20709376,1006632960,5.57432,5.45786,5.66928,5779.29,5681.9,5902,184.318,181.212,188.232,39.3802,38.7166,40.2164,3.01005,2.95932,3.07396,180.603,177.559,184.437 +GeForce RTX 3090,Voltage,4096,32,16,992,1,half,20840448,1040187392,5.73456,5.62448,5.84106,5804.9,5698.63,5918.06,185.038,181.65,188.645,39.5339,38.8101,40.3045,2.92586,2.87229,2.98289,181.403,178.082,184.939 +GeForce RTX 3090,Voltage,4096,32,16,1024,1,half,20971520,1073741824,5.90062,5.79536,5.99728,5823.51,5729.22,5928.84,185.539,182.535,188.895,39.641,38.9992,40.358,2.84351,2.79747,2.89494,181.985,179.038,185.276 +GeForce RTX 3090,Voltage,4096,32,32,32,1,half,33816576,33554432,0.341976,0.340864,0.343904,6279.67,6244.43,6300.12,197.006,195.901,197.648,42.091,41.8548,42.2281,98.1198,97.5692,98.4394,98.1198,97.5692,98.4394 +GeForce RTX 3090,Voltage,4096,32,32,64,1,half,34078720,67108864,0.663416,0.662144,0.664864,6474.03,6459.92,6486.46,152.525,152.193,152.818,32.5875,32.5165,32.6501,50.5783,50.4681,50.6754,101.157,100.936,101.351 +GeForce RTX 3090,Voltage,4096,32,32,96,1,half,34340864,100663296,0.991523,0.988096,0.996288,6497.6,6466.45,6520.07,136.16,135.507,136.631,29.091,28.9515,29.1916,33.8417,33.6795,33.9587,101.525,101.038,101.876 +GeForce RTX 3090,Voltage,4096,32,32,128,1,half,34603008,134217728,1.31364,1.30592,1.32771,6539.24,6469.73,6577.69,128.518,127.152,129.273,27.4582,27.1664,27.6197,25.5439,25.2724,25.6941,102.176,101.089,102.776 +GeForce RTX 3090,Voltage,4096,32,32,160,1,half,34865152,167772160,1.65525,1.63341,1.67334,6487.49,6416.74,6573.63,122.432,121.097,124.058,26.1581,25.8728,26.5054,20.2734,20.0523,20.5426,101.367,100.262,102.713 +GeForce RTX 3090,Voltage,4096,32,32,192,1,half,35127296,201326592,1.9856,1.95283,2.01581,6490.29,6391.93,6598.06,119.105,117.3,121.083,25.4472,25.0615,25.8697,16.9018,16.6456,17.1824,101.411,99.8739,103.095 +GeForce RTX 3090,Voltage,4096,32,32,224,1,half,35389440,234881024,2.3003,2.27347,2.3168,6535.38,6488.43,6612.08,117.501,116.657,118.88,25.1045,24.9241,25.3991,14.5879,14.4831,14.7591,102.115,101.382,103.314 +GeForce RTX 3090,Voltage,4096,32,32,256,1,half,35651584,268435456,2.62573,2.59174,2.6537,6543.34,6473.94,6628.69,115.818,114.59,117.329,24.745,24.4825,25.0678,12.78,12.6444,12.9467,102.24,101.155,103.573 +GeForce RTX 3090,Voltage,4096,32,32,288,1,half,35913728,301989888,2.95664,2.91626,2.97376,6537.27,6499.3,6627.45,114.292,113.628,115.869,24.4189,24.2771,24.7558,11.3494,11.2835,11.506,102.145,101.552,103.554 +GeForce RTX 3090,Voltage,4096,32,32,320,1,half,36175872,335544320,3.29183,3.24765,3.30998,6524,6487.9,6612.43,112.928,112.303,114.458,24.1274,23.9938,24.4544,10.1938,10.1373,10.3319,101.938,101.373,103.319 +GeForce RTX 3090,Voltage,4096,32,32,352,1,half,36438016,369098752,3.61113,3.56429,3.63411,6541.94,6500.16,6627.5,112.309,111.592,113.778,23.9952,23.8419,24.309,9.29253,9.23319,9.41406,102.218,101.565,103.555 +GeForce RTX 3090,Voltage,4096,32,32,384,1,half,36700160,402653184,3.96916,3.89414,4.01818,6493.1,6413.31,6617.58,110.702,109.341,112.824,23.6518,23.3612,24.1052,8.45456,8.35066,8.61664,101.455,100.208,103.4 +GeForce RTX 3090,Voltage,4096,32,32,416,1,half,36962304,436207616,4.27953,4.20954,4.34403,6524.15,6426.58,6631.92,110.578,108.924,112.404,23.6253,23.272,24.0155,7.84152,7.72426,7.97105,101.94,100.415,103.624 +GeForce RTX 3090,Voltage,4096,32,32,448,1,half,37224448,469762048,4.60585,4.53488,4.65754,6527.94,6455.08,6629.67,110.082,108.853,111.797,23.5193,23.2568,23.8858,7.28565,7.20433,7.39919,101.999,100.861,103.589 +GeForce RTX 3090,Voltage,4096,32,32,480,1,half,37486592,503316480,4.94258,4.86445,4.95824,6517.51,6496.71,6621.98,109.421,109.072,111.175,23.3781,23.3035,23.7528,6.78908,6.76741,6.89789,101.836,101.511,103.468 +GeForce RTX 3090,Voltage,4096,32,32,512,1,half,37748736,536870912,5.27439,5.17757,5.34202,6514.82,6431.98,6636.27,108.952,107.566,110.983,23.2779,22.9818,23.7118,6.36213,6.28123,6.48073,101.794,100.5,103.692 +GeForce RTX 3090,Voltage,4096,32,32,544,1,half,38010880,570425344,5.61499,5.51094,5.68589,6502.14,6420.67,6624.5,108.366,107.008,110.405,23.1527,22.8626,23.5884,5.97623,5.90135,6.08869,101.596,100.323,103.508 +GeForce RTX 3090,Voltage,4096,32,32,576,1,half,38273024,603979776,5.93735,5.82541,6.01181,6510.83,6429.8,6635.54,108.178,106.832,110.25,23.1126,22.825,23.5553,5.65176,5.58142,5.76001,101.732,100.466,103.68 +GeForce RTX 3090,Voltage,4096,32,32,608,1,half,38535168,637534208,6.25807,6.14893,6.34499,6520.41,6430.61,6635.66,108.04,106.552,109.949,23.083,22.7651,23.491,5.36218,5.28833,5.45696,101.881,100.478,103.682 +GeForce RTX 3090,Voltage,4096,32,32,640,1,half,38797312,671088640,6.60983,6.49283,6.66982,6498.23,6439.4,6614.94,107.405,106.432,109.334,22.9474,22.7397,23.3595,5.07674,5.03078,5.16792,101.535,100.616,103.358 +GeForce RTX 3090,Voltage,4096,32,32,672,1,half,39059456,704643072,6.94351,6.812,7.02506,6495.26,6419.47,6620.25,107.114,105.864,109.175,22.8853,22.6183,23.3257,4.83278,4.77639,4.92578,101.488,100.304,103.441 +GeForce RTX 3090,Voltage,4096,32,32,704,1,half,39321600,738197504,7.26395,7.12112,7.34819,6504.41,6429.42,6634.44,107.045,105.811,109.185,22.8705,22.6069,23.3277,4.61961,4.56635,4.71196,101.631,100.46,103.663 +GeForce RTX 3090,Voltage,4096,32,32,736,1,half,39583744,771751936,7.60572,7.44819,7.70688,6494.39,6408.83,6631.42,106.679,105.274,108.931,22.7924,22.4922,23.2734,4.41195,4.35383,4.50504,101.475,100.138,103.616 +GeForce RTX 3090,Voltage,4096,32,32,768,1,half,39845888,805306368,7.94484,7.77501,8.0775,6487.63,6380.64,6628.88,106.385,104.63,108.701,22.7295,22.3546,23.2244,4.22372,4.15406,4.31568,101.369,99.6974,103.576 +GeForce RTX 3090,Voltage,4096,32,32,800,1,half,40108032,838860800,8.30583,8.16176,8.35725,6463.95,6424.02,6577.88,105.828,105.174,107.694,22.6106,22.4709,23.0091,4.03997,4.01501,4.11118,100.999,100.375,102.779 +GeForce RTX 3090,Voltage,4096,32,32,832,1,half,40370176,872415232,8.63825,8.48358,8.68432,6463.79,6429.35,6581.48,105.67,105.107,107.594,22.5768,22.4565,22.9879,3.88449,3.86379,3.95522,100.997,100.459,102.836 +GeForce RTX 3090,Voltage,4096,32,32,864,1,half,40632320,905969664,8.94842,8.79043,9.0689,6479.88,6393.51,6596.04,105.789,104.379,107.685,22.6022,22.3009,23.0074,3.74993,3.69995,3.81715,101.248,99.8986,103.063 +GeForce RTX 3090,Voltage,4096,32,32,896,1,half,40894464,939524096,9.29539,9.13958,9.32163,6468.91,6450.54,6579.02,105.476,105.177,107.272,22.5354,22.4713,22.9189,3.60988,3.59963,3.67133,101.077,100.79,102.797 +GeForce RTX 3090,Voltage,4096,32,32,928,1,half,41156608,973078528,9.63896,9.45904,9.75741,6461.19,6382.54,6583.86,105.226,103.945,107.224,22.4819,22.2082,22.9087,3.48124,3.43887,3.54734,100.956,99.7271,102.873 +GeForce RTX 3090,Voltage,4096,32,32,960,1,half,41418752,1006632960,9.9678,9.80195,9.98797,6463.42,6450.21,6572.62,105.146,104.931,106.923,22.4648,22.4189,22.8444,3.36636,3.35949,3.42324,100.991,100.785,102.697 +GeForce RTX 3090,Voltage,4096,32,32,992,1,half,41680896,1040187392,10.3017,10.1114,10.4304,6462.41,6382.52,6583.88,105.021,103.723,106.995,22.4381,22.1607,22.8599,3.25726,3.21699,3.31849,100.975,99.7268,102.873 +GeForce RTX 3090,Voltage,4096,32,32,1024,1,half,41943040,1073741824,10.6234,10.4345,10.684,6468.79,6431.98,6585.8,105.023,104.425,106.923,22.4385,22.3108,22.8444,3.15859,3.14061,3.21572,101.075,100.5,102.903 +GeForce RTX 3090,Voltage,4096,32,64,32,1,half,67633152,33554432,0.635802,0.633792,0.6392,6755.23,6719.29,6776.62,159.15,158.303,159.654,34.003,33.8221,34.1107,105.55,104.989,105.885,52.7752,52.4944,52.9423 +GeForce RTX 3090,Voltage,4096,32,64,64,1,half,68157440,67108864,1.24633,1.24195,1.2623,6892.35,6804.97,6916.48,108.534,107.158,108.914,23.1887,22.8947,23.2699,53.8465,53.1638,54.035,53.8465,53.1638,54.035 +GeForce RTX 3090,Voltage,4096,32,64,96,1,half,68681728,100663296,1.87911,1.85034,1.91123,6858.15,6741.67,6963.55,90.136,88.6052,91.5212,19.2578,18.9308,19.5538,35.7195,35.1129,36.2685,53.5793,52.6693,54.4027 +GeForce RTX 3090,Voltage,4096,32,64,128,1,half,69206016,134217728,2.50962,2.4608,2.54851,6846.68,6741.14,6981.42,81.0703,79.8206,82.6657,17.3209,17.0539,17.6618,26.7449,26.3326,27.2712,53.4897,52.6651,54.5423 +GeForce RTX 3090,Voltage,4096,32,64,160,1,half,69730304,167772160,3.14873,3.07005,3.19562,6821.69,6720.09,6994.95,75.4449,74.3213,77.3612,16.1191,15.879,16.5285,21.3178,21.0003,21.8592,53.2944,52.5007,54.6481 +GeForce RTX 3090,Voltage,4096,32,64,192,1,half,70254592,201326592,3.76538,3.67862,3.828,6845.08,6731.92,7005.28,72.1385,70.946,73.8268,15.4126,15.1578,15.7733,17.8257,17.5311,18.2429,53.4772,52.5932,54.7288 +GeForce RTX 3090,Voltage,4096,32,64,224,1,half,70778880,234881024,4.36289,4.28429,4.43738,6891.74,6775.35,7017.45,70.0664,68.883,71.3444,14.9699,14.7171,15.243,15.3834,15.1235,15.6639,53.8417,52.9324,54.8238 +GeForce RTX 3090,Voltage,4096,32,64,256,1,half,71303168,268435456,4.98691,4.8921,5.0664,6890.86,6781.88,7023.52,68.1347,67.0572,69.4464,14.5572,14.327,14.8375,13.4587,13.2459,13.7178,53.8349,52.9835,54.8713 +GeForce RTX 3090,Voltage,4096,32,64,288,1,half,71827456,301989888,5.63139,5.50365,5.72682,6865.01,6749.77,7023.47,66.3893,65.2749,67.9217,14.1843,13.9462,14.5117,11.9184,11.7184,12.1935,53.6329,52.7326,54.8709 +GeForce RTX 3090,Voltage,4096,32,64,320,1,half,72351744,335544320,6.25862,6.12365,6.37296,6863.23,6739.36,7013.74,65.1805,64.0042,66.61,13.926,13.6747,14.2314,10.7238,10.5303,10.959,53.6189,52.6512,54.7948 +GeForce RTX 3090,Voltage,4096,32,64,352,1,half,72876032,369098752,6.86923,6.72314,6.99485,6878.41,6754.21,7027.17,64.3477,63.1858,65.7394,13.7481,13.4998,14.0454,9.77047,9.59404,9.98178,53.7376,52.7672,54.8998 +GeForce RTX 3090,Voltage,4096,32,64,384,1,half,73400320,402653184,7.48263,7.34755,7.57718,6888.12,6801.95,7014.53,63.6232,62.8272,64.7908,13.5933,13.4232,13.8428,8.96891,8.8567,9.1335,53.8134,53.1402,54.801 +GeForce RTX 3090,Voltage,4096,32,64,416,1,half,73924608,436207616,8.10044,7.95034,8.23766,6893.04,6777.96,7022.92,62.9782,61.9268,64.1649,13.4555,13.2309,13.709,8.28491,8.14659,8.44101,53.8519,52.9528,54.8666 +GeForce RTX 3090,Voltage,4096,32,64,448,1,half,74448896,469762048,8.71379,8.56109,8.79408,6900.73,6837.5,7023.59,62.456,61.8838,63.568,13.3439,13.2217,13.5815,7.70171,7.63114,7.83882,53.912,53.418,54.8718 +GeForce RTX 3090,Voltage,4096,32,64,480,1,half,74973184,503316480,9.33533,9.17037,9.45869,6901.46,6811.15,7025.29,61.9492,61.1385,63.0607,13.2356,13.0624,13.4731,7.18902,7.09494,7.31801,53.9177,53.2121,54.8851 +GeForce RTX 3090,Voltage,4096,32,64,512,1,half,75497472,536870912,9.90367,9.66832,10.0512,6939.32,6836.92,7107.7,61.8372,60.9247,63.3376,13.2117,13.0168,13.5323,6.77668,6.67668,6.94111,54.2135,53.4134,55.5289 +GeForce RTX 3090,Voltage,4096,32,64,544,1,half,76021760,570425344,10.5052,10.2819,10.6774,6950.82,6838.2,7101.27,61.5404,60.5433,62.8724,13.1483,12.9353,13.4329,6.38862,6.28511,6.5269,54.3033,53.4234,55.4787 +GeForce RTX 3090,Voltage,4096,32,64,576,1,half,76546048,603979776,11.1216,10.883,11.2976,6951.62,6842.97,7103.66,61.1926,60.2361,62.5309,13.074,12.8697,13.3599,6.0344,5.94008,6.16637,54.3096,53.4607,55.4973 +GeForce RTX 3090,Voltage,4096,32,64,608,1,half,77070336,637534208,11.7951,11.5387,11.9131,6918.74,6849.96,7072.26,60.587,59.9847,61.9314,12.9446,12.8159,13.2318,5.68975,5.63319,5.816,54.0526,53.5153,55.252 +GeForce RTX 3090,Voltage,4096,32,64,640,1,half,77594624,671088640,12.4058,12.1096,12.581,6924.58,6827.71,7093.51,60.3534,59.5091,61.8258,12.8947,12.7143,13.2093,5.40983,5.33415,5.54181,54.0983,53.3415,55.4181 +GeForce RTX 3090,Voltage,4096,32,64,672,1,half,78118912,704643072,13.0312,12.7007,13.0882,6921.74,6891.26,7101.52,60.0712,59.8066,61.6314,12.8344,12.7779,13.1677,5.15011,5.12742,5.28387,54.0761,53.8379,55.4806 +GeForce RTX 3090,Voltage,4096,32,64,704,1,half,78643200,738197504,13.6736,13.2872,13.9095,6910.77,6793.13,7111.28,59.7422,58.7252,61.4756,12.7641,12.5468,13.1345,4.90822,4.82467,5.05063,53.9904,53.0713,55.5569 +GeForce RTX 3090,Voltage,4096,32,64,736,1,half,79167488,771751936,14.2976,13.8971,14.4306,6909.51,6845.46,7108.29,59.5179,58.9662,61.2302,12.7162,12.5983,13.082,4.69396,4.65045,4.829,53.9805,53.4801,55.5335 +GeForce RTX 3090,Voltage,4096,32,64,768,1,half,79691776,805306368,14.9257,14.5076,15.1994,6906.58,6781.8,7105.18,59.2972,58.2259,61.0023,12.669,12.4402,13.0333,4.49647,4.41523,4.62577,53.9577,52.9828,55.5092 +GeForce RTX 3090,Voltage,4096,32,64,800,1,half,80216064,838860800,15.5445,15.202,15.7051,6907.82,6836.92,7063.15,59.1279,58.5211,60.4576,12.6329,12.5032,12.917,4.31739,4.27307,4.41447,53.9673,53.4134,55.1809 +GeForce RTX 3090,Voltage,4096,32,64,832,1,half,80740352,872415232,16.1542,15.7936,16.3039,6912.96,6849.24,7070.53,59.0058,58.4619,60.3507,12.6068,12.4906,12.8941,4.15442,4.11613,4.24912,54.0075,53.5097,55.2385 +GeForce RTX 3090,Voltage,4096,32,64,864,1,half,81264640,905969664,16.7458,16.5257,16.7923,6925.07,6905.81,7017.21,58.955,58.791,59.7395,12.5959,12.5609,12.7635,4.00756,3.99642,4.06089,54.1021,53.9516,54.822 +GeForce RTX 3090,Voltage,4096,32,64,896,1,half,81788928,939524096,17.4043,16.9057,17.6849,6910.12,6800.09,7113.52,58.6849,57.7505,60.4124,12.5382,12.3386,12.9073,3.85609,3.79469,3.9696,53.9853,53.1257,55.5744 +GeForce RTX 3090,Voltage,4096,32,64,928,1,half,82313216,973078528,18.0364,17.5131,18.237,6906.07,6829.76,7112.06,58.5177,57.871,60.263,12.5025,12.3643,12.8754,3.72094,3.67983,3.83193,53.9537,53.3575,55.5629 +GeForce RTX 3090,Voltage,4096,32,64,960,1,half,82837504,1006632960,18.6714,18.1646,18.8548,6901.21,6833.73,7093.41,58.3525,57.782,59.9776,12.4672,12.3453,12.8144,3.59438,3.55924,3.69448,53.9157,53.3885,55.4173 +GeForce RTX 3090,Voltage,4096,32,64,992,1,half,83361792,1040187392,19.2731,18.7151,19.4985,6908.63,6828.41,7114.24,58.2992,57.6223,60.0343,12.4558,12.3112,12.8265,3.48217,3.44174,3.58581,53.9737,53.347,55.58 +GeForce RTX 3090,Voltage,4096,32,64,1024,1,half,83886080,1073741824,19.8828,19.3125,20.187,6912.9,6808.3,7116.58,58.2264,57.3453,59.9419,12.4403,12.252,12.8068,3.37544,3.32436,3.47489,54.007,53.1898,55.5982 +GeForce RTX 3090,Voltage,4096,32,128,32,1,half,135266304,33554432,1.22649,1.21619,1.24285,7004.29,6911.49,7062.98,137.657,135.834,138.811,29.411,29.0213,29.6574,109.442,107.992,110.359,27.3605,26.998,27.5897 +GeForce RTX 3090,Voltage,4096,32,128,64,1,half,136314880,67108864,2.42055,2.36899,2.4825,7100.43,6920.4,7251.97,84.075,81.9432,85.8693,17.9629,17.5074,18.3463,55.4721,54.0656,56.656,27.7361,27.0328,28.328 +GeForce RTX 3090,Voltage,4096,32,128,96,1,half,137363456,100663296,3.63405,3.5303,3.69773,7092.96,6969.09,7299.6,65.5152,64.3711,67.4239,13.9975,13.7531,14.4053,36.9425,36.2974,38.0187,27.7069,27.223,28.5141 +GeForce RTX 3090,Voltage,4096,32,128,128,1,half,138412032,134217728,4.87836,4.71779,4.95562,7045.06,6933.5,7283.01,55.8996,55.0143,57.7876,11.9431,11.754,12.3465,27.5198,27.084,28.4493,27.5198,27.084,28.4493 +GeForce RTX 3090,Voltage,4096,32,128,160,1,half,139460608,167772160,6.02639,5.85789,6.13728,7128.28,6998.16,7331.94,50.9909,50.0601,52.4477,10.8944,10.6955,11.2056,22.2759,21.8693,22.9123,27.8449,27.3366,28.6404 +GeForce RTX 3090,Voltage,4096,32,128,192,1,half,140509184,201326592,7.21485,7.02733,7.30349,7144.29,7056.85,7334.17,47.3844,46.8045,48.6438,10.1238,9.99993,10.3929,18.6049,18.3772,19.0994,27.9074,27.5658,28.6491 +GeForce RTX 3090,Voltage,4096,32,128,224,1,half,141557760,234881024,8.42883,8.18509,8.57446,7134.71,7012.63,7346.23,44.6666,43.9023,45.9908,9.54317,9.37987,9.82609,15.9257,15.6532,16.3978,27.87,27.3931,28.6962 +GeForce RTX 3090,Voltage,4096,32,128,256,1,half,142606336,268435456,9.70478,9.41955,9.87235,7081.52,6960.8,7295.41,42.3577,41.6357,43.6371,9.04986,8.89559,9.32321,13.8311,13.5953,14.2488,27.6622,27.1906,28.4977 +GeForce RTX 3090,Voltage,4096,32,128,288,1,half,143654912,301989888,10.8897,10.5885,11.0995,7100.05,6965.15,7301.25,40.9277,40.1502,42.0876,8.74434,8.57821,8.99215,12.3265,12.0923,12.6758,27.7346,27.2076,28.5205 +GeForce RTX 3090,Voltage,4096,32,128,320,1,half,144703488,335544320,12.1198,11.7731,12.242,7087.9,7016.76,7296.23,39.6272,39.2295,40.7919,8.46647,8.38151,8.71532,11.0748,10.9637,11.4004,27.6871,27.4092,28.5009 +GeForce RTX 3090,Voltage,4096,32,128,352,1,half,145752064,369098752,13.3087,12.9291,13.4462,7100.15,7027.19,7308.29,38.6871,38.2896,39.8212,8.26563,8.18069,8.50793,10.0854,9.9818,10.3811,27.7349,27.45,28.548 +GeForce RTX 3090,Voltage,4096,32,128,384,1,half,146800640,402653184,14.5309,14.1673,14.6808,7094.05,7021.36,7275.87,37.8141,37.4267,38.7833,8.07912,7.99634,8.28619,9.23704,9.1424,9.47379,27.7111,27.4272,28.4214 +GeForce RTX 3090,Voltage,4096,32,128,416,1,half,147849216,436207616,15.7389,15.3648,15.8398,7095.32,7049.91,7267.86,37.1102,36.8727,38.0127,7.92873,7.87798,8.12153,8.52803,8.47344,8.7354,27.7161,27.5387,28.3901 +GeForce RTX 3090,Voltage,4096,32,128,448,1,half,148897792,469762048,16.945,16.626,17.2414,7097.44,6975.03,7233.19,36.512,35.8823,37.2103,7.80091,7.66637,7.95011,7.92125,7.78463,8.07275,27.7244,27.2462,28.2546 +GeForce RTX 3090,Voltage,4096,32,128,480,1,half,149946368,503316480,18.1113,17.8094,18.3309,7114.5,7029.06,7234.88,36.0704,35.6372,36.6808,7.70657,7.61401,7.83697,7.41094,7.32193,7.53634,27.791,27.4573,28.2613 +GeForce RTX 3090,Voltage,4096,32,128,512,1,half,150994944,536870912,19.3048,18.9621,19.6201,7119.69,7005,7248.08,35.6332,35.0592,36.2758,7.61315,7.49051,7.75044,6.95282,6.84082,7.07821,27.8113,27.3633,28.3128 +GeForce RTX 3090,Voltage,4096,32,128,544,1,half,152043520,570425344,20.5851,20.0976,21.1061,7094.41,6918.81,7265.99,35.0991,34.2304,35.948,7.49905,7.31343,7.68041,6.5206,6.3592,6.6783,27.7125,27.0266,28.3828 +GeForce RTX 3090,Voltage,4096,32,128,576,1,half,153092096,603979776,21.7825,21.1426,22.1701,7098.81,6974.19,7313.14,34.7584,34.1483,35.8079,7.42625,7.29589,7.65048,6.16216,6.05399,6.34822,27.7297,27.2429,28.567 +GeForce RTX 3090,Voltage,4096,32,128,608,1,half,154140672,637534208,23.0538,22.7198,23.6126,7079.89,6911.93,7183.54,34.3424,33.5276,34.8451,7.33736,7.16329,7.44478,5.82228,5.68415,5.90752,27.6558,26.9997,28.0607 +GeForce RTX 3090,Voltage,4096,32,128,640,1,half,155189248,671088640,24.2863,23.8911,24.8346,7074.46,6917.71,7190.9,34.0251,33.2712,34.5851,7.26957,7.1085,7.38923,5.52692,5.40446,5.61789,27.6346,27.0223,28.0894 +GeForce RTX 3090,Voltage,4096,32,128,672,1,half,156237824,704643072,25.536,24.9636,26.2933,7065,6860.64,7226.06,33.7168,32.7415,34.4854,7.2037,6.99533,7.36792,5.2567,5.10464,5.37653,27.5977,26.7994,28.2268 +GeForce RTX 3090,Voltage,4096,32,128,704,1,half,157286400,738197504,26.7594,26.2744,27.494,7062.96,6873.45,7192.51,33.4682,32.5702,34.082,7.15058,6.95873,7.28174,5.01631,4.88171,5.10831,27.5897,26.8494,28.0957 +GeForce RTX 3090,Voltage,4096,32,128,736,1,half,158334976,771751936,27.9895,27.5675,28.6075,7059.46,6906.18,7166.72,33.2336,32.512,33.7385,7.10047,6.9463,7.20835,4.79583,4.6917,4.8687,27.576,26.9773,27.995 +GeForce RTX 3090,Voltage,4096,32,128,768,1,half,159383552,805306368,29.1914,28.527,29.8343,7063.34,6910.12,7226.79,33.0519,32.335,33.8168,7.06165,6.90847,7.22506,4.59853,4.49878,4.70494,27.5912,26.9927,28.2296 +GeForce RTX 3090,Voltage,4096,32,128,800,1,half,160432128,838860800,30.4525,29.8449,31.1188,7052.8,6900.91,7195.47,32.819,32.1121,33.4828,7.01188,6.86087,7.15372,4.408,4.31307,4.49717,27.55,26.9567,28.1073 +GeForce RTX 3090,Voltage,4096,32,128,832,1,half,161480704,872415232,31.6257,31.2405,32.2769,7062.8,6919.46,7149,32.6957,32.0321,33.0947,6.98554,6.84377,7.0708,4.24447,4.15833,4.29627,27.5891,27.0291,27.9258 +GeForce RTX 3090,Voltage,4096,32,128,864,1,half,162529280,905969664,32.8261,32.4799,33.4841,7066.07,6926.53,7140.67,32.5535,31.9107,32.8972,6.95517,6.81782,7.0286,4.08916,4.00841,4.13233,27.6018,27.0567,27.8932 +GeForce RTX 3090,Voltage,4096,32,128,896,1,half,163577856,939524096,34.0788,33.7346,34.9564,7058.59,6880.52,7129.71,32.3732,31.5565,32.6994,6.91664,6.74216,6.98633,3.93895,3.83958,3.97863,27.5726,26.877,27.8504 +GeForce RTX 3090,Voltage,4096,32,128,928,1,half,164626432,973078528,35.3283,34.957,36.269,7052.16,6868.34,7126.14,32.208,31.3685,32.5459,6.88135,6.70198,6.95353,3.79966,3.70062,3.83951,27.5475,26.8295,27.8365 +GeForce RTX 3090,Voltage,4096,32,128,960,1,half,165675008,1006632960,36.6467,36.3141,37.0597,7032.23,6953.58,7096.36,31.9907,31.6329,32.2824,6.83491,6.75848,6.89725,3.66262,3.62166,3.69602,27.4696,27.1624,27.7202 +GeForce RTX 3090,Voltage,4096,32,128,992,1,half,166723584,1040187392,37.8424,37.501,38.4897,7037.08,6918.42,7100.83,31.8946,31.3567,32.1835,6.81438,6.69947,6.8761,3.54692,3.48711,3.57905,27.4886,27.0251,27.7376 +GeForce RTX 3090,Voltage,4096,32,128,1024,1,half,167772160,1073741824,39.0385,38.6972,39.7854,7041.5,6909.01,7103.3,31.8036,31.2053,32.0828,6.79495,6.66711,6.8546,3.43823,3.37354,3.46841,27.5058,26.9883,27.7473 +GeForce RTX 3090,Voltage,4096,32,256,32,1,half,270532608,33554432,2.46005,2.37658,2.58413,6991.09,6648.23,7228.83,123.744,117.675,127.952,26.4382,25.1416,27.3373,109.236,103.879,112.951,13.6545,12.9848,14.1188 +GeForce RTX 3090,Voltage,4096,32,256,64,1,half,272629760,67108864,4.88258,4.68928,5.01082,7039.28,6857.11,7327.29,69.6023,67.8011,72.4501,14.8708,14.4859,15.4792,54.9944,53.5712,57.2445,13.7486,13.3928,14.3111 +GeForce RTX 3090,Voltage,4096,32,256,96,1,half,274726912,100663296,7.2692,7.02093,7.54397,7092.33,6831.9,7340.85,51.6572,49.7603,53.4673,11.0367,10.6315,11.4235,36.9392,35.5828,38.2336,13.8522,13.3435,14.3376 +GeForce RTX 3090,Voltage,4096,32,256,128,1,half,276824064,134217728,9.61421,9.41094,9.6319,7147.9,7134.57,7302.08,42.7548,42.675,43.677,9.1347,9.11766,9.33173,27.9215,27.8694,28.5238,13.9607,13.9347,14.2619 +GeForce RTX 3090,Voltage,4096,32,256,160,1,half,278921216,167772160,12.048,11.6501,12.4385,7130.72,6905.93,7373.28,37.0811,35.9122,38.3425,7.9225,7.67275,8.19201,22.2835,21.581,23.0415,13.9272,13.4881,14.4009 +GeForce RTX 3090,Voltage,4096,32,256,192,1,half,281018368,201326592,14.4509,13.9684,14.9061,7133.95,6915.22,7379.45,33.3824,32.3588,34.5311,7.13225,6.91357,7.37769,18.578,18.0084,19.2173,13.9335,13.5063,14.413 +GeForce RTX 3090,Voltage,4096,32,256,224,1,half,283115520,234881024,16.8358,16.4866,17.2361,7143.48,6977.18,7294.37,30.7694,30.0531,31.4193,6.57398,6.42094,6.71284,15.9453,15.5741,16.2821,13.9521,13.6273,14.2468 +GeForce RTX 3090,Voltage,4096,32,256,256,1,half,285212672,268435456,19.2488,18.9449,19.8518,7140.62,6923.25,7254.66,28.7647,27.8891,29.2241,6.14567,5.95859,6.24382,13.9465,13.522,14.1693,13.9465,13.522,14.1693 +GeForce RTX 3090,Voltage,4096,32,256,288,1,half,287309824,301989888,21.6071,21.0678,22.1389,7156.39,6984.04,7339.1,27.2752,26.6183,27.9716,5.82743,5.68709,5.97622,12.4243,12.1251,12.7415,13.9773,13.6407,14.3342 +GeForce RTX 3090,Voltage,4096,32,256,320,1,half,289406976,335544320,24.0885,23.7003,24.7544,7132.65,6940.14,7248.8,25.9464,25.2461,26.3689,5.54354,5.39391,5.63381,11.1448,10.844,11.3263,13.931,13.555,14.1578 +GeForce RTX 3090,Voltage,4096,32,256,352,1,half,291504128,369098752,26.5198,26.0825,27.2632,7126.75,6931.64,7245.41,24.9126,24.2306,25.3274,5.32266,5.17695,5.41129,10.1232,9.84608,10.2918,13.9194,13.5384,14.1512 +GeForce RTX 3090,Voltage,4096,32,256,384,1,half,293601280,402653184,28.9322,28.5119,29.4973,7126.2,6989.05,7230.62,24.0672,23.604,24.4198,5.14203,5.04307,5.21737,9.2789,9.10033,9.41487,13.9184,13.6505,14.1223 +GeForce RTX 3090,Voltage,4096,32,256,416,1,half,295698432,436207616,31.3677,31.1721,32.2094,7120.61,6933.94,7164.69,23.3351,22.7233,23.4795,4.98562,4.85492,5.01648,8.55843,8.33406,8.6114,13.9074,13.5429,13.9935 +GeForce RTX 3090,Voltage,4096,32,256,448,1,half,297795584,469762048,33.7469,33.5612,34.3921,7127.6,6993.42,7166.56,22.7461,22.3179,22.8704,4.85977,4.76829,4.88634,7.95491,7.80516,7.99839,13.9211,13.659,13.9972 +GeForce RTX 3090,Voltage,4096,32,256,480,1,half,299892736,503316480,36.1385,35.9687,36.8831,7131.26,6986.89,7164.5,22.2272,21.7772,22.3308,4.7489,4.65276,4.77104,7.4284,7.27801,7.46302,13.9282,13.6463,13.9932 +GeForce RTX 3090,Voltage,4096,32,256,512,1,half,301989888,536870912,38.5208,38.3419,39.2927,7136.28,6995.65,7169.12,21.7782,21.349,21.8784,4.65299,4.56129,4.6744,6.96903,6.83169,7.0011,13.9381,13.6634,14.0022 +GeForce RTX 3090,Voltage,4096,32,256,544,1,half,304087040,570425344,41.0066,40.7515,41.8598,7122.83,6977.04,7166.79,21.328,20.8915,21.4596,4.5568,4.46353,4.58492,6.54672,6.41272,6.58713,13.9118,13.627,13.9976 +GeForce RTX 3090,Voltage,4096,32,256,576,1,half,306184192,603979776,43.3867,43.139,44.2364,7127.99,6990.58,7168.39,20.9795,20.575,21.0984,4.48233,4.39592,4.50774,6.18749,6.06821,6.22256,13.9219,13.6535,14.0008 +GeForce RTX 3090,Voltage,4096,32,256,608,1,half,308281344,637534208,45.7642,45.5284,46.7077,7133.07,6988.52,7169.53,20.6685,20.2497,20.7742,4.4159,4.32641,4.43847,5.86601,5.74714,5.89599,13.9318,13.6495,14.003 +GeForce RTX 3090,Voltage,4096,32,256,640,1,half,310378496,671088640,48.2474,47.9367,49.2373,7122.11,6978.39,7167.73,20.3439,19.9334,20.4742,4.34654,4.25884,4.37439,5.56415,5.45187,5.59979,13.9104,13.6297,13.9995 +GeForce RTX 3090,Voltage,4096,32,256,672,1,half,312475648,704643072,50.6752,50.3151,51.6218,7119.92,6988.86,7170.36,20.0728,19.7033,20.215,4.28862,4.20967,4.319,5.29756,5.20004,5.33509,13.9061,13.6501,14.0046 +GeForce RTX 3090,Voltage,4096,32,256,704,1,half,314572800,738197504,53.1064,52.7065,54.2271,7117.64,6969.89,7170.98,19.8256,19.4141,19.9742,4.23581,4.14788,4.26755,5.05514,4.95021,5.09302,13.9016,13.6131,14.0058 +GeForce RTX 3090,Voltage,4096,32,256,736,1,half,316669952,771751936,55.5625,55.1002,56.5884,7112.29,6982.64,7171.25,19.5911,19.234,19.7535,4.18571,4.10941,4.2204,4.83172,4.74364,4.87177,13.8912,13.638,14.0063 +GeForce RTX 3090,Voltage,4096,32,256,768,1,half,318767104,805306368,58.0245,57.5044,59.159,7106.67,6969.64,7170.18,19.3745,19.0009,19.5476,4.13942,4.0596,4.17641,4.62674,4.53753,4.66808,13.8802,13.6126,14.0043 +GeForce RTX 3090,Voltage,4096,32,256,800,1,half,320864256,838860800,60.4499,59.8964,61.7456,7105.81,6955.91,7170.66,19.1871,18.7823,19.3622,4.09938,4.0129,4.1368,4.44113,4.34744,4.48166,13.8785,13.5858,14.0052 +GeForce RTX 3090,Voltage,4096,32,256,832,1,half,322961408,872415232,62.8071,62.2779,64.1095,7112.58,6967.4,7172.31,19.0344,18.6459,19.1942,4.06676,3.98375,4.10091,4.27438,4.18714,4.31028,13.8917,13.6082,14.0084 +GeForce RTX 3090,Voltage,4096,32,256,864,1,half,325058560,905969664,65.2245,64.6578,66.5712,7112.35,6967.83,7174.02,18.8755,18.4919,19.0391,4.0328,3.95086,4.06777,4.11594,4.03231,4.15163,13.8913,13.609,14.0118 +GeForce RTX 3090,Voltage,4096,32,256,896,1,half,327155712,939524096,67.6595,67.0531,69.0817,7110.44,6963.29,7173.97,18.7234,18.336,18.8907,4.00032,3.91754,4.03606,3.96788,3.88577,4.00333,13.8876,13.6002,14.0117 +GeForce RTX 3090,Voltage,4096,32,256,928,1,half,329252864,973078528,70.0703,69.4636,71.4424,7110.84,6973.68,7172.33,18.5876,18.2291,18.7484,3.97131,3.89471,4.00565,3.83127,3.75737,3.8644,13.8884,13.6205,14.0085 +GeForce RTX 3090,Voltage,4096,32,256,960,1,half,331350016,1006632960,72.559,71.8723,73.9607,7103.62,6968.51,7171,18.4412,18.0905,18.6161,3.94002,3.86509,3.9774,3.6998,3.62943,3.7349,13.8743,13.6104,14.0059 +GeForce RTX 3090,Voltage,4096,32,256,992,1,half,333447168,1040187392,74.9764,74.2436,76.4271,7103.83,6968.41,7173.36,18.3224,17.9731,18.5017,3.91464,3.84002,3.95296,3.58056,3.51231,3.61561,13.8747,13.6102,14.0105 +GeForce RTX 3090,Voltage,4096,32,256,1024,1,half,335544320,1073741824,77.3995,76.623,78.9679,7103.58,6961.76,7174.81,18.2099,17.8463,18.3925,3.8906,3.81292,3.92961,3.46855,3.3993,3.50333,13.8742,13.5972,14.0133 +GeForce RTX 3090,Voltage,4096,32,512,32,1,half,541065216,33554432,4.93667,4.69958,5.13827,6963.87,6687.02,7311.23,116.461,111.831,122.27,24.8823,23.8931,26.1235,108.811,104.485,114.238,6.80066,6.5303,7.13987 +GeForce RTX 3090,Voltage,4096,32,512,64,1,half,545259520,67108864,9.70563,9.27946,10.1671,7083.48,6758.98,7405.55,63.1218,60.2302,65.9918,13.4862,12.8684,14.0994,55.3397,52.8045,57.8559,6.91746,6.60057,7.23198 +GeForce RTX 3090,Voltage,4096,32,512,96,1,half,549453824,100663296,14.5084,13.8821,15.1393,7106.43,6808.7,7425.31,44.82,42.9423,46.8312,9.57594,9.17476,10.0056,37.0127,35.462,38.6735,6.93987,6.64913,7.25128 +GeForce RTX 3090,Voltage,4096,32,512,128,1,half,553648128,134217728,19.2418,18.8382,20.118,7143.76,6831.66,7295.76,35.7537,34.1916,36.5144,7.63889,7.30516,7.80142,27.9053,26.6862,28.499,6.97633,6.67154,7.12476 +GeForce RTX 3090,Voltage,4096,32,512,160,1,half,557842432,167772160,24.0824,23.7478,24.6676,7134.62,6964.56,7234.31,30.134,29.4158,30.5551,6.43823,6.28477,6.52819,22.2957,21.7643,22.6072,6.9674,6.80133,7.06475 +GeForce RTX 3090,Voltage,4096,32,512,192,1,half,562036736,201326592,28.9218,28.566,29.5377,7129.47,6979.5,7216.9,26.399,25.8437,26.7227,5.64023,5.52159,5.7094,18.5663,18.1758,18.794,6.96237,6.81591,7.04776 +GeForce RTX 3090,Voltage,4096,32,512,224,1,half,566231040,234881024,33.6185,33.3096,34.4382,7155.13,6984.05,7220.69,23.8321,23.2623,24.0505,5.09182,4.97007,5.13847,15.9713,15.5894,16.1176,6.98744,6.82036,7.05146 +GeForce RTX 3090,Voltage,4096,32,512,256,1,half,570425344,268435456,38.4403,38.0666,39.2312,7151.47,7006.61,7220.97,21.8245,21.3825,22.0367,4.66289,4.56844,4.70821,13.9677,13.6848,14.1035,6.98386,6.8424,7.05173 +GeForce RTX 3090,Voltage,4096,32,512,288,1,half,574619648,301989888,43.2235,42.8079,44.2446,7155.41,6989.28,7223.84,20.2838,19.8128,20.4778,4.33369,4.23307,4.37514,12.4226,12.1342,12.5414,6.98771,6.82547,7.05454 +GeForce RTX 3090,Voltage,4096,32,512,320,1,half,578813952,335544320,48.0092,47.551,48.9632,7157.59,7017.46,7225.87,19.0473,18.6744,19.229,4.06952,3.98984,4.10834,11.1837,10.9648,11.2904,6.98983,6.85299,7.05651 +GeForce RTX 3090,Voltage,4096,32,512,352,1,half,583008256,369098752,53.0405,52.2798,54.1937,7126.92,6974.19,7229.51,17.9533,17.5686,18.2118,3.83579,3.75359,3.891,10.1235,9.90651,10.2692,6.95989,6.81073,7.06007 +GeForce RTX 3090,Voltage,4096,32,512,384,1,half,587202560,402653184,58.0131,57.4909,58.9518,7107.98,6994.14,7171.86,17.0642,16.7909,17.2176,3.64583,3.58744,3.6786,9.25518,9.10695,9.33836,6.94139,6.83021,7.00377 +GeForce RTX 3090,Voltage,4096,32,512,416,1,half,591396864,436207616,62.7643,61.7709,63.9946,7117.64,6979.91,7231.18,16.3745,16.0577,16.6357,3.49847,3.43078,3.55428,8.55486,8.38932,8.69133,6.95082,6.81632,7.0617 +GeForce RTX 3090,Voltage,4096,32,512,448,1,half,595591168,469762048,67.6321,67.045,69.1179,7113.37,6959.65,7174.83,15.754,15.4136,15.8901,3.3659,3.29316,3.39498,7.93903,7.76746,8.00763,6.94665,6.79653,7.00667 +GeForce RTX 3090,Voltage,4096,32,512,480,1,half,599785472,503316480,72.4508,71.8376,74.005,7114.31,6964.34,7174.46,15.2268,14.9058,15.3555,3.25325,3.18467,3.28075,7.41074,7.25452,7.47339,6.94757,6.80112,7.00631 +GeForce RTX 3090,Voltage,4096,32,512,512,1,half,603979776,536870912,77.3268,76.6014,78.577,7110.13,6996.39,7176.84,14.7549,14.5189,14.8933,3.15243,3.10201,3.18201,6.94349,6.83242,7.00863,6.94349,6.83242,7.00863 +GeForce RTX 3090,Voltage,4096,32,512,544,1,half,608174080,570425344,82.2337,81.4003,83.6228,7103.76,6985.12,7175.84,14.3336,14.0942,14.4791,3.06243,3.01128,3.0935,6.5292,6.42015,6.59545,6.93727,6.82141,7.00766 +GeForce RTX 3090,Voltage,4096,32,512,576,1,half,612368384,603979776,86.9705,86.1719,88.3664,7111.81,6998.99,7177.23,13.9867,13.7648,14.1154,2.98831,2.9409,3.01579,6.17344,6.07551,6.23023,6.94512,6.83495,7.00901 +GeForce RTX 3090,Voltage,4096,32,512,608,1,half,616562688,637534208,91.8143,90.9521,93.2591,7110.86,7000.23,7177.79,13.66,13.4474,13.7885,2.9185,2.87309,2.94597,5.84775,5.75677,5.90279,6.9442,6.83616,7.00956 +GeForce RTX 3090,Voltage,4096,32,512,640,1,half,620756992,671088640,96.7248,95.7505,98.7377,7105.29,6959.8,7176.93,13.3571,13.0836,13.4918,2.85379,2.79536,2.88257,5.55101,5.43735,5.60698,6.93876,6.79668,7.00872 +GeForce RTX 3090,Voltage,4096,32,512,672,1,half,624951296,704643072,101.568,100.518,103.146,7104.66,6995.45,7178.37,13.0916,12.8904,13.2274,2.79707,2.75407,2.82609,5.28621,5.20495,5.34105,6.93815,6.8315,7.01012 +GeForce RTX 3090,Voltage,4096,32,512,704,1,half,629145600,738197504,106.405,105.288,108.508,7104.7,6966.43,7179.5,12.8514,12.6013,12.9867,2.74575,2.69231,2.77465,5.04595,4.94775,5.09908,6.93819,6.80315,7.01123 +GeForce RTX 3090,Voltage,4096,32,512,736,1,half,633339904,771751936,111.271,110.079,113.458,7102.7,6965.34,7179.13,12.6285,12.3842,12.7643,2.69811,2.64594,2.72715,4.82521,4.73189,4.87712,6.93623,6.80209,7.01087 +GeForce RTX 3090,Voltage,4096,32,512,768,1,half,637534208,805306368,116.118,114.861,118.082,7102.26,6983.55,7179.43,12.4267,12.2189,12.5617,2.65499,2.61062,2.68384,4.62387,4.54658,4.67411,6.9358,6.81987,7.01116 +GeForce RTX 3090,Voltage,4096,32,512,800,1,half,641728512,838860800,120.93,119.644,122.962,7103.75,6985.84,7179.56,12.2443,12.041,12.3749,2.61603,2.57261,2.64395,4.43985,4.36615,4.48723,6.93726,6.82211,7.01129 +GeForce RTX 3090,Voltage,4096,32,512,832,1,half,645922816,872415232,125.914,124.414,128.448,7095.51,6954.97,7180.5,12.0595,11.8206,12.2039,2.57655,2.52552,2.60741,4.26413,4.17967,4.3152,6.92921,6.79196,7.0122 +GeForce RTX 3090,Voltage,4096,32,512,864,1,half,650117120,905969664,130.816,129.213,133.458,7092.34,6951.32,7179.75,11.8962,11.6597,12.0428,2.54167,2.49114,2.57299,4.10436,4.02276,4.15495,6.92612,6.7884,7.01147 +GeForce RTX 3090,Voltage,4096,32,512,896,1,half,654311424,939524096,135.589,133.971,138.263,7096.05,6958.27,7181.19,11.7558,11.5275,11.8969,2.51166,2.4629,2.5418,3.95985,3.88296,4.00736,6.92973,6.79518,7.01288 +GeForce RTX 3090,Voltage,4096,32,512,928,1,half,658505728,973078528,140.535,138.764,143.359,7090.75,6950.62,7180.76,11.6106,11.3811,11.758,2.48064,2.43161,2.51213,3.82045,3.74494,3.86894,6.92456,6.78771,7.01246 +GeForce RTX 3090,Voltage,4096,32,512,960,1,half,662700032,1006632960,145.302,143.555,147.881,7094.53,6970.41,7180.48,11.4893,11.2883,11.6285,2.45474,2.41179,2.48448,3.69507,3.63042,3.73983,6.92825,6.80704,7.01218 +GeForce RTX 3090,Voltage,4096,32,512,992,1,half,666894336,1040187392,150.127,148.485,152.109,7095.31,7002.57,7173.48,11.3714,11.2228,11.4967,2.42954,2.39778,2.4563,3.57626,3.52952,3.61566,6.92901,6.83845,7.00535 +GeForce RTX 3090,Voltage,4096,32,512,1024,1,half,671088640,1073741824,155.036,154.004,156.478,7092.16,7026.62,7139.5,11.2547,11.1506,11.3298,2.40459,2.38237,2.42064,3.46297,3.43097,3.48608,6.92594,6.86193,6.97217 +GeForce RTX 3090,Voltage,4096,32,1024,32,1,half,1082130432,33554432,9.87623,9.40669,10.3464,6960.37,6641.85,7305.39,113.004,107.833,118.605,24.1437,23.0388,25.3405,108.756,103.779,114.147,3.39862,3.24309,3.56708 +GeForce RTX 3090,Voltage,4096,32,1024,64,1,half,1090519040,67108864,19.4149,18.8643,19.8545,7079.63,6922.31,7285.66,59.6307,58.3056,61.366,12.7403,12.4572,13.111,55.3096,54.0805,56.9192,3.45685,3.38003,3.55745 +GeForce RTX 3090,Voltage,4096,32,1024,96,1,half,1098907648,100663296,29.2508,28.9063,29.9641,7048.98,6880.17,7131.96,41.0158,40.0336,41.4986,8.76316,8.5533,8.86632,36.7134,35.8342,37.1456,3.44189,3.35946,3.4824 +GeForce RTX 3090,Voltage,4096,32,1024,128,1,half,1107296256,134217728,38.8415,38.5776,39.7827,7077.57,6909.49,7125.32,31.9665,31.2074,32.1823,6.82976,6.66757,6.87584,27.6467,26.9902,27.8333,3.45584,3.37377,3.47916 +GeForce RTX 3090,Voltage,4096,32,1024,160,1,half,1115684864,167772160,48.5318,48.1934,49.8053,7080.52,6898.81,7129.56,26.4482,25.7695,26.6314,5.65075,5.50574,5.68989,22.1266,21.5588,22.2799,3.45728,3.36856,3.48123 +GeForce RTX 3090,Voltage,4096,32,1024,192,1,half,1124073472,201326592,58.2476,57.7842,59.4061,7079.3,6940.65,7135.46,22.7565,22.3108,22.9371,4.86201,4.76678,4.90058,18.4357,18.0746,18.5819,3.45669,3.38899,3.48411 +GeForce RTX 3090,Voltage,4096,32,1024,224,1,half,1132462080,234881024,67.8249,67.3881,69.5313,7092.84,6918.27,7138.29,20.1614,19.6652,20.2906,4.30754,4.20153,4.33515,15.8322,15.4426,15.9337,3.4633,3.37806,3.4855 +GeForce RTX 3090,Voltage,4096,32,1024,256,1,half,1140850688,268435456,77.4774,76.9847,78.92,7096.06,6965.99,7141.11,18.1906,17.8571,18.3061,3.88648,3.81524,3.91115,13.8595,13.6054,13.9475,3.46487,3.40136,3.48687 +GeForce RTX 3090,Voltage,4096,32,1024,288,1,half,1149239296,301989888,87.1286,86.3978,88.7407,7098.81,6969.47,7158.46,16.6571,16.3536,16.7971,3.55885,3.494,3.58875,12.3243,12.0998,12.4279,3.46622,3.40306,3.49534 +GeForce RTX 3090,Voltage,4096,32,1024,320,1,half,1157627904,335544320,96.7691,95.8576,98.5897,7101.82,6970.25,7168.91,15.4312,15.1453,15.577,3.29693,3.23585,3.32807,11.0966,10.891,11.2014,3.46768,3.40344,3.50044 +GeForce RTX 3090,Voltage,4096,32,1024,352,1,half,1166016512,369098752,106.357,105.427,108.48,7107.77,6968.22,7170.06,14.4345,14.1511,14.561,3.08398,3.02343,3.111,10.0963,9.89804,10.1847,3.47059,3.40245,3.501 +GeForce RTX 3090,Voltage,4096,32,1024,384,1,half,1174405120,402653184,116.056,115.083,117.915,7105.89,6993.46,7165.59,13.5896,13.3745,13.7037,2.90345,2.85751,2.92784,9.25247,9.10606,9.33019,3.46967,3.41477,3.49882 +GeForce RTX 3090,Voltage,4096,32,1024,416,1,half,1182793728,436207616,125.79,124.643,127.839,7102.36,6988.1,7167.29,12.8714,12.6644,12.9891,2.75002,2.70578,2.77517,8.53649,8.39916,8.61454,3.46795,3.41216,3.49966 +GeForce RTX 3090,Voltage,4096,32,1024,448,1,half,1191182336,469762048,135.378,133.723,138.005,7106.98,6971.3,7194.51,12.2696,12.0354,12.4208,2.62145,2.5714,2.65374,7.93189,7.78046,8.02958,3.4702,3.40395,3.51294 +GeForce RTX 3090,Voltage,4096,32,1024,480,1,half,1199570944,503316480,145.042,143.854,147.091,7107.14,7007.86,7165.53,11.7411,11.5771,11.8376,2.50853,2.47349,2.52914,7.40327,7.29985,7.4641,3.47028,3.42181,3.4988 +GeForce RTX 3090,Voltage,4096,32,1024,512,1,half,1207959552,536870912,154.699,152.943,156.488,7107.66,7026.19,7189.01,11.2793,11.15,11.4083,2.40985,2.38223,2.43743,6.94108,6.86151,7.02052,3.47054,3.43076,3.51026 +GeForce RTX 3090,Voltage,4096,32,1024,544,1,half,1216348160,570425344,164.475,163.022,166.008,7102.93,7037.19,7166.1,10.8637,10.7632,10.9603,2.32107,2.29959,2.34171,6.52842,6.46801,6.58649,3.46823,3.43613,3.49907 +GeForce RTX 3090,Voltage,4096,32,1024,576,1,half,1224736768,603979776,174.372,172.752,177.687,7094.06,6961.4,7160.26,10.4879,10.2918,10.5858,2.24078,2.19887,2.26169,6.15804,6.04288,6.2155,3.4639,3.39912,3.49622 +GeForce RTX 3090,Voltage,4096,32,1024,608,1,half,1233125376,637534208,184.301,182.42,187.63,7084.76,6958.73,7157.49,10.1505,9.96992,10.2547,2.16868,2.13011,2.19095,5.82628,5.72264,5.88609,3.45936,3.39782,3.49487 +GeForce RTX 3090,Voltage,4096,32,1024,640,1,half,1241513984,671088640,194.238,192.087,197.734,7076.12,6950.71,7155.04,9.84714,9.67261,9.95697,2.10387,2.06659,2.12734,5.52822,5.43024,5.58988,3.45514,3.3939,3.49367 +GeForce RTX 3090,Voltage,4096,32,1024,672,1,half,1249902592,704643072,204.464,202.353,207.077,7058.33,6968.96,7131.64,9.5598,9.43876,9.65909,2.04248,2.01662,2.0637,5.25174,5.18524,5.30628,3.44645,3.40281,3.48225 +GeForce RTX 3090,Voltage,4096,32,1024,704,1,half,1258291200,738197504,214.453,212.163,217.399,7049.93,6954.15,7125.79,9.30999,9.1835,9.41016,1.98911,1.96209,2.01051,5.00705,4.93903,5.06093,3.44235,3.39558,3.47939 +GeForce RTX 3090,Voltage,4096,32,1024,736,1,half,1266679808,771751936,224.519,222.558,227.115,7039.95,6959.24,7101.74,9.07942,8.97532,9.15911,1.93985,1.91761,1.95687,4.78257,4.72774,4.82455,3.43747,3.39806,3.46765 +GeForce RTX 3090,Voltage,4096,32,1024,768,1,half,1275068416,805306368,234.024,231.65,236.096,7047.67,6985.57,7119.66,8.88988,8.81156,8.98069,1.89935,1.88262,1.91875,4.58832,4.5479,4.6352,3.44124,3.41092,3.4764 +GeForce RTX 3090,Voltage,4096,32,1024,800,1,half,1283457024,838860800,243.632,241.724,244.81,7051.65,7017.62,7107.21,8.71127,8.66923,8.77991,1.86119,1.85221,1.87586,4.40728,4.38601,4.44201,3.44319,3.42657,3.47032 +GeForce RTX 3090,Voltage,4096,32,1024,832,1,half,1291845632,872415232,253.362,251.314,256.713,7052.15,6959.95,7109.47,8.54237,8.43067,8.61179,1.8251,1.80124,1.83994,4.23807,4.18266,4.27252,3.44343,3.39841,3.47142 +GeForce RTX 3090,Voltage,4096,32,1024,864,1,half,1300234240,905969664,263.522,261.839,265.969,7041.01,6976.09,7086.14,8.37215,8.29496,8.42582,1.78874,1.77225,1.8002,4.07466,4.03709,4.10078,3.43799,3.4063,3.46003 +GeForce RTX 3090,Voltage,4096,32,1024,896,1,half,1308622848,939524096,273.183,271.051,277.168,7043.63,6942.15,7098.83,8.22969,8.11112,8.29418,1.7583,1.73297,1.77208,3.9306,3.87397,3.9614,3.43927,3.38972,3.46622 +GeForce RTX 3090,Voltage,4096,32,1024,928,1,half,1317011456,973078528,282.932,280.08,288.193,7043.88,6915.04,7115.34,8.09444,7.94638,8.17655,1.7294,1.69777,1.74695,3.79519,3.72577,3.8337,3.4394,3.37648,3.47429 +GeForce RTX 3090,Voltage,4096,32,1024,960,1,half,1325400064,1006632960,292.86,290.684,297.496,7039.65,6929.8,7092.19,7.96315,7.83888,8.02257,1.70135,1.6748,1.71405,3.66648,3.60927,3.69385,3.43733,3.38369,3.46298 +GeForce RTX 3090,Voltage,4096,32,1024,992,1,half,1333788672,1040187392,302.596,300.218,307.195,7040.25,6934.7,7095.85,7.84554,7.72791,7.9075,1.67622,1.65109,1.68946,3.54851,3.49531,3.57653,3.43762,3.38608,3.46477 +GeForce RTX 3090,Voltage,4096,32,1024,1024,1,half,1342177280,1073741824,312.409,308.898,317.603,7039.13,6923.81,7118.93,7.73342,7.60673,7.82109,1.65227,1.6252,1.671,3.43707,3.38077,3.47604,3.43707,3.38077,3.47604 diff --git a/psrdada_cpp/cryopaf/profiling/profiling.cu b/psrdada_cpp/cryopaf/profiling/profiling.cu new file mode 100644 index 0000000000000000000000000000000000000000..05263fa53f94ea94290308861f3183fb199db6df --- /dev/null +++ b/psrdada_cpp/cryopaf/profiling/profiling.cu @@ -0,0 +1,201 @@ +#include <thrust/device_vector.h> +#include <thrust/copy.h> +#include <thrust/complex.h> +#include <cuda.h> +#include <random> +#include <cmath> +#include <fstream> +#include <chrono> + +#include <boost/filesystem.hpp> +#include <boost/program_options.hpp> + +#include "psrdada_cpp/cuda_utils.hpp" +#include "psrdada_cpp/multilog.hpp" +#include "psrdada_cpp/cryopaf/Unpacker.cuh" +#include "psrdada_cpp/cryopaf/Beamformer.cuh" +#include "psrdada_cpp/cryopaf/profiling/KernelStatistics.cuh" + +const size_t ERROR_IN_COMMAND_LINE = 1; +const size_t SUCCESS = 0; + +using namespace psrdada_cpp; +using namespace psrdada_cpp::cryopaf; +using namespace std::chrono; + +template<typename T> +void profile(ProfileConfig conf, std::size_t iter) +{ + // If template parameter is not of a complex dtype profiling has to be aborted + if( !(std::is_same<T, float2>::value) + && !(std::is_same<T, __half2>::value)) + { + BOOST_LOG_TRIVIAL(error) << "ProfilingError: Template type not supported"; + exit(1); + } + cudaStream_t stream; + CUDA_ERROR_CHECK(cudaStreamCreate(&stream)); + // Instantiate processor objects + Beamformer<T> beamformer(stream, + conf.n_samples, + conf.n_channel, + conf.n_elements, + conf.n_beam, + conf.integration); + + Unpacker<T> unpacker(stream, + conf.n_samples, + conf.n_channel, + conf.n_elements, + conf.protocol); + + // Calulate memory size for input, weights and output + std::size_t input_size = conf.n_samples + * conf.n_elements + * conf.n_channel + * conf.n_pol; + std::size_t weight_size = conf.n_beam + * conf.n_elements + * conf.n_channel + * conf.n_pol; + std::size_t output_size = conf.n_samples + * conf.n_beam + * conf.n_channel; + std::size_t required_mem = input_size * sizeof(T) + + weight_size * sizeof(T) + + output_size * sizeof(decltype(T::x)); + BOOST_LOG_TRIVIAL(debug) << "Required device memory: " << std::to_string(required_mem / (1024*1024)) << "MiB"; + + // Allocate device memory + thrust::device_vector<char> input_up(input_size * unpacker.sample_size(),0); + thrust::device_vector<T> input_bf(input_size, {.1, .1}); + thrust::device_vector<T> weights_bf(weight_size, {.1, .1}); + thrust::device_vector<T> output_bf_voltage(output_size * conf.n_pol); + thrust::device_vector<decltype(T::x)> output_bf_power(output_size / conf.integration, 0); + + // Calculation of compute complexity + std::size_t n = conf.n_beam + * conf.n_channel + * conf.n_elements + * conf.n_pol + * conf.n_samples; + std::size_t complexity_bf_vol = 8 * n; + std::size_t complexity_bf_pow = 8 * n + 4 * n /** + accumulation **/; + std::size_t complexity_unpack = n / conf.n_beam; + + // Create KernelStatistics object for each kernel + KernelProfiler voltage_profiler(conf, stream, + "Voltage", + complexity_bf_vol, + (input_bf.size() + weights_bf.size()) * sizeof(T), + output_bf_voltage.size() * sizeof(T), + input_bf.size() * sizeof(T)); + + KernelProfiler power_profiler(conf, stream, + "StokesI", + complexity_bf_pow, + (input_bf.size() + weights_bf.size()) * sizeof(T), + output_bf_power.size() * sizeof(decltype(T::x)), + input_bf.size() * sizeof(T)); + + KernelProfiler unpack_profiler(conf, stream, + "Unpacker", + complexity_unpack, + input_up.size() * sizeof(uint64_t), + input_bf.size() * sizeof(T), + input_up.size() * sizeof(uint64_t)); + + // Run all used kernels i-times + for(int i = 0; i < iter; i++) + { + // Call Stokes I detection beamformer kernel + power_profiler.measure_start(); + beamformer.process( + thrust::raw_pointer_cast(input_bf.data()), + thrust::raw_pointer_cast(weights_bf.data()), + thrust::raw_pointer_cast(output_bf_power.data())); + power_profiler.measure_stop(); + // Call to voltage beamformer kernel + voltage_profiler.measure_start(); + beamformer.process( + thrust::raw_pointer_cast(input_bf.data()), + thrust::raw_pointer_cast(weights_bf.data()), + thrust::raw_pointer_cast(output_bf_voltage.data())); + voltage_profiler.measure_stop(); + // Call to unpacking kernel + unpack_profiler.measure_start(); + unpacker.unpack( + thrust::raw_pointer_cast(input_up.data()), + thrust::raw_pointer_cast(input_bf.data())); + unpack_profiler.measure_stop(); + } + CUDA_ERROR_CHECK(cudaStreamDestroy(stream)); + + power_profiler.finialize(); + voltage_profiler.finialize(); + unpack_profiler.finialize(); + power_profiler.export_to_csv(conf.out_dir + "power_kernel.csv"); + voltage_profiler.export_to_csv(conf.out_dir + "voltage_kernel.csv"); + unpack_profiler.export_to_csv(conf.out_dir + "unpacker_kernel.csv"); +} + + +int main(int argc, char** argv) +{ + // Variables to store command line options + ProfileConfig conf; + int iter; + std::string precision; + std::string filename; + + // Parse command line + namespace po = boost::program_options; + po::options_description desc("Options"); + desc.add_options() + + ("help,h", "Print help messages") + ("samples", po::value<std::size_t>(&conf.n_samples)->default_value(1024), "Number of samples within one batch") + ("channels", po::value<std::size_t>(&conf.n_channel)->default_value(14), "Number of channels") + ("elements", po::value<std::size_t>(&conf.n_elements)->default_value(WARP_SIZE*4), "Number of elements") + ("beams", po::value<std::size_t>(&conf.n_beam)->default_value(64), "Number of beams") + ("integration", po::value<std::size_t>(&conf.integration)->default_value(1), "Integration interval; must be multiple 2^n and smaller 32") + ("device", po::value<int>(&conf.device_id)->default_value(0), "ID of GPU device") + ("protocol", po::value<std::string>(&conf.protocol)->default_value("codif"), "Protocol of input data; supported protocol 'codif'") + ("iteration", po::value<int>(&iter)->default_value(5), "Iterations to run") + ("precision", po::value<std::string>(&conf.precision)->default_value("half"), "Compute type of GEMM operation; supported precisions 'half' and 'single'") + ("outdir", po::value<std::string>(&conf.out_dir)->default_value("Results/"), "Output directory to store csv files"); + + po::variables_map vm; + try + { + po::store(po::parse_command_line(argc, argv, desc), vm); + if ( vm.count("help") ) + { + std::cout << "Beamform Profiling" << std::endl + << desc << std::endl; + return SUCCESS; + } + po::notify(vm); + } + catch(po::error& e) + { + std::cerr << "ERROR: " << e.what() << std::endl << std::endl; + std::cerr << desc << std::endl; + return ERROR_IN_COMMAND_LINE; + } + + if(conf.precision == "half") + { + profile<__half2>(conf, iter); + } + else if(conf.precision == "single") + { + profile<float2>(conf, iter); + } + else + { + BOOST_LOG_TRIVIAL(error) << "Compute type " << precision << " not implemented"; + } + + return 0; +} diff --git a/psrdada_cpp/cryopaf/profiling/src/KernelStatistics.cu b/psrdada_cpp/cryopaf/profiling/src/KernelStatistics.cu new file mode 100644 index 0000000000000000000000000000000000000000..8070bef150882497ccfe7d683cfa7bb1bb09fba6 --- /dev/null +++ b/psrdada_cpp/cryopaf/profiling/src/KernelStatistics.cu @@ -0,0 +1,158 @@ +#ifdef KERNEL_STATISTICS_CUH + +KernelProfiler::KernelProfiler(ProfileConfig& config, + cudaStream_t& cuda_stream, + std::string kernel_name, + std::size_t complexity, + std::size_t read_size, + std::size_t write_size, + std::size_t input_size) + : conf(config), + stream(cuda_stream), + name(kernel_name), + compute_complexity(complexity), + reads(read_size), + writes(write_size), + input_sz(input_size) +{ + CUDA_ERROR_CHECK(cudaEventCreate(&start)); + CUDA_ERROR_CHECK(cudaEventCreate(&stop)); + CUDA_ERROR_CHECK(cudaGetDeviceProperties(&prop, conf.device_id)); + peak_mem_bandwidth = prop.memoryClockRate * (prop.memoryBusWidth / 8) / 1e6; +} + +KernelProfiler::~KernelProfiler() +{ + CUDA_ERROR_CHECK(cudaEventDestroy(start)); + CUDA_ERROR_CHECK(cudaEventDestroy(stop)); +} + +void KernelProfiler::measure_start() +{ + CUDA_ERROR_CHECK(cudaEventRecord(start, stream)); +} +void KernelProfiler::measure_stop() +{ + CUDA_ERROR_CHECK(cudaEventRecord(stop, stream)); + CUDA_ERROR_CHECK(cudaEventSynchronize(stop)); + CUDA_ERROR_CHECK(cudaEventElapsedTime(&ms, start, stop)); + update(ms); +} + +void KernelProfiler::update(float time_ms) +{ + elapsed_time.push_back(time_ms); + compute_tput.push_back(compute_complexity / (time_ms * 1e6)); + memory_bw.push_back((reads + writes) / (time_ms * 1e6)); + input_bw.push_back(input_sz / (time_ms * 1e6)); + output_bw.push_back(writes / (time_ms * 1e6)); + iterations = elapsed_time.size(); +} + +void KernelProfiler::finialize() +{ + BOOST_LOG_TRIVIAL(debug) << "Finializing profiling results.."; + if(iterations > 0) + { + avg_time = std::accumulate(elapsed_time.begin(), elapsed_time.end(), .0) / iterations; + max_time = *(std::max_element(elapsed_time.begin(), elapsed_time.end())); + min_time = *(std::min_element(elapsed_time.begin(), elapsed_time.end())); + avg_tput = std::accumulate(compute_tput.begin(), compute_tput.end(), .0) / iterations; + min_tput = *(std::min_element(compute_tput.begin(), compute_tput.end())); + max_tput = *(std::max_element(compute_tput.begin(), compute_tput.end())); + avg_m_bw = std::accumulate(memory_bw.begin(), memory_bw.end(), .0) / iterations; + min_m_bw = *(std::min_element(memory_bw.begin(), memory_bw.end())); + max_m_bw = *(std::max_element(memory_bw.begin(), memory_bw.end())); + avg_m_bw_perc = avg_m_bw / peak_mem_bandwidth * 100; + min_m_bw_perc = min_m_bw / peak_mem_bandwidth * 100; + max_m_bw_perc = max_m_bw / peak_mem_bandwidth * 100; + avg_i_bw = std::accumulate(input_bw.begin(), input_bw.end(), .0) / iterations; + min_i_bw = *(std::min_element(input_bw.begin(), input_bw.end())); + max_i_bw = *(std::max_element(input_bw.begin(), input_bw.end())); + avg_o_bw = std::accumulate(output_bw.begin(), output_bw.end(), .0) / iterations; + min_o_bw = *(std::min_element(output_bw.begin(), output_bw.end())); + max_o_bw = *(std::max_element(output_bw.begin(), output_bw.end())); + } + else + { + BOOST_LOG_TRIVIAL(error) << "0 iterations, no kernel was profiled.."; + } +} + +void KernelProfiler::export_to_csv(std::string filename) +{ + std::ofstream csv; + std::ifstream test(filename.c_str()); + BOOST_LOG_TRIVIAL(debug) << "Exporting results to " << filename; + + // If file does not exists we add the header line + if(!test.good()) + { + BOOST_LOG_TRIVIAL(debug) << "Writing CSV header"; + csv.open(filename.c_str(), std::ios::out); + csv << "devicename," + << "kernelname," + << "samples," + << "channels," + << "elements," + << "beams," + << "integration," + << "precision," + << "reads," + << "writes," + << "avg_time," + << "min_time," + << "max_time," + << "avg_throughput," + << "min_throughput," + << "max_throughput," + << "avg_bandwidth," + << "min_bandwidth," + << "max_bandwidth," + << "percentage_avg_bandwidth," + << "percentage_min_bandwidth," + << "percentage_max_bandwidth," + << "input_avg_bandwidth," + << "input_min_bandwidth," + << "input_max_bandwidth," + << "output_avg_bandwidth," + << "output_min_bandwidth," + << "output_max_bandwidth\n"; + } + else + { + BOOST_LOG_TRIVIAL(debug) << "Appending data to CSV"; + csv.open(filename.c_str(), std::ios::app); + } + csv << prop.name << "," + << name << "," + << conf.n_samples << "," + << conf.n_channel << "," + << conf.n_elements << "," + << conf.n_beam << "," + << conf.integration << "," + << conf.precision << "," + << reads << "," + << writes << "," + << avg_time << "," + << min_time << "," + << max_time << "," + << avg_tput << "," + << min_tput << "," + << max_tput << "," + << avg_m_bw << "," + << min_m_bw << "," + << max_m_bw << "," + << avg_m_bw_perc << "," + << min_m_bw_perc << "," + << max_m_bw_perc << "," + << avg_i_bw << "," + << min_i_bw << "," + << max_i_bw << "," + << avg_o_bw << "," + << min_o_bw << "," + << max_o_bw << "\n"; + csv.close(); +} + +#endif diff --git a/psrdada_cpp/cryopaf/profiling/tools/CMakeLists.txt b/psrdada_cpp/cryopaf/profiling/tools/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..a745bcba767feed7730fd4816bc2aaef1b760138 --- /dev/null +++ b/psrdada_cpp/cryopaf/profiling/tools/CMakeLists.txt @@ -0,0 +1,17 @@ +set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O0 -g") +set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O0 -g") + +if(ENABLE_CUDA) +set(PSRDADA_CPP_CRYOPAF_TOOLS_LIBRARIES + ${CMAKE_PROJECT_NAME} + ${CMAKE_PROJECT_NAME}_cryopaf_tools + ${DEPENDENCY_LIBRARIES}) + +set(psrdada_cpp_cryopaf_tools_src + device_query.cpp) + +cuda_add_library(${CMAKE_PROJECT_NAME}_cryopaf_tools ${psrdada_cpp_cryopaf_tools_src}) + +cuda_add_executable(device_query device_query.cpp) + +endif(ENABLE_CUDA) diff --git a/psrdada_cpp/cryopaf/profiling/tools/benchmark.py b/psrdada_cpp/cryopaf/profiling/tools/benchmark.py new file mode 100644 index 0000000000000000000000000000000000000000..8f40d2efa8c63cfa1af90544330ead0388b7ae10 --- /dev/null +++ b/psrdada_cpp/cryopaf/profiling/tools/benchmark.py @@ -0,0 +1,60 @@ +import os +import subprocess +import argparse +import numpy as np +from argparse import RawTextHelpFormatter + + +PROFILING_EXEC = "/homes/nesser/SoftwareDev/Projects/psrdada_cpp/build/psrdada_cpp/cryopaf/profiling/profiling" +class Params: + def __init__(self, parser): + self.tsamp = int(parser.parse_args().tsamp) + self.channels = int(parser.parse_args().channels) + self.elements = [16,32,64,128,256,512,1024] + self.beams = np.arange(32,1024+32, step=32).tolist() + self.integration = int(parser.parse_args().integration) + self.device_id = int(parser.parse_args().device_id) + self.iteration = int(parser.parse_args().iteration) + self.protocol = parser.parse_args().protocol + self.precision = parser.parse_args().precision + self.outdir = parser.parse_args().outdir + self.cmd_args = {"samples" : self.tsamp, + "channels" : self.channels, + "elements" : self.elements, + "beams" : self.beams, + "integration" : self.integration, + "device" : self.device_id, + "iteration" : self.iteration, + "protocol" : self.protocol, + "outdir" : self.outdir, + "precision" : self.precision} + + +def run(exe, args): + for i in range(len(args["elements"])): + for k in range(len(args["beams"])): + # Create execute command + args_string = exe + " " + for key, value in args.items(): + if key == "elements": + args_string += " --" + key + " " + str(value[i]) + elif key == "beams": + args_string += " --" + key + " " + str(value[k]) + else: + args_string += " --" + key + " " + str(value) + print(args_string) + subprocess.call(args_string, shell=True) + +if __name__=="__main__": + parser = argparse.ArgumentParser(description='test', formatter_class=RawTextHelpFormatter) + parser.add_argument('--samples', '-s', action="store", default="4096", dest="tsamp", help = "Number of timestamps in databuffer") + parser.add_argument('--channels', '-c', action="store", default="7", dest="channels", help = "Number of channels") + parser.add_argument('--integration', '-int', action="store", default="1", dest="integration", help = "Integration integration") + parser.add_argument('--device_id', '-id', action="store", default="0", dest="device_id", help = "GPU device on which the kernels gets executed") + parser.add_argument('--iteration', '-i', action="store", default="20", dest="iteration", help = "Number of iterations per cycle") + parser.add_argument('--protocol', '-proto', action="store", default="codif", dest="protocol", help = "") + parser.add_argument('--precision', '-p', action="store", default="half", dest="precision", help = "") + parser.add_argument('--outdir', '-o', action="store", default="Results", dest="outdir", help = "") + + params = Params(parser) + run(PROFILING_EXEC, params.cmd_args) diff --git a/psrdada_cpp/cryopaf/profiling/tools/device_query.cpp b/psrdada_cpp/cryopaf/profiling/tools/device_query.cpp new file mode 100644 index 0000000000000000000000000000000000000000..f629bba5135498adfc3a4adc0d0c91e253b28fa2 --- /dev/null +++ b/psrdada_cpp/cryopaf/profiling/tools/device_query.cpp @@ -0,0 +1,320 @@ +/* + * Copyright 1993-2015 NVIDIA Corporation. All rights reserved. + * + * Please refer to the NVIDIA end user license agreement (EULA) associated + * with this source code for terms and conditions that govern your use of + * this software. Any use, reproduction, disclosure, or distribution of + * this software and related documentation outside the terms of the EULA + * is strictly prohibited. + * + */ +/* This sample queries the properties of the CUDA devices present in the system + * via CUDA Runtime API. */ + +// std::system includes + +#include <cuda_runtime.h> + +#include <iostream> +#include <memory> +#include <string> + +#include "psrdada_cpp/cuda_utils.hpp" + + +int *pArgc = NULL; +char **pArgv = NULL; + +#if CUDART_VERSION < 5000 + +// CUDA-C includes +#include <cuda.h> + +// This function wraps the CUDA Driver API into a template function +template <class T> +inline void getCudaAttribute(T *attribute, CUdevice_attribute device_attribute, + int device) { + CUresult error = cuDeviceGetAttribute(attribute, device_attribute, device); + + if (CUDA_SUCCESS != error) { + fprintf( + stderr, + "cuSafeCallNoSync() Driver API error = %04d from file <%s>, line %i.\n", + error, __FILE__, __LINE__); + + exit(EXIT_FAILURE); + } +} + +#endif /* CUDART_VERSION < 5000 */ + +//////////////////////////////////////////////////////////////////////////////// +// Program main +//////////////////////////////////////////////////////////////////////////////// +int main(int argc, char **argv) { + pArgc = &argc; + pArgv = argv; + + printf("%s Starting...\n\n", argv[0]); + printf( + " CUDA Device Query (Runtime API) version (CUDART static linking)\n\n"); + + int deviceCount = 0; + cudaError_t error_id = cudaGetDeviceCount(&deviceCount); + + if (error_id != cudaSuccess) { + printf("cudaGetDeviceCount returned %d\n-> %s\n", + static_cast<int>(error_id), cudaGetErrorString(error_id)); + printf("Result = FAIL\n"); + exit(EXIT_FAILURE); + } + + // This function call returns 0 if there are no CUDA capable devices. + if (deviceCount == 0) { + printf("There are no available device(s) that support CUDA\n"); + } else { + printf("Detected %d CUDA Capable device(s)\n", deviceCount); + } + + int dev, driverVersion = 0, runtimeVersion = 0; + + for (dev = 0; dev < deviceCount; ++dev) { + cudaSetDevice(dev); + cudaDeviceProp deviceProp; + cudaGetDeviceProperties(&deviceProp, dev); + + printf("\nDevice %d: \"%s\"\n", dev, deviceProp.name); + + // Console log + cudaDriverGetVersion(&driverVersion); + cudaRuntimeGetVersion(&runtimeVersion); + printf(" CUDA Driver Version / Runtime Version %d.%d / %d.%d\n", + driverVersion / 1000, (driverVersion % 100) / 10, + runtimeVersion / 1000, (runtimeVersion % 100) / 10); + printf(" CUDA Capability Major/Minor version number: %d.%d\n", + deviceProp.major, deviceProp.minor); + + char msg[256]; +#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64) + sprintf_s(msg, sizeof(msg), + " Total amount of global memory: %.0f MBytes " + "(%llu bytes)\n", + static_cast<float>(deviceProp.totalGlobalMem / 1048576.0f), + (unsigned long long)deviceProp.totalGlobalMem); +#else + snprintf(msg, sizeof(msg), + " Total amount of global memory: %.0f MBytes " + "(%llu bytes)\n", + static_cast<float>(deviceProp.totalGlobalMem / 1048576.0f), + (unsigned long long)deviceProp.totalGlobalMem); +#endif + printf("%s", msg); + + printf(" (%2d) Multiprocessors\n", + deviceProp.multiProcessorCount); + printf( + " GPU Max Clock rate: %.0f MHz (%0.2f " + "GHz)\n", + deviceProp.clockRate * 1e-3f, deviceProp.clockRate * 1e-6f); + +#if CUDART_VERSION >= 5000 + // This is supported in CUDA 5.0 (runtime API device properties) + printf(" Memory Clock rate: %.0f Mhz\n", + deviceProp.memoryClockRate * 1e-3f); + printf(" Memory Bus Width: %d-bit\n", + deviceProp.memoryBusWidth); + + if (deviceProp.l2CacheSize) { + printf(" L2 Cache Size: %d bytes\n", + deviceProp.l2CacheSize); + } + +#else + // This only available in CUDA 4.0-4.2 (but these were only exposed in the + // CUDA Driver API) + int memoryClock; + getCudaAttribute<int>(&memoryClock, CU_DEVICE_ATTRIBUTE_MEMORY_CLOCK_RATE, + dev); + printf(" Memory Clock rate: %.0f Mhz\n", + memoryClock * 1e-3f); + int memBusWidth; + getCudaAttribute<int>(&memBusWidth, + CU_DEVICE_ATTRIBUTE_GLOBAL_MEMORY_BUS_WIDTH, dev); + printf(" Memory Bus Width: %d-bit\n", + memBusWidth); + int L2CacheSize; + getCudaAttribute<int>(&L2CacheSize, CU_DEVICE_ATTRIBUTE_L2_CACHE_SIZE, dev); + + if (L2CacheSize) { + printf(" L2 Cache Size: %d bytes\n", + L2CacheSize); + } + +#endif + + printf( + " Maximum Texture Dimension Size (x,y,z) 1D=(%d), 2D=(%d, " + "%d), 3D=(%d, %d, %d)\n", + deviceProp.maxTexture1D, deviceProp.maxTexture2D[0], + deviceProp.maxTexture2D[1], deviceProp.maxTexture3D[0], + deviceProp.maxTexture3D[1], deviceProp.maxTexture3D[2]); + printf( + " Maximum Layered 1D Texture Size, (num) layers 1D=(%d), %d layers\n", + deviceProp.maxTexture1DLayered[0], deviceProp.maxTexture1DLayered[1]); + printf( + " Maximum Layered 2D Texture Size, (num) layers 2D=(%d, %d), %d " + "layers\n", + deviceProp.maxTexture2DLayered[0], deviceProp.maxTexture2DLayered[1], + deviceProp.maxTexture2DLayered[2]); + + printf(" Total amount of constant memory: %lu bytes\n", + deviceProp.totalConstMem); + printf(" Total amount of shared memory per block: %lu bytes\n", + deviceProp.sharedMemPerBlock); + printf(" Total number of registers available per block: %d\n", + deviceProp.regsPerBlock); + printf(" Warp size: %d\n", + deviceProp.warpSize); + printf(" Maximum number of threads per multiprocessor: %d\n", + deviceProp.maxThreadsPerMultiProcessor); + printf(" Maximum number of threads per block: %d\n", + deviceProp.maxThreadsPerBlock); + printf(" Max dimension size of a thread block (x,y,z): (%d, %d, %d)\n", + deviceProp.maxThreadsDim[0], deviceProp.maxThreadsDim[1], + deviceProp.maxThreadsDim[2]); + printf(" Max dimension size of a grid size (x,y,z): (%d, %d, %d)\n", + deviceProp.maxGridSize[0], deviceProp.maxGridSize[1], + deviceProp.maxGridSize[2]); + printf(" Maximum memory pitch: %lu bytes\n", + deviceProp.memPitch); + printf(" Texture alignment: %lu bytes\n", + deviceProp.textureAlignment); + printf( + " Concurrent copy and kernel execution: %s with %d copy " + "engine(s)\n", + (deviceProp.deviceOverlap ? "Yes" : "No"), deviceProp.asyncEngineCount); + printf(" Run time limit on kernels: %s\n", + deviceProp.kernelExecTimeoutEnabled ? "Yes" : "No"); + printf(" Integrated GPU sharing Host Memory: %s\n", + deviceProp.integrated ? "Yes" : "No"); + printf(" Support host page-locked memory mapping: %s\n", + deviceProp.canMapHostMemory ? "Yes" : "No"); + printf(" Alignment requirement for Surfaces: %s\n", + deviceProp.surfaceAlignment ? "Yes" : "No"); + printf(" Device has ECC support: %s\n", + deviceProp.ECCEnabled ? "Enabled" : "Disabled"); +#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64) + printf(" CUDA Device Driver Mode (TCC or WDDM): %s\n", + deviceProp.tccDriver ? "TCC (Tesla Compute Cluster Driver)" + : "WDDM (Windows Display Driver Model)"); +#endif + printf(" Device supports Unified Addressing (UVA): %s\n", + deviceProp.unifiedAddressing ? "Yes" : "No"); + printf(" Device supports Compute Preemption: %s\n", + deviceProp.computePreemptionSupported ? "Yes" : "No"); + printf(" Supports Cooperative Kernel Launch: %s\n", + deviceProp.cooperativeLaunch ? "Yes" : "No"); + printf(" Supports MultiDevice Co-op Kernel Launch: %s\n", + deviceProp.cooperativeMultiDeviceLaunch ? "Yes" : "No"); + printf(" Device PCI Domain ID / Bus ID / location ID: %d / %d / %d\n", + deviceProp.pciDomainID, deviceProp.pciBusID, deviceProp.pciDeviceID); + + const char *sComputeMode[] = { + "Default (multiple host threads can use ::cudaSetDevice() with device " + "simultaneously)", + "Exclusive (only one host thread in one process is able to use " + "::cudaSetDevice() with this device)", + "Prohibited (no host thread can use ::cudaSetDevice() with this " + "device)", + "Exclusive Process (many threads in one process is able to use " + "::cudaSetDevice() with this device)", + "Unknown", + NULL}; + printf(" Compute Mode:\n"); + printf(" < %s >\n", sComputeMode[deviceProp.computeMode]); + } + + // If there are 2 or more GPUs, query to determine whether RDMA is supported + if (deviceCount >= 2) { + cudaDeviceProp prop[64]; + int gpuid[64]; // we want to find the first two GPUs that can support P2P + int gpu_p2p_count = 0; + + for (int i = 0; i < deviceCount; i++) { + CUDA_ERROR_CHECK(cudaGetDeviceProperties(&prop[i], i)); + + // Only boards based on Fermi or later can support P2P + if ((prop[i].major >= 2) +#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64) + // on Windows (64-bit), the Tesla Compute Cluster driver for windows + // must be enabled to support this + && prop[i].tccDriver +#endif + ) { + // This is an array of P2P capable GPUs + gpuid[gpu_p2p_count++] = i; + } + } + + // Show all the combinations of support P2P GPUs + int can_access_peer; + + if (gpu_p2p_count >= 2) { + for (int i = 0; i < gpu_p2p_count; i++) { + for (int j = 0; j < gpu_p2p_count; j++) { + if (gpuid[i] == gpuid[j]) { + continue; + } + CUDA_ERROR_CHECK( + cudaDeviceCanAccessPeer(&can_access_peer, gpuid[i], gpuid[j])); + printf("> Peer access from %s (GPU%d) -> %s (GPU%d) : %s\n", + prop[gpuid[i]].name, gpuid[i], prop[gpuid[j]].name, gpuid[j], + can_access_peer ? "Yes" : "No"); + } + } + } + } + + // csv masterlog info + // ***************************** + // exe and CUDA driver name + printf("\n"); + std::string sProfileString = "deviceQuery, CUDA Driver = CUDART"; + char cTemp[16]; + + // driver version + sProfileString += ", CUDA Driver Version = "; +#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64) + sprintf_s(cTemp, 10, "%d.%d", driverVersion/1000, (driverVersion%100)/10); +#else + snprintf(cTemp, sizeof(cTemp), "%d.%d", driverVersion / 1000, + (driverVersion % 100) / 10); +#endif + sProfileString += cTemp; + + // Runtime version + sProfileString += ", CUDA Runtime Version = "; +#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64) + sprintf_s(cTemp, 10, "%d.%d", runtimeVersion/1000, (runtimeVersion%100)/10); +#else + snprintf(cTemp, sizeof(cTemp), "%d.%d", runtimeVersion / 1000, + (runtimeVersion % 100) / 10); +#endif + sProfileString += cTemp; + + // Device count + sProfileString += ", NumDevs = "; +#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64) + sprintf_s(cTemp, 10, "%d", deviceCount); +#else + snprintf(cTemp, sizeof(cTemp), "%d", deviceCount); +#endif + sProfileString += cTemp; + sProfileString += "\n"; + printf("%s", sProfileString.c_str()); + + printf("Result = PASS\n"); + + // finish + exit(EXIT_SUCCESS); +} diff --git a/psrdada_cpp/cryopaf/profiling/tools/plot_benchmark.py b/psrdada_cpp/cryopaf/profiling/tools/plot_benchmark.py new file mode 100644 index 0000000000000000000000000000000000000000..554e42bbea4268dfca929ecaa709256842ce966d --- /dev/null +++ b/psrdada_cpp/cryopaf/profiling/tools/plot_benchmark.py @@ -0,0 +1,64 @@ +import os +import matplotlib.pyplot as plt +import pandas as pd +import numpy as np +import sys + +import argparse +from argparse import RawTextHelpFormatter +sys.path.append('') +import benchmark as bench + +class Plotter(): + def __init__(self, filename, sep=","): + self.filename = filename + self.table = pd.read_csv(self.filename, sep=sep, engine='python') + self.elements = self.table["elements"].to_numpy() + self.beams = self.table["beams"].to_numpy() + self.execution_time = self.table["avg_time"].to_numpy() #* 1000 + self.beam_list = np.unique(self.beams) + self.elem_list = np.unique(self.elements) + + def plot(self, col="avg_time", ylabel="Time [ms]", xlabel="Beams", save=True): + i = 0 + y_values = self.table[col].to_numpy() + for a in self.elem_list: + plt.plot(self.beams[i:i+len(self.beam_list)], y_values[i:i+len(self.beam_list)], label=("elements 2 x " +str(a))) + i+=len(self.beam_list) + for line in self.beam_list: + plt.axvline(line, color='grey', linestyle="-.", linewidth=0.5) + if "bandwidth" in col: + hline = [15.754, 31.508, 63.015] + hlabel = ["PCIe3x16", "PCIe4x16", "PCIe5x16"] + hstyle = ["-.", "-.", "-."] + hcolor = ["black", "grey", "red"] + for idx, line in enumerate(hline): + plt.axhline(line, linestyle=hstyle[idx], color=hcolor[idx], linewidth=1, label=hlabel[idx]) + plt.ylabel(ylabel) + plt.xlabel(xlabel) + plt.legend() + plt.title(self.table["devicename"][0] + " " + self.table["kernelname"][0]) + plt.savefig(self.filename[:-4] + col + ".png") + plt.close() +if __name__=="__main__": + parser = argparse.ArgumentParser(description='test', formatter_class=RawTextHelpFormatter) + parser.add_argument('--dir', '-d', action="store", dest="dir", help = "Directory to .csv files") + dir = parser.parse_args().dir + pplotter = Plotter(dir + "power_kernel.csv") + vplotter = Plotter(dir + "voltage_kernel.csv") + uplotter = Plotter(dir + "unpacker_kernel.csv") + pplotter.plot(col="avg_time", ylabel="Time [ms]", xlabel="beams") + vplotter.plot(col="avg_time", ylabel="Time [ms]", xlabel="beams") + uplotter.plot(col="avg_time", ylabel="Time [ms]", xlabel="beams") + pplotter.plot(col="avg_throughput", ylabel="Throughput [GFLOPs]", xlabel="beams") + vplotter.plot(col="avg_throughput", ylabel="Throughput [GFLOPs]", xlabel="beams") + uplotter.plot(col="avg_throughput", ylabel="Throughput [GFLOPs]", xlabel="beams") + pplotter.plot(col="avg_bandwidth", ylabel="Memory Bandwidth [GB/s]", xlabel="beams") + vplotter.plot(col="avg_bandwidth", ylabel="Memory Bandwidth [GB/s]", xlabel="beams") + uplotter.plot(col="avg_bandwidth", ylabel="Memory Bandwidth [GB/s]", xlabel="beams") + pplotter.plot(col="input_avg_bandwidth", ylabel="Input Bandwidth [GB/s]", xlabel="beams") + vplotter.plot(col="input_avg_bandwidth", ylabel="Input Bandwidth [GB/s]", xlabel="beams") + uplotter.plot(col="input_avg_bandwidth", ylabel="Input Bandwidth [GB/s]", xlabel="beams") + pplotter.plot(col="output_avg_bandwidth", ylabel="Output Bandwidth [GB/s]", xlabel="beams") + vplotter.plot(col="output_avg_bandwidth", ylabel="Output Bandwidth [GB/s]", xlabel="beams") + uplotter.plot(col="output_avg_bandwidth", ylabel="Output Bandwidth [GB/s]", xlabel="beams") diff --git a/psrdada_cpp/cryopaf/src/Beamformer.cu b/psrdada_cpp/cryopaf/src/Beamformer.cu new file mode 100644 index 0000000000000000000000000000000000000000..0d3cc05eae1ff9bf9e098c9d9d3e1f1b5a665426 --- /dev/null +++ b/psrdada_cpp/cryopaf/src/Beamformer.cu @@ -0,0 +1,66 @@ +#ifdef BEAMFORMER_CUH_ + +namespace psrdada_cpp{ +namespace cryopaf{ + +template<class ComputeType> +Beamformer<ComputeType>::Beamformer( + cudaStream_t& stream, + std::size_t sample, + std::size_t channel, + std::size_t element, + std::size_t beam, + std::size_t integration) + : _stream(stream), + _sample(sample), + _channel(channel), + _element(element), + _beam(beam), + _integration(integration) +{ + grid.x = ceil(_beam / (double)TILE_SIZE); + grid.y = ceil(_sample / (double)TILE_SIZE); + grid.z = _channel; + block.x = TILE_SIZE; + block.y = TILE_SIZE; +} + +template<class ComputeType> +Beamformer<ComputeType>::~Beamformer() +{ + BOOST_LOG_TRIVIAL(debug) << "Destroy Beamformer object"; +} + +template<class ComputeType> +void Beamformer<ComputeType>::process(const ComputeType* input, const ComputeType* weights, ResultType* output) +{ + BOOST_LOG_TRIVIAL(debug) << "Power BF"; + beamformer_power_fpte_fpbe_ftb<<<grid, block, 0, _stream>>> + (input, weights, output, _sample, _element, _beam, _integration); +} + +template<class ComputeType> +void Beamformer<ComputeType>::process(const ComputeType* input, const ComputeType* weights, ComputeType* output) +{ + BOOST_LOG_TRIVIAL(debug) << "Voltage BF"; + beamformer_voltage_fpte_fpbe_fptb<<<grid, block, 0, _stream>>> + (input, weights, output, _sample, _element, _beam); +} + +template<class ComputeType> +void Beamformer<ComputeType>::print_layout() +{ + std::cout << " Kernel layout: " << std::endl + << " g.x = " << std::to_string(grid.x) << std::endl + << " g.y = " << std::to_string(grid.y) << std::endl + << " g.z = " << std::to_string(grid.z) << std::endl + << " b.x = " << std::to_string(block.x)<< std::endl + << " b.y = " << std::to_string(block.y)<< std::endl + << " b.z = " << std::to_string(block.z)<< std::endl; +} + + +} // namespace cryopaf +} // namespace psrdada_cpp + +#endif diff --git a/psrdada_cpp/cryopaf/src/Pipeline.cu b/psrdada_cpp/cryopaf/src/Pipeline.cu new file mode 100644 index 0000000000000000000000000000000000000000..8ab41d971de4b97ba406f160635e54b6db78dcd4 --- /dev/null +++ b/psrdada_cpp/cryopaf/src/Pipeline.cu @@ -0,0 +1,207 @@ +#ifdef PIPELINE_CUH_ + +namespace psrdada_cpp{ +namespace cryopaf{ + +template<class HandlerType, class ComputeType, class ResultType> +Pipeline<HandlerType, ComputeType, ResultType>::Pipeline + (PipelineConfig& conf, MultiLog &log, HandlerType &handler) + : _conf(conf), _log(log), _handler(handler) +{ + // Check if passed template types are valid + if( !(std::is_same<ComputeType, float2>::value) + && !(std::is_same<ComputeType, __half2>::value)) + { + BOOST_LOG_TRIVIAL(error) << "PipelineError: Template type not supported"; + exit(1); + } +#ifdef DEBUG + // Cuda events for profiling + CUDA_ERROR_CHECK( cudaEventCreate(&start) ); + CUDA_ERROR_CHECK( cudaEventCreate(&stop) ); +#endif + // Create streams + CUDA_ERROR_CHECK(cudaStreamCreate(&_h2d_stream)); + CUDA_ERROR_CHECK(cudaStreamCreate(&_prc_stream)); + CUDA_ERROR_CHECK(cudaStreamCreate(&_d2h_stream)); + + // Instantiate processor objects + unpacker = new Unpacker<ComputeType>(_prc_stream, + _conf.n_samples, + _conf.n_channel, + _conf.n_elements, + _conf.protocol); + beamformer = new Beamformer<ComputeType>(_prc_stream, + _conf.n_samples, + _conf.n_channel, + _conf.n_elements, + _conf.n_beam, + _conf.integration); + + // Calculate buffer sizes + std::size_t raw_input_size = _conf.n_samples + * _conf.n_channel + * _conf.n_elements + * _conf.n_pol + * unpacker->sample_size(); + std::size_t transpose_size = _conf.n_samples + * _conf.n_channel + * _conf.n_elements + * _conf.n_pol; + std::size_t weight_size = _conf.n_beam + * _conf.n_channel + * _conf.n_elements + * _conf.n_pol; + std::size_t output_size = 0; + if(conf.mode == "power") + { + output_size = _conf.n_beam + * _conf.n_channel + * _conf.n_samples + / _conf.integration; + } + else if (conf.mode == "voltage") + { + output_size = _conf.n_beam + * _conf.n_channel + * _conf.n_samples + * _conf.n_pol; + } + else + { + BOOST_LOG_TRIVIAL(debug) << "Beamform mode not known"; + exit(1); + } + std::size_t total_size = (raw_input_size + + transpose_size * sizeof(ComputeType) + + weight_size * sizeof(ComputeType) + + output_size * sizeof(ComputeType)) * 2; // Multiplied by two, since each buffer is double buffer + BOOST_LOG_TRIVIAL(info) << "Requested global device memory: " << total_size; + + // Instantiate buffers + _raw_input_buffer = new RawInputType(raw_input_size); + _input_buffer = new InputType(transpose_size); + _weight_buffer = new WeightType(weight_size); + _output_buffer = new OutputType(output_size); + +} + + +template<class HandlerType, class ComputeType, class ResultType> +Pipeline<HandlerType, ComputeType, ResultType>::~Pipeline() +{ + +#ifdef DEBUG + CUDA_ERROR_CHECK( cudaEventDestroy(start) ); + CUDA_ERROR_CHECK( cudaEventDestroy(stop) ); +#endif + if(_h2d_stream) + { + CUDA_ERROR_CHECK(cudaStreamDestroy(_h2d_stream)); + } + if(_prc_stream) + { + CUDA_ERROR_CHECK(cudaStreamDestroy(_prc_stream)); + } + if(_d2h_stream) + { + CUDA_ERROR_CHECK(cudaStreamDestroy(_d2h_stream)); + } + + if(_raw_input_buffer) + { + delete _raw_input_buffer; + } + if(_input_buffer) + { + delete _input_buffer; + } + if(_weight_buffer) + { + delete _weight_buffer; + } + if(_output_buffer) + { + delete _output_buffer; + } +} + + + +template<class HandlerType, class ComputeType, class ResultType> +void Pipeline<HandlerType, ComputeType, ResultType>::init(RawBytes &header_block) +{ + std::size_t bytes = header_block.total_bytes(); + _handler.init(header_block); +} + +template<class HandlerType, class ComputeType, class ResultType> +bool Pipeline<HandlerType, ComputeType, ResultType>::operator()(RawBytes &dada_input) +{ + _call_cnt += 1; + BOOST_LOG_TRIVIAL(debug) << "Processing "<< _call_cnt << " dada block.."; + if(dada_input.used_bytes() > _raw_input_buffer->total_bytes()) + { + BOOST_LOG_TRIVIAL(error) << "Unexpected Buffer Size - Got " + << dada_input.used_bytes() << " byte, expected " + << _input_buffer->total_bytes() << " byte)"; + CUDA_ERROR_CHECK(cudaDeviceSynchronize()); + return true; + } + +#ifdef DEBUG + CUDA_ERROR_CHECK( cudaEventRecord(start,0) ); +#endif + + CUDA_ERROR_CHECK(cudaMemcpyAsync(_raw_input_buffer->b_ptr(), dada_input.ptr(), dada_input.used_bytes(), cudaMemcpyHostToDevice, _h2d_stream)); + BOOST_LOG_TRIVIAL(debug) << "Copied dada block from host to device"; + if(_call_cnt == 1) + { + _raw_input_buffer->swap(); + return false; + } + + unpacker->unpack(_raw_input_buffer->a_ptr(), _input_buffer->b_ptr()); + _raw_input_buffer->swap(); + BOOST_LOG_TRIVIAL(debug) << "Unpacked data"; + + if(_call_cnt == 2) + { + _input_buffer->swap(); + return false; + } + + beamformer->process(_input_buffer->a_ptr(), _weight_buffer->a_ptr(), _output_buffer->b_ptr()); + _input_buffer->swap(); + BOOST_LOG_TRIVIAL(debug) << "Beamformed data"; + + if(_call_cnt == 3) + { + _output_buffer->swap(); + return false; + } + _output_buffer->async_copy(_d2h_stream); + BOOST_LOG_TRIVIAL(debug) << "Copied processed dada block from device to host"; + + // Wrap in a RawBytes object here; + RawBytes dada_output(static_cast<char*>((void*)_output_buffer->host.a_ptr()), + _output_buffer->total_bytes(), + _output_buffer->total_bytes()); + + _output_buffer->swap(); + _output_buffer->host.swap(); + + _handler(dada_output); +#ifdef DEBUG + CUDA_ERROR_CHECK(cudaEventRecord(stop, 0)); + CUDA_ERROR_CHECK(cudaEventSynchronize(stop)); + CUDA_ERROR_CHECK(cudaEventElapsedTime(&ms, start, stop)); + BOOST_LOG_TRIVIAL(debug) << "Took " << ms << " ms to process stream"; +#endif + return false; +} + +} // namespace cryopaf +} // namespace psrdada_cpp + +#endif diff --git a/psrdada_cpp/cryopaf/src/PipelineInterface.cu b/psrdada_cpp/cryopaf/src/PipelineInterface.cu new file mode 100644 index 0000000000000000000000000000000000000000..5febefca7ad05fc390adf4f9a499c94ae97a28df --- /dev/null +++ b/psrdada_cpp/cryopaf/src/PipelineInterface.cu @@ -0,0 +1,137 @@ +#ifdef PIPELINE_INTERFACE_HPP + +namespace psrdada_cpp{ +namespace cryopaf{ + +namespace bip = boost::interprocess; + +template<class T> +PipelineInterface<T>::PipelineInterface(PipelineInterfaceConfig& config, MultiLog& logger) + : conf(config), log(logger) +{ + smem = bip::shared_memory_object(bip::open_only, "SharedMemoryWeights", bip::read_write); + try + { + //Map the whole shared memory in this process + region = bip::mapped_region(smem, bip::read_write); + //Get the address of the mapped region + smem_addr = region.get_address(); + } + catch(bip::interprocess_exception &ex) + { + std::cout << ex.what() << std::endl; + exit(1); + } + qheader = new (smem_addr) QueueHeader(); + smem_weights = &(static_cast<T*>(smem_addr)[sizeof(QueueHeader)]); + vect_weights = std::vector<T>(conf.n_beam * conf.n_channel * conf.n_elements * conf.n_pol); +} + +template<class T> +PipelineInterface<T>::~PipelineInterface() +{ + +} + +template<class T> +void PipelineInterface<T>::run() +{ + while(!quit) + { + bip::scoped_lock<bip::interprocess_mutex> lock(qheader->mutex); + + if(qheader->data_in) + { + std::cout << "Waiting for reading weights from shared memory" << std::endl; + qheader->ready_to_write.wait(lock); + } + this->update(); + std::cout << "Writing new weights to shared memory " << std::endl; + memcpy(smem_weights, (void*)&vect_weights[0], vect_weights.size()*sizeof(T)); + qheader->data_in = true; + qheader->stop = false; + qheader->ready_to_read.notify_all(); + } + qheader->data_in = true; + qheader->stop = true; +} + +template<class T> +SimpleWeightGenerator<T>::SimpleWeightGenerator(PipelineInterfaceConfig& config, MultiLog& logger) + : PipelineInterface<T>(config, logger) +{ + +} + +template<class T> +SimpleWeightGenerator<T>::~SimpleWeightGenerator() +{ + +} + +template<class T> +void SimpleWeightGenerator<T>::update() +{ + if(this->conf.mode == "random") + { + random(); + } + else if(this->conf.mode == "bypass") + { + + if(this->update_cnt > 0) + { + this->quit = true; + } + bypass(); + } + else + { + throw std::runtime_error("Not implemented yet."); + } + this->update_cnt += 1; +} + +template<typename T> +void SimpleWeightGenerator<T>::bypass() +{ + std::size_t pos_x, pos_y; + int be = this->conf.n_beam * this->conf.n_elements; + int pbe = this->conf.n_pol * be; + for(int f = 0; f < this->conf.n_channel; f++) + { + for(int b = 0; b < this->conf.n_beam; b++) + { + for(int e = 0; e < this->conf.n_elements; e++) + { + pos_x = f * pbe + 0 * be + b * this->conf.n_elements + e; + pos_y = f * pbe + 1 * be + b * this->conf.n_elements + e; + if(b == e) + { + this->vect_weights[pos_x] = {1,0}; // Set X pol + this->vect_weights[pos_y] = {1,0}; // Set Y pol + } + else + { + this->vect_weights[pos_x] = {0,0}; + this->vect_weights[pos_y] = {0,0}; + } + } + } + } +} + +template<typename T> +void SimpleWeightGenerator<T>::random() +{ + std::default_random_engine generator; + std::normal_distribution<float> normal_dist(0.0, 1.0); + for (size_t i = 0; i < this->vect_weights.size(); i++) + { + this->vect_weights[i] = {normal_dist(generator), normal_dist(generator)}; + } +} + +} +} +#endif diff --git a/psrdada_cpp/cryopaf/src/Unpacker.cu b/psrdada_cpp/cryopaf/src/Unpacker.cu new file mode 100644 index 0000000000000000000000000000000000000000..378a1dbf02656479746d70244b939a3d415be7be --- /dev/null +++ b/psrdada_cpp/cryopaf/src/Unpacker.cu @@ -0,0 +1,90 @@ +#ifdef UNPACKER_CUH + +namespace psrdada_cpp { +namespace cryopaf { + +template<typename T> +Unpacker<T>::Unpacker(cudaStream_t& stream, + std::size_t nsamples, + std::size_t nchannels, + std::size_t nelements, + std::string protocol) + : _stream(stream), _protocol(protocol) +{ + if( !(std::is_same<T, float2>::value) + && !(std::is_same<T, __half2>::value)) + { + BOOST_LOG_TRIVIAL(error) << "UnpackerError: Template type not supported"; + exit(1); + } + if(_protocol == "codif") + { + if(nchannels % 7) + { + BOOST_LOG_TRIVIAL(error) << "UnpackerError: Unpacker expects a multiple of 7 channels"; + exit(1); + } + + grid.x = nsamples / NSAMP_DF; + grid.y = nelements; + grid.z = nchannels / NCHAN_CHK; + block.x = NSAMP_DF; + block.z = NCHAN_CHK; + } + else if(_protocol == "spead") + { + grid.x = nsamples / NSAMP_PER_HEAP; + grid.y = nelements; + grid.z = nchannels; + block.x = NSAMP_PER_HEAP; + } + else if(_protocol == "dummy_input") + { + BOOST_LOG_TRIVIAL(warning) << "UnpackerWarning: Skipping unpacking process"; + } + else + { + BOOST_LOG_TRIVIAL(error) << "UnpackerError: Protocol " << _protocol << " not implemented"; + exit(1); + } +} + + +template<typename T> +Unpacker<T>::~Unpacker() +{ + BOOST_LOG_TRIVIAL(debug) << "Destroy Unpacker object"; +} + + +template<typename T> +void Unpacker<T>::unpack(char* input, T* output) +{ + if(_protocol == "codif") + { + BOOST_LOG_TRIVIAL(debug) << "Unpack CODIF data"; + unpack_codif_to_fpte<<< grid, block, 0, _stream>>>((uint64_t*)input, output); + } + else if(_protocol == "spead") + { + BOOST_LOG_TRIVIAL(debug) << "Unpack SPEAD2 data"; + // unpack_spead_to_fpte<<< grid, block, 0, _stream>>>(input, output); + } +} + + + +template<typename T> +void Unpacker<T>::print_layout() +{ + std::cout << "Grid.x " << grid.x << std::endl; + std::cout << "Grid.y " << grid.y << std::endl; + std::cout << "Grid.z " << grid.z << std::endl; + std::cout << "block.x " << block.x << std::endl; + std::cout << "block.z " << block.z << std::endl; +} + +} //namespace cryopaf +} //namespace psrdada_cpp + +#endif diff --git a/psrdada_cpp/cryopaf/src/beamforming_cli.cu b/psrdada_cpp/cryopaf/src/beamforming_cli.cu new file mode 100644 index 0000000000000000000000000000000000000000..b730fe231435da0d20a234c233c7ec9b2623253a --- /dev/null +++ b/psrdada_cpp/cryopaf/src/beamforming_cli.cu @@ -0,0 +1,123 @@ +#include <thrust/device_vector.h> +#include <thrust/copy.h> +#include <thrust/complex.h> +#include <cuda.h> +#include <random> +#include <cmath> +#include <fstream> +#include <chrono> +#include <unordered_map> + + +#include "boost/filesystem.hpp" +#include "boost/program_options.hpp" + +#include "psrdada_cpp/cli_utils.hpp" +#include "psrdada_cpp/dada_input_stream.hpp" +#include "psrdada_cpp/dada_output_stream.hpp" +#include "psrdada_cpp/multilog.hpp" + +#include "psrdada_cpp/cryopaf/Pipeline.cuh" + + +const size_t ERROR_IN_COMMAND_LINE = 1; +const size_t SUCCESS = 0; +const size_t ERROR_UNHANDLED_EXCEPTION = 2; + +using namespace psrdada_cpp; +using namespace psrdada_cpp::cryopaf; + +template<typename T> +void launch(PipelineConfig& conf) +{ + MultiLog log(conf.logname); + DadaOutputStream output (conf.out_key, log); + if (conf.mode == "voltage") + { + // For voltage beamformer pipeline ComputeType and ResultType has to be equal + Pipeline<decltype(output), T, T> pipeline(conf, log, output); + DadaInputStream<decltype(pipeline)> input(conf.in_key, log, pipeline); + input.start(); + } + else if (conf.mode == "power") + { + // For power beamformer pipeline ResultType is ComputeType::x + Pipeline<decltype(output), T, decltype(T::x)> pipeline(conf, log, output); + DadaInputStream<decltype(pipeline)> input(conf.in_key, log, pipeline); + input.start(); + } + else + { + BOOST_LOG_TRIVIAL(error) << "Beamform mode " << conf.mode << " not implemented"; + } +} + +int main(int argc, char** argv) +{ + try + { + // Variables to store command line options + PipelineConfig conf; + std::string precision; + std::string kind; + + // Parse command line + namespace po = boost::program_options; + po::options_description desc("Options"); + desc.add_options() + ("help,h", "Print help messages") + ("in_key", po::value<std::string>()->required() + ->notifier([&conf](std::string key){conf.in_key = string_to_key(key);}), "Input dada key") + ("out_key", po::value<std::string>()->required() + ->notifier([&conf](std::string key){conf.out_key = string_to_key(key);}), "Output dada key") + ("samples", po::value<std::size_t>(&conf.n_samples)->default_value(262144), "Number of samples within one dada block") + ("channels", po::value<std::size_t>(&conf.n_channel)->default_value(7), "Number of channels") + ("elements", po::value<std::size_t>(&conf.n_elements)->default_value(36), "Number of elments") + ("beams", po::value<std::size_t>(&conf.n_beam)->default_value(36), "Number of beams") + ("integration", po::value<std::size_t>(&conf.integration)->default_value(1), "Integration interval; must be multiple 2^n and smaller 32") + ("device", po::value<int>(&conf.device_id)->default_value(0), "ID of GPU device") + ("mode", po::value<std::string>(&conf.mode)->default_value("power"), "Beamforming mode; valid inputs 'power' and 'voltage'") + ("input_type", po::value<std::string>(&conf.input_type)->default_value("float"), "Data type of received input data (supported types: float). It is always expected that the samples are complex (e.g. internally float becomes float2)") + ("precision", po::value<std::string>(&precision)->default_value("single"), "Compute type of GEMM operation; supported precisions 'half' and 'single'") + ("protocol", po::value<std::string>(&conf.protocol)->default_value("codif"), "Protocol of input data; supported 'codif', 'spead' and 'dummy_input'.") + ("log", po::value<std::string>(&conf.logname)->default_value("cryo_beamform.log"), "Directory of logfile"); + + po::variables_map vm; + try + { + po::store(po::parse_command_line(argc, argv, desc), vm); + if ( vm.count("help") ) + { + std::cout << "Cryopaf -- The CryoPAF Controller implementations" << std::endl + << desc << std::endl; + return SUCCESS; + } + po::notify(vm); + } + catch(po::error& e) + { + std::cerr << "ERROR: " << e.what() << std::endl << std::endl; + std::cerr << desc << std::endl; + return ERROR_IN_COMMAND_LINE; + } + if(precision == "half") + { + launch<__half2>(conf); + } + else if(precision == "single") + { + launch<float2>(conf); + } + else + { + BOOST_LOG_TRIVIAL(error) << "Compute type " << precision << " not implemented"; + } + } + catch(std::exception& e) + { + std::cerr << "Unhandled Exception reached the top of main: " + << e.what() << ", application will now exit" << std::endl; + return ERROR_UNHANDLED_EXCEPTION; + } + return SUCCESS; +} diff --git a/psrdada_cpp/cryopaf/src/weightupdater_cli.cu b/psrdada_cpp/cryopaf/src/weightupdater_cli.cu new file mode 100644 index 0000000000000000000000000000000000000000..38225b516b9526de76c4c41bb5d4dfce9a12a743 --- /dev/null +++ b/psrdada_cpp/cryopaf/src/weightupdater_cli.cu @@ -0,0 +1,95 @@ +#include "boost/filesystem.hpp" +#include "boost/program_options.hpp" + +#include "psrdada_cpp/multilog.hpp" +#include "psrdada_cpp/cryopaf/PipelineInterface.cuh" + + +const size_t ERROR_IN_COMMAND_LINE = 1; +const size_t SUCCESS = 0; +const size_t ERROR_UNHANDLED_EXCEPTION = 2; + +using namespace psrdada_cpp; +using namespace psrdada_cpp::cryopaf; + +template<typename T> +void launch(PipelineInterfaceConfig& conf) +{ + MultiLog log(conf.logname); + if (conf.mode == "bypass" || conf.mode == "random") + { + SimpleWeightGenerator<T> handle(conf, log); + handle.run(); + }else if (conf.mode == "tcp"){ + throw std::runtime_error("Not implemented yet."); + }else if (conf.mode == "file"){ + throw std::runtime_error("Not implemented yet."); + }else{ + throw std::runtime_error("Not implemented yet."); + } +} + +int main(int argc, char** argv) +{ + try + { + // Variables to store command line options + PipelineInterfaceConfig conf; + std::string precision; + + // Parse command line + namespace po = boost::program_options; + po::options_description desc("Options"); + desc.add_options() + ("help,h", "Print help messages") + ("channels", po::value<std::size_t>(&conf.n_channel)->default_value(7), "Number of channels") + ("elements", po::value<std::size_t>(&conf.n_elements)->default_value(32), "Number of antennas") + ("pol", po::value<std::size_t>(&conf.n_pol)->default_value(2), "Polarisation") + ("beams", po::value<std::size_t>(&conf.n_beam)->default_value(32), "Number of beams") + ("mode", po::value<std::string>(&conf.mode)->default_value("bypass"), "Power or voltage BF") + ("precision", po::value<std::string>(&precision)->default_value("single"), "Supported types: half, single, double") + ("log", po::value<std::string>(&conf.logname)->default_value("cryo_beamform.log"), "Store profile data to csv file"); + + po::variables_map vm; + try + { + po::store(po::parse_command_line(argc, argv, desc), vm); + if ( vm.count("help") ) + { + std::cout << "Cryopaf -- The CryoPAF Controller implementations" << std::endl + << desc << std::endl; + return SUCCESS; + } + po::notify(vm); + } + catch(po::error& e) + { + std::cerr << "ERROR: " << e.what() << std::endl << std::endl; + std::cerr << desc << std::endl; + return ERROR_IN_COMMAND_LINE; + } + if(precision == "half") + { + std::cout << "Not implemented yet" << std::endl; + } + else if(precision == "single") + { + launch<float2>(conf); + } + else if(precision == "double") + { + std::cout << "Not implemented yet" << std::endl; + } + else + { + std::cout << "Type not known" << std::endl; + } + } + catch(std::exception& e) + { + std::cerr << "Unhandled Exception reached the top of main: " + << e.what() << ", application will now exit" << std::endl; + return ERROR_UNHANDLED_EXCEPTION; + } + return SUCCESS; +} diff --git a/psrdada_cpp/cryopaf/test/BeamformTester.cuh b/psrdada_cpp/cryopaf/test/BeamformTester.cuh new file mode 100644 index 0000000000000000000000000000000000000000..79d05f2f0ec25e2a63a5651202d686b72b3ec0f5 --- /dev/null +++ b/psrdada_cpp/cryopaf/test/BeamformTester.cuh @@ -0,0 +1,128 @@ +#ifndef BEAMFORMER_TESTER_H_ +#define BEAMFORMER_TESTER_H_ + +#include <thrust/host_vector.h> +#include <thrust/device_vector.h> +#include <cuda_fp16.h> +#include <random> +#include <cmath> +#include <gtest/gtest.h> + +#include "psrdada_cpp/cryopaf/Beamformer.cuh" +#include "psrdada_cpp/common.hpp" +#include "psrdada_cpp/cuda_utils.hpp" + +namespace psrdada_cpp{ +namespace cryopaf{ +namespace test{ + +struct BeamformTestConfig{ + int device_id; + std::size_t n_samples; + std::size_t n_channel; + std::size_t n_elements; + std::size_t n_beam; + std::size_t integration; + const std::size_t n_pol = 2; + void print() + { + std::cout << "Test configuration" << std::endl; + std::cout << "device_id: " << device_id << std::endl; + std::cout << "n_samples: " << n_samples << std::endl; + std::cout << "n_channel: " << n_channel << std::endl; + std::cout << "n_elements: " << n_elements << std::endl; + std::cout << "n_pol: " << n_pol << std::endl; + std::cout << "n_beam: " << n_beam << std::endl; + std::cout << "integration: " << integration << std::endl; + } +}; + +class BeamformTester : public ::testing::TestWithParam<BeamformTestConfig> { +public: + BeamformTester(); + ~BeamformTester(); + + + /** + * @brief + * + * @param + */ + template <typename T, typename U> + void test(float tol=0.0001); + + + /** + * @brief + * + * @param + */ + template<typename T, typename U> + void cpu_process_power( + thrust::host_vector<T>& in, + thrust::host_vector<T>& weights, + thrust::host_vector<U>& out); + + /** + * @brief + * + * @param + */ + template<typename T> + void cpu_process_voltage( + thrust::host_vector<T>& in, + thrust::host_vector<T>& weights, + thrust::host_vector<T>& out); + + + /** + * @brief + * + * @param + */ + template<typename T, typename U> + void gpu_process( + thrust::host_vector<T>& in, + thrust::host_vector<T>& weights, + thrust::host_vector<U>& out); + + + /** + * @brief + * + * @param + */ + template <typename T> + void compare_power( + const thrust::host_vector<T> cpu, + const thrust::host_vector<T> gpu, + const float tol); + + /** + * @brief + * + * @param + */ + template <typename T> + void compare_voltage( + const thrust::host_vector<T> cpu, + const thrust::host_vector<T> gpu, + const float tol); + + +protected: + void SetUp() override; + void TearDown() override; + +private: + BeamformTestConfig conf; + cudaStream_t _stream; + +}; + +} // namespace psrdada_cpp +} // namespace cryopaf +} // namespace test + + +#endif //POWERBEAMFORMER_TESTER_H_ diff --git a/psrdada_cpp/cryopaf/test/CMakeLists.txt b/psrdada_cpp/cryopaf/test/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..c3d704f70bede3dc8bd8194131c2d7f7e0986a5d --- /dev/null +++ b/psrdada_cpp/cryopaf/test/CMakeLists.txt @@ -0,0 +1,12 @@ +include_directories(${GTEST_INCLUDE_DIR}) + +link_directories(${GTEST_LIBRARY_DIR}) + +set(gtest_beamforming_src + src/BeamformTester.cu + src/UnpackerTester.cu + src/gtest_beamforming.cu +) +cuda_add_executable(gtest_beamforming ${gtest_beamforming_src} ) +target_link_libraries(gtest_beamforming ${PSRDADA_CPP_CRYOPAF_LIBRARIES} ${GTEST_LIBRARIES}) +add_test(gtest_beamforming gtest_beamforming --test_data "${CMAKE_CURRENT_LIST_DIR}/data") diff --git a/psrdada_cpp/cryopaf/test/UnpackerTester.cuh b/psrdada_cpp/cryopaf/test/UnpackerTester.cuh new file mode 100644 index 0000000000000000000000000000000000000000..6750cf7dda31a4e566f58472dad1e48bbe4efddb --- /dev/null +++ b/psrdada_cpp/cryopaf/test/UnpackerTester.cuh @@ -0,0 +1,76 @@ +#ifndef UNPACKERTESTER_CUH +#define UNPACKERTESTER_CUH + +#include <random> +#include <gtest/gtest.h> +#include <vector> +#include <byteswap.h> +#include <thrust/host_vector.h> + +#include "psrdada_cpp/cryopaf/Unpacker.cuh" +#include "psrdada_cpp/common.hpp" +#include "psrdada_cpp/cuda_utils.hpp" + +namespace psrdada_cpp { +namespace cryopaf { +namespace test { + +struct UnpackerTestConfig{ + int device_id; + std::size_t n_samples; + std::size_t n_channel; + std::size_t n_elements; + std::string protocol; + const std::size_t n_pol = 2; + void print() + { + std::cout << "Test configuration" << std::endl; + std::cout << "device_id: " << device_id << std::endl; + std::cout << "n_samples: " << n_samples << std::endl; + std::cout << "n_channel: " << n_channel << std::endl; + std::cout << "n_elements: " << n_elements << std::endl; + std::cout << "n_pol: " << n_pol << std::endl; + std::cout << "protocol: " << protocol << std::endl; + } +}; + + +class UnpackerTester: public ::testing::TestWithParam<UnpackerTestConfig> +{ +public: + UnpackerTester(); + ~UnpackerTester(); + + template<typename T> + void test(); + +protected: + void SetUp() override; + void TearDown() override; + + template<typename T> + void compare( + thrust::host_vector<T>& cpu, + thrust::host_vector<T>& gpu); + + template<typename T> + void cpu_process( + thrust::host_vector<uint64_t>& input, + thrust::host_vector<T>& output); + + template<typename T> + void gpu_process( + thrust::host_vector<uint64_t>& input, + thrust::host_vector<T>& output); + +private: + UnpackerTestConfig conf; + +}; + +} //namespace test +} //namespace cryopaf +} //namespace psrdada_cpp + + +#endif //PSRDADA_CPP_EFFELSBERG_PAF_UNPACKERTESTER_CUH diff --git a/psrdada_cpp/cryopaf/test/src/BeamformTester.cu b/psrdada_cpp/cryopaf/test/src/BeamformTester.cu new file mode 100644 index 0000000000000000000000000000000000000000..ddd03a3c06397ae081e16bcddd9b56193a1c66cd --- /dev/null +++ b/psrdada_cpp/cryopaf/test/src/BeamformTester.cu @@ -0,0 +1,429 @@ +#include "psrdada_cpp/cryopaf/test/BeamformTester.cuh" + +namespace psrdada_cpp{ +namespace cryopaf{ +namespace test{ + + +BeamformTester::BeamformTester() + : ::testing::TestWithParam<BeamformTestConfig>(), + conf(GetParam()), // GetParam() is inherited from base TestWithParam + _stream(0) +{ + BOOST_LOG_TRIVIAL(debug) << "Creating instance of BeamformTester"; + CUDA_ERROR_CHECK(cudaSetDevice(conf.device_id)); +} + + +BeamformTester::~BeamformTester() +{ + BOOST_LOG_TRIVIAL(debug) << "Destroying instance of BeamformTester"; +} + + +void BeamformTester::SetUp() +{ +} + + +void BeamformTester::TearDown() +{ +} + + +template<typename T, typename U> +void BeamformTester::test(float tol) +{ + // Set up normal distributed sample and weight generator + const float input_level = 1.0f; + const double pi = std::acos(-1); + std::default_random_engine generator; + std::normal_distribution<float> normal_dist(0.0, input_level); + + // Calulate memory size for input, weights and output + std::size_t input_size = conf.n_samples + * conf.n_elements + * conf.n_channel + * conf.n_pol; + std::size_t weight_size = conf.n_beam + * conf.n_elements + * conf.n_channel + * conf.n_pol; + std::size_t output_size; + if constexpr (std::is_same<T, U>::value) + { + output_size = conf.n_samples + * conf.n_beam + * conf.n_channel + * conf.n_pol; + } + else + { + output_size = conf.n_samples + * conf.n_beam + * conf.n_channel + / conf.integration; + } + std::size_t required_mem = input_size * sizeof(T) + + weight_size * sizeof(T) + + output_size * sizeof(U); + BOOST_LOG_TRIVIAL(debug) << "Required device memory: " << std::to_string(required_mem / (1024*1024)) << "MiB"; + BOOST_LOG_TRIVIAL(debug) << "Required host memory: " << std::to_string((required_mem + output_size * sizeof(U)) / (1024*1024)) << "MiB"; + + // Allocate host vectors + thrust::host_vector<U> host_output(output_size); + thrust::host_vector<U> dev_output(output_size); + thrust::host_vector<T> input(input_size); + thrust::host_vector<T> weights(weight_size); + + // Generate test samples / normal distributed noise for input signal + for (size_t i = 0; i < input.size(); i++) + { + if constexpr (std::is_same<T, __half2>::value) + { + input[i] = __float22half2_rn({normal_dist(generator), normal_dist(generator)}); + } + else + { + input[i] = {normal_dist(generator), normal_dist(generator)}; + } + } + + // Generate test weights + for (size_t i = 0; i < weights.size(); i++) + { + if constexpr (std::is_same<T, __half2>::value) + { + weights[i] = __float22half2_rn({normal_dist(generator), normal_dist(generator)}); + } + else + { + weights[i] = {normal_dist(generator), normal_dist(generator)}; + } + } + + // launches CUDA kernel + gpu_process(input, weights, dev_output); + + if constexpr (std::is_same<T, U>::value) + { + // launches cpu beamforming + cpu_process_voltage(input, weights, host_output); + // compare results of both outputs + compare_voltage(host_output, dev_output, tol); + } + else + { + // launches cpu beamforming + cpu_process_power(input, weights, host_output); + // compare results of both outputs + compare_power(host_output, dev_output, tol); + } +} + + +template <typename T> +void BeamformTester::compare_power( + const thrust::host_vector<T> cpu, + const thrust::host_vector<T> gpu, + const float tol) +{ + // Check if vectors have the same size + ASSERT_TRUE(cpu.size() == gpu.size()) + << "Host and device vector size not equal" << std::endl; + + // Copy CUDA results to host + float abs_diff; + int arg_max_deviation = 0; + + float gpu_element; + float cpu_element; + float max_deviation = .0; + + for(std::size_t i = 0; i < gpu.size(); i++) + { + if constexpr (std::is_same<T, __half>::value) + { + gpu_element = __half2float(gpu[i]); + cpu_element = __half2float(cpu[i]); + } + else + { + gpu_element = gpu[i]; + cpu_element = cpu[i]; + } + + abs_diff = std::abs(cpu_element - gpu_element); + if(abs_diff > max_deviation) + { + arg_max_deviation = i; + max_deviation = abs_diff; + } + ASSERT_TRUE(std::abs(cpu_element - gpu_element) <= std::abs(gpu_element)*tol/2) + << "Beamformer with Stokes I: CPU and GPU results are unequal for element " << std::to_string(i) << std::endl + << " CPU result: " << std::to_string(cpu_element) << std::endl + << " GPU result: " << std::to_string(gpu_element) << std::endl; + } + BOOST_LOG_TRIVIAL(debug) << "Maximum deviation detected for element " << std::to_string(arg_max_deviation) << std::endl + << "Deviation abs(cpu[" << std::to_string(arg_max_deviation) + << "] - gpu[" << std::to_string(arg_max_deviation) << "]) = " + << std::to_string(max_deviation) << std::endl; +} + + +template <typename T> +void BeamformTester::compare_voltage( + const thrust::host_vector<T> cpu, + const thrust::host_vector<T> gpu, + const float tol) +{ + BOOST_LOG_TRIVIAL(debug) << "Comparing results .."; + // Check if vectors have the same size + ASSERT_TRUE(cpu.size() == gpu.size()) + << "Host and device vector size not equal" << std::endl; + + int arg_max = 0; + float absolute; + + float2 max_deviation = {0,0}; + float2 diff; + float2 gpu_element; + float2 cpu_element; + // Check each element of CPU and GPU implementation + for(std::size_t i = 0; i < gpu.size(); i++) + { + if constexpr (std::is_same<T, __half2>::value) + { + gpu_element = __half22float2(gpu[i]); + cpu_element = __half22float2(cpu[i]); + } + else + { + gpu_element = gpu[i]; + cpu_element = cpu[i]; + } + diff = csub(gpu_element, cpu_element); + absolute = cabs(diff); + + if(absolute > cabs(max_deviation)) + { + arg_max = i; + max_deviation = diff; + } + ASSERT_TRUE(absolute <= tol) << "Beamformer: CPU and GPU result is unequal for element " << std::to_string(i) << std::endl + << " CPU result: " << std::to_string(cpu_element.x) << "+ i*" << std::to_string(cpu_element.y) << std::endl + << " GPU result: " << std::to_string(gpu_element.x) << "+ i*" << std::to_string(gpu_element.y) << std::endl; + } + + BOOST_LOG_TRIVIAL(debug) << "Maximum deviation detected for element " << std::to_string(arg_max) << std::endl + << "Deviation abs(cpu[" << std::to_string(arg_max) + << "] - gpu[" << std::to_string(arg_max) << "]) = " + << std::to_string(max_deviation.x) << " + i* " << std::to_string(max_deviation.y); +} + + +template<typename T, typename U> +void BeamformTester::gpu_process( + thrust::host_vector<T>& in, + thrust::host_vector<T>& weights, + thrust::host_vector<U>& out) +{ + thrust::device_vector<T> dev_input = in; + thrust::device_vector<T> dev_weights = weights; + thrust::device_vector<U> dev_output(out.size()); + + cudaStream_t stream; + CUDA_ERROR_CHECK(cudaStreamCreate(&stream)); + + Beamformer<T> beamformer( + stream, + conf.n_samples, + conf.n_channel, + conf.n_elements, + conf.n_beam, + conf.integration); + + beamformer.process( + thrust::raw_pointer_cast(dev_input.data()), + thrust::raw_pointer_cast(dev_weights.data()), + thrust::raw_pointer_cast(dev_output.data())); + + CUDA_ERROR_CHECK(cudaDeviceSynchronize()); + CUDA_ERROR_CHECK(cudaStreamDestroy(stream)); + // Copy device 2 host (output) + out = dev_output; +} + + +template<typename T, typename U> +void BeamformTester::cpu_process_power( + thrust::host_vector<T>& in, // Dataprodcut: F-P-T-E + thrust::host_vector<T>& weights, // Dataproduct: F-P-B-E + thrust::host_vector<U>& out) // Dataprodcut: F-P-T-B +{ + BOOST_LOG_TRIVIAL(debug) << "Calculating CPU results... " << std::flush; + int te = conf.n_samples * conf.n_elements; + int be = conf.n_beam * conf.n_elements; + int tb = conf.n_beam * conf.n_samples / conf.integration; + int pte = conf.n_pol * te; + int pbe = conf.n_pol * be; + int ou_idx, in_idx, wg_idx; + float2 voltage = {0,0}; + float power; + for(int f = 0; f < conf.n_channel; f++) + { + for(int p = 0; p < conf.n_pol; p++) + { + for(int b = 0; b < conf.n_beam; b++) + { + for(int t = 0; t < conf.n_samples / conf.integration; t++) + { + ou_idx = f * tb + conf.n_beam * t + b; + power = 0; + for(int i = 0; i < conf.integration; i++) + { + voltage = {0,0}; + for(int e = 0; e < conf.n_elements; e++) + { + in_idx = f * pte + p * te + conf.n_elements * (t * conf.integration + i) + e; + wg_idx = f * pbe + p * be + conf.n_elements * b + e; + + if constexpr(std::is_same<T, __half2>::value) + { + voltage = cmadd(__half22float2(in[in_idx]), __half22float2(weights[wg_idx]), voltage); + } + else + { + voltage = cmadd(in[in_idx], weights[wg_idx], voltage); + } + } + power += cabs(voltage)*cabs(voltage) / conf.integration; + } + if constexpr (std::is_same<T, __half2>::value) + { + out[ou_idx] = __float2half(power + __half2float(out[ou_idx])); + } + else + { + out[ou_idx] += power; + } + } + } + } + } +} + + +template<typename T> +void BeamformTester::cpu_process_voltage( + thrust::host_vector<T>& in, // Dataprodcut: F-P-T-E + thrust::host_vector<T>& weights, // Dataproduct: F-P-B-E + thrust::host_vector<T>& out) // Dataprodcut: F-P-T-B +{ + BOOST_LOG_TRIVIAL(debug) << "Calculating CPU results... " << std::flush; + int te = conf.n_samples * conf.n_elements; + int be = conf.n_beam * conf.n_elements; + int tb = conf.n_beam * conf.n_samples; + int ptb = conf.n_pol * tb; + int pte = conf.n_pol * te; + int pbe = conf.n_pol * be; + int ou_idx, in_idx, wg_idx; + float2 voltage = {0,0}; + for(int f = 0; f < conf.n_channel; f++) + { + for(int p = 0; p < conf.n_pol; p++) + { + for(int t = 0; t < conf.n_samples; t++) + { + for(int b = 0; b < conf.n_beam; b++) + { + ou_idx = f * ptb + p * tb + conf.n_beam * t + b; + voltage = {0,0}; + for(int e = 0; e < conf.n_elements; e++) + { + in_idx = f * pte + p * te + conf.n_elements * t + e; + wg_idx = f * pbe + p * be + conf.n_elements * b + e; + + if constexpr(std::is_same<T, __half2>::value) + { + voltage = cmadd(__half22float2(in[in_idx]), __half22float2(weights[wg_idx]), voltage); + } + else + { + voltage = cmadd(in[in_idx], weights[wg_idx], voltage); + } + } + if constexpr (std::is_same<T, __half2>::value) + { + out[ou_idx] = __float22half2_rn(voltage); + } + else + { + out[ou_idx] = voltage; + } + } + } + } + } +} + +/** +* Testing with Google Test Framework +*/ + +TEST_P(BeamformTester, BeamformerVoltageHalf) +{ + std::cout << std::endl + << "-------------------------------------------------------------" << std::endl + << " Testing voltage mode with T=__half2 (half precision 2x16bit) " << std::endl + << "-------------------------------------------------------------" << std::endl << std::endl; + test<__half2, __half2>(5); // High inaccuarcy due to half to float casting and vice versa, we need to accept a high tolerance +} + +TEST_P(BeamformTester, BeamformerVoltageSingle){ + std::cout << std::endl + << "\n-------------------------------------------------------------" << std::endl + << " Testing voltage mode with T=float2 (single precision 2x32bit) " << std::endl + << "---------------------------------------------------------------\n" << std::endl; + test<float2, float2>(0.01); +} + +TEST_P(BeamformTester, BeamformerPowerHalf) +{ + std::cout << std::endl + << "-------------------------------------------------------------" << std::endl + << " Testing power mode with T=__half2 (half precision 2x16bit) " << std::endl + << "-------------------------------------------------------------" << std::endl << std::endl; + test<__half2, __half>(5); // High inaccuarcy due to half to float casting and vice versa between CPU and GPU. We need to accept a high tolerance. +} + +TEST_P(BeamformTester, BeamformerPowerSingle){ + std::cout << std::endl + << "\n-----------------------------------------------------------" << std::endl + << " Testing power mode with T=float2 (single precision 2x32bit) " << std::endl + << "-------------------------------------------------------------\n" << std::endl; + test<float2, float>(0.01); +} + + +INSTANTIATE_TEST_CASE_P(BeamformerTesterInstantiation, BeamformTester, ::testing::Values( + + // device ID | samples | channels | elements | beam | integration/integration + BeamformTestConfig{0, 8, 1, 4, 4, 1}, + BeamformTestConfig{0, 128, 3, 32, 32, 1}, + BeamformTestConfig{0, 512, 6, 67, 97, 1}, + BeamformTestConfig{0, 1024, 17, 512, 128, 1}, + BeamformTestConfig{0, 64, 1, 32, 256, 2}, + BeamformTestConfig{0, 128, 42, 32, 2048, 4}, + BeamformTestConfig{0, 256, 7, 32, 1024, 8}, + BeamformTestConfig{0, 512, 10, 32, 777, 16}, + BeamformTestConfig{0, 1024, 1, 32, 123, 32}, + BeamformTestConfig{0, 2048, 7, 15, 456, 1}, + BeamformTestConfig{0, 4096, 3, 33, 277, 2} +)); + + + +} // namespace psrdada_cpp +} // namespace cryopaf +} // namespace test diff --git a/psrdada_cpp/cryopaf/test/src/UnpackerTester.cu b/psrdada_cpp/cryopaf/test/src/UnpackerTester.cu new file mode 100644 index 0000000000000000000000000000000000000000..bccf59af829c0016411cce2187632924d16e7d01 --- /dev/null +++ b/psrdada_cpp/cryopaf/test/src/UnpackerTester.cu @@ -0,0 +1,197 @@ +#include "psrdada_cpp/cryopaf/test/UnpackerTester.cuh" + +namespace psrdada_cpp { +namespace cryopaf { +namespace test { + +UnpackerTester::UnpackerTester() + : ::testing::TestWithParam<UnpackerTestConfig>(), + conf(GetParam()) +{ + CUDA_ERROR_CHECK(cudaSetDevice(conf.device_id)); +} +UnpackerTester::~UnpackerTester() +{ + +} +void UnpackerTester::SetUp() +{ +} +void UnpackerTester::TearDown() +{ +} + +template<typename T> +void UnpackerTester::test() +{ + std::size_t n = conf.n_samples * conf.n_channel * conf.n_elements * conf.n_pol; + std::default_random_engine generator; + std::uniform_int_distribution<uint64_t> distribution(0,65535); + + thrust::host_vector<uint64_t> input(n/2); + thrust::host_vector<T> host_output(n); + thrust::host_vector<T> dev_output(n); + BOOST_LOG_TRIVIAL(debug) << "Required device memory: " << (n * (sizeof(T) + sizeof(uint64_t)/2)) / (1024*1024) << "MiB"; + BOOST_LOG_TRIVIAL(debug) << "Required host memory: " << (n * (2 * sizeof(T) + sizeof(uint64_t)/2)) / (1024*1024) << "MiB"; + + // Generate test samples + BOOST_LOG_TRIVIAL(debug) << "Generating " << n << " test samples..."; + for (int i = 0; i < n/2; i++) + { + input[i] = (uint64_t)((distribution(generator) << 48) & 0xFFFF000000000000LL); + input[i] += (uint64_t)((distribution(generator) << 32) & 0x0000FFFF00000000LL); + input[i] += (uint64_t)((distribution(generator) << 16) & 0x00000000FFFF0000LL); + input[i] += (uint64_t)((distribution(generator)) & 0x000000000000FFFFLL); + } + + cpu_process(input, host_output); + + gpu_process(input, dev_output); + + compare(host_output, dev_output); +} + +template<typename T> +void UnpackerTester::cpu_process( + thrust::host_vector<uint64_t>& input, + thrust::host_vector<T>& output) +{ + BOOST_LOG_TRIVIAL(debug) << "Computing CPU results..."; + uint64_t tmp; + int in_idx, out_idx_x, out_idx_y; + if(conf.protocol == "codif") + { + for (int f = 0; f < conf.n_channel; f++) + { + for(int t1 = 0; t1 < conf.n_samples/NSAMP_DF; t1++) + { + for(int a = 0; a < conf.n_elements; a++) + { + for(int t2 = 0; t2 < NSAMP_DF; t2++) + { + in_idx = t1 * conf.n_elements * conf.n_channel * NSAMP_DF + + a * conf.n_channel * NSAMP_DF + + t2 * conf.n_channel + + f; + out_idx_x = f * conf.n_pol * conf.n_samples * conf.n_elements + + (NSAMP_DF * t1 + t2) * conf.n_elements + + a; + out_idx_y = f * conf.n_pol * conf.n_samples * conf.n_elements + + conf.n_samples * conf.n_elements + + (NSAMP_DF * t1 + t2) * conf.n_elements + + a; + tmp = bswap_64(input[in_idx]); + if constexpr(std::is_same<T, __half2>::value) + { + output[out_idx_x].x = __float2half(static_cast<float>(tmp & 0x000000000000ffffULL)); + output[out_idx_x].y = __float2half(static_cast<float>((tmp & 0x00000000ffff0000ULL) >> 16)); + output[out_idx_y].x = __float2half(static_cast<float>((tmp & 0x0000ffff00000000ULL) >> 32)); + output[out_idx_y].y = __float2half(static_cast<float>((tmp & 0xffff000000000000ULL) >> 48)); + } + else + { + output[out_idx_x].x = static_cast<decltype(T::x)>(tmp & 0x000000000000ffffULL); + output[out_idx_x].y = static_cast<decltype(T::y)>((tmp & 0x00000000ffff0000ULL) >> 16); + output[out_idx_y].x = static_cast<decltype(T::x)>((tmp & 0x0000ffff00000000ULL) >> 32); + output[out_idx_y].y = static_cast<decltype(T::y)>((tmp & 0xffff000000000000ULL) >> 48); + } + } + } + } + } + } +} + +template<typename T> +void UnpackerTester::gpu_process( + thrust::host_vector<uint64_t>& input, + thrust::host_vector<T>& output) +{ + cudaStream_t stream; + CUDA_ERROR_CHECK(cudaStreamCreate(&stream)); + // Copy host 2 device (input) + thrust::device_vector<uint64_t> dev_input = input; + thrust::device_vector<T> dev_output(output.size()); + + BOOST_LOG_TRIVIAL(debug) << "Computing GPU results..."; + + Unpacker<T> unpacker(stream, conf.n_samples, conf.n_channel, conf.n_elements, conf.protocol); + unpacker.unpack( + (char*)thrust::raw_pointer_cast(dev_input.data()), + (T*)thrust::raw_pointer_cast(dev_output.data())); + + CUDA_ERROR_CHECK(cudaDeviceSynchronize()); + CUDA_ERROR_CHECK(cudaStreamDestroy(stream)); + // Copy device 2 host (output) + output = dev_output; +} + +template<typename T> +void UnpackerTester::compare( + thrust::host_vector<T>& cpu, + thrust::host_vector<T>& gpu) +{ + BOOST_LOG_TRIVIAL(debug) << "Comparing results..."; + + float2 gpu_element; + float2 cpu_element; + + ASSERT_TRUE(cpu.size() == gpu.size()) + << "Host and device vector size not equal" << std::endl; + for (int i = 0; i < cpu.size(); i++) + { + if constexpr (std::is_same<T, __half2>::value) + { + gpu_element = __half22float2(gpu[i]); + cpu_element = __half22float2(cpu[i]); + } + else + { + gpu_element = gpu[i]; + cpu_element = cpu[i]; + } + ASSERT_TRUE(cpu_element.x == gpu_element.x && cpu_element.y == gpu_element.y) + << "Unpacker: CPU and GPU results are unequal for element " << std::to_string(i) << std::endl + << " CPU result: " << std::to_string(cpu_element.x) << " + i*" << std::to_string(cpu_element.y) << std::endl + << " GPU result: " << std::to_string(gpu_element.x) << " + i*" << std::to_string(gpu_element.y) << std::endl; + } +} + +/** +* Testing with Google Test Framework +*/ + +TEST_P(UnpackerTester, UnpackerSinglePrecisionFPTE){ + BOOST_LOG_TRIVIAL(info) + << "\n------------------------------------------------------------------------" << std::endl + << " Testing unpacker with T=float2 (single precision 2x32bit), Format = FPTE " << std::endl + << "------------------------------------------------------------------------\n" << std::endl; + test<float2>(); +} + +TEST_P(UnpackerTester, UnpackerHalfPrecisionFPTE){ + BOOST_LOG_TRIVIAL(info) + << "\n------------------------------------------------------------------------" << std::endl + << " Testing unpacker with T=half2 (half precision 2x16bit), Format = FPTE " << std::endl + << "------------------------------------------------------------------------\n" << std::endl; + test<__half2>(); +} + +INSTANTIATE_TEST_CASE_P(UnpackerTesterInstantiation, UnpackerTester, ::testing::Values( + // devie id | samples | channels | elements | protocol + UnpackerTestConfig{0, 4096, 7, 36, "codif"}, + UnpackerTestConfig{0, 128, 14, 2, "codif"}, + UnpackerTestConfig{0, 256, 21, 32, "codif"}, + UnpackerTestConfig{0, 512, 21, 11, "codif"}, + UnpackerTestConfig{0, 1024, 14, 28, "codif"}, + UnpackerTestConfig{0, 2048, 21, 28, "codif"}, + UnpackerTestConfig{0, 4096, 14, 128, "codif"}, + UnpackerTestConfig{0, 1024, 14, 64, "codif"}, + UnpackerTestConfig{0, 256, 14, 17, "codif"}, + UnpackerTestConfig{0, 128, 14, 13, "codif"}, + UnpackerTestConfig{0, 896, 14, 11, "codif"} +)); + +} //namespace test +} // cryopaf +} //namespace psrdada_cpp diff --git a/psrdada_cpp/cryopaf/test/src/gtest_beamforming.cu b/psrdada_cpp/cryopaf/test/src/gtest_beamforming.cu new file mode 100644 index 0000000000000000000000000000000000000000..cb4af31397643a64ea09f4b0d3855aefb5fb0228 --- /dev/null +++ b/psrdada_cpp/cryopaf/test/src/gtest_beamforming.cu @@ -0,0 +1,7 @@ +#include <gtest/gtest.h> + +int main(int argc, char **argv) +{ + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +}