feat: storage: Parallel proving checks

node/builder_miner.go

@@ -214,7 +214,7 @@ func ConfigStorageMiner(c interface{}) Option {
 			Override(new(storagemarket.StorageProviderNode), storageadapter.NewProviderNodeAdapter(&cfg.Fees, &cfg.Dealmaking)),
 		),
 
-		Override(new(sectorstorage.SealerConfig), cfg.Storage),
+		Override(new(sectorstorage.Config), cfg.StorageManager()),
 		Override(new(*storage.AddressSelector), modules.AddressSelector(&cfg.Addresses)),
 	)
 }

node/config/def.go

@@ -138,7 +138,7 @@ func DefaultStorageMiner() *StorageMiner {
 			TerminateBatchWait: Duration(5 * time.Minute),
 		},
 
-		Storage: sectorstorage.SealerConfig{
+		Storage: SealerConfig{
 			AllowAddPiece:            true,
 			AllowPreCommit1:          true,
 			AllowPreCommit2:          true,

node/config/doc_gen.go

@@ -620,6 +620,14 @@ over the worker address if this flag is set.`,
 			Comment: ``,
 		},
 	},
+	"ProvingConfig": []DocField{
+		{
+			Name: "ParallelCheckLimit",
+			Type: "int",
+
+			Comment: `Maximum number of sector checks to run in parallel. (0 = unlimited)`,
+		},
+	},
 	"Pubsub": []DocField{
 		{
 			Name: "Bootstrapper",
@@ -691,6 +699,70 @@ default value is true`,
 This parameter is ONLY applicable if the retrieval pricing policy strategy has been configured to "external".`,
 		},
 	},
+	"SealerConfig": []DocField{
+		{
+			Name: "ParallelFetchLimit",
+			Type: "int",
+
+			Comment: ``,
+		},
+		{
+			Name: "AllowAddPiece",
+			Type: "bool",
+
+			Comment: `Local worker config`,
+		},
+		{
+			Name: "AllowPreCommit1",
+			Type: "bool",
+
+			Comment: ``,
+		},
+		{
+			Name: "AllowPreCommit2",
+			Type: "bool",
+
+			Comment: ``,
+		},
+		{
+			Name: "AllowCommit",
+			Type: "bool",
+
+			Comment: ``,
+		},
+		{
+			Name: "AllowUnseal",
+			Type: "bool",
+
+			Comment: ``,
+		},
+		{
+			Name: "AllowReplicaUpdate",
+			Type: "bool",
+
+			Comment: ``,
+		},
+		{
+			Name: "AllowProveReplicaUpdate2",
+			Type: "bool",
+
+			Comment: ``,
+		},
+		{
+			Name: "AllowRegenSectorKey",
+			Type: "bool",
+
+			Comment: ``,
+		},
+		{
+			Name: "ResourceFiltering",
+			Type: "sectorstorage.ResourceFilteringStrategy",
+
+			Comment: `ResourceFiltering instructs the system which resource filtering strategy
+to use when evaluating tasks against this worker. An empty value defaults
+to "hardware".`,
+		},
+	},
 	"SealingConfig": []DocField{
 		{
 			Name: "MaxWaitDealsSectors",
@@ -933,6 +1005,12 @@ Default is 20 (about once a week).`,
 
 			Comment: ``,
 		},
+		{
+			Name: "Proving",
+			Type: "ProvingConfig",
+
+			Comment: ``,
+		},
 		{
 			Name: "Sealing",
 			Type: "SealingConfig",
@@ -941,7 +1019,7 @@ Default is 20 (about once a week).`,
 		},
 		{
 			Name: "Storage",
-			Type: "sectorstorage.SealerConfig",
+			Type: "SealerConfig",
 
 			Comment: ``,
 		},

node/config/storage.go

@@ -8,6 +8,7 @@ import (
 
 	"golang.org/x/xerrors"
 
+	sectorstorage "github.com/filecoin-project/lotus/extern/sector-storage"
 	"github.com/filecoin-project/lotus/extern/sector-storage/stores"
 )
 
@@ -49,3 +50,20 @@ func WriteStorageFile(path string, config stores.StorageConfig) error {
 
 	return nil
 }
+
+func (c *StorageMiner) StorageManager() sectorstorage.Config {
+	return sectorstorage.Config{
+		ParallelFetchLimit:       c.Storage.ParallelFetchLimit,
+		AllowAddPiece:            c.Storage.AllowAddPiece,
+		AllowPreCommit1:          c.Storage.AllowPreCommit1,
+		AllowPreCommit2:          c.Storage.AllowPreCommit2,
+		AllowCommit:              c.Storage.AllowCommit,
+		AllowUnseal:              c.Storage.AllowUnseal,
+		AllowReplicaUpdate:       c.Storage.AllowReplicaUpdate,
+		AllowProveReplicaUpdate2: c.Storage.AllowProveReplicaUpdate2,
+		AllowRegenSectorKey:      c.Storage.AllowRegenSectorKey,
+		ResourceFiltering:        c.Storage.ResourceFiltering,
+
+		ParallelCheckLimit: c.Proving.ParallelCheckLimit,
+	}
+}

node/config/types.go

@@ -1,10 +1,9 @@
 package config
 
 import (
-	"github.com/ipfs/go-cid"
-
 	"github.com/filecoin-project/lotus/chain/types"
 	sectorstorage "github.com/filecoin-project/lotus/extern/sector-storage"
+	"github.com/ipfs/go-cid"
 )
 
 // // NOTE: ONLY PUT STRUCT DEFINITIONS IN THIS FILE
@@ -53,8 +52,9 @@ type StorageMiner struct {
 	Subsystems    MinerSubsystemConfig
 	Dealmaking    DealmakingConfig
 	IndexProvider IndexProviderConfig
+	Proving       ProvingConfig
 	Sealing       SealingConfig
-	Storage       sectorstorage.SealerConfig
+	Storage       SealerConfig
 	Fees          MinerFeeConfig
 	Addresses     MinerAddressConfig
 	DAGStore      DAGStoreConfig
@@ -216,6 +216,13 @@ type RetrievalPricingDefault struct {
 	VerifiedDealsFreeTransfer bool
 }
 
+type ProvingConfig struct {
+	// Maximum number of sector checks to run in parallel. (0 = unlimited)
+	ParallelCheckLimit int
+
+	// todo disable builtin post
+}
+
 type SealingConfig struct {
 	// Upper bound on how many sectors can be waiting for more deals to be packed in it before it begins sealing at any given time.
 	// If the miner is accepting multiple deals in parallel, up to MaxWaitDealsSectors of new sectors will be created.
@@ -307,6 +314,25 @@ type SealingConfig struct {
 	// todo TargetSectors - stop auto-pleding new sectors after this many sectors are sealed, default CC upgrade for deals sectors if above
 }
 
+type SealerConfig struct {
+	ParallelFetchLimit int
+
+	// Local worker config
+	AllowAddPiece            bool
+	AllowPreCommit1          bool
+	AllowPreCommit2          bool
+	AllowCommit              bool
+	AllowUnseal              bool
+	AllowReplicaUpdate       bool
+	AllowProveReplicaUpdate2 bool
+	AllowRegenSectorKey      bool
+
+	// ResourceFiltering instructs the system which resource filtering strategy
+	// to use when evaluating tasks against this worker. An empty value defaults
+	// to "hardware".
+	ResourceFiltering sectorstorage.ResourceFilteringStrategy
+}
+
 type BatchFeeConfig struct {
 	Base      types.FIL
 	PerSector types.FIL

node/modules/storageminer.go

@@ -739,11 +739,11 @@ func LocalStorage(mctx helpers.MetricsCtx, lc fx.Lifecycle, ls stores.LocalStora
 	return stores.NewLocal(ctx, ls, si, urls)
 }
 
-func RemoteStorage(lstor *stores.Local, si stores.SectorIndex, sa sectorstorage.StorageAuth, sc sectorstorage.SealerConfig) *stores.Remote {
+func RemoteStorage(lstor *stores.Local, si stores.SectorIndex, sa sectorstorage.StorageAuth, sc sectorstorage.Config) *stores.Remote {
 	return stores.NewRemote(lstor, si, http.Header(sa), sc.ParallelFetchLimit, &stores.DefaultPartialFileHandler{})
 }
 
-func SectorStorage(mctx helpers.MetricsCtx, lc fx.Lifecycle, lstor *stores.Local, stor stores.Store, ls stores.LocalStorage, si stores.SectorIndex, sc sectorstorage.SealerConfig, ds dtypes.MetadataDS) (*sectorstorage.Manager, error) {
+func SectorStorage(mctx helpers.MetricsCtx, lc fx.Lifecycle, lstor *stores.Local, stor stores.Store, ls stores.LocalStorage, si stores.SectorIndex, sc sectorstorage.Config, ds dtypes.MetadataDS) (*sectorstorage.Manager, error) {
 	ctx := helpers.LifecycleCtx(mctx, lc)
 
 	wsts := statestore.New(namespace.Wrap(ds, WorkerCallsPrefix))