sampler.h

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
// Copyright Contributors to the OpenQMC Project.
 
 
#pragma once
 
#include "float.h" // NOLINT: false positive
#include "gpu.h"
#include "range.h"
 
#include <cassert>
#include <cstddef>
#include <cstdint>
 
 
namespace oqmc
{
 
template <typename Impl>
class SamplerInterface
{
    // Dimensions per pattern.
    static constexpr auto maxDrawValue = 4;
 
    // Prevent value-construction.
    OQMC_HOST_DEVICE SamplerInterface(Impl impl);
 
    // Implemention type.
    Impl impl;
 
  public:
    static constexpr std::size_t cacheSize = Impl::cacheSize;
 
    static void initialiseCache(void* cache);
 
    /*AUTO_DEFINED*/ SamplerInterface() = default;
 
    OQMC_HOST_DEVICE SamplerInterface(int x, int y, int frame, int index,
                                      const void* cache);
 
    OQMC_HOST_DEVICE SamplerInterface newDomain(int key) const;
 
    OQMC_HOST_DEVICE SamplerInterface newDomainSplit(int key, int size,
                                                     int index) const;
 
    OQMC_HOST_DEVICE SamplerInterface newDomainDistrib(int key,
                                                       int index) const;
 
    OQMC_HOST_DEVICE SamplerInterface newDomainChain(int key, int index) const;
 
    template <int Size>
    OQMC_HOST_DEVICE void drawSample(std::uint32_t sample[Size]) const;
 
    template <int Size>
    OQMC_HOST_DEVICE void drawSample(std::uint32_t range,
                                     std::uint32_t sample[Size]) const;
 
    template <int Size>
    OQMC_HOST_DEVICE void drawSample(float sample[Size]) const;
 
    template <int Size>
    OQMC_HOST_DEVICE void drawRnd(std::uint32_t rnd[Size]) const;
 
    template <int Size>
    OQMC_HOST_DEVICE void drawRnd(std::uint32_t range,
                                  std::uint32_t rnd[Size]) const;
 
    template <int Size>
    OQMC_HOST_DEVICE void drawRnd(float rnd[Size]) const;
};
 
template <typename Impl>
void SamplerInterface<Impl>::initialiseCache(void* cache)
{
    Impl::initialiseCache(cache);
}
 
template <typename Impl>
SamplerInterface<Impl>::SamplerInterface(Impl impl) : impl(impl)
{
}
 
template <typename Impl>
SamplerInterface<Impl>::SamplerInterface(int x, int y, int frame, int index,
                                         const void* cache)
    : impl(x, y, frame, index, cache)
{
    assert(index >= 0);
}
 
template <typename Impl>
SamplerInterface<Impl> SamplerInterface<Impl>::newDomain(int key) const
{
    return {impl.newDomain(key)};
}
 
template <typename Impl>
SamplerInterface<Impl> SamplerInterface<Impl>::newDomainSplit(int key, int size,
                                                              int index) const
{
    assert(size > 0);
    assert(index >= 0);
 
    return {impl.newDomainSplit(key, size, index)};
}
 
template <typename Impl>
SamplerInterface<Impl> SamplerInterface<Impl>::newDomainDistrib(int key,
                                                                int index) const
{
    assert(index >= 0);
 
    return {impl.newDomainDistrib(key, index)};
}
 
template <typename Impl>
SamplerInterface<Impl> SamplerInterface<Impl>::newDomainChain(int key,
                                                              int index) const
{
    assert(index >= 0);
 
    return {impl.newDomain(key).newDomain(index)};
}
 
template <typename Impl>
template <int Size>
void SamplerInterface<Impl>::drawSample(std::uint32_t sample[Size]) const
{
    static_assert(Size >= 0, "Draw size greater or equal to zero.");
    static_assert(Size <= maxDrawValue, "Draw size less or equal to max.");
 
    impl.template drawSample<Size>(sample);
}
 
template <typename Impl>
template <int Size>
void SamplerInterface<Impl>::drawSample(std::uint32_t range,
                                        std::uint32_t sample[Size]) const
{
    assert(range > 0);
 
    std::uint32_t integerSample[Size];
    drawSample<Size>(integerSample);
 
    for(int i = 0; i < Size; ++i)
    {
        sample[i] = uintToRange(integerSample[i], range);
    }
}
 
template <typename Impl>
template <int Size>
void SamplerInterface<Impl>::drawSample(float sample[Size]) const
{
    std::uint32_t integerSample[Size];
    drawSample<Size>(integerSample);
 
    for(int i = 0; i < Size; ++i)
    {
        sample[i] = uintToFloat(integerSample[i]);
    }
}
 
template <typename Impl>
template <int Size>
void SamplerInterface<Impl>::drawRnd(std::uint32_t rnd[Size]) const
{
    static_assert(Size >= 0, "Draw size greater or equal to zero.");
    static_assert(Size <= maxDrawValue, "Draw size less or equal to max.");
 
    impl.template drawRnd<Size>(rnd);
}
 
template <typename Impl>
template <int Size>
void SamplerInterface<Impl>::drawRnd(std::uint32_t range,
                                     std::uint32_t rnd[Size]) const
{
    assert(range > 0);
 
    std::uint32_t integerRnd[Size];
    drawRnd<Size>(integerRnd);
 
    for(int i = 0; i < Size; ++i)
    {
        rnd[i] = uintToRange(integerRnd[i], range);
    }
}
 
template <typename Impl>
template <int Size>
void SamplerInterface<Impl>::drawRnd(float rnd[Size]) const
{
    std::uint32_t integerRnd[Size];
    drawRnd<Size>(integerRnd);
 
    for(int i = 0; i < Size; ++i)
    {
        rnd[i] = uintToFloat(integerRnd[i]);
    }
}
 
} // namespace oqmc