First draft of graph loading and intersection with automata.

Author: gsvgit

cfpq_add_context/add_contexts.py

@@ -0,0 +1,24 @@
+from load_graph import load_graph
+from intersection import intersection
+from gen_automata import generate
+import time
+
+def add_context(file_path):
+    load_graph_start = time.perf_counter()
+    
+    graph,number_of_contexts = load_graph(file_path)
+    
+    load_graph_end = time.perf_counter()
+    print("Graph loaded in ", load_graph_end - load_graph_start)
+    
+    automata = generate(number_of_contexts)
+    
+    automata_generation_end = time.perf_counter()
+    print("Automata generated in ", automata_generation_end - load_graph_end)
+
+    result = intersection(graph, automata)
+
+    intersection_end = time.perf_counter()
+    print("Graph and automata intersection competed in ", intersection_end - automata_generation_end)
+    
+    return result

cfpq_add_context/intersection.py

@@ -5,7 +5,6 @@
 from graphblas.core.operator import Semiring, Monoid, SelectOp
 from graphblas.core.dtypes import UINT64
 from graphblas import op, semiring
-from numba import njit, jit
 import gen_automata
 
 import labels
@@ -41,15 +40,6 @@ def bfs (matrix, sources):
 
     return reachable
 
-
-def filter_reachable_op(reachable_vertices):
-    _reachable_vertices = set(reachable_vertices)
-    def inner(x,i,j,k):        
-        return i in _reachable_vertices and j in _reachable_vertices
-    return inner
-
-SelectOp.register_new("filter_reachable", filter_reachable_op, parameterized=True, is_udt=True)
-
 def filter_not_zero_op(x,i,j,k):
     return x > 0
 
@@ -63,25 +53,10 @@ def intersection (graph, automata) :
     print_matrix_to_dot(intersection, "kron.dot")
 
     sources = [i * automata.nrows for i in range(0,graph.nrows)]
-    #reachable = frozenset(bfs(intersection, sources).to_coo(values=False)[0])
-    #reachable_vertices = set(bfs(intersection, sources).to_coo(values=False)[0])
 
     reachable_vertices_mask = bfs(intersection, sources).diag(name="reachable_vertices_mask")
 
-    #def filter_reachable_op(x,i,j,k):
-    #    return i in reachable_vertices and j in reachable_vertices
-
-    #SelectOp.register_new("filter_reachable", filter_reachable_op, is_udt=True)
-
-    #print("reachable = ", reachable_vertices)
-    #print("num of reachable = ", len(reachable_vertices))
-    #edges = intersection.to_edgelist()
-    #edges = zip(edges[0],edges[1])
-    #new_edges = [(_edg[0],_edg[1],_lbl) for (_edg,_lbl) in  edges if _edg[0] in reachable_vertices and _edg[1] in reachable_vertices]
-    #result = Matrix.from_edgelist(new_edges, dtype=intersection.dtype, nrows=intersection.nrows, ncols=intersection.ncols, name = "filtered intersection")
     result = Matrix(intersection.dtype, intersection.nrows, intersection.ncols, name = "filtered intersection")
-    #result << intersection.select(graphblas.select.filter_reachable(reachable_vertices=reachable_vertices))
-    #result << intersection.select(graphblas.select.filter_reachable)
     result << reachable_vertices_mask @ intersection
     print_matrix_to_dot(result, "kron_filtered.dot")
     return result
@@ -95,7 +70,6 @@ def test():
 
     i = intersection(graph, automata)
 
-    #print_matrix_to_dot(intersection, "kron.dot")
 
 def test2():
     graph_edges = [(0,0,(labels.mk_open_context(1))),(0,1,(labels.mk_open_context(1))),(1,1,(labels.mk_close_context(1)))]
@@ -146,6 +120,10 @@ def test7():
     i = intersection(graph, automata)
 
 def test8():
-    automata1 = gen_automata.generate(1)
-    automata2 = gen_automata.generate(1)
-    i = intersection(automata1, automata2)
+    graph_edges = [(0,0,1),(0,1,2),(1,1,3),(0,2,4),(2,0,5),(2,2,3)]    
+    
+    graph1 = Matrix.from_edgelist(graph_edges,dtype=UINT64, nrows=6, ncols=6, name="graph1")
+    graph2 = Matrix.from_edgelist(graph_edges,dtype=UINT64, nrows=6, ncols=6, name="graph2")
+
+    i = graph1.kronecker(graph2)
+    print_matrix_to_dot(i, "kron_build.dot")

cfpq_add_context/labels.py

@@ -16,6 +16,12 @@
 SIGMA_WITHOUT_OPEN_CONTEXTS = 0b0000000000000000000001111111111111111111111111111111111111111111
 NOTHING =                     0b0000000000000000000000000000000000000000000000000000000000000000
 
+ASSIGN = 1
+ASSIGN_R = 2
+ALLOC = 3
+ALLOC_R = 4
+OFFSET = 5
+
 def intersection_op (x:int, y:int) -> int:
     return (NOTHING - (x == y or (x & y == x and (y == SIGMA or y == SIGMA_WITHOUT_CONTEXTS or y == ALL_OPEN_CONTEXTS or y == SIGMA_WITHOUT_OPEN_CONTEXTS)))) & x
 
@@ -27,4 +33,8 @@ def mk_open_context(x:int) -> int :
 def mk_close_context(x:int) -> int : 
     return NOTHING | (x << 22)
 def mk_other(x:int) -> int : 
-    return NOTHING | x
+    return NOTHING | x
+def mk_load(i):
+    return mk_other(2 * i + OFFSET)
+def mk_store (i):
+    return mk_other(2 * i + 1 + OFFSET)

cfpq_add_context/load_graph.py

@@ -0,0 +1,62 @@
+import graphblas
+
+from graphblas.core.matrix import Matrix
+from graphblas.core.dtypes import UINT64
+
+import labels
+from utils import print_matrix_to_dot
+
+
+
+def load_graph(file_path):
+    nvertices = 0
+    number_of_contexts = 0
+    def get_edge_lbl(data_arr):
+        _context = 0
+        nonlocal number_of_contexts
+        if len(data_arr) == 4:
+            if "load" in data_arr[2]:
+                return labels.mk_load(int(data_arr[3]))
+            else:
+                return labels.mk_store(int(data_arr[3]))
+        elif data_arr[2] == "assign":
+            return labels.mk_other(labels.ASSIGN)
+        elif data_arr[2] == "assign_r":
+            return labels.mk_other(labels.ASSIGN_R)
+        elif data_arr[2] == "alloc":
+            return labels.mk_other(labels.ALLOC)
+        elif data_arr[2] == "alloc_r":
+            return labels.mk_other(labels.ALLOC_R)
+        elif "open" in data_arr[2]:
+            if "_r_" in data_arr[2]:
+                _context = 2 * int(data_arr[2].split('_')[2])
+            else:
+                _context =  2 * int(data_arr[2].split('_')[1]) + 1
+            number_of_contexts = max(number_of_contexts, _context)
+            return labels.mk_open_context(_context)
+        else:
+            if "_r_" in data_arr[2]:
+                _context = 2 * int(data_arr[2].split('_')[2])
+            else:
+                _context = 2 * int(data_arr[2].split('_')[1]) + 1
+            number_of_contexts = max(number_of_contexts, _context)
+            return labels.mk_close_context(_context)
+
+    def handle_line(line):
+        nonlocal nvertices
+        data = line.strip().split()
+        _lbl = get_edge_lbl(data)
+        _from = int(data[0])
+        _to = int(data[1])
+        
+        _max = max(_from,_to)
+        nvertices = max(nvertices, _max)
+
+        return (_from, _to, _lbl)
+
+    with open (file_path,'r') as file:
+        edges = [handle_line(line) for line in file if len(line.strip()) > 0]
+        result = Matrix.from_edgelist(edges, dtype=UINT64, nrows=nvertices + 1, ncols=nvertices + 1, name="graph")
+        print_matrix_to_dot(result, "graph.dot")
+        return (result, (number_of_contexts // 2) + 1)
+