[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,7 @@ def generate_code(sdfg: SDFG, validate=True) -> List[CodeObject]:
         target_objects.extend(tgt.get_generated_codeobjects())
 
     # Ensure that no new targets were dynamically added
+
     assert frame._dispatcher.used_targets == (frame.targets - {frame})
 
     # add a header file for calling the SDFG

dace/codegen/dispatcher.py

@@ -444,6 +444,8 @@ def dispatch_node(self, sdfg: SDFG, cfg: ControlFlowRegion, dfg: StateSubgraphVi
         state = cfg.state(state_id)
         disp = self.get_node_dispatcher(sdfg, state, node)
         self._used_targets.add(disp)
+        # print debugging for the dispatcher
+        print("SJJ: Dispatching node", node, "to", disp)
         disp.generate_node(sdfg, cfg, dfg, state_id, node, function_stream, callsite_stream)
 
     def get_scope_dispatcher(self, schedule: dtypes.ScheduleType) -> target.TargetCodeGenerator:

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