std::cout << tab really slow?

[nickhuangxinyu]

Hi, tabulate is very beatiful.

but compare with plain cout, it seems much slower.

my plain cout cost 0.002s but after i use tabulate, it cost 0.05 about 25 times comparing with plain.

Is there any method to speed up?

ps. i always use tabulate to show a stl map.
using table, add key row and column row, set some show style.

Did i miss anything?

thanks

ps. this is my show code:

#pragma once
#include <unordered_map>
#include <iomanip>
#include <locale>
#include <iostream>
#include <tabulate.hpp>

namespace util {
  namespace visual {
    template<class Key>
    std::vector<std::string> unfold(const std::pair<const Key, std::string>& p) {
      std::stringstream key_stream, val_stream;
      std::locale loc("C");
      key_stream.imbue(loc); val_stream.imbue(loc);
      const Key& key = p.first; const std::string& val = p.second;
      key_stream << key;
      val_stream << val;
      return {key_stream.str(), val_stream.str()};
    }

    template<class Key, class Value>
    std::vector<std::string> unfold(const std::pair<const Key, Value>& p) {
      std::stringstream key_stream, val_stream;
      std::locale loc("C");
      key_stream.imbue(loc); val_stream.imbue(loc);
      const Key& key = p.first; const Value& val = p.second;
      // printf("key = %d, val = %d\n", std::is_same<typename std::decay<Key>::type, std::string>::value, std::is_same<typename std::decay<Value>::type, std::string>::value);
      key_stream << key;
      if (val > 10 || val < -10) val_stream << (int64_t)val;
      else val_stream << std::fixed << std::setprecision(2) << val;
      return {key_stream.str(), val_stream.str()};
    }

    inline std::vector<std::string> unfold(const std::string & val) { return {val}; }

    template<typename T>
    void show(const T &m, const std::string& color="", const std::string& header = "") {
      std::cout.sync_with_stdio(false);
      std::cin.tie(nullptr);
      if (m.empty()) return;
      tabulate::Table tab;
      std::vector<std::vector<variant<std::string, const char *, tabulate::Table> > > vals;
      vals.resize(2);
      size_t count_ = 0;
      for (const auto & i : m) {
        const auto & j = unfold(i);
        size_t count = 0;
      for (const auto & i : m) {
        const auto & j = unfold(i);
        size_t count = 0;
        for (const auto& k : j) { /*printf("count=%d k=%s\n", count, k.c_str());*/ vals[count++].push_back(k); }
        count_ = count;
      }
      for (size_t i = 0 ; i < count_; ++i) tab.add_row(vals[i]);
      for (size_t i = 0; i < m.size(); ++i) {
        if (color == "red") tab[0][i].format().font_color(tabulate::Color::red).font_align(tabulate::FontAlign::center).font_style({tabulate::FontStyle::bold});
        else if (color == "green") tab[0][i].format().font_color(tabulate::Color::green).font_align(tabulate::FontAlign::center).font_style({tabulate::FontStyle::bold});
        else if (color == "yellow") tab[0][i].format().font_color(tabulate::Color::yellow).font_align(tabulate::FontAlign::center).font_style({tabulate::FontStyle::bold});
        else if (color == "blue") tab[0][i].format().font_color(tabulate::Color::blue).font_align(tabulate::FontAlign::center).font_style({tabulate::FontStyle::bold});
        else if (color == "magenta") tab[0][i].format().font_color(tabulate::Color::magenta).font_align(tabulate::FontAlign::center).font_style({tabulate::FontStyle::bold});
        else if (color == "cyan") tab[0][i].format().font_color(tabulate::Color::cyan).font_align(tabulate::FontAlign::center).font_style({tabulate::FontStyle::bold});
        else tab[0][i].format().font_align(tabulate::FontAlign::center).font_style({tabulate::FontStyle::bold});
      }
      if (vals.size() > 1) {
        auto & columns = tab.row(0);
        size_t count = 0;
        for (auto& c: columns) {
          const std::string& col = c.get_text();
          if (col.find("PNL") != std::string::npos) tab.column(count).format().width(12);
          if (col.find("MAX") != std::string::npos) tab.column(count).format().width(10);
          count++;
        }
      }
      for (size_t i = 0; i < m.size(); ++i) tab.column(i).format().font_align(tabulate::FontAlign::center);
      if (!header.empty()) std::cout << header << std::endl;
      std::cout << tab << std::endl;
    }
  }
}
 

[seanmamasde]

yeah it's really slow in my experience, if you're dealing with large amount of rows you can literally see the console output being produced, as standard output finished printing everything in one go. I am going to try texttable to see if that mitigates the problem.