Inside Bitcoin

1501                    ]
1502                }
1503            ]
1504        }
1505    ],
1506    "metadata": {
1507        "loops": {{sum(iterations)}},
1508        "inner_loops": {{batch}},
1509        "name": "{{title}}",
1510        "unit": "second"
1511    },
1512    "version": "1.0"
1513})DELIM";
1514}
1515
1516char const* json() noexcept {
1517    return R"DELIM({
1518    "results": [
1519{{#result}}        {
1520            "title": "{{title}}",
1521            "name": "{{name}}",
1522            "unit": "{{unit}}",
1523            "batch": {{batch}},
1524            "complexityN": {{complexityN}},
1525            "epochs": {{epochs}},
1526            "clockResolution": {{clockResolution}},
1527            "clockResolutionMultiple": {{clockResolutionMultiple}},
1528            "maxEpochTime": {{maxEpochTime}},
1529            "minEpochTime": {{minEpochTime}},
1530            "minEpochIterations": {{minEpochIterations}},
1531            "epochIterations": {{epochIterations}},
1532            "warmup": {{warmup}},
1533            "relative": {{relative}},
1534            "median(elapsed)": {{median(elapsed)}},
1535            "medianAbsolutePercentError(elapsed)": {{medianAbsolutePercentError(elapsed)}},
1536            "median(instructions)": {{median(instructions)}},
1537            "medianAbsolutePercentError(instructions)": {{medianAbsolutePercentError(instructions)}},
1538            "median(cpucycles)": {{median(cpucycles)}},
1539            "median(contextswitches)": {{median(contextswitches)}},
1540            "median(pagefaults)": {{median(pagefaults)}},
1541            "median(branchinstructions)": {{median(branchinstructions)}},
1542            "median(branchmisses)": {{median(branchmisses)}},
1543            "totalTime": {{sumProduct(iterations, elapsed)}},
1544            "measurements": [
1545{{#measurement}}                {
1546                    "iterations": {{iterations}},
1547                    "elapsed": {{elapsed}},
1548                    "pagefaults": {{pagefaults}},
1549                    "cpucycles": {{cpucycles}},
1550                    "contextswitches": {{contextswitches}},
1551                    "instructions": {{instructions}},
1552                    "branchinstructions": {{branchinstructions}},
1553                    "branchmisses": {{branchmisses}}
1554                }{{^-last}},{{/-last}}
1555{{/measurement}}            ]
1556        }{{^-last}},{{/-last}}
1557{{/result}}    ]
1558})DELIM";
1559}
1560
1561ANKERL_NANOBENCH(IGNORE_PADDED_PUSH)
1562struct Node {
1563    enum class Type { tag, content, section, inverted_section };
1564
1565    char const* begin;
1566    char const* end;
1567    std::vector<Node> children;
1568    Type type;
1569
1570    template <size_t N>
1571    // NOLINTNEXTLINE(hicpp-avoid-c-arrays,modernize-avoid-c-arrays,cppcoreguidelines-avoid-c-arrays)
1572    bool operator==(char const (&str)[N]) const noexcept {
1573        // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-array-to-pointer-decay)
1574        return static_cast<size_t>(std::distance(begin, end) + 1) == N && 0 == strncmp(str, begin, N - 1);
1575    }
1576};
1577ANKERL_NANOBENCH(IGNORE_PADDED_POP)
1578
1579// NOLINTNEXTLINE(misc-no-recursion)
1580static std::vector<Node> parseMustacheTemplate(char const** tpl) {
1581    std::vector<Node> nodes;
1582
1583    while (true) {
1584        auto const* begin = std::strstr(*tpl, "{{");
1585        auto const* end = begin;
1586        if (begin != nullptr) {
1587            // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
1588            begin += 2;
1589            end = std::strstr(begin, "}}");
1590        }
1591
1592        if (begin == nullptr || end == nullptr) {
1593            // nothing found, finish node
1594            // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
1595            nodes.emplace_back(Node{*tpl, *tpl + std::strlen(*tpl), std::vector<Node>{}, Node::Type::content});
1596            return nodes;
1597        }
1598
1599        // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
1600        nodes.emplace_back(Node{*tpl, begin - 2, std::vector<Node>{}, Node::Type::content});
1601
1602        // we found a tag
1603        // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
1604        *tpl = end + 2;
1605        switch (*begin) {
1606        case '/':
1607            // finished! bail out
1608            return nodes;
1609
1610        case '#':
1611            // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
1612            nodes.emplace_back(Node{begin + 1, end, parseMustacheTemplate(tpl), Node::Type::section});
1613            break;
1614
1615        case '^':
1616            // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
1617            nodes.emplace_back(Node{begin + 1, end, parseMustacheTemplate(tpl), Node::Type::inverted_section});
1618            break;
1619
1620        default:
1621            nodes.emplace_back(Node{begin, end, std::vector<Node>{}, Node::Type::tag});
1622            break;
1623        }
1624    }
1625}
1626
1627static bool generateFirstLast(Node const& n, size_t idx, size_t size, std::ostream& out) {
1628    ANKERL_NANOBENCH_LOG("n.type=" << static_cast<int>(n.type));
1629    bool const matchFirst = n == "-first";
1630    bool const matchLast = n == "-last";
1631    if (!matchFirst && !matchLast) {
1632        return false;
1633    }
1634
1635    bool doWrite = false;
1636    if (n.type == Node::Type::section) {
1637        doWrite = (matchFirst && idx == 0) || (matchLast && idx == size - 1);
1638    } else if (n.type == Node::Type::inverted_section) {
1639        doWrite = (matchFirst && idx != 0) || (matchLast && idx != size - 1);
1640    }
1641
1642    if (doWrite) {
1643        for (auto const& child : n.children) {
1644            if (child.type == Node::Type::content) {
1645                out.write(child.begin, std::distance(child.begin, child.end));
1646            }
1647        }
1648    }
1649    return true;
1650}
1651
1652static bool matchCmdArgs(std::string const& str, std::vector<std::string>& matchResult) {
1653    matchResult.clear();
1654    auto idxOpen = str.find('(');
1655    auto idxClose = str.find(')', idxOpen);
1656    if (idxClose == std::string::npos) {
1657        return false;
1658    }
1659
1660    matchResult.emplace_back(str.substr(0, idxOpen));
1661
1662    // split by comma
1663    matchResult.emplace_back();
1664    for (size_t i = idxOpen + 1; i != idxClose; ++i) {
1665        if (str[i] == ' ' || str[i] == '\t') {
1666            // skip whitespace
1667            continue;
1668        }
1669        if (str[i] == ',') {
1670            // got a comma => new string
1671            matchResult.emplace_back();
1672            continue;
1673        }
1674        // no whitespace no comma, append
1675        matchResult.back() += str[i];
1676    }
1677    return true;
1678}
1679
1680static bool generateConfigTag(Node const& n, Config const& config, std::ostream& out) {
1681    using detail::d;
1682
1683    if (n == "title") {
1684        out << config.mBenchmarkTitle;
1685        return true;
1686    }
1687    if (n == "name") {
1688        out << config.mBenchmarkName;
1689        return true;
1690    }
1691    if (n == "unit") {
1692        out << config.mUnit;
1693        return true;
1694    }
1695    if (n == "batch") {
1696        out << config.mBatch;
1697        return true;
1698    }
1699    if (n == "complexityN") {
1700        out << config.mComplexityN;
1701        return true;
1702    }
1703    if (n == "epochs") {
1704        out << config.mNumEpochs;
1705        return true;
1706    }
1707    if (n == "clockResolution") {
1708        out << d(detail::clockResolution());
1709        return true;
1710    }
1711    if (n == "clockResolutionMultiple") {
1712        out << config.mClockResolutionMultiple;
1713        return true;
1714    }
1715    if (n == "maxEpochTime") {
1716        out << d(config.mMaxEpochTime);
1717        return true;
1718    }
1719    if (n == "minEpochTime") {
1720        out << d(config.mMinEpochTime);
1721        return true;
1722    }
1723    if (n == "minEpochIterations") {
1724        out << config.mMinEpochIterations;
1725        return true;
1726    }
1727    if (n == "epochIterations") {
1728        out << config.mEpochIterations;
1729        return true;
1730    }
1731    if (n == "warmup") {
1732        out << config.mWarmup;
1733        return true;
1734    }
1735    if (n == "relative") {
1736        out << config.mIsRelative;
1737        return true;
1738    }
1739    return false;
1740}
1741
1742// NOLINTNEXTLINE(readability-function-cognitive-complexity)
1743static std::ostream& generateResultTag(Node const& n, Result const& r, std::ostream& out) {
1744    if (generateConfigTag(n, r.config(), out)) {
1745        return out;
1746    }
1747    // match e.g. "median(elapsed)"
1748    // g++ 4.8 doesn't implement std::regex :(
1749    // static std::regex const regOpArg1("^([a-zA-Z]+)\\(([a-zA-Z]*)\\)$");
1750    // std::cmatch matchResult;