使用模板元编程实现更好的LOG()宏

Question

一个典型的基于LOG()宏的日志记录解决方案可能看起来像这样：

#define LOG(msg) \
    std::cout << __FILE__ << "(" << __LINE__ << "): " << msg << std::endl 

这使得程序员可以使用便捷且类型安全的流操作符创建数据丰富的消息:

string file = "blah.txt";
int error = 123;
...
LOG("Read failed: " << file << " (" << error << ")");

// Outputs:
// test.cpp(5): Read failed: blah.txt (123)

问题在于这会导致编译器内联多个ostream::operator<<调用。这会增加生成的代码和函数大小，我怀疑这可能会影响指令缓存性能并阻碍编译器优化代码的能力。

以下是一种“简单”的替代方案，它使用可变参数模板函数来替换内联代码：

********* 解决方案#2: 可变参数模板函数 *********

#define LOG(...) LogWrapper(__FILE__, __LINE__, __VA_ARGS__)

// Log_Recursive wrapper that creates the ostringstream
template<typename... Args>
void LogWrapper(const char* file, int line, const Args&... args)
{
    std::ostringstream msg;
    Log_Recursive(file, line, msg, args...);
}

// "Recursive" variadic function
template<typename T, typename... Args>
void Log_Recursive(const char* file, int line, std::ostringstream& msg, 
                   T value, const Args&... args)
{
    msg << value;
    Log_Recursive(file, line, msg, args...);
}

// Terminator
void Log_Recursive(const char* file, int line, std::ostringstream& msg)
{
    std::cout << file << "(" << line << "): " << msg.str() << std::endl;
}

编译器会根据所需的消息参数的数量、种类和顺序自动生成模板函数的新实例。

好处是每个调用站点上的指令更少。缺点是用户必须将消息部分作为函数参数传递，而不能使用流操作符将它们组合起来。

LOG("Read failed: ", file, " (", error, ")");

********* 解决方案#3：表达式模板 *********

在@DyP的建议下，我创建了一个使用表达式模板的替代方案：

#define LOG(msg) Log(__FILE__, __LINE__, Part<bool, bool>() << msg)

template<typename T> struct PartTrait { typedef T Type; };

// Workaround GCC 4.7.2 not recognizing noinline attribute
#ifndef NOINLINE_ATTRIBUTE
  #ifdef __ICC
    #define NOINLINE_ATTRIBUTE __attribute__(( noinline ))
  #else
    #define NOINLINE_ATTRIBUTE
  #endif // __ICC
#endif // NOINLINE_ATTRIBUTE

// Mark as noinline since we want to minimize the log-related instructions
// at the call sites
template<typename T>
void Log(const char* file, int line, const T& msg) NOINLINE_ATTRIBUTE
{
    std::cout << file << ":" << line << ": " << msg << std::endl;
}

template<typename TValue, typename TPreviousPart>
struct Part : public PartTrait<Part<TValue, TPreviousPart>>
{
    Part()
        : value(nullptr), prev(nullptr)
    { }

    Part(const Part<TValue, TPreviousPart>&) = default;
    Part<TValue, TPreviousPart> operator=(
                           const Part<TValue, TPreviousPart>&) = delete;

    Part(const TValue& v, const TPreviousPart& p)
        : value(&v), prev(&p)
    { }

    std::ostream& output(std::ostream& os) const
    {
        if (prev)
            os << *prev;
        if (value)
            os << *value;
        return os;
    }

    const TValue* value;
    const TPreviousPart* prev;
};

// Specialization for stream manipulators (eg endl)

typedef std::ostream& (*PfnManipulator)(std::ostream&);

template<typename TPreviousPart>
struct Part<PfnManipulator, TPreviousPart>
    : public PartTrait<Part<PfnManipulator, TPreviousPart>>
{
    Part()
        : pfn(nullptr), prev(nullptr)
    { }

    Part(const Part<PfnManipulator, TPreviousPart>& that) = default;
    Part<PfnManipulator, TPreviousPart> operator=(const Part<PfnManipulator,
                                                  TPreviousPart>&) = delete;

    Part(PfnManipulator pfn_, const TPreviousPart& p)
    : pfn(pfn_), prev(&p)
    { }

    std::ostream& output(std::ostream& os) const
    {
        if (prev)
            os << *prev;
        if (pfn)
            pfn(os);
        return os;
    }

    PfnManipulator pfn;
    const TPreviousPart* prev;
};

template<typename TPreviousPart, typename T>
typename std::enable_if<
    std::is_base_of<PartTrait<TPreviousPart>, TPreviousPart>::value, 
    Part<T, TPreviousPart> >::type
operator<<(const TPreviousPart& prev, const T& value)
{
    return Part<T, TPreviousPart>(value, prev);
}

template<typename TPreviousPart>
typename std::enable_if<
    std::is_base_of<PartTrait<TPreviousPart>, TPreviousPart>::value,
    Part<PfnManipulator, TPreviousPart> >::type
operator<<(const TPreviousPart& prev, PfnManipulator value)
{
    return Part<PfnManipulator, TPreviousPart>(value, prev);
}

template<typename TPart>
typename std::enable_if<
    std::is_base_of<PartTrait<TPart>, TPart>::value,
    std::ostream&>::type
operator<<(std::ostream& os, const TPart& part)
{
    return part.output(os);
}

表达式模板的解决方案允许程序员使用熟悉、方便和类型安全的流操作符：

LOG("Read failed: " << file << " " << error);

然而，当内联创建 Part<A, B> 时，不会产生任何 operator<< 调用，这样我们就能兼顾两个方面：便捷的类型安全的流操作符 + 较少的指令。使用 -O3 编译选项编译的 ICC13 生成以下汇编代码：

movl      $.L_2__STRING.3, %edi
movl      $13, %esi
xorl      %eax, %eax
lea       72(%rsp), %rdx
lea       8(%rsp), %rcx
movq      %rax, 16(%rsp)
lea       88(%rsp), %r8
movq      $.L_2__STRING.4, 24(%rsp)
lea       24(%rsp), %r9
movq      %rcx, 32(%rsp)
lea       40(%rsp), %r10
movq      %r8, 40(%rsp)
lea       56(%rsp), %r11
movq      %r9, 48(%rsp)
movq      $.L_2__STRING.5, 56(%rsp)
movq      %r10, 64(%rsp)
movq      $nErrorCode.9291.0.16, 72(%rsp)
movq      %r11, 80(%rsp)
call      _Z3LogI4PartIiS0_IA2_cS0_ISsS0_IA14_cS0_IbbEEEEEENSt9enable_ifIXsr3std10is_base_ofI9PartTraitIT_ESA_EE5valueEvE4typeEPKciRKSA_

总共有19条指令，其中包括一个函数调用。似乎每增加一个额外的参数流就会增加3个指令。编译器根据消息部件的数量、种类和顺序创建不同的Log()函数实例化，这解释了奇怪的函数名称。

********* 解决方案 #4：Cato的表达式模板 *********

这是Cato的出色解决方案，并进行了微调以支持流操纵符（例如endl）：

#define LOG(msg) (Log(__FILE__, __LINE__, LogData<None>() << msg))

// Workaround GCC 4.7.2 not recognizing noinline attribute
#ifndef NOINLINE_ATTRIBUTE
  #ifdef __ICC
    #define NOINLINE_ATTRIBUTE __attribute__(( noinline ))
  #else
    #define NOINLINE_ATTRIBUTE
  #endif // __ICC
#endif // NOINLINE_ATTRIBUTE

template<typename List>
void Log(const char* file, int line, 
         LogData<List>&& data) NOINLINE_ATTRIBUTE
{
    std::cout << file << ":" << line << ": ";
    output(std::cout, std::move(data.list));
    std::cout << std::endl;
}

struct None { };

template<typename List>
struct LogData {
    List list;
};

template<typename Begin, typename Value>
constexpr LogData<std::pair<Begin&&, Value&&>> operator<<(LogData<Begin>&& begin, 
                                                          Value&& value) noexcept
{
    return {{ std::forward<Begin>(begin.list), std::forward<Value>(value) }};
}

template<typename Begin, size_t n>
constexpr LogData<std::pair<Begin&&, const char*>> operator<<(LogData<Begin>&& begin, 
                                                              const char (&value)[n]) noexcept
{
    return {{ std::forward<Begin>(begin.list), value }};
}

typedef std::ostream& (*PfnManipulator)(std::ostream&);

template<typename Begin>
constexpr LogData<std::pair<Begin&&, PfnManipulator>> operator<<(LogData<Begin>&& begin, 
                                                                 PfnManipulator value) noexcept
{
    return {{ std::forward<Begin>(begin.list), value }};
}

template <typename Begin, typename Last>
void output(std::ostream& os, std::pair<Begin, Last>&& data)
{
    output(os, std::move(data.first));
    os << data.second;
}

inline void output(std::ostream& os, None)
{ }

如Cato所指出的那样，与上一个解决方案相比，它的好处在于由于const char*专业化处理所有字符串文字，因此会导致更少的函数实例化。 它还会在调用现场生成较少的指令：

movb  $0, (%rsp)
movl  $.L_2__STRING.4, %ecx
movl  $.L_2__STRING.3, %edi
movl  $20, %esi
lea   212(%rsp), %r9
call  void Log<pair<pair<pair<pair<None, char const*>, string const&>, char const*>, int const&> >(char const*, int, LogData<pair<pair<pair<pair<None, char const*>, string const&>, char const*>, int const&> > const&)

请告诉我如果您能想到任何方法来提高此解决方案的性能或可用性。

- Marc Eaddy

---

我不太明白为什么要使用临时stringstream。为什么不用#define LOG(msg) std::cout << __FILE__ << '(' << __LINE__ << '(' << msg << std::endl？为什么需要flush（转换为lvalue应该是不必要的）？为什么要使用static_cast而不是std::move？ - dyp

如果你想保留<<运算符，但由于某种原因需要调用一个函数来累加参数，则可以使用表达式模板：#define LOG(msg) log_impl( my_expression_templ_start() << msg )（其中my_expression_templ_start是带有重载operator<<的结构体）。 - dyp

因为 ostringstream 是一个 ostream，所以我不明白在 ostringstream 上递归应用 << 如何降低代码复杂度。 - jxh

我认为从Log_Recursive中获取的__LINE__不是非常有用。请参考此答案以了解如何混合可变参数宏和可变参数模板的提示；您需要一个宏在正确的时间扩展__LINE__。 - DanielKO

我同意printf通常更易于阅读，但与流不同，printf不是类型安全的，并且需要将用户定义的类型转换为中间字符串。 - Marc Eaddy

Answer 1

这里有另一个表达式模板，根据我运行的一些测试似乎更有效率。特别地，通过将operator<<专门化为使用结果结构中的char *成员，避免了为不同长度的字符串创建多个函数。这种形式的其他专门化也应该很容易添加。

struct None { };

template <typename First,typename Second>
struct Pair {
  First first;
  Second second;
};

template <typename List>
struct LogData {
  List list;
};

template <typename Begin,typename Value>
LogData<Pair<Begin,const Value &>>
  operator<<(LogData<Begin> begin,const Value &value)
{
  return {{begin.list,value}};
}

template <typename Begin,size_t n>
LogData<Pair<Begin,const char *>>
  operator<<(LogData<Begin> begin,const char (&value)[n])
{
  return {{begin.list,value}};
}

inline void printList(std::ostream &os,None)
{
}


template <typename Begin,typename Last>
void printList(std::ostream &os,const Pair<Begin,Last> &data)
{
  printList(os,data.first);
  os << data.second;
}

template <typename List>
void log(const char *file,int line,const LogData<List> &data)
{
  std::cout << file << " (" << line << "): ";
  printList(std::cout,data.list);
  std::cout << "\n";
}

#define LOG(x) (log(__FILE__,__LINE__,LogData<None>() << x))

使用 G++ 4.7.2 编译器，开启 -O2 优化选项后，这将会生成一个非常紧凑的指令序列，等效于使用 char * 来填充包含参数的结构体中的字符串字面量。

- Vaughn Cato

---

这比我的原始解决方案简单得多，导致更少的函数实例化，并在调用现场生成更少的指令。我将其添加到我的原始问题末尾，并修改以支持流操作符。 - Marc Eaddy

Answer 2

我经历了完全相同的事情。最终，我采用了你概述的同样解决方案，只需要客户端API使用逗号而不是插入运算符即可。这使得事情保持相当简单，并且足够好用。强烈推荐。

- John Zwinck

---

我添加了一种替代的表达式模板解决方案，它允许您使用流运算符而不产生任何成本。请随意尝试！ - Marc Eaddy