Track detailed gas

Author: dariorussi

crates/sui-types/src/gas_model/tables.rs

@@ -70,6 +70,16 @@ pub struct GasStatus {
     instructions_current_tier_mult: u64,
 
     pub num_native_calls: u64,
+    pub transl_gas: u64,
+}
+
+#[derive(Debug)]
+pub struct GasDetails {
+    pub gas_left: u64,
+    pub instructions_executed: u64,
+    pub stack_height: u64,
+    pub memory_allocated: u64,
+    pub transl_gas_used: u64,
 }
 
 impl GasStatus {
@@ -106,6 +116,7 @@ impl GasStatus {
             stack_size_next_tier_start,
             instructions_next_tier_start,
             num_native_calls: 0,
+            transl_gas: 0,
         }
     }
 
@@ -133,6 +144,21 @@ impl GasStatus {
             stack_size_next_tier_start: None,
             instructions_next_tier_start: None,
             num_native_calls: 0,
+            transl_gas: 0,
+        }
+    }
+
+    pub fn set_transl_gas(&mut self, transl_gas: u64) {
+        self.transl_gas = transl_gas
+    }
+
+    pub fn gas_details(&self) -> GasDetails {
+        GasDetails {
+            gas_left: self.gas_left.into(),
+            instructions_executed: self.instructions_executed,
+            stack_height: self.stack_height_high_water_mark,
+            memory_allocated: self.stack_size_high_water_mark,
+            transl_gas_used: self.transl_gas,
         }
     }
 

sui-execution/latest/sui-adapter/src/execution_engine.rs

@@ -9,7 +9,6 @@ mod checked {
     use crate::execution_mode::{self, ExecutionMode};
     use crate::execution_value::SuiResolver;
     use csv::Writer;
-    use lz4_flex::frame::FrameEncoder;
     use move_binary_format::CompiledModule;
     use move_trace_format::format::MoveTraceBuilder;
     use move_vm_runtime::move_vm::MoveVM;
@@ -19,7 +18,6 @@ mod checked {
     use std::fs::File;
     use std::io::BufWriter;
     use std::sync::Mutex;
-    use similar::TextDiff;
     use std::{cell::RefCell, collections::HashSet, rc::Rc, sync::Arc};
     use sui_types::accumulator_root::{ACCUMULATOR_ROOT_CREATE_FUNC, ACCUMULATOR_ROOT_MODULE};
     use sui_types::balance::{
@@ -28,6 +26,7 @@ mod checked {
     };
     use sui_types::execution_params::ExecutionOrEarlyError;
     use sui_types::gas_coin::GAS;
+    use sui_types::gas_model::tables::GasDetails;
     use sui_types::messages_checkpoint::CheckpointTimestamp;
     use sui_types::metrics::LimitsMetrics;
     use sui_types::object::OBJECT_START_VERSION;
@@ -69,7 +68,6 @@ mod checked {
     use sui_types::error::{ExecutionError, ExecutionErrorKind};
     use sui_types::execution::{ExecutionTiming, ResultWithTimings};
     use sui_types::execution_status::{ExecutionFailureStatus, ExecutionStatus};
-    use sui_types::gas::GasCostSummary;
     use sui_types::gas::SuiGasStatus;
     use sui_types::gas::{GasCostSummary, GasUsageReport};
     use sui_types::id::UID;
@@ -93,14 +91,13 @@ mod checked {
         sui_system_state::{ADVANCE_EPOCH_FUNCTION_NAME, SUI_SYSTEM_MODULE_NAME},
     };
 
-    static CSV_WRITER: Lazy<Mutex<csv::Writer<FrameEncoder<std::io::BufWriter<std::fs::File>>>>> =
+    static CSV_WRITER: Lazy<Mutex<csv::Writer<std::io::BufWriter<std::fs::File>>>> =
         once_cell::sync::Lazy::new(|| {
-            let file = File::create("/opt/sui/gas.csv.lz4").expect("failed to create file");
-            let enc = BufWriter::new(file);
-            let enc = FrameEncoder::new(enc);
-            let mut writer = Writer::from_writer(enc);
+            let file = File::create("/opt/sui/gas.csv").expect("failed to create file");
+            let buf = BufWriter::new(file);
+            let mut writer = Writer::from_writer(buf);
             writer
-                .write_record(&[
+                .write_record([
                     "tx_digest",
                     "gas_budget",
                     "new_computation_cost",
@@ -111,6 +108,13 @@ mod checked {
                     "old_storage_rebate",
                     "new_gas_used",
                     "old_gas_used",
+                    "new_instructions",
+                    "old_instructions",
+                    "new_stack_height",
+                    "old_stack_hight",
+                    "new_memory_allocated",
+                    "old_memory_allocated",
+                    "translation",
                 ])
                 .expect("failed to write gas header");
             Mutex::new(writer)
@@ -120,13 +124,15 @@ mod checked {
         transaction_digest: String,
         new_gas: &GasUsageReport,
         old_gas: &GasUsageReport,
+        new_details: &GasDetails,
+        old_details: &GasDetails,
     ) {
         if new_gas.cost_summary == old_gas.cost_summary {
             return;
         }
         let mut writer = CSV_WRITER.lock().unwrap();
         writer
-            .write_record(&[
+            .write_record([
                 &transaction_digest,
                 &new_gas.gas_budget.to_string(),
                 &new_gas.cost_summary.computation_cost.to_string(),
@@ -137,6 +143,13 @@ mod checked {
                 &old_gas.cost_summary.storage_rebate.to_string(),
                 &new_gas.gas_used.to_string(),
                 &old_gas.gas_used.to_string(),
+                &new_details.instructions_executed.to_string(),
+                &old_details.instructions_executed.to_string(),
+                &new_details.stack_height.to_string(),
+                &old_details.stack_height.to_string(),
+                &new_details.memory_allocated.to_string(),
+                &old_details.memory_allocated.to_string(),
+                &new_details.transl_gas_used.to_string(),
             ])
             .expect("failed to write gas row");
         writer.flush().expect("failed to flush gas writer");
@@ -208,7 +221,8 @@ mod checked {
 
         compare_effects::<Mode>(&normal_effects, &new_effects);
 
-        normal_effects
+        let (temp_store, gas_status, effects, _gas_details, timing, res) = normal_effects;
+        (temp_store, gas_status, effects, timing, res)
     }
 
     #[instrument(name = "new_tx_execute_to_effects", level = "debug", skip_all)]
@@ -232,6 +246,7 @@ mod checked {
         InnerTemporaryStore,
         SuiGasStatus,
         TransactionEffects,
+        GasDetails,
         Vec<ExecutionTiming>,
         Result<Mode::ExecutionResults, ExecutionError>,
     ) {
@@ -306,6 +321,8 @@ mod checked {
             trace_builder_opt,
         );
 
+        let gas_details = gas_charger.move_gas_status().gas_details();
+
         let status = if let Err(error) = &execution_result {
             // Elaborate errors in logs if they are unexpected or their status is terse.
             use ExecutionErrorKind as K;
@@ -398,6 +415,7 @@ mod checked {
             inner,
             gas_charger.into_gas_status(),
             effects,
+            gas_details,
             timings,
             execution_result,
         )
@@ -408,13 +426,15 @@ mod checked {
             InnerTemporaryStore,
             SuiGasStatus,
             TransactionEffects,
+            GasDetails,
             Vec<ExecutionTiming>,
             Result<Mode::ExecutionResults, ExecutionError>,
         ),
         new_effects: &(
             InnerTemporaryStore,
             SuiGasStatus,
             TransactionEffects,
+            GasDetails,
             Vec<ExecutionTiming>,
             Result<Mode::ExecutionResults, ExecutionError>,
         ),
@@ -453,6 +473,8 @@ mod checked {
             normal_effects.2.transaction_digest().to_string(),
             &new_effects.1.gas_usage_report(),
             &normal_effects.1.gas_usage_report(),
+            &new_effects.3,
+            &normal_effects.3,
         );
 
         if !ok {

sui-execution/latest/sui-adapter/src/static_programmable_transactions/metering/translation_meter.rs

@@ -14,16 +14,32 @@ use sui_types::error::{ExecutionError, ExecutionErrorKind};
 pub struct TranslationMeter<'pc, 'gas> {
     protocol_config: &'pc ProtocolConfig,
     charger: &'gas mut GasCharger,
+    translation_gas: u64,
+}
+
+impl<'pc, 'gas> Drop for TranslationMeter<'pc, 'gas> {
+    fn drop(&mut self) {
+        let final_gas = self.charger.move_gas_status().gas_used_pre_gas_price();
+        if final_gas > self.translation_gas {
+            self.charger.move_gas_status_mut().set_transl_gas(
+                final_gas
+                    .checked_sub(self.translation_gas)
+                    .expect("translation gas should not fail"),
+            );
+        }
+    }
 }
 
 impl<'pc, 'gas> TranslationMeter<'pc, 'gas> {
     pub fn new(
         protocol_config: &'pc ProtocolConfig,
         gas_charger: &'gas mut GasCharger,
     ) -> TranslationMeter<'pc, 'gas> {
+        let translation_gas = gas_charger.move_gas_status().gas_used_pre_gas_price();
         TranslationMeter {
             protocol_config,
             charger: gas_charger,
+            translation_gas,
         }
     }
 

sui-execution/latest/sui-adapter/src/static_programmable_transactions/mod.rs

@@ -64,6 +64,7 @@ pub fn execute<Mode: ExecutionMode>(
     };
     let txn = typing::translate_and_verify::<Mode>(&mut translation_meter, &env, txn)
         .map_err(|e| (e, vec![]))?;
+    drop(translation_meter);
     execution::interpreter::execute::<Mode>(
         &mut env,
         metrics,