6 replies to this topic

[Lexikos]

Testing is needed for the following, with any scripts using RegEx:
[*:2ay91th6]AutoHotkey_pcre830.zip (Unicode 32-bit)
[*:2ay91th6]AutoHotkey_pcre830_ansi.zip
[*:2ay91th6]AutoHotkey_pcre830_x64.zipThese are based on v1.1.07.01, with PCRE 8.30 merged in. PCRE 8.30 supports building a 16-bit library in addition to the usual 8-bit library, superseding my earlier changes to support UTF-16. There have also been numerous bug-fixes and some other improvements. See pcre/changelog.txt.

PCRE 8.20 and later include just-in-time compilation of patterns - that is, patterns can be compiled to machine code for faster re-evaluation. This is enabled in the downloads above, and can be used by specifying the S (study) option. However, it adds about 68 KB to the final executable size (for Unicode 32-bit). I think that very few scripts are likely to benefit from it, so it will probably be disabled. Enabling/disabling it is a simple matter of adding/removing the following line in pcre/config.h before compiling:

#define SUPPORT_JIT

Note that AutoHotkey caches the last 100 patterns. I have also fixed a bug with the S (study) option; the study data wasn't freed when a studied pattern was dropped from the cache. (This was only a problem when hundreds of unique patterns were being used.)

For source code, see github.

[Lexikos]

Which patterns with what input? My tests showed less than double the speed when JIT compilation was used, and little or no improvement otherwise.

[nimda]

I found that it slowed down (vs AHK_L 1.1.07.01) for a single run, but sped up for subsequent runs (probably due to the compiling)

/* AHK_L 1.1.07.01
Single Run:  1190    = 0.000048s
10,000 runs: 1951143 = 0.078046s

AHK Beta
Single Run:  4177    = 0.000167s
10,000 runs: 1299058 = 0.051962s
*/

#NoEnv
SetBatchLines, -1
Process, Priority,, High

Timer("Init"), clipboard := ""

UrlRegEx =
(Join
(?i)\b((?:[a-z][\w-]+:(?:/{1,3}|[a-z0-9`%])|www\d{0,3}[.]
|[a-z0-9.\-]+[.][a-z]{2,4}/)(?:[^\s()<>]+|\(([^\s()<>]+
|(\([^\s()<>]+\)))*\))+(?:\(([^\s()<>]+
|(\([^\s()<>]+\)))*\)|[^\s``!()\[\]{};:'".,<>?«»“”‘’]))
)

Timer("Start")
RegExMatch("blah www.autohotkey.net/ blah", URLRegEx, O)
Clipboard .= Timer("Stop", "Single Run: {1} = {2}s`r`n", 1)


Timer("Start")
Loop 10000
   RegExMatch("blah `n v.gd/gdip_ `n", URLRegEx, O)
Clipboard .= Timer("Stop", "10,000 runs: {1} = {2}s", 1)

Timer(sMode, sContext="", bDisplay=0){
	static startCounter, QPFrequency
	if !QPFrequency
		DllCall("QueryPerformanceFrequency", "Int64*", QPFrequency)
	if ( sMode = "Start" ){
		DllCall("QueryPerformanceCounter", "Int64*", StartCounter)
		return StartCounter
	}
	else if ( sMode = "Stop" ){
		DllCall("QueryPerformanceCounter", "Int64*", EndCounter)
		Time1 := EndCounter - StartCounter
		Time2 := Time1 / QPFrequency
		if ( bDisplay ){
			if !sContext
				sContext := "{1}"
			StringReplace, sContext, sContext, {1}, %Time1%, All
			StringReplace, sContext, sContext, {2}, %Time2%, All
			MsgBox % sContext
		}
		return sContext
	}
}

[Lexikos]

The first run is always slower as the pattern has to be "compiled" to byte code. AutoHotkey caches the last 100 compiled patterns, so subsequent runs are typically faster. JIT compilation is not used by default as it takes longer if a compiled pattern isn't already in the cache. See my first post.

[nimda]

Lexikos,
I was not referring to the difference between single and multiple runs, but rather the difference between AutoHotkey versions.
When compiling a pattern for the first time, the Beta was slower.
When using cached patterns, the Beta was faster.