[GPGPU] Do not create copy statements when targetting managed memory

[grosser]

Summary

They are not used and consequently do not even need to be computed. This reduces
the overall compile time for our kernel from 1m33s to 17s.

[bollu]

LGTM

lib/CodeGen/PPCGCodeGeneration.cpp

3143 ↗

(On Diff #111650)

Consider either:

Schedule = map_to_device(PPCGGen, Schedule, /*to_from_device=*/ !PollyManagedMemory);

or

const bool CreateTransferToFromDevice = !PollyManagedMemory;
Schedule = map_to_device(PPCGGen, Schedule, CreateTransferToFromDevice);

lib/External/ppcg/gpu.c

5280 ↗

(On Diff #111650)

Could you please document why this is necessary in the comment above?

5683 ↗

(On Diff #111650)

Personal opinion: I don't like magic constants. Consider:

const int create_transfer_to_from_device = 1;
schedule = map_to_device(gen, schedule, create_transfer_to_from_device);

or something along those lines.

[grosser]

Thanks for the comments. Will address them and commit.

polly/trunk/lib/CodeGen/PPCGCodeGeneration.cpp

gpu_gen *generateGPU(ppcg_scop *PPCGScop, gpu_prog *PPCGProg) {
     Schedule =
         isl_schedule_align_params(Schedule, S->getFullParamSpace().release());
 
     if (!has_permutable || has_permutable < 0) {
       Schedule = isl_schedule_free(Schedule);
       DEBUG(dbgs() << getUniqueScopName(S)
                    << " does not have permutable bands. Bailing out\n";);
     } else {
-      Schedule = map_to_device(PPCGGen, Schedule);
+      const bool CreateTransferToFromDevice = !PollyManagedMemory;
+      Schedule = map_to_device(PPCGGen, Schedule, CreateTransferToFromDevice);
       PPCGGen->tree = generate_code(PPCGGen, isl_schedule_copy(Schedule));
     }
 
     if (DumpSchedule) {
       isl_printer *P = isl_printer_to_str(S->getIslCtx());
       P = isl_printer_set_yaml_style(P, ISL_YAML_STYLE_BLOCK);
       P = isl_printer_print_str(P, "Schedule\n");
       P = isl_printer_print_str(P, "========\n");

polly/trunk/lib/External/ppcg/gpu.h

 
 __isl_give isl_schedule_node *gpu_create_kernel(struct gpu_gen *gen,
   __isl_take isl_schedule_node *node, int scale,
   __isl_keep isl_multi_val *sizes);
 
 __isl_give isl_schedule *get_schedule(struct gpu_gen *gen);
 int has_any_permutable_node(__isl_keep isl_schedule *schedule);
 __isl_give isl_schedule *map_to_device(struct gpu_gen *gen,
-                                       __isl_take isl_schedule *schedule);
+                                       __isl_take isl_schedule *schedule,
+                                      int to_from_device);
 __isl_give isl_ast_node *generate_code(struct gpu_gen *gen,
                                        __isl_take isl_schedule *schedule);
 
 __isl_give isl_union_set *compute_may_persist(struct gpu_prog *prog);
 void collect_references(struct gpu_prog *prog, struct gpu_array_info *array);
 #endif

polly/trunk/lib/External/ppcg/gpu.c

  * are separated from the other children and are not mapped to
  * the device.
  *
  * The GPU code is generated in a context where at least one
  * statement instance is executed.  The corresponding guard is inserted
  * around the entire schedule.
  */
 __isl_give isl_schedule *map_to_device(struct gpu_gen *gen,
-  __isl_take isl_schedule *schedule)
+  __isl_take isl_schedule *schedule, int to_from_device)
 {
   isl_schedule_node *node;
   isl_set *context;
   isl_set *guard;
   isl_union_set *domain;
   isl_union_map *prefix;
   isl_union_pw_multi_aff *contraction;
   struct gpu_prog *prog;
__isl_give isl_schedule *map_to_device(struct gpu_gen *gen,
   domain = isl_schedule_node_get_domain(node);
   contraction = isl_schedule_node_get_subtree_contraction(node);
   domain = isl_union_set_preimage_union_pw_multi_aff(domain,
             isl_union_pw_multi_aff_copy(contraction));
   prefix = isl_schedule_node_get_prefix_schedule_union_map(node);
   prefix = isl_union_map_preimage_domain_union_pw_multi_aff(prefix,
             contraction);
   node = mark_kernels(gen, node);
+  if (to_from_device) {
     node = add_to_from_device(node, domain, prefix, gen->prog);
+  } else {
+    isl_union_set_free(domain);
+    isl_union_map_free(prefix);
+  }
   node = isl_schedule_node_root(node);
   node = isl_schedule_node_child(node, 0);
   node = isl_schedule_node_child(node, 0);
   node = isl_schedule_node_insert_guard(node, guard);
   node = isl_schedule_node_child(node, 0);
   node = add_init_clear_device(node);
   schedule = isl_schedule_node_get_schedule(node);
   isl_schedule_node_free(node);
static __isl_give isl_printer *generate(__isl_take isl_printer *p,
   any_permutable = has_any_permutable_node(schedule);
   if (any_permutable < 0 || !any_permutable) {
     if (any_permutable < 0)
       p = isl_printer_free(p);
     else
       p = print_cpu(p, scop, options);
     isl_schedule_free(schedule);
   } else {
-    schedule = map_to_device(gen, schedule);
+    const int create_to_from_device = 1;
+    schedule = map_to_device(gen, schedule, create_to_from_device);
     gen->tree = generate_code(gen, schedule);
     p = ppcg_set_macro_names(p);
     p = ppcg_print_exposed_declarations(p, prog->scop);
     p = gen->print(p, gen->prog, gen->tree, &gen->types,
             gen->print_user);
     isl_ast_node_free(gen->tree);
   }