[Draft PR] Graphcore backend support.

check_external_library_used.py

@@ -0,0 +1,13 @@
+from dace.libraries import blas
+
+print('BLAS calls will expand by default to', blas.default_implementation)
+
+if blas.IntelMKL.is_installed():
+    blas.default_implementation = 'MKL'
+elif blas.cuBLAS.is_installed():
+    blas.default_implementation = 'cuBLAS'
+elif blas.OpenBLAS.is_installed():
+    blas.default_implementation = 'OpenBLAS'
+elif not blas.BLAS.is_installed():
+    # No BLAS library found, use the unoptimized native SDFG fallback
+    blas.default_implementation = 'pure'

cpu.py

@@ -0,0 +1,20 @@
+# Copyright 2019-2021 ETH Zurich and the DaCe authors. All rights reserved.
+import dace
+import numpy as np
+
+@dace.program
+def cpu_vector_add(A: dace.int32[20], B: dace.int32[20], C: dace.int32[20]):
+    for i in dace.map[0:20]:       # parallelization construct
+       C[i] =  A[i] + B[i]
+
+if __name__ == '__main__':
+    sdfg = cpu_vector_add.to_sdfg(simplify=False)   # compiled SDFG
+
+    # call with values
+    A = np.ones((20), dtype=np.int32)   # 1,1,1,1,...
+    B = np.ones((20), dtype=np.int32)   # 1,1,1,1,...
+    C = np.zeros((20), dtype=np.int32)  # 0,0,0,0,...
+    sdfg(A, B, C)
+
+    # ref = np.full(20, 2, dtype=np.int32)     # 2,2,2,2,...
+    # assert np.array_equal(ref, C)

cpu_array_optimize.py

@@ -0,0 +1,25 @@
+import dace
+import numpy as np
+from dace.transformation.optimizer import SDFGOptimizer
+
+
+@dace.program
+def cpu_getstarted_optimize(A, B, C):
+    C = A + B
+    return C
+
+if __name__ == "__main__":
+    #a = np.random.rand(2,3)
+    # a = 10
+    # b = 20
+    # call with values
+    A = np.ones((20), dtype=np.int32)   # 1,1,1,1,...
+    B = np.ones((20), dtype=np.int32)   # 1,1,1,1,...
+    C = np.zeros((20), dtype=np.int32)  # 0,0,0,0,...
+    print ("before dace(CPU) (a,b)", A, B, C)
+    print("after dace(CPU)", cpu_getstarted_optimize(A, B, C))
+    sdfg = cpu_getstarted_optimize.to_sdfg(A, B, C)
+
+    # VISUALLY OPTIMIZE
+    sdfg = SDFGOptimizer(sdfg).optimize()
+    # sdfg.apply_gpu_transformations()

custom_codegen_external.py

@@ -0,0 +1,107 @@
+import dace
+from dace import registry
+from dace.sdfg.scope import ScopeSubgraphView
+from dace.codegen.prettycode import CodeIOStream
+from dace.codegen.targets.target import TargetCodeGenerator
+from dace.codegen.targets.framecode import DaCeCodeGenerator
+from dace.codegen.targets.cpp import sym2cpp
+
+@dace.program
+def custom_kernel(A: dace.float64[20, 30]):
+    for i, j in dace.map[0:20:2, 0:30]:
+        A[i, j] += A[i, j]
+
+
+
+dace.ScheduleType.register('LoopyLoop')
+dace.SCOPEDEFAULT_SCHEDULE[dace.ScheduleType.LoopyLoop] = dace.ScheduleType.Sequential
+dace.SCOPEDEFAULT_STORAGE[dace.ScheduleType.LoopyLoop] = dace.StorageType.CPU_Heap
+
+
+@registry.autoregister_params(name='loopy')
+class MyCustomLoop(TargetCodeGenerator):
+    def __init__(self, frame_codegen: DaCeCodeGenerator, sdfg: dace.SDFG):
+        ################################################################
+        # Define some locals:
+        # Can be used to call back to the frame-code generator
+        self.frame = frame_codegen
+        # Can be used to dispatch other code generators for allocation/nodes
+        self.dispatcher = frame_codegen.dispatcher
+
+        ################################################################
+        # Register handlers/hooks through dispatcher: Can be used for 
+        # nodes, memory copy/allocation, scopes, states, and more.
+
+        # In this case, register scopes
+        self.dispatcher.register_map_dispatcher(dace.ScheduleType.LoopyLoop, self)
+
+        # You can similarly use register_{array,copy,node,state}_dispatcher
+
+    # A scope dispatcher will trigger a method called generate_scope whenever 
+    # an SDFG has a scope with that schedule
+    def generate_scope(self, sdfg: dace.SDFG, scope: ScopeSubgraphView,
+                       state_id: int, function_stream: CodeIOStream,
+                       callsite_stream: CodeIOStream):
+        # The parameters here are:
+        # sdfg: The SDFG we are currently generating.
+        # scope: The subgraph of the state containing only the scope (map contents)
+        #        we want to generate the code for.
+        # state_id: The state in the SDFG the subgraph is taken from (i.e., 
+        #           `sdfg.node(state_id)` is the same as `scope.graph`)
+        # function_stream: A cursor to the global code (which can be used to define
+        #                  functions, hence the name).
+        # callsite_stream: A cursor to the current location in the code, most of
+        #                  the code is generated here.
+
+        # We can get the map entry node from the scope graph
+        entry_node = scope.source_nodes()[0]
+
+        # First, generate an opening brace (for instrumentation and dynamic map ranges)
+        callsite_stream.write('{', sdfg, state_id, entry_node)
+
+        ################################################################
+        # Generate specific code: We will generate a reversed loop with a 
+        # comment for each dimension of the map. For the sake of simplicity,
+        # dynamic map ranges are not supported.
+
+        for param, rng in zip(entry_node.map.params, entry_node.map.range):
+            # We use the sym2cpp function from the cpp support functions
+            # to convert symbolic expressions to proper C++
+            begin, end, stride = (sym2cpp(r) for r in rng)
+
+            # Every write is optionally (but recommended to be) tagged with
+            # 1-3 extra arguments, serving as line information to match
+            # SDFG, state, and graph nodes/edges to written code.
+            callsite_stream.write(f'''// Loopy-loop {param}
+            for (auto {param} = {end}; {param} >= {begin}; {param} -= {stride}) {{''',
+                                  sdfg, state_id, entry_node
+            )
+
+            # NOTE: CodeIOStream will automatically take care of indentation for us.
+
+
+        # Now that the loops have been defined, use the dispatcher to invoke any
+        # code generator (including this one) that is registered to deal with
+        # the internal nodes in the subgraph. We skip the MapEntry node.
+        self.dispatcher.dispatch_subgraph(sdfg, scope, state_id,
+                                          function_stream, callsite_stream,
+                                          skip_entry_node=True)
+
+        # NOTE: Since skip_exit_node above is set to False, closing braces will
+        #       be automatically generated
+
+# Preview SDFG
+sdfg = custom_kernel.to_sdfg()
+
+# Change schedule
+for node, _ in sdfg.all_nodes_recursive():
+    if isinstance(node, dace.nodes.MapEntry):
+        node.schedule = dace.ScheduleType.LoopyLoop
+
+# Code(sdfg.generate_code()[0].clean_code, language='cpp')
+
+
+# display
+from IPython.display import Code
+from IPython.display import display
+display(Code(sdfg.generate_code()[0].clean_code, language='cpp'))

dace/codegen/codegen.py

@@ -17,7 +17,7 @@
 from dace.codegen.instrumentation import InstrumentationProvider
 from dace.sdfg.state import SDFGState
 
-
+# include/* files, containing the signature header code.
 def generate_headers(sdfg: SDFG, frame: framecode.DaCeCodeGenerator) -> str:
     """ Generate a header file for the SDFG """
     proto = ""
@@ -34,7 +34,7 @@ def generate_headers(sdfg: SDFG, frame: framecode.DaCeCodeGenerator) -> str:
     proto += 'extern "C" void __program_%s(%sHandle_t handle%s);\n' % params
     return proto
 
-
+# sample/* files - contains the main() function.
 def generate_dummy(sdfg: SDFG, frame: framecode.DaCeCodeGenerator) -> str:
     """ Generates a C program calling this SDFG. Since we do not
         know the purpose/semantics of the program, we allocate
@@ -147,7 +147,10 @@ def _get_codegen_targets(sdfg: SDFG, frame: framecode.DaCeCodeGenerator):
     if sdfg.instrument != dtypes.InstrumentationType.No_Instrumentation:
         disp.instrumentation[sdfg.instrument] = provider_mapping[sdfg.instrument]
 
-
+# 3 step process
+# 1. Generate the code for the SDFG(.cpp file)(generate_code)(sdfg.generate_code()[0])
+# 2. Generate the header file for the SDFG(.h file)(generate_headers)(sdfg.generate_code()[1])
+# 3. Generate the main function to call the SDFG(.main file)(generate_dummy)(sdfg.generate_code()[2])
 def generate_code(sdfg: SDFG, validate=True) -> List[CodeObject]:
     """
     Generates code as a list of code objects for a given SDFG.
@@ -230,6 +233,7 @@ def generate_code(sdfg: SDFG, validate=True) -> List[CodeObject]:
     # NOTE: THE SDFG IS ASSUMED TO BE FROZEN (not change) FROM THIS POINT ONWARDS
 
     # Generate frame code (and the rest of the code)
+    # (, generated_code/clean_code, ...))
     (global_code, frame_code, used_targets, used_environments) = frame.generate_code(sdfg, None)
     target_objects = [
         CodeObject(sdfg.name,
@@ -246,6 +250,10 @@ def generate_code(sdfg: SDFG, validate=True) -> List[CodeObject]:
         target_objects.extend(tgt.get_generated_codeobjects())
 
     # Ensure that no new targets were dynamically added
+    print("\nused_targets = ", frame._dispatcher.used_targets)
+    print("\nframe.targets = ", frame.targets)
+    print("\nframe=", frame)
+
     assert frame._dispatcher.used_targets == (frame.targets - {frame})
 
     # add a header file for calling the SDFG

dace/codegen/targets/__init__.py

@@ -9,3 +9,4 @@
 from .mlir.mlir import MLIRCodeGen
 from .sve.codegen import SVECodeGen
 from .snitch import SnitchCodeGen
+from .ipu import IPUCodeGen

dace/codegen/targets/framecode.py

@@ -215,6 +215,13 @@ def generate_header(self, sdfg: SDFG, global_stream: CodeIOStream, callsite_stre
         for env in self.environments:
             self.statestruct.extend(env.state_fields)
 
+        # GRAPHCORE
+        # self.statestruct.append('IPUModel ipuModel;')
+        # self.statestruct.append('Device device = ipuModel.createDevice();')
+        # self.statestruct.append('Target target = device.getTarget();')
+        # self.statestruct.append('Graph graph(target);') 
+
+
         # Instrumentation preamble
         if len(self._dispatcher.instrumentation) > 2:
             self.statestruct.append('dace::perf::Report report;')
@@ -473,7 +480,6 @@ def dispatch_state(state: SDFGState) -> str:
             opbar.next()
             states_generated.add(state)  # For sanity check
             return stream.getvalue()
-
         if sdfg.root_sdfg.using_experimental_blocks:
             # Use control flow blocks embedded in the SDFG to generate control flow.
             cft = cflow.structured_control_flow_tree_with_regions(sdfg, dispatch_state)
@@ -885,6 +891,7 @@ def generate_code(self,
 
         # Allocate outer-level transients
         self.allocate_arrays_in_scope(sdfg, sdfg, sdfg, global_stream, callsite_stream)
+        callsite_stream.write('called allocate_arrays_in_scope outer\n', sdfg)
 
         # Define constants as top-level-allocated
         for cname, (ctype, _) in sdfg.constants_prop.items():
@@ -928,7 +935,7 @@ def generate_code(self,
         # Generate actual program body
 
         states_generated = self.generate_states(sdfg, global_stream, callsite_stream)
-
+        # Loop over states_generated and print them
         #######################################################################
 
         # Sanity check
@@ -940,6 +947,7 @@ def generate_code(self,
 
         # Deallocate transients
         self.deallocate_arrays_in_scope(sdfg, sdfg, sdfg, global_stream, callsite_stream)
+        callsite_stream.write('called deallocate_arrays_in_scope internal transient\n', sdfg)
 
         # Now that we have all the information about dependencies, generate
         # header and footer
@@ -969,16 +977,44 @@ def generate_code(self,
             header_global_stream.write(global_stream.getvalue())
             header_global_stream.write(footer_global_stream.getvalue())
             generated_header = header_global_stream.getvalue()
-
+            # print("generated header:")
+            # print("#" * 50)
+            # print(generated_header)
+            # print("#" * 50)
+            # # print("Footer Stream:")
+            # # print("#" * 50)
+            # # print(footer_stream.getvalue())
+            # # print("#" * 50)
+
+
+
             all_code = CodeIOStream()
             all_code.write(function_signature)
             all_code.write(header_stream.getvalue())
             all_code.write(callsite_stream.getvalue())
             all_code.write(footer_stream.getvalue())
             generated_code = all_code.getvalue()
+            # print("#" * 50)
+            # print("Function Signature:")
+            # print("#" * 50)
+            # print(function_signature)
+            # print("#" * 50)
+            # print("Header Stream:")
+            # print("#" * 50)
+            # header_stream.write("This is internal header, int x=10;")
+            # print(header_stream.getvalue())
+            # print("#" * 50)
+            # print("callsite Code:")
+            # print("#" * 50)
+            # print(callsite_stream.getvalue())
+            # print("#" * 50)
+            # print("Footer Stream:")
+            # print("#" * 50)
+            # print(footer_stream.getvalue())
+            # print("#" * 50)
         else:
-            generated_header = global_stream.getvalue()
-            generated_code = callsite_stream.getvalue()
+            generated_header = global_stream.getvalue() # header
+            generated_code = callsite_stream.getvalue() # frame
 
         # Clean up generated code
         gotos = re.findall(r'goto (.*?);', generated_code)
@@ -993,6 +1029,7 @@ def generate_code(self,
                 if label[0] not in gotos:
                     continue
             clean_code += line + '\n'
+        clean_code = generated_code
 
         # Return the generated global and local code strings
         return (generated_header, clean_code, self._dispatcher.used_targets, self._dispatcher.used_environments)