Add some benchmarks with unicode characters

libtermbench/termbench.cpp

@@ -419,6 +419,45 @@ std::unique_ptr<Test> sgrbg_line(size_t N)
     return std::make_unique<Line>(name, text);
 }
 
+std::unique_ptr<Test> unicode(size_t N)
+{
+    auto name = std::to_string(N) + " unicode";
+    std::string text {};
+    for(size_t i=0;i<N;++i)
+        text += std::string{"\u0041"};
+    text += std::string { "\n" };
+    return std::make_unique<Line>(name, text);
+}
+
+std::unique_ptr<Test> unicode_fire(size_t N)
+{
+    auto name = std::to_string(N) + " unicode fire";
+    std::string text {};
+    for(size_t i=0;i<N;++i)
+        text += std::string{"\U0001F525"};
+    text += std::string { "\n" };
+    return std::make_unique<Line>(name, text);
+}
+
+std::unique_ptr<Test> unicode_flag(size_t N)
+{
+    auto name = std::to_string(N) + " unicode flag";
+    std::string text {};
+    std::string flag{};
+    flag += std::string{"\U0001F3F4"};
+    flag += std::string{"\U000E0067"};
+    flag += std::string{"\U000E0062"};
+    flag += std::string{"\U000E0065"};
+    flag += std::string{"\U000E006E"};
+    flag += std::string{"\U000E0067"};
+    flag += std::string{"\U000E007F"};
+
+    for(size_t i=0;i<N;++i)
+        text += flag;
+    text += std::string { "\n" };
+    return std::make_unique<Line>(name, text);
+}
+
 std::unique_ptr<Test> crafted(std::string name, std::string description, std::string text)
 {
     return std::make_unique<CraftedTest>(std::move(name), std::move(description), std::move(text));

libtermbench/termbench.h

@@ -127,5 +127,8 @@ std::unique_ptr<Test> binary();
 std::unique_ptr<Test> ascii_line(size_t);
 std::unique_ptr<Test> sgr_line(size_t);
 std::unique_ptr<Test> sgrbg_line(size_t);
+std::unique_ptr<Test> unicode(size_t);
+std::unique_ptr<Test> unicode_fire(size_t);
+std::unique_ptr<Test> unicode_flag(size_t);
 std::unique_ptr<Test> crafted(std::string name, std::string description, std::string text);
 } // namespace termbench::tests

scripts/plot_results.jl

@@ -12,11 +12,17 @@ end
 
 function get_data(data, data_type)
     if data_type == :ascii
-        name = "chars per line"
+        name = "chars per line:"
     elseif data_type == :sgr
-        name = "chars with sgr per line"
+        name = "chars with sgr per line:"
     elseif data_type == :sgr_bg
-        name = "chars with sgr and bg per line"
+        name = "chars with sgr and bg per line:"
+    elseif data_type == :unicode
+        name = "unicode:"
+    elseif data_type == :fire
+        name = "unicode fire:"
+    elseif data_type == :flag
+        name = "unicode flag:"
     end
 
     lines = []
@@ -47,15 +53,15 @@ function generate_for_terminal(file_name)
     data = split(open(io->read(io, String), file_name), '\n')
     terminal_name = split(file_name,"_")[1]
 
+    markers = [:circle :rect :cross  :star4   :start5 :star6]
+
     get_data_l = (type) -> get_data(data,type)
-    ascii_speed = get_data_l(:ascii)
-    sgr_speed = get_data_l(:sgr)
-    sgr_bg_speed = get_data_l(:sgr_bg)
+    speed = [ get_data_l(t) for t in types]
 
     marker_size = 8
-    scatter!(ax,ascii_speed, label= terminal_name * "_ascii", marker = :circle, markersize = marker_size)
-    scatter!(ax,sgr_speed, label=terminal_name*"_sgr", marker = :rect, markersize = marker_size)
-    scatter!(ax,sgr_bg_speed, label=terminal_name*"_sgr_and_bg", marker = :cross, markersize = marker_size)
+    for (ind,dat) in enumerate(speed)
+        scatter!(ax,dat, label= terminal_name * "_" * string(types[ind]), marker = markers[ind], markersize = marker_size)
+    end
     axislegend(position = :rt)
 
     save("results_"*terminal_name*".png", fig)
@@ -74,12 +80,11 @@ function generate_comparison(type)
 end
 
 
+types =   [:ascii  :sgr  :sgr_bg :unicode :fire   :flag]
 generate_for_terminal("contour_results")
 generate_for_terminal("alacritty_results")
 generate_for_terminal("xterm_results")
 generate_for_terminal("kitty_results")
 
 
-save("comparison_ascii.png", generate_comparison(:ascii))
-save("comparison_sgr.png", generate_comparison(:sgr))
-save("comparison_sgr_bg.png", generate_comparison(:sgr_bg))
+[ save("comparison"*string(type)*".png", generate_comparison(type) for type in types)

tb/main.cpp

@@ -121,7 +121,7 @@ BenchSettings parseArguments(int argc, char const* argv[], TerminalSize const& i
         }
         else if (argv[i] == "--fixed-size"sv)
         {
-            settings.requestedTerminalSize.columns = 200;
+            settings.requestedTerminalSize.columns = 100;
             settings.requestedTerminalSize.lines = 30;
         }
         else if (argv[i] == "--stdout-fastpath"sv)
@@ -189,11 +189,13 @@ std::string loadFileContents(std::filesystem::path const& path)
 
 bool addTestsToBenchmark(termbench::Benchmark& tb, BenchSettings const& settings)
 {
+    /*
     tb.add(termbench::tests::many_lines());
     tb.add(termbench::tests::long_lines());
     tb.add(termbench::tests::sgr_fg_lines());
     tb.add(termbench::tests::sgr_fgbg_lines());
     tb.add(termbench::tests::binary());
+    */
     // TODO: The above tests should also be configurable via command line (-mlfgb).
 
     for (auto const& test: settings.craftedTests)
@@ -212,12 +214,17 @@ bool addTestsToBenchmark(termbench::Benchmark& tb, BenchSettings const& settings
         auto const maxColumns { settings.requestedTerminalSize.columns * 2u };
         for (size_t i = 0; i < maxColumns; ++i)
             tb.add(termbench::tests::ascii_line(i));
+        for (size_t i = 0; i < maxColumns; ++i)
+            tb.add(termbench::tests::unicode(i));
+        for (size_t i = 0; i < maxColumns; ++i)
+            tb.add(termbench::tests::unicode_fire(i));
+        for (size_t i = 0; i < maxColumns; ++i)
+            tb.add(termbench::tests::unicode_flag(i));
         for (size_t i = 0; i < maxColumns; ++i)
             tb.add(termbench::tests::sgr_line(i));
         for (size_t i = 0; i < maxColumns; ++i)
             tb.add(termbench::tests::sgrbg_line(i));
     }
-
     return true;
 }