apply alex's idea of not re-quantizing at all.

Author: zhiqiangxu

Diff for: actors/miner/src/deadline_state.rs

@@ -108,13 +108,12 @@ impl Deadlines {
         store: &BS,
         orig_deadline: &mut Deadline,
         dest_deadline: &mut Deadline,
-        dest_quant: QuantSpec,
         partitions: &BitField,
     ) -> anyhow::Result<()> {
         let mut orig_partitions = orig_deadline.partitions_amt(store)?;
         let mut dest_partitions = dest_deadline.partitions_amt(store)?;
 
-        // even though we're moving partitions intact, we still need to update from/to `Deadline` accordingly.
+        // even though we're moving partitions intact, we still need to update orig/dest `Deadline` accordingly.
 
         let first_dest_partition_idx = dest_partitions.count();
         for (i, orig_partition_idx) in partitions.iter().enumerate() {
@@ -128,13 +127,13 @@ impl Deadlines {
 
             let dest_partition_idx = first_dest_partition_idx + i as u64;
 
-            moving_partition.adjust_for_move(store, &dest_quant)?;
+            moving_partition.adjust_for_move(store)?;
 
             let all_sectors = moving_partition.sectors.len();
             let live_sectors = moving_partition.live_sectors().len();
             let early_terminations = orig_deadline.early_terminations.get(orig_partition_idx);
 
-            // start updating from/to `Deadline` here
+            // start updating orig/dest `Deadline` here
 
             orig_deadline.total_sectors -= all_sectors;
             orig_deadline.live_sectors -= live_sectors;
@@ -162,16 +161,16 @@ impl Deadlines {
             let mut dest_expirations_epochs: Array<BitField, _> =
                 Array::load(&dest_deadline.expirations_epochs, store)?;
             orig_expirations_epochs.for_each_mut(|orig_epoch, orig_bitfield| {
-                let dest_epoch = dest_quant.quantize_up(orig_epoch as ChainEpoch);
+                let dest_epoch = orig_epoch;
                 let mut to_bitfield =
-                    dest_expirations_epochs.get(dest_epoch as u64)?.cloned().unwrap_or_default();
+                    dest_expirations_epochs.get(dest_epoch)?.cloned().unwrap_or_default();
                 for (i, partition_id) in partitions.iter().enumerate() {
                     if orig_bitfield.get(partition_id) {
                         orig_bitfield.unset(partition_id);
                         to_bitfield.set(first_dest_partition_idx + i as u64);
                     }
                 }
-                dest_expirations_epochs.set(dest_epoch as u64, to_bitfield)?;
+                dest_expirations_epochs.set(dest_epoch, to_bitfield)?;
 
                 if orig_bitfield.is_empty() {
                     epochs_to_remove.push(orig_epoch);

Diff for: actors/miner/src/lib.rs

@@ -2841,8 +2841,6 @@ impl Actor {
                     .context_code(ExitCode::USR_ILLEGAL_STATE, "while removing partitions")?;
             }
 
-            let dest_quant = state.quant_spec_for_deadline(policy, params.dest_deadline);
-
             let mut dest_deadline =
                 deadlines.load_deadline(store, params.dest_deadline).context_code(
                     ExitCode::USR_ILLEGAL_STATE,
@@ -2853,7 +2851,6 @@ impl Actor {
                 store,
                 &mut orig_deadline,
                 &mut dest_deadline,
-                dest_quant,
                 &params.partitions,
             )
             .context_code(ExitCode::USR_ILLEGAL_STATE, "failed to move partitions")?;

Diff for: actors/miner/src/partition_state.rs

@@ -824,11 +824,7 @@ impl Partition {
     }
 
     // ajust epoch info of expirations_epochs and early_terminated within `Partition`
-    pub fn adjust_for_move<BS: Blockstore>(
-        &mut self,
-        store: &BS,
-        dest_quant: &QuantSpec,
-    ) -> anyhow::Result<()> {
+    pub fn adjust_for_move<BS: Blockstore>(&mut self, store: &BS) -> anyhow::Result<()> {
         let orig_expirations_epochs: Array<ExpirationSet, _> =
             Array::load(&self.expirations_epochs, store)?;
 
@@ -845,13 +841,11 @@ impl Partition {
         );
 
         orig_expirations_epochs.for_each(|from_epoch, expire_set| {
-            dest_expirations_epochs
-                .set(dest_quant.quantize_up(from_epoch as ChainEpoch) as u64, expire_set.clone())?;
+            dest_expirations_epochs.set(from_epoch, expire_set.clone())?;
             Ok(())
         })?;
         orig_early_terminations.for_each(|from_epoch, bitfield| {
-            dest_early_terminations
-                .set(dest_quant.quantize_up(from_epoch as ChainEpoch) as u64, bitfield.clone())?;
+            dest_early_terminations.set(from_epoch, bitfield.clone())?;
             Ok(())
         })?;
         self.expirations_epochs = dest_expirations_epochs.flush()?;

Diff for: actors/miner/src/testing.rs

@@ -629,9 +629,6 @@ impl ExpirationQueueStateSummary {
         let ret = expiration_queue.amt.for_each(|epoch, expiration_set| {
             let epoch = epoch as i64;
             let acc = acc.with_prefix(format!("expiration epoch {epoch}: "));
-            let quant_up = quant.quantize_up(epoch);
-            acc.require(quant_up == epoch, format!("expiration queue key {epoch} is not quantized, expected {quant_up}"));
-
             expiration_epochs.push(epoch);
 
             let mut on_time_sectors_pledge = TokenAmount::zero();
@@ -643,8 +640,7 @@ impl ExpirationQueueStateSummary {
 
                 // check expiring sectors are still alive
                 if let Some(sector) = live_sectors.get(&sector_number) {
-                    let target = quant.quantize_up(sector.expiration);
-                    acc.require(epoch >= target && (epoch-target)%quant.unit ==0 , format!("invalid expiration {epoch} for sector {sector_number}, expected {target}"));
+                    acc.require(epoch >= sector.expiration , format!("invalid expiration {epoch} for sector {sector_number}"));
                     on_time_sectors_pledge += sector.initial_pledge.clone();
                 } else {
                     acc.add(format!("on time expiration sector {sector_number} isn't live"));