Fully working. Just needs to be cleaned up.

Author: Evrytania

include/LTE-Tracker.h

@@ -45,6 +45,7 @@ class tracked_cell_t {
       crs_sp_av=NAN;
       crs_np_av=itpp::vec(4);
       crs_np_av=NAN;
+      launched=false;
     }
     inline uint8 const n_symb_dl() const {
       return (cp_type==cp_type_t::NORMAL)?7:((cp_type==cp_type_t::EXTENDED)?6:-1);
@@ -67,6 +68,8 @@ class tracked_cell_t {
 
     // Indicates that the tracker process is ready to receive data.
     bool tracker_thread_ready;
+    // Indicates that the thread has been launched
+    bool launched;
 
     // Mutex and measurement data produced by the tracker thread and read by
     // the display thread.
@@ -100,7 +103,6 @@ class tracked_cell_t {
     // threads.
     boost::mutex frame_timing_mutex;
     double frame_timing_private;
-
 };
 // Structure that is used to record all the tracked cells.
 typedef struct {
@@ -111,20 +113,12 @@ typedef struct {
   std::list <tracked_cell_t *> tracked_cells;
 } tracked_cell_list_t;
 // Global data shared by all threads
-/*
-typedef struct {
-  // The frequency offset of the dongle. This value will be updated
-  // continuously.
-  boost::mutex frequency_offset_mutex;
-  double frequency_offset;
-  // This value will never change.
-  double fc;
-} global_thread_data_t;
-*/
 class global_thread_data_t {
   public:
     // Constructor
     global_thread_data_t(const double & fc) : fc(fc) {
+      searcher_cycle_time_private=0;
+      cell_seconds_dropped_private=0;
     }
     // This value will never change.
     const double fc;
@@ -140,11 +134,40 @@ class global_thread_data_t {
       boost::mutex::scoped_lock lock(frequency_offset_mutex);
       frequency_offset_private=f;
     }
+    // Read/write searcher cycle time (via mutex).
+    // Mutex makes sure that no read or write is interrupted when
+    // only part of the data has been read.
+    inline double searcher_cycle_time() {
+      boost::mutex::scoped_lock lock(searcher_cycle_time_mutex);
+      double r=searcher_cycle_time_private;
+      return r;
+    }
+    inline void searcher_cycle_time(const double & t) {
+      boost::mutex::scoped_lock lock(searcher_cycle_time_mutex);
+      searcher_cycle_time_private=t;
+    }
+    inline uint32 cell_seconds_dropped() {
+      boost::mutex::scoped_lock lock(cell_seconds_dropped_mutex);
+      double r=cell_seconds_dropped_private;
+      return r;
+    }
+    inline void cell_seconds_dropped_inc() {
+      boost::mutex::scoped_lock lock(cell_seconds_dropped_mutex);
+      cell_seconds_dropped_private+=1;
+    }
+    uint32 searcher_thread_id;
+    uint32 producer_thread_id;
+    uint32 main_thread_id;
+    uint32 display_thread_id;
   private:
     // The frequency offset of the dongle. This value will be updated
     // continuously.
     boost::mutex frequency_offset_mutex;
     double frequency_offset_private;
+    boost::mutex searcher_cycle_time_mutex;
+    double searcher_cycle_time_private;
+    boost::mutex cell_seconds_dropped_mutex;
+    uint32 cell_seconds_dropped_private;
 };
 // IPC between main thread and searcher thread covering data capture issues.
 typedef struct {

src/LTE-Tracker.cpp

@@ -29,6 +29,8 @@
 #include <signal.h>
 #include <queue>
 #include <sys/stat.h>
+#include <sys/syscall.h>
+#include <sys/types.h>
 #include "rtl-sdr.h"
 #include "common.h"
 #include "macros.h"
@@ -895,6 +897,7 @@ int main(
   tracked_cell_list_t tracked_cell_list;
   capbuf_sync_t capbuf_sync;
   global_thread_data_t global_thread_data(fc);
+  global_thread_data.main_thread_id=syscall(SYS_gettid);
 
   // Calibrate the dongle's oscillator. This is similar to running the
   // program CellSearch with only one center frequency. All information

src/display_thread.cpp

@@ -29,6 +29,8 @@
 #include <signal.h>
 #include <queue>
 #include <curses.h>
+#include <sys/syscall.h>
+#include <sys/types.h>
 #include "rtl-sdr.h"
 #include "common.h"
 #include "macros.h"
@@ -51,6 +53,8 @@ void display_thread(
   global_thread_data_t & global_thread_data,
   tracked_cell_list_t & tracked_cell_list
 ) {
+  global_thread_data.display_thread_id=syscall(SYS_gettid);
+
   initscr();
   // What does this do?
   (void)echo();
@@ -67,8 +71,15 @@ void display_thread(
     {
       boost::mutex::scoped_lock lock(sampbuf_sync.mutex);
       //cout << "Raw sample buffer size: " << sampbuf_sync.fifo.size() << "/" << sampbuf_sync.fifo_peak_size << endl;
-      printw(" Raw buffer status: %6li/%6li\n\n",sampbuf_sync.fifo.size(),sampbuf_sync.fifo_peak_size);
+      printw(" Raw buffer status: %6li/%6li\n",sampbuf_sync.fifo.size(),sampbuf_sync.fifo_peak_size);
     }
+    printw("Searcher cycle time: %.1lf s\n\n",global_thread_data.searcher_cycle_time());
+    printw("Searcher thread ID: %5i\n",global_thread_data.searcher_thread_id);
+    printw("Producer thread ID: %5i\n",global_thread_data.producer_thread_id);
+    printw("Main     thread ID: %5i\n",global_thread_data.main_thread_id);
+    printw("Display  thread ID: %5i\n\n",global_thread_data.display_thread_id);
+
+    printw("Cell seconds dropped: %i\n\n",global_thread_data.cell_seconds_dropped());
 
     {
       boost::mutex::scoped_lock lock(tracked_cell_list.mutex);

src/producer_thread.cpp

@@ -28,6 +28,8 @@
 #include <sstream>
 #include <signal.h>
 #include <queue>
+#include <sys/syscall.h>
+#include <sys/types.h>
 #include "rtl-sdr.h"
 #include "common.h"
 #include "macros.h"
@@ -61,6 +63,8 @@ void producer_thread(
   tracked_cell_list_t & tracked_cell_list,
   double & fc
 ) {
+  global_thread_data.producer_thread_id=syscall(SYS_gettid);
+
   // Main loop which distributes data to the appropriate subthread.
   // Local storage for each cell.
   cell_local_t cell_local[504];
@@ -155,6 +159,11 @@ void producer_thread(
       list <tracked_cell_t *>::iterator it=tracked_cell_list.tracked_cells.begin();
       while (it!=tracked_cell_list.tracked_cells.end()) {
         tracked_cell_t & tracked_cell=(*(*it));
+        // See if this thread has been launched yet. If not, launch it.
+        if (!tracked_cell.launched) {
+          tracked_cell.thread=boost::thread(tracker_thread,boost::ref(tracked_cell),boost::ref(global_thread_data));
+          tracked_cell.launched=true;
+        }
         double frame_timing=tracked_cell.frame_timing();
 
         cell_local_t & cl=cell_local[tracked_cell.n_id_cell];

src/searcher_thread.cpp

@@ -29,6 +29,8 @@
 #include <signal.h>
 #include <queue>
 #include <valgrind/callgrind.h>
+#include <sys/syscall.h>
+#include <sys/types.h>
 #include "rtl-sdr.h"
 #include "common.h"
 #include "macros.h"
@@ -58,7 +60,9 @@ void searcher_thread(
     cout << "Searcher process has been launched." << endl;
   }
 
-  if (nice(10)==-1) {
+  global_thread_data.searcher_thread_id=syscall(SYS_gettid);
+
+  if (nice(20)==-1) {
     cerr << "Error: could not reduce searcher process priority" << endl;
     exit(-1);
   }
@@ -72,7 +76,11 @@ void searcher_thread(
   const double & fc=global_thread_data.fc;
 
   // Loop forever.
+  Real_Timer tt;
   while (true) {
+    // Used to measure searcher cycle time.
+    tt.tic();
+
     // Request data.
     {
       boost::mutex::scoped_lock lock(capbuf_sync.mutex);
@@ -209,17 +217,25 @@ void searcher_thread(
       //tracked_cell_t * new_cell = new tracked_cell_t((*iterator).n_id_cell(),(*iterator).n_ports,(*iterator).cp_type,(*iterator).frame_start/k_factor+capbuf_sync.late+global_1);
       tracked_cell_t * new_cell = new tracked_cell_t((*iterator).n_id_cell(),(*iterator).n_ports,(*iterator).cp_type,(*iterator).frame_start/k_factor+capbuf_sync.late,serial_num((*iterator).n_id_cell()));
       serial_num((*iterator).n_id_cell())++;
-      (*new_cell).thread=boost::thread(tracker_thread,boost::ref(*new_cell),boost::ref(global_thread_data));
+      // Cannot launch thread here. If thread was launched here, it would
+      // have the same (low) priority as the searcher thread.
+      //(*new_cell).thread=boost::thread(tracker_thread,boost::ref(*new_cell),boost::ref(global_thread_data));
       {
         boost::mutex::scoped_lock lock(tracked_cell_list.mutex);
         tracked_cell_list.tracked_cells.push_back(new_cell);
       }
       CALLGRIND_START_INSTRUMENTATION;
-      //cout << "Only one cell is allowed to be detected!!!" << endl;
-      //sleep(1000000);
+#define MAX_DETECTED 500000
+      static uint32 n_found=0;
+      n_found++;
+      if (n_found==MAX_DETECTED) {
+        cout << "Searcher thread has stopped!" << endl;
+        sleep(1000000);
+      }
 
       ++iterator;
     }
+    global_thread_data.searcher_cycle_time(tt.toc());
   }
   // Will never reach here...
 }

src/tracker_thread.cpp

@@ -700,6 +700,19 @@ void tracker_thread(
   //}
   // Each iteration of this loop processes one OFDM symbol.
   while (true) {
+    // If there is more than 1.5s worth of data in the fifo, dump
+    // data to allow the tracker threads to catch up.
+    {
+      boost::mutex::scoped_lock lock(tracked_cell.fifo_mutex);
+      uint16 n_ofdm_1s=(tracked_cell.cp_type==cp_type_t::NORMAL)?(7*2*1000):(6*2*1000);
+      while (tracked_cell.fifo.size()>n_ofdm_1s*1.5) {
+        for (uint32 t=0;t<n_ofdm_1s;t++) {
+          tracked_cell.fifo.pop();
+        }
+        global_thread_data.cell_seconds_dropped_inc();
+      }
+    }
+
     // Get the next frequency domain sample from the fifo.
     cvec syms;
     double frequency_offset;