The function now computes an optimal assignation (with respect to partition size) that minimizes the distance to the former assignation, using flow algorithms.

This commit was written by Mendes Oulamara <mendes.oulamara@pm.me>

@@ -177,0 +185,4 @@
+
+		//We compute the optimal number of partition to assign to
+		//every node and zone.
+		if let Some((part_per_nod, part_per_zone)) = self.optimal_proportions() {

@@ -213,0 +283,4 @@
+						self.ring_assignation_data.push(id as CompactNodeType);
+					} else {
+						panic!()
+					}

@@ -239,0 +324,4 @@
+	///This function compute the number of partition to assign to
+	///every node and zone, so that every partition is replicated
+	///self.replication_factor times and the capacity of a partition
+	///is maximized.

@@ -239,0 +325,4 @@
+	///every node and zone, so that every partition is replicated
+	///self.replication_factor times and the capacity of a partition
+	///is maximized.
+	fn optimal_proportions(&mut self) -> Option<(Vec<usize>, HashMap<String, usize>)> {

@@ -239,0 +339,4 @@
+				);
+			} else {
+				zone_capacity.insert(node_zone[i].clone(), node_capacity[i]);
+			}

@@ -288,0 +369,4 @@
+					),
+				)
+			})
+			.collect();

@@ -288,0 +380,4 @@
+				.keys()
+				.filter(|k| part_per_zone[*k] < nb_partitions)
+				.map(|k| zone_capacity[k])
+				.sum();

@@ -476,0 +524,4 @@
+				rf == cl.ring_assignation_data[rf * i..rf * (i + 1)]
+					.iter()
+					.map(|nod| node_zone[*nod as usize].clone())
+					.unique()

@@ -487,0 +538,4 @@
+					.filter(|x| **x == i as u8)
+					.count()
+			})
+			.collect::<Vec<_>>();

@@ -493,3 +543,1 @@
-				let mut part = PartitionAss::new();
-				for node_i in self.ring_assignation_data
-					[i * self.replication_factor..(i + 1) * self.replication_factor]
+		let zone_vec = node_zone.iter().unique().collect::<Vec<_>>();

@@ -499,0 +549,4 @@
+					.filter(|x| node_zone[**x as usize] == **z)
+					.count()
+			})
+			.collect::<Vec<_>>();

@@ -507,0 +573,4 @@
+				assert!(
+					node_capacity[idmin] * (node_nb_part[idnew] as u32 + 1)
+						>= node_capacity[idnew] * node_nb_part[idmin] as u32
+				);

@@ -522,0 +587,4 @@
+				if let Some(idnew) = node_of_z_iter.min_by(|i, j| {
+					(node_capacity[*i] * (node_nb_part[*j] as u32 + 1))
+						.cmp(&(node_capacity[*j] * (node_nb_part[*i] as u32 + 1)))
+				}) {

@@ -0,0 +2,4 @@
+ * This module deals with graph algorithm in complete bipartite
+ * graphs. It is used in layout.rs to build the partition to node
+ * assignation.
+ * */

@@ -0,0 +14,4 @@
+	c: i32,
+	flow: i32,
+	v: usize,
+	rev: usize,

@@ -0,0 +22,4 @@
+struct WeightedEdge {
+	w: i32,
+	u: usize,
+	v: usize,

@@ -0,0 +29,4 @@
+ * complete bipartite graph. It returns a matching that has the
+ * same degree as new_match at every vertex, and that is as close
+ * as possible to old_match.
+ * */

@@ -0,0 +45,4 @@
+		for j in 0..nb_right {
+			edge_vec[i * nb_right + j].u = i;
+			edge_vec[i * nb_right + j].v = nb_left + j;
+		}

@@ -0,0 +185,4 @@
+		graph[1][i].c = *c as i32;
+		graph[1][i].v = i + 2 + left_cap_vec.len();
+		graph[1][i].rev = 0;
+	}

@@ -0,0 +306,4 @@
+			}
+			//otherwise, we send flow to nbd.
+			lifo.push_back((graph[id][nbd].v, new_flow));
+		}