[4]:

# Example code constructionk=8448n=368*68enc=LDPC5GEncoder(k,n)dec=LDPC5GDecoder(enc)plt.spy(dec._pcm,markersize=0.3);plt.xlabel('Variable Nodes');plt.ylabel('Check Nodes');plt.title(f'Basegraph{enc._bg}, Lifting factor:{enc._z}');plt.show();

[5]:

# In the later CUDA implementation, we use int8 dtypes for the LLRs.# Thus, we need to clip the LLRs to the range [-127, 127]MAX_LLR_VALUE=127# depends on dtype# Damping(=scaling) factor of the outgoing LLRs to improve the decoding performance.# This is a heuristic value and typically a good choice.DAMPING_FACTOR=0.75defupdate_cn(llr_msg,llr_total,z,bg_cn,bg_cn_degree,num_rows,first_iter):"""    Inputs    ------    llr_msg: np.array [num_edges]        Incoming LLRs from variable nodes    llr_total: np.array [num_vns]        Accumulated LLRs from variable nodes    z: int | 2,...,384        Lifting factor    bg_cn: list of tuples        Check node configuration    bg_cn_degree: list        Check node degree    num_rows: int        Number of rows in the base graph    first_iter: bool        Whether this is the first iteration    Returns    -------    llr_msg: np.array [num_edges]        Updated LLRs from check nodes    """# Check node update function# These two loops can be parallelized in CUDAforiinrange(z):# between 2 and 384foridx_rowinrange(num_rows):# Either 46 or 42cn_degree=bg_cn_degree[idx_row]# Check node degree# List of tuples (idx_row, idx_col, s, msg_offset)cn=bg_cn[idx_row]# len(cn) = cn_degree# Search the "extrinsic" min of all incoming LLRs# This means we need to find the min and the second min of all incoming LLRsmin_1=MAX_LLR_VALUEmin_2=MAX_LLR_VALUEidx_min=-1node_sign=1# Temp buffer for signsmsg_sign=np.ones((19,))# Max CN degree is 19foriiinrange(cn_degree):# Calculate the index of the message in the LLR arraymsg_offset=cn[ii][3]s=cn[ii][2]idx_col=cn[ii][1]msg_idx=msg_offset*z+i# Total VN messaget=llr_total[idx_col*z+(i+s)%z]# Make extrinsic by subtracting the previous msgifnotfirst_iter:# Ignore in first iterationt-=llr_msg[msg_idx]# Store sign for 2nd recursionsign=1ifnp.abs(t)==0elsenp.sign(t)# Could be also used for syndrome-based check or early terminationnode_sign*=signmsg_sign[ii]=sign# For later sign calculation# Find min and second mint_abs=np.abs(t)ift_abs<min_1:min_2=min_1min_1=t_absidx_min=msg_idxelift_abs<min_2:min_2=t_abs# Apply damping factormin_1*=DAMPING_FACTORmin_2*=DAMPING_FACTOR# Clip min_val to MAX_LLR_VALUEmin_1=np.clip(min_1,-MAX_LLR_VALUE,MAX_LLR_VALUE)min_2=np.clip(min_2,-MAX_LLR_VALUE,MAX_LLR_VALUE)# Apply min and second min to the outgoing LLRforiiinrange(cn_degree):msg_offset=cn[ii][3]msg_idx=msg_offset*z+iifmsg_idx==idx_min:min_val=min_2else:min_val=min_1# And update outgoing msg including signllr_msg[msg_idx]=min_val*node_sign*msg_sign[ii]returnllr_msg

[6]:

defupdate_vn(llr_msg,llr_ch,llr_total,z,bg_vn,bg_vn_degree,num_cols):"""    Inputs    ------    llr_msg: np.array [num_edges]        Incoming LLRs from check nodes    llr_ch: np.array [num_vns]        Channel LLRs    llr_total: np.array [num_vns]        Accumulated LLRs from variable nodes    z: int | 2,...,384        Lifting factor    bg_vn: list of tuples        Variable node configuration    bg_vn_degree: list        Variable node degree    num_cols: int        Number of variable nodes    Returns    -------    llr_total: np.array [num_vns]        Updated LLRs from variable nodes    """# This can be parallelized in CUDAforiinrange(z):# Between 2 and 384foridx_colinrange(num_cols):# Either 52 or 68vn_degree=bg_vn_degree[idx_col]# Variable node degree# List of tuples (idx_col, idx_row, s, msg_offset)vn=bg_vn[idx_col]# len(vn) = vn_degree# Accumulate all incoming LLRsmsg_sum=0# Should be int16forjinrange(vn_degree):msg_offset=vn[j][3]s=vn[j][2]# Index of the msg in the LLR array# It is the idx_col-th variable node, and the j-th message from the idx_row-th check nodemsg_idx=msg_offset*z+(i-s)%z# Accumulate all incoming LLRsmsg_sum+=llr_msg[msg_idx].astype(np.int16)# Add the channel LLRsmsg_sum+=llr_ch[idx_col*z+i].astype(np.int16)llr_total[idx_col*z+i]=msg_sumreturnllr_total

[7]:

defpack_bits(llr_total,block_length,pack_bits=False):"""    Inputs    ------    llr_total: np.array [num_vns]        LLRs from variable nodes    block_length: int        Number of payload bits that are returned after decoding    pack_bits: bool        If True, the bits are packed into a byte array    Returns    -------    bits: np.array [block_length]        Decoded bits    """# OAI wants the bits in a byte arrayifpack_bits:# Round length to the nearest multiple of 8block_length=int(np.ceil(block_length/8)*8)bits=(llr_total[:block_length]<0).astype(np.uint8)bits=np.packbits(bits)else:bits=(llr_total[:block_length]<0).astype(np.uint8)returnbits

[8]:

defdecode_ldpc(bg,z,block_length,num_iter,llr_ch):"""    Inputs    ------    bg: int | 1,2        Basegraph used for decoding    z: int | 2,...,384        Lifting factor    block_length: int        Number of payload bits that are returned after decoding    num_iter: int        Max number of decoding iterations    llr_ch: np.array [68+z] or [52*z] for bg1 and bg2, respectively        Received channel LLRs    """############################# Initialize Variables############################bg_vn,bg_cn,bg_vn_degree,bg_cn_degree,num_cols,num_rows,num_edges=init_basegraph(bg,z)# Temporary message buffer# Max size is 316*384llr_msg=np.zeros((num_edges,),dtype=np.int8)# No need to initialize to 0# VN accumulator# We always init the max size of the LLR array given as 68*384# The accumulator needs higher precision than the message bufferllr_ch=llr_ch.astype(np.int8)############################# Main Decoding Loop############################llr_total=np.copy(llr_ch).astype(np.int16)# llr_total will be updated in the VN updateforiinrange(num_iter):# CN update# llr_msg not read, only written to in first iteration; will be filled with outputs of this functionllr_msg=update_cn(llr_msg,llr_total,z,bg_cn,bg_cn_degree,num_rows,i==0)# VN updatellr_total=update_vn(llr_msg,llr_ch,llr_total,z,bg_vn,bg_vn_degree,num_cols)# Pack bitsbits=pack_bits(llr_total,block_length,pack_bits=True)# [optional] apply syndrome check and if not successful return `num_iter+=1``returnbits,llr_total

[9]:

# Parametersk=1280# Payload sizen=2560# Codeword size after rate matchingnum_iter=8# Number of decoding iterationsllr_mag=10# LLR magnitude# Use Sionna for BG selectionenc=LDPC5GEncoder(k,n)bg=1ifenc._bg=="bg1"else2z=enc._z# Draw random bitsu=np.random.randint(0,2,k)# Encode using Sionnac=enc(np.expand_dims(u.astype(np.float32),0))[0].numpy()# Map to LLRsx=1-2*c# Clip to max LLR value due to int8 representationllr_ch=np.clip((llr_mag*x),-127,127).astype(np.int8)# Get code parametersnum_vn=68*zifbg==1else52*zparity_start=22*zifbg==1else10*z# Apply rate matchingllr_input=np.zeros(num_vn,dtype=np.int8)# Takes care of the punctured bits (initialized to 0 LLR)llr_input[2*z:k]=llr_ch[:k-2*z]# Unpunctured message bitsllr_input[k:parity_start]=127# Shortened bitsllr_input[parity_start:parity_start+n-k+2*z]=llr_ch[k-2*z:]# parity bits# Run decoderdecoder_outputs,_=decode_ldpc(bg,z,k,num_iter,llr_input)# Evaluate resultsu_hat=np.unpackbits(decoder_outputs.astype(np.uint8))[:k]# There may be a couple of extra bits if k is not a multiple of 8ifnp.all(u==u_hat):print("All payload bits decoded correctly!")else:print("Decoding failed!")print(f"Shape of LLR input:{llr_input.shape}")print(f"Shape of decoded bytes:{decoder_outputs.shape}")

All payload bits decoded correctly!Shape of LLR input: (6656,)Shape of decoded bytes: (160,)