ROL_VectorWorkspace.hpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//               Rapid Optimization Library (ROL) Package
//
// Copyright 2014 NTESS and the ROL contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER

#pragma once
#ifndef ROL_VECTORWORKSPACE_HPP
#define ROL_VECTORWORKSPACE_HPP

#include "ROL_Vector.hpp"
#include <iostream>
#include <map>
#include <utility>

namespace ROL {

namespace details {

template<typename Real>
class VectorWorkspace {

  using V = ROL::Vector<Real>;
  using size_type = typename std::vector<Real>::size_type;

private:

  struct VectorKey {
    friend class VectorWorkspace<Real>;
    size_t hash_code;
    int    dimension;

    VectorKey( const V& x ) :
      hash_code(typeid(x).hash_code()), 
      dimension( x.dimension() ) {}

    VectorKey( const Ptr<V>& x ) : 
      VectorKey( *x ) {}

    static std::string to_string( const VectorKey& key ) {
      std::stringstream ss;
      ss << "VectorKey(" << std::hex << key.hash_code << ","
                         << std::dec << key.dimension << ")";
      return ss.str();
    }

    bool operator < ( const VectorKey& x ) const {
      return ( hash_code < x.hash_code ) && ( dimension < x.dimension );
    }

    bool operator == ( const VectorKey& x ) const {
      return ( hash_code == x.hash_code ) && ( dimension == x.dimension );
    }

//    bool operator != ( const VectorKey& x ) const {
//      return ( hash_code != x.hash_code ) || ( dimension != x.dimension );
//    }

  }; // class VectorKey

  struct VectorStack {
  
    friend class VectorWorkspace<Real>;
    std::vector<Ptr<V>> vectors_;
    VectorKey key_;

    VectorStack( const V& x ) : vectors_( 1, x.clone() ),
      key_(VectorKey(x)) {}

    const VectorKey& getKey() const { return key_; }

    size_type size() const { return vectors_.size(); }

    size_type number_assigned() const {
      size_type count = 0;
      for( auto v : vectors_ ) count += ( getCount(v) > 3 );
      return count;
    }

    Ptr<V> clone( const V& x ) {
      VectorKey x_key(x);
      
      ROL_TEST_FOR_EXCEPTION( key_.hash_code != x_key.hash_code, std::logic_error,
        "VectorWorkspace::VectorStack tried to clone a std::vector of type "     <<
        std::hex << key_.hash_code << ", but it can only clone std::vectors of type " <<
        std::hex << x_key.hash_code );

      ROL_TEST_FOR_EXCEPTION( key_.dimension != x_key.dimension, std::logic_error, 
        "VectorWorkspace::VectorStack tried to clone a std::vector of dimension "     <<
        std::hex << key_.dimension << ", but it can only clone std::vectors of dimension " <<
        std::hex << x_key.dimension );

      for( auto e : vectors_ ) { // Return first unreferenced std::vector
        if( getCount(e) <= 2 ) { // Storing pointers in std::vector increments count  
          return e;
        }
      }   
      // If no unreferenced std::vectors exist, add a new one
      auto v = x.clone();
      vectors_.push_back( v );
      return v;
    }

    // For testing purposes
    std::vector<size_type> getRefCounts( void ) const {
      std::vector<size_type> counts;
      for( auto e: vectors_ ) counts.push_back( getCount(e) );
      return counts;
    }

  }; // VectorStack

  std::map<VectorKey,Ptr<VectorStack>> workspace_;
    
public:

  Ptr<V> clone( const V& x ) {  
   
    VectorKey        key(x);
    size_type        key_count{0};
    Ptr<VectorStack> vstack{nullPtr};

    for( auto e : workspace_ ) key_count += (key == e.first);

    if( key_count == 0 ) { // New key
      vstack = makePtr<VectorStack>(x);
      workspace_.insert( std::make_pair(key,vstack) );
    }
    else vstack = workspace_[key];

    return vstack->clone(x);
  }
 
  Ptr<V> clone( const Ptr<const V>& x ) { return clone(*x); }

  // Deep copy
  Ptr<V> copy( const V& x ) { 
    auto xc = clone(x);
    xc->set(x);
    return xc;
  }

  Ptr<V> copy( const Ptr<const V>& x ) { return copy(*x); }
  
  void status( std::ostream& os ) const {
    os << "\n\n" << std::string(80,'-') << std::endl;
    os << "VectorWorkspace contains the following VectorStack(hash_code,dim) entries:\n\n";
    for( auto entry : workspace_ ) {
      os << "  VectorStack("   << std::hex << entry.first.hash_code << ","
                               << std::dec << entry.first.dimension << ")";
      os << "\n  Reference Counts per element" << std::endl;
      for( auto e : entry.second->vectors_ ) {
        os << "        " << getCount( e ) << std::endl;
      }
    }
    os << std::string(80,'-') << std::endl;
  }


}; // VectorWorkspace

} // namespace details 

using details::VectorWorkspace;

} // namespace ROL


#endif