BCP_process.hpp

Go to the documentation of this file.

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

#if 1
   #define TMDBG  
   #define LPDBG 
#else
   #define TMDBG   printf("TMDBG: %s:%i\n", __FILE__, __LINE__)
   #define LPDBG   printf("LPDBG: %s:%i\n", __FILE__, __LINE__)
#endif

class BCP_buffer;

class BCP_process {
private:
    const int me;
    const int parent;
public:
    BCP_process(int self, int my_parent) : me(self), parent(my_parent) {}
    // default copy constructor & assignment operator are OK.
    virtual ~BCP_process() {}
    int get_process_id() const { return me; }
    int get_parent() const { return parent; }

    virtual BCP_buffer& get_message_buffer() = 0;
    virtual void process_message() = 0;
};

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

// (C) 2007 Copyright International Business Machines Corporation
// All Rights Reserved.
// This code is published under the Common Public License.
//
// Authors :
// Pierre Bonami, International Business Machines Corporation
// Andreas Waechter, International Business Machines Corporation
// Laszlo Ladanyi, International Business Machines Corporation
//
// Date : 10/03/2007

#include <map>
#include <vector>
#include <cmath>
#include "CoinHelperFunctions.hpp"

class BCP_scheduler {
public:
  BCP_scheduler();

  void setParams(double OverEstimationStatic,
                 double SwitchToRateThreshold,
                 double TimeRootNodeSolve,
                 double FactorTimeHorizon,
                 double OverEstimationRate,
                 double MaxNodeIdRatio,
                 int    MaxNodeIdNum,
                 int    MaxSbIdNum,
                 int    MinSbIdNum);

  void add_free_ids(int numIds, const int* ids);
  int request_sb_ids(int numIds, int* ids);
  void release_sb_id(int id);

  int request_node_id();
  void release_node_id(int id);
  inline bool has_free_node_id() const {
    return (!freeIds_.empty() && maxNodeIds_ > numNodeIds_);
  }
  inline int numNodeIds() const {
    return numNodeIds_;
  }
  inline int maxNodeIds() const {
    return maxNodeIds_;
  }
  inline double node_idle(int p) {
    return node_idle_time_[p];
  }
  inline double sb_idle(int p) {
    return sb_idle_time_[p];
  }
  void update_idle_times();

private:
  int max_id_allocation(int numIds);
  void update_rates(int add_req, int add_rel);

private:
  std::map<int, double> sb_idle_time_;
  std::map<int, double> node_idle_time_;
  std::map<int, double> last_release_type_;
  std::map<int, double> last_release_time_;
  int totalNumberIds_;
  std::vector<int> freeIds_;
  int numNodeIds_;
  int maxNodeIds_;

  double maxNodeIdRatio_;
  int    maxNodeIdNum_;
  int    maxSbIds_;
  int    minSbIds_;

  double rho_static_;
  double switch_thresh_;
  int numSecRateInterval_;
  std::vector<int> request_counts_;
  int request_counts_tot_;
  std::vector<int> release_counts_;
  int release_counts_tot_;
  int counts_ptr_;
  time_t time_last_action_;
  double rho_rate_;
  bool static_;
  bool have_rates_;
};

#endif