driver.hh

Go to the documentation of this file.

/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
/*
 *  Main authors:
 *     Christian Schulte <schulte@gecode.dev>
 *
 *  Copyright:
 *     Christian Schulte, 2009
 *
 *  This file is part of Gecode, the generic constraint
 *  development environment:
 *     http://www.gecode.dev
 *
 *  Permission is hereby granted, free of charge, to any person obtaining
 *  a copy of this software and associated documentation files (the
 *  "Software"), to deal in the Software without restriction, including
 *  without limitation the rights to use, copy, modify, merge, publish,
 *  distribute, sublicense, and/or sell copies of the Software, and to
 *  permit persons to whom the Software is furnished to do so, subject to
 *  the following conditions:
 *
 *  The above copyright notice and this permission notice shall be
 *  included in all copies or substantial portions of the Software.
 *
 *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 */
 
#ifndef GECODE_DRIVER_HH
#define GECODE_DRIVER_HH
 
#include <gecode/minimodel.hh>
#include <gecode/search.hh>
#ifdef GECODE_HAS_GIST
#include <gecode/gist.hh>
#endif
 
/*
 * Configure linking
 *
 */
#if !defined(GECODE_STATIC_LIBS) && \
    (defined(__CYGWIN__) || defined(__MINGW32__) || defined(_MSC_VER))
 
#ifdef GECODE_BUILD_DRIVER
#define GECODE_DRIVER_EXPORT __declspec( dllexport )
#else
#define GECODE_DRIVER_EXPORT __declspec( dllimport )
#endif
 
#else
 
#ifdef GECODE_GCC_HAS_CLASS_VISIBILITY
#define GECODE_DRIVER_EXPORT __attribute__ ((visibility("default")))
#else
#define GECODE_DRIVER_EXPORT
#endif
 
#endif
 
// Configure auto-linking
#ifndef GECODE_BUILD_DRIVER
#define GECODE_LIBRARY_NAME "Driver"
#include <gecode/support/auto-link.hpp>
#endif

 
namespace Gecode {
 


  enum ScriptMode {
    SM_SOLUTION,  
    SM_TIME,      
    SM_STAT,      
    SM_GIST,      
  };

  enum RestartMode {
    RM_NONE,     
    RM_CONSTANT, 
    RM_LINEAR,   
    RM_LUBY,     
    RM_GEOMETRIC 
  };
 
  class BaseOptions;
 
  namespace Driver {
    class GECODE_DRIVER_EXPORT BaseOption {
      friend class Gecode::BaseOptions;
    protected:
      const char* eopt;  
      const char* iopt;  
      const char* exp;   
      BaseOption* next;  
      char* argument(int argc, char* argv[]) const;
    public:
      BaseOption(const char* o, const char* e);
      virtual int parse(int argc, char* argv[]) = 0;
      virtual void help(void) = 0;
      virtual ~BaseOption(void);
      static char* strdup(const char* s);
      static char* stredup(const char* s);
      static void strdel(const char* s);
    };

    class GECODE_DRIVER_EXPORT StringValueOption : public BaseOption {
    protected:
      const char* cur; 
    public:
      StringValueOption(const char* o, const char* e, const char* v=nullptr);
      void value(const char* v);
      const char* value(void) const;
      virtual int parse(int argc, char* argv[]);
      virtual void help(void);
      virtual ~StringValueOption(void);
    };
 

    class GECODE_DRIVER_EXPORT StringOption : public BaseOption {
    protected:
      class Value {
      public:
        int         val;  
        const char* opt;  
        const char* help; 
        Value*      next; 
      };
      int    cur; 
      Value* fst; 
      Value* lst; 
    public:
      StringOption(const char* o, const char* e, int v=0);
      void value(int v);
      int value(void) const;
      void add(int v, const char* o, const char* h = nullptr);
      virtual int parse(int argc, char* argv[]);
      virtual void help(void);
      virtual ~StringOption(void);
    };
 

    class GECODE_DRIVER_EXPORT IntOption : public BaseOption {
    protected:
      int cur; 
    public:
      IntOption(const char* o, const char* e, int v=0);
      void value(int v);
      int value(void) const;
      virtual int parse(int argc, char* argv[]);
      virtual void help(void);
    };

    class GECODE_DRIVER_EXPORT UnsignedIntOption : public BaseOption {
    protected:
      unsigned int cur; 
    public:
      UnsignedIntOption(const char* o, const char* e, unsigned int v=0);
      void value(unsigned int v);
      unsigned int value(void) const;
      virtual int parse(int argc, char* argv[]);
      virtual void help(void);
    };

    class GECODE_DRIVER_EXPORT UnsignedLongLongIntOption : public BaseOption {
    protected:
      unsigned long long int cur; 
    public:
      UnsignedLongLongIntOption(const char* o, const char* e,
                                unsigned long long int v=0);
      void value(unsigned long long int v);
      unsigned long long int value(void) const;
      virtual int parse(int argc, char* argv[]);
      virtual void help(void);
    };

    class GECODE_DRIVER_EXPORT DoubleOption : public BaseOption {
    protected:
      double cur; 
    public:
      DoubleOption(const char* o, const char* e, double v=0);
      void value(double v);
      double value(void) const;
      virtual int parse(int argc, char* argv[]);
      virtual void help(void);
    };

    class GECODE_DRIVER_EXPORT BoolOption : public BaseOption {
    protected:
      bool cur; 
    public:
      BoolOption(const char* o, const char* e, bool v=false);
      void value(bool v);
      bool value(void) const;
      virtual int parse(int argc, char* argv[]);
      virtual void help(void);
    };

    class GECODE_DRIVER_EXPORT IplOption : public BaseOption {
    protected:
      IntPropLevel cur; 
    public:
      IplOption(IntPropLevel ipl=IPL_DEF);
      void value(IntPropLevel l);
      IntPropLevel value(void) const;
      virtual int parse(int argc, char* argv[]);
      virtual void help(void);
    };

    class GECODE_DRIVER_EXPORT TraceOption : public BaseOption {
    protected:
      int cur; 
    public:
      TraceOption(int f=0);
      void value(int f);
      int value(void) const;
      virtual int parse(int argc, char* argv[]);
      virtual void help(void);
    };

    class GECODE_DRIVER_EXPORT ProfilerOption : public BaseOption {
     protected:
      unsigned int cur_port;  
      int cur_execution_id;   
     public:
      ProfilerOption(const char* o, const char* e, unsigned int p = 0, int v = -1);
      void port(unsigned int p);
      unsigned int port(void) const;
      void execution_id(int i);
      int execution_id(void) const;
      virtual int parse(int argc, char* argv[]);
      virtual void help(void);
    };
  }

  class GECODE_DRIVER_EXPORT BaseOptions {
  protected:
    Driver::BaseOption* fst;   
    Driver::BaseOption* lst;   
    const char* _name; 
  public:
    BaseOptions(const char* s);
    virtual void help(void);

    void add(Driver::BaseOption& o);
    void parse(int& argc, char* argv[]);

    const char* name(void) const;
    void name(const char*);

    virtual ~BaseOptions(void);
  };

  class GECODE_DRIVER_EXPORT Options : public BaseOptions {
  protected:

    Driver::StringOption      _model;       
    Driver::StringOption      _symmetry;    
    Driver::StringOption      _propagation; 
    Driver::IplOption         _ipl;         
    Driver::StringOption      _branching;   
    Driver::DoubleOption      _decay;       
    Driver::UnsignedIntOption _seed;        
    Driver::DoubleOption      _step;        


    Driver::StringOption      _search;        
    Driver::UnsignedLongLongIntOption
                              _solutions;     
    Driver::DoubleOption      _threads;       
    Driver::UnsignedIntOption _c_d;           
    Driver::UnsignedIntOption _a_d;           
    Driver::UnsignedIntOption _d_l;           
    Driver::UnsignedLongLongIntOption
                              _node;          
    Driver::UnsignedLongLongIntOption
                              _fail;          
    Driver::DoubleOption      _time;          
    Driver::UnsignedIntOption _assets;        
    Driver::UnsignedIntOption _slice;         
    Driver::StringOption      _restart;       
    Driver::DoubleOption      _r_base;        
    Driver::UnsignedIntOption _r_scale;       
    Driver::UnsignedLongLongIntOption
                              _r_limit;       
    Driver::BoolOption        _nogoods;       
    Driver::UnsignedIntOption _nogoods_limit; 
    Driver::DoubleOption      _relax;         
    Driver::BoolOption        _interrupt;     


    Driver::StringOption      _mode;          
    Driver::UnsignedIntOption _samples;       
    Driver::UnsignedIntOption _iterations;    
    Driver::BoolOption        _print_last;    
    Driver::StringValueOption _out_file;      
    Driver::StringValueOption _log_file;      
    Driver::TraceOption       _trace;         
 
#ifdef GECODE_HAS_CPPROFILER
    Driver::ProfilerOption    _profiler;      
#endif

 
  public:
    Options(const char* s);



    void model(int v);
    void model(int v, const char* o, const char* h = nullptr);
    int model(void) const;

    void symmetry(int v);
    void symmetry(int v, const char* o, const char* h = nullptr);
    int symmetry(void) const;

    void propagation(int v);
    void propagation(int v, const char* o, const char* h = nullptr);
    int propagation(void) const;

    void ipl(IntPropLevel i);
    IntPropLevel ipl(void) const;

    void branching(int v);
    void branching(int v, const char* o, const char* h = nullptr);
    int branching(void) const;

    void decay(double d);
    double decay(void) const;

    void seed(unsigned int s);
    unsigned int seed(void) const;

    void step(double s);
    double step(void) const;



    void search(int v);
    void search(int v, const char* o, const char* h = nullptr);
    int search(void) const;

    void solutions(unsigned long long int n);
    unsigned long long int solutions(void) const;

    void threads(double n);
    double threads(void) const;

    void c_d(unsigned int d);
    unsigned int c_d(void) const;

    void a_d(unsigned int d);
    unsigned int a_d(void) const;

    void d_l(unsigned int d);
    unsigned int d_l(void) const;

    void node(unsigned long long int n);
    unsigned long long int node(void) const;

    void fail(unsigned long long int n);
    unsigned long long int fail(void) const;

    void time(double t);
    double time(void) const;

    void assets(unsigned int n);
    unsigned int assets(void) const;

    void slice(unsigned int n);
    unsigned int slice(void) const;

    void restart(RestartMode r);
    RestartMode restart(void) const;

    void restart_base(double base);
    double restart_base(void) const;

    void restart_scale(unsigned int scale);
    unsigned int restart_scale(void) const;

    void restart_limit(unsigned long long int n);
    unsigned long long int restart_limit(void) const;

    void nogoods(bool b);
    bool nogoods(void) const;

    void nogoods_limit(unsigned int l);
    unsigned int nogoods_limit(void) const;

    void relax(double d);
    double relax(void) const;

    void interrupt(bool b);
    bool interrupt(void) const;



    void mode(ScriptMode em);
    ScriptMode mode(void) const;

    void samples(unsigned int s);
    unsigned int samples(void) const;

    void iterations(unsigned int i);
    unsigned int iterations(void) const;

    void print_last(bool p);
    bool print_last(void) const;

    void out_file(const char* f);
    const char* out_file(void) const;

    void log_file(const char* f);
    const char* log_file(void) const;

    void trace(int f);
    int trace(void) const;
 
#ifdef GECODE_HAS_CPPROFILER
    void profiler_id(int i);
    int profiler_id(void) const;
    void profiler_port(unsigned int p);
    unsigned int profiler_port(void) const;
#endif
 
#ifdef GECODE_HAS_GIST
    class I_ {
    private:
      Support::DynamicArray<Gist::Inspector*,Heap> _click;
      unsigned int n_click;
      Support::DynamicArray<Gist::Inspector*,Heap> _solution;
      unsigned int n_solution;
      Support::DynamicArray<Gist::Inspector*,Heap> _move;
      unsigned int n_move;
      Support::DynamicArray<Gist::Comparator*,Heap> _compare;
      unsigned int n_compare;
    public:
      I_(void);
      void click(Gist::Inspector* i);
      void solution(Gist::Inspector* i);
      void move(Gist::Inspector* i);
      void compare(Gist::Comparator* i);

      Gist::Inspector* click(unsigned int i) const;
      Gist::Inspector* solution(unsigned int i) const;
      Gist::Inspector* move(unsigned int i) const;
      Gist::Comparator* compare(unsigned int i) const;
    } inspect;
#endif
  };
 
}
 
namespace Gecode {

  class GECODE_DRIVER_EXPORT SizeOptions : public Options {
  protected:
    unsigned int _size; 
  public:
    SizeOptions(const char* s);
    virtual void help(void);
    void parse(int& argc, char* argv[]);

    void size(unsigned int s);
    unsigned int size(void) const;
  };

  class GECODE_DRIVER_EXPORT InstanceOptions : public Options {
  protected:
    const char* _inst; 
  public:
    InstanceOptions(const char* s);
    virtual void help(void);
    void parse(int& argc, char* argv[]);

    void instance(const char* s);
    const char* instance(void) const;
    ~InstanceOptions(void);
  };
 
}
 
#include <gecode/driver/options.hpp>
 
namespace Gecode { namespace Driver {

  template<class BaseSpace>
  class ScriptBase : public BaseSpace {
  public:
    ScriptBase(const Options& opt);
    ScriptBase(ScriptBase& e);
    virtual void print(std::ostream& os) const;
    virtual void compare(const Space& home, std::ostream& os) const;
    static std::ostream& select_ostream(const char* sn, std::ofstream& ofs);
    template<class Script, template<class> class Engine, class Options>
    static void run(const Options& opt, Script* s=nullptr);
  private:
    template<class Script, template<class> class Engine, class Options,
             template<class, template<class> class> class Meta>
    static void runMeta(const Options& opt, Script* s);
  };
 
#ifdef GECODE_HAS_FLOAT_VARS

  template<class BaseSpace>
  class ExtractStepOption : public BaseSpace {
  public:
    ExtractStepOption(const Options& opt)
      : BaseSpace(opt.step()) {}

    ExtractStepOption(BaseSpace& e)
      : BaseSpace(e) {}
  };
 
#endif

  template<class BaseSpace>
  class IgnoreStepOption : public BaseSpace {
  public:
    IgnoreStepOption(const Options&) {}
    IgnoreStepOption(BaseSpace& e)
      : BaseSpace(e) {}
  };
 
}}
 
#include <gecode/driver/script.hpp>
 
namespace Gecode {


  typedef Driver::ScriptBase<Driver::IgnoreStepOption<Space> >
    Script;

  typedef Driver::ScriptBase<Driver::IgnoreStepOption<IntMinimizeSpace> >
    IntMinimizeScript;
  typedef Driver::ScriptBase<Driver::IgnoreStepOption<IntMaximizeSpace> >
    IntMaximizeScript;

  typedef Driver::ScriptBase<Driver::IgnoreStepOption<IntLexMinimizeSpace> >
    IntLexMinimizeScript;
  typedef Driver::ScriptBase<Driver::IgnoreStepOption<IntLexMaximizeSpace> >
    IntLexMaximizeScript;
 
#ifdef GECODE_HAS_FLOAT_VARS

  typedef Driver::ScriptBase<Driver::ExtractStepOption<FloatMinimizeSpace> >
    FloatMinimizeScript;
  typedef Driver::ScriptBase<Driver::ExtractStepOption<FloatMaximizeSpace> >
    FloatMaximizeScript;
 
#endif
 
}
 
#endif
 
// STATISTICS: driver-any