Method register_task_code

src/runtime/task/task_spec.cpp:55–106

static std::array<std::unique_ptr<task_spec>, TASK_SPEC_STORE_CAPACITY> s_task_spec_store;

void task_spec::register_task_code(task_code code,
                                   dsn_task_type_t type,
                                   dsn_task_priority_t pri,
                                   dsn::threadpool_code pool)
{
    CHECK_GE(code, 0);
    CHECK_LT(code, TASK_SPEC_STORE_CAPACITY);
    if (!s_task_spec_store[code]) {
        s_task_spec_store[code] =
            std::make_unique<task_spec>(code, code.to_string(), type, pri, pool);
        auto &spec = s_task_spec_store[code];

        if (type == TASK_TYPE_RPC_REQUEST) {
            std::string ack_name = std::string(code.to_string()) + std::string("_ACK");
            // for a rpc request, we firstly register it's ack code to invalid threadpool,
            // then the response code's definition will reassign a proper valid threadpool code.
            // please refer to the DEFINE_TASK_CODE_RPC/DEFINE_STORAGE_RPC_CODE in task_code.h
            // for more details.
            dsn::task_code ack_code(
                ack_name.c_str(), TASK_TYPE_RPC_RESPONSE, pri, THREAD_POOL_INVALID);
            spec->rpc_paired_code = ack_code;
            task_spec::get(ack_code.code())->rpc_paired_code = code;
        }
    } else {
        auto spec = task_spec::get(code);
        CHECK_EQ_MSG(
            spec->type,
            type,
            "task code {} registerd for {}, which does not match with previously registered {}",
            code,
            enum_to_string(type),
            enum_to_string(spec->type));

        if (spec->priority != pri) {
            LOG_WARNING("overwrite priority for task {} from {} to {}",
                        code,
                        enum_to_string(spec->priority),
                        enum_to_string(pri));
            spec->priority = pri;
        }

        if (spec->pool_code != pool) {
            if (spec->pool_code != THREAD_POOL_INVALID) {
                LOG_WARNING("overwrite default thread pool for task {} from {} to {}",
                            code,
                            spec->pool_code,
                            pool);
            }
            spec->pool_code = pool;
        }
    }
}

void task_spec::register_storage_task_code(task_code code,
                                           dsn_task_type_t type,