mili->milli

fvm/src/call_manager/default.rs

@@ -331,10 +331,10 @@ where
                 super::NO_DATA_BLOCK_ID
             };
 
-            let initial_miligas = max(kernel.get_miligas(), 0);
+            let initial_milligas = max(kernel.get_milligas(), 0);
 
             // Make a store and available gas
-            let mut store = engine.new_store(kernel, initial_miligas);
+            let mut store = engine.new_store(kernel, initial_milligas);
 
             // Instantiate the module.
             let instance = match engine
@@ -347,7 +347,7 @@ where
                     store
                         .data_mut()
                         .kernel
-                        .set_available_miligas("getinstance_fail", initial_miligas)
+                        .set_available_milligas("getinstance_fail", initial_milligas)
                         .unwrap();
                     return (Err(err), store.into_data().kernel.into_call_manager());
                 }
@@ -366,7 +366,7 @@ where
 
                 // Update GasTracker gas
                 use wasmtime::Val;
-                let available_miligas =
+                let available_milligas =
                     match store.data_mut().avail_gas_global.unwrap().get(&mut store) {
                         Val::I64(g) => Ok(g),
                         _ => Err(Abort::Fatal(anyhow::Error::msg("failed to get wasm gas"))),
@@ -375,7 +375,7 @@ where
                 store
                     .data_mut()
                     .kernel
-                    .set_available_miligas("wasm_exec_last", available_miligas)
+                    .set_available_milligas("wasm_exec_last", available_milligas)
                     .map_err(|e| match e {
                         ExecutionError::OutOfGas => Abort::OutOfGas,
                         ExecutionError::Fatal(m) => Abort::Fatal(m),

fvm/src/gas/mod.rs

@@ -10,111 +10,111 @@ mod charge;
 mod outputs;
 mod price_list;
 
-pub const MILIGAS_PRECISION: i64 = 1000;
+pub const MILLIGAS_PRECISION: i64 = 1000;
 
 pub struct GasTracker {
-    // TODO: convert to miligas
-    miligas_limit: i64,
-    miligas_used: i64,
+    // TODO: convert to milligas
+    milligas_limit: i64,
+    milligas_used: i64,
 
     own_limit: bool,
 }
 
 impl GasTracker {
     pub fn new(gas_limit: i64, gas_used: i64) -> Self {
         Self {
-            miligas_limit: gas_to_miligas(gas_limit),
-            miligas_used: gas_to_miligas(gas_used),
+            milligas_limit: gas_to_milligas(gas_limit),
+            milligas_used: gas_to_milligas(gas_used),
             own_limit: true,
         }
     }
 
     /// Safely consumes gas and returns an out of gas error if there is not sufficient
     /// enough gas remaining for charge.
-    fn charge_miligas(&mut self, name: &str, to_use: i64) -> Result<()> {
+    fn charge_milligas(&mut self, name: &str, to_use: i64) -> Result<()> {
         if !self.own_limit {
             panic!("charge_gas called when gas_limit owned by execution")
         }
 
-        match self.miligas_used.checked_add(to_use) {
+        match self.milligas_used.checked_add(to_use) {
             None => {
                 log::trace!("gas overflow: {}", name);
-                self.miligas_used = self.miligas_limit;
+                self.milligas_used = self.milligas_limit;
                 Err(ExecutionError::OutOfGas)
             }
             Some(used) => {
                 log::trace!("charged {} gas: {}", to_use, name);
-                if used > self.miligas_limit {
+                if used > self.milligas_limit {
                     log::trace!("out of gas: {}", name);
-                    self.miligas_used = self.miligas_limit;
+                    self.milligas_used = self.milligas_limit;
                     Err(ExecutionError::OutOfGas)
                 } else {
-                    self.miligas_used = used;
+                    self.milligas_used = used;
                     Ok(())
                 }
             }
         }
     }
 
     pub fn charge_gas(&mut self, charge: GasCharge) -> Result<()> {
-        self.charge_miligas(charge.name, charge.total() * MILIGAS_PRECISION)
+        self.charge_milligas(charge.name, charge.total() * MILLIGAS_PRECISION)
     }
 
-    /// returns available miligas; makes the gas tracker block gas charges until
+    /// returns available milligas; makes the gas tracker block gas charges until
     /// set_available_gas is called
-    pub fn get_miligas(&mut self) -> i64 {
+    pub fn get_milligas(&mut self) -> i64 {
         if !self.own_limit {
             panic!("get_gas called when gas_limit owned by execution")
         }
         self.own_limit = false;
 
-        self.miligas_limit - self.miligas_used
+        self.milligas_limit - self.milligas_used
     }
 
     /// sets new available gas, creating a new gas charge if needed
-    pub fn set_available_miligas(&mut self, name: &str, new_avail_mgas: i64) -> Result<()> {
+    pub fn set_available_milligas(&mut self, name: &str, new_avail_mgas: i64) -> Result<()> {
         if self.own_limit {
             panic!("gastracker already owns gas_limit, charge: {}", name)
         }
         self.own_limit = true;
 
-        let old_avail_miligas = self.miligas_limit - self.miligas_used;
-        let used = old_avail_miligas - new_avail_mgas;
+        let old_avail_milligas = self.milligas_limit - self.milligas_used;
+        let used = old_avail_milligas - new_avail_mgas;
 
         if used < 0 {
             return Err(ExecutionError::Fatal(anyhow::Error::msg(
                 "negative gas charge in set_available_gas",
             )));
         }
 
-        self.charge_miligas(name, used)
+        self.charge_milligas(name, used)
     }
 
     /// Getter for gas available.
     pub fn gas_limit(&self) -> i64 {
-        miligas_to_gas(self.miligas_limit, false)
+        milligas_to_gas(self.milligas_limit, false)
     }
 
     /// Getter for gas used.
     pub fn gas_used(&self) -> i64 {
-        miligas_to_gas(self.miligas_used, true)
+        milligas_to_gas(self.milligas_used, true)
     }
 }
 
 /// Converts the specified gas into equivalent fractional gas units
 #[inline]
-fn gas_to_miligas(gas: i64) -> i64 {
-    gas * MILIGAS_PRECISION
+fn gas_to_milligas(gas: i64) -> i64 {
+    gas * MILLIGAS_PRECISION
 }
 
 /// Converts the specified fractional gas units into gas units
 #[inline]
-fn miligas_to_gas(miligas: i64, round_up: bool) -> i64 {
-    let mut div_result = miligas / MILIGAS_PRECISION;
-    if miligas > 0 && round_up && miligas % MILIGAS_PRECISION != 0 {
+fn milligas_to_gas(milligas: i64, round_up: bool) -> i64 {
+    let mut div_result = milligas / MILLIGAS_PRECISION;
+    if milligas > 0 && round_up && milligas % MILLIGAS_PRECISION != 0 {
         div_result = div_result.saturating_add(1);
     }
-    if miligas < 0 && !round_up && miligas % MILIGAS_PRECISION != 0 {
+    if milligas < 0 && !round_up && milligas % MILLIGAS_PRECISION != 0 {
         div_result = div_result.saturating_sub(1);
     }
     div_result
@@ -135,10 +135,10 @@ mod tests {
     }
 
     #[test]
-    fn miligas_to_gas_round() {
-        assert_eq!(miligas_to_gas(100, false), 0);
-        assert_eq!(miligas_to_gas(100, true), 1);
-        assert_eq!(miligas_to_gas(-100, false), -1);
-        assert_eq!(miligas_to_gas(-100, true), 0);
+    fn milligas_to_gas_round() {
+        assert_eq!(milligas_to_gas(100, false), 0);
+        assert_eq!(milligas_to_gas(100, true), 1);
+        assert_eq!(milligas_to_gas(-100, false), -1);
+        assert_eq!(milligas_to_gas(-100, true), 0);
     }
 }

fvm/src/gas/price_list.rs

@@ -260,7 +260,7 @@ lazy_static! {
         // TODO: PARAM_FINISH
         block_stat: 1,
 
-        exec_instruction_cost_fr: (gas::MILIGAS_PRECISION / 2) as u64,
+        exec_instruction_cost_fr: (gas::MILLIGAS_PRECISION / 2) as u64,
         // TODO: PARAM_FINISH
     };
 }

fvm/src/kernel/default.rs

@@ -760,14 +760,14 @@ where
         self.call_manager.charge_gas(charge)
     }
 
-    fn set_available_miligas(&mut self, name: &str, new_gas: i64) -> Result<()> {
+    fn set_available_milligas(&mut self, name: &str, new_gas: i64) -> Result<()> {
         self.call_manager
             .gas_tracker_mut()
-            .set_available_miligas(name, new_gas)
+            .set_available_milligas(name, new_gas)
     }
 
-    fn get_miligas(&mut self) -> i64 {
-        self.call_manager.gas_tracker_mut().get_miligas()
+    fn get_milligas(&mut self) -> i64 {
+        self.call_manager.gas_tracker_mut().get_milligas()
     }
 
     fn price_list(&self) -> &PriceList {

fvm/src/kernel/mod.rs

@@ -228,10 +228,10 @@ pub trait GasOps {
     fn charge_gas(&mut self, name: &str, compute: i64) -> Result<()>;
 
     /// Returns available gas.
-    fn get_miligas(&mut self) -> i64;
+    fn get_milligas(&mut self) -> i64;
 
     /// Sets available gas to a new value, creating a gas charge if needed
-    fn set_available_miligas(&mut self, name: &str, newgas: i64) -> Result<()>;
+    fn set_available_milligas(&mut self, name: &str, newgas: i64) -> Result<()>;
 
     fn price_list(&self) -> &PriceList;
 }

fvm/src/machine/engine.rs

@@ -257,12 +257,12 @@ impl Engine {
     pub fn new_store<K: Kernel>(
         &self,
         kernel: K,
-        miligas: i64,
+        milligas: i64,
     ) -> wasmtime::Store<InvocationData<K>> {
         let mut store = wasmtime::Store::new(&self.0.engine, InvocationData::new(kernel));
 
         let ggtype = GlobalType::new(ValType::I64, Mutability::Var);
-        let gg = Global::new(&mut store, ggtype, Val::I64(miligas))
+        let gg = Global::new(&mut store, ggtype, Val::I64(milligas))
             .expect("failed to create available_gas global");
         store.data_mut().avail_gas_global = Some(gg);
 

fvm/src/syscalls/bind.rs

@@ -99,18 +99,18 @@ fn memory_and_data<'a, K: Kernel>(
 }
 
 fn gastracker_to_wasmgas(caller: &mut Caller<InvocationData<impl Kernel>>) -> Result<(), Trap> {
-    let avail_miligas = caller.data_mut().kernel.get_miligas();
+    let avail_milligas = caller.data_mut().kernel.get_milligas();
     let gas_global = caller.data_mut().avail_gas_global.unwrap();
 
     gas_global
-        .set(caller, Val::I64(avail_miligas))
+        .set(caller, Val::I64(avail_milligas))
         .map_err(|_| Trap::new("failed to set available gas"))
 }
 
 fn wasmgas_to_gastracker(caller: &mut Caller<InvocationData<impl Kernel>>) -> Result<(), Trap> {
     let global = caller.data_mut().avail_gas_global;
 
-    let miligas = match global.unwrap().get(&mut *caller) {
+    let milligas = match global.unwrap().get(&mut *caller) {
         Val::I64(g) => Ok(g),
         _ => Err(Trap::new("failed to get wasm gas")),
     }?;
@@ -120,7 +120,7 @@ fn wasmgas_to_gastracker(caller: &mut Caller<InvocationData<impl Kernel>>) -> Re
     caller
         .data_mut()
         .kernel
-        .set_available_miligas("wasm_exec", miligas)
+        .set_available_milligas("wasm_exec", milligas)
         .map_err(|_| Trap::new("setting available gas"))?;
     Ok(())
 }

testing/conformance/src/vm.rs

@@ -496,12 +496,12 @@ where
         self.0.charge_gas(name, compute)
     }
 
-    fn get_miligas(&mut self) -> i64 {
-        self.0.get_miligas()
+    fn get_milligas(&mut self) -> i64 {
+        self.0.get_milligas()
     }
 
-    fn set_available_miligas(&mut self, name: &str, newgas: i64) -> Result<()> {
-        self.0.set_available_miligas(name, newgas)
+    fn set_available_milligas(&mut self, name: &str, newgas: i64) -> Result<()> {
+        self.0.set_available_milligas(name, newgas)
     }
 
     fn price_list(&self) -> &PriceList {