gfwleak/stellar-stellar
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor(packet manager): hide packet manager schema and packet manager runtime

Browse Source
This commit is contained in:
luwenpeng
2024-09-19 17:26:34 +08:00
parent aedc675c34
commit 60caf1bda1
4 changed files with 205 additions and 246 deletions
Download Patch File Download Diff File Expand all files Collapse all files

256
infra/packet_manager/packet_manager.c
View File

@@ -24,12 +24,14 @@ struct packet_manager_schema
struct packet_manager_runtime
{
enum packet_stage stage;
struct packet_queue queue[PACKET_QUEUE_MAX];
void *cb_args;
on_packet_claimed_callback *claimed_cb;
enum packet_stage stage;
struct mq_runtime *mq;
struct packet_queue queue[PACKET_QUEUE_MAX];
struct packet_manager_runtime_stat stat;
struct packet_manager_stat stat;
};
struct packet_manager
@@ -169,11 +171,6 @@ error_out:
return NULL;
}
int packet_manager_schema_add_subscriber(struct packet_manager_schema *pkt_mgr_schema, enum packet_stage stage, on_packet_stage_callback cb, void *args)
{
return mq_schema_subscribe(pkt_mgr_schema->mq, pkt_mgr_schema->topic_id[stage], (on_msg_cb_func *)cb, args);
}
/******************************************************************************
* packet manager runtime
******************************************************************************/
@@ -215,120 +212,6 @@ static struct packet_manager_runtime *packet_manager_runtime_new()
return runtime;
}
void packet_manager_runtime_print_stat(struct packet_manager_runtime *runtime)
{
PACKET_MANAGER_LOG_DEBUG("runtime[%p] current stage: %s, pkts_ingress: %lu, pkts_egress: %lu",
runtime, packet_stage_to_str(runtime->stage),
runtime->stat.total.pkts_ingress, runtime->stat.total.pkts_egress);
for (int i = 0; i < PACKET_QUEUE_MAX; i++)
{
PACKET_MANAGER_LOG_DEBUG("runtime[%p] (%11s) queue stat => pkts_in: %lu, pkts_out: %lu, pkts_claim: %lu, pkts_schedule: %lu",
runtime,
packet_stage_to_str(i),
runtime->stat.queue[i].pkts_in,
runtime->stat.queue[i].pkts_out,
runtime->stat.queue[i].pkts_claim,
runtime->stat.queue[i].pkts_schedule);
}
}
struct packet_manager_runtime_stat *packet_manager_runtime_get_stat(struct packet_manager_runtime *runtime)
{
return &runtime->stat;
}
void packet_manager_runtime_init(struct packet_manager_runtime *pkt_mgr_rt, struct mq_runtime *mq_rt)
{
pkt_mgr_rt->mq = mq_rt;
}
void packet_manager_runtime_ingress(struct packet_manager_runtime *pkt_mgr_rt, struct packet *pkt)
{
pkt_mgr_rt->stat.total.pkts_ingress++;
pkt_mgr_rt->stat.queue[PACKET_STAGE_PREROUTING].pkts_in++;
TAILQ_INSERT_TAIL(&pkt_mgr_rt->queue[PACKET_STAGE_PREROUTING], pkt, stage_tqe);
}
struct packet *packet_manager_runtime_egress(struct packet_manager_runtime *pkt_mgr_rt)
{
struct packet *pkt = TAILQ_FIRST(&pkt_mgr_rt->queue[PACKET_STAGE_MAX]);
if (pkt)
{
pkt_mgr_rt->stat.total.pkts_egress++;
pkt_mgr_rt->stat.queue[PACKET_STAGE_MAX].pkts_out++;
TAILQ_REMOVE(&pkt_mgr_rt->queue[PACKET_STAGE_MAX], pkt, stage_tqe);
}
return pkt;
}
void packet_manager_runtime_dispatch(struct packet_manager_runtime *pkt_mgr_rt)
{
for (int i = 0; i < PACKET_STAGE_MAX; i++)
{
pkt_mgr_rt->stage = i;
packet_manager_runtime_print_stat(pkt_mgr_rt);
struct packet *pkt = NULL;
while ((pkt = TAILQ_FIRST(&pkt_mgr_rt->queue[pkt_mgr_rt->stage])))
{
packet_set_claim(pkt, false);
pkt_mgr_rt->claimed_cb = NULL;
pkt_mgr_rt->cb_args = NULL;
TAILQ_REMOVE(&pkt_mgr_rt->queue[pkt_mgr_rt->stage], pkt, stage_tqe);
pkt_mgr_rt->stat.queue[pkt_mgr_rt->stage].pkts_out++;
mq_runtime_publish_message(pkt_mgr_rt->mq, pkt_mgr_rt->stage, pkt);
mq_runtime_dispatch(pkt_mgr_rt->mq);
if (packet_is_claim(pkt))
{
if (pkt_mgr_rt->claimed_cb)
{
pkt_mgr_rt->claimed_cb(pkt, pkt_mgr_rt->cb_args);
}
packet_set_claim(pkt, false);
continue;
}
TAILQ_INSERT_TAIL(&pkt_mgr_rt->queue[pkt_mgr_rt->stage + 1], pkt, stage_tqe);
pkt_mgr_rt->stat.queue[pkt_mgr_rt->stage + 1].pkts_in++;
}
}
pkt_mgr_rt->stage = -1;
}
int packet_manager_runtime_claim_packet(struct packet_manager_runtime *pkt_mgr_rt, struct packet *pkt, on_packet_claimed_callback cb, void *args)
{
if (packet_is_claim(pkt))
{
PACKET_MANAGER_LOG_ERROR("packet is already claimed, cannot claim again");
return -1;
}
else
{
pkt_mgr_rt->claimed_cb = cb;
pkt_mgr_rt->cb_args = args;
packet_set_claim(pkt, true);
pkt_mgr_rt->stat.queue[pkt_mgr_rt->stage].pkts_claim++;
return 0;
}
}
void packet_manager_runtime_schedule_packet(struct packet_manager_runtime *pkt_mgr_rt, struct packet *pkt, enum packet_stage stage)
{
if (stage >= PACKET_STAGE_MAX)
{
PACKET_MANAGER_LOG_ERROR("invalid stage %d", stage);
assert(0);
return;
}
pkt_mgr_rt->stat.queue[stage].pkts_schedule++;
pkt_mgr_rt->stat.queue[stage].pkts_in++;
TAILQ_INSERT_TAIL(&pkt_mgr_rt->queue[stage], pkt, stage_tqe);
}
/******************************************************************************
* packet manager
******************************************************************************/
@@ -393,26 +276,137 @@ void packet_manager_free(struct packet_manager *pkt_mgr)
}
}
struct packet_manager_schema *packet_manager_get_schema(struct packet_manager *pkt_mgr)
int packet_manager_subscribe(struct packet_manager *pkt_mgr, enum packet_stage stage, on_packet_stage_callback cb, void *args)
{
if (pkt_mgr)
return mq_schema_subscribe(pkt_mgr->schema->mq, pkt_mgr->schema->topic_id[stage], (on_msg_cb_func *)cb, args);
}
void packet_manager_init(struct packet_manager *pkt_mgr, uint16_t thread_id, struct mq_runtime *mq_rt)
{
struct packet_manager_runtime *runtime = pkt_mgr->runtime[thread_id];
runtime->mq = mq_rt;
}
void packet_manager_ingress(struct packet_manager *pkt_mgr, uint16_t thread_id, struct packet *pkt)
{
struct packet_manager_runtime *runtime = pkt_mgr->runtime[thread_id];
runtime->stat.total.pkts_ingress++;
runtime->stat.queue[PACKET_STAGE_PREROUTING].pkts_in++;
TAILQ_INSERT_TAIL(&runtime->queue[PACKET_STAGE_PREROUTING], pkt, stage_tqe);
}
struct packet *packet_manager_egress(struct packet_manager *pkt_mgr, uint16_t thread_id)
{
struct packet_manager_runtime *runtime = pkt_mgr->runtime[thread_id];
struct packet *pkt = TAILQ_FIRST(&runtime->queue[PACKET_STAGE_MAX]);
if (pkt)
{
return pkt_mgr->schema;
runtime->stat.total.pkts_egress++;
runtime->stat.queue[PACKET_STAGE_MAX].pkts_out++;
TAILQ_REMOVE(&runtime->queue[PACKET_STAGE_MAX], pkt, stage_tqe);
}
return pkt;
}
void packet_manager_dispatch(struct packet_manager *pkt_mgr, uint16_t thread_id)
{
struct packet_manager_runtime *runtime = pkt_mgr->runtime[thread_id];
for (int i = 0; i < PACKET_STAGE_MAX; i++)
{
runtime->stage = i;
packet_manager_print_stat(pkt_mgr, thread_id);
struct packet *pkt = NULL;
while ((pkt = TAILQ_FIRST(&runtime->queue[runtime->stage])))
{
packet_set_claim(pkt, false);
runtime->claimed_cb = NULL;
runtime->cb_args = NULL;
TAILQ_REMOVE(&runtime->queue[runtime->stage], pkt, stage_tqe);
runtime->stat.queue[runtime->stage].pkts_out++;
mq_runtime_publish_message(runtime->mq, runtime->stage, pkt);
mq_runtime_dispatch(runtime->mq);
if (packet_is_claim(pkt))
{
if (runtime->claimed_cb)
{
runtime->claimed_cb(pkt, runtime->cb_args);
}
packet_set_claim(pkt, false);
continue;
}
TAILQ_INSERT_TAIL(&runtime->queue[runtime->stage + 1], pkt, stage_tqe);
runtime->stat.queue[runtime->stage + 1].pkts_in++;
}
}
runtime->stage = -1;
}
int packet_manager_claim_packet(struct packet_manager *pkt_mgr, uint16_t thread_id, struct packet *pkt, on_packet_claimed_callback cb, void *args)
{
struct packet_manager_runtime *runtime = pkt_mgr->runtime[thread_id];
if (packet_is_claim(pkt))
{
PACKET_MANAGER_LOG_ERROR("packet is already claimed, cannot claim again");
return -1;
}
else
{
return NULL;
runtime->claimed_cb = cb;
runtime->cb_args = args;
packet_set_claim(pkt, true);
runtime->stat.queue[runtime->stage].pkts_claim++;
return 0;
}
}
struct packet_manager_runtime *packet_manager_get_runtime(struct packet_manager *pkt_mgr, uint16_t thr_idx)
void packet_manager_schedule_packet(struct packet_manager *pkt_mgr, uint16_t thread_id, struct packet *pkt, enum packet_stage stage)
{
if (pkt_mgr && thr_idx < pkt_mgr->cfg->nr_worker_thread)
struct packet_manager_runtime *runtime = pkt_mgr->runtime[thread_id];
if (stage >= PACKET_STAGE_MAX)
{
return pkt_mgr->runtime[thr_idx];
PACKET_MANAGER_LOG_ERROR("invalid stage %d", stage);
assert(0);
return;
}
else
runtime->stat.queue[stage].pkts_schedule++;
runtime->stat.queue[stage].pkts_in++;
TAILQ_INSERT_TAIL(&runtime->queue[stage], pkt, stage_tqe);
}
struct packet_manager_stat *packet_manager_get_stat(struct packet_manager *pkt_mgr, uint16_t thread_id)
{
struct packet_manager_runtime *runtime = pkt_mgr->runtime[thread_id];
return &runtime->stat;
}
void packet_manager_print_stat(struct packet_manager *pkt_mgr, uint16_t thread_id)
{
struct packet_manager_runtime *runtime = pkt_mgr->runtime[thread_id];
PACKET_MANAGER_LOG_DEBUG("runtime[%p] current stage: %s, pkts_ingress: %lu, pkts_egress: %lu",
runtime, packet_stage_to_str(runtime->stage),
runtime->stat.total.pkts_ingress, runtime->stat.total.pkts_egress);
for (int i = 0; i < PACKET_QUEUE_MAX; i++)
{
return NULL;
PACKET_MANAGER_LOG_DEBUG("runtime[%p] (%11s) queue stat => pkts_in: %lu, pkts_out: %lu, pkts_claim: %lu, pkts_schedule: %lu",
runtime,
packet_stage_to_str(i),
runtime->stat.queue[i].pkts_in,
runtime->stat.queue[i].pkts_out,
runtime->stat.queue[i].pkts_claim,
runtime->stat.queue[i].pkts_schedule);
}
}