SupraSeal

.gitmodules

@@ -1,3 +1,7 @@
 [submodule "extern/filecoin-ffi"]
 	path = extern/filecoin-ffi
 	url = https://github.com/filecoin-project/filecoin-ffi.git
+[submodule "extern/supra_seal"]
+	path = extern/supra_seal
+	url = https://github.com/magik6k/supra_seal.git
+	branch = feat/multi-out-paths

Makefile

@@ -2,6 +2,8 @@ SHELL=/usr/bin/env bash
 
 GOCC?=go
 
+## FILECOIN-FFI
+
 FFI_PATH:=extern/filecoin-ffi/
 FFI_DEPS:=.install-filcrypto
 FFI_DEPS:=$(addprefix $(FFI_PATH),$(FFI_DEPS))
@@ -22,6 +24,23 @@ BUILD_DEPS+=ffi-version-check
 
 .PHONY: ffi-version-check
 
+## SUPRA-FFI
+
+ifeq ($(shell uname),Linux)
+SUPRA_FFI_PATH:=extern/supra_seal/
+SUPRA_FFI_DEPS:=.install-supraseal
+SUPRA_FFI_DEPS:=$(addprefix $(SUPRA_FFI_PATH),$(SUPRA_FFI_DEPS))
+
+$(SUPRA_FFI_DEPS): build/.supraseal-install ;
+
+build/.supraseal-install: $(SUPRA_FFI_PATH)
+	cd $(SUPRA_FFI_PATH) && ./build.sh
+	@touch $@
+
+MODULES+=$(SUPRA_FFI_PATH)
+CLEAN+=build/.supraseal-install
+endif
+
 $(MODULES): build/.update-modules ;
 # dummy file that marks the last time modules were updated
 build/.update-modules:
@@ -30,6 +49,12 @@ build/.update-modules:
 
 # end git modules
 
+## CUDA Library Path
+CUDA_PATH := $(shell dirname $$(dirname $$(which nvcc)))
+CUDA_LIB_PATH := $(CUDA_PATH)/lib64
+LIBRARY_PATH ?= $(CUDA_LIB_PATH)
+export LIBRARY_PATH
+
 ## MAIN BINARIES
 
 CLEAN+=build/.update-modules
@@ -41,7 +66,7 @@ deps: $(BUILD_DEPS)
 
 curio: $(BUILD_DEPS)
 	rm -f curio
-	GOAMD64=v3 $(GOCC) build $(GOFLAGS) -o curio -ldflags " -s -w \
+	GOAMD64=v3 CGO_LDFLAGS_ALLOW=$(CGO_LDFLAGS_ALLOW) $(GOCC) build $(GOFLAGS) -o curio -ldflags " -s -w \
 	-X github.com/filecoin-project/curio/build.IsOpencl=$(FFI_USE_OPENCL) \
 	-X github.com/filecoin-project/curio/build.CurrentCommit=+git_`git log -1 --format=%h_%cI`" \
 	./cmd/curio
@@ -54,6 +79,31 @@ sptool: $(BUILD_DEPS)
 .PHONY: sptool
 BINS+=sptool
 
+ifeq ($(shell uname),Linux)
+
+batchdep: build/.supraseal-install
+batchdep: $(BUILD_DEPS)
+,PHONY: batchdep
+
+batch: GOFLAGS+=-tags=supraseal
+batch: CGO_LDFLAGS_ALLOW='.*'
+batch: batchdep build
+.PHONY: batch
+
+batch-calibnet: GOFLAGS+=-tags=calibnet,supraseal
+batch-calibnet: CGO_LDFLAGS_ALLOW='.*'
+batch-calibnet: batchdep build
+.PHONY: batch-calibnet
+
+else
+batch:
+	@echo "Batch target is only available on Linux systems"
+	@exit 1
+
+batch-calibnet:
+	@echo "Batch-calibnet target is only available on Linux systems"
+	@exit 1
+endif
 
 calibnet: GOFLAGS+=-tags=calibnet
 calibnet: build

cmd/curio/calc.go

@@ -0,0 +1,169 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/fatih/color"
+	"github.com/urfave/cli/v2"
+
+	"github.com/filecoin-project/curio/tasks/sealsupra"
+)
+
+var calcCmd = &cli.Command{
+	Name:  "calc",
+	Usage: "Math Utils",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name: "actor",
+		},
+	},
+	Subcommands: []*cli.Command{
+		calcBatchCpuCmd,
+		calcSuprasealConfigCmd,
+	},
+}
+
+var calcBatchCpuCmd = &cli.Command{
+	Name:  "batch-cpu",
+	Usage: "Analyze and display the layout of batch sealer threads",
+	Description: `Analyze and display the layout of batch sealer threads on your CPU.
+
+It provides detailed information about CPU utilization for batch sealing operations, including core allocation, thread
+distribution for different batch sizes.`,
+	Flags: []cli.Flag{
+		&cli.BoolFlag{Name: "dual-hashers", Value: true},
+	},
+	Action: func(cctx *cli.Context) error {
+		info, err := sealsupra.GetSystemInfo()
+		if err != nil {
+			return err
+		}
+
+		fmt.Println("Basic CPU Information")
+		fmt.Println("")
+		fmt.Printf("Processor count: %d\n", info.ProcessorCount)
+		fmt.Printf("Core count: %d\n", info.CoreCount)
+		fmt.Printf("Thread count: %d\n", info.CoreCount*info.ThreadsPerCore)
+		fmt.Printf("Threads per core: %d\n", info.ThreadsPerCore)
+		fmt.Printf("Cores per L3 cache (CCX): %d\n", info.CoresPerL3)
+		fmt.Printf("L3 cache count (CCX count): %d\n", info.CoreCount/info.CoresPerL3)
+
+		ccxFreeCores := info.CoresPerL3 - 1 // one core per ccx goes to the coordinator
+		ccxFreeThreads := ccxFreeCores * info.ThreadsPerCore
+		fmt.Printf("Hasher Threads per CCX: %d\n", ccxFreeThreads)
+
+		sectorsPerThread := 1
+		if cctx.Bool("dual-hashers") {
+			sectorsPerThread = 2
+		}
+
+		sectorsPerCCX := ccxFreeThreads * sectorsPerThread
+		fmt.Printf("Sectors per CCX: %d\n", sectorsPerCCX)
+
+		fmt.Println("---------")
+
+		printForBatchSize := func(batchSize int) {
+			fmt.Printf("Batch Size: %s sectors\n", color.CyanString("%d", batchSize))
+			fmt.Println()
+
+			config, err := sealsupra.GenerateSupraSealConfig(*info, cctx.Bool("dual-hashers"), batchSize, nil)
+			if err != nil {
+				fmt.Printf("Error generating config: %s\n", err)
+				return
+			}
+
+			fmt.Printf("Required Threads: %d\n", config.RequiredThreads)
+			fmt.Printf("Required CCX: %d\n", config.RequiredCCX)
+			fmt.Printf("Required Cores: %d hasher (+4 minimum for non-hashers)\n", config.RequiredCores)
+
+			enoughCores := config.RequiredCores <= info.CoreCount
+			if enoughCores {
+				fmt.Printf("Enough cores available for hashers %s\n", color.GreenString("✔"))
+			} else {
+				fmt.Printf("Not enough cores available for hashers %s\n", color.RedString("✘"))
+				return
+			}
+
+			fmt.Printf("Non-hasher cores: %d\n", info.CoreCount-config.RequiredCores)
+
+			if config.P2WrRdOverlap {
+				color.Yellow("! P2 writer will share a core with P2 reader, performance may be impacted")
+			}
+			if config.P2HsP1WrOverlap {
+				color.Yellow("! P2 hasher will share a core with P1 writer, performance may be impacted")
+			}
+			if config.P2HcP2RdOverlap {
+				color.Yellow("! P2 hasher_cpu will share a core with P2 reader, performance may be impacted")
+			}
+
+			fmt.Println()
+			fmt.Printf("pc1 writer: %d\n", config.Topology.PC1Writer)
+			fmt.Printf("pc1 reader: %d\n", config.Topology.PC1Reader)
+			fmt.Printf("pc1 orchestrator: %d\n", config.Topology.PC1Orchestrator)
+			fmt.Println()
+			fmt.Printf("pc2 reader: %d\n", config.Topology.PC2Reader)
+			fmt.Printf("pc2 hasher: %d\n", config.Topology.PC2Hasher)
+			fmt.Printf("pc2 hasher_cpu: %d\n", config.Topology.PC2HasherCPU)
+			fmt.Printf("pc2 writer: %d\n", config.Topology.PC2Writer)
+			fmt.Printf("pc2 writer_cores: %d\n", config.Topology.PC2WriterCores)
+			fmt.Println()
+			fmt.Printf("c1 reader: %d\n", config.Topology.C1Reader)
+			fmt.Println()
+
+			fmt.Printf("Unoccupied Cores: %d\n\n", config.UnoccupiedCores)
+
+			fmt.Println("{")
+			fmt.Printf("  sectors = %d;\n", batchSize)
+			fmt.Println("  coordinators = (")
+			for i, coord := range config.Topology.SectorConfigs[0].Coordinators {
+				fmt.Printf("    { core = %d;\n      hashers = %d; }", coord.Core, coord.Hashers)
+				if i < len(config.Topology.SectorConfigs[0].Coordinators)-1 {
+					fmt.Println(",")
+				} else {
+					fmt.Println()
+				}
+			}
+			fmt.Println("  )")
+			fmt.Println("}")
+
+			fmt.Println("---------")
+		}
+
+		printForBatchSize(16)
+		printForBatchSize(32)
+		printForBatchSize(64)
+		printForBatchSize(128)
+
+		return nil
+	},
+}
+
+var calcSuprasealConfigCmd = &cli.Command{
+	Name:  "supraseal-config",
+	Usage: "Generate a supra_seal configuration",
+	Description: `Generate a supra_seal configuration for a given batch size.
+
+This command outputs a configuration expected by SupraSeal. Main purpose of this command is for debugging and testing.
+The config can be used directly with SupraSeal binaries to test it without involving Curio.`,
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name:  "dual-hashers",
+			Value: true,
+			Usage: "Zen3 and later supports two sectors per thread, set to false for older CPUs",
+		},
+		&cli.IntFlag{
+			Name:     "batch-size",
+			Aliases:  []string{"b"},
+			Required: true,
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		cstr, err := sealsupra.GenerateSupraSealConfigString(cctx.Bool("dual-hashers"), cctx.Int("batch-size"), nil)
+		if err != nil {
+			return err
+		}
+
+		fmt.Println(cstr)
+		return nil
+	},
+}

cmd/curio/main.go

@@ -67,6 +67,7 @@ func main() {
 		marketCmd,
 		fetchParamCmd,
 		ffiCmd,
+		calcCmd,
 	}
 
 	jaeger := tracing.SetupJaegerTracing("curio")

cmd/curio/pipeline.go

@@ -9,6 +9,8 @@ import (
 
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/builtin"
+	miner12 "github.com/filecoin-project/go-state-types/builtin/v12/miner"
 
 	"github.com/filecoin-project/curio/cmd/curio/guidedsetup"
 	"github.com/filecoin-project/curio/deps"
@@ -61,6 +63,12 @@ var sealStartCmd = &cli.Command{
 			Name:  "layers",
 			Usage: "list of layers to be interpreted (atop defaults). Default: base",
 		},
+		&cli.IntFlag{
+			Name:        "duration-days",
+			Aliases:     []string{"d"},
+			Usage:       "How long to commit sectors for",
+			DefaultText: "1278 (3.5 years)",
+		},
 	},
 	Action: func(cctx *cli.Context) error {
 		if !cctx.Bool("now") {
@@ -118,9 +126,23 @@ var sealStartCmd = &cli.Command{
 			return xerrors.Errorf("getting seal proof type: %w", err)
 		}
 
+		var userDuration *int64
+		if cctx.IsSet("duration-days") {
+			days := cctx.Int("duration-days")
+			userDuration = new(int64)
+			*userDuration = int64(days) * builtin.EpochsInDay
+
+			if miner12.MaxSectorExpirationExtension < *userDuration {
+				return xerrors.Errorf("duration exceeds max allowed: %d > %d", *userDuration, miner12.MaxSectorExpirationExtension)
+			}
+			if miner12.MinSectorExpiration > *userDuration {
+				return xerrors.Errorf("duration is too short: %d < %d", *userDuration, miner12.MinSectorExpiration)
+			}
+		}
+
 		num, err := seal.AllocateSectorNumbers(ctx, dep.Chain, dep.DB, act, cctx.Int("count"), func(tx *harmonydb.Tx, numbers []abi.SectorNumber) (bool, error) {
 			for _, n := range numbers {
-				_, err := tx.Exec("insert into sectors_sdr_pipeline (sp_id, sector_number, reg_seal_proof) values ($1, $2, $3)", mid, n, spt)
+				_, err := tx.Exec("insert into sectors_sdr_pipeline (sp_id, sector_number, reg_seal_proof, user_sector_duration_epochs) values ($1, $2, $3, $4)", mid, n, spt, userDuration)
 				if err != nil {
 					return false, xerrors.Errorf("inserting into sectors_sdr_pipeline: %w", err)
 				}

cmd/curio/rpc/rpc.go

@@ -30,14 +30,15 @@ import (
 	"github.com/filecoin-project/curio/api/client"
 	"github.com/filecoin-project/curio/build"
 	"github.com/filecoin-project/curio/deps"
+	"github.com/filecoin-project/curio/lib/metrics"
 	"github.com/filecoin-project/curio/lib/paths"
 	"github.com/filecoin-project/curio/lib/repo"
 	"github.com/filecoin-project/curio/web"
 
 	lapi "github.com/filecoin-project/lotus/api"
 	cliutil "github.com/filecoin-project/lotus/cli/util"
 	"github.com/filecoin-project/lotus/lib/rpcenc"
-	"github.com/filecoin-project/lotus/metrics"
+	lotusmetrics "github.com/filecoin-project/lotus/metrics"
 	"github.com/filecoin-project/lotus/metrics/proxy"
 	"github.com/filecoin-project/lotus/storage/pipeline/piece"
 	"github.com/filecoin-project/lotus/storage/sealer/fsutil"
@@ -71,6 +72,7 @@ func CurioHandler(
 	mux.Handle("/rpc/v0", rpcServer)
 	mux.Handle("/rpc/streams/v0/push/{uuid}", readerHandler)
 	mux.PathPrefix("/remote").HandlerFunc(remote)
+	mux.Handle("/debug/metrics", metrics.Exporter())
 	mux.PathPrefix("/").Handler(http.DefaultServeMux) // pprof
 
 	if !permissioned {
@@ -283,7 +285,7 @@ func ListenAndServe(ctx context.Context, dependencies *deps.Deps, shutdownChan c
 			permissioned),
 		ReadHeaderTimeout: time.Minute * 3,
 		BaseContext: func(listener net.Listener) context.Context {
-			ctx, _ := tag.New(context.Background(), tag.Upsert(metrics.APIInterface, "lotus-worker"))
+			ctx, _ := tag.New(context.Background(), tag.Upsert(lotusmetrics.APIInterface, "curio"))
 			return ctx
 		},
 		Addr: dependencies.ListenAddr,

cmd/curio/run.go

@@ -106,14 +106,7 @@ var runCmd = &cli.Command{
 				ctxclose()
 			}()
 		}
-		// Register all metric views
-		/*
-			if err := view.Register(
-				metrics.MinerNodeViews...,
-			); err != nil {
-				log.Fatalf("Cannot register the view: %v", err)
-			}
-		*/
+
 		// Set the metric to one so it is published to the exporter
 		stats.Record(ctx, metrics.LotusInfo.M(1))