Func.Bind()/ObjBindMethod() tricks - extended functions

[Coco]

Just some useful/convenient BoundFunc objects(there are many more of course) :

Code: Select all

WshShell := ComObjCreate("WScript.Shell")

Exec := ObjBindMethod(WshShell, "Exec")
%Exec%("calc.exe")

; alternative MsgBox
Popup := ObjBindMethod(WshShell, "Popup")
%Popup%("Hello World",, A_ScriptName)

; current process ID
A_ScriptPid := Func("DllCall").Bind("GetCurrentProcessId", "Ptr", 0)
%Popup%( "A_ScriptPid = " . %A_ScriptPid%() )

; count of key-value pairs
ObjCount := Func("NumGet").Bind(4 * A_PtrSize)
obj := {a:"Auto", h:"Hot", k:"key"}
%Popup%( "ObjCount = " . %ObjCount%(&obj) ) ; must pass address

StrUpper := Func("Format").Bind("{:Us}")
%Popup%( %StrUpper%("autohotkey") )

StrLower := Func("Format").Bind("{:Ls}")
%Popup%( %StrLower%("AUTOHOTKEY") )

StrTitle := Func("Format").Bind("{:Ts}")
%Popup%( %StrTitle%("the quick brown fox") )

DecToHex := Func("Format").Bind("0x{:X}")
%Popup%( "57007 = " . %DecToHex%(57007) )

IsWinVisible := Func("DllCall").Bind("IsWindowVisible", "Ptr")
%Popup%( %IsWinVisible%(A_ScriptHwnd + 0) ) ; must pass hWnd

IsWindow := Func("DllCall").Bind("IsWindow", "Ptr")
%Popup%( %IsWindow%(A_ScriptHwnd + 0) )

sc := ComObjCreate("ScriptControl")
sc.Language := "JScript"
JsEval := ObjBindMethod(sc, "Eval")
%Popup%( "1 + 1 = " . %JsEval%("1 + 1") )

; Readable OnMessage(es)
OnWinDestroy := Func("OnMessage").Bind(0x02)
%OnWinDestroy%("WM_DESTROY")
ExitApp

[toralf]

Did you test if a bound function is faster or slower than the normal call? E.g. Inside of a loop with multiple cycles.

[joedf]

Hmmm interesting

[geek]

I was halfway expecting to be able to do this

Code: Select all

Shell := ComObjCreate("WScript.Shell")
Exec := ObjBindMethod(Shell, "Exec", A_AhkPath " *")
Dyna := ObjBindMethod(Exec, "StdIn.Write")
; Or
Dyna := ObjBindMethod(ObjBindMethod(Exec, "StdIn"), "Write")

[Coco]

@toralf, nope I haven't benchmarked it yet. Performance should be similar to Func(function references).
@GeekDude, have you tried StdinWrite := ObjBindMethod(Exec.Stdin, "Write")? Since Exec.StdIn is a TextStream object.

[geek]

Exec.Stdin is a non-existent property on the Exec BoundFunc object

[Coco]

I see, you would have to do ObjBindMethod(Exec.Call().StdIn, "Write") which I assume is not what you really wanted.

[geek]

I could just actually write the function

[HotKeyIt]

I've done a bit testing in AHK_H using GetCurrentProcessId: (for reference: #DllImport, DynaCall)

Code: Select all

Method		  Result		Duration
#DllImport:	0x1F1C		1 (125)
DynaCall:     0x1F1C		1.36
DllCall:      0x1F1C		2.23
Bind:		   0x1F1C		3.39

So Bind is obviously much slower than direct DllCall and should be only used where speed does not matter or Bind is required.

Following the test script used for above results. (requires AutoHotkey_H v2)

Code: Select all

GetCurrentProcessIdBind := Func("DllCall").Bind(GetProcAddress(LoadLibrary("kernel32.dll"),"GetCurrentProcessId"), "Ptr", 0,"Cdecl")
GetCurrentProcessIdDynaCall := DynaCall("GetCurrentProcessId","ui==t")
ProcessSetPriority,High
loop:=1000000
QueryPerformanceCounter(getvar(v1:=0))
Loop loop
    var1:=GetCurrentProcessId() ; #DllImport
QueryPerformanceCounter(getvar(v2:=0))
Loop loop
    var2:=GetCurrentProcessIdDynaCall[] ; DynaCall
QueryPerformanceCounter(getvar(v3:=0))
Loop loop
    var3:=DllCall("GetCurrentProcessId","PTR",0,"Cdecl") ; DllCall
QueryPerformanceCounter(getvar(v4:=0))
Loop loop
    var4:=%GetCurrentProcessIdBind%() ; Bind call
QueryPerformanceCounter(getvar(v5:=0)),QueryPerformanceFrequency(getvar(p:=0))
MsgBox % format("Method`t`tResult`t`tDuration`n#DllImport:`t0x{1:X}`t`t1 ({2})`nDynaCall:`t`t0x{3:X}`t`t{4:.2f}`nDllCall:`t`t0x{5:X}`t`t{6:.2f}`nBind:`t`t0x{7:X}`t`t{8:.2f}`n",var1,Round((v2-v1)/p*1000,0),var2,(v3-v2)/(v2-v1),var3,(v4-v3)/(v2-v1),var4,(v5-v4)/(v2-v1))

EDIT:
Thanks Lexikos, example corrected above to use a pointer to GetCurrentProcessId to have proper comparison.
So the difference is not really big which is great

[lexikos]

You are comparing apples with oranges.

The main reason for the difference in performance is LoadLibrary/GetProcAddress. When you call DllCall directly or use #DllImport, "GetCurrentProcessId" is automatically resolved to a pointer at load-time. If you perform the same optimization manually, the bound function takes only about twice as long as a direct call (it's still < 1µs). A variadic call is partway between the two.

It should also be noted that GetCurrentProcessId is just a placeholder in this case. It does not normally take parameters, and is not Cdecl.

Most functions will take longer than GetCurrentProcessId, so the relative difference between the two methods of calling it will be lesser. For example, when I used the parameter list PointerToIsWindow, "ptr", A_ScriptHwnd, "int", the difference was less than one percent. In that test, a variadic call was actually faster than a normal call; probably due to differences in CPU cache utilization or other magic.

[HotKeyIt]

Many thanks Lexikos, I have updated example above to use a pointer for Bind Call, I totally missed that