unicode.SimpleFold does a binary search over the caseOrbit table, every letter.

Introducing a LUT for runes < 0x80, helped the Easy0i case.

var foldLUT [0x80]uint16

func SimpleFold(r rune) rune {
    if r < len(foldLUT) {
        return rune(foldLUT[r])
    }
    // ...

Results:

BenchmarkMatchEasy0i_32-8        1000000              1796 ns/op          17.82 MB/s
BenchmarkMatchEasy0i_1K-8          30000             50636 ns/op          20.22 MB/s
BenchmarkMatchEasy0i_32K-8          1000           2326133 ns/op          14.09 MB/s
BenchmarkMatchEasy0i_1M-8             20          74604270 ns/op          14.06 MB/s
BenchmarkMatchEasy0i_32M-8             1        2373135700 ns/op          14.14 MB/s

Nice. Use https://godoc.org/golang.org/x/tools/cmd/benchcmp to show the before & after numbers.

Send in a change? https://golang.org/doc/contribute.html

It's probably too late for Go 1.6, though, unless you send it soon and it addresses an existing bug or regression.

Sure, I can make CL for the unicode.SimpleFold optimization.

I'm not sure whether regexp part can or should be adjusted, to not use SimpleFold?

I don't think you can change SimpleFold to ToLower in regexp. I suspect that would break case-insensitive regexps over characters like "kKK" (little k, big k, Kelvin symbol)? But no, ToLower of kelvin symbol is lowercase 'k'.... http://play.golang.org/p/pqhR4ksOk_ But maybe there are other characters which SimpleFold to each other but don't map to the same ToLower character? You could brute force all the characters (or characters in the defined ranges) and see?

Done: https://go-review.googlesource.com/#/c/16943/

CL https://golang.org/cl/16943 mentions this issue.

Did the brute-force, it seems that there are multiple such cases: https://play.golang.org/p/D1_JuZYP0v. So yes, unicode.ToLower wouldn't be suitable. Then again, it would be possible to use regexp/syntax.minFoldRune (after making it single lookup).

Probably enough for Go 1.7. Leaving this open, though, if you were planning on doing more later.

Go 1.7 is looming and I don't see this mentioned anywhere in the release notes and no update on this ticket - is this being rolled into the 1.7 release? Regex is an unfortunate pain point for Go performance compared to other languages.

@aprice @egonelbre's improvements (https://go-review.googlesource.com/#/c/16943/) were merged and will be part of Go 1.7. (Localized performance improvements are typically not called out in the release notes.)

A change was submitted to speed up unicode.SimpleFold performance for ASCII, which in turns speeds up case-insensitive regexp performance for ASCII. That change is not significant enough to mention in the release notes. This issue remains open for improved case-folding performance for non-ASCII, if anybody wants to work on it.

I have moved my question to the forum, as requested.
https://forum.golangbridge.org/t/unicode-simplefold-implementataion-in-go-1-7/2999

Let's move general code/style questions to a mailing list and not clutter this bug. I'm happy to answer on a mailing list.

When making the easy fix, the better solution would have been to avoid calling SimpleFold and use minFoldRune with a LUT to make less lookups. Also, maybe, convert the case-insensitive part of regexp to minFold when compiling the regexp. However, I don't think I would be able to create the time to make such change.

You can't simply use strings.ToLower on "knicks" because that will fail to match the "k" against the Unicode Kelvin symbol U+212A (K). The extra overhead here compared to strings.ToLower is exactly to add that symbol.