算法1
输入：每个节点的局部校验块集合R，集群中节点个数N
输出：每轮局部校验块传输方向集合S
for j=1 to size(R)
    init deta = 1
    for i=1 to N
        if (i+deta == i)
            deta = deta + 1
        end if
        (i -> i+deta) add into Sj
    end for
    deta = deta + 1
    S.push(Sj)
end for


算法2
输入：当前未恢复的原始数据块集合 R，当前未恢复的横向校验块集合R*，
    当前所有待恢复数据块所属条带布局集合S，集群中节点个数N
输出：恢复任务Q
if (initial recovery)
	init Q, G
    updateGraph(G, N-1, R)
end if
M =  计算 G 的最大权匹配
while (M 匹配个数 < N - 1 && R+R* != null) do
	updateGraph(G, 1, R+R*)
	M =  计算 G 的最大权匹配
while end
if( M 匹配个数 == N - 1 || M 中缺少的目标节点k 未存放局部条带的校验块）
    (存在局部校验块的节点 -> STF node) 映射替换 M 中的一个匹配
else
    (k -> STF Node) 加入 M
end if
Q.push( M )
function updateGraph(G, n, r) //从数据块集合r中选择n个数据块的重构集，加入G中
    for i=1 to n-1 do
        if (!STF node && G的目标节点中不包括i)
            rx = 根据条带布局S，在r中寻找条带中不包含i的幸存节点集合
        end if
        (rx -> i) 加入G
    end for
    return G
end function

算法1
输入：未恢复的原始数据块集合 R，未恢复的横向校验块集合R*，条带布局S，集群中节点个数N
输出：恢复任务Q1，Q2

if (initial recovery)
    init Q1, Q2
    init G // 初始化二分图
    updateGraph(G, N-1, R)
end if
M =  计算 G 的最大匹配
if( M 匹配个数 == N - 1 || M 中缺少的目标节点k 未存放局部条带的校验块）
    (存在局部校验块的节点 -> STF node) 映射替换 M 中的一个匹配
else
    (k -> STF Node) 加入 M
end if
Q1.push( M )
预估M完成时间，计算要放入Q2的数据块个数 k
Q2.push( get k from {R + R*} )
function updateGraph(G, n, r) //从数据块集合r中选择n个数据块的重构集，加入G中
    for i=1 to n-1 do
        if (!STF node && G的目标节点中不包括i)
            rx = 根据条带布局S，在r中寻找条带中不包含i的幸存节点集合
        end if
        (rx -> i) 加入G
    end for
    return G
end function

算法1
输入：未恢复的条带集合R，集群中节点个数N，STF磁盘个数SN
输出：跨节点恢复任务Q
PQ = PriorityQueue(R)
while (PQ.peek() 不为空) do
	R1 = PQ.pop()
	bs = R1 在STFdisk中数据块个数
	if (bs >= m)
		R2 = PQ.pop()
		updateGraph(G, N-SN, R2)
		M = 计算 G 的最大匹配
		addMethod2(M) 
		PQ.pushFirst(R2)
	else 
		updateGraph(G, N-SN, R)
		M = 计算 G 的最大匹配
		addMethod2(M)
	end if
	PQ.pushFirst(R1)
	Q.push(M)
end while
return Q
function addMethod2(M)
	for i=1 to NS do
		k = 局部校验块存放节点
		(k -> STF Nodei) 加入 M
	end for
end function

主动恢复调度算法

输入：当前未恢复的原始数据块集合 R，跨节点调度二分图 G
当前未恢复的横向校验块集合R*，当前集群节点个数N，链路完成阈值 K
输出：恢复完成
while (R+R* 为空)
	Q1，Q2 = 算法4
	T1 = Q1.pop()
	t = T1预计完成时间
	T2 = Q2.pop()
	执行T1、T2
	while (t < 当前时间 && T2执行完成)
		allocateT2(R+R*)
	if(T1未完成)
		while(总的链路完成率P < K) 
			allocateT2(R+R*)
		G 中未完成链路带宽减半
	end if
end while
function allocateT2(r)
	Q2.push(one of r)
	T2 = Q2.pop()
	执行T2
end function