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

@@ -2,6 +2,7 @@ use glob::glob;
 use std::path::Path;
 use subweight_core::parse::overhead::Weight;
 use subweight_core::parse::pallet::ChromaticExtrinsic;
+use subweight_core::parse::pallet::ComponentRange;
 use subweight_core::parse::storage::Weights;
 use subweight_core::scope::Scope;
 use subweight_core::term::Term;
@@ -16,10 +17,9 @@ fn main() {
     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();
+            let (pallet, extrinsic, weight) = evaluate_weight(j, &mut scope).unwrap();
             println!(
                 "Pallet: {:?} ; Extrinsic: {:?} ; Weight: {:?}",
                 pallet, extrinsic, weight
@@ -58,8 +58,18 @@ fn read_overhead_weight() -> Weight {
 
 fn evaluate_weight(
     extrinsic: ChromaticExtrinsic,
-    scope: &Scope<Term<u128>>,
+    scope: &mut Scope<Term<u128>>,
 ) -> Result<(String, String, u128), String> {
+    // Extend the scope with the maximum value of the complexity parameter.
+    if let Some(params) = extrinsic.comp_ranges {
+        params
+            .iter()
+            .for_each(|(key, val): (&String, &ComponentRange)| {
+                scope.put_var(key.as_str(), Term::Scalar(val.max.into()));
+            });
+    }
+
+    // Evaluate the weight
     let weight = extrinsic
         .term
         .simplify(subweight_core::Dimension::Time)