add tx thread

readme.txt

 BUILD:
 x86
-sudo gcc -o trx trx_test.c oxgrf_lib.c -march=native -loxgrf_ss -g
+sudo gcc -o trx system.c trx_test.c oxgrf_lib.c -march=native -loxgrf_ss -g -lpthread
 
 arm
 sudo gcc -o trx trx_test.c yunsdr_lib.c  -lyunsdr_ss -g

system.h

+/*
+ * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The OpenAirInterface Software Alliance licenses this file to You under
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
+ * except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ *      contact@openairinterface.org
+ */
+
+#ifndef _SYSTEM_H_OAI_
+#define _SYSTEM_H_OAI_
+#include <stdint.h>
+#include <pthread.h>
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/****************************************************
+ * send a command to the background process
+ *     return -1 on error, 0 on success
+ ****************************************************/
+
+int background_system(char *command);
+
+/****************************************************
+ * initialize the background process
+ *     to be called very early
+ ****************************************************/
+
+void start_background_system(void);
+
+void set_latency_target(void);
+
+void threadCreate(pthread_t *t, void *(*func)(void *), void *param, char *name, int affinity, int priority);
+
+#define SCHED_OAI SCHED_RR
+#define OAI_PRIORITY_RT_LOW sched_get_priority_min(SCHED_OAI)
+#define OAI_PRIORITY_RT ((sched_get_priority_min(SCHED_OAI)+sched_get_priority_max(SCHED_OAI))/2)
+#define OAI_PRIORITY_RT_MAX sched_get_priority_max(SCHED_OAI)-2
+
+void thread_top_init(char *thread_name,
+                     int affinity,
+                     uint64_t runtime,
+                     uint64_t deadline,
+                     uint64_t period);
+
+/****************************************************
+ * Functions to check system at runtime.
+ ****************************************************/
+
+int checkIfFedoraDistribution(void);
+int checkIfGenericKernelOnFedora(void);
+int checkIfInsideContainer(void);
+int rt_sleep_ns (uint64_t x);
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* _SYSTEM_H_OAI_ */

trx_test.c

@@ -3,12 +3,17 @@
 #include <assert.h>
 
 #include "trx_test.h"
+#include "system.h"
+#include <semaphore.h>
+#include <pthread.h>
 
+#define NB_ANTENNAS_RX 4
+#define NB_ANTENNAS_TX 1
 
-#define NB_ANTENNAS_RX 1
-#define NB_ANTENNAS_TX 4
 #define SAMPLE_RATE    (122880000)
 
+//#define TX_RX_ONE_THREAD
+
 int txdata_size=61440*4;
 int rxdata_size=61440*4;
 int absolute_slot=0;
@@ -40,9 +45,61 @@ struct timespec  nr_get_timespec_diff(
  return result;
 }
 
+openair0_timestamp rx_timestamp, writeTimestamp;
+int32_t * rxp[NB_ANTENNAS_RX];
+int32_t * txp[NB_ANTENNAS_TX];
+int readBlockSize, writeBlockSize;
+int tx_cnt = 0;
+int rx_cnt = 0;
+sem_t ric_send_sem;
+double clock_gettime_cur_tx;
+
+static void *tx_thread(void *param)
+{
+  openair0_device *rfdevice = (openair0_device *) param;
+  double clock_gettime_cur;
+  struct timespec time_start;
+  struct timespec time_stop;
+
+  while (1) {
+
+    sem_wait (&ric_send_sem);
+    //printf("00000000 tx cnt %d rx cnt %d\n", tx_cnt, rx_cnt);
+    // use previous timing_advance value to compute writeTimestamp
+    //writeTimestamp = timestamp+samples_per_subframe/20*5;// sent after 5 slot.
+    writeTimestamp = rx_timestamp+samples_per_subframe/4;// sent after 5 slot.
+
+    // but use current UE->timing_advance value to compute writeBlockSize
+  
+    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_WRITE, VCD_FUNCTION_IN );
+    clock_gettime(CLOCK_REALTIME,&time_start);
+    #if 1
+    rfdevice->trx_write_func(rfdevice,
+                                              writeTimestamp,
+                                              (void **)txp,
+                                              writeBlockSize,
+                                              1,
+                                              1);
+    #endif                                          
+    clock_gettime(CLOCK_REALTIME,&time_stop ); 
+    clock_gettime_cur_tx = NR_TIMESPEC_TO_DOUBLE_US( nr_get_timespec_diff( &time_start, &time_stop ));                                         
+    tx_cnt++;
+    //printf("11111111 tx cnt %d rx cnt %d\n", tx_cnt, rx_cnt);
+    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_WRITE, VCD_FUNCTION_OUT );
+ 
+
+
+  }
+
+  return NULL;
+}
+
+
+
 int main( int argc, char **argv ) {
 
 
+ pthread_t tx_threads;
 
 //  test_t *t1=malloc(sizeof(test_t));
   test_t t2[4];
@@ -55,7 +112,7 @@ int main( int argc, char **argv ) {
   sched_setscheduler(getpid(), SCHED_RR, &rr_param);
   cpu_set_t mask;
   CPU_ZERO(&mask);
-  CPU_SET(5, &mask);
+  CPU_SET(20, &mask);
   int rc = sched_setaffinity(getpid(), sizeof(mask), &mask);
   assert(rc >= 0);
 
@@ -118,16 +175,19 @@ int main( int argc, char **argv ) {
 
   openair0_cfg[card].sdr_addrs = "dev=pciex:0,auxdac1=300";
 
-  openair0_timestamp timestamp, timestampold, writeTimestamp;
-  int32_t * rxp[NB_ANTENNAS_RX];
-  int32_t * txp[NB_ANTENNAS_TX];
+  openair0_timestamp timestampold ;
+
   int start_rx_stream = 1;
 
   double clock_gettime_cur;
-  struct timespec time_start;
-  struct timespec time_stop;
-
+  struct timespec time_start, time_start1;
+  struct timespec time_stop, time_stop1;
 
+  int res = sem_init(&ric_send_sem, 0, 0);  
+  if (res != 0)  
+  {  
+  perror("Semaphore initialization failed");  
+  }  
 
 
 
@@ -137,7 +197,7 @@ int main( int argc, char **argv ) {
   for (int i=0; i<NB_ANTENNAS_TX; i++) {
     txp[i] = (int32_t *) malloc16_clear( txdata_size );
   }
-    int readBlockSize, writeBlockSize;
+  
 
   readBlockSize = samples_per_subframe/2;
   writeBlockSize = readBlockSize;
@@ -145,17 +205,18 @@ int main( int argc, char **argv ) {
   device_init(&(rfdevice), &openair0_cfg[0]);
 
 
+  threadCreate(&tx_threads, tx_thread, &rfdevice, "tx_thread", 21, sched_get_priority_max(SCHED_RR)-2);
   rfdevice.trx_start_func(&rfdevice);
 
 //first time is very long, don't know why.
   clock_gettime(CLOCK_REALTIME,&time_start);
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_READ, VCD_FUNCTION_IN );
   rfdevice.trx_read_func(&rfdevice,
-                                          &timestamp,
+                                          &rx_timestamp,
                                           (void **)rxp,
                                           readBlockSize,
                                           1);
-  timestampold = timestamp;
+  timestampold = rx_timestamp;
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_READ, VCD_FUNCTION_OUT );
   clock_gettime(CLOCK_REALTIME,&time_stop);
   clock_gettime_cur = NR_TIMESPEC_TO_DOUBLE_US( nr_get_timespec_diff( &time_start, &time_stop ));//us
@@ -167,39 +228,46 @@ int main( int argc, char **argv ) {
     clock_gettime(CLOCK_REALTIME,&time_stop);
 
     clock_gettime_cur = NR_TIMESPEC_TO_DOUBLE_US( nr_get_timespec_diff( &time_start, &time_stop ));//us
-    if (clock_gettime_cur > 510) 
-         printf("slot_num %d, timestamp %ld, writeTimestamp %ld,time = %.2f sec, delay_time=%.2lf msec. readBlockSize %d. real read %ld.\n",
-          absolute_slot, timestamp,  writeTimestamp, ((float)absolute_slot)/2/1000, clock_gettime_cur/1000,readBlockSize,(timestamp - timestampold));
+    if ((clock_gettime_cur > 300) || (clock_gettime_cur_tx > 510))
+         printf("slot_num %d, timestamp %ld, writeTimestamp %ld,time = %.2f sec, delay_time=(%.2lf, %d) (tx %.2lf, %d)msec. readBlockSize %d. real read %ld.\n",
+          absolute_slot, rx_timestamp,  writeTimestamp, ((float)absolute_slot)/2/1000, clock_gettime_cur/1000,rx_cnt, clock_gettime_cur_tx/1000, tx_cnt, readBlockSize,(rx_timestamp - timestampold));
     clock_gettime(CLOCK_REALTIME,&time_start);
-    timestampold = timestamp;
+    timestampold = rx_timestamp;
 
 #if 1
     VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_READ, VCD_FUNCTION_IN );
     rfdevice.trx_read_func(&rfdevice,
-                                           &timestamp,
+                                           &rx_timestamp,
                                            (void **)rxp,
                                            readBlockSize,
                                            1);
+    rx_cnt++;
 
+ 
     VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_READ, VCD_FUNCTION_OUT );
 #endif
 
-#if 1
+#ifdef TX_RX_ONE_THREAD
     // use previous timing_advance value to compute writeTimestamp
     //writeTimestamp = timestamp+samples_per_subframe/20*5;// sent after 5 slot.
-    writeTimestamp += timestamp+samples_per_subframe/2;// sent after 5 slot.
+    writeTimestamp = rx_timestamp+samples_per_subframe/4;// sent after 5 slot.
 
     // but use current UE->timing_advance value to compute writeBlockSize
   
     VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_WRITE, VCD_FUNCTION_IN );
+    clock_gettime(CLOCK_REALTIME,&time_start1 ); 
     rfdevice.trx_write_func(&rfdevice,
                                               writeTimestamp,
                                               (void **)txp,
                                               writeBlockSize,
                                               1,
                                               1);
+    clock_gettime(CLOCK_REALTIME,&time_stop1 ); 
+    clock_gettime_cur_tx = NR_TIMESPEC_TO_DOUBLE_US( nr_get_timespec_diff( &time_start1, &time_stop1 ));  
     VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_WRITE, VCD_FUNCTION_OUT );
-  #endif  
+#else
+    sem_post(&ric_send_sem); 
+#endif  
 } // while !oai_exit
 
   return 0;