Update dir-spec.txt with new weight constraints. (7af0aa25) · Commits · Mike Perry / Tor

doc/spec/dir-spec.txt

+71 −49

Original line number	Diff line number	Diff line
		@@ -1632,6 +1632,7 @@
		"7" -- Provides keyword=integer pairs of consensus parameters
		"8" -- Provides microdescriptor summaries
		"9" -- Provides weights for selecting flagged routers in paths
		"10" -- Fixes edge case bugs in router flag selection weights

		Before generating a consensus, an authority must decide which consensus
		method to use. To do this, it looks for the highest version number
		@@ -1694,22 +1695,25 @@
		WmeE + WeeE == E (aka: Wee = 1-Wme)

		We are short 2 constraints with the above set. The remaining constraints
		come from examining different cases of network load.
		come from examining different cases of network load. The following
		constraints are used in consensus method 10 and above. There are another
		incorrect and obsolete set of constraints used for these same cases in
		consensus method 9. For those, see dir-spec.txt in Tor 0.2.2.10-alpha
		to 0.2.2.16-alpha.

		Case 1: E >= T/3 && G >= T/3 (Neither Exit nor Guard Scarce)

		In this case, the additional two constraints are: WmeE == WmdD and
		Wgd == 0, which maximizes Exit-flagged bandwidth in the middle position.
		In this case, the additional two constraints are: Wmg == Wmd,
		Wed == 1/3.

		This leads to the solution:

		Wgg = (weight_scale(D+E+G+M))/(3G)
		Wmd = (weight_scale(2D + 2E - G - M))/(6D)
		Wme = (weight_scale(2D + 2E - G - M))/(6E)
		Wee = (weight_scale(-2D + 4E + G + M))/(6E)
		Wmg = weight_scale - Wgg
		Wed = weight_scale - Wmd
		Wgd = 0
		Wgd = weight_scale/3
		Wed = weight_scale/3
		Wmd = weight_scale/3
		Wee = (weight_scale(E+G+M))/(3E)
		Wme = weight_scale - Wee
		Wmg = (weight_scale(2G-E-M))/(3*G)
		Wgg = weight_scale - Wmg

		Case 2: E < T/3 && G < T/3 (Both are scarce)

		@@ -1733,25 +1737,35 @@
		Subcase b: R+D >= S

		In this case, if M <= T/3, we have enough bandwidth to try to achieve
		a balancing condition, and add the constraints Wgg == 1 and
		WmeE == WmdD:
		a balancing condition.

		Add constraints Wgg = 1, Wmd == Wgd to maximize bandwidth in the guard
		position while still allowing exits to be used as middle nodes:

		Wee = (weight_scale*(E - G + M))/E
		Wed = (weight_scale(D - 2E + 4G - 2M))/(3*D)
		Wme = (weight_scale*(G-M))/E
		Wmg = 0
		Wgg = weight_scale
		Wgd = (weight_scale(D + E - 2G + M))/(3*D) (T/3 >= G (Ok))
		Wmd = (weight_scale(D + E + G - 2M))/(6*D) (T/3 >= M)
		Wme = (weight_scale(D + E + G - 2M))/(6*E)
		Wee = (weight_scale(-D + 5E - G + 2M))/(6E) (2E+M >= T/3)
		Wmg = 0;
		Wed = weight_scale - Wgd - Wmd
		Wmd = (weight_scale - Wed)/2
		Wgd = (weight_scale - Wed)/2

		If M >= T/3, the above solution will not be valid (one of the weights
		will be < 0 or > 1). In this case, we use:
		If this system ends up with any values out of range (ie negative, or
		above weight_scale), use the constraints Wgg == 1 and Wee == 1, since
		both those positions are scarce:

		Wgg = weight_scale
		Wee = weight_scale
		Wmg = Wme = Wmd = 0
		Wgd = (weight_scale(D+E-G))/(2D)
		Wed = weight_scale - Wgd
		Wed = (weight_scale(D - 2E + G + M))/(3*D)
		Wmd = (weight_Scale(D - 2M + G + E))/(3*D)
		Wme = 0
		Wmg = 0
		Wgd = weight_scale - Wed - Wmd

		If M > T/3, then the Wmd weight above will become negative. Set it to 0
		in this case:
		Wmd = 0
		Wgd = weight_scale - Wed

		Case 3: One of E < T/3 or G < T/3

		@@ -1761,34 +1775,42 @@
		if G=S:
		Wgg = Wgd = weight_scale;
		Wmd = Wed = Wmg = 0;
		Wme = (weight_scale(E-M))/(2E);
		// Minor subcase, if E is more scarce than M,
		// keep its bandwidth in place.
		if (E < M) Wme = 0;
		else Wme = (weight_scale(E-M))/(2E);
		Wee = weight_scale-Wme;
		if E=S:
		Wee = Wed = weight_scale;
		Wmd = Wgd = Wmg = 0;
		Wmg = (weight_scale(G-M))/(2G);
		Wmd = Wgd = Wme = 0;
		// Minor subcase, if G is more scarce than M,
		// keep its bandwidth in place.
		if (G < M) Wmg = 0;
		else Wmg = (weight_scale(G-M))/(2G);
		Wgg = weight_scale-Wmg;

		Subcase b: (S+D) >= T/3
		if G=S:
		Add constraints Wmg = 0, WmeE == WmdD to maximize exit bandwidth
		in the middle position:
		Wgd = (weight_scale(D + E - 2G + M))/(3*D);
		Wmd = (weight_scale(D + E + G - 2M))/(6*D);
		Wme = (weight_scale(D + E + G - 2M))/(6*E);
		Wee = (weight_scale(-D + 5E - G + 2M))/(6E);
		Wgg = weight_scale;
		Wmg = 0;
		Wed = weight_scale - Wgd - Wmd;
		Add constraints Wgg = 1, Wmd == Wed to maximize bandwidth
		in the guard position, while still allowing exits to be
		used as middle nodes:
		Wgg = weight_scale
		Wgd = (weight_scale(D - 2G + E + M))/(3*D)
		Wmg = 0
		Wee = (weight_scale(E+M))/(2E)
		Wme = weight_scale - Wee
		Wmd = (weight_scale - Wgd)/2
		Wed = (weight_scale - Wgd)/2
		if E=S:
		Add constraints Wgd = 0, WmeE == WmdD:
		Wgg = (weight_scale(D + E + G + M))/(3G);
		Wmd = (weight_scale(2D + 2E - G - M))/(6D);
		Wme = (weight_scale(2D + 2E - G - M))/(6E);
		Wee = (weight_scale(-2D + 4E + G + M))/(6E);
		Wgd = 0;
		Add constraints Wee == 1, Wmd == Wgd to maximize bandwidth
		in the exit position:
		Wee = weight_scale;
		Wed = (weight_scale(D - 2E + G + M))/(3*D);
		Wme = 0;
		Wgg = (weight_scale(G+M))/(2G);
		Wmg = weight_scale - Wgg;
		Wed = weight_scale - Wmd;
		Wmd = (weight_scale - Wed)/2;
		Wgd = (weight_scale - Wed)/2;

		To ensure consensus, all calculations are performed using integer math
		with a fixed precision determined by the bwweightscale consensus