---

model/jobs/SJob.h

Go to the documentation of this file.

/* #start# ***********************************************************

           Scheduling Simulator
        Lehrstuhl f"ur Effiziente Algorithmen
           Technische Universit"at M"unchen

 File    : $Id: SJob.h,v 1.8 2003/03/21 15:47:05 taeubig Exp $

 Purpose : the base class for jobs, handles the processing state
           (what is being done with it, how long does it still need
           to be processed etc.)

 * #end# ************************************************************* */

#ifndef SJOB_H
#define SJOB_H

// system header files
#include <iostream>

#include <LEDA/array.h>
#include <LEDA/list.h>

// project header files
#include "../SVisJob.h"
#include "../STSysSchedEvent.h"
#include "../topos/STopology.h"
#include "../../general/SObservable.h"
#include "../../general/STypeInfo.h"
#include "../../general/SPref.h"
#include "../../probability/SProbabilityDist.h"

// -----------------------------------------------------------------------
class SJobMod;
class SMachines;
// -----------------------------------------------------------------------

using std::cout;
using std::endl;

class SJob : public STypeInfo, public SObservable {
  friend class SJobMod;
  NOCOPY(SJob);
public:
  
  //SJob();

  // create Job with dist-distributed random proc time
  SJob(SProbabilityDist* dist);

  // create Job with proc time = proctime
  SJob(double proctime = 1.0);
  
  virtual ~SJob();

  enum State {
    // not yet released -> cannot be scheduled
    HIDDEN,
    // can be scheduled, but is not running at the moment
    RELEASED,
    // job runs on a machine
    RUNNING,
    // job is completely finished (all phases are over for jobs with
    // multiple phases)
    FINISHED,
    // job has been rejected at a certain penalty
    REJECTED
  };
  
  virtual void reset();

  // access functions

  int getIndex() const { return _index; };
  
  virtual double getProcTime();

 
  virtual double getRemProcTime() const { return _remProcTime; };
  
  bool isFinished() const {
    return getRemProcTime() <= _pref.getProcTimeEps();
  };

  double getReleaseTime() const { return _releaseTime; };
  
  double getDueTime() const { return _dueTime; };

  /*
  double getFirstStartTime() const {
    return _firstStartTime;
  };
  */

  double getStartTime(int operation = 0) const {
    return _startTime[operation];
  };

  const leda_array<double>& getStartTimes() const {
    return _startTime;
  };

  const STopology& getTopology() const { return *_pTop; };
  
  /* Get weight (priority) of job. 
   */
  const double getWeight() const { return _weight; };

  // get and set the state of the job

  State getState() const { return _state; };
  virtual void setState(State s);
  
  bool getOverDue() const { return _due; };

  virtual void setOverDue();
  
  virtual SJobMod& getModifier() =0;

  // simulation control

  virtual double getNextEventTime(double currTime) const;
  void simulate(double oldTime, double newTime);
  virtual void process(SMachines& machines, double duration) =0;
  
  double getExpProcTime(){
    if (_randProcTime) {
      if (_expProcTime != _procTimeDist->getExpectation())
        // _expProcTime = _procTimeDist->getExpectation();
        cout << "Error: expected proctime != expectation of proctime dist" << endl;
    }

    return _expProcTime;
    };
  SProbabilityDist* getProcTimeDist();
 
  bool hasRandProcTime();
 

  

protected:
  void advanceProcTime(double by);

  const SPref& getPref() const { return _pref; };

private:
  //  void copy(const SJob& j);

  STopology* _pTop;
  SVisJob* _pVisJob;
  int _index;
  double _procTime;
  double _remProcTime;
  double _dueTime;
  double _releaseTime;
  leda_array<double> _startTime;
  State _state;
  SProbabilityDist* _procTimeDist;
  bool _procTimeSet;
  bool _relTimeSet;
  bool _due;
  double _weight;
  bool _randProcTime;
  double _expProcTime;
public: // Public attributes
 
  SPref &_pref;
};
// -----------------------------------------------------------------------
std::ostream& operator<<(std::ostream& out, SJob &job);  
// -----------------------------------------------------------------------
// DEFINE_PTR_COMPARE(SJob);
inline int compare(SJob* p1, SJob* p2)
{
  if (p1->getIndex() < p2->getIndex())
    return -1; 
  else if (p1->getIndex() > p2->getIndex())
    return 1;
  else {
    // make sure the the object is actually the same: compare the pointers
    if (p1 == p2)
      return 0;
    else if (p1 < p2)
      return -1;
    else
      return 1;
  }
}
// -----------------------------------------------------------------------


#endif //SJOB_H

---