Rename AccountsDataMeter::consume (#23037)

program-runtime/src/accounts_data_meter.rs

@@ -73,20 +73,22 @@ impl AccountsDataMeter {
         self.maximum.saturating_sub(self.current())
     }
 
-    /// Consume accounts data space, in bytes.  If `amount` is positive, we are *increasing* the
+    /// Adjust the space used by accounts data by `amount` (in bytes).
-    /// amount of accounts data space used.  If `amount` is negative, we are *decreasing* the
+    ///
-    /// amount of accounts data space used.  If `amount` is greater than the remaining space,
+    /// If `amount` is *positive*, we *increase* the space used by accounts data.  If `amount` is
-    /// return an error and *do not* consume more accounts data space.
+    /// *negative*, we *decrease* the space used by accounts data.  If `amount` is greater than
-    pub fn consume(&mut self, amount: i64) -> Result<(), InstructionError> {
+    /// the remaining space, return an error and *do not* adjust accounts data space.
+    pub fn adjust_delta(&mut self, amount: i64) -> Result<(), InstructionError> {
         if amount > self.remaining() as i64 {
             return Err(InstructionError::AccountsDataBudgetExceeded);
         }
-        self.consume_unchecked(amount);
+        self.adjust_delta_unchecked(amount);
         Ok(())
     }
 
-    /// Unconditionally consume accounts data space.  Refer to `consume()` for more documentation.
+    /// Unconditionally adjust accounts data space.  Refer to `adjust_delta()` for more
-    pub fn consume_unchecked(&mut self, amount: i64) {
+    /// documentation.
+    pub fn adjust_delta_unchecked(&mut self, amount: i64) {
         self.delta = self.delta.saturating_add(amount);
     }
 }
@@ -141,63 +143,65 @@ mod tests {
     }
 
     #[test]
-    fn test_consume() {
+    fn test_adjust_delta() {
         let initial_accounts_data_len = 0;
         let mut accounts_data_meter = AccountsDataMeter::new(initial_accounts_data_len);
 
         // Test: simple, positive numbers
-        let result = accounts_data_meter.consume(0);
+        let result = accounts_data_meter.adjust_delta(0);
         assert!(result.is_ok());
-        let result = accounts_data_meter.consume(1);
+        let result = accounts_data_meter.adjust_delta(1);
         assert!(result.is_ok());
-        let result = accounts_data_meter.consume(4);
+        let result = accounts_data_meter.adjust_delta(4);
         assert!(result.is_ok());
-        let result = accounts_data_meter.consume(9);
+        let result = accounts_data_meter.adjust_delta(9);
         assert!(result.is_ok());
 
-        // Test: can consume the remaining amount
+        // Test: adjust_delta can use up the remaining amount
         let remaining = accounts_data_meter.remaining() as i64;
-        let result = accounts_data_meter.consume(remaining);
+        let result = accounts_data_meter.adjust_delta(remaining);
         assert!(result.is_ok());
         assert_eq!(accounts_data_meter.remaining(), 0);
     }
 
     #[test]
-    fn test_consume_deallocate() {
+    fn test_adjust_delta_deallocate() {
         let initial_accounts_data_len = 10_000;
         let mut accounts_data_meter = AccountsDataMeter::new(initial_accounts_data_len);
         let remaining_before = accounts_data_meter.remaining();
 
         let amount = (initial_accounts_data_len / 2) as i64;
         let amount = -amount;
-        let result = accounts_data_meter.consume(amount);
+        let result = accounts_data_meter.adjust_delta(amount);
         assert!(result.is_ok());
         let remaining_after = accounts_data_meter.remaining();
         assert_eq!(remaining_after, remaining_before + amount.abs() as u64);
     }
 
     #[test]
-    fn test_consume_too_much() {
+    fn test_adjust_delta_exceeding() {
         let initial_accounts_data_len = 0;
         let mut accounts_data_meter = AccountsDataMeter::new(initial_accounts_data_len);
 
-        // Test: consuming more than what's available (1) returns an error, (2) does not consume
+        // Test: adjusting delta by more than what's available
+        // (1) returns an error,
+        // (2) does not adjust delta
         let remaining = accounts_data_meter.remaining();
-        let result = accounts_data_meter.consume(remaining as i64 + 1);
+        let result = accounts_data_meter.adjust_delta(remaining as i64 + 1);
         assert!(result.is_err());
         assert_eq!(accounts_data_meter.remaining(), remaining);
     }
 
     #[test]
-    fn test_consume_zero() {
+    fn test_adjust_delta_zero() {
         // Pre-condition: set up the accounts data meter such that there is no remaining space
         let initial_accounts_data_len = 1234;
         let mut accounts_data_meter = AccountsDataMeter::new(initial_accounts_data_len);
         accounts_data_meter.maximum = initial_accounts_data_len;
         assert_eq!(accounts_data_meter.remaining(), 0);
 
-        // Test: can always consume zero, even if there is no remaining space
+        // Test: can always adjust delta by zero, even if there is no remaining space
-        let result = accounts_data_meter.consume(0);
+        let result = accounts_data_meter.adjust_delta(0);
         assert!(result.is_ok());
     }
 }

program-runtime/src/invoke_context.rs

@@ -507,9 +507,10 @@ impl<'a> InvokeContext<'a> {
             let post_data_len = account.data().len() as i64;
             let data_len_delta = post_data_len.saturating_sub(pre_data_len);
             if cap_accounts_data_len {
-                self.accounts_data_meter.consume(data_len_delta)?;
+                self.accounts_data_meter.adjust_delta(data_len_delta)?;
             } else {
-                self.accounts_data_meter.consume_unchecked(data_len_delta);
+                self.accounts_data_meter
+                    .adjust_delta_unchecked(data_len_delta);
             }
 
             Ok(())
@@ -600,9 +601,10 @@ impl<'a> InvokeContext<'a> {
                         let post_data_len = account.data().len() as i64;
                         let data_len_delta = post_data_len.saturating_sub(pre_data_len);
                         if cap_accounts_data_len {
-                            self.accounts_data_meter.consume(data_len_delta)?;
+                            self.accounts_data_meter.adjust_delta(data_len_delta)?;
                         } else {
-                            self.accounts_data_meter.consume_unchecked(data_len_delta);
+                            self.accounts_data_meter
+                                .adjust_delta_unchecked(data_len_delta);
                         }
 
                         return Ok(());