From f86307e1e4dfa11dd5bedf74395382a0774a9ba6 Mon Sep 17 00:00:00 2001 From: Mrinal Mishra Date: Thu, 10 Nov 2016 18:16:30 +0530 Subject: Add BTS level counters Adds counters for MCS blocks, 11 bit Rach counters and others. Change-Id: I605b0d66eb217decd35cbb8f87abfa577760245a --- src/bts.cpp | 53 ++++++++++++++++++++++++- src/bts.h | 120 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ src/tbf.cpp | 13 ++++++- src/tbf.h | 3 ++ src/tbf_dl.cpp | 54 ++++++++++++++++++++++++++ src/tbf_ul.cpp | 55 +++++++++++++++++++++++++- 6 files changed, 294 insertions(+), 4 deletions(-) diff --git a/src/bts.cpp b/src/bts.cpp index 0668c2da..fe3368da 100644 --- a/src/bts.cpp +++ b/src/bts.cpp @@ -88,6 +88,46 @@ static const struct rate_ctr_desc bts_ctr_description[] = { { "llc.dl_bytes", "RLC encapsulated PDUs"}, { "llc.ul_bytes", "full PDUs received "}, { "rach.requests", "RACH requests "}, + { "11bit_rach.requests", "11BIT_RACH requests "}, + { "immediate.assignment_UL", "Immediate Assign UL "}, + { "immediate.assignment_DL", "Immediate Assign DL "}, + { "pkt.ul_assignment", "Packet UL Assignment "}, + { "pkt.dl_assignment", "Packet DL Assignment "}, + { "ul.control", "UL control Block "}, + { "ul.assignment_poll_timeout", "UL Assign Timeout "}, + { "ul.assignment_failed", "UL Assign Failed "}, + { "dl.assignment_timeout", "DL Assign Timeout "}, + { "dl.assignment_failed", "DL Assign Failed "}, + { "pkt.ul_ack_nack_timeout", "PUAN Poll Timeout "}, + { "pkt.ul_ack_nack_failed", "PUAN poll Failed "}, + { "pkt.dl_ack_nack_timeout", "PDAN poll Timeout "}, + { "pkt.dl_ack_nack_failed", "PDAN poll Failed "}, + { "gprs.downlink_cs1", "CS1 downlink "}, + { "gprs.downlink_cs2", "CS2 downlink "}, + { "gprs.downlink_cs3", "CS3 downlink "}, + { "gprs.downlink_cs4", "CS4 downlink "}, + { "egprs.downlink_mcs1", "MCS1 downlink "}, + { "egprs.downlink_mcs2", "MCS2 downlink "}, + { "egprs.downlink_mcs3", "MCS3 downlink "}, + { "egprs.downlink_mcs4", "MCS4 downlink "}, + { "egprs.downlink_mcs5", "MCS5 downlink "}, + { "egprs.downlink_mcs6", "MCS6 downlink "}, + { "egprs.downlink_mcs7", "MCS7 downlink "}, + { "egprs.downlink_mcs8", "MCS8 downlink "}, + { "egprs.downlink_mcs9", "MCS9 downlink "}, + { "gprs.uplink_cs1", "CS1 Uplink "}, + { "gprs.uplink_cs2", "CS2 Uplink "}, + { "gprs.uplink_cs3", "CS3 Uplink "}, + { "gprs.uplink_cs4", "CS4 Uplink "}, + { "egprs.uplink_mcs1", "MCS1 Uplink "}, + { "egprs.uplink_mcs2", "MCS2 Uplink "}, + { "egprs.uplink_mcs3", "MCS3 Uplink "}, + { "egprs.uplink_mcs4", "MCS4 Uplink "}, + { "egprs.uplink_mcs5", "MCS5 Uplink "}, + { "egprs.uplink_mcs6", "MCS6 Uplink "}, + { "egprs.uplink_mcs7", "MCS7 Uplink "}, + { "egprs.uplink_mcs8", "MCS8 Uplink "}, + { "egprs.uplink_mcs9", "MCS9 Uplink "}, }; static const struct rate_ctr_group_desc bts_ctrg_desc = { @@ -485,6 +525,9 @@ int BTS::rcv_rach(uint16_t ra, uint32_t Fn, int16_t qta, uint8_t is_11bit, rach_frame(); + if (is_11bit) + rach_frame_11bit(); + LOGP(DRLCMAC, LOGL_DEBUG, "MS requests UL TBF on RACH, " "so we provide one \n" "ra=0x%02x Fn=%u qta=%d is_11bit=%d:\n", ra, Fn, qta, is_11bit); @@ -573,8 +616,10 @@ int BTS::rcv_rach(uint16_t ra, uint32_t Fn, int16_t qta, uint8_t is_11bit, m_bts.alpha, m_bts.gamma, -1, burst_type, sb); } - if (plen >= 0) + if (plen >= 0) { + immediate_assignment_ul_tbf(); pcu_l1if_tx_agch(immediate_assignment, plen); + } bitvec_free(immediate_assignment); @@ -699,8 +744,11 @@ void BTS::snd_dl_ass(gprs_rlcmac_tbf *tbf, uint8_t poll, const char *imsi) (tbf->pdch[ts]->last_rts_fn + 21216) % 2715648, tbf->ta(), tbf->trx->arfcn, ts, tbf->tsc(), 7, poll, tbf->poll_fn, m_bts.alpha, m_bts.gamma, -1); - if (plen >= 0) + if (plen >= 0) { + immediate_assignment_dl_tbf(); pcu_l1if_tx_pch(immediate_assignment, plen, imsi); + } + bitvec_free(immediate_assignment); } @@ -1363,6 +1411,7 @@ int gprs_rlcmac_pdch::rcv_control_block( decode_gsm_rlcmac_uplink(rlc_block, ul_control_block); LOGPC(DCSN1, LOGL_NOTICE, "\n"); LOGP(DRLCMAC, LOGL_DEBUG, "------------------------- RX : Uplink Control Block -------------------------\n"); + bts()->rlc_rcvd_control(); switch (ul_control_block->u.MESSAGE_TYPE) { case MT_PACKET_CONTROL_ACK: rcv_control_ack(&ul_control_block->u.Packet_Control_Acknowledgement, fn); diff --git a/src/bts.h b/src/bts.h index 8bea371f..33f5483b 100644 --- a/src/bts.h +++ b/src/bts.h @@ -265,6 +265,46 @@ public: CTR_LLC_DL_BYTES, CTR_LLC_UL_BYTES, CTR_RACH_REQUESTS, + CTR_11BIT_RACH_REQUESTS, + CTR_IMMEDIATE_ASSIGN_UL_TBF, + CTR_IMMEDIATE_ASSIGN_DL_TBF, + CTR_PKT_UL_ASSIGNMENT, + CTR_PKT_DL_ASSIGNMENT, + CTR_RLC_RECV_CONTROL, + CTR_PUA_POLL_TIMEDOUT, + CTR_PUA_POLL_FAILED, + CTR_PDA_POLL_TIMEDOUT, + CTR_PDA_POLL_FAILED, + CTR_PUAN_POLL_TIMEDOUT, + CTR_PUAN_POLL_FAILED, + CTR_PDAN_POLL_TIMEDOUT, + CTR_PDAN_POLL_FAILED, + CTR_GPRS_DL_CS1, + CTR_GPRS_DL_CS2, + CTR_GPRS_DL_CS3, + CTR_GPRS_DL_CS4, + CTR_EGPRS_DL_MCS1, + CTR_EGPRS_DL_MCS2, + CTR_EGPRS_DL_MCS3, + CTR_EGPRS_DL_MCS4, + CTR_EGPRS_DL_MCS5, + CTR_EGPRS_DL_MCS6, + CTR_EGPRS_DL_MCS7, + CTR_EGPRS_DL_MCS8, + CTR_EGPRS_DL_MCS9, + CTR_GPRS_UL_CS1, + CTR_GPRS_UL_CS2, + CTR_GPRS_UL_CS3, + CTR_GPRS_UL_CS4, + CTR_EGPRS_UL_MCS1, + CTR_EGPRS_UL_MCS2, + CTR_EGPRS_UL_MCS3, + CTR_EGPRS_UL_MCS4, + CTR_EGPRS_UL_MCS5, + CTR_EGPRS_UL_MCS6, + CTR_EGPRS_UL_MCS7, + CTR_EGPRS_UL_MCS8, + CTR_EGPRS_UL_MCS9, }; enum { @@ -352,6 +392,46 @@ public: void llc_dl_bytes(int bytes); void llc_ul_bytes(int bytes); void rach_frame(); + void rach_frame_11bit(); + void immediate_assignment_ul_tbf(); + void immediate_assignment_dl_tbf(); + void pkt_ul_assignment(); + void pkt_dl_assignemnt(); + void rlc_rcvd_control(); + void pua_poll_timedout(); + void pua_poll_failed(); + void pda_poll_timedout(); + void pda_poll_failed(); + void pkt_ul_ack_nack_poll_timedout(); + void pkt_ul_ack_nack_poll_failed(); + void pkt_dl_ack_nack_poll_timedout(); + void pkt_dl_ack_nack_poll_failed(); + void gprs_dl_cs1(); + void gprs_dl_cs2(); + void gprs_dl_cs3(); + void gprs_dl_cs4(); + void egprs_dl_mcs1(); + void egprs_dl_mcs2(); + void egprs_dl_mcs3(); + void egprs_dl_mcs4(); + void egprs_dl_mcs5(); + void egprs_dl_mcs6(); + void egprs_dl_mcs7(); + void egprs_dl_mcs8(); + void egprs_dl_mcs9(); + void gprs_ul_cs1(); + void gprs_ul_cs2(); + void gprs_ul_cs3(); + void gprs_ul_cs4(); + void egprs_ul_mcs1(); + void egprs_ul_mcs2(); + void egprs_ul_mcs3(); + void egprs_ul_mcs4(); + void egprs_ul_mcs5(); + void egprs_ul_mcs6(); + void egprs_ul_mcs7(); + void egprs_ul_mcs8(); + void egprs_ul_mcs9(); void ms_present(int32_t n); int32_t ms_present_get(); @@ -505,6 +585,46 @@ CREATE_COUNT_INLINE(llc_frame_sched, CTR_LLC_FRAME_SCHED); CREATE_COUNT_ADD_INLINE(llc_dl_bytes, CTR_LLC_DL_BYTES); CREATE_COUNT_ADD_INLINE(llc_ul_bytes, CTR_LLC_UL_BYTES); CREATE_COUNT_INLINE(rach_frame, CTR_RACH_REQUESTS); +CREATE_COUNT_INLINE(rach_frame_11bit, CTR_11BIT_RACH_REQUESTS); +CREATE_COUNT_INLINE(immediate_assignment_ul_tbf, CTR_IMMEDIATE_ASSIGN_UL_TBF); +CREATE_COUNT_INLINE(immediate_assignment_dl_tbf, CTR_IMMEDIATE_ASSIGN_DL_TBF); +CREATE_COUNT_INLINE(pkt_ul_assignment, CTR_PKT_UL_ASSIGNMENT); +CREATE_COUNT_INLINE(pkt_dl_assignemnt, CTR_PKT_DL_ASSIGNMENT); +CREATE_COUNT_INLINE(rlc_rcvd_control, CTR_RLC_RECV_CONTROL); +CREATE_COUNT_INLINE(pua_poll_timedout, CTR_PUA_POLL_TIMEDOUT); +CREATE_COUNT_INLINE(pua_poll_failed, CTR_PUA_POLL_FAILED); +CREATE_COUNT_INLINE(pda_poll_timedout, CTR_PDA_POLL_TIMEDOUT); +CREATE_COUNT_INLINE(pda_poll_failed, CTR_PDA_POLL_FAILED); +CREATE_COUNT_INLINE(pkt_ul_ack_nack_poll_timedout, CTR_PUAN_POLL_TIMEDOUT); +CREATE_COUNT_INLINE(pkt_ul_ack_nack_poll_failed, CTR_PUAN_POLL_FAILED); +CREATE_COUNT_INLINE(pkt_dl_ack_nack_poll_timedout, CTR_PDAN_POLL_TIMEDOUT); +CREATE_COUNT_INLINE(pkt_dl_ack_nack_poll_failed, CTR_PDAN_POLL_FAILED); +CREATE_COUNT_INLINE(gprs_dl_cs1, CTR_GPRS_DL_CS1); +CREATE_COUNT_INLINE(gprs_dl_cs2, CTR_GPRS_DL_CS2); +CREATE_COUNT_INLINE(gprs_dl_cs3, CTR_GPRS_DL_CS3); +CREATE_COUNT_INLINE(gprs_dl_cs4, CTR_GPRS_DL_CS4); +CREATE_COUNT_INLINE(egprs_dl_mcs1, CTR_EGPRS_DL_MCS1); +CREATE_COUNT_INLINE(egprs_dl_mcs2, CTR_EGPRS_DL_MCS2); +CREATE_COUNT_INLINE(egprs_dl_mcs3, CTR_EGPRS_DL_MCS3); +CREATE_COUNT_INLINE(egprs_dl_mcs4, CTR_EGPRS_DL_MCS4); +CREATE_COUNT_INLINE(egprs_dl_mcs5, CTR_EGPRS_DL_MCS5); +CREATE_COUNT_INLINE(egprs_dl_mcs6, CTR_EGPRS_DL_MCS6); +CREATE_COUNT_INLINE(egprs_dl_mcs7, CTR_EGPRS_DL_MCS7); +CREATE_COUNT_INLINE(egprs_dl_mcs8, CTR_EGPRS_DL_MCS8); +CREATE_COUNT_INLINE(egprs_dl_mcs9, CTR_EGPRS_DL_MCS9); +CREATE_COUNT_INLINE(gprs_ul_cs1, CTR_GPRS_UL_CS1); +CREATE_COUNT_INLINE(gprs_ul_cs2, CTR_GPRS_UL_CS2); +CREATE_COUNT_INLINE(gprs_ul_cs3, CTR_GPRS_UL_CS3); +CREATE_COUNT_INLINE(gprs_ul_cs4, CTR_GPRS_UL_CS4); +CREATE_COUNT_INLINE(egprs_ul_mcs1, CTR_EGPRS_UL_MCS1); +CREATE_COUNT_INLINE(egprs_ul_mcs2, CTR_EGPRS_UL_MCS2); +CREATE_COUNT_INLINE(egprs_ul_mcs3, CTR_EGPRS_UL_MCS3); +CREATE_COUNT_INLINE(egprs_ul_mcs4, CTR_EGPRS_UL_MCS4); +CREATE_COUNT_INLINE(egprs_ul_mcs5, CTR_EGPRS_UL_MCS5); +CREATE_COUNT_INLINE(egprs_ul_mcs6, CTR_EGPRS_UL_MCS6); +CREATE_COUNT_INLINE(egprs_ul_mcs7, CTR_EGPRS_UL_MCS7); +CREATE_COUNT_INLINE(egprs_ul_mcs8, CTR_EGPRS_UL_MCS8); +CREATE_COUNT_INLINE(egprs_ul_mcs9, CTR_EGPRS_UL_MCS9); #undef CREATE_COUNT_INLINE diff --git a/src/tbf.cpp b/src/tbf.cpp index 2d827270..072d0afb 100644 --- a/src/tbf.cpp +++ b/src/tbf.cpp @@ -508,12 +508,14 @@ void gprs_rlcmac_tbf::poll_timeout() } ul_ack_state = GPRS_RLCMAC_UL_ACK_NONE; bts->rlc_ack_timedout(); + bts->pkt_ul_ack_nack_poll_timedout(); if (state_is(GPRS_RLCMAC_FINISHED)) { gprs_rlcmac_ul_tbf *ul_tbf = as_ul_tbf(this); ul_tbf->m_n3103++; if (ul_tbf->m_n3103 == ul_tbf->bts->bts_data()->n3103) { LOGP(DRLCMAC, LOGL_NOTICE, "- N3103 exceeded\n"); + bts->pkt_ul_ack_nack_poll_failed(); ul_tbf->set_state(GPRS_RLCMAC_RELEASING); tbf_timer_start(ul_tbf, 3169, ul_tbf->bts->bts_data()->t3169, 0); return; @@ -533,11 +535,13 @@ void gprs_rlcmac_tbf::poll_timeout() ul_ass_state = GPRS_RLCMAC_UL_ASS_NONE; n3105++; bts->rlc_ass_timedout(); + bts->pua_poll_timedout(); if (n3105 == bts_data()->n3105) { LOGP(DRLCMAC, LOGL_NOTICE, "- N3105 exceeded\n"); set_state(GPRS_RLCMAC_RELEASING); tbf_timer_start(this, 3195, bts_data()->t3195, 0); bts->rlc_ass_failed(); + bts->pua_poll_failed(); return; } /* reschedule UL assignment */ @@ -553,11 +557,13 @@ void gprs_rlcmac_tbf::poll_timeout() dl_ass_state = GPRS_RLCMAC_DL_ASS_NONE; n3105++; bts->rlc_ass_timedout(); + bts->pda_poll_timedout(); if (n3105 == bts->bts_data()->n3105) { LOGP(DRLCMAC, LOGL_NOTICE, "- N3105 exceeded\n"); set_state(GPRS_RLCMAC_RELEASING); tbf_timer_start(this, 3195, bts_data()->t3195, 0); bts->rlc_ass_failed(); + bts->pda_poll_failed(); return; } /* reschedule DL assignment */ @@ -574,12 +580,15 @@ void gprs_rlcmac_tbf::poll_timeout() dl_tbf->n3105++; if (dl_tbf->state_is(GPRS_RLCMAC_RELEASING)) bts->rlc_rel_timedout(); - else + else { bts->rlc_ack_timedout(); + bts->pkt_dl_ack_nack_poll_timedout(); + } if (dl_tbf->n3105 == dl_tbf->bts->bts_data()->n3105) { LOGP(DRLCMAC, LOGL_NOTICE, "- N3105 exceeded\n"); dl_tbf->set_state(GPRS_RLCMAC_RELEASING); tbf_timer_start(dl_tbf, 3195, dl_tbf->bts_data()->t3195, 0); + bts->pkt_dl_ack_nack_poll_failed(); bts->rlc_ack_failed(); return; } @@ -991,6 +1000,7 @@ struct msgb *gprs_rlcmac_tbf::create_dl_ass(uint32_t fn, uint8_t ts) encode_gsm_rlcmac_downlink(ass_vec, mac_control_block); LOGPC(DCSN1, LOGL_NOTICE, "\n"); LOGP(DRLCMAC, LOGL_DEBUG, "------------------------- TX : Packet Downlink Assignment -------------------------\n"); + bts->pkt_dl_assignemnt(); bitvec_pack(ass_vec, msgb_put(msg, 23)); bitvec_free(ass_vec); talloc_free(mac_control_block); @@ -1087,6 +1097,7 @@ struct msgb *gprs_rlcmac_tbf::create_ul_ass(uint32_t fn, uint8_t ts) decode_gsm_rlcmac_downlink(ass_vec, mac_control_block); LOGPC(DCSN1, LOGL_NOTICE, "\n"); LOGP(DRLCMAC, LOGL_DEBUG, "------------------------- TX : Packet Uplink Assignment -------------------------\n"); + bts->pkt_ul_assignment(); bitvec_free(ass_vec); talloc_free(mac_control_block); diff --git a/src/tbf.h b/src/tbf.h index e0440535..1e98a24b 100644 --- a/src/tbf.h +++ b/src/tbf.h @@ -379,6 +379,7 @@ struct gprs_rlcmac_dl_tbf : public gprs_rlcmac_tbf { int abort(); void egprs_calc_window_size(); + void update_coding_scheme_counter_dl(const GprsCodingScheme cs); /* TODO: add the gettimeofday as parameter */ struct msgb *llc_dequeue(bssgp_bvc_ctx *bctx); @@ -467,6 +468,8 @@ struct gprs_rlcmac_ul_tbf : public gprs_rlcmac_tbf { struct gprs_rlc_data *block, uint8_t *data, const uint8_t block_idx); + void update_coding_scheme_counter_ul(const GprsCodingScheme cs); + /* Please note that all variables here will be reset when changing * from WAIT RELEASE back to FLOW state (re-use of TBF). * All states that need reset must be in this struct, so this is why diff --git a/src/tbf_dl.cpp b/src/tbf_dl.cpp index f6836f8b..185521d9 100644 --- a/src/tbf_dl.cpp +++ b/src/tbf_dl.cpp @@ -648,6 +648,7 @@ struct msgb *gprs_rlcmac_dl_tbf::create_dl_acked_block( num_bsns += 1; } + update_coding_scheme_counter_dl(cs); /* * if the intial mcs is 8 and retransmission mcs is either 6 or 3 * we have to include the padding of 6 octets in first segment @@ -1330,3 +1331,56 @@ void gprs_rlcmac_dl_tbf::egprs_calc_window_size() m_window.set_ws(ws); } + +void gprs_rlcmac_dl_tbf::update_coding_scheme_counter_dl(const GprsCodingScheme cs) +{ + uint8_t coding_scheme = 0; + + coding_scheme = GprsCodingScheme::Scheme(cs); + if (cs.isGprs()) { + switch (coding_scheme) { + case GprsCodingScheme::CS1 : + bts->gprs_dl_cs1(); + break; + case GprsCodingScheme::CS2 : + bts->gprs_dl_cs2(); + break; + case GprsCodingScheme::CS3 : + bts->gprs_dl_cs3(); + break; + case GprsCodingScheme::CS4 : + bts->gprs_dl_cs4(); + break; + } + } else { + switch (coding_scheme) { + case GprsCodingScheme::MCS1 : + bts->egprs_dl_mcs1(); + break; + case GprsCodingScheme::MCS2 : + bts->egprs_dl_mcs2(); + break; + case GprsCodingScheme::MCS3 : + bts->egprs_dl_mcs3(); + break; + case GprsCodingScheme::MCS4 : + bts->egprs_dl_mcs4(); + break; + case GprsCodingScheme::MCS5 : + bts->egprs_dl_mcs5(); + break; + case GprsCodingScheme::MCS6 : + bts->egprs_dl_mcs6(); + break; + case GprsCodingScheme::MCS7 : + bts->egprs_dl_mcs7(); + break; + case GprsCodingScheme::MCS8 : + bts->egprs_dl_mcs8(); + break; + case GprsCodingScheme::MCS9 : + bts->egprs_dl_mcs9(); + break; + } + } +} diff --git a/src/tbf_ul.cpp b/src/tbf_ul.cpp index f67ffd77..420fc1a4 100644 --- a/src/tbf_ul.cpp +++ b/src/tbf_ul.cpp @@ -175,7 +175,7 @@ int gprs_rlcmac_ul_tbf::rcv_data_block_acknowledged( /* Increment RX-counter */ this->m_rx_counter++; - + update_coding_scheme_counter_ul(rlc->cs); /* Loop over num_blocks */ for (block_idx = 0; block_idx < rlc->num_data_blocks; block_idx++) { int num_chunks; @@ -517,3 +517,56 @@ egprs_rlc_ul_reseg_bsn_state gprs_rlcmac_ul_tbf::handle_egprs_ul_spb( } return assemble_status; } + +void gprs_rlcmac_ul_tbf::update_coding_scheme_counter_ul(const GprsCodingScheme cs) +{ + uint8_t coding_scheme = 0; + + coding_scheme = GprsCodingScheme::Scheme(cs); + if (cs.isGprs()) { + switch (coding_scheme) { + case GprsCodingScheme::CS1 : + bts->gprs_ul_cs1(); + break; + case GprsCodingScheme::CS2 : + bts->gprs_ul_cs2(); + break; + case GprsCodingScheme::CS3 : + bts->gprs_ul_cs3(); + break; + case GprsCodingScheme::CS4 : + bts->gprs_ul_cs4(); + break; + } + } else { + switch (coding_scheme) { + case GprsCodingScheme::MCS1 : + bts->egprs_ul_mcs1(); + break; + case GprsCodingScheme::MCS2 : + bts->egprs_ul_mcs2(); + break; + case GprsCodingScheme::MCS3 : + bts->egprs_ul_mcs3(); + break; + case GprsCodingScheme::MCS4 : + bts->egprs_ul_mcs4(); + break; + case GprsCodingScheme::MCS5 : + bts->egprs_ul_mcs5(); + break; + case GprsCodingScheme::MCS6 : + bts->egprs_ul_mcs6(); + break; + case GprsCodingScheme::MCS7 : + bts->egprs_ul_mcs7(); + break; + case GprsCodingScheme::MCS8 : + bts->egprs_ul_mcs8(); + break; + case GprsCodingScheme::MCS9 : + bts->egprs_ul_mcs9(); + break; + } + } +} -- cgit v1.2.3