Feature: move partition

actors/miner/src/deadline_state.rs

@@ -23,6 +23,7 @@ use super::{
     BitFieldQueue, ExpirationSet, Partition, PartitionSectorMap, PoStPartition, PowerPair,
     SectorOnChainInfo, Sectors, TerminationResult,
 };
+
 use crate::SECTORS_AMT_BITWIDTH;
 
 // Bitwidth of AMTs determined empirically from mutation patterns and projections of mainnet data.
@@ -99,6 +100,94 @@ impl Deadlines {
         self.due[deadline_idx as usize] = store.put_cbor(deadline, Code::Blake2b256)?;
         Ok(())
     }
+
+    pub fn move_partitions<BS: Blockstore>(
+        store: &BS,
+        from_deadline: &mut Deadline,
+        to_deadline: &mut Deadline,
+        to_quant: QuantSpec,
+        partitions: &BitField,
+    ) -> anyhow::Result<()> {
+        let mut from_partitions = from_deadline.partitions_amt(store)?;
+        let mut to_partitions = to_deadline.partitions_amt(store)?;
+
+        // even though we're moving partitions intact, we still need to update from/to `Deadline` accordingly.
+
+        let first_to_partition_idx = to_partitions.count();
+        for (i, from_partition_idx) in partitions.iter().enumerate() {
+            let mut moving_partition = from_partitions
+                .get(from_partition_idx)?
+                .ok_or_else(|| actor_error!(not_found, "no partition {}", from_partition_idx))?
+                .clone();
+            if !moving_partition.faults.is_empty() || !moving_partition.unproven.is_empty() {
+                return Err(actor_error!(forbidden, "partition with faults or unproven sectors are not allowed to move, partition_idx {}", from_partition_idx))?;
+            }
+
+            let to_partition_idx = first_to_partition_idx + i as u64;
+
+            moving_partition.adjust_for_move(store, &to_quant)?;
+
+            let all_sectors = moving_partition.sectors.len();
+            let live_sectors = moving_partition.live_sectors().len();
+            let early_terminations = from_deadline.early_terminations.get(from_partition_idx);
+
+            // start updating from/to `Deadline` here
+
+            from_deadline.total_sectors -= all_sectors;
+            from_deadline.live_sectors -= live_sectors;
+            from_deadline.faulty_power -= &moving_partition.faulty_power;
+
+            to_deadline.total_sectors += all_sectors;
+            to_deadline.live_sectors += live_sectors;
+            to_deadline.faulty_power += &moving_partition.faulty_power;
+
+            // update early_terminations BitField of `Deadline`
+            if early_terminations {
+                from_deadline.early_terminations.unset(from_partition_idx);
+                to_deadline.early_terminations.set(to_partition_idx);
+            }
+
+            from_partitions.set(from_partition_idx, Partition::new(store)?)?;
+            to_partitions.set(to_partition_idx, moving_partition)?;
+        }
+
+        // update expirations_epochs Cid of Deadline.
+        {
+            let mut epochs_to_remove = Vec::<u64>::new();
+            let mut from_expirations_epochs: Array<BitField, _> =
+                Array::load(&from_deadline.expirations_epochs, store)?;
+            let mut to_expirations_epochs: Array<BitField, _> =
+                Array::load(&to_deadline.expirations_epochs, store)?;
+            from_expirations_epochs.for_each_mut(|from_epoch, from_bitfield| {
+                let to_epoch = to_quant.quantize_up(from_epoch as ChainEpoch);
+                let mut to_bitfield =
+                    to_expirations_epochs.get(to_epoch as u64)?.cloned().unwrap_or_default();
+                for (i, partition_id) in partitions.iter().enumerate() {
+                    if from_bitfield.get(partition_id) {
+                        from_bitfield.unset(partition_id);
+                        to_bitfield.set(first_to_partition_idx + i as u64);
+                    }
+                }
+                to_expirations_epochs.set(to_epoch as u64, to_bitfield)?;
+
+                if from_bitfield.is_empty() {
+                    epochs_to_remove.push(from_epoch);
+                }
+
+                Ok(())
+            })?;
+            if !epochs_to_remove.is_empty() {
+                from_expirations_epochs.batch_delete(epochs_to_remove, true)?;
+            }
+            from_deadline.expirations_epochs = from_expirations_epochs.flush()?;
+            to_deadline.expirations_epochs = to_expirations_epochs.flush()?;
+        }
+
+        from_deadline.partitions = from_partitions.flush()?;
+        to_deadline.partitions = to_partitions.flush()?;
+
+        Ok(())
+    }
 }
 
 /// Deadline holds the state for all sectors due at a specific deadline.

actors/miner/src/deadlines.rs

@@ -128,6 +128,73 @@ pub fn deadline_available_for_compaction(
         )
 }
 
+// the distance between from_deadline and to_deadline clockwise in deadline unit.
+fn deadline_distance(policy: &Policy, from_deadline: u64, to_deadline: u64) -> u64 {
+    if to_deadline >= from_deadline {
+        to_deadline - from_deadline
+    } else {
+        policy.wpost_period_deadlines - from_deadline + to_deadline
+    }
+}
+
+// only allow moving to a nearer deadline from current one
+pub fn deadline_available_for_move(
+    policy: &Policy,
+    from_deadline: u64,
+    to_deadline: u64,
+    current_deadline: &DeadlineInfo,
+) -> Result<(), String> {
+    if !deadline_is_mutable(
+        policy,
+        current_deadline.period_start,
+        from_deadline,
+        current_deadline.current_epoch,
+    ) {
+        return Err(format!(
+            "cannot move from a deadline {}, immutable at epoch {}",
+            from_deadline, current_deadline.current_epoch
+        ));
+    }
+
+    if !deadline_is_mutable(
+        policy,
+        current_deadline.period_start,
+        to_deadline,
+        current_deadline.current_epoch,
+    ) {
+        return Err(format!(
+            "cannot move to a deadline {}, immutable at epoch {}",
+            to_deadline, current_deadline.current_epoch
+        ));
+    }
+
+    if deadline_distance(policy, current_deadline.index, to_deadline)
+        >= deadline_distance(policy, current_deadline.index, from_deadline)
+    {
+        return Err(format!(
+            "can only move to a deadline which is nearer from current deadline {}, to_deadline {} is not nearer than from_deadline {}",
+            current_deadline.index, to_deadline, from_deadline
+        ));
+    }
+
+    Ok(())
+}
+
+// returns the nearest deadline info with index `target_deadline` that has already occured from the point of view of the current deadline(including the current deadline).
+pub fn nearest_occured_deadline_info(
+    policy: &Policy,
+    current_deadline: &DeadlineInfo,
+    target_deadline: u64,
+) -> DeadlineInfo {
+    // Find the proving period start for the deadline in question.
+    let mut pp_start = current_deadline.period_start;
+    if current_deadline.index < target_deadline {
+        pp_start -= policy.wpost_proving_period
+    }
+
+    new_deadline_info(policy, pp_start, target_deadline, current_deadline.current_epoch)
+}
+
 // Determine current period start and deadline index directly from current epoch and
 // the offset implied by the proving period. This works correctly even for the state
 // of a miner actor without an active deadline cron