Method StartRead

src/tabletnode/tabletnode_impl.cc:1282–1334

}

void ReadTabletTask::StartRead() {
  if (total_row_num_ == 0) {
    response_->set_status(kTabletNodeOk);
    response_->set_success_num(read_success_num_.Get());
    done_->Run();
    return;
  }

  response_->mutable_detail()->mutable_status()->Reserve(total_row_num_);
  for (int i = 0; i != total_row_num_; ++i) {
    response_->mutable_detail()->mutable_status()->AddAlreadyReserved();
  }

  int64_t max_task_num = FLAGS_tera_tabletnode_parallel_read_task_num;
  int64_t min_rows_per_task = FLAGS_tera_tabletnode_parallel_read_rows_per_task;
  int64_t max_size = max_task_num * min_rows_per_task;
  int64_t rows_per_task;

  if (max_size >= total_row_num_) {
    rows_per_task = min_rows_per_task;
  } else {
    if (max_task_num <= 1) {
      rows_per_task = total_row_num_;
    } else {
      rows_per_task = total_row_num_ / max_task_num + 1;
    }
  }
  int64_t shard_cnt = total_row_num_ / rows_per_task + 1;

  row_results_list_.reserve(shard_cnt);

  int64_t row_to_read = total_row_num_;
  int64_t offset = 0;
  while (row_to_read > 0) {
    row_results_list_.emplace_back();
    auto shard_request = make_shared<ShardRequest>(offset, std::min(rows_per_task, row_to_read),
                                                   &row_results_list_.back());
    row_to_read -= rows_per_task;
    offset += rows_per_task;
    // We split one read request to several shard_request.
    // row_to_read <= 0 means this is the last sharded request(No more rows need
    // to read).
    // So this sharded request is processed in current thread for reducing cost
    // of switching thread.
    // Otherwise, shard_request is added to read_thread_pool.
    if (row_to_read <= 0) {
      DoRead(shard_request);
    } else {
      read_thread_pool_->AddTask(
          std::bind(&ReadTabletTask::DoRead, shared_from_this(), shard_request));
    }
  }
}

void ReadTabletTask::DoRead(std::shared_ptr<ShardRequest> shard_req) {
  bool is_timeout{false};