state.h

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
// Copyright Contributors to the OpenQMC Project.
 
 
#pragma once
 
#include "encode.h"
#include "gpu.h"
#include "pcg.h"
 
#include <cassert>
#include <cstdint>
 
namespace oqmc
{
 
struct State64Bit
{
    static constexpr auto maxIndexBitSize = 16;   
    static constexpr auto maxIndexSize = 1 << 16; 
    static constexpr auto spatialEncodeBitSizeX = 8; 
    static constexpr auto spatialEncodeBitSizeY = 8; 
 
    static_assert(spatialEncodeBitSizeX == spatialEncodeBitSizeY,
                  "Encoding must have equal resolution in x and y");
 
    /*AUTO_DEFINED*/ State64Bit() = default;
 
    OQMC_HOST_DEVICE State64Bit(int x, int y, int frame, int index);
 
    OQMC_HOST_DEVICE State64Bit pixelDecorrelate() const;
 
    OQMC_HOST_DEVICE State64Bit newDomain(int key) const;
 
    OQMC_HOST_DEVICE State64Bit newDomainSplit(int key, int size,
                                               int index) const;
 
    OQMC_HOST_DEVICE State64Bit newDomainDistrib(int key, int index) const;
 
    template <int Size>
    OQMC_HOST_DEVICE void drawRnd(std::uint32_t rnd[Size]) const;
 
    std::uint32_t patternId; 
    std::uint16_t sampleId;  
    std::uint16_t pixelId;   
};
 
OQMC_HOST_DEVICE constexpr int computeIndexKey(int index)
{
    constexpr auto offset = State64Bit::maxIndexBitSize;
    return index >> offset;
}
 
OQMC_HOST_DEVICE constexpr int computeIndexId(int index)
{
    constexpr auto mask = State64Bit::maxIndexSize - 1;
    return index & mask;
}
 
inline State64Bit::State64Bit(int x, int y, int frame, int index)
{
    assert(index >= 0);
 
    const auto indexKey = computeIndexKey(index);
    const auto indexId = computeIndexId(index);
 
    constexpr auto xBits = State64Bit::spatialEncodeBitSizeX;
    constexpr auto yBits = State64Bit::spatialEncodeBitSizeY;
 
    const auto pixelId = encodeBits16<xBits, yBits, 0>({x, y, 0});
 
    this->patternId = pcg::init(frame + indexKey);
    this->sampleId = indexId;
    this->pixelId = pixelId;
}
 
inline State64Bit State64Bit::pixelDecorrelate() const
{
    return newDomain(pixelId);
}
 
inline State64Bit State64Bit::newDomain(int key) const
{
    auto ret = *this;
    ret.patternId = pcg::stateTransition(patternId + key);
 
    return ret;
}
 
inline State64Bit State64Bit::newDomainSplit(int key, int size, int index) const
{
    assert(size > 0);
    assert(index >= 0);
 
    const auto indexKey = computeIndexKey(sampleId * size + index);
    const auto indexId = computeIndexId(sampleId * size + index);
 
    auto ret = newDomain(key).newDomain(indexKey);
    ret.sampleId = indexId;
 
    return ret;
}
 
inline State64Bit State64Bit::newDomainDistrib(int key, int index) const
{
    assert(index >= 0);
 
    const auto indexKey = computeIndexKey(index);
    const auto indexId = computeIndexId(index);
 
    auto ret = newDomain(key).newDomain(indexKey).newDomain(sampleId);
    ret.sampleId = indexId;
 
    return ret;
}
 
template <int Size>
void State64Bit::drawRnd(std::uint32_t rnd[Size]) const
{
    static_assert(Size >= 0, "Draw size greater or equal to zero.");
 
    auto rngState = patternId + sampleId;
 
    for(int i = 0; i < Size; ++i)
    {
        rnd[i] = pcg::rng(rngState);
    }
}
 
static_assert(sizeof(State64Bit) == 8, "State64Bit must be 8 bytes in size.");
 
} // namespace oqmc