mirror of
https://review.haiku-os.org/buildtools
synced 2025-01-18 20:38:39 +01:00
5873a060ca
* these are dependencies for gcc 4 Graphite engine build. * CLooG 0.18.0 includes ISL 0.11.1 which is the backend that the build script enables. * PPL is needed by GCC build even if it isn't the chosen backend.
405 lines
13 KiB
C
405 lines
13 KiB
C
|
|
/**-------------------------------------------------------------------**
|
|
** CLooG **
|
|
**-------------------------------------------------------------------**
|
|
** block.c **
|
|
**-------------------------------------------------------------------**
|
|
** First version: june 11th 2005 **
|
|
**-------------------------------------------------------------------**/
|
|
|
|
|
|
/******************************************************************************
|
|
* CLooG : the Chunky Loop Generator (experimental) *
|
|
******************************************************************************
|
|
* *
|
|
* Copyright (C) 2001-2005 Cedric Bastoul *
|
|
* *
|
|
* This library is free software; you can redistribute it and/or *
|
|
* modify it under the terms of the GNU Lesser General Public *
|
|
* License as published by the Free Software Foundation; either *
|
|
* version 2.1 of the License, or (at your option) any later version. *
|
|
* *
|
|
* This library 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 *
|
|
* Lesser General Public License for more details. *
|
|
* *
|
|
* You should have received a copy of the GNU Lesser General Public *
|
|
* License along with this library; if not, write to the Free Software *
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, *
|
|
* Boston, MA 02110-1301 USA *
|
|
* *
|
|
* CLooG, the Chunky Loop Generator *
|
|
* Written by Cedric Bastoul, Cedric.Bastoul@inria.fr *
|
|
* *
|
|
******************************************************************************/
|
|
/* CAUTION: the english used for comments is probably the worst you ever read,
|
|
* please feel free to correct and improve it !
|
|
*/
|
|
|
|
# include <stdlib.h>
|
|
# include <stdio.h>
|
|
# include "../include/cloog/cloog.h"
|
|
|
|
|
|
/******************************************************************************
|
|
* Memory leaks hunting *
|
|
******************************************************************************/
|
|
|
|
|
|
/**
|
|
* These functions and global variables are devoted to memory leaks hunting: we
|
|
* want to know at each moment how many CloogBlock structures had been allocated
|
|
* (cloog_block_allocated) and how many had been freed (cloog_block_freed).
|
|
* Each time a CloogBlock structure is allocated, a call to the function
|
|
* cloog_block_leak_up() must be carried out, and respectively
|
|
* cloog_block_leak_down() when a CloogBlock structure is freed. The special
|
|
* variable cloog_block_max gives the maximal number of CloogBlock structures
|
|
* simultaneously alive (i.e. allocated and non-freed) in memory.
|
|
* - June 11th 2005: first version.
|
|
*/
|
|
|
|
|
|
static void cloog_block_leak_up(CloogState *state)
|
|
{
|
|
state->block_allocated++;
|
|
if ((state->block_allocated - state->block_freed) > state->block_max)
|
|
state->block_max = state->block_allocated - state->block_freed;
|
|
}
|
|
|
|
|
|
static void cloog_block_leak_down(CloogState *state)
|
|
{
|
|
state->block_freed++;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* Structure display function *
|
|
******************************************************************************/
|
|
|
|
|
|
/**
|
|
* cloog_domain_print_structure :
|
|
* this function is a human-friendly way to display the CloogDomain data
|
|
* structure, it includes an indentation level (level) in order to work with
|
|
* others print_structure functions.
|
|
* - June 16th 2005: first version.
|
|
*/
|
|
void cloog_block_print_structure(FILE * file, CloogBlock * block, int level)
|
|
{ int i ;
|
|
|
|
/* Go to the right level. */
|
|
for (i=0; i<level; i++)
|
|
fprintf(file,"|\t") ;
|
|
|
|
if (block != NULL)
|
|
{ fprintf(file,"+-- CloogBlock\n") ;
|
|
|
|
/* A blank line. */
|
|
for (i=0; i<level+2; i++)
|
|
fprintf(file,"|\t") ;
|
|
fprintf(file,"\n") ;
|
|
|
|
/* Print statement list. */
|
|
cloog_statement_print_structure(file,block->statement,level+1) ;
|
|
|
|
/* A blank line. */
|
|
for (i=0; i<level+2; i++)
|
|
fprintf(file,"|\t") ;
|
|
fprintf(file,"\n") ;
|
|
|
|
/* Print scattering function. */
|
|
for(i=0; i<level+1; i++)
|
|
fprintf(file,"|\t") ;
|
|
|
|
fprintf(file,"+-- Null scattering function\n") ;
|
|
|
|
/* A blank line. */
|
|
for (i=0; i<level+2; i++)
|
|
fprintf(file,"|\t") ;
|
|
fprintf(file,"\n") ;
|
|
|
|
/* Print scalar dimensions. */
|
|
for (i=0; i<level+1; i++)
|
|
fprintf(file,"|\t") ;
|
|
|
|
if (block->nb_scaldims == 0)
|
|
fprintf(file,"No scalar dimensions\n") ;
|
|
else
|
|
{ fprintf(file,"Scalar dimensions (%d):",block->nb_scaldims) ;
|
|
for (i = 0; i < block->nb_scaldims; i++) {
|
|
fprintf(file, " ");
|
|
cloog_int_print(file, block->scaldims[i]);
|
|
}
|
|
fprintf(file,"\n") ;
|
|
}
|
|
|
|
/* A blank line. */
|
|
for (i=0; i<level+2; i++)
|
|
fprintf(file,"|\t") ;
|
|
fprintf(file,"\n") ;
|
|
|
|
/* Print depth. */
|
|
for (i=0; i<level+1; i++)
|
|
fprintf(file,"|\t") ;
|
|
fprintf(file,"Depth: %d\n",block->depth) ;
|
|
|
|
/* A blank line. */
|
|
for (i=0; i<level+1; i++)
|
|
fprintf(file,"|\t") ;
|
|
fprintf(file,"\n") ;
|
|
}
|
|
else
|
|
fprintf(file,"+-- Null CloogBlock\n") ;
|
|
}
|
|
|
|
|
|
/**
|
|
* cloog_block_print function:
|
|
* This function prints the content of a CloogBlock structure (block) into a
|
|
* file (file, possibly stdout).
|
|
* - June 11th 2005: first version.
|
|
* - June 16th 2005: now just a call to cloog_block_print_structure.
|
|
*/
|
|
void cloog_block_print(FILE * file, CloogBlock * block)
|
|
{ cloog_block_print_structure(file,block,0) ;
|
|
}
|
|
|
|
|
|
/**
|
|
* cloog_block_list_print function:
|
|
* This function prints the content of a CloogBlock structure (block) into a
|
|
* file (file, possibly stdout).
|
|
* - June 16th 2005: first version.
|
|
*/
|
|
void cloog_block_list_print(FILE * file, CloogBlockList * blocklist)
|
|
{ int i=0 ;
|
|
|
|
while (blocklist != NULL)
|
|
{ fprintf(file,"+-- CloogBlockList node %d\n",i) ;
|
|
cloog_block_print_structure(file,blocklist->block,1) ;
|
|
blocklist = blocklist->next ;
|
|
i++ ;
|
|
}
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* Memory deallocation function *
|
|
******************************************************************************/
|
|
|
|
|
|
/**
|
|
* cloog_block_free function:
|
|
* This function frees the allocated memory for a CloogStatement structure.
|
|
* - June 11th 2005: first version.
|
|
* - June 30th 2005: scaldims field management.
|
|
*/
|
|
void cloog_block_free(CloogBlock * block)
|
|
{ int i ;
|
|
|
|
if (block != NULL)
|
|
{ block->references -- ;
|
|
|
|
if (block->references == 0) {
|
|
cloog_block_leak_down(block->state);
|
|
if (block->scaldims != NULL)
|
|
{ for (i=0;i<block->nb_scaldims;i++)
|
|
cloog_int_clear(block->scaldims[i]);
|
|
|
|
free(block->scaldims) ;
|
|
}
|
|
if (block->statement)
|
|
cloog_statement_free(block->statement);
|
|
free(block) ;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* cloog_block_list_free function:
|
|
* This function frees the allocated memory for a CloogBlockList structure.
|
|
* - June 11th 2005: first version.
|
|
*/
|
|
void cloog_block_list_free(CloogBlockList * blocklist)
|
|
{ CloogBlockList * temp ;
|
|
|
|
while (blocklist != NULL)
|
|
{ temp = blocklist->next ;
|
|
cloog_block_free(blocklist->block) ;
|
|
free(blocklist) ;
|
|
blocklist = temp ;
|
|
}
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* Processing functions *
|
|
******************************************************************************/
|
|
|
|
/**
|
|
* cloog_block_malloc function:
|
|
* This function allocates the memory space for a CloogBlock structure and
|
|
* sets its fields with default values. Then it returns a pointer to the
|
|
* allocated space.
|
|
* - November 21th 2005: first version.
|
|
*/
|
|
CloogBlock *cloog_block_malloc(CloogState *state)
|
|
{ CloogBlock * block ;
|
|
|
|
/* Memory allocation for the CloogBlock structure. */
|
|
block = (CloogBlock *)malloc(sizeof(CloogBlock)) ;
|
|
if (block == NULL)
|
|
cloog_die("memory overflow.\n");
|
|
cloog_block_leak_up(state);
|
|
|
|
/* We set the various fields with default values. */
|
|
block->state = state;
|
|
block->statement = NULL ;
|
|
block->nb_scaldims = 0 ;
|
|
block->scaldims = NULL ;
|
|
block->depth = 0 ;
|
|
block->references = 1 ;
|
|
block->usr = NULL;
|
|
|
|
return block ;
|
|
}
|
|
|
|
|
|
/**
|
|
* cloog_block_alloc function:
|
|
* This function allocates the memory space for a CloogBlock structure and
|
|
* sets its fields with those given as input. Then it returns a pointer to the
|
|
* allocated space. The two parameters nb_scaldims and scaldims are for internal
|
|
* service, put to respectively 0 and NULL if you don't know what they are
|
|
* useful for !
|
|
* - statement is the statement list of the block,
|
|
* - scattering is the scattering function for the block (NULL if unsure !),
|
|
* - nb_scaldims is the number of scalar dimensions (0 if unsure !),
|
|
* - scaldims is the array with the scalar dimensions values (NULL if unsure !),
|
|
* - depth is the original block depth (the number of outer loops).
|
|
**
|
|
* - June 11th 2005: first version.
|
|
* - June 30th 2005: addition of the nb_scaldims and scaldims parameters.
|
|
* - November 21th 2005: use of cloog_block_malloc.
|
|
*/
|
|
CloogBlock *cloog_block_alloc(CloogStatement *statement, int nb_scaldims,
|
|
cloog_int_t *scaldims, int depth)
|
|
{ CloogBlock * block ;
|
|
|
|
/* Block allocation. */
|
|
block = cloog_block_malloc(statement->state);
|
|
|
|
block->statement = statement ;
|
|
block->nb_scaldims = nb_scaldims ;
|
|
block->scaldims = scaldims ;
|
|
block->depth = depth ;
|
|
block->references = 1 ;
|
|
|
|
return block ;
|
|
}
|
|
|
|
|
|
/**
|
|
* cloog_block_list_malloc function:
|
|
* This function allocates the memory space for a CloogBlockList structure and
|
|
* sets its fields with default values. Then it returns a pointer to the
|
|
* allocated space.
|
|
* - November 21th 2005: first version.
|
|
*/
|
|
CloogBlockList * cloog_block_list_malloc()
|
|
{ CloogBlockList * blocklist ;
|
|
|
|
/* Memory allocation for the CloogBlock structure. */
|
|
blocklist = (CloogBlockList *)malloc(sizeof(CloogBlockList)) ;
|
|
if (blocklist == NULL)
|
|
cloog_die("memory overflow.\n");
|
|
|
|
/* We set the various fields with default values. */
|
|
blocklist->block = NULL ;
|
|
blocklist->next = NULL ;
|
|
|
|
return blocklist ;
|
|
}
|
|
|
|
|
|
/**
|
|
* cloog_block_list_alloc function:
|
|
* This function allocates the memory space for a CloogBlockList structure and
|
|
* sets its fields with those given as input. Then it returns a pointer to the
|
|
* allocated space.
|
|
* - block is the block element of the list node,
|
|
**
|
|
* - June 11th 2005: first version.
|
|
* - November 21th 2005: use of cloog_block_list_malloc.
|
|
*/
|
|
CloogBlockList * cloog_block_list_alloc(CloogBlock * block)
|
|
{ CloogBlockList * blocklist ;
|
|
|
|
/* Block list node allocation. */
|
|
blocklist = cloog_block_list_malloc() ;
|
|
|
|
blocklist->block = block ;
|
|
blocklist->block->references ++ ; /* The block has a new reference to it. */
|
|
blocklist->next = NULL ;
|
|
|
|
return blocklist ;
|
|
}
|
|
|
|
|
|
/**
|
|
* cloog_block_copy function:
|
|
* This function returns a copy of a CloogBlock structure 'block'. To save
|
|
* memory this is not a memory copy but we increment a counter of active
|
|
* references inside the structure, then return a pointer to that structure.
|
|
*/
|
|
CloogBlock * cloog_block_copy(CloogBlock * block)
|
|
{ if (block == NULL)
|
|
return NULL ;
|
|
|
|
block->references ++ ;
|
|
return block ;
|
|
}
|
|
|
|
|
|
/**
|
|
* cloog_block_merge function:
|
|
* this function adds at the end of the statement list of the block 'block',
|
|
* the statement list of the block 'merged'. Then the CloogBlock structure
|
|
* of 'merged' is freed (obviously not its statement list that is now
|
|
* included in 'block').
|
|
* - June 11th 2005: first version.
|
|
*/
|
|
void cloog_block_merge(CloogBlock * block, CloogBlock * merged)
|
|
{ CloogStatement * statement ;
|
|
|
|
if ((block == NULL) || (merged == NULL))
|
|
return ;
|
|
|
|
if (block->statement != NULL)
|
|
{ statement = block->statement ;
|
|
|
|
while (statement->next != NULL)
|
|
statement = statement->next ;
|
|
|
|
statement->next = merged->statement ;
|
|
}
|
|
else
|
|
block->statement = merged->statement ;
|
|
|
|
merged->statement = NULL;
|
|
cloog_block_free(merged);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|