Strict gas consumption on the high end usage (#14172)

## Description 

Make the gas charging harsher on the high end. 
This should affect nobody and make charging and running out of gas
faster on the high end.

## Test Plan 

Existing tests

---
If your changes are not user-facing and not a breaking change, you can
skip the following section. Otherwise, please indicate what changed, and
then add to the Release Notes section as highlighted during the release
process.

### Type of Change (Check all that apply)

- [ ] protocol change
- [ ] user-visible impact
- [ ] breaking change for a client SDKs
- [ ] breaking change for FNs (FN binary must upgrade)
- [ ] breaking change for validators or node operators (must upgrade
binaries)
- [ ] breaking change for on-chain data layout
- [ ] necessitate either a data wipe or data migration

### Release notes

Author: dariorussi

move-vm/types/src/views.rs

@@ -24,11 +24,8 @@ pub trait ValueView {
 
     /// Returns the abstract memory size of the value.
     ///
-    /// The concept of abstract memory size is not well-defined and is only kept for backward compatibility.
-    /// New applications should avoid using this.
-    ///
-    /// TODO(Gas): Encourage clients to replicate this in their own repo and get this removed once
-    ///            they are done.
+    /// This version of abstract memory size is not well-defined and is only kept for backward
+    /// compatibility.  New applications should avoid using this.
     fn legacy_abstract_memory_size(&self) -> AbstractMemorySize {
         use crate::values::{LEGACY_CONST_SIZE, LEGACY_REFERENCE_SIZE, LEGACY_STRUCT_SIZE};
 
@@ -120,6 +117,107 @@ pub trait ValueView {
 
         acc.0
     }
+
+    /// Returns the abstract memory size of the value.
+    fn abstract_memory_size(&self) -> AbstractMemorySize {
+        use crate::values::{LEGACY_CONST_SIZE, LEGACY_REFERENCE_SIZE, LEGACY_STRUCT_SIZE};
+
+        struct Acc(AbstractMemorySize);
+
+        impl ValueVisitor for Acc {
+            fn visit_u8(&mut self, _depth: usize, _val: u8) {
+                self.0 += LEGACY_CONST_SIZE;
+            }
+
+            fn visit_u16(&mut self, _depth: usize, _val: u16) {
+                self.0 += LEGACY_CONST_SIZE;
+            }
+
+            fn visit_u32(&mut self, _depth: usize, _val: u32) {
+                self.0 += LEGACY_CONST_SIZE;
+            }
+
+            fn visit_u64(&mut self, _depth: usize, _val: u64) {
+                self.0 += LEGACY_CONST_SIZE;
+            }
+
+            fn visit_u128(&mut self, _depth: usize, _val: u128) {
+                self.0 += LEGACY_CONST_SIZE;
+            }
+
+            fn visit_u256(&mut self, _depth: usize, _val: move_core_types::u256::U256) {
+                self.0 += LEGACY_CONST_SIZE;
+            }
+
+            fn visit_bool(&mut self, _depth: usize, _val: bool) {
+                self.0 += LEGACY_CONST_SIZE;
+            }
+
+            fn visit_address(&mut self, _depth: usize, _val: AccountAddress) {
+                self.0 += AbstractMemorySize::new(AccountAddress::LENGTH as u64);
+            }
+
+            fn visit_struct(&mut self, _depth: usize, _len: usize) -> bool {
+                self.0 += LEGACY_STRUCT_SIZE;
+                true
+            }
+
+            fn visit_vec(&mut self, _depth: usize, _len: usize) -> bool {
+                self.0 += LEGACY_STRUCT_SIZE;
+                true
+            }
+
+            fn visit_vec_u8(&mut self, _depth: usize, vals: &[u8]) {
+                self.0 += LEGACY_STRUCT_SIZE;
+                self.0 += ((size_of::<u8>() * vals.len()) as u64).into();
+            }
+
+            fn visit_vec_u16(&mut self, _depth: usize, vals: &[u16]) {
+                self.0 += LEGACY_STRUCT_SIZE;
+                self.0 += ((size_of::<u16>() * vals.len()) as u64).into();
+            }
+
+            fn visit_vec_u32(&mut self, _depth: usize, vals: &[u32]) {
+                self.0 += LEGACY_STRUCT_SIZE;
+                self.0 += ((size_of::<u32>() * vals.len()) as u64).into();
+            }
+
+            fn visit_vec_u64(&mut self, _depth: usize, vals: &[u64]) {
+                self.0 += LEGACY_STRUCT_SIZE;
+                self.0 += ((size_of::<u64>() * vals.len()) as u64).into();
+            }
+
+            fn visit_vec_u128(&mut self, _depth: usize, vals: &[u128]) {
+                self.0 += LEGACY_STRUCT_SIZE;
+                self.0 += ((size_of::<u128>() * vals.len()) as u64).into();
+            }
+
+            fn visit_vec_u256(&mut self, _depth: usize, vals: &[move_core_types::u256::U256]) {
+                self.0 += LEGACY_STRUCT_SIZE;
+                self.0 += ((size_of::<move_core_types::u256::U256>() * vals.len()) as u64).into();
+            }
+
+            fn visit_vec_bool(&mut self, _depth: usize, vals: &[bool]) {
+                self.0 += LEGACY_STRUCT_SIZE;
+                self.0 += ((size_of::<bool>() * vals.len()) as u64).into();
+            }
+
+            fn visit_vec_address(&mut self, _depth: usize, vals: &[AccountAddress]) {
+                self.0 += LEGACY_STRUCT_SIZE;
+                self.0 += ((size_of::<AccountAddress>() * vals.len()) as u64).into();
+            }
+
+            fn visit_ref(&mut self, _depth: usize, _is_global: bool) -> bool {
+                self.0 += LEGACY_REFERENCE_SIZE;
+                false
+            }
+        }
+
+        let mut acc = Acc(0.into());
+        self.visit(&mut acc);
+
+        acc.0
+    }
 }
 
 /// Trait that defines a visitor that could be used to traverse a value recursively.