revolve.h

Go to the documentation of this file.

/*----------------------------------------------------------------------------
 REVOLVE -- Checkpointing approaches
 File:     revolve.h
  
 Copyright (c) Andreas Griewank, Andrea Walther, Philipp Stumm
  
 This software is provided under the terms of
 the Common Public License. Any use, reproduction, or distribution of the
 software constitutes recipient's acceptance of the terms of this license.
 See the accompanying copy of the Common Public License for more details.
----------------------------------------------------------------------------*/

#ifndef _REVOLVE_H
#define _REVOLVE_H

#include <vector>

using namespace std;

#define checkup 10000
#define repsup 6400
#define MAXINT 2147483647

namespace ACTION
{
    enum action { advance, takeshot, restore, firsturn, youturn, terminate, error} ;
}



class Checkpoint
{
    public:

    Checkpoint(int s) { snaps=s; ch.reserve(snaps); number_of_writes.reserve(snaps); number_of_reads.reserve(snaps); }
    
    vector <int> ch;
    vector <int> ord_ch;
    vector <int> number_of_writes;
    vector <int> number_of_reads;
    void print_ch(ostream &file) { file << endl; for(int i=0;i<snaps;i++) file << ch[i] << " "; }
    void print_ord_ch(ostream &file) { file << endl; for(int i=0;i<snaps;i++) file << ord_ch[i] << " "; }
    void init_ord_ch() { ord_ch.reserve(snaps); }
    
    int advances, takeshots, commands;  
    ~Checkpoint() { ch.clear(); ord_ch.clear(); number_of_writes.clear(); number_of_reads.clear();};

    private:

    int snaps;
    
};



class Schedule
{
    public:

    Schedule(int sn,Checkpoint *c);
    Schedule(int sn) { snaps=sn; }
    
    virtual ACTION::action revolve(ostream & str) = 0;  
    int numforw(int steps, int snaps, ostream & str);
    virtual int get_capo()=0;   
    virtual int get_fine()=0;   
    virtual int get_check()=0;  
    virtual void set_fine(int f)=0;  
    virtual void set_capo(int c)=0; 
    int get_snaps() { return snaps; }
    Checkpoint *get_CP() { return checkpoint; }
//  vector <int> get_ch()   { return ch; }
    int get_advances() { return checkpoint->advances; }
    int get_shots() { return checkpoint->takeshots; }
    int get_commands() { return checkpoint->commands; }
    virtual int get_info(){ return info;}   
    
    
    ~Schedule() { /*delete[] ch;*/ }

    protected:
    Checkpoint *checkpoint;   
    int snaps;   
    int info;
};


class Online : public Schedule
{
    public:

    Online(int sn,Checkpoint *c,bool o);
    Online(Online &o);

    ACTION::action revolve(ostream & str) { return ACTION::error;}
    // already inherited from schedule
    //virtual ACTION::action revolve(ostream & str)=0;
    int get_check() { return check; }
    int get_capo()  { return capo; }
    // already virtual in parent class
    //  virtual int get_fine()=0;
    int get_fine() { return -1; }
    void set_fine(int) {}
    bool get_output()      { return output; }
    void set_capo(int c) { capo=c; }

    ~Online();

    protected:

    int check;
    bool output;
    int capo;

};



class Online_r2 : public Online
{
    public:

    Online_r2(int sn,Checkpoint *c,bool o);
    Online_r2(Online &o);

    ACTION::action revolve(ostream & str);
    int get_check() { return check; }
    int get_capo()  { return capo; }
    int get_fine()  { return -1; }
    bool get_output()      { return output; }
    void set_fine(int) {}

    ~Online_r2();

    private:

    int oldcapo_o,offset,incr,iter,t,oldind,old_f,ind;
    vector <int> num_rep;

};


class Online_r3 : public Online 
{
    public:

    Online_r3(int sn,Checkpoint *c);
    Online_r3(Online_r3 &o) ;

    ACTION::action revolve(ostream & str);

    int get_capo()  { return capo; }
    int get_fine()  { return -1; }

    void set_fine(int) {}

    int choose_cp(int number);
    void tdiff_akt();
    void akt_cp();
    
    
    int get_tdiff_end(int i) { return tdiff_end[i]; }

    ~Online_r3();

    protected:

    
    int forward;
    int ind_now;
    int cp;
    vector <int> ch3;
    vector <int> tdiff;
    vector <int> tdiff_end;
    vector <bool> cp_fest;
};




class Arevolve : public Online
{
    public:

  Arevolve(int sn,Checkpoint *c, ostream & str);
    Arevolve(Arevolve &o);

    int tmin(int steps, int snaps, ostream & str);
    int sumtmin();
    int mintmin();
    int get_fine() { return fine; }
    void akt_cp(int cp);
    
    void set_fine(int f) { fine=f; }

    enum ACTION::action revolve(ostream & str);

    ~Arevolve() { }
    
    private:

    int checkmax;
    int fine,oldfine,newcapo,oldcapo;
    ostream & str;

};

class Moin : public Online
{
    public:

    Moin(int sn,Checkpoint *c);
    Moin(Moin &o);
    
    bool is_dispensable(int *index);
    int get_lmin();
    void adjust_cp(int index);
    enum ACTION::action revolve(ostream & str);
    int get_fine()  { return -1; }
    void set_fine(int) {}

    ~Moin() { }
    
    private:

    vector<int> l;
    vector<bool> d;
    bool start,start1,is_d;
    int forward,lmin,index_old;
    
};



class Offline : public Schedule
{
    public:

  Offline(int st,int sn,Checkpoint *c, ostream & str);  
  Offline(int sn,Checkpoint *c,Online *o,int f, ostream & str); 
  Offline(Schedule *o, ostream & str) ;    
    Offline(Offline &o);     

    ACTION::action revolve(ostream & str);
    
    int get_check() { return check; }
    int get_capo() { return capo; }
    int get_fine() { return fine; }
    int get_snaps() { return snaps; }
    int get_commands() { return checkpoint->commands; }
    int get_steps()    { return steps; }
    bool get_online()  { return online; }
    vector <int> get_num_ch() { return num_ch; }
    int get_num_ch(int i) { return num_ch[i]; }

    void set_fine(int f) { fine=f;}
    void set_capo(int c) { capo=c; }
    
    
    ~Offline() { };

    private:

    int check, steps, oldsnaps, oldfine, capo, fine, turn,ind   ;
    vector <int> num_ch;
    bool online;
    ostream & str;
};


class Revolve
{
    public:
  Revolve(int st,int sn,ostream & _str);
  Revolve(int st,int sn,int sn_ram, ostream & _str);
  Revolve(int sn, ostream & _str);

    ACTION::action revolve(int* check,int* capo,int* fine,int snaps,int* info,bool *where_to_put);
    ACTION::action revolve(int* check,int* capo,int* fine,int snaps,int* info);
    ACTION::action revolve();

    int adjust(int steps, ostream & str);
    int maxrange(int ss, int tt, ostream & str);
    double expense(int steps, int snaps, ostream & str);
    int numforw(int steps, int snaps, ostream & str) { return f->numforw(steps,snaps,str); }
    void turn(int fine);
    
        
    vector <int> get_write_and_read_counts();
    int get_number_of_writes_i(int l, int c,int i);
    int get_number_of_reads_i(int l, int c,int i);
    
    
    int getadvances() { return f->get_advances(); }  
    int getcheck() { return check; }
    int getcheckram() { return indizes_ram[check]; }
    int getcheckrom() { return indizes_rom[check]; }
    int getcapo()  { return capo; }
    int getfine()  { return fine; }
    int getinfo()  { return info; }
    int getoldcapo() { return oldcapo; }
    bool getwhere() { return where_to_put; }
    void set_info(int inf) { info=inf; }
    void number_of_writes() { str << endl; for(int i=0;i<snaps;i++) str << checkpoint->number_of_writes[i] << " "; }
    void number_of_reads() { str << endl; for(int i=0;i<snaps;i++) str << checkpoint->number_of_reads[i] << " "; }
    
    int get_r(int steps,int snaps, ostream & str);
    int get_r(ostream & str);
    
    ~Revolve() { delete checkpoint; }

    private:

    int check,capo,fine,snaps,info,steps,r,oldcapo;
    Schedule *f;
    bool online, multi, where_to_put;
    Checkpoint *checkpoint;
    vector <bool> where;
    vector <int> indizes_ram,indizes_rom;
    // WWS 11.13
    ostream & str;
};


#endif

---