Questions Regarding compute_bler, sim_ber, and Goodput vs Spectral Efficiency

[hssam1002]

Hi, all.

I have a few questions regarding the use of compute_bler and sim_ber, as well as how to correctly compute and compare Goodput and spectral efficiency.

My questions are,

1. I’m currently using the compute_bler function to calculate BLER. This function takes b and b_hat as inputs, but does not require specifying a code rate. I'm wondering — is the code rate implicitly included in the bitstream b, or is it handled internally within the function?

2. I’m comparing theoretical spectral efficiency with simulated Goodput. The theoretical spectral efficiency is calculated as:
   SE (bits/s/Hz) = sum (log_2 det (I + SNR/N_t H[k]F[k] F[k]* H[k]*)) / K.

For Goodput, I used the following:
k_info : # of information bits
N_eff : # of effective subcarriers
f_scs : Subcarrier spacing (30k)
T_TTI = 1TTI length (0.005s)
Then:
Normalized Goodput (bits/s/Hz) = (1-BLER) * k_info / (N_eff * f_scs * T_TTI).
However, I noticed that the Goodput value is significantly lower than the theoretical spectral efficiency.
And much lower than the 3GPP standard, which is derived in
https://5g-tools.com/5g-nr-throughput-calculator/

• For instance, I simulated with
  N_eff : 1792
  f_scs : 30k
  T_TTI = 0.005
  Number of layers = 4
  256QAM and code_rate ~= 0.9, thus k_info is 156549.

Even though the BLER is 0,
my normalized Goodput was somewhere btw 7~8.
The closest calculation from the https://5g-tools.com/5g-nr-throughput-calculator/. is
Some where between 24 bits/s

This brings me to my final question:
I think I did something wrong with the calculation of the number of transmitted bits.
If multiple data streams are used (e.g., in MIMO), should I multiply the number of streams when computing the total number of coded bits?

This is my code.

num_bits_per_symbol = 8 # 256Q modulation
coderate = 0.91# Code rate
n_nb = int(rg_sch.num_data_symbols * num_bits_per_symbol) # Number of coded bits
k_nb = int(n_nb * coderate) # Number of information bits
tb_size = sionna.phy.nr.utils.calculate_tb_size(num_bits_per_symbol, coderate, target_tb_size = k_nb, num_coded_bits = n_nb)[0]
tb_encoder = sionna.phy.nr.TBEncoder(target_tb_size = tb_size,
                                 num_coded_bits = n_nb,
                                 target_coderate = coderate,
                                 num_bits_per_symbol = num_bits_per_symbol,
                                 num_layers = n_s,
                                 n_rnti = 1,
                                 n_id = 1,
                                 channel_type = "PDSCH",
                                 codeword_index = 0,
                                 use_scrambler = False,
                                 verbose = False,
                                 output_dtype = tf.float32)

I'd appreciate any clarification on these points. Thank you in advance!

[jhoydis]

Hi @hssam1002,

1. Yes, the BLER just tells you if a block of information bits was correctly transmitted or not. This is independent of the moderate, modulation scheme, etc.
2. Yes, you should multiply by the number of streams because they are sent in parallel on the same time-frequency resources.

[hssam1002]

I really appreciate it :)