update 0.0.2

source/Threads/StatisticsThread.cpp

@@ -1,9 +1,58 @@
 #include "Threads/StatisticsThread.hpp"
+#include <iostream>
 
 //-------------------------------------------------------------------------
 //-------------------------- StatisticsThread -----------------------------
 //-------------------------------------------------------------------------
 
+StatisticsThread::StatisticsThread() {
+    std::string name;
+    unsigned int lcore_id = rte_lcore_id();
+    for (int i = 0; i < 16; ++i) {
+        lcore_id = rte_get_next_lcore(lcore_id, true, true);
+
+        name = "RTE_RING_THREAD_";
+        name += i + 1;
+        const char* c =
+            name.c_str(); // wrap string to char pointer //TODO: good name
+
+        lcore_id = rte_get_next_lcore(lcore_id, true, true);
+        _s_queue[i] = rte_ring_create(c, 4, rte_lcore_to_socket_id(lcore_id),
+                                      RING_F_SP_ENQ | RING_F_SC_DEQ);
+
+        // checking for errors in creating rte rings
+        if (_s_queue[i] == NULL) {
+            if (rte_errno == E_RTE_NO_CONFIG) {
+                std::cout << "Error during RTE_RING creation at Ring " << i + 1
+                          << ", return Value = E_RTE_NO_CONFIG" << std::endl;
+            }
+            if (rte_errno == E_RTE_SECONDARY) {
+                std::cout << "Error during RTE_RING creation at Ring " << i + 1
+                          << ", return Value = E_RTE_SECONDARY" << std::endl;
+            }
+            if (rte_errno == EINVAL) {
+                std::cout << "Error during RTE_RING creation at Ring " << i + 1
+                          << ", return Value = EINVAL" << std::endl;
+            }
+            if (rte_errno == ENOSPC) {
+                std::cout << "Error during RTE_RING creation at Ring " << i + 1
+                          << ", return Value = ENOSPC" << std::endl;
+            }
+            if (rte_errno == EEXIST) {
+                std::cout << "Error during RTE_RING creation at Ring " << i + 1
+                          << ", return Value = EEXIST" << std::endl;
+            }
+            if (rte_errno == ENOMEM) {
+                std::cout << "Error during RTE_RING creation at Ring " << i + 1
+                          << ", return Value = ENOMEM" << std::endl;
+            }
+        }
+    } // rte_lcore_to_socket_id
+    _s_stats_monitor = new StatsMonitor;
+    _s_stats = new Stats;
+    _s_stats_monitor->total_time = 0;
+}
+
 rte_ring* StatisticsThread::_s_queue[16];
 
 int StatisticsThread::s_run(void* thread_vptr) {
@@ -14,42 +63,97 @@ int StatisticsThread::s_run(void* thread_vptr) {
 
 void StatisticsThread::run() {
     // Check for new statistics in each rte_ring
-    while (_quit != false) {
-        for (rte_ring* ring : _s_queue) {
-            // Get stats from queue and update them
+    std::cout << "\n StatisticThread running on lcore " << rte_lcore_id()
+              << ". [Ctrl+C to quit]\n"
+              << std::endl;
+    cycles_old = rte_get_tsc_cycles();
+    while (likely(_quit == false)) {
+        // Timer -> update_statistics_monitor
+        if (timer_get_seconds() >=
+            1) { // every second updating the stats monitor
+            timer_reset();
+            update_statistics_monitor();
+        }
+        for (struct rte_ring* ring : _s_queue) {
+            // get stats from each Thread and put them into _s_stats
             Stats* out;
-            rte_ring_dequeue(ring, (void**)&out);
+            if (rte_ring_dequeue(ring, (void**)&out) ==
+                0) {               // taking existing stats from ring
+                *_s_stats += *out; // updating _s_stats
 
-            if (true) { // \TODO test if empty
-                update_statistics(out);
+                /*delete out;
+                out = nullptr;*/
             }
         }
     }
 }
 
-void StatisticsThread::enqueue_statistics(int& id, Stats* new_stats) {
-    // enqueue statistics
-    rte_ring* ring = _s_queue[id];
-    rte_ring_enqueue(ring, new_stats);
+void StatisticsThread::enqueue_statistics(const unsigned int& id,
+                                          Stats* new_stats) {
+    // enqueue statistics (checked and working)
+    rte_ring_enqueue(_s_queue[id], (void*)new_stats);
 }
 
-Stats* StatisticsThread::_s_stats;
+void StatisticsThread::update_statistics_monitor() {
+    // called once per second
+    _s_stats_monitor->attacks_per_second = _s_stats->attacks;
+    _s_stats_monitor->attacks_percent =
+        ((double)_s_stats->attacks / (double)_s_stats->packets) * 100;
+    _s_stats_monitor->bytes_per_second = _s_stats->bytes;
+    _s_stats_monitor->dropped_per_second = _s_stats->dropped;
+    _s_stats_monitor->attacks_percent =
+        ((double)_s_stats->dropped / (double)_s_stats->packets) * 100;
+    _s_stats_monitor->packets_per_second = _s_stats->packets;
+    //_s_stats_monitor->process_speed = ;
+    ++_s_stats_monitor->total_time;
 
-void StatisticsThread::update_statistics(Stats* new_stats) {
-    //_s_stats += new_stats;
+    // delete old _s_stats
+    _s_stats->reset_stats();
+}
+
+void StatisticsThread::print_stats_monitor(){
+
+    std::cout << "Total runtime = " << _s_stats_monitor->total_time << "s" << std::endl;
+    std::cout << "Bytes per second  = " << _s_stats_monitor->bytes_per_second << std::endl;
+    std::cout << "Packets per second = " << _s_stats_monitor->packets_per_second << std::endl;
+    std::cout << "Attacks per Second = " << _s_stats_monitor->attacks_per_second << std::endl;
+    std::cout << "Attacks in percent = " << _s_stats_monitor->attacks_percent << "%" << std::endl;
+    std::cout << "Dropped packets per second = " << _s_stats_monitor->dropped_per_second << std::endl;
+    std::cout << "Dropped packets in percent = " << _s_stats_monitor->dropped_percent << "%" << std::endl;
+    std::cout << "Prozess speed = " << _s_stats_monitor->process_speed << std::endl;
+}
+
+uint64_t StatisticsThread::timer_get_seconds() {
+
+    cycles = rte_get_tsc_cycles();
+    hz = rte_get_tsc_hz();
+
+    // calculate
+    seconds = (cycles - cycles_old) / hz;
+
+    return seconds;
+}
+
+void StatisticsThread::timer_reset() {
+    seconds = 0;
+    cycles_old = cycles;
 }
 
 //-------------------------------------------------------------------------
-//-------------------------- Stats ----------------------------------------
+//------------------------------- Stats -----------------------------------
 //-------------------------------------------------------------------------
 
-Stats* Stats::operator+=(const Stats* new_stats) {
-    this->attacks += new_stats->attacks;
-    this->bytes += new_stats->bytes;
-    this->dropped += new_stats->dropped;
-    this->packets += new_stats->packets;
-    this->work_time += new_stats->work_time;
-    this->syn_level += new_stats->syn_level;
-
-    return this;
+Stats& Stats::operator+=(const Stats& new_stats) {
+    attacks += new_stats.attacks;
+    bytes += new_stats.bytes;
+    dropped += new_stats.dropped;
+    packets += new_stats.packets;
+    work_time += new_stats.work_time;
 }
+void Stats::reset_stats() {
+    attacks = 0;
+    bytes = 0;
+    dropped = 0;
+    packets = 0;
+    work_time = 0;
+}