changing level of abstration. some work remains

cmd/curio/deps/deps.go

@@ -308,7 +308,7 @@ Get it with: jq .PrivateKey ~/.lotus-miner/keystore/MF2XI2BNNJ3XILLQOJUXMYLUMU`,
 	}
 
 	if deps.CurioFfiWrap == nil {
-		deps.CurioFfiWrap = &ffiselect.CurioFFIWrap{Layers: deps.Layers}
+		deps.CurioFfiWrap = &ffiselect.CurioFFIWrap{}
 	}
 	if deps.Maddrs == nil {
 		deps.Maddrs = map[dtypes.MinerAddress]bool{}

cmd/curio/ffi.go

@@ -1,21 +1,17 @@
 package main
 
 import (
-	"context"
 	"encoding/gob"
 	"fmt"
 	"os"
 	"reflect"
 
 	"github.com/samber/lo"
 	"github.com/urfave/cli/v2"
-	"golang.org/x/xerrors"
 
-	"github.com/filecoin-project/lotus/cmd/curio/deps"
+	ffidirect "github.com/filecoin-project/lotus/lib/ffiselect/ffidirect"
+
 	"github.com/filecoin-project/lotus/lib/ffiselect"
-	"github.com/filecoin-project/lotus/storage/paths"
-	"github.com/filecoin-project/lotus/storage/sealer/ffiwrapper"
-	"github.com/filecoin-project/lotus/storage/sealer/storiface"
 )
 
 var ffiCmd = &cli.Command{
@@ -32,85 +28,29 @@ var ffiCmd = &cli.Command{
 				err = fmt.Errorf("panic: %v", r)
 			}
 			if err != nil {
-				gob.NewEncoder(output).Encode(ffiselect.ValErr{Val: nil, Err: err})
+				err = gob.NewEncoder(output).Encode(ffiselect.ValErr{Val: nil, Err: err})
+				if err != nil {
+					panic(err)
+				}
 			}
 		}()
 		var callInfo ffiselect.FFICall
 		if err := gob.NewDecoder(os.Stdin).Decode(&callInfo); err != nil {
 			return err
 		}
 
-		// wasteful, but *should* work
-		depnd, err := deps.GetDeps(cctx.Context, cctx)
-
-		w, err := ffiwrapper.New(&sectorProvider{index: depnd.Si, stor: depnd.LocalStore})
-		if err != nil {
-			return err
-		}
-
 		args := lo.Map(callInfo.Args, func(arg any, i int) reflect.Value {
 			return reflect.ValueOf(arg)
 		})
 
 		// All methods 1st arg is a context, not passed in.
 		args = append([]reflect.Value{reflect.ValueOf(cctx.Context)}, args...)
 
-		resAry := reflect.ValueOf(w).MethodByName(callInfo.Fn).Call(args)
+		resAry := reflect.ValueOf(ffidirect.FFI{}).MethodByName(callInfo.Fn).Call(args)
 		res := lo.Map(resAry, func(res reflect.Value, i int) any {
 			return res.Interface()
 		})
 
 		return gob.NewEncoder(output).Encode(ffiselect.ValErr{Val: res, Err: nil})
 	},
 }
-
-type sectorProvider struct {
-	index paths.SectorIndex
-	stor  *paths.Local
-}
-
-func (l *sectorProvider) AcquireSector(ctx context.Context, id storiface.SectorRef, existing storiface.SectorFileType, allocate storiface.SectorFileType, sealing storiface.PathType) (storiface.SectorPaths, func(), error) {
-	if allocate != storiface.FTNone {
-		return storiface.SectorPaths{}, nil, xerrors.New("read-only storage")
-	}
-
-	ctx, cancel := context.WithCancel(ctx)
-
-	// use TryLock to avoid blocking
-	locked, err := l.index.StorageTryLock(ctx, id.ID, existing, storiface.FTNone)
-	if err != nil {
-		cancel()
-		return storiface.SectorPaths{}, nil, xerrors.Errorf("acquiring sector lock: %w", err)
-	}
-	if !locked {
-		cancel()
-		return storiface.SectorPaths{}, nil, xerrors.Errorf("failed to acquire sector lock")
-	}
-
-	p, _, err := l.stor.AcquireSector(ctx, id, existing, allocate, sealing, storiface.AcquireMove)
-
-	return p, cancel, err
-}
-
-func (l *sectorProvider) AcquireSectorCopy(ctx context.Context, id storiface.SectorRef, existing storiface.SectorFileType, allocate storiface.SectorFileType, ptype storiface.PathType) (storiface.SectorPaths, func(), error) {
-	if allocate != storiface.FTNone {
-		return storiface.SectorPaths{}, nil, xerrors.New("read-only storage")
-	}
-
-	ctx, cancel := context.WithCancel(ctx)
-
-	// use TryLock to avoid blocking
-	locked, err := l.index.StorageTryLock(ctx, id.ID, existing, storiface.FTNone)
-	if err != nil {
-		cancel()
-		return storiface.SectorPaths{}, nil, xerrors.Errorf("acquiring sector lock: %w", err)
-	}
-	if !locked {
-		cancel()
-		return storiface.SectorPaths{}, nil, xerrors.Errorf("failed to acquire sector lock")
-	}
-
-	p, _, err := l.stor.AcquireSector(ctx, id, existing, allocate, ptype, storiface.AcquireCopy)
-
-	return p, cancel, err
-}

curiosrc/window/compute_do.go

@@ -363,8 +363,6 @@ func (t *WdPostTask) generateWindowPoSt(ctx context.Context, ppt abi.RegisteredP
 
 	var skipped []abi.SectorID
 	var flk sync.Mutex
-	cctx, cancel := context.WithCancel(ctx)
-	defer cancel()
 
 	sort.Slice(sectorInfo, func(i, j int) bool {
 		return sectorInfo[i].SectorNumber < sectorInfo[j].SectorNumber
@@ -409,18 +407,29 @@ func (t *WdPostTask) generateWindowPoSt(ctx context.Context, ppt abi.RegisteredP
 				})
 			}
 
-			sectorInfo := lo.Map(sectors, func(s storiface.PostSectorChallenge, i int) proof.ExtendedSectorInfo {
-				return proof.ExtendedSectorInfo{
-					SectorNumber: s.SectorNumber,
-					SealProof:    s.SealProof,
-					SealedCID:    s.SealedCID,
+			priSectors := lo.Map(sectors, func(s storiface.PostSectorChallenge, i int) ffi.PrivateSectorInfo {
+				return ffi.PrivateSectorInfo{
+					SectorInfo: proof.SectorInfo{
+						SectorNumber: s.SectorNumber,
+						SealProof:    s.SealProof,
+						SealedCID:    s.SealedCID,
+					},
+					CacheDirPath:     sectorCacheDirPath,
+					PoStProofType:    winningPostProofType,
+					SealedSectorPath: sealedSectorFile.Name(),
 				}
 			})
-			postProofs, sk, err := t.curioFfiWrap.GenerateWindowPoSt(cctx, minerID, ppt, sectorInfo, randomness)
-			if err != nil || len(sk) > 0 {
-				log.Errorf("generateWindowPost part:%d, skipped:%d, sectors: %d, err: %+v", partIdx, len(sk), len(sectors), err)
+			privateInfo := ffi.NewSortedPrivateSectorInfo(priSectors...)
+
+			postProofs, sectorNumbers, err := t.curioFfiWrap.GenerateWindowPoSt(minerID, privateInfo, randomness)
+
+			if err != nil || len(sectorNumbers) > 0 {
+				log.Errorf("generateWindowPost part:%d, skipped:%d, sectors: %d, err: %+v", partIdx, len(sectorNumbers), len(sectors), err)
 				flk.Lock()
-				skipped = append(skipped, sk...)
+				sectorIDs := lo.Map(sectorNumbers, func(s abi.SectorNumber, i int) abi.SectorID {
+					return abi.SectorID{Miner: minerID, Number: s}
+				})
+				skipped = append(skipped, sectorIDs...)
 
 				if err != nil {
 					retErr = multierr.Append(retErr, xerrors.Errorf("partitionIndex:%d err:%+v", partIdx, err))

lib/ffiselect/ffidirect/ffi-direct.go

@@ -0,0 +1,159 @@
+package ffidirect
+
+import (
+	"os"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/proof"
+	"github.com/ipfs/go-cid"
+
+	ffi "github.com/filecoin-project/filecoin-ffi"
+)
+
+// This allow reflection accesss to the FFI functions.
+type FFI struct{}
+
+// FFI.VerifySeal
+func (FFI) VerifySeal(info proof.SealVerifyInfo) (bool, error) {
+	return ffi.VerifySeal(info)
+}
+
+// FFI.VerifyAggregateSeals
+func (FFI) VerifyAggregateSeals(aggregate proof.AggregateSealVerifyProofAndInfos) (bool, error) {
+	return ffi.VerifyAggregateSeals(aggregate)
+}
+
+// FFI.VerifyWinningPoSt
+func (FFI) VerifyWinningPoSt(info proof.WinningPoStVerifyInfo) (bool, error) {
+	return ffi.VerifyWinningPoSt(info)
+}
+
+// FFI.VerifyWindowPoSt
+func (FFI) VerifyWindowPoSt(info proof.WindowPoStVerifyInfo) (bool, error) {
+	return ffi.VerifyWindowPoSt(info)
+}
+
+// FFI.GeneratePieceCID
+func (FFI) GeneratePieceCID(proofType abi.RegisteredSealProof, piecePath string, pieceSize abi.UnpaddedPieceSize) (cid.Cid, error) {
+	return ffi.GeneratePieceCID(proofType, piecePath, pieceSize)
+}
+
+// FFI.GenerateUnsealedCID
+func (FFI) GenerateUnsealedCID(proofType abi.RegisteredSealProof, pieces []abi.PieceInfo) (cid.Cid, error) {
+	return ffi.GenerateUnsealedCID(proofType, pieces)
+}
+
+// FFI.GeneratePieceCIDFromFile
+func (FFI) GeneratePieceCIDFromFile(proofType abi.RegisteredSealProof, pieceFile *os.File, pieceSize abi.UnpaddedPieceSize) (cid.Cid, error) {
+	return ffi.GeneratePieceCIDFromFile(proofType, pieceFile, pieceSize)
+}
+
+// FFI.WriteWithAlignment
+func (FFI) WriteWithAlignment(proofType abi.RegisteredSealProof, pieceFile *os.File, pieceBytes abi.UnpaddedPieceSize, stagedSectorFile *os.File, existingPieceSizes []abi.UnpaddedPieceSize) (leftAlignment, total abi.UnpaddedPieceSize, pieceCID cid.Cid, retErr error) {
+	return ffi.WriteWithAlignment(proofType, pieceFile, pieceBytes, stagedSectorFile, existingPieceSizes)
+}
+
+// FFI.WriteWithoutAlignment
+func (FFI) WriteWithoutAlignment(proofType abi.RegisteredSealProof, pieceFile *os.File, pieceBytes abi.UnpaddedPieceSize, stagedSectorFile *os.File) (abi.UnpaddedPieceSize, cid.Cid, error) {
+	return ffi.WriteWithoutAlignment(proofType, pieceFile, pieceBytes, stagedSectorFile)
+}
+
+// FFI.SealPreCommitPhase1
+func (FFI) SealPreCommitPhase1(proofType abi.RegisteredSealProof, cacheDirPath string, stagedSectorPath string, sealedSectorPath string, sectorNum abi.SectorNumber, minerID abi.ActorID, ticket abi.SealRandomness, pieces []abi.PieceInfo) (phase1Output []byte, err error) {
+	return ffi.SealPreCommitPhase1(proofType, cacheDirPath, stagedSectorPath, sealedSectorPath, sectorNum, minerID, ticket, pieces)
+}
+
+// FFI.SealPreCommitPhase2
+func (FFI) SealPreCommitPhase2(phase1Output []byte, cacheDirPath string, sealedSectorPath string) (sealedCID cid.Cid, unsealedCID cid.Cid, err error) {
+	return ffi.SealPreCommitPhase2(phase1Output, cacheDirPath, sealedSectorPath)
+}
+
+// FFI.SealCommitPhase1
+func (FFI) SealCommitPhase1(proofType abi.RegisteredSealProof, sealedCID cid.Cid, unsealedCID cid.Cid, cacheDirPath string, sealedSectorPath string, sectorNum abi.SectorNumber, minerID abi.ActorID, ticket abi.SealRandomness, seed abi.InteractiveSealRandomness, pieces []abi.PieceInfo) (phase1Output []byte, err error) {
+	return ffi.SealCommitPhase1(proofType, sealedCID, unsealedCID, cacheDirPath, sealedSectorPath, sectorNum, minerID, ticket, seed, pieces)
+}
+
+// FFI.SealCommitPhase2
+func (FFI) SealCommitPhase2(phase1Output []byte, sectorNum abi.SectorNumber, minerID abi.ActorID) ([]byte, error) {
+	return ffi.SealCommitPhase2(phase1Output, sectorNum, minerID)
+}
+
+// FFI.AggregateSealProofs
+func (FFI) AggregateSealProofs(aggregateInfo proof.AggregateSealVerifyProofAndInfos, proofs [][]byte) (out []byte, err error) {
+	return ffi.AggregateSealProofs(aggregateInfo, proofs)
+}
+
+// FFI.Unseal
+func (FFI) Unseal(proofType abi.RegisteredSealProof, cacheDirPath string, sealedSector *os.File, unsealOutput *os.File, sectorNum abi.SectorNumber, minerID abi.ActorID, ticket abi.SealRandomness, unsealedCID cid.Cid) error {
+	return ffi.Unseal(proofType, cacheDirPath, sealedSector, unsealOutput, sectorNum, minerID, ticket, unsealedCID)
+}
+
+// FFI.UnsealRange
+func (FFI) UnsealRange(proofType abi.RegisteredSealProof, cacheDirPath string, sealedSector *os.File, unsealOutput *os.File, sectorNum abi.SectorNumber, minerID abi.ActorID, ticket abi.SealRandomness, unsealedCID cid.Cid, unpaddedByteIndex uint64, unpaddedBytesAmount uint64) error {
+	return ffi.UnsealRange(proofType, cacheDirPath, sealedSector, unsealOutput, sectorNum, minerID, ticket, unsealedCID, unpaddedByteIndex, unpaddedBytesAmount)
+}
+
+// FFI.GenerateSDR
+func (FFI) GenerateSDR(proofType abi.RegisteredSealProof, cacheDirPath string, replicaId [32]byte) (err error) {
+	return ffi.GenerateSDR(proofType, cacheDirPath, replicaId)
+}
+
+// FFI.GenerateWinningPoStSectorChallenge
+func (FFI) GenerateWinningPoStSectorChallenge(proofType abi.RegisteredPoStProof, minerID abi.ActorID, randomness abi.PoStRandomness, eligibleSectorsLen uint64) ([]uint64, error) {
+	return ffi.GenerateWinningPoStSectorChallenge(proofType, minerID, randomness, eligibleSectorsLen)
+}
+
+// FFI.GenerateWinningPoSt
+func (FFI) GenerateWinningPoSt(minerID abi.ActorID, privateSectorInfo ffi.SortedPrivateSectorInfo, randomness abi.PoStRandomness) ([]proof.PoStProof, error) {
+	return ffi.GenerateWinningPoSt(minerID, privateSectorInfo, randomness)
+}
+
+// FFI.GenerateWindowPoSt
+func (FFI) GenerateWindowPoSt(minerID abi.ActorID, privateSectorInfo ffi.SortedPrivateSectorInfo, randomness abi.PoStRandomness) ([]proof.PoStProof, []abi.SectorNumber, error) {
+	return ffi.GenerateWindowPoSt(minerID, privateSectorInfo, randomness)
+}
+
+// FFI.GetGPUDevices
+func (FFI) GetGPUDevices() ([]string, error) {
+	return ffi.GetGPUDevices()
+}
+
+// FFI.GetSealVersion
+func (FFI) GetSealVersion(proofType abi.RegisteredSealProof) (string, error) {
+	return ffi.GetSealVersion(proofType)
+}
+
+// FFI.GetPoStVersion
+func (FFI) GetPoStVersion(proofType abi.RegisteredPoStProof) (string, error) {
+	return ffi.GetPoStVersion(proofType)
+}
+
+// FFI.GetNumPartitionForFallbackPost
+func (FFI) GetNumPartitionForFallbackPost(proofType abi.RegisteredPoStProof, numSectors uint) (uint, error) {
+	return ffi.GetNumPartitionForFallbackPost(proofType, numSectors)
+}
+
+// FFI.ClearCache
+func (FFI) ClearCache(sectorSize uint64, cacheDirPath string) error {
+	return ffi.ClearCache(sectorSize, cacheDirPath)
+}
+
+// FFI.ClearSyntheticProofs
+func (FFI) ClearSyntheticProofs(sectorSize uint64, cacheDirPath string) error {
+	return ffi.ClearSyntheticProofs(sectorSize, cacheDirPath)
+}
+
+// FFI.GenerateSynthProofs
+func (FFI) GenerateSynthProofs(proofType abi.RegisteredSealProof, sealedCID, unsealedCID cid.Cid, cacheDirPath, replicaPath string, sector_id abi.SectorNumber, minerID abi.ActorID, ticket []byte, pieces []abi.PieceInfo) error {
+	return ffi.GenerateSynthProofs(proofType, sealedCID, unsealedCID, cacheDirPath, replicaPath, sector_id, minerID, ticket, pieces)
+}
+
+// FFI.FauxRep
+func (FFI) FauxRep(proofType abi.RegisteredSealProof, cacheDirPath string, sealedSectorPath string) (cid.Cid, error) {
+	return ffi.FauxRep(proofType, cacheDirPath, sealedSectorPath)
+}
+
+// FFI.FauxRep2
+func (FFI) FauxRep2(proofType abi.RegisteredSealProof, cacheDirPath string, existingPAuxPath string) (cid.Cid, error) {
+	return ffi.FauxRep2(proofType, cacheDirPath, existingPAuxPath)
+}