1 files changed, 60 insertions, 22 deletions

diff --git a/xlators/cluster/dht/src/dht-selfheal.c b/xlators/cluster/dht/src/dht-selfheal.c
index 8463abdbfaf..77afde82e16 100644
--- a/xlators/cluster/dht/src/dht-selfheal.c
+++ b/xlators/cluster/dht/src/dht-selfheal.c
@@ -38,12 +38,20 @@ dht_overlap_calc (dht_layout_t *old, int o, dht_layout_t *new, int n)
 	if (old->list[o].err > 0 || new->list[n].err > 0)
 		return 0;
 
+        if (old->list[o].start == old->list[o].stop) {
+                return 0;
+        }
+
+        if (new->list[n].start == new->list[n].stop) {
+                return 0;
+        }
+
 	if ((old->list[o].start > new->list[n].stop) ||
 	    (old->list[o].stop < new->list[n].start))
 		return 0;
 
-	return max (old->list[o].start, new->list[n].start) -
-		min (old->list[o].stop, new->list[n].stop);
+	return min (old->list[o].stop, new->list[n].stop) -
+	        max (old->list[o].start, new->list[n].start) + 1;
 }
 
 
@@ -564,18 +572,25 @@ void dht_selfheal_layout_new_directory (call_frame_t *frame, loc_t *loc,
 					dht_layout_t *new_layout);
 
 void dht_layout_entry_swap (dht_layout_t *layout, int i, int j);
+void dht_layout_range_swap (dht_layout_t *layout, int i, int j);
+
+/*
+ * It's a bit icky using local variables in a macro, but it makes the rest
+ * of the code a lot clearer.
+ */
+#define OV_ENTRY(x,y)      table[x*new->cnt+y]
 
 void
 dht_selfheal_layout_maximize_overlap (call_frame_t *frame, loc_t *loc,
 				      dht_layout_t *new, dht_layout_t *old)
 {
 	int           i            = 0;
-	int           k            = 0;
+	int           j            = 0;
 	uint32_t      curr_overlap = 0;
 	uint32_t      max_overlap  = 0;
 	int           max_overlap_idx = -1;
 	uint32_t      overlap      = 0;
-
+        uint32_t     *table = NULL;
 
 	dht_layout_sort_volname (old);
 	/* Now both old_layout->list[] and new_layout->list[]
@@ -584,31 +599,54 @@ dht_selfheal_layout_maximize_overlap (call_frame_t *frame, loc_t *loc,
 	   to the same subvolumes
 	*/
 
+        /* Build a table of overlaps between new[i] and old[j]. */
+        table = alloca(sizeof(overlap)*old->cnt*new->cnt);
+        if (!table) {
+                return;
+        }
+        memset(table,0,sizeof(overlap)*new->cnt*new->cnt);
+        for (i = 0; i < new->cnt; ++i) {
+                for (j = 0; j < old->cnt; ++j) {
+                        OV_ENTRY(i,j) = dht_overlap_calc(old,j,new,i);
+                }
+        }
+
 	for (i = 0; i < new->cnt; i++) {
-		if (new->list[i].err > 0)
+		if (new->list[i].err > 0) {
 			/* Subvol might be marked for decommission
 			   with EINVAL, or some other serious error
 			   marked with positive errno.
 			*/
 			continue;
+                }
 
-		curr_overlap = dht_overlap_calc (old, i, new, i);
-		max_overlap = curr_overlap;
-		max_overlap_idx = i;
-
-		/* Subvols up to `i' have already found their best
-		   matches. Search only from the rest.
-		*/
-		for (k = (i + 1); k < new->cnt; k++) {
-			overlap = dht_overlap_calc (old, i, new, k);
-			if (overlap > max_overlap) {
-				max_overlap_idx = k;
-				max_overlap = overlap;
-			}
-		}
-
-		if (max_overlap > curr_overlap)
-			dht_layout_entry_swap (new, i, max_overlap_idx);
+                max_overlap = 0;
+                max_overlap_idx = i;
+                for (j = (i + 1); j < new->cnt; ++j) {
+                        /* Calculate the overlap now. */
+                        curr_overlap = OV_ENTRY(i,i) + OV_ENTRY(j,j);
+                        /* Calculate the overlap after the proposed swap. */
+                        overlap = OV_ENTRY(i,j) + OV_ENTRY(j,i);
+                        /* Are we better than status quo? */
+                        if (overlap > curr_overlap) {
+                                overlap -= curr_overlap;
+                                /* Are we better than the previous choice? */
+                                if (overlap > max_overlap) {
+                                        max_overlap = overlap;
+                                        max_overlap_idx = j;
+                                }
+                        }
+                }
+
+		if (max_overlap_idx != i) {
+ 			dht_layout_range_swap (new, i, max_overlap_idx);
+                        /* Need to swap the table values too. */
+                        for (j = 0; j < old->cnt; ++j) {
+                                overlap = OV_ENTRY(i,j);
+                                OV_ENTRY(i,j) = OV_ENTRY(max_overlap_idx,j);
+                                OV_ENTRY(max_overlap_idx,j) = overlap;
+                        }
+                }
 	}
 }