/home/coin/SVN-release/CoinAll-1.1.0/Bcp/src/include/BCP_message.hpp

Go to the documentation of this file.

// Copyright (C) 2000, International Business Machines
// Corporation and others.  All Rights Reserved.
#ifndef _BCP_MESSAGE_H
#define _BCP_MESSAGE_H

// This file is fully docified.

#include <utility>

#include "BCP_string.hpp"
#include "BCP_message_tag.hpp"
#include "BCP_vector.hpp"


//#############################################################################

class BCP_buffer;
class USER_initialize;

//#############################################################################

class BCP_proc_id {
public:
   virtual ~BCP_proc_id() {}
   virtual bool is_same_process(const BCP_proc_id* other_process) const = 0;
   virtual BCP_proc_id* clone() const = 0;
};

// no need to document 
const BCP_proc_id* const BCP_AnyProcess = 0;

//#############################################################################

class BCP_proc_array {
private:
   BCP_proc_array(const BCP_proc_array&);
   BCP_proc_array& operator=(const BCP_proc_array&);
private:
   BCP_vec<BCP_proc_id*> _procs;
   BCP_vec<BCP_proc_id*> _free_procs;
public:
   BCP_proc_array() : _procs(), _free_procs() {}
    ~BCP_proc_array() {
        purge_ptr_vector(_procs);
    }
   inline bool is_free_proc(const int index) {
      const BCP_proc_id* proc = _procs[index];
      int i;
      for (i = _free_procs.size() - 1; i >= 0; --i)
         if (_free_procs[i]->is_same_process(proc))
            break;
      return (i >= 0);
   }
   inline int index_of_proc(const BCP_proc_id* proc) {
      int i;
      for (i = _procs.size() - 1; i >= 0; --i)
         if (_procs[i]->is_same_process(proc))
            break;
      return i;
   }
   inline BCP_vec<BCP_proc_id*>& procs() { return _procs; }
   inline const BCP_vec<BCP_proc_id*>& procs() const { return _procs; }
   inline const BCP_proc_id* process(const int i) { return _procs[i]; }
   inline int size() const { return _procs.size(); }
   inline int free_num() const { return _free_procs.size(); }
   inline int busy_num() const { return _procs.size() - _free_procs.size(); }
   BCP_proc_id* get_free_proc() {
      if (_free_procs.size() > 0) {
         BCP_proc_id* proc = _free_procs.back();
         _free_procs.pop_back();
         return proc;
      }
      return 0;
   }
   inline void clear() {
      purge_ptr_vector(_procs);
      _free_procs.clear();
   }
   inline void add_procs(BCP_vec<BCP_proc_id*>::const_iterator first,
                         BCP_vec<BCP_proc_id*>::const_iterator last) {
      // the new procs are free to begin with
      _free_procs.insert(_free_procs.end(), first, last);
      while (first != last) {
          _procs.insert(_procs.end(), (*first)->clone());
          ++first;
      }
   }
   inline void delete_proc(const int index) { 
      const BCP_proc_id* proc = _procs[index]; 
      int i; 
      for (i = _free_procs.size() - 1; i >= 0; --i)
         if (_free_procs[i]->is_same_process(proc))
            break;
      if (i >= 0)
         _free_procs.erase(_free_procs.entry(i));
      delete _procs[index];
      _procs.erase(_procs.entry(index));
   }

   // *FIXME* check if the process is in _procs! 
   void set_proc_free(BCP_proc_id* proc) {
      _free_procs.push_back(proc);
   }
};

//#############################################################################

class BCP_message_environment{
public:
   virtual ~BCP_message_environment() {}
   virtual BCP_proc_id* register_process(USER_initialize* user_init) = 0;
   virtual BCP_proc_id* parent_process() = 0;
   virtual bool alive(const BCP_proc_id* pid) = 0;
   virtual BCP_vec<BCP_proc_id*>::iterator
   alive(const BCP_proc_array& parray) = 0;
   virtual void send(const BCP_proc_id* const target,
                     const BCP_message_tag tag) = 0;
   virtual void send(const BCP_proc_id* const target,
                     const BCP_message_tag tag,
                     const BCP_buffer& buf) = 0;
   virtual void multicast(const BCP_proc_array* const target,
                          const BCP_message_tag tag) = 0;
   virtual void multicast(const BCP_proc_array* const target,
                          const BCP_message_tag tag,
                          const BCP_buffer& buf) = 0;
   virtual void multicast(BCP_vec<BCP_proc_id*>::const_iterator beg,
                          BCP_vec<BCP_proc_id*>::const_iterator end,
                          const BCP_message_tag tag) = 0;
   virtual void multicast(BCP_vec<BCP_proc_id*>::const_iterator beg,
                          BCP_vec<BCP_proc_id*>::const_iterator end,
                          const BCP_message_tag tag,
                          const BCP_buffer& buf) = 0;
   // blocking receive w/ timeout (ms??) from given source given msgtag (can give wildcard anymsg, anyproc)
   virtual void receive(const BCP_proc_id* const source,
                        const BCP_message_tag tag, BCP_buffer& buf,
                        const double timeout) = 0;
   virtual bool probe(const BCP_proc_id* const source, 
                      const BCP_message_tag tag) = 0; 
   virtual BCP_proc_id* start_process(const BCP_string& exe,
                                      const bool debug) = 0;
   virtual BCP_proc_id* start_process(const BCP_string& exe,
                                      const BCP_string& machine,
                                      const bool debug) = 0;
   virtual BCP_proc_array* start_processes(const BCP_string& exe,
                                           const int proc_num,
                                           const bool debug) = 0;
   virtual BCP_proc_array* start_processes(const BCP_string& exe,
                                           const int proc_num,
                                           const BCP_vec<BCP_string>& machines,
                                           const bool debug) = 0;
   //    virtual void stop_process(BCP_proc_id& process) = 0;
   //    virtual void stop_processes(BCP_proc_array& processes) = 0;

   virtual BCP_proc_id* unpack_proc_id(BCP_buffer& buf) = 0;
   virtual void pack_proc_id(BCP_buffer& buf, const BCP_proc_id* pid) = 0;
   virtual int num_procs() { return 0; }
};

#endif

---