std::string sender_ip, int64_t backend_id, bool enable_profile,

int64_t wg_id)

: _load_id(load_id),

_timeout_s(timeout_s),

_is_high_priority(is_high_priority),

_sender_ip(std::move(sender_ip)),

_backend_id(backend_id),

_enable_profile(enable_profile) {

std::shared_ptr<QueryContext> query_context =

ExecEnv::GetInstance()->fragment_mgr()->get_query_ctx(_load_id.to_thrift());

if (query_context != nullptr) {

_resource_ctx = query_context->resource_ctx();

} else {

_resource_ctx = ResourceContext::create_shared();

_resource_ctx->task_controller()->set_task_id(_load_id.to_thrift());

// when memtable on sink is not enabled, load can not find queryctx

std::shared_ptr<MemTrackerLimiter> mem_tracker = MemTrackerLimiter::create_shared(

MemTrackerLimiter::Type::LOAD,

fmt::format("(FromLoadChannel)Load#Id={}", _load_id.to_string()));

_resource_ctx->memory_context()->set_mem_tracker(mem_tracker);

WorkloadGroupPtr wg_ptr = nullptr;

if (wg_id > 0) {

wg_ptr = ExecEnv::GetInstance()->workload_group_mgr()->get_group(wg_id);

if (wg_ptr != nullptr) {

wg_ptr->add_mem_tracker_limiter(mem_tracker);

_resource_ctx->set_workload_group(wg_ptr);

}

}

}

g_loadchannel_cnt << 1;

// _last_updated_time should be set before being inserted to

// _load_channels in load_channel_mgr, or it may be erased

// immediately by gc thread.

_last_updated_time.store(time(nullptr));

_init_profile();

_profile = std::make_unique<RuntimeProfile>("LoadChannels");

_mgr_add_batch_timer = ADD_TIMER(_profile, "LoadChannelMgrAddBatchTime");

_handle_mem_limit_timer = ADD_TIMER(_profile, "HandleMemLimitTime");

_self_profile =

_profile->create_child(fmt::format("LoadChannel load_id={} (host={}, backend_id={})",

_load_id.to_string(), _sender_ip, _backend_id),

true, true);

_add_batch_number_counter = ADD_COUNTER(_self_profile, "NumberBatchAdded", TUnit::UNIT);

_add_batch_timer = ADD_TIMER(_self_profile, "AddBatchTime");

_handle_eos_timer = ADD_CHILD_TIMER(_self_profile, "HandleEosTime", "AddBatchTime");

_add_batch_times = ADD_COUNTER(_self_profile, "AddBatchTimes", TUnit::UNIT);

if (config::is_cloud_mode() && params.txn_expiration() <= 0) {

return Status::InternalError(

"The txn expiration of PTabletWriterOpenRequest is invalid, value={}",

params.txn_expiration());

}

SCOPED_ATTACH_TASK(_resource_ctx);

int64_t index_id = params.index_id();

std::shared_ptr<BaseTabletsChannel> channel;

{

std::lock_guard<std::mutex> l(_lock);

auto it = _tablets_channels.find(index_id);

if (it != _tablets_channels.end()) {

channel = it->second;

} else {

// just for VLOG

if (_txn_id == 0) [[unlikely]] {

_txn_id = params.txn_id();

}

// create a new tablets channel

TabletsChannelKey key(params.id(), index_id);

BaseStorageEngine& engine = ExecEnv::GetInstance()->storage_engine();

if (config::is_cloud_mode()) {

channel = std::make_shared<CloudTabletsChannel>(engine.to_cloud(), key, _load_id,

_is_high_priority, _self_profile);

} else {

channel = std::make_shared<TabletsChannel>(engine.to_local(), key, _load_id,

_is_high_priority, _self_profile);

}

{

std::lock_guard<std::mutex> l(_tablets_channels_lock);

_tablets_channels.insert({index_id, channel});

}

}

}

if (params.is_incremental()) {

// incremental open would ensure not to open tablet repeatedly

RETURN_IF_ERROR(channel->incremental_open(params));

} else {

RETURN_IF_ERROR(channel->open(params));

}

_opened = true;

_last_updated_time.store(time(nullptr));

return Status::OK();

bool& is_finished, const int64_t index_id) {

std::lock_guard<std::mutex> l(_lock);

auto it = _tablets_channels.find(index_id);

if (it == _tablets_channels.end()) {

if (_finished_channel_ids.find(index_id) != _finished_channel_ids.end()) {

// this channel is already finished, just return OK

is_finished = true;

return Status::OK();

}

std::stringstream ss;

ss << "load channel " << _load_id << " add batch with unknown index id: " << index_id;

return Status::InternalError(ss.str());

}

is_finished = false;

channel = it->second;

return Status::OK();

PTabletWriterAddBlockResult* response) {

SCOPED_TIMER(_add_batch_timer);

COUNTER_UPDATE(_add_batch_times, 1);

SCOPED_ATTACH_TASK(_resource_ctx);

int64_t index_id = request.index_id();

// 1. get tablets channel

std::shared_ptr<BaseTabletsChannel> channel;

bool is_finished = false;

Status st = _get_tablets_channel(channel, is_finished, index_id);

if (!st.ok() || is_finished) {

return st;

}

// 2. add block to tablets channel

if (request.has_block()) {

RETURN_IF_ERROR(channel->add_batch(request, response));

_add_batch_number_counter->update(1);

}

// 3. handle eos

// if channel is incremental, maybe hang on close until all close request arrived.

if (request.has_eos() && request.eos()) {

st = _handle_eos(channel.get(), request, response);

_report_profile(response);

if (!st.ok()) {

return st;

}

} else if (_add_batch_number_counter->value() % 100 == 1) {

_report_profile(response);

}

_last_updated_time.store(time(nullptr));

return st;

const PTabletWriterAddBlockRequest& request,

PTabletWriterAddBlockResult* response) {

_self_profile->add_info_string("EosHost", fmt::format("{}", request.backend_id()));

bool finished = false;

auto index_id = request.index_id();

RETURN_IF_ERROR(channel->close(this, request, response, &finished));

// for init node, we close waiting(hang on) all close request and let them return together.

if (request.has_hang_wait() && request.hang_wait()) {

DCHECK(!channel->is_incremental_channel());

VLOG_DEBUG << fmt::format("txn {}: reciever index {} close waiting by sender {}", _txn_id,

request.index_id(), request.sender_id());

int count = 0;

while (!channel->is_finished()) {

bthread_usleep(1000);

count++;

}

// now maybe finished or cancelled.

VLOG_TRACE << "reciever close wait finished!" << request.sender_id();

if (count >= 1000 * _timeout_s) { // maybe config::streaming_load_rpc_max_alive_time_sec

return Status::InternalError("Tablets channel didn't wait all close");

}

}

if (finished) {

std::lock_guard<std::mutex> l(_lock);

{

std::lock_guard<std::mutex> l(_tablets_channels_lock);

_tablets_channels_rows.insert(std::make_pair(

index_id,

std::make_pair(channel->total_received_rows(), channel->num_rows_filtered())));

_tablets_channels.erase(index_id);

}

LOG(INFO) << "txn " << _txn_id << " closed tablets_channel " << index_id;

_finished_channel_ids.emplace(index_id);

}

return Status::OK();

if (!_enable_profile) {

return;

}

// TabletSink and LoadChannel in BE are M: N relationship,

// Every once in a while LoadChannel will randomly return its own runtime profile to a TabletSink,

// so usually all LoadChannel runtime profiles are saved on each TabletSink,

// and the timeliness of the same LoadChannel profile saved on different TabletSinks is different,

// and each TabletSink will periodically send fe reports all the LoadChannel profiles saved by itself,

// and ensures to update the latest LoadChannel profile according to the timestamp.

_self_profile->set_timestamp(_last_updated_time);

{

std::lock_guard<std::mutex> l(_tablets_channels_lock);

for (auto& it : _tablets_channels) {

it.second->refresh_profile();

}

}

TRuntimeProfileTree tprofile;

ThriftSerializer ser(false, 4096);

uint8_t* buf = nullptr;

uint32_t len = 0;

std::lock_guard<SpinLock> l(_profile_serialize_lock);

_profile->to_thrift(&tprofile);

auto st = ser.serialize(&tprofile, &len, &buf);

if (st.ok()) {

response->set_load_channel_profile(std::string((const char*)buf, len));

} else {

LOG(WARNING) << "load channel TRuntimeProfileTree serialize failed, errmsg=" << st;

}

if (!_opened) {

return false;

}

std::lock_guard<std::mutex> l(_lock);

return _tablets_channels.empty();

std::lock_guard<std::mutex> l(_lock);

for (auto& it : _tablets_channels) {

static_cast<void>(it.second->cancel());

}

return Status::OK();