Latest version.

DrTodd13 · DrTodd13 · commit 2893849c2748 · 2019-10-02T14:46:53.000-07:00
diff --git a/numba/lowering.py b/numba/lowering.py
@@ -156,6 +156,7 @@ def post_lower(self):
         """
         # Add omp offloading metadata if present.
         if hasattr(self, 'omp_offload'):
+            print("Has omp_offload")
             omp_offload_metadata = self.module.get_or_insert_named_metadata('omp_offload.info')
             for oi in self.omp_offload:
                 omp_offload_metadata.add(oi)
diff --git a/numba/npyufunc/parfor.py b/numba/npyufunc/parfor.py
@@ -112,10 +112,11 @@ def get_next_offload_number(lowerer):
     return cur
 
 class openmp_region_start(ir.Stmt):
-    def __init__(self, tags, loc):
+    def __init__(self, tags, region_number, loc):
         self.tags = tags
-        self.omp_region_var = None
+        self.region_number = region_number
         self.loc = loc
+        self.omp_region_var = None
         self.omp_metadata = None
 
     def has_target(self):
@@ -132,6 +133,8 @@ def lower(self, lowerer):
         builder = lowerer.builder
         library = lowerer.library
 
+        builder.module.device_triples = "spir64"
+
         llvm_token_t = lc.Type.token()
         fnty = lir.FunctionType(llvm_token_t, [])
         pre_fn = builder.module.declare_intrinsic('llvm.directive.region.entry', (), fnty)
@@ -143,7 +146,8 @@ def lower(self, lowerer):
                  lir.IntType(32)(lb.getFileIdForFile(self.loc.filename)),   # File ID of the file with the entry.
                  lowerer.fndesc.mangled_name,   # Mangled name of the function with the entry.
                  lir.IntType(32)(self.loc.line),  # Line in the source file where with the entry.
-                 lir.IntType(32)(get_next_offload_number(lowerer)),   # Order the entry was created.
+                 lir.IntType(32)(self.region_number),   # Order the entry was created.
+                 #lir.IntType(32)(get_next_offload_number(lowerer)),   # Order the entry was created.
                  lir.IntType(32)(0)    # Entry kind.  Should always be 0 I think.
                 ])
             add_offload_info(lowerer, self.omp_metadata)
@@ -1433,7 +1437,7 @@ def _create_gufunc_for_parfor_body(
                     rhs = instr.value
                     if isinstance(rhs, ir.Expr) and rhs.op == 'call':
 #                        print("definitions", gufunc_ir._definitions)
-#                        pdb.set_trace()
+                        #pdb.set_trace()
 #                        func_def = get_definition(gufunc_ir, rhs.func)
                         callname = find_callname(gufunc_ir, rhs)
 #                        print("func_def", func_def, type(func_def))
diff --git a/numba/parfor.py b/numba/parfor.py
@@ -2739,7 +2739,7 @@ def lower_parfor_sequential(typingctx, func_ir, typemap, calltypes, openmp):
     new_blocks = {}
     for (block_label, block) in func_ir.blocks.items():
         block_label, parfor_found = _lower_parfor_sequential_block(
-            block_label, block, new_blocks, typemap, calltypes, parfor_found, openmp, typingctx)
+            block_label, block, new_blocks, typemap, calltypes, parfor_found, openmp, typingctx, func_ir)
         # old block stays either way
         new_blocks[block_label] = block
     func_ir.blocks = new_blocks
@@ -2761,11 +2761,10 @@ def lower_parfor_sequential(typingctx, func_ir, typemap, calltypes, openmp):
             next_region_end_index = 0
             for i, inst in enumerate(block.body):
                 if inst in openmp_ends:
-                    block.body[next_region_end_index=1:i+1] = block.body[next_region_end_index:i]
+                    block.body[next_region_end_index+1:i+1] = block.body[next_region_end_index:i]
                     block.body[next_region_end_index] = inst
                     next_region_end_index += 1
                     dprint("Found openmp end")
-                    break
     dprint_func_ir(func_ir, "after elevating openmp end")
     return
 
@@ -2914,6 +2913,14 @@ def add_prints(block, typemap, calltypes):
 
     return new_block
 
+def get_next_region_number(func_ir):
+    if hasattr(func_ir, 'offload_number'):
+        cur = func_ir.offload_number
+    else:
+        cur = 0
+    func_ir.offload_number = cur + 1
+    return cur
+
 def _lower_parfor_openmp(
         block_label,
         block,
@@ -2922,7 +2929,8 @@ def _lower_parfor_openmp(
         calltypes,
         parfor_found,
         openmp,
-        typingctx):
+        typingctx,
+        func_ir):
     add_directives = True
 
     global omp_count
@@ -3023,8 +3031,12 @@ def _lower_parfor_openmp(
         ompubvar, ompubvar_assign = create_assign_var("ompub", types.uintp, subexpr, scope, loc, typemap)
         inst.init_block.body.append(ompubvar_assign)
 
+        region_number = get_next_region_number(func_ir)
+
         # ----------------------------------------------------------------
 
+        print("PyArg_UnpackTuple symbol", llvmlite.binding.address_of_symbol('PyArg_UnpackTuple'))
+#        if openmp == True or openmp == 'cpu' or openmp == 'target':
         if openmp == True or openmp == 'cpu':
             openmp_start_tags = [ openmp_tag("DIR.OMP.PARALLEL.LOOP") ]
             openmp_end_tags = [ openmp_tag("DIR.OMP.END.PARALLEL.LOOP") ]
@@ -3046,7 +3058,7 @@ def _lower_parfor_openmp(
             openmp_start_tags.append(openmp_tag("QUAL.OMP.NORMALIZED.UB", ompubvar))
 
             # Add OpenMP LLVM directives.
-            or_start = numba.npyufunc.parfor.openmp_region_start(openmp_start_tags, loc)
+            or_start = numba.npyufunc.parfor.openmp_region_start(openmp_start_tags, region_number, loc)
             # Append OpenMP directive right to the block right before the loop.
 
             if omp_count != -1:
@@ -3067,12 +3079,24 @@ def _lower_parfor_openmp(
                 block.body.insert(0, or_end)
         elif openmp == 'target':
             openmp_target_start_tags = [ openmp_tag("DIR.OMP.TARGET"),
-                                         openmp_tag("QUAL.OMP.OFFLOAD.ENTRY.IDX", 0) ]
+                                         openmp_tag("QUAL.OMP.OFFLOAD.ENTRY.IDX", region_number),
+                                         openmp_tag("QUAL.OMP.PRIVATE", index_variable),
+                                         openmp_tag("QUAL.OMP.FIRSTPRIVATE", omplbvar),
+                                         openmp_tag("QUAL.OMP.FIRSTPRIVATE", ompubvar)]
             openmp_target_end_tags = [ openmp_tag("DIR.OMP.END.TARGET") ]
-            openmp_teams_start_tags = [ openmp_tag("DIR.OMP.TEAMS") ]
+
+            openmp_teams_start_tags = [ openmp_tag("DIR.OMP.TEAMS"),
+                                        openmp_tag("QUAL.OMP.PRIVATE", index_variable),
+                                        openmp_tag("QUAL.OMP.SHARED", omplbvar),
+                                        openmp_tag("QUAL.OMP.SHARED", ompubvar)]
             openmp_teams_end_tags = [ openmp_tag("DIR.OMP.END.TEAMS") ]
+
             openmp_distparloop_start_tags = [ openmp_tag("DIR.OMP.DISTRIBUTE.PARLOOP"),
-                                              openmp_tag("QUAL.OMP.SCHEDULE.STATIC", 1) ]
+                                              openmp_tag("QUAL.OMP.SCHEDULE.STATIC", 1),
+                                              openmp_tag("QUAL.OMP.PRIVATE", index_variable),
+                                              openmp_tag("QUAL.OMP.FIRSTPRIVATE", omplbvar),
+                                              openmp_tag("QUAL.OMP.NORMALIZED.IV", index_variable),
+                                              openmp_tag("QUAL.OMP.NORMALIZED.UB", ompubvar)]
             openmp_distparloop_end_tags = [ openmp_tag("DIR.OMP.END.DISTRIBUTE.PARLOOP") ]
 
 #            for i in range(ndims):
@@ -3097,35 +3121,28 @@ def _lower_parfor_openmp(
                 openmp_start_tags.append(openmp_tag("QUAL.OMP.COLLAPSE", ndims))
 
             # Add OpenMP LLVM directives.
-            target_start = numba.npyufunc.parfor.openmp_region_start(openmp_target_start_tags, loc)
-            # Append OpenMP directive right to the block right before the loop.
-            if add_directives:
-                inst.init_block.body.append(target_start)
+            target_start = numba.npyufunc.parfor.openmp_region_start(openmp_target_start_tags, region_number, loc)
+            teams_start = numba.npyufunc.parfor.openmp_region_start(openmp_teams_start_tags, region_number, loc)
+            distparloop_start = numba.npyufunc.parfor.openmp_region_start(openmp_distparloop_start_tags, region_number, loc)
 
-            teams_start = numba.npyufunc.parfor.openmp_region_start(openmp_teams_start_tags, loc)
-            # Append OpenMP directive right to the block right before the loop.
+            # Append OpenMP directives to the block right before the loop.
             if add_directives:
+                inst.init_block.body.append(target_start)
                 inst.init_block.body.append(teams_start)
-
-            distparloop_start = numba.npyufunc.parfor.openmp_region_start(openmp_distparloop_start_tags, loc)
-            # Append OpenMP directive right to the block right before the loop.
-            if add_directives:
                 inst.init_block.body.append(distparloop_start)
 
             distparloop_end = numba.npyufunc.parfor.openmp_region_end(distparloop_start, openmp_distparloop_end_tags, loc)
-            # Prepend OpenMP directive right to the block right after the loop.
-            if add_directives:
-                block.body.insert(0, distparloop_end)
-
             teams_end = numba.npyufunc.parfor.openmp_region_end(teams_start, openmp_teams_end_tags, loc)
-            # Prepend OpenMP directive right to the block right after the loop.
-            if add_directives:
-                block.body.insert(0, teams_end)
-
             target_end = numba.npyufunc.parfor.openmp_region_end(target_start, openmp_target_end_tags, loc)
-            # Prepend OpenMP directive right to the block right after the loop.
+
+            # Prepend OpenMP directives to the block right after the loop.
             if add_directives:
+                # Because we always insert at position 0, we insert in the reverse
+                # order we want them to be in the IR (which is itself the reverse
+                # order that the region.entry directives were inserted.
                 block.body.insert(0, target_end)
+                block.body.insert(0, teams_end)
+                block.body.insert(0, distparloop_end)
 
         inst.init_block.body.append(pi_assign)
         inst.init_block.body.append(omplbvar_assign)
@@ -3166,6 +3183,7 @@ def _lower_parfor_openmp(
 
         # Make init block jump to top test.
         inst.init_block.body.append(ir.Jump(top_test_label, loc))
+        #inst.init_block.body.append(ir.Jump(jump_to_body_block_label, loc))
         if not collapse and ndims > 1:
             parfor_copy = copy.copy(inst)
             parfor_copy.init_block = ir.Block(scope, loc)
@@ -3191,7 +3209,7 @@ def _lower_parfor_openmp(
             # Add parfor body to blocks
             for (l, b) in inst.loop_body.items():
                 l, parfor_found = _lower_parfor_sequential_block(
-                    l, b, new_blocks, typemap, calltypes, parfor_found, False, typingctx)
+                    l, b, new_blocks, typemap, calltypes, parfor_found, False, typingctx, func_ir)
                 #new_blocks[l] = add_prints(b, typemap, calltypes)
                 new_blocks[l] = b
 
@@ -3296,10 +3314,11 @@ def _lower_parfor_sequential_block(
         calltypes,
         parfor_found,
         openmp,
-        typingctx):
+        typingctx,
+        func_ir):
     if openmp != False:
         return _lower_parfor_openmp(block_label, block, new_blocks, typemap,
-                                    calltypes, parfor_found, openmp, typingctx)
+                                    calltypes, parfor_found, openmp, typingctx, func_ir)
 
     scope = block.scope
     i = _find_first_parfor(block.body)
diff --git a/numba/targets/codegen.py b/numba/targets/codegen.py
@@ -22,6 +22,8 @@
                       'i886', 'i986'])
 
 
+Todd = True
+
 def _is_x86(triple):
     arch = triple.split('-')[0]
     return arch in _x86arch
@@ -58,6 +60,32 @@ def display(self, filename=None, view=False):
     def __repr__(self):
         return self.dot
 
+def test_link():
+    ll.initialize()
+    ll.initialize_all_targets()
+    ll.initialize_native_asmprinter()
+
+    target = ll.Target.from_triple(ll.get_process_triple())
+    tm = target.create_target_machine()
+
+
+    llvm_module = ll.parse_assembly("""
+        declare i32 @PyArg_UnpackTuple(i8*, i8*, i64, i64, ...)
+        declare double @sin(double)
+        define i64 @foo() {
+            ret i64 ptrtoint (i32 (i8*, i8*, i64, i64, ...)* @PyArg_UnpackTuple to i64)
+        }
+        """)
+
+    engine = ll.create_mcjit_compiler(llvm_module, tm)
+    addr = engine.get_function_address('PyArg_UnpackTuple')
+    print('PyArg_UnpackTuple', addr)  # printing 0x0
+
+
+    addr = engine.get_function_address('foo')
+    foo = ctypes.CFUNCTYPE(ctypes.c_int64)(addr)
+    print('foo', addr)
+    print("PyArg_UnpackTuple", foo())  # print non zero
 
 class CodeLibrary(object):
     """
@@ -190,17 +218,20 @@ def add_ir_module(self, ir_module):
         self.add_llvm_module(ll_module)
 
     def add_llvm_module(self, ll_module):
+        print("CodeLibrary::add_llvm_module", self._name)
         self._optimize_functions(ll_module)
         # TODO: we shouldn't need to recreate the LLVM module object
         ll_module = remove_redundant_nrt_refct(ll_module)
         self._final_module.link_in(ll_module)
+        print("CodeLibrary::add_llvm_module end", self._name)
 
     def finalize(self):
         """
         Finalize the library.  After this call, nothing can be added anymore.
         Finalization involves various stages of code optimization and
         linking.
         """
+        print("CodeLibrary::finalize", self._name)
         require_global_compiler_lock()
 
         # Report any LLVM-related problems to the user
@@ -211,6 +242,7 @@ def finalize(self):
         if config.DUMP_FUNC_OPT:
             dump("FUNCTION OPTIMIZED DUMP %s" % self._name, self.get_llvm_str())
 
+        print("Before link_in")
         # Link libraries for shared code
         for library in self._linking_libraries:
             self._final_module.link_in(
@@ -222,8 +254,12 @@ def finalize(self):
 
         self._final_module.verify()
         self._finalize_final_module()
+        print("CodeLibrary::finalize end", self._name)
+        if self._name == 'f1':
+            import pdb
+            #pdb.set_trace()
 
-    def _finalize_dyanmic_globals(self):
+    def _finalize_dynamic_globals(self):
         # Scan for dynamic globals
         for gv in self._final_module.global_variables:
             if gv.name.startswith('numba.dynamic.globals'):
@@ -241,7 +277,11 @@ def _finalize_final_module(self):
         """
         Make the underlying LLVM module ready to use.
         """
-        self._finalize_dyanmic_globals()
+        if self._name == "f1":
+            import pdb
+            #pdb.set_trace()
+
+        self._finalize_dynamic_globals()
         self._verify_declare_only_symbols()
 
         # Remember this on the module, for the object cache hooks
@@ -261,6 +301,7 @@ def _finalize_final_module(self):
             dump("OPTIMIZED DUMP %s" % self._name, self.get_llvm_str())
 
         if config.DUMP_ASSEMBLY:
+            test_link()
             # CUDA backend cannot return assembly this early, so don't
             # attempt to dump assembly if nothing is produced.
             asm = self.get_asm_str()
@@ -499,6 +540,8 @@ def scan_unresolved_symbols(self, module, engine):
         prefix = self.PREFIX
 
         for gv in module.global_variables:
+            if Todd:
+                print("scan_unresolved_symbols", gv)
             if gv.name.startswith(prefix):
                 sym = gv.name[len(prefix):]
                 # Avoid remapping to existing GV
@@ -515,17 +558,23 @@ def scan_defined_symbols(self, module):
         Scan and track all defined symbols.
         """
         for fn in module.functions:
+            if Todd:
+                print("scan_defined_symbols", fn)
             if not fn.is_declaration:
                 self._defined.add(fn.name)
 
     def resolve(self, engine):
         """
         Fix unresolved symbols if they are defined.
         """
+        if Todd:
+            print("RuntimeLinker resolve", self._unresolved, self._defined)
         # An iterator to get all unresolved but available symbols
         pending = [name for name in self._unresolved if name in self._defined]
         # Resolve pending symbols
         for name in pending:
+            if Todd:
+                print("name", name)
             # Get runtime address
             fnptr = engine.get_function_address(name)
             # Fix all usage
@@ -570,13 +619,17 @@ def _load_defined_symbols(self, mod):
         """Extract symbols from the module
         """
         for gsets in (mod.functions, mod.global_variables):
+            if Todd:
+                print("_load_defined_symbols", gsets, self._defined_symbols)
             self._defined_symbols |= {gv.name for gv in gsets
                                       if not gv.is_declaration}
 
     def add_module(self, module):
         """Override ExecutionEngine.add_module
         to keep info about defined symbols.
         """
+        if Todd:
+            print("add_module", module)
         self._load_defined_symbols(module)
         return self._ee.add_module(module)
 
diff --git a/numba/targets/cpu.py b/numba/targets/cpu.py
