Automatic weights documentation

Parse the weight files to calculate both extrinsic weights and relative weights, and include the results in the documentation #128 (closed).

This requires:

1. The pallet weights computed on the reference machine.
2. The extrinsic weights computed on the reference machine to get the weight overhead of the execution of one extrinsic.
3. The paritydb weights computed on the reference machine to get the weight of read and write in the database.

Include in the docs: The relative weight for all extrinsics available as: \frac{weight_{extrinsic_base} + weight_{extrinsic}}{weight_{block}}*100

• In the case where the extrinsic has a complexity parameter, the weight is calculated as the worst-case scenario, i.e., the maximal value set during benchmarking.
• In the case where no weight is available, the value is set to -1% and translated to "No weight available" in the doc.

To-do list:

• parse weight files.
• compute weights from files.
• add relative weight in % of block max.
• fix overhead benchmark.
• include computed weights in the autogenerated documentation.
• fix missing weights.
• automatic block max extraction from metadata.

resources/weight_analyzer/src/main.rs

 use glob::glob;
+use std::collections::HashMap;
 use std::path::Path;
 use subweight_core::parse::overhead::Weight;
 use subweight_core::parse::pallet::ChromaticExtrinsic;
@@ -7,25 +8,26 @@ use subweight_core::parse::storage::Weights;
 use subweight_core::scope::Scope;
 use subweight_core::term::Term;
 
+const MAX_BLOCK_WEIGHT: f64 = 2_000_000_000_000.; // TODO auto extraction from metadata using
+                                                  // frame_system blockweights constant
+
+#[derive(Debug)]
+pub struct WeightInfo {
+    pub weight: u128,
+    pub relative_weight: f64,
+}
+
 fn main() {
     let pallet_weights = read_pallet_weight();
     let db_weight = read_db_weight();
-    let _overhead_weight = read_overhead_weight();
+    let _overhead_weights = read_overhead_weight();
 
-    // Initialize scope
+    // Initialize scope with db weights
     let mut scope = Scope::from_substrate();
     scope = scope.with_storage_weights(db_weight.weights.read, db_weight.weights.write);
 
-    // Test
-    for i in pallet_weights {
-        for j in i {
-            let (pallet, extrinsic, weight) = evaluate_weight(j, &mut scope).unwrap();
-            println!(
-                "Pallet: {:?} ; Extrinsic: {:?} ; Weight: {:?}",
-                pallet, extrinsic, weight
-            );
-        }
-    }
+    let weight_by_pallet = process(pallet_weights, scope);
+    println!("{:?}", weight_by_pallet);
 }
 
 fn read_pallet_weight() -> Vec<Vec<ChromaticExtrinsic>> {
@@ -59,7 +61,7 @@ fn read_overhead_weight() -> Weight {
 fn evaluate_weight(
     extrinsic: ChromaticExtrinsic,
     scope: &mut Scope<Term<u128>>,
-) -> Result<(String, String, u128), String> {
+) -> Result<(String, String, WeightInfo), String> {
     // Extend the scope with the maximum value of the complexity parameter.
     if let Some(params) = extrinsic.comp_ranges {
         params
@@ -76,5 +78,27 @@ fn evaluate_weight(
         .expect("Can't evaluate")
         .eval(scope)
         .unwrap();
-    Ok((extrinsic.pallet, extrinsic.name, weight))
+    let relative_weight = (weight as f64) / MAX_BLOCK_WEIGHT * 100.;
+    Ok((
+        extrinsic.pallet,
+        extrinsic.name,
+        WeightInfo {
+            weight,
+            relative_weight,
+        },
+    ))
+}
+
+fn process(
+    pallet_weights: Vec<Vec<ChromaticExtrinsic>>,
+    mut scope: Scope<Term<u128>>,
+) -> HashMap<String, HashMap<String, WeightInfo>> {
+    let mut weight_by_pallet = HashMap::new();
+    for i in pallet_weights {
+        for j in i {
+            let (pallet, extrinsic, weight) = evaluate_weight(j, &mut scope).unwrap();
+            weight_by_pallet.insert(pallet.clone(), HashMap::from([(extrinsic.clone(), weight)]));
+        }
+    }
+    weight_by_pallet
 }