memory.c

intel ipp4.1性能库的一些例子。

/*********************************************************************
 * File: memory.c
 * Description: Creation functions for all data structures.
 *
 * Author: Joerg Hoffmann / Frank Rittinger
 *
 *********************************************************************/ 
/*********************************************************************
 * (C) Copyright 1998 Albert Ludwigs University Freiburg
 *     Institute of Computer Science
 *
 * All rights reserved. Use of this software is permitted for 
 * non-commercial research purposes, and it may be copied only 
 * for that use.  All copies must include this copyright message.
 * This software is made available AS IS, and neither the authors
 * nor the  Albert Ludwigs University Freiburg make any warranty
 * about the software or its performance. 
 *********************************************************************/



#include "ipp.h"
#include "utilities.h"
#include "memory.h"
#include "pddl.h"







/**********************************************************************
 ********************** CREATION FUNCTIONS ****************************
 *********************************************************************/

/**********************************************************************
 * Allocates memory for a new string with length len.
 *
 * int len: length of string to allocate INCLUDING the '\0'
 * RETURNS a pointer to the allocated memory
 *********************************************************************/
char *
new_token(int len)
{
  char * tok = (char*) calloc(len, sizeof(char));
  CHECK_PTR(tok);
#ifdef MEMORY_INFO
  gmemory += len * sizeof(char);
#endif
  return tok;
}

/**********************************************************************
 * Allocates new memory for a list of strings and initializes
 * all members to NULL.
 *
 * RETURNS a pointer to the allocated memory
 *********************************************************************/
TokenList *
new_token_list(void)
{
  TokenList * result = (TokenList *) malloc(sizeof(TokenList));
  CHECK_PTR(result);
#ifdef MEMORY_INFO
  gmemory += sizeof(TokenList);
#endif
  result->item = NULL; 
  result->next = NULL;
  return result;
}

/**********************************************************************
 * Allocates new memory for a list of lists of strings and 
 * initializes all members to NULL.
 *
 * RETURNS a pointer to the allocated memory
 *********************************************************************/
FactList * 
new_fact_list(void)
{
  FactList * result = (FactList *) malloc(sizeof(FactList));
  CHECK_PTR(result);
#ifdef MEMORY_INFO
  gmemory += sizeof(FactList);
#endif
  result->item = NULL; 
  result->next = NULL;
  return result;
}



TypedList *new_TypedList( void )

{

  TypedList *result = ( TypedList * ) calloc( 1, sizeof( TypedList ) );
  CHECK_PTR(result);

  result->name = NULL; 
  result->type = NULL;
  result->n = -1;

  return result;

}



TypedListList *new_TypedListList( void )

{

  TypedListList *result = ( TypedListList * ) calloc( 1, sizeof( TypedListList ) );
  CHECK_PTR(result);

  result->predicate = NULL; 
  result->args = NULL;

  return result;

}



/**********************************************************************
 * Allocates new memory for a PL1 tree node.
 *
 * Connective c: The type of node, see pddl.h for a full description.
 * RETURNS a pointer to the allocated memory
 *********************************************************************/
PlNode *
new_pl_node(Connective c)
{
  PlNode * result = (PlNode *) malloc(sizeof(PlNode));
  CHECK_PTR(result);
#ifdef MEMORY_INFO
  gmemory += sizeof(PlNode);
#endif
  result->connective = c;
  result->atom = NULL;
  result->sons = NULL;
  result->next = NULL;
  return result;
}

CodeNode *new_CodeNode( Connective c )

{

  CodeNode *result = ( CodeNode * ) calloc( 1, sizeof( CodeNode ) );
  CHECK_PTR(result);
#ifdef MEMORY_INFO
  gmemory += sizeof( CodeNode );
#endif

  result->connective = c;

  result->var = 0;
  result->var_type = 0;
  result->predicate = 0;

  result->visited = FALSE;

  result->sons = NULL;
  result->next = NULL;

  return result;

}

/**********************************************************************
 * Allocates new memory for a PL1 style operator.
 *
 * char * name: The name of the operator, memory will be allocated.
 * RETURNS a pointer to the allocated memory
 *********************************************************************/
PlOperator *
new_pl_operator(char * name)
{
  PlOperator * result = (PlOperator *) malloc(sizeof(PlOperator));
  CHECK_PTR(result);
#ifdef MEMORY_INFO
  gmemory += sizeof(PlOperator);
#endif
  if (NULL != name)
    {
      result->name = new_token_list();
      result->name->item = new_token(strlen(name)+1);
      CHECK_PTR(result->name->item);
      strcpy(result->name->item, name);
    }
  else
    {
      result->name = NULL;
    }

  result->params = NULL;
  result->preconds = NULL;
  result->effects = NULL;
  result->number_of_real_params = 0;
  result->next = NULL;
  return result;
}


CodeOperator *new_CodeOperator( void )

{

  int i;

  CodeOperator * result = ( CodeOperator * ) calloc( 1, sizeof( CodeOperator ) );
  CHECK_PTR(result);
#ifdef MEMORY_INFO
  gmemory += sizeof( CodeOperator );
#endif

  result->name = NULL;

  result->num_vars = 0;
  /* achtung: var_types und inst_table bleiben uninitialisiert!
   * --> wird nicht drauf zugegriffen, immer von vorne bis num_vars
   *
   * mir egal.
   */
  for ( i = 0; i < MAX_VARS; i++ ) {
    result->inst_table[i] = -1;
  }

  result->preconds = NULL;
  result->conditionals = NULL;

  result->number_of_real_params = 0;

  result->next = NULL;

  return result;

}


/**********************************************************************
 * Allocates new memory for a PL1 style axiom operator. Creates a
 * unique name and marks it with the hidden string.
 *
 * RETURNS a pointer to the allocated memory
 *********************************************************************/
PlOperator *
new_axiom_op_list(void)
{
  static int count;
  char * name;
  PlOperator * ret;

  /* WARNING: count should not exceed 999 */
  count++;
  name = new_token(strlen(HIDDEN_STR)+strlen(AXIOM_STR)+3+1);
  sprintf(name, "%s%s%d", HIDDEN_STR, AXIOM_STR, count);

  ret = new_pl_operator(name);
  free(name);

  return ret;
}

/*
 * memory functions for graph stuff...
 */


OpNode *new_op_node( int time, char *name, Bool is_noop,
		     BitVector *pos_precond_vector,
		     BitVector *neg_precond_vector )

{

  OpNode *tmp = ( OpNode * ) calloc ( 1, sizeof( OpNode ) );
  CHECK_PTR( tmp );
#ifdef MEMORY_INFO
  ggraph_memory += sizeof( OpNode );
#endif

  if ( name ) {
    tmp->name = copy_string( name );
  } else {
    tmp->name = NULL;
  }
  tmp->index = gops_count;

  tmp->uid_block = gops_count / gcword_size;
  tmp->uid_mask = 1 << ( gops_count % gcword_size );
  gops_count++;

  tmp->preconds = NULL;
  tmp->unconditional = NULL;
  tmp->conditionals = NULL;

  tmp->is_noop = is_noop;

  tmp->info_at[time] = new_op_level_info();

  tmp->pos_precond_vector = pos_precond_vector;
  tmp->neg_precond_vector = neg_precond_vector;

  tmp->next = NULL;

  tmp->unactivated_effects = NULL;
  tmp->thread = NULL;

  return tmp;

}

EfNode *new_ef_node( int time, OpNode *op,
		     BitVector *pos_effect_vector,
		     BitVector *neg_effect_vector )

{

  EfNode *tmp = ( EfNode * ) calloc ( 1, sizeof( EfNode ) );
  CHECK_PTR( tmp );
#ifdef MEMORY_INFO
  ggraph_memory += sizeof( EfNode );
#endif

  tmp->op = op;
  tmp->first_occurence = time;

  tmp->conditions = NULL;
  tmp->effects = NULL;

  tmp->pos_effect_vector = pos_effect_vector;
  tmp->neg_effect_vector = neg_effect_vector;

  tmp->info_at[time] = new_ef_level_info();

  tmp->next = NULL;

  return tmp;

}

FtNode *new_ft_node( int time, int index, Bool positive, Bool dummy )

{

  int i;

  FtNode *tmp = ( FtNode * ) calloc ( 1, sizeof( FtNode ) );
  CHECK_PTR( tmp );
#ifdef MEMORY_INFO
  ggraph_memory += sizeof( FtNode );
#endif

  if ( !dummy ) {
    gfacts_count++;
  }
  if ( positive ) gprint_ftnum++;

  tmp->index = index;
  tmp->uid_block = index / gcword_size;
  tmp->uid_mask = 1 << ( index % gcword_size );

  tmp->positive = positive;

  tmp->adders = NULL;
  tmp->preconds = NULL;

  tmp->noop = NULL;

  tmp->info_at[time] = new_ft_level_info( tmp );
  for ( i = 0; i < time; i++ ) {
    tmp->info_at[i] = NULL;
  }

  tmp->next = NULL;

  return tmp;

}

FtEdge *new_ft_edge( FtNode *ft )

{

  FtEdge *tmp = ( FtEdge * ) calloc ( 1, sizeof( FtEdge ) );
  CHECK_PTR( tmp );
#ifdef MEMORY_INFO
  ggraph_memory += sizeof( FtEdge );
#endif

  tmp->ft = ft;
  tmp->next = NULL;

  return tmp;

}

EfEdge *new_ef_edge( EfNode *ef )

{

  EfEdge *tmp = ( EfEdge * ) calloc ( 1, sizeof( EfEdge ) );
  CHECK_PTR( tmp );
#ifdef MEMORY_INFO
  ggraph_memory += sizeof( EfEdge );
#endif

  tmp->ef = ef;
  tmp->next = NULL;

  return tmp;

}

OpEdge *new_op_edge( OpNode *op )

{

  OpEdge *tmp = ( OpEdge * ) calloc ( 1, sizeof( OpEdge ) );
  CHECK_PTR( tmp );
#ifdef MEMORY_INFO
  ggraph_memory += sizeof( OpEdge );
#endif

  tmp->op = op;
  tmp->next = NULL;

  return tmp;

}

OpLevelInfo *new_op_level_info( void )

{

  OpLevelInfo *tmp = ( OpLevelInfo * ) calloc ( 1, sizeof( OpLevelInfo ) );
  CHECK_PTR( tmp );
#ifdef MEMORY_INFO
  ggraph_memory += sizeof( OpLevelInfo );
#endif

  tmp->is_used = 0;
  tmp->exclusives = NULL;

  return tmp;

}

EfLevelInfo *new_ef_level_info( void )

{

  EfLevelInfo *tmp = ( EfLevelInfo * ) calloc ( 1, sizeof( EfLevelInfo ) );
  CHECK_PTR( tmp );
#ifdef MEMORY_INFO
  ggraph_memory += sizeof( EfLevelInfo );
#endif

  tmp->is_dummy = FALSE;

  tmp->cond_pos_exclusives = NULL;
  tmp->cond_neg_exclusives = NULL;

  return tmp;

}

FtLevelInfo *new_ft_level_info( FtNode *ft )

{

  FtLevelInfo *tmp = ( FtLevelInfo * ) calloc ( 1, sizeof( FtLevelInfo ) );
  CHECK_PTR( tmp );
#ifdef MEMORY_INFO
  ggraph_memory += sizeof( FtLevelInfo );
#endif

  tmp->adders_pointer = NULL;
  tmp->is_dummy = FALSE;

  tmp->is_goal = 0;
  tmp->is_true = 0;
  tmp->is_goal_for[0] = NULL;

  tmp->pos_exclusives = new_excl_bit_vector( gft_vector_length );
  tmp->neg_exclusives = new_excl_bit_vector( gft_vector_length );
  /* adders erst spaeter allozieren !: groesse op - vecs unbekannt */

  /* achtung! funktioniert nur, falls bitvectoren konstant lang!! */
  if ( ft->positive ) {
    (tmp->neg_exclusives)[ft->uid_block] |= ft->uid_mask;
  } else {
    (tmp->pos_exclusives)[ft->uid_block] |= ft->uid_mask;
  }

  tmp->adders = NULL;
  tmp->adders_exclusives = NULL;

  tmp->memo_start = NULL;

  return tmp;

}


OpPair *new_op_pair( OpNode *o1, OpNode *o2 )

{

  OpPair *tmp = ( OpPair * ) calloc ( 1, sizeof( OpPair ) );
  CHECK_PTR( tmp );
#ifdef MEMORY_INFO
  gexcl_memory += sizeof( OpPair );
#endif

  tmp->o1 = o1;
  tmp->o2 = o2;

  tmp->next = NULL;

  return tmp;

}
  

FtPair *new_ft_pair( FtNode *f1, FtNode *f2 )

{

  FtPair *tmp = ( FtPair * ) calloc ( 1, sizeof( FtPair ) );
  CHECK_PTR( tmp );
#ifdef MEMORY_INFO
  gexcl_memory += sizeof( FtPair );
#endif

  tmp->f1 = f1;
  tmp->f2 = f2;

  tmp->next = NULL;

  return tmp;

}
  


MemoNode *new_memo_node( int double_index, int way )

{

  MemoNode *tmp = ( MemoNode * ) calloc( 1, sizeof( MemoNode ) );
  CHECK_PTR( tmp );
#ifdef MEMORY_INFO
  gmemo_memory += sizeof( MemoNode );
#endif

  tmp->double_index = double_index;

  tmp->sons = NULL;

  tmp->min_way = way;

  /* evtl. prev = NULL
   */
  tmp->next = NULL;

  return tmp;

}


MemoNode_table *new_memo_node_table( void )

{

  MemoNode_table *tmp = ( MemoNode_table * ) calloc( 1, sizeof( MemoNode_table ) );
  CHECK_PTR( tmp );
#ifdef MEMORY_INFO
  gmemo_memory += sizeof( MemoNode_table );
#endif

  return tmp;

}



Candidate *new_candidate( void )

{

  Candidate *tmp = ( Candidate * ) calloc( 1, sizeof( Candidate ) );
  CHECK_PTR( tmp );
#ifdef MEMORY_INFO
  gwave_memory += sizeof( Candidate );
#endif

  return tmp;

}




RelevantFact *new_RelevantFact( CodeNode *n )

{

  RelevantFact *r;
  int i;

  r = ( RelevantFact * ) calloc( 1, sizeof( RelevantFact ) );

  CHECK_PTR( r );
#ifdef MEMORY_INFO
  ggraph_memory += sizeof( Candidate );
#endif

  if ( n ) {
    r->predicate = n->predicate;
    for ( i=0; i<garity[n->predicate]; i++ ) {
      r->arguments[i] = n->arguments[i];