Add distributed deadlock detection

knizhnik · knizhnik · commit 3f420060987a · 2015-11-09T23:58:42.000+03:00
diff --git a/contrib/pg_dtm/dtmd/include/transaction.h b/contrib/pg_dtm/dtmd/include/transaction.h
@@ -34,6 +34,16 @@ typedef struct Transaction {
 	void *listeners[CHAR_TO_INDEX('z')]; // we are going to use 'a' to 'z' for indexing
 } Transaction;
 
+static inline void l2_list_is_empty(L2List* elem)
+{
+    return elem->next == elem;
+}
+
+static inline void l2_list_init(L2List* elem)
+{
+    elem->next = elem->prev = elem;
+}
+
 static inline void l2_list_link(L2List* after, L2List* elem)
 {
     elem->next = after->next;
diff --git a/contrib/pg_dtm/dtmd/src/ddd.c b/contrib/pg_dtm/dtmd/src/ddd.c
@@ -0,0 +1,121 @@
+#include "transaction.h"
+
+typedef struct Instance {
+    struct Edge* edges; /* local subgraph */    
+} Instance;
+
+typedef struct Edge {
+    L2List node; /* node of list of outgoing eedges */
+    struct Edge* next;  /* list of edges of local subgraph */  
+    struct Vertex* dst;
+    struct Vertex* src;
+} Edge;
+
+typedef struct Vertex
+{
+    L2List outgoingEdges;
+    xid_t xid;    
+    int nIncomingEdges;
+    bool visited;
+} Vertex;
+
+typedef struct Graph
+{
+    Vertex* hashtable[MAX_TRANSACTIONS];
+    Edge* freeEdges;
+    Vertex* freeVertexes;
+} Graph;
+
+void initGraph(Graph* graph)
+{
+    memset(graph->hashtable, 0. sizeof(graph->hashtable));
+    graph->freeEdges = NULL;
+    graph->freeVertexes = NULL;
+}
+
+Edge* newEdge(Graph* graph)
+{
+    Edge* edge = graph->freeEdges;
+    if (edge == NULL) { 
+        edge = (Edge*)malloc(sizeof(Edge));
+    } else { 
+        graph->freeEdges = edge->next;
+    }
+    return edge;
+}
+
+void freeVertex(Graph* graph, Vertex* vertex)
+{
+    vertex->node.next = (L2List*)graph->freeVertexes;
+    graph->freeVertexes = vertex;
+}
+
+void freeEdge(Graph* graph, Edge* edge)
+{
+    edge->next = graph->freeEdges;
+    graph->freeEdges = edge;
+}
+
+Vertex* newVertex(Graph* graph)
+{
+    Vertex* v = graph->freeVertexes;
+    if (v == NULL) { 
+        v = (Vertex*)malloc(sizeof(Vertex));
+    } else { 
+        graph->freeVertexes = (Vertex*)v.node.next;
+    }
+    return v;
+}
+
+Vertex* findVertex(Graph* graph, xid_t xid)
+{
+    xid_t h = xid;
+    Vertex* v;
+    while ((v = graph->hashtable[h % MAX_TRANSACTIONS]) != NULL) { 
+        if (v->xid == xid) { 
+            return v;
+        }
+        h += 1;
+    }
+    v = newVertex(graph);
+    l2_list_init(v->outgoingEdges);
+    v->xid = xid;
+    v->nIncomingEdges = 0;
+    graph->hashtable[h % MAX_TRANSACTIONS] = v;
+    return v;
+}
+
+void addSubgraph(Instance* instance, Graph* graph, xid_t* xids, int n_xids)
+{
+    xid_t *last = xids + n_xids;
+    Edge *e, *next, *edges = NULL;
+    while (xids != last) { 
+        Vertex* src = findVertex(graph, *xids++);
+        xid_t xid;
+        while ((xid = *xids++) != 0) { 
+            Vertex* dst = findVertex(graph, xid);
+            e = newEdge(graph);
+            dst->nIncomingEdges += 1;
+            e->dst = dst;
+            e->src = src;
+            e->next = edges;
+            edges = e;
+            l2_list_link(&src->outgoingEdges, &e->node);
+        }
+    }
+    for (e = instance->edges; e != NULL; e = next) { 
+        next = e->next;
+        l2_list_unlink(&e->node);
+        if (--e->dst->nIncomingEdges == 0 && l2_list_is_empty(&e->dst->outgoingEdges)) {
+            freeVertex(e->dst);
+        }
+        if (e->src->nIncomingEdges == 0 && l2_list_is_empty(&e->src->outgoingEdges)) {
+            freeVertex(e->src);
+        }
+        freeEdge(e);
+    }
+}
+
+bool findLoop(Graph* graph)
+{
+}
diff --git a/contrib/pg_dtm/pg_dtm.c b/contrib/pg_dtm/pg_dtm.c
@@ -91,6 +91,7 @@ static void DtmBackgroundWorker(Datum arg);
 
 static void ByteBufferAlloc(ByteBuffer* buf);
 static void ByteBufferAppend(ByteBuffer* buf, void* data, int len);
+static void ByteBufferAppendInt32(ByteBuffer* buf, int data);
 static void ByteBufferFree(ByteBuffer* buf);
 
 
@@ -976,21 +977,49 @@ static void ByteBufferAppend(ByteBuffer* buf, void* data, int len)
     buf->used += len;
 }
 
+static void ByteBufferAppendInt32(ByteBuffer* buf, int data)
+{
+    ByteBufferAppend(buf, &data, sizeof data);
+}
+
 static void ByteBufferFree(ByteBuffer* buf)
 {
     pfree(buf->data);
 }
 
-#define APPEND(buf, x) ByteBufferAppend(buf, &x, sizeof(x))
-
 static void DtmSerializeLock(PROCLOCK* proclock, void* arg)
 {
     ByteBuffer* buf = (ByteBuffer*)arg;
     LOCK* lock = proclock->tag.myLock;
+    PGPROC* proc = proclock->tag.myProc;
     if (lock != NULL) {
-        APPEND(buf, proclock->tag.myProc->lxid);
-        APPEND(buf, proclock->holdMask);
-        APPEND(buf, lock->tag.locktag_lockmethodid);
+        if (proc->waitLock == lock) { 
+            LockMethod lockMethodTable = GetLocksMethodTable(lock);
+            int numLockModes = lockMethodTable->numLockModes;
+            int conflictMask = lockMethodTable->conflictTab[proc->waitLockMode];
+            SHM_QUEUE *procLocks = &(lock->procLocks);
+            int lm;
+            
+            ByteBufferAppendInt32(buf, proc->lxid); /* waiting transaction */
+            proclock = (PROCLOCK *) SHMQueueNext(procLocks, procLocks,
+                                                 offsetof(PROCLOCK, lockLink));
+            while (proclock)
+            {
+                if (proc != proclock->tag.myProc) { 
+                    for (lm = 1; lm <= numLockModes; lm++)
+                    {
+                        if ((proclock->holdMask & LOCKBIT_ON(lm)) && (conflictMask & LOCKBIT_ON(lm)))
+                        {
+                            ByteBufferAppendInt32(buf, proclock->tag.myProc->lxid); /* transaction holding lock */
+                            break;
+                        }
+                    }
+                }
+                proclock = (PROCLOCK *) SHMQueueNext(procLocks, &proclock->lockLink,
+                                                     offsetof(PROCLOCK, lockLink));
+            }
+            ByteBufferAppendInt32(buf, 0); /* end of lock owners list */
+        }
     }
 }
 
