DistributedIndex.hpp

/*------------------------------------------------------------------------*/
/*                 Copyright 2010 Sandia Corporation.                     */
/*  Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive   */
/*  license for use of this work by or on behalf of the U.S. Government.  */
/*  Export of this program may require a license from the                 */
/*  United States Government.                                             */
/*------------------------------------------------------------------------*/

#ifndef stk_util_parallel_DistributedIndex_hpp
#define stk_util_parallel_DistributedIndex_hpp

#include <stdint.h>
#include <utility>
#include <vector>
#include <stk_util/parallel/Parallel.hpp>

class UnitTestSTKParallelDistributedIndex ;

namespace stk {
namespace parallel {

class DistributedIndex {
public:
  typedef uint64_t                    KeyType ;
  typedef int                         ProcType ;
  typedef std::pair<KeyType,KeyType>  KeySpan ;
  typedef std::pair<KeyType,ProcType> KeyProc ;

  /*----------------------------------------*/

  ~DistributedIndex();

  DistributedIndex( ParallelMachine comm ,
                    const std::vector<KeySpan> & partition_spans );

  /*----------------------------------------*/
  void query( std::vector<KeyProc> & sharing_of_local_keys ) const ;

  void query( const std::vector<KeyType> & keys , 
              std::vector<KeyProc> & sharing_of_keys ) const ;

  void query_to_usage( const std::vector<KeyType> & keys , 
                       std::vector<KeyProc> & sharing_of_keys ) const ;

  /*------------------------------------------------------------------*/
  void update_keys( const std::vector<KeyType> & add_new_keys ,
                    const std::vector<KeyType> & remove_existing_keys );

  void generate_new_keys(
    const std::vector<size_t>                 & requests ,
          std::vector< std::vector<KeyType> > & requested_keys );

private:

  /*------------------------------------------------------------------*/
  void generate_new_global_key_upper_bound(
    const std::vector<size_t>  & requests ,
          std::vector<DistributedIndex::KeyType> & global_key_upper_bound ) const;


  void generate_new_keys_local_planning(
    const std::vector<DistributedIndex::KeyType> & global_key_upper_bound ,
    const std::vector<size_t>  & requests_local ,
          std::vector<long>    & new_requests ,
          std::vector<KeyType> & requested_keys ,
          std::vector<KeyType> & contrib_keys ) const ;

  void generate_new_keys_global_planning(
    const std::vector<long>    & new_request ,
          std::vector<long>    & my_donations ) const ;

  void query( const std::vector<KeyProc> & request ,
                    std::vector<KeyProc> & sharing_of_keys ) const ;

  /*------------------------------------------------------------------*/
  ProcType to_which_proc( const KeyType & key ) const ;

  /*------------------------------------------------------------------*/
  /*  Disable default construction and copies. */

  DistributedIndex();
  DistributedIndex( const DistributedIndex & );
  DistributedIndex & operator = ( const DistributedIndex & );

  /*------------------------------------------------------------------*/

  ParallelMachine      m_comm ;      
  ProcType             m_comm_rank ; 
  ProcType             m_comm_size ; 
  size_t               m_span_count ;
  std::vector<KeySpan> m_key_span ;  
  std::vector<KeyProc> m_key_usage ; 

  /*  Unit testing of internal methods requires the unit test to have
   *  access to those internal methods.
   */
  friend class ::UnitTestSTKParallelDistributedIndex ;
};

//----------------------------------------------------------------------

} // namespace parallel
} // namespace stk

//----------------------------------------------------------------------

#endif