Method createTask

ethstorage/p2p/protocol/syncclient.go:326–400

(sid uint64, lastKvIndex uint64)

}

func (s *SyncClient) createTask(sid uint64, lastKvIndex uint64) *task {
	task := task{
		Contract:       s.storageManager.ContractAddress(),
		ShardId:        sid,
		nextIdx:        0,
		statelessPeers: make(map[peer.ID]struct{}),
		state: &SyncState{
			PeerCount:         0,
			BlobsToSync:       0,
			BlobsSynced:       0,
			SyncProgress:      0,
			SyncedSeconds:     0,
			EmptyFilled:       0,
			EmptyToFill:       0,
			FillEmptySeconds:  0,
			FillEmptyProgress: 0,
		},
	}

	healTask := healTask{
		task:    &task,
		Indexes: make(map[uint64]int64),
	}

	first, limit := s.storageManager.KvEntries()*sid, s.storageManager.KvEntries()*(sid+1)
	firstEmpty, limitForEmpty := uint64(0), uint64(0)
	if first >= lastKvIndex {
		firstEmpty, limitForEmpty = first, limit
		limit = first
	} else if limit >= lastKvIndex {
		firstEmpty, limitForEmpty = lastKvIndex, limit
		limit = lastKvIndex
	}

	subTasks := make([]*subTask, 0)
	// split subTask for a shard to 16 subtasks and if one batch is too small
	// set to minSubTaskSize
	maxTaskSize := max((limit-first+s.syncerParams.SyncConcurrency-1)/s.syncerParams.SyncConcurrency, minSubTaskSize)

	for first < limit {
		last := min(first+maxTaskSize, limit)
		subTask := subTask{
			task:  &task,
			next:  first,
			First: first,
			Last:  last,
			done:  false,
		}

		subTasks = append(subTasks, &subTask)
		first = last
	}

	subEmptyTasks := make([]*subEmptyTask, 0)
	if limitForEmpty > 0 {
		task.state.EmptyToFill = limitForEmpty - firstEmpty
		maxEmptyTaskSize := max((limitForEmpty-firstEmpty+uint64(maxFillEmptyTaskTreads)-1)/uint64(maxFillEmptyTaskTreads), minSubTaskSize)