aorefkov
/
simstr
mirror of https://github.com/orefkov/simstr.git
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
simstr/bench/results.html

4402 lines
298 KiB
HTML
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

<html>
<head>
<meta charset="UTF-8" />
<link href="results.css" rel="stylesheet" />
<title>SimStr benchmarks results</title>
<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.9.0/styles/default.min.css">
<script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.9.0/highlight.min.js"></script>
<script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
<script>
let bench_sets = {};
let activeBuilder = buildTestsByPlatformsBar;
let buildAsLine = {
"Copy not literal Str with N symbols": "Length of the copied string",
"Replace All Str To Longer Size": "Length of the string to be replaced",
"Replace All Str To Same Size": "Length of the string to be replaced"
};
function hl() {
document.querySelectorAll('.tooltiptext.code').forEach((el) => {
hljs.highlightElement(el);
});
}
function addBarChart(id, data) {
let canvas = document.getElementById('chart' + id);
new Chart(canvas, {
type: 'bar',
data: data,
options: {
scales: {
y: {
beginAtZero: true
},
x: {
title: {
text: "Time (ns)",
display: true
}
}
},
indexAxis: 'y',
plugins: {
legend: {
position: 'right',
labels: {
font: {
family: "'Cascadia Code', Consolas, 'Courier New', Courier, monospace"
}
}
}
}
}
});
}
function platformChecked(idx) {
return document.getElementById('pl' + idx).checked;
}
function buildPlatformsByTestsBar(bsName) {
if (buildAsLine[bsName]) {
buildPlatformsByTestsLine(bsName, buildAsLine[bsName]);
return;
}
let data = { labels: [], datasets: [] };
for (const i in platform_names) {
if (platformChecked(i))
data.datasets.push({ label: platform_names[i], data: [], borderWidth: 1 });
}
let bs = bench_sets[bsName];
for (const test of bs.tests) {
data.labels.push(test.name);
let ds = 0;
for (const i in test.data) {
if (platformChecked(i)) {
data.datasets[ds++].data.push(test.data[i]);
}
}
}
addBarChart(bs.id, data);
}
function buildTestsByPlatformsBar(bsName) {
if (buildAsLine[bsName], buildAsLine[bsName]) {
buildTestsByPlatformsLine(bsName, buildAsLine[bsName]);
return;
}
let data = { labels: [], datasets: [] };
let bs = bench_sets[bsName];
for (const test of bs.tests) {
data.datasets.push({ label: test.name, data: [], borderWidth: 1 });
}
for (const i in platform_names) {
if (platformChecked(i)) {
data.labels.push(platform_names[i]);
for (const j in bs.tests) {
data.datasets[j].data.push(bs.tests[j].data[i]);
}
}
}
addBarChart(bs.id, data);
}
function buildCanvas(plCount) {
document.querySelectorAll("canvas.bench_chart").forEach(e => e.remove());
for (var bs_name in bench_sets) {
let bs = bench_sets[bs_name];
if (plCount) {
let canvas = document.createElement('canvas');
canvas.id = "chart" + bs.id;
canvas.classList.add('bench_chart');
let h = 20 * plCount * bs.tests.length;
canvas.style.width = "100%";
canvas.style.height = h + "px";
canvas.height = h * devicePixelRatio;
document.getElementById(bs.id).after(canvas);
}
}
}
function addLineChart(canvas, data, title, scaleTitle) {
new Chart(canvas, {
type: 'line',
data: data,
options: {
scales: {
y: {
beginAtZero: true,
title: {
text: scaleTitle,
display: true
}
},
x: {
title: {
text: "Time (ns)",
display: true
}
}
},
indexAxis: 'y',
plugins: {
title: {
display: true,
text: title,
},
legend: {
position: 'right',
labels: {
font: {
family: "'Cascadia Code', Consolas, 'Courier New', Courier, monospace"
}
}
}
}
}
});
}
function buildTestsByPlatformsLineOne(bs, canvas, plIdx, scaleTitle) {
let data = { datasets: [] };
let prevTest = '';
let curData = undefined;
for (const test of bs.tests) {
let m = test.name.match(/(.+)[\/\|](\d+)$/);
if (m[1] != prevTest) {
prevTest = m[1];
curData = { label: prevTest, data: [], borderWidth: 1 };
data.datasets.push(curData);
}
curData.data.push([test.data[plIdx], m[2]]);
}
addLineChart(canvas, data, platform_names[plIdx], scaleTitle);
}
function buildTestsByPlatformsLine(bsName, scaleTitle) {
let bs = bench_sets[bsName];
let canvas = document.getElementById('chart' + bs.id);
let after = null;
for (const i in platform_names) {
if (platformChecked(i)) {
if (!canvas) {
canvas = document.createElement('canvas');
canvas.classList.add('bench_chart');
canvas.style.width = "100%";
after.after(canvas);
}
canvas.style.height = "300px";
canvas.height = 300 * devicePixelRatio;
buildTestsByPlatformsLineOne(bs, canvas, i, scaleTitle);
after = canvas;
canvas = null;
}
}
}
function buildPlatformsByTestsLineOne(bs, canvas, after, testData, title, scaleTitle) {
let data = { datasets: [] };
for (const i in platform_names) {
if (platformChecked(i)) {
ds = {label: platform_names[i], data: []};
for (const test of testData) {
ds.data.push([test.data[i], test.count]);
}
data.datasets.push(ds);
}
}
if (!canvas) {
canvas = document.createElement('canvas');
canvas.classList.add('bench_chart');
canvas.style.width = "100%";
after.after(canvas);
}
canvas.style.height = "300px";
canvas.height = 300 * devicePixelRatio;
addLineChart(canvas, data, title, scaleTitle);
return canvas;
}
function buildPlatformsByTestsLine(bsName, scaleTitle) {
let bs = bench_sets[bsName];
let canvas = document.getElementById('chart' + bs.id);
let after = null;
let data = [];
let prevTest = '';
for (const test of bs.tests) {
let m = test.name.match(/(.+)[\/\|](\d+)$/);
if (m[1] != prevTest) {
if (data.length) {
after = buildPlatformsByTestsLineOne(bs, canvas, after, data, prevTest, scaleTitle);
canvas = null;
}
prevTest = m[1];
data = [];
}
data.push({count: m[2], data: test.data});
}
if (data.length) {
buildPlatformsByTestsLineOne(bs, canvas, after, data, prevTest, scaleTitle);
}
}
function buildCharts() {
let plCount = 0;
for (const i in platform_names) {
if (platformChecked(i))
plCount++;
}
buildCanvas(plCount);
for (var bs_name in bench_sets) {
activeBuilder(bs_name);
}
}
function switchGrouping() {
activeBuilder = document.getElementById('gbp').checked ? buildTestsByPlatformsBar : buildPlatformsByTestsBar;
buildCharts();
}
document.addEventListener('DOMContentLoaded', (event) => {
if (!hljs) {
let scriptTag = document.createElement('script');
scriptTag.src = "https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.9.0/highlight.min.js";
scriptTag.onload = hl;
scriptTag.onreadystatechange = hl;
document.body.appendChild(scriptTag);
} else {
hl();
}
if (!Chart) {
let scriptTag = document.createElement('script');
scriptTag.src = "https://cdn.jsdelivr.net/npm/chart.js";
scriptTag.onload = buildCharts;
scriptTag.onreadystatechange = buildCharts;
document.body.appendChild(scriptTag);
} else {
buildCharts();
}
});
</script>
</head><body><div class="header"><h2>simstr benchmarks results</h2>
<div style="font-size:16pt;margin:20px;text-align:center"><a href="https://github.com/orefkov/simstr">simstr</a> is a powerful and convenient library for productive work with strings in C++.</div>
<span>All times in ns.</span>
<span><a href="https://github.com/orefkov/simstr/blob/main/bench/bench_str.cpp">Source for benchmarks</a></span>
<div>Group tests by platforms in charts: <input type="checkbox" id="gbp" checked onchange="switchGrouping()"/></div><div class="test_platforms"><h3>Test configurations:</h3><ul>
<li><span class="platform">Xeon E5-2682 v4, Ubuntu 22 (WSL), Clang-21</span><span class="tooltip">32 X 2494.22 MHz CPU s<span class="tooltiptext">CPU Caches:
L1 Data 32 KiB (x16)
L1 Instruction 32 KiB (x16)
L2 Unified 256 KiB (x16)
L3 Unified 40960 KiB (x1)
Load Average: 0.31, 0.73, 0.52
***WARNING*** ASLR is enabled, the results may have unreproducible noise in them.</span></span>&nbsp;Include in charts: <input type="checkbox" id="pl0" checked onchange="buildCharts()"/></li>
<li><span class="platform">Xeon E5-2682 v4, Ubuntu 22 (WSL), GCC-13</span><span class="tooltip">32 X 2494.22 MHz CPU s<span class="tooltiptext">CPU Caches:
L1 Data 32 KiB (x16)
L1 Instruction 32 KiB (x16)
L2 Unified 256 KiB (x16)
L3 Unified 40960 KiB (x1)
Load Average: 0.00, 0.00, 0.00
***WARNING*** ASLR is enabled, the results may have unreproducible noise in them.</span></span>&nbsp;Include in charts: <input type="checkbox" id="pl1" checked onchange="buildCharts()"/></li>
<li><span class="platform">Xeon E5-2682 v4, Windows 10, Clang-19</span><span class="tooltip">32 X 2494 MHz CPU s<span class="tooltiptext">CPU Caches:
L1 Data 32 KiB (x16)
L1 Instruction 32 KiB (x16)
L2 Unified 256 KiB (x16)
L3 Unified 40960 KiB (x1)</span></span>&nbsp;Include in charts: <input type="checkbox" id="pl2" checked onchange="buildCharts()"/></li>
<li><span class="platform">Xeon E5-2682 v4, Windows 10, MSVC-19</span><span class="tooltip">32 X 2494 MHz CPU s<span class="tooltiptext">CPU Caches:
L1 Data 32 KiB (x16)
L1 Instruction 32 KiB (x16)
L2 Unified 256 KiB (x16)
L3 Unified 40960 KiB (x1)</span></span>&nbsp;Include in charts: <input type="checkbox" id="pl3" checked onchange="buildCharts()"/></li>
<li><span class="platform">Xeon E5-2682 v4, WASM Chrome 143, Clang-21</span><span class="tooltip">32 X 2513.96 MHz CPU s<span class="tooltiptext">Chrome/143.0.0.0 webasm</span></span>&nbsp;Include in charts: <input type="checkbox" id="pl4" checked onchange="buildCharts()"/></li>
</ul></div></div>
<script>const platform_names=['Xeon E5-2682 v4, Ubuntu 22 (WSL), Clang-21','Xeon E5-2682 v4, Ubuntu 22 (WSL), GCC-13','Xeon E5-2682 v4, Windows 10, Clang-19','Xeon E5-2682 v4, Windows 10, MSVC-19','Xeon E5-2682 v4, WASM Chrome 143, Clang-21'];</script>
<div class="benchset" id="bs1"><h4><a id="bs15359472366966513900" href="#bs15359472366966513900">#</a>&nbsp;Concatenate email</h4>
<table><thead><tr><th>Benchmark name</th><th width="5%">Comment</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), Clang-21</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), GCC-13</th><th width="8%">Xeon E5-2682 v4, Windows 10, Clang-19</th><th width="8%">Xeon E5-2682 v4, Windows 10, MSVC-19</th><th width="8%">Xeon E5-2682 v4, WASM Chrome 143, Clang-21</th></tr></thead><tbody>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L94">Concat email std::format</a><span class="tooltiptext code">std::string email_concat_format(std::string_view name, std::string_view domain, std::string_view tld) {
return std::format(&quot;{}@{}.{}&quot;, name, domain, tld);
}</span></span></td><td></td><td class="benchmarkresult">167</td><td class="benchmarkresult">176</td><td class="benchmarkresult">210</td><td class="benchmarkresult">254</td><td class="benchmarkresult">529</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L109">Concat email std::stringstream</a><span class="tooltiptext code">std::string email_concat_stream(std::string_view name, std::string_view domain, std::string_view tld) {
std::stringstream s;
s &lt;&lt; name &lt;&lt; &quot;@&quot; &lt;&lt; domain &lt;&lt; &quot;.&quot; &lt;&lt; tld;
return s.str();
}</span></span></td><td></td><td class="benchmarkresult">324</td><td class="benchmarkresult">332</td><td class="benchmarkresult">856</td><td class="benchmarkresult">934</td><td class="benchmarkresult">1155</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L60">Concat email stringzilla append</a><span class="tooltiptext code">sz::string email_concat_stringzilla_app(sz::string name, sz::string_view domain, sz::string_view tld) {
return name.append(&quot;@&quot;).append(domain).append(&quot;.&quot;).append(tld);
}</span></span></td><td></td><td class="benchmarkresult">135</td><td class="benchmarkresult">115</td><td class="benchmarkresult">271</td><td class="benchmarkresult">268</td><td class="benchmarkresult">249</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L77">Concat email stringzilla concat</a><span class="tooltiptext code">sz::string email_concat_stringzilla_exp(sz::string name, sz::string_view domain, sz::string_view tld) {
return sz::string{name | sz::string_view{&quot;@&quot;} | domain | sz::string_view{&quot;.&quot;} | tld};
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">В stringzilla тоже есть конкатенация строковыми выражениями, но не
так удобна и развита, как в simstr.
Stringzilla also has concatenation by expression templates,
but it's not as convenient or advanced as simstr.</span></span></td><td class="benchmarkresult">53.5</td><td class="benchmarkresult">46.6</td><td class="benchmarkresult">128</td><td class="benchmarkresult">129</td><td class="benchmarkresult">95.2</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L126">Concat email std::string append</a><span class="tooltiptext code">std::string email_concat_std(std::string name, std::string_view domain, std::string_view tld) {
return name.append(&quot;@&quot;).append(domain).append(&quot;.&quot;).append(tld);
}</span></span></td><td></td><td class="benchmarkresult">72.9</td><td class="benchmarkresult">99.0</td><td class="benchmarkresult">187</td><td class="benchmarkresult">197</td><td class="benchmarkresult">324</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L142">Concat email std::string by strexpr</a><span class="tooltiptext code">std::string email_concat_std_expr(std::string_view name, std::string_view domain, std::string_view tld) {
return +name + &quot;@&quot; + domain + &quot;.&quot; + tld;
}</span></span></td><td></td><td class="benchmarkresult">43.5</td><td class="benchmarkresult">35.6</td><td class="benchmarkresult">107</td><td class="benchmarkresult">110</td><td class="benchmarkresult">92.7</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L157">Concat email stringa</a><span class="tooltiptext code">stringa email_concat_sim_expr(ssa name, ssa domain, ssa tld) {
return name + &quot;@&quot; + domain + &quot;.&quot; + tld;
}</span></span></td><td></td><td class="benchmarkresult">39.4</td><td class="benchmarkresult">40.5</td><td class="benchmarkresult">93.1</td><td class="benchmarkresult">99.5</td><td class="benchmarkresult">71.3</td></tr>
</tbody></table></div><script>bench_sets['Concatenate email'] = {id:'bs1', tests:[
{name:'Concat email std::format',data:[167,176,210,254,529]},
{name:'Concat email std::stringstream',data:[324,332,856,934,1155]},
{name:'Concat email stringzilla append',data:[135,115,271,268,249]},
{name:'Concat email stringzilla concat',data:[53.5,46.6,128,129,95.2]},
{name:'Concat email std::string append',data:[72.9,99.0,187,197,324]},
{name:'Concat email std::string by strexpr',data:[43.5,35.6,107,110,92.7]},
{name:'Concat email stringa',data:[39.4,40.5,93.1,99.5,71.3]}
]}</script>
<div class="benchset" id="bs2"><h4><a id="bs70109915512075798510" href="#bs70109915512075798510">#</a>&nbsp;Concatenate string + Number + &quot;Literal&quot;</h4>
<table><thead><tr><th>Benchmark name</th><th width="5%">Comment</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), Clang-21</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), GCC-13</th><th width="8%">Xeon E5-2682 v4, Windows 10, Clang-19</th><th width="8%">Xeon E5-2682 v4, Windows 10, MSVC-19</th><th width="8%">Xeon E5-2682 v4, WASM Chrome 143, Clang-21</th></tr></thead><tbody>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L181">Concat std::string and number by std to std::string</a><span class="tooltiptext code">void ConcatStdToStd(benchmark::State&amp; state) {
std::string s1 = &quot;start &quot;;
for (auto _: state) {
for (int i = 1; i &lt;= 100&#39;000; i *= 10) {
benchmark::DoNotOptimize(s1);
std::string str = s1 + std::to_string(i) + &quot; end&quot;;
benchmark::DoNotOptimize(str);
}
}
}</span></span></td><td></td><td class="benchmarkresult">214</td><td class="benchmarkresult">209</td><td class="benchmarkresult">264</td><td class="benchmarkresult">337</td><td class="benchmarkresult">1115</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L192">Concat std::string and number by StrExpr to std::string</a><span class="tooltiptext code">void ConcatSimToStd(benchmark::State&amp; state) {
std::string s1 = &quot;start &quot;;
for (auto _: state) {
for (int i = 1; i &lt;= 100&#39;000; i *= 10) {
benchmark::DoNotOptimize(s1);
std::string str = +s1 + i + &quot; end&quot;;
benchmark::DoNotOptimize(str);
}
}
}</span></span></td><td></td><td class="benchmarkresult">104</td><td class="benchmarkresult">98.1</td><td class="benchmarkresult">156</td><td class="benchmarkresult">219</td><td class="benchmarkresult">530</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L203">Concat stringa and number by StrExpr to simstr::stringa</a><span class="tooltiptext code">void ConcatSimToSim(benchmark::State&amp; state) {
stra s1 = &quot;start &quot;;
for (auto _: state) {
for (int i = 1; i &lt;= 100&#39;000; i *= 10) {
benchmark::DoNotOptimize(s1);
stringa str = s1 + i + &quot; end&quot;;
benchmark::DoNotOptimize(str);
}
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">stringa в отличии от std::string,
вмещает в SSO 23 символа вместо 15, поэтому
в конце теста std::string приходится аллоцировать память,
а в stringa весь тест входит в SSO.
Unlike std::string, stringa
holds 23 characters in SSO instead of 15, so
at the end of the std::string test, memory has to be allocated,
while in stringa , the entire test is included in SSO.</span></span></td><td class="benchmarkresult">67.7</td><td class="benchmarkresult">73.0</td><td class="benchmarkresult">69.1</td><td class="benchmarkresult">111</td><td class="benchmarkresult">227</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L214">Concat stringa and number by e_concat to simstr::stringa</a><span class="tooltiptext code">void ConcatSimToSimConcat(benchmark::State&amp; state) {
stra s1 = &quot;start &quot;;
for (auto _: state) {
for (int i = 1; i &lt;= 100&#39;000; i *= 10) {
benchmark::DoNotOptimize(s1);
stringa str = e_concat(&quot;&quot;, s1, i, &quot; end&quot;);
benchmark::DoNotOptimize(str);
}
}
}</span></span></td><td></td><td class="benchmarkresult">70.8</td><td class="benchmarkresult">79.7</td><td class="benchmarkresult">74.9</td><td class="benchmarkresult">116</td><td class="benchmarkresult">258</td></tr>
</tbody></table></div><script>bench_sets['Concatenate string + Number + "Literal"'] = {id:'bs2', tests:[
{name:'Concat std::string and number by std to std::string',data:[214,209,264,337,1115]},
{name:'Concat std::string and number by StrExpr to std::string',data:[104,98.1,156,219,530]},
{name:'Concat stringa and number by StrExpr to simstr::stringa',data:[67.7,73.0,69.1,111,227]},
{name:'Concat stringa and number by e_concat to simstr::stringa',data:[70.8,79.7,74.9,116,258]}
]}</script>
<div class="benchset" id="bs3"><h4><a id="bs146911715078927772520" href="#bs146911715078927772520">#</a>&nbsp;Concatenate string + Hex Number + &quot;Literal&quot;</h4>
<table><thead><tr><th>Benchmark name</th><th width="5%">Comment</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), Clang-21</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), GCC-13</th><th width="8%">Xeon E5-2682 v4, Windows 10, Clang-19</th><th width="8%">Xeon E5-2682 v4, Windows 10, MSVC-19</th><th width="8%">Xeon E5-2682 v4, WASM Chrome 143, Clang-21</th></tr></thead><tbody>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L231">Concat std::string and format hex number and literal to std::string</a><span class="tooltiptext code">void ConcatStdToFmtHex(benchmark::State&amp; state) {
// We use a short string so that the longest result is 15 characters and fits in the std::string SSO buffer.
std::string s1 = &quot;art &quot;;
for (auto _: state) {
for (unsigned i = 1; i &lt;= 100&#39;000; i *= 10) {
benchmark::DoNotOptimize(s1);
// It is not worked for char8_t, char16_t, char32_t :(
std::string str = s1 + std::format(&quot;{:#x}&quot;, i) + &quot; end&quot;;
benchmark::DoNotOptimize(str);
}
}
}</span></span></td><td></td><td class="benchmarkresult">689</td><td class="benchmarkresult">746</td><td class="benchmarkresult">715</td><td class="benchmarkresult">1043</td><td class="benchmarkresult">2114</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L244">std::format std::string and hex number by literal to std::string</a><span class="tooltiptext code">void ConcatAllFmtToHex(benchmark::State&amp; state) {
// We use a short string so that the longest result is 15 characters and fits in the std::string SSO buffer.
std::string s1 = &quot;art &quot;;
for (auto _: state) {
for (unsigned i = 1; i &lt;= 100&#39;000; i *= 10) {
benchmark::DoNotOptimize(s1);
// It is not worked for char8_t, char16_t, char32_t :(
std::string str = std::format(&quot;{}{:#x} end&quot;, s1, i);
benchmark::DoNotOptimize(str);
}
}
}</span></span></td><td></td><td class="benchmarkresult">889</td><td class="benchmarkresult">970</td><td class="benchmarkresult">1496</td><td class="benchmarkresult">1859</td><td class="benchmarkresult">2763</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L256">Concat std::string and std::to_chars and string to std::string</a><span class="tooltiptext code">void ConcatStdToCharsHex(benchmark::State&amp; state) {
// We use a short string so that the longest result is 15 characters and fits in the std::string SSO buffer.
std::string s1 = &quot;art &quot;;
for (auto _: state) {
for (unsigned i = 1; i &lt;= 100&#39;000; i *= 10) {
benchmark::DoNotOptimize(s1);
// it worked only for char :(
char buf[40];
size_t len = std::to_chars(buf, buf + std::size(buf), i, 16).ptr - buf;
std::string str = s1 + &quot;0x&quot; + std::string(buf, len) + &quot; end&quot;;
benchmark::DoNotOptimize(str);
}
}
}</span></span></td><td></td><td class="benchmarkresult">199</td><td class="benchmarkresult">254</td><td class="benchmarkresult">194</td><td class="benchmarkresult">256</td><td class="benchmarkresult">743</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L271">Concat std::string and hex number and literal by StrExpr to std::string</a><span class="tooltiptext code">void ConcatSimToStdHex(benchmark::State&amp; state) {
// We use a short string so that the longest result is 15 characters and fits in the std::string SSO buffer.
std::string s1 = &quot;art &quot;;
for (auto _: state) {
for (unsigned i = 1; i &lt;= 100&#39;000; i *= 10) {
benchmark::DoNotOptimize(s1);
// Can work for all types of symbols
std::string str = +s1 + i / 1_f16 + &quot; end&quot;;
benchmark::DoNotOptimize(str);
}
}
}</span></span></td><td></td><td class="benchmarkresult">134</td><td class="benchmarkresult">126</td><td class="benchmarkresult">89.2</td><td class="benchmarkresult">136</td><td class="benchmarkresult">547</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L284">Concat stringa and hex number and literal by StrExpr to simstr::stringa</a><span class="tooltiptext code">void ConcatSimToSimHex(benchmark::State&amp; state) {
// stringa SSO buffer is 23, but we use a short string to compare under the same conditions
stra s1 = &quot;art &quot;;
for (auto _: state) {
for (unsigned i = 1; i &lt;= 100&#39;000; i *= 10) {
benchmark::DoNotOptimize(s1);
// Can work for all types of symbols
stringa str = s1 + i / 1_f16 + &quot; end&quot;;
benchmark::DoNotOptimize(str);
}
}
}</span></span></td><td></td><td class="benchmarkresult">117</td><td class="benchmarkresult">120</td><td class="benchmarkresult">70.7</td><td class="benchmarkresult">105</td><td class="benchmarkresult">220</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L297">Concat stringa and hex number and literal by e_concat to simstr::stringa</a><span class="tooltiptext code">void ConcatSimToSimHexC(benchmark::State&amp; state) {
// stringa SSO buffer is 23, but we use a short string to compare under the same conditions
stra s1 = &quot;art &quot;;
for (auto _: state) {
for (unsigned i = 1; i &lt;= 100&#39;000; i *= 10) {
benchmark::DoNotOptimize(s1);
// Can work for all types of symbols
stringa str = e_concat(&quot;&quot;, s1, i / 1_f16, &quot; end&quot;);
benchmark::DoNotOptimize(str);
}
}
}</span></span></td><td></td><td class="benchmarkresult">123</td><td class="benchmarkresult">128</td><td class="benchmarkresult">77.7</td><td class="benchmarkresult">103</td><td class="benchmarkresult">211</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L310">Subst stringa and hex number by e_subst literal to simstr::stringa</a><span class="tooltiptext code">void ConcatSimToSimHexS(benchmark::State&amp; state) {
// stringa SSO buffer is 23, but we use a short string to compare under the same conditions
stra s1 = &quot;art &quot;;
for (auto _: state) {
for (unsigned i = 1; i &lt;= 100&#39;000; i *= 10) {
benchmark::DoNotOptimize(s1);
stringa str = e_subst(&quot;{}{} end&quot;, s1, i / 1_f16);
benchmark::DoNotOptimize(str);
}
}
}</span></span></td><td></td><td class="benchmarkresult">188</td><td class="benchmarkresult">169</td><td class="benchmarkresult">156</td><td class="benchmarkresult">176</td><td class="benchmarkresult">354</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L322">Subst stringa and hex number by e_vsubst stra to simstr::stringa</a><span class="tooltiptext code">void ConcatSimToSimHexVS(benchmark::State&amp; state) {
// stringa SSO buffer is 23, but we use a short string to compare under the same conditions
stra s1 = &quot;art &quot;;
for (auto _: state) {
for (unsigned i = 1; i &lt;= 100&#39;000; i *= 10) {
benchmark::DoNotOptimize(s1);
stringa str = e_vsubst(&quot;{}{} end&quot;_ss, s1, i / 1_f16);
benchmark::DoNotOptimize(str);
}
}
}</span></span></td><td></td><td class="benchmarkresult">310</td><td class="benchmarkresult">292</td><td class="benchmarkresult">291</td><td class="benchmarkresult">362</td><td class="benchmarkresult">936</td></tr>
</tbody></table></div><script>bench_sets['Concatenate string + Hex Number + "Literal"'] = {id:'bs3', tests:[
{name:'Concat std::string and format hex number and literal to std::string',data:[689,746,715,1043,2114]},
{name:'std::format std::string and hex number by literal to std::string',data:[889,970,1496,1859,2763]},
{name:'Concat std::string and std::to_chars and string to std::string',data:[199,254,194,256,743]},
{name:'Concat std::string and hex number and literal by StrExpr to std::string',data:[134,126,89.2,136,547]},
{name:'Concat stringa and hex number and literal by StrExpr to simstr::stringa',data:[117,120,70.7,105,220]},
{name:'Concat stringa and hex number and literal by e_concat to simstr::stringa',data:[123,128,77.7,103,211]},
{name:'Subst stringa and hex number by e_subst literal to simstr::stringa',data:[188,169,156,176,354]},
{name:'Subst stringa and hex number by e_vsubst stra to simstr::stringa',data:[310,292,291,362,936]}
]}</script>
<div class="benchset" id="bs4"><h4><a id="bs32341904136562619220" href="#bs32341904136562619220">#</a>&nbsp;format/vformat and subst/vsubst octal number to 32 symbols result</h4>
<table><thead><tr><th>Benchmark name</th><th width="5%">Comment</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), Clang-21</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), GCC-13</th><th width="8%">Xeon E5-2682 v4, Windows 10, Clang-19</th><th width="8%">Xeon E5-2682 v4, Windows 10, MSVC-19</th><th width="8%">Xeon E5-2682 v4, WASM Chrome 143, Clang-21</th></tr></thead><tbody>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L344">&quot;abcdefghihklmopqr &quot;_ss + i / 0x8a010_fmt + &quot; end&quot;</a><span class="tooltiptext code">void ConcatSimToSimOct(benchmark::State&amp; state) {
for (auto _: state) {
for (unsigned i = 1; i &lt;= 100&#39;000; i *= 10) {
stringa str = &quot;abcdefghihklmopqr &quot;_ss + i / 0x8a010_fmt + &quot; end&quot;;
benchmark::DoNotOptimize(str);
}
}
}</span></span></td><td></td><td class="benchmarkresult">277</td><td class="benchmarkresult">261</td><td class="benchmarkresult">685</td><td class="benchmarkresult">701</td><td class="benchmarkresult">434</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L353">e_subst(&quot;abcdefghihklmopqr {} end&quot;, i / 0x8a010_fmt)</a><span class="tooltiptext code">void SubstSimToSimOct(benchmark::State&amp; state) {
for (auto _: state) {
for (unsigned i = 1; i &lt;= 100&#39;000; i *= 10) {
stringa str = e_subst(&quot;abcdefghihklmopqr {} end&quot;, i / 0x8a010_fmt);
benchmark::DoNotOptimize(str);
}
}
}</span></span></td><td></td><td class="benchmarkresult">353</td><td class="benchmarkresult">320</td><td class="benchmarkresult">758</td><td class="benchmarkresult">798</td><td class="benchmarkresult">634</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L362">e_vsubst(pattern, i / 0x8a010_fmt)</a><span class="tooltiptext code">void VSubstSimToSimOct(benchmark::State&amp; state) {
ssa pattern = &quot;abcdefghihklmopqr {} end&quot;;
for (auto _: state) {
for (unsigned i = 1; i &lt;= 100&#39;000; i *= 10) {
stringa str = e_vsubst(pattern, i / 0x8a010_fmt);
benchmark::DoNotOptimize(str);
}
}
}</span></span></td><td></td><td class="benchmarkresult">615</td><td class="benchmarkresult">614</td><td class="benchmarkresult">1128</td><td class="benchmarkresult">1111</td><td class="benchmarkresult">1530</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L402">fmt::format(FMT_COMPILE(&quot;abcdefghihklmopqr {:#010o} end&quot;), i)</a><span class="tooltiptext code">void FmtFormatComp(benchmark::State&amp; state) {
for (auto _: state) {
for (unsigned i = 1; i &lt;= 100&#39;000; i *= 10) {
std::string str = fmt::format(FMT_COMPILE(&quot;abcdefghihklmopqr {:#010o} end&quot;), i);
benchmark::DoNotOptimize(str);
}
}
}</span></span></td><td></td><td class="benchmarkresult">685</td><td class="benchmarkresult">745</td><td class="benchmarkresult">1424</td><td class="benchmarkresult">1617</td><td class="benchmarkresult">2320</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L411">fmt::format(&quot;abcdefghihklmopqr {:#010o} end&quot;, i)</a><span class="tooltiptext code">void FmtFormat(benchmark::State&amp; state) {
for (auto _: state) {
for (unsigned i = 1; i &lt;= 100&#39;000; i *= 10) {
std::string str = fmt::format(&quot;abcdefghihklmopqr {:#010o} end&quot;, i);
benchmark::DoNotOptimize(str);
}
}
}</span></span></td><td></td><td class="benchmarkresult">854</td><td class="benchmarkresult">847</td><td class="benchmarkresult">1375</td><td class="benchmarkresult">1440</td><td class="benchmarkresult">3086</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L372">std::format(&quot;abcdefghihklmopqr {:#010o} end&quot;, i)</a><span class="tooltiptext code">void FormatStdToStdOct(benchmark::State&amp; state) {
for (auto _: state) {
for (unsigned i = 1; i &lt;= 100&#39;000; i *= 10) {
std::string str = std::format(&quot;abcdefghihklmopqr {:#010o} end&quot;, i);
benchmark::DoNotOptimize(str);
}
}
}</span></span></td><td></td><td class="benchmarkresult">1016</td><td class="benchmarkresult">1276</td><td class="benchmarkresult">1657</td><td class="benchmarkresult">1885</td><td class="benchmarkresult">3154</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L381">std::vformat(pattern, std::make_format_args(i))</a><span class="tooltiptext code">void VFormatStdToStdOct(benchmark::State&amp; state) {
std::string_view pattern = &quot;abcdefghihklmopqr {:#010o} end&quot;;
for (auto _: state) {
for (unsigned i = 1; i &lt;= 100&#39;000; i *= 10) {
std::string str = std::vformat(pattern, std::make_format_args(i));
benchmark::DoNotOptimize(str);
}
}
}</span></span></td><td></td><td class="benchmarkresult">1016</td><td class="benchmarkresult">1145</td><td class="benchmarkresult">1574</td><td class="benchmarkresult">1957</td><td class="benchmarkresult">3173</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L391">strm &lt;&lt; &quot;abcdefghihklmopqr 0&quot; &lt;&lt; std::oct &lt;&lt; std::setw(9) &lt;&lt; std::setfill(&#39;0&#39;) &lt;&lt; i &lt;&lt; &quot; end&quot;</a><span class="tooltiptext code">void StreamStdToStdOct(benchmark::State&amp; state) {
for (auto _: state) {
for (unsigned i = 1; i &lt;= 100&#39;000; i *= 10) {
std::stringstream strm;
strm &lt;&lt; &quot;abcdefghihklmopqr 0&quot; &lt;&lt; std::oct &lt;&lt; std::setw(9) &lt;&lt; std::setfill(&#39;0&#39;) &lt;&lt; i &lt;&lt; &quot; end&quot;;
std::string str = strm.str();
benchmark::DoNotOptimize(str);
}
}
}</span></span></td><td></td><td class="benchmarkresult">2057</td><td class="benchmarkresult">2189</td><td class="benchmarkresult">6773</td><td class="benchmarkresult">7169</td><td class="benchmarkresult">8797</td></tr>
</tbody></table></div><script>bench_sets['format/vformat and subst/vsubst octal number to 32 symbols result'] = {id:'bs4', tests:[
{name:'"abcdefghihklmopqr "_ss + i / 0x8a010_fmt + " end"',data:[277,261,685,701,434]},
{name:'e_subst("abcdefghihklmopqr {} end", i / 0x8a010_fmt)',data:[353,320,758,798,634]},
{name:'e_vsubst(pattern, i / 0x8a010_fmt)',data:[615,614,1128,1111,1530]},
{name:'fmt::format(FMT_COMPILE("abcdefghihklmopqr {:#010o} end"), i)',data:[685,745,1424,1617,2320]},
{name:'fmt::format("abcdefghihklmopqr {:#010o} end", i)',data:[854,847,1375,1440,3086]},
{name:'std::format("abcdefghihklmopqr {:#010o} end", i)',data:[1016,1276,1657,1885,3154]},
{name:'std::vformat(pattern, std::make_format_args(i))',data:[1016,1145,1574,1957,3173]},
{name:'strm << "abcdefghihklmopqr 0" << std::oct << std::setw(9) << std::setfill(\'0\') << i << " end"',data:[2057,2189,6773,7169,8797]}
]}</script>
<div class="benchset" id="bs5"><h4><a id="bs59672599204338055190" href="#bs59672599204338055190">#</a>&nbsp;Concatenate string + &quot;Literal&quot;</h4>
<table><thead><tr><th>Benchmark name</th><th width="5%">Comment</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), Clang-21</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), GCC-13</th><th width="8%">Xeon E5-2682 v4, Windows 10, Clang-19</th><th width="8%">Xeon E5-2682 v4, Windows 10, MSVC-19</th><th width="8%">Xeon E5-2682 v4, WASM Chrome 143, Clang-21</th></tr></thead><tbody>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L431">Concat std::string by std to std::string</a><span class="tooltiptext code">void ConcatStdToStdS(benchmark::State&amp; state) {
std::string s1 = &quot;start &quot;;
for (auto _: state) {
for (int i = 1; i &lt;= 100&#39;000; i *= 10) {
benchmark::DoNotOptimize(s1);
std::string str = s1 + &quot; end&quot;;
benchmark::DoNotOptimize(str);
}
}
}</span></span></td><td></td><td class="benchmarkresult">45.6</td><td class="benchmarkresult">49.4</td><td class="benchmarkresult">44.0</td><td class="benchmarkresult">59.3</td><td class="benchmarkresult">115</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L442">Concat std::string by StrExpr to std::string</a><span class="tooltiptext code">void ConcatSimToStdS(benchmark::State&amp; state) {
std::string s1 = &quot;start &quot;;
for (auto _: state) {
for (int i = 1; i &lt;= 100&#39;000; i *= 10) {
benchmark::DoNotOptimize(s1);
std::string str = +s1 + &quot; end&quot;;
benchmark::DoNotOptimize(str);
}
}
}</span></span></td><td></td><td class="benchmarkresult">32.2</td><td class="benchmarkresult">31.8</td><td class="benchmarkresult">39.2</td><td class="benchmarkresult">77.1</td><td class="benchmarkresult">128</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L453">Concat stringa by StrExpr to stringa</a><span class="tooltiptext code">void ConcatSimToSimS(benchmark::State&amp; state) {
stra s1 = &quot;start &quot;;
for (auto _: state) {
for (int i = 1; i &lt;= 100&#39;000; i *= 10) {
benchmark::DoNotOptimize(s1);
stringa str = s1 + &quot; end&quot;;
benchmark::DoNotOptimize(str);
}
}
}</span></span></td><td></td><td class="benchmarkresult">28.5</td><td class="benchmarkresult">27.9</td><td class="benchmarkresult">28.9</td><td class="benchmarkresult">51.4</td><td class="benchmarkresult">110</td></tr>
</tbody></table></div><script>bench_sets['Concatenate string + "Literal"'] = {id:'bs5', tests:[
{name:'Concat std::string by std to std::string',data:[45.6,49.4,44.0,59.3,115]},
{name:'Concat std::string by StrExpr to std::string',data:[32.2,31.8,39.2,77.1,128]},
{name:'Concat stringa by StrExpr to stringa',data:[28.5,27.9,28.9,51.4,110]}
]}</script>
<div class="benchset" id="bs6"><h4><a id="bs68116594352702954700" href="#bs68116594352702954700">#</a>&nbsp;Find three concatenated string in string_view</h4>
<table><thead><tr><th>Benchmark name</th><th width="5%">Comment</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), Clang-21</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), GCC-13</th><th width="8%">Xeon E5-2682 v4, Windows 10, Clang-19</th><th width="8%">Xeon E5-2682 v4, Windows 10, MSVC-19</th><th width="8%">Xeon E5-2682 v4, WASM Chrome 143, Clang-21</th></tr></thead><tbody>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L469">Find concat three std::string</a><span class="tooltiptext code">size_t find_pos_str(std::string_view src, std::string_view name) {
// before C++26 we can not concatenate string and string_view...
return src.find(&quot;\n- &quot;s + std::string{name} + &quot; -\n&quot;);
}</span></span></td><td></td><td class="benchmarkresult">114</td><td class="benchmarkresult">140</td><td class="benchmarkresult">206</td><td class="benchmarkresult">212</td><td class="benchmarkresult">226</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L474">Find concat three strexpr</a><span class="tooltiptext code">size_t find_pos_exp(ssa src, ssa name) {
return src.find(std::string{&quot;\n- &quot; + name + &quot; -\n&quot;});
}</span></span></td><td></td><td class="benchmarkresult">49.6</td><td class="benchmarkresult">38.1</td><td class="benchmarkresult">117</td><td class="benchmarkresult">123</td><td class="benchmarkresult">117</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L478">Find concat three simstr</a><span class="tooltiptext code">size_t find_pos_sim(ssa src, ssa name) {
return src.find(lstringa&lt;200>{&quot;\n- &quot; + name + &quot; -\n&quot;});
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">Если результат конкатенации меньше 207 символов,
он собирается в буфере на стеке, без аллокации и деалокации.
If the concatenation result is less than 207 characters,
it is collected in a stack-based buffer, without allocation or deallocation.</span></span></td><td class="benchmarkresult">19.5</td><td class="benchmarkresult">16.1</td><td class="benchmarkresult">21.4</td><td class="benchmarkresult">28.3</td><td class="benchmarkresult">71.5</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L482">Find concat three stringzilla string</a><span class="tooltiptext code">size_t find_pos_sz(sz::string_view src, sz::string_view name) {
return src.find(sz::string{&quot;\n- &quot;}.append(name).append(&quot; -\n&quot;));
}</span></span></td><td></td><td class="benchmarkresult">145</td><td class="benchmarkresult">130</td><td class="benchmarkresult">217</td><td class="benchmarkresult">231</td><td class="benchmarkresult">288</td></tr>
</tbody></table></div><script>bench_sets['Find three concatenated string in string_view'] = {id:'bs6', tests:[
{name:'Find concat three std::string',data:[114,140,206,212,226]},
{name:'Find concat three strexpr',data:[49.6,38.1,117,123,117]},
{name:'Find concat three simstr',data:[19.5,16.1,21.4,28.3,71.5]},
{name:'Find concat three stringzilla string',data:[145,130,217,231,288]}
]}</script>
<div class="benchset" id="bs7"><h4><a id="bs145290966789248325200" href="#bs145290966789248325200">#</a>&nbsp;Build Type Name</h4>
<table><thead><tr><th>Benchmark name</th><th width="5%">Comment</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), Clang-21</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), GCC-13</th><th width="8%">Xeon E5-2682 v4, Windows 10, Clang-19</th><th width="8%">Xeon E5-2682 v4, Windows 10, MSVC-19</th><th width="8%">Xeon E5-2682 v4, WASM Chrome 143, Clang-21</th></tr></thead><tbody>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L558">BuildTypeNameStr 0/0</a><span class="tooltiptext code">std::string buildTypeNameStr(std::string_view type_name, size_t prec, size_t scale) {
std::string res{type_name};
if (prec) {
res += &quot;(&quot; + std::to_string(prec);
if (scale) {
res += &quot;,&quot; + std::to_string(scale);
}
res += &quot;)&quot;;
}
return res;
}</span></span></td><td></td><td class="benchmarkresult">7.33</td><td class="benchmarkresult">10.0</td><td class="benchmarkresult">8.40</td><td class="benchmarkresult">17.3</td><td class="benchmarkresult">23.4</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L570">BuildTypeNameExp 0/0</a><span class="tooltiptext code">std::string buildTypeNameExp(ssa type_name, size_t prec, size_t scale) {
if (prec) {
return type_name + &quot;(&quot; + prec + e_if(scale, &quot;,&quot;_ss + scale) + &quot;)&quot;;
}
return type_name;
}</span></span></td><td></td><td class="benchmarkresult">6.78</td><td class="benchmarkresult">8.41</td><td class="benchmarkresult">7.59</td><td class="benchmarkresult">13.5</td><td class="benchmarkresult">27.3</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L577">BuildTypeNameSim 0/0</a><span class="tooltiptext code">stringa buildTypeNameSim(ssa type_name, size_t prec, size_t scale) {
if (prec) {
return type_name + &quot;(&quot; + prec + e_if(scale, &quot;,&quot;_ss + scale) + &quot;)&quot;;
}
return type_name;
}</span></span></td><td></td><td class="benchmarkresult">5.04</td><td class="benchmarkresult">5.95</td><td class="benchmarkresult">7.74</td><td class="benchmarkresult">15.2</td><td class="benchmarkresult">20.9</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L558">BuildTypeNameStr 10/10</a><span class="tooltiptext code">std::string buildTypeNameStr(std::string_view type_name, size_t prec, size_t scale) {
std::string res{type_name};
if (prec) {
res += &quot;(&quot; + std::to_string(prec);
if (scale) {
res += &quot;,&quot; + std::to_string(scale);
}
res += &quot;)&quot;;
}
return res;
}</span></span></td><td></td><td class="benchmarkresult">57.9</td><td class="benchmarkresult">79.6</td><td class="benchmarkresult">60.1</td><td class="benchmarkresult">80.4</td><td class="benchmarkresult">403</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L570">BuildTypeNameExp 10/10</a><span class="tooltiptext code">std::string buildTypeNameExp(ssa type_name, size_t prec, size_t scale) {
if (prec) {
return type_name + &quot;(&quot; + prec + e_if(scale, &quot;,&quot;_ss + scale) + &quot;)&quot;;
}
return type_name;
}</span></span></td><td></td><td class="benchmarkresult">31.0</td><td class="benchmarkresult">26.7</td><td class="benchmarkresult">33.0</td><td class="benchmarkresult">39.4</td><td class="benchmarkresult">122</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L577">BuildTypeNameSim 10/10</a><span class="tooltiptext code">stringa buildTypeNameSim(ssa type_name, size_t prec, size_t scale) {
if (prec) {
return type_name + &quot;(&quot; + prec + e_if(scale, &quot;,&quot;_ss + scale) + &quot;)&quot;;
}
return type_name;
}</span></span></td><td></td><td class="benchmarkresult">23.6</td><td class="benchmarkresult">23.7</td><td class="benchmarkresult">25.5</td><td class="benchmarkresult">37.3</td><td class="benchmarkresult">75.6</td></tr>
</tbody></table></div><script>bench_sets['Build Type Name'] = {id:'bs7', tests:[
{name:'BuildTypeNameStr 0/0',data:[7.33,10.0,8.40,17.3,23.4]},
{name:'BuildTypeNameExp 0/0',data:[6.78,8.41,7.59,13.5,27.3]},
{name:'BuildTypeNameSim 0/0',data:[5.04,5.95,7.74,15.2,20.9]},
{name:'BuildTypeNameStr 10/10',data:[57.9,79.6,60.1,80.4,403]},
{name:'BuildTypeNameExp 10/10',data:[31.0,26.7,33.0,39.4,122]},
{name:'BuildTypeNameSim 10/10',data:[23.6,23.7,25.5,37.3,75.6]}
]}</script>
<div class="benchset" id="bs8"><h4><a id="bs54035654251116789780" href="#bs54035654251116789780">#</a>&nbsp;Replace string by copy</h4>
<table><thead><tr><th>Benchmark name</th><th width="5%">Comment</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), Clang-21</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), GCC-13</th><th width="8%">Xeon E5-2682 v4, Windows 10, Clang-19</th><th width="8%">Xeon E5-2682 v4, Windows 10, MSVC-19</th><th width="8%">Xeon E5-2682 v4, WASM Chrome 143, Clang-21</th></tr></thead><tbody>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L631">Concat with replace str</a><span class="tooltiptext code">std::string make_str_str(std::string_view from, std::string_view pattern, std::string_view repl) {
auto str_replace = [](std::string_view from, std::string_view pattern, std::string_view repl) {
std::string result;
for (size_t offset = 0; ;) {
size_t pos = from.find(pattern, offset);
if (pos == std::string::npos) {
result += from.substr(offset);
break;
}
result += from.substr(offset, pos - offset);
result += repl;
offset = pos + pattern.length();
}
return result;
};
return &quot;&lt;&quot; + str_replace(from, pattern, repl) + &quot;>&quot;;
}</span></span></td><td></td><td class="benchmarkresult">203</td><td class="benchmarkresult">233</td><td class="benchmarkresult">317</td><td class="benchmarkresult">359</td><td class="benchmarkresult">544</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L649">Concat with replace exp</a><span class="tooltiptext code">std::string make_str_exp(std::string_view from, std::string_view pattern, std::string_view repl) {
return &quot;&lt;&quot; + e_repl(from, pattern, repl) + &quot;>&quot;;
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">В simstr строковое выражение для замены подстрок
есть "из коробки".
simstr has a string expression for replacing substrings out of the box.</span></span></td><td class="benchmarkresult">147</td><td class="benchmarkresult">136</td><td class="benchmarkresult">214</td><td class="benchmarkresult">220</td><td class="benchmarkresult">258</td></tr>
</tbody></table></div><script>bench_sets['Replace string by copy'] = {id:'bs8', tests:[
{name:'Concat with replace str',data:[203,233,317,359,544]},
{name:'Concat with replace exp',data:[147,136,214,220,258]}
]}</script>
<div class="benchset" id="bs9"><h4><a id="bs77666948964429305550" href="#bs77666948964429305550">#</a>&nbsp;Create Empty Str</h4>
<table><thead><tr><th>Benchmark name</th><th width="5%">Comment</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), Clang-21</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), GCC-13</th><th width="8%">Xeon E5-2682 v4, Windows 10, Clang-19</th><th width="8%">Xeon E5-2682 v4, Windows 10, MSVC-19</th><th width="8%">Xeon E5-2682 v4, WASM Chrome 143, Clang-21</th></tr></thead><tbody>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L683">std::string e;</a><span class="tooltiptext code">template&lt;typename T>
void CreateEmpty(benchmark::State&amp; state) {
for (auto _: state) {
T empty_string;
benchmark::DoNotOptimize(empty_string);
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">Пустые строки, ничего необычного.
Empty lines, nothing unusual.</span></span></td><td class="benchmarkresult">1.12</td><td class="benchmarkresult">1.10</td><td class="benchmarkresult">1.13</td><td class="benchmarkresult">2.60</td><td class="benchmarkresult">2.28</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L683">std::string_view e;</a><span class="tooltiptext code">template&lt;typename T>
void CreateEmpty(benchmark::State&amp; state) {
for (auto _: state) {
T empty_string;
benchmark::DoNotOptimize(empty_string);
}
}</span></span></td><td></td><td class="benchmarkresult">0.370</td><td class="benchmarkresult">0.743</td><td class="benchmarkresult">0.369</td><td class="benchmarkresult">1.84</td><td class="benchmarkresult">0.732</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L683">ssa e;</a><span class="tooltiptext code">template&lt;typename T>
void CreateEmpty(benchmark::State&amp; state) {
for (auto _: state) {
T empty_string;
benchmark::DoNotOptimize(empty_string);
}
}</span></span></td><td></td><td class="benchmarkresult">0.369</td><td class="benchmarkresult">0.185</td><td class="benchmarkresult">0.363</td><td class="benchmarkresult">1.87</td><td class="benchmarkresult">0.368</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L683">stringa e;</a><span class="tooltiptext code">template&lt;typename T>
void CreateEmpty(benchmark::State&amp; state) {
for (auto _: state) {
T empty_string;
benchmark::DoNotOptimize(empty_string);
}
}</span></span></td><td></td><td class="benchmarkresult">0.749</td><td class="benchmarkresult">0.743</td><td class="benchmarkresult">0.744</td><td class="benchmarkresult">2.21</td><td class="benchmarkresult">2.14</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L683">lstringa&lt;20> e;</a><span class="tooltiptext code">template&lt;typename T>
void CreateEmpty(benchmark::State&amp; state) {
for (auto _: state) {
T empty_string;
benchmark::DoNotOptimize(empty_string);
}
}</span></span></td><td></td><td class="benchmarkresult">1.13</td><td class="benchmarkresult">1.11</td><td class="benchmarkresult">1.15</td><td class="benchmarkresult">2.59</td><td class="benchmarkresult">2.17</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L683">lstringa&lt;40> e;</a><span class="tooltiptext code">template&lt;typename T>
void CreateEmpty(benchmark::State&amp; state) {
for (auto _: state) {
T empty_string;
benchmark::DoNotOptimize(empty_string);
}
}</span></span></td><td></td><td class="benchmarkresult">1.13</td><td class="benchmarkresult">1.12</td><td class="benchmarkresult">1.11</td><td class="benchmarkresult">2.59</td><td class="benchmarkresult">2.48</td></tr>
</tbody></table></div><script>bench_sets['Create Empty Str'] = {id:'bs9', tests:[
{name:'std::string e;',data:[1.12,1.10,1.13,2.60,2.28]},
{name:'std::string_view e;',data:[0.370,0.743,0.369,1.84,0.732]},
{name:'ssa e;',data:[0.369,0.185,0.363,1.87,0.368]},
{name:'stringa e;',data:[0.749,0.743,0.744,2.21,2.14]},
{name:'lstringa<20> e;',data:[1.13,1.11,1.15,2.59,2.17]},
{name:'lstringa<40> e;',data:[1.13,1.12,1.11,2.59,2.48]}
]}</script>
<div class="benchset" id="bs10"><h4><a id="bs181001525395597238060" href="#bs181001525395597238060">#</a>&nbsp;Create Str from short literal (9 symbols)</h4>
<table><thead><tr><th>Benchmark name</th><th width="5%">Comment</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), Clang-21</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), GCC-13</th><th width="8%">Xeon E5-2682 v4, Windows 10, Clang-19</th><th width="8%">Xeon E5-2682 v4, Windows 10, MSVC-19</th><th width="8%">Xeon E5-2682 v4, WASM Chrome 143, Clang-21</th></tr></thead><tbody>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L698">std::string e = &quot;Test text&quot;;</a><span class="tooltiptext code">template&lt;typename T>
void CreateShortLiteral(benchmark::State&amp; state) {
for (auto _: state) {
T empty_string = TEST_TEXT;
benchmark::DoNotOptimize(empty_string);
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">Короткий литерал помещается во внутренний буфер std::string,
время тратится только на копирование 10 байтов.
The short literal is placed in the internal std::string buffer;
time is spent only copying 10 bytes.</span></span></td><td class="benchmarkresult">1.86</td><td class="benchmarkresult">1.87</td><td class="benchmarkresult">1.82</td><td class="benchmarkresult">2.61</td><td class="benchmarkresult">2.43</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L698">std::string_view e = &quot;Test text&quot;;</a><span class="tooltiptext code">template&lt;typename T>
void CreateShortLiteral(benchmark::State&amp; state) {
for (auto _: state) {
T empty_string = TEST_TEXT;
benchmark::DoNotOptimize(empty_string);
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">И string_view, и ssa - по сути одно и то же:
указатель на текст и его длина.
Both string_view and ssa are essentially the same thing:
a pointer to text and its length.</span></span></td><td class="benchmarkresult">0.743</td><td class="benchmarkresult">0.758</td><td class="benchmarkresult">0.729</td><td class="benchmarkresult">1.84</td><td class="benchmarkresult">1.09</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L698">ssa e = &quot;Test text&quot;;</a><span class="tooltiptext code">template&lt;typename T>
void CreateShortLiteral(benchmark::State&amp; state) {
for (auto _: state) {
T empty_string = TEST_TEXT;
benchmark::DoNotOptimize(empty_string);
}
}</span></span></td><td></td><td class="benchmarkresult">0.376</td><td class="benchmarkresult">0.742</td><td class="benchmarkresult">0.371</td><td class="benchmarkresult">1.87</td><td class="benchmarkresult">0.726</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L698">stringa e = &quot;Test text&quot;;</a><span class="tooltiptext code">template&lt;typename T>
void CreateShortLiteral(benchmark::State&amp; state) {
for (auto _: state) {
T empty_string = TEST_TEXT;
benchmark::DoNotOptimize(empty_string);
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">stringa при инициализации константным литералом так же
сохраняет только указатель на текст и его длину.
When initialized with a constant literal, stringa also stores
only a pointer to the text and its length.</span></span></td><td class="benchmarkresult">1.11</td><td class="benchmarkresult">1.13</td><td class="benchmarkresult">1.11</td><td class="benchmarkresult">2.59</td><td class="benchmarkresult">2.19</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L698">lstringa&lt;20> e = &quot;Test text&quot;;</a><span class="tooltiptext code">template&lt;typename T>
void CreateShortLiteral(benchmark::State&amp; state) {
for (auto _: state) {
T empty_string = TEST_TEXT;
benchmark::DoNotOptimize(empty_string);
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">Внутреннего буфера хватает для размещения символов,
время уходит только на копирование байтов.
The internal buffer is sufficient to accommodate characters;
time is spent only on copying bytes.</span></span></td><td class="benchmarkresult">1.89</td><td class="benchmarkresult">1.86</td><td class="benchmarkresult">1.85</td><td class="benchmarkresult">2.65</td><td class="benchmarkresult">2.62</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L698">lstringa&lt;40> e = &quot;Test text&quot;;</a><span class="tooltiptext code">template&lt;typename T>
void CreateShortLiteral(benchmark::State&amp; state) {
for (auto _: state) {
T empty_string = TEST_TEXT;
benchmark::DoNotOptimize(empty_string);
}
}</span></span></td><td></td><td class="benchmarkresult">1.86</td><td class="benchmarkresult">1.87</td><td class="benchmarkresult">1.83</td><td class="benchmarkresult">2.58</td><td class="benchmarkresult">2.59</td></tr>
</tbody></table></div><script>bench_sets['Create Str from short literal (9 symbols)'] = {id:'bs10', tests:[
{name:'std::string e = "Test text";',data:[1.86,1.87,1.82,2.61,2.43]},
{name:'std::string_view e = "Test text";',data:[0.743,0.758,0.729,1.84,1.09]},
{name:'ssa e = "Test text";',data:[0.376,0.742,0.371,1.87,0.726]},
{name:'stringa e = "Test text";',data:[1.11,1.13,1.11,2.59,2.19]},
{name:'lstringa<20> e = "Test text";',data:[1.89,1.86,1.85,2.65,2.62]},
{name:'lstringa<40> e = "Test text";',data:[1.86,1.87,1.83,2.58,2.59]}
]}</script>
<div class="benchset" id="bs11"><h4><a id="bs132333183298742730280" href="#bs132333183298742730280">#</a>&nbsp;Create Str from long literal (30 symbols)</h4>
<table><thead><tr><th>Benchmark name</th><th width="5%">Comment</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), Clang-21</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), GCC-13</th><th width="8%">Xeon E5-2682 v4, Windows 10, Clang-19</th><th width="8%">Xeon E5-2682 v4, Windows 10, MSVC-19</th><th width="8%">Xeon E5-2682 v4, WASM Chrome 143, Clang-21</th></tr></thead><tbody>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L713">std::string e = &quot;123456789012345678901234567890&quot;;</a><span class="tooltiptext code">template&lt;typename T>
void CreateLongLiteral(benchmark::State&amp; state) {
for (auto _: state) {
T empty_string{LONG_TEXT};
benchmark::DoNotOptimize(empty_string);
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">Вот тут уже литерал не помещается во внутренний буфер,
возникает аллокация и копирование 30-и байтов.
Но как же отстает аллокация под Windows от Linux'а, 20 vs 70 ns...
Here, the literal doesn't fit into the internal buffer,
and 30 bytes are allocated and copied.
But how much slower is allocation under Windows than under Linux, 20 ns vs. 70 ns...</span></span></td><td class="benchmarkresult">20.0</td><td class="benchmarkresult">20.8</td><td class="benchmarkresult">75.8</td><td class="benchmarkresult">80.5</td><td class="benchmarkresult">26.1</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L713">std::string_view e = &quot;123456789012345678901234567890&quot;;</a><span class="tooltiptext code">template&lt;typename T>
void CreateLongLiteral(benchmark::State&amp; state) {
for (auto _: state) {
T empty_string{LONG_TEXT};
benchmark::DoNotOptimize(empty_string);
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">string_view и ssa по прежнему ничего не делают, кроме
запоминания указателя на текст и его размера.
string_view and ssa still do nothing except
remember the pointer to the text and its size.</span></span></td><td class="benchmarkresult">0.744</td><td class="benchmarkresult">0.733</td><td class="benchmarkresult">0.727</td><td class="benchmarkresult">1.80</td><td class="benchmarkresult">1.15</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L713">ssa e = &quot;123456789012345678901234567890&quot;;</a><span class="tooltiptext code">template&lt;typename T>
void CreateLongLiteral(benchmark::State&amp; state) {
for (auto _: state) {
T empty_string{LONG_TEXT};
benchmark::DoNotOptimize(empty_string);
}
}</span></span></td><td></td><td class="benchmarkresult">0.373</td><td class="benchmarkresult">0.748</td><td class="benchmarkresult">0.369</td><td class="benchmarkresult">1.87</td><td class="benchmarkresult">0.737</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L713">stringa e = &quot;123456789012345678901234567890&quot;;</a><span class="tooltiptext code">template&lt;typename T>
void CreateLongLiteral(benchmark::State&amp; state) {
for (auto _: state) {
T empty_string{LONG_TEXT};
benchmark::DoNotOptimize(empty_string);
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">stringa на константных литералах не отстает!
stringa doesn't lag behind on constant literals!</span></span></td><td class="benchmarkresult">1.11</td><td class="benchmarkresult">1.13</td><td class="benchmarkresult">1.09</td><td class="benchmarkresult">2.89</td><td class="benchmarkresult">2.21</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L713">lstringa&lt;20> e = &quot;123456789012345678901234567890&quot;;</a><span class="tooltiptext code">template&lt;typename T>
void CreateLongLiteral(benchmark::State&amp; state) {
for (auto _: state) {
T empty_string{LONG_TEXT};
benchmark::DoNotOptimize(empty_string);
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">lstringa<20> может вместить в себя до 23 символов,
Очевидно, что для 30-и символов уже нужна аллокация.
Obviously, 30 characters already require allocation.</span></span></td><td class="benchmarkresult">21.2</td><td class="benchmarkresult">20.2</td><td class="benchmarkresult">76.5</td><td class="benchmarkresult">76.2</td><td class="benchmarkresult">24.2</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L713">lstringa&lt;40> e = &quot;123456789012345678901234567890&quot;;</a><span class="tooltiptext code">template&lt;typename T>
void CreateLongLiteral(benchmark::State&amp; state) {
for (auto _: state) {
T empty_string{LONG_TEXT};
benchmark::DoNotOptimize(empty_string);
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">А в lstringa<40> влезает до 47 символов, так что просто
копируется 30 байтов.
And lstringa<40> can hold up to 47 characters, so 30
bytes are simply copied.</span></span></td><td class="benchmarkresult">2.59</td><td class="benchmarkresult">1.86</td><td class="benchmarkresult">2.52</td><td class="benchmarkresult">3.40</td><td class="benchmarkresult">2.92</td></tr>
</tbody></table></div><script>bench_sets['Create Str from long literal (30 symbols)'] = {id:'bs11', tests:[
{name:'std::string e = "123456789012345678901234567890";',data:[20.0,20.8,75.8,80.5,26.1]},
{name:'std::string_view e = "123456789012345678901234567890";',data:[0.744,0.733,0.727,1.80,1.15]},
{name:'ssa e = "123456789012345678901234567890";',data:[0.373,0.748,0.369,1.87,0.737]},
{name:'stringa e = "123456789012345678901234567890";',data:[1.11,1.13,1.09,2.89,2.21]},
{name:'lstringa<20> e = "123456789012345678901234567890";',data:[21.2,20.2,76.5,76.2,24.2]},
{name:'lstringa<40> e = "123456789012345678901234567890";',data:[2.59,1.86,2.52,3.40,2.92]}
]}</script>
<div class="benchset" id="bs12"><h4><a id="bs6234433963744178700" href="#bs6234433963744178700">#</a>&nbsp;Create copy of Str with 9 symbols</h4>
<table><thead><tr><th>Benchmark name</th><th width="5%">Comment</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), Clang-21</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), GCC-13</th><th width="8%">Xeon E5-2682 v4, Windows 10, Clang-19</th><th width="8%">Xeon E5-2682 v4, Windows 10, MSVC-19</th><th width="8%">Xeon E5-2682 v4, WASM Chrome 143, Clang-21</th></tr></thead><tbody>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L728">std::string e = &quot;Test text&quot;; auto c{e};</a><span class="tooltiptext code">template&lt;typename T>
void CopyShortString(benchmark::State&amp; state) {
T x{TEST_TEXT};
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">Строка в пределах SSO, так что просто копирует байты.
The string is within the SSO, so it just copies the bytes.</span></span></td><td class="benchmarkresult">5.24</td><td class="benchmarkresult">4.89</td><td class="benchmarkresult">1.86</td><td class="benchmarkresult">5.98</td><td class="benchmarkresult">3.78</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L728">std::string_view e = &quot;Test text&quot;; auto c{e};</a><span class="tooltiptext code">template&lt;typename T>
void CopyShortString(benchmark::State&amp; state) {
T x{TEST_TEXT};
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td></td><td class="benchmarkresult">0.371</td><td class="benchmarkresult">0.382</td><td class="benchmarkresult">0.370</td><td class="benchmarkresult">3.49</td><td class="benchmarkresult">1.08</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L728">ssa e = &quot;Test text&quot;; auto c{e};</a><span class="tooltiptext code">template&lt;typename T>
void CopyShortString(benchmark::State&amp; state) {
T x{TEST_TEXT};
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">ssa и string_view не владеют строкой, копируется
только информация о строке.
ssa and string_view don't own the string; only the
string information is copied.</span></span></td><td class="benchmarkresult">0.376</td><td class="benchmarkresult">0.382</td><td class="benchmarkresult">0.365</td><td class="benchmarkresult">3.51</td><td class="benchmarkresult">1.21</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L728">stringa e = &quot;Test text&quot;; auto c{e};</a><span class="tooltiptext code">template&lt;typename T>
void CopyShortString(benchmark::State&amp; state) {
T x{TEST_TEXT};
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">Копирование stringa происходит быстро,
особенно если она инициализирована литералом.
Copying a stringa is fast,
especially if it is initialized with a literal.</span></span></td><td class="benchmarkresult">1.10</td><td class="benchmarkresult">1.31</td><td class="benchmarkresult">1.32</td><td class="benchmarkresult">4.07</td><td class="benchmarkresult">2.70</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L728">lstringa&lt;20> e = &quot;Test text&quot;; auto c{e};</a><span class="tooltiptext code">template&lt;typename T>
void CopyShortString(benchmark::State&amp; state) {
T x{TEST_TEXT};
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">В обоих случаях хватает внутреннего буфера.
In both cases, the internal buffer is sufficient.</span></span></td><td class="benchmarkresult">1.50</td><td class="benchmarkresult">1.14</td><td class="benchmarkresult">1.50</td><td class="benchmarkresult">4.75</td><td class="benchmarkresult">4.86</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L728">lstringa&lt;40> e = &quot;Test text&quot;; auto c{e};</a><span class="tooltiptext code">template&lt;typename T>
void CopyShortString(benchmark::State&amp; state) {
T x{TEST_TEXT};
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">Только копируются байты.
Only bytes are copied.</span></span></td><td class="benchmarkresult">1.48</td><td class="benchmarkresult">1.12</td><td class="benchmarkresult">1.50</td><td class="benchmarkresult">4.91</td><td class="benchmarkresult">4.84</td></tr>
</tbody></table></div><script>bench_sets['Create copy of Str with 9 symbols'] = {id:'bs12', tests:[
{name:'std::string e = "Test text"; auto c{e};',data:[5.24,4.89,1.86,5.98,3.78]},
{name:'std::string_view e = "Test text"; auto c{e};',data:[0.371,0.382,0.370,3.49,1.08]},
{name:'ssa e = "Test text"; auto c{e};',data:[0.376,0.382,0.365,3.51,1.21]},
{name:'stringa e = "Test text"; auto c{e};',data:[1.10,1.31,1.32,4.07,2.70]},
{name:'lstringa<20> e = "Test text"; auto c{e};',data:[1.50,1.14,1.50,4.75,4.86]},
{name:'lstringa<40> e = "Test text"; auto c{e};',data:[1.48,1.12,1.50,4.91,4.84]}
]}</script>
<div class="benchset" id="bs13"><h4><a id="bs76384575499199461500" href="#bs76384575499199461500">#</a>&nbsp;Create copy of Str with 30 symbols</h4>
<table><thead><tr><th>Benchmark name</th><th width="5%">Comment</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), Clang-21</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), GCC-13</th><th width="8%">Xeon E5-2682 v4, Windows 10, Clang-19</th><th width="8%">Xeon E5-2682 v4, Windows 10, MSVC-19</th><th width="8%">Xeon E5-2682 v4, WASM Chrome 143, Clang-21</th></tr></thead><tbody>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L745">std::string e = &quot;123456789012345678901234567890&quot;; auto c{e};</a><span class="tooltiptext code">template&lt;typename T>
void CopyLongString(benchmark::State&amp; state) {
T x = LONG_TEXT;
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">Копирования длинной строки вызывает аллокацию,
SSO уже не хватает. И снова как же отстаёт аллокация под Windows...
Copying a long string causes allocations,
SSO is no longer sufficient. And again, how allocation lags under Windows...</span></span></td><td class="benchmarkresult">19.3</td><td class="benchmarkresult">24.5</td><td class="benchmarkresult">79.4</td><td class="benchmarkresult">77.8</td><td class="benchmarkresult">53.4</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L745">std::string_view e = &quot;123456789012345678901234567890&quot;; auto c{e};</a><span class="tooltiptext code">template&lt;typename T>
void CopyLongString(benchmark::State&amp; state) {
T x = LONG_TEXT;
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
}
}</span></span></td><td></td><td class="benchmarkresult">0.744</td><td class="benchmarkresult">0.746</td><td class="benchmarkresult">0.743</td><td class="benchmarkresult">1.85</td><td class="benchmarkresult">1.12</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L745">ssa e = &quot;123456789012345678901234567890&quot;; auto c{e};</a><span class="tooltiptext code">template&lt;typename T>
void CopyLongString(benchmark::State&amp; state) {
T x = LONG_TEXT;
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
}
}</span></span></td><td></td><td class="benchmarkresult">0.379</td><td class="benchmarkresult">0.746</td><td class="benchmarkresult">0.374</td><td class="benchmarkresult">1.85</td><td class="benchmarkresult">0.746</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L745">stringa e = &quot;123456789012345678901234567890&quot;; auto c{e};</a><span class="tooltiptext code">template&lt;typename T>
void CopyLongString(benchmark::State&amp; state) {
T x = LONG_TEXT;
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">А вот у stringa копирование литерала не зависит от его длины,
сравни с предыдущим бенчмарком.
But with stringa, literal copying doesn't depend on its length,
compare with the previous benchmark.</span></span></td><td class="benchmarkresult">1.11</td><td class="benchmarkresult">1.11</td><td class="benchmarkresult">1.83</td><td class="benchmarkresult">3.01</td><td class="benchmarkresult">2.18</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L745">lstringa&lt;20> e = &quot;123456789012345678901234567890&quot;; auto c{e};</a><span class="tooltiptext code">template&lt;typename T>
void CopyLongString(benchmark::State&amp; state) {
T x = LONG_TEXT;
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">Не влезает, аллокация.
Doesn't fit, allocation.</span></span></td><td class="benchmarkresult">20.7</td><td class="benchmarkresult">21.2</td><td class="benchmarkresult">76.4</td><td class="benchmarkresult">82.2</td><td class="benchmarkresult">22.5</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L745">lstringa&lt;40> e = &quot;123456789012345678901234567890&quot;; auto c{e};</a><span class="tooltiptext code">template&lt;typename T>
void CopyLongString(benchmark::State&amp; state) {
T x = LONG_TEXT;
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">Уложили во внутренний буфер.
Placed in the internal buffer.</span></span></td><td class="benchmarkresult">4.59</td><td class="benchmarkresult">4.20</td><td class="benchmarkresult">4.95</td><td class="benchmarkresult">7.97</td><td class="benchmarkresult">17.0</td></tr>
</tbody></table></div><script>bench_sets['Create copy of Str with 30 symbols'] = {id:'bs13', tests:[
{name:'std::string e = "123456789012345678901234567890"; auto c{e};',data:[19.3,24.5,79.4,77.8,53.4]},
{name:'std::string_view e = "123456789012345678901234567890"; auto c{e};',data:[0.744,0.746,0.743,1.85,1.12]},
{name:'ssa e = "123456789012345678901234567890"; auto c{e};',data:[0.379,0.746,0.374,1.85,0.746]},
{name:'stringa e = "123456789012345678901234567890"; auto c{e};',data:[1.11,1.11,1.83,3.01,2.18]},
{name:'lstringa<20> e = "123456789012345678901234567890"; auto c{e};',data:[20.7,21.2,76.4,82.2,22.5]},
{name:'lstringa<40> e = "123456789012345678901234567890"; auto c{e};',data:[4.59,4.20,4.95,7.97,17.0]}
]}</script>
<div class="benchset" id="bs14"><h4><a id="bs21623892135774528620" href="#bs21623892135774528620">#</a>&nbsp;Find 9 symbols text in end of 99 symbols text</h4>
<table><thead><tr><th>Benchmark name</th><th width="5%">Comment</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), Clang-21</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), GCC-13</th><th width="8%">Xeon E5-2682 v4, Windows 10, Clang-19</th><th width="8%">Xeon E5-2682 v4, Windows 10, MSVC-19</th><th width="8%">Xeon E5-2682 v4, WASM Chrome 143, Clang-21</th></tr></thead><tbody>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L762">sz::string::find;</a><span class="tooltiptext code">template&lt;typename T>
void Find(benchmark::State&amp; state) {
T x{LONG_TEXT LONG_TEXT LONG_TEXT TEST_TEXT};
for (auto _: state) {
int i = (int)x.find(TEST_TEXT);
#ifdef CHECK_RESULT
if (i != 90) {
state.SkipWithError(&quot;not find?&quot;);
break;
}
#endif
benchmark::DoNotOptimize(i);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">stringzilla более заточена на поиск больших строк в больших строках.
stringzilla is more focused on searching large strings within large strings.</span></span></td><td class="benchmarkresult">94.7</td><td class="benchmarkresult">92.9</td><td class="benchmarkresult">97.9</td><td class="benchmarkresult">116</td><td class="benchmarkresult">123</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L762">std::string::find;</a><span class="tooltiptext code">template&lt;typename T>
void Find(benchmark::State&amp; state) {
T x{LONG_TEXT LONG_TEXT LONG_TEXT TEST_TEXT};
for (auto _: state) {
int i = (int)x.find(TEST_TEXT);
#ifdef CHECK_RESULT
if (i != 90) {
state.SkipWithError(&quot;not find?&quot;);
break;
}
#endif
benchmark::DoNotOptimize(i);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">Здесь "победила дружба", у всех типов по колонке примерно одинаково.
Однако, Windows и Linux явно в разных весовых категориях.
Here, "friendship wins," with all types scoring roughly equally.
However, Windows and Linux are clearly in different weight classes.</span></span></td><td class="benchmarkresult">7.15</td><td class="benchmarkresult">6.97</td><td class="benchmarkresult">40.2</td><td class="benchmarkresult">40.4</td><td class="benchmarkresult">40.4</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L762">std::string_view::find;</a><span class="tooltiptext code">template&lt;typename T>
void Find(benchmark::State&amp; state) {
T x{LONG_TEXT LONG_TEXT LONG_TEXT TEST_TEXT};
for (auto _: state) {
int i = (int)x.find(TEST_TEXT);
#ifdef CHECK_RESULT
if (i != 90) {
state.SkipWithError(&quot;not find?&quot;);
break;
}
#endif
benchmark::DoNotOptimize(i);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td></td><td class="benchmarkresult">7.65</td><td class="benchmarkresult">7.27</td><td class="benchmarkresult">52.2</td><td class="benchmarkresult">39.5</td><td class="benchmarkresult">43.8</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L762">ssa::find;</a><span class="tooltiptext code">template&lt;typename T>
void Find(benchmark::State&amp; state) {
T x{LONG_TEXT LONG_TEXT LONG_TEXT TEST_TEXT};
for (auto _: state) {
int i = (int)x.find(TEST_TEXT);
#ifdef CHECK_RESULT
if (i != 90) {
state.SkipWithError(&quot;not find?&quot;);
break;
}
#endif
benchmark::DoNotOptimize(i);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td></td><td class="benchmarkresult">7.31</td><td class="benchmarkresult">6.74</td><td class="benchmarkresult">19.3</td><td class="benchmarkresult">22.2</td><td class="benchmarkresult">41.7</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L762">stringa::find;</a><span class="tooltiptext code">template&lt;typename T>
void Find(benchmark::State&amp; state) {
T x{LONG_TEXT LONG_TEXT LONG_TEXT TEST_TEXT};
for (auto _: state) {
int i = (int)x.find(TEST_TEXT);
#ifdef CHECK_RESULT
if (i != 90) {
state.SkipWithError(&quot;not find?&quot;);
break;
}
#endif
benchmark::DoNotOptimize(i);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td></td><td class="benchmarkresult">8.30</td><td class="benchmarkresult">6.85</td><td class="benchmarkresult">19.4</td><td class="benchmarkresult">31.4</td><td class="benchmarkresult">41.7</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L762">lstringa&lt;20>::find;</a><span class="tooltiptext code">template&lt;typename T>
void Find(benchmark::State&amp; state) {
T x{LONG_TEXT LONG_TEXT LONG_TEXT TEST_TEXT};
for (auto _: state) {
int i = (int)x.find(TEST_TEXT);
#ifdef CHECK_RESULT
if (i != 90) {
state.SkipWithError(&quot;not find?&quot;);
break;
}
#endif
benchmark::DoNotOptimize(i);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td></td><td class="benchmarkresult">6.70</td><td class="benchmarkresult">6.45</td><td class="benchmarkresult">17.9</td><td class="benchmarkresult">22.4</td><td class="benchmarkresult">39.4</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L762">lstringa&lt;40>::find;</a><span class="tooltiptext code">template&lt;typename T>
void Find(benchmark::State&amp; state) {
T x{LONG_TEXT LONG_TEXT LONG_TEXT TEST_TEXT};
for (auto _: state) {
int i = (int)x.find(TEST_TEXT);
#ifdef CHECK_RESULT
if (i != 90) {
state.SkipWithError(&quot;not find?&quot;);
break;
}
#endif
benchmark::DoNotOptimize(i);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td></td><td class="benchmarkresult">6.75</td><td class="benchmarkresult">6.42</td><td class="benchmarkresult">18.1</td><td class="benchmarkresult">22.0</td><td class="benchmarkresult">39.6</td></tr>
</tbody></table></div><script>bench_sets['Find 9 symbols text in end of 99 symbols text'] = {id:'bs14', tests:[
{name:'sz::string::find;',data:[94.7,92.9,97.9,116,123]},
{name:'std::string::find;',data:[7.15,6.97,40.2,40.4,40.4]},
{name:'std::string_view::find;',data:[7.65,7.27,52.2,39.5,43.8]},
{name:'ssa::find;',data:[7.31,6.74,19.3,22.2,41.7]},
{name:'stringa::find;',data:[8.30,6.85,19.4,31.4,41.7]},
{name:'lstringa<20>::find;',data:[6.70,6.45,17.9,22.4,39.4]},
{name:'lstringa<40>::find;',data:[6.75,6.42,18.1,22.0,39.6]}
]}</script>
<div class="benchset" id="bs15"><h4><a id="bs170792414351801782640" href="#bs170792414351801782640">#</a>&nbsp;Copy not literal Str with N symbols</h4>
<table><thead><tr><th>Benchmark name</th><th width="5%">Comment</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), Clang-21</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), GCC-13</th><th width="8%">Xeon E5-2682 v4, Windows 10, Clang-19</th><th width="8%">Xeon E5-2682 v4, Windows 10, MSVC-19</th><th width="8%">Xeon E5-2682 v4, WASM Chrome 143, Clang-21</th></tr></thead><tbody>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">std::string copy{str_with_len_N};/15</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td></td><td class="benchmarkresult">5.79</td><td class="benchmarkresult">8.62</td><td class="benchmarkresult">1.87</td><td class="benchmarkresult">5.26</td><td class="benchmarkresult">54.0</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">std::string copy{str_with_len_N};/16</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">Явно виден скачок, где заканчивается SSO и начинается аллокация.
Обратите внимание, что WASM - 32-битный, и там размер
SSO у std::string меньше, 10 символов + 0.
The jump where SSO ends and allocation begins is clearly visible.
Note that WASM is 32-bit, and the size of the SSO for std::string is
smaller, as far as I remember: 11 characters + 0.</span></span></td><td class="benchmarkresult">23.7</td><td class="benchmarkresult">28.1</td><td class="benchmarkresult">82.8</td><td class="benchmarkresult">83.1</td><td class="benchmarkresult">50.8</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">std::string copy{str_with_len_N};/23</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">Дальше просто добавляется время на копирование байтов.
Then the time for copying bytes is simply added.</span></span></td><td class="benchmarkresult">22.8</td><td class="benchmarkresult">27.6</td><td class="benchmarkresult">80.2</td><td class="benchmarkresult">82.5</td><td class="benchmarkresult">50.7</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">std::string copy{str_with_len_N};/24</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td></td><td class="benchmarkresult">23.4</td><td class="benchmarkresult">27.9</td><td class="benchmarkresult">78.8</td><td class="benchmarkresult">82.7</td><td class="benchmarkresult">51.0</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">std::string copy{str_with_len_N};/32</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td></td><td class="benchmarkresult">23.0</td><td class="benchmarkresult">27.6</td><td class="benchmarkresult">86.0</td><td class="benchmarkresult">83.9</td><td class="benchmarkresult">57.8</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">std::string copy{str_with_len_N};/64</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td></td><td class="benchmarkresult">22.8</td><td class="benchmarkresult">26.4</td><td class="benchmarkresult">84.4</td><td class="benchmarkresult">85.2</td><td class="benchmarkresult">57.0</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">std::string copy{str_with_len_N};/128</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td></td><td class="benchmarkresult">24.9</td><td class="benchmarkresult">28.2</td><td class="benchmarkresult">90.9</td><td class="benchmarkresult">86.3</td><td class="benchmarkresult">57.2</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">std::string copy{str_with_len_N};/256</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td></td><td class="benchmarkresult">31.4</td><td class="benchmarkresult">33.5</td><td class="benchmarkresult">87.4</td><td class="benchmarkresult">88.9</td><td class="benchmarkresult">68.5</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">std::string copy{str_with_len_N};/512</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td></td><td class="benchmarkresult">29.2</td><td class="benchmarkresult">33.2</td><td class="benchmarkresult">90.0</td><td class="benchmarkresult">93.3</td><td class="benchmarkresult">65.9</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">std::string copy{str_with_len_N};/1024</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td></td><td class="benchmarkresult">33.8</td><td class="benchmarkresult">37.8</td><td class="benchmarkresult">100</td><td class="benchmarkresult">99.3</td><td class="benchmarkresult">88.6</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">std::string copy{str_with_len_N};/2048</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td></td><td class="benchmarkresult">77.6</td><td class="benchmarkresult">81.0</td><td class="benchmarkresult">129</td><td class="benchmarkresult">131</td><td class="benchmarkresult">113</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">std::string copy{str_with_len_N};/4096</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">Чем длиннее строка, тем дольше создаётся копия.
The longer the string, the longer it takes to create a copy.</span></span></td><td class="benchmarkresult">117</td><td class="benchmarkresult">121</td><td class="benchmarkresult">180</td><td class="benchmarkresult">184</td><td class="benchmarkresult">159</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">stringa copy{str_with_len_N};/15</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">Здесь stringa инициализируется не литералом,
а значит, должна сама хранить символы.
Here, stringa is not initialized with a literal,
meaning it must store characters itself.</span></span></td><td class="benchmarkresult">1.10</td><td class="benchmarkresult">1.31</td><td class="benchmarkresult">1.32</td><td class="benchmarkresult">4.06</td><td class="benchmarkresult">2.40</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">stringa copy{str_with_len_N};/16</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">Под WASM SSO у stringa составляет 15 символов. Кроме того,
собиралось без поддержки потоков, поэтому атомарный
инкремент заменён на обычный, судя по времени.
Under WASM, stringa has a 15-character SSO. Furthermore,
it was built without thread support, so the atomic
increment was replaced with a regular one, judging by the time.</span></span></td><td class="benchmarkresult">1.09</td><td class="benchmarkresult">1.30</td><td class="benchmarkresult">1.33</td><td class="benchmarkresult">4.11</td><td class="benchmarkresult">4.81</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">stringa copy{str_with_len_N};/23</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">SSO в stringa до 23 символов, и даже 23
копируются быстрее, чем 15 в std::string.
SSO in stringa is up to 23 characters, and even 23
copies faster than 15 in std::string.</span></span></td><td class="benchmarkresult">1.10</td><td class="benchmarkresult">1.30</td><td class="benchmarkresult">1.33</td><td class="benchmarkresult">3.97</td><td class="benchmarkresult">4.81</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">stringa copy{str_with_len_N};/24</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">Всё, не влезаем в SSO, а значит, используем shared буфер.
Добавляется время на атомарный инкремент счётчика.
That's it, we're not using SSO, so we're using a shared buffer.
Time is added for the atomic counter increment.</span></span></td><td class="benchmarkresult">16.0</td><td class="benchmarkresult">16.2</td><td class="benchmarkresult">15.9</td><td class="benchmarkresult">18.5</td><td class="benchmarkresult">4.86</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">stringa copy{str_with_len_N};/32</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td></td><td class="benchmarkresult">16.0</td><td class="benchmarkresult">16.1</td><td class="benchmarkresult">15.8</td><td class="benchmarkresult">19.0</td><td class="benchmarkresult">4.81</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">stringa copy{str_with_len_N};/64</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td></td><td class="benchmarkresult">16.1</td><td class="benchmarkresult">16.2</td><td class="benchmarkresult">15.8</td><td class="benchmarkresult">18.5</td><td class="benchmarkresult">5.13</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">stringa copy{str_with_len_N};/128</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td></td><td class="benchmarkresult">16.1</td><td class="benchmarkresult">16.1</td><td class="benchmarkresult">15.9</td><td class="benchmarkresult">18.9</td><td class="benchmarkresult">5.28</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">stringa copy{str_with_len_N};/256</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td></td><td class="benchmarkresult">16.0</td><td class="benchmarkresult">16.2</td><td class="benchmarkresult">15.8</td><td class="benchmarkresult">18.5</td><td class="benchmarkresult">5.19</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">stringa copy{str_with_len_N};/512</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td></td><td class="benchmarkresult">16.0</td><td class="benchmarkresult">16.2</td><td class="benchmarkresult">15.9</td><td class="benchmarkresult">18.5</td><td class="benchmarkresult">4.80</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">stringa copy{str_with_len_N};/1024</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td></td><td class="benchmarkresult">16.0</td><td class="benchmarkresult">16.1</td><td class="benchmarkresult">15.9</td><td class="benchmarkresult">18.8</td><td class="benchmarkresult">4.86</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">stringa copy{str_with_len_N};/2048</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td></td><td class="benchmarkresult">16.5</td><td class="benchmarkresult">16.3</td><td class="benchmarkresult">15.8</td><td class="benchmarkresult">18.5</td><td class="benchmarkresult">4.82</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">stringa copy{str_with_len_N};/4096</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">И как видно, кроме инкремента нет накладных расходов,
время копирования не зависит от длины строки.
And as you can see, there are no overhead costs other than the
increment; copying time does not depend on the string length.</span></span></td><td class="benchmarkresult">16.1</td><td class="benchmarkresult">16.1</td><td class="benchmarkresult">16.0</td><td class="benchmarkresult">18.7</td><td class="benchmarkresult">4.82</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">lstringa&lt;16> copy{str_with_len_N};/15</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">lstringa<16> использует SSO до 23 символов.
А в WASM 32-битная архитектура, SSO до 19 символов.
lstringa<16> uses SSO up to 23 characters.
WASM has a 32-bit architecture, so SSO is up to 19 characters.</span></span></td><td class="benchmarkresult">1.51</td><td class="benchmarkresult">1.09</td><td class="benchmarkresult">1.55</td><td class="benchmarkresult">4.59</td><td class="benchmarkresult">4.09</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">lstringa&lt;16> copy{str_with_len_N};/16</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td></td><td class="benchmarkresult">4.98</td><td class="benchmarkresult">4.54</td><td class="benchmarkresult">5.54</td><td class="benchmarkresult">9.69</td><td class="benchmarkresult">16.1</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">lstringa&lt;16> copy{str_with_len_N};/23</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td></td><td class="benchmarkresult">5.02</td><td class="benchmarkresult">4.54</td><td class="benchmarkresult">5.65</td><td class="benchmarkresult">9.56</td><td class="benchmarkresult">38.4</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">lstringa&lt;16> copy{str_with_len_N};/24</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">И после начинает вести себя при копировании, как std::string.
And then it starts to behave like std::string when copied.</span></span></td><td class="benchmarkresult">25.3</td><td class="benchmarkresult">24.5</td><td class="benchmarkresult">79.9</td><td class="benchmarkresult">81.8</td><td class="benchmarkresult">39.6</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">lstringa&lt;16> copy{str_with_len_N};/32</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td></td><td class="benchmarkresult">25.3</td><td class="benchmarkresult">24.6</td><td class="benchmarkresult">87.1</td><td class="benchmarkresult">85.0</td><td class="benchmarkresult">41.7</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">lstringa&lt;16> copy{str_with_len_N};/64</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td></td><td class="benchmarkresult">26.8</td><td class="benchmarkresult">26.2</td><td class="benchmarkresult">83.3</td><td class="benchmarkresult">83.6</td><td class="benchmarkresult">42.5</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">lstringa&lt;16> copy{str_with_len_N};/128</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td></td><td class="benchmarkresult">27.1</td><td class="benchmarkresult">26.6</td><td class="benchmarkresult">89.2</td><td class="benchmarkresult">89.7</td><td class="benchmarkresult">46.0</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">lstringa&lt;16> copy{str_with_len_N};/256</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td></td><td class="benchmarkresult">28.3</td><td class="benchmarkresult">27.5</td><td class="benchmarkresult">90.0</td><td class="benchmarkresult">89.5</td><td class="benchmarkresult">56.1</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">lstringa&lt;16> copy{str_with_len_N};/512</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td></td><td class="benchmarkresult">31.1</td><td class="benchmarkresult">30.7</td><td class="benchmarkresult">92.9</td><td class="benchmarkresult">90.5</td><td class="benchmarkresult">54.9</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">lstringa&lt;16> copy{str_with_len_N};/1024</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td></td><td class="benchmarkresult">53.5</td><td class="benchmarkresult">54.1</td><td class="benchmarkresult">103</td><td class="benchmarkresult">99.9</td><td class="benchmarkresult">68.5</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">lstringa&lt;16> copy{str_with_len_N};/2048</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td></td><td class="benchmarkresult">64.2</td><td class="benchmarkresult">64.5</td><td class="benchmarkresult">124</td><td class="benchmarkresult">129</td><td class="benchmarkresult">97.6</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">lstringa&lt;16> copy{str_with_len_N};/4096</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td></td><td class="benchmarkresult">90.2</td><td class="benchmarkresult">87.1</td><td class="benchmarkresult">188</td><td class="benchmarkresult">189</td><td class="benchmarkresult">143</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">lstringa&lt;512> copy{str_with_len_N};/15</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td></td><td class="benchmarkresult">1.50</td><td class="benchmarkresult">1.13</td><td class="benchmarkresult">1.47</td><td class="benchmarkresult">4.41</td><td class="benchmarkresult">4.74</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">lstringa&lt;512> copy{str_with_len_N};/16</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td></td><td class="benchmarkresult">4.92</td><td class="benchmarkresult">4.86</td><td class="benchmarkresult">5.24</td><td class="benchmarkresult">9.33</td><td class="benchmarkresult">16.3</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">lstringa&lt;512> copy{str_with_len_N};/23</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td></td><td class="benchmarkresult">4.88</td><td class="benchmarkresult">4.79</td><td class="benchmarkresult">5.28</td><td class="benchmarkresult">9.47</td><td class="benchmarkresult">16.0</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">lstringa&lt;512> copy{str_with_len_N};/24</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td></td><td class="benchmarkresult">4.60</td><td class="benchmarkresult">4.73</td><td class="benchmarkresult">5.18</td><td class="benchmarkresult">9.35</td><td class="benchmarkresult">16.2</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">lstringa&lt;512> copy{str_with_len_N};/32</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td></td><td class="benchmarkresult">4.58</td><td class="benchmarkresult">4.59</td><td class="benchmarkresult">8.27</td><td class="benchmarkresult">12.4</td><td class="benchmarkresult">19.5</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">lstringa&lt;512> copy{str_with_len_N};/64</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td></td><td class="benchmarkresult">5.95</td><td class="benchmarkresult">5.99</td><td class="benchmarkresult">8.17</td><td class="benchmarkresult">12.4</td><td class="benchmarkresult">19.3</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">lstringa&lt;512> copy{str_with_len_N};/128</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td></td><td class="benchmarkresult">6.42</td><td class="benchmarkresult">6.99</td><td class="benchmarkresult">8.43</td><td class="benchmarkresult">12.8</td><td class="benchmarkresult">19.5</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">lstringa&lt;512> copy{str_with_len_N};/256</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td></td><td class="benchmarkresult">7.92</td><td class="benchmarkresult">8.23</td><td class="benchmarkresult">9.98</td><td class="benchmarkresult">13.9</td><td class="benchmarkresult">22.1</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">lstringa&lt;512> copy{str_with_len_N};/512</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">Даже 512 символов копируются быстрее, чем
одна аллокация или атомарный инкремент.
Even 512 characters are copied faster than a single
allocation or atomic increment.</span></span></td><td class="benchmarkresult">10.3</td><td class="benchmarkresult">10.4</td><td class="benchmarkresult">11.2</td><td class="benchmarkresult">15.6</td><td class="benchmarkresult">23.7</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">lstringa&lt;512> copy{str_with_len_N};/1024</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">А дальше уже как у всех.
And then it's like everyone else.</span></span></td><td class="benchmarkresult">53.2</td><td class="benchmarkresult">55.5</td><td class="benchmarkresult">98.0</td><td class="benchmarkresult">99.7</td><td class="benchmarkresult">73.4</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">lstringa&lt;512> copy{str_with_len_N};/2048</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td></td><td class="benchmarkresult">63.2</td><td class="benchmarkresult">66.3</td><td class="benchmarkresult">128</td><td class="benchmarkresult">128</td><td class="benchmarkresult">102</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L786">lstringa&lt;512> copy{str_with_len_N};/4096</a><span class="tooltiptext code">template&lt;typename T>
void CopyDynString(benchmark::State&amp; state) {
T x(state.range(0), &#39;a&#39;);
for (auto _: state) {
T copy{x};
benchmark::DoNotOptimize(copy);
benchmark::DoNotOptimize(x);
}
}</span></span></td><td></td><td class="benchmarkresult">89.4</td><td class="benchmarkresult">90.6</td><td class="benchmarkresult">189</td><td class="benchmarkresult">190</td><td class="benchmarkresult">150</td></tr>
</tbody></table></div><script>bench_sets['Copy not literal Str with N symbols'] = {id:'bs15', tests:[
{name:'std::string copy{str_with_len_N};/15',data:[5.79,8.62,1.87,5.26,54.0]},
{name:'std::string copy{str_with_len_N};/16',data:[23.7,28.1,82.8,83.1,50.8]},
{name:'std::string copy{str_with_len_N};/23',data:[22.8,27.6,80.2,82.5,50.7]},
{name:'std::string copy{str_with_len_N};/24',data:[23.4,27.9,78.8,82.7,51.0]},
{name:'std::string copy{str_with_len_N};/32',data:[23.0,27.6,86.0,83.9,57.8]},
{name:'std::string copy{str_with_len_N};/64',data:[22.8,26.4,84.4,85.2,57.0]},
{name:'std::string copy{str_with_len_N};/128',data:[24.9,28.2,90.9,86.3,57.2]},
{name:'std::string copy{str_with_len_N};/256',data:[31.4,33.5,87.4,88.9,68.5]},
{name:'std::string copy{str_with_len_N};/512',data:[29.2,33.2,90.0,93.3,65.9]},
{name:'std::string copy{str_with_len_N};/1024',data:[33.8,37.8,100,99.3,88.6]},
{name:'std::string copy{str_with_len_N};/2048',data:[77.6,81.0,129,131,113]},
{name:'std::string copy{str_with_len_N};/4096',data:[117,121,180,184,159]},
{name:'stringa copy{str_with_len_N};/15',data:[1.10,1.31,1.32,4.06,2.40]},
{name:'stringa copy{str_with_len_N};/16',data:[1.09,1.30,1.33,4.11,4.81]},
{name:'stringa copy{str_with_len_N};/23',data:[1.10,1.30,1.33,3.97,4.81]},
{name:'stringa copy{str_with_len_N};/24',data:[16.0,16.2,15.9,18.5,4.86]},
{name:'stringa copy{str_with_len_N};/32',data:[16.0,16.1,15.8,19.0,4.81]},
{name:'stringa copy{str_with_len_N};/64',data:[16.1,16.2,15.8,18.5,5.13]},
{name:'stringa copy{str_with_len_N};/128',data:[16.1,16.1,15.9,18.9,5.28]},
{name:'stringa copy{str_with_len_N};/256',data:[16.0,16.2,15.8,18.5,5.19]},
{name:'stringa copy{str_with_len_N};/512',data:[16.0,16.2,15.9,18.5,4.80]},
{name:'stringa copy{str_with_len_N};/1024',data:[16.0,16.1,15.9,18.8,4.86]},
{name:'stringa copy{str_with_len_N};/2048',data:[16.5,16.3,15.8,18.5,4.82]},
{name:'stringa copy{str_with_len_N};/4096',data:[16.1,16.1,16.0,18.7,4.82]},
{name:'lstringa<16> copy{str_with_len_N};/15',data:[1.51,1.09,1.55,4.59,4.09]},
{name:'lstringa<16> copy{str_with_len_N};/16',data:[4.98,4.54,5.54,9.69,16.1]},
{name:'lstringa<16> copy{str_with_len_N};/23',data:[5.02,4.54,5.65,9.56,38.4]},
{name:'lstringa<16> copy{str_with_len_N};/24',data:[25.3,24.5,79.9,81.8,39.6]},
{name:'lstringa<16> copy{str_with_len_N};/32',data:[25.3,24.6,87.1,85.0,41.7]},
{name:'lstringa<16> copy{str_with_len_N};/64',data:[26.8,26.2,83.3,83.6,42.5]},
{name:'lstringa<16> copy{str_with_len_N};/128',data:[27.1,26.6,89.2,89.7,46.0]},
{name:'lstringa<16> copy{str_with_len_N};/256',data:[28.3,27.5,90.0,89.5,56.1]},
{name:'lstringa<16> copy{str_with_len_N};/512',data:[31.1,30.7,92.9,90.5,54.9]},
{name:'lstringa<16> copy{str_with_len_N};/1024',data:[53.5,54.1,103,99.9,68.5]},
{name:'lstringa<16> copy{str_with_len_N};/2048',data:[64.2,64.5,124,129,97.6]},
{name:'lstringa<16> copy{str_with_len_N};/4096',data:[90.2,87.1,188,189,143]},
{name:'lstringa<512> copy{str_with_len_N};/15',data:[1.50,1.13,1.47,4.41,4.74]},
{name:'lstringa<512> copy{str_with_len_N};/16',data:[4.92,4.86,5.24,9.33,16.3]},
{name:'lstringa<512> copy{str_with_len_N};/23',data:[4.88,4.79,5.28,9.47,16.0]},
{name:'lstringa<512> copy{str_with_len_N};/24',data:[4.60,4.73,5.18,9.35,16.2]},
{name:'lstringa<512> copy{str_with_len_N};/32',data:[4.58,4.59,8.27,12.4,19.5]},
{name:'lstringa<512> copy{str_with_len_N};/64',data:[5.95,5.99,8.17,12.4,19.3]},
{name:'lstringa<512> copy{str_with_len_N};/128',data:[6.42,6.99,8.43,12.8,19.5]},
{name:'lstringa<512> copy{str_with_len_N};/256',data:[7.92,8.23,9.98,13.9,22.1]},
{name:'lstringa<512> copy{str_with_len_N};/512',data:[10.3,10.4,11.2,15.6,23.7]},
{name:'lstringa<512> copy{str_with_len_N};/1024',data:[53.2,55.5,98.0,99.7,73.4]},
{name:'lstringa<512> copy{str_with_len_N};/2048',data:[63.2,66.3,128,128,102]},
{name:'lstringa<512> copy{str_with_len_N};/4096',data:[89.4,90.6,189,190,150]}
]}</script>
<div class="benchset" id="bs16"><h4><a id="bs94756718925776995960" href="#bs94756718925776995960">#</a>&nbsp;Convert to int &#39;1234567&#39;</h4>
<table><thead><tr><th>Benchmark name</th><th width="5%">Comment</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), Clang-21</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), GCC-13</th><th width="8%">Xeon E5-2682 v4, Windows 10, Clang-19</th><th width="8%">Xeon E5-2682 v4, Windows 10, MSVC-19</th><th width="8%">Xeon E5-2682 v4, WASM Chrome 143, Clang-21</th></tr></thead><tbody>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L801">std::string s = &quot;123456789&quot;; int res = std::strtol(s.c_str(), 0, 10);</a><span class="tooltiptext code">void ToIntStr10(benchmark::State&amp; state, const std::string&amp; s, int c) {
for (auto _: state) {
int res = std::strtol(s.c_str(), nullptr, 10);
#ifdef CHECK_RESULT
if (res != c) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(res);
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">В simstr для конвертации в число достаточно куска строки,
нет нужды в null терминированности. Ближайший аналог такого
поведения "std::from_chars", но он к сожалению очень ограничен
по возможностям. Здесь я попытался произвести тесты, близкие по
логике к работе std::from_chars
In simstr, a string fragment is sufficient for conversion to a number;
there's no need for null termination. The closest analog to this behavior
is "std::from_chars," but unfortunately, it is very limited in its capabilities.
Here, I attempted to run tests that are similar in logic to std::from_chars.</span></span></td><td class="benchmarkresult">27.4</td><td class="benchmarkresult">27.8</td><td class="benchmarkresult">31.3</td><td class="benchmarkresult">31.8</td><td class="benchmarkresult">91.8</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L840">std::string_view s = &quot;123456789&quot;; std::from_chars(s.data(), s.data() + s.size(), res, 10);</a><span class="tooltiptext code">void ToIntFromChars10(benchmark::State&amp; state, const std::string_view&amp; s, int c) {
for (auto _: state) {
int res = 0;
std::from_chars(s.data(), s.data() + s.size(), res, 10);
#ifdef CHECK_RESULT
if (res != c) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(res);
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">from_chars требует точного указания основания счисления,
не допускает знаков плюс, пробелов, префиксов 0x и т.п.
from_chars requires an exact radix specification and does not allow plus
signs, spaces, 0x prefixes, etc.</span></span></td><td class="benchmarkresult">12.9</td><td class="benchmarkresult">11.3</td><td class="benchmarkresult">13.6</td><td class="benchmarkresult">12.0</td><td class="benchmarkresult">0.732</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L868">stringa s = &quot;123456789&quot;; int res = s.to_int&lt;int, true, 10, false></a><span class="tooltiptext code">template&lt;typename T>
void ToIntSimStr10(benchmark::State&amp; state, T t, int c) {
for (auto _: state) {
int res = t. template to_int&lt;int, true, 10, false, false>().value;
#ifdef CHECK_RESULT
if (res != c) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(res);
benchmark::DoNotOptimize(t);
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">Здесь для to_int заданы такие же ограничения - проверять переполнение,
десятичная система, без лидирующих пробелов и знака плюс
Here, to_int has the same restrictions: check for overflow,
decimal system, no leading spaces, and no plus sign.</span></span></td><td class="benchmarkresult">9.54</td><td class="benchmarkresult">7.94</td><td class="benchmarkresult">13.4</td><td class="benchmarkresult">17.3</td><td class="benchmarkresult">18.7</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L868">ssa s = &quot;123456789&quot;; int res = s.to_int&lt;int, true, 10, false></a><span class="tooltiptext code">template&lt;typename T>
void ToIntSimStr10(benchmark::State&amp; state, T t, int c) {
for (auto _: state) {
int res = t. template to_int&lt;int, true, 10, false, false>().value;
#ifdef CHECK_RESULT
if (res != c) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(res);
benchmark::DoNotOptimize(t);
}
}</span></span></td><td></td><td class="benchmarkresult">9.23</td><td class="benchmarkresult">8.54</td><td class="benchmarkresult">12.5</td><td class="benchmarkresult">15.4</td><td class="benchmarkresult">17.2</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L868">lstringa&lt;20> s = &quot;123456789&quot;; int res = s.to_int&lt;int, true, 10, false></a><span class="tooltiptext code">template&lt;typename T>
void ToIntSimStr10(benchmark::State&amp; state, T t, int c) {
for (auto _: state) {
int res = t. template to_int&lt;int, true, 10, false, false>().value;
#ifdef CHECK_RESULT
if (res != c) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(res);
benchmark::DoNotOptimize(t);
}
}</span></span></td><td></td><td class="benchmarkresult">9.45</td><td class="benchmarkresult">7.90</td><td class="benchmarkresult">13.4</td><td class="benchmarkresult">14.8</td><td class="benchmarkresult">17.0</td></tr>
</tbody></table></div><script>bench_sets['Convert to int \'1234567\''] = {id:'bs16', tests:[
{name:'std::string s = "123456789"; int res = std::strtol(s.c_str(), 0, 10);',data:[27.4,27.8,31.3,31.8,91.8]},
{name:'std::string_view s = "123456789"; std::from_chars(s.data(), s.data() + s.size(), res, 10);',data:[12.9,11.3,13.6,12.0,0.732]},
{name:'stringa s = "123456789"; int res = s.to_int<int, true, 10, false>',data:[9.54,7.94,13.4,17.3,18.7]},
{name:'ssa s = "123456789"; int res = s.to_int<int, true, 10, false>',data:[9.23,8.54,12.5,15.4,17.2]},
{name:'lstringa<20> s = "123456789"; int res = s.to_int<int, true, 10, false>',data:[9.45,7.90,13.4,14.8,17.0]}
]}</script>
<div class="benchset" id="bs17"><h4><a id="bs182426078870126042750" href="#bs182426078870126042750">#</a>&nbsp;Convert to unsigned &#39;abcDef&#39;</h4>
<table><thead><tr><th>Benchmark name</th><th width="5%">Comment</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), Clang-21</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), GCC-13</th><th width="8%">Xeon E5-2682 v4, Windows 10, Clang-19</th><th width="8%">Xeon E5-2682 v4, Windows 10, MSVC-19</th><th width="8%">Xeon E5-2682 v4, WASM Chrome 143, Clang-21</th></tr></thead><tbody>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L814">std::string s = &quot;abcDef&quot;; int res = std::strtol(s.c_str(), 0, 16);</a><span class="tooltiptext code">void ToIntStr16(benchmark::State&amp; state, const std::string&amp; s, int c) {
for (auto _: state) {
int res = std::strtol(s.c_str(), nullptr, 16);
#ifdef CHECK_RESULT
if (res != c) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(res);
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">Всё то же, только для 16ричной системы
Everything is the same, only for the hexadecimal system</span></span></td><td class="benchmarkresult">23.7</td><td class="benchmarkresult">23.5</td><td class="benchmarkresult">33.4</td><td class="benchmarkresult">35.1</td><td class="benchmarkresult">66.6</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L854">std::string_view s = &quot;abcDef&quot;; std::from_chars(s.data(), s.data() + s.size(), res, 16);</a><span class="tooltiptext code">void ToIntFromChars16(benchmark::State&amp; state, const std::string_view&amp; s, int c) {
for (auto _: state) {
int res = 0;
std::from_chars(s.data(), s.data() + s.size(), res, 16);
#ifdef CHECK_RESULT
if (res != c) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(res);
}
}</span></span></td><td></td><td class="benchmarkresult">9.43</td><td class="benchmarkresult">9.03</td><td class="benchmarkresult">8.21</td><td class="benchmarkresult">8.95</td><td class="benchmarkresult">18.0</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L883">stringa s = &quot;abcDef&quot;; int res = s.to_int&lt;int, true, 16, false></a><span class="tooltiptext code">template&lt;typename T>
void ToIntSimStr16(benchmark::State&amp; state, T t, int c) {
for (auto _: state) {
int res = t. template to_int&lt;int, true, 16, false, false>().value;
#ifdef CHECK_RESULT
if (res != c) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(res);
benchmark::DoNotOptimize(t);
}
}</span></span></td><td></td><td class="benchmarkresult">7.59</td><td class="benchmarkresult">7.93</td><td class="benchmarkresult">12.3</td><td class="benchmarkresult">14.5</td><td class="benchmarkresult">17.9</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L883">ssa s = &quot;abcDef&quot;; int res = s.to_int&lt;int, true, 16, false></a><span class="tooltiptext code">template&lt;typename T>
void ToIntSimStr16(benchmark::State&amp; state, T t, int c) {
for (auto _: state) {
int res = t. template to_int&lt;int, true, 16, false, false>().value;
#ifdef CHECK_RESULT
if (res != c) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(res);
benchmark::DoNotOptimize(t);
}
}</span></span></td><td></td><td class="benchmarkresult">7.57</td><td class="benchmarkresult">7.49</td><td class="benchmarkresult">7.49</td><td class="benchmarkresult">12.3</td><td class="benchmarkresult">16.3</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L883">lstringa&lt;20> s = &quot;abcDef&quot;; int res = s.to_int&lt;int, true, 16, false></a><span class="tooltiptext code">template&lt;typename T>
void ToIntSimStr16(benchmark::State&amp; state, T t, int c) {
for (auto _: state) {
int res = t. template to_int&lt;int, true, 16, false, false>().value;
#ifdef CHECK_RESULT
if (res != c) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(res);
benchmark::DoNotOptimize(t);
}
}</span></span></td><td></td><td class="benchmarkresult">7.56</td><td class="benchmarkresult">7.49</td><td class="benchmarkresult">11.8</td><td class="benchmarkresult">13.1</td><td class="benchmarkresult">16.2</td></tr>
</tbody></table></div><script>bench_sets['Convert to unsigned \'abcDef\''] = {id:'bs17', tests:[
{name:'std::string s = "abcDef"; int res = std::strtol(s.c_str(), 0, 16);',data:[23.7,23.5,33.4,35.1,66.6]},
{name:'std::string_view s = "abcDef"; std::from_chars(s.data(), s.data() + s.size(), res, 16);',data:[9.43,9.03,8.21,8.95,18.0]},
{name:'stringa s = "abcDef"; int res = s.to_int<int, true, 16, false>',data:[7.59,7.93,12.3,14.5,17.9]},
{name:'ssa s = "abcDef"; int res = s.to_int<int, true, 16, false>',data:[7.57,7.49,7.49,12.3,16.3]},
{name:'lstringa<20> s = "abcDef"; int res = s.to_int<int, true, 16, false>',data:[7.56,7.49,11.8,13.1,16.2]}
]}</script>
<div class="benchset" id="bs18"><h4><a id="bs52606100125109966680" href="#bs52606100125109966680">#</a>&nbsp;Convert to int &#39; 1234567&#39;</h4>
<table><thead><tr><th>Benchmark name</th><th width="5%">Comment</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), Clang-21</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), GCC-13</th><th width="8%">Xeon E5-2682 v4, Windows 10, Clang-19</th><th width="8%">Xeon E5-2682 v4, Windows 10, MSVC-19</th><th width="8%">Xeon E5-2682 v4, WASM Chrome 143, Clang-21</th></tr></thead><tbody>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L827">std::string s = &quot; 123456789&quot;; int res = std::strtol(s.c_str(), 0, 0);</a><span class="tooltiptext code">void ToIntStr0(benchmark::State&amp; state, const std::string&amp; s, int c) {
for (auto _: state) {
int res = std::strtol(s.c_str(), nullptr, 0);
#ifdef CHECK_RESULT
if (res != c) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(res);
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">А здесь уже парсинг произвольного числа.
And here we have parsing of an arbitrary number.</span></span></td><td class="benchmarkresult">28.5</td><td class="benchmarkresult">29.2</td><td class="benchmarkresult">44.0</td><td class="benchmarkresult">46.9</td><td class="benchmarkresult">106</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L898">stringa s = &quot; 123456789&quot;; int res = s.to_int&lt;int>; // Check overflow</a><span class="tooltiptext code">template&lt;typename T>
void ToIntSimStr0(benchmark::State&amp; state, T t, int c) {
for (auto _: state) {
int res = t. template to_int&lt;int>().value;
#ifdef CHECK_RESULT
if (res != c) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(res);
benchmark::DoNotOptimize(t);
}
}</span></span></td><td></td><td class="benchmarkresult">11.5</td><td class="benchmarkresult">15.4</td><td class="benchmarkresult">16.3</td><td class="benchmarkresult">22.2</td><td class="benchmarkresult">14.7</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L913">ssa s = &quot; 123456789&quot;; int res = s.to_int&lt;int, false>; // No check overflow</a><span class="tooltiptext code">void ToIntNoOverflow(benchmark::State&amp; state, ssa t, int c) {
for (auto _: state) {
int res = t.to_int&lt;int, false>().value;
#ifdef CHECK_RESULT
if (res != c) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(res);
benchmark::DoNotOptimize(t);
}
}</span></span></td><td></td><td class="benchmarkresult">13.3</td><td class="benchmarkresult">13.5</td><td class="benchmarkresult">13.0</td><td class="benchmarkresult">18.8</td><td class="benchmarkresult">15.5</td></tr>
</tbody></table></div><script>bench_sets['Convert to int \' 1234567\''] = {id:'bs18', tests:[
{name:'std::string s = " 123456789"; int res = std::strtol(s.c_str(), 0, 0);',data:[28.5,29.2,44.0,46.9,106]},
{name:'stringa s = " 123456789"; int res = s.to_int<int>; // Check overflow',data:[11.5,15.4,16.3,22.2,14.7]},
{name:'ssa s = " 123456789"; int res = s.to_int<int, false>; // No check overflow',data:[13.3,13.5,13.0,18.8,15.5]}
]}</script>
<div class="benchset" id="bs19"><h4><a id="bs182348477702821075660" href="#bs182348477702821075660">#</a>&nbsp;Convert to double &#39;1234.567e10&#39;</h4>
<table><thead><tr><th>Benchmark name</th><th width="5%">Comment</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), Clang-21</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), GCC-13</th><th width="8%">Xeon E5-2682 v4, Windows 10, Clang-19</th><th width="8%">Xeon E5-2682 v4, Windows 10, MSVC-19</th><th width="8%">Xeon E5-2682 v4, WASM Chrome 143, Clang-21</th></tr></thead><tbody>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L943">std::string s = &quot;1234.567e10&quot;; double res = std::strtod(s.c_str(), nullptr);</a><span class="tooltiptext code">void ToDoubleStr(benchmark::State&amp; state, const std::string&amp; s, double c) {
for (auto _: state) {
char* ptr = nullptr;
double res = std::strtod(s.c_str(), &amp;ptr);
if (ptr == s.c_str()) {
state.SkipWithError(&quot;not equal&quot;);
}
#ifdef CHECK_RESULT
if (res != c) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(res);
}
}</span></span></td><td></td><td class="benchmarkresult">66.5</td><td class="benchmarkresult">64.3</td><td class="benchmarkresult">97.7</td><td class="benchmarkresult">100</td><td class="benchmarkresult">301</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L960">std::string_view s = &quot;1234.567e10&quot;; std::from_chars(s.data(), s.data() + s.size(), res);</a><span class="tooltiptext code">void ToDoubleFromChars(benchmark::State&amp; state, const std::string_view&amp; s, double c) {
for (auto _: state) {
double res = 0;
if (std::from_chars(s.data(), s.data() + s.size(), res).ec != std::errc{}) {
state.SkipWithError(&quot;not equal&quot;);
}
#ifdef CHECK_RESULT
if (res != c) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(res);
}
}</span></span></td><td></td><td class="benchmarkresult">24.0</td><td class="benchmarkresult">23.8</td><td class="benchmarkresult">60.5</td><td class="benchmarkresult">87.4</td><td class="benchmarkresult">106</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L976">ssa s = &quot;1234.567e10&quot;; double res = *s.to_double()</a><span class="tooltiptext code">template&lt;typename T>
void ToDoubleSimStr(benchmark::State&amp; state, T t, double c) {
for (auto _: state) {
auto r = t.template to_double&lt;false>();
if (!r) {
state.SkipWithError(&quot;not equal&quot;);
}
double res = *r;
#ifdef CHECK_RESULT
if (res != c) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(res);
benchmark::DoNotOptimize(t);
}
}</span></span></td><td></td><td class="benchmarkresult">26.0</td><td class="benchmarkresult">24.8</td><td class="benchmarkresult">36.2</td><td class="benchmarkresult">38.0</td><td class="benchmarkresult">41.1</td></tr>
</tbody></table></div><script>bench_sets['Convert to double \'1234.567e10\''] = {id:'bs19', tests:[
{name:'std::string s = "1234.567e10"; double res = std::strtod(s.c_str(), nullptr);',data:[66.5,64.3,97.7,100,301]},
{name:'std::string_view s = "1234.567e10"; std::from_chars(s.data(), s.data() + s.size(), res);',data:[24.0,23.8,60.5,87.4,106]},
{name:'ssa s = "1234.567e10"; double res = *s.to_double()',data:[26.0,24.8,36.2,38.0,41.1]}
]}</script>
<div class="benchset" id="bs20"><h4><a id="bs96505608161678391610" href="#bs96505608161678391610">#</a>&nbsp;Append const literal of 16 bytes 64 times, 1024 total length</h4>
<table><thead><tr><th>Benchmark name</th><th width="5%">Comment</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), Clang-21</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), GCC-13</th><th width="8%">Xeon E5-2682 v4, Windows 10, Clang-19</th><th width="8%">Xeon E5-2682 v4, Windows 10, MSVC-19</th><th width="8%">Xeon E5-2682 v4, WASM Chrome 143, Clang-21</th></tr></thead><tbody>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1000">std::stringstream str; ... str &lt;&lt; &quot;abbaabbaabbaabba&quot;;</a><span class="tooltiptext code">void AppendStreamConstLiteral(benchmark::State&amp; state) {
for (auto _: state) {
std::string result;
std::stringstream str;
for (size_t c = 0; c &lt; 64; c++) {
str &lt;&lt; TEXT_16;
}
result = str.str();
#ifdef CHECK_RESULT
if (result.size() != 1024) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(str);
}
}</span></span></td><td></td><td class="benchmarkresult">1388</td><td class="benchmarkresult">1348</td><td class="benchmarkresult">4713</td><td class="benchmarkresult">5729</td><td class="benchmarkresult">6596</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1019">std::string str; ... str += &quot;abbaabbaabbaabba&quot;;</a><span class="tooltiptext code">void AppendStdStringConstLiteral(benchmark::State&amp; state) {
for (auto _: state) {
std::string result;
for (size_t c = 0; c &lt; 64; c++) {
result += TEXT_16;
}
#ifdef CHECK_RESULT
if (result.size() != 1024) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
}
}</span></span></td><td></td><td class="benchmarkresult">368</td><td class="benchmarkresult">326</td><td class="benchmarkresult">1083</td><td class="benchmarkresult">1363</td><td class="benchmarkresult">858</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1035">lstringa&lt;8> str; ... str += &quot;abbaabbaabbaabba&quot;;</a><span class="tooltiptext code">template&lt;unsigned N>
void AppendLstringConstLiteral(benchmark::State&amp; state) {
for (auto _: state) {
lstringa&lt;N> result;
for (size_t c = 0; c &lt; 64; c++) {
result += TEXT_16;
}
#ifdef CHECK_RESULT
if (result.length() != 1024) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
}
}</span></span></td><td></td><td class="benchmarkresult">374</td><td class="benchmarkresult">358</td><td class="benchmarkresult">824</td><td class="benchmarkresult">970</td><td class="benchmarkresult">782</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1035">lstringa&lt;128> str; ... str += &quot;abbaabbaabbaabba&quot;;</a><span class="tooltiptext code">template&lt;unsigned N>
void AppendLstringConstLiteral(benchmark::State&amp; state) {
for (auto _: state) {
lstringa&lt;N> result;
for (size_t c = 0; c &lt; 64; c++) {
result += TEXT_16;
}
#ifdef CHECK_RESULT
if (result.length() != 1024) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">Чем больше внутренний буфер, тем меньше раз требуется
аллокация, тем быстрее результат.
The larger the internal buffer, the fewer allocations are
required, and the faster the result.</span></span></td><td class="benchmarkresult">233</td><td class="benchmarkresult">236</td><td class="benchmarkresult">391</td><td class="benchmarkresult">542</td><td class="benchmarkresult">591</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1035">lstringa&lt;512> str; ... str += &quot;abbaabbaabbaabba&quot;;</a><span class="tooltiptext code">template&lt;unsigned N>
void AppendLstringConstLiteral(benchmark::State&amp; state) {
for (auto _: state) {
lstringa&lt;N> result;
for (size_t c = 0; c &lt; 64; c++) {
result += TEXT_16;
}
#ifdef CHECK_RESULT
if (result.length() != 1024) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
}
}</span></span></td><td></td><td class="benchmarkresult">237</td><td class="benchmarkresult">211</td><td class="benchmarkresult">254</td><td class="benchmarkresult">369</td><td class="benchmarkresult">461</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1035">lstringa&lt;1024> str; ... str += &quot;abbaabbaabbaabba&quot;;</a><span class="tooltiptext code">template&lt;unsigned N>
void AppendLstringConstLiteral(benchmark::State&amp; state) {
for (auto _: state) {
lstringa&lt;N> result;
for (size_t c = 0; c &lt; 64; c++) {
result += TEXT_16;
}
#ifdef CHECK_RESULT
if (result.length() != 1024) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
}
}</span></span></td><td></td><td class="benchmarkresult">163</td><td class="benchmarkresult">140</td><td class="benchmarkresult">134</td><td class="benchmarkresult">230</td><td class="benchmarkresult">372</td></tr>
</tbody></table></div><script>bench_sets['Append const literal of 16 bytes 64 times, 1024 total length'] = {id:'bs20', tests:[
{name:'std::stringstream str; ... str << "abbaabbaabbaabba";',data:[1388,1348,4713,5729,6596]},
{name:'std::string str; ... str += "abbaabbaabbaabba";',data:[368,326,1083,1363,858]},
{name:'lstringa<8> str; ... str += "abbaabbaabbaabba";',data:[374,358,824,970,782]},
{name:'lstringa<128> str; ... str += "abbaabbaabbaabba";',data:[233,236,391,542,591]},
{name:'lstringa<512> str; ... str += "abbaabbaabbaabba";',data:[237,211,254,369,461]},
{name:'lstringa<1024> str; ... str += "abbaabbaabbaabba";',data:[163,140,134,230,372]}
]}</script>
<div class="benchset" id="bs21"><h4><a id="bs36931044816721597850" href="#bs36931044816721597850">#</a>&nbsp;Append string of 16 bytes and const literal of 16 bytes 32 times, 1024 total length</h4>
<table><thead><tr><th>Benchmark name</th><th width="5%">Comment</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), Clang-21</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), GCC-13</th><th width="8%">Xeon E5-2682 v4, Windows 10, Clang-19</th><th width="8%">Xeon E5-2682 v4, Windows 10, MSVC-19</th><th width="8%">Xeon E5-2682 v4, WASM Chrome 143, Clang-21</th></tr></thead><tbody>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1060">std::stringstream str; ... str &lt;&lt; str_var &lt;&lt; &quot;abbaabbaabbaabba&quot;;</a><span class="tooltiptext code">void AppendStreamStrConstLiteral(benchmark::State&amp; state) {
std::string s1 = TEXT_16;
for (auto _: state) {
std::string result;
std::stringstream s;
for (size_t c = 0; c &lt; 32; c++) {
s &lt;&lt; s1 &lt;&lt; TEXT_16;
}
result = s.str();
#ifdef CHECK_RESULT
if (result.size() != 1024) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(s1);
}
}</span></span></td><td></td><td class="benchmarkresult">1478</td><td class="benchmarkresult">1373</td><td class="benchmarkresult">4606</td><td class="benchmarkresult">5840</td><td class="benchmarkresult">7324</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1080">std::string str; ... str += str_var + &quot;abbaabbaabbaabba&quot;;</a><span class="tooltiptext code">void AppendStdStrStrConstLiteral(benchmark::State&amp; state) {
std::string p1 = TEXT_16;
for (auto _: state) {
std::string result;
for (size_t c = 0; c &lt; 32; c++) {
result += p1 + TEXT_16;
}
#ifdef CHECK_RESULT
if (result.size() != 1024) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(p1);
}
}</span></span></td><td></td><td class="benchmarkresult">1286</td><td class="benchmarkresult">1249</td><td class="benchmarkresult">3825</td><td class="benchmarkresult">3841</td><td class="benchmarkresult">2429</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1098">lstringa&lt;8> str; ... str += str_var + &quot;abbaabbaabbaabba&quot;;</a><span class="tooltiptext code">template&lt;unsigned N>
void AppendLstringStrConstLiteral(benchmark::State&amp; state) {
stringa p1 = TEXT_16;
for (auto _: state) {
lstringa&lt;N> result;
for (size_t c = 0; c &lt; 32; c++) {
result += p1 + TEXT_16;
}
#ifdef CHECK_RESULT
if (result.length() != 1024) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(p1);
}
}</span></span></td><td></td><td class="benchmarkresult">435</td><td class="benchmarkresult">401</td><td class="benchmarkresult">746</td><td class="benchmarkresult">856</td><td class="benchmarkresult">1035</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1098">lstringa&lt;128> str; ... str += str_var + &quot;abbaabbaabbaabba&quot;;</a><span class="tooltiptext code">template&lt;unsigned N>
void AppendLstringStrConstLiteral(benchmark::State&amp; state) {
stringa p1 = TEXT_16;
for (auto _: state) {
lstringa&lt;N> result;
for (size_t c = 0; c &lt; 32; c++) {
result += p1 + TEXT_16;
}
#ifdef CHECK_RESULT
if (result.length() != 1024) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(p1);
}
}</span></span></td><td></td><td class="benchmarkresult">336</td><td class="benchmarkresult">355</td><td class="benchmarkresult">468</td><td class="benchmarkresult">542</td><td class="benchmarkresult">886</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1098">lstringa&lt;512> str; ... str += str_var + &quot;abbaabbaabbaabba&quot;;</a><span class="tooltiptext code">template&lt;unsigned N>
void AppendLstringStrConstLiteral(benchmark::State&amp; state) {
stringa p1 = TEXT_16;
for (auto _: state) {
lstringa&lt;N> result;
for (size_t c = 0; c &lt; 32; c++) {
result += p1 + TEXT_16;
}
#ifdef CHECK_RESULT
if (result.length() != 1024) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(p1);
}
}</span></span></td><td></td><td class="benchmarkresult">280</td><td class="benchmarkresult">300</td><td class="benchmarkresult">303</td><td class="benchmarkresult">391</td><td class="benchmarkresult">745</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1098">lstringa&lt;1024> str; ... str += str_var + &quot;abbaabbaabbaabba&quot;;</a><span class="tooltiptext code">template&lt;unsigned N>
void AppendLstringStrConstLiteral(benchmark::State&amp; state) {
stringa p1 = TEXT_16;
for (auto _: state) {
lstringa&lt;N> result;
for (size_t c = 0; c &lt; 32; c++) {
result += p1 + TEXT_16;
}
#ifdef CHECK_RESULT
if (result.length() != 1024) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(p1);
}
}</span></span></td><td></td><td class="benchmarkresult">214</td><td class="benchmarkresult">249</td><td class="benchmarkresult">184</td><td class="benchmarkresult">288</td><td class="benchmarkresult">685</td></tr>
</tbody></table></div><script>bench_sets['Append string of 16 bytes and const literal of 16 bytes 32 times, 1024 total length'] = {id:'bs21', tests:[
{name:'std::stringstream str; ... str << str_var << "abbaabbaabbaabba";',data:[1478,1373,4606,5840,7324]},
{name:'std::string str; ... str += str_var + "abbaabbaabbaabba";',data:[1286,1249,3825,3841,2429]},
{name:'lstringa<8> str; ... str += str_var + "abbaabbaabbaabba";',data:[435,401,746,856,1035]},
{name:'lstringa<128> str; ... str += str_var + "abbaabbaabbaabba";',data:[336,355,468,542,886]},
{name:'lstringa<512> str; ... str += str_var + "abbaabbaabbaabba";',data:[280,300,303,391,745]},
{name:'lstringa<1024> str; ... str += str_var + "abbaabbaabbaabba";',data:[214,249,184,288,685]}
]}</script>
<div class="benchset" id="bs22"><h4><a id="bs8293767858383349360" href="#bs8293767858383349360">#</a>&nbsp;Append string of 16 bytes and const literal of 16 bytes 2048 times, 65536 total length</h4>
<table><thead><tr><th>Benchmark name</th><th width="5%">Comment</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), Clang-21</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), GCC-13</th><th width="8%">Xeon E5-2682 v4, Windows 10, Clang-19</th><th width="8%">Xeon E5-2682 v4, Windows 10, MSVC-19</th><th width="8%">Xeon E5-2682 v4, WASM Chrome 143, Clang-21</th></tr></thead><tbody>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1126">std::stringstream str; ... str &lt;&lt; str_var &lt;&lt; &quot;abbaabbaabbaabba&quot;; 2048 times</a><span class="tooltiptext code">void AppendStreamStrConstLiteralBig(benchmark::State&amp; state) {
std::string s1 = TEXT_16;
for (auto _: state) {
std::string result;
std::stringstream s;
for (size_t c = 0; c &lt; 2048; c++) {
s &lt;&lt; s1 &lt;&lt; TEXT_16;
}
result = s.str();
#ifdef CHECK_RESULT
if (result.size() != 1024 * 64) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(s1);
}
}</span></span></td><td></td><td class="benchmarkresult">119217</td><td class="benchmarkresult">118986</td><td class="benchmarkresult">224278</td><td class="benchmarkresult">288424</td><td class="benchmarkresult">367555</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1146">std::string str; ... str += str_var + &quot;abbaabbaabbaabba&quot;; 2048 times</a><span class="tooltiptext code">void AppendStdStrStrConstLiteralBig(benchmark::State&amp; state) {
std::string p1 = TEXT_16;
for (auto _: state) {
std::string result;
for (size_t c = 0; c &lt; 2048; c++) {
result += p1 + TEXT_16;
}
#ifdef CHECK_RESULT
if (result.size() != 1024 * 64) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(p1);
}
}</span></span></td><td></td><td class="benchmarkresult">72734</td><td class="benchmarkresult">73469</td><td class="benchmarkresult">192363</td><td class="benchmarkresult">189131</td><td class="benchmarkresult">128555</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1164">lstringa&lt;8> str; ... str += str_var + &quot;abbaabbaabbaabba&quot;; 2048 times</a><span class="tooltiptext code">template&lt;unsigned N>
void AppendLstringStrConstLiteralBig(benchmark::State&amp; state) {
stringa p1 = TEXT_16;
for (auto _: state) {
lstringa&lt;N> result;
for (size_t c = 0; c &lt; 2048; c++) {
result += p1 + TEXT_16;
}
#ifdef CHECK_RESULT
if (result.length() != 1024 * 64) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(p1);
}
}</span></span></td><td></td><td class="benchmarkresult">46679</td><td class="benchmarkresult">47566</td><td class="benchmarkresult">20974</td><td class="benchmarkresult">24955</td><td class="benchmarkresult">51145</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1164">lstringa&lt;128> str; ... str += str_var + &quot;abbaabbaabbaabba&quot;; 2048 times</a><span class="tooltiptext code">template&lt;unsigned N>
void AppendLstringStrConstLiteralBig(benchmark::State&amp; state) {
stringa p1 = TEXT_16;
for (auto _: state) {
lstringa&lt;N> result;
for (size_t c = 0; c &lt; 2048; c++) {
result += p1 + TEXT_16;
}
#ifdef CHECK_RESULT
if (result.length() != 1024 * 64) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(p1);
}
}</span></span></td><td></td><td class="benchmarkresult">28145</td><td class="benchmarkresult">26208</td><td class="benchmarkresult">16889</td><td class="benchmarkresult">21987</td><td class="benchmarkresult">48871</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1164">lstringa&lt;512> str; ... str += str_var + &quot;abbaabbaabbaabba&quot;; 2048 times</a><span class="tooltiptext code">template&lt;unsigned N>
void AppendLstringStrConstLiteralBig(benchmark::State&amp; state) {
stringa p1 = TEXT_16;
for (auto _: state) {
lstringa&lt;N> result;
for (size_t c = 0; c &lt; 2048; c++) {
result += p1 + TEXT_16;
}
#ifdef CHECK_RESULT
if (result.length() != 1024 * 64) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(p1);
}
}</span></span></td><td></td><td class="benchmarkresult">19090</td><td class="benchmarkresult">20362</td><td class="benchmarkresult">16287</td><td class="benchmarkresult">22099</td><td class="benchmarkresult">49022</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1164">lstringa&lt;1024> str; ... str += str_var + &quot;abbaabbaabbaabba&quot;; 2048 times</a><span class="tooltiptext code">template&lt;unsigned N>
void AppendLstringStrConstLiteralBig(benchmark::State&amp; state) {
stringa p1 = TEXT_16;
for (auto _: state) {
lstringa&lt;N> result;
for (size_t c = 0; c &lt; 2048; c++) {
result += p1 + TEXT_16;
}
#ifdef CHECK_RESULT
if (result.length() != 1024 * 64) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(p1);
}
}</span></span></td><td></td><td class="benchmarkresult">16083</td><td class="benchmarkresult">16214</td><td class="benchmarkresult">16280</td><td class="benchmarkresult">23376</td><td class="benchmarkresult">47869</td></tr>
</tbody></table></div><script>bench_sets['Append string of 16 bytes and const literal of 16 bytes 2048 times, 65536 total length'] = {id:'bs22', tests:[
{name:'std::stringstream str; ... str << str_var << "abbaabbaabbaabba"; 2048 times',data:[119217,118986,224278,288424,367555]},
{name:'std::string str; ... str += str_var + "abbaabbaabbaabba"; 2048 times',data:[72734,73469,192363,189131,128555]},
{name:'lstringa<8> str; ... str += str_var + "abbaabbaabbaabba"; 2048 times',data:[46679,47566,20974,24955,51145]},
{name:'lstringa<128> str; ... str += str_var + "abbaabbaabbaabba"; 2048 times',data:[28145,26208,16889,21987,48871]},
{name:'lstringa<512> str; ... str += str_var + "abbaabbaabbaabba"; 2048 times',data:[19090,20362,16287,22099,49022]},
{name:'lstringa<1024> str; ... str += str_var + "abbaabbaabbaabba"; 2048 times',data:[16083,16214,16280,23376,47869]}
]}</script>
<div class="benchset" id="bs23"><h4><a id="bs66949588770596833730" href="#bs66949588770596833730">#</a>&nbsp;Append 2 string of 16 bytes 32 times, 1024 total length</h4>
<table><thead><tr><th>Benchmark name</th><th width="5%">Comment</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), Clang-21</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), GCC-13</th><th width="8%">Xeon E5-2682 v4, Windows 10, Clang-19</th><th width="8%">Xeon E5-2682 v4, Windows 10, MSVC-19</th><th width="8%">Xeon E5-2682 v4, WASM Chrome 143, Clang-21</th></tr></thead><tbody>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1191">std::stringstream str; ... str &lt;&lt; str_var1 &lt;&lt; str_var2;</a><span class="tooltiptext code">void AppendStream2String(benchmark::State&amp; state) {
std::string s1 = TEXT_16;
std::string s2 = TEXT_16;
for (auto _: state) {
std::string result;
std::stringstream s;
for (size_t c = 0; c &lt; 32; c++) {
s &lt;&lt; s1 &lt;&lt; s2;
}
result = s.str();
#ifdef CHECK_RESULT
if (result.size() != 1024) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(s1);
benchmark::DoNotOptimize(s2);
}
}</span></span></td><td></td><td class="benchmarkresult">1398</td><td class="benchmarkresult">1401</td><td class="benchmarkresult">4491</td><td class="benchmarkresult">5471</td><td class="benchmarkresult">7371</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1213">std::string str; ... str += str_var1 + str_var2;</a><span class="tooltiptext code">void AppendStdStr2String(benchmark::State&amp; state) {
std::string s1 = TEXT_16;
std::string s2 = TEXT_16;
for (auto _: state) {
std::string result;
for (size_t c = 0; c &lt; 32; c++) {
result += s1 + s2;
}
#ifdef CHECK_RESULT
if (result.size() != 1024) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(s1);
benchmark::DoNotOptimize(s2);
}
}</span></span></td><td></td><td class="benchmarkresult">1396</td><td class="benchmarkresult">1418</td><td class="benchmarkresult">4048</td><td class="benchmarkresult">4091</td><td class="benchmarkresult">2705</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1234">lstringa&lt;16> str; ... str += str_var1 + str_var2;</a><span class="tooltiptext code">template&lt;unsigned N>
void AppendLstring2String(benchmark::State&amp; state) {
stra s1 = TEXT_16;
stra s2 = TEXT_16;
for (auto _: state) {
lstringa&lt;N> result;
for (size_t c = 0; c &lt; 32; c++) {
result += s1 + s2;
}
#ifdef CHECK_RESULT
if (result.length() != 1024) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(s1);
benchmark::DoNotOptimize(s2);
}
}</span></span></td><td></td><td class="benchmarkresult">489</td><td class="benchmarkresult">484</td><td class="benchmarkresult">813</td><td class="benchmarkresult">933</td><td class="benchmarkresult">1272</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1234">lstringa&lt;128> str; ... str += str_var1 + str_var2;</a><span class="tooltiptext code">template&lt;unsigned N>
void AppendLstring2String(benchmark::State&amp; state) {
stra s1 = TEXT_16;
stra s2 = TEXT_16;
for (auto _: state) {
lstringa&lt;N> result;
for (size_t c = 0; c &lt; 32; c++) {
result += s1 + s2;
}
#ifdef CHECK_RESULT
if (result.length() != 1024) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(s1);
benchmark::DoNotOptimize(s2);
}
}</span></span></td><td></td><td class="benchmarkresult">404</td><td class="benchmarkresult">418</td><td class="benchmarkresult">526</td><td class="benchmarkresult">641</td><td class="benchmarkresult">1198</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1234">lstringa&lt;512> str; ... str += str_var1 + str_var2;</a><span class="tooltiptext code">template&lt;unsigned N>
void AppendLstring2String(benchmark::State&amp; state) {
stra s1 = TEXT_16;
stra s2 = TEXT_16;
for (auto _: state) {
lstringa&lt;N> result;
for (size_t c = 0; c &lt; 32; c++) {
result += s1 + s2;
}
#ifdef CHECK_RESULT
if (result.length() != 1024) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(s1);
benchmark::DoNotOptimize(s2);
}
}</span></span></td><td></td><td class="benchmarkresult">374</td><td class="benchmarkresult">371</td><td class="benchmarkresult">398</td><td class="benchmarkresult">483</td><td class="benchmarkresult">1033</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1234">lstringa&lt;1024> str; ... str += str_var1 + str_var2;</a><span class="tooltiptext code">template&lt;unsigned N>
void AppendLstring2String(benchmark::State&amp; state) {
stra s1 = TEXT_16;
stra s2 = TEXT_16;
for (auto _: state) {
lstringa&lt;N> result;
for (size_t c = 0; c &lt; 32; c++) {
result += s1 + s2;
}
#ifdef CHECK_RESULT
if (result.length() != 1024) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(s1);
benchmark::DoNotOptimize(s2);
}
}</span></span></td><td></td><td class="benchmarkresult">292</td><td class="benchmarkresult">320</td><td class="benchmarkresult">295</td><td class="benchmarkresult">389</td><td class="benchmarkresult">960</td></tr>
</tbody></table></div><script>bench_sets['Append 2 string of 16 bytes 32 times, 1024 total length'] = {id:'bs23', tests:[
{name:'std::stringstream str; ... str << str_var1 << str_var2;',data:[1398,1401,4491,5471,7371]},
{name:'std::string str; ... str += str_var1 + str_var2;',data:[1396,1418,4048,4091,2705]},
{name:'lstringa<16> str; ... str += str_var1 + str_var2;',data:[489,484,813,933,1272]},
{name:'lstringa<128> str; ... str += str_var1 + str_var2;',data:[404,418,526,641,1198]},
{name:'lstringa<512> str; ... str += str_var1 + str_var2;',data:[374,371,398,483,1033]},
{name:'lstringa<1024> str; ... str += str_var1 + str_var2;',data:[292,320,295,389,960]}
]}</script>
<div class="benchset" id="bs24"><h4><a id="bs130432147582115154460" href="#bs130432147582115154460">#</a>&nbsp;Append text, number, text</h4>
<table><thead><tr><th>Benchmark name</th><th width="5%">Comment</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), Clang-21</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), GCC-13</th><th width="8%">Xeon E5-2682 v4, Windows 10, Clang-19</th><th width="8%">Xeon E5-2682 v4, Windows 10, MSVC-19</th><th width="8%">Xeon E5-2682 v4, WASM Chrome 143, Clang-21</th></tr></thead><tbody>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1263">std::stringstream str; str &lt;&lt; &quot;test = &quot; &lt;&lt; k &lt;&lt; &quot; times&quot;;</a><span class="tooltiptext code">void AppendStreamStrNumStr(benchmark::State&amp; state) {
for (auto _: state) {
for (unsigned k = 1; k &lt;= 1&#39;000&#39;000&#39;000; k *= 10) {
std::stringstream t;
t &lt;&lt; &quot;test = &quot; &lt;&lt; k &lt;&lt; &quot; times&quot;;
std::string result = t.str();
#ifdef CHECK_RESULT
if (!result.starts_with(&quot;test = &quot;) || !result.ends_with(&quot; times&quot;)) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(k);
}
}
}</span></span></td><td></td><td class="benchmarkresult">3075</td><td class="benchmarkresult">3267</td><td class="benchmarkresult">10555</td><td class="benchmarkresult">12668</td><td class="benchmarkresult">11807</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1281">std::string str = &quot;test = &quot; + std::to_string(k) + &quot; times&quot;;</a><span class="tooltiptext code">void AppendStdStringStrNumStr(benchmark::State&amp; state) {
for (auto _: state) {
for (unsigned k = 1; k &lt;= 1&#39;000&#39;000&#39;000; k *= 10) {
std::string result = &quot;test = &quot; + std::to_string(k) + &quot; times&quot;;
#ifdef CHECK_RESULT
if (!result.starts_with(&quot;test = &quot;) || !result.ends_with(&quot; times&quot;)) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(k);
}
}
}</span></span></td><td></td><td class="benchmarkresult">444</td><td class="benchmarkresult">434</td><td class="benchmarkresult">1061</td><td class="benchmarkresult">1270</td><td class="benchmarkresult">1850</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1297">char buf[100]; sprintf(buf, &quot;test = %u times&quot;, k); std::string str = buf;</a><span class="tooltiptext code">void AppendSprintfStrNumStr(benchmark::State&amp; state) {
for (auto _: state) {
for (unsigned k = 1; k &lt;= 1&#39;000&#39;000&#39;000; k *= 10) {
char buf[100];
std::sprintf(buf, &quot;test = %u times&quot;, k);
std::string result = buf;
#ifdef CHECK_RESULT
if (!result.starts_with(&quot;test = &quot;) || !result.ends_with(&quot; times&quot;)) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(k);
}
}
}</span></span></td><td></td><td class="benchmarkresult">1377</td><td class="benchmarkresult">1519</td><td class="benchmarkresult">2843</td><td class="benchmarkresult">2806</td><td class="benchmarkresult">5459</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1315">std::string str = std::format(&quot;test = {} times&quot;, k);</a><span class="tooltiptext code">void AppendFormatStrNumStr(benchmark::State&amp; state) {
for (auto _: state) {
for (unsigned k = 1; k &lt;= 1&#39;000&#39;000&#39;000; k *= 10) {
std::string result = std::format(&quot;test = {} times&quot;, k);
#ifdef CHECK_RESULT
if (!result.starts_with(&quot;test = &quot;) || !result.ends_with(&quot; times&quot;)) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(k);
}
}
}</span></span></td><td></td><td class="benchmarkresult">1125</td><td class="benchmarkresult">1497</td><td class="benchmarkresult">1908</td><td class="benchmarkresult">2376</td><td class="benchmarkresult">2886</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1331">lstringa&lt;8> str; str.format(&quot;test = {} times&quot;, k);</a><span class="tooltiptext code">template&lt;typename T>
void AppendSimStrStrNumStrF(benchmark::State&amp; state) {
for (auto _: state) {
for (unsigned k = 1; k &lt;= 1&#39;000&#39;000&#39;000; k *= 10) {
T result;
result.format(&quot;test = {} times&quot;, k);
#ifdef CHECK_RESULT
if (!result.starts_with(&quot;test = &quot;) || !result.ends_with(&quot; times&quot;)) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(k);
}
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">В simstr format с первого раза не помещается в такую строку без аллокации.
In simstr format, the first time it doesn't fit into such a
string without allocation.</span></span></td><td class="benchmarkresult">1386</td><td class="benchmarkresult">1586</td><td class="benchmarkresult">2056</td><td class="benchmarkresult">2630</td><td class="benchmarkresult">4975</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1331">lstringa&lt;32> str; str.format(&quot;test = {} times&quot;, k);</a><span class="tooltiptext code">template&lt;typename T>
void AppendSimStrStrNumStrF(benchmark::State&amp; state) {
for (auto _: state) {
for (unsigned k = 1; k &lt;= 1&#39;000&#39;000&#39;000; k *= 10) {
T result;
result.format(&quot;test = {} times&quot;, k);
#ifdef CHECK_RESULT
if (!result.starts_with(&quot;test = &quot;) || !result.ends_with(&quot; times&quot;)) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(k);
}
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">А в такую помещается. Используйте сразу буфера подходящего размера.
And it fits in this one. Use buffers of the appropriate size right away.</span></span></td><td class="benchmarkresult">1021</td><td class="benchmarkresult">1126</td><td class="benchmarkresult">1029</td><td class="benchmarkresult">1546</td><td class="benchmarkresult">4261</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1349">lstringa&lt;8> str = &quot;test = &quot; + k + &quot; times&quot;;</a><span class="tooltiptext code">template&lt;typename T>
void AppendSimStrStrNumStr(benchmark::State&amp; state) {
for (auto _: state) {
for (unsigned k = 1; k &lt;= 1&#39;000&#39;000&#39;000; k *= 10) {
T result = &quot;test = &quot;_ss + k + &quot; times&quot;;
#ifdef CHECK_RESULT
if (!result.starts_with(&quot;test = &quot;) || !result.ends_with(&quot; times&quot;)) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(k);
}
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">Результат не помещается в SSO, возникает аллокация.
The result does not fit into SSO, an allocation occurs.</span></span></td><td class="benchmarkresult">282</td><td class="benchmarkresult">315</td><td class="benchmarkresult">832</td><td class="benchmarkresult">925</td><td class="benchmarkresult">592</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1349">lstringa&lt;32> str = &quot;test = &quot; + k + &quot; times&quot;;</a><span class="tooltiptext code">template&lt;typename T>
void AppendSimStrStrNumStr(benchmark::State&amp; state) {
for (auto _: state) {
for (unsigned k = 1; k &lt;= 1&#39;000&#39;000&#39;000; k *= 10) {
T result = &quot;test = &quot;_ss + k + &quot; times&quot;;
#ifdef CHECK_RESULT
if (!result.starts_with(&quot;test = &quot;) || !result.ends_with(&quot; times&quot;)) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(k);
}
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">А здесь и ниже - результат укладывается в SSO.
Ещё раз - используйте сразу буфера подходящего размера.
And here and below, the result fits within SSO.
Once again, use appropriately sized buffers from the start.</span></span></td><td class="benchmarkresult">127</td><td class="benchmarkresult">154</td><td class="benchmarkresult">138</td><td class="benchmarkresult">173</td><td class="benchmarkresult">376</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1349">stringa str = &quot;test = &quot; + k + &quot; times&quot;;</a><span class="tooltiptext code">template&lt;typename T>
void AppendSimStrStrNumStr(benchmark::State&amp; state) {
for (auto _: state) {
for (unsigned k = 1; k &lt;= 1&#39;000&#39;000&#39;000; k *= 10) {
T result = &quot;test = &quot;_ss + k + &quot; times&quot;;
#ifdef CHECK_RESULT
if (!result.starts_with(&quot;test = &quot;) || !result.ends_with(&quot; times&quot;)) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(k);
}
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">Под WASM размер SSO 15 символов, что явно не хватает для размещения
результата, отсюда и такое время.
Under WASM, the SSO size is 15 characters, which is clearly not
enough to accommodate the result, hence the long time.</span></span></td><td class="benchmarkresult">123</td><td class="benchmarkresult">133</td><td class="benchmarkresult">123</td><td class="benchmarkresult">180</td><td class="benchmarkresult">573</td></tr>
</tbody></table></div><script>bench_sets['Append text, number, text'] = {id:'bs24', tests:[
{name:'std::stringstream str; str << "test = " << k << " times";',data:[3075,3267,10555,12668,11807]},
{name:'std::string str = "test = " + std::to_string(k) + " times";',data:[444,434,1061,1270,1850]},
{name:'char buf[100]; sprintf(buf, "test = %u times", k); std::string str = buf;',data:[1377,1519,2843,2806,5459]},
{name:'std::string str = std::format("test = {} times", k);',data:[1125,1497,1908,2376,2886]},
{name:'lstringa<8> str; str.format("test = {} times", k);',data:[1386,1586,2056,2630,4975]},
{name:'lstringa<32> str; str.format("test = {} times", k);',data:[1021,1126,1029,1546,4261]},
{name:'lstringa<8> str = "test = " + k + " times";',data:[282,315,832,925,592]},
{name:'lstringa<32> str = "test = " + k + " times";',data:[127,154,138,173,376]},
{name:'stringa str = "test = " + k + " times";',data:[123,133,123,180,573]}
]}</script>
<div class="benchset" id="bs25"><h4><a id="bs7106975351756760120" href="#bs7106975351756760120">#</a>&nbsp;Split text and convert to int</h4>
<table><thead><tr><th>Benchmark name</th><th width="5%">Comment</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), Clang-21</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), GCC-13</th><th width="8%">Xeon E5-2682 v4, Windows 10, Clang-19</th><th width="8%">Xeon E5-2682 v4, Windows 10, MSVC-19</th><th width="8%">Xeon E5-2682 v4, WASM Chrome 143, Clang-21</th></tr></thead><tbody>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1379">std::string::find + substr + std::strtol</a><span class="tooltiptext code">void SplitConvertIntStdString(benchmark::State&amp; state) {
std::string numbers = NUMBER_LIST;
for (auto _: state) {
int total = 0;
for (size_t start = 0; start &lt; numbers.length(); ) {
int delim = numbers.find(&quot;-!-&quot;, start);
if (delim == std::string::npos) {
delim = numbers.size();
}
std::string part = numbers.substr(start, delim - start);
total += std::strtol(part.c_str(), nullptr, 0);
start = delim + 3;
}
#ifdef CHECK_RESULT
if (total != 218) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(total);
benchmark::DoNotOptimize(numbers);
}
}</span></span></td><td></td><td class="benchmarkresult">265</td><td class="benchmarkresult">265</td><td class="benchmarkresult">549</td><td class="benchmarkresult">556</td><td class="benchmarkresult">693</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1403">ssa::splitter + ssa::as_int</a><span class="tooltiptext code">void SplitConvertIntSimStr(benchmark::State&amp; state) {
stra numbers = NUMBER_LIST;
for (auto _: state) {
int total = 0;
for (auto splitter = numbers.splitter(&quot;-!-&quot;); !splitter.is_done();) {
total += splitter.next().as_int&lt;int>();
}
#ifdef CHECK_RESULT
if (total != 218) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(total);
benchmark::DoNotOptimize(numbers);
}
}</span></span></td><td></td><td class="benchmarkresult">155</td><td class="benchmarkresult">143</td><td class="benchmarkresult">164</td><td class="benchmarkresult">302</td><td class="benchmarkresult">240</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1420">ssa::splitf + functor</a><span class="tooltiptext code">void SplitConvertIntSplitf(benchmark::State&amp; state) {
stra numbers = NUMBER_LIST;
for (auto _: state) {
int total = 0;
numbers.splitf&lt;void>(&quot;-!-&quot;, [&amp;](ssa&amp; part){total += part.as_int&lt;int>();});
#ifdef CHECK_RESULT
if (total != 218) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(total);
benchmark::DoNotOptimize(numbers);
}
}</span></span></td><td></td><td class="benchmarkresult">206</td><td class="benchmarkresult">125</td><td class="benchmarkresult">188</td><td class="benchmarkresult">216</td><td class="benchmarkresult">281</td></tr>
</tbody></table></div><script>bench_sets['Split text and convert to int'] = {id:'bs25', tests:[
{name:'std::string::find + substr + std::strtol',data:[265,265,549,556,693]},
{name:'ssa::splitter + ssa::as_int',data:[155,143,164,302,240]},
{name:'ssa::splitf + functor',data:[206,125,188,216,281]}
]}</script>
<div class="benchset" id="bs26"><h4><a id="bs151373809886162287550" href="#bs151373809886162287550">#</a>&nbsp;Replace symbols in text ~400 symbols</h4>
<table><thead><tr><th>Benchmark name</th><th width="5%">Comment</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), Clang-21</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), GCC-13</th><th width="8%">Xeon E5-2682 v4, Windows 10, Clang-19</th><th width="8%">Xeon E5-2682 v4, Windows 10, MSVC-19</th><th width="8%">Xeon E5-2682 v4, WASM Chrome 143, Clang-21</th></tr></thead><tbody>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1441">Naive (and wrong) replace symbols with std::string find + replace</a><span class="tooltiptext code">void ReplaceSymbolsStdStringNaiveWrong(benchmark::State&amp; state) {
std::string_view source =
&quot;abcdefg124 &lt; jhsfjsh sjdfsh jfhjd &amp;&amp; jdjdj >&quot;
&quot; ksjd-fksjd \&quot;dkjfs-jkhdf dfj &#39; kdkd \&quot;dkfdkfkdjf&quot;
&quot;abcdefg124 &lt; jhsfjsh sjdfsh jfhjd &amp;&amp; jdjdj >&quot;
&quot; ksjd-fksjd \&quot;dkjfs-jkhdf dfj &#39; kdkd \&quot;dkfdkfkdjf&quot;
&quot;abcdefg124 &lt; jhsfjsh sjdfsh jfhjd &amp;&amp; jdjdj >&quot;
&quot; ksjd-fksjd \&quot;dkjfs-jkhdf dfj &#39; kdkd \&quot;dkfdkfkdjf&quot;
&quot;abcdefg124 &lt; jhsfjsh sjdfsh jfhjd &amp;&amp; jdjdj >&quot;
&quot; ksjd-fksjd \&quot;dkjfs-jkhdf dfj &#39; kdkd \&quot;dkfdkfkdjf&quot;
;
std::vector&lt;std::pair&lt;u8s, std::string_view>> repl = {
{&#39;&amp;&#39;, &quot;&amp;amp;&quot;},
{&#39;-&#39;, &quot;&quot;},
{&#39;&lt;&#39;, &quot;&amp;lt;&quot;},
{&#39;>&#39;, &quot;&amp;gt;&quot;},
{&#39;\&#39;&#39;, &quot;&amp;#39;&quot;},
{&#39;\&quot;&#39;, &quot;&amp;quot;&quot;}
};
auto repl_all = [](std::string&amp; str, char s, std::string_view repl) {
size_t start_pos = 0;
while((start_pos = str.find(s, start_pos)) != std::string::npos) {
str.replace(start_pos, 1, repl);
start_pos += repl.length();
}
};
for (auto _: state) {
std::string result{source};
for (const auto&amp; r : repl) {
repl_all(result, r.first, r.second);
}
#ifdef CHECK_RESULT
if (result
!=
&quot;abcdefg124 &amp;lt; jhsfjsh sjdfsh jfhjd &amp;amp;&amp;amp; jdjdj &amp;gt;&quot;
&quot; ksjdfksjd &amp;quot;dkjfsjkhdf dfj &amp;#39; kdkd &amp;quot;dkfdkfkdjf&quot;
&quot;abcdefg124 &amp;lt; jhsfjsh sjdfsh jfhjd &amp;amp;&amp;amp; jdjdj &amp;gt;&quot;
&quot; ksjdfksjd &amp;quot;dkjfsjkhdf dfj &amp;#39; kdkd &amp;quot;dkfdkfkdjf&quot;
&quot;abcdefg124 &amp;lt; jhsfjsh sjdfsh jfhjd &amp;amp;&amp;amp; jdjdj &amp;gt;&quot;
&quot; ksjdfksjd &amp;quot;dkjfsjkhdf dfj &amp;#39; kdkd &amp;quot;dkfdkfkdjf&quot;
&quot;abcdefg124 &amp;lt; jhsfjsh sjdfsh jfhjd &amp;amp;&amp;amp; jdjdj &amp;gt;&quot;
&quot; ksjdfksjd &amp;quot;dkjfsjkhdf dfj &amp;#39; kdkd &amp;quot;dkfdkfkdjf&quot;
) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(source);
benchmark::DoNotOptimize(repl);
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">Это наивная реализация, которая неверно отработает на
таких заменах, как 'a'->'b' и 'b'->'a'. Но если замены не конфликтуют,
то работает быстро.
This is a naive implementation that will fail to handle substitutions
such as 'a'->'b' and 'b'->'a'. But if the substitutions don't conflict,
it works quickly.</span></span></td><td class="benchmarkresult">841</td><td class="benchmarkresult">837</td><td class="benchmarkresult">1161</td><td class="benchmarkresult">1259</td><td class="benchmarkresult">2875</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1495">replace symbols with std::string find_first_of + replace</a><span class="tooltiptext code">void ReplaceSymbolsStdStringNaiveRight(benchmark::State&amp; state) {
std::string_view source =
&quot;abcdefg124 &lt; jhsfjsh sjdfsh jfhjd &amp;&amp; jdjdj >&quot;
&quot; ksjd-fksjd \&quot;dkjfs-jkhdf dfj &#39; kdkd \&quot;dkfdkfkdjf&quot;
&quot;abcdefg124 &lt; jhsfjsh sjdfsh jfhjd &amp;&amp; jdjdj >&quot;
&quot; ksjd-fksjd \&quot;dkjfs-jkhdf dfj &#39; kdkd \&quot;dkfdkfkdjf&quot;
&quot;abcdefg124 &lt; jhsfjsh sjdfsh jfhjd &amp;&amp; jdjdj >&quot;
&quot; ksjd-fksjd \&quot;dkjfs-jkhdf dfj &#39; kdkd \&quot;dkfdkfkdjf&quot;
&quot;abcdefg124 &lt; jhsfjsh sjdfsh jfhjd &amp;&amp; jdjdj >&quot;
&quot; ksjd-fksjd \&quot;dkjfs-jkhdf dfj &#39; kdkd \&quot;dkfdkfkdjf&quot;
;
std::vector&lt;std::pair&lt;u8s, std::string_view>> repl = {
{&#39;-&#39;, &quot;&quot;},
{&#39;&lt;&#39;, &quot;&amp;lt;&quot;},
{&#39;>&#39;, &quot;&amp;gt;&quot;},
{&#39;\&#39;&#39;, &quot;&amp;#39;&quot;},
{&#39;\&quot;&#39;, &quot;&amp;quot;&quot;},
{&#39;&amp;&#39;, &quot;&amp;amp;&quot;},
};
for (auto _: state) {
std::string result{source};
std::string pattern;
for (const auto&amp; r : repl) {
pattern += r.first;
}
size_t start_pos = 0;
while((start_pos = result.find_first_of(pattern, start_pos)) != std::string::npos) {
size_t idx = pattern.find(result[start_pos]);
result.replace(start_pos, 1, repl[idx].second);
start_pos += repl[idx].second.length();
}
#ifdef CHECK_RESULT
if (result
!=
&quot;abcdefg124 &amp;lt; jhsfjsh sjdfsh jfhjd &amp;amp;&amp;amp; jdjdj &amp;gt;&quot;
&quot; ksjdfksjd &amp;quot;dkjfsjkhdf dfj &amp;#39; kdkd &amp;quot;dkfdkfkdjf&quot;
&quot;abcdefg124 &amp;lt; jhsfjsh sjdfsh jfhjd &amp;amp;&amp;amp; jdjdj &amp;gt;&quot;
&quot; ksjdfksjd &amp;quot;dkjfsjkhdf dfj &amp;#39; kdkd &amp;quot;dkfdkfkdjf&quot;
&quot;abcdefg124 &amp;lt; jhsfjsh sjdfsh jfhjd &amp;amp;&amp;amp; jdjdj &amp;gt;&quot;
&quot; ksjdfksjd &amp;quot;dkjfsjkhdf dfj &amp;#39; kdkd &amp;quot;dkfdkfkdjf&quot;
&quot;abcdefg124 &amp;lt; jhsfjsh sjdfsh jfhjd &amp;amp;&amp;amp; jdjdj &amp;gt;&quot;
&quot; ksjdfksjd &amp;quot;dkjfsjkhdf dfj &amp;#39; kdkd &amp;quot;dkfdkfkdjf&quot;
) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(source);
benchmark::DoNotOptimize(repl);
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">Дальше уже правильные реализации, не зависящие от конфликтующих замен.
Further, there are correct implementations that do not depend on
conflicting replacements.</span></span></td><td class="benchmarkresult">2450</td><td class="benchmarkresult">2361</td><td class="benchmarkresult">2012</td><td class="benchmarkresult">2262</td><td class="benchmarkresult">5461</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1549">replace symbols with std::string_view find_first_of + copy</a><span class="tooltiptext code">void ReplaceSymbolsStdString(benchmark::State&amp; state) {
std::string_view source =
&quot;abcdefg124 &lt; jhsfjsh sjdfsh jfhjd &amp;&amp; jdjdj >&quot;
&quot; ksjd-fksjd \&quot;dkjfs-jkhdf dfj &#39; kdkd \&quot;dkfdkfkdjf&quot;
&quot;abcdefg124 &lt; jhsfjsh sjdfsh jfhjd &amp;&amp; jdjdj >&quot;
&quot; ksjd-fksjd \&quot;dkjfs-jkhdf dfj &#39; kdkd \&quot;dkfdkfkdjf&quot;
&quot;abcdefg124 &lt; jhsfjsh sjdfsh jfhjd &amp;&amp; jdjdj >&quot;
&quot; ksjd-fksjd \&quot;dkjfs-jkhdf dfj &#39; kdkd \&quot;dkfdkfkdjf&quot;
&quot;abcdefg124 &lt; jhsfjsh sjdfsh jfhjd &amp;&amp; jdjdj >&quot;
&quot; ksjd-fksjd \&quot;dkjfs-jkhdf dfj &#39; kdkd \&quot;dkfdkfkdjf&quot;
;
const std::string_view repl_from = &quot;-&lt;>&#39;\&quot;&amp;&quot;;
const std::string_view repl_to[] = {&quot;&quot;, &quot;&amp;lt;&quot;, &quot;&amp;gt;&quot;, &quot;&amp;#39;&quot;, &quot;&amp;quot;&quot;, &quot;&amp;amp;&quot;};
for (auto _: state) {
std::string result;
for (size_t start = 0; start &lt; source.size();) {
size_t idx = source.find_first_of(repl_from, start);
if (idx == std::string::npos) {
result += source.substr(start);
break;
}
if (idx > start) {
result += source.substr(start, idx - start);
}
size_t what = repl_from.find(source[idx]);
result += repl_to[what];
start = idx + 1;
}
#ifdef CHECK_RESULT
if (result
!=
&quot;abcdefg124 &amp;lt; jhsfjsh sjdfsh jfhjd &amp;amp;&amp;amp; jdjdj &amp;gt;&quot;
&quot; ksjdfksjd &amp;quot;dkjfsjkhdf dfj &amp;#39; kdkd &amp;quot;dkfdkfkdjf&quot;
&quot;abcdefg124 &amp;lt; jhsfjsh sjdfsh jfhjd &amp;amp;&amp;amp; jdjdj &amp;gt;&quot;
&quot; ksjdfksjd &amp;quot;dkjfsjkhdf dfj &amp;#39; kdkd &amp;quot;dkfdkfkdjf&quot;
&quot;abcdefg124 &amp;lt; jhsfjsh sjdfsh jfhjd &amp;amp;&amp;amp; jdjdj &amp;gt;&quot;
&quot; ksjdfksjd &amp;quot;dkjfsjkhdf dfj &amp;#39; kdkd &amp;quot;dkfdkfkdjf&quot;
&quot;abcdefg124 &amp;lt; jhsfjsh sjdfsh jfhjd &amp;amp;&amp;amp; jdjdj &amp;gt;&quot;
&quot; ksjdfksjd &amp;quot;dkjfsjkhdf dfj &amp;#39; kdkd &amp;quot;dkfdkfkdjf&quot;
) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(source);
}
}</span></span></td><td></td><td class="benchmarkresult">1078</td><td class="benchmarkresult">965</td><td class="benchmarkresult">2385</td><td class="benchmarkresult">2618</td><td class="benchmarkresult">3004</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1602">replace runtime symbols with string expressions and without remembering all search results</a><span class="tooltiptext code">template&lt;bool UseVector>
void ReplaceSymbolsDynPatternSimStr(benchmark::State&amp; state) {
stra source =
&quot;abcdefg124 &lt; jhsfjsh sjdfsh jfhjd &amp;&amp; jdjdj >&quot;
&quot; ksjd-fksjd \&quot;dkjfs-jkhdf dfj &#39; kdkd \&quot;dkfdkfkdjf&quot;
&quot;abcdefg124 &lt; jhsfjsh sjdfsh jfhjd &amp;&amp; jdjdj >&quot;
&quot; ksjd-fksjd \&quot;dkjfs-jkhdf dfj &#39; kdkd \&quot;dkfdkfkdjf&quot;
&quot;abcdefg124 &lt; jhsfjsh sjdfsh jfhjd &amp;&amp; jdjdj >&quot;
&quot; ksjd-fksjd \&quot;dkjfs-jkhdf dfj &#39; kdkd \&quot;dkfdkfkdjf&quot;
&quot;abcdefg124 &lt; jhsfjsh sjdfsh jfhjd &amp;&amp; jdjdj >&quot;
&quot; ksjd-fksjd \&quot;dkjfs-jkhdf dfj &#39; kdkd \&quot;dkfdkfkdjf&quot;
;
std::vector&lt;std::pair&lt;u8s, ssa>> repl = {
{&#39;-&#39;, &quot;&quot;},
{&#39;&lt;&#39;, &quot;&amp;lt;&quot;},
{&#39;>&#39;, &quot;&amp;gt;&quot;},
{&#39;\&#39;&#39;, &quot;&amp;#39;&quot;},
{&#39;\&quot;&#39;, &quot;&amp;quot;&quot;},
{&#39;&amp;&#39;, &quot;&amp;amp;&quot;},
};
for (auto _: state) {
stringa result = expr_replace_symbols&lt;u8s, UseVector>{source, repl};
#ifdef CHECK_RESULT
if (result
!=
&quot;abcdefg124 &amp;lt; jhsfjsh sjdfsh jfhjd &amp;amp;&amp;amp; jdjdj &amp;gt;&quot;
&quot; ksjdfksjd &amp;quot;dkjfsjkhdf dfj &amp;#39; kdkd &amp;quot;dkfdkfkdjf&quot;
&quot;abcdefg124 &amp;lt; jhsfjsh sjdfsh jfhjd &amp;amp;&amp;amp; jdjdj &amp;gt;&quot;
&quot; ksjdfksjd &amp;quot;dkjfsjkhdf dfj &amp;#39; kdkd &amp;quot;dkfdkfkdjf&quot;
&quot;abcdefg124 &amp;lt; jhsfjsh sjdfsh jfhjd &amp;amp;&amp;amp; jdjdj &amp;gt;&quot;
&quot; ksjdfksjd &amp;quot;dkjfsjkhdf dfj &amp;#39; kdkd &amp;quot;dkfdkfkdjf&quot;
&quot;abcdefg124 &amp;lt; jhsfjsh sjdfsh jfhjd &amp;amp;&amp;amp; jdjdj &amp;gt;&quot;
&quot; ksjdfksjd &amp;quot;dkjfsjkhdf dfj &amp;#39; kdkd &amp;quot;dkfdkfkdjf&quot;
) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(source);
benchmark::DoNotOptimize(repl);
}
}</span></span></td><td></td><td class="benchmarkresult">1274</td><td class="benchmarkresult">1436</td><td class="benchmarkresult">1607</td><td class="benchmarkresult">1689</td><td class="benchmarkresult">2942</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1602">replace runtime symbols with simstr and memorization of all search results</a><span class="tooltiptext code">template&lt;bool UseVector>
void ReplaceSymbolsDynPatternSimStr(benchmark::State&amp; state) {
stra source =
&quot;abcdefg124 &lt; jhsfjsh sjdfsh jfhjd &amp;&amp; jdjdj >&quot;
&quot; ksjd-fksjd \&quot;dkjfs-jkhdf dfj &#39; kdkd \&quot;dkfdkfkdjf&quot;
&quot;abcdefg124 &lt; jhsfjsh sjdfsh jfhjd &amp;&amp; jdjdj >&quot;
&quot; ksjd-fksjd \&quot;dkjfs-jkhdf dfj &#39; kdkd \&quot;dkfdkfkdjf&quot;
&quot;abcdefg124 &lt; jhsfjsh sjdfsh jfhjd &amp;&amp; jdjdj >&quot;
&quot; ksjd-fksjd \&quot;dkjfs-jkhdf dfj &#39; kdkd \&quot;dkfdkfkdjf&quot;
&quot;abcdefg124 &lt; jhsfjsh sjdfsh jfhjd &amp;&amp; jdjdj >&quot;
&quot; ksjd-fksjd \&quot;dkjfs-jkhdf dfj &#39; kdkd \&quot;dkfdkfkdjf&quot;
;
std::vector&lt;std::pair&lt;u8s, ssa>> repl = {
{&#39;-&#39;, &quot;&quot;},
{&#39;&lt;&#39;, &quot;&amp;lt;&quot;},
{&#39;>&#39;, &quot;&amp;gt;&quot;},
{&#39;\&#39;&#39;, &quot;&amp;#39;&quot;},
{&#39;\&quot;&#39;, &quot;&amp;quot;&quot;},
{&#39;&amp;&#39;, &quot;&amp;amp;&quot;},
};
for (auto _: state) {
stringa result = expr_replace_symbols&lt;u8s, UseVector>{source, repl};
#ifdef CHECK_RESULT
if (result
!=
&quot;abcdefg124 &amp;lt; jhsfjsh sjdfsh jfhjd &amp;amp;&amp;amp; jdjdj &amp;gt;&quot;
&quot; ksjdfksjd &amp;quot;dkjfsjkhdf dfj &amp;#39; kdkd &amp;quot;dkfdkfkdjf&quot;
&quot;abcdefg124 &amp;lt; jhsfjsh sjdfsh jfhjd &amp;amp;&amp;amp; jdjdj &amp;gt;&quot;
&quot; ksjdfksjd &amp;quot;dkjfsjkhdf dfj &amp;#39; kdkd &amp;quot;dkfdkfkdjf&quot;
&quot;abcdefg124 &amp;lt; jhsfjsh sjdfsh jfhjd &amp;amp;&amp;amp; jdjdj &amp;gt;&quot;
&quot; ksjdfksjd &amp;quot;dkjfsjkhdf dfj &amp;#39; kdkd &amp;quot;dkfdkfkdjf&quot;
&quot;abcdefg124 &amp;lt; jhsfjsh sjdfsh jfhjd &amp;amp;&amp;amp; jdjdj &amp;gt;&quot;
&quot; ksjdfksjd &amp;quot;dkjfsjkhdf dfj &amp;#39; kdkd &amp;quot;dkfdkfkdjf&quot;
) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(source);
benchmark::DoNotOptimize(repl);
}
}</span></span></td><td></td><td class="benchmarkresult">1053</td><td class="benchmarkresult">1067</td><td class="benchmarkresult">1371</td><td class="benchmarkresult">1490</td><td class="benchmarkresult">2367</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1649">replace const symbols with string expressions and without remembering all search results</a><span class="tooltiptext code">template&lt;bool UseVector>
void ReplaceSymbolsCons2PatternSimStr(benchmark::State&amp; state) {
stra source =
&quot;abcdefg124 &lt; jhsfjsh sjdfsh jfhjd &amp;&amp; jdjdj >&quot;
&quot; ksjd-fksjd \&quot;dkjfs-jkhdf dfj &#39; kdkd \&quot;dkfdkfkdjf&quot;
&quot;abcdefg124 &lt; jhsfjsh sjdfsh jfhjd &amp;&amp; jdjdj >&quot;
&quot; ksjd-fksjd \&quot;dkjfs-jkhdf dfj &#39; kdkd \&quot;dkfdkfkdjf&quot;
&quot;abcdefg124 &lt; jhsfjsh sjdfsh jfhjd &amp;&amp; jdjdj >&quot;
&quot; ksjd-fksjd \&quot;dkjfs-jkhdf dfj &#39; kdkd \&quot;dkfdkfkdjf&quot;
&quot;abcdefg124 &lt; jhsfjsh sjdfsh jfhjd &amp;&amp; jdjdj >&quot;
&quot; ksjd-fksjd \&quot;dkjfs-jkhdf dfj &#39; kdkd \&quot;dkfdkfkdjf&quot;
;
for (auto _: state) {
stringa result = e_repl_const_symbols&lt;UseVector>(source,
&#39;-&#39;, &quot;&quot;,
&#39;&lt;&#39;, &quot;&amp;lt;&quot;,
&#39;>&#39;, &quot;&amp;gt;&quot;,
&#39;\&#39;&#39;, &quot;&amp;#39;&quot;,
&#39;\&quot;&#39;, &quot;&amp;quot;&quot;,
&#39;&amp;&#39;, &quot;&amp;amp;&quot;
);
#ifdef CHECK_RESULT
if (result
!=
&quot;abcdefg124 &amp;lt; jhsfjsh sjdfsh jfhjd &amp;amp;&amp;amp; jdjdj &amp;gt;&quot;
&quot; ksjdfksjd &amp;quot;dkjfsjkhdf dfj &amp;#39; kdkd &amp;quot;dkfdkfkdjf&quot;
&quot;abcdefg124 &amp;lt; jhsfjsh sjdfsh jfhjd &amp;amp;&amp;amp; jdjdj &amp;gt;&quot;
&quot; ksjdfksjd &amp;quot;dkjfsjkhdf dfj &amp;#39; kdkd &amp;quot;dkfdkfkdjf&quot;
&quot;abcdefg124 &amp;lt; jhsfjsh sjdfsh jfhjd &amp;amp;&amp;amp; jdjdj &amp;gt;&quot;
&quot; ksjdfksjd &amp;quot;dkjfsjkhdf dfj &amp;#39; kdkd &amp;quot;dkfdkfkdjf&quot;
&quot;abcdefg124 &amp;lt; jhsfjsh sjdfsh jfhjd &amp;amp;&amp;amp; jdjdj &amp;gt;&quot;
&quot; ksjdfksjd &amp;quot;dkjfsjkhdf dfj &amp;#39; kdkd &amp;quot;dkfdkfkdjf&quot;
) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(source);
}
}</span></span></td><td></td><td class="benchmarkresult">1009</td><td class="benchmarkresult">1246</td><td class="benchmarkresult">1229</td><td class="benchmarkresult">1255</td><td class="benchmarkresult">2442</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1649">replace const symbols with string expressions and memorization of all search results</a><span class="tooltiptext code">template&lt;bool UseVector>
void ReplaceSymbolsCons2PatternSimStr(benchmark::State&amp; state) {
stra source =
&quot;abcdefg124 &lt; jhsfjsh sjdfsh jfhjd &amp;&amp; jdjdj >&quot;
&quot; ksjd-fksjd \&quot;dkjfs-jkhdf dfj &#39; kdkd \&quot;dkfdkfkdjf&quot;
&quot;abcdefg124 &lt; jhsfjsh sjdfsh jfhjd &amp;&amp; jdjdj >&quot;
&quot; ksjd-fksjd \&quot;dkjfs-jkhdf dfj &#39; kdkd \&quot;dkfdkfkdjf&quot;
&quot;abcdefg124 &lt; jhsfjsh sjdfsh jfhjd &amp;&amp; jdjdj >&quot;
&quot; ksjd-fksjd \&quot;dkjfs-jkhdf dfj &#39; kdkd \&quot;dkfdkfkdjf&quot;
&quot;abcdefg124 &lt; jhsfjsh sjdfsh jfhjd &amp;&amp; jdjdj >&quot;
&quot; ksjd-fksjd \&quot;dkjfs-jkhdf dfj &#39; kdkd \&quot;dkfdkfkdjf&quot;
;
for (auto _: state) {
stringa result = e_repl_const_symbols&lt;UseVector>(source,
&#39;-&#39;, &quot;&quot;,
&#39;&lt;&#39;, &quot;&amp;lt;&quot;,
&#39;>&#39;, &quot;&amp;gt;&quot;,
&#39;\&#39;&#39;, &quot;&amp;#39;&quot;,
&#39;\&quot;&#39;, &quot;&amp;quot;&quot;,
&#39;&amp;&#39;, &quot;&amp;amp;&quot;
);
#ifdef CHECK_RESULT
if (result
!=
&quot;abcdefg124 &amp;lt; jhsfjsh sjdfsh jfhjd &amp;amp;&amp;amp; jdjdj &amp;gt;&quot;
&quot; ksjdfksjd &amp;quot;dkjfsjkhdf dfj &amp;#39; kdkd &amp;quot;dkfdkfkdjf&quot;
&quot;abcdefg124 &amp;lt; jhsfjsh sjdfsh jfhjd &amp;amp;&amp;amp; jdjdj &amp;gt;&quot;
&quot; ksjdfksjd &amp;quot;dkjfsjkhdf dfj &amp;#39; kdkd &amp;quot;dkfdkfkdjf&quot;
&quot;abcdefg124 &amp;lt; jhsfjsh sjdfsh jfhjd &amp;amp;&amp;amp; jdjdj &amp;gt;&quot;
&quot; ksjdfksjd &amp;quot;dkjfsjkhdf dfj &amp;#39; kdkd &amp;quot;dkfdkfkdjf&quot;
&quot;abcdefg124 &amp;lt; jhsfjsh sjdfsh jfhjd &amp;amp;&amp;amp; jdjdj &amp;gt;&quot;
&quot; ksjdfksjd &amp;quot;dkjfsjkhdf dfj &amp;#39; kdkd &amp;quot;dkfdkfkdjf&quot;
) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(source);
}
}</span></span></td><td></td><td class="benchmarkresult">883</td><td class="benchmarkresult">850</td><td class="benchmarkresult">1149</td><td class="benchmarkresult">1217</td><td class="benchmarkresult">2031</td></tr>
</tbody></table></div><script>bench_sets['Replace symbols in text ~400 symbols'] = {id:'bs26', tests:[
{name:'Naive (and wrong) replace symbols with std::string find + replace',data:[841,837,1161,1259,2875]},
{name:'replace symbols with std::string find_first_of + replace',data:[2450,2361,2012,2262,5461]},
{name:'replace symbols with std::string_view find_first_of + copy',data:[1078,965,2385,2618,3004]},
{name:'replace runtime symbols with string expressions and without remembering all search results',data:[1274,1436,1607,1689,2942]},
{name:'replace runtime symbols with simstr and memorization of all search results',data:[1053,1067,1371,1490,2367]},
{name:'replace const symbols with string expressions and without remembering all search results',data:[1009,1246,1229,1255,2442]},
{name:'replace const symbols with string expressions and memorization of all search results',data:[883,850,1149,1217,2031]}
]}</script>
<div class="benchset" id="bs27"><h4><a id="bs96756339547767401190" href="#bs96756339547767401190">#</a>&nbsp;Replace symbols in text ~40 symbols</h4>
<table><thead><tr><th>Benchmark name</th><th width="5%">Comment</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), Clang-21</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), GCC-13</th><th width="8%">Xeon E5-2682 v4, Windows 10, Clang-19</th><th width="8%">Xeon E5-2682 v4, Windows 10, MSVC-19</th><th width="8%">Xeon E5-2682 v4, WASM Chrome 143, Clang-21</th></tr></thead><tbody>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1703">Short Naive (and wrong) replace symbols with std::string find + replace</a><span class="tooltiptext code">void ShortReplaceSymbolsStdStringNaiveWrong(benchmark::State&amp; state) {
std::string_view source =
&quot;abcdefg124 &lt; jhsfjsh sjdfsh jfhjd &amp;&amp; jdjdj >&quot;
;
std::vector&lt;std::pair&lt;u8s, std::string_view>> repl = {
{&#39;&amp;&#39;, &quot;&amp;amp;&quot;},
{&#39;-&#39;, &quot;&quot;},
{&#39;&lt;&#39;, &quot;&amp;lt;&quot;},
{&#39;>&#39;, &quot;&amp;gt;&quot;},
{&#39;\&#39;&#39;, &quot;&amp;#39;&quot;},
{&#39;\&quot;&#39;, &quot;&amp;quot;&quot;}
};
auto repl_all = [](std::string&amp; str, char s, std::string_view repl) {
size_t start_pos = 0;
while((start_pos = str.find(s, start_pos)) != std::string::npos) {
str.replace(start_pos, 1, repl);
start_pos += repl.length();
}
};
for (auto _: state) {
std::string result{source};
for (const auto&amp; r : repl) {
repl_all(result, r.first, r.second);
}
#ifdef CHECK_RESULT
if (result
!=
&quot;abcdefg124 &amp;lt; jhsfjsh sjdfsh jfhjd &amp;amp;&amp;amp; jdjdj &amp;gt;&quot;
) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(source);
benchmark::DoNotOptimize(repl);
}
}</span></span></td><td></td><td class="benchmarkresult">165</td><td class="benchmarkresult">158</td><td class="benchmarkresult">307</td><td class="benchmarkresult">330</td><td class="benchmarkresult">516</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1743">Short replace symbols with std::string find_first_of + replace</a><span class="tooltiptext code">void ShortReplaceSymbolsStdStringNaiveRight(benchmark::State&amp; state) {
std::string_view source =
&quot;abcdefg124 &lt; jhsfjsh sjdfsh jfhjd &amp;&amp; jdjdj >&quot;
;
std::vector&lt;std::pair&lt;u8s, std::string_view>> repl = {
{&#39;-&#39;, &quot;&quot;},
{&#39;&lt;&#39;, &quot;&amp;lt;&quot;},
{&#39;>&#39;, &quot;&amp;gt;&quot;},
{&#39;\&#39;&#39;, &quot;&amp;#39;&quot;},
{&#39;\&quot;&#39;, &quot;&amp;quot;&quot;},
{&#39;&amp;&#39;, &quot;&amp;amp;&quot;},
};
for (auto _: state) {
std::string result{source};
std::string pattern;
for (const auto&amp; r : repl) {
pattern += r.first;
}
size_t start_pos = 0;
while((start_pos = result.find_first_of(pattern, start_pos)) != std::string::npos) {
size_t idx = pattern.find(result[start_pos]);
result.replace(start_pos, 1, repl[idx].second);
start_pos += repl[idx].second.length();
}
#ifdef CHECK_RESULT
if (result
!=
&quot;abcdefg124 &amp;lt; jhsfjsh sjdfsh jfhjd &amp;amp;&amp;amp; jdjdj &amp;gt;&quot;
) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(source);
benchmark::DoNotOptimize(repl);
}
}</span></span></td><td></td><td class="benchmarkresult">318</td><td class="benchmarkresult">338</td><td class="benchmarkresult">358</td><td class="benchmarkresult">423</td><td class="benchmarkresult">774</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1783">Short replace symbols with std::string_view find_first_of + copy</a><span class="tooltiptext code">void ShortReplaceSymbolsStdString(benchmark::State&amp; state) {
std::string_view source =
&quot;abcdefg124 &lt; jhsfjsh sjdfsh jfhjd &amp;&amp; jdjdj >&quot;
;
const std::string_view repl_from = &quot;-&lt;>&#39;\&quot;&amp;&quot;;
const std::string_view repl_to[] = {&quot;&quot;, &quot;&amp;lt;&quot;, &quot;&amp;gt;&quot;, &quot;&amp;#39;&quot;, &quot;&amp;quot;&quot;, &quot;&amp;amp;&quot;};
for (auto _: state) {
std::string result;
for (size_t start = 0; start &lt; source.size();) {
size_t idx = source.find_first_of(repl_from, start);
if (idx == std::string::npos) {
result += source.substr(start);
break;
}
if (idx > start) {
result += source.substr(start, idx - start);
}
size_t what = repl_from.find_first_of(source[idx]);
result += repl_to[what];
start = idx + 1;
}
#ifdef CHECK_RESULT
if (result
!=
&quot;abcdefg124 &amp;lt; jhsfjsh sjdfsh jfhjd &amp;amp;&amp;amp; jdjdj &amp;gt;&quot;
) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(source);
}
}</span></span></td><td></td><td class="benchmarkresult">152</td><td class="benchmarkresult">160</td><td class="benchmarkresult">313</td><td class="benchmarkresult">350</td><td class="benchmarkresult">439</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1822">Short replace runtime symbols with string expressions and without remembering all search results</a><span class="tooltiptext code">template&lt;bool UseVector>
void ShortReplaceSymbolsDynPatternSimStr(benchmark::State&amp; state) {
stra source =
&quot;abcdefg124 &lt; jhsfjsh sjdfsh jfhjd &amp;&amp; jdjdj >&quot;
;
std::vector&lt;std::pair&lt;u8s, ssa>> repl = {
{&#39;-&#39;, &quot;&quot;},
{&#39;&lt;&#39;, &quot;&amp;lt;&quot;},
{&#39;>&#39;, &quot;&amp;gt;&quot;},
{&#39;\&#39;&#39;, &quot;&amp;#39;&quot;},
{&#39;\&quot;&#39;, &quot;&amp;quot;&quot;},
{&#39;&amp;&#39;, &quot;&amp;amp;&quot;},
};
for (auto _: state) {
stringa result = expr_replace_symbols&lt;u8s, UseVector>{source, repl};
#ifdef CHECK_RESULT
if (result
!=
&quot;abcdefg124 &amp;lt; jhsfjsh sjdfsh jfhjd &amp;amp;&amp;amp; jdjdj &amp;gt;&quot;
) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(source);
benchmark::DoNotOptimize(repl);
}
}</span></span></td><td></td><td class="benchmarkresult">163</td><td class="benchmarkresult">204</td><td class="benchmarkresult">276</td><td class="benchmarkresult">312</td><td class="benchmarkresult">389</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1822">Short replace runtime symbols with simstr and memorization of all search results</a><span class="tooltiptext code">template&lt;bool UseVector>
void ShortReplaceSymbolsDynPatternSimStr(benchmark::State&amp; state) {
stra source =
&quot;abcdefg124 &lt; jhsfjsh sjdfsh jfhjd &amp;&amp; jdjdj >&quot;
;
std::vector&lt;std::pair&lt;u8s, ssa>> repl = {
{&#39;-&#39;, &quot;&quot;},
{&#39;&lt;&#39;, &quot;&amp;lt;&quot;},
{&#39;>&#39;, &quot;&amp;gt;&quot;},
{&#39;\&#39;&#39;, &quot;&amp;#39;&quot;},
{&#39;\&quot;&#39;, &quot;&amp;quot;&quot;},
{&#39;&amp;&#39;, &quot;&amp;amp;&quot;},
};
for (auto _: state) {
stringa result = expr_replace_symbols&lt;u8s, UseVector>{source, repl};
#ifdef CHECK_RESULT
if (result
!=
&quot;abcdefg124 &amp;lt; jhsfjsh sjdfsh jfhjd &amp;amp;&amp;amp; jdjdj &amp;gt;&quot;
) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(source);
benchmark::DoNotOptimize(repl);
}
}</span></span></td><td></td><td class="benchmarkresult">187</td><td class="benchmarkresult">193</td><td class="benchmarkresult">345</td><td class="benchmarkresult">418</td><td class="benchmarkresult">439</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1855">Short replace const symbols with string expressions and without remembering all search results</a><span class="tooltiptext code">template&lt;bool UseVector>
void ShortReplaceSymbolsCons2PatternSimStr(benchmark::State&amp; state) {
stra source =
&quot;abcdefg124 &lt; jhsfjsh sjdfsh jfhjd &amp;&amp; jdjdj >&quot;
;
for (auto _: state) {
stringa result = e_repl_const_symbols&lt;UseVector>(source,
&#39;-&#39;, &quot;&quot;,
&#39;&lt;&#39;, &quot;&amp;lt;&quot;,
&#39;>&#39;, &quot;&amp;gt;&quot;,
&#39;\&#39;&#39;, &quot;&amp;#39;&quot;,
&#39;\&quot;&#39;, &quot;&amp;quot;&quot;,
&#39;&amp;&#39;, &quot;&amp;amp;&quot;
);
#ifdef CHECK_RESULT
if (result
!=
&quot;abcdefg124 &amp;lt; jhsfjsh sjdfsh jfhjd &amp;amp;&amp;amp; jdjdj &amp;gt;&quot;
) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(source);
}
}</span></span></td><td></td><td class="benchmarkresult">126</td><td class="benchmarkresult">150</td><td class="benchmarkresult">212</td><td class="benchmarkresult">252</td><td class="benchmarkresult">292</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1855">Short replace const symbols with string expressions and memorization of all search results</a><span class="tooltiptext code">template&lt;bool UseVector>
void ShortReplaceSymbolsCons2PatternSimStr(benchmark::State&amp; state) {
stra source =
&quot;abcdefg124 &lt; jhsfjsh sjdfsh jfhjd &amp;&amp; jdjdj >&quot;
;
for (auto _: state) {
stringa result = e_repl_const_symbols&lt;UseVector>(source,
&#39;-&#39;, &quot;&quot;,
&#39;&lt;&#39;, &quot;&amp;lt;&quot;,
&#39;>&#39;, &quot;&amp;gt;&quot;,
&#39;\&#39;&#39;, &quot;&amp;#39;&quot;,
&#39;\&quot;&#39;, &quot;&amp;quot;&quot;,
&#39;&amp;&#39;, &quot;&amp;amp;&quot;
);
#ifdef CHECK_RESULT
if (result
!=
&quot;abcdefg124 &amp;lt; jhsfjsh sjdfsh jfhjd &amp;amp;&amp;amp; jdjdj &amp;gt;&quot;
) {
state.SkipWithError(&quot;not equal&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(source);
}
}</span></span></td><td></td><td class="benchmarkresult">147</td><td class="benchmarkresult">140</td><td class="benchmarkresult">294</td><td class="benchmarkresult">325</td><td class="benchmarkresult">320</td></tr>
</tbody></table></div><script>bench_sets['Replace symbols in text ~40 symbols'] = {id:'bs27', tests:[
{name:'Short Naive (and wrong) replace symbols with std::string find + replace',data:[165,158,307,330,516]},
{name:'Short replace symbols with std::string find_first_of + replace',data:[318,338,358,423,774]},
{name:'Short replace symbols with std::string_view find_first_of + copy',data:[152,160,313,350,439]},
{name:'Short replace runtime symbols with string expressions and without remembering all search results',data:[163,204,276,312,389]},
{name:'Short replace runtime symbols with simstr and memorization of all search results',data:[187,193,345,418,439]},
{name:'Short replace const symbols with string expressions and without remembering all search results',data:[126,150,212,252,292]},
{name:'Short replace const symbols with string expressions and memorization of all search results',data:[147,140,294,325,320]}
]}</script>
<div class="benchset" id="bs28"><h4><a id="bs77745698784557935900" href="#bs77745698784557935900">#</a>&nbsp;Replace All Str To Longer Size</h4>
<table><thead><tr><th>Benchmark name</th><th width="5%">Comment</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), Clang-21</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), GCC-13</th><th width="8%">Xeon E5-2682 v4, Windows 10, Clang-19</th><th width="8%">Xeon E5-2682 v4, Windows 10, MSVC-19</th><th width="8%">Xeon E5-2682 v4, WASM Chrome 143, Clang-21</th></tr></thead><tbody>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1894">replace bb to ---- in std::string|64</a><span class="tooltiptext code">template&lt;size_t Long>
void ReplaceAllLongerStdString(benchmark::State&amp; state) {
std::string_view source = &quot;aaaaaaaaaaaaaaaaaaabbbaaaaaaaabbbbaaaaabaaaaaaaaaaaaaaaaaaaaabba&quot;;
std::string_view sample = &quot;aaaaaaaaaaaaaaaaaaa----baaaaaaaa--------aaaaabaaaaaaaaaaaaaaaaaaaaa----a&quot;;
std::string_view pattern = &quot;bb&quot;;
std::string_view repl = &quot;----&quot;;
std::string big_source, big_sample;
for (int i = 0; i &lt; Long; i++) {
big_source += source;
big_sample += sample;
}
for (auto _: state) {
std::string result{big_source};
size_t start_pos = 0;
while((start_pos = result.find(pattern, start_pos)) != std::string::npos) {
result.replace(start_pos, pattern.length(), repl);
start_pos += repl.length();
}
#ifdef CHECK_RESULT
if (result != big_sample) {
state.SkipWithError(&quot;error in replace&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(source);
benchmark::DoNotOptimize(pattern);
benchmark::DoNotOptimize(repl);
}
}</span></span></td><td></td><td class="benchmarkresult">152</td><td class="benchmarkresult">157</td><td class="benchmarkresult">219</td><td class="benchmarkresult">239</td><td class="benchmarkresult">394</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1894">replace bb to ---- in std::string|256</a><span class="tooltiptext code">template&lt;size_t Long>
void ReplaceAllLongerStdString(benchmark::State&amp; state) {
std::string_view source = &quot;aaaaaaaaaaaaaaaaaaabbbaaaaaaaabbbbaaaaabaaaaaaaaaaaaaaaaaaaaabba&quot;;
std::string_view sample = &quot;aaaaaaaaaaaaaaaaaaa----baaaaaaaa--------aaaaabaaaaaaaaaaaaaaaaaaaaa----a&quot;;
std::string_view pattern = &quot;bb&quot;;
std::string_view repl = &quot;----&quot;;
std::string big_source, big_sample;
for (int i = 0; i &lt; Long; i++) {
big_source += source;
big_sample += sample;
}
for (auto _: state) {
std::string result{big_source};
size_t start_pos = 0;
while((start_pos = result.find(pattern, start_pos)) != std::string::npos) {
result.replace(start_pos, pattern.length(), repl);
start_pos += repl.length();
}
#ifdef CHECK_RESULT
if (result != big_sample) {
state.SkipWithError(&quot;error in replace&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(source);
benchmark::DoNotOptimize(pattern);
benchmark::DoNotOptimize(repl);
}
}</span></span></td><td></td><td class="benchmarkresult">538</td><td class="benchmarkresult">492</td><td class="benchmarkresult">750</td><td class="benchmarkresult">796</td><td class="benchmarkresult">1197</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1894">replace bb to ---- in std::string|512</a><span class="tooltiptext code">template&lt;size_t Long>
void ReplaceAllLongerStdString(benchmark::State&amp; state) {
std::string_view source = &quot;aaaaaaaaaaaaaaaaaaabbbaaaaaaaabbbbaaaaabaaaaaaaaaaaaaaaaaaaaabba&quot;;
std::string_view sample = &quot;aaaaaaaaaaaaaaaaaaa----baaaaaaaa--------aaaaabaaaaaaaaaaaaaaaaaaaaa----a&quot;;
std::string_view pattern = &quot;bb&quot;;
std::string_view repl = &quot;----&quot;;
std::string big_source, big_sample;
for (int i = 0; i &lt; Long; i++) {
big_source += source;
big_sample += sample;
}
for (auto _: state) {
std::string result{big_source};
size_t start_pos = 0;
while((start_pos = result.find(pattern, start_pos)) != std::string::npos) {
result.replace(start_pos, pattern.length(), repl);
start_pos += repl.length();
}
#ifdef CHECK_RESULT
if (result != big_sample) {
state.SkipWithError(&quot;error in replace&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(source);
benchmark::DoNotOptimize(pattern);
benchmark::DoNotOptimize(repl);
}
}</span></span></td><td></td><td class="benchmarkresult">1070</td><td class="benchmarkresult">990</td><td class="benchmarkresult">1352</td><td class="benchmarkresult">1522</td><td class="benchmarkresult">2361</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1894">replace bb to ---- in std::string|1024</a><span class="tooltiptext code">template&lt;size_t Long>
void ReplaceAllLongerStdString(benchmark::State&amp; state) {
std::string_view source = &quot;aaaaaaaaaaaaaaaaaaabbbaaaaaaaabbbbaaaaabaaaaaaaaaaaaaaaaaaaaabba&quot;;
std::string_view sample = &quot;aaaaaaaaaaaaaaaaaaa----baaaaaaaa--------aaaaabaaaaaaaaaaaaaaaaaaaaa----a&quot;;
std::string_view pattern = &quot;bb&quot;;
std::string_view repl = &quot;----&quot;;
std::string big_source, big_sample;
for (int i = 0; i &lt; Long; i++) {
big_source += source;
big_sample += sample;
}
for (auto _: state) {
std::string result{big_source};
size_t start_pos = 0;
while((start_pos = result.find(pattern, start_pos)) != std::string::npos) {
result.replace(start_pos, pattern.length(), repl);
start_pos += repl.length();
}
#ifdef CHECK_RESULT
if (result != big_sample) {
state.SkipWithError(&quot;error in replace&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(source);
benchmark::DoNotOptimize(pattern);
benchmark::DoNotOptimize(repl);
}
}</span></span></td><td></td><td class="benchmarkresult">2384</td><td class="benchmarkresult">2325</td><td class="benchmarkresult">3028</td><td class="benchmarkresult">3121</td><td class="benchmarkresult">4872</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1894">replace bb to ---- in std::string|2048</a><span class="tooltiptext code">template&lt;size_t Long>
void ReplaceAllLongerStdString(benchmark::State&amp; state) {
std::string_view source = &quot;aaaaaaaaaaaaaaaaaaabbbaaaaaaaabbbbaaaaabaaaaaaaaaaaaaaaaaaaaabba&quot;;
std::string_view sample = &quot;aaaaaaaaaaaaaaaaaaa----baaaaaaaa--------aaaaabaaaaaaaaaaaaaaaaaaaaa----a&quot;;
std::string_view pattern = &quot;bb&quot;;
std::string_view repl = &quot;----&quot;;
std::string big_source, big_sample;
for (int i = 0; i &lt; Long; i++) {
big_source += source;
big_sample += sample;
}
for (auto _: state) {
std::string result{big_source};
size_t start_pos = 0;
while((start_pos = result.find(pattern, start_pos)) != std::string::npos) {
result.replace(start_pos, pattern.length(), repl);
start_pos += repl.length();
}
#ifdef CHECK_RESULT
if (result != big_sample) {
state.SkipWithError(&quot;error in replace&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(source);
benchmark::DoNotOptimize(pattern);
benchmark::DoNotOptimize(repl);
}
}</span></span></td><td></td><td class="benchmarkresult">6072</td><td class="benchmarkresult">6064</td><td class="benchmarkresult">7680</td><td class="benchmarkresult">7894</td><td class="benchmarkresult">11862</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1928">replace bb to ---- in lstringa&lt;8>|64</a><span class="tooltiptext code">template&lt;size_t N, size_t Count>
void ReplaceAllLongerSimString(benchmark::State&amp; state) {
ssa source = &quot;aaaaaaaaaaaaaaaaaaabbbaaaaaaaabbbbaaaaabaaaaaaaaaaaaaaaaaaaaabba&quot;;
ssa sample = &quot;aaaaaaaaaaaaaaaaaaa----baaaaaaaa--------aaaaabaaaaaaaaaaaaaaaaaaaaa----a&quot;;
lstringa&lt;2048> big_source{Count, source}, big_sample{Count, sample};
for (auto _: state) {
lstringa&lt;N> result = big_source;
result.replace(&quot;bb&quot;, &quot;----&quot;);
#ifdef CHECK_RESULT
if (result.to_str() != big_sample) {
std::cout &lt;&lt; result.length() &lt;&lt; &quot;: &quot; &lt;&lt; result &lt;&lt; &quot;\n\n&quot; &lt;&lt; big_sample.length() &lt;&lt; &quot;: &quot; &lt;&lt; big_sample &lt;&lt; &quot;\n\n&quot;;
state.SkipWithError(&quot;error in replace&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(source);
}
}</span></span></td><td></td><td class="benchmarkresult">129</td><td class="benchmarkresult">145</td><td class="benchmarkresult">217</td><td class="benchmarkresult">230</td><td class="benchmarkresult">306</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1928">replace bb to ---- in lstringa&lt;8>|256</a><span class="tooltiptext code">template&lt;size_t N, size_t Count>
void ReplaceAllLongerSimString(benchmark::State&amp; state) {
ssa source = &quot;aaaaaaaaaaaaaaaaaaabbbaaaaaaaabbbbaaaaabaaaaaaaaaaaaaaaaaaaaabba&quot;;
ssa sample = &quot;aaaaaaaaaaaaaaaaaaa----baaaaaaaa--------aaaaabaaaaaaaaaaaaaaaaaaaaa----a&quot;;
lstringa&lt;2048> big_source{Count, source}, big_sample{Count, sample};
for (auto _: state) {
lstringa&lt;N> result = big_source;
result.replace(&quot;bb&quot;, &quot;----&quot;);
#ifdef CHECK_RESULT
if (result.to_str() != big_sample) {
std::cout &lt;&lt; result.length() &lt;&lt; &quot;: &quot; &lt;&lt; result &lt;&lt; &quot;\n\n&quot; &lt;&lt; big_sample.length() &lt;&lt; &quot;: &quot; &lt;&lt; big_sample &lt;&lt; &quot;\n\n&quot;;
state.SkipWithError(&quot;error in replace&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(source);
}
}</span></span></td><td></td><td class="benchmarkresult">430</td><td class="benchmarkresult">475</td><td class="benchmarkresult">609</td><td class="benchmarkresult">671</td><td class="benchmarkresult">953</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1928">replace bb to ---- in lstringa&lt;8>|512</a><span class="tooltiptext code">template&lt;size_t N, size_t Count>
void ReplaceAllLongerSimString(benchmark::State&amp; state) {
ssa source = &quot;aaaaaaaaaaaaaaaaaaabbbaaaaaaaabbbbaaaaabaaaaaaaaaaaaaaaaaaaaabba&quot;;
ssa sample = &quot;aaaaaaaaaaaaaaaaaaa----baaaaaaaa--------aaaaabaaaaaaaaaaaaaaaaaaaaa----a&quot;;
lstringa&lt;2048> big_source{Count, source}, big_sample{Count, sample};
for (auto _: state) {
lstringa&lt;N> result = big_source;
result.replace(&quot;bb&quot;, &quot;----&quot;);
#ifdef CHECK_RESULT
if (result.to_str() != big_sample) {
std::cout &lt;&lt; result.length() &lt;&lt; &quot;: &quot; &lt;&lt; result &lt;&lt; &quot;\n\n&quot; &lt;&lt; big_sample.length() &lt;&lt; &quot;: &quot; &lt;&lt; big_sample &lt;&lt; &quot;\n\n&quot;;
state.SkipWithError(&quot;error in replace&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(source);
}
}</span></span></td><td></td><td class="benchmarkresult">825</td><td class="benchmarkresult">862</td><td class="benchmarkresult">1052</td><td class="benchmarkresult">1119</td><td class="benchmarkresult">1732</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1928">replace bb to ---- in lstringa&lt;8>|1024</a><span class="tooltiptext code">template&lt;size_t N, size_t Count>
void ReplaceAllLongerSimString(benchmark::State&amp; state) {
ssa source = &quot;aaaaaaaaaaaaaaaaaaabbbaaaaaaaabbbbaaaaabaaaaaaaaaaaaaaaaaaaaabba&quot;;
ssa sample = &quot;aaaaaaaaaaaaaaaaaaa----baaaaaaaa--------aaaaabaaaaaaaaaaaaaaaaaaaaa----a&quot;;
lstringa&lt;2048> big_source{Count, source}, big_sample{Count, sample};
for (auto _: state) {
lstringa&lt;N> result = big_source;
result.replace(&quot;bb&quot;, &quot;----&quot;);
#ifdef CHECK_RESULT
if (result.to_str() != big_sample) {
std::cout &lt;&lt; result.length() &lt;&lt; &quot;: &quot; &lt;&lt; result &lt;&lt; &quot;\n\n&quot; &lt;&lt; big_sample.length() &lt;&lt; &quot;: &quot; &lt;&lt; big_sample &lt;&lt; &quot;\n\n&quot;;
state.SkipWithError(&quot;error in replace&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(source);
}
}</span></span></td><td></td><td class="benchmarkresult">1613</td><td class="benchmarkresult">1756</td><td class="benchmarkresult">1878</td><td class="benchmarkresult">2032</td><td class="benchmarkresult">3256</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1928">replace bb to ---- in lstringa&lt;8>|2048</a><span class="tooltiptext code">template&lt;size_t N, size_t Count>
void ReplaceAllLongerSimString(benchmark::State&amp; state) {
ssa source = &quot;aaaaaaaaaaaaaaaaaaabbbaaaaaaaabbbbaaaaabaaaaaaaaaaaaaaaaaaaaabba&quot;;
ssa sample = &quot;aaaaaaaaaaaaaaaaaaa----baaaaaaaa--------aaaaabaaaaaaaaaaaaaaaaaaaaa----a&quot;;
lstringa&lt;2048> big_source{Count, source}, big_sample{Count, sample};
for (auto _: state) {
lstringa&lt;N> result = big_source;
result.replace(&quot;bb&quot;, &quot;----&quot;);
#ifdef CHECK_RESULT
if (result.to_str() != big_sample) {
std::cout &lt;&lt; result.length() &lt;&lt; &quot;: &quot; &lt;&lt; result &lt;&lt; &quot;\n\n&quot; &lt;&lt; big_sample.length() &lt;&lt; &quot;: &quot; &lt;&lt; big_sample &lt;&lt; &quot;\n\n&quot;;
state.SkipWithError(&quot;error in replace&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(source);
}
}</span></span></td><td></td><td class="benchmarkresult">3174</td><td class="benchmarkresult">3286</td><td class="benchmarkresult">3548</td><td class="benchmarkresult">3867</td><td class="benchmarkresult">6323</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1951">replace bb to ---- by init stringa|64</a><span class="tooltiptext code">template&lt;size_t Count>
void ReplaceAllLongerSimStringExpr(benchmark::State&amp; state) {
ssa source = &quot;aaaaaaaaaaaaaaaaaaabbbaaaaaaaabbbbaaaaabaaaaaaaaaaaaaaaaaaaaabba&quot;;
ssa sample = &quot;aaaaaaaaaaaaaaaaaaa----baaaaaaaa--------aaaaabaaaaaaaaaaaaaaaaaaaaa----a&quot;;
lstringa&lt;2048> big_source{Count, source}, big_sample{Count, sample};
for (auto _: state) {
stringa result = e_repl(big_source, &quot;bb&quot;, &quot;----&quot;);
#ifdef CHECK_RESULT
if (result.to_str() != big_sample) {
std::cout &lt;&lt; result.length() &lt;&lt; &quot;: &quot; &lt;&lt; result &lt;&lt; &quot;\n\n&quot; &lt;&lt; big_sample.length() &lt;&lt; &quot;: &quot; &lt;&lt; big_sample &lt;&lt; &quot;\n\n&quot;;
state.SkipWithError(&quot;error in replace&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(source);
}
}</span></span></td><td></td><td class="benchmarkresult">94.5</td><td class="benchmarkresult">87.1</td><td class="benchmarkresult">162</td><td class="benchmarkresult">200</td><td class="benchmarkresult">162</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1951">replace bb to ---- by init stringa|256</a><span class="tooltiptext code">template&lt;size_t Count>
void ReplaceAllLongerSimStringExpr(benchmark::State&amp; state) {
ssa source = &quot;aaaaaaaaaaaaaaaaaaabbbaaaaaaaabbbbaaaaabaaaaaaaaaaaaaaaaaaaaabba&quot;;
ssa sample = &quot;aaaaaaaaaaaaaaaaaaa----baaaaaaaa--------aaaaabaaaaaaaaaaaaaaaaaaaaa----a&quot;;
lstringa&lt;2048> big_source{Count, source}, big_sample{Count, sample};
for (auto _: state) {
stringa result = e_repl(big_source, &quot;bb&quot;, &quot;----&quot;);
#ifdef CHECK_RESULT
if (result.to_str() != big_sample) {
std::cout &lt;&lt; result.length() &lt;&lt; &quot;: &quot; &lt;&lt; result &lt;&lt; &quot;\n\n&quot; &lt;&lt; big_sample.length() &lt;&lt; &quot;: &quot; &lt;&lt; big_sample &lt;&lt; &quot;\n\n&quot;;
state.SkipWithError(&quot;error in replace&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(source);
}
}</span></span></td><td></td><td class="benchmarkresult">299</td><td class="benchmarkresult">267</td><td class="benchmarkresult">363</td><td class="benchmarkresult">463</td><td class="benchmarkresult">527</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1951">replace bb to ---- by init stringa|512</a><span class="tooltiptext code">template&lt;size_t Count>
void ReplaceAllLongerSimStringExpr(benchmark::State&amp; state) {
ssa source = &quot;aaaaaaaaaaaaaaaaaaabbbaaaaaaaabbbbaaaaabaaaaaaaaaaaaaaaaaaaaabba&quot;;
ssa sample = &quot;aaaaaaaaaaaaaaaaaaa----baaaaaaaa--------aaaaabaaaaaaaaaaaaaaaaaaaaa----a&quot;;
lstringa&lt;2048> big_source{Count, source}, big_sample{Count, sample};
for (auto _: state) {
stringa result = e_repl(big_source, &quot;bb&quot;, &quot;----&quot;);
#ifdef CHECK_RESULT
if (result.to_str() != big_sample) {
std::cout &lt;&lt; result.length() &lt;&lt; &quot;: &quot; &lt;&lt; result &lt;&lt; &quot;\n\n&quot; &lt;&lt; big_sample.length() &lt;&lt; &quot;: &quot; &lt;&lt; big_sample &lt;&lt; &quot;\n\n&quot;;
state.SkipWithError(&quot;error in replace&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(source);
}
}</span></span></td><td></td><td class="benchmarkresult">696</td><td class="benchmarkresult">651</td><td class="benchmarkresult">789</td><td class="benchmarkresult">1075</td><td class="benchmarkresult">1213</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1951">replace bb to ---- by init stringa|1024</a><span class="tooltiptext code">template&lt;size_t Count>
void ReplaceAllLongerSimStringExpr(benchmark::State&amp; state) {
ssa source = &quot;aaaaaaaaaaaaaaaaaaabbbaaaaaaaabbbbaaaaabaaaaaaaaaaaaaaaaaaaaabba&quot;;
ssa sample = &quot;aaaaaaaaaaaaaaaaaaa----baaaaaaaa--------aaaaabaaaaaaaaaaaaaaaaaaaaa----a&quot;;
lstringa&lt;2048> big_source{Count, source}, big_sample{Count, sample};
for (auto _: state) {
stringa result = e_repl(big_source, &quot;bb&quot;, &quot;----&quot;);
#ifdef CHECK_RESULT
if (result.to_str() != big_sample) {
std::cout &lt;&lt; result.length() &lt;&lt; &quot;: &quot; &lt;&lt; result &lt;&lt; &quot;\n\n&quot; &lt;&lt; big_sample.length() &lt;&lt; &quot;: &quot; &lt;&lt; big_sample &lt;&lt; &quot;\n\n&quot;;
state.SkipWithError(&quot;error in replace&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(source);
}
}</span></span></td><td></td><td class="benchmarkresult">1546</td><td class="benchmarkresult">1455</td><td class="benchmarkresult">1587</td><td class="benchmarkresult">2167</td><td class="benchmarkresult">2565</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1951">replace bb to ---- by init stringa|2048</a><span class="tooltiptext code">template&lt;size_t Count>
void ReplaceAllLongerSimStringExpr(benchmark::State&amp; state) {
ssa source = &quot;aaaaaaaaaaaaaaaaaaabbbaaaaaaaabbbbaaaaabaaaaaaaaaaaaaaaaaaaaabba&quot;;
ssa sample = &quot;aaaaaaaaaaaaaaaaaaa----baaaaaaaa--------aaaaabaaaaaaaaaaaaaaaaaaaaa----a&quot;;
lstringa&lt;2048> big_source{Count, source}, big_sample{Count, sample};
for (auto _: state) {
stringa result = e_repl(big_source, &quot;bb&quot;, &quot;----&quot;);
#ifdef CHECK_RESULT
if (result.to_str() != big_sample) {
std::cout &lt;&lt; result.length() &lt;&lt; &quot;: &quot; &lt;&lt; result &lt;&lt; &quot;\n\n&quot; &lt;&lt; big_sample.length() &lt;&lt; &quot;: &quot; &lt;&lt; big_sample &lt;&lt; &quot;\n\n&quot;;
state.SkipWithError(&quot;error in replace&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(source);
}
}</span></span></td><td></td><td class="benchmarkresult">3176</td><td class="benchmarkresult">2933</td><td class="benchmarkresult">2912</td><td class="benchmarkresult">4357</td><td class="benchmarkresult">5315</td></tr>
</tbody></table></div><script>bench_sets['Replace All Str To Longer Size'] = {id:'bs28', tests:[
{name:'replace bb to ---- in std::string|64',data:[152,157,219,239,394]},
{name:'replace bb to ---- in std::string|256',data:[538,492,750,796,1197]},
{name:'replace bb to ---- in std::string|512',data:[1070,990,1352,1522,2361]},
{name:'replace bb to ---- in std::string|1024',data:[2384,2325,3028,3121,4872]},
{name:'replace bb to ---- in std::string|2048',data:[6072,6064,7680,7894,11862]},
{name:'replace bb to ---- in lstringa<8>|64',data:[129,145,217,230,306]},
{name:'replace bb to ---- in lstringa<8>|256',data:[430,475,609,671,953]},
{name:'replace bb to ---- in lstringa<8>|512',data:[825,862,1052,1119,1732]},
{name:'replace bb to ---- in lstringa<8>|1024',data:[1613,1756,1878,2032,3256]},
{name:'replace bb to ---- in lstringa<8>|2048',data:[3174,3286,3548,3867,6323]},
{name:'replace bb to ---- by init stringa|64',data:[94.5,87.1,162,200,162]},
{name:'replace bb to ---- by init stringa|256',data:[299,267,363,463,527]},
{name:'replace bb to ---- by init stringa|512',data:[696,651,789,1075,1213]},
{name:'replace bb to ---- by init stringa|1024',data:[1546,1455,1587,2167,2565]},
{name:'replace bb to ---- by init stringa|2048',data:[3176,2933,2912,4357,5315]}
]}</script>
<div class="benchset" id="bs29"><h4><a id="bs74494088982050398630" href="#bs74494088982050398630">#</a>&nbsp;Replace All Str To Same Size</h4>
<table><thead><tr><th>Benchmark name</th><th width="5%">Comment</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), Clang-21</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), GCC-13</th><th width="8%">Xeon E5-2682 v4, Windows 10, Clang-19</th><th width="8%">Xeon E5-2682 v4, Windows 10, MSVC-19</th><th width="8%">Xeon E5-2682 v4, WASM Chrome 143, Clang-21</th></tr></thead><tbody>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1973">replace bb to -- in std::string|64</a><span class="tooltiptext code">template&lt;size_t Long>
void ReplaceAllEqualStdString(benchmark::State&amp; state) {
std::string_view source = &quot;aaaaaaaaaaaaaaaaaaabbbaaaaaaaabbbbaaaaabaaaaaaaaaaaaaaaaaaaaabba&quot;;
std::string_view sample = &quot;aaaaaaaaaaaaaaaaaaa--baaaaaaaa----aaaaabaaaaaaaaaaaaaaaaaaaaa--a&quot;;
std::string_view pattern = &quot;bb&quot;;
std::string_view repl = &quot;--&quot;;
std::string big_source, big_sample;
for (int i = 0; i &lt; Long; i++) {
big_source += source;
big_sample += sample;
}
for (auto _: state) {
std::string result{big_source};
size_t start_pos = 0;
while((start_pos = result.find(pattern, start_pos)) != std::string::npos) {
result.replace(start_pos, pattern.length(), repl);
start_pos += repl.length();
}
#ifdef CHECK_RESULT
if (result != big_sample) {
state.SkipWithError(&quot;error in replace&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(source);
benchmark::DoNotOptimize(pattern);
benchmark::DoNotOptimize(repl);
}
}</span></span></td><td></td><td class="benchmarkresult">106</td><td class="benchmarkresult">111</td><td class="benchmarkresult">181</td><td class="benchmarkresult">201</td><td class="benchmarkresult">256</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1973">replace bb to -- in std::string|256</a><span class="tooltiptext code">template&lt;size_t Long>
void ReplaceAllEqualStdString(benchmark::State&amp; state) {
std::string_view source = &quot;aaaaaaaaaaaaaaaaaaabbbaaaaaaaabbbbaaaaabaaaaaaaaaaaaaaaaaaaaabba&quot;;
std::string_view sample = &quot;aaaaaaaaaaaaaaaaaaa--baaaaaaaa----aaaaabaaaaaaaaaaaaaaaaaaaaa--a&quot;;
std::string_view pattern = &quot;bb&quot;;
std::string_view repl = &quot;--&quot;;
std::string big_source, big_sample;
for (int i = 0; i &lt; Long; i++) {
big_source += source;
big_sample += sample;
}
for (auto _: state) {
std::string result{big_source};
size_t start_pos = 0;
while((start_pos = result.find(pattern, start_pos)) != std::string::npos) {
result.replace(start_pos, pattern.length(), repl);
start_pos += repl.length();
}
#ifdef CHECK_RESULT
if (result != big_sample) {
state.SkipWithError(&quot;error in replace&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(source);
benchmark::DoNotOptimize(pattern);
benchmark::DoNotOptimize(repl);
}
}</span></span></td><td></td><td class="benchmarkresult">382</td><td class="benchmarkresult">366</td><td class="benchmarkresult">480</td><td class="benchmarkresult">517</td><td class="benchmarkresult">819</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1973">replace bb to -- in std::string|512</a><span class="tooltiptext code">template&lt;size_t Long>
void ReplaceAllEqualStdString(benchmark::State&amp; state) {
std::string_view source = &quot;aaaaaaaaaaaaaaaaaaabbbaaaaaaaabbbbaaaaabaaaaaaaaaaaaaaaaaaaaabba&quot;;
std::string_view sample = &quot;aaaaaaaaaaaaaaaaaaa--baaaaaaaa----aaaaabaaaaaaaaaaaaaaaaaaaaa--a&quot;;
std::string_view pattern = &quot;bb&quot;;
std::string_view repl = &quot;--&quot;;
std::string big_source, big_sample;
for (int i = 0; i &lt; Long; i++) {
big_source += source;
big_sample += sample;
}
for (auto _: state) {
std::string result{big_source};
size_t start_pos = 0;
while((start_pos = result.find(pattern, start_pos)) != std::string::npos) {
result.replace(start_pos, pattern.length(), repl);
start_pos += repl.length();
}
#ifdef CHECK_RESULT
if (result != big_sample) {
state.SkipWithError(&quot;error in replace&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(source);
benchmark::DoNotOptimize(pattern);
benchmark::DoNotOptimize(repl);
}
}</span></span></td><td></td><td class="benchmarkresult">724</td><td class="benchmarkresult">738</td><td class="benchmarkresult">826</td><td class="benchmarkresult">924</td><td class="benchmarkresult">1546</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1973">replace bb to -- in std::string|1024</a><span class="tooltiptext code">template&lt;size_t Long>
void ReplaceAllEqualStdString(benchmark::State&amp; state) {
std::string_view source = &quot;aaaaaaaaaaaaaaaaaaabbbaaaaaaaabbbbaaaaabaaaaaaaaaaaaaaaaaaaaabba&quot;;
std::string_view sample = &quot;aaaaaaaaaaaaaaaaaaa--baaaaaaaa----aaaaabaaaaaaaaaaaaaaaaaaaaa--a&quot;;
std::string_view pattern = &quot;bb&quot;;
std::string_view repl = &quot;--&quot;;
std::string big_source, big_sample;
for (int i = 0; i &lt; Long; i++) {
big_source += source;
big_sample += sample;
}
for (auto _: state) {
std::string result{big_source};
size_t start_pos = 0;
while((start_pos = result.find(pattern, start_pos)) != std::string::npos) {
result.replace(start_pos, pattern.length(), repl);
start_pos += repl.length();
}
#ifdef CHECK_RESULT
if (result != big_sample) {
state.SkipWithError(&quot;error in replace&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(source);
benchmark::DoNotOptimize(pattern);
benchmark::DoNotOptimize(repl);
}
}</span></span></td><td></td><td class="benchmarkresult">1457</td><td class="benchmarkresult">1431</td><td class="benchmarkresult">1598</td><td class="benchmarkresult">1771</td><td class="benchmarkresult">2954</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L1973">replace bb to -- in std::string|2048</a><span class="tooltiptext code">template&lt;size_t Long>
void ReplaceAllEqualStdString(benchmark::State&amp; state) {
std::string_view source = &quot;aaaaaaaaaaaaaaaaaaabbbaaaaaaaabbbbaaaaabaaaaaaaaaaaaaaaaaaaaabba&quot;;
std::string_view sample = &quot;aaaaaaaaaaaaaaaaaaa--baaaaaaaa----aaaaabaaaaaaaaaaaaaaaaaaaaa--a&quot;;
std::string_view pattern = &quot;bb&quot;;
std::string_view repl = &quot;--&quot;;
std::string big_source, big_sample;
for (int i = 0; i &lt; Long; i++) {
big_source += source;
big_sample += sample;
}
for (auto _: state) {
std::string result{big_source};
size_t start_pos = 0;
while((start_pos = result.find(pattern, start_pos)) != std::string::npos) {
result.replace(start_pos, pattern.length(), repl);
start_pos += repl.length();
}
#ifdef CHECK_RESULT
if (result != big_sample) {
state.SkipWithError(&quot;error in replace&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(source);
benchmark::DoNotOptimize(pattern);
benchmark::DoNotOptimize(repl);
}
}</span></span></td><td></td><td class="benchmarkresult">2855</td><td class="benchmarkresult">2775</td><td class="benchmarkresult">3822</td><td class="benchmarkresult">3511</td><td class="benchmarkresult">5749</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L2006">replace bb to -- in lstringa&lt;8>|64</a><span class="tooltiptext code">template&lt;size_t N, size_t Long>
void ReplaceAllEqualSimString(benchmark::State&amp; state) {
ssa source = &quot;aaaaaaaaaaaaaaaaaaabbbaaaaaaaabbbbaaaaabaaaaaaaaaaaaaaaaaaaaabba&quot;;
ssa sample = &quot;aaaaaaaaaaaaaaaaaaa--baaaaaaaa----aaaaabaaaaaaaaaaaaaaaaaaaaa--a&quot;;
lstringa&lt;2048> big_source{Long, source}, big_sample{Long, sample};
for (auto _: state) {
lstringa&lt;N> result = big_source;
result.replace(&quot;bb&quot;, &quot;--&quot;);
#ifdef CHECK_RESULT
if (result.to_str() != big_sample) {
std::cout &lt;&lt; result.length() &lt;&lt; &quot;: &quot; &lt;&lt; result &lt;&lt; &quot;\n\n&quot; &lt;&lt; big_sample.length() &lt;&lt; &quot;: &quot; &lt;&lt; big_sample &lt;&lt; &quot;\n\n&quot;;
state.SkipWithError(&quot;error in replace&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(source);
}
}</span></span></td><td></td><td class="benchmarkresult">94.1</td><td class="benchmarkresult">95.4</td><td class="benchmarkresult">174</td><td class="benchmarkresult">189</td><td class="benchmarkresult">206</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L2006">replace bb to -- in lstringa&lt;8>|256</a><span class="tooltiptext code">template&lt;size_t N, size_t Long>
void ReplaceAllEqualSimString(benchmark::State&amp; state) {
ssa source = &quot;aaaaaaaaaaaaaaaaaaabbbaaaaaaaabbbbaaaaabaaaaaaaaaaaaaaaaaaaaabba&quot;;
ssa sample = &quot;aaaaaaaaaaaaaaaaaaa--baaaaaaaa----aaaaabaaaaaaaaaaaaaaaaaaaaa--a&quot;;
lstringa&lt;2048> big_source{Long, source}, big_sample{Long, sample};
for (auto _: state) {
lstringa&lt;N> result = big_source;
result.replace(&quot;bb&quot;, &quot;--&quot;);
#ifdef CHECK_RESULT
if (result.to_str() != big_sample) {
std::cout &lt;&lt; result.length() &lt;&lt; &quot;: &quot; &lt;&lt; result &lt;&lt; &quot;\n\n&quot; &lt;&lt; big_sample.length() &lt;&lt; &quot;: &quot; &lt;&lt; big_sample &lt;&lt; &quot;\n\n&quot;;
state.SkipWithError(&quot;error in replace&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(source);
}
}</span></span></td><td></td><td class="benchmarkresult">282</td><td class="benchmarkresult">282</td><td class="benchmarkresult">429</td><td class="benchmarkresult">434</td><td class="benchmarkresult">650</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L2006">replace bb to -- in lstringa&lt;8>|512</a><span class="tooltiptext code">template&lt;size_t N, size_t Long>
void ReplaceAllEqualSimString(benchmark::State&amp; state) {
ssa source = &quot;aaaaaaaaaaaaaaaaaaabbbaaaaaaaabbbbaaaaabaaaaaaaaaaaaaaaaaaaaabba&quot;;
ssa sample = &quot;aaaaaaaaaaaaaaaaaaa--baaaaaaaa----aaaaabaaaaaaaaaaaaaaaaaaaaa--a&quot;;
lstringa&lt;2048> big_source{Long, source}, big_sample{Long, sample};
for (auto _: state) {
lstringa&lt;N> result = big_source;
result.replace(&quot;bb&quot;, &quot;--&quot;);
#ifdef CHECK_RESULT
if (result.to_str() != big_sample) {
std::cout &lt;&lt; result.length() &lt;&lt; &quot;: &quot; &lt;&lt; result &lt;&lt; &quot;\n\n&quot; &lt;&lt; big_sample.length() &lt;&lt; &quot;: &quot; &lt;&lt; big_sample &lt;&lt; &quot;\n\n&quot;;
state.SkipWithError(&quot;error in replace&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(source);
}
}</span></span></td><td></td><td class="benchmarkresult">520</td><td class="benchmarkresult">531</td><td class="benchmarkresult">733</td><td class="benchmarkresult">779</td><td class="benchmarkresult">1202</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L2006">replace bb to -- in lstringa&lt;8>|1024</a><span class="tooltiptext code">template&lt;size_t N, size_t Long>
void ReplaceAllEqualSimString(benchmark::State&amp; state) {
ssa source = &quot;aaaaaaaaaaaaaaaaaaabbbaaaaaaaabbbbaaaaabaaaaaaaaaaaaaaaaaaaaabba&quot;;
ssa sample = &quot;aaaaaaaaaaaaaaaaaaa--baaaaaaaa----aaaaabaaaaaaaaaaaaaaaaaaaaa--a&quot;;
lstringa&lt;2048> big_source{Long, source}, big_sample{Long, sample};
for (auto _: state) {
lstringa&lt;N> result = big_source;
result.replace(&quot;bb&quot;, &quot;--&quot;);
#ifdef CHECK_RESULT
if (result.to_str() != big_sample) {
std::cout &lt;&lt; result.length() &lt;&lt; &quot;: &quot; &lt;&lt; result &lt;&lt; &quot;\n\n&quot; &lt;&lt; big_sample.length() &lt;&lt; &quot;: &quot; &lt;&lt; big_sample &lt;&lt; &quot;\n\n&quot;;
state.SkipWithError(&quot;error in replace&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(source);
}
}</span></span></td><td></td><td class="benchmarkresult">1069</td><td class="benchmarkresult">1029</td><td class="benchmarkresult">1377</td><td class="benchmarkresult">1465</td><td class="benchmarkresult">2364</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L2006">replace bb to -- in lstringa&lt;8>|2048</a><span class="tooltiptext code">template&lt;size_t N, size_t Long>
void ReplaceAllEqualSimString(benchmark::State&amp; state) {
ssa source = &quot;aaaaaaaaaaaaaaaaaaabbbaaaaaaaabbbbaaaaabaaaaaaaaaaaaaaaaaaaaabba&quot;;
ssa sample = &quot;aaaaaaaaaaaaaaaaaaa--baaaaaaaa----aaaaabaaaaaaaaaaaaaaaaaaaaa--a&quot;;
lstringa&lt;2048> big_source{Long, source}, big_sample{Long, sample};
for (auto _: state) {
lstringa&lt;N> result = big_source;
result.replace(&quot;bb&quot;, &quot;--&quot;);
#ifdef CHECK_RESULT
if (result.to_str() != big_sample) {
std::cout &lt;&lt; result.length() &lt;&lt; &quot;: &quot; &lt;&lt; result &lt;&lt; &quot;\n\n&quot; &lt;&lt; big_sample.length() &lt;&lt; &quot;: &quot; &lt;&lt; big_sample &lt;&lt; &quot;\n\n&quot;;
state.SkipWithError(&quot;error in replace&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(source);
}
}</span></span></td><td></td><td class="benchmarkresult">2100</td><td class="benchmarkresult">2008</td><td class="benchmarkresult">2655</td><td class="benchmarkresult">2810</td><td class="benchmarkresult">4378</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L2028">replace bb to -- by init stringa|64</a><span class="tooltiptext code">template&lt;size_t Count>
void ReplaceAllEqualSimStringExpr(benchmark::State&amp; state) {
ssa source = &quot;aaaaaaaaaaaaaaaaaaabbbaaaaaaaabbbbaaaaabaaaaaaaaaaaaaaaaaaaaabba&quot;;
ssa sample = &quot;aaaaaaaaaaaaaaaaaaa--baaaaaaaa----aaaaabaaaaaaaaaaaaaaaaaaaaa--a&quot;;
ssa pattern = &quot;bb&quot;;
ssa repl = &quot;--&quot;;
lstringa&lt;2048> big_source{Count, source}, big_sample{Count, sample};
for (auto _: state) {
stringa result = e_repl(big_source.to_str(), &quot;bb&quot;, &quot;--&quot;);
#ifdef CHECK_RESULT
if (result.to_str() != big_sample) {
std::cout &lt;&lt; result.length() &lt;&lt; &quot;: &quot; &lt;&lt; result &lt;&lt; &quot;\n\n&quot; &lt;&lt; big_sample.length() &lt;&lt; &quot;: &quot; &lt;&lt; big_sample &lt;&lt; &quot;\n\n&quot;;
state.SkipWithError(&quot;error in replace&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(source);
benchmark::DoNotOptimize(pattern);
benchmark::DoNotOptimize(repl);
}
}</span></span></td><td></td><td class="benchmarkresult">76.1</td><td class="benchmarkresult">83.6</td><td class="benchmarkresult">150</td><td class="benchmarkresult">166</td><td class="benchmarkresult">147</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L2028">replace bb to -- by init stringa|256</a><span class="tooltiptext code">template&lt;size_t Count>
void ReplaceAllEqualSimStringExpr(benchmark::State&amp; state) {
ssa source = &quot;aaaaaaaaaaaaaaaaaaabbbaaaaaaaabbbbaaaaabaaaaaaaaaaaaaaaaaaaaabba&quot;;
ssa sample = &quot;aaaaaaaaaaaaaaaaaaa--baaaaaaaa----aaaaabaaaaaaaaaaaaaaaaaaaaa--a&quot;;
ssa pattern = &quot;bb&quot;;
ssa repl = &quot;--&quot;;
lstringa&lt;2048> big_source{Count, source}, big_sample{Count, sample};
for (auto _: state) {
stringa result = e_repl(big_source.to_str(), &quot;bb&quot;, &quot;--&quot;);
#ifdef CHECK_RESULT
if (result.to_str() != big_sample) {
std::cout &lt;&lt; result.length() &lt;&lt; &quot;: &quot; &lt;&lt; result &lt;&lt; &quot;\n\n&quot; &lt;&lt; big_sample.length() &lt;&lt; &quot;: &quot; &lt;&lt; big_sample &lt;&lt; &quot;\n\n&quot;;
state.SkipWithError(&quot;error in replace&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(source);
benchmark::DoNotOptimize(pattern);
benchmark::DoNotOptimize(repl);
}
}</span></span></td><td></td><td class="benchmarkresult">234</td><td class="benchmarkresult">265</td><td class="benchmarkresult">325</td><td class="benchmarkresult">375</td><td class="benchmarkresult">472</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L2028">replace bb to -- by init stringa|512</a><span class="tooltiptext code">template&lt;size_t Count>
void ReplaceAllEqualSimStringExpr(benchmark::State&amp; state) {
ssa source = &quot;aaaaaaaaaaaaaaaaaaabbbaaaaaaaabbbbaaaaabaaaaaaaaaaaaaaaaaaaaabba&quot;;
ssa sample = &quot;aaaaaaaaaaaaaaaaaaa--baaaaaaaa----aaaaabaaaaaaaaaaaaaaaaaaaaa--a&quot;;
ssa pattern = &quot;bb&quot;;
ssa repl = &quot;--&quot;;
lstringa&lt;2048> big_source{Count, source}, big_sample{Count, sample};
for (auto _: state) {
stringa result = e_repl(big_source.to_str(), &quot;bb&quot;, &quot;--&quot;);
#ifdef CHECK_RESULT
if (result.to_str() != big_sample) {
std::cout &lt;&lt; result.length() &lt;&lt; &quot;: &quot; &lt;&lt; result &lt;&lt; &quot;\n\n&quot; &lt;&lt; big_sample.length() &lt;&lt; &quot;: &quot; &lt;&lt; big_sample &lt;&lt; &quot;\n\n&quot;;
state.SkipWithError(&quot;error in replace&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(source);
benchmark::DoNotOptimize(pattern);
benchmark::DoNotOptimize(repl);
}
}</span></span></td><td></td><td class="benchmarkresult">439</td><td class="benchmarkresult">501</td><td class="benchmarkresult">519</td><td class="benchmarkresult">621</td><td class="benchmarkresult">912</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L2028">replace bb to -- by init stringa|1024</a><span class="tooltiptext code">template&lt;size_t Count>
void ReplaceAllEqualSimStringExpr(benchmark::State&amp; state) {
ssa source = &quot;aaaaaaaaaaaaaaaaaaabbbaaaaaaaabbbbaaaaabaaaaaaaaaaaaaaaaaaaaabba&quot;;
ssa sample = &quot;aaaaaaaaaaaaaaaaaaa--baaaaaaaa----aaaaabaaaaaaaaaaaaaaaaaaaaa--a&quot;;
ssa pattern = &quot;bb&quot;;
ssa repl = &quot;--&quot;;
lstringa&lt;2048> big_source{Count, source}, big_sample{Count, sample};
for (auto _: state) {
stringa result = e_repl(big_source.to_str(), &quot;bb&quot;, &quot;--&quot;);
#ifdef CHECK_RESULT
if (result.to_str() != big_sample) {
std::cout &lt;&lt; result.length() &lt;&lt; &quot;: &quot; &lt;&lt; result &lt;&lt; &quot;\n\n&quot; &lt;&lt; big_sample.length() &lt;&lt; &quot;: &quot; &lt;&lt; big_sample &lt;&lt; &quot;\n\n&quot;;
state.SkipWithError(&quot;error in replace&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(source);
benchmark::DoNotOptimize(pattern);
benchmark::DoNotOptimize(repl);
}
}</span></span></td><td></td><td class="benchmarkresult">854</td><td class="benchmarkresult">1004</td><td class="benchmarkresult">1010</td><td class="benchmarkresult">1112</td><td class="benchmarkresult">1712</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L2028">replace bb to -- by init stringa|2048</a><span class="tooltiptext code">template&lt;size_t Count>
void ReplaceAllEqualSimStringExpr(benchmark::State&amp; state) {
ssa source = &quot;aaaaaaaaaaaaaaaaaaabbbaaaaaaaabbbbaaaaabaaaaaaaaaaaaaaaaaaaaabba&quot;;
ssa sample = &quot;aaaaaaaaaaaaaaaaaaa--baaaaaaaa----aaaaabaaaaaaaaaaaaaaaaaaaaa--a&quot;;
ssa pattern = &quot;bb&quot;;
ssa repl = &quot;--&quot;;
lstringa&lt;2048> big_source{Count, source}, big_sample{Count, sample};
for (auto _: state) {
stringa result = e_repl(big_source.to_str(), &quot;bb&quot;, &quot;--&quot;);
#ifdef CHECK_RESULT
if (result.to_str() != big_sample) {
std::cout &lt;&lt; result.length() &lt;&lt; &quot;: &quot; &lt;&lt; result &lt;&lt; &quot;\n\n&quot; &lt;&lt; big_sample.length() &lt;&lt; &quot;: &quot; &lt;&lt; big_sample &lt;&lt; &quot;\n\n&quot;;
state.SkipWithError(&quot;error in replace&quot;);
break;
}
#endif
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(source);
benchmark::DoNotOptimize(pattern);
benchmark::DoNotOptimize(repl);
}
}</span></span></td><td></td><td class="benchmarkresult">1646</td><td class="benchmarkresult">1944</td><td class="benchmarkresult">1741</td><td class="benchmarkresult">2125</td><td class="benchmarkresult">2832</td></tr>
</tbody></table></div><script>bench_sets['Replace All Str To Same Size'] = {id:'bs29', tests:[
{name:'replace bb to -- in std::string|64',data:[106,111,181,201,256]},
{name:'replace bb to -- in std::string|256',data:[382,366,480,517,819]},
{name:'replace bb to -- in std::string|512',data:[724,738,826,924,1546]},
{name:'replace bb to -- in std::string|1024',data:[1457,1431,1598,1771,2954]},
{name:'replace bb to -- in std::string|2048',data:[2855,2775,3822,3511,5749]},
{name:'replace bb to -- in lstringa<8>|64',data:[94.1,95.4,174,189,206]},
{name:'replace bb to -- in lstringa<8>|256',data:[282,282,429,434,650]},
{name:'replace bb to -- in lstringa<8>|512',data:[520,531,733,779,1202]},
{name:'replace bb to -- in lstringa<8>|1024',data:[1069,1029,1377,1465,2364]},
{name:'replace bb to -- in lstringa<8>|2048',data:[2100,2008,2655,2810,4378]},
{name:'replace bb to -- by init stringa|64',data:[76.1,83.6,150,166,147]},
{name:'replace bb to -- by init stringa|256',data:[234,265,325,375,472]},
{name:'replace bb to -- by init stringa|512',data:[439,501,519,621,912]},
{name:'replace bb to -- by init stringa|1024',data:[854,1004,1010,1112,1712]},
{name:'replace bb to -- by init stringa|2048',data:[1646,1944,1741,2125,2832]}
]}</script>
<div class="benchset" id="bs30"><h4><a id="bs8410196985047277720" href="#bs8410196985047277720">#</a>&nbsp;Hash Map insert and find</h4>
<table><thead><tr><th>Benchmark name</th><th width="5%">Comment</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), Clang-21</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), GCC-13</th><th width="8%">Xeon E5-2682 v4, Windows 10, Clang-19</th><th width="8%">Xeon E5-2682 v4, Windows 10, MSVC-19</th><th width="8%">Xeon E5-2682 v4, WASM Chrome 143, Clang-21</th></tr></thead><tbody>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L2125">hashStrMapA&lt;size_t> emplace &amp; find stringa;</a><span class="tooltiptext code">void HashMapSimStr(benchmark::State&amp; state) {
for (auto _: state) {
hashStrMapA&lt;size_t> store;
for (size_t idx = 0; idx &lt; bs_sim.size(); idx++) {
store.try_emplace(bs_sim[idx], idx);
}
#ifdef CHECK_RESULT
if (store.size() != bs_sim.size()) {
state.SkipWithError(&quot;bad inserts&quot;);
}
#endif
for (size_t idx = 0; idx &lt; bs_sim.size(); idx++) {
auto find = store.find(bs_sim[idx]);
size_t res = find->second;
#ifdef CHECK_RESULT
if (res != idx) {
state.SkipWithError(&quot;bad find&quot;);
}
#endif
benchmark::DoNotOptimize(res);
}
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">Вставляем в hashStrMapA 10000 stringa длиной от 30 до 50
символов, а потом ищем их в ней
We insert 10,000 strings of length from 30 to 50 characters into
hashStrMapA, and then search for them in it.</span></span></td><td class="benchmarkresult">3606014</td><td class="benchmarkresult">3698007</td><td class="benchmarkresult">4020366</td><td class="benchmarkresult">4428253</td><td class="benchmarkresult">3227313</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L2149">std::unordered_map&lt;std::string, size_t> emplace &amp; find std::string;</a><span class="tooltiptext code">void HashMapStdStr(benchmark::State&amp; state) {
for (auto _: state) {
std::unordered_map&lt;std::string, size_t> store;
for (size_t idx = 0; idx &lt; bs_std.size(); idx++) {
store.try_emplace(bs_std[idx], idx);
}
#ifdef CHECK_RESULT
if (store.size() != bs_std.size()) {
state.SkipWithError(&quot;bad inserts&quot;);
}
#endif
for (size_t idx = 0; idx &lt; bs_std.size(); idx++) {
auto find = store.find(bs_std[idx]);
size_t res = find->second;
#ifdef CHECK_RESULT
if (res != idx) {
state.SkipWithError(&quot;bad find&quot;);
}
#endif
benchmark::DoNotOptimize(res);
}
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">То же самое c std::string и std::unordered_map
Same thing with std::string and std::unordered_map</span></span></td><td class="benchmarkresult">3523575</td><td class="benchmarkresult">3645916</td><td class="benchmarkresult">5598760</td><td class="benchmarkresult">5898002</td><td class="benchmarkresult">3640106</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L2173">hashStrMapA&lt;size_t> emplace &amp; find ssa;</a><span class="tooltiptext code">void HashMapSimSsa(benchmark::State&amp; state) {
for (auto _: state) {
hashStrMapA&lt;size_t> store;
for (size_t idx = 0; idx &lt; bs_sim.size(); idx++) {
store.emplace(bs_sim[idx], idx);
}
#ifdef CHECK_RESULT
if (store.size() != bs_sim.size()) {
state.SkipWithError(&quot;bad inserts&quot;);
}
#endif
for (size_t idx = 0; idx &lt; bs_sim.size(); idx++) {
ssa key = bs_sim[idx];
auto find = store.find(key);
size_t res = find->second;
#ifdef CHECK_RESULT
if (res != idx) {
state.SkipWithError(&quot;bad find&quot;);
}
#endif
benchmark::DoNotOptimize(res);
}
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">Теперь вставляем stringa, а ищем ssa
Now we insert stringa and search for ssa</span></span></td><td class="benchmarkresult">3593513</td><td class="benchmarkresult">3708079</td><td class="benchmarkresult">3439706</td><td class="benchmarkresult">4082178</td><td class="benchmarkresult">3237505</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L2198">std::unordered_map&lt;std::string, size_t> emplace &amp; find std::string_view;</a><span class="tooltiptext code">void HashMapStdStrView(benchmark::State&amp; state) {
for (auto _: state) {
std::unordered_map&lt;std::string, size_t> store;
for (size_t idx = 0; idx &lt; bs_std.size(); idx++) {
store.emplace(bs_std[idx], idx);
}
#ifdef CHECK_RESULT
if (store.size() != bs_std.size()) {
state.SkipWithError(&quot;bad inserts&quot;);
}
#endif
for (size_t idx = 0; idx &lt; bs_std.size(); idx++) {
std::string_view key = bs_std[idx];
auto find = store.find(std::string{key});
size_t res = find->second;
#ifdef CHECK_RESULT
if (res != idx) {
state.SkipWithError(&quot;bad find&quot;);
}
#endif
benchmark::DoNotOptimize(res);
}
}
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">Вставляем std::string, а ищем std::string_view
We insert std::string and look for std::string_view</span></span></td><td class="benchmarkresult">4068399</td><td class="benchmarkresult">4189102</td><td class="benchmarkresult">7068855</td><td class="benchmarkresult">6303534</td><td class="benchmarkresult">4135414</td></tr>
</tbody></table></div><script>bench_sets['Hash Map insert and find'] = {id:'bs30', tests:[
{name:'hashStrMapA<size_t> emplace & find stringa;',data:[3606014,3698007,4020366,4428253,3227313]},
{name:'std::unordered_map<std::string, size_t> emplace & find std::string;',data:[3523575,3645916,5598760,5898002,3640106]},
{name:'hashStrMapA<size_t> emplace & find ssa;',data:[3593513,3708079,3439706,4082178,3237505]},
{name:'std::unordered_map<std::string, size_t> emplace & find std::string_view;',data:[4068399,4189102,7068855,6303534,4135414]}
]}</script>
<div class="benchset" id="bs31"><h4><a id="bs131384792586914680410" href="#bs131384792586914680410">#</a>&nbsp;Build Full Func Name</h4>
<table><thead><tr><th>Benchmark name</th><th width="5%">Comment</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), Clang-21</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), GCC-13</th><th width="8%">Xeon E5-2682 v4, Windows 10, Clang-19</th><th width="8%">Xeon E5-2682 v4, Windows 10, MSVC-19</th><th width="8%">Xeon E5-2682 v4, WASM Chrome 143, Clang-21</th></tr></thead><tbody>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L2408">Build func full name std::string;</a><span class="tooltiptext code">std::string build_full_name_std() const {
std::string str{has_ret_type_resolver ? &quot;any&quot;sv : type_names_sv[(unsigned)ret_type]};
str += &quot; &quot;;
str += std_name;
str += &quot;(&quot;;
bool add_comma = false;
for (const auto&amp; param : params) {
if (add_comma) {
str += &quot;, &quot;;
}
if (param.optional) {
str += &quot;[&quot;;
}
param.allowed_types.to_stdstr(str);
if (param.optional) {
str += &quot;]&quot;;
}
add_comma = true;
}
if (unlim_params) {
if (add_comma) {
str += &quot;, &quot;;
}
str += &quot;...&quot;;
}
str += &quot;)&quot;;
//std::cout &lt;&lt; &quot;Len=&quot; &lt;&lt; str.length() &lt;&lt; &quot;, Cap=&quot; &lt;&lt; str.capacity() &lt;&lt; &quot;\n&quot;;
return str;
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">Обыденная задача, подобные часто могут встретится в работе:
По неким данным сгенерировать текст. В этом случае по данным
о неких функциях сформировать их полное имя с типами параметров и
возвращаемого значения. Алгоритм на std::string.
A common task, similar to this one, can often be encountered in work:
Generate text from given data. In this case, using data
on certain functions, generate their full names with parameter types and
return values. The algorithm uses std::string.</span></span></td><td class="benchmarkresult">678</td><td class="benchmarkresult">853</td><td class="benchmarkresult">1506</td><td class="benchmarkresult">1604</td><td class="benchmarkresult">3605</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L2440">Build func full name std::string 1;</a><span class="tooltiptext code">std::string build_full_name_std1() const {
std::string str{has_ret_type_resolver ? &quot;any&quot;sv : type_names_sv[(unsigned)ret_type]};
str += &quot; &quot; + std_name + &quot;(&quot;;
bool add_comma = false;
for (const auto&amp; param : params) {
if (add_comma) {
str += &quot;, &quot;;
}
if (param.optional) {
str += &quot;[&quot;;
}
param.allowed_types.to_stdstr(str);
if (param.optional) {
str += &quot;]&quot;;
}
add_comma = true;
}
if (unlim_params) {
if (add_comma) {
str += &quot;, &quot;;
}
str += &quot;...&quot;;
}
str += &quot;)&quot;;
//std::cout &lt;&lt; &quot;Len=&quot; &lt;&lt; str.length() &lt;&lt; &quot;, Cap=&quot; &lt;&lt; str.capacity() &lt;&lt; &quot;\n&quot;;
return str;
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">Почти тот же алгоритм, но несколько последовательных
+= к строке заменены на одно += + + +.
Almost the same algorithm, but several consecutive
+= to a string are replaced with a single += + + +.</span></span></td><td class="benchmarkresult">776</td><td class="benchmarkresult">912</td><td class="benchmarkresult">1582</td><td class="benchmarkresult">1697</td><td class="benchmarkresult">3610</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L2470">Build func full name std::stream;</a><span class="tooltiptext code">std::string build_full_name_stream() const {
std::ostringstream str;
if (has_ret_type_resolver) {
str &lt;&lt; &quot;any&quot;;
} else {
str &lt;&lt; type_names_sv[(unsigned)ret_type];
}
str &lt;&lt; &quot; &quot; &lt;&lt; std_name &lt;&lt; &quot;(&quot;;
bool add_comma = false;
for (const auto&amp; param : params) {
if (add_comma) {
str &lt;&lt; &quot;, &quot;;
}
if (param.optional) {
str &lt;&lt; &quot;[&quot;;
}
param.allowed_types.to_stream(str);
if (param.optional) {
str &lt;&lt; &quot;]&quot;;
}
add_comma = true;
}
if (unlim_params) {
if (add_comma) {
str &lt;&lt; &quot;, &quot;;
}
str &lt;&lt; &quot;...&quot;;
}
str &lt;&lt; &quot;)&quot;;
return str.str();
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">Строим имя функции через std::ostringstream и <<
We construct the function name through std::ostringstream and <<</span></span></td><td class="benchmarkresult">2611</td><td class="benchmarkresult">2502</td><td class="benchmarkresult">8167</td><td class="benchmarkresult">10054</td><td class="benchmarkresult">12391</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L2381">Build func full name stringa;</a><span class="tooltiptext code">stringa build_full_name() const {
lstringa&lt;512> str = e_choice(has_ret_type_resolver, &quot;any&quot;, type_names[(unsigned)ret_type]) + &quot; &quot; + name + &quot;(&quot;;
bool add_comma = false;
for (const auto&amp; param : params) {
str += e_if(add_comma, &quot;, &quot;) + e_if(param.optional, &quot;[&quot;);
param.allowed_types.to_simstr(str);
if (param.optional) {
str += &quot;]&quot;;
}
add_comma = true;
}
return str + e_if(unlim_params, e_if(add_comma, &quot;, &quot;) + &quot;...&quot;) + &quot;)&quot;;
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">Реализация на simstr строках и строковых выражениях.
Инфа о параметрах добавляется в текущую строку
Implementation using simstr strings and string expressions.
Parameter information is appended to the current line.</span></span></td><td class="benchmarkresult">484</td><td class="benchmarkresult">459</td><td class="benchmarkresult">790</td><td class="benchmarkresult">879</td><td class="benchmarkresult">1610</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L2396">Build func full name stringa 1;</a><span class="tooltiptext code">stringa build_full_name1() const {
lstringa&lt;512> str = e_choice(has_ret_type_resolver, &quot;any&quot;, type_names[(unsigned)ret_type]) + &quot; &quot; + name + &quot;(&quot;;
bool add_comma = false;
for (const auto&amp; param : params) {
str += e_if(add_comma, &quot;, &quot;) + e_if(param.optional, &quot;[&quot;) + param.allowed_types.get_simstr() + e_if(param.optional, &quot;]&quot;);
add_comma = true;
}
return str + e_if(unlim_params, e_if(add_comma, &quot;, &quot;) + &quot;...&quot;) + &quot;)&quot;;
}</span></span></td><td><span class="tooltip info">&nbsp;>>&nbsp;<span class="tooltiptext">Реализация на simstr строках и строковых выражениях.
Инфа о параметрах добавляется во временную строку, а потом
разом добавляется в текущую строку. Позволяет операции в цикле
записать в одну строку, но чуть проигрывает по времени выполнения.
Implementation using simstr strings and string expressions.
Parameter information is added to a temporary string, and then
all at once to the current string. This allows loop operations
to be written in a single string, but is slightly slower in execution time.</span></span></td><td class="benchmarkresult">610</td><td class="benchmarkresult">627</td><td class="benchmarkresult">877</td><td class="benchmarkresult">982</td><td class="benchmarkresult">1874</td></tr>
</tbody></table></div><script>bench_sets['Build Full Func Name'] = {id:'bs31', tests:[
{name:'Build func full name std::string;',data:[678,853,1506,1604,3605]},
{name:'Build func full name std::string 1;',data:[776,912,1582,1697,3610]},
{name:'Build func full name std::stream;',data:[2611,2502,8167,10054,12391]},
{name:'Build func full name stringa;',data:[484,459,790,879,1610]},
{name:'Build func full name stringa 1;',data:[610,627,877,982,1874]}
]}</script>
<div class="benchset" id="bs32"><h4><a id="bs36691618230457010710" href="#bs36691618230457010710">#</a>&nbsp;Make Upper</h4>
<table><thead><tr><th>Benchmark name</th><th width="5%">Comment</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), Clang-21</th><th width="8%">Xeon E5-2682 v4, Ubuntu 22 (WSL), GCC-13</th><th width="8%">Xeon E5-2682 v4, Windows 10, Clang-19</th><th width="8%">Xeon E5-2682 v4, Windows 10, MSVC-19</th><th width="8%">Xeon E5-2682 v4, WASM Chrome 143, Clang-21</th></tr></thead><tbody>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L2610">To upper case std::wstring</a><span class="tooltiptext code">void UpperCaseStd(benchmark::State&amp; state) {
static const auto&amp; loc = std::locale(&quot;en_US.utf8&quot;);
for (auto _: state) {
std::wstring test = L&quot;TestПриветTest&quot;;
benchmark::DoNotOptimize(test);
std::transform(test.begin(), test.end(), test.begin(), [](wchar_t s) {
return std::toupper(s, loc);
});
benchmark::DoNotOptimize(test);
#ifdef CHECK_RESULT
if (test != L&quot;TESTПРИВЕТTEST&quot;) {
state.SkipWithError(&quot;Bad upper case&quot;);
}
#endif
}
}</span></span></td><td></td><td class="benchmarkresult">151</td><td class="benchmarkresult">166</td><td class="benchmarkresult">1526</td><td class="benchmarkresult">1424</td><td class="benchmarkresult">203</td></tr>
<tr><td class="benchmarkname"><span class="tooltip"><a target="blank" href="https://github.com/orefkov/simstr/blob/rel1.7.1/bench/bench_str.cpp#L2630">To upper case lstringw&lt;15></a><span class="tooltiptext code">void UpperCaseSim(benchmark::State&amp; state) {
for (auto _: state) {
lstringw&lt;15> test = L&quot;TestПриветTest&quot;;
benchmark::DoNotOptimize(test);
test.upper();
benchmark::DoNotOptimize(test);
#ifdef CHECK_RESULT
if (test != L&quot;TESTПРИВЕТTEST&quot;) {
state.SkipWithError(&quot;Bad upper case&quot;);
}
#endif
}
}</span></span></td><td></td><td class="benchmarkresult">41.4</td><td class="benchmarkresult">42.0</td><td class="benchmarkresult">40.3</td><td class="benchmarkresult">50.5</td><td class="benchmarkresult">63.5</td></tr>
</tbody></table></div><script>bench_sets['Make Upper'] = {id:'bs32', tests:[
{name:'To upper case std::wstring',data:[151,166,1526,1424,203]},
{name:'To upper case lstringw<15>',data:[41.4,42.0,40.3,50.5,63.5]}
]}</script></body></html>
Reference in New Issue View Git Blame Copy Permalink