Begin updating to SS:GB 6.2.0; static inline still WIP

Author: eriknw

suitesparse_graphblas/build.py

@@ -8,7 +8,12 @@
 
 ffibuilder = FFI()
 
-with open(os.path.join(thisdir, "source.c")) as f:
+if is_win:
+    source_filename = "source_no_complex.c"
+else:
+    source_filename = "source.c"
+
+with open(os.path.join(thisdir, source_filename)) as f:
     source = f.read()
 
 include_dirs = [os.path.join(sys.prefix, "include")]

suitesparse_graphblas/create_headers.py

@@ -315,6 +315,7 @@ def groupby(index, seq):
     "CMPLX",
     "CMPLXF",
     "GB_PUBLIC",
+    "GB_restrict",
     "GRAPHBLAS_H",
     "GrB_INVALID_HANDLE",
     "GrB_NULL",
@@ -426,6 +427,23 @@ def get_groups(ast):
     seen.update(vals)
     groups["GxB typedef funcs"] = sorted(vals, key=sort_key)
 
+    vals = []
+    next_i = -1
+    for i, line in enumerate(lines):
+        if i < next_i or line in seen:
+            continue
+        if "inline static" in line and ("GB" in line or "GrB" in line or "GxB" in line):
+            val = [line]
+            i += 1
+            while lines[i] != "}":
+                val.append(lines[i])
+                i += 1
+            val.append(lines[i])
+            next_i = i + 1
+            seen.update(val)
+            vals.append("\n".join(val))
+    groups["static inline"] = vals
+
     vals = {x for x in lines if "typedef" in x and "GrB" in x} - seen
     assert not vals, ", ".join(sorted(vals))
     groups["not seen"] = sorted(set(lines) - seen, key=sort_key)
@@ -579,6 +597,19 @@ def visit_Decl(self, node):
             if isinstance(node.type, c_ast.FuncDecl) and node.storage == ["extern"]:
                 self.functions.append(node)
 
+    class FuncDefVisitorStaticInline(c_ast.NodeVisitor):
+        def __init__(self):
+            self.functions = []
+
+        def visit_FuncDef(self, node):
+            decl = node.decl
+            if (
+                isinstance(decl.type, c_ast.FuncDecl)
+                and decl.storage == ["static"]
+                and decl.funcspec == ["inline"]
+            ):
+                self.functions.append(node)
+
     def handle_function_node(node):
         if generator.visit(node.type.type) != "GrB_Info":
             raise ValueError(generator.visit(node))
@@ -599,6 +630,7 @@ def handle_function_node(node):
             group = {
                 # Apply our naming scheme
                 "GrB_Matrix": "matrix",
+                "Matrix": "matrix",
                 "GrB_Vector": "vector",
                 "GxB_Scalar": "scalar",
                 "SelectOp": "selectop",
@@ -610,6 +642,7 @@ def handle_function_node(node):
                 "Type": "type",
                 "UnaryOp": "unary",
                 "IndexUnaryOp": "indexunary",
+                "Iterator": "iterator",
                 # "everything else" is "core"
                 "getVersion": "core",
                 "Global": "core",
@@ -636,16 +669,42 @@ def handle_function_node(node):
     assert len(gxb_nodes) == len(groups["GxB methods"])
     assert len(gb_nodes) == len(groups["GB methods"])
 
+    visitor = FuncDefVisitorStaticInline()
+    visitor.visit(ast)
+    static_inline_nodes = visitor.functions
+    assert len(static_inline_nodes) == len(groups["static inline"])
+    for node in static_inline_nodes:
+        # Sanity check
+        text = generator.visit(node).strip()
+        assert text in groups["static inline"]
+
+    def handle_static_inline(node):
+        decl = node.decl
+        if decl.name in DEPRECATED:
+            return
+        text = generator.visit(node).strip()
+        if skip_complex and has_complex(text):
+            return
+        return {
+            "name": decl.name,
+            "group": "static inline",
+            "node": node,
+            "text": text + "\n",
+        }
+
     grb_funcs = (handle_function_node(node) for node in grb_nodes)
     gxb_funcs = (handle_function_node(node) for node in gxb_nodes)
     gb_funcs = (handle_function_node(node) for node in gb_nodes)
+    si_funcs = (handle_static_inline(node) for node in static_inline_nodes)
     grb_funcs = [x for x in grb_funcs if x is not None]
     gxb_funcs = [x for x in gxb_funcs if x is not None]
     gb_funcs = [x for x in gb_funcs if x is not None]
+    si_funcs = [x for x in si_funcs if x is not None]
 
     rv["GrB methods"] = sorted(grb_funcs, key=lambda x: sort_key(x["text"]))
     rv["GxB methods"] = sorted(gxb_funcs, key=lambda x: sort_key(x["text"]))
     rv["GB methods"] = sorted(gb_funcs, key=lambda x: sort_key(x["text"]))
+    rv["static inline"] = si_funcs  # Should we sort these?
     for key in groups.keys() - rv.keys():
         rv[key] = groups[key]
     return rv
@@ -732,6 +791,10 @@ def handle_funcs(group):
     text.append("****************/")
     text.extend(handle_funcs(groups["GxB methods"]))
 
+    # Cython doesn't like compiling this; add to source.c instead (may work?)
+    # text.append("")
+    # text.extend(handle_funcs(groups["static inline"]))
+
     text.append("")
     text.append("/* int DEFINES */")
     for item in sorted(defines, key=sort_key):
@@ -744,7 +807,7 @@ def handle_funcs(group):
     return text
 
 
-def create_source_text(*, char_defines=None):
+def create_source_text(groups, *, char_defines=None):
     if char_defines is None:
         char_defines = CHAR_DEFINES
     text = [
@@ -753,6 +816,9 @@ def create_source_text(*, char_defines=None):
     ]
     for item in sorted(char_defines, key=sort_key):
         text.append(f"char *{item}_STR = {item};")
+    text.append("")
+    for node in groups["static inline"]:
+        text.append(node["text"])
     return text
 
 
@@ -780,6 +846,7 @@ def main():
     final_h = os.path.join(thisdir, "suitesparse_graphblas.h")
     final_no_complex_h = os.path.join(thisdir, "suitesparse_graphblas_no_complex.h")
     source_c = os.path.join(thisdir, "source.c")
+    source_no_complex_c = os.path.join(thisdir, "source_no_complex.c")
 
     # Copy original file
     print(f"Step 1: copy {args.graphblas} to {graphblas_h}")
@@ -814,12 +881,18 @@ def main():
 
     # Create source
     print(f"Step 5: create {source_c}")
-    text = create_source_text()
+    text = create_source_text(groups)
     with open(source_c, "w") as f:
         f.write("\n".join(text))
 
+    # Create source (no complex)
+    print(f"Step 6: create {source_no_complex_c}")
+    text = create_source_text(groups_no_complex)
+    with open(source_no_complex_c, "w") as f:
+        f.write("\n".join(text))
+
     # Check defines
-    print("Step 6: check #define definitions")
+    print("Step 7: check #define definitions")
     with open(graphblas_h) as f:
         text = f.read()
     define_lines = re.compile(r".*?#define\s+\w+\s+")