include/cloog/block.h

   1
   2    /**-------------------------------------------------------------------**
   3     **                              CLooG                                **
   4     **-------------------------------------------------------------------**
   5     **                             block.h                               **
   6     **-------------------------------------------------------------------**
   7     **                    First version: June 11th 2005                  **
   8     **-------------------------------------------------------------------**/
   9
  10
  11 /******************************************************************************
  12  *               CLooG : the Chunky Loop Generator (experimental)             *
  13  ******************************************************************************
  14  *                                                                            *
  15  * Copyright (C) 2001-2005 Cedric Bastoul                                     *
  16  *                                                                            *
  17  * This is free software; you can redistribute it and/or modify it under the  *
  18  * terms of the GNU General Public License as published by the Free Software  *
  19  * Foundation; either version 2 of the License, or (at your option) any later *
  20  * version.                                                                   *
  21  *                                                                            *
  22  * This software is distributed in the hope that it will be useful, but       *
  23  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY *
  24  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License   *
  25  * for more details.                                                          *
  26  *                                                                            *
  27  * You should have received a copy of the GNU General Public License along    *
  28  * with software; if not, write to the Free Software Foundation, Inc.,        *
  29  * 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA                     *
  30  *                                                                            *
  31  * CLooG, the Chunky Loop Generator                                           *
  32  * Written by Cedric Bastoul, Cedric.Bastoul@inria.fr                         *
  33  *                                                                            *
  34  ******************************************************************************/
  35
  36
  37 #ifndef CLOOG_BLOCK_H
  38 #define CLOOG_BLOCK_H
  39 #if defined(__cplusplus)
  40 extern "C"
  41   {
  42 #endif
  43
  44
  45 /**
  46  * CloogBlock structure:
  47  * this structure contains the informations of a statement block. It may happen
  48  * that users are lazy enough to ask CLooG to generate the code for statements
  49  * with exactly the same domain/scattering pair (possibly differing by only one
  50  * constant) instead of giving only one pair. CLooG provides them a last chance
  51  * to save time and memory by trying to find these blocks itself. The block
  52  * contains the statement list and the common informations of the statements.
  53  * This structure contains also the number of existing active references to it:
  54  * because CLooG uses many copies of blocks there is no need to actually copy
  55  * these blocks but just to return a pointer to them and to increment the number
  56  * of active references. Each time a CloogBlock will be freed, we will decrement
  57  * the active reference counter and actually free it if its value is zero.
  58  */
  59 struct cloogblock
  60 { CloogStatement * statement ;  /**< The list of statements in the block. */
  61   CloogMatrix * scattering ;    /**< The scattering function for the block. */
  62   int  nb_scaldims ;            /**< Number of scalar dimensions. */
  63   Value * scaldims ;            /**< Scalar dimension values. */
  64   int depth ;                   /**< Original block depth (outer loop number).*/
  65   int references ;              /**< Number of references to this structure. */
  66 } ;
  67 typedef struct cloogblock CloogBlock ;
  68
  69
  70 /**
  71  * CloogBlockList structure:
  72  * this structure reprensents a node of a linked list of CloogBlock structures.
  73  */
  74 struct cloogblocklist
  75 { CloogBlock * block ;          /**< An element of the list. */
  76   struct cloogblocklist * next ;/**< Pointer to the next element of the list.*/
  77 } ;
  78 typedef struct cloogblocklist CloogBlockList ;
  79
  80
  81 /******************************************************************************
  82  *                          Structure display function                        *
  83  ******************************************************************************/
  84 void cloog_block_print_structure(FILE *, CloogBlock *, int) ;
  85 void cloog_block_print(FILE *, CloogBlock *) ;
  86 void cloog_block_list_print(FILE *, CloogBlockList *) ;
  87
  88
  89 /******************************************************************************
  90  *                         Memory deallocation function                       *
  91  ******************************************************************************/
  92 void cloog_block_free(CloogBlock *) ;
  93 void cloog_block_list_free(CloogBlockList *) ;
  94
  95
  96 /******************************************************************************
  97  *                            Processing functions                            *
  98  ******************************************************************************/
  99 CloogBlock     * cloog_block_malloc() ;
 100 CloogBlock     * cloog_block_alloc(CloogStatement*,CloogMatrix*,int,Value*,int);
 101 CloogBlockList * cloog_block_list_malloc() ;
 102 CloogBlockList * cloog_block_list_alloc(CloogBlock *) ;
 103 CloogBlock     * cloog_block_copy(CloogBlock * block) ;
 104 void             cloog_block_merge(CloogBlock *, CloogBlock *) ;
 105
 106 #if defined(__cplusplus)
 107   }
 108 #endif
 109 #endif /* define _H */
 110