nnfw::cker::random::PhiloxRandom Class Reference

#include <PhiloxRandom.h>

Public Types
using	ResultType = Array< uint32_t, 4 >
using	ResultElementType = uint32_t
using	Key = Array< uint32_t, 2 >

Public Member Functions
PHILOX_DEVICE_INLINE	PhiloxRandom ()
PHILOX_DEVICE_INLINE	PhiloxRandom (uint64_t seed)
PHILOX_DEVICE_INLINE	PhiloxRandom (uint64_t seed_lo, uint64_t seed_hi)
PHILOX_DEVICE_INLINE	PhiloxRandom (ResultType counter, Key key)
PHILOX_DEVICE_INLINE ResultType const &	counter () const
PHILOX_DEVICE_INLINE Key const &	key () const
PHILOX_DEVICE_INLINE void	Skip (uint64_t count)
PHILOX_DEVICE_INLINE ResultType	operator() ()

Static Public Attributes
static constexpr int	kResultElementCount = 4
static constexpr int	kElementCost = 10

Detailed Description

Definition at line 107 of file PhiloxRandom.h.

Member Typedef Documentation

Key

using nnfw::cker::random::PhiloxRandom::Key = Array<uint32_t, 2>

Definition at line 118 of file PhiloxRandom.h.

ResultElementType

using nnfw::cker::random::PhiloxRandom::ResultElementType = uint32_t

Definition at line 111 of file PhiloxRandom.h.

ResultType

using nnfw::cker::random::PhiloxRandom::ResultType = Array<uint32_t, 4>

Definition at line 110 of file PhiloxRandom.h.

Constructor & Destructor Documentation

PhiloxRandom() [1/4]

PHILOX_DEVICE_INLINE nnfw::cker::random::PhiloxRandom::PhiloxRandom ( )

inline

Definition at line 121 of file PhiloxRandom.h.

{}

PhiloxRandom() [2/4]

PHILOX_DEVICE_INLINE nnfw::cker::random::PhiloxRandom::PhiloxRandom ( uint64_t  seed )

inlineexplicit

Definition at line 124 of file PhiloxRandom.h.

  {
    key_[0] = static_cast<uint32_t>(seed);
    key_[1] = static_cast<uint32_t>(seed >> 32);
  }

PhiloxRandom() [3/4]

PHILOX_DEVICE_INLINE nnfw::cker::random::PhiloxRandom::PhiloxRandom ( uint64_t  seed_lo, uint64_t  seed_hi  )

inlineexplicit

Definition at line 131 of file PhiloxRandom.h.

  {
    key_[0] = static_cast<uint32_t>(seed_lo);
    key_[1] = static_cast<uint32_t>(seed_lo >> 32);
    counter_[2] = static_cast<uint32_t>(seed_hi);
    counter_[3] = static_cast<uint32_t>(seed_hi >> 32);
  }

PhiloxRandom() [4/4]

PHILOX_DEVICE_INLINE nnfw::cker::random::PhiloxRandom::PhiloxRandom ( ResultType  counter, Key  key  )

inline

Definition at line 140 of file PhiloxRandom.h.

: counter_(counter), key_(key) {}

Member Function Documentation

counter()

PHILOX_DEVICE_INLINE ResultType const & nnfw::cker::random::PhiloxRandom::counter ( ) const

inline

Definition at line 143 of file PhiloxRandom.h.

{ return counter_; }

Referenced by operator()().

key()

PHILOX_DEVICE_INLINE Key const & nnfw::cker::random::PhiloxRandom::key ( ) const

inline

Definition at line 146 of file PhiloxRandom.h.

{ return key_; }

Referenced by operator()().

operator()()

PHILOX_DEVICE_INLINE ResultType nnfw::cker::random::PhiloxRandom::operator() ( )

inline

Definition at line 173 of file PhiloxRandom.h.

  {
    ResultType counter = counter_;
    Key key = key_;
 
    // Run the single rounds for ten times. Manually unrolling the loop
    // for better performance.
    counter = ComputeSingleRound(counter, key);
    RaiseKey(&key);
    counter = ComputeSingleRound(counter, key);
    RaiseKey(&key);
    counter = ComputeSingleRound(counter, key);
    RaiseKey(&key);
    counter = ComputeSingleRound(counter, key);
    RaiseKey(&key);
    counter = ComputeSingleRound(counter, key);
    RaiseKey(&key);
    counter = ComputeSingleRound(counter, key);
    RaiseKey(&key);
    counter = ComputeSingleRound(counter, key);
    RaiseKey(&key);
    counter = ComputeSingleRound(counter, key);
    RaiseKey(&key);
    counter = ComputeSingleRound(counter, key);
    RaiseKey(&key);
    counter = ComputeSingleRound(counter, key);
 
    SkipOne();
 
    return counter;
  }

References counter(), and key().

Skip()

PHILOX_DEVICE_INLINE void nnfw::cker::random::PhiloxRandom::Skip ( uint64_t  count )

inline

Definition at line 150 of file PhiloxRandom.h.

  {
    const uint32_t count_lo = static_cast<uint32_t>(count);
    uint32_t count_hi = static_cast<uint32_t>(count >> 32);
 
    counter_[0] += count_lo;
    if (counter_[0] < count_lo)
    {
      ++count_hi;
    }
 
    counter_[1] += count_hi;
    if (counter_[1] < count_hi)
    {
      if (++counter_[2] == 0)
      {
        ++counter_[3];
      }
    }
  }

Referenced by nnfw::cker::functor::FillPhiloxRandomTask< Distribution, true >::Run(), and nnfw::cker::functor::FillPhiloxRandomTask< Distribution, false >::Run().

Field Documentation

kElementCost

constexpr int nnfw::cker::random::PhiloxRandom::kElementCost = 10

staticconstexpr

Definition at line 115 of file PhiloxRandom.h.

kResultElementCount

constexpr int nnfw::cker::random::PhiloxRandom::kResultElementCount = 4

staticconstexpr

Definition at line 113 of file PhiloxRandom.h.

Referenced by nnfw::cker::functor::FillPhiloxRandomTask< Distribution, true >::Run().

---

The documentation for this class was generated from the following file:

• compute/cker/include/cker/operation/Helper/PhiloxRandom.h