Add Bron–Kerbosch algorithm to find maximum clique in graph

Author: knizhnik

Makefile

@@ -1,5 +1,5 @@
 MODULE_big = multimaster
-OBJS = multimaster.o arbiter.o bytebuf.o bgwpool.o pglogical_output.o pglogical_proto.o pglogical_receiver.o pglogical_apply.o pglogical_hooks.o pglogical_config.o
+OBJS = multimaster.o arbiter.o bytebuf.o bgwpool.o pglogical_output.o pglogical_proto.o pglogical_receiver.o pglogical_apply.o pglogical_hooks.o pglogical_config.o ddd.o bkb.o
 
 EXTENSION = multimaster
 DATA = multimaster--1.0.sql

arbiter.c

@@ -81,7 +81,7 @@ typedef struct
 	MtmMessageCode code; /* Message code: MSG_READY, MSG_PREPARE, MSG_COMMIT, MSG_ABORT */
     int            node; /* Sender node ID */
 	TransactionId  dxid; /* Transaction ID at destination node */
-	TransactionId  sxid; /* Transaction IO at sender node */  
+	TransactionId  sxid; /* Transaction ID at sender node */  
 	csn_t          csn;  /* local CSN in case of sending data from replica to master, global CSN master->replica */
 	nodemask_t     disabledNodeMask; /* bitmask of disabled nodes at the sender of message */
 } MtmArbiterMessage;
@@ -353,9 +353,11 @@ static void MtmOpenConnections()
 
 static bool MtmSendToNode(int node, void const* buf, int size)
 {
-	while (!MtmWriteSocket(sockets[node], buf, size)) { 
+	while (sockets[node] < 0 || !MtmWriteSocket(sockets[node], buf, size)) { 
 		elog(WARNING, "Arbiter failed to write socket: %d", errno);
-		close(sockets[node]);
+		if (sockets[node] >= 0) { 
+			close(sockets[node]);
+		}
 		sockets[node] = MtmConnectSocket(hosts[node], MtmArbiterPort + node + 1, MtmReconnectAttempts);
 		if (sockets[node] < 0) { 
 			MtmOnLostConnection(node+1);
@@ -400,6 +402,8 @@ static void MtmAcceptOneConnection()
 				close(fd);
 			} else { 
 				elog(NOTICE, "Arbiter established connection with node %d", msg.node); 
+				BIT_CLEAR(ds->connectivityMask, msg.node-1);
+				MtmOnConnectNode(msg.node);
 				MtmRegisterSocket(fd, msg.node-1);
 				sockets[msg.node-1] = fd;
 			}

bkb.c

@@ -1,18 +1,22 @@
+#include "postgres.h"
+#include "bkb.h"
+
 /*
- * Bron–Kerbosch algorithm to find maximum clque in graph
+ * Bron–Kerbosch algorithm to find maximum clique in graph
  */  
 
 typedef struct {
 	int size;
 	int nodes[MAX_NODES];
-} List;
+} NodeList;
 
-static void list_append(List* list, int n)
+static void list_append(NodeList* list, int n)
 {
-	nodes[list->size++] = n;
+	Assert(list->size < MAX_NODES);
+	list->nodes[list->size++] = n;
 }
 
-static void list_copy(List* dst, List* src)
+static void list_copy(NodeList* dst, NodeList const* src)
 {
 	int i;
 	int n = src->size;
@@ -23,13 +27,15 @@ static void list_copy(List* dst, List* src)
 }
 
 
-static void findMaximumIndependentSet(List* cur, List* result, nodemask_t* graph, int* oldSet, int ne, int ce) 
+static void findMaximumIndependentSet(NodeList* cur, NodeList* result, nodemask_t* graph, int* oldSet, int ne, int ce) 
 {
     int nod = 0;
     int minnod = ce;
     int fixp = -1;
     int s = -1;
-	int i, j;
+	int i, j, k;
+	int newce, newne;
+	int sel;
     int newSet[MAX_NODES];
 
     for (i = 0; i < ce && minnod != 0; i++) {
@@ -39,8 +45,9 @@ static void findMaximumIndependentSet(List* cur, List* result, nodemask_t* graph
 
 		for (j = ne; j < ce; j++) { 
 			if (!BIT_CHECK(graph[p], oldSet[j])) {
-				if (++cnt == minnod)
+				if (++cnt == minnod) { 
 					break;
+				}
 				pos = j;
 			}
 		}
@@ -57,19 +64,19 @@ static void findMaximumIndependentSet(List* cur, List* result, nodemask_t* graph
     }
 
 
-    for (int k = minnod + nod; k >= 1; k--) {
-        int sel = oldSet[s];
+    for (k = minnod + nod; k >= 1; k--) {
+        sel = oldSet[s];
 		oldSet[s] = oldSet[ne];
 		oldSet[ne] = sel;
 
-		int newne = 0;
-		for (int i = 0; i < ne; i++) {
+		newne = 0;
+		for (i = 0; i < ne; i++) {
 			if (BIT_CHECK(graph[sel], oldSet[i])) {
 				newSet[newne++] = oldSet[i];
 			}
 		}
-		int newce = newne;
-		for (int i = ne + 1; i < ce; i++) {
+	    newce = newne;
+		for (i = ne + 1; i < ce; i++) {
 			if (BIT_CHECK(graph[sel], oldSet[i])) { 
 				newSet[newce++] = oldSet[i];
 			}
@@ -84,28 +91,30 @@ static void findMaximumIndependentSet(List* cur, List* result, nodemask_t* graph
 				findMaximumIndependentSet(cur, result, graph, newSet, newne, newce);
 			}
 		}
-		cur.size -= 1;
+		cur->size -= 1;
 		if (k > 1) {
 			for (s = ++ne; BIT_CHECK(graph[fixp], oldSet[s]); s++);
 		}
 	}
 }
 
-nodemask_t MtmFindMaxClique(nodemask_t* graphs, in n_nodes);
+nodemask_t MtmFindMaxClique(nodemask_t* graph, int n_nodes)
 {
-	List tmp;
-	List result;
-	nodemask_t mask = 0;
+	NodeList tmp;
+	NodeList result;
+	nodemask_t mask;
 	int all[MAX_NODES];
 	int i;
+
 	tmp.size = 0;
 	result.size = 0;
 	for (i = 0; i < n_nodes; i++) { 
-		all[i]= i;
+		all[i] = i;
 	}
 	findMaximumIndependentSet(&tmp, &result, graph, all, 0, n_nodes);
+	mask = 0;
 	for (i = 0; i < result.size; i++) { 
 		mask |= (nodemask_t)1 << result.nodes[i];
 	}
-	return ~mask;
+	return mask;
 }

bkb.h

@@ -0,0 +1,16 @@
+/*
+ * Bron–Kerbosch algorithm to find maximum clique in graph
+ */  
+#ifndef __BKB_H__
+#define __BKB_H__
+
+#define MAX_NODES 64
+
+typedef uint64_t nodemask_t;
+#define BIT_CHECK(mask, bit) (((mask) & ((nodemask_t)1 << (bit))) != 0)
+#define BIT_CLEAR(mask, bit) (mask &= ~((nodemask_t)1 << (bit)))
+#define BIT_SET(mask, bit)   (mask |= ((nodemask_t)1 << (bit)))
+
+extern nodemask_t MtmFindMaxClique(nodemask_t* matrix, int n_modes);
+
+#endif

ddd.c

@@ -1,6 +1,8 @@
-#include <stddef.h>
-#include <stdlib.h>
-#include <string.h>
+#include "postgres.h"
+#include "access/clog.h"
+#include "storage/lwlock.h"
+#include "utils/hsearch.h"
+
 #include "ddd.h"
 
 
@@ -11,10 +13,10 @@ void MtmGraphInit(MtmGraph* graph)
 
 static inline MtmVertex* findVertex(MtmGraph* graph, GlobalTransactionId* gtid)
 {
-    xid_t h = gtid->xid % MAX_TRANSACTIONS;
+    uint32 h = gtid->xid % MAX_TRANSACTIONS;
     MtmVertex* v;
-    for (v = graph->hashtable[h]; v != NULL; v = v->next) { 
-        if (v->gtid == *gtid) { 
+    for (v = graph->hashtable[h]; v != NULL; v = v->collision) { 
+        if (EQUAL_GTID(v->gtid, *gtid)) { 
             return v;
         }
     }
@@ -29,30 +31,28 @@ static inline MtmVertex* findVertex(MtmGraph* graph, GlobalTransactionId* gtid)
 void MtmGraphAdd(MtmGraph* graph, GlobalTransactionId* gtid, int size)
 {
     GlobalTransactionId* last = gtid + size;
-    MtmEdge *e, *next, *edges = NULL;
     while (gtid != last) { 
-        Vertex* src = findVertex(graph, gtid++);
+        MtmVertex* src = findVertex(graph, gtid++);
         while (gtid->node != 0) { 
-            Vertex* dst = findVertex(graph, gtid++);
-            e = (MtmEdge*)palloc(sizeof(MtmEdge));
-            dst->nIncomingEdges += 1;
+            MtmVertex* dst = findVertex(graph, gtid++);
+            MtmEdge* e = (MtmEdge*)palloc(sizeof(MtmEdge));
             e->dst = dst;
             e->src = src;
-            e->next = v->outgoingEdges;
-            v->outgoingEdges = e;
+            e->next = src->outgoingEdges;
+            src->outgoingEdges = e;
         }
 		gtid += 1;
     }
 }
 
 static bool recursiveTraverseGraph(MtmVertex* root, MtmVertex* v)
 {
-    Edge* e;
-    v->node = VISITED_NODE_MARK;
+    MtmEdge* e;
+    v->gtid.node = VISITED_NODE_MARK;
     for (e = v->outgoingEdges; e != NULL; e = e->next) {
         if (e->dst == root) { 
             return true;
-        } else if (e->dst->node != VISITED_NODE_MAR && recursiveTraverseGraph(root, e->dst)) { /* loop */
+        } else if (e->dst->gtid.node != VISITED_NODE_MARK && recursiveTraverseGraph(root, e->dst)) { /* loop */
             return true;
         } 
     }
@@ -61,9 +61,9 @@ static bool recursiveTraverseGraph(MtmVertex* root, MtmVertex* v)
 
 bool MtmGraphFindLoop(MtmGraph* graph, GlobalTransactionId* root)
 {
-    Vertex* v;
-    for (v = graph->hashtable[root->xid % MAX_TRANSACTIONS]; v != NULL; v = v->next) { 
-        if (v->gtid == *root) { 
+    MtmVertex* v;
+    for (v = graph->hashtable[root->xid % MAX_TRANSACTIONS]; v != NULL; v = v->collision) { 
+        if (EQUAL_GTID(v->gtid, *root)) { 
             if (recursiveTraverseGraph(v, v)) { 
                 return true;
             }

ddd.h

@@ -1,4 +1,5 @@
 #ifndef __DDD_H__
+#define __DDD_H__
 
 #include "multimaster.h"
 
@@ -20,8 +21,8 @@ typedef struct MtmVertex
 
 typedef struct MtmGraph
 {
-    MtmVertex* hashtable[MTM_MAX_TRANSACTIONS];
-} Graph;
+    MtmVertex* hashtable[MAX_TRANSACTIONS];
+} MtmGraph;
 
 extern void MtmGraphInit(MtmGraph* graph);
 extern void MtmGraphAdd(MtmGraph* graph, GlobalTransactionId* subgraph, int size);