refactoring

Author: jeremyko

atomic_print.hpp

@@ -23,24 +23,20 @@
 #include <iostream>
 #include <mutex>
 
-using namespace std;
 ///////////////////////////////////////////////////////////////////////////////
 class AtomicPrint
 {
     public:
-        AtomicPrint()
-        {
+        AtomicPrint() {
             lock_mutex_.lock();
         }
 
-        AtomicPrint(string strMsg)
-        {
+        AtomicPrint(std::string msg) {
             lock_mutex_.lock();
-            cout << strMsg <<"\n";
+            std::cout << msg <<"\n";
         }
 
-        ~AtomicPrint()
-        {
+        ~AtomicPrint() {
             lock_mutex_.unlock();
         }
 

common_def.hpp

@@ -1,41 +1,84 @@
+/****************************************************************************
+ Copyright (c) 2015, ko jung hyun
+ 
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+ 
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+ ****************************************************************************/
 
-#ifndef __COMMON_DEF_HPP__
-#define __COMMON_DEF_HPP__
+#ifndef COMMON_DEF_HPP
+#define COMMON_DEF_HPP
 
 #include <atomic>
-//#include <mutex>
+#include <iostream>
 #include <condition_variable>
-
 #include <pthread.h> //blocking strategy : mutex, condition_var on shared memory
 #include <sys/stat.h>
 #include <sys/mman.h>
 #include <fcntl.h>
 #include <sys/ipc.h> 
 #include <sys/shm.h> 
 #define CACHE_LINE_SIZE 64 
+#define MAX_CONSUMER    200
+#define DEFAULT_RING_BUFFER_SIZE  1024
+
+///////////////////////////////////////////////////////////////////////////////
+//color printf
+#define COLOR_RED  "\x1B[31m"
+#define COLOR_GREEN "\x1B[32m" 
+#define COLOR_BLUE "\x1B[34m"
+#define COLOR_RESET "\x1B[0m"
+#define  LOG_WHERE "("<<__FILE__<<"-"<<__func__<<"-"<<__LINE__<<") "
+#define  WHERE_DEF __FILE__,__func__,__LINE__
 
+#ifdef DEBUG_PRINTF
+#define  DEBUG_LOG(x)  std::cout<<LOG_WHERE << x << "\n"
+#define  DEBUG_RED_LOG(x) std::cout<<LOG_WHERE << COLOR_RED<< x << COLOR_RESET << "\n"
+#define  DEBUG_GREEN_LOG(x) std::cout<<LOG_WHERE << COLOR_GREEN<< x << COLOR_RESET << "\n"
+#define  DEBUG_ELOG(x) std::cerr<<LOG_WHERE << COLOR_RED<< x << COLOR_RESET << "\n"
+#else
+#define  DEBUG_LOG(x) 
+#define  DEBUG_ELOG(x) 
+#define  DEBUG_RED_LOG(x) 
+#define  DEBUG_GREEN_LOG(x)
+#endif
+#define  PRINT_ELOG(x) std::cerr<<LOG_WHERE << COLOR_RED<< x << COLOR_RESET << "\n"
+
+///////////////////////////////////////////////////////////////////////////////
 typedef struct _OneBufferData_
 {
-    int64_t  nData;
-    int  producerId;
-
+    int64_t data;
+    size_t  producer_id;
 } OneBufferData ;
+const size_t LEN_ONE_BUFFER_DATA = sizeof(OneBufferData);
 
-#define MAX_CONSUMER 200
 typedef struct _RingBufferStatusOnSharedMem_
 {
-    int  nBufferSize   ;
-    int  nTotalMemSize ;
-    std::atomic<int> registered_producer_count ;
-    std::atomic<int> registered_consumer_count;
+    size_t  buffer_size   ;
+    size_t  total_mem_size ;
+    std::atomic<size_t> registered_producer_count ;
+    std::atomic<size_t> registered_consumer_count;
     std::atomic<int64_t> cursor  alignas(CACHE_LINE_SIZE);  
     std::atomic<int64_t> next    alignas(CACHE_LINE_SIZE); 
-    int64_t arrayOfConsumerIndexes [MAX_CONSUMER] __attribute__ ((aligned (CACHE_LINE_SIZE)));
-
-    pthread_cond_t   condVar;
-    pthread_mutex_t  mtxLock;
-
-
+    int64_t array_of_consumer_indexes [MAX_CONSUMER] __attribute__ ((aligned (CACHE_LINE_SIZE)));
+    //TODO use uint64_t
+    pthread_cond_t   cond_var;
+    pthread_mutex_t  mtx_lock;
 } RingBufferStatusOnSharedMem ;
 
-#endif
+#endif //COMMON_DEF_HPP
+

elapsed_time.hpp

@@ -36,38 +36,27 @@ typedef enum _ENUM_TIME_RESOLUTION_
 
 } ENUM_TIME_RESOLUTION;
 
+////////////////////////////////////////////////////////////////////////////////
 class ElapsedTime
 {
     public:
-        ElapsedTime()
-        {
+        ElapsedTime() {
             SetStartTime();
         }
+        ~ElapsedTime() {}
 
-        ~ElapsedTime()
-        {
-        }
-
-        void SetStartTime()
-        {
+        void SetStartTime() {
             start_time_ = std::chrono::steady_clock::now(); 
         }
-
-        long long SetEndTime( ENUM_TIME_RESOLUTION resolution)
-        {
+        long long SetEndTime( ENUM_TIME_RESOLUTION resolution) {
             end_time_ = std::chrono::steady_clock::now(); 
-
-            if(resolution == MILLI_SEC_RESOLUTION)
-            {
+            if(resolution == MILLI_SEC_RESOLUTION) {
                 millisecs_t duration(std::chrono::duration_cast<millisecs_t>(end_time_ - start_time_));
                 return duration.count();
-            }
-            else if (resolution == MICRO_SEC_RESOLUTION)
-            {
+            } else if (resolution == MICRO_SEC_RESOLUTION) {
                 microsecs_t duration(std::chrono::duration_cast<microsecs_t>(end_time_ - start_time_));
                 return duration.count();
             }
-
             return -1; //error
         }
 

ring_buffer.hpp

@@ -20,73 +20,59 @@
  THE SOFTWARE.
  ****************************************************************************/
 
-#ifndef __DISRUPTORCPP_RING_BUFFER_HPP__
-#define __DISRUPTORCPP_RING_BUFFER_HPP__
-//20150721 kojh create
+#ifndef DISRUPTORCPP_RING_BUFFER_HPP
+#define DISRUPTORCPP_RING_BUFFER_HPP
 
 #include <iostream>
 #include <memory>
 #include <vector>
+#include "common_def.hpp" 
 
-#define DEFAULT_RING_BUFFER_SIZE  1024
-
+////////////////////////////////////////////////////////////////////////////////
 template<typename T>
 class RingBuffer
 {
     public:
-
-        RingBuffer()
-        {
-            nCapacity_ = DEFAULT_RING_BUFFER_SIZE;
+        RingBuffer() {
+            capacity_ = DEFAULT_RING_BUFFER_SIZE;
             buffer_.reserve(DEFAULT_RING_BUFFER_SIZE);
         }
-
         RingBuffer(const std::vector<T>& buffer) : buffer_(buffer) {}
 
-        T& operator[](const int64_t & sequence) 
-        { 
-            return buffer_[sequence & (nCapacity_ - 1)]; //only when multiple of 2
+        T& operator[](const int64_t & sequence) { 
+            return buffer_[sequence & (capacity_ - 1)]; //only when multiple of 2
         }
 
-        int64_t GetTranslatedIndex( int64_t sequence)
-        {
-            int64_t translated_index = (sequence & (nCapacity_ - 1)) ; 
+        int64_t GetTranslatedIndex( int64_t sequence) {
+            int64_t translated_index = (sequence & (capacity_ - 1)) ; 
             return translated_index ;
         }
 
-        bool SetCapacity(int nCapacity)
-        {
-            bool bIsPower2 =  nCapacity && !( (nCapacity-1) & nCapacity ) ; 
-
-            if( bIsPower2 ==0 )
-            {
-                std::cerr << "Buffer capacity error: power of 2 required!" << '\n';
+        bool SetCapacity(size_t capacity) {
+            bool is_power2 =  capacity && !( (capacity-1) & capacity ) ; 
+            if( is_power2 ==0 ) {
+                DEBUG_ELOG("Buffer capacity error: power of 2 required!");
                 return false;
             }
 
-            try 
-            {
-                buffer_.reserve(nCapacity);
-            }
-            catch (const std::length_error& le) 
-            {
-                std::cerr << "Length error: " << le.what() << '\n';
+            try {
+                buffer_.reserve(capacity);
+            } catch (const std::length_error& le) {
+                DEBUG_ELOG("Length error: " << le.what() );
                 return false;
             }
-
-            nCapacity_ = nCapacity;
+            capacity_ = capacity;
             return true;
         }
 
     private:
-        int nCapacity_ ;
+        size_t          capacity_ ;
         std::vector<T>  buffer_;
-
         RingBuffer(const RingBuffer&);
         void operator=(const RingBuffer&);
         RingBuffer(RingBuffer&&);
         void operator=(const RingBuffer&&);
 };
 
-#endif
+#endif //DISRUPTORCPP_RING_BUFFER_HPP