identification.c File Reference

#include "safescale.h"

Include dependency graph for identification.c:

Go to the source code of this file.

Functions
static void	search_sequence_containing (statement s, void *a_context)
static statement	sequence_statement_containing (statement root_statement, statement searched_stat)
static bool	statement_is_contained_in_a_sequence_p (statement root_statement, statement searched_stat)
static void	check_if_statement_contains_comment (statement s, void *a_context)
	Add in the statement containing comments in the list of statements. More...
static list	get_statements_with_comments_containing (string comment_portion, statement stat)
	Build a list with statements containing comments. More...
static string	get_function_name_by_searching_tag (statement stat, string tag)
	Return the identified function name of the externalized portion of code by searching comment matching tag. More...
static void	clean_statement_from_tags (string comment_portion, statement stat)
static void	remove_begin_tag (statement stat, string function_name)
	Remove begin tag for a given statement and function. More...
static void	remove_end_tag (statement stat, string function_name)
	Remove end tag for given statement and function. More...
static statement	isolate_code_portion (statement begin_tag_statement, statement end_tag_statement, statement sequence_statement)
	Transform a statement in a sequence statement with a single statement which is the embedded statement that will be distributed. More...
static list	identify_statements_to_distribute (statement module_stat)
	Return a list of statements that are marked for externalization. More...
bool	safescale_distributor_init (const char *module_name)
	Main phase for block code detection. More...

Function Documentation

check_if_statement_contains_comment()

static void check_if_statement_contains_comment ( statement  s, void *  a_context  )

static

Add in the statement containing comments in the list of statements.

Definition at line 78 of file identification.c.

{
  statement_checking_context* context = (statement_checking_context*) a_context;
  string comments;
 
  if (!statement_with_empty_comment_p(s))
  {    
    comments = statement_comments(s);
    
    if (strstr(comments, context->searched_string) != NULL) 
    {
      context->list_of_statements = CONS(STATEMENT, s, context->list_of_statements);
    }
  }
}

References CONS, STATEMENT, statement_comments, and statement_with_empty_comment_p().

Referenced by get_statements_with_comments_containing().

Here is the call graph for this function:

Here is the caller graph for this function:

clean_statement_from_tags()

static void clean_statement_from_tags ( string  comment_portion, statement  stat  )

static

Definition at line 202 of file identification.c.

{
  if (!statement_with_empty_comment_p(stat)) 
  {
    string new_comments = NULL;
 
    string searched_string = strdup(comment_portion);
    searched_string[strcspn(comment_portion, "%s")] = '\0';
    string comments = strdup(statement_comments(stat));
    char * next_line = strtok(comments, "\n");
 
    if (next_line != NULL) 
    {
      do 
      {
        if (strstr(next_line, searched_string) == NULL) 
        {
          if (new_comments != NULL) 
          {
            new_comments = strdup(concatenate(new_comments, next_line, "\n", NULL));
          }
          else 
          {
            new_comments = strdup(concatenate("", next_line, "\n", NULL));
          }
        }
 
        next_line = strtok(NULL, "\n");
      }
      while (next_line != NULL);
    }
    
    if (new_comments != NULL) 
    {
      statement_comments(stat) = new_comments;
    }
    else 
    {
      statement_comments(stat) = empty_comments;
      free(new_comments);
    }
    free(searched_string);
    free(comments);
  }
}

References concatenate(), empty_comments, free(), statement_comments, statement_with_empty_comment_p(), and strdup().

Referenced by remove_begin_tag(), and remove_end_tag().

Here is the call graph for this function:

Here is the caller graph for this function:

get_function_name_by_searching_tag()

static string get_function_name_by_searching_tag ( statement  stat, string  tag  )

static

Return the identified function name of the externalized portion of code by searching comment matching tag.

Definition at line 142 of file identification.c.

{
  string comments = NULL;
  string searched_string;
  string comment_portion = strdup(tag);
  char* function_name = NULL;
  char* next_line;
  instruction i = statement_instruction(stat);
  
  pips_debug(5, "BEGIN get_function_name_by_searching_tag [%s] on \n", tag);
 
  ifdebug(5) 
  {
    print_statement(stat);
  }
 
  if (instruction_tag(i) == is_instruction_sequence) 
  {
    stat = STATEMENT(gen_nth(0, sequence_statements(instruction_sequence(i))));
  }
  
  if (!statement_with_empty_comment_p(stat)) 
  {
    searched_string = strdup(comment_portion);
    searched_string[strcspn(comment_portion, "%s")] = '\0';
    comments = strdup(statement_comments(stat));
    next_line = strtok(comments, "\n");
  
    if (next_line != NULL) 
    {
      do 
      {
        string first_occurence = strstr(next_line, searched_string);
 
        if (first_occurence != NULL) 
        {
          function_name = malloc(256);
          sscanf(first_occurence, comment_portion, function_name);
          pips_debug(5, "Found function: [%s]\n", function_name);
        }
 
        next_line = strtok(NULL, "\n");
      }
      while (next_line != NULL);
    }
  }
 
  free(comment_portion);
  if (comments)
    free(comments);
 
  pips_debug(5, "END get_function_name_by_searching_tag [%s] on \n", tag);
 
  return function_name;
}

References free(), gen_nth(), ifdebug, instruction_sequence, instruction_tag, is_instruction_sequence, malloc(), pips_debug, print_statement(), sequence_statements, STATEMENT, statement_comments, statement_instruction, statement_with_empty_comment_p(), and strdup().

Referenced by identify_statements_to_distribute(), and isolate_code_portion().

Here is the call graph for this function:

Here is the caller graph for this function:

get_statements_with_comments_containing()

static list get_statements_with_comments_containing ( string  comment_portion, statement  stat  )

static

Build a list with statements containing comments.

Set searched string

Reset and get list of statements

Definition at line 98 of file identification.c.

{
  string percent;
  statement_checking_context context;
 
  ifdebug(5)
  {
    pips_debug(5, "Comment portion: %s\n", comment_portion);
    pips_debug(5, "Statement:\n");
    print_statement(stat);
  }
 
  /* Set searched string */
  context.searched_string = strdup(comment_portion);
  percent = strstr(context.searched_string, "%s");
 
  pips_debug(5, "Percent: %s\n", percent);
 
  if (percent == NULL)
    pips_user_error("Malformed statement comment to search. Should be of the form 'BLAH_%%s'\n");
 
  *percent = '\0';
 
  /* Reset and get list of statements */
  context.list_of_statements = NIL;
  
  ifdebug(5) 
  {
    pips_debug(5, "Searching statements with comments: %s\n", context.searched_string);      
    pips_debug(5, "In statement:\n");      
    print_statement(stat);
  }
 
  gen_context_recurse(stat, &context, statement_domain, gen_true2, check_if_statement_contains_comment);
  
  free(context.searched_string);
 
  return context.list_of_statements;  
}

References check_if_statement_contains_comment(), free(), gen_context_recurse, gen_true2(), ifdebug, NIL, pips_debug, pips_user_error, print_statement(), statement_domain, and strdup().

Referenced by identify_statements_to_distribute().

Here is the call graph for this function:

Here is the caller graph for this function:

identify_statements_to_distribute()

static list identify_statements_to_distribute ( statement  module_stat )

static

Return a list of statements that are marked for externalization.

Restructure code to avoid imbricated sequences if some portions are found to allow more than one INIT

Identify statements containing a begin tag

Check all statements are contained in a sequence

Definition at line 399 of file identification.c.

{
  list statements_containing_begin_tag;
  list statements_contained_in_a_sequence = NIL;
  list statements_to_distribute = NIL;
  
  /* Restructure code to avoid imbricated sequences if some portions are found to allow more than one INIT */
  simple_restructure_statement(module_stat);
 
  /* Identify statements containing a begin tag */
  statements_containing_begin_tag = get_statements_with_comments_containing(EXTERNALIZED_CODE_PRAGMA_BEGIN, module_stat); 
  
  /* Check all statements are contained in a sequence */
  MAP(STATEMENT, s, {
                      ifdebug(5) 
                      {
                        pips_debug(5, "Potential externalizable statement:\n");
                        print_statement(s);
                      }
 
                      if (statement_is_contained_in_a_sequence_p(module_stat,s)) 
                      {
                        statements_contained_in_a_sequence = CONS(STATEMENT, s, statements_contained_in_a_sequence);
                      }
                      else 
                      {
                        pips_user_warning("Malformed externalized code portion identified. Ignored.\n");
                      }
                    }, statements_containing_begin_tag);
  
  /* */
  MAP(STATEMENT, s, {
                      statement sequence_statement;
                      string function_name;
                      list potential_end_statement = NIL;
 
                      sequence_statement = sequence_statement_containing(module_stat, s);
 
                      pips_debug(5, "Potential externalizable statement contained in a sequence \n");
                      print_statement(s);
 
                      function_name = get_function_name_by_searching_tag(s, EXTERNALIZED_CODE_PRAGMA_BEGIN);
 
                      if (function_name != NULL) 
                      {
                        pips_debug(5, "Name: [%s] \n", function_name);
 
                        potential_end_statement = get_statements_with_comments_containing(EXTERNALIZED_CODE_PRAGMA_END, sequence_statement);
 
                      if (gen_length(potential_end_statement) == 1) 
                      {
                        statement begin_tag_statement = s;
                        statement end_tag_statement = STATEMENT(gen_nth(0, potential_end_statement));
                        statement container_of_end_tag_statement = sequence_statement_containing(sequence_statement, end_tag_statement);
 
                        if (container_of_end_tag_statement == sequence_statement) 
                        {
                          statement externalized_code = isolate_code_portion(begin_tag_statement, end_tag_statement, sequence_statement);
 
                          statements_to_distribute = CONS(STATEMENT, externalized_code, statements_to_distribute);
                        }
                        else 
                        {
                          pips_user_warning("Malformed externalized code portion identified [%s]. End tag found at a bad place!!!. Ignored.\n", function_name);
                        }
                      }
                      else 
                      {
                        pips_user_warning("Malformed externalized code portion identified [%s]. %d end tags found!!!. Ignored.\n", function_name, gen_length(potential_end_statement));
                      }
                    }
                    else 
                    {
                      pips_user_warning("Malformed externalized code portion identified [Unnamed]!!!. Ignored.\n");
                    }
                  }, statements_contained_in_a_sequence);
 
  return statements_to_distribute;
}

References CONS, EXTERNALIZED_CODE_PRAGMA_BEGIN, EXTERNALIZED_CODE_PRAGMA_END, gen_length(), gen_nth(), get_function_name_by_searching_tag(), get_statements_with_comments_containing(), ifdebug, isolate_code_portion(), MAP, NIL, pips_debug, pips_user_warning, print_statement(), sequence_statement_containing(), simple_restructure_statement(), STATEMENT, and statement_is_contained_in_a_sequence_p().

Referenced by safescale_distributor_init().

Here is the call graph for this function:

Here is the caller graph for this function:

isolate_code_portion()

static statement isolate_code_portion ( statement  begin_tag_statement, statement  end_tag_statement, statement  sequence_statement  )

static

Transform a statement in a sequence statement with a single statement which is the embedded statement that will be distributed.

Count the number of statements to isolate in a single statement

Insert an analyzed tag

Build a new isolated sequence statement

Build a new sequence containing isolated sequence statement

Rebuild the sequence in the good order

Nothing to do, the code is already isolated !

Definition at line 280 of file identification.c.

{
  instruction i = statement_instruction(sequence_statement);
  list seq_stats = sequence_statements(instruction_sequence(i));
  list new_seq_stats = NIL;
  list isolated_seq_stats = NIL;
  bool statement_to_isolate = false;
  int nb_of_statements_to_isolate = 0;
  string function_name = get_function_name_by_searching_tag(begin_tag_statement, EXTERNALIZED_CODE_PRAGMA_BEGIN);
 
  pips_assert("sequence_statement is a sequence", instruction_tag(i) == is_instruction_sequence);
  pips_assert("function_name is not NULL", function_name != NULL);
 
  /* Count the number of statements to isolate in a single statement */
  MAP(STATEMENT, s, {
                      if ((statement_to_isolate && (s != end_tag_statement)) || ((!statement_to_isolate) && (s == begin_tag_statement))) 
                      {
                        nb_of_statements_to_isolate++;
                        isolated_seq_stats = CONS(STATEMENT, s, isolated_seq_stats);
                      }
 
                      if (statement_to_isolate && (s == end_tag_statement)) 
                      {
                        statement_to_isolate = false;
                      }
 
                      if ((!statement_to_isolate) && (s == begin_tag_statement)) 
                      {
                        statement_to_isolate = true;
                      }    
                    }, seq_stats);
 
  remove_begin_tag(begin_tag_statement, function_name);
  remove_end_tag(end_tag_statement, function_name);
 
  /* Insert an analyzed tag */
  {
    char *new_tag = malloc(256);
 
    sprintf(new_tag, strdup(concatenate("\n", EXTERNALIZED_CODE_PRAGMA_ANALYZED_PREFIX_TOP, EXTERNALIZED_CODE_PRAGMA_ANALYZED_TOP, "\n", NULL)), function_name, nb_of_statements_to_isolate);
    insert_comments_to_statement(begin_tag_statement, new_tag);
  }
 
  pips_debug(5, "Found %d statement to isolate\n", nb_of_statements_to_isolate);      
 
  if (nb_of_statements_to_isolate > 1) 
  {
    /* Build a new isolated sequence statement */    
    sequence new_sequence = make_sequence(gen_nreverse(isolated_seq_stats));
    instruction sequence_instruction = make_instruction(is_instruction_sequence, new_sequence);
    statement returned_statement = make_statement (entity_empty_label(),
                                                   statement_number(sequence_statement),
                                                   statement_ordering(sequence_statement),
                                                   empty_comments,
                                                   sequence_instruction,
                                                   NIL,
                                                   NULL,
                                                   statement_extensions (sequence_statement), make_synchronization_none());
    bool isolated_seq_stats_is_inserted = false;
    
    /* Build a new sequence containing isolated sequence statement */
    MAP(STATEMENT, s, {
                        if ((statement_to_isolate && (s != end_tag_statement)) || ((!statement_to_isolate) && (s == begin_tag_statement))) 
                        {
                          if (!isolated_seq_stats_is_inserted) 
                          {
                            new_seq_stats = CONS(STATEMENT, returned_statement, new_seq_stats);
                            isolated_seq_stats_is_inserted = true;
                          }
                        }
                        else 
                        {
                          new_seq_stats = CONS(STATEMENT, s, new_seq_stats);
                        }
 
                        if (statement_to_isolate && (s == end_tag_statement)) 
                        {
                          statement_to_isolate = false;
                        }
 
                        if ((!statement_to_isolate) && (s == begin_tag_statement)) 
                        {
                          statement_to_isolate = true;
                        }
                      }, seq_stats); 
 
    /* Rebuild the sequence in the good order */
    sequence_statements(instruction_sequence(i)) = gen_nreverse(new_seq_stats);
 
    ifdebug(5) 
    {
      pips_debug(5,"Isolating and returning statement:\n");
      print_statement(returned_statement);
    }
 
    return returned_statement;
  }
  else if (nb_of_statements_to_isolate == 1) 
  {
    /* Nothing to do, the code is already isolated ! */
    ifdebug(5) 
    {
      pips_debug(5,"Isolating and returning statement:\n");
      print_statement(begin_tag_statement);
    }
 
    return begin_tag_statement;
  }
  else 
  {
    pips_user_warning("Malformed externalized code portion identified. No operation to do. Ignored.\n");
    return NULL;
  }
}

References concatenate(), CONS, empty_comments, entity_empty_label(), EXTERNALIZED_CODE_PRAGMA_ANALYZED_PREFIX_TOP, EXTERNALIZED_CODE_PRAGMA_ANALYZED_TOP, EXTERNALIZED_CODE_PRAGMA_BEGIN, gen_nreverse(), get_function_name_by_searching_tag(), ifdebug, insert_comments_to_statement(), instruction_sequence, instruction_tag, is_instruction_sequence, make_instruction(), make_sequence(), make_statement(), make_synchronization_none(), malloc(), MAP, NIL, pips_assert, pips_debug, pips_user_warning, print_statement(), remove_begin_tag(), remove_end_tag(), sequence_statements, STATEMENT, statement_extensions, statement_instruction, statement_number, statement_ordering, and strdup().

Referenced by identify_statements_to_distribute().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_begin_tag()

static void remove_begin_tag ( statement  stat, string  function_name  )

static

Remove begin tag for a given statement and function.

Definition at line 252 of file identification.c.

{
  char* removed_tag = malloc(256);
 
  sprintf(removed_tag, EXTERNALIZED_CODE_PRAGMA_BEGIN, function_name);
  pips_debug(2, "REMOVE %s from\n", removed_tag);
  print_statement(stat);
  clean_statement_from_tags(removed_tag, stat);
}

References clean_statement_from_tags(), EXTERNALIZED_CODE_PRAGMA_BEGIN, malloc(), pips_debug, and print_statement().

Referenced by isolate_code_portion().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_end_tag()

static void remove_end_tag ( statement  stat, string  function_name  )

static

Remove end tag for given statement and function.

Definition at line 266 of file identification.c.

{
  char* removed_tag = malloc(256);
 
  sprintf(removed_tag, EXTERNALIZED_CODE_PRAGMA_END, function_name);
  pips_debug(2, "REMOVE %s from\n", removed_tag);
  print_statement(stat);
  clean_statement_from_tags(removed_tag, stat);
}

References clean_statement_from_tags(), EXTERNALIZED_CODE_PRAGMA_END, malloc(), pips_debug, and print_statement().

Referenced by isolate_code_portion().

Here is the call graph for this function:

Here is the caller graph for this function:

safescale_distributor_init()

bool safescale_distributor_init

(

const char *

module_name

)

Main phase for block code detection.

identification.c

Get the resources

Doi the job

Reorder the module because new statements have been added

Update/release resources

Parameters

module_name

odule_name

Definition at line 483 of file identification.c.

{
  /* Get the resources */
  statement stat = (statement) db_get_memory_resource(DBR_CODE, module_name, true);
  
 
  set_current_module_statement(stat);
  set_current_module_entity(module_name_to_entity(module_name));
 
  debug_on("SAFESCALE_DISTRIBUTOR_DEBUG_LEVEL");
 
  /* Doi the job */
  pips_debug(2, "BEGIN of SAFESCALE_DISTRIBUTOR_INIT\n");
  identify_statements_to_distribute(stat);
  pips_debug(2, "END of SAFESCALE_DISTRIBUTOR_INIT\n");
 
  pips_assert("Statement structure is consistent after SAFESCALE_DISTRIBUTOR_INIT", gen_consistent_p((gen_chunk*) stat));             
  pips_assert("Statement is consistent after SAFESCALE_DISTRIBUTOR_INIT", statement_consistent_p(stat));
 
  /* Reorder the module because new statements have been added */  
  module_reorder(stat);
  DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name, stat);
  DB_PUT_MEMORY_RESOURCE(DBR_CALLEES, module_name, compute_callees(stat));
  
  /* Update/release resources */
  reset_current_module_statement();
  reset_current_module_entity();
  
  debug_off();
  
  return true;
}

References compute_callees(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, gen_consistent_p(), identify_statements_to_distribute(), module_name(), module_name_to_entity(), module_reorder(), pips_assert, pips_debug, reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), set_current_module_statement(), and statement_consistent_p().

Here is the call graph for this function:

search_sequence_containing()

static void search_sequence_containing ( statement  s, void *  a_context  )

static

Definition at line 33 of file identification.c.

{
  sequence_searching_context* context = (sequence_searching_context*) a_context;
  instruction i = statement_instruction(s);
  
  if (instruction_tag(i) == is_instruction_sequence) 
  {
    MAP(STATEMENT, s2, {
                         if (s2 == context->searched_statement) 
                         {
                           context->found_sequence_statement = s;
                         }
                       }, sequence_statements(instruction_sequence(i)));
  }
}

References instruction_sequence, instruction_tag, is_instruction_sequence, MAP, sequence_statements, STATEMENT, and statement_instruction.

Referenced by sequence_statement_containing().

Here is the caller graph for this function:

sequence_statement_containing()

static statement sequence_statement_containing ( statement  root_statement, statement  searched_stat  )

static

Definition at line 53 of file identification.c.

{
  sequence_searching_context context;
 
  context.searched_statement = searched_stat;
  context.found_sequence_statement = NULL;
 
  gen_context_recurse(root_statement, &context, statement_domain, gen_true2, search_sequence_containing);
 
  return context.found_sequence_statement;
}

References gen_context_recurse, gen_true2(), search_sequence_containing(), and statement_domain.

Referenced by identify_statements_to_distribute(), and statement_is_contained_in_a_sequence_p().

Here is the call graph for this function:

Here is the caller graph for this function:

statement_is_contained_in_a_sequence_p()

static bool statement_is_contained_in_a_sequence_p ( statement  root_statement, statement  searched_stat  )

static

Definition at line 69 of file identification.c.

{
  return (sequence_statement_containing(root_statement, searched_stat) != NULL);
}

References sequence_statement_containing().

Referenced by identify_statements_to_distribute().

Here is the call graph for this function:

Here is the caller graph for this function: