act.h

Go to the documentation of this file.

/*************************************************************************
 *
 *  This file is part of the ACT library
 *
 *  Copyright (c) 2018-2019 Rajit Manohar
 *
 *  This program is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License
 *  as published by the Free Software Foundation; either version 2
 *  of the License, or (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor,
 *  Boston, MA  02110-1301, USA.
 *
 **************************************************************************
 */
#ifndef __ACT_H__
#define __ACT_H__
 
#include <act/types.h>
#include <act/lang.h>
#include <act/body.h>
#include <act/value.h>
#include <common/config.h>
#include <map>
#include <unordered_set>
 
#define ACT_MODEL_CHP  0                
#define ACT_MODEL_HSE  1                
#define ACT_MODEL_PRS  2                
#define ACT_MODEL_DEVICE 3              
#define ACT_MODEL_TOTAL 4               
 
 
extern const char *act_model_names[]; 
 
class ActPass;
class Log;
 
class Act {
 public:
  static void Init (int *argc, char ***argv, const char *optional_conf);
 
  static void Init (int *argc, char ***argv, list_t *multi_conf = NULL);
 
  static int getOptions (int *argc, char ***argv);
 
  static void setOptionString (char *str);
 
  static int max_recurse_depth;
 
  static int max_loop_iterations;
 
#define WARNING_FLAG(x,y) \
  static int x ;
#include "warn.def"
  
  static list_t *cmdline_args;
 
  static int emit_depend;
 
  static void config_info (const char *s);
  static void generic_msg (const char *s);
 
 
  Act (const char *s = NULL);
  ~Act ();
 
  void Merge (const char *s);
 
 
  bool LocalizeGlobal (const char *s);
 
  void Expand ();
 
 
  void mangle (char *s);
 
  int mangle_set_char (unsigned char c);
 
  int mangle_active() { return any_mangling; } 
  int mangle_string (const char *src, char *dst, int sz);
  
  int unmangle_string (const char *src, char *dst, int sz);
 
  void mfprintf (FILE *fp, const char *s, ...);
 
  void ufprintf (FILE *fp, const char *s, ...);
 
  int msnprintf (char *fp, int sz, const char *s, ...);
 
  int usnprintf (char *fp, int sz, const char *s, ...);
 
  void msnprintfproc (char *fp, int sz, UserDef *u, int omit_ns = 0);
 
  void mfprintfproc (FILE *fp, UserDef *u, int omit_ns = 0);
 
  int unmangle_stringproc (const char *src, char *dst, int sz);
 
  /* 
     API functions
  */
 
  Process *findProcess (const char *s, bool allow_expand = false);
 
  Process *findProcess (ActNamespace *ns, const char *s, bool allow_expand = false);
 
  UserDef *findUserdef (const char *s);
 
  ActNamespace *findNamespace (const char *s);
  
  ActNamespace *findNamespace (ActNamespace *ns, const char *s);
 
  
  ActNamespace *Global() { return gns; }
 
  void Print (FILE *fp);
 
  void pass_register (const char *name, ActPass *p);
 
  ActPass *pass_find (const char *name);
  
  void pass_unregister (const char *name);
  
  const char *pass_name (const char *name);
 
  list_t *getDecomp (Process *p);
 
  list_t *getDecompTypes ();
 
  TypeFactory *getTypeFactory () { return tf; }
 
  /*
    Get modeling level of detail and refinement steps.
  */
  int getLevel ();              
  int getLevel (Process *p);    
  int getLevel (ActId *id);     
 
  int getRefSteps() { return refine_steps; } 
  void decRefSteps() { refine_steps--; } 
  
  void incRefSteps() { refine_steps++; } 
 
private:
  TypeFactory *tf;              
  ActNamespace *gns;            
 
  
  int mangle_characters[256];   
  int inv_map[256];             
  int any_mangling;            
 
#if 0
  int mangle_langle_idx;  /* index of '<' */
  int mangle_min_idx;     /* index of the min of , . { } */
  int mangle_mode;
#endif  
 
  static Log *L;  
 
  struct Hashtable *passes;     
 
  int refine_steps;             
 
  int num_type_levels[ACT_MODEL_TOTAL]; 
  
  char **type_levels[ACT_MODEL_TOTAL];  
  
  int num_inst_levels[ACT_MODEL_TOTAL]; 
  
  char **inst_levels[ACT_MODEL_TOTAL]; 
 
  int default_level;  
 
  static char *_getopt_string; 
 
  static int _process_act_arg (const char *argvp, int *tech_specified, char **conf);
};
 
class ActPass {
protected:
  int _finished;                
  
  int _sticky_visited;          
  
  Act *a;                       
  
  list_t *deps;                 
 
  list_t *fwdeps;               
  
  const char *name;             
 
  int _update_propagate;        
  
  int _root_dirty;              
  
  Process *_root;               
  
  void *_global_info;           
  
 
  virtual void _actual_update (Process *p);
 
  int AddDependency (const char *pass);
 
public:
  ActPass (Act *_a, const char *name, int doroot = 0);
  
  virtual ~ActPass ();                         
 
 
  void update (Process *p);
 
  int rundeps (Process *p = NULL);
 
  const char *getName();
 
  virtual int run(Process *p = NULL); // run pass on a process; NULL =
                                      // top level
 
 
  int completed()  { return (_finished == 2) ? 1 : 0; }
 
  int pending()  { return (_finished == 1) ? 1 : 0; }
 
  void *getMap (UserDef *u);
 
  void *getGlobalInfo () { return _global_info; }
 
  Act *getAct () { return a; }
 
  ActPass *getPass (const char *name) { return a->pass_find (name); }
 
  Process *getRoot() { return _root; }
 
 
  virtual void run_recursive (Process *p = NULL, int mode = 0);
 
  void disableUpdate () { _update_propagate = 0; }
 
  void enableUpdate () { _update_propagate = 1; }
 
  void mkStickyVisited () { _sticky_visited = 1; }
 
  void clrStickyVisited() { _sticky_visited = 0; }
 
  static void refreshAll (Act *a, Process *p = NULL);
 
private:
  virtual void *pre_op (Process *p, int mode = 0);
 
  virtual void *pre_op (Channel *c, int mode = 0);
 
  virtual void *pre_op (Data *d, int mode = 0);
 
  virtual void *local_op (Process *p, int mode = 0);
 
  
  virtual void *local_op (Channel *c, int mode = 0);
  
  virtual void *local_op (Data *d, int mode = 0);
 
  virtual void free_local (void *);
 
  int init (); 
 
  void recursive_op (UserDef *p, int mode = 0); 
 
  void init_map ();             
  
  void free_map ();             
  
  std::map<UserDef *, void *> *pmap; 
  
  std::unordered_set<UserDef *> *visited_flag; 
};
 
class Technology;
class ActDynamicPass;
 
class ActDynamicPass : public ActPass {
 
  struct act_sh_passlib_info {
    char *lib; 
    void *lib_ptr; 
    int refs;  
  };
 
  struct act_sh_dispatch_table {
 
    void (*_init) (ActPass *ap);
 
 
    void (*_run) (ActPass *ap, Process *p);
    
    void (*_recursive) (ActPass *ap, Process *p, int mode);
 
    void *(*_proc) (ActPass *ap, Process *p, int mode);
    
    void *(*_chan) (ActPass *ap, Channel *c, int mode);
    
    void *(*_data) (ActPass *ap, Data *d, int mode);
 
    void (*_free) (ActPass *ap, void *v);
 
    /*
     * This called prior to the pass being destroyed
     * @param ap is the pass
     */
    void (*_done) (ActPass *ap);
 
    /*
     * A pass-specific function that can be defined to run arbitrary
     * commands associated with a pass.
     * @param ap is the pass
     * @param name is the name of the command to run
     * @return return value of the command (-1 is reserved to mean the
     * command does not exist).
     */
    int (*_runcmd) (ActPass *ap, const char *name);
  };
 
  
public:
  ActDynamicPass (Act *_a, const char *name, const char *lib, const char *prefix);
  
  ~ActDynamicPass ();           
 
  int run (Process *p = NULL);
 
  void run_recursive (Process *p = NULL, int mode = 0);
 
  void setParam (const char *name, void *v);
  
  void setParam (const char *name, int v);
 
  void setParam (const char *name, double v);
 
  int getIntParam (const char *name);
  
  void *getPtrParam (const char *name);
  
  double getRealParam (const char *name);
 
  bool hasParam (const char *name);
 
  int runcmd (const char *name);
 
  struct Hashtable *getConfig ();
 
  Technology *getTech () { return T; }
 
  bool loaded() { return _load_success; }
 
  int addDependency (const char *name) { return AddDependency (name); }
  
private:
 
  virtual void *local_op (Process *, int = 0);
  virtual void *local_op (Channel *, int  = 0);
  virtual void *local_op (Data *, int  = 0);
  virtual void free_local (void *);
 
  bool _load_success; 
  
  char *_libused;  
  
  act_sh_dispatch_table _d;  
  
  struct Hashtable *_params;  
  
  struct Hashtable *_config_state; 
  
  Technology *T;                
  
  static list_t *_sh_libs;
};
 
 
/* this should be elsewhere */
 
Expr *const_expr (long val);
 
Expr *const_expr_bool (int v);
 
Expr *const_expr_real (double v);
 
 
void act_add_global_pint (const char *name, int val);
 
 
void act_add_global_pbool (const char *name, int val);
 
#endif /* __ACT_H__ */