2020-08-10 08:07:36 +00:00
|
|
|
package messagepool
|
|
|
|
|
|
|
|
import (
|
|
|
|
"context"
|
|
|
|
"sort"
|
2020-09-01 22:17:22 +00:00
|
|
|
"time"
|
2020-08-10 08:07:36 +00:00
|
|
|
|
|
|
|
"golang.org/x/xerrors"
|
|
|
|
|
|
|
|
"github.com/filecoin-project/go-address"
|
|
|
|
"github.com/filecoin-project/lotus/build"
|
2020-08-12 06:41:02 +00:00
|
|
|
"github.com/filecoin-project/lotus/chain/messagepool/gasguess"
|
2020-08-10 08:07:36 +00:00
|
|
|
"github.com/filecoin-project/lotus/chain/types"
|
2020-08-26 15:38:23 +00:00
|
|
|
"github.com/filecoin-project/lotus/journal"
|
2020-08-17 07:03:39 +00:00
|
|
|
"github.com/ipfs/go-cid"
|
2020-08-10 08:07:36 +00:00
|
|
|
)
|
|
|
|
|
2020-08-11 11:26:06 +00:00
|
|
|
const repubMsgLimit = 30
|
2020-08-10 08:07:36 +00:00
|
|
|
|
2020-09-01 22:17:22 +00:00
|
|
|
var RepublishBatchDelay = 200 * time.Millisecond
|
|
|
|
|
2020-08-10 08:07:36 +00:00
|
|
|
func (mp *MessagePool) republishPendingMessages() error {
|
|
|
|
mp.curTsLk.Lock()
|
|
|
|
ts := mp.curTs
|
|
|
|
|
|
|
|
baseFee, err := mp.api.ChainComputeBaseFee(context.TODO(), ts)
|
|
|
|
if err != nil {
|
2020-08-12 06:18:04 +00:00
|
|
|
mp.curTsLk.Unlock()
|
2020-08-10 08:07:36 +00:00
|
|
|
return xerrors.Errorf("computing basefee: %w", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
pending := make(map[address.Address]map[uint64]*types.SignedMessage)
|
|
|
|
mp.lk.Lock()
|
2020-08-17 07:03:39 +00:00
|
|
|
mp.republished = nil // clear this to avoid races triggering an early republish
|
2020-08-10 08:07:36 +00:00
|
|
|
for actor := range mp.localAddrs {
|
|
|
|
mset, ok := mp.pending[actor]
|
|
|
|
if !ok {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
if len(mset.msgs) == 0 {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
// we need to copy this while holding the lock to avoid races with concurrent modification
|
|
|
|
pend := make(map[uint64]*types.SignedMessage, len(mset.msgs))
|
|
|
|
for nonce, m := range mset.msgs {
|
|
|
|
pend[nonce] = m
|
|
|
|
}
|
|
|
|
pending[actor] = pend
|
|
|
|
}
|
|
|
|
mp.lk.Unlock()
|
2020-08-12 06:18:04 +00:00
|
|
|
mp.curTsLk.Unlock()
|
2020-08-10 08:07:36 +00:00
|
|
|
|
|
|
|
if len(pending) == 0 {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
var chains []*msgChain
|
|
|
|
for actor, mset := range pending {
|
|
|
|
next := mp.createMessageChains(actor, mset, baseFee, ts)
|
|
|
|
chains = append(chains, next...)
|
|
|
|
}
|
|
|
|
|
|
|
|
if len(chains) == 0 {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
sort.Slice(chains, func(i, j int) bool {
|
|
|
|
return chains[i].Before(chains[j])
|
|
|
|
})
|
|
|
|
|
|
|
|
// we don't republish negative performing chains; this is an error that will be screamed
|
|
|
|
// at the user
|
|
|
|
if chains[0].gasPerf < 0 {
|
|
|
|
return xerrors.Errorf("skipping republish: all message chains have negative gas performance; best gas performance: %f", chains[0].gasPerf)
|
|
|
|
}
|
|
|
|
|
|
|
|
gasLimit := int64(build.BlockGasLimit)
|
2020-08-12 06:41:02 +00:00
|
|
|
minGas := int64(gasguess.MinGas)
|
2020-08-10 08:07:36 +00:00
|
|
|
var msgs []*types.SignedMessage
|
2020-08-12 06:41:02 +00:00
|
|
|
for i := 0; i < len(chains); {
|
|
|
|
chain := chains[i]
|
|
|
|
|
2020-08-10 08:07:36 +00:00
|
|
|
// we can exceed this if we have picked (some) longer chain already
|
|
|
|
if len(msgs) > repubMsgLimit {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
2020-08-12 06:41:02 +00:00
|
|
|
// there is not enough gas for any message
|
|
|
|
if gasLimit <= minGas {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
2020-08-10 08:07:36 +00:00
|
|
|
// we don't republish negative performing chains, as they won't be included in
|
|
|
|
// a block anyway
|
|
|
|
if chain.gasPerf < 0 {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
2020-08-12 06:41:02 +00:00
|
|
|
// has the chain been invalidated?
|
|
|
|
if !chain.valid {
|
|
|
|
i++
|
|
|
|
continue
|
2020-08-10 08:07:36 +00:00
|
|
|
}
|
|
|
|
|
2020-08-12 06:41:02 +00:00
|
|
|
// does it fit in a block?
|
|
|
|
if chain.gasLimit <= gasLimit {
|
|
|
|
gasLimit -= chain.gasLimit
|
|
|
|
msgs = append(msgs, chain.msgs...)
|
|
|
|
i++
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
// we can't fit the current chain but there is gas to spare
|
|
|
|
// trim it and push it down
|
2020-08-29 12:55:19 +00:00
|
|
|
chain.Trim(gasLimit, mp, baseFee, ts)
|
2020-08-12 06:41:02 +00:00
|
|
|
for j := i; j < len(chains)-1; j++ {
|
|
|
|
if chains[j].Before(chains[j+1]) {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
chains[j], chains[j+1] = chains[j+1], chains[j]
|
|
|
|
}
|
2020-08-10 08:07:36 +00:00
|
|
|
}
|
|
|
|
|
2020-08-17 07:03:39 +00:00
|
|
|
count := 0
|
2020-08-10 08:07:36 +00:00
|
|
|
log.Infof("republishing %d messages", len(msgs))
|
|
|
|
for _, m := range msgs {
|
|
|
|
mb, err := m.Serialize()
|
|
|
|
if err != nil {
|
|
|
|
return xerrors.Errorf("cannot serialize message: %w", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
err = mp.api.PubSubPublish(build.MessagesTopic(mp.netName), mb)
|
|
|
|
if err != nil {
|
|
|
|
return xerrors.Errorf("cannot publish: %w", err)
|
|
|
|
}
|
2020-08-17 07:03:39 +00:00
|
|
|
|
|
|
|
count++
|
2020-09-01 22:17:22 +00:00
|
|
|
|
|
|
|
if count < len(msgs) {
|
|
|
|
// this delay is here to encourage the pubsub subsystem to process the messages serially
|
|
|
|
// and avoid creating nonce gaps because of concurrent validation.
|
|
|
|
time.Sleep(RepublishBatchDelay)
|
|
|
|
}
|
2020-08-17 07:03:39 +00:00
|
|
|
}
|
|
|
|
|
2020-08-26 15:38:23 +00:00
|
|
|
if len(msgs) > 0 {
|
|
|
|
journal.J.RecordEvent(mp.evtTypes[evtTypeMpoolRepub], func() interface{} {
|
2020-09-04 09:54:56 +00:00
|
|
|
msgs := make([]MessagePoolEvtMessage, 0, len(msgs))
|
2020-08-26 15:38:23 +00:00
|
|
|
for _, m := range msgs {
|
2020-09-04 09:54:56 +00:00
|
|
|
msgs = append(msgs, MessagePoolEvtMessage{Message: m.Message, CID: m.Cid()})
|
2020-08-26 15:38:23 +00:00
|
|
|
}
|
|
|
|
return MessagePoolEvt{
|
|
|
|
Action: "repub",
|
|
|
|
Messages: msgs,
|
|
|
|
}
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2020-08-17 07:03:39 +00:00
|
|
|
// track most recently republished messages
|
|
|
|
republished := make(map[cid.Cid]struct{})
|
|
|
|
for _, m := range msgs[:count] {
|
|
|
|
republished[m.Cid()] = struct{}{}
|
2020-08-10 08:07:36 +00:00
|
|
|
}
|
|
|
|
|
2020-08-17 07:03:39 +00:00
|
|
|
mp.lk.Lock()
|
|
|
|
// update the republished set so that we can trigger early republish from head changes
|
|
|
|
mp.republished = republished
|
|
|
|
mp.lk.Unlock()
|
|
|
|
|
2020-08-10 08:07:36 +00:00
|
|
|
return nil
|
|
|
|
}
|