package sealing import ( "io" "math/bits" "math/rand" "sync" "github.com/hashicorp/go-multierror" sectorbuilder "github.com/filecoin-project/go-sectorbuilder" ) func fillersFromRem(toFill uint64) ([]uint64, error) { // Convert to in-sector bytes for easier math: // // Sector size to user bytes ratio is constant, e.g. for 1024B we have 1016B // of user-usable data. // // (1024/1016 = 128/127) // // Given that we can get sector size by simply adding 1/127 of the user // bytes // // (we convert to sector bytes as they are nice round binary numbers) toFill += toFill / 127 // We need to fill the sector with pieces that are powers of 2. Conveniently // computers store numbers in binary, which means we can look at 1s to get // all the piece sizes we need to fill the sector. It also means that number // of pieces is the number of 1s in the number of remaining bytes to fill out := make([]uint64, bits.OnesCount64(toFill)) for i := range out { // Extract the next lowest non-zero bit next := bits.TrailingZeros64(toFill) psize := uint64(1) << next // e.g: if the number is 0b010100, psize will be 0b000100 // set that bit to 0 by XORing it, so the next iteration looks at the // next bit toFill ^= psize // Add the piece size to the list of pieces we need to create out[i] = sectorbuilder.UserBytesForSectorSize(psize) } return out, nil } func (m *Sealing) fastPledgeCommitment(size uint64, parts uint64) (commP [sectorbuilder.CommLen]byte, err error) { parts = 1 << bits.Len64(parts) // round down to nearest power of 2 if size/parts < 127 { parts = size / 127 } piece := sectorbuilder.UserBytesForSectorSize((size + size/127) / parts) out := make([]sectorbuilder.PublicPieceInfo, parts) var lk sync.Mutex var wg sync.WaitGroup wg.Add(int(parts)) for i := uint64(0); i < parts; i++ { go func(i uint64) { defer wg.Done() commP, perr := sectorbuilder.GeneratePieceCommitment(io.LimitReader(rand.New(rand.NewSource(42+int64(i))), int64(piece)), piece) lk.Lock() if perr != nil { err = multierror.Append(err, perr) } out[i] = sectorbuilder.PublicPieceInfo{ Size: piece, CommP: commP, } lk.Unlock() }(i) } wg.Wait() if err != nil { return [32]byte{}, err } return sectorbuilder.GenerateDataCommitment(m.sb.SectorSize(), out) } func (m *Sealing) ListSectors() ([]SectorInfo, error) { var sectors []SectorInfo if err := m.sectors.List(§ors); err != nil { return nil, err } return sectors, nil } func (m *Sealing) GetSectorInfo(sid uint64) (SectorInfo, error) { var out SectorInfo err := m.sectors.Get(sid).Get(&out) return out, err }