Butterfly Layer的一个节点，依赖degree个前一层的节点。每个Parent序号的计较公式：
个中，node是节点编号，pos是Parents编号，factor是系数（和层的编号有关）。这种有牢靠隔断的依赖形状，，有点像蝴蝶翅膀的条纹，所以称butterfly layer。
num_butterfly_layers: 7,
PoREP的NSE算法，是SDR算法的别的一种实验。实验低落单个处理惩罚的数据巨细(window)，实验不回收节点的前后依赖（layer的计较可以并行），加大单层的依赖，加大layer的层数。整个算法底层照旧回收sha256算法。NSE算法可以领略为安详性和机能之间均衡的一种实验。 Feat/nse update neptune alt
(el1, el2)
let (el1, el2) = (0..k).fold(
pub degree: usize,
Merge: 7e7eab2 578d12c
sector_size,
hasher.input(&[parent_a_value, parent_b_value]);
所有Parents的Hash计较，相对简朴，就是所有Parent数据拼接后的Hash值。
}
}
let mut hasher = Sha256::new();
/// Total number of layers.
let config = Config {
pub struct ExpanderGraph {
文章利用的源代码的最后一个提交信息如下：
Expander Layer
pub degree: usize,
详细的hash计较逻辑，请查察storage-proofs/porep/src/nse/vanilla/batch_hasher.rs的batch_hash函数。
|(mut el1, mut el2), l| {
};
/// The degree of the graph.
NSE，之所以称为NSE，因为N，Narrow。Narrow的意思是比之前的SDR算法，窄，每次处理惩罚的数据为一个Window。
let parent_a_value = &layer_in[parent_a * NODE_SIZE..(parent_a + 1) * NODE_SIZE]; 层数的设置，以及Expander/Butterfly的一些参数设置都没有确定。从测试代码的设置看：
self.hash[4..8].copy_from_slice(&self.counter.to_be_bytes());
return None;
let parent_a = parent_a as usize;
}
k: 8,
pub num_layers: u32,
Mask Layer
self.hash = hasher.finish();
// counter – 4 bytes
/// The number of nodes in a window. Must be a power of 2.
// node index – 4 bytes
if self.pos >= self.graph.degree as u32 {
let replica_id = <PoseidonHasher as Hasher>::Domain::random(rng);
Butterfly Layer的计较雷同于Expander Layer，差异的是获取Parents的方法以及Parents的hash计较方法。Parents的计较依赖ButterflyGraph的实现：
let parent1 = parents[y1 as usize];
for (i, j) in (0..degree).tuples() {
window配置为1，expander的依赖配置为384，butterfly的依赖为16。总共15层。
Mask Layer和详细的数据没有干系，和window编号/节点编号有关：
let y2 = j + (l as usize * degree as usize);
pub k: u32,
每个window需要颠末许多层的处理惩罚，这些层分为mask layer，expander layer, butterfly layer。焦点逻辑在storage-proofs/porep/src/nse/vanilla/labels.rs的encode_with_trees函数中。self.hash[..4].copy_from_slice(&self.node.to_be_bytes());
hasher.input(&[&self.hash[..], &[0u8; 32]]);
1. 整体流程 },
pub num_nodes_window: u32,
degree_expander: 384,
for (parent_a, parent_b) in graph.parents(node_index, layer_index).tuples() {
node + pos * factor
在多层处理惩罚竣事后，最后一层的bufferfly layer和原始数据举办encode，生成最后的Replica layer。计较进程，就是在最后一层bufferfly layer的基本上，再做一次bufferfly计较，功效和原始数据举办大数加法计较。具体的计较进程，请查察storage-proofs/porep/src/nse/vanilla/labels.rs的butterfly_encode_decode_layer函数。
add_assign(&mut el2, ¤t2, &modulus);
batch hash的名称，来自于batch，在做hash之前，需要将k个parents先做模加，模加的功效再做hash。
num_nodes_window: (sector_size / num_windows) / NODE_SIZE,
self.hash[i] = 0;
);
let rng = &mut XorShiftRng::from_seed(crate::TEST_SEED);
pub struct ButterflyGraph {
fn next(&mut self) -> Option<Self::Item> {
let parent_raw = self.node + self.pos * self.factor;
领略NSE算法，可以从storage-proofs/porep/src/nse/vanilla/porep.rs中NarrowStackedExpander布局的replicate函数看起。
/// The degree of the graph.
每个Window颠末层层的处理惩罚，城市生成对应的Replica。所有Window对应的每一层的数据一起构建成Merkle树。所有Window对应的Replica的数据也一起构建成Merkle树。这两棵树树根的Poseidon Hash的功效作为comm_r。comm_d以及comm_r是需要上链的数据。
self.pos += 1;
let parent_b = parent_b as usize;
let y1 = i + (l as usize * degree as usize);
let parent2 = parents[y2 as usize];
简朴的说，每个node依赖的parent的个数是degree*k个。parents简直定通过节点编号以及parents序号的hash功效来确定。
总结：
let current1 = read_at(data, parent1 as usize);
let k = k as u32;
hasher.input(&[&fr_repr_as_bytes(&el1), &fr_repr_as_bytes(&el2)]);
}
Author: porcuquine <[email protected]>
Butterfly Layer
// hash two 32 byte chunks at once
for i in 8..32 {
pub bits: u32,
/// Number of butterfly layers.
let num_windows = 1;
commit af4bdcb6da4b371230eed441218c459e99d32068 (HEAD -> feat/nse, origin/feat/nse)
// mod N
Merge pull request #1118 from filecoin-project/feat/nse-update-neptune-alt
}
}
degree_butterfly: 16,
add_assign(&mut el1, ¤t1, &modulus);
2. 多层处理惩罚
(FrRepr::from(0), FrRepr::from(0)),
Some(parent)
parent节点的计较请查察storage-proofs/porep/src/nse/vanilla/expander_graph.rs中ExpanderGraphParentsIter布局的update_hash和next函数：
let parent_b_value = &layer_in[parent_b * NODE_SIZE..(parent_b + 1) * NODE_SIZE];
/// The number of bits required to identify a single parent.
/// Batching hashing factor.
pub num_butterfly_layers: u32,
let parent = parent_raw & (self.graph.num_nodes_window – 1);
Date: Wed May 20 12:11:43 2020 -0700
let current2 = read_at(data, parent2 as usize);
num_expander_layers: 8,
// Compute hash of the parents.
Expander Layer基于ExpanderGraph生成依赖的上一层的节点的数据。这些数据和一些编号信息的sha256的功效作为新的节点的数据。示意如下：
PoREP算法，从window SDR改成SDR，时间并不长。新的PoREP算法NSE已经在酝酿中。NSE算法的全称：Narrow Stacked Expander PoRep。在rust-fil-proofs的feat/nse分支，可以查察NSE算法的实现。
3. 生成Replica
郑重声明：本文版权归原作者所有，转载文章仅为传播更多信息之目的，如作者信息标记有误，请第一时间联系我们修改或删除，多谢。
