add relative weight

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
 }