[NR_UE][DLSCH] Optimize layer demapping for PDSCH performance

- Use switch on mod_order to make memcpy size a compile-time constant,
  allowing the compiler to inline it as fixed-size vector stores
Signed-off-by: Rupanjali <rupanjali.srivastava@openairinterface.org>

openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_demodulation.c

@@ -675,6 +675,18 @@ static void nr_dlsch_mmse(uint32_t rx_size_symbol,
   }
 }
 
+/* Constant MO lets the compiler inline memcpy as fixed-size vector stores */
+static inline void layer_demapping(uint8_t Nl, int nb_re, int16_t **layer_ptrs, int16_t *llr_out, int MO)
+{
+  int k = 0;
+  for (int j = 0; j < nb_re; j++) {
+    for (int l = 0; l < Nl; l++) {
+      memcpy(llr_out + k, layer_ptrs[l] + j * MO, MO * sizeof(int16_t));
+      k += MO;
+    }
+  }
+}
+
 static void nr_dlsch_layer_demapping(const uint8_t Nl,
                                      const uint8_t mod_order,
                                      const int llrLayerSize,
@@ -687,32 +699,41 @@ static void nr_dlsch_layer_demapping(const uint8_t Nl,
   const int s1 = dlsch_config->number_symbols;
 
   int k = 0;
-  switch (Nl) {
-    case 1:
-      for (int i = s0; i < (s0 + s1); i++) {
-        memcpy(llr + k, llr_layers[i][0], re_len[i] * mod_order * sizeof(int16_t));
-        k += re_len[i] * mod_order;
-      }
-      break;
 
-    case 2:
-    case 3:
-    case 4:
-      for (int i = s0; i < (s0 + s1); i++) {
-        int m = 0;
-        for (int j = 0; j < re_len[i]; j++) {
-          for (int l = 0; l < Nl; l++) {
-            memcpy(llr + k, llr_layers[i][l] + m * mod_order, sizeof(int16_t) * mod_order);
-            k += mod_order;
-            // if (i<4) printf("length%d: llr_layers[l%d][m%d]=%d: \n",length,l,m,llr_layers[l][i*mod_order+m]);
-          }
-          m++;
-        }
-      }
-      break;
+  if (Nl == 1) {
+    /* Single layer: one contiguous memcpy per symbol, no interleaving needed. */
+    for (int i = s0; i < (s0 + s1); i++) {
+      memcpy(llr + k, llr_layers[i][0], re_len[i] * mod_order * sizeof(int16_t));
+      k += re_len[i] * mod_order;
+    }
+    return;
+  }
 
-    default:
-      AssertFatal(0, "Not supported number of layers %d\n", Nl);
+  AssertFatal(Nl <= 4, "Not supported number of layers %d\n", Nl);
+
+  /* Switch on mod_order so MO is a compile-time literal, enabling the compiler
+   * to inline memcpy as fixed-size vector stores. */
+  for (int i = s0; i < (s0 + s1); i++) {
+    int16_t *p_layer[Nl];
+    for (int l = 0; l < Nl; l++)
+      p_layer[l] = (int16_t *)llr_layers[i][l];
+    switch (mod_order) {
+      case 2:
+        layer_demapping(Nl, re_len[i], p_layer, llr + k, 2);
+        break;
+      case 4:
+        layer_demapping(Nl, re_len[i], p_layer, llr + k, 4);
+        break;
+      case 6:
+        layer_demapping(Nl, re_len[i], p_layer, llr + k, 6);
+        break;
+      case 8:
+        layer_demapping(Nl, re_len[i], p_layer, llr + k, 8);
+        break;
+      default:
+        AssertFatal(0, "Unknown mod_order %d\n", mod_order);
+    }
+    k += re_len[i] * mod_order * Nl;
   }
 }