[PR #650] [MERGED] Remove some branches in HtmlHelper.TryParseHtmlTagOpenTag by using bitmask #1165

New Issue

Closed

opened 2026-01-29 14:50:45 +00:00 by claunia · 0 comments

claunia commented 2026-01-29 14:50:45 +00:00

Owner

Copy Link

📋 Pull Request Information

Original PR: https://github.com/xoofx/markdig/pull/650
Author: @gfoidl
Created: 7/21/2022
Status: ✅ Merged
Merged: 8/12/2022
Merged by: @xoofx

Base: master ← Head: htmlhelper-TryParseHtmlTagOpenTag_remove_branches

---

📝 Commits (1)

• bfd7b64 Remove some branches in HtmlHelper.TryParseHtmlTagOpenTag by using bitmasks

📊 Changes

1 file changed (+40 additions, -2 deletions)

View changed files

📝 src/Markdig/Helpers/HtmlHelper.cs (+40 -2)

📄 Description

Eliminate some branches in HtmlHelper.TryParseHtmlTagOpenTag (due to || comparisons) by using a bitmask approach instead.
Further the generated machine code has a test jump-combo, which allows optimizations at cpu-level (macro fusion, etc.).

Other places in that type seem not worthwile, as the count of cmps can't be lowered that the current count is.

Benchmarks

The benchmarks are done on a trimmed-down version of the code, to just test these parts of the code changed.

IsSpaceOrSpecialHtmlChar

|  Method |     Mean |   Error |  StdDev | Ratio | RatioSD | Code Size |
|-------- |---------:|--------:|--------:|------:|--------:|----------:|
| Default | 181.4 ns | 3.48 ns | 3.09 ns |  1.00 |    0.00 |      60 B |
|  Switch | 209.6 ns | 3.65 ns | 3.91 ns |  1.16 |    0.02 |      60 B |
|    Mask | 118.4 ns | 2.40 ns | 3.59 ns |  0.65 |    0.03 |      57 B |

benchmark code

using System.Diagnostics;
using System.Runtime.CompilerServices;
using BenchmarkDotNet.Attributes;

Bench bench = new();
Console.WriteLine(bench.Default());
Console.WriteLine(bench.Switch());
Console.WriteLine(bench.Mask());

#if !DEBUG
BenchmarkDotNet.Running.BenchmarkRunner.Run<Bench>();
#endif

[DisassemblyDiagnoser]
//[ShortRunJob]
public class Bench
{
    private static readonly char[] s_chars = { ' ', '\n', '"', '\'', '=', '<', '>', '`' };

    public Bench()
    {
        foreach (char c in s_chars)
        {
            Console.WriteLine($"{(int)c}");
        }

        Console.WriteLine();
    }

    [Benchmark(Baseline = true)]
    public int Default()
    {
        int count = 0;

        for (int cc = char.MinValue; cc <= char.MaxValue; ++cc)
        {
            char c = (char)cc;
            if (IsMatch0(c))
            {
                Debug.Assert(s_chars.Contains(c), $"{c} ({(int)c}) shouldn't be true");
                count++;
            }
        }

        Debug.Assert(count == s_chars.Length, $"wrong count, expected {s_chars.Length}, actual: {count}");
        return count;
    }

    //[Benchmark]
    public int Switch()
    {
        int count = 0;

        for (int cc = char.MinValue; cc <= char.MaxValue; ++cc)
        {
            char c = (char)cc;
            if (IsMatch00(c))
            {
                Debug.Assert(s_chars.Contains(c), $"{c} ({(int)c}) shouldn't be true");
                count++;
            }
        }

        Debug.Assert(count == s_chars.Length, $"wrong count, expected {s_chars.Length}, actual: {count}");
        return count;
    }

    [Benchmark]
    public int Mask()
    {
        int count = 0;

        for (int cc = char.MinValue; cc <= char.MaxValue; ++cc)
        {
            char c = (char)cc;
            if (IsMatch1(c))
            {
                Debug.Assert(s_chars.Contains(c), $"{c} ({(int)c}) shouldn't be true");
                count++;
            }
        }

        Debug.Assert(count == s_chars.Length, $"wrong count, expected {s_chars.Length}, actual: {count}");
        return count;
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private static bool IsMatch0(char c)
    {
        return c == ' ' || c == '\n' || c == '"' || c == '\'' || c == '=' || c == '<' || c == '>' || c == '`';
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private static bool IsMatch00(char c) => c switch
    {
        ' ' or '\n' or '"' or '\'' or '=' or '<' or '>' or '`' => true,
        _ => false,
    };

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private static bool IsMatch1(char c)
    {
        if (c > '>')
        {
            return c == '`';
        }

        const long BitMask =
              (1L << ' ')
            | (1L << '\n')
            | (1L << '"')
            | (1L << '\'')
            | (1L << '=')
            | (1L << '<')
            | (1L << '>');

        return (BitMask & (1L << c)) != 0;
    }
}

IsCharToAppend

|  Method |     Mean |   Error |  StdDev | Ratio | RatioSD | Code Size |
|-------- |---------:|--------:|--------:|------:|--------:|----------:|
| Default | 131.0 ns | 2.22 ns | 2.07 ns |  1.00 |    0.00 |      40 B |
|    Mask | 121.6 ns | 1.65 ns | 1.37 ns |  0.93 |    0.02 |      53 B |

benchmark code

using System.Diagnostics;
using System.Runtime.CompilerServices;
using BenchmarkDotNet.Attributes;

Bench bench = new();
Console.WriteLine(bench.Default());
Console.WriteLine(bench.Mask());

#if !DEBUG
BenchmarkDotNet.Running.BenchmarkRunner.Run<Bench>();
#endif

[DisassemblyDiagnoser]
//[ShortRunJob]
public class Bench
{
    private static readonly char[] s_chars = { '_', ':', '.', '-' };

    public Bench()
    {
        foreach (char c in s_chars)
        {
            Console.WriteLine($"{(int)c}");
        }

        Console.WriteLine();
    }

    [Benchmark(Baseline = true)]
    public int Default()
    {
        int count = 0;

        for (int cc = char.MinValue; cc < char.MaxValue; ++cc)
        {
            char c = (char)cc;
            if (IsMatch0(c))
            {
                Debug.Assert(s_chars.Contains(c), $"{c} ({(int)c}) shouldn't be true");
                count++;
            }
        }

        Debug.Assert(count == s_chars.Length, $"wrong count, expected {s_chars.Length}, actual: {count}");
        return count;
    }

    [Benchmark]
    public int Mask()
    {
        int count = 0;

        for (int cc = char.MinValue; cc < char.MaxValue; ++cc)
        {
            char c = (char)cc;
            if (IsMatch1(c))
            {
                Debug.Assert(s_chars.Contains(c), $"{c} ({(int)c}) shouldn't be true");
                count++;
            }
        }

        Debug.Assert(count == s_chars.Length, $"wrong count, expected {s_chars.Length}, actual: {count}");
        return count;
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private static bool IsMatch0(char c)
    {
        return c == '_' || c == ':' || c == '.' || c == '-';
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private static bool IsMatch1(char c)
    {
        if ((uint)(c - '-') > '_' - '-')
        {
            return false;
        }

        const long BitMask =
              (1L << '_')
            | (1L << ':')
            | (1L << '.')
            | (1L << '-');

        return (BitMask & (1L << c)) != 0;
    }
}

---

_{🔄 This issue represents a GitHub Pull Request. It cannot be merged through Gitea due to API limitations.}

## 📋 Pull Request Information **Original PR:** https://github.com/xoofx/markdig/pull/650 **Author:** [@gfoidl](https://github.com/gfoidl) **Created:** 7/21/2022 **Status:** ✅ Merged **Merged:** 8/12/2022 **Merged by:** [@xoofx](https://github.com/xoofx) **Base:** `master` ← **Head:** `htmlhelper-TryParseHtmlTagOpenTag_remove_branches` --- ### 📝 Commits (1) - [`bfd7b64`](https://github.com/xoofx/markdig/commit/bfd7b6460c8c7fc431df0dc48a3e01672dc5c1b5) Remove some branches in HtmlHelper.TryParseHtmlTagOpenTag by using bitmasks ### 📊 Changes **1 file changed** (+40 additions, -2 deletions) <details> <summary>View changed files</summary> 📝 `src/Markdig/Helpers/HtmlHelper.cs` (+40 -2) </details> ### 📄 Description Eliminate some branches in `HtmlHelper.TryParseHtmlTagOpenTag` (due to `||` comparisons) by using a bitmask approach instead. Further the generated machine code has a `test jump`-combo, which allows optimizations at cpu-level (macro fusion, etc.). Other places in that type seem not worthwile, as the count of `cmp`s can't be lowered that the current count is. ### Benchmarks The benchmarks are done on a trimmed-down version of the code, to just test these parts of the code changed. #### IsSpaceOrSpecialHtmlChar ``` | Method | Mean | Error | StdDev | Ratio | RatioSD | Code Size | |-------- |---------:|--------:|--------:|------:|--------:|----------:| | Default | 181.4 ns | 3.48 ns | 3.09 ns | 1.00 | 0.00 | 60 B | | Switch | 209.6 ns | 3.65 ns | 3.91 ns | 1.16 | 0.02 | 60 B | | Mask | 118.4 ns | 2.40 ns | 3.59 ns | 0.65 | 0.03 | 57 B | ``` <details> <summary>benchmark code</summary> ```c# using System.Diagnostics; using System.Runtime.CompilerServices; using BenchmarkDotNet.Attributes; Bench bench = new(); Console.WriteLine(bench.Default()); Console.WriteLine(bench.Switch()); Console.WriteLine(bench.Mask()); #if !DEBUG BenchmarkDotNet.Running.BenchmarkRunner.Run<Bench>(); #endif [DisassemblyDiagnoser] //[ShortRunJob] public class Bench { private static readonly char[] s_chars = { ' ', '\n', '"', '\'', '=', '<', '>', '`' }; public Bench() { foreach (char c in s_chars) { Console.WriteLine($"{(int)c}"); } Console.WriteLine(); } [Benchmark(Baseline = true)] public int Default() { int count = 0; for (int cc = char.MinValue; cc <= char.MaxValue; ++cc) { char c = (char)cc; if (IsMatch0(c)) { Debug.Assert(s_chars.Contains(c), $"{c} ({(int)c}) shouldn't be true"); count++; } } Debug.Assert(count == s_chars.Length, $"wrong count, expected {s_chars.Length}, actual: {count}"); return count; } //[Benchmark] public int Switch() { int count = 0; for (int cc = char.MinValue; cc <= char.MaxValue; ++cc) { char c = (char)cc; if (IsMatch00(c)) { Debug.Assert(s_chars.Contains(c), $"{c} ({(int)c}) shouldn't be true"); count++; } } Debug.Assert(count == s_chars.Length, $"wrong count, expected {s_chars.Length}, actual: {count}"); return count; } [Benchmark] public int Mask() { int count = 0; for (int cc = char.MinValue; cc <= char.MaxValue; ++cc) { char c = (char)cc; if (IsMatch1(c)) { Debug.Assert(s_chars.Contains(c), $"{c} ({(int)c}) shouldn't be true"); count++; } } Debug.Assert(count == s_chars.Length, $"wrong count, expected {s_chars.Length}, actual: {count}"); return count; } [MethodImpl(MethodImplOptions.AggressiveInlining)] private static bool IsMatch0(char c) { return c == ' ' || c == '\n' || c == '"' || c == '\'' || c == '=' || c == '<' || c == '>' || c == '`'; } [MethodImpl(MethodImplOptions.AggressiveInlining)] private static bool IsMatch00(char c) => c switch { ' ' or '\n' or '"' or '\'' or '=' or '<' or '>' or '`' => true, _ => false, }; [MethodImpl(MethodImplOptions.AggressiveInlining)] private static bool IsMatch1(char c) { if (c > '>') { return c == '`'; } const long BitMask = (1L << ' ') | (1L << '\n') | (1L << '"') | (1L << '\'') | (1L << '=') | (1L << '<') | (1L << '>'); return (BitMask & (1L << c)) != 0; } } ``` </details> #### IsCharToAppend ``` | Method | Mean | Error | StdDev | Ratio | RatioSD | Code Size | |-------- |---------:|--------:|--------:|------:|--------:|----------:| | Default | 131.0 ns | 2.22 ns | 2.07 ns | 1.00 | 0.00 | 40 B | | Mask | 121.6 ns | 1.65 ns | 1.37 ns | 0.93 | 0.02 | 53 B | ``` <details> <summary>benchmark code</summary> ```c# using System.Diagnostics; using System.Runtime.CompilerServices; using BenchmarkDotNet.Attributes; Bench bench = new(); Console.WriteLine(bench.Default()); Console.WriteLine(bench.Mask()); #if !DEBUG BenchmarkDotNet.Running.BenchmarkRunner.Run<Bench>(); #endif [DisassemblyDiagnoser] //[ShortRunJob] public class Bench { private static readonly char[] s_chars = { '_', ':', '.', '-' }; public Bench() { foreach (char c in s_chars) { Console.WriteLine($"{(int)c}"); } Console.WriteLine(); } [Benchmark(Baseline = true)] public int Default() { int count = 0; for (int cc = char.MinValue; cc < char.MaxValue; ++cc) { char c = (char)cc; if (IsMatch0(c)) { Debug.Assert(s_chars.Contains(c), $"{c} ({(int)c}) shouldn't be true"); count++; } } Debug.Assert(count == s_chars.Length, $"wrong count, expected {s_chars.Length}, actual: {count}"); return count; } [Benchmark] public int Mask() { int count = 0; for (int cc = char.MinValue; cc < char.MaxValue; ++cc) { char c = (char)cc; if (IsMatch1(c)) { Debug.Assert(s_chars.Contains(c), $"{c} ({(int)c}) shouldn't be true"); count++; } } Debug.Assert(count == s_chars.Length, $"wrong count, expected {s_chars.Length}, actual: {count}"); return count; } [MethodImpl(MethodImplOptions.AggressiveInlining)] private static bool IsMatch0(char c) { return c == '_' || c == ':' || c == '.' || c == '-'; } [MethodImpl(MethodImplOptions.AggressiveInlining)] private static bool IsMatch1(char c) { if ((uint)(c - '-') > '_' - '-') { return false; } const long BitMask = (1L << '_') | (1L << ':') | (1L << '.') | (1L << '-'); return (BitMask & (1L << c)) != 0; } } ``` </details> --- _{🔄 This issue represents a GitHub Pull Request. It cannot be merged through Gitea due to API limitations.}

claunia added the pull-request label 2026-01-29 14:50:45 +00:00

claunia closed this issue 2026-01-29 14:50:45 +00:00

Sign in to join this conversation.

No Branch/Tag Specified

Branches Tags

master

example-lunet-api-doc

jira-markup

perf-core-vs-mono

0.44.0

0.43.0

0.42.0

0.41.3

0.41.2

0.41.1

0.41.0

0.40.0

0.39.1

0.39.0

0.38.0

0.37.0

0.36.2

0.36.1

0.36.0

0.35.0

0.34.0

0.33.0

0.32.0

0.31.0

0.30.4

0.30.3

0.30.2

0.30.1

0.30.0

0.29.0

0.28.1

0.28.0

0.27.0

0.26.0

0.25.0

0.24.0

0.23.0

0.22.1

0.22.0

0.21.1

0.21.0

0.20.0

0.18.3

0.18.2

0.18.1

0.18.0

0.17.1

0.17.0

v0.16.0

v0.15.7

v0.15.6

v0.15.5

v0.15.4

v0.15.3

v0.15.2

v0.15.1

v0.15.0

v0.14.9

v0.14.8

v0.14.7

v0.14.6

v0.14.5

v0.14.4

v0.14.3

v0.14.2

v0.14.1

v0.14.0

v0.13.4

v0.13.3

v0.13.2

v0.13.1

v0.13.0

v0.12.4

v0.12.3

v0.12.2

v0.12.1

v0.12.0

v0.11.0

v0.10.7

v0.10.6

v0.10.5

v0.10.4

v0.10.3

v0.10.2

v0.10.1

v0.10.0

v0.9.1

v0.9.0

v0.8.5

v0.8.4

v0.8.3

v0.8.2

v0.8.1

v0.8.0

v0.7.5

v0.7.4

v0.7.3

v0.7.2

v0.7.1

v0.7.0

v0.6.2

v0.6.1

v0.6.0

v0.5.12

v0.5.11

v0.5.10

v0.5.9

v0.5.8

v0.5.7

v0.5.6

v0.5.5

v0.5.4

v0.5.3

v0.5.2

v0.5.1

v0.5.0

v0.4.0

v0.3.4

v0.3.3

v0.3.2

v0.3.1

v0.3.0

v0.2.1

v0.2.0

v0.1.1

v0.1.0

Labels

Clear labels

bug

documentation

enhancement

extension

Hacktoberfest

invalid

PR Welcome!

pull-request

Mirrored from GitHub Pull Request

question

wontfix

No Label pull-request

Milestone

No items

No Milestone

Projects

Clear projects

No project

Assignees

Clear assignees

claunia

No Assignees

1 Participants

Notifications

Subscribe

Due Date

No due date set.

Dependencies

No dependencies set.

Reference: starred/markdig#1165