LCOV - code coverage report
Current view: top level - gcc - ipa-hsa.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 6 141 4.3 %
Date: 2020-04-04 11:58:09 Functions: 2 8 25.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Callgraph based analysis of static variables.
       2                 :            :    Copyright (C) 2015-2020 Free Software Foundation, Inc.
       3                 :            :    Contributed by Martin Liska <mliska@suse.cz>
       4                 :            : 
       5                 :            : This file is part of GCC.
       6                 :            : 
       7                 :            : GCC is free software; you can redistribute it and/or modify it under
       8                 :            : the terms of the GNU General Public License as published by the Free
       9                 :            : Software Foundation; either version 3, or (at your option) any later
      10                 :            : version.
      11                 :            : 
      12                 :            : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      13                 :            : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      14                 :            : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      15                 :            : for more details.
      16                 :            : 
      17                 :            : You should have received a copy of the GNU General Public License
      18                 :            : along with GCC; see the file COPYING3.  If not see
      19                 :            : <http://www.gnu.org/licenses/>.  */
      20                 :            : 
      21                 :            : /* Interprocedural HSA pass is responsible for creation of HSA clones.
      22                 :            :    For all these HSA clones, we emit HSAIL instructions and pass processing
      23                 :            :    is terminated.  */
      24                 :            : 
      25                 :            : #include "config.h"
      26                 :            : #include "system.h"
      27                 :            : #include "coretypes.h"
      28                 :            : #include "tm.h"
      29                 :            : #include "is-a.h"
      30                 :            : #include "hash-set.h"
      31                 :            : #include "vec.h"
      32                 :            : #include "tree.h"
      33                 :            : #include "tree-pass.h"
      34                 :            : #include "function.h"
      35                 :            : #include "basic-block.h"
      36                 :            : #include "gimple.h"
      37                 :            : #include "dumpfile.h"
      38                 :            : #include "gimple-pretty-print.h"
      39                 :            : #include "tree-streamer.h"
      40                 :            : #include "stringpool.h"
      41                 :            : #include "cgraph.h"
      42                 :            : #include "print-tree.h"
      43                 :            : #include "alloc-pool.h"
      44                 :            : #include "symbol-summary.h"
      45                 :            : #include "hsa-common.h"
      46                 :            : 
      47                 :            : namespace {
      48                 :            : 
      49                 :            : /* If NODE is not versionable, warn about not emiting HSAIL and return false.
      50                 :            :    Otherwise return true.  */
      51                 :            : 
      52                 :            : static bool
      53                 :          0 : check_warn_node_versionable (cgraph_node *node)
      54                 :            : {
      55                 :          0 :   if (!node->versionable)
      56                 :            :     {
      57                 :          0 :       warning_at (EXPR_LOCATION (node->decl), OPT_Whsa,
      58                 :            :                   "could not emit HSAIL for function %s: function cannot be "
      59                 :            :                   "cloned", node->dump_name ());
      60                 :          0 :       return false;
      61                 :            :     }
      62                 :            :   return true;
      63                 :            : }
      64                 :            : 
      65                 :            : /* The function creates HSA clones for all functions that were either
      66                 :            :    marked as HSA kernels or are callable HSA functions.  Apart from that,
      67                 :            :    we redirect all edges that come from an HSA clone and end in another
      68                 :            :    HSA clone to connect these two functions.  */
      69                 :            : 
      70                 :            : static unsigned int
      71                 :          0 : process_hsa_functions (void)
      72                 :            : {
      73                 :          0 :   struct cgraph_node *node;
      74                 :            : 
      75                 :          0 :   if (hsa_summaries == NULL)
      76                 :          0 :     hsa_summaries = new hsa_summary_t (symtab);
      77                 :            : 
      78                 :          0 :   FOR_EACH_DEFINED_FUNCTION (node)
      79                 :            :     {
      80                 :          0 :       hsa_function_summary *s = hsa_summaries->get (node);
      81                 :            : 
      82                 :            :       /* A linked function is skipped.  */
      83                 :          0 :       if (s != NULL && s->m_bound_function != NULL)
      84                 :          0 :         continue;
      85                 :            : 
      86                 :          0 :       if (s != NULL)
      87                 :            :         {
      88                 :          0 :           if (!check_warn_node_versionable (node))
      89                 :          0 :             continue;
      90                 :          0 :           cgraph_node *clone
      91                 :          0 :             = node->create_virtual_clone (vec <cgraph_edge *> (),
      92                 :            :                                           NULL, NULL, "hsa", 0);
      93                 :          0 :           TREE_PUBLIC (clone->decl) = TREE_PUBLIC (node->decl);
      94                 :          0 :           clone->externally_visible = node->externally_visible;
      95                 :            : 
      96                 :          0 :           clone->force_output = true;
      97                 :          0 :           hsa_summaries->link_functions (clone, node, s->m_kind, false);
      98                 :            : 
      99                 :          0 :           if (dump_file)
     100                 :          0 :             fprintf (dump_file, "Created a new HSA clone: %s, type: %s\n",
     101                 :            :                      clone->dump_name (),
     102                 :          0 :                      s->m_kind == HSA_KERNEL ? "kernel" : "function");
     103                 :            :         }
     104                 :          0 :       else if (hsa_callable_function_p (node->decl)
     105                 :            :                /* At this point, this is enough to identify clones for
     106                 :            :                   parallel, which for HSA would need to be kernels anyway.  */
     107                 :          0 :                && !DECL_ARTIFICIAL (node->decl))
     108                 :            :         {
     109                 :          0 :           if (!check_warn_node_versionable (node))
     110                 :          0 :             continue;
     111                 :          0 :           cgraph_node *clone
     112                 :          0 :             = node->create_virtual_clone (vec <cgraph_edge *> (),
     113                 :            :                                           NULL, NULL, "hsa", 0);
     114                 :          0 :           TREE_PUBLIC (clone->decl) = TREE_PUBLIC (node->decl);
     115                 :          0 :           clone->externally_visible = node->externally_visible;
     116                 :            : 
     117                 :          0 :           if (!node->local)
     118                 :          0 :             clone->force_output = true;
     119                 :          0 :           hsa_summaries->link_functions (clone, node, HSA_FUNCTION, false);
     120                 :            : 
     121                 :          0 :           if (dump_file)
     122                 :          0 :             fprintf (dump_file, "Created a new HSA function clone: %s\n",
     123                 :            :                      clone->dump_name ());
     124                 :            :         }
     125                 :            :     }
     126                 :            : 
     127                 :            :   /* Redirect all edges that are between HSA clones.  */
     128                 :          0 :   FOR_EACH_DEFINED_FUNCTION (node)
     129                 :            :     {
     130                 :          0 :       cgraph_edge *e = node->callees;
     131                 :            : 
     132                 :          0 :       while (e)
     133                 :            :         {
     134                 :          0 :           hsa_function_summary *src = hsa_summaries->get (node);
     135                 :          0 :           if (src != NULL && src->m_gpu_implementation_p)
     136                 :            :             {
     137                 :          0 :               hsa_function_summary *dst = hsa_summaries->get (e->callee);
     138                 :          0 :               if (dst != NULL && !dst->m_gpu_implementation_p)
     139                 :            :                 {
     140                 :          0 :                   e->redirect_callee (dst->m_bound_function);
     141                 :          0 :                   if (dump_file)
     142                 :          0 :                     fprintf (dump_file,
     143                 :            :                              "Redirecting edge to HSA function: %s->%s\n",
     144                 :          0 :                              e->caller->dump_name (),
     145                 :          0 :                              e->callee->dump_name ());
     146                 :            :                 }
     147                 :            :             }
     148                 :            : 
     149                 :          0 :           e = e->next_callee;
     150                 :            :         }
     151                 :            :     }
     152                 :            : 
     153                 :          0 :   return 0;
     154                 :            : }
     155                 :            : 
     156                 :            : /* Iterate all HSA functions and stream out HSA function summary.  */
     157                 :            : 
     158                 :            : static void
     159                 :          0 : ipa_hsa_write_summary (void)
     160                 :            : {
     161                 :          0 :   struct bitpack_d bp;
     162                 :          0 :   struct cgraph_node *node;
     163                 :          0 :   struct output_block *ob;
     164                 :          0 :   unsigned int count = 0;
     165                 :          0 :   lto_symtab_encoder_iterator lsei;
     166                 :          0 :   lto_symtab_encoder_t encoder;
     167                 :            : 
     168                 :          0 :   if (!hsa_summaries)
     169                 :          0 :     return;
     170                 :            : 
     171                 :          0 :   ob = create_output_block (LTO_section_ipa_hsa);
     172                 :          0 :   encoder = ob->decl_state->symtab_node_encoder;
     173                 :          0 :   ob->symbol = NULL;
     174                 :          0 :   for (lsei = lsei_start_function_in_partition (encoder); !lsei_end_p (lsei);
     175                 :          0 :        lsei_next_function_in_partition (&lsei))
     176                 :            :     {
     177                 :          0 :       node = lsei_cgraph_node (lsei);
     178                 :          0 :       hsa_function_summary *s = hsa_summaries->get (node);
     179                 :            : 
     180                 :          0 :       if (s != NULL)
     181                 :          0 :         count++;
     182                 :            :     }
     183                 :            : 
     184                 :          0 :   streamer_write_uhwi (ob, count);
     185                 :            : 
     186                 :            :   /* Process all of the functions.  */
     187                 :          0 :   for (lsei = lsei_start_function_in_partition (encoder); !lsei_end_p (lsei);
     188                 :          0 :        lsei_next_function_in_partition (&lsei))
     189                 :            :     {
     190                 :          0 :       node = lsei_cgraph_node (lsei);
     191                 :          0 :       hsa_function_summary *s = hsa_summaries->get (node);
     192                 :            : 
     193                 :          0 :       if (s != NULL)
     194                 :            :         {
     195                 :          0 :           encoder = ob->decl_state->symtab_node_encoder;
     196                 :          0 :           int node_ref = lto_symtab_encoder_encode (encoder, node);
     197                 :          0 :           streamer_write_uhwi (ob, node_ref);
     198                 :            : 
     199                 :          0 :           bp = bitpack_create (ob->main_stream);
     200                 :          0 :           bp_pack_value (&bp, s->m_kind, 2);
     201                 :          0 :           bp_pack_value (&bp, s->m_gpu_implementation_p, 1);
     202                 :          0 :           bp_pack_value (&bp, s->m_bound_function != NULL, 1);
     203                 :          0 :           streamer_write_bitpack (&bp);
     204                 :          0 :           if (s->m_bound_function)
     205                 :          0 :             stream_write_tree (ob, s->m_bound_function->decl, true);
     206                 :            :         }
     207                 :            :     }
     208                 :            : 
     209                 :          0 :   streamer_write_char_stream (ob->main_stream, 0);
     210                 :          0 :   produce_asm (ob, NULL);
     211                 :          0 :   destroy_output_block (ob);
     212                 :            : }
     213                 :            : 
     214                 :            : /* Read section in file FILE_DATA of length LEN with data DATA.  */
     215                 :            : 
     216                 :            : static void
     217                 :          0 : ipa_hsa_read_section (struct lto_file_decl_data *file_data, const char *data,
     218                 :            :                        size_t len)
     219                 :            : {
     220                 :          0 :   const struct lto_function_header *header
     221                 :            :     = (const struct lto_function_header *) data;
     222                 :          0 :   const int cfg_offset = sizeof (struct lto_function_header);
     223                 :          0 :   const int main_offset = cfg_offset + header->cfg_size;
     224                 :          0 :   const int string_offset = main_offset + header->main_size;
     225                 :          0 :   class data_in *data_in;
     226                 :          0 :   unsigned int i;
     227                 :          0 :   unsigned int count;
     228                 :            : 
     229                 :          0 :   lto_input_block ib_main ((const char *) data + main_offset,
     230                 :          0 :                            header->main_size, file_data->mode_table);
     231                 :            : 
     232                 :          0 :   data_in
     233                 :          0 :     = lto_data_in_create (file_data, (const char *) data + string_offset,
     234                 :          0 :                           header->string_size, vNULL);
     235                 :          0 :   count = streamer_read_uhwi (&ib_main);
     236                 :            : 
     237                 :          0 :   for (i = 0; i < count; i++)
     238                 :            :     {
     239                 :          0 :       unsigned int index;
     240                 :          0 :       struct cgraph_node *node;
     241                 :          0 :       lto_symtab_encoder_t encoder;
     242                 :            : 
     243                 :          0 :       index = streamer_read_uhwi (&ib_main);
     244                 :          0 :       encoder = file_data->symtab_node_encoder;
     245                 :          0 :       node = dyn_cast<cgraph_node *> (lto_symtab_encoder_deref (encoder,
     246                 :            :                                                                 index));
     247                 :          0 :       gcc_assert (node->definition);
     248                 :          0 :       hsa_function_summary *s = hsa_summaries->get_create (node);
     249                 :            : 
     250                 :          0 :       struct bitpack_d bp = streamer_read_bitpack (&ib_main);
     251                 :          0 :       s->m_kind = (hsa_function_kind) bp_unpack_value (&bp, 2);
     252                 :          0 :       s->m_gpu_implementation_p = bp_unpack_value (&bp, 1);
     253                 :          0 :       bool has_tree = bp_unpack_value (&bp, 1);
     254                 :            : 
     255                 :          0 :       if (has_tree)
     256                 :            :         {
     257                 :          0 :           tree decl = stream_read_tree (&ib_main, data_in);
     258                 :          0 :           s->m_bound_function = cgraph_node::get_create (decl);
     259                 :            :         }
     260                 :            :     }
     261                 :          0 :   lto_free_section_data (file_data, LTO_section_ipa_hsa, NULL, data,
     262                 :            :                          len);
     263                 :          0 :   lto_data_in_delete (data_in);
     264                 :          0 : }
     265                 :            : 
     266                 :            : /* Load streamed HSA functions summary and assign the summary to a function.  */
     267                 :            : 
     268                 :            : static void
     269                 :          0 : ipa_hsa_read_summary (void)
     270                 :            : {
     271                 :          0 :   struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
     272                 :          0 :   struct lto_file_decl_data *file_data;
     273                 :          0 :   unsigned int j = 0;
     274                 :            : 
     275                 :          0 :   if (hsa_summaries == NULL)
     276                 :          0 :     hsa_summaries = new hsa_summary_t (symtab);
     277                 :            : 
     278                 :          0 :   while ((file_data = file_data_vec[j++]))
     279                 :            :     {
     280                 :          0 :       size_t len;
     281                 :          0 :       const char *data
     282                 :          0 :         = lto_get_summary_section_data (file_data, LTO_section_ipa_hsa, &len);
     283                 :          0 :       if (data)
     284                 :          0 :         ipa_hsa_read_section (file_data, data, len);
     285                 :            :     }
     286                 :          0 : }
     287                 :            : 
     288                 :            : const pass_data pass_data_ipa_hsa =
     289                 :            : {
     290                 :            :   IPA_PASS, /* type */
     291                 :            :   "hsa", /* name */
     292                 :            :   OPTGROUP_OMP, /* optinfo_flags */
     293                 :            :   TV_IPA_HSA, /* tv_id */
     294                 :            :   0, /* properties_required */
     295                 :            :   0, /* properties_provided */
     296                 :            :   0, /* properties_destroyed */
     297                 :            :   0, /* todo_flags_start */
     298                 :            :   TODO_dump_symtab, /* todo_flags_finish */
     299                 :            : };
     300                 :            : 
     301                 :            : class pass_ipa_hsa : public ipa_opt_pass_d
     302                 :            : {
     303                 :            : public:
     304                 :     200773 :   pass_ipa_hsa (gcc::context *ctxt)
     305                 :            :     : ipa_opt_pass_d (pass_data_ipa_hsa, ctxt,
     306                 :            :                       NULL, /* generate_summary */
     307                 :            :                       ipa_hsa_write_summary, /* write_summary */
     308                 :            :                       ipa_hsa_read_summary, /* read_summary */
     309                 :            :                       ipa_hsa_write_summary, /* write_optimization_summary */
     310                 :            :                       ipa_hsa_read_summary, /* read_optimization_summary */
     311                 :            :                       NULL, /* stmt_fixup */
     312                 :            :                       0, /* function_transform_todo_flags_start */
     313                 :            :                       NULL, /* function_transform */
     314                 :     401546 :                       NULL) /* variable_transform */
     315                 :            :     {}
     316                 :            : 
     317                 :            :   /* opt_pass methods: */
     318                 :            :   virtual bool gate (function *);
     319                 :            : 
     320                 :          0 :   virtual unsigned int execute (function *) { return process_hsa_functions (); }
     321                 :            : 
     322                 :            : }; // class pass_ipa_reference
     323                 :            : 
     324                 :            : bool
     325                 :     437522 : pass_ipa_hsa::gate (function *)
     326                 :            : {
     327                 :     437522 :   return hsa_gen_requested_p ();
     328                 :            : }
     329                 :            : 
     330                 :            : } // anon namespace
     331                 :            : 
     332                 :            : ipa_opt_pass_d *
     333                 :     200773 : make_pass_ipa_hsa (gcc::context *ctxt)
     334                 :            : {
     335                 :     200773 :   return new pass_ipa_hsa (ctxt);
     336                 :            : }

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.