AutoHotkey Community

; QueryPerfomanceCounter - Benchmark Skript
; Version 1.0 (w) 2008 by DerRaphael / zLib License Style Release

DllCall("QueryPerformanceFrequency", "Int64*", BenchMark[F])
; BENCHMARK START
; Äußere Runden / Outer Rounds
@OR := 5
; Innere Läufe / Inner Runs
@IR := 10

; INIT VAR - use for simplicity this script as source
Gosub, GetVariable
Gosub, BuildRef

; Start Benchmark
Loop,4
{
   Setting := A_Index
   SetBatchLines, 20
   Critical, Off
   Process, Priority,, Normal
   if (A_Index = 1) {
      CurrentSettings := "SetBatchLines, 20 / Critical, Off / Process Priority Normal"
   } else if (A_Index = 2) {
      CurrentSettings := "SetBatchLines, -1 / Critical, Off / Process Priority Normal"
      SetBatchLines, -1
      Critical, Off
      Process, Priority,, Normal
   } else if (A_Index = 3) {
      CurrentSettings := "SetBatchLines, -1 / Critical, On / Process Priority Normal"
      SetBatchLines, -1
      Critical, On
      Process, Priority,, Normal
   } else if (A_Index = 4) {
      CurrentSettings := "SetBatchLines, -1 / Critical, On / Process Priority Realtime"
      SetBatchLines, -1
      Critical, On
      Process, Priority,, R
   }
   OfficialResult .= "`n" CurrentSettings "`n"
   
   Loop, % @OR
   {
      A_Run := A_Index
      Loop, % @IR
      {
         ; Zähler der auszuführenden Tests / Count of Tests to accomplish
         A_Test := 0
         
         ; SOBM***********************************************************************************
         A_Test+=1
         
         if !StrLen(Desc[%A_Test%])
            Desc[%A_Test%] := "randallf's original function"
           
         DllCall("QueryPerformanceCounter", "Int64 *", BenchMark[SC]) ; StartCounter
         
         ; Hier komme hinein, was getestet wird / Insert what needs to be tested
       res := ReverseLines(var)
         ; Hier ist zuende, was getestet wurde / End of whatever has been tested
         
         DllCall("QueryPerformanceCounter", "Int64 *", BenchMark[EC]) ; EndCounter
         
         Result[%A_Test%][%A_Run%][%A_Index%] := (BenchMark[EC] - BenchMark[SC]) / BenchMark[F]
         ; ***********************************************************************************EOBM
         ; SOBM***********************************************************************************
         A_Test+=1
         
         if !StrLen(Desc[%A_Test%])
            Desc[%A_Test%] := "dR's reverse - I (loop w/ ternary)"
           
         DllCall("QueryPerformanceCounter", "Int64 *", BenchMark[SC]) ; StartCounter
         
         ; Hier komme hinein, was getestet wird / Insert what needs to be tested
       res := reverse(var)
         ; Hier ist zuende, was getestet wurde / End of whatever has been tested
         
         DllCall("QueryPerformanceCounter", "Int64 *", BenchMark[EC]) ; EndCounter
         
         Result[%A_Test%][%A_Run%][%A_Index%] := (BenchMark[EC] - BenchMark[SC]) / BenchMark[F]
     
       if ( res != ref )
         MsgBox FAIL@%A_Test%
         ; ***********************************************************************************EOBM
         ; SOBM***********************************************************************************
         A_Test+=1
         
         if !StrLen(Desc[%A_Test%])
            Desc[%A_Test%] := "dR's reverse - II (recursive sort callback)"
           
         DllCall("QueryPerformanceCounter", "Int64 *", BenchMark[SC]) ; StartCounter
         
         ; Hier komme hinein, was getestet wird / Insert what needs to be tested
       res := reverse2(var)
         ; Hier ist zuende, was getestet wurde / End of whatever has been tested
         
         DllCall("QueryPerformanceCounter", "Int64 *", BenchMark[EC]) ; EndCounter
         
         Result[%A_Test%][%A_Run%][%A_Index%] := (BenchMark[EC] - BenchMark[SC]) / BenchMark[F]
     
       if ( res != ref )
         MsgBox FAIL@%A_Test%
         ; ***********************************************************************************EOBM
         ; SOBM***********************************************************************************
         A_Test+=1
         
         if !StrLen(Desc[%A_Test%])
            Desc[%A_Test%] := "dR's reverse - III (loop w/ substring)"
           
         DllCall("QueryPerformanceCounter", "Int64 *", BenchMark[SC]) ; StartCounter
         
         ; Hier komme hinein, was getestet wird / Insert what needs to be tested
       res := reverse3(var)
         ; Hier ist zuende, was getestet wurde / End of whatever has been tested
         
         DllCall("QueryPerformanceCounter", "Int64 *", BenchMark[EC]) ; EndCounter
         
         Result[%A_Test%][%A_Run%][%A_Index%] := (BenchMark[EC] - BenchMark[SC]) / BenchMark[F]
     
       if ( res != ref )
         MsgBox FAIL@%A_Test%
         ; ***********************************************************************************EOBM
         ; SOBM***********************************************************************************
         A_Test+=1
         
         if !StrLen(Desc[%A_Test%])
            Desc[%A_Test%] := "jBalli's jReverse I"
           
         DllCall("QueryPerformanceCounter", "Int64 *", BenchMark[SC]) ; StartCounter
         
         ; Hier komme hinein, was getestet wird / Insert what needs to be tested
       res := jReverse(var)
         ; Hier ist zuende, was getestet wurde / End of whatever has been tested
         
         DllCall("QueryPerformanceCounter", "Int64 *", BenchMark[EC]) ; EndCounter
         
         Result[%A_Test%][%A_Run%][%A_Index%] := (BenchMark[EC] - BenchMark[SC]) / BenchMark[F]
     
       if ( res != ref )
         MsgBox FAIL@%A_Test%
         ; ***********************************************************************************EOBM
         ; SOBM***********************************************************************************
         A_Test+=1
         
         if !StrLen(Desc[%A_Test%])
            Desc[%A_Test%] := "ReverseDirectionByNewline by rseding91"
           
         DllCall("QueryPerformanceCounter", "Int64 *", BenchMark[SC]) ; StartCounter
         
         ; Hier komme hinein, was getestet wird / Insert what needs to be tested
         ReverseDirectionByNewline(byref var)
         ; Hier ist zuende, was getestet wurde / End of whatever has been tested
         
         DllCall("QueryPerformanceCounter", "Int64 *", BenchMark[EC]) ; EndCounter
         
         Result[%A_Test%][%A_Run%][%A_Index%] := (BenchMark[EC] - BenchMark[SC]) / BenchMark[F]
     
       if ( res != ref )
         MsgBox FAIL@%A_Test%
         ; ***********************************************************************************EOBM
         ; SOBM***********************************************************************************
         A_Test+=1
         
         if !StrLen(Desc[%A_Test%])
            Desc[%A_Test%] := "QPC Benchmark BuildIn"
           
         DllCall("QueryPerformanceCounter", "Int64 *", BenchMark[SC]) ; StartCounter
         
         ; Hier komme hinein, was getestet wird / Insert what needs to be tested
       res := QPC_BenchmarkInternal( Var )
         ; Hier ist zuende, was getestet wurde / End of whatever has been tested
         
         DllCall("QueryPerformanceCounter", "Int64 *", BenchMark[EC]) ; EndCounter
         
         Result[%A_Test%][%A_Run%][%A_Index%] := (BenchMark[EC] - BenchMark[SC]) / BenchMark[F]
     
       if ( res != ref )
         MsgBox FAIL@%A_Test%
         ; ***********************************************************************************EOBM
      }
      ; Zeiten mitteln / Average Timings
      Loop, % A_Test
      {
         A_Test := A_Index
         Result[%A_Test%][%A_Run%] := 0
         Loop, % @IR
            Result[%A_Test%][%A_Run%] += Result[%A_Test%][%A_Run%][%A_Index%]
         Result[%A_Test%][%A_Run%] /= @IR
      }
   }
   ; BENCHMARK END
   ; Resultate ermitteln / Calculate Results
   Loop, % A_Test
   {
      A_Test := A_Index
      Result[%A_Test%] := 0
      Loop, % A_Run
         Result[%A_Test%] += Result[%A_Test%][%A_Index%]
      Result[%A_Test%] /= @OR
      OfficialResult .= Result[%A_Test%] " sec`t(" Desc[%A_Test%] ")`n"
   }
}
SetBatchLines, 20
Critical, Off
Process, Priority,, Normal

MsgBox,64,Benchmark Results %@OR% Runs with %@IR% Rounds, %OfficialResult%
ExitApp

ReverseDirectionByNewline(byref var,Delimiter="`n",Omit="")
{
   Local FastRtlMoveMemory, Offset, T1, T2, T3
MsgBox
   If (StrLen(Delimiter) > 1 or StrLen(Omit) > 1)
      Return -1
   FastRtlMoveMemory := DllCall("GetProcAddress", A_IsUnicode ? Ptr : uint, DllCall("GetModuleHandle", "str", "kernel32.dll"), A_IsUnicode ? AStr : str, "RtlMoveMemory")
   Offset := StrLen(var), T1 := &var
   If (A_IsUnicode){
      Offset *= 2
      Loop, Parse, var,%Delimiter%,%Omit%
         T2 := A_LoopField Delimiter Omit, T3 := StrLen(T2)*2, Offset -= T3, DllCall(FastRtlMoveMemory,"UInt",T1 + Offset,"UInt",&T2,"UInt",T3)
   } Else {
      Loop, Parse, var,%Delimiter%,%Omit%
         T2 := A_LoopField Delimiter Omit, T3 := StrLen(T2), Offset -= T3, DllCall(FastRtlMoveMemory,"UInt",T1 + Offset,"UInt",&T2,"UInt",T3)
   }
}

; TEST FUNCTIONS
; Randallf's Original Function
ReverseLines(InputVar) ;reverses lines in a variable read from a file that was delimited by `n
{
   StringSplit, a, InputVar, `n
   While a0
   {
      If Reversed
      {
         Reversed := Reversed . "`n" . a%a0%
      }
      Else
      {
         Reversed := a%a0%
      }
     
      a0--
   }
   Return Reversed
}

; dR I
reverse(var) {
   Loop,Parse,var,`n
      n := a_loopfield ( strlen( n ) ? "`n" : "" ) n
   return n
}
; dR II
reverse2( a,b = "",c = "init" ) { ; adapted from sort help's last sample
   if ( c != "init" )
      return c
   else
      sort,a,% "F " A_ThisFunc
   return a
}
; dR III
reverse3(var) {
   Loop,Parse,var,`n
      n := a_loopfield "`n" n
   return SubStr( n,1,-1 )
}
; jBally I
jReverse(p_Data)
    {
    l_AutoTrim:=A_AutoTrim
    AutoTrim off
    VarSetCapacity(Reversed,StrLen(p_Data))
    loop parse,p_Data,`n,`r
        if StrLen(Reversed)=0
            Reversed:=A_LoopField
         else
            Reversed=%A_LoopField%`n%Reversed%
    AutoTrim %l_AutoTrim%
    return Reversed
   }
; buildIn
QPC_BenchmarkInternal( Var )
{
   sort, var, F SortDummyCallBack
   return var
}

GetVariable:
var =
(Ltrim Join`n
   Lorem ipsum dolor sit amet, consetetur sadipscing elitr,
   sed diam nonumy eirmod tempor invidunt ut labore et dolore
   magna aliquyam erat, sed diam voluptua. At vero eos et
   accusam et justo duo dolores et ea rebum. Stet clita kasd
   gubergren, no sea takimata sanctus est Lorem ipsum dolor
   sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing
   elitr,  sed diam nonumy eirmod tempor invidunt ut labore et
   dolore magna aliquyam erat, sed diam voluptua. At vero eos
   et accusam et justo duo dolores et ea rebum. Stet clita
   kasd gubergren, no sea takimata sanctus est Lorem ipsum
   dolor sit amet. Lorem ipsum dolor sit amet, consetetur
   sadipscing elitr,  sed diam nonumy eirmod tempor invidunt
   ut labore et dolore magna aliquyam erat, sed diam voluptua.
   At vero eos et accusam et justo duo dolores et ea rebum.
   Stet clita kasd gubergren, no sea takimata sanctus est
   Lorem ipsum dolor sit amet.
   Duis autem vel eum iriure dolor in hendrerit in vulputate
   velit esse molestie consequat, vel illum dolore eu feugiat
   nulla facilisis at vero eros et accumsan et iusto odio
   dignissim qui blandit praesent luptatum zzril delenit augue
   duis dolore te feugait nulla facilisi. Lorem ipsum dolor
   sit amet, consectetuer adipiscing elit, sed diam nonummy
   nibh euismod tincidunt ut laoreet dolore magna aliquam erat
   volutpat.
   Ut wisi enim ad minim veniam, quis nostrud exerci tation
   ullamcorper suscipit lobortis nisl ut aliquip ex ea commodo
   consequat. Duis autem vel eum iriure dolor in hendrerit in
   vulputate velit esse molestie consequat, vel illum dolore
   eu feugiat nulla facilisis at vero eros et accumsan et iusto
   odio dignissim qui blandit praesent luptatum zzril delenit
   augue duis dolore te feugait nulla facilisi.
   Nam liber tempor cum soluta nobis eleifend option congue
   nihil imperdiet doming id quod mazim placerat facer possim
   assum. Lorem ipsum dolor sit amet, consectetuer adipiscing
   elit, sed diam nonummy nibh euismod tincidunt ut laoreet
   dolore magna aliquam erat volutpat. Ut wisi enim ad minim
   veniam, quis nostrud exerci tation ullamcorper suscipit
   lobortis nisl ut aliquip ex ea commodo consequat.
   Duis autem vel eum iriure dolor in hendrerit in vulputate
   velit esse molestie consequat, vel illum dolore eu feugiat
   nulla facilisis.
   At vero eos et accusam et justo duo dolores et ea rebum.
   Stet clita kasd gubergren, no sea takimata sanctus est
   Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet,
   consetetur sadipscing elitr,  sed diam nonumy eirmod tempor
   invidunt ut labore et dolore magna aliquyam erat, sed diam
   voluptua. At vero eos et accusam et justo duo dolores et ea
   rebum. Stet clita kasd gubergren, no sea takimata sanctus
   est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet,
   consetetur sadipscing elitr,  At accusam aliquyam diam diam
   dolore dolores duo eirmod eos erat, et nonumy sed tempor et
   et invidunt justo labore Stet clita ea et gubergren, kasd
   magna no rebum. sanctus sea sed takimata ut vero voluptua.
   est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet,
   consetetur sadipscing elitr,  sed diam nonumy eirmod tempor
   invidunt ut labore et dolore magna aliquyam erat.
   Consetetur sadipscing elitr,  sed diam nonumy eirmod tempor
   invidunt ut labore et dolore magna aliquyam erat, sed diam
   voluptua. At vero eos et accusam et justo duo dolores et ea
   rebum. Stet clita kasd gubergren, no sea takimata sanctus est
   Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet,
   consetetur sadipscing elitr,  sed diam nonumy eirmod tempor
   invidunt ut labore et dolore magna aliquyam erat, sed diam
   voluptua. At vero eos et accusam et justo duo dolores et ea
   rebum. Stet clita kasd gubergren, no sea takimata sanctus est
   Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet,
   consetetur sadipscing elitr,  sed diam nonumy eirmod tempor
   invidunt ut labore et dolore magna aliquyam erat, sed diam
   voluptua. At vero eos et accusam et justo duo dolores et ea
   rebum. Stet clita kasd gubergren, no sea takimata sanctus
   est Lorem ipsum dolor sit amet.
)
Return

BuildRef:
   Ref := var
   Sort,Ref,F SortDummyCallBack
Return

SortDummyCallBack(a,b,c)
{
   return c
}

; dR I
reverse(var) {
   Loop,Parse,var,`n
      n := a_loopfield ( strlen( n ) ? "`n" : "" ) n
   return n
}

; dR I
reverse(var) {
   Loop,Parse,var,`n
      n .= n ? "`n" A_LoopField : A_LoopField
   return n
}

; dR I
reverse(var) {
   Loop,Parse,var,`n
      n .= n ? "`n" A_LoopField n : A_LoopField n
   return n
}

; dR I
reverse(var) {
   Loop,Parse,var,`n
      n := n ? A_LoopField  "`n" n : A_LoopField ; adding in front of the var
   return n
}

ReverseDirectionByNewline(byref var,Delimiter="`n",Omit="")
{
   Local Offset, T1, T2, T3, T4
   Static FastRtlMoveMemory
   If (StrLen(Delimiter) > 1 or StrLen(Omit) > 1)
      Return -1
   If !FastRTLMoveMemory
      FastRtlMoveMemory := DllCall("GetProcAddress", A_IsUnicode ? Ptr : uint, DllCall("GetModuleHandle", "str", "kernel32.dll"), A_IsUnicode ? AStr : str, "RtlMoveMemory")
   Offset := StrLen(var), T1 := &var
   If Omit
      T4 := SubStr(Var,-1), T4 := T4 = Delimiter Omit ? 1 : 0
   Else
      T4 := SubStr(Var,0), T4 := T4 = Delimiter ? 1 : 0
   If (A_IsUnicode){
      Offset *= 2
      If (T4){
         Loop, Parse, var,%Delimiter%,%Omit%
            T2 := A_LoopField Delimiter Omit, T3 := StrLen(T2)*2, Offset -= T3, DllCall(FastRtlMoveMemory,"UInt",T1 + Offset,"UInt",&T2,"UInt",T3)
      } Else {
         Loop, Parse, var,%Delimiter%,%Omit%
            T2 := A_Index = 1 ? A_LoopField : A_LoopField Delimiter Omit, T3 := StrLen(T2)*2, Offset -= T3, DllCall(FastRtlMoveMemory,"UInt",T1 + Offset,"UInt",&T2,"UInt",T3)
      }
   } Else {
      If (T4){
         Loop, Parse, var,%Delimiter%,%Omit%
            T2 := A_LoopField Delimiter Omit, T3 := StrLen(T2), Offset -= T3, DllCall(FastRtlMoveMemory,"UInt",T1 + Offset,"UInt",&T2,"UInt",T3)
      } Else {
         Loop, Parse, var,%Delimiter%,%Omit%
            T2 := A_Index = 1 ? A_LoopField : A_LoopField Delimiter Omit, T3 := StrLen(T2), Offset -= T3, DllCall(FastRtlMoveMemory,"UInt",T1 + Offset,"UInt",&T2,"UInt",T3)
      }
   }
}

ReverseDirectionByNewline(byref var,Delimiter="`n",Omit="") {
   Local Offset, T1, T2, T3, T4
   Static FastRtlMoveMemory
   If (StrLen(Delimiter) > 1 or StrLen(Omit) > 1)
      Return -1
   If !FastRTLMoveMemory
      FastRtlMoveMemory := DllCall("GetProcAddress", A_IsUnicode ? Ptr : uint, DllCall("GetModuleHandle", "str", "kernel32.dll"), A_IsUnicode ? AStr : str, "RtlMoveMemory")
   Offset := StrLen(var), T1 := &var
   Omit ? (T4 := SubStr(Var,-1), T4 := T4 = Delimiter Omit ? 1 : 0) : (T4 := SubStr(Var,0), T4 := T4 = Delimiter ? 1 : 0)
   A_IsUnicode ? Offset *= mp := 2 : mp := 1
   If (T4)
      Loop, Parse, var,%Delimiter%,%Omit%
         T2 := A_LoopField Delimiter Omit, T3 := StrLen(T2)*mp, Offset -= T3, DllCall(FastRtlMoveMemory,"UInt",T1 + Offset,"UInt",&T2,"UInt",T3)
   Else Loop, Parse, var,%Delimiter%,%Omit%
      T2 := A_Index = 1 ? A_LoopField : A_LoopField Delimiter Omit, T3 := StrLen(T2)*mp, Offset -= T3, DllCall(FastRtlMoveMemory,"UInt",T1 + Offset,"UInt",&T2,"UInt",T3)
   }

ReverseDirectionByNewline(byref var,Delimiter="`n",Omit="") {
   Static FastRtlMoveMemory
   If (StrLen(Delimiter) > 1 or StrLen(Omit) > 1)
      Return -1
   If !FastRTLMoveMemory
      FastRtlMoveMemory := DllCall("GetProcAddress", A_IsUnicode ? Ptr : uint, DllCall("GetModuleHandle", "str", "kernel32.dll"), A_IsUnicode ? AStr : str, "RtlMoveMemory")
   Offset := StrLen(var), T1 := &var
   Omit ? (T4 := SubStr(Var,-1), T4 := T4 = Delimiter Omit ? 1 : 0) : (T4 := SubStr(Var,0), T4 := T4 = Delimiter ? 1 : 0)
   A_IsUnicode ? Offset *= mp := 2 : mp := 1
   IfNotEqual,T4,%False%,Loop,Parse,var,%Delimiter%,%Omit%
      T2 := A_LoopField Delimiter Omit, T3 := StrLen(T2)*mp, Offset -= T3, DllCall(FastRtlMoveMemory,"UInt",T1 + Offset,"UInt",&T2,"UInt",T3)
   Else Loop,Parse,var,%Delimiter%,%Omit%
      T2 := A_Index = 1 ? A_LoopField : A_LoopField Delimiter Omit, T3 := StrLen(T2)*mp, Offset -= T3, DllCall(FastRtlMoveMemory,"UInt",T1 + Offset,"UInt",&T2,"UInt",T3)
   }