Add min_deadlock_duration

knizhnik · knizhnik · commit 7c81f05248e1 · 2015-11-10T23:31:04.000+03:00
diff --git a/contrib/pg_dtm/dtmd/include/ddd.h b/contrib/pg_dtm/dtmd/include/ddd.h
@@ -21,6 +21,7 @@ typedef struct Vertex
     xid_t xid;    
     int nIncomingEdges;
     int visited;
+    int deadlock_duration;
 } Vertex;
 
 typedef struct Graph
@@ -29,11 +30,12 @@ typedef struct Graph
     Edge* freeEdges;
     Vertex* freeVertexes;
     int marker;
+    int min_deadlock_duration;
 } Graph;
 
 
 extern void initGraph(Graph* graph);
 extern void addSubgraph(Instance* instance, Graph* graph, xid_t* xids, int n_xids);
-extern bool findCycle(Graph* graph, xid_t root);
+extern bool detectDeadLock(Graph* graph, xid_t root);
 
 #endif
diff --git a/contrib/pg_dtm/dtmd/src/ddd.c b/contrib/pg_dtm/dtmd/src/ddd.c
@@ -11,6 +11,7 @@ void initGraph(Graph* graph)
     graph->freeEdges = NULL;
     graph->freeVertexes = NULL;
     graph->marker = 0;
+    graph->min_deadlock_duration = 3;
 }
 
 static inline Edge* newEdge(Graph* graph)
@@ -51,6 +52,7 @@ static inline Vertex* newVertex(Graph* graph)
     } else { 
         graph->freeVertexes = v->next;
     }
+    v->deadlock_duration = 0;
     return v;
 }
 
@@ -120,12 +122,15 @@ static bool recursiveTraverseGraph(Vertex* root, Vertex* v, int marker)
     return false;        
 }
 
-bool findCycle(Graph* graph, xid_t root)
+bool detectDeadLock(Graph* graph, xid_t root)
 {
     Vertex* v;
     for (v = graph->hashtable[root % MAX_TRANSACTIONS]; v != NULL; v = v->next) { 
         if (v->xid == root) { 
-            return recursiveTraverseGraph(v, v, ++graph->marker);
+            if (recursiveTraverseGraph(v, v, ++graph->marker)) { 
+                return ++v->deadlock_duration >= graph->min_deadlock_duration;
+            }
+            v->deadlock_duration = 0;
         }
     }
     return false;        
diff --git a/contrib/pg_dtm/dtmd/src/main.c b/contrib/pg_dtm/dtmd/src/main.c
@@ -547,7 +547,7 @@ static void ondeadlock(client_t client, int argc, xid_t *argv) {
     xid_t root = argv[1];
     Instance* instance = &CLIENT_USERDATA(client)->instance;
     addSubgraph(instance, &graph, argv+2, argc-2);
-    bool hasDeadLock = findCycle(&graph, root);
+    bool hasDeadLock = detectDeadLock(&graph, root);
     client_message_shortcut(client, hasDeadLock ? RES_DEADLOCK : RES_OK);
 }
     
@@ -595,7 +595,7 @@ static void onmessage(client_t client, size_t len, char *data) {
 
 static void usage(char *prog) {
 	printf(
-		"Usage: %s [-d DATADIR] [-k] [-a HOST] [-p PORT] [-l LOGFILE]\n"
+		"Usage: %s [-d DATADIR] [-k] [-a HOST] [-p PORT] [-l LOGFILE] [-m MIN_DEADLOCK_DURATION]\n"
 		"   arbiter will try to kill the other one running at\n"
 		"   the same DATADIR.\n"
 		"   -l : Run as a daemon and write output to LOGFILE.\n"
@@ -688,8 +688,10 @@ int main(int argc, char **argv) {
 	bool assassin = false;
 	int listenport = DEFAULT_LISTENPORT;
 
+    initGraph(&graph);
+
 	int opt;
-	while ((opt = getopt(argc, argv, "hd:a:p:l:k")) != -1) {
+	while ((opt = getopt(argc, argv, "hd:a:p:l:k:m:")) != -1) {
 		switch (opt) {
 			case 'd':
 				datadir = optarg;
@@ -710,6 +712,9 @@ int main(int argc, char **argv) {
 			case 'k':
 				assassin = true;
 				break;
+			case 'm':
+                graph.min_deadlock_duration = atoi(optarg);
+                break;
 			default:
 				usage(argv[0]);
 				return EXIT_FAILURE;

Original file line number	Diff line number	Diff line change
`@@ -11,6 +11,7 @@ void initGraph(Graph* graph)`
`11`	`11`	`graph->freeEdges = NULL;`
`12`	`12`	`graph->freeVertexes = NULL;`
`13`	`13`	`graph->marker = 0;`
	`14`	`+ graph->min_deadlock_duration = 3;`
`14`	`15`	`}`
`15`	`16`
`16`	`17`	`static inline Edge* newEdge(Graph* graph)`
`@@ -51,6 +52,7 @@ static inline Vertex* newVertex(Graph* graph)`
`51`	`52`	`} else {`
`52`	`53`	`graph->freeVertexes = v->next;`
`53`	`54`	`}`
	`55`	`+ v->deadlock_duration = 0;`
`54`	`56`	`return v;`
`55`	`57`	`}`
`56`	`58`
`@@ -120,12 +122,15 @@ static bool recursiveTraverseGraph(Vertex* root, Vertex* v, int marker)`
`120`	`122`	`return false;`
`121`	`123`	`}`
`122`	`124`
`123`		`-bool findCycle(Graph* graph, xid_t root)`
	`125`	`+bool detectDeadLock(Graph* graph, xid_t root)`
`124`	`126`	`{`
`125`	`127`	`Vertex* v;`
`126`	`128`	`for (v = graph->hashtable[root % MAX_TRANSACTIONS]; v != NULL; v = v->next) {`
`127`	`129`	`if (v->xid == root) {`
`128`		`- return recursiveTraverseGraph(v, v, ++graph->marker);`
	`130`	`+ if (recursiveTraverseGraph(v, v, ++graph->marker)) {`
	`131`	`+ return ++v->deadlock_duration >= graph->min_deadlock_duration;`
	`132`	`+ }`
	`133`	`+ v->deadlock_duration = 0;`
`129`	`134`	`}`
`130`	`135`	`}`
`131`	`136`	`return false;`