package sectorstorage import ( "context" "sync" "time" ffi "github.com/filecoin-project/filecoin-ffi" "github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper" builtin6 "github.com/filecoin-project/specs-actors/v6/actors/builtin" "github.com/hashicorp/go-multierror" xerrors "golang.org/x/xerrors" "github.com/filecoin-project/specs-actors/actors/runtime/proof" ) func (m *Manager) GenerateWinningPoSt(ctx context.Context, minerID abi.ActorID, sectorInfo []proof.SectorInfo, randomness abi.PoStRandomness) ([]proof.PoStProof, error) { if !m.sched.winningPoStSched.CanSched(ctx) { log.Info("GenerateWinningPoSt run at lotus-miner") return m.Prover.GenerateWinningPoSt(ctx, minerID, sectorInfo, randomness) } return m.generateWinningPoSt(ctx, minerID, sectorInfo, randomness) } func (m *Manager) generateWinningPoSt(ctx context.Context, minerID abi.ActorID, sectorInfo []proof.SectorInfo, randomness abi.PoStRandomness) ([]proof.PoStProof, error) { randomness[31] &= 0x3f ps, skipped, done, err := m.PubSectorToPriv(ctx, minerID, sectorInfo, nil, abi.RegisteredSealProof.RegisteredWinningPoStProof) if err != nil { return nil, err } defer done() if len(skipped) > 0 { return nil, xerrors.Errorf("pubSectorToPriv skipped sectors: %+v", skipped) } var sectorNums []abi.SectorNumber for _, s := range ps.Values() { sectorNums = append(sectorNums, s.SectorNumber) } postChallenges, err := m.GeneratePoStFallbackSectorChallenges(ctx, ps.Values()[0].PoStProofType, minerID, randomness, sectorNums) if err != nil { return nil, xerrors.Errorf("generating fallback challenges: %v", err) } var proofs []proof.PoStProof err = m.sched.winningPoStSched.Schedule(ctx, false, func(ctx context.Context, w Worker) error { out, err := w.GenerateWinningPoSt(ctx, minerID, ps, randomness, postChallenges) if err != nil { return err } proofs = out return nil }) if err != nil { return nil, err } return proofs, nil } func (m *Manager) GenerateWindowPoSt(ctx context.Context, minerID abi.ActorID, sectorInfo []proof.SectorInfo, randomness abi.PoStRandomness) (proof []proof.PoStProof, skipped []abi.SectorID, err error) { if !m.sched.windowPoStSched.CanSched(ctx) { log.Info("GenerateWindowPoSt run at lotus-miner") return m.Prover.GenerateWindowPoSt(ctx, minerID, sectorInfo, randomness) } return m.generateWindowPoSt(ctx, minerID, sectorInfo, randomness) } func (m *Manager) generateWindowPoSt(ctx context.Context, minerID abi.ActorID, sectorInfo []proof.SectorInfo, randomness abi.PoStRandomness) ([]proof.PoStProof, []abi.SectorID, error) { var retErr error = nil randomness[31] &= 0x3f out := make([]proof.PoStProof, 0) if len(sectorInfo) == 0 { return nil, nil, xerrors.New("generate window post len(sectorInfo)=0") } //get window proof type proofType, err := abi.RegisteredSealProof.RegisteredWindowPoStProof(sectorInfo[0].SealProof) if err != nil { return nil, nil, err } // Get sorted and de-duplicate sectors info ps, skipped, done, err := m.PubSectorToPriv(ctx, minerID, sectorInfo, nil, abi.RegisteredSealProof.RegisteredWindowPoStProof) if err != nil { return nil, nil, xerrors.Errorf("PubSectorToPriv failed: %+v", err) } if len(skipped) > 0 { return nil, skipped, xerrors.Errorf("skipped = %d", len(skipped)) } defer done() partitionSectorsCount, err := builtin6.PoStProofWindowPoStPartitionSectors(proofType) if err != nil { return nil, nil, xerrors.Errorf("get sectors count of partition failed:%+v", err) } // The partitions number of this batch partitionCount := (len(ps.Values()) + int(partitionSectorsCount) - 1) / int(partitionSectorsCount) log.Infof("generateWindowPoSt len(partitionSectorsCount):%d len(partitionCount):%d \n", partitionSectorsCount, partitionCount) var faults []abi.SectorID var flk sync.Mutex cctx, cancel := context.WithCancel(ctx) defer cancel() var sectorNums []abi.SectorNumber for _, s := range ps.Values() { sectorNums = append(sectorNums, s.SectorNumber) } postChallenges, err := m.GeneratePoStFallbackSectorChallenges(ctx, ps.Values()[0].PoStProofType, minerID, randomness, sectorNums) if err != nil { return nil, nil, xerrors.Errorf("generating fallback challenges: %v", err) } proofList := make([]ffi.PartitionProof, partitionCount) var wg sync.WaitGroup for i := 0; i < partitionCount; i++ { wg.Add(1) go func(n int) { defer wg.Done() proof, faultsectors, err := m.generatePartitionWindowPost(cctx, minerID, n, int(partitionSectorsCount), partitionCount, ps, randomness, postChallenges) if err != nil { retErr = multierror.Append(retErr, xerrors.Errorf("partitionCount:%d err:%+v", i, err)) if len(faultsectors) > 0 { log.Errorf("generateWindowPost groupCount:%d, faults:%d, err: %+v", i, len(faultsectors), err) flk.Lock() faults = append(faults, faultsectors...) flk.Unlock() } cancel() return } proofList[n] = proof }(i) time.Sleep(1 * time.Second) } wg.Wait() postProofs, err := ffi.MergeWindowPoStPartitionProofs(proofType, proofList) if len(faults) > 0 { log.Warnf("GenerateWindowPoSt get faults: %d", len(faults)) return out, faults, retErr } out = append(out, *postProofs) return out, skipped, retErr } func (m *Manager) generatePartitionWindowPost(ctx context.Context, minerID abi.ActorID, index int, psc int, groupCount int, ps ffi.SortedPrivateSectorInfo, randomness abi.PoStRandomness, postChallenges *ffi.FallbackChallenges) (ffi.PartitionProof, []abi.SectorID, error) { var faults []abi.SectorID start := index * psc end := (index + 1) * psc if index == groupCount-1 { end = len(ps.Values()) } log.Infow("generateWindowPost", "start", start, "end", end, "index", index) privsectors, err := m.SplitSortedPrivateSectorInfo(ctx, ps, start, end) if err != nil { return ffi.PartitionProof{}, faults, xerrors.Errorf("generateWindowPost GetScopeSortedPrivateSectorInfo failed: %w", err) } var result *ffiwrapper.WindowPoStResult err = m.sched.windowPoStSched.Schedule(ctx, true, func(ctx context.Context, w Worker) error { out, err := w.GenerateWindowPoSt(ctx, minerID, privsectors, index, start, randomness, postChallenges) if err != nil { return err } result = &out return nil }) if err != nil { return ffi.PartitionProof{}, faults, err } if len(result.Skipped) > 0 { log.Warnf("generateWindowPost partition:%d, get faults:%d", index, len(result.Skipped)) return ffi.PartitionProof{}, result.Skipped, xerrors.Errorf("generatePartitionWindowPoStProofs partition:%d get faults:%d", index, len(result.Skipped)) } return result.PoStProofs, faults, err }