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

1509 lines
93 KiB
Plaintext
Raw Normal View History

TbfTest: Make logging more verbose Sponsored-by: On-Waves ehf
2014-06-11 16:33:14 +00:00
********** TBF starts here **********
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
Allocating DL TBF: MS_CLASS=0
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Creating MS object, TLLI = 0x00000000
TbfTest: Make logging more verbose Sponsored-by: On-Waves ehf
2014-06-11 16:33:14 +00:00
Slot Allocation (Algorithm A) for class 0
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
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
- Skipping TS 4, because not enabled
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Skipping TS 7, because not enabled
- Skipping TS 3, because num TBFs 0 >= 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
- Assign downlink TS=2 TFI=0
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 2, TRX 0): Attaching TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=NULL), 1 TBFs, USFs = 00, TFIs = 00000001.
TbfTest: Make logging more verbose Sponsored-by: On-Waves ehf
2014-06-11 16:33:14 +00:00
- Setting Control TS 2
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Attaching TBF to MS object, TLLI = 0x00000000, TBF = TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=NULL)
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
Allocated TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=NULL): trx = 0, ul_slots = 04, dl_slots = 04
tbf: Always call set_tlli/confirm_tlli in update_ms Currently the m_tlli member in GprsMs is set by the constructor, circumventing the TLLI confirmation mechanism. This commit replaces the get_or_create_ms() method by a create_ms() method which takes the TLLI and the direction (UL or DL) as parameters to select either set_tlli() or confirm_tlli(). The MS object is instantiated with TLLI = 0, and therefore GprsMs::tlli() is extended to return the DL TLLI if both of the other TLLI are not set. Note that create_ms() will not check whether an MS object with a matching TLLI is already stored in the list, so it should only be called after a corresponding get_ms() in general. Sponsored-by: On-Waves ehf
2015-05-21 14:58:22 +00:00
The MS object cannot fully confirm an unexpected TLLI: 0x00002342, partly confirmed
tbf: Store the timing advance (TA) value in the GprsMs object The TA value rather relates to an MS and not to a single TBF. So all TBFs share the same TA value. Currently the TA value is stored per TBF and eventually copied from an old TBF to a new one. It is in general only passed with an RACH request when the TLLI and thus the MS is not yet known. This commit adds a TA member to the GprsMs class and uses that one when the TBF is associated to an MS object. Since the TBF is not always associated with an MS object (after RACH or when it has been replaced by another TBF), the TA value is still stored in each TBF and that value is used as long as no MS object is being associated. Sponsored-by: On-Waves ehf
2015-05-22 15:48:04 +00:00
Modifying MS object, TLLI = 0x00002342, TA 0 -> 4
TbfTest: Make logging more verbose Sponsored-by: On-Waves ehf
2014-06-11 16:33:14 +00:00
********** TBF starts here **********
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
Allocating UL TBF: MS_CLASS=0
TbfTest: Make logging more verbose Sponsored-by: On-Waves ehf
2014-06-11 16:33:14 +00:00
Slot Allocation (Algorithm A) for class 0
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
alloc: Base algo A on reserved PDCHs Currently algorithm A bases its time slots selection on the number of TBF actively using the PDCHs. This statistically prefers the first time slots, especially with short living TBFs. So when the first TBF is triggered by an uplink transfer (which generally results in a short-lived TBF) the potentially longer living DL TBF will be bound to the same slot. When another MS then requests an uplink TBF, it will get the same slot (no UL TBF currently active). This commit changes the algorithm to base its selection on reserved slots instead. Sponsored-by: On-Waves ehf
2015-06-30 08:24:37 +00:00
- Skipping TS 3, because need to reuse TS
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
- Skipping TS 4, because not enabled
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Skipping TS 7, because not enabled
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
- Assign uplink TS=2 TFI=0 USF=0
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 2, TRX 0): Attaching TBF(TFI=0 TLLI=0x00000000 DIR=UL STATE=NULL), 1 TBFs, USFs = 01, TFIs = 00000001.
TbfTest: Make logging more verbose Sponsored-by: On-Waves ehf
2014-06-11 16:33:14 +00:00
- Setting Control TS 2
tbf: Remove the TLLI from the TBFs Currently the TLLI is stored in each TBF. Since each MS is now represented by a GprsMs object which takes care of TLLI updating, and each TBF that has been associated with an TLLI also contains a reference to a GprsMs object, per TBF TLLI handling is no longer needed. Keeping all TBF m_tlli members up to date is complex and doesn't currently work correctly in all circumstances. This commit removes m_tlli and related members from the TBF class and the tbf_by_tlli functions from the BTS class. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-20 10:06:46 +00:00
Attaching TBF to MS object, TLLI = 0x00002342, TBF = TBF(TFI=0 TLLI=0x00002342 DIR=UL STATE=NULL)
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
Allocated TBF(TFI=0 TLLI=0x00002342 DIR=UL STATE=NULL): trx = 0, ul_slots = 04, dl_slots = 00
tbf: Always call set_tlli/confirm_tlli in update_ms Currently the m_tlli member in GprsMs is set by the constructor, circumventing the TLLI confirmation mechanism. This commit replaces the get_or_create_ms() method by a create_ms() method which takes the TLLI and the direction (UL or DL) as parameters to select either set_tlli() or confirm_tlli(). The MS object is instantiated with TLLI = 0, and therefore GprsMs::tlli() is extended to return the DL TLLI if both of the other TLLI are not set. Note that create_ms() will not check whether an MS object with a matching TLLI is already stored in the list, so it should only be called after a corresponding get_ms() in general. Sponsored-by: On-Waves ehf
2015-05-21 14:58:22 +00:00
Modifying MS object, TLLI: 0x00000000 -> 0x00002342, already confirmed partly
ms: Support new and old TLLIs According to the specification (GSM 04.08/24.008, 4.7.1.5) after a new P-TMSI has been assigned, the old P-TMSI must be kept basically until it has been used by both sides. Since the TLLI will be derived from the P-TMSI, the old TLLI must also be kept until the new TLLI has been used by both MS and SGSN. This commit modifies the TLLI handling of GprsMs accordingly. set_tlli() is only used with TLLIs derived from MS messages, confirm_tlli() is used with TLLIs derived from messages received from the SGSN. tlli() returns the value set by the MS. check_tlli() matches each of the TLLI used by either MS or SGSN as well as the old TLLI until it has been confirmed. Sponsored-by: On-Waves ehf
2015-05-15 13:50:43 +00:00
The MS object cannot fully confirm an unexpected TLLI: 0x00004232, partly confirmed
Modifying MS object, TLLI: 0x00002342 -> 0x00004232, already confirmed partly
tbf: Store the timing advance (TA) value in the GprsMs object The TA value rather relates to an MS and not to a single TBF. So all TBFs share the same TA value. Currently the TA value is stored per TBF and eventually copied from an old TBF to a new one. It is in general only passed with an RACH request when the TLLI and thus the MS is not yet known. This commit adds a TA member to the GprsMs class and uses that one when the TBF is associated to an MS object. Since the TBF is not always associated with an MS object (after RACH or when it has been replaced by another TBF), the TA value is still stored in each TBF and that value is used as long as no MS object is being associated. Sponsored-by: On-Waves ehf
2015-05-22 15:48:04 +00:00
Modifying MS object, TLLI = 0x00004232, TA 4 -> 6
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
Searching for first unallocated TFI: TRX=0
tests/tbf: Test for final ack issue Ticket: SYS#382 Sponsored-by: On-Waves ehf
2014-08-15 16:19:41 +00:00
Found TFI=0.
********** TBF starts here **********
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
Allocating DL TBF: MS_CLASS=45
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Creating MS object, TLLI = 0x00000000
Modifying MS object, TLLI = 0x00000000, MS class 0 -> 45
tests/tbf: Test for final ack issue Ticket: SYS#382 Sponsored-by: On-Waves ehf
2014-08-15 16:19:41 +00:00
Slot Allocation (Algorithm A) for class 45
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
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
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Skipping TS 7, because not enabled
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
- Assign downlink TS=4 TFI=0
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Attaching TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=NULL), 1 TBFs, USFs = 00, TFIs = 00000001.
tests/tbf: Test for final ack issue Ticket: SYS#382 Sponsored-by: On-Waves ehf
2014-08-15 16:19:41 +00:00
- Setting Control TS 4
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Attaching TBF to MS object, TLLI = 0x00000000, TBF = TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=NULL)
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
Allocated TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=NULL): trx = 0, ul_slots = 10, dl_slots = 10
tests/tbf: Test for final ack issue Ticket: SYS#382 Sponsored-by: On-Waves ehf
2014-08-15 16:19:41 +00:00
TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=NULL) changes state from NULL to FLOW
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
The MS object cannot fully confirm an unexpected TLLI: 0xffeeddcc, partly confirmed
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) append
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) append
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) start Packet Downlink Assignment (PACCH)
tests/tbf: Test for final ack issue Ticket: SYS#382 Sponsored-by: On-Waves ehf
2014-08-15 16:19:41 +00:00
+++++++++++++++++++++++++ TX : Packet Downlink Assignment +++++++++++++++++++++++++
------------------------- TX : Packet Downlink Assignment -------------------------
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
Scheduling control message at RTS for TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) (TRX=0, TS=4)
tests/tbf: Test for final ack issue Ticket: SYS#382 Sponsored-by: On-Waves ehf
2014-08-15 16:19:41 +00:00
Sending data request: trx=0 ts=4 sapi=5 arfcn=0 fn=0 block=0 data=4f 08 20 00 44 02 00 02 08 04 00 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b
tbf: Poll MS on idle DL TBFs If an MS wants to open a new UL TBF, it can either use (P)RACH or request one in a Ack/Nack message for a DL TBF (PACCH). When a TBF becomes idle (LCC queue is empty but the TBF is kept open), there aren't any Ack/Nack requests that can be used by the MS to ask for an UL TBF, therefore it has to use the RACH. This leads to many RACH requests even for a single HTTP transaction, so it takes some time to retrieve even a simple web page. This commit modifies the scheduler to regularly send Ack/Nack requests on idle DL TBFs. It does so by extending the priority based scheduling algorithm to have 5 priority levels (highest priority first): - Control block is pending - High age (100%) threshold reached (-> request Ack/Nack) - Data is waiting or there are pending Nacks - Low age (200ms) threshold reached (-> request Ack/Nack) - Pending Nacks that have been resent already - None of the above (-> send DL dummy control block) The 'age' refers to the time since since the last control block has been sent on the TBF. This high age threshold is set to dl-tbf-idle-time or to 50% of T3190 (whichever is smaller), aiming for at least a poll (and TBF shutdown) after the TBF has expired and to safely prevent expiry of T3190. So if dl-tbf-idle-time > 200ms, there will be a poll every 200ms and a final poll after dl-tbf-idle-time. On high load, the interval between polls can get higher, but the 'high age' poll should be in place. This commit implements the scheduling with respect to GSM 44.060, 9.3.1a ("Delayed release of downlink TBF"). Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-20 13:26:05 +00:00
Scheduling data message at RTS for DL TFI=0 (TRX=0, TS=4) prio=3
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) downlink (V(A)==0 .. V(S)==0)
tbf: Fix downlink packet loss When the MS is pinged with a longer interval, many packets get lost even if the GprsMs object is kept. If the interval is above the time where the DL TBF is in state FLOW (mainly influenced be the dl-tbf-idle-time command), an new TBF must be requested via AGCH for each ICMP PING message. Currently the LLC frame containing the PING is immediately stored in the TBF and gets lost, if TBF establishment fails for some reason. This commit moves all calls to put_frame() to schedule_next_frame(), where the data is moved from the LLC queue to the frame storage within the TBF object. This method is only called from within create_new_bsn() when the TBF is in the FLOW state and the frame is going to be encoded immediately. At all other places, where put_frame() has been called before, the LLC message is just appended to the LLC queue in the GprsMs object. This change effectively simplifies the related code parts, since date/len information and discard notifications is no longer needed there. Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 12:06:09 +00:00
- Dequeue next LLC for TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) (len=200)
tbf: Include CS into create_new_bsn log message This change lets the test suite fail, so it get its own commit. Sponsored-by: On-Waves ehf
2015-06-12 08:48:05 +00:00
- Sending new block at BSN 0, CS=1
tbf: Use put_frame in append_data if the TBF has no data Currently if append_data() is used when there is no LLC data in the DL TBF, it will either call reuse_tbf() which in turn will call put_frame(), or it will append the LLC message to the queue, even if the queue and the frame buffer are empty. This only happens with the test case so far, but this would change when idle DL TBFs are kept open for some time. It results in empty LLC message being sent to the MS (see log below). This commit changes append_data to check for this case and to eventually use put_frame() instead of appending the LLC data to the queue. Addresses: TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=FLOW) downlink (V(A)==0 .. V(S)==0) - Sending new block at BSN 0 -- Chunk with length 0 is less than remaining space (20): add length header to to delimit LLC frame Complete DL frame for TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=FLOW)len=0 - Dequeue next LLC for TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=FLOW) (len=200) Sponsored-by: On-Waves ehf
2015-03-24 10:04:19 +00:00
-- Chunk with length 200 larger than space (20) left in block: copy only remaining space, and we are done
data block: 07 00 01 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13
Sending data request: trx=0 ts=4 sapi=5 arfcn=0 fn=4 block=1 data=07 00 01 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
Received RTS for PDCH: TRX=0 TS=4 FN=8 block_nr=2 scheduling free USF for polling at FN=13 of TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW)
tbf: Poll MS on idle DL TBFs If an MS wants to open a new UL TBF, it can either use (P)RACH or request one in a Ack/Nack message for a DL TBF (PACCH). When a TBF becomes idle (LCC queue is empty but the TBF is kept open), there aren't any Ack/Nack requests that can be used by the MS to ask for an UL TBF, therefore it has to use the RACH. This leads to many RACH requests even for a single HTTP transaction, so it takes some time to retrieve even a simple web page. This commit modifies the scheduler to regularly send Ack/Nack requests on idle DL TBFs. It does so by extending the priority based scheduling algorithm to have 5 priority levels (highest priority first): - Control block is pending - High age (100%) threshold reached (-> request Ack/Nack) - Data is waiting or there are pending Nacks - Low age (200ms) threshold reached (-> request Ack/Nack) - Pending Nacks that have been resent already - None of the above (-> send DL dummy control block) The 'age' refers to the time since since the last control block has been sent on the TBF. This high age threshold is set to dl-tbf-idle-time or to 50% of T3190 (whichever is smaller), aiming for at least a poll (and TBF shutdown) after the TBF has expired and to safely prevent expiry of T3190. So if dl-tbf-idle-time > 200ms, there will be a poll every 200ms and a final poll after dl-tbf-idle-time. On high load, the interval between polls can get higher, but the 'high age' poll should be in place. This commit implements the scheduling with respect to GSM 44.060, 9.3.1a ("Delayed release of downlink TBF"). Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-20 13:26:05 +00:00
Scheduling data message at RTS for DL TFI=0 (TRX=0, TS=4) prio=3
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) downlink (V(A)==0 .. V(S)==1)
tbf: Include CS into create_new_bsn log message This change lets the test suite fail, so it get its own commit. Sponsored-by: On-Waves ehf
2015-06-12 08:48:05 +00:00
- Sending new block at BSN 1, CS=1
tbf: Use put_frame in append_data if the TBF has no data Currently if append_data() is used when there is no LLC data in the DL TBF, it will either call reuse_tbf() which in turn will call put_frame(), or it will append the LLC message to the queue, even if the queue and the frame buffer are empty. This only happens with the test case so far, but this would change when idle DL TBFs are kept open for some time. It results in empty LLC message being sent to the MS (see log below). This commit changes append_data to check for this case and to eventually use put_frame() instead of appending the LLC data to the queue. Addresses: TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=FLOW) downlink (V(A)==0 .. V(S)==0) - Sending new block at BSN 0 -- Chunk with length 0 is less than remaining space (20): add length header to to delimit LLC frame Complete DL frame for TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=FLOW)len=0 - Dequeue next LLC for TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=FLOW) (len=200) Sponsored-by: On-Waves ehf
2015-03-24 10:04:19 +00:00
-- Chunk with length 180 larger than space (20) left in block: copy only remaining space, and we are done
data block: 07 00 03 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20 21 22 23 24 25 26 27
Sending data request: trx=0 ts=4 sapi=5 arfcn=0 fn=8 block=2 data=07 00 03 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20 21 22 23 24 25 26 27
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) downlink acknowledge
tests/tbf: Test for final ack issue Ticket: SYS#382 Sponsored-by: On-Waves ehf
2014-08-15 16:19:41 +00:00
- Final ACK received.
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) changes state from FLOW to WAIT RELEASE
tbf: Always start T3193 when changing state to GPRS_RLCMAC_WAIT_RELEASE Currently when receiving a PACKET DL ACK/NACK message with the Final Ack Indicator bit set, the TBF's state is set to GPRS_RLCMAC_WAIT_RELEASE but T3193 is only started when the LLC queue is empty. Otherwise the reuse_tbf() method is called to establish a new DL TBF. In that case, the timer is not started. This will leave the current TBF without a timer so it is potentially not released later on. This is recognisable by sticky entries in the output of the 'show tbf all' command and possibly allocation failures if there are too many of them. This commit changes the code to always start T3193 to make sure, that a timer is always active when the the state is set to GPRS_RLCMAC_WAIT_RELEASE. Note that TS 44.060, 9.3.2.6 requests to release the 'old' TBF immediately in some cases, which is not implemented by this change. This will lead to a longer reservation period of the TFI only, which is safer than reassigning it too early. Sponsored-by: On-Waves ehf
2015-08-13 16:36:56 +00:00
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=WAIT RELEASE) starting timer 3193.
tests/tbf: Test for final ack issue Ticket: SYS#382 Sponsored-by: On-Waves ehf
2014-08-15 16:19:41 +00:00
********** TBF starts here **********
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
Allocating DL TBF: MS_CLASS=45
tests/tbf: Test for final ack issue Ticket: SYS#382 Sponsored-by: On-Waves ehf
2014-08-15 16:19:41 +00:00
Slot Allocation (Algorithm A) for class 45
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
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
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Skipping TS 7, because not enabled
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
- Assign downlink TS=4 TFI=1
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Attaching TBF(TFI=1 TLLI=0x00000000 DIR=DL STATE=NULL), 2 TBFs, USFs = 00, TFIs = 00000003.
tests/tbf: Test for final ack issue Ticket: SYS#382 Sponsored-by: On-Waves ehf
2014-08-15 16:19:41 +00:00
- Setting Control TS 4
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
Attaching TBF to MS object, TLLI = 0xffeeddcc, TBF = TBF(TFI=1 TLLI=0xffeeddcc DIR=DL STATE=NULL)
Detaching TBF from MS object, TLLI = 0xffeeddcc, TBF = TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=WAIT RELEASE)
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
Allocated TBF(TFI=1 TLLI=0xffeeddcc DIR=DL STATE=NULL): trx = 0, ul_slots = 10, dl_slots = 10
tests/tbf: Test for final ack issue Ticket: SYS#382 Sponsored-by: On-Waves ehf
2014-08-15 16:19:41 +00:00
TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=WAIT RELEASE) Trigger dowlink assignment on PACCH, because another LLC PDU has arrived in between
Send dowlink assignment on PACCH, because TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=WAIT RELEASE) exists
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
TBF(TFI=1 TLLI=0xffeeddcc DIR=DL STATE=NULL) changes state from NULL to ASSIGN
TBF(TFI=1 TLLI=0xffeeddcc DIR=DL STATE=ASSIGN) starting timer 0.
tests/tbf: Test for final ack issue Ticket: SYS#382 Sponsored-by: On-Waves ehf
2014-08-15 16:19:41 +00:00
DL packet loss of IMSI= / TLLI=0x00000000: 0%
TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=WAIT RELEASE) free
tbf: Always start T3193 when changing state to GPRS_RLCMAC_WAIT_RELEASE Currently when receiving a PACKET DL ACK/NACK message with the Final Ack Indicator bit set, the TBF's state is set to GPRS_RLCMAC_WAIT_RELEASE but T3193 is only started when the LLC queue is empty. Otherwise the reuse_tbf() method is called to establish a new DL TBF. In that case, the timer is not started. This will leave the current TBF without a timer so it is potentially not released later on. This is recognisable by sticky entries in the output of the 'show tbf all' command and possibly allocation failures if there are too many of them. This commit changes the code to always start T3193 to make sure, that a timer is always active when the the state is set to GPRS_RLCMAC_WAIT_RELEASE. Note that TS 44.060, 9.3.2.6 requests to release the 'old' TBF immediately in some cases, which is not implemented by this change. This will lead to a longer reservation period of the TFI only, which is safer than reassigning it too early. Sponsored-by: On-Waves ehf
2015-08-13 16:36:56 +00:00
TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=WAIT RELEASE) stopping timer 3193.
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Detaching TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=WAIT RELEASE), 1 TBFs, USFs = 00, TFIs = 00000002.
tests/tbf: Test for final ack issue Ticket: SYS#382 Sponsored-by: On-Waves ehf
2014-08-15 16:19:41 +00:00
********** TBF ends here **********
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
TBF(TFI=1 TLLI=0xffeeddcc DIR=DL STATE=ASSIGN) free
TBF(TFI=1 TLLI=0xffeeddcc DIR=DL STATE=ASSIGN) stopping timer 0.
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Detaching TBF(TFI=1 TLLI=0xffeeddcc DIR=DL STATE=ASSIGN), 0 TBFs, USFs = 00, TFIs = 00000000.
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
Detaching TBF from MS object, TLLI = 0xffeeddcc, TBF = TBF(TFI=1 TLLI=0xffeeddcc DIR=DL STATE=ASSIGN)
tests/tbf: Test for final ack issue Ticket: SYS#382 Sponsored-by: On-Waves ehf
2014-08-15 16:19:41 +00:00
********** TBF ends here **********
tbf: Remove TBF chaining (m_new_tbf and m_old_tbf) Currently a new TBF is chained to an existing older one, either of the other direction (active or releasing) or of the same direction (releasing). This does not work properly work if and uplink and a downlink TBF are being established at the same time while an old TBF is being released. In that case, one of them is thrown away and the pending procedure is cancelled. The chaining is no longer necessary since the GprsMs objects have been introduced which keep track of the active TBFs. This commit removes the TBF members m_new_tbf and m_old_tbf and the related methods and code paths. Note that a new TBF can replace an older TBF entry of the same direction within an MS object when it is associated with an MS (e.g. by TLLI or because it is assigned via another, already associated TBF). In that case, the old TBF is no longer associated with an MS object. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-22 13:47:55 +00:00
Destroying MS object, TLLI = 0xffeeddcc
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
Searching for first unallocated TFI: TRX=0
tbf/test: Modify test to create a dangling TBF pointer When new_tbf is freed before dl_tbf in test_tbf_final_ack, dl_tbf still contains a pointer to it in m_new_tbf. This patch changes the test to accept a test mode parameter and runs it twice which a different order of tbf_free in each run. Consistency checks are added, to check for a danglilng m_new_tbf pointer in both cases. Sponsored-by: On-Waves ehf
2015-02-23 13:26:59 +00:00
Found TFI=0.
********** TBF starts here **********
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
Allocating DL TBF: MS_CLASS=45
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Creating MS object, TLLI = 0x00000000
Modifying MS object, TLLI = 0x00000000, MS class 0 -> 45
tbf/test: Modify test to create a dangling TBF pointer When new_tbf is freed before dl_tbf in test_tbf_final_ack, dl_tbf still contains a pointer to it in m_new_tbf. This patch changes the test to accept a test mode parameter and runs it twice which a different order of tbf_free in each run. Consistency checks are added, to check for a danglilng m_new_tbf pointer in both cases. Sponsored-by: On-Waves ehf
2015-02-23 13:26:59 +00:00
Slot Allocation (Algorithm A) for class 45
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
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
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Skipping TS 7, because not enabled
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
- Assign downlink TS=4 TFI=0
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Attaching TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=NULL), 1 TBFs, USFs = 00, TFIs = 00000001.
tbf/test: Modify test to create a dangling TBF pointer When new_tbf is freed before dl_tbf in test_tbf_final_ack, dl_tbf still contains a pointer to it in m_new_tbf. This patch changes the test to accept a test mode parameter and runs it twice which a different order of tbf_free in each run. Consistency checks are added, to check for a danglilng m_new_tbf pointer in both cases. Sponsored-by: On-Waves ehf
2015-02-23 13:26:59 +00:00
- Setting Control TS 4
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Attaching TBF to MS object, TLLI = 0x00000000, TBF = TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=NULL)
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
Allocated TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=NULL): trx = 0, ul_slots = 10, dl_slots = 10
tbf/test: Modify test to create a dangling TBF pointer When new_tbf is freed before dl_tbf in test_tbf_final_ack, dl_tbf still contains a pointer to it in m_new_tbf. This patch changes the test to accept a test mode parameter and runs it twice which a different order of tbf_free in each run. Consistency checks are added, to check for a danglilng m_new_tbf pointer in both cases. Sponsored-by: On-Waves ehf
2015-02-23 13:26:59 +00:00
TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=NULL) changes state from NULL to FLOW
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
The MS object cannot fully confirm an unexpected TLLI: 0xffeeddcc, partly confirmed
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) append
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) append
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) start Packet Downlink Assignment (PACCH)
tbf/test: Modify test to create a dangling TBF pointer When new_tbf is freed before dl_tbf in test_tbf_final_ack, dl_tbf still contains a pointer to it in m_new_tbf. This patch changes the test to accept a test mode parameter and runs it twice which a different order of tbf_free in each run. Consistency checks are added, to check for a danglilng m_new_tbf pointer in both cases. Sponsored-by: On-Waves ehf
2015-02-23 13:26:59 +00:00
+++++++++++++++++++++++++ TX : Packet Downlink Assignment +++++++++++++++++++++++++
------------------------- TX : Packet Downlink Assignment -------------------------
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
Scheduling control message at RTS for TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) (TRX=0, TS=4)
tbf/test: Modify test to create a dangling TBF pointer When new_tbf is freed before dl_tbf in test_tbf_final_ack, dl_tbf still contains a pointer to it in m_new_tbf. This patch changes the test to accept a test mode parameter and runs it twice which a different order of tbf_free in each run. Consistency checks are added, to check for a danglilng m_new_tbf pointer in both cases. Sponsored-by: On-Waves ehf
2015-02-23 13:26:59 +00:00
Sending data request: trx=0 ts=4 sapi=5 arfcn=0 fn=0 block=0 data=4f 08 20 00 44 02 00 02 08 04 00 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b
tbf: Poll MS on idle DL TBFs If an MS wants to open a new UL TBF, it can either use (P)RACH or request one in a Ack/Nack message for a DL TBF (PACCH). When a TBF becomes idle (LCC queue is empty but the TBF is kept open), there aren't any Ack/Nack requests that can be used by the MS to ask for an UL TBF, therefore it has to use the RACH. This leads to many RACH requests even for a single HTTP transaction, so it takes some time to retrieve even a simple web page. This commit modifies the scheduler to regularly send Ack/Nack requests on idle DL TBFs. It does so by extending the priority based scheduling algorithm to have 5 priority levels (highest priority first): - Control block is pending - High age (100%) threshold reached (-> request Ack/Nack) - Data is waiting or there are pending Nacks - Low age (200ms) threshold reached (-> request Ack/Nack) - Pending Nacks that have been resent already - None of the above (-> send DL dummy control block) The 'age' refers to the time since since the last control block has been sent on the TBF. This high age threshold is set to dl-tbf-idle-time or to 50% of T3190 (whichever is smaller), aiming for at least a poll (and TBF shutdown) after the TBF has expired and to safely prevent expiry of T3190. So if dl-tbf-idle-time > 200ms, there will be a poll every 200ms and a final poll after dl-tbf-idle-time. On high load, the interval between polls can get higher, but the 'high age' poll should be in place. This commit implements the scheduling with respect to GSM 44.060, 9.3.1a ("Delayed release of downlink TBF"). Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-20 13:26:05 +00:00
Scheduling data message at RTS for DL TFI=0 (TRX=0, TS=4) prio=3
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) downlink (V(A)==0 .. V(S)==0)
tbf: Fix downlink packet loss When the MS is pinged with a longer interval, many packets get lost even if the GprsMs object is kept. If the interval is above the time where the DL TBF is in state FLOW (mainly influenced be the dl-tbf-idle-time command), an new TBF must be requested via AGCH for each ICMP PING message. Currently the LLC frame containing the PING is immediately stored in the TBF and gets lost, if TBF establishment fails for some reason. This commit moves all calls to put_frame() to schedule_next_frame(), where the data is moved from the LLC queue to the frame storage within the TBF object. This method is only called from within create_new_bsn() when the TBF is in the FLOW state and the frame is going to be encoded immediately. At all other places, where put_frame() has been called before, the LLC message is just appended to the LLC queue in the GprsMs object. This change effectively simplifies the related code parts, since date/len information and discard notifications is no longer needed there. Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 12:06:09 +00:00
- Dequeue next LLC for TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) (len=200)
tbf: Include CS into create_new_bsn log message This change lets the test suite fail, so it get its own commit. Sponsored-by: On-Waves ehf
2015-06-12 08:48:05 +00:00
- Sending new block at BSN 0, CS=1
tbf: Use put_frame in append_data if the TBF has no data Currently if append_data() is used when there is no LLC data in the DL TBF, it will either call reuse_tbf() which in turn will call put_frame(), or it will append the LLC message to the queue, even if the queue and the frame buffer are empty. This only happens with the test case so far, but this would change when idle DL TBFs are kept open for some time. It results in empty LLC message being sent to the MS (see log below). This commit changes append_data to check for this case and to eventually use put_frame() instead of appending the LLC data to the queue. Addresses: TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=FLOW) downlink (V(A)==0 .. V(S)==0) - Sending new block at BSN 0 -- Chunk with length 0 is less than remaining space (20): add length header to to delimit LLC frame Complete DL frame for TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=FLOW)len=0 - Dequeue next LLC for TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=FLOW) (len=200) Sponsored-by: On-Waves ehf
2015-03-24 10:04:19 +00:00
-- Chunk with length 200 larger than space (20) left in block: copy only remaining space, and we are done
data block: 07 00 01 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13
Sending data request: trx=0 ts=4 sapi=5 arfcn=0 fn=4 block=1 data=07 00 01 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
Received RTS for PDCH: TRX=0 TS=4 FN=8 block_nr=2 scheduling free USF for polling at FN=13 of TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW)
tbf: Poll MS on idle DL TBFs If an MS wants to open a new UL TBF, it can either use (P)RACH or request one in a Ack/Nack message for a DL TBF (PACCH). When a TBF becomes idle (LCC queue is empty but the TBF is kept open), there aren't any Ack/Nack requests that can be used by the MS to ask for an UL TBF, therefore it has to use the RACH. This leads to many RACH requests even for a single HTTP transaction, so it takes some time to retrieve even a simple web page. This commit modifies the scheduler to regularly send Ack/Nack requests on idle DL TBFs. It does so by extending the priority based scheduling algorithm to have 5 priority levels (highest priority first): - Control block is pending - High age (100%) threshold reached (-> request Ack/Nack) - Data is waiting or there are pending Nacks - Low age (200ms) threshold reached (-> request Ack/Nack) - Pending Nacks that have been resent already - None of the above (-> send DL dummy control block) The 'age' refers to the time since since the last control block has been sent on the TBF. This high age threshold is set to dl-tbf-idle-time or to 50% of T3190 (whichever is smaller), aiming for at least a poll (and TBF shutdown) after the TBF has expired and to safely prevent expiry of T3190. So if dl-tbf-idle-time > 200ms, there will be a poll every 200ms and a final poll after dl-tbf-idle-time. On high load, the interval between polls can get higher, but the 'high age' poll should be in place. This commit implements the scheduling with respect to GSM 44.060, 9.3.1a ("Delayed release of downlink TBF"). Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-20 13:26:05 +00:00
Scheduling data message at RTS for DL TFI=0 (TRX=0, TS=4) prio=3
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) downlink (V(A)==0 .. V(S)==1)
tbf: Include CS into create_new_bsn log message This change lets the test suite fail, so it get its own commit. Sponsored-by: On-Waves ehf
2015-06-12 08:48:05 +00:00
- Sending new block at BSN 1, CS=1
tbf: Use put_frame in append_data if the TBF has no data Currently if append_data() is used when there is no LLC data in the DL TBF, it will either call reuse_tbf() which in turn will call put_frame(), or it will append the LLC message to the queue, even if the queue and the frame buffer are empty. This only happens with the test case so far, but this would change when idle DL TBFs are kept open for some time. It results in empty LLC message being sent to the MS (see log below). This commit changes append_data to check for this case and to eventually use put_frame() instead of appending the LLC data to the queue. Addresses: TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=FLOW) downlink (V(A)==0 .. V(S)==0) - Sending new block at BSN 0 -- Chunk with length 0 is less than remaining space (20): add length header to to delimit LLC frame Complete DL frame for TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=FLOW)len=0 - Dequeue next LLC for TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=FLOW) (len=200) Sponsored-by: On-Waves ehf
2015-03-24 10:04:19 +00:00
-- Chunk with length 180 larger than space (20) left in block: copy only remaining space, and we are done
data block: 07 00 03 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20 21 22 23 24 25 26 27
Sending data request: trx=0 ts=4 sapi=5 arfcn=0 fn=8 block=2 data=07 00 03 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20 21 22 23 24 25 26 27
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) downlink acknowledge
tbf/test: Modify test to create a dangling TBF pointer When new_tbf is freed before dl_tbf in test_tbf_final_ack, dl_tbf still contains a pointer to it in m_new_tbf. This patch changes the test to accept a test mode parameter and runs it twice which a different order of tbf_free in each run. Consistency checks are added, to check for a danglilng m_new_tbf pointer in both cases. Sponsored-by: On-Waves ehf
2015-02-23 13:26:59 +00:00
- Final ACK received.
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) changes state from FLOW to WAIT RELEASE
tbf: Always start T3193 when changing state to GPRS_RLCMAC_WAIT_RELEASE Currently when receiving a PACKET DL ACK/NACK message with the Final Ack Indicator bit set, the TBF's state is set to GPRS_RLCMAC_WAIT_RELEASE but T3193 is only started when the LLC queue is empty. Otherwise the reuse_tbf() method is called to establish a new DL TBF. In that case, the timer is not started. This will leave the current TBF without a timer so it is potentially not released later on. This is recognisable by sticky entries in the output of the 'show tbf all' command and possibly allocation failures if there are too many of them. This commit changes the code to always start T3193 to make sure, that a timer is always active when the the state is set to GPRS_RLCMAC_WAIT_RELEASE. Note that TS 44.060, 9.3.2.6 requests to release the 'old' TBF immediately in some cases, which is not implemented by this change. This will lead to a longer reservation period of the TFI only, which is safer than reassigning it too early. Sponsored-by: On-Waves ehf
2015-08-13 16:36:56 +00:00
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=WAIT RELEASE) starting timer 3193.
tbf/test: Modify test to create a dangling TBF pointer When new_tbf is freed before dl_tbf in test_tbf_final_ack, dl_tbf still contains a pointer to it in m_new_tbf. This patch changes the test to accept a test mode parameter and runs it twice which a different order of tbf_free in each run. Consistency checks are added, to check for a danglilng m_new_tbf pointer in both cases. Sponsored-by: On-Waves ehf
2015-02-23 13:26:59 +00:00
********** TBF starts here **********
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
Allocating DL TBF: MS_CLASS=45
tbf/test: Modify test to create a dangling TBF pointer When new_tbf is freed before dl_tbf in test_tbf_final_ack, dl_tbf still contains a pointer to it in m_new_tbf. This patch changes the test to accept a test mode parameter and runs it twice which a different order of tbf_free in each run. Consistency checks are added, to check for a danglilng m_new_tbf pointer in both cases. Sponsored-by: On-Waves ehf
2015-02-23 13:26:59 +00:00
Slot Allocation (Algorithm A) for class 45
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
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
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Skipping TS 7, because not enabled
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
- Assign downlink TS=4 TFI=1
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Attaching TBF(TFI=1 TLLI=0x00000000 DIR=DL STATE=NULL), 2 TBFs, USFs = 00, TFIs = 00000003.
tbf/test: Modify test to create a dangling TBF pointer When new_tbf is freed before dl_tbf in test_tbf_final_ack, dl_tbf still contains a pointer to it in m_new_tbf. This patch changes the test to accept a test mode parameter and runs it twice which a different order of tbf_free in each run. Consistency checks are added, to check for a danglilng m_new_tbf pointer in both cases. Sponsored-by: On-Waves ehf
2015-02-23 13:26:59 +00:00
- Setting Control TS 4
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
Attaching TBF to MS object, TLLI = 0xffeeddcc, TBF = TBF(TFI=1 TLLI=0xffeeddcc DIR=DL STATE=NULL)
Detaching TBF from MS object, TLLI = 0xffeeddcc, TBF = TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=WAIT RELEASE)
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
Allocated TBF(TFI=1 TLLI=0xffeeddcc DIR=DL STATE=NULL): trx = 0, ul_slots = 10, dl_slots = 10
tbf/test: Modify test to create a dangling TBF pointer When new_tbf is freed before dl_tbf in test_tbf_final_ack, dl_tbf still contains a pointer to it in m_new_tbf. This patch changes the test to accept a test mode parameter and runs it twice which a different order of tbf_free in each run. Consistency checks are added, to check for a danglilng m_new_tbf pointer in both cases. Sponsored-by: On-Waves ehf
2015-02-23 13:26:59 +00:00
TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=WAIT RELEASE) Trigger dowlink assignment on PACCH, because another LLC PDU has arrived in between
Send dowlink assignment on PACCH, because TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=WAIT RELEASE) exists
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
TBF(TFI=1 TLLI=0xffeeddcc DIR=DL STATE=NULL) changes state from NULL to ASSIGN
TBF(TFI=1 TLLI=0xffeeddcc DIR=DL STATE=ASSIGN) starting timer 0.
TBF(TFI=1 TLLI=0xffeeddcc DIR=DL STATE=ASSIGN) free
TBF(TFI=1 TLLI=0xffeeddcc DIR=DL STATE=ASSIGN) stopping timer 0.
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Detaching TBF(TFI=1 TLLI=0xffeeddcc DIR=DL STATE=ASSIGN), 1 TBFs, USFs = 00, TFIs = 00000001.
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
Detaching TBF from MS object, TLLI = 0xffeeddcc, TBF = TBF(TFI=1 TLLI=0xffeeddcc DIR=DL STATE=ASSIGN)
tbf/test: Modify test to create a dangling TBF pointer When new_tbf is freed before dl_tbf in test_tbf_final_ack, dl_tbf still contains a pointer to it in m_new_tbf. This patch changes the test to accept a test mode parameter and runs it twice which a different order of tbf_free in each run. Consistency checks are added, to check for a danglilng m_new_tbf pointer in both cases. Sponsored-by: On-Waves ehf
2015-02-23 13:26:59 +00:00
********** TBF ends here **********
DL packet loss of IMSI= / TLLI=0x00000000: 0%
TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=WAIT RELEASE) free
tbf: Always start T3193 when changing state to GPRS_RLCMAC_WAIT_RELEASE Currently when receiving a PACKET DL ACK/NACK message with the Final Ack Indicator bit set, the TBF's state is set to GPRS_RLCMAC_WAIT_RELEASE but T3193 is only started when the LLC queue is empty. Otherwise the reuse_tbf() method is called to establish a new DL TBF. In that case, the timer is not started. This will leave the current TBF without a timer so it is potentially not released later on. This is recognisable by sticky entries in the output of the 'show tbf all' command and possibly allocation failures if there are too many of them. This commit changes the code to always start T3193 to make sure, that a timer is always active when the the state is set to GPRS_RLCMAC_WAIT_RELEASE. Note that TS 44.060, 9.3.2.6 requests to release the 'old' TBF immediately in some cases, which is not implemented by this change. This will lead to a longer reservation period of the TFI only, which is safer than reassigning it too early. Sponsored-by: On-Waves ehf
2015-08-13 16:36:56 +00:00
TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=WAIT RELEASE) stopping timer 3193.
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Detaching TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=WAIT RELEASE), 0 TBFs, USFs = 00, TFIs = 00000000.
tbf/test: Modify test to create a dangling TBF pointer When new_tbf is freed before dl_tbf in test_tbf_final_ack, dl_tbf still contains a pointer to it in m_new_tbf. This patch changes the test to accept a test mode parameter and runs it twice which a different order of tbf_free in each run. Consistency checks are added, to check for a danglilng m_new_tbf pointer in both cases. Sponsored-by: On-Waves ehf
2015-02-23 13:26:59 +00:00
********** TBF ends here **********
tbf: Remove TBF chaining (m_new_tbf and m_old_tbf) Currently a new TBF is chained to an existing older one, either of the other direction (active or releasing) or of the same direction (releasing). This does not work properly work if and uplink and a downlink TBF are being established at the same time while an old TBF is being released. In that case, one of them is thrown away and the pending procedure is cancelled. The chaining is no longer necessary since the GprsMs objects have been introduced which keep track of the active TBFs. This commit removes the TBF members m_new_tbf and m_old_tbf and the related methods and code paths. Note that a new TBF can replace an older TBF entry of the same direction within an MS object when it is associated with an MS (e.g. by TLLI or because it is assigned via another, already associated TBF). In that case, the old TBF is no longer associated with an MS object. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-22 13:47:55 +00:00
Destroying MS object, TLLI = 0xffeeddcc
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
Searching for first unallocated TFI: TRX=0
tbf/test: Add test for delayed release This tests checks the implementation of the delayed release of an downlink TBF. Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-25 09:48:52 +00:00
Found TFI=0.
********** TBF starts here **********
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
Allocating DL TBF: MS_CLASS=45
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Creating MS object, TLLI = 0x00000000
Modifying MS object, TLLI = 0x00000000, MS class 0 -> 45
tbf/test: Add test for delayed release This tests checks the implementation of the delayed release of an downlink TBF. Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-25 09:48:52 +00:00
Slot Allocation (Algorithm A) for class 45
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
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
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Skipping TS 7, because not enabled
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
- Assign downlink TS=4 TFI=0
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Attaching TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=NULL), 1 TBFs, USFs = 00, TFIs = 00000001.
tbf/test: Add test for delayed release This tests checks the implementation of the delayed release of an downlink TBF. Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-25 09:48:52 +00:00
- Setting Control TS 4
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Attaching TBF to MS object, TLLI = 0x00000000, TBF = TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=NULL)
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
Allocated TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=NULL): trx = 0, ul_slots = 10, dl_slots = 10
tbf/test: Add test for delayed release This tests checks the implementation of the delayed release of an downlink TBF. Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-25 09:48:52 +00:00
TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=NULL) changes state from NULL to FLOW
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
The MS object cannot fully confirm an unexpected TLLI: 0xffeeddcc, partly confirmed
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) append
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) append
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) start Packet Downlink Assignment (PACCH)
tbf/test: Add test for delayed release This tests checks the implementation of the delayed release of an downlink TBF. Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-25 09:48:52 +00:00
+++++++++++++++++++++++++ TX : Packet Downlink Assignment +++++++++++++++++++++++++
------------------------- TX : Packet Downlink Assignment -------------------------
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
Scheduling control message at RTS for TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) (TRX=0, TS=4)
tbf/test: Add test for delayed release This tests checks the implementation of the delayed release of an downlink TBF. Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-25 09:48:52 +00:00
Sending data request: trx=0 ts=4 sapi=5 arfcn=0 fn=0 block=0 data=4f 08 20 00 44 02 00 02 08 04 00 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b
tbf: Poll MS on idle DL TBFs If an MS wants to open a new UL TBF, it can either use (P)RACH or request one in a Ack/Nack message for a DL TBF (PACCH). When a TBF becomes idle (LCC queue is empty but the TBF is kept open), there aren't any Ack/Nack requests that can be used by the MS to ask for an UL TBF, therefore it has to use the RACH. This leads to many RACH requests even for a single HTTP transaction, so it takes some time to retrieve even a simple web page. This commit modifies the scheduler to regularly send Ack/Nack requests on idle DL TBFs. It does so by extending the priority based scheduling algorithm to have 5 priority levels (highest priority first): - Control block is pending - High age (100%) threshold reached (-> request Ack/Nack) - Data is waiting or there are pending Nacks - Low age (200ms) threshold reached (-> request Ack/Nack) - Pending Nacks that have been resent already - None of the above (-> send DL dummy control block) The 'age' refers to the time since since the last control block has been sent on the TBF. This high age threshold is set to dl-tbf-idle-time or to 50% of T3190 (whichever is smaller), aiming for at least a poll (and TBF shutdown) after the TBF has expired and to safely prevent expiry of T3190. So if dl-tbf-idle-time > 200ms, there will be a poll every 200ms and a final poll after dl-tbf-idle-time. On high load, the interval between polls can get higher, but the 'high age' poll should be in place. This commit implements the scheduling with respect to GSM 44.060, 9.3.1a ("Delayed release of downlink TBF"). Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-20 13:26:05 +00:00
Scheduling data message at RTS for DL TFI=0 (TRX=0, TS=4) prio=3
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) downlink (V(A)==0 .. V(S)==0)
tbf: Fix downlink packet loss When the MS is pinged with a longer interval, many packets get lost even if the GprsMs object is kept. If the interval is above the time where the DL TBF is in state FLOW (mainly influenced be the dl-tbf-idle-time command), an new TBF must be requested via AGCH for each ICMP PING message. Currently the LLC frame containing the PING is immediately stored in the TBF and gets lost, if TBF establishment fails for some reason. This commit moves all calls to put_frame() to schedule_next_frame(), where the data is moved from the LLC queue to the frame storage within the TBF object. This method is only called from within create_new_bsn() when the TBF is in the FLOW state and the frame is going to be encoded immediately. At all other places, where put_frame() has been called before, the LLC message is just appended to the LLC queue in the GprsMs object. This change effectively simplifies the related code parts, since date/len information and discard notifications is no longer needed there. Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 12:06:09 +00:00
- Dequeue next LLC for TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) (len=200)
tbf: Include CS into create_new_bsn log message This change lets the test suite fail, so it get its own commit. Sponsored-by: On-Waves ehf
2015-06-12 08:48:05 +00:00
- Sending new block at BSN 0, CS=1
tbf/test: Add test for delayed release This tests checks the implementation of the delayed release of an downlink TBF. Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-25 09:48:52 +00:00
-- Chunk with length 200 larger than space (20) left in block: copy only remaining space, and we are done
data block: 07 00 01 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13
Sending data request: trx=0 ts=4 sapi=5 arfcn=0 fn=4 block=1 data=07 00 01 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
Received RTS for PDCH: TRX=0 TS=4 FN=8 block_nr=2 scheduling free USF for polling at FN=13 of TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW)
tbf: Poll MS on idle DL TBFs If an MS wants to open a new UL TBF, it can either use (P)RACH or request one in a Ack/Nack message for a DL TBF (PACCH). When a TBF becomes idle (LCC queue is empty but the TBF is kept open), there aren't any Ack/Nack requests that can be used by the MS to ask for an UL TBF, therefore it has to use the RACH. This leads to many RACH requests even for a single HTTP transaction, so it takes some time to retrieve even a simple web page. This commit modifies the scheduler to regularly send Ack/Nack requests on idle DL TBFs. It does so by extending the priority based scheduling algorithm to have 5 priority levels (highest priority first): - Control block is pending - High age (100%) threshold reached (-> request Ack/Nack) - Data is waiting or there are pending Nacks - Low age (200ms) threshold reached (-> request Ack/Nack) - Pending Nacks that have been resent already - None of the above (-> send DL dummy control block) The 'age' refers to the time since since the last control block has been sent on the TBF. This high age threshold is set to dl-tbf-idle-time or to 50% of T3190 (whichever is smaller), aiming for at least a poll (and TBF shutdown) after the TBF has expired and to safely prevent expiry of T3190. So if dl-tbf-idle-time > 200ms, there will be a poll every 200ms and a final poll after dl-tbf-idle-time. On high load, the interval between polls can get higher, but the 'high age' poll should be in place. This commit implements the scheduling with respect to GSM 44.060, 9.3.1a ("Delayed release of downlink TBF"). Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-20 13:26:05 +00:00
Scheduling data message at RTS for DL TFI=0 (TRX=0, TS=4) prio=3
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) downlink (V(A)==0 .. V(S)==1)
tbf: Include CS into create_new_bsn log message This change lets the test suite fail, so it get its own commit. Sponsored-by: On-Waves ehf
2015-06-12 08:48:05 +00:00
- Sending new block at BSN 1, CS=1
tbf/test: Add test for delayed release This tests checks the implementation of the delayed release of an downlink TBF. Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-25 09:48:52 +00:00
-- Chunk with length 180 larger than space (20) left in block: copy only remaining space, and we are done
data block: 07 00 03 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20 21 22 23 24 25 26 27
Sending data request: trx=0 ts=4 sapi=5 arfcn=0 fn=8 block=2 data=07 00 03 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20 21 22 23 24 25 26 27
tbf: Poll MS on idle DL TBFs If an MS wants to open a new UL TBF, it can either use (P)RACH or request one in a Ack/Nack message for a DL TBF (PACCH). When a TBF becomes idle (LCC queue is empty but the TBF is kept open), there aren't any Ack/Nack requests that can be used by the MS to ask for an UL TBF, therefore it has to use the RACH. This leads to many RACH requests even for a single HTTP transaction, so it takes some time to retrieve even a simple web page. This commit modifies the scheduler to regularly send Ack/Nack requests on idle DL TBFs. It does so by extending the priority based scheduling algorithm to have 5 priority levels (highest priority first): - Control block is pending - High age (100%) threshold reached (-> request Ack/Nack) - Data is waiting or there are pending Nacks - Low age (200ms) threshold reached (-> request Ack/Nack) - Pending Nacks that have been resent already - None of the above (-> send DL dummy control block) The 'age' refers to the time since since the last control block has been sent on the TBF. This high age threshold is set to dl-tbf-idle-time or to 50% of T3190 (whichever is smaller), aiming for at least a poll (and TBF shutdown) after the TBF has expired and to safely prevent expiry of T3190. So if dl-tbf-idle-time > 200ms, there will be a poll every 200ms and a final poll after dl-tbf-idle-time. On high load, the interval between polls can get higher, but the 'high age' poll should be in place. This commit implements the scheduling with respect to GSM 44.060, 9.3.1a ("Delayed release of downlink TBF"). Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-20 13:26:05 +00:00
Scheduling data message at RTS for DL TFI=0 (TRX=0, TS=4) prio=3
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) downlink (V(A)==0 .. V(S)==2)
tbf: Include CS into create_new_bsn log message This change lets the test suite fail, so it get its own commit. Sponsored-by: On-Waves ehf
2015-06-12 08:48:05 +00:00
- Sending new block at BSN 2, CS=1
tbf/test: Add test for delayed release This tests checks the implementation of the delayed release of an downlink TBF. Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-25 09:48:52 +00:00
-- Chunk with length 160 larger than space (20) left in block: copy only remaining space, and we are done
data block: 07 00 05 28 29 2a 2b 2c 2d 2e 2f 30 31 32 33 34 35 36 37 38 39 3a 3b
Sending data request: trx=0 ts=4 sapi=5 arfcn=0 fn=13 block=3 data=07 00 05 28 29 2a 2b 2c 2d 2e 2f 30 31 32 33 34 35 36 37 38 39 3a 3b
tbf: Poll MS on idle DL TBFs If an MS wants to open a new UL TBF, it can either use (P)RACH or request one in a Ack/Nack message for a DL TBF (PACCH). When a TBF becomes idle (LCC queue is empty but the TBF is kept open), there aren't any Ack/Nack requests that can be used by the MS to ask for an UL TBF, therefore it has to use the RACH. This leads to many RACH requests even for a single HTTP transaction, so it takes some time to retrieve even a simple web page. This commit modifies the scheduler to regularly send Ack/Nack requests on idle DL TBFs. It does so by extending the priority based scheduling algorithm to have 5 priority levels (highest priority first): - Control block is pending - High age (100%) threshold reached (-> request Ack/Nack) - Data is waiting or there are pending Nacks - Low age (200ms) threshold reached (-> request Ack/Nack) - Pending Nacks that have been resent already - None of the above (-> send DL dummy control block) The 'age' refers to the time since since the last control block has been sent on the TBF. This high age threshold is set to dl-tbf-idle-time or to 50% of T3190 (whichever is smaller), aiming for at least a poll (and TBF shutdown) after the TBF has expired and to safely prevent expiry of T3190. So if dl-tbf-idle-time > 200ms, there will be a poll every 200ms and a final poll after dl-tbf-idle-time. On high load, the interval between polls can get higher, but the 'high age' poll should be in place. This commit implements the scheduling with respect to GSM 44.060, 9.3.1a ("Delayed release of downlink TBF"). Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-20 13:26:05 +00:00
Scheduling data message at RTS for DL TFI=0 (TRX=0, TS=4) prio=3
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) downlink (V(A)==0 .. V(S)==3)
tbf: Include CS into create_new_bsn log message This change lets the test suite fail, so it get its own commit. Sponsored-by: On-Waves ehf
2015-06-12 08:48:05 +00:00
- Sending new block at BSN 3, CS=1
tbf/test: Add test for delayed release This tests checks the implementation of the delayed release of an downlink TBF. Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-25 09:48:52 +00:00
-- Chunk with length 140 larger than space (20) left in block: copy only remaining space, and we are done
data block: 07 00 07 3c 3d 3e 3f 40 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f
Sending data request: trx=0 ts=4 sapi=5 arfcn=0 fn=17 block=4 data=07 00 07 3c 3d 3e 3f 40 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f
tbf: Poll MS on idle DL TBFs If an MS wants to open a new UL TBF, it can either use (P)RACH or request one in a Ack/Nack message for a DL TBF (PACCH). When a TBF becomes idle (LCC queue is empty but the TBF is kept open), there aren't any Ack/Nack requests that can be used by the MS to ask for an UL TBF, therefore it has to use the RACH. This leads to many RACH requests even for a single HTTP transaction, so it takes some time to retrieve even a simple web page. This commit modifies the scheduler to regularly send Ack/Nack requests on idle DL TBFs. It does so by extending the priority based scheduling algorithm to have 5 priority levels (highest priority first): - Control block is pending - High age (100%) threshold reached (-> request Ack/Nack) - Data is waiting or there are pending Nacks - Low age (200ms) threshold reached (-> request Ack/Nack) - Pending Nacks that have been resent already - None of the above (-> send DL dummy control block) The 'age' refers to the time since since the last control block has been sent on the TBF. This high age threshold is set to dl-tbf-idle-time or to 50% of T3190 (whichever is smaller), aiming for at least a poll (and TBF shutdown) after the TBF has expired and to safely prevent expiry of T3190. So if dl-tbf-idle-time > 200ms, there will be a poll every 200ms and a final poll after dl-tbf-idle-time. On high load, the interval between polls can get higher, but the 'high age' poll should be in place. This commit implements the scheduling with respect to GSM 44.060, 9.3.1a ("Delayed release of downlink TBF"). Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-20 13:26:05 +00:00
Scheduling data message at RTS for DL TFI=0 (TRX=0, TS=4) prio=3
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) downlink (V(A)==0 .. V(S)==4)
tbf: Include CS into create_new_bsn log message This change lets the test suite fail, so it get its own commit. Sponsored-by: On-Waves ehf
2015-06-12 08:48:05 +00:00
- Sending new block at BSN 4, CS=1
tbf/test: Add test for delayed release This tests checks the implementation of the delayed release of an downlink TBF. Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-25 09:48:52 +00:00
-- Chunk with length 120 larger than space (20) left in block: copy only remaining space, and we are done
data block: 07 00 09 50 51 52 53 54 55 56 57 58 59 5a 5b 5c 5d 5e 5f 60 61 62 63
Sending data request: trx=0 ts=4 sapi=5 arfcn=0 fn=21 block=5 data=07 00 09 50 51 52 53 54 55 56 57 58 59 5a 5b 5c 5d 5e 5f 60 61 62 63
tbf: Poll MS on idle DL TBFs If an MS wants to open a new UL TBF, it can either use (P)RACH or request one in a Ack/Nack message for a DL TBF (PACCH). When a TBF becomes idle (LCC queue is empty but the TBF is kept open), there aren't any Ack/Nack requests that can be used by the MS to ask for an UL TBF, therefore it has to use the RACH. This leads to many RACH requests even for a single HTTP transaction, so it takes some time to retrieve even a simple web page. This commit modifies the scheduler to regularly send Ack/Nack requests on idle DL TBFs. It does so by extending the priority based scheduling algorithm to have 5 priority levels (highest priority first): - Control block is pending - High age (100%) threshold reached (-> request Ack/Nack) - Data is waiting or there are pending Nacks - Low age (200ms) threshold reached (-> request Ack/Nack) - Pending Nacks that have been resent already - None of the above (-> send DL dummy control block) The 'age' refers to the time since since the last control block has been sent on the TBF. This high age threshold is set to dl-tbf-idle-time or to 50% of T3190 (whichever is smaller), aiming for at least a poll (and TBF shutdown) after the TBF has expired and to safely prevent expiry of T3190. So if dl-tbf-idle-time > 200ms, there will be a poll every 200ms and a final poll after dl-tbf-idle-time. On high load, the interval between polls can get higher, but the 'high age' poll should be in place. This commit implements the scheduling with respect to GSM 44.060, 9.3.1a ("Delayed release of downlink TBF"). Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-20 13:26:05 +00:00
Scheduling data message at RTS for DL TFI=0 (TRX=0, TS=4) prio=3
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) downlink (V(A)==0 .. V(S)==5)
tbf: Include CS into create_new_bsn log message This change lets the test suite fail, so it get its own commit. Sponsored-by: On-Waves ehf
2015-06-12 08:48:05 +00:00
- Sending new block at BSN 5, CS=1
tbf/test: Add test for delayed release This tests checks the implementation of the delayed release of an downlink TBF. Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-25 09:48:52 +00:00
-- Chunk with length 100 larger than space (20) left in block: copy only remaining space, and we are done
data block: 07 00 0b 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f 70 71 72 73 74 75 76 77
Sending data request: trx=0 ts=4 sapi=5 arfcn=0 fn=26 block=6 data=07 00 0b 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f 70 71 72 73 74 75 76 77
tbf: Poll MS on idle DL TBFs If an MS wants to open a new UL TBF, it can either use (P)RACH or request one in a Ack/Nack message for a DL TBF (PACCH). When a TBF becomes idle (LCC queue is empty but the TBF is kept open), there aren't any Ack/Nack requests that can be used by the MS to ask for an UL TBF, therefore it has to use the RACH. This leads to many RACH requests even for a single HTTP transaction, so it takes some time to retrieve even a simple web page. This commit modifies the scheduler to regularly send Ack/Nack requests on idle DL TBFs. It does so by extending the priority based scheduling algorithm to have 5 priority levels (highest priority first): - Control block is pending - High age (100%) threshold reached (-> request Ack/Nack) - Data is waiting or there are pending Nacks - Low age (200ms) threshold reached (-> request Ack/Nack) - Pending Nacks that have been resent already - None of the above (-> send DL dummy control block) The 'age' refers to the time since since the last control block has been sent on the TBF. This high age threshold is set to dl-tbf-idle-time or to 50% of T3190 (whichever is smaller), aiming for at least a poll (and TBF shutdown) after the TBF has expired and to safely prevent expiry of T3190. So if dl-tbf-idle-time > 200ms, there will be a poll every 200ms and a final poll after dl-tbf-idle-time. On high load, the interval between polls can get higher, but the 'high age' poll should be in place. This commit implements the scheduling with respect to GSM 44.060, 9.3.1a ("Delayed release of downlink TBF"). Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-20 13:26:05 +00:00
Scheduling data message at RTS for DL TFI=0 (TRX=0, TS=4) prio=3
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) downlink (V(A)==0 .. V(S)==6)
tbf: Include CS into create_new_bsn log message This change lets the test suite fail, so it get its own commit. Sponsored-by: On-Waves ehf
2015-06-12 08:48:05 +00:00
- Sending new block at BSN 6, CS=1
tbf/test: Add test for delayed release This tests checks the implementation of the delayed release of an downlink TBF. Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-25 09:48:52 +00:00
-- Chunk with length 80 larger than space (20) left in block: copy only remaining space, and we are done
data block: 07 00 0d 78 79 7a 7b 7c 7d 7e 7f 80 81 82 83 84 85 86 87 88 89 8a 8b
Sending data request: trx=0 ts=4 sapi=5 arfcn=0 fn=30 block=7 data=07 00 0d 78 79 7a 7b 7c 7d 7e 7f 80 81 82 83 84 85 86 87 88 89 8a 8b
tbf: Poll MS on idle DL TBFs If an MS wants to open a new UL TBF, it can either use (P)RACH or request one in a Ack/Nack message for a DL TBF (PACCH). When a TBF becomes idle (LCC queue is empty but the TBF is kept open), there aren't any Ack/Nack requests that can be used by the MS to ask for an UL TBF, therefore it has to use the RACH. This leads to many RACH requests even for a single HTTP transaction, so it takes some time to retrieve even a simple web page. This commit modifies the scheduler to regularly send Ack/Nack requests on idle DL TBFs. It does so by extending the priority based scheduling algorithm to have 5 priority levels (highest priority first): - Control block is pending - High age (100%) threshold reached (-> request Ack/Nack) - Data is waiting or there are pending Nacks - Low age (200ms) threshold reached (-> request Ack/Nack) - Pending Nacks that have been resent already - None of the above (-> send DL dummy control block) The 'age' refers to the time since since the last control block has been sent on the TBF. This high age threshold is set to dl-tbf-idle-time or to 50% of T3190 (whichever is smaller), aiming for at least a poll (and TBF shutdown) after the TBF has expired and to safely prevent expiry of T3190. So if dl-tbf-idle-time > 200ms, there will be a poll every 200ms and a final poll after dl-tbf-idle-time. On high load, the interval between polls can get higher, but the 'high age' poll should be in place. This commit implements the scheduling with respect to GSM 44.060, 9.3.1a ("Delayed release of downlink TBF"). Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-20 13:26:05 +00:00
Scheduling data message at RTS for DL TFI=0 (TRX=0, TS=4) prio=3
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) downlink (V(A)==0 .. V(S)==7)
tbf: Include CS into create_new_bsn log message This change lets the test suite fail, so it get its own commit. Sponsored-by: On-Waves ehf
2015-06-12 08:48:05 +00:00
- Sending new block at BSN 7, CS=1
tbf/test: Add test for delayed release This tests checks the implementation of the delayed release of an downlink TBF. Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-25 09:48:52 +00:00
-- Chunk with length 60 larger than space (20) left in block: copy only remaining space, and we are done
data block: 07 00 0f 8c 8d 8e 8f 90 91 92 93 94 95 96 97 98 99 9a 9b 9c 9d 9e 9f
Sending data request: trx=0 ts=4 sapi=5 arfcn=0 fn=34 block=8 data=07 00 0f 8c 8d 8e 8f 90 91 92 93 94 95 96 97 98 99 9a 9b 9c 9d 9e 9f
tbf: Poll MS on idle DL TBFs If an MS wants to open a new UL TBF, it can either use (P)RACH or request one in a Ack/Nack message for a DL TBF (PACCH). When a TBF becomes idle (LCC queue is empty but the TBF is kept open), there aren't any Ack/Nack requests that can be used by the MS to ask for an UL TBF, therefore it has to use the RACH. This leads to many RACH requests even for a single HTTP transaction, so it takes some time to retrieve even a simple web page. This commit modifies the scheduler to regularly send Ack/Nack requests on idle DL TBFs. It does so by extending the priority based scheduling algorithm to have 5 priority levels (highest priority first): - Control block is pending - High age (100%) threshold reached (-> request Ack/Nack) - Data is waiting or there are pending Nacks - Low age (200ms) threshold reached (-> request Ack/Nack) - Pending Nacks that have been resent already - None of the above (-> send DL dummy control block) The 'age' refers to the time since since the last control block has been sent on the TBF. This high age threshold is set to dl-tbf-idle-time or to 50% of T3190 (whichever is smaller), aiming for at least a poll (and TBF shutdown) after the TBF has expired and to safely prevent expiry of T3190. So if dl-tbf-idle-time > 200ms, there will be a poll every 200ms and a final poll after dl-tbf-idle-time. On high load, the interval between polls can get higher, but the 'high age' poll should be in place. This commit implements the scheduling with respect to GSM 44.060, 9.3.1a ("Delayed release of downlink TBF"). Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-20 13:26:05 +00:00
Scheduling data message at RTS for DL TFI=0 (TRX=0, TS=4) prio=3
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) downlink (V(A)==0 .. V(S)==8)
tbf: Include CS into create_new_bsn log message This change lets the test suite fail, so it get its own commit. Sponsored-by: On-Waves ehf
2015-06-12 08:48:05 +00:00
- Sending new block at BSN 8, CS=1
tbf/test: Add test for delayed release This tests checks the implementation of the delayed release of an downlink TBF. Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-25 09:48:52 +00:00
-- Chunk with length 40 larger than space (20) left in block: copy only remaining space, and we are done
data block: 07 00 11 a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 aa ab ac ad ae af b0 b1 b2 b3
Sending data request: trx=0 ts=4 sapi=5 arfcn=0 fn=39 block=9 data=07 00 11 a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 aa ab ac ad ae af b0 b1 b2 b3
tbf: Poll MS on idle DL TBFs If an MS wants to open a new UL TBF, it can either use (P)RACH or request one in a Ack/Nack message for a DL TBF (PACCH). When a TBF becomes idle (LCC queue is empty but the TBF is kept open), there aren't any Ack/Nack requests that can be used by the MS to ask for an UL TBF, therefore it has to use the RACH. This leads to many RACH requests even for a single HTTP transaction, so it takes some time to retrieve even a simple web page. This commit modifies the scheduler to regularly send Ack/Nack requests on idle DL TBFs. It does so by extending the priority based scheduling algorithm to have 5 priority levels (highest priority first): - Control block is pending - High age (100%) threshold reached (-> request Ack/Nack) - Data is waiting or there are pending Nacks - Low age (200ms) threshold reached (-> request Ack/Nack) - Pending Nacks that have been resent already - None of the above (-> send DL dummy control block) The 'age' refers to the time since since the last control block has been sent on the TBF. This high age threshold is set to dl-tbf-idle-time or to 50% of T3190 (whichever is smaller), aiming for at least a poll (and TBF shutdown) after the TBF has expired and to safely prevent expiry of T3190. So if dl-tbf-idle-time > 200ms, there will be a poll every 200ms and a final poll after dl-tbf-idle-time. On high load, the interval between polls can get higher, but the 'high age' poll should be in place. This commit implements the scheduling with respect to GSM 44.060, 9.3.1a ("Delayed release of downlink TBF"). Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-20 13:26:05 +00:00
Scheduling data message at RTS for DL TFI=0 (TRX=0, TS=4) prio=3
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) downlink (V(A)==0 .. V(S)==9)
tbf: Include CS into create_new_bsn log message This change lets the test suite fail, so it get its own commit. Sponsored-by: On-Waves ehf
2015-06-12 08:48:05 +00:00
- Sending new block at BSN 9, CS=1
tbf/test: Add test for delayed release This tests checks the implementation of the delayed release of an downlink TBF. Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-25 09:48:52 +00:00
-- Chunk with length 20 would exactly fit into space (20): add length header with LI=0, to make frame extend to next block, and we are done
data block: 07 00 12 01 b4 b5 b6 b7 b8 b9 ba bb bc bd be bf c0 c1 c2 c3 c4 c5 c6
Sending data request: trx=0 ts=4 sapi=5 arfcn=0 fn=43 block=10 data=07 00 12 01 b4 b5 b6 b7 b8 b9 ba bb bc bd be bf c0 c1 c2 c3 c4 c5 c6
tbf: Poll MS on idle DL TBFs If an MS wants to open a new UL TBF, it can either use (P)RACH or request one in a Ack/Nack message for a DL TBF (PACCH). When a TBF becomes idle (LCC queue is empty but the TBF is kept open), there aren't any Ack/Nack requests that can be used by the MS to ask for an UL TBF, therefore it has to use the RACH. This leads to many RACH requests even for a single HTTP transaction, so it takes some time to retrieve even a simple web page. This commit modifies the scheduler to regularly send Ack/Nack requests on idle DL TBFs. It does so by extending the priority based scheduling algorithm to have 5 priority levels (highest priority first): - Control block is pending - High age (100%) threshold reached (-> request Ack/Nack) - Data is waiting or there are pending Nacks - Low age (200ms) threshold reached (-> request Ack/Nack) - Pending Nacks that have been resent already - None of the above (-> send DL dummy control block) The 'age' refers to the time since since the last control block has been sent on the TBF. This high age threshold is set to dl-tbf-idle-time or to 50% of T3190 (whichever is smaller), aiming for at least a poll (and TBF shutdown) after the TBF has expired and to safely prevent expiry of T3190. So if dl-tbf-idle-time > 200ms, there will be a poll every 200ms and a final poll after dl-tbf-idle-time. On high load, the interval between polls can get higher, but the 'high age' poll should be in place. This commit implements the scheduling with respect to GSM 44.060, 9.3.1a ("Delayed release of downlink TBF"). Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-20 13:26:05 +00:00
Scheduling data message at RTS for DL TFI=0 (TRX=0, TS=4) prio=3
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) downlink (V(A)==0 .. V(S)==10)
tbf: Include CS into create_new_bsn log message This change lets the test suite fail, so it get its own commit. Sponsored-by: On-Waves ehf
2015-06-12 08:48:05 +00:00
- Sending new block at BSN 10, CS=1
tbf/test: Add test for delayed release This tests checks the implementation of the delayed release of an downlink TBF. Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-25 09:48:52 +00:00
-- Chunk with length 1 is less than remaining space (20): add length header to to delimit LLC frame
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
Complete DL frame for TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW)len=200
- Dequeue next LLC for TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) (len=200)
tbf/test: Add test for delayed release This tests checks the implementation of the delayed release of an downlink TBF. Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-25 09:48:52 +00:00
-- Chunk with length 200 larger than space (18) left in block: copy only remaining space, and we are done
data block: 07 00 14 07 c7 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11
Sending data request: trx=0 ts=4 sapi=5 arfcn=0 fn=47 block=11 data=07 00 14 07 c7 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11
tbf: Poll MS on idle DL TBFs If an MS wants to open a new UL TBF, it can either use (P)RACH or request one in a Ack/Nack message for a DL TBF (PACCH). When a TBF becomes idle (LCC queue is empty but the TBF is kept open), there aren't any Ack/Nack requests that can be used by the MS to ask for an UL TBF, therefore it has to use the RACH. This leads to many RACH requests even for a single HTTP transaction, so it takes some time to retrieve even a simple web page. This commit modifies the scheduler to regularly send Ack/Nack requests on idle DL TBFs. It does so by extending the priority based scheduling algorithm to have 5 priority levels (highest priority first): - Control block is pending - High age (100%) threshold reached (-> request Ack/Nack) - Data is waiting or there are pending Nacks - Low age (200ms) threshold reached (-> request Ack/Nack) - Pending Nacks that have been resent already - None of the above (-> send DL dummy control block) The 'age' refers to the time since since the last control block has been sent on the TBF. This high age threshold is set to dl-tbf-idle-time or to 50% of T3190 (whichever is smaller), aiming for at least a poll (and TBF shutdown) after the TBF has expired and to safely prevent expiry of T3190. So if dl-tbf-idle-time > 200ms, there will be a poll every 200ms and a final poll after dl-tbf-idle-time. On high load, the interval between polls can get higher, but the 'high age' poll should be in place. This commit implements the scheduling with respect to GSM 44.060, 9.3.1a ("Delayed release of downlink TBF"). Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-20 13:26:05 +00:00
Scheduling data message at RTS for DL TFI=0 (TRX=0, TS=4) prio=4
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) downlink (V(A)==0 .. V(S)==11)
tbf: Include CS into create_new_bsn log message This change lets the test suite fail, so it get its own commit. Sponsored-by: On-Waves ehf
2015-06-12 08:48:05 +00:00
- Sending new block at BSN 11, CS=1
tbf/test: Add test for delayed release This tests checks the implementation of the delayed release of an downlink TBF. Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-25 09:48:52 +00:00
-- Chunk with length 182 larger than space (20) left in block: copy only remaining space, and we are done
data block: 07 00 17 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20 21 22 23 24 25
Sending data request: trx=0 ts=4 sapi=5 arfcn=0 fn=52 block=12 data=07 00 17 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20 21 22 23 24 25
tbf: Poll MS on idle DL TBFs If an MS wants to open a new UL TBF, it can either use (P)RACH or request one in a Ack/Nack message for a DL TBF (PACCH). When a TBF becomes idle (LCC queue is empty but the TBF is kept open), there aren't any Ack/Nack requests that can be used by the MS to ask for an UL TBF, therefore it has to use the RACH. This leads to many RACH requests even for a single HTTP transaction, so it takes some time to retrieve even a simple web page. This commit modifies the scheduler to regularly send Ack/Nack requests on idle DL TBFs. It does so by extending the priority based scheduling algorithm to have 5 priority levels (highest priority first): - Control block is pending - High age (100%) threshold reached (-> request Ack/Nack) - Data is waiting or there are pending Nacks - Low age (200ms) threshold reached (-> request Ack/Nack) - Pending Nacks that have been resent already - None of the above (-> send DL dummy control block) The 'age' refers to the time since since the last control block has been sent on the TBF. This high age threshold is set to dl-tbf-idle-time or to 50% of T3190 (whichever is smaller), aiming for at least a poll (and TBF shutdown) after the TBF has expired and to safely prevent expiry of T3190. So if dl-tbf-idle-time > 200ms, there will be a poll every 200ms and a final poll after dl-tbf-idle-time. On high load, the interval between polls can get higher, but the 'high age' poll should be in place. This commit implements the scheduling with respect to GSM 44.060, 9.3.1a ("Delayed release of downlink TBF"). Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-20 13:26:05 +00:00
Scheduling data message at RTS for DL TFI=0 (TRX=0, TS=4) prio=4
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) downlink (V(A)==0 .. V(S)==12)
tbf: Include CS into create_new_bsn log message This change lets the test suite fail, so it get its own commit. Sponsored-by: On-Waves ehf
2015-06-12 08:48:05 +00:00
- Sending new block at BSN 12, CS=1
tbf/test: Add test for delayed release This tests checks the implementation of the delayed release of an downlink TBF. Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-25 09:48:52 +00:00
-- Chunk with length 162 larger than space (20) left in block: copy only remaining space, and we are done
data block: 07 00 19 26 27 28 29 2a 2b 2c 2d 2e 2f 30 31 32 33 34 35 36 37 38 39
Sending data request: trx=0 ts=4 sapi=5 arfcn=0 fn=56 block=13 data=07 00 19 26 27 28 29 2a 2b 2c 2d 2e 2f 30 31 32 33 34 35 36 37 38 39
tbf: Poll MS on idle DL TBFs If an MS wants to open a new UL TBF, it can either use (P)RACH or request one in a Ack/Nack message for a DL TBF (PACCH). When a TBF becomes idle (LCC queue is empty but the TBF is kept open), there aren't any Ack/Nack requests that can be used by the MS to ask for an UL TBF, therefore it has to use the RACH. This leads to many RACH requests even for a single HTTP transaction, so it takes some time to retrieve even a simple web page. This commit modifies the scheduler to regularly send Ack/Nack requests on idle DL TBFs. It does so by extending the priority based scheduling algorithm to have 5 priority levels (highest priority first): - Control block is pending - High age (100%) threshold reached (-> request Ack/Nack) - Data is waiting or there are pending Nacks - Low age (200ms) threshold reached (-> request Ack/Nack) - Pending Nacks that have been resent already - None of the above (-> send DL dummy control block) The 'age' refers to the time since since the last control block has been sent on the TBF. This high age threshold is set to dl-tbf-idle-time or to 50% of T3190 (whichever is smaller), aiming for at least a poll (and TBF shutdown) after the TBF has expired and to safely prevent expiry of T3190. So if dl-tbf-idle-time > 200ms, there will be a poll every 200ms and a final poll after dl-tbf-idle-time. On high load, the interval between polls can get higher, but the 'high age' poll should be in place. This commit implements the scheduling with respect to GSM 44.060, 9.3.1a ("Delayed release of downlink TBF"). Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-20 13:26:05 +00:00
Scheduling data message at RTS for DL TFI=0 (TRX=0, TS=4) prio=4
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) downlink (V(A)==0 .. V(S)==13)
tbf: Include CS into create_new_bsn log message This change lets the test suite fail, so it get its own commit. Sponsored-by: On-Waves ehf
2015-06-12 08:48:05 +00:00
- Sending new block at BSN 13, CS=1
tbf/test: Add test for delayed release This tests checks the implementation of the delayed release of an downlink TBF. Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-25 09:48:52 +00:00
-- Chunk with length 142 larger than space (20) left in block: copy only remaining space, and we are done
data block: 07 00 1b 3a 3b 3c 3d 3e 3f 40 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d
Sending data request: trx=0 ts=4 sapi=5 arfcn=0 fn=60 block=14 data=07 00 1b 3a 3b 3c 3d 3e 3f 40 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d
tbf: Poll MS on idle DL TBFs If an MS wants to open a new UL TBF, it can either use (P)RACH or request one in a Ack/Nack message for a DL TBF (PACCH). When a TBF becomes idle (LCC queue is empty but the TBF is kept open), there aren't any Ack/Nack requests that can be used by the MS to ask for an UL TBF, therefore it has to use the RACH. This leads to many RACH requests even for a single HTTP transaction, so it takes some time to retrieve even a simple web page. This commit modifies the scheduler to regularly send Ack/Nack requests on idle DL TBFs. It does so by extending the priority based scheduling algorithm to have 5 priority levels (highest priority first): - Control block is pending - High age (100%) threshold reached (-> request Ack/Nack) - Data is waiting or there are pending Nacks - Low age (200ms) threshold reached (-> request Ack/Nack) - Pending Nacks that have been resent already - None of the above (-> send DL dummy control block) The 'age' refers to the time since since the last control block has been sent on the TBF. This high age threshold is set to dl-tbf-idle-time or to 50% of T3190 (whichever is smaller), aiming for at least a poll (and TBF shutdown) after the TBF has expired and to safely prevent expiry of T3190. So if dl-tbf-idle-time > 200ms, there will be a poll every 200ms and a final poll after dl-tbf-idle-time. On high load, the interval between polls can get higher, but the 'high age' poll should be in place. This commit implements the scheduling with respect to GSM 44.060, 9.3.1a ("Delayed release of downlink TBF"). Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-20 13:26:05 +00:00
Scheduling data message at RTS for DL TFI=0 (TRX=0, TS=4) prio=4
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) downlink (V(A)==0 .. V(S)==14)
tbf: Include CS into create_new_bsn log message This change lets the test suite fail, so it get its own commit. Sponsored-by: On-Waves ehf
2015-06-12 08:48:05 +00:00
- Sending new block at BSN 14, CS=1
tbf/test: Add test for delayed release This tests checks the implementation of the delayed release of an downlink TBF. Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-25 09:48:52 +00:00
-- Chunk with length 122 larger than space (20) left in block: copy only remaining space, and we are done
data block: 07 00 1d 4e 4f 50 51 52 53 54 55 56 57 58 59 5a 5b 5c 5d 5e 5f 60 61
Sending data request: trx=0 ts=4 sapi=5 arfcn=0 fn=65 block=15 data=07 00 1d 4e 4f 50 51 52 53 54 55 56 57 58 59 5a 5b 5c 5d 5e 5f 60 61
tbf: Poll MS on idle DL TBFs If an MS wants to open a new UL TBF, it can either use (P)RACH or request one in a Ack/Nack message for a DL TBF (PACCH). When a TBF becomes idle (LCC queue is empty but the TBF is kept open), there aren't any Ack/Nack requests that can be used by the MS to ask for an UL TBF, therefore it has to use the RACH. This leads to many RACH requests even for a single HTTP transaction, so it takes some time to retrieve even a simple web page. This commit modifies the scheduler to regularly send Ack/Nack requests on idle DL TBFs. It does so by extending the priority based scheduling algorithm to have 5 priority levels (highest priority first): - Control block is pending - High age (100%) threshold reached (-> request Ack/Nack) - Data is waiting or there are pending Nacks - Low age (200ms) threshold reached (-> request Ack/Nack) - Pending Nacks that have been resent already - None of the above (-> send DL dummy control block) The 'age' refers to the time since since the last control block has been sent on the TBF. This high age threshold is set to dl-tbf-idle-time or to 50% of T3190 (whichever is smaller), aiming for at least a poll (and TBF shutdown) after the TBF has expired and to safely prevent expiry of T3190. So if dl-tbf-idle-time > 200ms, there will be a poll every 200ms and a final poll after dl-tbf-idle-time. On high load, the interval between polls can get higher, but the 'high age' poll should be in place. This commit implements the scheduling with respect to GSM 44.060, 9.3.1a ("Delayed release of downlink TBF"). Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-20 13:26:05 +00:00
Scheduling data message at RTS for DL TFI=0 (TRX=0, TS=4) prio=4
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) downlink (V(A)==0 .. V(S)==15)
tbf: Include CS into create_new_bsn log message This change lets the test suite fail, so it get its own commit. Sponsored-by: On-Waves ehf
2015-06-12 08:48:05 +00:00
- Sending new block at BSN 15, CS=1
tbf/test: Add test for delayed release This tests checks the implementation of the delayed release of an downlink TBF. Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-25 09:48:52 +00:00
-- Chunk with length 102 larger than space (20) left in block: copy only remaining space, and we are done
data block: 07 00 1f 62 63 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f 70 71 72 73 74 75
Sending data request: trx=0 ts=4 sapi=5 arfcn=0 fn=69 block=16 data=07 00 1f 62 63 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f 70 71 72 73 74 75
tbf: Poll MS on idle DL TBFs If an MS wants to open a new UL TBF, it can either use (P)RACH or request one in a Ack/Nack message for a DL TBF (PACCH). When a TBF becomes idle (LCC queue is empty but the TBF is kept open), there aren't any Ack/Nack requests that can be used by the MS to ask for an UL TBF, therefore it has to use the RACH. This leads to many RACH requests even for a single HTTP transaction, so it takes some time to retrieve even a simple web page. This commit modifies the scheduler to regularly send Ack/Nack requests on idle DL TBFs. It does so by extending the priority based scheduling algorithm to have 5 priority levels (highest priority first): - Control block is pending - High age (100%) threshold reached (-> request Ack/Nack) - Data is waiting or there are pending Nacks - Low age (200ms) threshold reached (-> request Ack/Nack) - Pending Nacks that have been resent already - None of the above (-> send DL dummy control block) The 'age' refers to the time since since the last control block has been sent on the TBF. This high age threshold is set to dl-tbf-idle-time or to 50% of T3190 (whichever is smaller), aiming for at least a poll (and TBF shutdown) after the TBF has expired and to safely prevent expiry of T3190. So if dl-tbf-idle-time > 200ms, there will be a poll every 200ms and a final poll after dl-tbf-idle-time. On high load, the interval between polls can get higher, but the 'high age' poll should be in place. This commit implements the scheduling with respect to GSM 44.060, 9.3.1a ("Delayed release of downlink TBF"). Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-20 13:26:05 +00:00
Scheduling data message at RTS for DL TFI=0 (TRX=0, TS=4) prio=4
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) downlink (V(A)==0 .. V(S)==16)
tbf: Include CS into create_new_bsn log message This change lets the test suite fail, so it get its own commit. Sponsored-by: On-Waves ehf
2015-06-12 08:48:05 +00:00
- Sending new block at BSN 16, CS=1
tbf/test: Add test for delayed release This tests checks the implementation of the delayed release of an downlink TBF. Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-25 09:48:52 +00:00
-- Chunk with length 82 larger than space (20) left in block: copy only remaining space, and we are done
data block: 07 00 21 76 77 78 79 7a 7b 7c 7d 7e 7f 80 81 82 83 84 85 86 87 88 89
Sending data request: trx=0 ts=4 sapi=5 arfcn=0 fn=73 block=17 data=07 00 21 76 77 78 79 7a 7b 7c 7d 7e 7f 80 81 82 83 84 85 86 87 88 89
tbf: Poll MS on idle DL TBFs If an MS wants to open a new UL TBF, it can either use (P)RACH or request one in a Ack/Nack message for a DL TBF (PACCH). When a TBF becomes idle (LCC queue is empty but the TBF is kept open), there aren't any Ack/Nack requests that can be used by the MS to ask for an UL TBF, therefore it has to use the RACH. This leads to many RACH requests even for a single HTTP transaction, so it takes some time to retrieve even a simple web page. This commit modifies the scheduler to regularly send Ack/Nack requests on idle DL TBFs. It does so by extending the priority based scheduling algorithm to have 5 priority levels (highest priority first): - Control block is pending - High age (100%) threshold reached (-> request Ack/Nack) - Data is waiting or there are pending Nacks - Low age (200ms) threshold reached (-> request Ack/Nack) - Pending Nacks that have been resent already - None of the above (-> send DL dummy control block) The 'age' refers to the time since since the last control block has been sent on the TBF. This high age threshold is set to dl-tbf-idle-time or to 50% of T3190 (whichever is smaller), aiming for at least a poll (and TBF shutdown) after the TBF has expired and to safely prevent expiry of T3190. So if dl-tbf-idle-time > 200ms, there will be a poll every 200ms and a final poll after dl-tbf-idle-time. On high load, the interval between polls can get higher, but the 'high age' poll should be in place. This commit implements the scheduling with respect to GSM 44.060, 9.3.1a ("Delayed release of downlink TBF"). Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-20 13:26:05 +00:00
Scheduling data message at RTS for DL TFI=0 (TRX=0, TS=4) prio=4
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) downlink (V(A)==0 .. V(S)==17)
tbf: Include CS into create_new_bsn log message This change lets the test suite fail, so it get its own commit. Sponsored-by: On-Waves ehf
2015-06-12 08:48:05 +00:00
- Sending new block at BSN 17, CS=1
tbf/test: Add test for delayed release This tests checks the implementation of the delayed release of an downlink TBF. Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-25 09:48:52 +00:00
-- Chunk with length 62 larger than space (20) left in block: copy only remaining space, and we are done
data block: 07 00 23 8a 8b 8c 8d 8e 8f 90 91 92 93 94 95 96 97 98 99 9a 9b 9c 9d
Sending data request: trx=0 ts=4 sapi=5 arfcn=0 fn=78 block=18 data=07 00 23 8a 8b 8c 8d 8e 8f 90 91 92 93 94 95 96 97 98 99 9a 9b 9c 9d
tbf: Poll MS on idle DL TBFs If an MS wants to open a new UL TBF, it can either use (P)RACH or request one in a Ack/Nack message for a DL TBF (PACCH). When a TBF becomes idle (LCC queue is empty but the TBF is kept open), there aren't any Ack/Nack requests that can be used by the MS to ask for an UL TBF, therefore it has to use the RACH. This leads to many RACH requests even for a single HTTP transaction, so it takes some time to retrieve even a simple web page. This commit modifies the scheduler to regularly send Ack/Nack requests on idle DL TBFs. It does so by extending the priority based scheduling algorithm to have 5 priority levels (highest priority first): - Control block is pending - High age (100%) threshold reached (-> request Ack/Nack) - Data is waiting or there are pending Nacks - Low age (200ms) threshold reached (-> request Ack/Nack) - Pending Nacks that have been resent already - None of the above (-> send DL dummy control block) The 'age' refers to the time since since the last control block has been sent on the TBF. This high age threshold is set to dl-tbf-idle-time or to 50% of T3190 (whichever is smaller), aiming for at least a poll (and TBF shutdown) after the TBF has expired and to safely prevent expiry of T3190. So if dl-tbf-idle-time > 200ms, there will be a poll every 200ms and a final poll after dl-tbf-idle-time. On high load, the interval between polls can get higher, but the 'high age' poll should be in place. This commit implements the scheduling with respect to GSM 44.060, 9.3.1a ("Delayed release of downlink TBF"). Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-20 13:26:05 +00:00
Scheduling data message at RTS for DL TFI=0 (TRX=0, TS=4) prio=4
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) downlink (V(A)==0 .. V(S)==18)
tbf: Include CS into create_new_bsn log message This change lets the test suite fail, so it get its own commit. Sponsored-by: On-Waves ehf
2015-06-12 08:48:05 +00:00
- Sending new block at BSN 18, CS=1
tbf/test: Add test for delayed release This tests checks the implementation of the delayed release of an downlink TBF. Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-25 09:48:52 +00:00
-- Chunk with length 42 larger than space (20) left in block: copy only remaining space, and we are done
data block: 07 00 25 9e 9f a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 aa ab ac ad ae af b0 b1
Sending data request: trx=0 ts=4 sapi=5 arfcn=0 fn=82 block=19 data=07 00 25 9e 9f a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 aa ab ac ad ae af b0 b1
tbf: Poll MS on idle DL TBFs If an MS wants to open a new UL TBF, it can either use (P)RACH or request one in a Ack/Nack message for a DL TBF (PACCH). When a TBF becomes idle (LCC queue is empty but the TBF is kept open), there aren't any Ack/Nack requests that can be used by the MS to ask for an UL TBF, therefore it has to use the RACH. This leads to many RACH requests even for a single HTTP transaction, so it takes some time to retrieve even a simple web page. This commit modifies the scheduler to regularly send Ack/Nack requests on idle DL TBFs. It does so by extending the priority based scheduling algorithm to have 5 priority levels (highest priority first): - Control block is pending - High age (100%) threshold reached (-> request Ack/Nack) - Data is waiting or there are pending Nacks - Low age (200ms) threshold reached (-> request Ack/Nack) - Pending Nacks that have been resent already - None of the above (-> send DL dummy control block) The 'age' refers to the time since since the last control block has been sent on the TBF. This high age threshold is set to dl-tbf-idle-time or to 50% of T3190 (whichever is smaller), aiming for at least a poll (and TBF shutdown) after the TBF has expired and to safely prevent expiry of T3190. So if dl-tbf-idle-time > 200ms, there will be a poll every 200ms and a final poll after dl-tbf-idle-time. On high load, the interval between polls can get higher, but the 'high age' poll should be in place. This commit implements the scheduling with respect to GSM 44.060, 9.3.1a ("Delayed release of downlink TBF"). Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-20 13:26:05 +00:00
Scheduling data message at RTS for DL TFI=0 (TRX=0, TS=4) prio=4
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) downlink (V(A)==0 .. V(S)==19)
tbf: Include CS into create_new_bsn log message This change lets the test suite fail, so it get its own commit. Sponsored-by: On-Waves ehf
2015-06-12 08:48:05 +00:00
- Sending new block at BSN 19, CS=1
tbf/test: Add test for delayed release This tests checks the implementation of the delayed release of an downlink TBF. Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-25 09:48:52 +00:00
-- Chunk with length 22 larger than space (20) left in block: copy only remaining space, and we are done
data block: 07 00 27 b2 b3 b4 b5 b6 b7 b8 b9 ba bb bc bd be bf c0 c1 c2 c3 c4 c5
Sending data request: trx=0 ts=4 sapi=5 arfcn=0 fn=86 block=20 data=07 00 27 b2 b3 b4 b5 b6 b7 b8 b9 ba bb bc bd be bf c0 c1 c2 c3 c4 c5
tbf: Poll MS on idle DL TBFs If an MS wants to open a new UL TBF, it can either use (P)RACH or request one in a Ack/Nack message for a DL TBF (PACCH). When a TBF becomes idle (LCC queue is empty but the TBF is kept open), there aren't any Ack/Nack requests that can be used by the MS to ask for an UL TBF, therefore it has to use the RACH. This leads to many RACH requests even for a single HTTP transaction, so it takes some time to retrieve even a simple web page. This commit modifies the scheduler to regularly send Ack/Nack requests on idle DL TBFs. It does so by extending the priority based scheduling algorithm to have 5 priority levels (highest priority first): - Control block is pending - High age (100%) threshold reached (-> request Ack/Nack) - Data is waiting or there are pending Nacks - Low age (200ms) threshold reached (-> request Ack/Nack) - Pending Nacks that have been resent already - None of the above (-> send DL dummy control block) The 'age' refers to the time since since the last control block has been sent on the TBF. This high age threshold is set to dl-tbf-idle-time or to 50% of T3190 (whichever is smaller), aiming for at least a poll (and TBF shutdown) after the TBF has expired and to safely prevent expiry of T3190. So if dl-tbf-idle-time > 200ms, there will be a poll every 200ms and a final poll after dl-tbf-idle-time. On high load, the interval between polls can get higher, but the 'high age' poll should be in place. This commit implements the scheduling with respect to GSM 44.060, 9.3.1a ("Delayed release of downlink TBF"). Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-20 13:26:05 +00:00
Scheduling data message at RTS for DL TFI=0 (TRX=0, TS=4) prio=4
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) downlink (V(A)==0 .. V(S)==20)
tbf: Include CS into create_new_bsn log message This change lets the test suite fail, so it get its own commit. Sponsored-by: On-Waves ehf
2015-06-12 08:48:05 +00:00
- Sending new block at BSN 20, CS=1
tbf/test: Add test for delayed release This tests checks the implementation of the delayed release of an downlink TBF. Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-25 09:48:52 +00:00
-- Chunk with length 2 is less than remaining space (20): add length header to to delimit LLC frame
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
Complete DL frame for TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW)len=200
tbf/test: Add test for delayed release This tests checks the implementation of the delayed release of an downlink TBF. Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-25 09:48:52 +00:00
-- Empty chunk, added LLC dummy command of size 16, drained_since=0
-- Chunk with length 16 is less than remaining space (17): add length header to to delimit LLC frame
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
Complete DL frame for TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW)len=16
tbf/test: Add test for delayed release This tests checks the implementation of the delayed release of an downlink TBF. Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-25 09:48:52 +00:00
-- No space left, so we are done.
data block: 07 00 28 0a 41 c6 c7 43 c0 01 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b
- Scheduling Ack/Nack polling, because is was requested explicitly (e.g. first final block sent).
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
Polling is already sheduled for TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW), so we must wait for requesting downlink ack
tbf/test: Add test for delayed release This tests checks the implementation of the delayed release of an downlink TBF. Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-25 09:48:52 +00:00
Sending data request: trx=0 ts=4 sapi=5 arfcn=0 fn=91 block=21 data=07 00 28 0a 41 c6 c7 43 c0 01 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) downlink acknowledge
tbf/test: Add test for delayed release This tests checks the implementation of the delayed release of an downlink TBF. Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-25 09:48:52 +00:00
- ack: (BSN=85)"RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR"(BSN=20) R=ACK I=NACK
- got ack for BSN=20
- got ack for BSN=19
- got ack for BSN=18
- got ack for BSN=17
- got ack for BSN=16
- got ack for BSN=15
- got ack for BSN=14
- got ack for BSN=13
- got ack for BSN=12
- got ack for BSN=11
- got ack for BSN=10
- got ack for BSN=9
- got ack for BSN=8
- got ack for BSN=7
- got ack for BSN=6
- got ack for BSN=5
- got ack for BSN=4
- got ack for BSN=3
- got ack for BSN=2
- got ack for BSN=1
- got ack for BSN=0
- V(B): (V(A)=21)""(V(S)-1=20) A=Acked N=Nacked U=Unacked X=Resend-Unacked I=Invalid
tbf: Poll MS on idle DL TBFs If an MS wants to open a new UL TBF, it can either use (P)RACH or request one in a Ack/Nack message for a DL TBF (PACCH). When a TBF becomes idle (LCC queue is empty but the TBF is kept open), there aren't any Ack/Nack requests that can be used by the MS to ask for an UL TBF, therefore it has to use the RACH. This leads to many RACH requests even for a single HTTP transaction, so it takes some time to retrieve even a simple web page. This commit modifies the scheduler to regularly send Ack/Nack requests on idle DL TBFs. It does so by extending the priority based scheduling algorithm to have 5 priority levels (highest priority first): - Control block is pending - High age (100%) threshold reached (-> request Ack/Nack) - Data is waiting or there are pending Nacks - Low age (200ms) threshold reached (-> request Ack/Nack) - Pending Nacks that have been resent already - None of the above (-> send DL dummy control block) The 'age' refers to the time since since the last control block has been sent on the TBF. This high age threshold is set to dl-tbf-idle-time or to 50% of T3190 (whichever is smaller), aiming for at least a poll (and TBF shutdown) after the TBF has expired and to safely prevent expiry of T3190. So if dl-tbf-idle-time > 200ms, there will be a poll every 200ms and a final poll after dl-tbf-idle-time. On high load, the interval between polls can get higher, but the 'high age' poll should be in place. This commit implements the scheduling with respect to GSM 44.060, 9.3.1a ("Delayed release of downlink TBF"). Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-20 13:26:05 +00:00
Scheduling data message at RTS for DL TFI=0 (TRX=0, TS=4) prio=4
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) downlink (V(A)==21 .. V(S)==21)
tbf: Include CS into create_new_bsn log message This change lets the test suite fail, so it get its own commit. Sponsored-by: On-Waves ehf
2015-06-12 08:48:05 +00:00
- Sending new block at BSN 21, CS=1
tbf/test: Add test for delayed release This tests checks the implementation of the delayed release of an downlink TBF. Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-25 09:48:52 +00:00
-- Empty chunk, added LLC dummy command of size 19, drained_since=4
-- Chunk with length 19 is less than remaining space (20): add length header to to delimit LLC frame
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
Complete DL frame for TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW)len=19
tbf/test: Add test for delayed release This tests checks the implementation of the delayed release of an downlink TBF. Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-25 09:48:52 +00:00
-- No space left, so we are done.
data block: 07 00 2a 4d 43 c0 01 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b
- Scheduling Ack/Nack polling, because is was requested explicitly (e.g. first final block sent).
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
Polling is already sheduled for TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW), so we must wait for requesting downlink ack
tbf/test: Add test for delayed release This tests checks the implementation of the delayed release of an downlink TBF. Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-25 09:48:52 +00:00
Sending data request: trx=0 ts=4 sapi=5 arfcn=0 fn=95 block=22 data=07 00 2a 4d 43 c0 01 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) downlink acknowledge
tbf/test: Add test for delayed release This tests checks the implementation of the delayed release of an downlink TBF. Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-25 09:48:52 +00:00
- ack: (BSN=86)"RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR"(BSN=21) R=ACK I=NACK
- got ack for BSN=21
- V(B): (V(A)=22)""(V(S)-1=21) A=Acked N=Nacked U=Unacked X=Resend-Unacked I=Invalid
tbf: Poll MS on idle DL TBFs If an MS wants to open a new UL TBF, it can either use (P)RACH or request one in a Ack/Nack message for a DL TBF (PACCH). When a TBF becomes idle (LCC queue is empty but the TBF is kept open), there aren't any Ack/Nack requests that can be used by the MS to ask for an UL TBF, therefore it has to use the RACH. This leads to many RACH requests even for a single HTTP transaction, so it takes some time to retrieve even a simple web page. This commit modifies the scheduler to regularly send Ack/Nack requests on idle DL TBFs. It does so by extending the priority based scheduling algorithm to have 5 priority levels (highest priority first): - Control block is pending - High age (100%) threshold reached (-> request Ack/Nack) - Data is waiting or there are pending Nacks - Low age (200ms) threshold reached (-> request Ack/Nack) - Pending Nacks that have been resent already - None of the above (-> send DL dummy control block) The 'age' refers to the time since since the last control block has been sent on the TBF. This high age threshold is set to dl-tbf-idle-time or to 50% of T3190 (whichever is smaller), aiming for at least a poll (and TBF shutdown) after the TBF has expired and to safely prevent expiry of T3190. So if dl-tbf-idle-time > 200ms, there will be a poll every 200ms and a final poll after dl-tbf-idle-time. On high load, the interval between polls can get higher, but the 'high age' poll should be in place. This commit implements the scheduling with respect to GSM 44.060, 9.3.1a ("Delayed release of downlink TBF"). Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-20 13:26:05 +00:00
Scheduling data message at RTS for DL TFI=0 (TRX=0, TS=4) prio=4
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) downlink (V(A)==22 .. V(S)==22)
tbf: Include CS into create_new_bsn log message This change lets the test suite fail, so it get its own commit. Sponsored-by: On-Waves ehf
2015-06-12 08:48:05 +00:00
- Sending new block at BSN 22, CS=1
tbf/test: Add test for delayed release This tests checks the implementation of the delayed release of an downlink TBF. Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-25 09:48:52 +00:00
-- Empty chunk, added LLC dummy command of size 19, drained_since=112
-- Chunk with length 19 is less than remaining space (20): add length header to to delimit LLC frame
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
Complete DL frame for TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW)len=19
tbf/test: Add test for delayed release This tests checks the implementation of the delayed release of an downlink TBF. Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-25 09:48:52 +00:00
-- Final block, so we done.
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FLOW) changes state from FLOW to FINISHED
tbf/test: Add test for delayed release This tests checks the implementation of the delayed release of an downlink TBF. Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-25 09:48:52 +00:00
data block: 07 01 2c 4d 43 c0 01 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b
- Scheduling Ack/Nack polling, because is was requested explicitly (e.g. first final block sent).
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
Polling is already sheduled for TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FINISHED), so we must wait for requesting downlink ack
tbf/test: Add test for delayed release This tests checks the implementation of the delayed release of an downlink TBF. Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-25 09:48:52 +00:00
Sending data request: trx=0 ts=4 sapi=5 arfcn=0 fn=203 block=23 data=07 01 2c 4d 43 c0 01 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FINISHED) downlink acknowledge
tbf/test: Add test for delayed release This tests checks the implementation of the delayed release of an downlink TBF. Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-25 09:48:52 +00:00
- Final ACK received.
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=FINISHED) changes state from FINISHED to WAIT RELEASE
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=WAIT RELEASE) starting timer 3193.
DL packet loss of IMSI= / TLLI=0xffeeddcc: 0%
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=WAIT RELEASE) free
TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=WAIT RELEASE) stopping timer 3193.
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Detaching TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=WAIT RELEASE), 0 TBFs, USFs = 00, TFIs = 00000000.
tbf/test: Attach TLLI and MS objects to TBFs Currently the DL TBF's TLLI are not set. This will have to change in the future, when the m_new_tbf chaining is replaced by the usage of MS object to group TBFs. This commit just calls update_ms() on newly created TBFs. This changes many of the lines written to stderr due to the TLLI change, but doesn't change other aspects or messages beside creating and destroying MS objects. Sponsored-by: On-Waves ehf
2015-05-22 13:40:08 +00:00
Detaching TBF from MS object, TLLI = 0xffeeddcc, TBF = TBF(TFI=0 TLLI=0xffeeddcc DIR=DL STATE=WAIT RELEASE)
Destroying MS object, TLLI = 0xffeeddcc
tbf/test: Add test for delayed release This tests checks the implementation of the delayed release of an downlink TBF. Ticket: #556 Sponsored-by: On-Waves ehf
2015-03-25 09:48:52 +00:00
********** TBF ends here **********
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
Searching for first unallocated TFI: TRX=0
tbf: Move IMSI to MS object Currently the IMSI is stored in the TBFs. Since it directly refers to an MS, it should rather be stored in an MS object. This patch move the m_imsi field from gprs_rlcmac_tbf to GprsMs, changes gprs_rlcmac_tbf::imsi() to get the IMSI from the associated MS object, and adds getter and setter to GprsMs. Before changing the IMSI of the associated MS object, assign_imsi() checks if there is already another MS object with the same IMSI and eventually resets the IMSI of that one. So using update_ms() and assign_imsi() ensures that there are not two MS object entries is the storage with the same TLLI or the same IMSI. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-21 09:07:16 +00:00
Found TFI=0.
********** TBF starts here **********
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
Allocating DL TBF: MS_CLASS=45
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Creating MS object, TLLI = 0x00000000
Modifying MS object, TLLI = 0x00000000, MS class 0 -> 45
tbf: Move IMSI to MS object Currently the IMSI is stored in the TBFs. Since it directly refers to an MS, it should rather be stored in an MS object. This patch move the m_imsi field from gprs_rlcmac_tbf to GprsMs, changes gprs_rlcmac_tbf::imsi() to get the IMSI from the associated MS object, and adds getter and setter to GprsMs. Before changing the IMSI of the associated MS object, assign_imsi() checks if there is already another MS object with the same IMSI and eventually resets the IMSI of that one. So using update_ms() and assign_imsi() ensures that there are not two MS object entries is the storage with the same TLLI or the same IMSI. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-21 09:07:16 +00:00
Slot Allocation (Algorithm A) for class 45
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
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
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Skipping TS 7, because not enabled
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
- Assign downlink TS=4 TFI=0
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Attaching TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=NULL), 1 TBFs, USFs = 00, TFIs = 00000001.
tbf: Move IMSI to MS object Currently the IMSI is stored in the TBFs. Since it directly refers to an MS, it should rather be stored in an MS object. This patch move the m_imsi field from gprs_rlcmac_tbf to GprsMs, changes gprs_rlcmac_tbf::imsi() to get the IMSI from the associated MS object, and adds getter and setter to GprsMs. Before changing the IMSI of the associated MS object, assign_imsi() checks if there is already another MS object with the same IMSI and eventually resets the IMSI of that one. So using update_ms() and assign_imsi() ensures that there are not two MS object entries is the storage with the same TLLI or the same IMSI. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-21 09:07:16 +00:00
- Setting Control TS 4
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Attaching TBF to MS object, TLLI = 0x00000000, TBF = TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=NULL)
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
Allocated TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=NULL): trx = 0, ul_slots = 10, dl_slots = 10
tbf: Move IMSI to MS object Currently the IMSI is stored in the TBFs. Since it directly refers to an MS, it should rather be stored in an MS object. This patch move the m_imsi field from gprs_rlcmac_tbf to GprsMs, changes gprs_rlcmac_tbf::imsi() to get the IMSI from the associated MS object, and adds getter and setter to GprsMs. Before changing the IMSI of the associated MS object, assign_imsi() checks if there is already another MS object with the same IMSI and eventually resets the IMSI of that one. So using update_ms() and assign_imsi() ensures that there are not two MS object entries is the storage with the same TLLI or the same IMSI. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-21 09:07:16 +00:00
TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=NULL) changes state from NULL to FLOW
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
Searching for first unallocated TFI: TRX=0
tbf: Move IMSI to MS object Currently the IMSI is stored in the TBFs. Since it directly refers to an MS, it should rather be stored in an MS object. This patch move the m_imsi field from gprs_rlcmac_tbf to GprsMs, changes gprs_rlcmac_tbf::imsi() to get the IMSI from the associated MS object, and adds getter and setter to GprsMs. Before changing the IMSI of the associated MS object, assign_imsi() checks if there is already another MS object with the same IMSI and eventually resets the IMSI of that one. So using update_ms() and assign_imsi() ensures that there are not two MS object entries is the storage with the same TLLI or the same IMSI. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-21 09:07:16 +00:00
Found TFI=1.
********** TBF starts here **********
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
Allocating DL TBF: MS_CLASS=45
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Creating MS object, TLLI = 0x00000000
Modifying MS object, TLLI = 0x00000000, MS class 0 -> 45
tbf: Move IMSI to MS object Currently the IMSI is stored in the TBFs. Since it directly refers to an MS, it should rather be stored in an MS object. This patch move the m_imsi field from gprs_rlcmac_tbf to GprsMs, changes gprs_rlcmac_tbf::imsi() to get the IMSI from the associated MS object, and adds getter and setter to GprsMs. Before changing the IMSI of the associated MS object, assign_imsi() checks if there is already another MS object with the same IMSI and eventually resets the IMSI of that one. So using update_ms() and assign_imsi() ensures that there are not two MS object entries is the storage with the same TLLI or the same IMSI. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-21 09:07:16 +00:00
Slot Allocation (Algorithm A) for class 45
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
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
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Skipping TS 7, because not enabled
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
- Assign downlink TS=4 TFI=1
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Attaching TBF(TFI=1 TLLI=0x00000000 DIR=DL STATE=NULL), 2 TBFs, USFs = 00, TFIs = 00000003.
tbf: Move IMSI to MS object Currently the IMSI is stored in the TBFs. Since it directly refers to an MS, it should rather be stored in an MS object. This patch move the m_imsi field from gprs_rlcmac_tbf to GprsMs, changes gprs_rlcmac_tbf::imsi() to get the IMSI from the associated MS object, and adds getter and setter to GprsMs. Before changing the IMSI of the associated MS object, assign_imsi() checks if there is already another MS object with the same IMSI and eventually resets the IMSI of that one. So using update_ms() and assign_imsi() ensures that there are not two MS object entries is the storage with the same TLLI or the same IMSI. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-21 09:07:16 +00:00
- Setting Control TS 4
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Attaching TBF to MS object, TLLI = 0x00000000, TBF = TBF(TFI=1 TLLI=0x00000000 DIR=DL STATE=NULL)
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
Allocated TBF(TFI=1 TLLI=0x00000000 DIR=DL STATE=NULL): trx = 0, ul_slots = 10, dl_slots = 10
tbf: Move IMSI to MS object Currently the IMSI is stored in the TBFs. Since it directly refers to an MS, it should rather be stored in an MS object. This patch move the m_imsi field from gprs_rlcmac_tbf to GprsMs, changes gprs_rlcmac_tbf::imsi() to get the IMSI from the associated MS object, and adds getter and setter to GprsMs. Before changing the IMSI of the associated MS object, assign_imsi() checks if there is already another MS object with the same IMSI and eventually resets the IMSI of that one. So using update_ms() and assign_imsi() ensures that there are not two MS object entries is the storage with the same TLLI or the same IMSI. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-21 09:07:16 +00:00
TBF(TFI=1 TLLI=0x00000000 DIR=DL STATE=NULL) changes state from NULL to FLOW
The MS object cannot fully confirm an unexpected TLLI: 0xf1000001, partly confirmed
The MS object cannot fully confirm an unexpected TLLI: 0xf1000002, partly confirmed
Modifying MS object, TLLI = 0xf1000001, IMSI '' -> '001001000000001'
Modifying MS object, TLLI = 0xf1000001, IMSI '001001000000001' -> '001001000000002'
ms: Use the IMSI to retrieve the MS object This commit extends get_ms() to really compare the IMSI if it has been given. Matching by TLLI has a higher precedence than matching by IMSI. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-21 09:07:53 +00:00
TBF(TFI=1 TLLI=0xf1000002 DIR=DL STATE=FLOW) the IMSI '001001000000002' was already assigned to another MS object: TLLI = 0xf1000001, that IMSI will be removed
tbf: Clean old MS objects if they have the same TLLI Currently if an MS retries to access the PCU by using RACH and if there is already an entry for that MS, a duplicated MS object referring to the same TLLI is created. This is caused by blindly setting the TLLI without querying the MS storage to avoid inconsitencies. This leads to several entries in the MS storage that are assigned to the same TLLI. If that happens, 'show ms all' can display multiple entries with the same TLLI (note that an MS object can belong to several TLLIs, so there might be an intersection that is not visible in the list) or 'show tbf all' can show entries with MS_CLASS == 0 in some cases. This commit changes update_ms() to merge and clean up old entries that belong to the given TLLI if they exist. Some data (like the MS class) is copied to the new MS object. Note that TBF belonging to the old MS object are deleted immediately if they have not registered a timer. Sponsored-by: On-Waves ehf
2015-08-16 16:19:32 +00:00
TBF(TFI=0 TLLI=0xf1000001 DIR=DL STATE=FLOW) free
TBF(TFI=0 TLLI=0xf1000001 DIR=DL STATE=FLOW) Software error: Pending downlink assignment. This may not happen, because the assignment message never gets transmitted. Please be sure not to free in this state. PLEASE FIX!
PDCH(TS 4, TRX 0): Detaching TBF(TFI=0 TLLI=0xf1000001 DIR=DL STATE=FLOW), 1 TBFs, USFs = 00, TFIs = 00000002.
Detaching TBF from MS object, TLLI = 0xf1000001, TBF = TBF(TFI=0 TLLI=0xf1000001 DIR=DL STATE=FLOW)
********** TBF ends here **********
ms: Move MS information merging to GprsMS Currently the merging of the meta information (MS class, IMSI) takes place in gprs_rlcmac_tbf::merge_and_clear_ms(). This makes it difficult to merge the internal state and does not directly relate to TBFs anyway. This commit moves this into a new method GprsMs::merge_old_ms. Sponsored-by: On-Waves ehf
2015-08-18 09:55:03 +00:00
Modifying MS object, TLLI = 0xf1000002, IMSI '' -> '001001000000002'
Clearing MS object, TLLI: 0xf1000001, IMSI: '001001000000002'
tbf: Clean old MS objects if they have the same TLLI Currently if an MS retries to access the PCU by using RACH and if there is already an entry for that MS, a duplicated MS object referring to the same TLLI is created. This is caused by blindly setting the TLLI without querying the MS storage to avoid inconsitencies. This leads to several entries in the MS storage that are assigned to the same TLLI. If that happens, 'show ms all' can display multiple entries with the same TLLI (note that an MS object can belong to several TLLIs, so there might be an intersection that is not visible in the list) or 'show tbf all' can show entries with MS_CLASS == 0 in some cases. This commit changes update_ms() to merge and clean up old entries that belong to the given TLLI if they exist. Some data (like the MS class) is copied to the new MS object. Note that TBF belonging to the old MS object are deleted immediately if they have not registered a timer. Sponsored-by: On-Waves ehf
2015-08-16 16:19:32 +00:00
Destroying MS object, TLLI = 0x00000000
tbf: Move IMSI to MS object Currently the IMSI is stored in the TBFs. Since it directly refers to an MS, it should rather be stored in an MS object. This patch move the m_imsi field from gprs_rlcmac_tbf to GprsMs, changes gprs_rlcmac_tbf::imsi() to get the IMSI from the associated MS object, and adds getter and setter to GprsMs. Before changing the IMSI of the associated MS object, assign_imsi() checks if there is already another MS object with the same IMSI and eventually resets the IMSI of that one. So using update_ms() and assign_imsi() ensures that there are not two MS object entries is the storage with the same TLLI or the same IMSI. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-21 09:07:16 +00:00
TBF(TFI=1 TLLI=0xf1000002 DIR=DL STATE=FLOW) free
TBF(TFI=1 TLLI=0xf1000002 DIR=DL STATE=FLOW) Software error: Pending downlink assignment. This may not happen, because the assignment message never gets transmitted. Please be sure not to free in this state. PLEASE FIX!
tbf: Clean old MS objects if they have the same TLLI Currently if an MS retries to access the PCU by using RACH and if there is already an entry for that MS, a duplicated MS object referring to the same TLLI is created. This is caused by blindly setting the TLLI without querying the MS storage to avoid inconsitencies. This leads to several entries in the MS storage that are assigned to the same TLLI. If that happens, 'show ms all' can display multiple entries with the same TLLI (note that an MS object can belong to several TLLIs, so there might be an intersection that is not visible in the list) or 'show tbf all' can show entries with MS_CLASS == 0 in some cases. This commit changes update_ms() to merge and clean up old entries that belong to the given TLLI if they exist. Some data (like the MS class) is copied to the new MS object. Note that TBF belonging to the old MS object are deleted immediately if they have not registered a timer. Sponsored-by: On-Waves ehf
2015-08-16 16:19:32 +00:00
PDCH(TS 4, TRX 0): Detaching TBF(TFI=1 TLLI=0xf1000002 DIR=DL STATE=FLOW), 0 TBFs, USFs = 00, TFIs = 00000000.
tbf: Move IMSI to MS object Currently the IMSI is stored in the TBFs. Since it directly refers to an MS, it should rather be stored in an MS object. This patch move the m_imsi field from gprs_rlcmac_tbf to GprsMs, changes gprs_rlcmac_tbf::imsi() to get the IMSI from the associated MS object, and adds getter and setter to GprsMs. Before changing the IMSI of the associated MS object, assign_imsi() checks if there is already another MS object with the same IMSI and eventually resets the IMSI of that one. So using update_ms() and assign_imsi() ensures that there are not two MS object entries is the storage with the same TLLI or the same IMSI. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-21 09:07:16 +00:00
Detaching TBF from MS object, TLLI = 0xf1000002, TBF = TBF(TFI=1 TLLI=0xf1000002 DIR=DL STATE=FLOW)
Destroying MS object, TLLI = 0xf1000002
********** TBF ends here **********
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
********** TBF starts here **********
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
Allocating DL TBF: MS_CLASS=45
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Creating MS object, TLLI = 0x00000000
Modifying MS object, TLLI = 0x00000000, MS class 0 -> 45
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
Slot Allocation (Algorithm A) for class 45
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
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
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Skipping TS 7, because not enabled
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
- Assign downlink TS=4 TFI=0
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Attaching TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=NULL), 1 TBFs, USFs = 00, TFIs = 00000001.
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
- Setting Control TS 4
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Attaching TBF to MS object, TLLI = 0x00000000, TBF = TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=NULL)
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
Allocated TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=NULL): trx = 0, ul_slots = 10, dl_slots = 10
tbf: Always call set_tlli/confirm_tlli in update_ms Currently the m_tlli member in GprsMs is set by the constructor, circumventing the TLLI confirmation mechanism. This commit replaces the get_or_create_ms() method by a create_ms() method which takes the TLLI and the direction (UL or DL) as parameters to select either set_tlli() or confirm_tlli(). The MS object is instantiated with TLLI = 0, and therefore GprsMs::tlli() is extended to return the DL TLLI if both of the other TLLI are not set. Note that create_ms() will not check whether an MS object with a matching TLLI is already stored in the list, so it should only be called after a corresponding get_ms() in general. Sponsored-by: On-Waves ehf
2015-05-21 14:58:22 +00:00
The MS object cannot fully confirm an unexpected TLLI: 0xc0000000, partly confirmed
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=0 TLLI=0xc0000000 DIR=DL STATE=NULL) [DOWNLINK] START
tbf: Move IMSI to MS object Currently the IMSI is stored in the TBFs. Since it directly refers to an MS, it should rather be stored in an MS object. This patch move the m_imsi field from gprs_rlcmac_tbf to GprsMs, changes gprs_rlcmac_tbf::imsi() to get the IMSI from the associated MS object, and adds getter and setter to GprsMs. Before changing the IMSI of the associated MS object, assign_imsi() checks if there is already another MS object with the same IMSI and eventually resets the IMSI of that one. So using update_ms() and assign_imsi() ensures that there are not two MS object entries is the storage with the same TLLI or the same IMSI. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-21 09:07:16 +00:00
Modifying MS object, TLLI = 0xc0000000, IMSI '' -> '001001000000000'
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Send dowlink assignment for TBF(TFI=0 TLLI=0xc0000000 DIR=DL STATE=NULL) on PCH, no TBF exist (IMSI=001001000000000)
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=0 TLLI=0xc0000000 DIR=DL STATE=NULL) changes state from NULL to ASSIGN
TX: START TBF(TFI=0 TLLI=0xc0000000 DIR=DL STATE=ASSIGN) Immediate Assignment Downlink (PCH)
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Sending data request: trx=0 ts=0 sapi=3 arfcn=0 fn=0 block=0 data=30 30 30 2d 06 3f 30 0c 00 00 7d 80 00 00 00 dc 00 00 00 08 00 23 2b 2b 2b 2b
tbf: Fix downlink packet loss When the MS is pinged with a longer interval, many packets get lost even if the GprsMs object is kept. If the interval is above the time where the DL TBF is in state FLOW (mainly influenced be the dl-tbf-idle-time command), an new TBF must be requested via AGCH for each ICMP PING message. Currently the LLC frame containing the PING is immediately stored in the TBF and gets lost, if TBF establishment fails for some reason. This commit moves all calls to put_frame() to schedule_next_frame(), where the data is moved from the LLC queue to the frame storage within the TBF object. This method is only called from within create_new_bsn() when the TBF is in the FLOW state and the frame is going to be encoded immediately. At all other places, where put_frame() has been called before, the LLC message is just appended to the LLC queue in the GprsMs object. This change effectively simplifies the related code parts, since date/len information and discard notifications is no longer needed there. Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 12:06:09 +00:00
TBF(TFI=0 TLLI=0xc0000000 DIR=DL STATE=ASSIGN) append
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
********** TBF starts here **********
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
Allocating DL TBF: MS_CLASS=45
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Creating MS object, TLLI = 0x00000000
Modifying MS object, TLLI = 0x00000000, MS class 0 -> 45
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
Slot Allocation (Algorithm A) for class 45
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
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
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Skipping TS 7, because not enabled
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
- Assign downlink TS=4 TFI=1
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Attaching TBF(TFI=1 TLLI=0x00000000 DIR=DL STATE=NULL), 2 TBFs, USFs = 00, TFIs = 00000003.
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
- Setting Control TS 4
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Attaching TBF to MS object, TLLI = 0x00000000, TBF = TBF(TFI=1 TLLI=0x00000000 DIR=DL STATE=NULL)
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
Allocated TBF(TFI=1 TLLI=0x00000000 DIR=DL STATE=NULL): trx = 0, ul_slots = 10, dl_slots = 10
tbf: Always call set_tlli/confirm_tlli in update_ms Currently the m_tlli member in GprsMs is set by the constructor, circumventing the TLLI confirmation mechanism. This commit replaces the get_or_create_ms() method by a create_ms() method which takes the TLLI and the direction (UL or DL) as parameters to select either set_tlli() or confirm_tlli(). The MS object is instantiated with TLLI = 0, and therefore GprsMs::tlli() is extended to return the DL TLLI if both of the other TLLI are not set. Note that create_ms() will not check whether an MS object with a matching TLLI is already stored in the list, so it should only be called after a corresponding get_ms() in general. Sponsored-by: On-Waves ehf
2015-05-21 14:58:22 +00:00
The MS object cannot fully confirm an unexpected TLLI: 0xc0000001, partly confirmed
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=1 TLLI=0xc0000001 DIR=DL STATE=NULL) [DOWNLINK] START
tbf: Move IMSI to MS object Currently the IMSI is stored in the TBFs. Since it directly refers to an MS, it should rather be stored in an MS object. This patch move the m_imsi field from gprs_rlcmac_tbf to GprsMs, changes gprs_rlcmac_tbf::imsi() to get the IMSI from the associated MS object, and adds getter and setter to GprsMs. Before changing the IMSI of the associated MS object, assign_imsi() checks if there is already another MS object with the same IMSI and eventually resets the IMSI of that one. So using update_ms() and assign_imsi() ensures that there are not two MS object entries is the storage with the same TLLI or the same IMSI. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-21 09:07:16 +00:00
Modifying MS object, TLLI = 0xc0000001, IMSI '' -> '001001000000001'
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Send dowlink assignment for TBF(TFI=1 TLLI=0xc0000001 DIR=DL STATE=NULL) on PCH, no TBF exist (IMSI=001001000000001)
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=1 TLLI=0xc0000001 DIR=DL STATE=NULL) changes state from NULL to ASSIGN
TX: START TBF(TFI=1 TLLI=0xc0000001 DIR=DL STATE=ASSIGN) Immediate Assignment Downlink (PCH)
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Sending data request: trx=0 ts=0 sapi=3 arfcn=0 fn=0 block=0 data=30 30 31 2d 06 3f 30 0c 00 00 7d 80 00 00 00 dc 00 00 00 18 40 23 2b 2b 2b 2b
tbf: Fix downlink packet loss When the MS is pinged with a longer interval, many packets get lost even if the GprsMs object is kept. If the interval is above the time where the DL TBF is in state FLOW (mainly influenced be the dl-tbf-idle-time command), an new TBF must be requested via AGCH for each ICMP PING message. Currently the LLC frame containing the PING is immediately stored in the TBF and gets lost, if TBF establishment fails for some reason. This commit moves all calls to put_frame() to schedule_next_frame(), where the data is moved from the LLC queue to the frame storage within the TBF object. This method is only called from within create_new_bsn() when the TBF is in the FLOW state and the frame is going to be encoded immediately. At all other places, where put_frame() has been called before, the LLC message is just appended to the LLC queue in the GprsMs object. This change effectively simplifies the related code parts, since date/len information and discard notifications is no longer needed there. Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 12:06:09 +00:00
TBF(TFI=1 TLLI=0xc0000001 DIR=DL STATE=ASSIGN) append
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
********** TBF starts here **********
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
Allocating DL TBF: MS_CLASS=45
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Creating MS object, TLLI = 0x00000000
Modifying MS object, TLLI = 0x00000000, MS class 0 -> 45
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
Slot Allocation (Algorithm A) for class 45
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
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
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Skipping TS 7, because not enabled
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
- Assign downlink TS=4 TFI=2
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Attaching TBF(TFI=2 TLLI=0x00000000 DIR=DL STATE=NULL), 3 TBFs, USFs = 00, TFIs = 00000007.
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
- Setting Control TS 4
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Attaching TBF to MS object, TLLI = 0x00000000, TBF = TBF(TFI=2 TLLI=0x00000000 DIR=DL STATE=NULL)
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
Allocated TBF(TFI=2 TLLI=0x00000000 DIR=DL STATE=NULL): trx = 0, ul_slots = 10, dl_slots = 10
tbf: Always call set_tlli/confirm_tlli in update_ms Currently the m_tlli member in GprsMs is set by the constructor, circumventing the TLLI confirmation mechanism. This commit replaces the get_or_create_ms() method by a create_ms() method which takes the TLLI and the direction (UL or DL) as parameters to select either set_tlli() or confirm_tlli(). The MS object is instantiated with TLLI = 0, and therefore GprsMs::tlli() is extended to return the DL TLLI if both of the other TLLI are not set. Note that create_ms() will not check whether an MS object with a matching TLLI is already stored in the list, so it should only be called after a corresponding get_ms() in general. Sponsored-by: On-Waves ehf
2015-05-21 14:58:22 +00:00
The MS object cannot fully confirm an unexpected TLLI: 0xc0000002, partly confirmed
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=2 TLLI=0xc0000002 DIR=DL STATE=NULL) [DOWNLINK] START
tbf: Move IMSI to MS object Currently the IMSI is stored in the TBFs. Since it directly refers to an MS, it should rather be stored in an MS object. This patch move the m_imsi field from gprs_rlcmac_tbf to GprsMs, changes gprs_rlcmac_tbf::imsi() to get the IMSI from the associated MS object, and adds getter and setter to GprsMs. Before changing the IMSI of the associated MS object, assign_imsi() checks if there is already another MS object with the same IMSI and eventually resets the IMSI of that one. So using update_ms() and assign_imsi() ensures that there are not two MS object entries is the storage with the same TLLI or the same IMSI. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-21 09:07:16 +00:00
Modifying MS object, TLLI = 0xc0000002, IMSI '' -> '001001000000002'
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Send dowlink assignment for TBF(TFI=2 TLLI=0xc0000002 DIR=DL STATE=NULL) on PCH, no TBF exist (IMSI=001001000000002)
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=2 TLLI=0xc0000002 DIR=DL STATE=NULL) changes state from NULL to ASSIGN
TX: START TBF(TFI=2 TLLI=0xc0000002 DIR=DL STATE=ASSIGN) Immediate Assignment Downlink (PCH)
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Sending data request: trx=0 ts=0 sapi=3 arfcn=0 fn=0 block=0 data=30 30 32 2d 06 3f 30 0c 00 00 7d 80 00 00 00 dc 00 00 00 28 80 23 2b 2b 2b 2b
tbf: Fix downlink packet loss When the MS is pinged with a longer interval, many packets get lost even if the GprsMs object is kept. If the interval is above the time where the DL TBF is in state FLOW (mainly influenced be the dl-tbf-idle-time command), an new TBF must be requested via AGCH for each ICMP PING message. Currently the LLC frame containing the PING is immediately stored in the TBF and gets lost, if TBF establishment fails for some reason. This commit moves all calls to put_frame() to schedule_next_frame(), where the data is moved from the LLC queue to the frame storage within the TBF object. This method is only called from within create_new_bsn() when the TBF is in the FLOW state and the frame is going to be encoded immediately. At all other places, where put_frame() has been called before, the LLC message is just appended to the LLC queue in the GprsMs object. This change effectively simplifies the related code parts, since date/len information and discard notifications is no longer needed there. Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 12:06:09 +00:00
TBF(TFI=2 TLLI=0xc0000002 DIR=DL STATE=ASSIGN) append
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
********** TBF starts here **********
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
Allocating DL TBF: MS_CLASS=45
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Creating MS object, TLLI = 0x00000000
Modifying MS object, TLLI = 0x00000000, MS class 0 -> 45
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
Slot Allocation (Algorithm A) for class 45
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
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
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Skipping TS 7, because not enabled
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
- Assign downlink TS=4 TFI=3
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Attaching TBF(TFI=3 TLLI=0x00000000 DIR=DL STATE=NULL), 4 TBFs, USFs = 00, TFIs = 0000000f.
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
- Setting Control TS 4
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Attaching TBF to MS object, TLLI = 0x00000000, TBF = TBF(TFI=3 TLLI=0x00000000 DIR=DL STATE=NULL)
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
Allocated TBF(TFI=3 TLLI=0x00000000 DIR=DL STATE=NULL): trx = 0, ul_slots = 10, dl_slots = 10
tbf: Always call set_tlli/confirm_tlli in update_ms Currently the m_tlli member in GprsMs is set by the constructor, circumventing the TLLI confirmation mechanism. This commit replaces the get_or_create_ms() method by a create_ms() method which takes the TLLI and the direction (UL or DL) as parameters to select either set_tlli() or confirm_tlli(). The MS object is instantiated with TLLI = 0, and therefore GprsMs::tlli() is extended to return the DL TLLI if both of the other TLLI are not set. Note that create_ms() will not check whether an MS object with a matching TLLI is already stored in the list, so it should only be called after a corresponding get_ms() in general. Sponsored-by: On-Waves ehf
2015-05-21 14:58:22 +00:00
The MS object cannot fully confirm an unexpected TLLI: 0xc0000003, partly confirmed
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=3 TLLI=0xc0000003 DIR=DL STATE=NULL) [DOWNLINK] START
tbf: Move IMSI to MS object Currently the IMSI is stored in the TBFs. Since it directly refers to an MS, it should rather be stored in an MS object. This patch move the m_imsi field from gprs_rlcmac_tbf to GprsMs, changes gprs_rlcmac_tbf::imsi() to get the IMSI from the associated MS object, and adds getter and setter to GprsMs. Before changing the IMSI of the associated MS object, assign_imsi() checks if there is already another MS object with the same IMSI and eventually resets the IMSI of that one. So using update_ms() and assign_imsi() ensures that there are not two MS object entries is the storage with the same TLLI or the same IMSI. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-21 09:07:16 +00:00
Modifying MS object, TLLI = 0xc0000003, IMSI '' -> '001001000000003'
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Send dowlink assignment for TBF(TFI=3 TLLI=0xc0000003 DIR=DL STATE=NULL) on PCH, no TBF exist (IMSI=001001000000003)
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=3 TLLI=0xc0000003 DIR=DL STATE=NULL) changes state from NULL to ASSIGN
TX: START TBF(TFI=3 TLLI=0xc0000003 DIR=DL STATE=ASSIGN) Immediate Assignment Downlink (PCH)
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Sending data request: trx=0 ts=0 sapi=3 arfcn=0 fn=0 block=0 data=30 30 33 2d 06 3f 30 0c 00 00 7d 80 00 00 00 dc 00 00 00 38 c0 23 2b 2b 2b 2b
tbf: Fix downlink packet loss When the MS is pinged with a longer interval, many packets get lost even if the GprsMs object is kept. If the interval is above the time where the DL TBF is in state FLOW (mainly influenced be the dl-tbf-idle-time command), an new TBF must be requested via AGCH for each ICMP PING message. Currently the LLC frame containing the PING is immediately stored in the TBF and gets lost, if TBF establishment fails for some reason. This commit moves all calls to put_frame() to schedule_next_frame(), where the data is moved from the LLC queue to the frame storage within the TBF object. This method is only called from within create_new_bsn() when the TBF is in the FLOW state and the frame is going to be encoded immediately. At all other places, where put_frame() has been called before, the LLC message is just appended to the LLC queue in the GprsMs object. This change effectively simplifies the related code parts, since date/len information and discard notifications is no longer needed there. Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 12:06:09 +00:00
TBF(TFI=3 TLLI=0xc0000003 DIR=DL STATE=ASSIGN) append
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
********** TBF starts here **********
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
Allocating DL TBF: MS_CLASS=45
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Creating MS object, TLLI = 0x00000000
Modifying MS object, TLLI = 0x00000000, MS class 0 -> 45
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
Slot Allocation (Algorithm A) for class 45
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
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
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Skipping TS 7, because not enabled
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
- Assign downlink TS=4 TFI=4
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Attaching TBF(TFI=4 TLLI=0x00000000 DIR=DL STATE=NULL), 5 TBFs, USFs = 00, TFIs = 0000001f.
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
- Setting Control TS 4
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Attaching TBF to MS object, TLLI = 0x00000000, TBF = TBF(TFI=4 TLLI=0x00000000 DIR=DL STATE=NULL)
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
Allocated TBF(TFI=4 TLLI=0x00000000 DIR=DL STATE=NULL): trx = 0, ul_slots = 10, dl_slots = 10
tbf: Always call set_tlli/confirm_tlli in update_ms Currently the m_tlli member in GprsMs is set by the constructor, circumventing the TLLI confirmation mechanism. This commit replaces the get_or_create_ms() method by a create_ms() method which takes the TLLI and the direction (UL or DL) as parameters to select either set_tlli() or confirm_tlli(). The MS object is instantiated with TLLI = 0, and therefore GprsMs::tlli() is extended to return the DL TLLI if both of the other TLLI are not set. Note that create_ms() will not check whether an MS object with a matching TLLI is already stored in the list, so it should only be called after a corresponding get_ms() in general. Sponsored-by: On-Waves ehf
2015-05-21 14:58:22 +00:00
The MS object cannot fully confirm an unexpected TLLI: 0xc0000004, partly confirmed
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=4 TLLI=0xc0000004 DIR=DL STATE=NULL) [DOWNLINK] START
tbf: Move IMSI to MS object Currently the IMSI is stored in the TBFs. Since it directly refers to an MS, it should rather be stored in an MS object. This patch move the m_imsi field from gprs_rlcmac_tbf to GprsMs, changes gprs_rlcmac_tbf::imsi() to get the IMSI from the associated MS object, and adds getter and setter to GprsMs. Before changing the IMSI of the associated MS object, assign_imsi() checks if there is already another MS object with the same IMSI and eventually resets the IMSI of that one. So using update_ms() and assign_imsi() ensures that there are not two MS object entries is the storage with the same TLLI or the same IMSI. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-21 09:07:16 +00:00
Modifying MS object, TLLI = 0xc0000004, IMSI '' -> '001001000000004'
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Send dowlink assignment for TBF(TFI=4 TLLI=0xc0000004 DIR=DL STATE=NULL) on PCH, no TBF exist (IMSI=001001000000004)
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=4 TLLI=0xc0000004 DIR=DL STATE=NULL) changes state from NULL to ASSIGN
TX: START TBF(TFI=4 TLLI=0xc0000004 DIR=DL STATE=ASSIGN) Immediate Assignment Downlink (PCH)
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Sending data request: trx=0 ts=0 sapi=3 arfcn=0 fn=0 block=0 data=30 30 34 2d 06 3f 30 0c 00 00 7d 80 00 00 00 dc 00 00 00 49 00 23 2b 2b 2b 2b
tbf: Fix downlink packet loss When the MS is pinged with a longer interval, many packets get lost even if the GprsMs object is kept. If the interval is above the time where the DL TBF is in state FLOW (mainly influenced be the dl-tbf-idle-time command), an new TBF must be requested via AGCH for each ICMP PING message. Currently the LLC frame containing the PING is immediately stored in the TBF and gets lost, if TBF establishment fails for some reason. This commit moves all calls to put_frame() to schedule_next_frame(), where the data is moved from the LLC queue to the frame storage within the TBF object. This method is only called from within create_new_bsn() when the TBF is in the FLOW state and the frame is going to be encoded immediately. At all other places, where put_frame() has been called before, the LLC message is just appended to the LLC queue in the GprsMs object. This change effectively simplifies the related code parts, since date/len information and discard notifications is no longer needed there. Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 12:06:09 +00:00
TBF(TFI=4 TLLI=0xc0000004 DIR=DL STATE=ASSIGN) append
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
********** TBF starts here **********
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
Allocating DL TBF: MS_CLASS=45
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Creating MS object, TLLI = 0x00000000
Modifying MS object, TLLI = 0x00000000, MS class 0 -> 45
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
Slot Allocation (Algorithm A) for class 45
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
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
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Skipping TS 7, because not enabled
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
- Assign downlink TS=4 TFI=5
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Attaching TBF(TFI=5 TLLI=0x00000000 DIR=DL STATE=NULL), 6 TBFs, USFs = 00, TFIs = 0000003f.
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
- Setting Control TS 4
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Attaching TBF to MS object, TLLI = 0x00000000, TBF = TBF(TFI=5 TLLI=0x00000000 DIR=DL STATE=NULL)
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
Allocated TBF(TFI=5 TLLI=0x00000000 DIR=DL STATE=NULL): trx = 0, ul_slots = 10, dl_slots = 10
tbf: Always call set_tlli/confirm_tlli in update_ms Currently the m_tlli member in GprsMs is set by the constructor, circumventing the TLLI confirmation mechanism. This commit replaces the get_or_create_ms() method by a create_ms() method which takes the TLLI and the direction (UL or DL) as parameters to select either set_tlli() or confirm_tlli(). The MS object is instantiated with TLLI = 0, and therefore GprsMs::tlli() is extended to return the DL TLLI if both of the other TLLI are not set. Note that create_ms() will not check whether an MS object with a matching TLLI is already stored in the list, so it should only be called after a corresponding get_ms() in general. Sponsored-by: On-Waves ehf
2015-05-21 14:58:22 +00:00
The MS object cannot fully confirm an unexpected TLLI: 0xc0000005, partly confirmed
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=5 TLLI=0xc0000005 DIR=DL STATE=NULL) [DOWNLINK] START
tbf: Move IMSI to MS object Currently the IMSI is stored in the TBFs. Since it directly refers to an MS, it should rather be stored in an MS object. This patch move the m_imsi field from gprs_rlcmac_tbf to GprsMs, changes gprs_rlcmac_tbf::imsi() to get the IMSI from the associated MS object, and adds getter and setter to GprsMs. Before changing the IMSI of the associated MS object, assign_imsi() checks if there is already another MS object with the same IMSI and eventually resets the IMSI of that one. So using update_ms() and assign_imsi() ensures that there are not two MS object entries is the storage with the same TLLI or the same IMSI. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-21 09:07:16 +00:00
Modifying MS object, TLLI = 0xc0000005, IMSI '' -> '001001000000005'
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Send dowlink assignment for TBF(TFI=5 TLLI=0xc0000005 DIR=DL STATE=NULL) on PCH, no TBF exist (IMSI=001001000000005)
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=5 TLLI=0xc0000005 DIR=DL STATE=NULL) changes state from NULL to ASSIGN
TX: START TBF(TFI=5 TLLI=0xc0000005 DIR=DL STATE=ASSIGN) Immediate Assignment Downlink (PCH)
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Sending data request: trx=0 ts=0 sapi=3 arfcn=0 fn=0 block=0 data=30 30 35 2d 06 3f 30 0c 00 00 7d 80 00 00 00 dc 00 00 00 59 40 23 2b 2b 2b 2b
tbf: Fix downlink packet loss When the MS is pinged with a longer interval, many packets get lost even if the GprsMs object is kept. If the interval is above the time where the DL TBF is in state FLOW (mainly influenced be the dl-tbf-idle-time command), an new TBF must be requested via AGCH for each ICMP PING message. Currently the LLC frame containing the PING is immediately stored in the TBF and gets lost, if TBF establishment fails for some reason. This commit moves all calls to put_frame() to schedule_next_frame(), where the data is moved from the LLC queue to the frame storage within the TBF object. This method is only called from within create_new_bsn() when the TBF is in the FLOW state and the frame is going to be encoded immediately. At all other places, where put_frame() has been called before, the LLC message is just appended to the LLC queue in the GprsMs object. This change effectively simplifies the related code parts, since date/len information and discard notifications is no longer needed there. Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 12:06:09 +00:00
TBF(TFI=5 TLLI=0xc0000005 DIR=DL STATE=ASSIGN) append
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
********** TBF starts here **********
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
Allocating DL TBF: MS_CLASS=45
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Creating MS object, TLLI = 0x00000000
Modifying MS object, TLLI = 0x00000000, MS class 0 -> 45
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
Slot Allocation (Algorithm A) for class 45
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
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
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Skipping TS 7, because not enabled
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
- Assign downlink TS=4 TFI=6
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Attaching TBF(TFI=6 TLLI=0x00000000 DIR=DL STATE=NULL), 7 TBFs, USFs = 00, TFIs = 0000007f.
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
- Setting Control TS 4
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Attaching TBF to MS object, TLLI = 0x00000000, TBF = TBF(TFI=6 TLLI=0x00000000 DIR=DL STATE=NULL)
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
Allocated TBF(TFI=6 TLLI=0x00000000 DIR=DL STATE=NULL): trx = 0, ul_slots = 10, dl_slots = 10
tbf: Always call set_tlli/confirm_tlli in update_ms Currently the m_tlli member in GprsMs is set by the constructor, circumventing the TLLI confirmation mechanism. This commit replaces the get_or_create_ms() method by a create_ms() method which takes the TLLI and the direction (UL or DL) as parameters to select either set_tlli() or confirm_tlli(). The MS object is instantiated with TLLI = 0, and therefore GprsMs::tlli() is extended to return the DL TLLI if both of the other TLLI are not set. Note that create_ms() will not check whether an MS object with a matching TLLI is already stored in the list, so it should only be called after a corresponding get_ms() in general. Sponsored-by: On-Waves ehf
2015-05-21 14:58:22 +00:00
The MS object cannot fully confirm an unexpected TLLI: 0xc0000006, partly confirmed
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=6 TLLI=0xc0000006 DIR=DL STATE=NULL) [DOWNLINK] START
tbf: Move IMSI to MS object Currently the IMSI is stored in the TBFs. Since it directly refers to an MS, it should rather be stored in an MS object. This patch move the m_imsi field from gprs_rlcmac_tbf to GprsMs, changes gprs_rlcmac_tbf::imsi() to get the IMSI from the associated MS object, and adds getter and setter to GprsMs. Before changing the IMSI of the associated MS object, assign_imsi() checks if there is already another MS object with the same IMSI and eventually resets the IMSI of that one. So using update_ms() and assign_imsi() ensures that there are not two MS object entries is the storage with the same TLLI or the same IMSI. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-21 09:07:16 +00:00
Modifying MS object, TLLI = 0xc0000006, IMSI '' -> '001001000000006'
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Send dowlink assignment for TBF(TFI=6 TLLI=0xc0000006 DIR=DL STATE=NULL) on PCH, no TBF exist (IMSI=001001000000006)
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=6 TLLI=0xc0000006 DIR=DL STATE=NULL) changes state from NULL to ASSIGN
TX: START TBF(TFI=6 TLLI=0xc0000006 DIR=DL STATE=ASSIGN) Immediate Assignment Downlink (PCH)
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Sending data request: trx=0 ts=0 sapi=3 arfcn=0 fn=0 block=0 data=30 30 36 2d 06 3f 30 0c 00 00 7d 80 00 00 00 dc 00 00 00 69 80 23 2b 2b 2b 2b
tbf: Fix downlink packet loss When the MS is pinged with a longer interval, many packets get lost even if the GprsMs object is kept. If the interval is above the time where the DL TBF is in state FLOW (mainly influenced be the dl-tbf-idle-time command), an new TBF must be requested via AGCH for each ICMP PING message. Currently the LLC frame containing the PING is immediately stored in the TBF and gets lost, if TBF establishment fails for some reason. This commit moves all calls to put_frame() to schedule_next_frame(), where the data is moved from the LLC queue to the frame storage within the TBF object. This method is only called from within create_new_bsn() when the TBF is in the FLOW state and the frame is going to be encoded immediately. At all other places, where put_frame() has been called before, the LLC message is just appended to the LLC queue in the GprsMs object. This change effectively simplifies the related code parts, since date/len information and discard notifications is no longer needed there. Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 12:06:09 +00:00
TBF(TFI=6 TLLI=0xc0000006 DIR=DL STATE=ASSIGN) append
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
********** TBF starts here **********
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
Allocating DL TBF: MS_CLASS=45
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Creating MS object, TLLI = 0x00000000
Modifying MS object, TLLI = 0x00000000, MS class 0 -> 45
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
Slot Allocation (Algorithm A) for class 45
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
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
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Skipping TS 7, because not enabled
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
- Assign downlink TS=4 TFI=7
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Attaching TBF(TFI=7 TLLI=0x00000000 DIR=DL STATE=NULL), 8 TBFs, USFs = 00, TFIs = 000000ff.
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
- Setting Control TS 4
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Attaching TBF to MS object, TLLI = 0x00000000, TBF = TBF(TFI=7 TLLI=0x00000000 DIR=DL STATE=NULL)
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
Allocated TBF(TFI=7 TLLI=0x00000000 DIR=DL STATE=NULL): trx = 0, ul_slots = 10, dl_slots = 10
tbf: Always call set_tlli/confirm_tlli in update_ms Currently the m_tlli member in GprsMs is set by the constructor, circumventing the TLLI confirmation mechanism. This commit replaces the get_or_create_ms() method by a create_ms() method which takes the TLLI and the direction (UL or DL) as parameters to select either set_tlli() or confirm_tlli(). The MS object is instantiated with TLLI = 0, and therefore GprsMs::tlli() is extended to return the DL TLLI if both of the other TLLI are not set. Note that create_ms() will not check whether an MS object with a matching TLLI is already stored in the list, so it should only be called after a corresponding get_ms() in general. Sponsored-by: On-Waves ehf
2015-05-21 14:58:22 +00:00
The MS object cannot fully confirm an unexpected TLLI: 0xc0000007, partly confirmed
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=7 TLLI=0xc0000007 DIR=DL STATE=NULL) [DOWNLINK] START
tbf: Move IMSI to MS object Currently the IMSI is stored in the TBFs. Since it directly refers to an MS, it should rather be stored in an MS object. This patch move the m_imsi field from gprs_rlcmac_tbf to GprsMs, changes gprs_rlcmac_tbf::imsi() to get the IMSI from the associated MS object, and adds getter and setter to GprsMs. Before changing the IMSI of the associated MS object, assign_imsi() checks if there is already another MS object with the same IMSI and eventually resets the IMSI of that one. So using update_ms() and assign_imsi() ensures that there are not two MS object entries is the storage with the same TLLI or the same IMSI. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-21 09:07:16 +00:00
Modifying MS object, TLLI = 0xc0000007, IMSI '' -> '001001000000007'
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Send dowlink assignment for TBF(TFI=7 TLLI=0xc0000007 DIR=DL STATE=NULL) on PCH, no TBF exist (IMSI=001001000000007)
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=7 TLLI=0xc0000007 DIR=DL STATE=NULL) changes state from NULL to ASSIGN
TX: START TBF(TFI=7 TLLI=0xc0000007 DIR=DL STATE=ASSIGN) Immediate Assignment Downlink (PCH)
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Sending data request: trx=0 ts=0 sapi=3 arfcn=0 fn=0 block=0 data=30 30 37 2d 06 3f 30 0c 00 00 7d 80 00 00 00 dc 00 00 00 79 c0 23 2b 2b 2b 2b
tbf: Fix downlink packet loss When the MS is pinged with a longer interval, many packets get lost even if the GprsMs object is kept. If the interval is above the time where the DL TBF is in state FLOW (mainly influenced be the dl-tbf-idle-time command), an new TBF must be requested via AGCH for each ICMP PING message. Currently the LLC frame containing the PING is immediately stored in the TBF and gets lost, if TBF establishment fails for some reason. This commit moves all calls to put_frame() to schedule_next_frame(), where the data is moved from the LLC queue to the frame storage within the TBF object. This method is only called from within create_new_bsn() when the TBF is in the FLOW state and the frame is going to be encoded immediately. At all other places, where put_frame() has been called before, the LLC message is just appended to the LLC queue in the GprsMs object. This change effectively simplifies the related code parts, since date/len information and discard notifications is no longer needed there. Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 12:06:09 +00:00
TBF(TFI=7 TLLI=0xc0000007 DIR=DL STATE=ASSIGN) append
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
********** TBF starts here **********
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
Allocating DL TBF: MS_CLASS=45
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Creating MS object, TLLI = 0x00000000
Modifying MS object, TLLI = 0x00000000, MS class 0 -> 45
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
Slot Allocation (Algorithm A) for class 45
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
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
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Skipping TS 7, because not enabled
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
- Assign downlink TS=4 TFI=8
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Attaching TBF(TFI=8 TLLI=0x00000000 DIR=DL STATE=NULL), 9 TBFs, USFs = 00, TFIs = 000001ff.
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
- Setting Control TS 4
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Attaching TBF to MS object, TLLI = 0x00000000, TBF = TBF(TFI=8 TLLI=0x00000000 DIR=DL STATE=NULL)
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
Allocated TBF(TFI=8 TLLI=0x00000000 DIR=DL STATE=NULL): trx = 0, ul_slots = 10, dl_slots = 10
tbf: Always call set_tlli/confirm_tlli in update_ms Currently the m_tlli member in GprsMs is set by the constructor, circumventing the TLLI confirmation mechanism. This commit replaces the get_or_create_ms() method by a create_ms() method which takes the TLLI and the direction (UL or DL) as parameters to select either set_tlli() or confirm_tlli(). The MS object is instantiated with TLLI = 0, and therefore GprsMs::tlli() is extended to return the DL TLLI if both of the other TLLI are not set. Note that create_ms() will not check whether an MS object with a matching TLLI is already stored in the list, so it should only be called after a corresponding get_ms() in general. Sponsored-by: On-Waves ehf
2015-05-21 14:58:22 +00:00
The MS object cannot fully confirm an unexpected TLLI: 0xc0000008, partly confirmed
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=8 TLLI=0xc0000008 DIR=DL STATE=NULL) [DOWNLINK] START
tbf: Move IMSI to MS object Currently the IMSI is stored in the TBFs. Since it directly refers to an MS, it should rather be stored in an MS object. This patch move the m_imsi field from gprs_rlcmac_tbf to GprsMs, changes gprs_rlcmac_tbf::imsi() to get the IMSI from the associated MS object, and adds getter and setter to GprsMs. Before changing the IMSI of the associated MS object, assign_imsi() checks if there is already another MS object with the same IMSI and eventually resets the IMSI of that one. So using update_ms() and assign_imsi() ensures that there are not two MS object entries is the storage with the same TLLI or the same IMSI. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-21 09:07:16 +00:00
Modifying MS object, TLLI = 0xc0000008, IMSI '' -> '001001000000008'
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Send dowlink assignment for TBF(TFI=8 TLLI=0xc0000008 DIR=DL STATE=NULL) on PCH, no TBF exist (IMSI=001001000000008)
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=8 TLLI=0xc0000008 DIR=DL STATE=NULL) changes state from NULL to ASSIGN
TX: START TBF(TFI=8 TLLI=0xc0000008 DIR=DL STATE=ASSIGN) Immediate Assignment Downlink (PCH)
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Sending data request: trx=0 ts=0 sapi=3 arfcn=0 fn=0 block=0 data=30 30 38 2d 06 3f 30 0c 00 00 7d 80 00 00 00 dc 00 00 00 8a 00 23 2b 2b 2b 2b
tbf: Fix downlink packet loss When the MS is pinged with a longer interval, many packets get lost even if the GprsMs object is kept. If the interval is above the time where the DL TBF is in state FLOW (mainly influenced be the dl-tbf-idle-time command), an new TBF must be requested via AGCH for each ICMP PING message. Currently the LLC frame containing the PING is immediately stored in the TBF and gets lost, if TBF establishment fails for some reason. This commit moves all calls to put_frame() to schedule_next_frame(), where the data is moved from the LLC queue to the frame storage within the TBF object. This method is only called from within create_new_bsn() when the TBF is in the FLOW state and the frame is going to be encoded immediately. At all other places, where put_frame() has been called before, the LLC message is just appended to the LLC queue in the GprsMs object. This change effectively simplifies the related code parts, since date/len information and discard notifications is no longer needed there. Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 12:06:09 +00:00
TBF(TFI=8 TLLI=0xc0000008 DIR=DL STATE=ASSIGN) append
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
********** TBF starts here **********
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
Allocating DL TBF: MS_CLASS=45
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Creating MS object, TLLI = 0x00000000
Modifying MS object, TLLI = 0x00000000, MS class 0 -> 45
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
Slot Allocation (Algorithm A) for class 45
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
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
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Skipping TS 7, because not enabled
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
- Assign downlink TS=4 TFI=9
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Attaching TBF(TFI=9 TLLI=0x00000000 DIR=DL STATE=NULL), 10 TBFs, USFs = 00, TFIs = 000003ff.
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
- Setting Control TS 4
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Attaching TBF to MS object, TLLI = 0x00000000, TBF = TBF(TFI=9 TLLI=0x00000000 DIR=DL STATE=NULL)
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
Allocated TBF(TFI=9 TLLI=0x00000000 DIR=DL STATE=NULL): trx = 0, ul_slots = 10, dl_slots = 10
tbf: Always call set_tlli/confirm_tlli in update_ms Currently the m_tlli member in GprsMs is set by the constructor, circumventing the TLLI confirmation mechanism. This commit replaces the get_or_create_ms() method by a create_ms() method which takes the TLLI and the direction (UL or DL) as parameters to select either set_tlli() or confirm_tlli(). The MS object is instantiated with TLLI = 0, and therefore GprsMs::tlli() is extended to return the DL TLLI if both of the other TLLI are not set. Note that create_ms() will not check whether an MS object with a matching TLLI is already stored in the list, so it should only be called after a corresponding get_ms() in general. Sponsored-by: On-Waves ehf
2015-05-21 14:58:22 +00:00
The MS object cannot fully confirm an unexpected TLLI: 0xc0000009, partly confirmed
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=9 TLLI=0xc0000009 DIR=DL STATE=NULL) [DOWNLINK] START
tbf: Move IMSI to MS object Currently the IMSI is stored in the TBFs. Since it directly refers to an MS, it should rather be stored in an MS object. This patch move the m_imsi field from gprs_rlcmac_tbf to GprsMs, changes gprs_rlcmac_tbf::imsi() to get the IMSI from the associated MS object, and adds getter and setter to GprsMs. Before changing the IMSI of the associated MS object, assign_imsi() checks if there is already another MS object with the same IMSI and eventually resets the IMSI of that one. So using update_ms() and assign_imsi() ensures that there are not two MS object entries is the storage with the same TLLI or the same IMSI. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-21 09:07:16 +00:00
Modifying MS object, TLLI = 0xc0000009, IMSI '' -> '001001000000009'
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Send dowlink assignment for TBF(TFI=9 TLLI=0xc0000009 DIR=DL STATE=NULL) on PCH, no TBF exist (IMSI=001001000000009)
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=9 TLLI=0xc0000009 DIR=DL STATE=NULL) changes state from NULL to ASSIGN
TX: START TBF(TFI=9 TLLI=0xc0000009 DIR=DL STATE=ASSIGN) Immediate Assignment Downlink (PCH)
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Sending data request: trx=0 ts=0 sapi=3 arfcn=0 fn=0 block=0 data=30 30 39 2d 06 3f 30 0c 00 00 7d 80 00 00 00 dc 00 00 00 9a 40 23 2b 2b 2b 2b
tbf: Fix downlink packet loss When the MS is pinged with a longer interval, many packets get lost even if the GprsMs object is kept. If the interval is above the time where the DL TBF is in state FLOW (mainly influenced be the dl-tbf-idle-time command), an new TBF must be requested via AGCH for each ICMP PING message. Currently the LLC frame containing the PING is immediately stored in the TBF and gets lost, if TBF establishment fails for some reason. This commit moves all calls to put_frame() to schedule_next_frame(), where the data is moved from the LLC queue to the frame storage within the TBF object. This method is only called from within create_new_bsn() when the TBF is in the FLOW state and the frame is going to be encoded immediately. At all other places, where put_frame() has been called before, the LLC message is just appended to the LLC queue in the GprsMs object. This change effectively simplifies the related code parts, since date/len information and discard notifications is no longer needed there. Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 12:06:09 +00:00
TBF(TFI=9 TLLI=0xc0000009 DIR=DL STATE=ASSIGN) append
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
********** TBF starts here **********
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
Allocating DL TBF: MS_CLASS=45
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Creating MS object, TLLI = 0x00000000
Modifying MS object, TLLI = 0x00000000, MS class 0 -> 45
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
Slot Allocation (Algorithm A) for class 45
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
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
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Skipping TS 7, because not enabled
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
- Assign downlink TS=4 TFI=10
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Attaching TBF(TFI=10 TLLI=0x00000000 DIR=DL STATE=NULL), 11 TBFs, USFs = 00, TFIs = 000007ff.
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
- Setting Control TS 4
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Attaching TBF to MS object, TLLI = 0x00000000, TBF = TBF(TFI=10 TLLI=0x00000000 DIR=DL STATE=NULL)
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
Allocated TBF(TFI=10 TLLI=0x00000000 DIR=DL STATE=NULL): trx = 0, ul_slots = 10, dl_slots = 10
tbf: Always call set_tlli/confirm_tlli in update_ms Currently the m_tlli member in GprsMs is set by the constructor, circumventing the TLLI confirmation mechanism. This commit replaces the get_or_create_ms() method by a create_ms() method which takes the TLLI and the direction (UL or DL) as parameters to select either set_tlli() or confirm_tlli(). The MS object is instantiated with TLLI = 0, and therefore GprsMs::tlli() is extended to return the DL TLLI if both of the other TLLI are not set. Note that create_ms() will not check whether an MS object with a matching TLLI is already stored in the list, so it should only be called after a corresponding get_ms() in general. Sponsored-by: On-Waves ehf
2015-05-21 14:58:22 +00:00
The MS object cannot fully confirm an unexpected TLLI: 0xc000000a, partly confirmed
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=10 TLLI=0xc000000a DIR=DL STATE=NULL) [DOWNLINK] START
tbf: Move IMSI to MS object Currently the IMSI is stored in the TBFs. Since it directly refers to an MS, it should rather be stored in an MS object. This patch move the m_imsi field from gprs_rlcmac_tbf to GprsMs, changes gprs_rlcmac_tbf::imsi() to get the IMSI from the associated MS object, and adds getter and setter to GprsMs. Before changing the IMSI of the associated MS object, assign_imsi() checks if there is already another MS object with the same IMSI and eventually resets the IMSI of that one. So using update_ms() and assign_imsi() ensures that there are not two MS object entries is the storage with the same TLLI or the same IMSI. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-21 09:07:16 +00:00
Modifying MS object, TLLI = 0xc000000a, IMSI '' -> '001001000000010'
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Send dowlink assignment for TBF(TFI=10 TLLI=0xc000000a DIR=DL STATE=NULL) on PCH, no TBF exist (IMSI=001001000000010)
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=10 TLLI=0xc000000a DIR=DL STATE=NULL) changes state from NULL to ASSIGN
TX: START TBF(TFI=10 TLLI=0xc000000a DIR=DL STATE=ASSIGN) Immediate Assignment Downlink (PCH)
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Sending data request: trx=0 ts=0 sapi=3 arfcn=0 fn=0 block=0 data=30 31 30 2d 06 3f 30 0c 00 00 7d 80 00 00 00 dc 00 00 00 aa 80 23 2b 2b 2b 2b
tbf: Fix downlink packet loss When the MS is pinged with a longer interval, many packets get lost even if the GprsMs object is kept. If the interval is above the time where the DL TBF is in state FLOW (mainly influenced be the dl-tbf-idle-time command), an new TBF must be requested via AGCH for each ICMP PING message. Currently the LLC frame containing the PING is immediately stored in the TBF and gets lost, if TBF establishment fails for some reason. This commit moves all calls to put_frame() to schedule_next_frame(), where the data is moved from the LLC queue to the frame storage within the TBF object. This method is only called from within create_new_bsn() when the TBF is in the FLOW state and the frame is going to be encoded immediately. At all other places, where put_frame() has been called before, the LLC message is just appended to the LLC queue in the GprsMs object. This change effectively simplifies the related code parts, since date/len information and discard notifications is no longer needed there. Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 12:06:09 +00:00
TBF(TFI=10 TLLI=0xc000000a DIR=DL STATE=ASSIGN) append
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
********** TBF starts here **********
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
Allocating DL TBF: MS_CLASS=45
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Creating MS object, TLLI = 0x00000000
Modifying MS object, TLLI = 0x00000000, MS class 0 -> 45
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
Slot Allocation (Algorithm A) for class 45
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
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
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Skipping TS 7, because not enabled
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
- Assign downlink TS=4 TFI=11
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Attaching TBF(TFI=11 TLLI=0x00000000 DIR=DL STATE=NULL), 12 TBFs, USFs = 00, TFIs = 00000fff.
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
- Setting Control TS 4
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Attaching TBF to MS object, TLLI = 0x00000000, TBF = TBF(TFI=11 TLLI=0x00000000 DIR=DL STATE=NULL)
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
Allocated TBF(TFI=11 TLLI=0x00000000 DIR=DL STATE=NULL): trx = 0, ul_slots = 10, dl_slots = 10
tbf: Always call set_tlli/confirm_tlli in update_ms Currently the m_tlli member in GprsMs is set by the constructor, circumventing the TLLI confirmation mechanism. This commit replaces the get_or_create_ms() method by a create_ms() method which takes the TLLI and the direction (UL or DL) as parameters to select either set_tlli() or confirm_tlli(). The MS object is instantiated with TLLI = 0, and therefore GprsMs::tlli() is extended to return the DL TLLI if both of the other TLLI are not set. Note that create_ms() will not check whether an MS object with a matching TLLI is already stored in the list, so it should only be called after a corresponding get_ms() in general. Sponsored-by: On-Waves ehf
2015-05-21 14:58:22 +00:00
The MS object cannot fully confirm an unexpected TLLI: 0xc000000b, partly confirmed
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=11 TLLI=0xc000000b DIR=DL STATE=NULL) [DOWNLINK] START
tbf: Move IMSI to MS object Currently the IMSI is stored in the TBFs. Since it directly refers to an MS, it should rather be stored in an MS object. This patch move the m_imsi field from gprs_rlcmac_tbf to GprsMs, changes gprs_rlcmac_tbf::imsi() to get the IMSI from the associated MS object, and adds getter and setter to GprsMs. Before changing the IMSI of the associated MS object, assign_imsi() checks if there is already another MS object with the same IMSI and eventually resets the IMSI of that one. So using update_ms() and assign_imsi() ensures that there are not two MS object entries is the storage with the same TLLI or the same IMSI. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-21 09:07:16 +00:00
Modifying MS object, TLLI = 0xc000000b, IMSI '' -> '001001000000011'
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Send dowlink assignment for TBF(TFI=11 TLLI=0xc000000b DIR=DL STATE=NULL) on PCH, no TBF exist (IMSI=001001000000011)
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=11 TLLI=0xc000000b DIR=DL STATE=NULL) changes state from NULL to ASSIGN
TX: START TBF(TFI=11 TLLI=0xc000000b DIR=DL STATE=ASSIGN) Immediate Assignment Downlink (PCH)
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Sending data request: trx=0 ts=0 sapi=3 arfcn=0 fn=0 block=0 data=30 31 31 2d 06 3f 30 0c 00 00 7d 80 00 00 00 dc 00 00 00 ba c0 23 2b 2b 2b 2b
tbf: Fix downlink packet loss When the MS is pinged with a longer interval, many packets get lost even if the GprsMs object is kept. If the interval is above the time where the DL TBF is in state FLOW (mainly influenced be the dl-tbf-idle-time command), an new TBF must be requested via AGCH for each ICMP PING message. Currently the LLC frame containing the PING is immediately stored in the TBF and gets lost, if TBF establishment fails for some reason. This commit moves all calls to put_frame() to schedule_next_frame(), where the data is moved from the LLC queue to the frame storage within the TBF object. This method is only called from within create_new_bsn() when the TBF is in the FLOW state and the frame is going to be encoded immediately. At all other places, where put_frame() has been called before, the LLC message is just appended to the LLC queue in the GprsMs object. This change effectively simplifies the related code parts, since date/len information and discard notifications is no longer needed there. Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 12:06:09 +00:00
TBF(TFI=11 TLLI=0xc000000b DIR=DL STATE=ASSIGN) append
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
********** TBF starts here **********
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
Allocating DL TBF: MS_CLASS=45
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Creating MS object, TLLI = 0x00000000
Modifying MS object, TLLI = 0x00000000, MS class 0 -> 45
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
Slot Allocation (Algorithm A) for class 45
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
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
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Skipping TS 7, because not enabled
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
- Assign downlink TS=4 TFI=12
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Attaching TBF(TFI=12 TLLI=0x00000000 DIR=DL STATE=NULL), 13 TBFs, USFs = 00, TFIs = 00001fff.
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
- Setting Control TS 4
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Attaching TBF to MS object, TLLI = 0x00000000, TBF = TBF(TFI=12 TLLI=0x00000000 DIR=DL STATE=NULL)
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
Allocated TBF(TFI=12 TLLI=0x00000000 DIR=DL STATE=NULL): trx = 0, ul_slots = 10, dl_slots = 10
tbf: Always call set_tlli/confirm_tlli in update_ms Currently the m_tlli member in GprsMs is set by the constructor, circumventing the TLLI confirmation mechanism. This commit replaces the get_or_create_ms() method by a create_ms() method which takes the TLLI and the direction (UL or DL) as parameters to select either set_tlli() or confirm_tlli(). The MS object is instantiated with TLLI = 0, and therefore GprsMs::tlli() is extended to return the DL TLLI if both of the other TLLI are not set. Note that create_ms() will not check whether an MS object with a matching TLLI is already stored in the list, so it should only be called after a corresponding get_ms() in general. Sponsored-by: On-Waves ehf
2015-05-21 14:58:22 +00:00
The MS object cannot fully confirm an unexpected TLLI: 0xc000000c, partly confirmed
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=12 TLLI=0xc000000c DIR=DL STATE=NULL) [DOWNLINK] START
tbf: Move IMSI to MS object Currently the IMSI is stored in the TBFs. Since it directly refers to an MS, it should rather be stored in an MS object. This patch move the m_imsi field from gprs_rlcmac_tbf to GprsMs, changes gprs_rlcmac_tbf::imsi() to get the IMSI from the associated MS object, and adds getter and setter to GprsMs. Before changing the IMSI of the associated MS object, assign_imsi() checks if there is already another MS object with the same IMSI and eventually resets the IMSI of that one. So using update_ms() and assign_imsi() ensures that there are not two MS object entries is the storage with the same TLLI or the same IMSI. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-21 09:07:16 +00:00
Modifying MS object, TLLI = 0xc000000c, IMSI '' -> '001001000000012'
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Send dowlink assignment for TBF(TFI=12 TLLI=0xc000000c DIR=DL STATE=NULL) on PCH, no TBF exist (IMSI=001001000000012)
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=12 TLLI=0xc000000c DIR=DL STATE=NULL) changes state from NULL to ASSIGN
TX: START TBF(TFI=12 TLLI=0xc000000c DIR=DL STATE=ASSIGN) Immediate Assignment Downlink (PCH)
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Sending data request: trx=0 ts=0 sapi=3 arfcn=0 fn=0 block=0 data=30 31 32 2d 06 3f 30 0c 00 00 7d 80 00 00 00 dc 00 00 00 cb 00 23 2b 2b 2b 2b
tbf: Fix downlink packet loss When the MS is pinged with a longer interval, many packets get lost even if the GprsMs object is kept. If the interval is above the time where the DL TBF is in state FLOW (mainly influenced be the dl-tbf-idle-time command), an new TBF must be requested via AGCH for each ICMP PING message. Currently the LLC frame containing the PING is immediately stored in the TBF and gets lost, if TBF establishment fails for some reason. This commit moves all calls to put_frame() to schedule_next_frame(), where the data is moved from the LLC queue to the frame storage within the TBF object. This method is only called from within create_new_bsn() when the TBF is in the FLOW state and the frame is going to be encoded immediately. At all other places, where put_frame() has been called before, the LLC message is just appended to the LLC queue in the GprsMs object. This change effectively simplifies the related code parts, since date/len information and discard notifications is no longer needed there. Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 12:06:09 +00:00
TBF(TFI=12 TLLI=0xc000000c DIR=DL STATE=ASSIGN) append
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
********** TBF starts here **********
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
Allocating DL TBF: MS_CLASS=45
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Creating MS object, TLLI = 0x00000000
Modifying MS object, TLLI = 0x00000000, MS class 0 -> 45
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
Slot Allocation (Algorithm A) for class 45
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
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
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Skipping TS 7, because not enabled
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
- Assign downlink TS=4 TFI=13
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Attaching TBF(TFI=13 TLLI=0x00000000 DIR=DL STATE=NULL), 14 TBFs, USFs = 00, TFIs = 00003fff.
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
- Setting Control TS 4
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Attaching TBF to MS object, TLLI = 0x00000000, TBF = TBF(TFI=13 TLLI=0x00000000 DIR=DL STATE=NULL)
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
Allocated TBF(TFI=13 TLLI=0x00000000 DIR=DL STATE=NULL): trx = 0, ul_slots = 10, dl_slots = 10
tbf: Always call set_tlli/confirm_tlli in update_ms Currently the m_tlli member in GprsMs is set by the constructor, circumventing the TLLI confirmation mechanism. This commit replaces the get_or_create_ms() method by a create_ms() method which takes the TLLI and the direction (UL or DL) as parameters to select either set_tlli() or confirm_tlli(). The MS object is instantiated with TLLI = 0, and therefore GprsMs::tlli() is extended to return the DL TLLI if both of the other TLLI are not set. Note that create_ms() will not check whether an MS object with a matching TLLI is already stored in the list, so it should only be called after a corresponding get_ms() in general. Sponsored-by: On-Waves ehf
2015-05-21 14:58:22 +00:00
The MS object cannot fully confirm an unexpected TLLI: 0xc000000d, partly confirmed
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=13 TLLI=0xc000000d DIR=DL STATE=NULL) [DOWNLINK] START
tbf: Move IMSI to MS object Currently the IMSI is stored in the TBFs. Since it directly refers to an MS, it should rather be stored in an MS object. This patch move the m_imsi field from gprs_rlcmac_tbf to GprsMs, changes gprs_rlcmac_tbf::imsi() to get the IMSI from the associated MS object, and adds getter and setter to GprsMs. Before changing the IMSI of the associated MS object, assign_imsi() checks if there is already another MS object with the same IMSI and eventually resets the IMSI of that one. So using update_ms() and assign_imsi() ensures that there are not two MS object entries is the storage with the same TLLI or the same IMSI. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-21 09:07:16 +00:00
Modifying MS object, TLLI = 0xc000000d, IMSI '' -> '001001000000013'
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Send dowlink assignment for TBF(TFI=13 TLLI=0xc000000d DIR=DL STATE=NULL) on PCH, no TBF exist (IMSI=001001000000013)
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=13 TLLI=0xc000000d DIR=DL STATE=NULL) changes state from NULL to ASSIGN
TX: START TBF(TFI=13 TLLI=0xc000000d DIR=DL STATE=ASSIGN) Immediate Assignment Downlink (PCH)
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Sending data request: trx=0 ts=0 sapi=3 arfcn=0 fn=0 block=0 data=30 31 33 2d 06 3f 30 0c 00 00 7d 80 00 00 00 dc 00 00 00 db 40 23 2b 2b 2b 2b
tbf: Fix downlink packet loss When the MS is pinged with a longer interval, many packets get lost even if the GprsMs object is kept. If the interval is above the time where the DL TBF is in state FLOW (mainly influenced be the dl-tbf-idle-time command), an new TBF must be requested via AGCH for each ICMP PING message. Currently the LLC frame containing the PING is immediately stored in the TBF and gets lost, if TBF establishment fails for some reason. This commit moves all calls to put_frame() to schedule_next_frame(), where the data is moved from the LLC queue to the frame storage within the TBF object. This method is only called from within create_new_bsn() when the TBF is in the FLOW state and the frame is going to be encoded immediately. At all other places, where put_frame() has been called before, the LLC message is just appended to the LLC queue in the GprsMs object. This change effectively simplifies the related code parts, since date/len information and discard notifications is no longer needed there. Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 12:06:09 +00:00
TBF(TFI=13 TLLI=0xc000000d DIR=DL STATE=ASSIGN) append
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
********** TBF starts here **********
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
Allocating DL TBF: MS_CLASS=45
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Creating MS object, TLLI = 0x00000000
Modifying MS object, TLLI = 0x00000000, MS class 0 -> 45
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
Slot Allocation (Algorithm A) for class 45
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
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
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Skipping TS 7, because not enabled
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
- Assign downlink TS=4 TFI=14
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Attaching TBF(TFI=14 TLLI=0x00000000 DIR=DL STATE=NULL), 15 TBFs, USFs = 00, TFIs = 00007fff.
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
- Setting Control TS 4
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Attaching TBF to MS object, TLLI = 0x00000000, TBF = TBF(TFI=14 TLLI=0x00000000 DIR=DL STATE=NULL)
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
Allocated TBF(TFI=14 TLLI=0x00000000 DIR=DL STATE=NULL): trx = 0, ul_slots = 10, dl_slots = 10
tbf: Always call set_tlli/confirm_tlli in update_ms Currently the m_tlli member in GprsMs is set by the constructor, circumventing the TLLI confirmation mechanism. This commit replaces the get_or_create_ms() method by a create_ms() method which takes the TLLI and the direction (UL or DL) as parameters to select either set_tlli() or confirm_tlli(). The MS object is instantiated with TLLI = 0, and therefore GprsMs::tlli() is extended to return the DL TLLI if both of the other TLLI are not set. Note that create_ms() will not check whether an MS object with a matching TLLI is already stored in the list, so it should only be called after a corresponding get_ms() in general. Sponsored-by: On-Waves ehf
2015-05-21 14:58:22 +00:00
The MS object cannot fully confirm an unexpected TLLI: 0xc000000e, partly confirmed
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=14 TLLI=0xc000000e DIR=DL STATE=NULL) [DOWNLINK] START
tbf: Move IMSI to MS object Currently the IMSI is stored in the TBFs. Since it directly refers to an MS, it should rather be stored in an MS object. This patch move the m_imsi field from gprs_rlcmac_tbf to GprsMs, changes gprs_rlcmac_tbf::imsi() to get the IMSI from the associated MS object, and adds getter and setter to GprsMs. Before changing the IMSI of the associated MS object, assign_imsi() checks if there is already another MS object with the same IMSI and eventually resets the IMSI of that one. So using update_ms() and assign_imsi() ensures that there are not two MS object entries is the storage with the same TLLI or the same IMSI. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-21 09:07:16 +00:00
Modifying MS object, TLLI = 0xc000000e, IMSI '' -> '001001000000014'
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Send dowlink assignment for TBF(TFI=14 TLLI=0xc000000e DIR=DL STATE=NULL) on PCH, no TBF exist (IMSI=001001000000014)
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=14 TLLI=0xc000000e DIR=DL STATE=NULL) changes state from NULL to ASSIGN
TX: START TBF(TFI=14 TLLI=0xc000000e DIR=DL STATE=ASSIGN) Immediate Assignment Downlink (PCH)
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Sending data request: trx=0 ts=0 sapi=3 arfcn=0 fn=0 block=0 data=30 31 34 2d 06 3f 30 0c 00 00 7d 80 00 00 00 dc 00 00 00 eb 80 23 2b 2b 2b 2b
tbf: Fix downlink packet loss When the MS is pinged with a longer interval, many packets get lost even if the GprsMs object is kept. If the interval is above the time where the DL TBF is in state FLOW (mainly influenced be the dl-tbf-idle-time command), an new TBF must be requested via AGCH for each ICMP PING message. Currently the LLC frame containing the PING is immediately stored in the TBF and gets lost, if TBF establishment fails for some reason. This commit moves all calls to put_frame() to schedule_next_frame(), where the data is moved from the LLC queue to the frame storage within the TBF object. This method is only called from within create_new_bsn() when the TBF is in the FLOW state and the frame is going to be encoded immediately. At all other places, where put_frame() has been called before, the LLC message is just appended to the LLC queue in the GprsMs object. This change effectively simplifies the related code parts, since date/len information and discard notifications is no longer needed there. Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 12:06:09 +00:00
TBF(TFI=14 TLLI=0xc000000e DIR=DL STATE=ASSIGN) append
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
********** TBF starts here **********
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
Allocating DL TBF: MS_CLASS=45
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Creating MS object, TLLI = 0x00000000
Modifying MS object, TLLI = 0x00000000, MS class 0 -> 45
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
Slot Allocation (Algorithm A) for class 45
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
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
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Skipping TS 7, because not enabled
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
- Assign downlink TS=4 TFI=15
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Attaching TBF(TFI=15 TLLI=0x00000000 DIR=DL STATE=NULL), 16 TBFs, USFs = 00, TFIs = 0000ffff.
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
- Setting Control TS 4
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Attaching TBF to MS object, TLLI = 0x00000000, TBF = TBF(TFI=15 TLLI=0x00000000 DIR=DL STATE=NULL)
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
Allocated TBF(TFI=15 TLLI=0x00000000 DIR=DL STATE=NULL): trx = 0, ul_slots = 10, dl_slots = 10
tbf: Always call set_tlli/confirm_tlli in update_ms Currently the m_tlli member in GprsMs is set by the constructor, circumventing the TLLI confirmation mechanism. This commit replaces the get_or_create_ms() method by a create_ms() method which takes the TLLI and the direction (UL or DL) as parameters to select either set_tlli() or confirm_tlli(). The MS object is instantiated with TLLI = 0, and therefore GprsMs::tlli() is extended to return the DL TLLI if both of the other TLLI are not set. Note that create_ms() will not check whether an MS object with a matching TLLI is already stored in the list, so it should only be called after a corresponding get_ms() in general. Sponsored-by: On-Waves ehf
2015-05-21 14:58:22 +00:00
The MS object cannot fully confirm an unexpected TLLI: 0xc000000f, partly confirmed
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=15 TLLI=0xc000000f DIR=DL STATE=NULL) [DOWNLINK] START
tbf: Move IMSI to MS object Currently the IMSI is stored in the TBFs. Since it directly refers to an MS, it should rather be stored in an MS object. This patch move the m_imsi field from gprs_rlcmac_tbf to GprsMs, changes gprs_rlcmac_tbf::imsi() to get the IMSI from the associated MS object, and adds getter and setter to GprsMs. Before changing the IMSI of the associated MS object, assign_imsi() checks if there is already another MS object with the same IMSI and eventually resets the IMSI of that one. So using update_ms() and assign_imsi() ensures that there are not two MS object entries is the storage with the same TLLI or the same IMSI. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-21 09:07:16 +00:00
Modifying MS object, TLLI = 0xc000000f, IMSI '' -> '001001000000015'
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Send dowlink assignment for TBF(TFI=15 TLLI=0xc000000f DIR=DL STATE=NULL) on PCH, no TBF exist (IMSI=001001000000015)
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=15 TLLI=0xc000000f DIR=DL STATE=NULL) changes state from NULL to ASSIGN
TX: START TBF(TFI=15 TLLI=0xc000000f DIR=DL STATE=ASSIGN) Immediate Assignment Downlink (PCH)
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Sending data request: trx=0 ts=0 sapi=3 arfcn=0 fn=0 block=0 data=30 31 35 2d 06 3f 30 0c 00 00 7d 80 00 00 00 dc 00 00 00 fb c0 23 2b 2b 2b 2b
tbf: Fix downlink packet loss When the MS is pinged with a longer interval, many packets get lost even if the GprsMs object is kept. If the interval is above the time where the DL TBF is in state FLOW (mainly influenced be the dl-tbf-idle-time command), an new TBF must be requested via AGCH for each ICMP PING message. Currently the LLC frame containing the PING is immediately stored in the TBF and gets lost, if TBF establishment fails for some reason. This commit moves all calls to put_frame() to schedule_next_frame(), where the data is moved from the LLC queue to the frame storage within the TBF object. This method is only called from within create_new_bsn() when the TBF is in the FLOW state and the frame is going to be encoded immediately. At all other places, where put_frame() has been called before, the LLC message is just appended to the LLC queue in the GprsMs object. This change effectively simplifies the related code parts, since date/len information and discard notifications is no longer needed there. Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 12:06:09 +00:00
TBF(TFI=15 TLLI=0xc000000f DIR=DL STATE=ASSIGN) append
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
********** TBF starts here **********
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
Allocating DL TBF: MS_CLASS=45
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Creating MS object, TLLI = 0x00000000
Modifying MS object, TLLI = 0x00000000, MS class 0 -> 45
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
Slot Allocation (Algorithm A) for class 45
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
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
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Skipping TS 7, because not enabled
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
- Assign downlink TS=4 TFI=16
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Attaching TBF(TFI=16 TLLI=0x00000000 DIR=DL STATE=NULL), 17 TBFs, USFs = 00, TFIs = 0001ffff.
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
- Setting Control TS 4
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Attaching TBF to MS object, TLLI = 0x00000000, TBF = TBF(TFI=16 TLLI=0x00000000 DIR=DL STATE=NULL)
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
Allocated TBF(TFI=16 TLLI=0x00000000 DIR=DL STATE=NULL): trx = 0, ul_slots = 10, dl_slots = 10
tbf: Always call set_tlli/confirm_tlli in update_ms Currently the m_tlli member in GprsMs is set by the constructor, circumventing the TLLI confirmation mechanism. This commit replaces the get_or_create_ms() method by a create_ms() method which takes the TLLI and the direction (UL or DL) as parameters to select either set_tlli() or confirm_tlli(). The MS object is instantiated with TLLI = 0, and therefore GprsMs::tlli() is extended to return the DL TLLI if both of the other TLLI are not set. Note that create_ms() will not check whether an MS object with a matching TLLI is already stored in the list, so it should only be called after a corresponding get_ms() in general. Sponsored-by: On-Waves ehf
2015-05-21 14:58:22 +00:00
The MS object cannot fully confirm an unexpected TLLI: 0xc0000010, partly confirmed
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=16 TLLI=0xc0000010 DIR=DL STATE=NULL) [DOWNLINK] START
tbf: Move IMSI to MS object Currently the IMSI is stored in the TBFs. Since it directly refers to an MS, it should rather be stored in an MS object. This patch move the m_imsi field from gprs_rlcmac_tbf to GprsMs, changes gprs_rlcmac_tbf::imsi() to get the IMSI from the associated MS object, and adds getter and setter to GprsMs. Before changing the IMSI of the associated MS object, assign_imsi() checks if there is already another MS object with the same IMSI and eventually resets the IMSI of that one. So using update_ms() and assign_imsi() ensures that there are not two MS object entries is the storage with the same TLLI or the same IMSI. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-21 09:07:16 +00:00
Modifying MS object, TLLI = 0xc0000010, IMSI '' -> '001001000000016'
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Send dowlink assignment for TBF(TFI=16 TLLI=0xc0000010 DIR=DL STATE=NULL) on PCH, no TBF exist (IMSI=001001000000016)
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=16 TLLI=0xc0000010 DIR=DL STATE=NULL) changes state from NULL to ASSIGN
TX: START TBF(TFI=16 TLLI=0xc0000010 DIR=DL STATE=ASSIGN) Immediate Assignment Downlink (PCH)
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Sending data request: trx=0 ts=0 sapi=3 arfcn=0 fn=0 block=0 data=30 31 36 2d 06 3f 30 0c 00 00 7d 80 00 00 00 dc 00 00 01 0c 00 23 2b 2b 2b 2b
tbf: Fix downlink packet loss When the MS is pinged with a longer interval, many packets get lost even if the GprsMs object is kept. If the interval is above the time where the DL TBF is in state FLOW (mainly influenced be the dl-tbf-idle-time command), an new TBF must be requested via AGCH for each ICMP PING message. Currently the LLC frame containing the PING is immediately stored in the TBF and gets lost, if TBF establishment fails for some reason. This commit moves all calls to put_frame() to schedule_next_frame(), where the data is moved from the LLC queue to the frame storage within the TBF object. This method is only called from within create_new_bsn() when the TBF is in the FLOW state and the frame is going to be encoded immediately. At all other places, where put_frame() has been called before, the LLC message is just appended to the LLC queue in the GprsMs object. This change effectively simplifies the related code parts, since date/len information and discard notifications is no longer needed there. Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 12:06:09 +00:00
TBF(TFI=16 TLLI=0xc0000010 DIR=DL STATE=ASSIGN) append
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
********** TBF starts here **********
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
Allocating DL TBF: MS_CLASS=45
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Creating MS object, TLLI = 0x00000000
Modifying MS object, TLLI = 0x00000000, MS class 0 -> 45
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
Slot Allocation (Algorithm A) for class 45
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
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
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Skipping TS 7, because not enabled
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
- Assign downlink TS=4 TFI=17
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Attaching TBF(TFI=17 TLLI=0x00000000 DIR=DL STATE=NULL), 18 TBFs, USFs = 00, TFIs = 0003ffff.
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
- Setting Control TS 4
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Attaching TBF to MS object, TLLI = 0x00000000, TBF = TBF(TFI=17 TLLI=0x00000000 DIR=DL STATE=NULL)
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
Allocated TBF(TFI=17 TLLI=0x00000000 DIR=DL STATE=NULL): trx = 0, ul_slots = 10, dl_slots = 10
tbf: Always call set_tlli/confirm_tlli in update_ms Currently the m_tlli member in GprsMs is set by the constructor, circumventing the TLLI confirmation mechanism. This commit replaces the get_or_create_ms() method by a create_ms() method which takes the TLLI and the direction (UL or DL) as parameters to select either set_tlli() or confirm_tlli(). The MS object is instantiated with TLLI = 0, and therefore GprsMs::tlli() is extended to return the DL TLLI if both of the other TLLI are not set. Note that create_ms() will not check whether an MS object with a matching TLLI is already stored in the list, so it should only be called after a corresponding get_ms() in general. Sponsored-by: On-Waves ehf
2015-05-21 14:58:22 +00:00
The MS object cannot fully confirm an unexpected TLLI: 0xc0000011, partly confirmed
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=17 TLLI=0xc0000011 DIR=DL STATE=NULL) [DOWNLINK] START
tbf: Move IMSI to MS object Currently the IMSI is stored in the TBFs. Since it directly refers to an MS, it should rather be stored in an MS object. This patch move the m_imsi field from gprs_rlcmac_tbf to GprsMs, changes gprs_rlcmac_tbf::imsi() to get the IMSI from the associated MS object, and adds getter and setter to GprsMs. Before changing the IMSI of the associated MS object, assign_imsi() checks if there is already another MS object with the same IMSI and eventually resets the IMSI of that one. So using update_ms() and assign_imsi() ensures that there are not two MS object entries is the storage with the same TLLI or the same IMSI. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-21 09:07:16 +00:00
Modifying MS object, TLLI = 0xc0000011, IMSI '' -> '001001000000017'
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Send dowlink assignment for TBF(TFI=17 TLLI=0xc0000011 DIR=DL STATE=NULL) on PCH, no TBF exist (IMSI=001001000000017)
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=17 TLLI=0xc0000011 DIR=DL STATE=NULL) changes state from NULL to ASSIGN
TX: START TBF(TFI=17 TLLI=0xc0000011 DIR=DL STATE=ASSIGN) Immediate Assignment Downlink (PCH)
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Sending data request: trx=0 ts=0 sapi=3 arfcn=0 fn=0 block=0 data=30 31 37 2d 06 3f 30 0c 00 00 7d 80 00 00 00 dc 00 00 01 1c 40 23 2b 2b 2b 2b
tbf: Fix downlink packet loss When the MS is pinged with a longer interval, many packets get lost even if the GprsMs object is kept. If the interval is above the time where the DL TBF is in state FLOW (mainly influenced be the dl-tbf-idle-time command), an new TBF must be requested via AGCH for each ICMP PING message. Currently the LLC frame containing the PING is immediately stored in the TBF and gets lost, if TBF establishment fails for some reason. This commit moves all calls to put_frame() to schedule_next_frame(), where the data is moved from the LLC queue to the frame storage within the TBF object. This method is only called from within create_new_bsn() when the TBF is in the FLOW state and the frame is going to be encoded immediately. At all other places, where put_frame() has been called before, the LLC message is just appended to the LLC queue in the GprsMs object. This change effectively simplifies the related code parts, since date/len information and discard notifications is no longer needed there. Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 12:06:09 +00:00
TBF(TFI=17 TLLI=0xc0000011 DIR=DL STATE=ASSIGN) append
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
********** TBF starts here **********
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
Allocating DL TBF: MS_CLASS=45
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Creating MS object, TLLI = 0x00000000
Modifying MS object, TLLI = 0x00000000, MS class 0 -> 45
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
Slot Allocation (Algorithm A) for class 45
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
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
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Skipping TS 7, because not enabled
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
- Assign downlink TS=4 TFI=18
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Attaching TBF(TFI=18 TLLI=0x00000000 DIR=DL STATE=NULL), 19 TBFs, USFs = 00, TFIs = 0007ffff.
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
- Setting Control TS 4
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Attaching TBF to MS object, TLLI = 0x00000000, TBF = TBF(TFI=18 TLLI=0x00000000 DIR=DL STATE=NULL)
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
Allocated TBF(TFI=18 TLLI=0x00000000 DIR=DL STATE=NULL): trx = 0, ul_slots = 10, dl_slots = 10
tbf: Always call set_tlli/confirm_tlli in update_ms Currently the m_tlli member in GprsMs is set by the constructor, circumventing the TLLI confirmation mechanism. This commit replaces the get_or_create_ms() method by a create_ms() method which takes the TLLI and the direction (UL or DL) as parameters to select either set_tlli() or confirm_tlli(). The MS object is instantiated with TLLI = 0, and therefore GprsMs::tlli() is extended to return the DL TLLI if both of the other TLLI are not set. Note that create_ms() will not check whether an MS object with a matching TLLI is already stored in the list, so it should only be called after a corresponding get_ms() in general. Sponsored-by: On-Waves ehf
2015-05-21 14:58:22 +00:00
The MS object cannot fully confirm an unexpected TLLI: 0xc0000012, partly confirmed
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=18 TLLI=0xc0000012 DIR=DL STATE=NULL) [DOWNLINK] START
tbf: Move IMSI to MS object Currently the IMSI is stored in the TBFs. Since it directly refers to an MS, it should rather be stored in an MS object. This patch move the m_imsi field from gprs_rlcmac_tbf to GprsMs, changes gprs_rlcmac_tbf::imsi() to get the IMSI from the associated MS object, and adds getter and setter to GprsMs. Before changing the IMSI of the associated MS object, assign_imsi() checks if there is already another MS object with the same IMSI and eventually resets the IMSI of that one. So using update_ms() and assign_imsi() ensures that there are not two MS object entries is the storage with the same TLLI or the same IMSI. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-21 09:07:16 +00:00
Modifying MS object, TLLI = 0xc0000012, IMSI '' -> '001001000000018'
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Send dowlink assignment for TBF(TFI=18 TLLI=0xc0000012 DIR=DL STATE=NULL) on PCH, no TBF exist (IMSI=001001000000018)
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=18 TLLI=0xc0000012 DIR=DL STATE=NULL) changes state from NULL to ASSIGN
TX: START TBF(TFI=18 TLLI=0xc0000012 DIR=DL STATE=ASSIGN) Immediate Assignment Downlink (PCH)
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Sending data request: trx=0 ts=0 sapi=3 arfcn=0 fn=0 block=0 data=30 31 38 2d 06 3f 30 0c 00 00 7d 80 00 00 00 dc 00 00 01 2c 80 23 2b 2b 2b 2b
tbf: Fix downlink packet loss When the MS is pinged with a longer interval, many packets get lost even if the GprsMs object is kept. If the interval is above the time where the DL TBF is in state FLOW (mainly influenced be the dl-tbf-idle-time command), an new TBF must be requested via AGCH for each ICMP PING message. Currently the LLC frame containing the PING is immediately stored in the TBF and gets lost, if TBF establishment fails for some reason. This commit moves all calls to put_frame() to schedule_next_frame(), where the data is moved from the LLC queue to the frame storage within the TBF object. This method is only called from within create_new_bsn() when the TBF is in the FLOW state and the frame is going to be encoded immediately. At all other places, where put_frame() has been called before, the LLC message is just appended to the LLC queue in the GprsMs object. This change effectively simplifies the related code parts, since date/len information and discard notifications is no longer needed there. Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 12:06:09 +00:00
TBF(TFI=18 TLLI=0xc0000012 DIR=DL STATE=ASSIGN) append
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
********** TBF starts here **********
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
Allocating DL TBF: MS_CLASS=45
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Creating MS object, TLLI = 0x00000000
Modifying MS object, TLLI = 0x00000000, MS class 0 -> 45
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
Slot Allocation (Algorithm A) for class 45
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
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
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Skipping TS 7, because not enabled
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
- Assign downlink TS=4 TFI=19
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Attaching TBF(TFI=19 TLLI=0x00000000 DIR=DL STATE=NULL), 20 TBFs, USFs = 00, TFIs = 000fffff.
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
- Setting Control TS 4
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Attaching TBF to MS object, TLLI = 0x00000000, TBF = TBF(TFI=19 TLLI=0x00000000 DIR=DL STATE=NULL)
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
Allocated TBF(TFI=19 TLLI=0x00000000 DIR=DL STATE=NULL): trx = 0, ul_slots = 10, dl_slots = 10
tbf: Always call set_tlli/confirm_tlli in update_ms Currently the m_tlli member in GprsMs is set by the constructor, circumventing the TLLI confirmation mechanism. This commit replaces the get_or_create_ms() method by a create_ms() method which takes the TLLI and the direction (UL or DL) as parameters to select either set_tlli() or confirm_tlli(). The MS object is instantiated with TLLI = 0, and therefore GprsMs::tlli() is extended to return the DL TLLI if both of the other TLLI are not set. Note that create_ms() will not check whether an MS object with a matching TLLI is already stored in the list, so it should only be called after a corresponding get_ms() in general. Sponsored-by: On-Waves ehf
2015-05-21 14:58:22 +00:00
The MS object cannot fully confirm an unexpected TLLI: 0xc0000013, partly confirmed
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=19 TLLI=0xc0000013 DIR=DL STATE=NULL) [DOWNLINK] START
tbf: Move IMSI to MS object Currently the IMSI is stored in the TBFs. Since it directly refers to an MS, it should rather be stored in an MS object. This patch move the m_imsi field from gprs_rlcmac_tbf to GprsMs, changes gprs_rlcmac_tbf::imsi() to get the IMSI from the associated MS object, and adds getter and setter to GprsMs. Before changing the IMSI of the associated MS object, assign_imsi() checks if there is already another MS object with the same IMSI and eventually resets the IMSI of that one. So using update_ms() and assign_imsi() ensures that there are not two MS object entries is the storage with the same TLLI or the same IMSI. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-21 09:07:16 +00:00
Modifying MS object, TLLI = 0xc0000013, IMSI '' -> '001001000000019'
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Send dowlink assignment for TBF(TFI=19 TLLI=0xc0000013 DIR=DL STATE=NULL) on PCH, no TBF exist (IMSI=001001000000019)
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=19 TLLI=0xc0000013 DIR=DL STATE=NULL) changes state from NULL to ASSIGN
TX: START TBF(TFI=19 TLLI=0xc0000013 DIR=DL STATE=ASSIGN) Immediate Assignment Downlink (PCH)
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Sending data request: trx=0 ts=0 sapi=3 arfcn=0 fn=0 block=0 data=30 31 39 2d 06 3f 30 0c 00 00 7d 80 00 00 00 dc 00 00 01 3c c0 23 2b 2b 2b 2b
tbf: Fix downlink packet loss When the MS is pinged with a longer interval, many packets get lost even if the GprsMs object is kept. If the interval is above the time where the DL TBF is in state FLOW (mainly influenced be the dl-tbf-idle-time command), an new TBF must be requested via AGCH for each ICMP PING message. Currently the LLC frame containing the PING is immediately stored in the TBF and gets lost, if TBF establishment fails for some reason. This commit moves all calls to put_frame() to schedule_next_frame(), where the data is moved from the LLC queue to the frame storage within the TBF object. This method is only called from within create_new_bsn() when the TBF is in the FLOW state and the frame is going to be encoded immediately. At all other places, where put_frame() has been called before, the LLC message is just appended to the LLC queue in the GprsMs object. This change effectively simplifies the related code parts, since date/len information and discard notifications is no longer needed there. Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 12:06:09 +00:00
TBF(TFI=19 TLLI=0xc0000013 DIR=DL STATE=ASSIGN) append
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
********** TBF starts here **********
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
Allocating DL TBF: MS_CLASS=45
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Creating MS object, TLLI = 0x00000000
Modifying MS object, TLLI = 0x00000000, MS class 0 -> 45
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
Slot Allocation (Algorithm A) for class 45
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
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
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Skipping TS 7, because not enabled
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
- Assign downlink TS=4 TFI=20
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Attaching TBF(TFI=20 TLLI=0x00000000 DIR=DL STATE=NULL), 21 TBFs, USFs = 00, TFIs = 001fffff.
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
- Setting Control TS 4
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Attaching TBF to MS object, TLLI = 0x00000000, TBF = TBF(TFI=20 TLLI=0x00000000 DIR=DL STATE=NULL)
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
Allocated TBF(TFI=20 TLLI=0x00000000 DIR=DL STATE=NULL): trx = 0, ul_slots = 10, dl_slots = 10
tbf: Always call set_tlli/confirm_tlli in update_ms Currently the m_tlli member in GprsMs is set by the constructor, circumventing the TLLI confirmation mechanism. This commit replaces the get_or_create_ms() method by a create_ms() method which takes the TLLI and the direction (UL or DL) as parameters to select either set_tlli() or confirm_tlli(). The MS object is instantiated with TLLI = 0, and therefore GprsMs::tlli() is extended to return the DL TLLI if both of the other TLLI are not set. Note that create_ms() will not check whether an MS object with a matching TLLI is already stored in the list, so it should only be called after a corresponding get_ms() in general. Sponsored-by: On-Waves ehf
2015-05-21 14:58:22 +00:00
The MS object cannot fully confirm an unexpected TLLI: 0xc0000014, partly confirmed
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=20 TLLI=0xc0000014 DIR=DL STATE=NULL) [DOWNLINK] START
tbf: Move IMSI to MS object Currently the IMSI is stored in the TBFs. Since it directly refers to an MS, it should rather be stored in an MS object. This patch move the m_imsi field from gprs_rlcmac_tbf to GprsMs, changes gprs_rlcmac_tbf::imsi() to get the IMSI from the associated MS object, and adds getter and setter to GprsMs. Before changing the IMSI of the associated MS object, assign_imsi() checks if there is already another MS object with the same IMSI and eventually resets the IMSI of that one. So using update_ms() and assign_imsi() ensures that there are not two MS object entries is the storage with the same TLLI or the same IMSI. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-21 09:07:16 +00:00
Modifying MS object, TLLI = 0xc0000014, IMSI '' -> '001001000000020'
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Send dowlink assignment for TBF(TFI=20 TLLI=0xc0000014 DIR=DL STATE=NULL) on PCH, no TBF exist (IMSI=001001000000020)
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=20 TLLI=0xc0000014 DIR=DL STATE=NULL) changes state from NULL to ASSIGN
TX: START TBF(TFI=20 TLLI=0xc0000014 DIR=DL STATE=ASSIGN) Immediate Assignment Downlink (PCH)
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Sending data request: trx=0 ts=0 sapi=3 arfcn=0 fn=0 block=0 data=30 32 30 2d 06 3f 30 0c 00 00 7d 80 00 00 00 dc 00 00 01 4d 00 23 2b 2b 2b 2b
tbf: Fix downlink packet loss When the MS is pinged with a longer interval, many packets get lost even if the GprsMs object is kept. If the interval is above the time where the DL TBF is in state FLOW (mainly influenced be the dl-tbf-idle-time command), an new TBF must be requested via AGCH for each ICMP PING message. Currently the LLC frame containing the PING is immediately stored in the TBF and gets lost, if TBF establishment fails for some reason. This commit moves all calls to put_frame() to schedule_next_frame(), where the data is moved from the LLC queue to the frame storage within the TBF object. This method is only called from within create_new_bsn() when the TBF is in the FLOW state and the frame is going to be encoded immediately. At all other places, where put_frame() has been called before, the LLC message is just appended to the LLC queue in the GprsMs object. This change effectively simplifies the related code parts, since date/len information and discard notifications is no longer needed there. Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 12:06:09 +00:00
TBF(TFI=20 TLLI=0xc0000014 DIR=DL STATE=ASSIGN) append
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
********** TBF starts here **********
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
Allocating DL TBF: MS_CLASS=45
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Creating MS object, TLLI = 0x00000000
Modifying MS object, TLLI = 0x00000000, MS class 0 -> 45
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
Slot Allocation (Algorithm A) for class 45
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
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
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Skipping TS 7, because not enabled
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
- Assign downlink TS=4 TFI=21
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Attaching TBF(TFI=21 TLLI=0x00000000 DIR=DL STATE=NULL), 22 TBFs, USFs = 00, TFIs = 003fffff.
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
- Setting Control TS 4
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Attaching TBF to MS object, TLLI = 0x00000000, TBF = TBF(TFI=21 TLLI=0x00000000 DIR=DL STATE=NULL)
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
Allocated TBF(TFI=21 TLLI=0x00000000 DIR=DL STATE=NULL): trx = 0, ul_slots = 10, dl_slots = 10
tbf: Always call set_tlli/confirm_tlli in update_ms Currently the m_tlli member in GprsMs is set by the constructor, circumventing the TLLI confirmation mechanism. This commit replaces the get_or_create_ms() method by a create_ms() method which takes the TLLI and the direction (UL or DL) as parameters to select either set_tlli() or confirm_tlli(). The MS object is instantiated with TLLI = 0, and therefore GprsMs::tlli() is extended to return the DL TLLI if both of the other TLLI are not set. Note that create_ms() will not check whether an MS object with a matching TLLI is already stored in the list, so it should only be called after a corresponding get_ms() in general. Sponsored-by: On-Waves ehf
2015-05-21 14:58:22 +00:00
The MS object cannot fully confirm an unexpected TLLI: 0xc0000015, partly confirmed
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=21 TLLI=0xc0000015 DIR=DL STATE=NULL) [DOWNLINK] START
tbf: Move IMSI to MS object Currently the IMSI is stored in the TBFs. Since it directly refers to an MS, it should rather be stored in an MS object. This patch move the m_imsi field from gprs_rlcmac_tbf to GprsMs, changes gprs_rlcmac_tbf::imsi() to get the IMSI from the associated MS object, and adds getter and setter to GprsMs. Before changing the IMSI of the associated MS object, assign_imsi() checks if there is already another MS object with the same IMSI and eventually resets the IMSI of that one. So using update_ms() and assign_imsi() ensures that there are not two MS object entries is the storage with the same TLLI or the same IMSI. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-21 09:07:16 +00:00
Modifying MS object, TLLI = 0xc0000015, IMSI '' -> '001001000000021'
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Send dowlink assignment for TBF(TFI=21 TLLI=0xc0000015 DIR=DL STATE=NULL) on PCH, no TBF exist (IMSI=001001000000021)
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=21 TLLI=0xc0000015 DIR=DL STATE=NULL) changes state from NULL to ASSIGN
TX: START TBF(TFI=21 TLLI=0xc0000015 DIR=DL STATE=ASSIGN) Immediate Assignment Downlink (PCH)
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Sending data request: trx=0 ts=0 sapi=3 arfcn=0 fn=0 block=0 data=30 32 31 2d 06 3f 30 0c 00 00 7d 80 00 00 00 dc 00 00 01 5d 40 23 2b 2b 2b 2b
tbf: Fix downlink packet loss When the MS is pinged with a longer interval, many packets get lost even if the GprsMs object is kept. If the interval is above the time where the DL TBF is in state FLOW (mainly influenced be the dl-tbf-idle-time command), an new TBF must be requested via AGCH for each ICMP PING message. Currently the LLC frame containing the PING is immediately stored in the TBF and gets lost, if TBF establishment fails for some reason. This commit moves all calls to put_frame() to schedule_next_frame(), where the data is moved from the LLC queue to the frame storage within the TBF object. This method is only called from within create_new_bsn() when the TBF is in the FLOW state and the frame is going to be encoded immediately. At all other places, where put_frame() has been called before, the LLC message is just appended to the LLC queue in the GprsMs object. This change effectively simplifies the related code parts, since date/len information and discard notifications is no longer needed there. Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 12:06:09 +00:00
TBF(TFI=21 TLLI=0xc0000015 DIR=DL STATE=ASSIGN) append
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
********** TBF starts here **********
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
Allocating DL TBF: MS_CLASS=45
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Creating MS object, TLLI = 0x00000000
Modifying MS object, TLLI = 0x00000000, MS class 0 -> 45
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
Slot Allocation (Algorithm A) for class 45
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
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
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Skipping TS 7, because not enabled
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
- Assign downlink TS=4 TFI=22
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Attaching TBF(TFI=22 TLLI=0x00000000 DIR=DL STATE=NULL), 23 TBFs, USFs = 00, TFIs = 007fffff.
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
- Setting Control TS 4
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Attaching TBF to MS object, TLLI = 0x00000000, TBF = TBF(TFI=22 TLLI=0x00000000 DIR=DL STATE=NULL)
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
Allocated TBF(TFI=22 TLLI=0x00000000 DIR=DL STATE=NULL): trx = 0, ul_slots = 10, dl_slots = 10
tbf: Always call set_tlli/confirm_tlli in update_ms Currently the m_tlli member in GprsMs is set by the constructor, circumventing the TLLI confirmation mechanism. This commit replaces the get_or_create_ms() method by a create_ms() method which takes the TLLI and the direction (UL or DL) as parameters to select either set_tlli() or confirm_tlli(). The MS object is instantiated with TLLI = 0, and therefore GprsMs::tlli() is extended to return the DL TLLI if both of the other TLLI are not set. Note that create_ms() will not check whether an MS object with a matching TLLI is already stored in the list, so it should only be called after a corresponding get_ms() in general. Sponsored-by: On-Waves ehf
2015-05-21 14:58:22 +00:00
The MS object cannot fully confirm an unexpected TLLI: 0xc0000016, partly confirmed
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=22 TLLI=0xc0000016 DIR=DL STATE=NULL) [DOWNLINK] START
tbf: Move IMSI to MS object Currently the IMSI is stored in the TBFs. Since it directly refers to an MS, it should rather be stored in an MS object. This patch move the m_imsi field from gprs_rlcmac_tbf to GprsMs, changes gprs_rlcmac_tbf::imsi() to get the IMSI from the associated MS object, and adds getter and setter to GprsMs. Before changing the IMSI of the associated MS object, assign_imsi() checks if there is already another MS object with the same IMSI and eventually resets the IMSI of that one. So using update_ms() and assign_imsi() ensures that there are not two MS object entries is the storage with the same TLLI or the same IMSI. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-21 09:07:16 +00:00
Modifying MS object, TLLI = 0xc0000016, IMSI '' -> '001001000000022'
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Send dowlink assignment for TBF(TFI=22 TLLI=0xc0000016 DIR=DL STATE=NULL) on PCH, no TBF exist (IMSI=001001000000022)
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=22 TLLI=0xc0000016 DIR=DL STATE=NULL) changes state from NULL to ASSIGN
TX: START TBF(TFI=22 TLLI=0xc0000016 DIR=DL STATE=ASSIGN) Immediate Assignment Downlink (PCH)
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Sending data request: trx=0 ts=0 sapi=3 arfcn=0 fn=0 block=0 data=30 32 32 2d 06 3f 30 0c 00 00 7d 80 00 00 00 dc 00 00 01 6d 80 23 2b 2b 2b 2b
tbf: Fix downlink packet loss When the MS is pinged with a longer interval, many packets get lost even if the GprsMs object is kept. If the interval is above the time where the DL TBF is in state FLOW (mainly influenced be the dl-tbf-idle-time command), an new TBF must be requested via AGCH for each ICMP PING message. Currently the LLC frame containing the PING is immediately stored in the TBF and gets lost, if TBF establishment fails for some reason. This commit moves all calls to put_frame() to schedule_next_frame(), where the data is moved from the LLC queue to the frame storage within the TBF object. This method is only called from within create_new_bsn() when the TBF is in the FLOW state and the frame is going to be encoded immediately. At all other places, where put_frame() has been called before, the LLC message is just appended to the LLC queue in the GprsMs object. This change effectively simplifies the related code parts, since date/len information and discard notifications is no longer needed there. Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 12:06:09 +00:00
TBF(TFI=22 TLLI=0xc0000016 DIR=DL STATE=ASSIGN) append
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
********** TBF starts here **********
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
Allocating DL TBF: MS_CLASS=45
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Creating MS object, TLLI = 0x00000000
Modifying MS object, TLLI = 0x00000000, MS class 0 -> 45
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
Slot Allocation (Algorithm A) for class 45
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
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
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Skipping TS 7, because not enabled
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
- Assign downlink TS=4 TFI=23
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Attaching TBF(TFI=23 TLLI=0x00000000 DIR=DL STATE=NULL), 24 TBFs, USFs = 00, TFIs = 00ffffff.
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
- Setting Control TS 4
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Attaching TBF to MS object, TLLI = 0x00000000, TBF = TBF(TFI=23 TLLI=0x00000000 DIR=DL STATE=NULL)
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
Allocated TBF(TFI=23 TLLI=0x00000000 DIR=DL STATE=NULL): trx = 0, ul_slots = 10, dl_slots = 10
tbf: Always call set_tlli/confirm_tlli in update_ms Currently the m_tlli member in GprsMs is set by the constructor, circumventing the TLLI confirmation mechanism. This commit replaces the get_or_create_ms() method by a create_ms() method which takes the TLLI and the direction (UL or DL) as parameters to select either set_tlli() or confirm_tlli(). The MS object is instantiated with TLLI = 0, and therefore GprsMs::tlli() is extended to return the DL TLLI if both of the other TLLI are not set. Note that create_ms() will not check whether an MS object with a matching TLLI is already stored in the list, so it should only be called after a corresponding get_ms() in general. Sponsored-by: On-Waves ehf
2015-05-21 14:58:22 +00:00
The MS object cannot fully confirm an unexpected TLLI: 0xc0000017, partly confirmed
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=23 TLLI=0xc0000017 DIR=DL STATE=NULL) [DOWNLINK] START
tbf: Move IMSI to MS object Currently the IMSI is stored in the TBFs. Since it directly refers to an MS, it should rather be stored in an MS object. This patch move the m_imsi field from gprs_rlcmac_tbf to GprsMs, changes gprs_rlcmac_tbf::imsi() to get the IMSI from the associated MS object, and adds getter and setter to GprsMs. Before changing the IMSI of the associated MS object, assign_imsi() checks if there is already another MS object with the same IMSI and eventually resets the IMSI of that one. So using update_ms() and assign_imsi() ensures that there are not two MS object entries is the storage with the same TLLI or the same IMSI. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-21 09:07:16 +00:00
Modifying MS object, TLLI = 0xc0000017, IMSI '' -> '001001000000023'
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Send dowlink assignment for TBF(TFI=23 TLLI=0xc0000017 DIR=DL STATE=NULL) on PCH, no TBF exist (IMSI=001001000000023)
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=23 TLLI=0xc0000017 DIR=DL STATE=NULL) changes state from NULL to ASSIGN
TX: START TBF(TFI=23 TLLI=0xc0000017 DIR=DL STATE=ASSIGN) Immediate Assignment Downlink (PCH)
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Sending data request: trx=0 ts=0 sapi=3 arfcn=0 fn=0 block=0 data=30 32 33 2d 06 3f 30 0c 00 00 7d 80 00 00 00 dc 00 00 01 7d c0 23 2b 2b 2b 2b
tbf: Fix downlink packet loss When the MS is pinged with a longer interval, many packets get lost even if the GprsMs object is kept. If the interval is above the time where the DL TBF is in state FLOW (mainly influenced be the dl-tbf-idle-time command), an new TBF must be requested via AGCH for each ICMP PING message. Currently the LLC frame containing the PING is immediately stored in the TBF and gets lost, if TBF establishment fails for some reason. This commit moves all calls to put_frame() to schedule_next_frame(), where the data is moved from the LLC queue to the frame storage within the TBF object. This method is only called from within create_new_bsn() when the TBF is in the FLOW state and the frame is going to be encoded immediately. At all other places, where put_frame() has been called before, the LLC message is just appended to the LLC queue in the GprsMs object. This change effectively simplifies the related code parts, since date/len information and discard notifications is no longer needed there. Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 12:06:09 +00:00
TBF(TFI=23 TLLI=0xc0000017 DIR=DL STATE=ASSIGN) append
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
********** TBF starts here **********
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
Allocating DL TBF: MS_CLASS=45
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Creating MS object, TLLI = 0x00000000
Modifying MS object, TLLI = 0x00000000, MS class 0 -> 45
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
Slot Allocation (Algorithm A) for class 45
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
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
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Skipping TS 7, because not enabled
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
- Assign downlink TS=4 TFI=24
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Attaching TBF(TFI=24 TLLI=0x00000000 DIR=DL STATE=NULL), 25 TBFs, USFs = 00, TFIs = 01ffffff.
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
- Setting Control TS 4
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Attaching TBF to MS object, TLLI = 0x00000000, TBF = TBF(TFI=24 TLLI=0x00000000 DIR=DL STATE=NULL)
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
Allocated TBF(TFI=24 TLLI=0x00000000 DIR=DL STATE=NULL): trx = 0, ul_slots = 10, dl_slots = 10
tbf: Always call set_tlli/confirm_tlli in update_ms Currently the m_tlli member in GprsMs is set by the constructor, circumventing the TLLI confirmation mechanism. This commit replaces the get_or_create_ms() method by a create_ms() method which takes the TLLI and the direction (UL or DL) as parameters to select either set_tlli() or confirm_tlli(). The MS object is instantiated with TLLI = 0, and therefore GprsMs::tlli() is extended to return the DL TLLI if both of the other TLLI are not set. Note that create_ms() will not check whether an MS object with a matching TLLI is already stored in the list, so it should only be called after a corresponding get_ms() in general. Sponsored-by: On-Waves ehf
2015-05-21 14:58:22 +00:00
The MS object cannot fully confirm an unexpected TLLI: 0xc0000018, partly confirmed
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=24 TLLI=0xc0000018 DIR=DL STATE=NULL) [DOWNLINK] START
tbf: Move IMSI to MS object Currently the IMSI is stored in the TBFs. Since it directly refers to an MS, it should rather be stored in an MS object. This patch move the m_imsi field from gprs_rlcmac_tbf to GprsMs, changes gprs_rlcmac_tbf::imsi() to get the IMSI from the associated MS object, and adds getter and setter to GprsMs. Before changing the IMSI of the associated MS object, assign_imsi() checks if there is already another MS object with the same IMSI and eventually resets the IMSI of that one. So using update_ms() and assign_imsi() ensures that there are not two MS object entries is the storage with the same TLLI or the same IMSI. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-21 09:07:16 +00:00
Modifying MS object, TLLI = 0xc0000018, IMSI '' -> '001001000000024'
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Send dowlink assignment for TBF(TFI=24 TLLI=0xc0000018 DIR=DL STATE=NULL) on PCH, no TBF exist (IMSI=001001000000024)
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=24 TLLI=0xc0000018 DIR=DL STATE=NULL) changes state from NULL to ASSIGN
TX: START TBF(TFI=24 TLLI=0xc0000018 DIR=DL STATE=ASSIGN) Immediate Assignment Downlink (PCH)
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Sending data request: trx=0 ts=0 sapi=3 arfcn=0 fn=0 block=0 data=30 32 34 2d 06 3f 30 0c 00 00 7d 80 00 00 00 dc 00 00 01 8e 00 23 2b 2b 2b 2b
tbf: Fix downlink packet loss When the MS is pinged with a longer interval, many packets get lost even if the GprsMs object is kept. If the interval is above the time where the DL TBF is in state FLOW (mainly influenced be the dl-tbf-idle-time command), an new TBF must be requested via AGCH for each ICMP PING message. Currently the LLC frame containing the PING is immediately stored in the TBF and gets lost, if TBF establishment fails for some reason. This commit moves all calls to put_frame() to schedule_next_frame(), where the data is moved from the LLC queue to the frame storage within the TBF object. This method is only called from within create_new_bsn() when the TBF is in the FLOW state and the frame is going to be encoded immediately. At all other places, where put_frame() has been called before, the LLC message is just appended to the LLC queue in the GprsMs object. This change effectively simplifies the related code parts, since date/len information and discard notifications is no longer needed there. Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 12:06:09 +00:00
TBF(TFI=24 TLLI=0xc0000018 DIR=DL STATE=ASSIGN) append
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
********** TBF starts here **********
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
Allocating DL TBF: MS_CLASS=45
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Creating MS object, TLLI = 0x00000000
Modifying MS object, TLLI = 0x00000000, MS class 0 -> 45
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
Slot Allocation (Algorithm A) for class 45
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
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
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Skipping TS 7, because not enabled
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
- Assign downlink TS=4 TFI=25
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Attaching TBF(TFI=25 TLLI=0x00000000 DIR=DL STATE=NULL), 26 TBFs, USFs = 00, TFIs = 03ffffff.
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
- Setting Control TS 4
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Attaching TBF to MS object, TLLI = 0x00000000, TBF = TBF(TFI=25 TLLI=0x00000000 DIR=DL STATE=NULL)
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
Allocated TBF(TFI=25 TLLI=0x00000000 DIR=DL STATE=NULL): trx = 0, ul_slots = 10, dl_slots = 10
tbf: Always call set_tlli/confirm_tlli in update_ms Currently the m_tlli member in GprsMs is set by the constructor, circumventing the TLLI confirmation mechanism. This commit replaces the get_or_create_ms() method by a create_ms() method which takes the TLLI and the direction (UL or DL) as parameters to select either set_tlli() or confirm_tlli(). The MS object is instantiated with TLLI = 0, and therefore GprsMs::tlli() is extended to return the DL TLLI if both of the other TLLI are not set. Note that create_ms() will not check whether an MS object with a matching TLLI is already stored in the list, so it should only be called after a corresponding get_ms() in general. Sponsored-by: On-Waves ehf
2015-05-21 14:58:22 +00:00
The MS object cannot fully confirm an unexpected TLLI: 0xc0000019, partly confirmed
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=25 TLLI=0xc0000019 DIR=DL STATE=NULL) [DOWNLINK] START
tbf: Move IMSI to MS object Currently the IMSI is stored in the TBFs. Since it directly refers to an MS, it should rather be stored in an MS object. This patch move the m_imsi field from gprs_rlcmac_tbf to GprsMs, changes gprs_rlcmac_tbf::imsi() to get the IMSI from the associated MS object, and adds getter and setter to GprsMs. Before changing the IMSI of the associated MS object, assign_imsi() checks if there is already another MS object with the same IMSI and eventually resets the IMSI of that one. So using update_ms() and assign_imsi() ensures that there are not two MS object entries is the storage with the same TLLI or the same IMSI. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-21 09:07:16 +00:00
Modifying MS object, TLLI = 0xc0000019, IMSI '' -> '001001000000025'
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Send dowlink assignment for TBF(TFI=25 TLLI=0xc0000019 DIR=DL STATE=NULL) on PCH, no TBF exist (IMSI=001001000000025)
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=25 TLLI=0xc0000019 DIR=DL STATE=NULL) changes state from NULL to ASSIGN
TX: START TBF(TFI=25 TLLI=0xc0000019 DIR=DL STATE=ASSIGN) Immediate Assignment Downlink (PCH)
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Sending data request: trx=0 ts=0 sapi=3 arfcn=0 fn=0 block=0 data=30 32 35 2d 06 3f 30 0c 00 00 7d 80 00 00 00 dc 00 00 01 9e 40 23 2b 2b 2b 2b
tbf: Fix downlink packet loss When the MS is pinged with a longer interval, many packets get lost even if the GprsMs object is kept. If the interval is above the time where the DL TBF is in state FLOW (mainly influenced be the dl-tbf-idle-time command), an new TBF must be requested via AGCH for each ICMP PING message. Currently the LLC frame containing the PING is immediately stored in the TBF and gets lost, if TBF establishment fails for some reason. This commit moves all calls to put_frame() to schedule_next_frame(), where the data is moved from the LLC queue to the frame storage within the TBF object. This method is only called from within create_new_bsn() when the TBF is in the FLOW state and the frame is going to be encoded immediately. At all other places, where put_frame() has been called before, the LLC message is just appended to the LLC queue in the GprsMs object. This change effectively simplifies the related code parts, since date/len information and discard notifications is no longer needed there. Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 12:06:09 +00:00
TBF(TFI=25 TLLI=0xc0000019 DIR=DL STATE=ASSIGN) append
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
********** TBF starts here **********
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
Allocating DL TBF: MS_CLASS=45
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Creating MS object, TLLI = 0x00000000
Modifying MS object, TLLI = 0x00000000, MS class 0 -> 45
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
Slot Allocation (Algorithm A) for class 45
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
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
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Skipping TS 7, because not enabled
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
- Assign downlink TS=4 TFI=26
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Attaching TBF(TFI=26 TLLI=0x00000000 DIR=DL STATE=NULL), 27 TBFs, USFs = 00, TFIs = 07ffffff.
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
- Setting Control TS 4
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Attaching TBF to MS object, TLLI = 0x00000000, TBF = TBF(TFI=26 TLLI=0x00000000 DIR=DL STATE=NULL)
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
Allocated TBF(TFI=26 TLLI=0x00000000 DIR=DL STATE=NULL): trx = 0, ul_slots = 10, dl_slots = 10
tbf: Always call set_tlli/confirm_tlli in update_ms Currently the m_tlli member in GprsMs is set by the constructor, circumventing the TLLI confirmation mechanism. This commit replaces the get_or_create_ms() method by a create_ms() method which takes the TLLI and the direction (UL or DL) as parameters to select either set_tlli() or confirm_tlli(). The MS object is instantiated with TLLI = 0, and therefore GprsMs::tlli() is extended to return the DL TLLI if both of the other TLLI are not set. Note that create_ms() will not check whether an MS object with a matching TLLI is already stored in the list, so it should only be called after a corresponding get_ms() in general. Sponsored-by: On-Waves ehf
2015-05-21 14:58:22 +00:00
The MS object cannot fully confirm an unexpected TLLI: 0xc000001a, partly confirmed
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=26 TLLI=0xc000001a DIR=DL STATE=NULL) [DOWNLINK] START
tbf: Move IMSI to MS object Currently the IMSI is stored in the TBFs. Since it directly refers to an MS, it should rather be stored in an MS object. This patch move the m_imsi field from gprs_rlcmac_tbf to GprsMs, changes gprs_rlcmac_tbf::imsi() to get the IMSI from the associated MS object, and adds getter and setter to GprsMs. Before changing the IMSI of the associated MS object, assign_imsi() checks if there is already another MS object with the same IMSI and eventually resets the IMSI of that one. So using update_ms() and assign_imsi() ensures that there are not two MS object entries is the storage with the same TLLI or the same IMSI. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-21 09:07:16 +00:00
Modifying MS object, TLLI = 0xc000001a, IMSI '' -> '001001000000026'
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Send dowlink assignment for TBF(TFI=26 TLLI=0xc000001a DIR=DL STATE=NULL) on PCH, no TBF exist (IMSI=001001000000026)
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=26 TLLI=0xc000001a DIR=DL STATE=NULL) changes state from NULL to ASSIGN
TX: START TBF(TFI=26 TLLI=0xc000001a DIR=DL STATE=ASSIGN) Immediate Assignment Downlink (PCH)
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Sending data request: trx=0 ts=0 sapi=3 arfcn=0 fn=0 block=0 data=30 32 36 2d 06 3f 30 0c 00 00 7d 80 00 00 00 dc 00 00 01 ae 80 23 2b 2b 2b 2b
tbf: Fix downlink packet loss When the MS is pinged with a longer interval, many packets get lost even if the GprsMs object is kept. If the interval is above the time where the DL TBF is in state FLOW (mainly influenced be the dl-tbf-idle-time command), an new TBF must be requested via AGCH for each ICMP PING message. Currently the LLC frame containing the PING is immediately stored in the TBF and gets lost, if TBF establishment fails for some reason. This commit moves all calls to put_frame() to schedule_next_frame(), where the data is moved from the LLC queue to the frame storage within the TBF object. This method is only called from within create_new_bsn() when the TBF is in the FLOW state and the frame is going to be encoded immediately. At all other places, where put_frame() has been called before, the LLC message is just appended to the LLC queue in the GprsMs object. This change effectively simplifies the related code parts, since date/len information and discard notifications is no longer needed there. Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 12:06:09 +00:00
TBF(TFI=26 TLLI=0xc000001a DIR=DL STATE=ASSIGN) append
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
********** TBF starts here **********
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
Allocating DL TBF: MS_CLASS=45
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Creating MS object, TLLI = 0x00000000
Modifying MS object, TLLI = 0x00000000, MS class 0 -> 45
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
Slot Allocation (Algorithm A) for class 45
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
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
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Skipping TS 7, because not enabled
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
- Assign downlink TS=4 TFI=27
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Attaching TBF(TFI=27 TLLI=0x00000000 DIR=DL STATE=NULL), 28 TBFs, USFs = 00, TFIs = 0fffffff.
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
- Setting Control TS 4
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Attaching TBF to MS object, TLLI = 0x00000000, TBF = TBF(TFI=27 TLLI=0x00000000 DIR=DL STATE=NULL)
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
Allocated TBF(TFI=27 TLLI=0x00000000 DIR=DL STATE=NULL): trx = 0, ul_slots = 10, dl_slots = 10
tbf: Always call set_tlli/confirm_tlli in update_ms Currently the m_tlli member in GprsMs is set by the constructor, circumventing the TLLI confirmation mechanism. This commit replaces the get_or_create_ms() method by a create_ms() method which takes the TLLI and the direction (UL or DL) as parameters to select either set_tlli() or confirm_tlli(). The MS object is instantiated with TLLI = 0, and therefore GprsMs::tlli() is extended to return the DL TLLI if both of the other TLLI are not set. Note that create_ms() will not check whether an MS object with a matching TLLI is already stored in the list, so it should only be called after a corresponding get_ms() in general. Sponsored-by: On-Waves ehf
2015-05-21 14:58:22 +00:00
The MS object cannot fully confirm an unexpected TLLI: 0xc000001b, partly confirmed
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=27 TLLI=0xc000001b DIR=DL STATE=NULL) [DOWNLINK] START
tbf: Move IMSI to MS object Currently the IMSI is stored in the TBFs. Since it directly refers to an MS, it should rather be stored in an MS object. This patch move the m_imsi field from gprs_rlcmac_tbf to GprsMs, changes gprs_rlcmac_tbf::imsi() to get the IMSI from the associated MS object, and adds getter and setter to GprsMs. Before changing the IMSI of the associated MS object, assign_imsi() checks if there is already another MS object with the same IMSI and eventually resets the IMSI of that one. So using update_ms() and assign_imsi() ensures that there are not two MS object entries is the storage with the same TLLI or the same IMSI. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-21 09:07:16 +00:00
Modifying MS object, TLLI = 0xc000001b, IMSI '' -> '001001000000027'
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Send dowlink assignment for TBF(TFI=27 TLLI=0xc000001b DIR=DL STATE=NULL) on PCH, no TBF exist (IMSI=001001000000027)
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=27 TLLI=0xc000001b DIR=DL STATE=NULL) changes state from NULL to ASSIGN
TX: START TBF(TFI=27 TLLI=0xc000001b DIR=DL STATE=ASSIGN) Immediate Assignment Downlink (PCH)
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Sending data request: trx=0 ts=0 sapi=3 arfcn=0 fn=0 block=0 data=30 32 37 2d 06 3f 30 0c 00 00 7d 80 00 00 00 dc 00 00 01 be c0 23 2b 2b 2b 2b
tbf: Fix downlink packet loss When the MS is pinged with a longer interval, many packets get lost even if the GprsMs object is kept. If the interval is above the time where the DL TBF is in state FLOW (mainly influenced be the dl-tbf-idle-time command), an new TBF must be requested via AGCH for each ICMP PING message. Currently the LLC frame containing the PING is immediately stored in the TBF and gets lost, if TBF establishment fails for some reason. This commit moves all calls to put_frame() to schedule_next_frame(), where the data is moved from the LLC queue to the frame storage within the TBF object. This method is only called from within create_new_bsn() when the TBF is in the FLOW state and the frame is going to be encoded immediately. At all other places, where put_frame() has been called before, the LLC message is just appended to the LLC queue in the GprsMs object. This change effectively simplifies the related code parts, since date/len information and discard notifications is no longer needed there. Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 12:06:09 +00:00
TBF(TFI=27 TLLI=0xc000001b DIR=DL STATE=ASSIGN) append
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
********** TBF starts here **********
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
Allocating DL TBF: MS_CLASS=45
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Creating MS object, TLLI = 0x00000000
Modifying MS object, TLLI = 0x00000000, MS class 0 -> 45
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
Slot Allocation (Algorithm A) for class 45
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
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
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Skipping TS 7, because not enabled
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
- Assign downlink TS=4 TFI=28
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Attaching TBF(TFI=28 TLLI=0x00000000 DIR=DL STATE=NULL), 29 TBFs, USFs = 00, TFIs = 1fffffff.
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
- Setting Control TS 4
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Attaching TBF to MS object, TLLI = 0x00000000, TBF = TBF(TFI=28 TLLI=0x00000000 DIR=DL STATE=NULL)
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
Allocated TBF(TFI=28 TLLI=0x00000000 DIR=DL STATE=NULL): trx = 0, ul_slots = 10, dl_slots = 10
tbf: Always call set_tlli/confirm_tlli in update_ms Currently the m_tlli member in GprsMs is set by the constructor, circumventing the TLLI confirmation mechanism. This commit replaces the get_or_create_ms() method by a create_ms() method which takes the TLLI and the direction (UL or DL) as parameters to select either set_tlli() or confirm_tlli(). The MS object is instantiated with TLLI = 0, and therefore GprsMs::tlli() is extended to return the DL TLLI if both of the other TLLI are not set. Note that create_ms() will not check whether an MS object with a matching TLLI is already stored in the list, so it should only be called after a corresponding get_ms() in general. Sponsored-by: On-Waves ehf
2015-05-21 14:58:22 +00:00
The MS object cannot fully confirm an unexpected TLLI: 0xc000001c, partly confirmed
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=28 TLLI=0xc000001c DIR=DL STATE=NULL) [DOWNLINK] START
tbf: Move IMSI to MS object Currently the IMSI is stored in the TBFs. Since it directly refers to an MS, it should rather be stored in an MS object. This patch move the m_imsi field from gprs_rlcmac_tbf to GprsMs, changes gprs_rlcmac_tbf::imsi() to get the IMSI from the associated MS object, and adds getter and setter to GprsMs. Before changing the IMSI of the associated MS object, assign_imsi() checks if there is already another MS object with the same IMSI and eventually resets the IMSI of that one. So using update_ms() and assign_imsi() ensures that there are not two MS object entries is the storage with the same TLLI or the same IMSI. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-21 09:07:16 +00:00
Modifying MS object, TLLI = 0xc000001c, IMSI '' -> '001001000000028'
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Send dowlink assignment for TBF(TFI=28 TLLI=0xc000001c DIR=DL STATE=NULL) on PCH, no TBF exist (IMSI=001001000000028)
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=28 TLLI=0xc000001c DIR=DL STATE=NULL) changes state from NULL to ASSIGN
TX: START TBF(TFI=28 TLLI=0xc000001c DIR=DL STATE=ASSIGN) Immediate Assignment Downlink (PCH)
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Sending data request: trx=0 ts=0 sapi=3 arfcn=0 fn=0 block=0 data=30 32 38 2d 06 3f 30 0c 00 00 7d 80 00 00 00 dc 00 00 01 cf 00 23 2b 2b 2b 2b
tbf: Fix downlink packet loss When the MS is pinged with a longer interval, many packets get lost even if the GprsMs object is kept. If the interval is above the time where the DL TBF is in state FLOW (mainly influenced be the dl-tbf-idle-time command), an new TBF must be requested via AGCH for each ICMP PING message. Currently the LLC frame containing the PING is immediately stored in the TBF and gets lost, if TBF establishment fails for some reason. This commit moves all calls to put_frame() to schedule_next_frame(), where the data is moved from the LLC queue to the frame storage within the TBF object. This method is only called from within create_new_bsn() when the TBF is in the FLOW state and the frame is going to be encoded immediately. At all other places, where put_frame() has been called before, the LLC message is just appended to the LLC queue in the GprsMs object. This change effectively simplifies the related code parts, since date/len information and discard notifications is no longer needed there. Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 12:06:09 +00:00
TBF(TFI=28 TLLI=0xc000001c DIR=DL STATE=ASSIGN) append
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
********** TBF starts here **********
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
Allocating DL TBF: MS_CLASS=45
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Creating MS object, TLLI = 0x00000000
Modifying MS object, TLLI = 0x00000000, MS class 0 -> 45
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
Slot Allocation (Algorithm A) for class 45
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
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
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Skipping TS 7, because not enabled
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
- Assign downlink TS=4 TFI=29
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Attaching TBF(TFI=29 TLLI=0x00000000 DIR=DL STATE=NULL), 30 TBFs, USFs = 00, TFIs = 3fffffff.
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
- Setting Control TS 4
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Attaching TBF to MS object, TLLI = 0x00000000, TBF = TBF(TFI=29 TLLI=0x00000000 DIR=DL STATE=NULL)
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
Allocated TBF(TFI=29 TLLI=0x00000000 DIR=DL STATE=NULL): trx = 0, ul_slots = 10, dl_slots = 10
tbf: Always call set_tlli/confirm_tlli in update_ms Currently the m_tlli member in GprsMs is set by the constructor, circumventing the TLLI confirmation mechanism. This commit replaces the get_or_create_ms() method by a create_ms() method which takes the TLLI and the direction (UL or DL) as parameters to select either set_tlli() or confirm_tlli(). The MS object is instantiated with TLLI = 0, and therefore GprsMs::tlli() is extended to return the DL TLLI if both of the other TLLI are not set. Note that create_ms() will not check whether an MS object with a matching TLLI is already stored in the list, so it should only be called after a corresponding get_ms() in general. Sponsored-by: On-Waves ehf
2015-05-21 14:58:22 +00:00
The MS object cannot fully confirm an unexpected TLLI: 0xc000001d, partly confirmed
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=29 TLLI=0xc000001d DIR=DL STATE=NULL) [DOWNLINK] START
tbf: Move IMSI to MS object Currently the IMSI is stored in the TBFs. Since it directly refers to an MS, it should rather be stored in an MS object. This patch move the m_imsi field from gprs_rlcmac_tbf to GprsMs, changes gprs_rlcmac_tbf::imsi() to get the IMSI from the associated MS object, and adds getter and setter to GprsMs. Before changing the IMSI of the associated MS object, assign_imsi() checks if there is already another MS object with the same IMSI and eventually resets the IMSI of that one. So using update_ms() and assign_imsi() ensures that there are not two MS object entries is the storage with the same TLLI or the same IMSI. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-21 09:07:16 +00:00
Modifying MS object, TLLI = 0xc000001d, IMSI '' -> '001001000000029'
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Send dowlink assignment for TBF(TFI=29 TLLI=0xc000001d DIR=DL STATE=NULL) on PCH, no TBF exist (IMSI=001001000000029)
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=29 TLLI=0xc000001d DIR=DL STATE=NULL) changes state from NULL to ASSIGN
TX: START TBF(TFI=29 TLLI=0xc000001d DIR=DL STATE=ASSIGN) Immediate Assignment Downlink (PCH)
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Sending data request: trx=0 ts=0 sapi=3 arfcn=0 fn=0 block=0 data=30 32 39 2d 06 3f 30 0c 00 00 7d 80 00 00 00 dc 00 00 01 df 40 23 2b 2b 2b 2b
tbf: Fix downlink packet loss When the MS is pinged with a longer interval, many packets get lost even if the GprsMs object is kept. If the interval is above the time where the DL TBF is in state FLOW (mainly influenced be the dl-tbf-idle-time command), an new TBF must be requested via AGCH for each ICMP PING message. Currently the LLC frame containing the PING is immediately stored in the TBF and gets lost, if TBF establishment fails for some reason. This commit moves all calls to put_frame() to schedule_next_frame(), where the data is moved from the LLC queue to the frame storage within the TBF object. This method is only called from within create_new_bsn() when the TBF is in the FLOW state and the frame is going to be encoded immediately. At all other places, where put_frame() has been called before, the LLC message is just appended to the LLC queue in the GprsMs object. This change effectively simplifies the related code parts, since date/len information and discard notifications is no longer needed there. Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 12:06:09 +00:00
TBF(TFI=29 TLLI=0xc000001d DIR=DL STATE=ASSIGN) append
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
********** TBF starts here **********
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
Allocating DL TBF: MS_CLASS=45
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Creating MS object, TLLI = 0x00000000
Modifying MS object, TLLI = 0x00000000, MS class 0 -> 45
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
Slot Allocation (Algorithm A) for class 45
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
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
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Skipping TS 7, because not enabled
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
- Assign downlink TS=4 TFI=30
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Attaching TBF(TFI=30 TLLI=0x00000000 DIR=DL STATE=NULL), 31 TBFs, USFs = 00, TFIs = 7fffffff.
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
- Setting Control TS 4
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Attaching TBF to MS object, TLLI = 0x00000000, TBF = TBF(TFI=30 TLLI=0x00000000 DIR=DL STATE=NULL)
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
Allocated TBF(TFI=30 TLLI=0x00000000 DIR=DL STATE=NULL): trx = 0, ul_slots = 10, dl_slots = 10
tbf: Always call set_tlli/confirm_tlli in update_ms Currently the m_tlli member in GprsMs is set by the constructor, circumventing the TLLI confirmation mechanism. This commit replaces the get_or_create_ms() method by a create_ms() method which takes the TLLI and the direction (UL or DL) as parameters to select either set_tlli() or confirm_tlli(). The MS object is instantiated with TLLI = 0, and therefore GprsMs::tlli() is extended to return the DL TLLI if both of the other TLLI are not set. Note that create_ms() will not check whether an MS object with a matching TLLI is already stored in the list, so it should only be called after a corresponding get_ms() in general. Sponsored-by: On-Waves ehf
2015-05-21 14:58:22 +00:00
The MS object cannot fully confirm an unexpected TLLI: 0xc000001e, partly confirmed
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=30 TLLI=0xc000001e DIR=DL STATE=NULL) [DOWNLINK] START
tbf: Move IMSI to MS object Currently the IMSI is stored in the TBFs. Since it directly refers to an MS, it should rather be stored in an MS object. This patch move the m_imsi field from gprs_rlcmac_tbf to GprsMs, changes gprs_rlcmac_tbf::imsi() to get the IMSI from the associated MS object, and adds getter and setter to GprsMs. Before changing the IMSI of the associated MS object, assign_imsi() checks if there is already another MS object with the same IMSI and eventually resets the IMSI of that one. So using update_ms() and assign_imsi() ensures that there are not two MS object entries is the storage with the same TLLI or the same IMSI. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-21 09:07:16 +00:00
Modifying MS object, TLLI = 0xc000001e, IMSI '' -> '001001000000030'
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Send dowlink assignment for TBF(TFI=30 TLLI=0xc000001e DIR=DL STATE=NULL) on PCH, no TBF exist (IMSI=001001000000030)
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=30 TLLI=0xc000001e DIR=DL STATE=NULL) changes state from NULL to ASSIGN
TX: START TBF(TFI=30 TLLI=0xc000001e DIR=DL STATE=ASSIGN) Immediate Assignment Downlink (PCH)
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Sending data request: trx=0 ts=0 sapi=3 arfcn=0 fn=0 block=0 data=30 33 30 2d 06 3f 30 0c 00 00 7d 80 00 00 00 dc 00 00 01 ef 80 23 2b 2b 2b 2b
tbf: Fix downlink packet loss When the MS is pinged with a longer interval, many packets get lost even if the GprsMs object is kept. If the interval is above the time where the DL TBF is in state FLOW (mainly influenced be the dl-tbf-idle-time command), an new TBF must be requested via AGCH for each ICMP PING message. Currently the LLC frame containing the PING is immediately stored in the TBF and gets lost, if TBF establishment fails for some reason. This commit moves all calls to put_frame() to schedule_next_frame(), where the data is moved from the LLC queue to the frame storage within the TBF object. This method is only called from within create_new_bsn() when the TBF is in the FLOW state and the frame is going to be encoded immediately. At all other places, where put_frame() has been called before, the LLC message is just appended to the LLC queue in the GprsMs object. This change effectively simplifies the related code parts, since date/len information and discard notifications is no longer needed there. Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 12:06:09 +00:00
TBF(TFI=30 TLLI=0xc000001e DIR=DL STATE=ASSIGN) append
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
********** TBF starts here **********
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
Allocating DL TBF: MS_CLASS=45
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Creating MS object, TLLI = 0x00000000
Modifying MS object, TLLI = 0x00000000, MS class 0 -> 45
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
Slot Allocation (Algorithm A) for class 45
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
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
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Skipping TS 7, because not enabled
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
- Assign downlink TS=4 TFI=31
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Attaching TBF(TFI=31 TLLI=0x00000000 DIR=DL STATE=NULL), 32 TBFs, USFs = 00, TFIs = ffffffff.
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
- Setting Control TS 4
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Attaching TBF to MS object, TLLI = 0x00000000, TBF = TBF(TFI=31 TLLI=0x00000000 DIR=DL STATE=NULL)
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
Allocated TBF(TFI=31 TLLI=0x00000000 DIR=DL STATE=NULL): trx = 0, ul_slots = 10, dl_slots = 10
tbf: Always call set_tlli/confirm_tlli in update_ms Currently the m_tlli member in GprsMs is set by the constructor, circumventing the TLLI confirmation mechanism. This commit replaces the get_or_create_ms() method by a create_ms() method which takes the TLLI and the direction (UL or DL) as parameters to select either set_tlli() or confirm_tlli(). The MS object is instantiated with TLLI = 0, and therefore GprsMs::tlli() is extended to return the DL TLLI if both of the other TLLI are not set. Note that create_ms() will not check whether an MS object with a matching TLLI is already stored in the list, so it should only be called after a corresponding get_ms() in general. Sponsored-by: On-Waves ehf
2015-05-21 14:58:22 +00:00
The MS object cannot fully confirm an unexpected TLLI: 0xc000001f, partly confirmed
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=31 TLLI=0xc000001f DIR=DL STATE=NULL) [DOWNLINK] START
tbf: Move IMSI to MS object Currently the IMSI is stored in the TBFs. Since it directly refers to an MS, it should rather be stored in an MS object. This patch move the m_imsi field from gprs_rlcmac_tbf to GprsMs, changes gprs_rlcmac_tbf::imsi() to get the IMSI from the associated MS object, and adds getter and setter to GprsMs. Before changing the IMSI of the associated MS object, assign_imsi() checks if there is already another MS object with the same IMSI and eventually resets the IMSI of that one. So using update_ms() and assign_imsi() ensures that there are not two MS object entries is the storage with the same TLLI or the same IMSI. Ticket: #1674 Sponsored-by: On-Waves ehf
2015-05-21 09:07:16 +00:00
Modifying MS object, TLLI = 0xc000001f, IMSI '' -> '001001000000031'
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Send dowlink assignment for TBF(TFI=31 TLLI=0xc000001f DIR=DL STATE=NULL) on PCH, no TBF exist (IMSI=001001000000031)
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
TBF(TFI=31 TLLI=0xc000001f DIR=DL STATE=NULL) changes state from NULL to ASSIGN
TX: START TBF(TFI=31 TLLI=0xc000001f DIR=DL STATE=ASSIGN) Immediate Assignment Downlink (PCH)
tbf/test: Fix IMSI creation Currently the generated IMSI contains blanks due to a missing '0' flag in the corresponding snprintf statement. In addition, the buffer is effectively limited to 15 bytes which is shorter than the generated character sequence, such that the last character of the IMSI is removed. This patch fixes both issues. Since snprintf itself will add a terminating \0 character, the whole buffer can be passed to snprintf. Sponsored-by: On-Waves ehf
2015-05-21 10:06:58 +00:00
Sending data request: trx=0 ts=0 sapi=3 arfcn=0 fn=0 block=0 data=30 33 31 2d 06 3f 30 0c 00 00 7d 80 00 00 00 dc 00 00 01 ff c0 23 2b 2b 2b 2b
tbf: Fix downlink packet loss When the MS is pinged with a longer interval, many packets get lost even if the GprsMs object is kept. If the interval is above the time where the DL TBF is in state FLOW (mainly influenced be the dl-tbf-idle-time command), an new TBF must be requested via AGCH for each ICMP PING message. Currently the LLC frame containing the PING is immediately stored in the TBF and gets lost, if TBF establishment fails for some reason. This commit moves all calls to put_frame() to schedule_next_frame(), where the data is moved from the LLC queue to the frame storage within the TBF object. This method is only called from within create_new_bsn() when the TBF is in the FLOW state and the frame is going to be encoded immediately. At all other places, where put_frame() has been called before, the LLC message is just appended to the LLC queue in the GprsMs object. This change effectively simplifies the related code parts, since date/len information and discard notifications is no longer needed there. Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 12:06:09 +00:00
TBF(TFI=31 TLLI=0xc000001f DIR=DL STATE=ASSIGN) append
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
********** TBF starts here **********
Allocating DL TBF: MS_CLASS=45
Creating MS object, TLLI = 0x00000000
Modifying MS object, TLLI = 0x00000000, MS class 0 -> 45
Slot Allocation (Algorithm A) for class 45
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
- Failed to find a usable TRX (TFI exhausted)
tbf/test: Add test for DL TBF exhaustion This test calls gprs_rlcmac_dl_tbf::handle() with varying TLLI and IMSI until the function fails. Sponsored-by: On-Waves ehf
2015-04-09 17:17:21 +00:00
No PDCH resource
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
Destroying MS object, TLLI = 0x00000000
tbf/test: Add test for DL LLC packet loss Currently LLC frames are lost or even reordered when the TBF has be established via the AGCH and the procedure fails for some reason. This test tries to reproduce this behaviour by throwing away the first TBF while calling the handle() method several times. The results of create_dl_acked_block() are checked against expected values (this is currently party disabled because the bug still persists). Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 11:41:00 +00:00
********** TBF starts here **********
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
Allocating DL TBF: MS_CLASS=45
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Creating MS object, TLLI = 0x00000000
Modifying MS object, TLLI = 0x00000000, MS class 0 -> 45
tbf/test: Add test for DL LLC packet loss Currently LLC frames are lost or even reordered when the TBF has be established via the AGCH and the procedure fails for some reason. This test tries to reproduce this behaviour by throwing away the first TBF while calling the handle() method several times. The results of create_dl_acked_block() are checked against expected values (this is currently party disabled because the bug still persists). Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 11:41:00 +00:00
Slot Allocation (Algorithm A) for class 45
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
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
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Skipping TS 7, because not enabled
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
- Assign downlink TS=4 TFI=0
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Attaching TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=NULL), 1 TBFs, USFs = 00, TFIs = 00000001.
tbf/test: Add test for DL LLC packet loss Currently LLC frames are lost or even reordered when the TBF has be established via the AGCH and the procedure fails for some reason. This test tries to reproduce this behaviour by throwing away the first TBF while calling the handle() method several times. The results of create_dl_acked_block() are checked against expected values (this is currently party disabled because the bug still persists). Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 11:41:00 +00:00
- Setting Control TS 4
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Attaching TBF to MS object, TLLI = 0x00000000, TBF = TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=NULL)
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
Allocated TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=NULL): trx = 0, ul_slots = 10, dl_slots = 10
tbf/test: Add test for DL LLC packet loss Currently LLC frames are lost or even reordered when the TBF has be established via the AGCH and the procedure fails for some reason. This test tries to reproduce this behaviour by throwing away the first TBF while calling the handle() method several times. The results of create_dl_acked_block() are checked against expected values (this is currently party disabled because the bug still persists). Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 11:41:00 +00:00
The MS object cannot fully confirm an unexpected TLLI: 0xc0123456, partly confirmed
TBF(TFI=0 TLLI=0xc0123456 DIR=DL STATE=NULL) [DOWNLINK] START
Modifying MS object, TLLI = 0xc0123456, IMSI '' -> '001001000123456'
Send dowlink assignment for TBF(TFI=0 TLLI=0xc0123456 DIR=DL STATE=NULL) on PCH, no TBF exist (IMSI=001001000123456)
TBF(TFI=0 TLLI=0xc0123456 DIR=DL STATE=NULL) changes state from NULL to ASSIGN
TX: START TBF(TFI=0 TLLI=0xc0123456 DIR=DL STATE=ASSIGN) Immediate Assignment Downlink (PCH)
Sending data request: trx=0 ts=0 sapi=3 arfcn=0 fn=0 block=0 data=34 35 36 2d 06 3f 30 0c 00 00 7d 80 00 00 00 dc 01 23 45 68 00 23 2b 2b 2b 2b
TBF(TFI=0 TLLI=0xc0123456 DIR=DL STATE=ASSIGN) append
tbf: Fix downlink packet loss When the MS is pinged with a longer interval, many packets get lost even if the GprsMs object is kept. If the interval is above the time where the DL TBF is in state FLOW (mainly influenced be the dl-tbf-idle-time command), an new TBF must be requested via AGCH for each ICMP PING message. Currently the LLC frame containing the PING is immediately stored in the TBF and gets lost, if TBF establishment fails for some reason. This commit moves all calls to put_frame() to schedule_next_frame(), where the data is moved from the LLC queue to the frame storage within the TBF object. This method is only called from within create_new_bsn() when the TBF is in the FLOW state and the frame is going to be encoded immediately. At all other places, where put_frame() has been called before, the LLC message is just appended to the LLC queue in the GprsMs object. This change effectively simplifies the related code parts, since date/len information and discard notifications is no longer needed there. Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 12:06:09 +00:00
TBF(TFI=0 TLLI=0xc0123456 DIR=DL STATE=ASSIGN) append
tbf/test: Add test for DL LLC packet loss Currently LLC frames are lost or even reordered when the TBF has be established via the AGCH and the procedure fails for some reason. This test tries to reproduce this behaviour by throwing away the first TBF while calling the handle() method several times. The results of create_dl_acked_block() are checked against expected values (this is currently party disabled because the bug still persists). Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 11:41:00 +00:00
TBF(TFI=0 TLLI=0xc0123456 DIR=DL STATE=ASSIGN) free
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Detaching TBF(TFI=0 TLLI=0xc0123456 DIR=DL STATE=ASSIGN), 0 TBFs, USFs = 00, TFIs = 00000000.
tbf/test: Add test for DL LLC packet loss Currently LLC frames are lost or even reordered when the TBF has be established via the AGCH and the procedure fails for some reason. This test tries to reproduce this behaviour by throwing away the first TBF while calling the handle() method several times. The results of create_dl_acked_block() are checked against expected values (this is currently party disabled because the bug still persists). Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 11:41:00 +00:00
Detaching TBF from MS object, TLLI = 0xc0123456, TBF = TBF(TFI=0 TLLI=0xc0123456 DIR=DL STATE=ASSIGN)
********** TBF ends here **********
********** TBF starts here **********
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
Allocating DL TBF: MS_CLASS=45
tbf/test: Add test for DL LLC packet loss Currently LLC frames are lost or even reordered when the TBF has be established via the AGCH and the procedure fails for some reason. This test tries to reproduce this behaviour by throwing away the first TBF while calling the handle() method several times. The results of create_dl_acked_block() are checked against expected values (this is currently party disabled because the bug still persists). Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 11:41:00 +00:00
Slot Allocation (Algorithm A) for class 45
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
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
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Skipping TS 7, because not enabled
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
- Assign downlink TS=4 TFI=0
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 4, TRX 0): Attaching TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=NULL), 1 TBFs, USFs = 00, TFIs = 00000001.
tbf/test: Add test for DL LLC packet loss Currently LLC frames are lost or even reordered when the TBF has be established via the AGCH and the procedure fails for some reason. This test tries to reproduce this behaviour by throwing away the first TBF while calling the handle() method several times. The results of create_dl_acked_block() are checked against expected values (this is currently party disabled because the bug still persists). Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 11:41:00 +00:00
- Setting Control TS 4
Attaching TBF to MS object, TLLI = 0xc0123456, TBF = TBF(TFI=0 TLLI=0xc0123456 DIR=DL STATE=NULL)
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
Allocated TBF(TFI=0 TLLI=0xc0123456 DIR=DL STATE=NULL): trx = 0, ul_slots = 10, dl_slots = 10
tbf/test: Add test for DL LLC packet loss Currently LLC frames are lost or even reordered when the TBF has be established via the AGCH and the procedure fails for some reason. This test tries to reproduce this behaviour by throwing away the first TBF while calling the handle() method several times. The results of create_dl_acked_block() are checked against expected values (this is currently party disabled because the bug still persists). Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 11:41:00 +00:00
TBF(TFI=0 TLLI=0xc0123456 DIR=DL STATE=NULL) [DOWNLINK] START
Send dowlink assignment for TBF(TFI=0 TLLI=0xc0123456 DIR=DL STATE=NULL) on PCH, no TBF exist (IMSI=001001000123456)
TBF(TFI=0 TLLI=0xc0123456 DIR=DL STATE=NULL) changes state from NULL to ASSIGN
TX: START TBF(TFI=0 TLLI=0xc0123456 DIR=DL STATE=ASSIGN) Immediate Assignment Downlink (PCH)
Sending data request: trx=0 ts=0 sapi=3 arfcn=0 fn=0 block=0 data=34 35 36 2d 06 3f 30 0c 00 00 7d 80 00 00 00 dc 01 23 45 68 00 23 2b 2b 2b 2b
tbf: Fix downlink packet loss When the MS is pinged with a longer interval, many packets get lost even if the GprsMs object is kept. If the interval is above the time where the DL TBF is in state FLOW (mainly influenced be the dl-tbf-idle-time command), an new TBF must be requested via AGCH for each ICMP PING message. Currently the LLC frame containing the PING is immediately stored in the TBF and gets lost, if TBF establishment fails for some reason. This commit moves all calls to put_frame() to schedule_next_frame(), where the data is moved from the LLC queue to the frame storage within the TBF object. This method is only called from within create_new_bsn() when the TBF is in the FLOW state and the frame is going to be encoded immediately. At all other places, where put_frame() has been called before, the LLC message is just appended to the LLC queue in the GprsMs object. This change effectively simplifies the related code parts, since date/len information and discard notifications is no longer needed there. Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 12:06:09 +00:00
TBF(TFI=0 TLLI=0xc0123456 DIR=DL STATE=ASSIGN) append
tbf/test: Add test for DL LLC packet loss Currently LLC frames are lost or even reordered when the TBF has be established via the AGCH and the procedure fails for some reason. This test tries to reproduce this behaviour by throwing away the first TBF while calling the handle() method several times. The results of create_dl_acked_block() are checked against expected values (this is currently party disabled because the bug still persists). Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 11:41:00 +00:00
TBF(TFI=0 TLLI=0xc0123456 DIR=DL STATE=ASSIGN) downlink (V(A)==0 .. V(S)==0)
tbf: Fix downlink packet loss When the MS is pinged with a longer interval, many packets get lost even if the GprsMs object is kept. If the interval is above the time where the DL TBF is in state FLOW (mainly influenced be the dl-tbf-idle-time command), an new TBF must be requested via AGCH for each ICMP PING message. Currently the LLC frame containing the PING is immediately stored in the TBF and gets lost, if TBF establishment fails for some reason. This commit moves all calls to put_frame() to schedule_next_frame(), where the data is moved from the LLC queue to the frame storage within the TBF object. This method is only called from within create_new_bsn() when the TBF is in the FLOW state and the frame is going to be encoded immediately. At all other places, where put_frame() has been called before, the LLC message is just appended to the LLC queue in the GprsMs object. This change effectively simplifies the related code parts, since date/len information and discard notifications is no longer needed there. Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 12:06:09 +00:00
- Dequeue next LLC for TBF(TFI=0 TLLI=0xc0123456 DIR=DL STATE=ASSIGN) (len=19)
tbf/test: Add test for DL LLC packet loss Currently LLC frames are lost or even reordered when the TBF has be established via the AGCH and the procedure fails for some reason. This test tries to reproduce this behaviour by throwing away the first TBF while calling the handle() method several times. The results of create_dl_acked_block() are checked against expected values (this is currently party disabled because the bug still persists). Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 11:41:00 +00:00
- Sending new block at BSN 0, CS=1
-- Chunk with length 19 is less than remaining space (20): add length header to to delimit LLC frame
Complete DL frame for TBF(TFI=0 TLLI=0xc0123456 DIR=DL STATE=ASSIGN)len=19
- Dequeue next LLC for TBF(TFI=0 TLLI=0xc0123456 DIR=DL STATE=ASSIGN) (len=19)
-- No space left, so we are done.
tbf: Fix downlink packet loss When the MS is pinged with a longer interval, many packets get lost even if the GprsMs object is kept. If the interval is above the time where the DL TBF is in state FLOW (mainly influenced be the dl-tbf-idle-time command), an new TBF must be requested via AGCH for each ICMP PING message. Currently the LLC frame containing the PING is immediately stored in the TBF and gets lost, if TBF establishment fails for some reason. This commit moves all calls to put_frame() to schedule_next_frame(), where the data is moved from the LLC queue to the frame storage within the TBF object. This method is only called from within create_new_bsn() when the TBF is in the FLOW state and the frame is going to be encoded immediately. At all other places, where put_frame() has been called before, the LLC message is just appended to the LLC queue in the GprsMs object. This change effectively simplifies the related code parts, since date/len information and discard notifications is no longer needed there. Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 12:06:09 +00:00
data block: 07 00 00 4d 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01
MSG = 07 00 00 4d 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01
tbf/test: Add test for DL LLC packet loss Currently LLC frames are lost or even reordered when the TBF has be established via the AGCH and the procedure fails for some reason. This test tries to reproduce this behaviour by throwing away the first TBF while calling the handle() method several times. The results of create_dl_acked_block() are checked against expected values (this is currently party disabled because the bug still persists). Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 11:41:00 +00:00
TBF(TFI=0 TLLI=0xc0123456 DIR=DL STATE=ASSIGN) downlink (V(A)==0 .. V(S)==1)
- Sending new block at BSN 1, CS=1
-- Chunk with length 19 is less than remaining space (20): add length header to to delimit LLC frame
Complete DL frame for TBF(TFI=0 TLLI=0xc0123456 DIR=DL STATE=ASSIGN)len=19
tbf: Fix downlink packet loss When the MS is pinged with a longer interval, many packets get lost even if the GprsMs object is kept. If the interval is above the time where the DL TBF is in state FLOW (mainly influenced be the dl-tbf-idle-time command), an new TBF must be requested via AGCH for each ICMP PING message. Currently the LLC frame containing the PING is immediately stored in the TBF and gets lost, if TBF establishment fails for some reason. This commit moves all calls to put_frame() to schedule_next_frame(), where the data is moved from the LLC queue to the frame storage within the TBF object. This method is only called from within create_new_bsn() when the TBF is in the FLOW state and the frame is going to be encoded immediately. At all other places, where put_frame() has been called before, the LLC message is just appended to the LLC queue in the GprsMs object. This change effectively simplifies the related code parts, since date/len information and discard notifications is no longer needed there. Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 12:06:09 +00:00
- Dequeue next LLC for TBF(TFI=0 TLLI=0xc0123456 DIR=DL STATE=ASSIGN) (len=19)
-- No space left, so we are done.
data block: 07 00 02 4d 02 02 02 02 02 02 02 02 02 02 02 02 02 02 02 02 02 02 02
MSG = 07 00 02 4d 02 02 02 02 02 02 02 02 02 02 02 02 02 02 02 02 02 02 02
TBF(TFI=0 TLLI=0xc0123456 DIR=DL STATE=ASSIGN) downlink (V(A)==0 .. V(S)==2)
- Sending new block at BSN 2, CS=1
-- Chunk with length 19 is less than remaining space (20): add length header to to delimit LLC frame
Complete DL frame for TBF(TFI=0 TLLI=0xc0123456 DIR=DL STATE=ASSIGN)len=19
tbf/test: Add test for DL LLC packet loss Currently LLC frames are lost or even reordered when the TBF has be established via the AGCH and the procedure fails for some reason. This test tries to reproduce this behaviour by throwing away the first TBF while calling the handle() method several times. The results of create_dl_acked_block() are checked against expected values (this is currently party disabled because the bug still persists). Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 11:41:00 +00:00
-- Final block, so we done.
TBF(TFI=0 TLLI=0xc0123456 DIR=DL STATE=ASSIGN) changes state from ASSIGN to FINISHED
tbf: Fix downlink packet loss When the MS is pinged with a longer interval, many packets get lost even if the GprsMs object is kept. If the interval is above the time where the DL TBF is in state FLOW (mainly influenced be the dl-tbf-idle-time command), an new TBF must be requested via AGCH for each ICMP PING message. Currently the LLC frame containing the PING is immediately stored in the TBF and gets lost, if TBF establishment fails for some reason. This commit moves all calls to put_frame() to schedule_next_frame(), where the data is moved from the LLC queue to the frame storage within the TBF object. This method is only called from within create_new_bsn() when the TBF is in the FLOW state and the frame is going to be encoded immediately. At all other places, where put_frame() has been called before, the LLC message is just appended to the LLC queue in the GprsMs object. This change effectively simplifies the related code parts, since date/len information and discard notifications is no longer needed there. Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 12:06:09 +00:00
data block: 07 01 04 4d 03 03 03 03 03 03 03 03 03 03 03 03 03 03 03 03 03 03 03
tbf/test: Add test for DL LLC packet loss Currently LLC frames are lost or even reordered when the TBF has be established via the AGCH and the procedure fails for some reason. This test tries to reproduce this behaviour by throwing away the first TBF while calling the handle() method several times. The results of create_dl_acked_block() are checked against expected values (this is currently party disabled because the bug still persists). Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 11:41:00 +00:00
- Scheduling Ack/Nack polling, because is was requested explicitly (e.g. first final block sent).
Polling cannot be sheduled in this TS 7, waiting for TS 4
tbf: Fix downlink packet loss When the MS is pinged with a longer interval, many packets get lost even if the GprsMs object is kept. If the interval is above the time where the DL TBF is in state FLOW (mainly influenced be the dl-tbf-idle-time command), an new TBF must be requested via AGCH for each ICMP PING message. Currently the LLC frame containing the PING is immediately stored in the TBF and gets lost, if TBF establishment fails for some reason. This commit moves all calls to put_frame() to schedule_next_frame(), where the data is moved from the LLC queue to the frame storage within the TBF object. This method is only called from within create_new_bsn() when the TBF is in the FLOW state and the frame is going to be encoded immediately. At all other places, where put_frame() has been called before, the LLC message is just appended to the LLC queue in the GprsMs object. This change effectively simplifies the related code parts, since date/len information and discard notifications is no longer needed there. Ticket: #1759 Sponsored-by: On-Waves ehf
2015-06-12 12:06:09 +00:00
MSG = 07 01 04 4d 03 03 03 03 03 03 03 03 03 03 03 03 03 03 03 03 03 03 03
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
Searching for first unallocated TFI: TRX=0
tbf/test: Add tests for single and two phase access These tests cover the message exchange from receiving from the first RACH request to the first data block when establishing an uplink TBF. This will be used to check, whether TA and other values are passed to an MS object correctly. In addition, the RX RACH log message in rcv_rach is extended to contain the single block fn. Sponsored-by: On-Waves ehf
2015-05-27 11:03:15 +00:00
Found TFI=0.
MS requests UL TBF on RACH, so we provide one:
********** TBF starts here **********
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
Allocating UL TBF: MS_CLASS=0
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Creating MS object, TLLI = 0x00000000
tbf/test: Add tests for single and two phase access These tests cover the message exchange from receiving from the first RACH request to the first data block when establishing an uplink TBF. This will be used to check, whether TA and other values are passed to an MS object correctly. In addition, the RX RACH log message in rcv_rach is extended to contain the single block fn. Sponsored-by: On-Waves ehf
2015-05-27 11:03:15 +00:00
Slot Allocation (Algorithm A) for class 0
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
- Skipping TS 4, because not enabled
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
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
- Assign uplink TS=7 TFI=0 USF=0
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 7, TRX 0): Attaching TBF(TFI=0 TLLI=0x00000000 DIR=UL STATE=NULL), 1 TBFs, USFs = 01, TFIs = 00000001.
tbf/test: Add tests for single and two phase access These tests cover the message exchange from receiving from the first RACH request to the first data block when establishing an uplink TBF. This will be used to check, whether TA and other values are passed to an MS object correctly. In addition, the RX RACH log message in rcv_rach is extended to contain the single block fn. Sponsored-by: On-Waves ehf
2015-05-27 11:03:15 +00:00
- Setting Control TS 7
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Attaching TBF to MS object, TLLI = 0x00000000, TBF = TBF(TFI=0 TLLI=0x00000000 DIR=UL STATE=NULL)
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
Allocated TBF(TFI=0 TLLI=0x00000000 DIR=UL STATE=NULL): trx = 0, ul_slots = 80, dl_slots = 00
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Modifying MS object, TLLI = 0x00000000, TA 0 -> 7
tbf/test: Add tests for single and two phase access These tests cover the message exchange from receiving from the first RACH request to the first data block when establishing an uplink TBF. This will be used to check, whether TA and other values are passed to an MS object correctly. In addition, the RX RACH log message in rcv_rach is extended to contain the single block fn. Sponsored-by: On-Waves ehf
2015-05-27 11:03:15 +00:00
TBF(TFI=0 TLLI=0x00000000 DIR=UL STATE=NULL) changes state from NULL to FLOW
TBF(TFI=0 TLLI=0x00000000 DIR=UL STATE=FLOW) starting timer 3169.
TBF(TFI=0 TLLI=0x00000000 DIR=UL STATE=FLOW) [UPLINK] START
TBF(TFI=0 TLLI=0x00000000 DIR=UL STATE=FLOW) RX: [PCU <- BTS] RACH qbit-ta=31 ra=0x03, Fn=2654167 (17,25,9)
TBF(TFI=0 TLLI=0x00000000 DIR=UL STATE=FLOW) TX: START Immediate Assignment Uplink (AGCH)
tbf: Move the current CS field to GprsMs Currently the current CS value is stored in the cs field of gprs_rlcmac_tbf and initialised when it is used the first time. This commit adds separate fields for UL and DL CS values to the GprsMs class and provides corresponding getter methods for GprsMs and gprs_rlcmac_tbf. Ticket: #1739 Sponsored-by: On-Waves ehf
2015-06-02 14:00:41 +00:00
Sending data request: trx=0 ts=0 sapi=2 arfcn=0 fn=0 block=0 data=2d 06 3f 10 0f 00 00 03 8b 29 07 00 c8 00 10 0b 2b 2b 2b 2b 2b 2b 2b
tbf/test: Add tests for single and two phase access These tests cover the message exchange from receiving from the first RACH request to the first data block when establishing an uplink TBF. This will be used to check, whether TA and other values are passed to an MS object correctly. In addition, the RX RACH log message in rcv_rach is extended to contain the single block fn. Sponsored-by: On-Waves ehf
2015-05-27 11:03:15 +00:00
UL DATA TFI=0 received (V(Q)=0 .. V(R)=0)
Modifying MS object, UL TLLI: 0x00000000 -> 0xf1223344, not yet confirmed
Decoded premier TLLI=0xf1223344 of UL DATA TFI=0.
TBF(TFI=0 TLLI=0xf1223344 DIR=UL STATE=FLOW) restarting timer 3169 while old timer 3169 pending
- BSN 0 storing in window (0..63)
- Raising V(R) to 1
- Taking block 0 out, raising V(Q) to 1
- Assembling frames: (len=23)
-- Frame 1 starts at offset 0
- Data length after length fields: 20
- Length after skipping TLLI: 16
TBF(TFI=0 TLLI=0xf1223344 DIR=UL STATE=FLOW) complete UL frame that fits precisely in last block: len=16
LLC [PCU -> SGSN] TBF(TFI=0 TLLI=0xf1223344 DIR=UL STATE=FLOW) len=16
No bctx
- No gaps in received block, last block: BSN=0 CV=0
- Finished with UL TBF
TBF(TFI=0 TLLI=0xf1223344 DIR=UL STATE=FLOW) changes state from FLOW to FINISHED
- Scheduling Ack/Nack, because TLLI is included.
- Scheduling Ack/Nack, because last block has CV==0.
tbf/test: Move UL TBF establishment into separate functions Currently the functions test_tbf_single_phase and test_tbf_two_phase do the test logging, BTS intialisation, and the complete message sequencing on their own. Therefore they cannot be used to test more complex sequences like TBF reestablishment. This commit moves the code that does the actual messaging into own functions. The frame number handling is generalised which also fixes a block number wrapping error on the way. Sponsored-by: On-Waves ehf
2015-08-19 12:00:43 +00:00
Got 'TBF(TFI=0 TLLI=0xf1223344 DIR=UL STATE=FINISHED)', TA=7
tbf: Store the timing advance (TA) value in the GprsMs object The TA value rather relates to an MS and not to a single TBF. So all TBFs share the same TA value. Currently the TA value is stored per TBF and eventually copied from an old TBF to a new one. It is in general only passed with an RACH request when the TLLI and thus the MS is not yet known. This commit adds a TA member to the GprsMs class and uses that one when the TBF is associated to an MS object. Since the TBF is not always associated with an MS object (after RACH or when it has been replaced by another TBF), the TA value is still stored in each TBF and that value is used as long as no MS object is being associated. Sponsored-by: On-Waves ehf
2015-05-22 15:48:04 +00:00
Got MS: TLLI = 0xf1223344, TA = 7
tbf/test: Fix existing tests This commit fixes several issues: - Set MS class in request - Set IMSI in establish_ul_tbf_two_phase - Fake assigment acknowledgement in establish_ul_tbf_two_phase - Fix TFI bit offset to 1 (was 2) Sponsored-by: On-Waves ehf
2015-08-21 16:00:54 +00:00
********** TBF starts here **********
Allocating DL TBF: MS_CLASS=0
Slot Allocation (Algorithm A) for class 0
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
- Skipping TS 4, because not enabled
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Assign downlink TS=7 TFI=0
PDCH(TS 7, TRX 0): Attaching TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=NULL), 1 TBFs, USFs = 01, TFIs = 00000001.
- Setting Control TS 7
Attaching TBF to MS object, TLLI = 0xf1223344, TBF = TBF(TFI=0 TLLI=0xf1223344 DIR=DL STATE=NULL)
Allocated TBF(TFI=0 TLLI=0xf1223344 DIR=DL STATE=NULL): trx = 0, ul_slots = 80, dl_slots = 80
Modifying MS object, TLLI: 0xf1223344 confirmed
TBF(TFI=0 TLLI=0xf1223344 DIR=DL STATE=NULL) [DOWNLINK] START
Modifying MS object, TLLI = 0xf1223344, IMSI '' -> '0011223344'
Send dowlink assignment for TBF(TFI=0 TLLI=0xf1223344 DIR=DL STATE=NULL) on PCH, no TBF exist (IMSI=0011223344)
TBF(TFI=0 TLLI=0xf1223344 DIR=DL STATE=NULL) changes state from NULL to ASSIGN
TX: START TBF(TFI=0 TLLI=0xf1223344 DIR=DL STATE=ASSIGN) Immediate Assignment Downlink (PCH)
Sending data request: trx=0 ts=0 sapi=3 arfcn=0 fn=0 block=0 data=33 34 34 2d 06 3f 30 0f 00 00 7d 80 00 07 00 df 12 23 34 48 00 23 2b 2b 2b 2b
TBF(TFI=0 TLLI=0xf1223344 DIR=DL STATE=ASSIGN) append
TBF(TFI=0 TLLI=0xf1223344 DIR=DL STATE=ASSIGN) changes state from ASSIGN to FLOW
tbf/test: Add tests for single and two phase access These tests cover the message exchange from receiving from the first RACH request to the first data block when establishing an uplink TBF. This will be used to check, whether TA and other values are passed to an MS object correctly. In addition, the RX RACH log message in rcv_rach is extended to contain the single block fn. Sponsored-by: On-Waves ehf
2015-05-27 11:03:15 +00:00
Sending data request: trx=0 ts=7 sapi=5 arfcn=0 fn=2654218 block=8 data=47 94 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b
MS requests UL TBF on RACH, so we provide one:
MS requests single block allocation
RX: [PCU <- BTS] RACH qbit-ta=31 ra=0x73, Fn=2654167 (17,25,9), SBFn=2654270
TX: Immediate Assignment Uplink (AGCH)
Sending data request: trx=0 ts=0 sapi=2 arfcn=0 fn=0 block=0 data=2d 06 3f 10 0f 00 00 73 8b 29 07 00 c0 0c 5a 43 2b 2b 2b 2b 2b 2b 2b
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
Searching for first unallocated TFI: TRX=0
tbf/test: Add tests for single and two phase access These tests cover the message exchange from receiving from the first RACH request to the first data block when establishing an uplink TBF. This will be used to check, whether TA and other values are passed to an MS object correctly. In addition, the RX RACH log message in rcv_rach is extended to contain the single block fn. Sponsored-by: On-Waves ehf
2015-05-27 11:03:15 +00:00
Found TFI=0.
+++++++++++++++++++++++++ RX : Uplink Control Block +++++++++++++++++++++++++
------------------------- RX : Uplink Control Block -------------------------
MS requests UL TBF in packet resource request of single block, so we provide one:
********** TBF starts here **********
tbf/test: Fix existing tests This commit fixes several issues: - Set MS class in request - Set IMSI in establish_ul_tbf_two_phase - Fake assigment acknowledgement in establish_ul_tbf_two_phase - Fix TFI bit offset to 1 (was 2) Sponsored-by: On-Waves ehf
2015-08-21 16:00:54 +00:00
Allocating UL TBF: MS_CLASS=1
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Creating MS object, TLLI = 0x00000000
tbf/test: Fix existing tests This commit fixes several issues: - Set MS class in request - Set IMSI in establish_ul_tbf_two_phase - Fake assigment acknowledgement in establish_ul_tbf_two_phase - Fix TFI bit offset to 1 (was 2) Sponsored-by: On-Waves ehf
2015-08-21 16:00:54 +00:00
Modifying MS object, TLLI = 0x00000000, MS class 0 -> 1
Slot Allocation (Algorithm A) for class 1
tbf/test: Add tests for single and two phase access These tests cover the message exchange from receiving from the first RACH request to the first data block when establishing an uplink TBF. This will be used to check, whether TA and other values are passed to an MS object correctly. In addition, the RX RACH log message in rcv_rach is extended to contain the single block fn. Sponsored-by: On-Waves ehf
2015-05-27 11:03:15 +00:00
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
- Skipping TS 4, because not enabled
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
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
- Assign uplink TS=7 TFI=0 USF=0
tbf: Keep a set of used TFI and USF per PDCH Currently is is rather expensive to get TFI and USF usage per PDCH, because the TBFs need to be scanned to get that information. This commit adds corresponding bit sets which get updated by the attach_tbf/detach_tbf methods of the gprs_rlcmac_pdch class. Sponsored-by: On-Waves ehf
2015-06-30 12:10:13 +00:00
PDCH(TS 7, TRX 0): Attaching TBF(TFI=0 TLLI=0x00000000 DIR=UL STATE=NULL), 1 TBFs, USFs = 01, TFIs = 00000001.
tbf/test: Add tests for single and two phase access These tests cover the message exchange from receiving from the first RACH request to the first data block when establishing an uplink TBF. This will be used to check, whether TA and other values are passed to an MS object correctly. In addition, the RX RACH log message in rcv_rach is extended to contain the single block fn. Sponsored-by: On-Waves ehf
2015-05-27 11:03:15 +00:00
- Setting Control TS 7
tbf: Always create an MS object on TBF allocation Currently the MS object are created when the TLLI gets known. Therefore some information (TA, MS class) must be stored in the TBF itself and is copied to the MS object later on. This would get even more complex, if the allocation algorithms were extended based on this scheme. This commit ensures, that an MS object will always be created on TBF allocation, even if the TLLI is not yet known. These 'anonymous' objects are still managed by the MS storage. To avoid dangling entries without a TLLI there (which cannnot be retrieved anyway), the timer in the MS objects is not started after all TBF have been detached, so that they get deleted immediately in that case. Note that an MS object can still be removed (e.g. by replacement) from an existing TBF, so tbf->ms() can be NULL. Ticket: #1794 Sponsored-by: On-Waves ehf
2015-06-19 07:08:23 +00:00
Attaching TBF to MS object, TLLI = 0x00000000, TBF = TBF(TFI=0 TLLI=0x00000000 DIR=UL STATE=NULL)
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
Allocated TBF(TFI=0 TLLI=0x00000000 DIR=UL STATE=NULL): trx = 0, ul_slots = 80, dl_slots = 00
tbf/test: Add tests for single and two phase access These tests cover the message exchange from receiving from the first RACH request to the first data block when establishing an uplink TBF. This will be used to check, whether TA and other values are passed to an MS object correctly. In addition, the RX RACH log message in rcv_rach is extended to contain the single block fn. Sponsored-by: On-Waves ehf
2015-05-27 11:03:15 +00:00
TBF(TFI=0 TLLI=0x00000000 DIR=UL STATE=NULL) changes state from NULL to ASSIGN
TBF(TFI=0 TLLI=0x00000000 DIR=UL STATE=ASSIGN) starting timer 3169.
Modifying MS object, UL TLLI: 0x00000000 -> 0xf1223344, not yet confirmed
tbf: Store the timing advance (TA) value in the GprsMs object The TA value rather relates to an MS and not to a single TBF. So all TBFs share the same TA value. Currently the TA value is stored per TBF and eventually copied from an old TBF to a new one. It is in general only passed with an RACH request when the TLLI and thus the MS is not yet known. This commit adds a TA member to the GprsMs class and uses that one when the TBF is associated to an MS object. Since the TBF is not always associated with an MS object (after RACH or when it has been replaced by another TBF), the TA value is still stored in each TBF and that value is used as long as no MS object is being associated. Sponsored-by: On-Waves ehf
2015-05-22 15:48:04 +00:00
Modifying MS object, TLLI = 0xf1223344, TA 0 -> 7
tbf/test: Add tests for single and two phase access These tests cover the message exchange from receiving from the first RACH request to the first data block when establishing an uplink TBF. This will be used to check, whether TA and other values are passed to an MS object correctly. In addition, the RX RACH log message in rcv_rach is extended to contain the single block fn. Sponsored-by: On-Waves ehf
2015-05-27 11:03:15 +00:00
Change control TS to 7 until assinment is complete.
TBF(TFI=0 TLLI=0xf1223344 DIR=UL STATE=ASSIGN)s start Packet Uplink Assignment (PACCH)
+++++++++++++++++++++++++ TX : Packet Uplink Assignment +++++++++++++++++++++++++
------------------------- TX : Packet Uplink Assignment -------------------------
Scheduling control message at RTS for TBF(TFI=0 TLLI=0xf1223344 DIR=UL STATE=ASSIGN) (TRX=0, TS=7)
tbf/test: Move UL TBF establishment into separate functions Currently the functions test_tbf_single_phase and test_tbf_two_phase do the test logging, BTS intialisation, and the complete message sequencing on their own. Therefore they cannot be used to test more complex sequences like TBF reestablishment. This commit moves the code that does the actual messaging into own functions. The frame number handling is generalised which also fixes a block number wrapping error on the way. Sponsored-by: On-Waves ehf
2015-08-19 12:00:43 +00:00
Sending data request: trx=0 ts=7 sapi=5 arfcn=0 fn=2654270 block=8 data=4f 28 5e 24 46 68 8f 1d 00 00 88 00 08 2b 2b 2b 2b 2b 2b 2b 2b 2b 2b
tbf/test: Fix existing tests This commit fixes several issues: - Set MS class in request - Set IMSI in establish_ul_tbf_two_phase - Fake assigment acknowledgement in establish_ul_tbf_two_phase - Fix TFI bit offset to 1 (was 2) Sponsored-by: On-Waves ehf
2015-08-21 16:00:54 +00:00
TBF(TFI=0 TLLI=0xf1223344 DIR=UL STATE=ASSIGN) changes state from ASSIGN to FLOW
tbf/test: Add tests for single and two phase access These tests cover the message exchange from receiving from the first RACH request to the first data block when establishing an uplink TBF. This will be used to check, whether TA and other values are passed to an MS object correctly. In addition, the RX RACH log message in rcv_rach is extended to contain the single block fn. Sponsored-by: On-Waves ehf
2015-05-27 11:03:15 +00:00
UL DATA TFI=0 received (V(Q)=0 .. V(R)=0)
tbf/test: Fix existing tests This commit fixes several issues: - Set MS class in request - Set IMSI in establish_ul_tbf_two_phase - Fake assigment acknowledgement in establish_ul_tbf_two_phase - Fix TFI bit offset to 1 (was 2) Sponsored-by: On-Waves ehf
2015-08-21 16:00:54 +00:00
TBF(TFI=0 TLLI=0xf1223344 DIR=UL STATE=FLOW) restarting timer 3169 while old timer 3169 pending
tbf/test: Add tests for single and two phase access These tests cover the message exchange from receiving from the first RACH request to the first data block when establishing an uplink TBF. This will be used to check, whether TA and other values are passed to an MS object correctly. In addition, the RX RACH log message in rcv_rach is extended to contain the single block fn. Sponsored-by: On-Waves ehf
2015-05-27 11:03:15 +00:00
- BSN 0 storing in window (0..63)
- Raising V(R) to 1
- Taking block 0 out, raising V(Q) to 1
- Assembling frames: (len=23)
-- Frame 1 starts at offset 0
- Data length after length fields: 20
tbf/test: Fix existing tests This commit fixes several issues: - Set MS class in request - Set IMSI in establish_ul_tbf_two_phase - Fake assigment acknowledgement in establish_ul_tbf_two_phase - Fix TFI bit offset to 1 (was 2) Sponsored-by: On-Waves ehf
2015-08-21 16:00:54 +00:00
- No gaps in received block, last block: BSN=0 CV=15
Got 'TBF(TFI=0 TLLI=0xf1223344 DIR=UL STATE=FLOW)', TA=7
tbf: Store the timing advance (TA) value in the GprsMs object The TA value rather relates to an MS and not to a single TBF. So all TBFs share the same TA value. Currently the TA value is stored per TBF and eventually copied from an old TBF to a new one. It is in general only passed with an RACH request when the TLLI and thus the MS is not yet known. This commit adds a TA member to the GprsMs class and uses that one when the TBF is associated to an MS object. Since the TBF is not always associated with an MS object (after RACH or when it has been replaced by another TBF), the TA value is still stored in each TBF and that value is used as long as no MS object is being associated. Sponsored-by: On-Waves ehf
2015-05-22 15:48:04 +00:00
Got MS: TLLI = 0xf1223344, TA = 7
tbf/test: Fix existing tests This commit fixes several issues: - Set MS class in request - Set IMSI in establish_ul_tbf_two_phase - Fake assigment acknowledgement in establish_ul_tbf_two_phase - Fix TFI bit offset to 1 (was 2) Sponsored-by: On-Waves ehf
2015-08-21 16:00:54 +00:00
********** TBF starts here **********
Allocating DL TBF: MS_CLASS=0
Slot Allocation (Algorithm A) for class 0
- Skipping TS 0, because not enabled
- Skipping TS 1, because not enabled
- Skipping TS 2, because not enabled
- Skipping TS 3, because not enabled
- Skipping TS 4, because not enabled
- Skipping TS 5, because not enabled
- Skipping TS 6, because not enabled
- Assign downlink TS=7 TFI=0
PDCH(TS 7, TRX 0): Attaching TBF(TFI=0 TLLI=0x00000000 DIR=DL STATE=NULL), 1 TBFs, USFs = 01, TFIs = 00000001.
- Setting Control TS 7
Attaching TBF to MS object, TLLI = 0xf1223344, TBF = TBF(TFI=0 TLLI=0xf1223344 DIR=DL STATE=NULL)
Allocated TBF(TFI=0 TLLI=0xf1223344 DIR=DL STATE=NULL): trx = 0, ul_slots = 80, dl_slots = 80
Modifying MS object, TLLI: 0xf1223344 confirmed
TBF(TFI=0 TLLI=0xf1223344 DIR=DL STATE=NULL) [DOWNLINK] START
Modifying MS object, TLLI = 0xf1223344, IMSI '' -> '0011223344'
Send dowlink assignment on PACCH, because TBF(TFI=0 TLLI=0xf1223344 DIR=UL STATE=FLOW) exists
TBF(TFI=0 TLLI=0xf1223344 DIR=DL STATE=NULL) changes state from NULL to ASSIGN
TBF(TFI=0 TLLI=0xf1223344 DIR=DL STATE=ASSIGN) starting timer 0.
TBF(TFI=0 TLLI=0xf1223344 DIR=DL STATE=ASSIGN) append
TBF(TFI=0 TLLI=0xf1223344 DIR=DL STATE=ASSIGN) changes state from ASSIGN to FLOW