osprey/be/lno/parallel.h

Go to the documentation of this file.

/*
 * Copyright 2005, 2006 PathScale, Inc.  All Rights Reserved.
 */

/*

  Copyright (C) 2000, 2001 Silicon Graphics, Inc.  All Rights Reserved.

  This program is free software; you can redistribute it and/or modify it
  under the terms of version 2 of the GNU General Public License as
  published by the Free Software Foundation.

  This program is distributed in the hope that it would be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

  Further, this software is distributed without any warranty that it is
  free of the rightful claim of any third person regarding infringement 
  or the like.  Any license provided herein, whether implied or 
  otherwise, applies only to this software file.  Patent licenses, if 
  any, provided herein do not apply to combinations of this program with 
  other software, or any other product whatsoever.  

  You should have received a copy of the GNU General Public License along
  with this program; if not, write the Free Software Foundation, Inc., 59
  Temple Place - Suite 330, Boston MA 02111-1307, USA.

  Contact information:  Silicon Graphics, Inc., 1600 Amphitheatre Pky,
  Mountain View, CA 94043, or:

  http://www.sgi.com

  For further information regarding this notice, see:

  http://oss.sgi.com/projects/GenInfo/NoticeExplan

*/


// -*-C++-*-

#ifndef parallel_INCLUDED
#define parallel_INCLUDED "parallel.h"

#ifndef pu_info_INCLUDED 
#include <sys/types.h>
#endif
#ifndef pu_info_INCLUDED 
#include "pu_info.h"
#endif
#ifndef sxlist_INCLUDED
#include "sxlist.h"
#endif
#ifndef sdlist_INCLUDED
#include "sdlist.h"
#endif
#ifndef snl_INCLUDED
#include "snl.h"
#endif

enum INTERCHANGE_TYPE {INT_NONE, INT_PERMUTABLE, INT_INVARIANT, INT_GENERAL}; 

enum PAR_DIR_TYPE {PD_NONE, PD_PREFER_CONCURRENT, PD_NO_CONCURRENT}; 

class PARALLEL_INFO {
  double _cost;
  INT _work_estimate; 
  INT _nloops;
  INT _permutation[SNL_MAX_LOOPS];
  INTERCHANGE_TYPE _int_type; 
  INT _sd_split_depth; 
  INT _split_depth; 
  INT _parallel_depth;
  INT _is_doacross;
  INT _doacross_tile_size;
  INT _sync_distances[2];
  INT _doacross_overhead;
  double _reduction_cycles;
  double _loop_cycles;
  double _parallel_cycles;
  double _machine_cycles;
  double _cache_cycles_per_iter;
  double _cache_cycles;
  BOOL _preferred_concurrent;
  WN*  _wn_outer;

 public:
  PARALLEL_INFO(INT nloops); 
  PARALLEL_INFO(WN* wn_outer, INT permutation[], INT nloops, 
    INT parallel_depth, INTERCHANGE_TYPE int_type, SNL_DEP_MATRIX** sdm_array, 
    BOOL sdm_scl[], SX_INFO* sx_info, SD_INFO* sd_info, INT sd_split_depth,
    double machine_cycles, double work_estimate); 
 PARALLEL_INFO(WN* wn_outer, INT permutation[], INT nloops, 
    INT parallel_depth, INTERCHANGE_TYPE int_type, SNL_DEP_MATRIX** sdm_array, 
    BOOL sdm_scl[], SX_INFO* sx_info, SD_INFO* sd_info, INT sd_split_depth,
    double machine_cycles, double work_estimate, BOOL dummy); 
  ~PARALLEL_INFO() {}
  double Cost() {return _cost;} 
  INT Work_Estimate() {return _work_estimate;}
  INT Parallel_Depth() {return _parallel_depth;}
  INT Parallel_Loop() { return _permutation[_parallel_depth - Do_Loop_Depth(_wn_outer)]; }
  INT* Permutation() {return _permutation;} 
  INT Permutation(INT i) {return _permutation[i];} 
  INT Nloops() {return _nloops;}
  INTERCHANGE_TYPE Int_Type() {return _int_type;}
  INT Sd_Split_Depth() {return _sd_split_depth;}
  INT Split_Depth() {return _split_depth;}
  INT Is_Doacross() {return _is_doacross;}
  INT Doacross_Tile_Size() {return _doacross_tile_size;}
  INT* Sync_Distances() {return _sync_distances;}
  INT Doacross_Overhead() {return _doacross_overhead;}
  void Set_Preferred(void) { _preferred_concurrent = TRUE; }
  void Print(FILE *f);
  double Reduction_Cost(void) { return _reduction_cycles; }
  double Parallel_Overhead_Cost(void) { return _parallel_cycles; }
  double Loop_Cost(void) { return _loop_cycles; }
  double Machine_Cost(void) { return _machine_cycles; }
  double Cache_Cost(void) { return _cache_cycles; }
};

extern WN* Minimal_Kernel(WN* wn_outer, INT nloops);
extern BOOL General_Permutation(WN* wn_outer, INT permutation[], INT nloops);
extern BOOL Invariant_Permutation(WN* wn_outer, INT permutation[], INT nloops);
extern BOOL Fully_Permutable_Permutation(WN* wn_outer, INT nloops);
extern SNL_DEP_MATRIX** Inv_Dep_Info(WN* wn_outer, INT nloops, 
  BOOL check_privates = FALSE, BOOL definitely = FALSE);
extern BOOL SNL_Legal_Perm_Deps(SNL_DEP_MATRIX* sdm_body, INT permutation[],
  INT nloops); 
extern void Mark_Auto_Parallelizable_Loops(WN* func_nd); 
extern BOOL Outermore_Parallel_Construct(WN* wn_loop, BOOL check_suggested); 
extern BOOL Innermore_Parallel_Loop(WN* wn_loop, BOOL check_suggested); 
extern void Auto_Parallelization(PU_Info* current_pu, WN* func_nd);
extern BOOL Is_Privatizable_With_Context(WN* loop, WN* wn, BOOL defnitely);
extern double Compute_Work_Estimate(double machine, double cache);
extern BOOL Cannot_Concurrentize(WN* wn_loop); 
extern void Mark_Critical_Section_Loops(WN* func_nd);
extern void Mark_Threadprivate_Loops(WN* func_nd);
extern BOOL Outermore_Parallel_Construct_Or_Lego_Loop(WN* wn_loop);
extern BOOL Innermore_Parallel_Or_Lego_Loop(WN* wn_loop);
extern void IPA_LNO_Evaluate_Call_Infos(WN* func_nd);
extern void IPA_LNO_Unevaluate_Call_Infos(WN* func_nd);

#ifdef KEY
extern INT Last_Apo_Loop_Id;
#endif

#endif /* parallel_INCLUDED */ 

---