ComponentMask.hpp

Go to the documentation of this file.

/*
 * ------------------------------------------------------------------------------------------------------------
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (c) 2018-2020 Lawrence Livermore National Security LLC
 * Copyright (c) 2018-2020 The Board of Trustees of the Leland Stanford Junior University
 * Copyright (c) 2018-2020 TotalEnergies
 * Copyright (c) 2019-     GEOSX Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */
 
#ifndef GEOS_LINEARALGEBRA_UTILITIES_COMPONENTMASK_HPP_
#define GEOS_LINEARALGEBRA_UTILITIES_COMPONENTMASK_HPP_
 
#include "common/GeosxMacros.hpp"
#include "common/Logger.hpp"
 
#include <cstdint>
 
namespace geos
{
 
namespace internal
{
 
template< typename T >
constexpr bool always_false( T )
{
  return false;
}
 
template< int N >
struct ComponentMaskType
{
  static_assert( always_false( N ), "Unsupported template parameter N for ComponentMask. Use a value between 8 and 64." );
};
 
#define GEOS_LAI_COMPONENTMASK_DECL( N ) \
  template<> \
  struct ComponentMaskType< N > \
  { \
    using type = std::uint ## N ## _t; \
  }
 
GEOS_LAI_COMPONENTMASK_DECL( 8 );
GEOS_LAI_COMPONENTMASK_DECL( 16 );
GEOS_LAI_COMPONENTMASK_DECL( 32 );
GEOS_LAI_COMPONENTMASK_DECL( 64 );
 
#undef GEOS_LAI_COMPONENTMASK_DECL
 
constexpr std::uint32_t roundToNextPowerOfTwo( std::uint32_t v )
{
  if( v <= 8 ) return 8;
  v--;
  v |= v >> 1;
  v |= v >> 2;
  v |= v >> 4;
  v |= v >> 8;
  v |= v >> 16;
  v++;
  return v;
}
 
}
 
template< int MAX_COMP >
class ComponentMask
{
private:
 
  static constexpr int NUM_BITS = internal::roundToNextPowerOfTwo( MAX_COMP );
 
  using mask_t = typename internal::ComponentMaskType< NUM_BITS >::type;
 
public:
 
 
  GEOS_HOST_DEVICE
  ComponentMask( int const numComp, bool const includeAll )
    : m_mask( includeAll ? -1 : 0 )
  {
    setNumComp( numComp );
  }
 
  GEOS_HOST_DEVICE
  explicit ComponentMask( int const numComp = 0 )
    : ComponentMask( numComp, false )
  {}
 
  GEOS_HOST_DEVICE
  ComponentMask( int const numComp, int const lo, int const hi )
    : ComponentMask( numComp )
  {
    for( int i = lo; i < hi; ++i )
    {
      set( i );
    }
  }
 
  template< int N, typename = std::enable_if_t< ( N < MAX_COMP ) > >
  GEOS_HOST_DEVICE
  ComponentMask( ComponentMask< N > const & other )
    : m_numComp( other.numComp() )
  {
    for( int i : other )
    {
      set( i );
    }
  }
 
 
 
  class Iterator
  {
public:
 
    using difference_type = int;                         
    using value_type = int;                              
    using pointer = void;                                
    using reference = int;                               
    using iterator_category = std::forward_iterator_tag; 
 
    GEOS_HOST_DEVICE
    GEOS_FORCE_INLINE
    reference operator*() const
    {
      return m_index;
    }
 
    GEOS_HOST_DEVICE
    GEOS_FORCE_INLINE
    Iterator & operator++()
    {
      GEOS_ASSERT_NE( m_mask, 0 );
      skipOne();
      findNextBit();
      return *this;
    }
 
    GEOS_HOST_DEVICE
    GEOS_FORCE_INLINE
    Iterator operator++( int ) &
    {
      Iterator old = *this;
      ++*this;
      return old;
    }
 
    GEOS_HOST_DEVICE
    GEOS_FORCE_INLINE
    bool operator==( Iterator const & other ) const
    {
      return m_mask == other.m_mask;
    }
 
    GEOS_HOST_DEVICE
    GEOS_FORCE_INLINE
    bool operator!=( Iterator const & other ) const
    {
      return !(*this == other);
    }
 
private:
 
    GEOS_HOST_DEVICE
    inline
    void skipOne()
    {
      m_mask >>= 1;
      ++m_index;
    }
 
    GEOS_HOST_DEVICE
    GEOS_FORCE_INLINE
    void findNextBit()
    {
      if( m_mask )
      {
        // TODO: use hardware intrinsics (ffs/ctz) where possible
        while( !( m_mask & 1 ) )
        {
          skipOne();
        }
      }
    }
 
    GEOS_HOST_DEVICE
    Iterator( mask_t const mask, int const index )
      : m_mask( mask ),
      m_index( index )
    {
      findNextBit();
    }
 
    friend class ComponentMask;
 
    mask_t m_mask;
    int m_index;
  };
 
  GEOS_HOST_DEVICE
  Iterator begin() const
  {
    return Iterator( m_mask, 0 );
  }
 
  GEOS_HOST_DEVICE
  Iterator end() const
  {
    return Iterator( 0, -1 );
  }
 
  GEOS_HOST_DEVICE
  int size() const
  {
    mask_t mask = m_mask;
    int c = 0;
    for(; mask != 0; ++c )
    {
      mask &= mask - 1;
    }
    return c;
  }
 
  GEOS_HOST_DEVICE
  int numComp() const
  {
    return m_numComp;
  }
 
  GEOS_HOST_DEVICE
  bool empty() const
  {
    return m_mask == 0;
  }
 
  GEOS_HOST_DEVICE
  bool operator[]( int const i ) const
  {
    GEOS_ASSERT_GT( m_numComp, i );
    return m_mask & (mask_t( 1 ) << i);
  }
 
 
 
  GEOS_HOST_DEVICE
  void clear()
  {
    m_mask = 0;
  }
 
  GEOS_HOST_DEVICE
  void setNumComp( int const numComp )
  {
    GEOS_ASSERT_GE( numComp, 0 );
    GEOS_ASSERT_GE( MAX_COMP, numComp );
    m_numComp = numComp;
    if( numComp < NUM_BITS )
    {
      m_mask &= ( mask_t( 1 ) << numComp ) - 1;
    }
  }
 
  GEOS_HOST_DEVICE
  void set( int const i )
  {
    GEOS_ASSERT_GE( i, 0 );
    GEOS_ASSERT_GT( m_numComp, i );
    m_mask |= mask_t( 1 ) << i;
  }
 
  GEOS_HOST_DEVICE
  void unset( int const i )
  {
    GEOS_ASSERT_GE( i, 0 );
    GEOS_ASSERT_GT( m_numComp, i );
    m_mask &= ~(mask_t( 1 ) << i);
  }
 
  GEOS_HOST_DEVICE
  void invert()
  {
    m_mask = ~m_mask;
    setNumComp( m_numComp );
  }
 
  GEOS_HOST_DEVICE
  ComponentMask & operator+=( int const i )
  {
    set( i );
    return *this;
  }
 
  GEOS_HOST_DEVICE
  ComponentMask & operator-=( int const i )
  {
    unset( i );
    return *this;
  }
 
  GEOS_HOST_DEVICE
  ComponentMask operator~() const
  {
    ComponentMask mask( *this );
    mask.invert();
    return mask;
  }
 
  GEOS_HOST_DEVICE
  friend ComponentMask operator+( ComponentMask const & mask, int const i )
  {
    ComponentMask new_mask = mask;
    new_mask += i;
    return new_mask;
  }
 
  GEOS_HOST_DEVICE
  friend ComponentMask operator+( int const i, ComponentMask const & mask )
  {
    return mask + i;
  }
 
  GEOS_HOST_DEVICE
  friend ComponentMask operator-( ComponentMask const & mask, int const i )
  {
    ComponentMask new_mask = mask;
    new_mask -= i;
    return new_mask;
  }
 
  GEOS_HOST_DEVICE
  friend ComponentMask operator-( int const i, ComponentMask const & mask )
  {
    return mask - i;
  }
 
 
private:
 
  mask_t m_mask = 0;
 
  int m_numComp = MAX_COMP;
};
 
}
 
#endif //GEOS_LINEARALGEBRA_UTILITIES_COMPONENTMASK_HPP_