Idea: Reflections for `WeightInfo` functions

[ggwpez]

Currently we have the WeightInfo trait which exposes several weight functions in the form of:

pub trait WeightInfo {
	fn call_a() -> Weight;
	fn call_b() -> Weight;
	…
}

Sometimes you want to iterate over all weight functions and do something weight their name or result (eg in paritytech/substrate#12485).

One way to do this would be to have another type; WeightMetaInfo whose implementation is auto-generated as well:

pub trait WeighMetatInfo<W: WeightInfo> {
	/// Executes a callback for each weight function by passing in its name and return value.
	fn visit_weight_functions<F: Fn(&'static str, Weight) -> R, R>(f: F) -> Vec<R>;
}

This would allow us to do:

• Mocked WeigtInfo implementations such that the weight of a call can be dynamically set in a test (Is already possible, but not in a spell-checked way without ugly macros).
• Checking that all weights of a pallet are in a specific bound as part of the runtime-integrity check (eg. no Zero or stray todo!()).

I am not entirely convinced that this is the best design, but having this in some way would be nice.

[tifecool]

I'm interested in picking this up, but not sure I quite get the proposal.

From my understanding, something like this is what's being asked for:

/// Struct containing names of weight functions and their results
pub struct WeightMetaInfo{
	names: Vec<&str>,
	results: Vec<Weight>
}

impl WeightInfo{
	
	/// Gets `WeightMetaInfo`
	fn get_weight_meta_info() -> WeightMetaInfo{
		//code
	}
} 

Or a struct containing a hashmap

[xlc]

One way could refactor out all the code generation logic. Instead of generate codes that hard to be consumed by other tools, it should generate data.

e.g.

trait GetWeightInfoData {
	fn weight_data(call: Call) -> WeightInfoData;
	fn weight<const S: usize>(call: Call, args: [u32: S]) -> Weight {
		// do the math
	}
}

struct WeightData {
	weight: Weight,
	reads: u64,
	writes: u64,
}

struct WeightInfoData {
	base: WeightData,
	args: Vec<WeightData>,
}

enum Call {
	AddRegistrar,
	SetIdentity,
}

impl GetWeightInfoData for Call {
	fn weight_data(call: Call) -> WeightInfoData {
		match call {
			Call::AddRegistrar => WeightInfoData {
				base: WeightData {
					weight: Weight::from_ref_time(16_649_000 as u64),
					reads: 1,
					writes: 1,
				},
				args: vec![
					WeightData {
						weight: Weight::from_ref_time(241_000 as u64),
						reads: 0,
						writes: 0,
					}
				],
			}
			Call::SetIdentity => WeightInfoData {
				base: WeightData {
					weight: Weight::from_ref_time(31_322_000 as u64),
					reads: 1,
					writes: 1,
				},
				args: vec![
					WeightData {
						weight: Weight::from_ref_time(252_000 as u64),
						reads: 0,
						writes: 0,
					},
					WeightData {
						weight: Weight::from_ref_time(312_000 as u64),
						reads: 0,
						writes: 0,
					}
				],
			}
		}
	}
}

In that way it is easy to work with WeightInfoData and do whatever check. Could do some derive on the enum Call to be able to iterate all the calls.

[ggwpez]

Thanks for the ideas @xlc. Using data here instead of math terms should make it easier downstream indeed.
Could be extended to take the correct component ranges into account, instead of just u32.
The only problem I see is that pallet Call does not correspond 1:1 to benchmark functions. Sometimes we use a .max in a pallet::weight annotation or something.
Also I would like to have some for_all_weight_functions! macro that can be used for downstream code generation per benchmark function. So that a MockedWeightInfo could be macro-generated.