VectorBase.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_INTERFACES_VECTORBASE_HPP_
#define GEOS_LINEARALGEBRA_INTERFACES_VECTORBASE_HPP_
 
#include "linearAlgebra/common/common.hpp"
#include "common/MpiWrapper.hpp"
#include "common/GEOS_RAJA_Interface.hpp"
 
namespace geos
{
 
template< typename VECTOR >
class VectorBase
{
protected:
 
  using Vector = VECTOR;
 
 
  inline bool closed() const { return m_closed; }
 
  virtual bool created() const = 0;
 
  inline bool ready() const { return created() && closed(); }
 
 
 
  virtual void create( localIndex const localSize, MPI_Comm const & comm )
  {
    GEOS_UNUSED_VAR( comm );
    GEOS_LAI_ASSERT( closed() );
    GEOS_LAI_ASSERT_GE( localSize, 0 );
    reset();
 
    // Ideally, resizing to the same size should be a no-op.
    // But bufferManipulation::resize() always forces a touch in host memory.
    // We want to avoid moving values to device again in that case.
    if( m_values.size() != localSize )
    {
      m_values.resize( localSize );
    }
  }
 
  void setName( string const & name )
  {
    m_values.setName( name );
  }
 
 
 
  virtual arrayView1d< real64 > open()
  {
    GEOS_LAI_ASSERT( ready() );
    m_closed = false;
    return m_values.toView();
  }
 
  virtual void close() = 0;
 
  virtual void touch() = 0;
 
  virtual void reset()
  {
    // Clearing the array causes issues on GPU when it is later resized again
    // (the bug is in bufferManipulation::resize(), which calls buf.data() without
    // moving the buffer to host, if a capacity increase does not occur, i.e. the new
    // array size is exactly the same as the one prior to clearing).
 
    //m_values.clear();
    m_closed = true;
  };
 
 
 
  virtual void set( real64 const value ) = 0;
 
  virtual void zero()
  {
    set( 0.0 );
  }
 
  virtual void rand( unsigned const seed ) = 0;
 
 
 
  virtual void scale( real64 const factor ) = 0;
 
  virtual void reciprocal() = 0;
 
  virtual real64 dot( Vector const & vec ) const = 0;
 
  virtual void copy( Vector const & x ) = 0;
 
  virtual void axpy( real64 const alpha,
                     Vector const & x ) = 0;
 
  virtual void axpby( real64 const alpha,
                      Vector const & x,
                      real64 const beta ) = 0;
 
  virtual void pointwiseProduct( Vector const & x,
                                 Vector & y ) const = 0;
 
  virtual real64 norm1() const = 0;
 
  virtual real64 norm2() const = 0;
 
  virtual real64 normInf() const = 0;
 
 
 
  virtual globalIndex globalSize() const = 0;
 
  virtual localIndex localSize() const = 0;
 
  virtual globalIndex ilower() const = 0;
 
  virtual globalIndex iupper() const = 0;
 
  arrayView1d< real64 const > values() const
  {
    GEOS_LAI_ASSERT( ready() );
    return m_values.toViewConst();
  }
 
  virtual MPI_Comm comm() const = 0;
 
 
 
  virtual void print( std::ostream & os = std::cout ) const = 0;
 
  virtual void write( string const & filename,
                      LAIOutputFormat const format = LAIOutputFormat::MATRIX_MARKET ) const = 0;
 
 
  friend std::ostream & operator<<( std::ostream & os, Vector const & vec )
  {
    vec.print( os );
    return os;
  }
 
  bool m_closed = true;
 
  array1d< real64 > m_values;
};
 
} // namespace geos
 
#endif //GEOS_LINEARALGEBRA_INTERFACES_VECTORBASE_HPP_