ArrayOfSets.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2021, Lawrence Livermore National Security, LLC and LvArray contributors.
 * All rights reserved.
 * See the LICENSE file for details.
 * SPDX-License-Identifier: (BSD-3-Clause)
 */

#pragma once

#include "ArrayOfSetsView.hpp"

namespace LvArray
{

// Forward declaration of the ArrayOfArrays class so that we can define the assimilate method.
template< typename T, typename INDEX_TYPE, template< typename > class BUFFER_TYPE >
class ArrayOfArrays;


template< typename T,
          typename INDEX_TYPE,
          template< typename > class BUFFER_TYPE >
class ArrayOfSets : protected ArrayOfSetsView< T, INDEX_TYPE, BUFFER_TYPE >
{

  using ParentClass = ArrayOfSetsView< T, INDEX_TYPE, BUFFER_TYPE >;

public:
  using typename ParentClass::ValueType;
  using typename ParentClass::IndexType;
  using typename ParentClass::value_type;
  using typename ParentClass::size_type;


  inline
  ArrayOfSets( INDEX_TYPE const nsets=0, INDEX_TYPE defaultSetCapacity=0 ):
    ParentClass( true )
  {
    resize( nsets, defaultSetCapacity );
    setName( "" );
  }

  inline
  ArrayOfSets( ArrayOfSets const & src ):
    ParentClass( true )
  { *this = src; }

  inline
  ArrayOfSets( ArrayOfSets && ) = default;

  inline
  ~ArrayOfSets()
  { ParentClass::free(); }



  inline
  ArrayOfSets & operator=( ArrayOfSets const & src )
  {
    ParentClass::setEqualTo( src.m_numArrays,
                             src.m_offsets[ src.m_numArrays ],
                             src.m_offsets,
                             src.m_sizes,
                             src.m_values );
    return *this;
  }

  inline
  ArrayOfSets & operator=( ArrayOfSets && src )
  {
    ParentClass::free();
    ParentClass::operator=( std::move( src ) );
    return *this;
  }

  template< typename POLICY >
  inline
  void assimilate( ArrayOfArrays< T, INDEX_TYPE, BUFFER_TYPE > && src,
                   sortedArrayManipulation::Description const desc )
  {
    ParentClass::free();
    ParentClass::assimilate( reinterpret_cast< ParentClass && >( src ) );

    INDEX_TYPE const numSets = size();
    ArrayOfArraysView< T, INDEX_TYPE const, true, BUFFER_TYPE > const view =
      ArrayOfArraysView< T, INDEX_TYPE const, true, BUFFER_TYPE >( numSets,
                                                                   this->m_offsets,
                                                                   this->m_sizes,
                                                                   this->m_values );
    BUFFER_TYPE< INDEX_TYPE > const sizes = this->m_sizes;

    if( desc == sortedArrayManipulation::UNSORTED_NO_DUPLICATES )
    {
      RAJA::forall< POLICY >( RAJA::TypedRangeSegment< INDEX_TYPE >( 0, numSets ),
                              [view] LVARRAY_HOST_DEVICE ( INDEX_TYPE const i )
        {
          ArraySlice< T, 1, 0, INDEX_TYPE > const setValues = view[i];
          sortedArrayManipulation::makeSorted( setValues.begin(), setValues.end() );
        } );
    }
    else if( desc == sortedArrayManipulation::SORTED_WITH_DUPLICATES )
    {
      RAJA::forall< POLICY >( RAJA::TypedRangeSegment< INDEX_TYPE >( 0, numSets ),
                              [view, sizes] LVARRAY_HOST_DEVICE ( INDEX_TYPE const i )
        {
          ArraySlice< T, 1, 0, INDEX_TYPE > const setValues = view[i];
          INDEX_TYPE const numUniqueValues = sortedArrayManipulation::removeDuplicates( setValues.begin(), setValues.end() );
          arrayManipulation::resize< T >( setValues, setValues.size(), numUniqueValues );
          sizes[ i ] = numUniqueValues;
        } );
    }
    else if( desc == sortedArrayManipulation::UNSORTED_WITH_DUPLICATES )
    {
      RAJA::forall< POLICY >( RAJA::TypedRangeSegment< INDEX_TYPE >( 0, numSets ),
                              [view, sizes] LVARRAY_HOST_DEVICE ( INDEX_TYPE const i )
        {
          ArraySlice< T, 1, 0, INDEX_TYPE > const setValues = view[ i ];
          INDEX_TYPE const numUniqueValues = sortedArrayManipulation::makeSortedUnique( setValues.begin(), setValues.end() );
          arrayManipulation::resize< T >( setValues, setValues.size(), numUniqueValues );
          sizes[ i ] = numUniqueValues;
        } );
    }

#ifdef ARRAY_BOUNDS_CHECK
    consistencyCheck();
#endif
  }

  using ParentClass::resizeFromCapacities;



  constexpr inline
  ArrayOfSetsView< T, INDEX_TYPE const, BUFFER_TYPE >
  toView() const &
  { return ParentClass::toView(); }

  constexpr inline
  ArrayOfSetsView< T, INDEX_TYPE const, BUFFER_TYPE >
  toView() const && = delete;

  constexpr inline
  ArrayOfSetsView< T const, INDEX_TYPE const, BUFFER_TYPE >
  toViewConst() const &
  { return ParentClass::toViewConst(); }

  constexpr inline
  ArrayOfSetsView< T const, INDEX_TYPE const, BUFFER_TYPE >
  toViewConst() const && = delete;

  constexpr inline
  ArrayOfArraysView< T const, INDEX_TYPE const, true, BUFFER_TYPE >
  toArrayOfArraysView() const &
  { return ParentClass::toArrayOfArraysView(); }

  constexpr inline
  ArrayOfArraysView< T const, INDEX_TYPE const, true, BUFFER_TYPE >
  toArrayOfArraysView() const && = delete;



  inline
  INDEX_TYPE size() const
  { return ParentClass::size(); }

  using ParentClass::sizeOfSet;
  using ParentClass::capacity;
  using ParentClass::capacityOfSet;
  using ParentClass::valueCapacity;
  using ParentClass::contains;
  using ParentClass::consistencyCheck;




  using ParentClass::operator[];
  using ParentClass::operator();



  using ParentClass::reserve;
  using ParentClass::reserveValues;

  void resize( INDEX_TYPE const newSize, INDEX_TYPE const defaultArrayCapacity=0 )
  { return ParentClass::resize( newSize, defaultArrayCapacity ); }

  using ParentClass::compress;



  inline
  void appendSet( INDEX_TYPE const setCapacity=0 )
  {
    INDEX_TYPE const maxOffset = this->m_offsets[ this->m_numArrays ];
    bufferManipulation::emplaceBack( this->m_offsets, this->m_numArrays + 1, maxOffset );
    bufferManipulation::emplaceBack( this->m_sizes, this->m_numArrays, 0 );
    ++this->m_numArrays;

    setCapacityOfSet( this->m_numArrays - 1, setCapacity );
  }

  inline
  void insertSet( INDEX_TYPE const i, INDEX_TYPE const setCapacity=0 )
  {
    ARRAYOFARRAYS_CHECK_INSERT_BOUNDS( i );
    LVARRAY_ASSERT( arrayManipulation::isPositive( setCapacity ) );

    // Insert an set of capacity zero at the given location
    INDEX_TYPE const offset = this->m_offsets[i];
    bufferManipulation::emplace( this->m_offsets, this->m_numArrays + 1, i + 1, offset );
    bufferManipulation::emplace( this->m_sizes, this->m_numArrays, i, 0 );
    ++this->m_numArrays;

    // Set the capacity of the new set
    setCapacityOfSet( i, setCapacity );
  }

  inline
  void eraseSet( INDEX_TYPE const i )
  {
    ARRAYOFARRAYS_CHECK_BOUNDS( i );

    setCapacityOfSet( i, 0 );
    bufferManipulation::erase( this->m_offsets, this->m_numArrays + 1, i + 1 );
    bufferManipulation::erase( this->m_sizes, this->m_numArrays, i );
    --this->m_numArrays;
  }



  inline
  bool insertIntoSet( INDEX_TYPE const i, T const & val )
  { return ParentClass::insertIntoSetImpl( i, val, CallBacks( *this, i ) ); }

  template< typename ITER >
  inline
  INDEX_TYPE insertIntoSet( INDEX_TYPE const i, ITER const first, ITER const last )
  { return ParentClass::insertIntoSetImpl( i, first, last, CallBacks( *this, i ) ); }

  LVARRAY_HOST_DEVICE inline
  bool removeFromSet( INDEX_TYPE const i, T const & value ) const
  { return ParentClass::removeFromSet( i, value ); }

  template< typename ITER >
  LVARRAY_HOST_DEVICE inline
  INDEX_TYPE removeFromSet( INDEX_TYPE const i, ITER const first, ITER const last ) const
  { return ParentClass::removeFromSet( i, first, last ); }

  void clearSet( INDEX_TYPE const i )
  {
    ARRAYOFARRAYS_CHECK_BOUNDS( i );

    INDEX_TYPE const prevSize = sizeOfSet( i );
    T * const values = getSetValues( i );
    arrayManipulation::resize( values, prevSize, INDEX_TYPE( 0 ) );
    this->m_sizes[ i ] = 0;
  }

  inline
  void setCapacityOfSet( INDEX_TYPE const i, INDEX_TYPE newCapacity )
  { ParentClass::setCapacityOfArray( i, newCapacity ); }

  inline
  void reserveCapacityOfSet( INDEX_TYPE const i, INDEX_TYPE newCapacity )
  {
    ARRAYOFARRAYS_CHECK_BOUNDS( i );
    if( newCapacity > capacityOfSet( i ) ) setCapacityOfSet( i, newCapacity );
  }



  void move( MemorySpace const space, bool const touch=true ) const
  { return ParentClass::move( space, touch ); }


  void setName( std::string const & name )
  { ParentClass::template setName< decltype( *this ) >( name ); }

private:

  using ParentClass::getSetValues;

  class CallBacks : public sortedArrayManipulation::CallBacks< T >
  {
public:

    inline
    CallBacks( ArrayOfSets & aos, INDEX_TYPE const i ):
      m_aos( aos ),
      m_i( i )
    {}

    inline
    T * incrementSize( T * const curPtr, INDEX_TYPE const nToAdd ) const
    {
      LVARRAY_UNUSED_VARIABLE( curPtr );
      INDEX_TYPE const newNNZ = m_aos.sizeOfSet( m_i ) + nToAdd;
      if( newNNZ > m_aos.capacityOfSet( m_i ) )
      {
        m_aos.setCapacityOfSet( m_i, 2 * newNNZ );
      }

      return m_aos.getSetValues( m_i );
    }

private:
    ArrayOfSets & m_aos;

    INDEX_TYPE const m_i;
  };
};

} /* namespace LvArray */