cellular-infrastructure
/
osmo-pcu
mirror of https://gerrit.osmocom.org/osmo-pcu
9
0
Fork 1
Code Issues Releases Wiki Activity
osmo-pcu/tests/alloc/AllocTest.cpp

871 lines
23 KiB
C++
Raw Normal View History

alloc: Add very basic test case for the alloc_a algorithm
2013-10-16 15:29:31 +00:00
/* AllocTest.cpp
*
* Copyright (C) 2013 by Holger Hans Peter Freyther
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include "gprs_rlcmac.h"
#include "gprs_debug.h"
#include "tbf.h"
Move out tbf subclasses from tbf.h to their own headers It's a good start towards clearing current mess between parent and the 2 children classes. Change-Id: Ibc22ea2e02609af7ee058b8bc15df2115d4c6f60
2019-09-25 15:47:02 +00:00
#include "tbf_ul.h"
Unify BTS into a C usable structure Previous work on BTS class started to get stuff out of the C++ struct into a C struct (BTS -> struct gprs_glcmac_bts) so that some parts of it were accessible from C code. Doing so, however, ended up being messy too, since all code needs to be switching from one object to another, which actually refer to the same logical component. Let's instead rejoin the structures and make sure the struct is accessible and usable from both C and C++ code by rewriting all methods to be C compatible and converting 3 allocated suboject as pointers. This way BTS can internally still use those C++ objects while providing a clean APi to both C and C++ code. Change-Id: I7d12c896c5ded659ca9d3bff4cf3a3fc857db9dd
2021-01-14 15:48:38 +00:00
#include "tbf_dl.h"
bts/tbf: Move the lists into the BTS and do the look-up from the BTS The list belongs to the BTS. This makes cleaning this up more easy and establishes a hierachy of resources that start from the BTS. The debug_diagram code is now broken.
2013-10-19 19:10:38 +00:00
#include "bts.h"
Unify BTS into a C usable structure Previous work on BTS class started to get stuff out of the C++ struct into a C struct (BTS -> struct gprs_glcmac_bts) so that some parts of it were accessible from C code. Doing so, however, ended up being messy too, since all code needs to be switching from one object to another, which actually refer to the same logical component. Let's instead rejoin the structures and make sure the struct is accessible and usable from both C and C++ code by rewriting all methods to be C compatible and converting 3 allocated suboject as pointers. This way BTS can internally still use those C++ objects while providing a clean APi to both C and C++ code. Change-Id: I7d12c896c5ded659ca9d3bff4cf3a3fc857db9dd
2021-01-14 15:48:38 +00:00
#include "gprs_ms.h"
bts: delete pch_timer list in destructor Run bts_pch_timer_remove() on each entry of the BTS specific pch_timer list, so we don't have a memory leak and so the timer doesn't potentially fire for a deallocated BTS. Fixes: d3c7591 ("Add counters: pcu.bts.N.pch.requests.timeout") Change-Id: Ia5e33d1894408e93a51c452002ef2f5758808269
2021-08-23 12:19:21 +00:00
#include "bts_pch_timer.h"
alloc: Add very basic test case for the alloc_a algorithm
2013-10-16 15:29:31 +00:00
#include <string.h>
#include <stdio.h>
extern "C" {
AllocTest: remove assumption on max MS class So far the allocation was only tested up to hardcoded MS class 29. Drop that assumption and test for all supported MS classes. Adjust expected test output as necessary. Note: using mslot_class_max() forces allocation for MS classes 30 and 31 for which no actual data is available (will be added in follow-up patches) which current implementation treats differently depending on TX/RX direction - see gprs_alloc_max_dl_slots_per_ms(). Because of that we have to adjust the expected number of allocations in test_successive_allocation() as well. Change-Id: I7737f303d97197ef159b14a19c3312a11f07b433 Related: OS#2282
2018-01-23 19:57:08 +00:00
#include "mslot_class.h"
alloc: Add very basic test case for the alloc_a algorithm
2013-10-16 15:29:31 +00:00
#include <osmocom/core/application.h>
#include <osmocom/core/msgb.h>
#include <osmocom/core/talloc.h>
#include <osmocom/core/utils.h>
tbf: Move existing tbf_state implementation to osmo_fsm This is only an initial implementation, where all state changes are still done outside the FSM itself. The idea is to do the move in several commits so that they can be digested better in logical steps and avoid major break up. Related: OS#2709 Change-Id: I6bb4baea2dee191ba5bbcbec2ea9dcf681aa1237
2021-05-14 10:50:46 +00:00
#include <osmocom/core/fsm.h>
alloc: Add very basic test case for the alloc_a algorithm
2013-10-16 15:29:31 +00:00
}
/* globals used by the code */
void *tall_pcu_ctx;
int16_t spoof_mnc = 0, spoof_mcc = 0;
implement support for 3-digit MNC with leading zeros Receive the mnc_3_digits flag from the PCU interface. Bump the PCU interface to 9. This is one part of the three identical pcuif_proto.h patches: - I49cd762c3c9d7ee6a82451bdf3ffa2a060767947 (osmo-bts) - I787fed84a7b613158a5618dd5cffafe4e4927234 (osmo-pcu) - I78f30aef7aa224b2e9db54c3a844d8f520b3aee0 (osmo-bsc) Add 3-digit flags and use the new RAI and LAI API from libosmocore throughout the code base to be able to handle an MNC < 100 that has three digits (leading zeros). Depends: Id2240f7f518494c9df6c8bda52c0d5092f90f221 (libosmocore), Ib7176b1d65a03b76f41f94bc9d3293a8a07d24c6 (libosmocore) Change-Id: I787fed84a7b613158a5618dd5cffafe4e4927234
2018-02-20 23:39:07 +00:00
bool spoof_mnc_3_digits = false;
alloc: Add very basic test case for the alloc_a algorithm
2013-10-16 15:29:31 +00:00
bts, tbf: Split alloc_tbf function into separate UL and DL versions UL and DL tbfs are used in very separate parts and are not the same thing so split the alloc function and use the UL/DL version throughout the code. Ticket: SYS#389 Sponsored-by: On-Waves ehf
2014-07-16 16:54:10 +00:00
static gprs_rlcmac_tbf *tbf_alloc(struct gprs_rlcmac_bts *bts,
tbf: Pass the MS object around instead of old_tbf Currently the old TBF (either uplink or downlink) is passed around at TBF allocation mainly to get information about the MS. To implement more complex allocation algorithms, the MS object itself will be needed anyway. This commit replaces the old_tbf arguments by MS object arguments. Sponsored-by: On-Waves ehf
2015-06-18 15:16:26 +00:00
GprsMs *ms, gprs_rlcmac_tbf_direction dir,
Expect ms object to exist before calling tbf_alloc_dl_tbf() Same as previous commit, this time for the DL counterpart. Change-Id: I87f6cdf8288a688466020bda0874e68b57aa71c4
2020-05-08 16:15:59 +00:00
uint8_t use_trx, bool single_slot)
bts, tbf: Split alloc_tbf function into separate UL and DL versions UL and DL tbfs are used in very separate parts and are not the same thing so split the alloc function and use the UL/DL version throughout the code. Ticket: SYS#389 Sponsored-by: On-Waves ehf
2014-07-16 16:54:10 +00:00
{
Expect ms object to exist before calling tbf_alloc_dl_tbf() Same as previous commit, this time for the DL counterpart. Change-Id: I87f6cdf8288a688466020bda0874e68b57aa71c4
2020-05-08 16:15:59 +00:00
OSMO_ASSERT(ms != NULL);
Expect ms object to exist before calling tbf_alloc_ul_tbf() It's really non-sense from architectural point of view to pass an optional pointer to the MS holding the TBF and creating it otherwise. TBFs shouldn't be creating MS they belong too. This simple change requiring so many code line changes really exhibits how badly entangled the object relationship is. Another commit will follow doing the same for dl tbf. Change-Id: I010aa5877902816ae246e09ad5ad87946f96855c
2020-05-08 15:44:33 +00:00
bts, tbf: Split alloc_tbf function into separate UL and DL versions UL and DL tbfs are used in very separate parts and are not the same thing so split the alloc function and use the UL/DL version throughout the code. Ticket: SYS#389 Sponsored-by: On-Waves ehf
2014-07-16 16:54:10 +00:00
if (dir == GPRS_RLCMAC_UL_TBF)
Expect ms object to exist before calling tbf_alloc_ul_tbf() It's really non-sense from architectural point of view to pass an optional pointer to the MS holding the TBF and creating it otherwise. TBFs shouldn't be creating MS they belong too. This simple change requiring so many code line changes really exhibits how badly entangled the object relationship is. Another commit will follow doing the same for dl tbf. Change-Id: I010aa5877902816ae246e09ad5ad87946f96855c
2020-05-08 15:44:33 +00:00
return tbf_alloc_ul_tbf(bts, ms, use_trx, single_slot);
bts, tbf: Split alloc_tbf function into separate UL and DL versions UL and DL tbfs are used in very separate parts and are not the same thing so split the alloc function and use the UL/DL version throughout the code. Ticket: SYS#389 Sponsored-by: On-Waves ehf
2014-07-16 16:54:10 +00:00
else
Expect ms object to exist before calling tbf_alloc_dl_tbf() Same as previous commit, this time for the DL counterpart. Change-Id: I87f6cdf8288a688466020bda0874e68b57aa71c4
2020-05-08 16:15:59 +00:00
return tbf_alloc_dl_tbf(bts, ms, use_trx, single_slot);
bts, tbf: Split alloc_tbf function into separate UL and DL versions UL and DL tbfs are used in very separate parts and are not the same thing so split the alloc function and use the UL/DL version throughout the code. Ticket: SYS#389 Sponsored-by: On-Waves ehf
2014-07-16 16:54:10 +00:00
}
Unify BTS into a C usable structure Previous work on BTS class started to get stuff out of the C++ struct into a C struct (BTS -> struct gprs_glcmac_bts) so that some parts of it were accessible from C code. Doing so, however, ended up being messy too, since all code needs to be switching from one object to another, which actually refer to the same logical component. Let's instead rejoin the structures and make sure the struct is accessible and usable from both C and C++ code by rewriting all methods to be C compatible and converting 3 allocated suboject as pointers. This way BTS can internally still use those C++ objects while providing a clean APi to both C and C++ code. Change-Id: I7d12c896c5ded659ca9d3bff4cf3a3fc857db9dd
2021-01-14 15:48:38 +00:00
static void check_tfi_usage(struct gprs_rlcmac_bts *bts)
alloc/test: Check for TFI conflicts This commit adds the check_tfi_usage function that checks the TFI usage. It iterates through all TBFs, records on which PDCH it uses which TFI and check for conflicts. It also checks the bits returned by pdch->assigned_tfi(). The latter suffers from an bug in that method (no separation of uplink and downlink), so a conditional fprintf is used instead of an assertion. The method tfi_find_free is checked for conflicts after allocations. Sponsored-by: On-Waves ehf
2015-07-09 09:35:50 +00:00
{
int pdch_no;
struct gprs_rlcmac_tbf *tfi_usage[8][8][2][32] = {{{{NULL}}}};
Unify BTS into a C usable structure Previous work on BTS class started to get stuff out of the C++ struct into a C struct (BTS -> struct gprs_glcmac_bts) so that some parts of it were accessible from C code. Doing so, however, ended up being messy too, since all code needs to be switching from one object to another, which actually refer to the same logical component. Let's instead rejoin the structures and make sure the struct is accessible and usable from both C and C++ code by rewriting all methods to be C compatible and converting 3 allocated suboject as pointers. This way BTS can internally still use those C++ objects while providing a clean APi to both C and C++ code. Change-Id: I7d12c896c5ded659ca9d3bff4cf3a3fc857db9dd
2021-01-14 15:48:38 +00:00
struct llist_head *tbf_lists[2] = {
Move TBF list from BTS to the TRX structure The TBFs are managed per TRX. Move the global list from BTS to TRX. Related: OS#1541 Change-Id: Id3c59c11d57d765fe68aaebaac94290c0d84feb2
2021-05-13 16:39:36 +00:00
&bts->trx[0].ul_tbfs,
&bts->trx[0].dl_tbfs
alloc/test: Check for TFI conflicts This commit adds the check_tfi_usage function that checks the TFI usage. It iterates through all TBFs, records on which PDCH it uses which TFI and check for conflicts. It also checks the bits returned by pdch->assigned_tfi(). The latter suffers from an bug in that method (no separation of uplink and downlink), so a conditional fprintf is used instead of an assertion. The method tfi_find_free is checked for conflicts after allocations. Sponsored-by: On-Waves ehf
2015-07-09 09:35:50 +00:00
};
Unify BTS into a C usable structure Previous work on BTS class started to get stuff out of the C++ struct into a C struct (BTS -> struct gprs_glcmac_bts) so that some parts of it were accessible from C code. Doing so, however, ended up being messy too, since all code needs to be switching from one object to another, which actually refer to the same logical component. Let's instead rejoin the structures and make sure the struct is accessible and usable from both C and C++ code by rewriting all methods to be C compatible and converting 3 allocated suboject as pointers. This way BTS can internally still use those C++ objects while providing a clean APi to both C and C++ code. Change-Id: I7d12c896c5ded659ca9d3bff4cf3a3fc857db9dd
2021-01-14 15:48:38 +00:00
struct llist_item *pos;
alloc/test: Check for TFI conflicts This commit adds the check_tfi_usage function that checks the TFI usage. It iterates through all TBFs, records on which PDCH it uses which TFI and check for conflicts. It also checks the bits returned by pdch->assigned_tfi(). The latter suffers from an bug in that method (no separation of uplink and downlink), so a conditional fprintf is used instead of an assertion. The method tfi_find_free is checked for conflicts after allocations. Sponsored-by: On-Waves ehf
2015-07-09 09:35:50 +00:00
gprs_rlcmac_tbf *tbf;
unsigned list_idx;
struct gprs_rlcmac_tbf **tbf_var;
for (list_idx = 0; list_idx < ARRAY_SIZE(tbf_lists); list_idx += 1)
{
Unify BTS into a C usable structure Previous work on BTS class started to get stuff out of the C++ struct into a C struct (BTS -> struct gprs_glcmac_bts) so that some parts of it were accessible from C code. Doing so, however, ended up being messy too, since all code needs to be switching from one object to another, which actually refer to the same logical component. Let's instead rejoin the structures and make sure the struct is accessible and usable from both C and C++ code by rewriting all methods to be C compatible and converting 3 allocated suboject as pointers. This way BTS can internally still use those C++ objects while providing a clean APi to both C and C++ code. Change-Id: I7d12c896c5ded659ca9d3bff4cf3a3fc857db9dd
2021-01-14 15:48:38 +00:00
llist_for_each_entry(pos, tbf_lists[list_idx], list) {
tbf = (struct gprs_rlcmac_tbf *)pos->entry;
alloc/test: Check for TFI conflicts This commit adds the check_tfi_usage function that checks the TFI usage. It iterates through all TBFs, records on which PDCH it uses which TFI and check for conflicts. It also checks the bits returned by pdch->assigned_tfi(). The latter suffers from an bug in that method (no separation of uplink and downlink), so a conditional fprintf is used instead of an assertion. The method tfi_find_free is checked for conflicts after allocations. Sponsored-by: On-Waves ehf
2015-07-09 09:35:50 +00:00
for (pdch_no = 0; pdch_no < 8; pdch_no += 1) {
struct gprs_rlcmac_pdch *pdch = tbf->pdch[pdch_no];
if (pdch == NULL)
continue;
tbf_var = &tfi_usage
[tbf->trx->trx_no]
[pdch_no]
[tbf->direction]
[tbf->tfi()];
OSMO_ASSERT(*tbf_var == NULL);
if (tbf->direction == GPRS_RLCMAC_DL_TBF) {
OSMO_ASSERT(pdch->dl_tbf_by_tfi(
tbf->tfi()) == tbf);
Unify BTS into a C usable structure Previous work on BTS class started to get stuff out of the C++ struct into a C struct (BTS -> struct gprs_glcmac_bts) so that some parts of it were accessible from C code. Doing so, however, ended up being messy too, since all code needs to be switching from one object to another, which actually refer to the same logical component. Let's instead rejoin the structures and make sure the struct is accessible and usable from both C and C++ code by rewriting all methods to be C compatible and converting 3 allocated suboject as pointers. This way BTS can internally still use those C++ objects while providing a clean APi to both C and C++ code. Change-Id: I7d12c896c5ded659ca9d3bff4cf3a3fc857db9dd
2021-01-14 15:48:38 +00:00
OSMO_ASSERT(bts_dl_tbf_by_tfi(bts,
alloc/test: Check for TFI conflicts This commit adds the check_tfi_usage function that checks the TFI usage. It iterates through all TBFs, records on which PDCH it uses which TFI and check for conflicts. It also checks the bits returned by pdch->assigned_tfi(). The latter suffers from an bug in that method (no separation of uplink and downlink), so a conditional fprintf is used instead of an assertion. The method tfi_find_free is checked for conflicts after allocations. Sponsored-by: On-Waves ehf
2015-07-09 09:35:50 +00:00
tbf->tfi(),
tbf: Put the TFI->TBF mapping into the PDCH objects Currently the TBFs are registered in a TFI indexed array within the TRX objects. TBFs can be searched globally by TFI and TRX number. This conflicts with the use of the same TFI for different TBF on different PDCH. This use case requires the specification of the PDCH as additional search dimension. This commit moves the TFI index TBF arrays into the PDCH objects. The related methods are updated accordingly. Ticket: #1793 Sponsored-by: On-Waves ehf
2015-07-10 17:52:37 +00:00
tbf->trx->trx_no,
pdch_no) == tbf);
alloc/test: Check for TFI conflicts This commit adds the check_tfi_usage function that checks the TFI usage. It iterates through all TBFs, records on which PDCH it uses which TFI and check for conflicts. It also checks the bits returned by pdch->assigned_tfi(). The latter suffers from an bug in that method (no separation of uplink and downlink), so a conditional fprintf is used instead of an assertion. The method tfi_find_free is checked for conflicts after allocations. Sponsored-by: On-Waves ehf
2015-07-09 09:35:50 +00:00
} else {
OSMO_ASSERT(pdch->ul_tbf_by_tfi(
tbf->tfi()) == tbf);
Unify BTS into a C usable structure Previous work on BTS class started to get stuff out of the C++ struct into a C struct (BTS -> struct gprs_glcmac_bts) so that some parts of it were accessible from C code. Doing so, however, ended up being messy too, since all code needs to be switching from one object to another, which actually refer to the same logical component. Let's instead rejoin the structures and make sure the struct is accessible and usable from both C and C++ code by rewriting all methods to be C compatible and converting 3 allocated suboject as pointers. This way BTS can internally still use those C++ objects while providing a clean APi to both C and C++ code. Change-Id: I7d12c896c5ded659ca9d3bff4cf3a3fc857db9dd
2021-01-14 15:48:38 +00:00
OSMO_ASSERT(bts_ul_tbf_by_tfi(bts,
alloc/test: Check for TFI conflicts This commit adds the check_tfi_usage function that checks the TFI usage. It iterates through all TBFs, records on which PDCH it uses which TFI and check for conflicts. It also checks the bits returned by pdch->assigned_tfi(). The latter suffers from an bug in that method (no separation of uplink and downlink), so a conditional fprintf is used instead of an assertion. The method tfi_find_free is checked for conflicts after allocations. Sponsored-by: On-Waves ehf
2015-07-09 09:35:50 +00:00
tbf->tfi(),
tbf: Put the TFI->TBF mapping into the PDCH objects Currently the TBFs are registered in a TFI indexed array within the TRX objects. TBFs can be searched globally by TFI and TRX number. This conflicts with the use of the same TFI for different TBF on different PDCH. This use case requires the specification of the PDCH as additional search dimension. This commit moves the TFI index TBF arrays into the PDCH objects. The related methods are updated accordingly. Ticket: #1793 Sponsored-by: On-Waves ehf
2015-07-10 17:52:37 +00:00
tbf->trx->trx_no,
pdch_no) == tbf);
alloc/test: Check for TFI conflicts This commit adds the check_tfi_usage function that checks the TFI usage. It iterates through all TBFs, records on which PDCH it uses which TFI and check for conflicts. It also checks the bits returned by pdch->assigned_tfi(). The latter suffers from an bug in that method (no separation of uplink and downlink), so a conditional fprintf is used instead of an assertion. The method tfi_find_free is checked for conflicts after allocations. Sponsored-by: On-Waves ehf
2015-07-09 09:35:50 +00:00
}
*tbf_var = tbf;
pdch: Manage TFIs per direction Currently a single bit set is used to maintain a set of used TFI without distinguishing between uplink and downlink. Since the namespaces of UL and DL TFI are separate, this implementation is not correct. This commit changes gprs_rlcmac_pdch to use a separate bit set for each direction. It also replace the corresponding conditional fprintf statement in check_tfi_usage (AllocTest.cpp) by an equivalent OSMO_ASSERT. Sponsored-by: On-Waves ehf
2015-07-08 10:53:16 +00:00
OSMO_ASSERT(pdch->assigned_tfi(tbf->direction) &
(1 << tbf->tfi()));
alloc/test: Check for TFI conflicts This commit adds the check_tfi_usage function that checks the TFI usage. It iterates through all TBFs, records on which PDCH it uses which TFI and check for conflicts. It also checks the bits returned by pdch->assigned_tfi(). The latter suffers from an bug in that method (no separation of uplink and downlink), so a conditional fprintf is used instead of an assertion. The method tfi_find_free is checked for conflicts after allocations. Sponsored-by: On-Waves ehf
2015-07-09 09:35:50 +00:00
}
}
}
}
alloc/test: Enhance test_alloc_a This commit adds: - an assertion to check that count is valid, - an assertion the verify that tbf_alloc did not fail - a slots parameter to specify the enabled slots - additional test invocations with more slots enabled Sponsored-by: On-Waves ehf
2015-06-29 10:45:11 +00:00
static void test_alloc_a(gprs_rlcmac_tbf_direction dir,
uint8_t slots, const int count)
alloc: Add very basic test case for the alloc_a algorithm
2013-10-16 15:29:31 +00:00
{
int tfi;
alloc/test: Enhance test_alloc_a This commit adds: - an assertion to check that count is valid, - an assertion the verify that tbf_alloc did not fail - a slots parameter to specify the enabled slots - additional test invocations with more slots enabled Sponsored-by: On-Waves ehf
2015-06-29 10:45:11 +00:00
int i;
alloc/test: Check for TFI conflicts This commit adds the check_tfi_usage function that checks the TFI usage. It iterates through all TBFs, records on which PDCH it uses which TFI and check for conflicts. It also checks the bits returned by pdch->assigned_tfi(). The latter suffers from an bug in that method (no separation of uplink and downlink), so a conditional fprintf is used instead of an assertion. The method tfi_find_free is checked for conflicts after allocations. Sponsored-by: On-Waves ehf
2015-07-09 09:35:50 +00:00
uint8_t used_trx, tmp_trx;
Allow multiple bts objects in PCU This patch doesn't really tests whether osmo-pcu can work on a multi-bts environment, but it prepares the data structures to be able to do so at any later point in time. Change-Id: I6b10913f46c19d438c4e250a436a7446694b725a
2021-01-18 16:14:14 +00:00
struct gprs_rlcmac_bts *bts = bts_alloc(the_pcu, 0);
Expect ms object to exist before calling tbf_alloc_dl_tbf() Same as previous commit, this time for the DL counterpart. Change-Id: I87f6cdf8288a688466020bda0874e68b57aa71c4
2020-05-08 16:15:59 +00:00
GprsMs *ms;
alloc: Allocate TFI per slot (algorithm A) Currently the TFI are managed per TRX, thus only a maximum of 32 TBF per direction and per TRX are possible simultaneously. This commit modifies algorithm_a() to allow the sharing of TFI between different PDCH. Since algorithm A only assigns a single slot to each TBF, the TFI of each PDCH can be assigned independently. This increases the maximum to 32 TBF per direction and per PDCH concerning the TFI allocation. Ticket: #1793 Sponsored-by: On-Waves ehf
2015-07-10 10:25:25 +00:00
struct gprs_rlcmac_tbf *tbfs[32*8+1] = { 0, };
alloc: Add very basic test case for the alloc_a algorithm
2013-10-16 15:29:31 +00:00
printf("Testing alloc_a direction(%d)\n", dir);
Split PCU global PCU object from BTS object Currently the BTS object (and gprs_rlcmac_bts struct) are used to hold both PCU global fields and BTS specific fields, all mangled together. The BTS is even accessed in lots of places by means of a singleton. This patch introduces a new struct gprs_pcu object aimed at holding all global state, and several fields are already moved from BTS to it. The new object can be accessed as global variable "the_pcu", reusing and including an already exisitng "the_pcu" global variable only used for bssgp related purposes so far. This is only a first step towards having a complete split global pcu and BTS, some fields are still kept in BTS and will be moved over follow-up smaller patches in the future (since this patch is already quite big). So far, the code still only supports one BTS, which can be accessed using the_pcu->bts. In the future that field will be replaced with a list, and the BTS singletons will be removed. The cur_fn output changes in TbfTest are actually a side effect fix, since the singleton main_bts() now points internally to the_pcu->bts, hence the same we allocate and assign in the test. Beforehand, "the_bts" was allocated in the stack while main_bts() still returned an unrelated singleton BTS object instance. Related: OS#4935 Change-Id: I88e3c6471b80245ce3798223f1a61190f14aa840
2021-01-13 17:54:38 +00:00
the_pcu->alloc_algorithm = alloc_algorithm_a;
alloc: Add very basic test case for the alloc_a algorithm
2013-10-16 15:29:31 +00:00
bts/tbf: Move the lists into the BTS and do the look-up from the BTS The list belongs to the BTS. This makes cleaning this up more easy and establishes a hierachy of resources that start from the BTS. The debug_diagram code is now broken.
2013-10-19 19:10:38 +00:00
struct gprs_rlcmac_trx *trx = &bts->trx[0];
alloc/test: Enhance test_alloc_a This commit adds: - an assertion to check that count is valid, - an assertion the verify that tbf_alloc did not fail - a slots parameter to specify the enabled slots - additional test invocations with more slots enabled Sponsored-by: On-Waves ehf
2015-06-29 10:45:11 +00:00
for (i = 0; i < 8; i += 1)
if (slots & (1 << i))
trx->pdch[i].enable();
OSMO_ASSERT(count >= 0 && count <= (int)ARRAY_SIZE(tbfs));
alloc: Add very basic test case for the alloc_a algorithm
2013-10-16 15:29:31 +00:00
/**
* Currently alloc_a will only allocate from the first
* PDCH and all possible usf's. We run out of usf's before
* we are out of tfi's. Observe this and make sure that at
* least this part is working okay.
*/
alloc: Allocate TFI per slot (algorithm A) Currently the TFI are managed per TRX, thus only a maximum of 32 TBF per direction and per TRX are possible simultaneously. This commit modifies algorithm_a() to allow the sharing of TFI between different PDCH. Since algorithm A only assigns a single slot to each TBF, the TFI of each PDCH can be assigned independently. This increases the maximum to 32 TBF per direction and per PDCH concerning the TFI allocation. Ticket: #1793 Sponsored-by: On-Waves ehf
2015-07-10 10:25:25 +00:00
for (i = 0; i < (int)ARRAY_SIZE(tbfs); ++i) {
Unify BTS into a C usable structure Previous work on BTS class started to get stuff out of the C++ struct into a C struct (BTS -> struct gprs_glcmac_bts) so that some parts of it were accessible from C code. Doing so, however, ended up being messy too, since all code needs to be switching from one object to another, which actually refer to the same logical component. Let's instead rejoin the structures and make sure the struct is accessible and usable from both C and C++ code by rewriting all methods to be C compatible and converting 3 allocated suboject as pointers. This way BTS can internally still use those C++ objects while providing a clean APi to both C and C++ code. Change-Id: I7d12c896c5ded659ca9d3bff4cf3a3fc857db9dd
2021-01-14 15:48:38 +00:00
ms = bts_alloc_ms(bts, 0, 0);
Expect ms object to exist before calling tbf_alloc_dl_tbf() Same as previous commit, this time for the DL counterpart. Change-Id: I87f6cdf8288a688466020bda0874e68b57aa71c4
2020-05-08 16:15:59 +00:00
tbfs[i] = tbf_alloc(bts, ms, dir, -1, 0);
alloc: Allocate TFI per slot (algorithm A) Currently the TFI are managed per TRX, thus only a maximum of 32 TBF per direction and per TRX are possible simultaneously. This commit modifies algorithm_a() to allow the sharing of TFI between different PDCH. Since algorithm A only assigns a single slot to each TBF, the TFI of each PDCH can be assigned independently. This increases the maximum to 32 TBF per direction and per PDCH concerning the TFI allocation. Ticket: #1793 Sponsored-by: On-Waves ehf
2015-07-10 10:25:25 +00:00
if (tbfs[i] == NULL)
break;
used_trx = tbfs[i]->trx->trx_no;
Unify BTS into a C usable structure Previous work on BTS class started to get stuff out of the C++ struct into a C struct (BTS -> struct gprs_glcmac_bts) so that some parts of it were accessible from C code. Doing so, however, ended up being messy too, since all code needs to be switching from one object to another, which actually refer to the same logical component. Let's instead rejoin the structures and make sure the struct is accessible and usable from both C and C++ code by rewriting all methods to be C compatible and converting 3 allocated suboject as pointers. This way BTS can internally still use those C++ objects while providing a clean APi to both C and C++ code. Change-Id: I7d12c896c5ded659ca9d3bff4cf3a3fc857db9dd
2021-01-14 15:48:38 +00:00
tfi = bts_tfi_find_free(bts, dir, &tmp_trx, used_trx);
alloc/test: Check for TFI conflicts This commit adds the check_tfi_usage function that checks the TFI usage. It iterates through all TBFs, records on which PDCH it uses which TFI and check for conflicts. It also checks the bits returned by pdch->assigned_tfi(). The latter suffers from an bug in that method (no separation of uplink and downlink), so a conditional fprintf is used instead of an assertion. The method tfi_find_free is checked for conflicts after allocations. Sponsored-by: On-Waves ehf
2015-07-09 09:35:50 +00:00
OSMO_ASSERT(tbfs[i]->tfi() != tfi);
alloc: Add very basic test case for the alloc_a algorithm
2013-10-16 15:29:31 +00:00
}
Unify BTS into a C usable structure Previous work on BTS class started to get stuff out of the C++ struct into a C struct (BTS -> struct gprs_glcmac_bts) so that some parts of it were accessible from C code. Doing so, however, ended up being messy too, since all code needs to be switching from one object to another, which actually refer to the same logical component. Let's instead rejoin the structures and make sure the struct is accessible and usable from both C and C++ code by rewriting all methods to be C compatible and converting 3 allocated suboject as pointers. This way BTS can internally still use those C++ objects while providing a clean APi to both C and C++ code. Change-Id: I7d12c896c5ded659ca9d3bff4cf3a3fc857db9dd
2021-01-14 15:48:38 +00:00
check_tfi_usage(bts);
alloc: Allocate TFI per slot (algorithm A) Currently the TFI are managed per TRX, thus only a maximum of 32 TBF per direction and per TRX are possible simultaneously. This commit modifies algorithm_a() to allow the sharing of TFI between different PDCH. Since algorithm A only assigns a single slot to each TBF, the TFI of each PDCH can be assigned independently. This increases the maximum to 32 TBF per direction and per PDCH concerning the TFI allocation. Ticket: #1793 Sponsored-by: On-Waves ehf
2015-07-10 10:25:25 +00:00
OSMO_ASSERT(i == count);
alloc: Add very basic test case for the alloc_a algorithm
2013-10-16 15:29:31 +00:00
bts: Add counter availablePDCHAllocatedTime We basically want to probe whether it's possible to allocate TBFs, or whether we know it will fail due to all main resources being already in use (TFI, USF). Having bts_all_pdch_allocated() return false doesn't mean though that an MS will be able to allocate a TBF for sure. That's because further restrictions are applied based on MS: whether it was already attached to a specific TRX, whether the ms_class allows for a certain multislot combination, etc. However, it should provide a general idea on whether for sure the PCU is unable to provide more allocations. More fine grained state about failures can still be followed by looking at tbf:alloc:failed:* rate counters. Related: SYS#4878 Depends: Iabb17a08e6e1a86f168cdb008fba05ecd4776bdd (libosmocore) Change-Id: Ie0f0c451558817bddc3fe1a0f0df531f14c9f1d3
2021-11-10 18:09:10 +00:00
OSMO_ASSERT(bts_all_pdch_allocated(bts));
alloc: Allocate TFI per slot (algorithm A) Currently the TFI are managed per TRX, thus only a maximum of 32 TBF per direction and per TRX are possible simultaneously. This commit modifies algorithm_a() to allow the sharing of TFI between different PDCH. Since algorithm A only assigns a single slot to each TBF, the TFI of each PDCH can be assigned independently. This increases the maximum to 32 TBF per direction and per PDCH concerning the TFI allocation. Ticket: #1793 Sponsored-by: On-Waves ehf
2015-07-10 10:25:25 +00:00
for (i = 0; i < count; ++i)
alloc: Add very basic test case for the alloc_a algorithm
2013-10-16 15:29:31 +00:00
if (tbfs[i])
tbf_free(tbfs[i]);
Unify BTS into a C usable structure Previous work on BTS class started to get stuff out of the C++ struct into a C struct (BTS -> struct gprs_glcmac_bts) so that some parts of it were accessible from C code. Doing so, however, ended up being messy too, since all code needs to be switching from one object to another, which actually refer to the same logical component. Let's instead rejoin the structures and make sure the struct is accessible and usable from both C and C++ code by rewriting all methods to be C compatible and converting 3 allocated suboject as pointers. This way BTS can internally still use those C++ objects while providing a clean APi to both C and C++ code. Change-Id: I7d12c896c5ded659ca9d3bff4cf3a3fc857db9dd
2021-01-14 15:48:38 +00:00
ms = bts_alloc_ms(bts, 0, 0);
Expect ms object to exist before calling tbf_alloc_dl_tbf() Same as previous commit, this time for the DL counterpart. Change-Id: I87f6cdf8288a688466020bda0874e68b57aa71c4
2020-05-08 16:15:59 +00:00
tbfs[0] = tbf_alloc(bts, ms, dir, -1, 0);
alloc: Fix UBSAN for accessing the array at -16 This test will check that we exhaust the available TFIs, so the last TFI is -16 and then we try to store to that address. It is surprising that it worked!
2016-02-22 14:14:01 +00:00
OSMO_ASSERT(tbfs[0]);
tbf_free(tbfs[0]);
Unify BTS into a C usable structure Previous work on BTS class started to get stuff out of the C++ struct into a C struct (BTS -> struct gprs_glcmac_bts) so that some parts of it were accessible from C code. Doing so, however, ended up being messy too, since all code needs to be switching from one object to another, which actually refer to the same logical component. Let's instead rejoin the structures and make sure the struct is accessible and usable from both C and C++ code by rewriting all methods to be C compatible and converting 3 allocated suboject as pointers. This way BTS can internally still use those C++ objects while providing a clean APi to both C and C++ code. Change-Id: I7d12c896c5ded659ca9d3bff4cf3a3fc857db9dd
2021-01-14 15:48:38 +00:00
talloc_free(bts);
alloc: Add very basic test case for the alloc_a algorithm
2013-10-16 15:29:31 +00:00
}
static void test_alloc_a()
{
alloc/test: Enhance test_alloc_a This commit adds: - an assertion to check that count is valid, - an assertion the verify that tbf_alloc did not fail - a slots parameter to specify the enabled slots - additional test invocations with more slots enabled Sponsored-by: On-Waves ehf
2015-06-29 10:45:11 +00:00
/* slots 2 - 3 */
alloc: Allocate TFI per slot (algorithm A) Currently the TFI are managed per TRX, thus only a maximum of 32 TBF per direction and per TRX are possible simultaneously. This commit modifies algorithm_a() to allow the sharing of TFI between different PDCH. Since algorithm A only assigns a single slot to each TBF, the TFI of each PDCH can be assigned independently. This increases the maximum to 32 TBF per direction and per PDCH concerning the TFI allocation. Ticket: #1793 Sponsored-by: On-Waves ehf
2015-07-10 10:25:25 +00:00
test_alloc_a(GPRS_RLCMAC_DL_TBF, 0x0c, 32*2);
alloc: Load balancing for algo A Currently only the first enabled PDCH will be used. Beside the throughput this will also limit the number of TBFs: - number of UL TBFs <= 7 - number of DL TBFs <= 32 This commit changes the allocation algorithm to use the PDCH with the least number of attached TBFs. This will improve the troughput in both directions and the UL limits: - number of UL TBFs <= min(32, N_PDCH * 7) UL TBFs Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 14:35:38 +00:00
test_alloc_a(GPRS_RLCMAC_UL_TBF, 0x0c, 14);
alloc/test: Enhance test_alloc_a This commit adds: - an assertion to check that count is valid, - an assertion the verify that tbf_alloc did not fail - a slots parameter to specify the enabled slots - additional test invocations with more slots enabled Sponsored-by: On-Waves ehf
2015-06-29 10:45:11 +00:00
/* slots 1 - 5 */
alloc: Allocate TFI per slot (algorithm A) Currently the TFI are managed per TRX, thus only a maximum of 32 TBF per direction and per TRX are possible simultaneously. This commit modifies algorithm_a() to allow the sharing of TFI between different PDCH. Since algorithm A only assigns a single slot to each TBF, the TFI of each PDCH can be assigned independently. This increases the maximum to 32 TBF per direction and per PDCH concerning the TFI allocation. Ticket: #1793 Sponsored-by: On-Waves ehf
2015-07-10 10:25:25 +00:00
test_alloc_a(GPRS_RLCMAC_DL_TBF, 0x1e, 32*4);
alloc: Load balancing for algo A Currently only the first enabled PDCH will be used. Beside the throughput this will also limit the number of TBFs: - number of UL TBFs <= 7 - number of DL TBFs <= 32 This commit changes the allocation algorithm to use the PDCH with the least number of attached TBFs. This will improve the troughput in both directions and the UL limits: - number of UL TBFs <= min(32, N_PDCH * 7) UL TBFs Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 14:35:38 +00:00
test_alloc_a(GPRS_RLCMAC_UL_TBF, 0x1e, 28);
alloc: Add very basic test case for the alloc_a algorithm
2013-10-16 15:29:31 +00:00
}
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
static void dump_assignment(struct gprs_rlcmac_tbf *tbf, const char *dir, bool verbose)
alloc/tests: Create an allocation test for various scenarious The allocation in the TBF/BTS code is quite complex. In parts this is due the assignment and requests occuring under differen circumstances. Attempt to re-create the commono scenarios. Remove the bogus msclass check in gprs_rlcmac_tbf::update as the allocation code will check the ms class anyway.
2013-12-25 18:16:55 +00:00
{
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
if (!verbose)
return;
pcu: Fix non-critical warnings These fixes do not affect the semantics of the code. They either help gcc by providing default values that won't be used ("may be uninitialised"), remove unused variables, or change signed to unsigned variables to avoid comparison warnings. Addresses: bts.cpp:494:32: warning: 'tbf' may be used uninitialized in this function emu/test_replay_gprs_attach.cpp:81:27: warning: comparison between signed and unsigned integer expressions emu/test_pdp_activation.cpp:95:23: warning: unused variable ‘budh’ emu/test_pdp_activation.cpp:97:6: warning: variable ‘rc’ set but not used emu/pcu_emu.cpp:109:26: warning: unused variable ‘bts’ alloc/AllocTest.cpp:74:27: warning: unused variable ‘tbf’ osmocom/core/utils.h:13:50: warning: comparison between signed and unsigned integer expressions types/TypesTest.cpp:319:7: warning: unused variable ‘count’ types/TypesTest.cpp:320:11: warning: unused variable ‘rbb’ alloc/AllocTest.cpp:74:27: warning: unused variable ‘tbf’ alloc/AllocTest.cpp:132:11: warning: unused variable ‘ts_no’
2015-05-04 06:21:17 +00:00
for (size_t i = 0; i < ARRAY_SIZE(tbf->pdch); ++i)
alloc/tests: Create an allocation test for various scenarious The allocation in the TBF/BTS code is quite complex. In parts this is due the assignment and requests occuring under differen circumstances. Attempt to re-create the commono scenarios. Remove the bogus msclass check in gprs_rlcmac_tbf::update as the allocation code will check the ms class anyway.
2013-12-25 18:16:55 +00:00
if (tbf->pdch[i])
Fix dozens of compiler warnings across the board Change-Id: I166109dc05d3323b92cd2a42f0c7e6009950e15d
2017-02-08 16:07:40 +00:00
printf("PDCH[%zu] is used for %s\n", i, dir);
alloc/tests: Create an allocation test for various scenarious The allocation in the TBF/BTS code is quite complex. In parts this is due the assignment and requests occuring under differen circumstances. Attempt to re-create the commono scenarios. Remove the bogus msclass check in gprs_rlcmac_tbf::update as the allocation code will check the ms class anyway.
2013-12-25 18:16:55 +00:00
printf("PDCH[%d] is control_ts for %s\n", tbf->control_ts, dir);
printf("PDCH[%d] is first common for %s\n", tbf->first_common_ts, dir);
}
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
#define ENABLE_PDCH(ts_no, enable_flag, trx) \
if (enable_flag) \
trx->pdch[ts_no].enable();
static inline void enable_ts_on_bts(struct gprs_rlcmac_bts *bts,
bool ts0, bool ts1, bool ts2, bool ts3, bool ts4, bool ts5, bool ts6, bool ts7)
alloc/tests: Create an allocation test for various scenarious The allocation in the TBF/BTS code is quite complex. In parts this is due the assignment and requests occuring under differen circumstances. Attempt to re-create the commono scenarios. Remove the bogus msclass check in gprs_rlcmac_tbf::update as the allocation code will check the ms class anyway.
2013-12-25 18:16:55 +00:00
{
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
struct gprs_rlcmac_trx *trx = &bts->trx[0];
alloc/tests: Create an allocation test for various scenarious The allocation in the TBF/BTS code is quite complex. In parts this is due the assignment and requests occuring under differen circumstances. Attempt to re-create the commono scenarios. Remove the bogus msclass check in gprs_rlcmac_tbf::update as the allocation code will check the ms class anyway.
2013-12-25 18:16:55 +00:00
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
ENABLE_PDCH(0, ts0, trx);
ENABLE_PDCH(1, ts1, trx);
ENABLE_PDCH(2, ts2, trx);
ENABLE_PDCH(3, ts3, trx);
ENABLE_PDCH(4, ts4, trx);
ENABLE_PDCH(5, ts5, trx);
ENABLE_PDCH(6, ts6, trx);
ENABLE_PDCH(7, ts7, trx);
}
alloc/tests: Create an allocation test for various scenarious The allocation in the TBF/BTS code is quite complex. In parts this is due the assignment and requests occuring under differen circumstances. Attempt to re-create the commono scenarios. Remove the bogus msclass check in gprs_rlcmac_tbf::update as the allocation code will check the ms class anyway.
2013-12-25 18:16:55 +00:00
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
static inline bool test_alloc_b_ul_dl(bool ts0, bool ts1, bool ts2, bool ts3, bool ts4, bool ts5, bool ts6, bool ts7,
uint8_t ms_class, bool verbose)
{
Allow multiple bts objects in PCU This patch doesn't really tests whether osmo-pcu can work on a multi-bts environment, but it prepares the data structures to be able to do so at any later point in time. Change-Id: I6b10913f46c19d438c4e250a436a7446694b725a
2021-01-18 16:14:14 +00:00
struct gprs_rlcmac_bts *bts = bts_alloc(the_pcu, 0);
Expect ms object to exist before calling tbf_alloc_ul_tbf() It's really non-sense from architectural point of view to pass an optional pointer to the MS holding the TBF and creating it otherwise. TBFs shouldn't be creating MS they belong too. This simple change requiring so many code line changes really exhibits how badly entangled the object relationship is. Another commit will follow doing the same for dl tbf. Change-Id: I010aa5877902816ae246e09ad5ad87946f96855c
2020-05-08 15:44:33 +00:00
GprsMs *ms;
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
gprs_rlcmac_ul_tbf *ul_tbf;
gprs_rlcmac_dl_tbf *dl_tbf;
if (verbose)
alloc/tests: Create an allocation test for various scenarious The allocation in the TBF/BTS code is quite complex. In parts this is due the assignment and requests occuring under differen circumstances. Attempt to re-create the commono scenarios. Remove the bogus msclass check in gprs_rlcmac_tbf::update as the allocation code will check the ms class anyway.
2013-12-25 18:16:55 +00:00
printf("Testing UL then DL assignment.\n");
Split PCU global PCU object from BTS object Currently the BTS object (and gprs_rlcmac_bts struct) are used to hold both PCU global fields and BTS specific fields, all mangled together. The BTS is even accessed in lots of places by means of a singleton. This patch introduces a new struct gprs_pcu object aimed at holding all global state, and several fields are already moved from BTS to it. The new object can be accessed as global variable "the_pcu", reusing and including an already exisitng "the_pcu" global variable only used for bssgp related purposes so far. This is only a first step towards having a complete split global pcu and BTS, some fields are still kept in BTS and will be moved over follow-up smaller patches in the future (since this patch is already quite big). So far, the code still only supports one BTS, which can be accessed using the_pcu->bts. In the future that field will be replaced with a list, and the BTS singletons will be removed. The cur_fn output changes in TbfTest are actually a side effect fix, since the singleton main_bts() now points internally to the_pcu->bts, hence the same we allocate and assign in the test. Beforehand, "the_bts" was allocated in the stack while main_bts() still returned an unrelated singleton BTS object instance. Related: OS#4935 Change-Id: I88e3c6471b80245ce3798223f1a61190f14aa840
2021-01-13 17:54:38 +00:00
the_pcu->alloc_algorithm = alloc_algorithm_b;
alloc/tests: Create an allocation test for various scenarious The allocation in the TBF/BTS code is quite complex. In parts this is due the assignment and requests occuring under differen circumstances. Attempt to re-create the commono scenarios. Remove the bogus msclass check in gprs_rlcmac_tbf::update as the allocation code will check the ms class anyway.
2013-12-25 18:16:55 +00:00
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
enable_ts_on_bts(bts, ts0, ts1, ts2, ts3, ts4, ts5, ts6, ts7);
alloc/tests: Create an allocation test for various scenarious The allocation in the TBF/BTS code is quite complex. In parts this is due the assignment and requests occuring under differen circumstances. Attempt to re-create the commono scenarios. Remove the bogus msclass check in gprs_rlcmac_tbf::update as the allocation code will check the ms class anyway.
2013-12-25 18:16:55 +00:00
Unify BTS into a C usable structure Previous work on BTS class started to get stuff out of the C++ struct into a C struct (BTS -> struct gprs_glcmac_bts) so that some parts of it were accessible from C code. Doing so, however, ended up being messy too, since all code needs to be switching from one object to another, which actually refer to the same logical component. Let's instead rejoin the structures and make sure the struct is accessible and usable from both C and C++ code by rewriting all methods to be C compatible and converting 3 allocated suboject as pointers. This way BTS can internally still use those C++ objects while providing a clean APi to both C and C++ code. Change-Id: I7d12c896c5ded659ca9d3bff4cf3a3fc857db9dd
2021-01-14 15:48:38 +00:00
ms = bts_alloc_ms(bts, ms_class, 0);
AllocTest: Avoid queuing tons of to-be-freed ms When both TBFs (Dl, Ul), are detached, ms_detach_tbf() will call ms_start_timer() which will hold a reference of the MS (ms_ref()) and wait for X seconds (VTY config, T=-2030, 60 seconds by default) before unrefing the MS, which will trigger ms_update_status() finally (ref==0) and will in turn call cb.ms_idle(), which will tell the ms_storage to free the MS. This mechanism is used to keep MS objects around for a certain time so that when new TBFs are established, we have cached interesting information about the MS, ready to use. However, in AllocTest, tons of MS are allocated in a loop calling a function (such as test_alloc_b_ul_dl()). In that function, a BTS is allocated in the stack and at the end of the function BTS::cleanup() is called due to implicit destructor, which ends up calling ms_storage::cleanup() which removes all MS from its list and frees them *if they are not idle*. The problem here, is that due to T=-2030, an extra reference is hold and hence the ms is not considered idle (ms_is_idle() checks ms->ref==0). As a result, the MS is never freed, because we don't use libosmocore mainloop here (and in any case, it would take 60 seconds to free it). By setting the timeout of T=-2030 to 0, ms_start_timer will avoid using the timer and will also avoid holding the extra reference, hence allowing ms_storage to free the object during cleanup(). This fix really helps in improving performance for AllocTest specially after MS object contains a rate_ctr. As tons of MS objects were left alive, they stood in the rate_ctr single per-process queue, making the test last crazy amount of time and spending 50% of the time or more iterating the list full of MS related rate counters. Change-Id: I6b6ebe8903e4fe76da5e09b02b6ef28542007b6c
2021-01-11 19:40:19 +00:00
/* Avoid delaying free to avoid tons of to-be-freed ms objects queuing */
ms_set_timeout(ms, 0);
Expect ms object to exist before calling tbf_alloc_ul_tbf() It's really non-sense from architectural point of view to pass an optional pointer to the MS holding the TBF and creating it otherwise. TBFs shouldn't be creating MS they belong too. This simple change requiring so many code line changes really exhibits how badly entangled the object relationship is. Another commit will follow doing the same for dl tbf. Change-Id: I010aa5877902816ae246e09ad5ad87946f96855c
2020-05-08 15:44:33 +00:00
ul_tbf = tbf_alloc_ul_tbf(bts, ms, -1, true);
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
if (!ul_tbf)
return false;
alloc/tests: Create an allocation test for various scenarious The allocation in the TBF/BTS code is quite complex. In parts this is due the assignment and requests occuring under differen circumstances. Attempt to re-create the commono scenarios. Remove the bogus msclass check in gprs_rlcmac_tbf::update as the allocation code will check the ms class anyway.
2013-12-25 18:16:55 +00:00
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
OSMO_ASSERT(ul_tbf->ms());
Convert GprsMS and helpers classes to C As we integrate osmo-pcu more and more with libosmocore features, it becomes really hard to use them since libosmocore relies heavily on C specific compilation features, which are not available in old C++ compilers (such as designated initializers for complex types in FSMs). GprsMs is right now a quite simple object since initial design of osmo-pcu made it optional and most of the logic was placed and stored duplicated in TBF objects. However, that's changing as we introduce more features, with the GprsMS class getting more weight. Hence, let's move it now to be a C struct in order to be able to easily use libosmocore features there, such as FSMs. Some helper classes which GprsMs uses are also mostly move to C since they are mostly structs with methods, so there's no point in having duplicated APIs for C++ and C for such simple cases. For some more complex classes, like (ul_,dl_)tbf, C API bindings are added where needed so that GprsMs can use functionalitites from that class. Most of those APIs can be kept afterwards and drop the C++ ones since they provide no benefit in general. Change-Id: I0b50e3367aaad9dcada76da97b438e452c8b230c
2020-12-16 14:59:45 +00:00
OSMO_ASSERT(ms_current_trx(ul_tbf->ms()));
alloc/tests: Create an allocation test for various scenarious The allocation in the TBF/BTS code is quite complex. In parts this is due the assignment and requests occuring under differen circumstances. Attempt to re-create the commono scenarios. Remove the bogus msclass check in gprs_rlcmac_tbf::update as the allocation code will check the ms class anyway.
2013-12-25 18:16:55 +00:00
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
dump_assignment(ul_tbf, "UL", verbose);
alloc/test: Go through all possible ms_classes for the allocation Generate results for all possible classes.
2013-12-25 18:25:10 +00:00
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
/* assume final ack has not been sent */
Convert GprsMS and helpers classes to C As we integrate osmo-pcu more and more with libosmocore features, it becomes really hard to use them since libosmocore relies heavily on C specific compilation features, which are not available in old C++ compilers (such as designated initializers for complex types in FSMs). GprsMs is right now a quite simple object since initial design of osmo-pcu made it optional and most of the logic was placed and stored duplicated in TBF objects. However, that's changing as we introduce more features, with the GprsMS class getting more weight. Hence, let's move it now to be a C struct in order to be able to easily use libosmocore features there, such as FSMs. Some helper classes which GprsMs uses are also mostly move to C since they are mostly structs with methods, so there's no point in having duplicated APIs for C++ and C for such simple cases. For some more complex classes, like (ul_,dl_)tbf, C API bindings are added where needed so that GprsMs can use functionalitites from that class. Most of those APIs can be kept afterwards and drop the C++ ones since they provide no benefit in general. Change-Id: I0b50e3367aaad9dcada76da97b438e452c8b230c
2020-12-16 14:59:45 +00:00
dl_tbf = tbf_alloc_dl_tbf(bts, ms, ms_current_trx(ms)->trx_no, false);
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
if (!dl_tbf)
return false;
alloc/test: Check for TFI conflicts This commit adds the check_tfi_usage function that checks the TFI usage. It iterates through all TBFs, records on which PDCH it uses which TFI and check for conflicts. It also checks the bits returned by pdch->assigned_tfi(). The latter suffers from an bug in that method (no separation of uplink and downlink), so a conditional fprintf is used instead of an assertion. The method tfi_find_free is checked for conflicts after allocations. Sponsored-by: On-Waves ehf
2015-07-09 09:35:50 +00:00
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
dump_assignment(dl_tbf, "DL", verbose);
alloc/tests: Create an allocation test for various scenarious The allocation in the TBF/BTS code is quite complex. In parts this is due the assignment and requests occuring under differen circumstances. Attempt to re-create the commono scenarios. Remove the bogus msclass check in gprs_rlcmac_tbf::update as the allocation code will check the ms class anyway.
2013-12-25 18:16:55 +00:00
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
OSMO_ASSERT(dl_tbf->first_common_ts == ul_tbf->first_common_ts);
Unify BTS into a C usable structure Previous work on BTS class started to get stuff out of the C++ struct into a C struct (BTS -> struct gprs_glcmac_bts) so that some parts of it were accessible from C code. Doing so, however, ended up being messy too, since all code needs to be switching from one object to another, which actually refer to the same logical component. Let's instead rejoin the structures and make sure the struct is accessible and usable from both C and C++ code by rewriting all methods to be C compatible and converting 3 allocated suboject as pointers. This way BTS can internally still use those C++ objects while providing a clean APi to both C and C++ code. Change-Id: I7d12c896c5ded659ca9d3bff4cf3a3fc857db9dd
2021-01-14 15:48:38 +00:00
check_tfi_usage(bts);
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
tbf_free(dl_tbf);
tbf_free(ul_tbf);
Unify BTS into a C usable structure Previous work on BTS class started to get stuff out of the C++ struct into a C struct (BTS -> struct gprs_glcmac_bts) so that some parts of it were accessible from C code. Doing so, however, ended up being messy too, since all code needs to be switching from one object to another, which actually refer to the same logical component. Let's instead rejoin the structures and make sure the struct is accessible and usable from both C and C++ code by rewriting all methods to be C compatible and converting 3 allocated suboject as pointers. This way BTS can internally still use those C++ objects while providing a clean APi to both C and C++ code. Change-Id: I7d12c896c5ded659ca9d3bff4cf3a3fc857db9dd
2021-01-14 15:48:38 +00:00
talloc_free(bts);
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
return true;
}
alloc/tests: Create an allocation test for various scenarious The allocation in the TBF/BTS code is quite complex. In parts this is due the assignment and requests occuring under differen circumstances. Attempt to re-create the commono scenarios. Remove the bogus msclass check in gprs_rlcmac_tbf::update as the allocation code will check the ms class anyway.
2013-12-25 18:16:55 +00:00
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
static inline bool test_alloc_b_dl_ul(bool ts0, bool ts1, bool ts2, bool ts3, bool ts4, bool ts5, bool ts6, bool ts7,
uint8_t ms_class, bool verbose)
{
Allow multiple bts objects in PCU This patch doesn't really tests whether osmo-pcu can work on a multi-bts environment, but it prepares the data structures to be able to do so at any later point in time. Change-Id: I6b10913f46c19d438c4e250a436a7446694b725a
2021-01-18 16:14:14 +00:00
struct gprs_rlcmac_bts *bts = bts_alloc(the_pcu, 0);
Expect ms object to exist before calling tbf_alloc_ul_tbf() It's really non-sense from architectural point of view to pass an optional pointer to the MS holding the TBF and creating it otherwise. TBFs shouldn't be creating MS they belong too. This simple change requiring so many code line changes really exhibits how badly entangled the object relationship is. Another commit will follow doing the same for dl tbf. Change-Id: I010aa5877902816ae246e09ad5ad87946f96855c
2020-05-08 15:44:33 +00:00
GprsMs *ms;
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
gprs_rlcmac_ul_tbf *ul_tbf;
gprs_rlcmac_dl_tbf *dl_tbf;
if (verbose)
alloc/tests: Create an allocation test for various scenarious The allocation in the TBF/BTS code is quite complex. In parts this is due the assignment and requests occuring under differen circumstances. Attempt to re-create the commono scenarios. Remove the bogus msclass check in gprs_rlcmac_tbf::update as the allocation code will check the ms class anyway.
2013-12-25 18:16:55 +00:00
printf("Testing DL then UL assignment followed by update\n");
Split PCU global PCU object from BTS object Currently the BTS object (and gprs_rlcmac_bts struct) are used to hold both PCU global fields and BTS specific fields, all mangled together. The BTS is even accessed in lots of places by means of a singleton. This patch introduces a new struct gprs_pcu object aimed at holding all global state, and several fields are already moved from BTS to it. The new object can be accessed as global variable "the_pcu", reusing and including an already exisitng "the_pcu" global variable only used for bssgp related purposes so far. This is only a first step towards having a complete split global pcu and BTS, some fields are still kept in BTS and will be moved over follow-up smaller patches in the future (since this patch is already quite big). So far, the code still only supports one BTS, which can be accessed using the_pcu->bts. In the future that field will be replaced with a list, and the BTS singletons will be removed. The cur_fn output changes in TbfTest are actually a side effect fix, since the singleton main_bts() now points internally to the_pcu->bts, hence the same we allocate and assign in the test. Beforehand, "the_bts" was allocated in the stack while main_bts() still returned an unrelated singleton BTS object instance. Related: OS#4935 Change-Id: I88e3c6471b80245ce3798223f1a61190f14aa840
2021-01-13 17:54:38 +00:00
the_pcu->alloc_algorithm = alloc_algorithm_b;
alloc/tests: Create an allocation test for various scenarious The allocation in the TBF/BTS code is quite complex. In parts this is due the assignment and requests occuring under differen circumstances. Attempt to re-create the commono scenarios. Remove the bogus msclass check in gprs_rlcmac_tbf::update as the allocation code will check the ms class anyway.
2013-12-25 18:16:55 +00:00
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
enable_ts_on_bts(bts, ts0, ts1, ts2, ts3, ts4, ts5, ts6, ts7);
alloc/tests: Create an allocation test for various scenarious The allocation in the TBF/BTS code is quite complex. In parts this is due the assignment and requests occuring under differen circumstances. Attempt to re-create the commono scenarios. Remove the bogus msclass check in gprs_rlcmac_tbf::update as the allocation code will check the ms class anyway.
2013-12-25 18:16:55 +00:00
Unify BTS into a C usable structure Previous work on BTS class started to get stuff out of the C++ struct into a C struct (BTS -> struct gprs_glcmac_bts) so that some parts of it were accessible from C code. Doing so, however, ended up being messy too, since all code needs to be switching from one object to another, which actually refer to the same logical component. Let's instead rejoin the structures and make sure the struct is accessible and usable from both C and C++ code by rewriting all methods to be C compatible and converting 3 allocated suboject as pointers. This way BTS can internally still use those C++ objects while providing a clean APi to both C and C++ code. Change-Id: I7d12c896c5ded659ca9d3bff4cf3a3fc857db9dd
2021-01-14 15:48:38 +00:00
ms = bts_alloc_ms(bts, ms_class, 0);
AllocTest: Avoid queuing tons of to-be-freed ms When both TBFs (Dl, Ul), are detached, ms_detach_tbf() will call ms_start_timer() which will hold a reference of the MS (ms_ref()) and wait for X seconds (VTY config, T=-2030, 60 seconds by default) before unrefing the MS, which will trigger ms_update_status() finally (ref==0) and will in turn call cb.ms_idle(), which will tell the ms_storage to free the MS. This mechanism is used to keep MS objects around for a certain time so that when new TBFs are established, we have cached interesting information about the MS, ready to use. However, in AllocTest, tons of MS are allocated in a loop calling a function (such as test_alloc_b_ul_dl()). In that function, a BTS is allocated in the stack and at the end of the function BTS::cleanup() is called due to implicit destructor, which ends up calling ms_storage::cleanup() which removes all MS from its list and frees them *if they are not idle*. The problem here, is that due to T=-2030, an extra reference is hold and hence the ms is not considered idle (ms_is_idle() checks ms->ref==0). As a result, the MS is never freed, because we don't use libosmocore mainloop here (and in any case, it would take 60 seconds to free it). By setting the timeout of T=-2030 to 0, ms_start_timer will avoid using the timer and will also avoid holding the extra reference, hence allowing ms_storage to free the object during cleanup(). This fix really helps in improving performance for AllocTest specially after MS object contains a rate_ctr. As tons of MS objects were left alive, they stood in the rate_ctr single per-process queue, making the test last crazy amount of time and spending 50% of the time or more iterating the list full of MS related rate counters. Change-Id: I6b6ebe8903e4fe76da5e09b02b6ef28542007b6c
2021-01-11 19:40:19 +00:00
/* Avoid delaying free to avoid tons of to-be-freed ms objects queuing */
ms_set_timeout(ms, 0);
Expect ms object to exist before calling tbf_alloc_dl_tbf() Same as previous commit, this time for the DL counterpart. Change-Id: I87f6cdf8288a688466020bda0874e68b57aa71c4
2020-05-08 16:15:59 +00:00
dl_tbf = tbf_alloc_dl_tbf(bts, ms, -1, true);
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
if (!dl_tbf)
return false;
alloc/tests: Create an allocation test for various scenarious The allocation in the TBF/BTS code is quite complex. In parts this is due the assignment and requests occuring under differen circumstances. Attempt to re-create the commono scenarios. Remove the bogus msclass check in gprs_rlcmac_tbf::update as the allocation code will check the ms class anyway.
2013-12-25 18:16:55 +00:00
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
dl_tbf->update_ms(0x23, GPRS_RLCMAC_DL_TBF);
Expect ms object to exist before calling tbf_alloc_dl_tbf() Same as previous commit, this time for the DL counterpart. Change-Id: I87f6cdf8288a688466020bda0874e68b57aa71c4
2020-05-08 16:15:59 +00:00
OSMO_ASSERT(dl_tbf->ms() == ms);
Convert GprsMS and helpers classes to C As we integrate osmo-pcu more and more with libosmocore features, it becomes really hard to use them since libosmocore relies heavily on C specific compilation features, which are not available in old C++ compilers (such as designated initializers for complex types in FSMs). GprsMs is right now a quite simple object since initial design of osmo-pcu made it optional and most of the logic was placed and stored duplicated in TBF objects. However, that's changing as we introduce more features, with the GprsMS class getting more weight. Hence, let's move it now to be a C struct in order to be able to easily use libosmocore features there, such as FSMs. Some helper classes which GprsMs uses are also mostly move to C since they are mostly structs with methods, so there's no point in having duplicated APIs for C++ and C for such simple cases. For some more complex classes, like (ul_,dl_)tbf, C API bindings are added where needed so that GprsMs can use functionalitites from that class. Most of those APIs can be kept afterwards and drop the C++ ones since they provide no benefit in general. Change-Id: I0b50e3367aaad9dcada76da97b438e452c8b230c
2020-12-16 14:59:45 +00:00
OSMO_ASSERT(ms_current_trx(dl_tbf->ms()));
alloc/test: Go through all possible ms_classes for the allocation Generate results for all possible classes.
2013-12-25 18:25:10 +00:00
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
dump_assignment(dl_tbf, "DL", verbose);
alloc/tests: Create an allocation test for various scenarious The allocation in the TBF/BTS code is quite complex. In parts this is due the assignment and requests occuring under differen circumstances. Attempt to re-create the commono scenarios. Remove the bogus msclass check in gprs_rlcmac_tbf::update as the allocation code will check the ms class anyway.
2013-12-25 18:16:55 +00:00
Convert GprsMS and helpers classes to C As we integrate osmo-pcu more and more with libosmocore features, it becomes really hard to use them since libosmocore relies heavily on C specific compilation features, which are not available in old C++ compilers (such as designated initializers for complex types in FSMs). GprsMs is right now a quite simple object since initial design of osmo-pcu made it optional and most of the logic was placed and stored duplicated in TBF objects. However, that's changing as we introduce more features, with the GprsMS class getting more weight. Hence, let's move it now to be a C struct in order to be able to easily use libosmocore features there, such as FSMs. Some helper classes which GprsMs uses are also mostly move to C since they are mostly structs with methods, so there's no point in having duplicated APIs for C++ and C for such simple cases. For some more complex classes, like (ul_,dl_)tbf, C API bindings are added where needed so that GprsMs can use functionalitites from that class. Most of those APIs can be kept afterwards and drop the C++ ones since they provide no benefit in general. Change-Id: I0b50e3367aaad9dcada76da97b438e452c8b230c
2020-12-16 14:59:45 +00:00
ul_tbf = tbf_alloc_ul_tbf(bts, ms, ms_current_trx(ms)->trx_no, false);
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
if (!ul_tbf)
return false;
alloc/test: Check for TFI conflicts This commit adds the check_tfi_usage function that checks the TFI usage. It iterates through all TBFs, records on which PDCH it uses which TFI and check for conflicts. It also checks the bits returned by pdch->assigned_tfi(). The latter suffers from an bug in that method (no separation of uplink and downlink), so a conditional fprintf is used instead of an assertion. The method tfi_find_free is checked for conflicts after allocations. Sponsored-by: On-Waves ehf
2015-07-09 09:35:50 +00:00
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
ul_tbf->update_ms(0x23, GPRS_RLCMAC_UL_TBF);
ul_tbf->m_contention_resolution_done = 1;
alloc/tests: Create an allocation test for various scenarious The allocation in the TBF/BTS code is quite complex. In parts this is due the assignment and requests occuring under differen circumstances. Attempt to re-create the commono scenarios. Remove the bogus msclass check in gprs_rlcmac_tbf::update as the allocation code will check the ms class anyway.
2013-12-25 18:16:55 +00:00
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
dump_assignment(ul_tbf, "UL", verbose);
alloc/tests: Create an allocation test for various scenarious The allocation in the TBF/BTS code is quite complex. In parts this is due the assignment and requests occuring under differen circumstances. Attempt to re-create the commono scenarios. Remove the bogus msclass check in gprs_rlcmac_tbf::update as the allocation code will check the ms class anyway.
2013-12-25 18:16:55 +00:00
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
OSMO_ASSERT(dl_tbf->first_common_ts == ul_tbf->first_common_ts);
alloc/tests: Create an allocation test for various scenarious The allocation in the TBF/BTS code is quite complex. In parts this is due the assignment and requests occuring under differen circumstances. Attempt to re-create the commono scenarios. Remove the bogus msclass check in gprs_rlcmac_tbf::update as the allocation code will check the ms class anyway.
2013-12-25 18:16:55 +00:00
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
/* now update the dl_tbf */
dl_tbf->update();
dump_assignment(dl_tbf, "DL", verbose);
OSMO_ASSERT(dl_tbf->first_common_ts == ul_tbf->first_common_ts);
alloc/tests: Create an allocation test for various scenarious The allocation in the TBF/BTS code is quite complex. In parts this is due the assignment and requests occuring under differen circumstances. Attempt to re-create the commono scenarios. Remove the bogus msclass check in gprs_rlcmac_tbf::update as the allocation code will check the ms class anyway.
2013-12-25 18:16:55 +00:00
Unify BTS into a C usable structure Previous work on BTS class started to get stuff out of the C++ struct into a C struct (BTS -> struct gprs_glcmac_bts) so that some parts of it were accessible from C code. Doing so, however, ended up being messy too, since all code needs to be switching from one object to another, which actually refer to the same logical component. Let's instead rejoin the structures and make sure the struct is accessible and usable from both C and C++ code by rewriting all methods to be C compatible and converting 3 allocated suboject as pointers. This way BTS can internally still use those C++ objects while providing a clean APi to both C and C++ code. Change-Id: I7d12c896c5ded659ca9d3bff4cf3a3fc857db9dd
2021-01-14 15:48:38 +00:00
check_tfi_usage(bts);
alloc/tests: Create an allocation test for various scenarious The allocation in the TBF/BTS code is quite complex. In parts this is due the assignment and requests occuring under differen circumstances. Attempt to re-create the commono scenarios. Remove the bogus msclass check in gprs_rlcmac_tbf::update as the allocation code will check the ms class anyway.
2013-12-25 18:16:55 +00:00
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
tbf_free(dl_tbf);
tbf_free(ul_tbf);
Unify BTS into a C usable structure Previous work on BTS class started to get stuff out of the C++ struct into a C struct (BTS -> struct gprs_glcmac_bts) so that some parts of it were accessible from C code. Doing so, however, ended up being messy too, since all code needs to be switching from one object to another, which actually refer to the same logical component. Let's instead rejoin the structures and make sure the struct is accessible and usable from both C and C++ code by rewriting all methods to be C compatible and converting 3 allocated suboject as pointers. This way BTS can internally still use those C++ objects while providing a clean APi to both C and C++ code. Change-Id: I7d12c896c5ded659ca9d3bff4cf3a3fc857db9dd
2021-01-14 15:48:38 +00:00
talloc_free(bts);
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
return true;
}
alloc/tests: Create an allocation test for various scenarious The allocation in the TBF/BTS code is quite complex. In parts this is due the assignment and requests occuring under differen circumstances. Attempt to re-create the commono scenarios. Remove the bogus msclass check in gprs_rlcmac_tbf::update as the allocation code will check the ms class anyway.
2013-12-25 18:16:55 +00:00
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
static inline bool test_alloc_b_jolly(uint8_t ms_class)
{
Allow multiple bts objects in PCU This patch doesn't really tests whether osmo-pcu can work on a multi-bts environment, but it prepares the data structures to be able to do so at any later point in time. Change-Id: I6b10913f46c19d438c4e250a436a7446694b725a
2021-01-18 16:14:14 +00:00
struct gprs_rlcmac_bts *bts = bts_alloc(the_pcu, 0);
Expect ms object to exist before calling tbf_alloc_ul_tbf() It's really non-sense from architectural point of view to pass an optional pointer to the MS holding the TBF and creating it otherwise. TBFs shouldn't be creating MS they belong too. This simple change requiring so many code line changes really exhibits how badly entangled the object relationship is. Another commit will follow doing the same for dl tbf. Change-Id: I010aa5877902816ae246e09ad5ad87946f96855c
2020-05-08 15:44:33 +00:00
GprsMs *ms;
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
int tfi;
uint8_t trx_no;
gprs_rlcmac_tbf *ul_tbf, *dl_tbf;
alloc/tests: Create an allocation test for various scenarious The allocation in the TBF/BTS code is quite complex. In parts this is due the assignment and requests occuring under differen circumstances. Attempt to re-create the commono scenarios. Remove the bogus msclass check in gprs_rlcmac_tbf::update as the allocation code will check the ms class anyway.
2013-12-25 18:16:55 +00:00
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
printf("Testing jolly example\n");
alloc/test: Go through all possible ms_classes for the allocation Generate results for all possible classes.
2013-12-25 18:25:10 +00:00
Split PCU global PCU object from BTS object Currently the BTS object (and gprs_rlcmac_bts struct) are used to hold both PCU global fields and BTS specific fields, all mangled together. The BTS is even accessed in lots of places by means of a singleton. This patch introduces a new struct gprs_pcu object aimed at holding all global state, and several fields are already moved from BTS to it. The new object can be accessed as global variable "the_pcu", reusing and including an already exisitng "the_pcu" global variable only used for bssgp related purposes so far. This is only a first step towards having a complete split global pcu and BTS, some fields are still kept in BTS and will be moved over follow-up smaller patches in the future (since this patch is already quite big). So far, the code still only supports one BTS, which can be accessed using the_pcu->bts. In the future that field will be replaced with a list, and the BTS singletons will be removed. The cur_fn output changes in TbfTest are actually a side effect fix, since the singleton main_bts() now points internally to the_pcu->bts, hence the same we allocate and assign in the test. Beforehand, "the_bts" was allocated in the stack while main_bts() still returned an unrelated singleton BTS object instance. Related: OS#4935 Change-Id: I88e3c6471b80245ce3798223f1a61190f14aa840
2021-01-13 17:54:38 +00:00
the_pcu->alloc_algorithm = alloc_algorithm_b;
alloc/test: Check for TFI conflicts This commit adds the check_tfi_usage function that checks the TFI usage. It iterates through all TBFs, records on which PDCH it uses which TFI and check for conflicts. It also checks the bits returned by pdch->assigned_tfi(). The latter suffers from an bug in that method (no separation of uplink and downlink), so a conditional fprintf is used instead of an assertion. The method tfi_find_free is checked for conflicts after allocations. Sponsored-by: On-Waves ehf
2015-07-09 09:35:50 +00:00
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
enable_ts_on_bts(bts, false, true, true, true, true, false, false, false);
Unify BTS into a C usable structure Previous work on BTS class started to get stuff out of the C++ struct into a C struct (BTS -> struct gprs_glcmac_bts) so that some parts of it were accessible from C code. Doing so, however, ended up being messy too, since all code needs to be switching from one object to another, which actually refer to the same logical component. Let's instead rejoin the structures and make sure the struct is accessible and usable from both C and C++ code by rewriting all methods to be C compatible and converting 3 allocated suboject as pointers. This way BTS can internally still use those C++ objects while providing a clean APi to both C and C++ code. Change-Id: I7d12c896c5ded659ca9d3bff4cf3a3fc857db9dd
2021-01-14 15:48:38 +00:00
tfi = bts_tfi_find_free(bts, GPRS_RLCMAC_UL_TBF, &trx_no, -1);
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
OSMO_ASSERT(tfi >= 0);
Unify BTS into a C usable structure Previous work on BTS class started to get stuff out of the C++ struct into a C struct (BTS -> struct gprs_glcmac_bts) so that some parts of it were accessible from C code. Doing so, however, ended up being messy too, since all code needs to be switching from one object to another, which actually refer to the same logical component. Let's instead rejoin the structures and make sure the struct is accessible and usable from both C and C++ code by rewriting all methods to be C compatible and converting 3 allocated suboject as pointers. This way BTS can internally still use those C++ objects while providing a clean APi to both C and C++ code. Change-Id: I7d12c896c5ded659ca9d3bff4cf3a3fc857db9dd
2021-01-14 15:48:38 +00:00
ms = bts_alloc_ms(bts, ms_class, 0);
AllocTest: Avoid queuing tons of to-be-freed ms When both TBFs (Dl, Ul), are detached, ms_detach_tbf() will call ms_start_timer() which will hold a reference of the MS (ms_ref()) and wait for X seconds (VTY config, T=-2030, 60 seconds by default) before unrefing the MS, which will trigger ms_update_status() finally (ref==0) and will in turn call cb.ms_idle(), which will tell the ms_storage to free the MS. This mechanism is used to keep MS objects around for a certain time so that when new TBFs are established, we have cached interesting information about the MS, ready to use. However, in AllocTest, tons of MS are allocated in a loop calling a function (such as test_alloc_b_ul_dl()). In that function, a BTS is allocated in the stack and at the end of the function BTS::cleanup() is called due to implicit destructor, which ends up calling ms_storage::cleanup() which removes all MS from its list and frees them *if they are not idle*. The problem here, is that due to T=-2030, an extra reference is hold and hence the ms is not considered idle (ms_is_idle() checks ms->ref==0). As a result, the MS is never freed, because we don't use libosmocore mainloop here (and in any case, it would take 60 seconds to free it). By setting the timeout of T=-2030 to 0, ms_start_timer will avoid using the timer and will also avoid holding the extra reference, hence allowing ms_storage to free the object during cleanup(). This fix really helps in improving performance for AllocTest specially after MS object contains a rate_ctr. As tons of MS objects were left alive, they stood in the rate_ctr single per-process queue, making the test last crazy amount of time and spending 50% of the time or more iterating the list full of MS related rate counters. Change-Id: I6b6ebe8903e4fe76da5e09b02b6ef28542007b6c
2021-01-11 19:40:19 +00:00
/* Avoid delaying free to avoid tons of to-be-freed ms objects queuing */
ms_set_timeout(ms, 0);
Expect ms object to exist before calling tbf_alloc_ul_tbf() It's really non-sense from architectural point of view to pass an optional pointer to the MS holding the TBF and creating it otherwise. TBFs shouldn't be creating MS they belong too. This simple change requiring so many code line changes really exhibits how badly entangled the object relationship is. Another commit will follow doing the same for dl tbf. Change-Id: I010aa5877902816ae246e09ad5ad87946f96855c
2020-05-08 15:44:33 +00:00
ul_tbf = tbf_alloc_ul_tbf(bts, ms, -1, false);
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
if (!ul_tbf)
return false;
Expect ms object to exist before calling tbf_alloc_dl_tbf() Same as previous commit, this time for the DL counterpart. Change-Id: I87f6cdf8288a688466020bda0874e68b57aa71c4
2020-05-08 16:15:59 +00:00
OSMO_ASSERT(ul_tbf->ms() == ms);
Convert GprsMS and helpers classes to C As we integrate osmo-pcu more and more with libosmocore features, it becomes really hard to use them since libosmocore relies heavily on C specific compilation features, which are not available in old C++ compilers (such as designated initializers for complex types in FSMs). GprsMs is right now a quite simple object since initial design of osmo-pcu made it optional and most of the logic was placed and stored duplicated in TBF objects. However, that's changing as we introduce more features, with the GprsMS class getting more weight. Hence, let's move it now to be a C struct in order to be able to easily use libosmocore features there, such as FSMs. Some helper classes which GprsMs uses are also mostly move to C since they are mostly structs with methods, so there's no point in having duplicated APIs for C++ and C for such simple cases. For some more complex classes, like (ul_,dl_)tbf, C API bindings are added where needed so that GprsMs can use functionalitites from that class. Most of those APIs can be kept afterwards and drop the C++ ones since they provide no benefit in general. Change-Id: I0b50e3367aaad9dcada76da97b438e452c8b230c
2020-12-16 14:59:45 +00:00
OSMO_ASSERT(ms_current_trx(ul_tbf->ms()));
trx_no = ms_current_trx(ms)->trx_no;
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
dump_assignment(ul_tbf, "UL", true);
/* assume final ack has not been sent */
Expect ms object to exist before calling tbf_alloc_dl_tbf() Same as previous commit, this time for the DL counterpart. Change-Id: I87f6cdf8288a688466020bda0874e68b57aa71c4
2020-05-08 16:15:59 +00:00
dl_tbf = tbf_alloc_dl_tbf(bts, ms, trx_no, false);
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
if (!dl_tbf)
return false;
dump_assignment(dl_tbf, "DL", true);
OSMO_ASSERT(dl_tbf->first_common_ts == ul_tbf->first_common_ts);
Unify BTS into a C usable structure Previous work on BTS class started to get stuff out of the C++ struct into a C struct (BTS -> struct gprs_glcmac_bts) so that some parts of it were accessible from C code. Doing so, however, ended up being messy too, since all code needs to be switching from one object to another, which actually refer to the same logical component. Let's instead rejoin the structures and make sure the struct is accessible and usable from both C and C++ code by rewriting all methods to be C compatible and converting 3 allocated suboject as pointers. This way BTS can internally still use those C++ objects while providing a clean APi to both C and C++ code. Change-Id: I7d12c896c5ded659ca9d3bff4cf3a3fc857db9dd
2021-01-14 15:48:38 +00:00
check_tfi_usage(bts);
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
tbf_free(dl_tbf);
tbf_free(ul_tbf);
Unify BTS into a C usable structure Previous work on BTS class started to get stuff out of the C++ struct into a C struct (BTS -> struct gprs_glcmac_bts) so that some parts of it were accessible from C code. Doing so, however, ended up being messy too, since all code needs to be switching from one object to another, which actually refer to the same logical component. Let's instead rejoin the structures and make sure the struct is accessible and usable from both C and C++ code by rewriting all methods to be C compatible and converting 3 allocated suboject as pointers. This way BTS can internally still use those C++ objects while providing a clean APi to both C and C++ code. Change-Id: I7d12c896c5ded659ca9d3bff4cf3a3fc857db9dd
2021-01-14 15:48:38 +00:00
talloc_free(bts);
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
return true;
alloc/tests: Create an allocation test for various scenarious The allocation in the TBF/BTS code is quite complex. In parts this is due the assignment and requests occuring under differen circumstances. Attempt to re-create the commono scenarios. Remove the bogus msclass check in gprs_rlcmac_tbf::update as the allocation code will check the ms class anyway.
2013-12-25 18:16:55 +00:00
}
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
static void test_alloc_b_for_ms(uint8_t ms_class)
{
bool rc;
printf("Going to test multislot assignment MS_CLASS=%d\n", ms_class);
/*
* PDCH is on TS 6,7,8 and we start with a UL allocation and
* then follow two DL allocations (once single, once normal).
*
* Uplink assigned and still available..
*/
rc = test_alloc_b_ul_dl(false, false, false, false, false, true, true, true, ms_class, true);
if (!rc)
return;
/**
* Test with the other order.. first DL and then UL
*/
rc = test_alloc_b_dl_ul(false, false, false, false, false, true, true, true, ms_class, true);
if (!rc)
return;
alloc/test: Add a crazy test that tests each possible combination Make a crazy test that will test each possible PDCH configuration and MS Class and verify that the UL/DL assignments work and that they are on the same first_common_ts.
2013-12-26 09:19:18 +00:00
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
/* Andreas osmocom-pcu example */
test_alloc_b_jolly(ms_class);
}
static void test_alloc_mass(bool ts0, bool ts1, bool ts2, bool ts3, bool ts4, bool ts5, bool ts6, bool ts7, int ms_class)
alloc/test: Add a crazy test that tests each possible combination Make a crazy test that will test each possible PDCH configuration and MS Class and verify that the UL/DL assignments work and that they are on the same first_common_ts.
2013-12-26 09:19:18 +00:00
{
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
bool rc;
alloc/test: Add a crazy test that tests each possible combination Make a crazy test that will test each possible PDCH configuration and MS Class and verify that the UL/DL assignments work and that they are on the same first_common_ts.
2013-12-26 09:19:18 +00:00
/* we can test the allocation failures differently */
if (!ts0 && !ts1 && !ts2 && !ts3 && !ts4 && !ts5 && !ts6 && !ts7)
return;
printf("Mass test: TS0(%c%c%c%c%c%c%c%c)TS7 MS_Class=%d\n",
ts0 ? 'O' : 'x',
ts1 ? 'O' : 'x',
ts2 ? 'O' : 'x',
ts3 ? 'O' : 'x',
ts4 ? 'O' : 'x',
ts5 ? 'O' : 'x',
ts6 ? 'O' : 'x',
ts7 ? 'O' : 'x', ms_class);
fflush(stdout);
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
rc = test_alloc_b_ul_dl(ts0, ts1, ts2, ts3, ts4, ts5, ts6, ts7, ms_class, false);
if (!rc)
return;
alloc/test: Add a crazy test that tests each possible combination Make a crazy test that will test each possible PDCH configuration and MS Class and verify that the UL/DL assignments work and that they are on the same first_common_ts.
2013-12-26 09:19:18 +00:00
/**
* Test with the other order.. first DL and then UL
*/
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
test_alloc_b_dl_ul(ts0, ts1, ts2, ts3, ts4, ts5, ts6, ts7, ms_class, false);
alloc/test: Add a crazy test that tests each possible combination Make a crazy test that will test each possible PDCH configuration and MS Class and verify that the UL/DL assignments work and that they are on the same first_common_ts.
2013-12-26 09:19:18 +00:00
}
static void test_all_alloc_b()
{
/* it is a bit crazy... */
for (uint8_t ts0 = 0; ts0 < 2; ++ts0)
for (uint8_t ts1 = 0; ts1 < 2; ++ts1)
for (uint8_t ts2 = 0; ts2 < 2; ++ts2)
for (uint8_t ts3 = 0; ts3 < 2; ++ts3)
for (uint8_t ts4 = 0; ts4 < 2; ++ts4)
for (uint8_t ts5 = 0; ts5 < 2; ++ts5)
for (uint8_t ts6 = 0; ts6 < 2; ++ts6)
for (uint8_t ts7 = 0; ts7 < 2; ++ts7)
AllocTest: remove assumption on max MS class So far the allocation was only tested up to hardcoded MS class 29. Drop that assumption and test for all supported MS classes. Adjust expected test output as necessary. Note: using mslot_class_max() forces allocation for MS classes 30 and 31 for which no actual data is available (will be added in follow-up patches) which current implementation treats differently depending on TX/RX direction - see gprs_alloc_max_dl_slots_per_ms(). Because of that we have to adjust the expected number of allocations in test_successive_allocation() as well. Change-Id: I7737f303d97197ef159b14a19c3312a11f07b433 Related: OS#2282
2018-01-23 19:57:08 +00:00
for (int ms_class = 0; ms_class < mslot_class_max(); ++ms_class)
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
test_alloc_mass(ts0, ts1, ts2, ts3, ts4, ts5, ts6, ts7, ms_class);
alloc/test: Add a crazy test that tests each possible combination Make a crazy test that will test each possible PDCH configuration and MS Class and verify that the UL/DL assignments work and that they are on the same first_common_ts.
2013-12-26 09:19:18 +00:00
}
alloc/test: Go through all possible ms_classes for the allocation Generate results for all possible classes.
2013-12-25 18:25:10 +00:00
static void test_alloc_b()
{
AllocTest: remove assumption on max MS class So far the allocation was only tested up to hardcoded MS class 29. Drop that assumption and test for all supported MS classes. Adjust expected test output as necessary. Note: using mslot_class_max() forces allocation for MS classes 30 and 31 for which no actual data is available (will be added in follow-up patches) which current implementation treats differently depending on TX/RX direction - see gprs_alloc_max_dl_slots_per_ms(). Because of that we have to adjust the expected number of allocations in test_successive_allocation() as well. Change-Id: I7737f303d97197ef159b14a19c3312a11f07b433 Related: OS#2282
2018-01-23 19:57:08 +00:00
for (int i = 0; i < mslot_class_max(); ++i)
AllocTest: adjust test_alloc_b() This function contains 3 independent test cases. Let's split them into separate functions to simplify further modifications: * split test cases into separate functions * use them for mass test as well * change function names to avoid confusion * make individual test cases return error instead of failing via assert on allocation failure The top-level test_alloc_b() is used as part of exhaustion tests in test_all_alloc_b() for example, so it's expected that allocation might fail (due to TFI or USF exhaustion for example) eventually. In this case it's better to indicate it to caller instead of failing entire program. The test output does not require any adjustements because we do not exhaust to the point of allocation failure yet. Change-Id: Id7e03a85ce96e7d617cecee963759bae589a3a1a Related: OS#2282
2017-11-21 17:13:31 +00:00
test_alloc_b_for_ms(i);
alloc/test: Add a crazy test that tests each possible combination Make a crazy test that will test each possible PDCH configuration and MS Class and verify that the UL/DL assignments work and that they are on the same first_common_ts.
2013-12-26 09:19:18 +00:00
test_all_alloc_b();
alloc/test: Go through all possible ms_classes for the allocation Generate results for all possible classes.
2013-12-25 18:25:10 +00:00
}
alloc/test: Use lower case for slots with TFI shortage Indicate those slots with lower case letters that do not have a spare TFI for the other direction if such a TBF has not been attached to the MS object yet. Sponsored-by: On-Waves ehf
2015-07-16 16:19:09 +00:00
static char get_dir_char(uint8_t mask, uint8_t tx, uint8_t rx, uint8_t busy)
alloc/test: Add test for successive allocation This test allocates as many as possible UL/DL TBF pairs, shows their PDCH usage, and checks how many of them has been created successfully. Sponsored-by: On-Waves ehf
2015-06-29 10:19:52 +00:00
{
alloc/test: Use lower case for slots with TFI shortage Indicate those slots with lower case letters that do not have a spare TFI for the other direction if such a TBF has not been attached to the MS object yet. Sponsored-by: On-Waves ehf
2015-07-16 16:19:09 +00:00
int offs = busy ? 32 : 0;
return (mask & tx & rx) ? 'C' + offs :
(mask & tx) ? 'U' + offs :
(mask & rx) ? 'D' + offs :
alloc/test: Add test for successive allocation This test allocates as many as possible UL/DL TBF pairs, shows their PDCH usage, and checks how many of them has been created successfully. Sponsored-by: On-Waves ehf
2015-06-29 10:19:52 +00:00
'.';
}
enum test_mode {
TEST_MODE_UL_ONLY,
TEST_MODE_DL_ONLY,
TEST_MODE_UL_AND_DL,
TEST_MODE_DL_AND_UL,
TEST_MODE_DL_AFTER_UL,
TEST_MODE_UL_AFTER_DL,
};
AllocTest: expand test output * print MS classes * unify and print test mode description * print additional info on test completion This only changes meta info about test run but not the actual test output. Change-Id: I30a4b8f561a9677f4e9ded33a051a249bd15a6a2 Related: OS#2282
2017-11-27 12:21:41 +00:00
static inline char *test_mode_descr(enum test_mode t)
{
switch (t) {
case TEST_MODE_UL_ONLY: return (char*)"UL only";
case TEST_MODE_DL_ONLY: return (char*)"DL only";
case TEST_MODE_UL_AND_DL: return (char*)"UL and DL";
case TEST_MODE_DL_AND_UL: return (char*)"DL and UL";
case TEST_MODE_DL_AFTER_UL: return (char*)"DL after UL";
case TEST_MODE_UL_AFTER_DL: return (char*)"UL after DL";
default: return NULL;
}
}
Unify BTS into a C usable structure Previous work on BTS class started to get stuff out of the C++ struct into a C struct (BTS -> struct gprs_glcmac_bts) so that some parts of it were accessible from C code. Doing so, however, ended up being messy too, since all code needs to be switching from one object to another, which actually refer to the same logical component. Let's instead rejoin the structures and make sure the struct is accessible and usable from both C and C++ code by rewriting all methods to be C compatible and converting 3 allocated suboject as pointers. This way BTS can internally still use those C++ objects while providing a clean APi to both C and C++ code. Change-Id: I7d12c896c5ded659ca9d3bff4cf3a3fc857db9dd
2021-01-14 15:48:38 +00:00
static GprsMs *alloc_tbfs(struct gprs_rlcmac_bts *bts, struct GprsMs *old_ms, enum test_mode mode)
alloc/test: Add test for successive allocation This test allocates as many as possible UL/DL TBF pairs, shows their PDCH usage, and checks how many of them has been created successfully. Sponsored-by: On-Waves ehf
2015-06-29 10:19:52 +00:00
{
Convert GprsMS and helpers classes to C As we integrate osmo-pcu more and more with libosmocore features, it becomes really hard to use them since libosmocore relies heavily on C specific compilation features, which are not available in old C++ compilers (such as designated initializers for complex types in FSMs). GprsMs is right now a quite simple object since initial design of osmo-pcu made it optional and most of the logic was placed and stored duplicated in TBF objects. However, that's changing as we introduce more features, with the GprsMS class getting more weight. Hence, let's move it now to be a C struct in order to be able to easily use libosmocore features there, such as FSMs. Some helper classes which GprsMs uses are also mostly move to C since they are mostly structs with methods, so there's no point in having duplicated APIs for C++ and C for such simple cases. For some more complex classes, like (ul_,dl_)tbf, C API bindings are added where needed so that GprsMs can use functionalitites from that class. Most of those APIs can be kept afterwards and drop the C++ ones since they provide no benefit in general. Change-Id: I0b50e3367aaad9dcada76da97b438e452c8b230c
2020-12-16 14:59:45 +00:00
struct GprsMs *ms, *new_ms;
tbf: Move TFI selection into alloc_algorithm Currently the TFI and the TRX have to be determined before the actual TBF allocation function is called, passing TFI and TRX number as parameters. This does fit to TFI reuse for different slots, since this were tightly coupled with the slot selection. This commit just moves the TFI selection into the alloc_algorithm functions. The tfi parameter is removed from the the TFI alloc functions. The trx parameter is changed into use_trx to optionally limit the trx selection (same semantics like in tfi_find_free). Sponsored-by: On-Waves ehf
2015-07-10 08:41:36 +00:00
uint8_t trx_no = -1;
alloc/test: Add test for successive allocation This test allocates as many as possible UL/DL TBF pairs, shows their PDCH usage, and checks how many of them has been created successfully. Sponsored-by: On-Waves ehf
2015-06-29 10:19:52 +00:00
Convert GprsMS and helpers classes to C As we integrate osmo-pcu more and more with libosmocore features, it becomes really hard to use them since libosmocore relies heavily on C specific compilation features, which are not available in old C++ compilers (such as designated initializers for complex types in FSMs). GprsMs is right now a quite simple object since initial design of osmo-pcu made it optional and most of the logic was placed and stored duplicated in TBF objects. However, that's changing as we introduce more features, with the GprsMS class getting more weight. Hence, let's move it now to be a C struct in order to be able to easily use libosmocore features there, such as FSMs. Some helper classes which GprsMs uses are also mostly move to C since they are mostly structs with methods, so there's no point in having duplicated APIs for C++ and C for such simple cases. For some more complex classes, like (ul_,dl_)tbf, C API bindings are added where needed so that GprsMs can use functionalitites from that class. Most of those APIs can be kept afterwards and drop the C++ ones since they provide no benefit in general. Change-Id: I0b50e3367aaad9dcada76da97b438e452c8b230c
2020-12-16 14:59:45 +00:00
OSMO_ASSERT(old_ms != NULL);
Expect ms object to exist before calling tbf_alloc_ul_tbf() It's really non-sense from architectural point of view to pass an optional pointer to the MS holding the TBF and creating it otherwise. TBFs shouldn't be creating MS they belong too. This simple change requiring so many code line changes really exhibits how badly entangled the object relationship is. Another commit will follow doing the same for dl tbf. Change-Id: I010aa5877902816ae246e09ad5ad87946f96855c
2020-05-08 15:44:33 +00:00
alloc/test: Add test for successive allocation This test allocates as many as possible UL/DL TBF pairs, shows their PDCH usage, and checks how many of them has been created successfully. Sponsored-by: On-Waves ehf
2015-06-29 10:19:52 +00:00
gprs_rlcmac_tbf *tbf = NULL;
Convert GprsMS and helpers classes to C As we integrate osmo-pcu more and more with libosmocore features, it becomes really hard to use them since libosmocore relies heavily on C specific compilation features, which are not available in old C++ compilers (such as designated initializers for complex types in FSMs). GprsMs is right now a quite simple object since initial design of osmo-pcu made it optional and most of the logic was placed and stored duplicated in TBF objects. However, that's changing as we introduce more features, with the GprsMS class getting more weight. Hence, let's move it now to be a C struct in order to be able to easily use libosmocore features there, such as FSMs. Some helper classes which GprsMs uses are also mostly move to C since they are mostly structs with methods, so there's no point in having duplicated APIs for C++ and C for such simple cases. For some more complex classes, like (ul_,dl_)tbf, C API bindings are added where needed so that GprsMs can use functionalitites from that class. Most of those APIs can be kept afterwards and drop the C++ ones since they provide no benefit in general. Change-Id: I0b50e3367aaad9dcada76da97b438e452c8b230c
2020-12-16 14:59:45 +00:00
if (ms_current_trx(old_ms))
trx_no = ms_current_trx(old_ms)->trx_no;
tbf: Move TFI selection into alloc_algorithm Currently the TFI and the TRX have to be determined before the actual TBF allocation function is called, passing TFI and TRX number as parameters. This does fit to TFI reuse for different slots, since this were tightly coupled with the slot selection. This commit just moves the TFI selection into the alloc_algorithm functions. The tfi parameter is removed from the the TFI alloc functions. The trx parameter is changed into use_trx to optionally limit the trx selection (same semantics like in tfi_find_free). Sponsored-by: On-Waves ehf
2015-07-10 08:41:36 +00:00
Convert GprsMS and helpers classes to C As we integrate osmo-pcu more and more with libosmocore features, it becomes really hard to use them since libosmocore relies heavily on C specific compilation features, which are not available in old C++ compilers (such as designated initializers for complex types in FSMs). GprsMs is right now a quite simple object since initial design of osmo-pcu made it optional and most of the logic was placed and stored duplicated in TBF objects. However, that's changing as we introduce more features, with the GprsMS class getting more weight. Hence, let's move it now to be a C struct in order to be able to easily use libosmocore features there, such as FSMs. Some helper classes which GprsMs uses are also mostly move to C since they are mostly structs with methods, so there's no point in having duplicated APIs for C++ and C for such simple cases. For some more complex classes, like (ul_,dl_)tbf, C API bindings are added where needed so that GprsMs can use functionalitites from that class. Most of those APIs can be kept afterwards and drop the C++ ones since they provide no benefit in general. Change-Id: I0b50e3367aaad9dcada76da97b438e452c8b230c
2020-12-16 14:59:45 +00:00
ms_ref(old_ms);
alloc/test: Put TBF allocation loop into alloc_many_tbfs Currently all TBFs are deleted after the allocation loop finishes. This make it difficult to interleave the TBF allocation like it happens with real MS. This commit refactors the allocation loop into alloc_many_tbfs and adds support for TLLIs, which are derived from the counter value and used to retrieve an old MS object if alloc_many_tbfs is called a second time. Note that this does not make a difference for the existing tests. Sponsored-by: On-Waves ehf
2015-07-13 12:38:18 +00:00
alloc/test: Add test for successive allocation This test allocates as many as possible UL/DL TBF pairs, shows their PDCH usage, and checks how many of them has been created successfully. Sponsored-by: On-Waves ehf
2015-06-29 10:19:52 +00:00
/* Allocate what is needed first */
switch (mode) {
case TEST_MODE_UL_ONLY:
case TEST_MODE_DL_AFTER_UL:
case TEST_MODE_UL_AND_DL:
Convert GprsMS and helpers classes to C As we integrate osmo-pcu more and more with libosmocore features, it becomes really hard to use them since libosmocore relies heavily on C specific compilation features, which are not available in old C++ compilers (such as designated initializers for complex types in FSMs). GprsMs is right now a quite simple object since initial design of osmo-pcu made it optional and most of the logic was placed and stored duplicated in TBF objects. However, that's changing as we introduce more features, with the GprsMS class getting more weight. Hence, let's move it now to be a C struct in order to be able to easily use libosmocore features there, such as FSMs. Some helper classes which GprsMs uses are also mostly move to C since they are mostly structs with methods, so there's no point in having duplicated APIs for C++ and C for such simple cases. For some more complex classes, like (ul_,dl_)tbf, C API bindings are added where needed so that GprsMs can use functionalitites from that class. Most of those APIs can be kept afterwards and drop the C++ ones since they provide no benefit in general. Change-Id: I0b50e3367aaad9dcada76da97b438e452c8b230c
2020-12-16 14:59:45 +00:00
if (ms_ul_tbf(old_ms))
tbf_free(ms_ul_tbf(old_ms));
tbf = tbf_alloc_ul_tbf(bts, old_ms, trx_no, false);
if (tbf == NULL) {
bts: Add counter availablePDCHAllocatedTime We basically want to probe whether it's possible to allocate TBFs, or whether we know it will fail due to all main resources being already in use (TFI, USF). Having bts_all_pdch_allocated() return false doesn't mean though that an MS will be able to allocate a TBF for sure. That's because further restrictions are applied based on MS: whether it was already attached to a specific TRX, whether the ms_class allows for a certain multislot combination, etc. However, it should provide a general idea on whether for sure the PCU is unable to provide more allocations. More fine grained state about failures can still be followed by looking at tbf:alloc:failed:* rate counters. Related: SYS#4878 Depends: Iabb17a08e6e1a86f168cdb008fba05ecd4776bdd (libosmocore) Change-Id: Ie0f0c451558817bddc3fe1a0f0df531f14c9f1d3
2021-11-10 18:09:10 +00:00
OSMO_ASSERT(trx_no != -1 || bts_all_pdch_allocated(bts));
Convert GprsMS and helpers classes to C As we integrate osmo-pcu more and more with libosmocore features, it becomes really hard to use them since libosmocore relies heavily on C specific compilation features, which are not available in old C++ compilers (such as designated initializers for complex types in FSMs). GprsMs is right now a quite simple object since initial design of osmo-pcu made it optional and most of the logic was placed and stored duplicated in TBF objects. However, that's changing as we introduce more features, with the GprsMS class getting more weight. Hence, let's move it now to be a C struct in order to be able to easily use libosmocore features there, such as FSMs. Some helper classes which GprsMs uses are also mostly move to C since they are mostly structs with methods, so there's no point in having duplicated APIs for C++ and C for such simple cases. For some more complex classes, like (ul_,dl_)tbf, C API bindings are added where needed so that GprsMs can use functionalitites from that class. Most of those APIs can be kept afterwards and drop the C++ ones since they provide no benefit in general. Change-Id: I0b50e3367aaad9dcada76da97b438e452c8b230c
2020-12-16 14:59:45 +00:00
ms_unref(old_ms);
alloc/test: Add test for successive allocation This test allocates as many as possible UL/DL TBF pairs, shows their PDCH usage, and checks how many of them has been created successfully. Sponsored-by: On-Waves ehf
2015-06-29 10:19:52 +00:00
return NULL;
Convert GprsMS and helpers classes to C As we integrate osmo-pcu more and more with libosmocore features, it becomes really hard to use them since libosmocore relies heavily on C specific compilation features, which are not available in old C++ compilers (such as designated initializers for complex types in FSMs). GprsMs is right now a quite simple object since initial design of osmo-pcu made it optional and most of the logic was placed and stored duplicated in TBF objects. However, that's changing as we introduce more features, with the GprsMS class getting more weight. Hence, let's move it now to be a C struct in order to be able to easily use libosmocore features there, such as FSMs. Some helper classes which GprsMs uses are also mostly move to C since they are mostly structs with methods, so there's no point in having duplicated APIs for C++ and C for such simple cases. For some more complex classes, like (ul_,dl_)tbf, C API bindings are added where needed so that GprsMs can use functionalitites from that class. Most of those APIs can be kept afterwards and drop the C++ ones since they provide no benefit in general. Change-Id: I0b50e3367aaad9dcada76da97b438e452c8b230c
2020-12-16 14:59:45 +00:00
}
alloc/test: Add test for successive allocation This test allocates as many as possible UL/DL TBF pairs, shows their PDCH usage, and checks how many of them has been created successfully. Sponsored-by: On-Waves ehf
2015-06-29 10:19:52 +00:00
break;
case TEST_MODE_DL_ONLY:
case TEST_MODE_UL_AFTER_DL:
case TEST_MODE_DL_AND_UL:
Convert GprsMS and helpers classes to C As we integrate osmo-pcu more and more with libosmocore features, it becomes really hard to use them since libosmocore relies heavily on C specific compilation features, which are not available in old C++ compilers (such as designated initializers for complex types in FSMs). GprsMs is right now a quite simple object since initial design of osmo-pcu made it optional and most of the logic was placed and stored duplicated in TBF objects. However, that's changing as we introduce more features, with the GprsMS class getting more weight. Hence, let's move it now to be a C struct in order to be able to easily use libosmocore features there, such as FSMs. Some helper classes which GprsMs uses are also mostly move to C since they are mostly structs with methods, so there's no point in having duplicated APIs for C++ and C for such simple cases. For some more complex classes, like (ul_,dl_)tbf, C API bindings are added where needed so that GprsMs can use functionalitites from that class. Most of those APIs can be kept afterwards and drop the C++ ones since they provide no benefit in general. Change-Id: I0b50e3367aaad9dcada76da97b438e452c8b230c
2020-12-16 14:59:45 +00:00
if (ms_dl_tbf(old_ms))
tbf_free(ms_dl_tbf(old_ms));
tbf = tbf_alloc_dl_tbf(bts, old_ms, trx_no, false);
if (tbf == NULL) {
bts: Add counter availablePDCHAllocatedTime We basically want to probe whether it's possible to allocate TBFs, or whether we know it will fail due to all main resources being already in use (TFI, USF). Having bts_all_pdch_allocated() return false doesn't mean though that an MS will be able to allocate a TBF for sure. That's because further restrictions are applied based on MS: whether it was already attached to a specific TRX, whether the ms_class allows for a certain multislot combination, etc. However, it should provide a general idea on whether for sure the PCU is unable to provide more allocations. More fine grained state about failures can still be followed by looking at tbf:alloc:failed:* rate counters. Related: SYS#4878 Depends: Iabb17a08e6e1a86f168cdb008fba05ecd4776bdd (libosmocore) Change-Id: Ie0f0c451558817bddc3fe1a0f0df531f14c9f1d3
2021-11-10 18:09:10 +00:00
OSMO_ASSERT(trx_no != -1 || bts_all_pdch_allocated(bts));
Convert GprsMS and helpers classes to C As we integrate osmo-pcu more and more with libosmocore features, it becomes really hard to use them since libosmocore relies heavily on C specific compilation features, which are not available in old C++ compilers (such as designated initializers for complex types in FSMs). GprsMs is right now a quite simple object since initial design of osmo-pcu made it optional and most of the logic was placed and stored duplicated in TBF objects. However, that's changing as we introduce more features, with the GprsMS class getting more weight. Hence, let's move it now to be a C struct in order to be able to easily use libosmocore features there, such as FSMs. Some helper classes which GprsMs uses are also mostly move to C since they are mostly structs with methods, so there's no point in having duplicated APIs for C++ and C for such simple cases. For some more complex classes, like (ul_,dl_)tbf, C API bindings are added where needed so that GprsMs can use functionalitites from that class. Most of those APIs can be kept afterwards and drop the C++ ones since they provide no benefit in general. Change-Id: I0b50e3367aaad9dcada76da97b438e452c8b230c
2020-12-16 14:59:45 +00:00
ms_unref(old_ms);
alloc/test: Add test for successive allocation This test allocates as many as possible UL/DL TBF pairs, shows their PDCH usage, and checks how many of them has been created successfully. Sponsored-by: On-Waves ehf
2015-06-29 10:19:52 +00:00
return NULL;
Convert GprsMS and helpers classes to C As we integrate osmo-pcu more and more with libosmocore features, it becomes really hard to use them since libosmocore relies heavily on C specific compilation features, which are not available in old C++ compilers (such as designated initializers for complex types in FSMs). GprsMs is right now a quite simple object since initial design of osmo-pcu made it optional and most of the logic was placed and stored duplicated in TBF objects. However, that's changing as we introduce more features, with the GprsMS class getting more weight. Hence, let's move it now to be a C struct in order to be able to easily use libosmocore features there, such as FSMs. Some helper classes which GprsMs uses are also mostly move to C since they are mostly structs with methods, so there's no point in having duplicated APIs for C++ and C for such simple cases. For some more complex classes, like (ul_,dl_)tbf, C API bindings are added where needed so that GprsMs can use functionalitites from that class. Most of those APIs can be kept afterwards and drop the C++ ones since they provide no benefit in general. Change-Id: I0b50e3367aaad9dcada76da97b438e452c8b230c
2020-12-16 14:59:45 +00:00
}
alloc/test: Add test for successive allocation This test allocates as many as possible UL/DL TBF pairs, shows their PDCH usage, and checks how many of them has been created successfully. Sponsored-by: On-Waves ehf
2015-06-29 10:19:52 +00:00
}
OSMO_ASSERT(tbf);
OSMO_ASSERT(tbf->ms());
Convert GprsMS and helpers classes to C As we integrate osmo-pcu more and more with libosmocore features, it becomes really hard to use them since libosmocore relies heavily on C specific compilation features, which are not available in old C++ compilers (such as designated initializers for complex types in FSMs). GprsMs is right now a quite simple object since initial design of osmo-pcu made it optional and most of the logic was placed and stored duplicated in TBF objects. However, that's changing as we introduce more features, with the GprsMS class getting more weight. Hence, let's move it now to be a C struct in order to be able to easily use libosmocore features there, such as FSMs. Some helper classes which GprsMs uses are also mostly move to C since they are mostly structs with methods, so there's no point in having duplicated APIs for C++ and C for such simple cases. For some more complex classes, like (ul_,dl_)tbf, C API bindings are added where needed so that GprsMs can use functionalitites from that class. Most of those APIs can be kept afterwards and drop the C++ ones since they provide no benefit in general. Change-Id: I0b50e3367aaad9dcada76da97b438e452c8b230c
2020-12-16 14:59:45 +00:00
OSMO_ASSERT(old_ms == tbf->ms());
alloc/test: Add test for successive allocation This test allocates as many as possible UL/DL TBF pairs, shows their PDCH usage, and checks how many of them has been created successfully. Sponsored-by: On-Waves ehf
2015-06-29 10:19:52 +00:00
ms = tbf->ms();
Convert GprsMS and helpers classes to C As we integrate osmo-pcu more and more with libosmocore features, it becomes really hard to use them since libosmocore relies heavily on C specific compilation features, which are not available in old C++ compilers (such as designated initializers for complex types in FSMs). GprsMs is right now a quite simple object since initial design of osmo-pcu made it optional and most of the logic was placed and stored duplicated in TBF objects. However, that's changing as we introduce more features, with the GprsMS class getting more weight. Hence, let's move it now to be a C struct in order to be able to easily use libosmocore features there, such as FSMs. Some helper classes which GprsMs uses are also mostly move to C since they are mostly structs with methods, so there's no point in having duplicated APIs for C++ and C for such simple cases. For some more complex classes, like (ul_,dl_)tbf, C API bindings are added where needed so that GprsMs can use functionalitites from that class. Most of those APIs can be kept afterwards and drop the C++ ones since they provide no benefit in general. Change-Id: I0b50e3367aaad9dcada76da97b438e452c8b230c
2020-12-16 14:59:45 +00:00
ms_ref(ms);
new_ms = ms;
alloc/test: Add test for successive allocation This test allocates as many as possible UL/DL TBF pairs, shows their PDCH usage, and checks how many of them has been created successfully. Sponsored-by: On-Waves ehf
2015-06-29 10:19:52 +00:00
/* Continue with what is needed next */
switch (mode) {
case TEST_MODE_UL_ONLY:
case TEST_MODE_DL_ONLY:
/* We are done */
alloc/test: Delete first TBF after the second is allocated Currently when using the test modes TEST_MODE_DL_AFTER_UL or TEST_MODE_UL_AFTER_DL, the first TBF is deleted before the second is allocated. The far more interesting case were to keep the first TBF a little bit longer until the second TBF has been created and delete then. This comes closer the the situation observed with real MS, where the first TBF takes some time (timeout or waiting for Ack) before it gets deleted and thus detached from the MS object. This commit delays the call to tbf_free accordingly. The effect can be observed in the results of the algo A tests, where the uniform distribution of the allocated PDCH is lost. Sponsored-by: On-Waves ehf
2015-07-07 09:31:28 +00:00
break;
alloc/test: Add test for successive allocation This test allocates as many as possible UL/DL TBF pairs, shows their PDCH usage, and checks how many of them has been created successfully. Sponsored-by: On-Waves ehf
2015-06-29 10:19:52 +00:00
case TEST_MODE_DL_AFTER_UL:
case TEST_MODE_UL_AND_DL:
Unify BTS into a C usable structure Previous work on BTS class started to get stuff out of the C++ struct into a C struct (BTS -> struct gprs_glcmac_bts) so that some parts of it were accessible from C code. Doing so, however, ended up being messy too, since all code needs to be switching from one object to another, which actually refer to the same logical component. Let's instead rejoin the structures and make sure the struct is accessible and usable from both C and C++ code by rewriting all methods to be C compatible and converting 3 allocated suboject as pointers. This way BTS can internally still use those C++ objects while providing a clean APi to both C and C++ code. Change-Id: I7d12c896c5ded659ca9d3bff4cf3a3fc857db9dd
2021-01-14 15:48:38 +00:00
new_ms = alloc_tbfs(bts, ms, TEST_MODE_DL_ONLY);
alloc/test: Delete first TBF after the second is allocated Currently when using the test modes TEST_MODE_DL_AFTER_UL or TEST_MODE_UL_AFTER_DL, the first TBF is deleted before the second is allocated. The far more interesting case were to keep the first TBF a little bit longer until the second TBF has been created and delete then. This comes closer the the situation observed with real MS, where the first TBF takes some time (timeout or waiting for Ack) before it gets deleted and thus detached from the MS object. This commit delays the call to tbf_free accordingly. The effect can be observed in the results of the algo A tests, where the uniform distribution of the allocated PDCH is lost. Sponsored-by: On-Waves ehf
2015-07-07 09:31:28 +00:00
break;
alloc/test: Add test for successive allocation This test allocates as many as possible UL/DL TBF pairs, shows their PDCH usage, and checks how many of them has been created successfully. Sponsored-by: On-Waves ehf
2015-06-29 10:19:52 +00:00
case TEST_MODE_UL_AFTER_DL:
case TEST_MODE_DL_AND_UL:
Unify BTS into a C usable structure Previous work on BTS class started to get stuff out of the C++ struct into a C struct (BTS -> struct gprs_glcmac_bts) so that some parts of it were accessible from C code. Doing so, however, ended up being messy too, since all code needs to be switching from one object to another, which actually refer to the same logical component. Let's instead rejoin the structures and make sure the struct is accessible and usable from both C and C++ code by rewriting all methods to be C compatible and converting 3 allocated suboject as pointers. This way BTS can internally still use those C++ objects while providing a clean APi to both C and C++ code. Change-Id: I7d12c896c5ded659ca9d3bff4cf3a3fc857db9dd
2021-01-14 15:48:38 +00:00
new_ms = alloc_tbfs(bts, ms, TEST_MODE_UL_ONLY);
alloc/test: Delete first TBF after the second is allocated Currently when using the test modes TEST_MODE_DL_AFTER_UL or TEST_MODE_UL_AFTER_DL, the first TBF is deleted before the second is allocated. The far more interesting case were to keep the first TBF a little bit longer until the second TBF has been created and delete then. This comes closer the the situation observed with real MS, where the first TBF takes some time (timeout or waiting for Ack) before it gets deleted and thus detached from the MS object. This commit delays the call to tbf_free accordingly. The effect can be observed in the results of the algo A tests, where the uniform distribution of the allocated PDCH is lost. Sponsored-by: On-Waves ehf
2015-07-07 09:31:28 +00:00
break;
}
/* Optionally delete the TBF */
switch (mode) {
case TEST_MODE_DL_AFTER_UL:
case TEST_MODE_UL_AFTER_DL:
tbf_free(tbf);
alloc/test: Free the TBF if the recursion has failed Currently if both an uplink and a downlink TBF are to be allocated by alloc_tbfs() and the second allocation fails, the first TBF is not freed. This commit changes the recursive function to free the TBF if the ms variable has been changed to NULL. Sponsored-by: On-Waves ehf
2015-07-16 16:23:33 +00:00
tbf = NULL;
alloc/test: Delete first TBF after the second is allocated Currently when using the test modes TEST_MODE_DL_AFTER_UL or TEST_MODE_UL_AFTER_DL, the first TBF is deleted before the second is allocated. The far more interesting case were to keep the first TBF a little bit longer until the second TBF has been created and delete then. This comes closer the the situation observed with real MS, where the first TBF takes some time (timeout or waiting for Ack) before it gets deleted and thus detached from the MS object. This commit delays the call to tbf_free accordingly. The effect can be observed in the results of the algo A tests, where the uniform distribution of the allocated PDCH is lost. Sponsored-by: On-Waves ehf
2015-07-07 09:31:28 +00:00
break;
default:
break;
alloc/test: Add test for successive allocation This test allocates as many as possible UL/DL TBF pairs, shows their PDCH usage, and checks how many of them has been created successfully. Sponsored-by: On-Waves ehf
2015-06-29 10:19:52 +00:00
}
Convert GprsMS and helpers classes to C As we integrate osmo-pcu more and more with libosmocore features, it becomes really hard to use them since libosmocore relies heavily on C specific compilation features, which are not available in old C++ compilers (such as designated initializers for complex types in FSMs). GprsMs is right now a quite simple object since initial design of osmo-pcu made it optional and most of the logic was placed and stored duplicated in TBF objects. However, that's changing as we introduce more features, with the GprsMS class getting more weight. Hence, let's move it now to be a C struct in order to be able to easily use libosmocore features there, such as FSMs. Some helper classes which GprsMs uses are also mostly move to C since they are mostly structs with methods, so there's no point in having duplicated APIs for C++ and C for such simple cases. For some more complex classes, like (ul_,dl_)tbf, C API bindings are added where needed so that GprsMs can use functionalitites from that class. Most of those APIs can be kept afterwards and drop the C++ ones since they provide no benefit in general. Change-Id: I0b50e3367aaad9dcada76da97b438e452c8b230c
2020-12-16 14:59:45 +00:00
if (!new_ms && tbf)
alloc/test: Free the TBF if the recursion has failed Currently if both an uplink and a downlink TBF are to be allocated by alloc_tbfs() and the second allocation fails, the first TBF is not freed. This commit changes the recursive function to free the TBF if the ms variable has been changed to NULL. Sponsored-by: On-Waves ehf
2015-07-16 16:23:33 +00:00
tbf_free(tbf);
Convert GprsMS and helpers classes to C As we integrate osmo-pcu more and more with libosmocore features, it becomes really hard to use them since libosmocore relies heavily on C specific compilation features, which are not available in old C++ compilers (such as designated initializers for complex types in FSMs). GprsMs is right now a quite simple object since initial design of osmo-pcu made it optional and most of the logic was placed and stored duplicated in TBF objects. However, that's changing as we introduce more features, with the GprsMS class getting more weight. Hence, let's move it now to be a C struct in order to be able to easily use libosmocore features there, such as FSMs. Some helper classes which GprsMs uses are also mostly move to C since they are mostly structs with methods, so there's no point in having duplicated APIs for C++ and C for such simple cases. For some more complex classes, like (ul_,dl_)tbf, C API bindings are added where needed so that GprsMs can use functionalitites from that class. Most of those APIs can be kept afterwards and drop the C++ ones since they provide no benefit in general. Change-Id: I0b50e3367aaad9dcada76da97b438e452c8b230c
2020-12-16 14:59:45 +00:00
ms_unref(old_ms);
ms_unref(ms);
return new_ms;
alloc/test: Add test for successive allocation This test allocates as many as possible UL/DL TBF pairs, shows their PDCH usage, and checks how many of them has been created successfully. Sponsored-by: On-Waves ehf
2015-06-29 10:19:52 +00:00
}
Unify BTS into a C usable structure Previous work on BTS class started to get stuff out of the C++ struct into a C struct (BTS -> struct gprs_glcmac_bts) so that some parts of it were accessible from C code. Doing so, however, ended up being messy too, since all code needs to be switching from one object to another, which actually refer to the same logical component. Let's instead rejoin the structures and make sure the struct is accessible and usable from both C and C++ code by rewriting all methods to be C compatible and converting 3 allocated suboject as pointers. This way BTS can internally still use those C++ objects while providing a clean APi to both C and C++ code. Change-Id: I7d12c896c5ded659ca9d3bff4cf3a3fc857db9dd
2021-01-14 15:48:38 +00:00
static unsigned alloc_many_tbfs(struct gprs_rlcmac_bts *bts, unsigned min_class,
alloc/test: Put TBF allocation loop into alloc_many_tbfs Currently all TBFs are deleted after the allocation loop finishes. This make it difficult to interleave the TBF allocation like it happens with real MS. This commit refactors the allocation loop into alloc_many_tbfs and adds support for TLLIs, which are derived from the counter value and used to retrieve an old MS object if alloc_many_tbfs is called a second time. Note that this does not make a difference for the existing tests. Sponsored-by: On-Waves ehf
2015-07-13 12:38:18 +00:00
unsigned max_class, enum test_mode mode)
alloc/test: Add test for successive allocation This test allocates as many as possible UL/DL TBF pairs, shows their PDCH usage, and checks how many of them has been created successfully. Sponsored-by: On-Waves ehf
2015-06-29 10:19:52 +00:00
{
unsigned counter;
unsigned ms_class = min_class;
for (counter = 0; 1; counter += 1) {
gprs_rlcmac_tbf *ul_tbf, *dl_tbf;
uint8_t ul_slots = 0;
uint8_t dl_slots = 0;
alloc/test: Use lower case for slots with TFI shortage Indicate those slots with lower case letters that do not have a spare TFI for the other direction if such a TBF has not been attached to the MS object yet. Sponsored-by: On-Waves ehf
2015-07-16 16:19:09 +00:00
uint8_t busy_slots = 0;
alloc/test: Add test for successive allocation This test allocates as many as possible UL/DL TBF pairs, shows their PDCH usage, and checks how many of them has been created successfully. Sponsored-by: On-Waves ehf
2015-06-29 10:19:52 +00:00
unsigned i;
int tfi = -1;
alloc/test: Check for TFI conflicts This commit adds the check_tfi_usage function that checks the TFI usage. It iterates through all TBFs, records on which PDCH it uses which TFI and check for conflicts. It also checks the bits returned by pdch->assigned_tfi(). The latter suffers from an bug in that method (no separation of uplink and downlink), so a conditional fprintf is used instead of an assertion. The method tfi_find_free is checked for conflicts after allocations. Sponsored-by: On-Waves ehf
2015-07-09 09:35:50 +00:00
int tfi2;
alloc/test: Use lower case for slots with TFI shortage Indicate those slots with lower case letters that do not have a spare TFI for the other direction if such a TBF has not been attached to the MS object yet. Sponsored-by: On-Waves ehf
2015-07-16 16:19:09 +00:00
uint8_t trx_no2;
struct gprs_rlcmac_trx *trx;
alloc/test: Add test for successive allocation This test allocates as many as possible UL/DL TBF pairs, shows their PDCH usage, and checks how many of them has been created successfully. Sponsored-by: On-Waves ehf
2015-06-29 10:19:52 +00:00
GprsMs *ms;
alloc/test: Check for TFI conflicts This commit adds the check_tfi_usage function that checks the TFI usage. It iterates through all TBFs, records on which PDCH it uses which TFI and check for conflicts. It also checks the bits returned by pdch->assigned_tfi(). The latter suffers from an bug in that method (no separation of uplink and downlink), so a conditional fprintf is used instead of an assertion. The method tfi_find_free is checked for conflicts after allocations. Sponsored-by: On-Waves ehf
2015-07-09 09:35:50 +00:00
enum gprs_rlcmac_tbf_direction dir;
alloc/test: Put TBF allocation loop into alloc_many_tbfs Currently all TBFs are deleted after the allocation loop finishes. This make it difficult to interleave the TBF allocation like it happens with real MS. This commit refactors the allocation loop into alloc_many_tbfs and adds support for TLLIs, which are derived from the counter value and used to retrieve an old MS object if alloc_many_tbfs is called a second time. Note that this does not make a difference for the existing tests. Sponsored-by: On-Waves ehf
2015-07-13 12:38:18 +00:00
uint32_t tlli = counter + 0xc0000000;
Unify BTS into a C usable structure Previous work on BTS class started to get stuff out of the C++ struct into a C struct (BTS -> struct gprs_glcmac_bts) so that some parts of it were accessible from C code. Doing so, however, ended up being messy too, since all code needs to be switching from one object to another, which actually refer to the same logical component. Let's instead rejoin the structures and make sure the struct is accessible and usable from both C and C++ code by rewriting all methods to be C compatible and converting 3 allocated suboject as pointers. This way BTS can internally still use those C++ objects while providing a clean APi to both C and C++ code. Change-Id: I7d12c896c5ded659ca9d3bff4cf3a3fc857db9dd
2021-01-14 15:48:38 +00:00
ms = bts_ms_by_tlli(bts, tlli, GSM_RESERVED_TMSI);
Expect ms object to exist before calling tbf_alloc_ul_tbf() It's really non-sense from architectural point of view to pass an optional pointer to the MS holding the TBF and creating it otherwise. TBFs shouldn't be creating MS they belong too. This simple change requiring so many code line changes really exhibits how badly entangled the object relationship is. Another commit will follow doing the same for dl tbf. Change-Id: I010aa5877902816ae246e09ad5ad87946f96855c
2020-05-08 15:44:33 +00:00
if (!ms)
Unify BTS into a C usable structure Previous work on BTS class started to get stuff out of the C++ struct into a C struct (BTS -> struct gprs_glcmac_bts) so that some parts of it were accessible from C code. Doing so, however, ended up being messy too, since all code needs to be switching from one object to another, which actually refer to the same logical component. Let's instead rejoin the structures and make sure the struct is accessible and usable from both C and C++ code by rewriting all methods to be C compatible and converting 3 allocated suboject as pointers. This way BTS can internally still use those C++ objects while providing a clean APi to both C and C++ code. Change-Id: I7d12c896c5ded659ca9d3bff4cf3a3fc857db9dd
2021-01-14 15:48:38 +00:00
ms = bts_alloc_ms(bts, 0, 0);
Convert GprsMS and helpers classes to C As we integrate osmo-pcu more and more with libosmocore features, it becomes really hard to use them since libosmocore relies heavily on C specific compilation features, which are not available in old C++ compilers (such as designated initializers for complex types in FSMs). GprsMs is right now a quite simple object since initial design of osmo-pcu made it optional and most of the logic was placed and stored duplicated in TBF objects. However, that's changing as we introduce more features, with the GprsMS class getting more weight. Hence, let's move it now to be a C struct in order to be able to easily use libosmocore features there, such as FSMs. Some helper classes which GprsMs uses are also mostly move to C since they are mostly structs with methods, so there's no point in having duplicated APIs for C++ and C for such simple cases. For some more complex classes, like (ul_,dl_)tbf, C API bindings are added where needed so that GprsMs can use functionalitites from that class. Most of those APIs can be kept afterwards and drop the C++ ones since they provide no benefit in general. Change-Id: I0b50e3367aaad9dcada76da97b438e452c8b230c
2020-12-16 14:59:45 +00:00
ms_set_ms_class(ms, ms_class);
Unify BTS into a C usable structure Previous work on BTS class started to get stuff out of the C++ struct into a C struct (BTS -> struct gprs_glcmac_bts) so that some parts of it were accessible from C code. Doing so, however, ended up being messy too, since all code needs to be switching from one object to another, which actually refer to the same logical component. Let's instead rejoin the structures and make sure the struct is accessible and usable from both C and C++ code by rewriting all methods to be C compatible and converting 3 allocated suboject as pointers. This way BTS can internally still use those C++ objects while providing a clean APi to both C and C++ code. Change-Id: I7d12c896c5ded659ca9d3bff4cf3a3fc857db9dd
2021-01-14 15:48:38 +00:00
ms = alloc_tbfs(bts, ms, mode);
alloc/test: Add test for successive allocation This test allocates as many as possible UL/DL TBF pairs, shows their PDCH usage, and checks how many of them has been created successfully. Sponsored-by: On-Waves ehf
2015-06-29 10:19:52 +00:00
if (!ms)
break;
Convert GprsMS and helpers classes to C As we integrate osmo-pcu more and more with libosmocore features, it becomes really hard to use them since libosmocore relies heavily on C specific compilation features, which are not available in old C++ compilers (such as designated initializers for complex types in FSMs). GprsMs is right now a quite simple object since initial design of osmo-pcu made it optional and most of the logic was placed and stored duplicated in TBF objects. However, that's changing as we introduce more features, with the GprsMS class getting more weight. Hence, let's move it now to be a C struct in order to be able to easily use libosmocore features there, such as FSMs. Some helper classes which GprsMs uses are also mostly move to C since they are mostly structs with methods, so there's no point in having duplicated APIs for C++ and C for such simple cases. For some more complex classes, like (ul_,dl_)tbf, C API bindings are added where needed so that GprsMs can use functionalitites from that class. Most of those APIs can be kept afterwards and drop the C++ ones since they provide no benefit in general. Change-Id: I0b50e3367aaad9dcada76da97b438e452c8b230c
2020-12-16 14:59:45 +00:00
ms_set_tlli(ms, tlli);
alloc/test: Put TBF allocation loop into alloc_many_tbfs Currently all TBFs are deleted after the allocation loop finishes. This make it difficult to interleave the TBF allocation like it happens with real MS. This commit refactors the allocation loop into alloc_many_tbfs and adds support for TLLIs, which are derived from the counter value and used to retrieve an old MS object if alloc_many_tbfs is called a second time. Note that this does not make a difference for the existing tests. Sponsored-by: On-Waves ehf
2015-07-13 12:38:18 +00:00
Convert GprsMS and helpers classes to C As we integrate osmo-pcu more and more with libosmocore features, it becomes really hard to use them since libosmocore relies heavily on C specific compilation features, which are not available in old C++ compilers (such as designated initializers for complex types in FSMs). GprsMs is right now a quite simple object since initial design of osmo-pcu made it optional and most of the logic was placed and stored duplicated in TBF objects. However, that's changing as we introduce more features, with the GprsMS class getting more weight. Hence, let's move it now to be a C struct in order to be able to easily use libosmocore features there, such as FSMs. Some helper classes which GprsMs uses are also mostly move to C since they are mostly structs with methods, so there's no point in having duplicated APIs for C++ and C for such simple cases. For some more complex classes, like (ul_,dl_)tbf, C API bindings are added where needed so that GprsMs can use functionalitites from that class. Most of those APIs can be kept afterwards and drop the C++ ones since they provide no benefit in general. Change-Id: I0b50e3367aaad9dcada76da97b438e452c8b230c
2020-12-16 14:59:45 +00:00
ul_tbf = ms_ul_tbf(ms);
dl_tbf = ms_dl_tbf(ms);
trx = ms_current_trx(ms);
alloc/test: Use lower case for slots with TFI shortage Indicate those slots with lower case letters that do not have a spare TFI for the other direction if such a TBF has not been attached to the MS object yet. Sponsored-by: On-Waves ehf
2015-07-16 16:19:09 +00:00
OSMO_ASSERT(ul_tbf || dl_tbf);
alloc/test: Add test for successive allocation This test allocates as many as possible UL/DL TBF pairs, shows their PDCH usage, and checks how many of them has been created successfully. Sponsored-by: On-Waves ehf
2015-06-29 10:19:52 +00:00
if (ul_tbf) {
ul_slots = 1 << ul_tbf->first_common_ts;
tfi = ul_tbf->tfi();
alloc/test: Check for TFI conflicts This commit adds the check_tfi_usage function that checks the TFI usage. It iterates through all TBFs, records on which PDCH it uses which TFI and check for conflicts. It also checks the bits returned by pdch->assigned_tfi(). The latter suffers from an bug in that method (no separation of uplink and downlink), so a conditional fprintf is used instead of an assertion. The method tfi_find_free is checked for conflicts after allocations. Sponsored-by: On-Waves ehf
2015-07-09 09:35:50 +00:00
dir = GPRS_RLCMAC_UL_TBF;
alloc/test: Use lower case for slots with TFI shortage Indicate those slots with lower case letters that do not have a spare TFI for the other direction if such a TBF has not been attached to the MS object yet. Sponsored-by: On-Waves ehf
2015-07-16 16:19:09 +00:00
} else {
alloc/test: Add test for successive allocation This test allocates as many as possible UL/DL TBF pairs, shows their PDCH usage, and checks how many of them has been created successfully. Sponsored-by: On-Waves ehf
2015-06-29 10:19:52 +00:00
ul_slots = 1 << dl_tbf->first_common_ts;
tfi = dl_tbf->tfi();
alloc/test: Check for TFI conflicts This commit adds the check_tfi_usage function that checks the TFI usage. It iterates through all TBFs, records on which PDCH it uses which TFI and check for conflicts. It also checks the bits returned by pdch->assigned_tfi(). The latter suffers from an bug in that method (no separation of uplink and downlink), so a conditional fprintf is used instead of an assertion. The method tfi_find_free is checked for conflicts after allocations. Sponsored-by: On-Waves ehf
2015-07-09 09:35:50 +00:00
dir = GPRS_RLCMAC_DL_TBF;
alloc/test: Add test for successive allocation This test allocates as many as possible UL/DL TBF pairs, shows their PDCH usage, and checks how many of them has been created successfully. Sponsored-by: On-Waves ehf
2015-06-29 10:19:52 +00:00
}
for (i = 0; dl_tbf && i < ARRAY_SIZE(dl_tbf->pdch); i += 1)
if (dl_tbf->pdch[i])
dl_slots |= 1 << i;
TS alloc: properly count UL slots Add cycle to mark multiple allocated UL slots similar to the way we count DL slots in AllocTest. Until multislot UL allocation is implemented it does not affect test output. Change-Id: I2705405119421da3066c6c6bdd5830df4c133a36 Related: OS#2282
2017-09-11 08:38:59 +00:00
for (i = 0; ul_tbf && i < ARRAY_SIZE(ul_tbf->pdch); i += 1)
if (ul_tbf->pdch[i])
ul_slots |= 1 << i;
alloc/test: Use lower case for slots with TFI shortage Indicate those slots with lower case letters that do not have a spare TFI for the other direction if such a TBF has not been attached to the MS object yet. Sponsored-by: On-Waves ehf
2015-07-16 16:19:09 +00:00
for (i = 0; trx && i < ARRAY_SIZE(trx->pdch); i += 1) {
struct gprs_rlcmac_pdch *pdch = &trx->pdch[i];
if (ul_tbf && dl_tbf)
continue;
if (ul_tbf &&
Simplify TS alloc: use defines for constants * define and use constant for occupied TFI instead copying the same magic number all over the place * use libosmocore's define for bit pretty-printer Change-Id: I2699ceebf0cbec01652a02fa68ccc9e9419d0293 Related: OS#2282
2017-09-20 15:55:28 +00:00
pdch->assigned_tfi(GPRS_RLCMAC_DL_TBF) != NO_FREE_TFI)
alloc/test: Use lower case for slots with TFI shortage Indicate those slots with lower case letters that do not have a spare TFI for the other direction if such a TBF has not been attached to the MS object yet. Sponsored-by: On-Waves ehf
2015-07-16 16:19:09 +00:00
continue;
if (dl_tbf &&
Simplify TS alloc: use defines for constants * define and use constant for occupied TFI instead copying the same magic number all over the place * use libosmocore's define for bit pretty-printer Change-Id: I2699ceebf0cbec01652a02fa68ccc9e9419d0293 Related: OS#2282
2017-09-20 15:55:28 +00:00
pdch->assigned_tfi(GPRS_RLCMAC_UL_TBF) != NO_FREE_TFI)
alloc/test: Use lower case for slots with TFI shortage Indicate those slots with lower case letters that do not have a spare TFI for the other direction if such a TBF has not been attached to the MS object yet. Sponsored-by: On-Waves ehf
2015-07-16 16:19:09 +00:00
continue;
busy_slots |= 1 << i;
}
Simplify TS alloc: use defines for constants * define and use constant for occupied TFI instead copying the same magic number all over the place * use libosmocore's define for bit pretty-printer Change-Id: I2699ceebf0cbec01652a02fa68ccc9e9419d0293 Related: OS#2282
2017-09-20 15:55:28 +00:00
printf(" TBF[%d] class %d reserves " OSMO_BIT_SPEC "\n",
alloc/test: Add test for successive allocation This test allocates as many as possible UL/DL TBF pairs, shows their PDCH usage, and checks how many of them has been created successfully. Sponsored-by: On-Waves ehf
2015-06-29 10:19:52 +00:00
tfi, ms_class,
alloc/test: Use lower case for slots with TFI shortage Indicate those slots with lower case letters that do not have a spare TFI for the other direction if such a TBF has not been attached to the MS object yet. Sponsored-by: On-Waves ehf
2015-07-16 16:19:09 +00:00
get_dir_char(0x01, ul_slots, dl_slots, busy_slots),
get_dir_char(0x02, ul_slots, dl_slots, busy_slots),
get_dir_char(0x04, ul_slots, dl_slots, busy_slots),
get_dir_char(0x08, ul_slots, dl_slots, busy_slots),
get_dir_char(0x10, ul_slots, dl_slots, busy_slots),
get_dir_char(0x20, ul_slots, dl_slots, busy_slots),
get_dir_char(0x40, ul_slots, dl_slots, busy_slots),
get_dir_char(0x80, ul_slots, dl_slots, busy_slots));
alloc/test: Add test for successive allocation This test allocates as many as possible UL/DL TBF pairs, shows their PDCH usage, and checks how many of them has been created successfully. Sponsored-by: On-Waves ehf
2015-06-29 10:19:52 +00:00
alloc/test: Check for TFI conflicts This commit adds the check_tfi_usage function that checks the TFI usage. It iterates through all TBFs, records on which PDCH it uses which TFI and check for conflicts. It also checks the bits returned by pdch->assigned_tfi(). The latter suffers from an bug in that method (no separation of uplink and downlink), so a conditional fprintf is used instead of an assertion. The method tfi_find_free is checked for conflicts after allocations. Sponsored-by: On-Waves ehf
2015-07-09 09:35:50 +00:00
if (tfi >= 0) {
Convert GprsMS and helpers classes to C As we integrate osmo-pcu more and more with libosmocore features, it becomes really hard to use them since libosmocore relies heavily on C specific compilation features, which are not available in old C++ compilers (such as designated initializers for complex types in FSMs). GprsMs is right now a quite simple object since initial design of osmo-pcu made it optional and most of the logic was placed and stored duplicated in TBF objects. However, that's changing as we introduce more features, with the GprsMS class getting more weight. Hence, let's move it now to be a C struct in order to be able to easily use libosmocore features there, such as FSMs. Some helper classes which GprsMs uses are also mostly move to C since they are mostly structs with methods, so there's no point in having duplicated APIs for C++ and C for such simple cases. For some more complex classes, like (ul_,dl_)tbf, C API bindings are added where needed so that GprsMs can use functionalitites from that class. Most of those APIs can be kept afterwards and drop the C++ ones since they provide no benefit in general. Change-Id: I0b50e3367aaad9dcada76da97b438e452c8b230c
2020-12-16 14:59:45 +00:00
OSMO_ASSERT(ms_current_trx(ms));
Unify BTS into a C usable structure Previous work on BTS class started to get stuff out of the C++ struct into a C struct (BTS -> struct gprs_glcmac_bts) so that some parts of it were accessible from C code. Doing so, however, ended up being messy too, since all code needs to be switching from one object to another, which actually refer to the same logical component. Let's instead rejoin the structures and make sure the struct is accessible and usable from both C and C++ code by rewriting all methods to be C compatible and converting 3 allocated suboject as pointers. This way BTS can internally still use those C++ objects while providing a clean APi to both C and C++ code. Change-Id: I7d12c896c5ded659ca9d3bff4cf3a3fc857db9dd
2021-01-14 15:48:38 +00:00
tfi2 = bts_tfi_find_free(bts, dir, &trx_no2,
Convert GprsMS and helpers classes to C As we integrate osmo-pcu more and more with libosmocore features, it becomes really hard to use them since libosmocore relies heavily on C specific compilation features, which are not available in old C++ compilers (such as designated initializers for complex types in FSMs). GprsMs is right now a quite simple object since initial design of osmo-pcu made it optional and most of the logic was placed and stored duplicated in TBF objects. However, that's changing as we introduce more features, with the GprsMS class getting more weight. Hence, let's move it now to be a C struct in order to be able to easily use libosmocore features there, such as FSMs. Some helper classes which GprsMs uses are also mostly move to C since they are mostly structs with methods, so there's no point in having duplicated APIs for C++ and C for such simple cases. For some more complex classes, like (ul_,dl_)tbf, C API bindings are added where needed so that GprsMs can use functionalitites from that class. Most of those APIs can be kept afterwards and drop the C++ ones since they provide no benefit in general. Change-Id: I0b50e3367aaad9dcada76da97b438e452c8b230c
2020-12-16 14:59:45 +00:00
ms_current_trx(ms)->trx_no);
alloc/test: Check for TFI conflicts This commit adds the check_tfi_usage function that checks the TFI usage. It iterates through all TBFs, records on which PDCH it uses which TFI and check for conflicts. It also checks the bits returned by pdch->assigned_tfi(). The latter suffers from an bug in that method (no separation of uplink and downlink), so a conditional fprintf is used instead of an assertion. The method tfi_find_free is checked for conflicts after allocations. Sponsored-by: On-Waves ehf
2015-07-09 09:35:50 +00:00
OSMO_ASSERT(tfi != tfi2);
alloc/test: Fix trx_no assertion Currently the value of trx_no2 is used in the assertion, even if the call to tfi_find_free has failed. This commit fixes the asserted expression to only compare the trx_no values if the function call has succeeded. Sponsored-by: On-Waves ehf
2015-07-16 16:28:22 +00:00
OSMO_ASSERT(tfi2 < 0 ||
Convert GprsMS and helpers classes to C As we integrate osmo-pcu more and more with libosmocore features, it becomes really hard to use them since libosmocore relies heavily on C specific compilation features, which are not available in old C++ compilers (such as designated initializers for complex types in FSMs). GprsMs is right now a quite simple object since initial design of osmo-pcu made it optional and most of the logic was placed and stored duplicated in TBF objects. However, that's changing as we introduce more features, with the GprsMS class getting more weight. Hence, let's move it now to be a C struct in order to be able to easily use libosmocore features there, such as FSMs. Some helper classes which GprsMs uses are also mostly move to C since they are mostly structs with methods, so there's no point in having duplicated APIs for C++ and C for such simple cases. For some more complex classes, like (ul_,dl_)tbf, C API bindings are added where needed so that GprsMs can use functionalitites from that class. Most of those APIs can be kept afterwards and drop the C++ ones since they provide no benefit in general. Change-Id: I0b50e3367aaad9dcada76da97b438e452c8b230c
2020-12-16 14:59:45 +00:00
trx_no2 == ms_current_trx(ms)->trx_no);
alloc/test: Check for TFI conflicts This commit adds the check_tfi_usage function that checks the TFI usage. It iterates through all TBFs, records on which PDCH it uses which TFI and check for conflicts. It also checks the bits returned by pdch->assigned_tfi(). The latter suffers from an bug in that method (no separation of uplink and downlink), so a conditional fprintf is used instead of an assertion. The method tfi_find_free is checked for conflicts after allocations. Sponsored-by: On-Waves ehf
2015-07-09 09:35:50 +00:00
}
alloc/test: Add test for successive allocation This test allocates as many as possible UL/DL TBF pairs, shows their PDCH usage, and checks how many of them has been created successfully. Sponsored-by: On-Waves ehf
2015-06-29 10:19:52 +00:00
ms_class += 1;
if (ms_class > max_class)
ms_class = min_class;
}
alloc/test: Put TBF allocation loop into alloc_many_tbfs Currently all TBFs are deleted after the allocation loop finishes. This make it difficult to interleave the TBF allocation like it happens with real MS. This commit refactors the allocation loop into alloc_many_tbfs and adds support for TLLIs, which are derived from the counter value and used to retrieve an old MS object if alloc_many_tbfs is called a second time. Note that this does not make a difference for the existing tests. Sponsored-by: On-Waves ehf
2015-07-13 12:38:18 +00:00
return counter;
}
Remove uneeded ms param from alloc_algorithm_func_t func Since a while ago, the data architecture was changed so that TBF is guaranteed to always have a MS object associated. Hence, it makes no sense to pass the MS object as a separate param as we can take it from tbf object and makes code less confusing. Change-Id: Idc0c76cf6f007afa4236480cdad0d8e99dabec5f
2021-02-25 17:08:10 +00:00
static void test_successive_allocation(alloc_algorithm_func_t algo, unsigned min_class,
alloc/test: Put TBF allocation loop into alloc_many_tbfs Currently all TBFs are deleted after the allocation loop finishes. This make it difficult to interleave the TBF allocation like it happens with real MS. This commit refactors the allocation loop into alloc_many_tbfs and adds support for TLLIs, which are derived from the counter value and used to retrieve an old MS object if alloc_many_tbfs is called a second time. Note that this does not make a difference for the existing tests. Sponsored-by: On-Waves ehf
2015-07-13 12:38:18 +00:00
unsigned max_class, enum test_mode mode,
unsigned expect_num, const char *text)
{
Allow multiple bts objects in PCU This patch doesn't really tests whether osmo-pcu can work on a multi-bts environment, but it prepares the data structures to be able to do so at any later point in time. Change-Id: I6b10913f46c19d438c4e250a436a7446694b725a
2021-01-18 16:14:14 +00:00
struct gprs_rlcmac_bts *bts = bts_alloc(the_pcu, 0);
alloc/test: Put TBF allocation loop into alloc_many_tbfs Currently all TBFs are deleted after the allocation loop finishes. This make it difficult to interleave the TBF allocation like it happens with real MS. This commit refactors the allocation loop into alloc_many_tbfs and adds support for TLLIs, which are derived from the counter value and used to retrieve an old MS object if alloc_many_tbfs is called a second time. Note that this does not make a difference for the existing tests. Sponsored-by: On-Waves ehf
2015-07-13 12:38:18 +00:00
struct gprs_rlcmac_trx *trx;
unsigned counter;
AllocTest: expand test output * print MS classes * unify and print test mode description * print additional info on test completion This only changes meta info about test run but not the actual test output. Change-Id: I30a4b8f561a9677f4e9ded33a051a249bd15a6a2 Related: OS#2282
2017-11-27 12:21:41 +00:00
printf("Going to test assignment with many TBF, algorithm %s class %u..%u (%s)\n",
text, min_class, max_class, test_mode_descr(mode));
alloc/test: Put TBF allocation loop into alloc_many_tbfs Currently all TBFs are deleted after the allocation loop finishes. This make it difficult to interleave the TBF allocation like it happens with real MS. This commit refactors the allocation loop into alloc_many_tbfs and adds support for TLLIs, which are derived from the counter value and used to retrieve an old MS object if alloc_many_tbfs is called a second time. Note that this does not make a difference for the existing tests. Sponsored-by: On-Waves ehf
2015-07-13 12:38:18 +00:00
Split PCU global PCU object from BTS object Currently the BTS object (and gprs_rlcmac_bts struct) are used to hold both PCU global fields and BTS specific fields, all mangled together. The BTS is even accessed in lots of places by means of a singleton. This patch introduces a new struct gprs_pcu object aimed at holding all global state, and several fields are already moved from BTS to it. The new object can be accessed as global variable "the_pcu", reusing and including an already exisitng "the_pcu" global variable only used for bssgp related purposes so far. This is only a first step towards having a complete split global pcu and BTS, some fields are still kept in BTS and will be moved over follow-up smaller patches in the future (since this patch is already quite big). So far, the code still only supports one BTS, which can be accessed using the_pcu->bts. In the future that field will be replaced with a list, and the BTS singletons will be removed. The cur_fn output changes in TbfTest are actually a side effect fix, since the singleton main_bts() now points internally to the_pcu->bts, hence the same we allocate and assign in the test. Beforehand, "the_bts" was allocated in the stack while main_bts() still returned an unrelated singleton BTS object instance. Related: OS#4935 Change-Id: I88e3c6471b80245ce3798223f1a61190f14aa840
2021-01-13 17:54:38 +00:00
the_pcu->alloc_algorithm = algo;
alloc/test: Put TBF allocation loop into alloc_many_tbfs Currently all TBFs are deleted after the allocation loop finishes. This make it difficult to interleave the TBF allocation like it happens with real MS. This commit refactors the allocation loop into alloc_many_tbfs and adds support for TLLIs, which are derived from the counter value and used to retrieve an old MS object if alloc_many_tbfs is called a second time. Note that this does not make a difference for the existing tests. Sponsored-by: On-Waves ehf
2015-07-13 12:38:18 +00:00
trx = &bts->trx[0];
trx->pdch[3].enable();
trx->pdch[4].enable();
trx->pdch[5].enable();
trx->pdch[6].enable();
trx->pdch[7].enable();
Unify BTS into a C usable structure Previous work on BTS class started to get stuff out of the C++ struct into a C struct (BTS -> struct gprs_glcmac_bts) so that some parts of it were accessible from C code. Doing so, however, ended up being messy too, since all code needs to be switching from one object to another, which actually refer to the same logical component. Let's instead rejoin the structures and make sure the struct is accessible and usable from both C and C++ code by rewriting all methods to be C compatible and converting 3 allocated suboject as pointers. This way BTS can internally still use those C++ objects while providing a clean APi to both C and C++ code. Change-Id: I7d12c896c5ded659ca9d3bff4cf3a3fc857db9dd
2021-01-14 15:48:38 +00:00
counter = alloc_many_tbfs(bts, min_class, max_class, mode);
alloc/test: Put TBF allocation loop into alloc_many_tbfs Currently all TBFs are deleted after the allocation loop finishes. This make it difficult to interleave the TBF allocation like it happens with real MS. This commit refactors the allocation loop into alloc_many_tbfs and adds support for TLLIs, which are derived from the counter value and used to retrieve an old MS object if alloc_many_tbfs is called a second time. Note that this does not make a difference for the existing tests. Sponsored-by: On-Waves ehf
2015-07-13 12:38:18 +00:00
AllocTest: expand test output * print MS classes * unify and print test mode description * print additional info on test completion This only changes meta info about test run but not the actual test output. Change-Id: I30a4b8f561a9677f4e9ded33a051a249bd15a6a2 Related: OS#2282
2017-11-27 12:21:41 +00:00
printf(" Successfully allocated %u UL TBFs, algorithm %s class %u..%u (%s)\n",
counter, text, min_class, max_class, test_mode_descr(mode));
alloc/test: Show expectation before failure To simplify debugging, show the actuals value before the assertion fails in some cases. Sponsored-by: On-Waves ehf
2015-07-16 13:01:38 +00:00
if (counter != expect_num)
AllocTest: expand test output * print MS classes * unify and print test mode description * print additional info on test completion This only changes meta info about test run but not the actual test output. Change-Id: I30a4b8f561a9677f4e9ded33a051a249bd15a6a2 Related: OS#2282
2017-11-27 12:21:41 +00:00
fprintf(stderr, " Expected %u TBFs (got %u), algorithm %s class %u..%u (%s)\n",
expect_num, counter, text, min_class, max_class, test_mode_descr(mode));
alloc/test: Show expectation before failure To simplify debugging, show the actuals value before the assertion fails in some cases. Sponsored-by: On-Waves ehf
2015-07-16 13:01:38 +00:00
alloc: Load balancing for algo A Currently only the first enabled PDCH will be used. Beside the throughput this will also limit the number of TBFs: - number of UL TBFs <= 7 - number of DL TBFs <= 32 This commit changes the allocation algorithm to use the PDCH with the least number of attached TBFs. This will improve the troughput in both directions and the UL limits: - number of UL TBFs <= min(32, N_PDCH * 7) UL TBFs Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 14:35:38 +00:00
OSMO_ASSERT(counter == expect_num);
alloc: Allocate TFI per slot (algorithm A) Currently the TFI are managed per TRX, thus only a maximum of 32 TBF per direction and per TRX are possible simultaneously. This commit modifies algorithm_a() to allow the sharing of TFI between different PDCH. Since algorithm A only assigns a single slot to each TBF, the TFI of each PDCH can be assigned independently. This increases the maximum to 32 TBF per direction and per PDCH concerning the TFI allocation. Ticket: #1793 Sponsored-by: On-Waves ehf
2015-07-10 10:25:25 +00:00
Unify BTS into a C usable structure Previous work on BTS class started to get stuff out of the C++ struct into a C struct (BTS -> struct gprs_glcmac_bts) so that some parts of it were accessible from C code. Doing so, however, ended up being messy too, since all code needs to be switching from one object to another, which actually refer to the same logical component. Let's instead rejoin the structures and make sure the struct is accessible and usable from both C and C++ code by rewriting all methods to be C compatible and converting 3 allocated suboject as pointers. This way BTS can internally still use those C++ objects while providing a clean APi to both C and C++ code. Change-Id: I7d12c896c5ded659ca9d3bff4cf3a3fc857db9dd
2021-01-14 15:48:38 +00:00
check_tfi_usage(bts);
talloc_free(bts);
alloc/test: Add test for successive allocation This test allocates as many as possible UL/DL TBF pairs, shows their PDCH usage, and checks how many of them has been created successfully. Sponsored-by: On-Waves ehf
2015-06-29 10:19:52 +00:00
}
Remove uneeded ms param from alloc_algorithm_func_t func Since a while ago, the data architecture was changed so that TBF is guaranteed to always have a MS object associated. Hence, it makes no sense to pass the MS object as a separate param as we can take it from tbf object and makes code less confusing. Change-Id: Idc0c76cf6f007afa4236480cdad0d8e99dabec5f
2021-02-25 17:08:10 +00:00
static void test_many_connections(alloc_algorithm_func_t algo, unsigned expect_num,
alloc/test: Add test for interleaved TBF chains MS iniated TCP connections generally result in a sequence of short time UL and longer lasting DL TBFs, being interleaved between several MS. This scenario is not covered by the existing tests. This commit adds a test, that allocates as man as possible TBFs several times with different test modes without clearing the BTS (and thus the TBF list) in between. The number of allocated DL TBFs in each round is expected to be constant. Sponsored-by: On-Waves ehf
2015-07-13 12:50:08 +00:00
const char *text)
{
Allow multiple bts objects in PCU This patch doesn't really tests whether osmo-pcu can work on a multi-bts environment, but it prepares the data structures to be able to do so at any later point in time. Change-Id: I6b10913f46c19d438c4e250a436a7446694b725a
2021-01-18 16:14:14 +00:00
struct gprs_rlcmac_bts *bts = bts_alloc(the_pcu, 0);
alloc/test: Add test for interleaved TBF chains MS iniated TCP connections generally result in a sequence of short time UL and longer lasting DL TBFs, being interleaved between several MS. This scenario is not covered by the existing tests. This commit adds a test, that allocates as man as possible TBFs several times with different test modes without clearing the BTS (and thus the TBF list) in between. The number of allocated DL TBFs in each round is expected to be constant. Sponsored-by: On-Waves ehf
2015-07-13 12:50:08 +00:00
struct gprs_rlcmac_trx *trx;
int counter1, counter2 = -1;
unsigned i;
enum test_mode mode_seq[] = {
TEST_MODE_DL_AFTER_UL,
TEST_MODE_UL_ONLY,
TEST_MODE_DL_AFTER_UL,
TEST_MODE_DL_ONLY,
};
AllocTest: expand test output * print MS classes * unify and print test mode description * print additional info on test completion This only changes meta info about test run but not the actual test output. Change-Id: I30a4b8f561a9677f4e9ded33a051a249bd15a6a2 Related: OS#2282
2017-11-27 12:21:41 +00:00
printf("Going to test assignment with many connections, algorithm %s\n", text);
alloc/test: Add test for interleaved TBF chains MS iniated TCP connections generally result in a sequence of short time UL and longer lasting DL TBFs, being interleaved between several MS. This scenario is not covered by the existing tests. This commit adds a test, that allocates as man as possible TBFs several times with different test modes without clearing the BTS (and thus the TBF list) in between. The number of allocated DL TBFs in each round is expected to be constant. Sponsored-by: On-Waves ehf
2015-07-13 12:50:08 +00:00
Split PCU global PCU object from BTS object Currently the BTS object (and gprs_rlcmac_bts struct) are used to hold both PCU global fields and BTS specific fields, all mangled together. The BTS is even accessed in lots of places by means of a singleton. This patch introduces a new struct gprs_pcu object aimed at holding all global state, and several fields are already moved from BTS to it. The new object can be accessed as global variable "the_pcu", reusing and including an already exisitng "the_pcu" global variable only used for bssgp related purposes so far. This is only a first step towards having a complete split global pcu and BTS, some fields are still kept in BTS and will be moved over follow-up smaller patches in the future (since this patch is already quite big). So far, the code still only supports one BTS, which can be accessed using the_pcu->bts. In the future that field will be replaced with a list, and the BTS singletons will be removed. The cur_fn output changes in TbfTest are actually a side effect fix, since the singleton main_bts() now points internally to the_pcu->bts, hence the same we allocate and assign in the test. Beforehand, "the_bts" was allocated in the stack while main_bts() still returned an unrelated singleton BTS object instance. Related: OS#4935 Change-Id: I88e3c6471b80245ce3798223f1a61190f14aa840
2021-01-13 17:54:38 +00:00
the_pcu->alloc_algorithm = algo;
alloc/test: Add test for interleaved TBF chains MS iniated TCP connections generally result in a sequence of short time UL and longer lasting DL TBFs, being interleaved between several MS. This scenario is not covered by the existing tests. This commit adds a test, that allocates as man as possible TBFs several times with different test modes without clearing the BTS (and thus the TBF list) in between. The number of allocated DL TBFs in each round is expected to be constant. Sponsored-by: On-Waves ehf
2015-07-13 12:50:08 +00:00
trx = &bts->trx[0];
trx->pdch[3].enable();
trx->pdch[4].enable();
trx->pdch[5].enable();
trx->pdch[6].enable();
trx->pdch[7].enable();
for (i = 0; i < ARRAY_SIZE(mode_seq); i += 1) {
Unify BTS into a C usable structure Previous work on BTS class started to get stuff out of the C++ struct into a C struct (BTS -> struct gprs_glcmac_bts) so that some parts of it were accessible from C code. Doing so, however, ended up being messy too, since all code needs to be switching from one object to another, which actually refer to the same logical component. Let's instead rejoin the structures and make sure the struct is accessible and usable from both C and C++ code by rewriting all methods to be C compatible and converting 3 allocated suboject as pointers. This way BTS can internally still use those C++ objects while providing a clean APi to both C and C++ code. Change-Id: I7d12c896c5ded659ca9d3bff4cf3a3fc857db9dd
2021-01-14 15:48:38 +00:00
counter1 = alloc_many_tbfs(bts, 1, mslot_class_max(), mode_seq[i]);
alloc/test: Add test for interleaved TBF chains MS iniated TCP connections generally result in a sequence of short time UL and longer lasting DL TBFs, being interleaved between several MS. This scenario is not covered by the existing tests. This commit adds a test, that allocates as man as possible TBFs several times with different test modes without clearing the BTS (and thus the TBF list) in between. The number of allocated DL TBFs in each round is expected to be constant. Sponsored-by: On-Waves ehf
2015-07-13 12:50:08 +00:00
fprintf(stderr, " Allocated %d TBFs (previously %d)\n",
counter1, counter2);
Unify BTS into a C usable structure Previous work on BTS class started to get stuff out of the C++ struct into a C struct (BTS -> struct gprs_glcmac_bts) so that some parts of it were accessible from C code. Doing so, however, ended up being messy too, since all code needs to be switching from one object to another, which actually refer to the same logical component. Let's instead rejoin the structures and make sure the struct is accessible and usable from both C and C++ code by rewriting all methods to be C compatible and converting 3 allocated suboject as pointers. This way BTS can internally still use those C++ objects while providing a clean APi to both C and C++ code. Change-Id: I7d12c896c5ded659ca9d3bff4cf3a3fc857db9dd
2021-01-14 15:48:38 +00:00
check_tfi_usage(bts);
alloc/test: Add test for interleaved TBF chains MS iniated TCP connections generally result in a sequence of short time UL and longer lasting DL TBFs, being interleaved between several MS. This scenario is not covered by the existing tests. This commit adds a test, that allocates as man as possible TBFs several times with different test modes without clearing the BTS (and thus the TBF list) in between. The number of allocated DL TBFs in each round is expected to be constant. Sponsored-by: On-Waves ehf
2015-07-13 12:50:08 +00:00
/* This will stop earlier due to USF shortage */
if (mode_seq[i] == TEST_MODE_UL_ONLY)
continue;
alloc/test: Show expectation before failure To simplify debugging, show the actuals value before the assertion fails in some cases. Sponsored-by: On-Waves ehf
2015-07-16 13:01:38 +00:00
if (counter2 >= 0) {
if (counter1 < counter2)
fprintf(stderr, " Expected %d >= %d in %s\n",
counter1, counter2, text);
alloc/test: Add test for interleaved TBF chains MS iniated TCP connections generally result in a sequence of short time UL and longer lasting DL TBFs, being interleaved between several MS. This scenario is not covered by the existing tests. This commit adds a test, that allocates as man as possible TBFs several times with different test modes without clearing the BTS (and thus the TBF list) in between. The number of allocated DL TBFs in each round is expected to be constant. Sponsored-by: On-Waves ehf
2015-07-13 12:50:08 +00:00
OSMO_ASSERT(counter1 >= counter2);
alloc/test: Show expectation before failure To simplify debugging, show the actuals value before the assertion fails in some cases. Sponsored-by: On-Waves ehf
2015-07-16 13:01:38 +00:00
}
alloc/test: Add test for interleaved TBF chains MS iniated TCP connections generally result in a sequence of short time UL and longer lasting DL TBFs, being interleaved between several MS. This scenario is not covered by the existing tests. This commit adds a test, that allocates as man as possible TBFs several times with different test modes without clearing the BTS (and thus the TBF list) in between. The number of allocated DL TBFs in each round is expected to be constant. Sponsored-by: On-Waves ehf
2015-07-13 12:50:08 +00:00
counter2 = counter1;
}
printf(" Successfully allocated %d TBFs\n", counter1);
alloc/test: Show expectation before failure To simplify debugging, show the actuals value before the assertion fails in some cases. Sponsored-by: On-Waves ehf
2015-07-16 13:01:38 +00:00
if (counter1 != (int)expect_num)
AllocTest: expand test output * print MS classes * unify and print test mode description * print additional info on test completion This only changes meta info about test run but not the actual test output. Change-Id: I30a4b8f561a9677f4e9ded33a051a249bd15a6a2 Related: OS#2282
2017-11-27 12:21:41 +00:00
fprintf(stderr, " Expected %d TBFs (got %d) for algorithm %s\n", expect_num, counter1, text);
alloc/test: Add test for interleaved TBF chains MS iniated TCP connections generally result in a sequence of short time UL and longer lasting DL TBFs, being interleaved between several MS. This scenario is not covered by the existing tests. This commit adds a test, that allocates as man as possible TBFs several times with different test modes without clearing the BTS (and thus the TBF list) in between. The number of allocated DL TBFs in each round is expected to be constant. Sponsored-by: On-Waves ehf
2015-07-13 12:50:08 +00:00
OSMO_ASSERT(expect_num == (unsigned)counter1);
Unify BTS into a C usable structure Previous work on BTS class started to get stuff out of the C++ struct into a C struct (BTS -> struct gprs_glcmac_bts) so that some parts of it were accessible from C code. Doing so, however, ended up being messy too, since all code needs to be switching from one object to another, which actually refer to the same logical component. Let's instead rejoin the structures and make sure the struct is accessible and usable from both C and C++ code by rewriting all methods to be C compatible and converting 3 allocated suboject as pointers. This way BTS can internally still use those C++ objects while providing a clean APi to both C and C++ code. Change-Id: I7d12c896c5ded659ca9d3bff4cf3a3fc857db9dd
2021-01-14 15:48:38 +00:00
talloc_free(bts);
alloc/test: Add test for interleaved TBF chains MS iniated TCP connections generally result in a sequence of short time UL and longer lasting DL TBFs, being interleaved between several MS. This scenario is not covered by the existing tests. This commit adds a test, that allocates as man as possible TBFs several times with different test modes without clearing the BTS (and thus the TBF list) in between. The number of allocated DL TBFs in each round is expected to be constant. Sponsored-by: On-Waves ehf
2015-07-13 12:50:08 +00:00
}
AllocTest: expand test output * print MS classes * unify and print test mode description * print additional info on test completion This only changes meta info about test run but not the actual test output. Change-Id: I30a4b8f561a9677f4e9ded33a051a249bd15a6a2 Related: OS#2282
2017-11-27 12:21:41 +00:00
static inline void test_a_b_dyn(enum test_mode mode, uint8_t exp_A, uint8_t exp_B, uint8_t exp_dyn)
alloc/test: Add test for successive allocation This test allocates as many as possible UL/DL TBF pairs, shows their PDCH usage, and checks how many of them has been created successfully. Sponsored-by: On-Waves ehf
2015-06-29 10:19:52 +00:00
{
AllocTest: expand test output * print MS classes * unify and print test mode description * print additional info on test completion This only changes meta info about test run but not the actual test output. Change-Id: I30a4b8f561a9677f4e9ded33a051a249bd15a6a2 Related: OS#2282
2017-11-27 12:21:41 +00:00
test_successive_allocation(alloc_algorithm_a, 1, 1, mode, exp_A, "A");
test_successive_allocation(alloc_algorithm_b, 10, 10, mode, exp_B, "B");
test_successive_allocation(alloc_algorithm_dynamic, 10, 10, mode, exp_dyn, "dynamic");
alloc/test: Add test for successive allocation This test allocates as many as possible UL/DL TBF pairs, shows their PDCH usage, and checks how many of them has been created successfully. Sponsored-by: On-Waves ehf
2015-06-29 10:19:52 +00:00
}
AllocTest: expand test output * print MS classes * unify and print test mode description * print additional info on test completion This only changes meta info about test run but not the actual test output. Change-Id: I30a4b8f561a9677f4e9ded33a051a249bd15a6a2 Related: OS#2282
2017-11-27 12:21:41 +00:00
static void test_successive_allocations()
alloc/test: Add test for interleaved TBF chains MS iniated TCP connections generally result in a sequence of short time UL and longer lasting DL TBFs, being interleaved between several MS. This scenario is not covered by the existing tests. This commit adds a test, that allocates as man as possible TBFs several times with different test modes without clearing the BTS (and thus the TBF list) in between. The number of allocated DL TBFs in each round is expected to be constant. Sponsored-by: On-Waves ehf
2015-07-13 12:50:08 +00:00
{
AllocTest: expand test output * print MS classes * unify and print test mode description * print additional info on test completion This only changes meta info about test run but not the actual test output. Change-Id: I30a4b8f561a9677f4e9ded33a051a249bd15a6a2 Related: OS#2282
2017-11-27 12:21:41 +00:00
test_successive_allocation(alloc_algorithm_a, 1, 1, TEST_MODE_UL_AND_DL, 35, "A");
Support uplink multi-slot allocations Before this patch, allocate_usf() was implemented to only allocate 1 USF per TBF, regardless of the available ul_slot mask. As a result, only 1 slot at max was allocated to any TBF. That's a pity because usual multislot classes like 12 support up to 2 UL slots per TBF (in common TS with DL). This patch reworks allocate_usf() to allocate as many UL multislots as possible (given mslot class, current USF availability, TFI availability, related DL TBF slots for the same MS, etc.). As a result, it can be seen that AllocTest results change substantially and maximum concurrent TBF allocation drops under some conditions. That happens due to more USFs being reserved (because each TBF has now more UL slots reserved). Hence now USF exhaustion becomes the usual limitation factor as per the number of concurrent TBFs than can be handled per TRX (as opposed to TFIs previously). Some of the biggest limitations in test appear though because really high end multislot classes are used, which can consume high volumes of UL slots (USFs), and which are probably not the most extended devices in the field. Moreover, in general the curren timeslot allocator for a given multislot class will in general try to optimize the DL side gathering most of the possible timeslots there. That means, for instance on ms class 12 (4 Tx, 4Rx, 5 Sum), 4 DL slots and 1 UL slot will still be selected. But in the case where only 3 PDCHs are available, then with this new multi-slot UL support a TBF will reserve 3 DL slots and 2 UL slots, while before this patch it would only taken 1 UL slot instead of 2. This USF exhaustion situation can be improved in the future by parametrizing (VTY command?) the maximum amount of UL slots that a TBF can reserve, making for instance a default value of 2, meaning usual classes can gather up 2 UL timelosts at a time while forbidding high-end hungry classes to gather up to 8 UL timeslots. Another approach would be to dynamically limit the amount of allowed reservable UL timeslots based on current USF reservation load. Related: OS#2282 Change-Id: Id97cc6e3b769511b591b1694549e0dac55227c43
2021-02-22 16:20:15 +00:00
test_successive_allocation(alloc_algorithm_b, 10, 10, TEST_MODE_UL_AND_DL, 15, "B");
test_successive_allocation(alloc_algorithm_b, 12, 12, TEST_MODE_UL_AND_DL, 15, "B");
AllocTest: expand test output * print MS classes * unify and print test mode description * print additional info on test completion This only changes meta info about test run but not the actual test output. Change-Id: I30a4b8f561a9677f4e9ded33a051a249bd15a6a2 Related: OS#2282
2017-11-27 12:21:41 +00:00
Support uplink multi-slot allocations Before this patch, allocate_usf() was implemented to only allocate 1 USF per TBF, regardless of the available ul_slot mask. As a result, only 1 slot at max was allocated to any TBF. That's a pity because usual multislot classes like 12 support up to 2 UL slots per TBF (in common TS with DL). This patch reworks allocate_usf() to allocate as many UL multislots as possible (given mslot class, current USF availability, TFI availability, related DL TBF slots for the same MS, etc.). As a result, it can be seen that AllocTest results change substantially and maximum concurrent TBF allocation drops under some conditions. That happens due to more USFs being reserved (because each TBF has now more UL slots reserved). Hence now USF exhaustion becomes the usual limitation factor as per the number of concurrent TBFs than can be handled per TRX (as opposed to TFIs previously). Some of the biggest limitations in test appear though because really high end multislot classes are used, which can consume high volumes of UL slots (USFs), and which are probably not the most extended devices in the field. Moreover, in general the curren timeslot allocator for a given multislot class will in general try to optimize the DL side gathering most of the possible timeslots there. That means, for instance on ms class 12 (4 Tx, 4Rx, 5 Sum), 4 DL slots and 1 UL slot will still be selected. But in the case where only 3 PDCHs are available, then with this new multi-slot UL support a TBF will reserve 3 DL slots and 2 UL slots, while before this patch it would only taken 1 UL slot instead of 2. This USF exhaustion situation can be improved in the future by parametrizing (VTY command?) the maximum amount of UL slots that a TBF can reserve, making for instance a default value of 2, meaning usual classes can gather up 2 UL timelosts at a time while forbidding high-end hungry classes to gather up to 8 UL timeslots. Another approach would be to dynamically limit the amount of allowed reservable UL timeslots based on current USF reservation load. Related: OS#2282 Change-Id: Id97cc6e3b769511b591b1694549e0dac55227c43
2021-02-22 16:20:15 +00:00
test_successive_allocation(alloc_algorithm_b, 1, 12, TEST_MODE_UL_AND_DL, 23, "B");
test_successive_allocation(alloc_algorithm_b, 1, mslot_class_max(), TEST_MODE_UL_AND_DL, 17, "B");
test_successive_allocation(alloc_algorithm_dynamic, 1, mslot_class_max(), TEST_MODE_UL_AND_DL, 17, "dynamic");
AllocTest: expand test output * print MS classes * unify and print test mode description * print additional info on test completion This only changes meta info about test run but not the actual test output. Change-Id: I30a4b8f561a9677f4e9ded33a051a249bd15a6a2 Related: OS#2282
2017-11-27 12:21:41 +00:00
Support uplink multi-slot allocations Before this patch, allocate_usf() was implemented to only allocate 1 USF per TBF, regardless of the available ul_slot mask. As a result, only 1 slot at max was allocated to any TBF. That's a pity because usual multislot classes like 12 support up to 2 UL slots per TBF (in common TS with DL). This patch reworks allocate_usf() to allocate as many UL multislots as possible (given mslot class, current USF availability, TFI availability, related DL TBF slots for the same MS, etc.). As a result, it can be seen that AllocTest results change substantially and maximum concurrent TBF allocation drops under some conditions. That happens due to more USFs being reserved (because each TBF has now more UL slots reserved). Hence now USF exhaustion becomes the usual limitation factor as per the number of concurrent TBFs than can be handled per TRX (as opposed to TFIs previously). Some of the biggest limitations in test appear though because really high end multislot classes are used, which can consume high volumes of UL slots (USFs), and which are probably not the most extended devices in the field. Moreover, in general the curren timeslot allocator for a given multislot class will in general try to optimize the DL side gathering most of the possible timeslots there. That means, for instance on ms class 12 (4 Tx, 4Rx, 5 Sum), 4 DL slots and 1 UL slot will still be selected. But in the case where only 3 PDCHs are available, then with this new multi-slot UL support a TBF will reserve 3 DL slots and 2 UL slots, while before this patch it would only taken 1 UL slot instead of 2. This USF exhaustion situation can be improved in the future by parametrizing (VTY command?) the maximum amount of UL slots that a TBF can reserve, making for instance a default value of 2, meaning usual classes can gather up 2 UL timelosts at a time while forbidding high-end hungry classes to gather up to 8 UL timeslots. Another approach would be to dynamically limit the amount of allowed reservable UL timeslots based on current USF reservation load. Related: OS#2282 Change-Id: Id97cc6e3b769511b591b1694549e0dac55227c43
2021-02-22 16:20:15 +00:00
test_a_b_dyn(TEST_MODE_DL_AND_UL, 35, 15, 15);
test_a_b_dyn(TEST_MODE_DL_AFTER_UL, 160, 32, 101);
test_a_b_dyn(TEST_MODE_UL_AFTER_DL, 35, 15, 15);
test_a_b_dyn(TEST_MODE_UL_ONLY, 35, 15, 21);
AllocTest: expand test output * print MS classes * unify and print test mode description * print additional info on test completion This only changes meta info about test run but not the actual test output. Change-Id: I30a4b8f561a9677f4e9ded33a051a249bd15a6a2 Related: OS#2282
2017-11-27 12:21:41 +00:00
test_a_b_dyn(TEST_MODE_DL_ONLY, 160, 32, 101);
alloc/test: Add test for interleaved TBF chains MS iniated TCP connections generally result in a sequence of short time UL and longer lasting DL TBFs, being interleaved between several MS. This scenario is not covered by the existing tests. This commit adds a test, that allocates as man as possible TBFs several times with different test modes without clearing the BTS (and thus the TBF list) in between. The number of allocated DL TBFs in each round is expected to be constant. Sponsored-by: On-Waves ehf
2015-07-13 12:50:08 +00:00
}
DL TS allocation: add test case to show TS allocation bug for 2nd DL TBF This patch adds a test case test_2_consecutive_dl_tbfs which expects a current bug with TS allocation for 2nd DL TBF. The test's expectation is corrected along with the bug fix in a subsequent commit Related: OS#1792 Change-Id: I890e4fbb2b64037e051433e70082a197e2a929a6
2016-09-06 12:45:45 +00:00
static void test_2_consecutive_dl_tbfs()
{
Allow multiple bts objects in PCU This patch doesn't really tests whether osmo-pcu can work on a multi-bts environment, but it prepares the data structures to be able to do so at any later point in time. Change-Id: I6b10913f46c19d438c4e250a436a7446694b725a
2021-01-18 16:14:14 +00:00
struct gprs_rlcmac_bts *bts = bts_alloc(the_pcu, 0);
Expect ms object to exist before calling tbf_alloc_dl_tbf() Same as previous commit, this time for the DL counterpart. Change-Id: I87f6cdf8288a688466020bda0874e68b57aa71c4
2020-05-08 16:15:59 +00:00
GprsMs *ms;
DL TS allocation: add test case to show TS allocation bug for 2nd DL TBF This patch adds a test case test_2_consecutive_dl_tbfs which expects a current bug with TS allocation for 2nd DL TBF. The test's expectation is corrected along with the bug fix in a subsequent commit Related: OS#1792 Change-Id: I890e4fbb2b64037e051433e70082a197e2a929a6
2016-09-06 12:45:45 +00:00
struct gprs_rlcmac_trx *trx;
uint8_t ms_class = 11;
uint8_t egprs_ms_class = 11;
gprs_rlcmac_tbf *dl_tbf1, *dl_tbf2;
uint8_t numTs1 = 0, numTs2 = 0;
printf("Testing DL TS allocation for Multi UEs\n");
Split PCU global PCU object from BTS object Currently the BTS object (and gprs_rlcmac_bts struct) are used to hold both PCU global fields and BTS specific fields, all mangled together. The BTS is even accessed in lots of places by means of a singleton. This patch introduces a new struct gprs_pcu object aimed at holding all global state, and several fields are already moved from BTS to it. The new object can be accessed as global variable "the_pcu", reusing and including an already exisitng "the_pcu" global variable only used for bssgp related purposes so far. This is only a first step towards having a complete split global pcu and BTS, some fields are still kept in BTS and will be moved over follow-up smaller patches in the future (since this patch is already quite big). So far, the code still only supports one BTS, which can be accessed using the_pcu->bts. In the future that field will be replaced with a list, and the BTS singletons will be removed. The cur_fn output changes in TbfTest are actually a side effect fix, since the singleton main_bts() now points internally to the_pcu->bts, hence the same we allocate and assign in the test. Beforehand, "the_bts" was allocated in the stack while main_bts() still returned an unrelated singleton BTS object instance. Related: OS#4935 Change-Id: I88e3c6471b80245ce3798223f1a61190f14aa840
2021-01-13 17:54:38 +00:00
the_pcu->alloc_algorithm = alloc_algorithm_b;
DL TS allocation: add test case to show TS allocation bug for 2nd DL TBF This patch adds a test case test_2_consecutive_dl_tbfs which expects a current bug with TS allocation for 2nd DL TBF. The test's expectation is corrected along with the bug fix in a subsequent commit Related: OS#1792 Change-Id: I890e4fbb2b64037e051433e70082a197e2a929a6
2016-09-06 12:45:45 +00:00
trx = &bts->trx[0];
trx->pdch[4].enable();
trx->pdch[5].enable();
trx->pdch[6].enable();
trx->pdch[7].enable();
Unify BTS into a C usable structure Previous work on BTS class started to get stuff out of the C++ struct into a C struct (BTS -> struct gprs_glcmac_bts) so that some parts of it were accessible from C code. Doing so, however, ended up being messy too, since all code needs to be switching from one object to another, which actually refer to the same logical component. Let's instead rejoin the structures and make sure the struct is accessible and usable from both C and C++ code by rewriting all methods to be C compatible and converting 3 allocated suboject as pointers. This way BTS can internally still use those C++ objects while providing a clean APi to both C and C++ code. Change-Id: I7d12c896c5ded659ca9d3bff4cf3a3fc857db9dd
2021-01-14 15:48:38 +00:00
ms = bts_alloc_ms(bts, ms_class, egprs_ms_class);
Expect ms object to exist before calling tbf_alloc_dl_tbf() Same as previous commit, this time for the DL counterpart. Change-Id: I87f6cdf8288a688466020bda0874e68b57aa71c4
2020-05-08 16:15:59 +00:00
dl_tbf1 = tbf_alloc_dl_tbf(bts, ms, 0, false);
DL TS allocation: add test case to show TS allocation bug for 2nd DL TBF This patch adds a test case test_2_consecutive_dl_tbfs which expects a current bug with TS allocation for 2nd DL TBF. The test's expectation is corrected along with the bug fix in a subsequent commit Related: OS#1792 Change-Id: I890e4fbb2b64037e051433e70082a197e2a929a6
2016-09-06 12:45:45 +00:00
OSMO_ASSERT(dl_tbf1);
for (int i = 0; i < 8; i++) {
if (dl_tbf1->pdch[i])
numTs1++;
}
OSMO_ASSERT(numTs1 == 4);
printf("TBF1: numTs(%d)\n", numTs1);
Unify BTS into a C usable structure Previous work on BTS class started to get stuff out of the C++ struct into a C struct (BTS -> struct gprs_glcmac_bts) so that some parts of it were accessible from C code. Doing so, however, ended up being messy too, since all code needs to be switching from one object to another, which actually refer to the same logical component. Let's instead rejoin the structures and make sure the struct is accessible and usable from both C and C++ code by rewriting all methods to be C compatible and converting 3 allocated suboject as pointers. This way BTS can internally still use those C++ objects while providing a clean APi to both C and C++ code. Change-Id: I7d12c896c5ded659ca9d3bff4cf3a3fc857db9dd
2021-01-14 15:48:38 +00:00
ms = bts_alloc_ms(bts, ms_class, egprs_ms_class);
Expect ms object to exist before calling tbf_alloc_dl_tbf() Same as previous commit, this time for the DL counterpart. Change-Id: I87f6cdf8288a688466020bda0874e68b57aa71c4
2020-05-08 16:15:59 +00:00
dl_tbf2 = tbf_alloc_dl_tbf(bts, ms, 0, false);
DL TS allocation: add test case to show TS allocation bug for 2nd DL TBF This patch adds a test case test_2_consecutive_dl_tbfs which expects a current bug with TS allocation for 2nd DL TBF. The test's expectation is corrected along with the bug fix in a subsequent commit Related: OS#1792 Change-Id: I890e4fbb2b64037e051433e70082a197e2a929a6
2016-09-06 12:45:45 +00:00
OSMO_ASSERT(dl_tbf2);
for (int i = 0; i < 8; i++) {
if (dl_tbf2->pdch[i])
numTs2++;
}
/*
* TODO: currently 2nd DL TBF gets 3 TS
* This behaviour will be fixed in subsequent patch
*/
printf("TBF2: numTs(%d)\n", numTs2);
OSMO_ASSERT(numTs2 == 3);
tbf_free(dl_tbf1);
tbf_free(dl_tbf2);
Unify BTS into a C usable structure Previous work on BTS class started to get stuff out of the C++ struct into a C struct (BTS -> struct gprs_glcmac_bts) so that some parts of it were accessible from C code. Doing so, however, ended up being messy too, since all code needs to be switching from one object to another, which actually refer to the same logical component. Let's instead rejoin the structures and make sure the struct is accessible and usable from both C and C++ code by rewriting all methods to be C compatible and converting 3 allocated suboject as pointers. This way BTS can internally still use those C++ objects while providing a clean APi to both C and C++ code. Change-Id: I7d12c896c5ded659ca9d3bff4cf3a3fc857db9dd
2021-01-14 15:48:38 +00:00
talloc_free(bts);
DL TS allocation: add test case to show TS allocation bug for 2nd DL TBF This patch adds a test case test_2_consecutive_dl_tbfs which expects a current bug with TS allocation for 2nd DL TBF. The test's expectation is corrected along with the bug fix in a subsequent commit Related: OS#1792 Change-Id: I890e4fbb2b64037e051433e70082a197e2a929a6
2016-09-06 12:45:45 +00:00
}
bts: delete pch_timer list in destructor Run bts_pch_timer_remove() on each entry of the BTS specific pch_timer list, so we don't have a memory leak and so the timer doesn't potentially fire for a deallocated BTS. Fixes: d3c7591 ("Add counters: pcu.bts.N.pch.requests.timeout") Change-Id: Ia5e33d1894408e93a51c452002ef2f5758808269
2021-08-23 12:19:21 +00:00
static void test_bts_pch_timer(void)
{
struct gprs_rlcmac_bts *bts = bts_alloc(the_pcu, 0);
bts_pch_timer: Fix timer working only for MI type IMSI This commit actually addresses 2 errors: 1- gprs_bssgp_pcu_rx_paging_ps() called gprs_rlcmac_paging_request() with MI which can be either TMSI or IMSI, and the later always called bts_pch_timer_start() passing mi->imsi regardless of the MI type. Hence, trash was being accessed & stored into bts_pch_timer structures if MI type used for paging was TMSI. 2- When the MS received the PS paging on CCCH and requests an UL TBF, it will send some data. If one phase access is used for whatever reason, the IMSI may not be yet available in the GprsMs object since we never received it (and we'd only have it by means of PktResourceReq). Hence, let's better first try to match the paging by TLLI/TMSI if set in both places, and otherwise use the IMSI. Related: OS#5297 Change-Id: Iedffb7c6978a3faf0fc26ce2181dde9791a8b6f4
2021-11-08 16:38:47 +00:00
struct osmo_mobile_identity mi_imsi1, mi_imsi2;
tests/alloc: Extend test_bts_pch_timer() to validate MI type TMSI Change-Id: I3673d387fa735b54fbc137ffaa18af581fa1b85a
2021-11-08 16:49:52 +00:00
struct osmo_mobile_identity mi_tmsi1;
bts_pch_timer: Fix timer working only for MI type IMSI This commit actually addresses 2 errors: 1- gprs_bssgp_pcu_rx_paging_ps() called gprs_rlcmac_paging_request() with MI which can be either TMSI or IMSI, and the later always called bts_pch_timer_start() passing mi->imsi regardless of the MI type. Hence, trash was being accessed & stored into bts_pch_timer structures if MI type used for paging was TMSI. 2- When the MS received the PS paging on CCCH and requests an UL TBF, it will send some data. If one phase access is used for whatever reason, the IMSI may not be yet available in the GprsMs object since we never received it (and we'd only have it by means of PktResourceReq). Hence, let's better first try to match the paging by TLLI/TMSI if set in both places, and otherwise use the IMSI. Related: OS#5297 Change-Id: Iedffb7c6978a3faf0fc26ce2181dde9791a8b6f4
2021-11-08 16:38:47 +00:00
mi_imsi1.type = mi_imsi2.type = GSM_MI_TYPE_IMSI;
tests/alloc: Extend test_bts_pch_timer() to validate MI type TMSI Change-Id: I3673d387fa735b54fbc137ffaa18af581fa1b85a
2021-11-08 16:49:52 +00:00
mi_tmsi1.type = GSM_MI_TYPE_TMSI;
bts_pch_timer: Fix timer working only for MI type IMSI This commit actually addresses 2 errors: 1- gprs_bssgp_pcu_rx_paging_ps() called gprs_rlcmac_paging_request() with MI which can be either TMSI or IMSI, and the later always called bts_pch_timer_start() passing mi->imsi regardless of the MI type. Hence, trash was being accessed & stored into bts_pch_timer structures if MI type used for paging was TMSI. 2- When the MS received the PS paging on CCCH and requests an UL TBF, it will send some data. If one phase access is used for whatever reason, the IMSI may not be yet available in the GprsMs object since we never received it (and we'd only have it by means of PktResourceReq). Hence, let's better first try to match the paging by TLLI/TMSI if set in both places, and otherwise use the IMSI. Related: OS#5297 Change-Id: Iedffb7c6978a3faf0fc26ce2181dde9791a8b6f4
2021-11-08 16:38:47 +00:00
OSMO_STRLCPY_ARRAY(mi_imsi1.imsi, "1234");
OSMO_STRLCPY_ARRAY(mi_imsi2.imsi, "5678");
tests/alloc: Extend test_bts_pch_timer() to validate MI type TMSI Change-Id: I3673d387fa735b54fbc137ffaa18af581fa1b85a
2021-11-08 16:49:52 +00:00
mi_tmsi1.tmsi = 987654321;
bts: delete pch_timer list in destructor Run bts_pch_timer_remove() on each entry of the BTS specific pch_timer list, so we don't have a memory leak and so the timer doesn't potentially fire for a deallocated BTS. Fixes: d3c7591 ("Add counters: pcu.bts.N.pch.requests.timeout") Change-Id: Ia5e33d1894408e93a51c452002ef2f5758808269
2021-08-23 12:19:21 +00:00
fprintf(stderr, "Testing bts_pch_timer dealloc on bts dealloc\n");
log_set_category_filter(osmo_stderr_target, DPCU, 1, LOGL_DEBUG);
fprintf(stderr, "Starting PCH timer for 2 IMSI\n");
bts_pch_timer: Fix timer working only for MI type IMSI This commit actually addresses 2 errors: 1- gprs_bssgp_pcu_rx_paging_ps() called gprs_rlcmac_paging_request() with MI which can be either TMSI or IMSI, and the later always called bts_pch_timer_start() passing mi->imsi regardless of the MI type. Hence, trash was being accessed & stored into bts_pch_timer structures if MI type used for paging was TMSI. 2- When the MS received the PS paging on CCCH and requests an UL TBF, it will send some data. If one phase access is used for whatever reason, the IMSI may not be yet available in the GprsMs object since we never received it (and we'd only have it by means of PktResourceReq). Hence, let's better first try to match the paging by TLLI/TMSI if set in both places, and otherwise use the IMSI. Related: OS#5297 Change-Id: Iedffb7c6978a3faf0fc26ce2181dde9791a8b6f4
2021-11-08 16:38:47 +00:00
bts_pch_timer_start(bts, &mi_imsi1, mi_imsi1.imsi);
bts_pch_timer_start(bts, &mi_imsi2, mi_imsi2.imsi);
tests/alloc: Extend test_bts_pch_timer() to validate MI type TMSI Change-Id: I3673d387fa735b54fbc137ffaa18af581fa1b85a
2021-11-08 16:49:52 +00:00
fprintf(stderr, "Starting PCH timer for 1 TMSI\n");
bts_pch_timer_start(bts, &mi_tmsi1, "6666");
bts: delete pch_timer list in destructor Run bts_pch_timer_remove() on each entry of the BTS specific pch_timer list, so we don't have a memory leak and so the timer doesn't potentially fire for a deallocated BTS. Fixes: d3c7591 ("Add counters: pcu.bts.N.pch.requests.timeout") Change-Id: Ia5e33d1894408e93a51c452002ef2f5758808269
2021-08-23 12:19:21 +00:00
fprintf(stderr, "Deallocating BTS, expecting the PCH timer to be stopped and deallocated\n");
talloc_free(bts);
}
alloc: Add very basic test case for the alloc_a algorithm
2013-10-16 15:29:31 +00:00
int main(int argc, char **argv)
{
tall_pcu_ctx = talloc_named_const(NULL, 1, "moiji-mobile AllocTest context");
if (!tall_pcu_ctx)
abort();
main, tests: use msgb_talloc_ctx_init() (new) msgb_set_talloc_ctx() is deprecated since libosmocore commit f45334be29016a36594aacc07c90e262e4994525 / change-id I747fbbf977c4d2c868c8dead64cfc5fd86eb8d4c Change-Id: I8d40abec428b739460ed545c9983d1b63021bd08
2017-02-08 16:07:31 +00:00
msgb_talloc_ctx_init(tall_pcu_ctx, 0);
use osmo_init_logging2() with proper talloc ctx There is a duality of initialization: early_init() in bts.cpp wants to init logging even before static instances get initialized. Make sure that tall_pcu_ctx is initialized during early_init() as well. There is a build context that does not seem to include bts.cpp (osmo-pcu-remote), so to be sure, init tall_pcu_ctx as NULL and both in early_init() as well as pcu_main.cpp, init both tall_pcu_ctx and logging if it is still NULL. Change-Id: I2199b62d0270bd35dec2283e8f5b364b7c63915b
2018-04-01 14:54:40 +00:00
osmo_init_logging2(tall_pcu_ctx, &gprs_log_info);
alloc: Add very basic test case for the alloc_a algorithm
2013-10-16 15:29:31 +00:00
log_set_use_color(osmo_stderr_target, 0);
tests: Replace deprecated API log_set_print_filename Change-Id: Idcc4875592c81f17ac98c4f6098492b3d9dd33d2
2021-02-19 13:01:52 +00:00
log_set_print_filename2(osmo_stderr_target, LOG_FILENAME_NONE);
tests: Explicitly drop category from log Let's disable category here since we don't care about its formatting here. In any case, every test relying on logging output validation should always explicitly state the config to avoid issues in the future if default values change. Change-Id: I7f9c56313cfaa74ebe666f44763a83d8102f5484 Related: OS#5034
2021-02-19 13:00:48 +00:00
log_set_print_category(osmo_stderr_target, 0);
log_set_print_category_hex(osmo_stderr_target, 0);
gprs_debug: Use only LOGL_NOTICE as default loglevel The default loglevels of some log categories are configured to LOGL_INFO. This is still to verbose, lets use LOGL_NOTICE here. Change-Id: Ibb1cd1a94fb4fdd0147e073f8c1c82562c2c14ef Related: OS#2577
2020-03-25 11:23:52 +00:00
log_set_category_filter(osmo_stderr_target, DTBF, 1, LOGL_INFO);
alloc/test: Use LOGL_DEBUG environment variable When this environment variable is set, the logging level is set to LOGL_DEBUG to help debugging without putting everything into AllocTest.err. Sponsored-by: On-Waves ehf
2015-06-29 11:00:20 +00:00
if (getenv("LOGL_DEBUG"))
log_set_log_level(osmo_stderr_target, LOGL_DEBUG);
tbf: Move existing tbf_state implementation to osmo_fsm This is only an initial implementation, where all state changes are still done outside the FSM itself. The idea is to do the move in several commits so that they can be digested better in logical steps and avoid major break up. Related: OS#2709 Change-Id: I6bb4baea2dee191ba5bbcbec2ea9dcf681aa1237
2021-05-14 10:50:46 +00:00
osmo_fsm_log_addr(false);
alloc: Add very basic test case for the alloc_a algorithm
2013-10-16 15:29:31 +00:00
Split PCU global PCU object from BTS object Currently the BTS object (and gprs_rlcmac_bts struct) are used to hold both PCU global fields and BTS specific fields, all mangled together. The BTS is even accessed in lots of places by means of a singleton. This patch introduces a new struct gprs_pcu object aimed at holding all global state, and several fields are already moved from BTS to it. The new object can be accessed as global variable "the_pcu", reusing and including an already exisitng "the_pcu" global variable only used for bssgp related purposes so far. This is only a first step towards having a complete split global pcu and BTS, some fields are still kept in BTS and will be moved over follow-up smaller patches in the future (since this patch is already quite big). So far, the code still only supports one BTS, which can be accessed using the_pcu->bts. In the future that field will be replaced with a list, and the BTS singletons will be removed. The cur_fn output changes in TbfTest are actually a side effect fix, since the singleton main_bts() now points internally to the_pcu->bts, hence the same we allocate and assign in the test. Beforehand, "the_bts" was allocated in the stack while main_bts() still returned an unrelated singleton BTS object instance. Related: OS#4935 Change-Id: I88e3c6471b80245ce3798223f1a61190f14aa840
2021-01-13 17:54:38 +00:00
the_pcu = gprs_pcu_alloc(tall_pcu_ctx);
alloc: Add very basic test case for the alloc_a algorithm
2013-10-16 15:29:31 +00:00
test_alloc_a();
alloc/tests: Create an allocation test for various scenarious The allocation in the TBF/BTS code is quite complex. In parts this is due the assignment and requests occuring under differen circumstances. Attempt to re-create the commono scenarios. Remove the bogus msclass check in gprs_rlcmac_tbf::update as the allocation code will check the ms class anyway.
2013-12-25 18:16:55 +00:00
test_alloc_b();
AllocTest: expand test output * print MS classes * unify and print test mode description * print additional info on test completion This only changes meta info about test run but not the actual test output. Change-Id: I30a4b8f561a9677f4e9ded33a051a249bd15a6a2 Related: OS#2282
2017-11-27 12:21:41 +00:00
test_successive_allocations();
test_many_connections(alloc_algorithm_a, 160, "A");
Add multislot classes from latest spec The table B.1 is copy-pasted from 3GPP TS 45.002 and reformatted via Emacs macros into C struct to avoid typos. The test output expanded accordingly. The allocation test expectations and output are adjusted accordingly. Note: classes 35-45 which need TA offset are not properly supported yet. This can be extended once we have such devices available for tests. Change-Id: I1ef2eb99c517f25e7d1e71b985a3e0eb3879eb2c Related: OS#2282
2018-01-23 19:58:49 +00:00
test_many_connections(alloc_algorithm_b, 32, "B");
AllocTest: expand test output * print MS classes * unify and print test mode description * print additional info on test completion This only changes meta info about test run but not the actual test output. Change-Id: I30a4b8f561a9677f4e9ded33a051a249bd15a6a2 Related: OS#2282
2017-11-27 12:21:41 +00:00
test_many_connections(alloc_algorithm_dynamic, 160, "dynamic");
DL TS allocation: add test case to show TS allocation bug for 2nd DL TBF This patch adds a test case test_2_consecutive_dl_tbfs which expects a current bug with TS allocation for 2nd DL TBF. The test's expectation is corrected along with the bug fix in a subsequent commit Related: OS#1792 Change-Id: I890e4fbb2b64037e051433e70082a197e2a929a6
2016-09-06 12:45:45 +00:00
test_2_consecutive_dl_tbfs();
bts: delete pch_timer list in destructor Run bts_pch_timer_remove() on each entry of the BTS specific pch_timer list, so we don't have a memory leak and so the timer doesn't potentially fire for a deallocated BTS. Fixes: d3c7591 ("Add counters: pcu.bts.N.pch.requests.timeout") Change-Id: Ia5e33d1894408e93a51c452002ef2f5758808269
2021-08-23 12:19:21 +00:00
test_bts_pch_timer();
Split PCU global PCU object from BTS object Currently the BTS object (and gprs_rlcmac_bts struct) are used to hold both PCU global fields and BTS specific fields, all mangled together. The BTS is even accessed in lots of places by means of a singleton. This patch introduces a new struct gprs_pcu object aimed at holding all global state, and several fields are already moved from BTS to it. The new object can be accessed as global variable "the_pcu", reusing and including an already exisitng "the_pcu" global variable only used for bssgp related purposes so far. This is only a first step towards having a complete split global pcu and BTS, some fields are still kept in BTS and will be moved over follow-up smaller patches in the future (since this patch is already quite big). So far, the code still only supports one BTS, which can be accessed using the_pcu->bts. In the future that field will be replaced with a list, and the BTS singletons will be removed. The cur_fn output changes in TbfTest are actually a side effect fix, since the singleton main_bts() now points internally to the_pcu->bts, hence the same we allocate and assign in the test. Beforehand, "the_bts" was allocated in the stack while main_bts() still returned an unrelated singleton BTS object instance. Related: OS#4935 Change-Id: I88e3c6471b80245ce3798223f1a61190f14aa840
2021-01-13 17:54:38 +00:00
talloc_free(the_pcu);
alloc: Add very basic test case for the alloc_a algorithm
2013-10-16 15:29:31 +00:00
return EXIT_SUCCESS;
}
/*
* stubs that should not be reached
*/
extern "C" {
void l1if_pdch_req() { abort(); }
void l1if_connect_pdch() { abort(); }
void l1if_close_pdch() { abort(); }
void l1if_open_pdch() { abort(); }
}