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::path::Path;
+use subweight_core::parse::overhead::Weight;
+use subweight_core::parse::pallet::ChromaticExtrinsic;
+use subweight_core::parse::storage::Weights;
+use subweight_core::scope::Scope;
+use subweight_core::term::Term;
+
+fn main() {
+    let pallet_weights = read_pallet_weight();
+    let db_weight = read_db_weight();
+    let _overhead_weight = read_overhead_weight();
+
+    // Initialize scope
+    let mut scope = Scope::from_substrate();
+    scope = scope.with_storage_weights(db_weight.weights.read, db_weight.weights.write);
+
+    // Test
+    // TODO Fix subweight-core parser not working with parameters
+    for i in pallet_weights {
+        for j in i {
+            let (pallet, extrinsic, weight) = evaluate_weight(j, &scope).unwrap();
+            println!(
+                "Pallet: {:?} ; Extrinsic: {:?} ; Weight: {:?}",
+                pallet, extrinsic, weight
+            );
+        }
+    }
+}
+
+fn read_pallet_weight() -> Vec<Vec<ChromaticExtrinsic>> {
+    let mut parsed_files = Vec::new();
+    for path in glob("../../runtime/common/src/weights/pallet_*")
+        .expect("No pallet found")
+        .filter_map(Result::ok)
+    {
+        let file = subweight_core::parse::pallet::parse_file(&path);
+        if let Ok(file) = file {
+            parsed_files.push(file);
+        }
+    }
+    parsed_files
+}
+
+fn read_db_weight() -> Weights {
+    subweight_core::parse::storage::parse_file(Path::new(
+        "../../runtime/common/src/weights/paritydb_weights.rs",
+    ))
+    .expect("No DB weights")
+}
+
+fn read_overhead_weight() -> Weight {
+    subweight_core::parse::overhead::parse_file(Path::new(
+        "../../runtime/common/src/weights/block_weights.rs",
+    ))
+    .expect("No overhead weight")
+}
+
+fn evaluate_weight(
+    extrinsic: ChromaticExtrinsic,
+    scope: &Scope<Term<u128>>,
+) -> Result<(String, String, u128), String> {
+    let weight = extrinsic
+        .term
+        .simplify(subweight_core::Dimension::Time)
+        .expect("Can't evaluate")
+        .eval(scope)
+        .unwrap();
+    Ok((extrinsic.pallet, extrinsic.name, weight))
+}