Let's take out the compiler's dependent things

Taking one step towards cross-platform

Author: Roman-Koshelev

runtime/Cycles.h

@@ -18,6 +18,7 @@
 
 #include <stdint.h>
 
+#include "Portability.h"
 
 namespace PerfUtils {
 
@@ -34,7 +35,7 @@ class Cycles {
      * Return the current value of the fine-grain CPU cycle counter
      * (accessed via the RDTSC instruction).
      */
-    static __inline __attribute__((always_inline))
+    static NANOLOG_ALWAYS_INLINE
     uint64_t
     rdtsc()
     {
@@ -48,7 +49,7 @@ class Cycles {
         return (((uint64_t)hi << 32) | lo);
     }
 
-    static __inline __attribute__((always_inline))
+    static NANOLOG_ALWAYS_INLINE
     double
     perSecond(){
         return getCyclesPerSec();
@@ -80,7 +81,7 @@ class Cycles {
      * Returns the conversion factor between cycles in seconds, using
      * a mock value for testing when appropriate.
      */
-    static __inline __attribute__((always_inline))
+    static NANOLOG_ALWAYS_INLINE
     double
     getCyclesPerSec()
     {

runtime/Log.h

@@ -23,6 +23,7 @@
 #include "Common.h"
 #include "Cycles.h"
 #include "Packer.h"
+#include "Portability.h"
 #include "TestUtil.h"
 #include "Util.h"
 
@@ -221,10 +222,12 @@ namespace Log {
      * in the first two bits and this structure is used to extract those bits
      * when the type/identify is unknown.
      */
+    NANOLOG_PACK_PUSH
     struct UnknownHeader {
         uint8_t entryType:2;
         uint8_t other:6;
-    } __attribute((packed));
+    } NANOLOG_PACK_ATTR;
+    NANOLOG_PACK_POP
 
     static_assert(sizeof(UnknownHeader) == 1, "Unknown Header should have a"
             " byte size of 1 to ensure that we can always determine the entry"
@@ -239,6 +242,7 @@ namespace Log {
      *      (1-8 bytes) pack()-ed rdtsc() timestamp
      *      (0-n bytes) arguments (determined by preprocessor)
      */
+    NANOLOG_PACK_PUSH
     struct CompressedEntry {
         // Byte representation of an EntryType::LOG_MSGS_OR_DIC to identify this
         // as a CompressedRecordEntry.
@@ -252,7 +256,8 @@ namespace Log {
 
         // Value returned by pack(timestamp)
         uint8_t additionalTimestampBytes:4;
-    } __attribute__((packed));
+    } NANOLOG_PACK_ATTR;
+    NANOLOG_PACK_POP
 
     /**
      * Marker in the compressed log that indicates to which StagingBuffer/thread
@@ -261,6 +266,7 @@ namespace Log {
      * thread finishes processing a peek() and moves on to outputting the next
      * StagingBuffer.
      */
+    NANOLOG_PACK_PUSH
     struct BufferExtent {
         // Byte representation of EntryType::BUFFER_EXTENT
         uint8_t entryType:2;
@@ -289,7 +295,8 @@ namespace Log {
         static constexpr uint32_t maxSizeOfHeader() {
             return sizeof(BufferExtent) + sizeof(uint32_t);
         }
-    } __attribute__((packed));
+    } NANOLOG_PACK_ATTR;
+    NANOLOG_PACK_POP
 
     /**
      * Synchronization data structure in the compressed log that correlates the
@@ -298,6 +305,7 @@ namespace Log {
      * once at the beginning of a new log. If multiple exist in the log file,
      * that means the file has been appended to.
      */
+    NANOLOG_PACK_PUSH
     struct Checkpoint {
         // Byte representation of an EntryType::CHECKPOINT
         uint64_t entryType:2;
@@ -322,14 +330,16 @@ namespace Log {
         // in the log file.
         uint32_t totalMetadataEntries;
 
-    } __attribute__((packed));
+    } NANOLOG_PACK_ATTR;
+    NANOLOG_PACK_POP
 
     /**
      * A DictionaryFragment contains a partial mapping of unique identifiers to
      * static log information on disk. Following this structure is one or more
      * CompressedLogInfo. The order in which these log infos appear determine
      * its unique identifier (i.e. by order of appearance starting at 0).
      */
+    NANOLOG_PACK_PUSH
     struct DictionaryFragment {
         // Byte representation of an EntryType::LOG_MSG_OR_DIC to indicate
         // the start of a dictionary fragment.
@@ -341,12 +351,14 @@ namespace Log {
         // Total number of FormatMetadata encountered so far in the log
         // including this fragment (used as a sanity check only).
         uint32_t totalMetadataEntries;
-    } __attribute__((packed));
+    } NANOLOG_PACK_ATTR;
+    NANOLOG_PACK_POP
 
     /**
      * Stores the static log information associated with a log message on disk.
      * Following this structure are the filename and format string.
      */
+    NANOLOG_PACK_PUSH
     struct CompressedLogInfo {
         // LogLevel severity of the original log invocation
         uint8_t severity;
@@ -361,14 +373,16 @@ namespace Log {
         // Length of the format string that is associated with this log
         // invocation and comes after filename.
         uint16_t formatStringLength;
-    } __attribute((packed));
+    } NANOLOG_PACK_ATTR;
+    NANOLOG_PACK_POP
 
     /**
      * Describes a unique log message within the user sources. The order in
      * which this structure appears in the log file determines the associated
      * logId. Following this structure are the source filename and
      * PrintFragments required for this message.
      */
+    NANOLOG_PACK_PUSH
     struct FormatMetadata {
         // Number of nibbles in the dynamic data stream used to pack() arguments
         uint8_t numNibbles;
@@ -387,12 +401,14 @@ namespace Log {
 
         // Filename for the original source file containing the LOG statement
         char filename[];
-    } __attribute__((packed));
+    } NANOLOG_PACK_ATTR;
+    NANOLOG_PACK_POP
 
     /**
      * Describes how to interpret the dynamic log stream and partially
      * reconstruct the original log message.
      */
+    NANOLOG_PACK_PUSH
     struct PrintFragment {
         // The type of the argument to pull from the dynamic buffer to the
         // partial format string (formatFragment)
@@ -410,7 +426,8 @@ namespace Log {
         // A fragment of the original LOG statement that contains at most
         // one format specifier.
         char formatFragment[];
-    } __attribute__((packed));
+    } NANOLOG_PACK_ATTR;
+    NANOLOG_PACK_POP
 
 
     /**

runtime/NanoLogCpp17.h

@@ -25,6 +25,7 @@
 #include "Common.h"
 #include "Cycles.h"
 #include "Packer.h"
+#include "Portability.h"
 #include "NanoLog.h"
 
 /***
@@ -825,9 +826,9 @@ compressSingle(BufferUtils::TwoNibbles* nibbles,
  * https://stackoverflow.com/questions/23443511/how-to-match-empty-arguments-pack-in-variadic-template
  */
 template<typename... Ts>
-__attribute__((always_inline))
-inline void compress_internal(BufferUtils::TwoNibbles*, int,
-                              const bool*, bool, int, char **, char **);
+NANOLOG_ALWAYS_INLINE
+void compress_internal(BufferUtils::TwoNibbles*, int,
+                       const bool*, bool, int, char **, char **);
 
 /**
  * Recursively peels off an argument from an argument pack and compresses
@@ -855,15 +856,14 @@ inline void compress_internal(BufferUtils::TwoNibbles*, int,
  *      Output buffer to write the compressed results to
  */
 template<typename T1, typename... Ts>
-inline void
-__attribute__((always_inline))
-compressHelper(BufferUtils::TwoNibbles *nibbles,
-                int nibbleCnt,
-                const ParamType *paramTypes,
-                bool stringsOnly,
-                int argNum,
-                char **in,
-                char **out)
+NANOLOG_ALWAYS_INLINE
+void compressHelper(BufferUtils::TwoNibbles *nibbles,
+                    int nibbleCnt,
+                    const ParamType *paramTypes,
+                    bool stringsOnly,
+                    int argNum,
+                    char **in,
+                    char **out)
 {
     // Peel off the first argument, and recursively process the rest
     compressSingle<T1>(nibbles, &nibbleCnt, paramTypes[argNum], stringsOnly,
@@ -874,22 +874,20 @@ compressHelper(BufferUtils::TwoNibbles *nibbles,
 
 
 template<typename... Ts>
-inline void
-__attribute__((always_inline))
-compress_internal(BufferUtils::TwoNibbles *nibbles, int nibbleCnt,
-                  const ParamType *isArgString, bool stringsOnly, int argNum,
-                  char **in, char **out)
+NANOLOG_ALWAYS_INLINE 
+void compress_internal(BufferUtils::TwoNibbles *nibbles, int nibbleCnt,
+                       const ParamType *isArgString, bool stringsOnly, int argNum,
+                       char **in, char **out)
 {
     compressHelper<Ts...>(nibbles, nibbleCnt, isArgString, stringsOnly,
                                 argNum, in, out);
 }
 
 template<>
-inline void
-__attribute__((always_inline))
-compress_internal(BufferUtils::TwoNibbles *nibbles, int nibbleCnt,
-                  const ParamType *isArgString, bool stringsOnly, int argNum,
-                  char **in, char **out)
+NANOLOG_ALWAYS_INLINE 
+void compress_internal(BufferUtils::TwoNibbles *nibbles, int nibbleCnt,
+                       const ParamType *isArgString, bool stringsOnly, int argNum,
+                       char **in, char **out)
 {
     // This is a catch for compress when the template arguments are empty,
     // in which case we do nothing. This is needed since the head/tail pack
@@ -1058,8 +1056,8 @@ log(int &logId,
  *      format parameters
  */
 static void
-__attribute__ ((format (printf, 1, 2)))
-checkFormat(const char *, ...) {}
+NANOLOG_PRINTF_FORMAT_ATTR(1, 2)
+checkFormat(NANOLOG_PRINTF_FORMAT const char *, ...) {}
 
 
 /**

runtime/Packer.h

@@ -20,6 +20,7 @@
 #include <cstdint>
 
 #include "Common.h"
+#include "Portability.h"
 
 #ifndef PACKER_H
 #define PACKER_H
@@ -71,10 +72,12 @@ namespace BufferUtils {
  * Packs two 4-bit nibbles into one byte. This is used to pack the special
  * codes returned by pack() in the compressed log.
  */
+NANOLOG_PACK_PUSH
 struct TwoNibbles {
     uint8_t first:4;
     uint8_t second:4;
-} __attribute__((packed));
+} NANOLOG_PACK_ATTR;
+NANOLOG_PACK_POP
 
 /**
  * Given an unsigned integer and a char array, find the fewest number of

runtime/Perf.cc

@@ -48,6 +48,7 @@
 #include "Cycles.h"
 #include "Log.h"
 #include "PerfHelper.h"
+#include "Portability.h"
 #include "Util.h"
 #include "Fence.h"
 
@@ -93,7 +94,7 @@ void function(uint64_t cycles) {
  * Return the current value of the fine-grain CPU cycle counter
  * (accessed via the RDTSC instruction).
  */
-static __inline __attribute__((always_inline))
+static NANOLOG_ALWAYS_INLINE
 uint64_t
 rdtsc()
 {
@@ -106,7 +107,7 @@ rdtsc()
  * Return the current value of the fine-grain CPU cycle counter
  * (accessed via the RDTSCP instruction).
  */
-static __inline __attribute__((always_inline))
+static NANOLOG_ALWAYS_INLINE
 uint64_t
 rdtscp()
 {

runtime/PerfHelper.h

@@ -26,10 +26,12 @@
 #include <stdint.h>
 #include <stdio.h>
 
+#include "Portability.h"
+
 namespace PerfHelper {
 
 void flushCache();
-uint64_t plusOne(uint64_t x) __attribute__ ((noinline));
+uint64_t plusOne(uint64_t x) NANOLOG_NOINLINE;
 
 // Simple function that performs no computation
 template<int addTo>

runtime/Portability.h

@@ -0,0 +1,55 @@
+#ifndef NANOLOG_PORTABILITY_H
+#define NANOLOG_PORTABILITY_H
+
+#ifdef _MSC_VER
+#define NANOLOG_ALWAYS_INLINE __forceinline
+#elif defined(__GNUC__)
+#define NANOLOG_ALWAYS_INLINE inline __attribute__((__always_inline__))
+#else
+#define NANOLOG_ALWAYS_INLINE inline
+#endif
+
+#ifdef _MSC_VER
+#define NANOLOG_NOINLINE __declspec(noinline)
+#elif defined(__GNUC__)
+#define NANOLOG_NOINLINE __attribute__((__noinline__))
+#else
+#define NANOLOG_NOINLINE
+#endif
+
+#ifdef _MSC_VER
+#define NANOLOG_PACK_ATTR
+#define NANOLOG_PACK_PUSH __pragma(pack(push, 1))
+#define NANOLOG_PACK_POP __pragma(pack(pop))
+#elif defined(__GNUC__)
+#define NANOLOG_PACK_ATTR __attribute__((__packed__))
+#define NANOLOG_PACK_PUSH
+#define NANOLOG_PACK_POP
+#else
+#define NANOLOG_PACK_ATTR
+#define NANOLOG_PACK_PUSH
+#define NANOLOG_PACK_POP
+#endif
+
+#if _MSC_VER
+
+#ifdef _USE_ATTRIBUTES_FOR_SAL
+#undef _USE_ATTRIBUTES_FOR_SAL
+#endif
+
+#define _USE_ATTRIBUTES_FOR_SAL 1
+#include <sal.h>
+
+#define NANOLOG_PRINTF_FORMAT _Printf_format_string_
+#define NANOLOG_PRINTF_FORMAT_ATTR(string_index, first_to_check)
+
+#elif defined(__GNUC__)
+#define NANOLOG_PRINTF_FORMAT
+#define NANOLOG_PRINTF_FORMAT_ATTR(string_index, first_to_check) \
+  __attribute__((__format__(__printf__, string_index, first_to_check)))
+#else
+#define NANOLOG_PRINTF_FORMAT
+#define NANOLOG_PRINTF_FORMAT_ATTR(string_index, first_to_check)
+#endif
+
+#endif /* NANOLOG_PORTABILITY_H */