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   int  nb_scaldims ;            /**< Number of scalar dimensions. */
  62   Value * scaldims ;            /**< Scalar dimension values. */
  63   int depth ;                   /**< Original block depth (outer loop number).*/
  64   int references ;              /**< Number of references to this structure. */
  65   void * usr;                   /**< User field, for library user convenience.
  66                                  *   This pointer is not freed when the
  67                                  *   CloogBlock structure is freed.
  68                                  */
  69 } ;
  70 typedef struct cloogblock CloogBlock ;
  71
  72
  73 /**
  74  * CloogBlockList structure:
  75  * this structure reprensents a node of a linked list of CloogBlock structures.
  76  */
  77 struct cloogblocklist
  78 { CloogBlock * block ;          /**< An element of the list. */
  79   struct cloogblocklist * next ;/**< Pointer to the next element of the list.*/
  80 } ;
  81 typedef struct cloogblocklist CloogBlockList ;
  82
  83
  84 /******************************************************************************
  85  *                          Structure display function                        *
  86  ******************************************************************************/
  87 void cloog_block_print_structure(FILE *, CloogBlock *, int) ;
  88 void cloog_block_print(FILE *, CloogBlock *) ;
  89 void cloog_block_list_print(FILE *, CloogBlockList *) ;
  90
  91
  92 /******************************************************************************
  93  *                         Memory deallocation function                       *
  94  ******************************************************************************/
  95 void cloog_block_free(CloogBlock *) ;
  96 void cloog_block_list_free(CloogBlockList *) ;
  97
  98
  99 /******************************************************************************
 100  *                            Processing functions                            *
 101  ******************************************************************************/
 102 CloogBlock     * cloog_block_malloc(void);
 103 CloogBlock     * cloog_block_alloc(CloogStatement *statement, int nb_scaldims,
 104                                     Value *scaldims, int depth);
 105 CloogBlockList * cloog_block_list_malloc(void);
 106 CloogBlockList * cloog_block_list_alloc(CloogBlock *) ;
 107 CloogBlock     * cloog_block_copy(CloogBlock * block) ;
 108 void             cloog_block_merge(CloogBlock *, CloogBlock *) ;
 109
 110 #if defined(__cplusplus)
 111   }
 112 #endif
 113 #endif /* define _H */
 114