Multithreading for AutoIt - finally

[spudw2k]

People should stop trying to make these kind of scripts. They're all the same, and don't work.

It does work, but maybe not how you want to use this. I have run into issues before with adlibs that screw up other parts of my code by altering variables or arrays at the wrong time. This script is very cool, but application in a practical manner may be difficult.

The title says: "Multithreading for AutoIt - finally", so: No,.. it doesn't work.

Maybe false advertising, but it is still functional.

↓

Edited November 7, 2008 by spudw2k

[Kip]

The title says: "Multithreading for AutoIt - finally", so: No,.. it doesn't work.

[jennico]

what ? who says it does not work ?

seems to be a question of common sense:

Func fone()
[s]for $n1 = 1 to 9000
GuiCtrlSetData($lab1,$n)
sleep(500)
next
EndFunc

Func ftwo()

for $n2 = 1 to 9000
GuiCtrlSetData($lab2,$n)
sleep(400)
next

EndFunc[/s]

[b]Wrong ![/b]

Dim $n1,$n2

_AdlibEnable("fone",500,9000)
_AdlibEnable("ftwo",400,9000)

Func fone()
$n1+=1
GuiCtrlSetData($lab1,$n)
EndFunc

Func ftwo()
$n2 += 1
GuiCtrlSetData($lab2,$n)
EndFunc

[b]Right ![/b]

Edited November 7, 2008 by jennico

[Creator]

Dude! This is really great. I certainly have good use for this!

[Malkey]

Here is a similitude of your similitude of multi-tasking, using mrRevoked's example.

The effect of these two scripts look similar.

jennico, please, tell me the errors of my ways,

if you must.

expandcollapse popup

#include <StaticConstants.au3>
#include <WindowsConstants.au3>
#include <GuiListBox.au3>
#include <GuiEdit.au3>

AdlibEnable("Multi", 1)

Global $x, $f = 1,$iCount = 0
Global $List1,$List2,$Progress1,$Slider1,$Button1,$Button2,$Edit1,$Label1,$Label2
$Form1 = GUICreate("Form1", 427, 407, 193, 125)
$List1 = GUICtrlCreateList("", 8, 8, 201, 214)
$List2 = GUICtrlCreateList("", 216, 8, 193, 214)
$Progress1 = GUICtrlCreateProgress(8, 232, 150, 17)
$Slider1 = GUICtrlCreateSlider(8, 256, 150, 45)
$Button1 = GUICtrlCreateButton("Button1", 8, 312, 75, 25, 0)
$Button2 = GUICtrlCreateButton("Button2", 8, 352, 75, 25, 0)
$Edit1 = GUICtrlCreateEdit("", 216, 232, 185, 97)
$Label1 = GUICtrlCreateLabel("Label1", 112, 312, 80, 17)
$Label2 = GUICtrlCreateLabel("Label2", 112, 352, 36, 17)
$Button3 = GUICtrlCreateButton("Pause", 248, 360, 75, 25, 0)
$Button4 = GUICtrlCreateButton("Resume", 328, 360, 75, 25, 0)
GUISetState(@SW_SHOW)

While 1
    $nMsg = GUIGetMsg()
    Switch $nMsg
        Case $GUI_EVENT_CLOSE
            Exit
        Case $Button3 ; Pause
            $f = 0
        Case $Button4
            $f = 1
    EndSwitch
WEnd

Func Multi()    
    If $f = 1 Then  ; Pause         
        _GUICtrlListBox_AddString($List1, @SEC & "=" & Random(0, 9))
        _GUICtrlListBox_AddString($List2, @SEC &"="& Random(9, 0) )
        GUICtrlSetData($Progress1, Random(0, 100, 1))       
        $iCount += 1
        GUICtrlSetData($Label1, "count: " & $iCount)
        
        $x = Mod($x + 1, 4200)  
        If Mod($x, 40) = 0 Then GUICtrlSetData($Slider1, Random(0, 100, 1))
        If Mod($x, 50) = 0 Then ControlMove("", "", $Button1, Random(0, 18), Random(300, 350))
        If Mod($x, 600) = 0 Then ControlMove("", "", $Button2, Random(0, 24), Random(336, 352))
        If Mod($x, 70) = 0 Then _GUICtrlEdit_AppendText($Edit1, "Hellow World, welcome to my world" & @CRLF)        
        If Mod($x, 100) = 0 Then ToolTip("Hello", Random(@DesktopHeight, @DesktopWidth, 1))
        If Mod($x, 200) = 0 Then ConsoleWrite("The cow barks like a fish" & @LF)        
    EndIf
EndFunc   ;==>Multi

[jennico]

thanks, i like this example very much, but it's not suitable for my UDF.

of course, there's an important difference.

in your script you use:

AdlibEnable("Multi", 1)

my script does not do this ! it calculates the greatest common divisor of all thread (instance) frequencies and then enables Adlib on this base. this is the highest possible main frequency of all threads.

the two example scripts share one attitude: they implement instance(s) that afford a frequency of 1 (remember: this is only one millisecond !!!). this is so fast that you barely need to enable an adlib for it. you can just leave it in the main loop. so, the examples are nonsense in a way that they do not need Adlib.

i don't have to say that in a complex program that does more than just wait for a message in its main loop, you will get problems. i quote my description for _AdlibEnable:

Important recommendation:

If possible, please use round (multiples of each others) time frequencies to avoid CPU load . The main calling frequency of multiple adlibs is their greatest common divisor.

E.g. for two adlib instances, better choose 100 and 50 (main=50) for time than 99 and 51 (main=3).

If you choose two primes instead, the main frequency will be 1 ms and your CPU will possibly be locked.

this is the deep core of my implementation. besides that, you can pass arguments, you can pause and resume instances and have many more options using my UDF. it's up to you if you want to use it or not.

And there is another, very important difference to my script: everyone who has experience in scripting knows that every If declaration slows down a program immensely (moreover, you use lots of Mod's in a quasi-real-time loop). maybe you cannot imagine how much a CPU has to work on If and Mod. but you can avoid all that time wasting by using several adlib instances. got it ?

and let me say a very last word towards multithreading, as i pointed out before: real multithreading is not possible no matter what language you use. so please to everyone who wants to go on picking on this theme: leave it and admit your naivity on this instead !

On a single processor, Multithreading generally occurs by time-division multiplexing ("time slicing"). ... This context switching can happen so fast as to give the illusion of simultaneity to an end user. ... Absent that, programs can still implement threading by using timers, signals, or other methods to interrupt their own execution and hence perform a sort of ad hoc time-slicing. These are sometimes called user-space threads.

taken from wikipedia english, "thread".

multithreading is just an illusion, a simulation of reality, a phantom. or, if you define it on a lower level, my UDF definitely enables multithreading. please terminate this discussion now. use your common sense. this issue is eaten.

please observe my nine ball "experiment": you can define 9 adlib threads that only have the (easy) job to move and display the balls on the table in a straight, fixed direction. every thread has its own frequency according to the speed of the ball and the direction vector. the main loop only has the (more complicated) job to calculate the collisions and the resulting speeds and vectors for the balls and pass the new arguments to the nine Adlib threads when the calculated collision time has come. the main loop will not move or display anything. so you have ten independent threads, each of them has its own more or less complicated part of the job. this is commonly called mulitithreading. of course, as i stated in the first post, there are different ways to achieve it. using my _Adlib.au3 is definitely one of the most intelligent.

j.

Edited November 8, 2008 by jennico

[Kip]

my UDF definitely enables multithreading.

It does not, it only runs multiple functions right after each other. It doesn't run them at the same time.

[jennico]

@Kip, if this really makes you cry, why don't you run to your mom and tell her about your problem. personally, i really don't care.

meanwhile i released an improved version in the second posting. generally, i tried to imply a better synchronicity of threads so that a new thread will not interrupt the rythms of the previous threads. two new functions included. now the common usage of one function by two or more threads (passing different params) is allowed.

there is still a big disadvantage that has to be solved. it concerns the lack of realtime implementation so that every individual thread can be executed regularly and not simultaneously in a common "rythm". at this point, i have no idea how to achieve it. if you need realtime, in this regard _Timer_SetTimer is a good alternative.

j.

ah, i have to udate the example script. i'll do that another day.

Edited November 9, 2008 by jennico

[JRowe]

Use the _CoProc UDF, and this for a scheduler. You'll achieve real synchronicity (insofar as your CPU is able to handle multiple scripts.)

What Kip is saying is simply demonstrated. Drag the gui of your example script, and everything pauses. Granted, it's calculated and updated correctly based on timing information, but that doesn't allow for non-timing based calculations... during the drag, nothing is happening. Start two processes... a GUI process and a scheduler process, then have the Scheduler process directly update the GUI. The GUI process should own the window handle. Then, when you drag it, or otherwise interact with it, the updates will still occur. This is "real" multithreading, as kip views it. Or as close to real multithreading as it's possible to get with AutoIt.

The problems people have with CoProc (Scheduling) are the problems solved here. The problems people have here (Synchronicity) are solved by CoProc.

Combine the two (launch arbitrary new processes as threads, or schedule according to priority and assign various priority processes) and we have a winner. Manage the "thread" processes, set their CPU priority, manage memory, and do it with a clean, easy syntax, and you have pure gold.

Edited November 9, 2008 by jrowe

[Kip]

@Kip, if this really makes you cry, why don't you run to your mom and tell her about your problem. personally, i really don't care.

meanwhile i released an improved version in the second posting. generally, i tried to imply a better synchronicity of threads so that a new thread will not interrupt the rythms of the previous threads. two new functions included. now the common usage of one function by two or more threads (passing different params) is allowed.

Who says I'm crying?

I'm just saying this isn't multithreading, so you can stop calling them threads. Use an other word instead: "function", I don't know if you've ever heard of it.

[jennico]

well i will look for that _CoProc UDF. maybe they can be combined. could be interesting.

i made some efforts before on that issue. for example, the IE.au3 blocks your script. when you use the native IE object codes instead without error handling, your script will be terminated on every IE error.

the solution is: the first script writes a second .au3 script with the IE part and starts it. the communication can be enabled by command line params or an inifile. your primary script will not be blocked or affected by errors in the second script anymore. an error handler will care for the messageboxes.

i implemented this in ForumSearch.au3 (but i think nobody has noticed it). so maybe i put together some of my signature scripts.

you could even start a new instance of the primary script with commandline params. this would work without AutoIt installed.

j.

Edited November 9, 2008 by jennico

[martin]

is it so hard to understand ? programming always means simulation. if i post my nine ball game here and i call the post "playing billard with AutoIt", you would still tell me that this is not true, because AutoIt can not play billard ? of course it cannot. it is just a SIMULATION.

even if you run two programs at the same time, this is not really "multitasking", because the CPU can only work on one process at a time, and the others have to wait.

and sorry:

Func fone()
for $n1 = 1 to 9000
GuiCtrlSetData($lab1,$n)
sleep(500)
next
EndFunc

Func ftwo()

for $n2 = 1 to 9000
GuiCtrlSetData($lab2,$n)
sleep(400)
next

EndFunc

who would be so clever to put a sleep in an adlib function, and afterwards he blames my UDF for not working ?

if you make a script sleep you should not expect it to go on working.

j.

Sorry you have been so upset by my post. You seem to have misunderstood my example though. If a udf is called multitasking but what it does is something else then it seems reasonable to me to say so. The sleeps in my example functions were just to represent something which takes some time to execute. I asked the question about what happens if a function called takes longer than the frequecy. You didn't reply to that but if it's a limitation then it should be spelled out in the comments in the udf. Your udf does not give the same result as, for example, running two scripts under windows because with your udf either one function or another is running but not both. Of course the cpu only does one thing at a time but if function1 affects variables as it progresses, then function1 is halted while function2 runs which handles another set of variables, and you are able to switch back to either function and have it continue from where it stopped then you have multitasking as I understand it, but that cannot be done with this udf. So as I said, I simply thought that if it is not multitasking then it shouldn't be called multitasking. But you can call it what you like of course.

Your example of billiard balls was not explained to me suffiuciently to let me understand why it would be better to use your udf than not, so I simply asked why. If you reply to my question about what you said by referring me to what you said then that is not helping me; I am quite happy to be persuaded by you, but at the moment examples like one of lokster's screensavers seem to do the job very well withoutout any special functions or timing.

[Rick]

oh get a room you two, if it solves a problem for someone then the project has been useful, irrespective of what its called.

Edited November 10, 2008 by Rick

[AzKay]

Well, Seeing as everyones arguing about how its not multithreading, and the OP saying it "simulates" multithreading, Well.

expandcollapse popup

#Include <_Adlib.au3>

_AdlibEnable("Test1", 1000)
_AdlibEnable("Test2", 1000)
_AdlibEnable("Test3", 1000)
_AdlibEnable("Test4", 1000)
_AdlibEnable("Test5", 1000)

While 1
    Sleep(100)
WEnd

Func Test1()
    Local $oHTTP
    $oHTTP = ObjCreate("winhttp.winhttprequest.5.1")
    $oHTTP.Open("GET", "http://google.com", False)
    $oHTTP.Send()
    ConsoleWrite("+> Response #1 KGO" & @CRLF)
EndFunc

Func Test2()
    Local $oHTTP
    $oHTTP = ObjCreate("winhttp.winhttprequest.5.1")
    $oHTTP.Open("GET", "http://google.com", False)
    $oHTTP.Send()
    ConsoleWrite("+> Response #2 KGO" & @CRLF)
EndFunc

Func Test3()
    Local $oHTTP
    $oHTTP = ObjCreate("winhttp.winhttprequest.5.1")
    $oHTTP.Open("GET", "http://google.com", False)
    $oHTTP.Send()
    ConsoleWrite("+> Response #3 KGO" & @CRLF)
EndFunc

Func Test4()
    Local $oHTTP
    $oHTTP = ObjCreate("winhttp.winhttprequest.5.1")
    $oHTTP.Open("GET", "http://google.com", False)
    $oHTTP.Send()
    ConsoleWrite("+> Response #4 KGO" & @CRLF)
EndFunc

Func Test5()
    Local $oHTTP
    $oHTTP = ObjCreate("winhttp.winhttprequest.5.1")
    $oHTTP.Open("GET", "http://google.com", False)
    $oHTTP.Send()
    ConsoleWrite("+> Response #5 KGO" & @CRLF)
EndFunc

Does that "simulate" it to you?

No. It still only does the one httprequest at a time, not all of them in seperate "threads".

If it was really "simulating" multithreading, it would still be doing 5 httprequests every second.

Edited November 10, 2008 by AzKay

[Dinosaurr]

Well, just going to say that this will not work at all.

I wasn't using it for the multithreading just for the fact that i could pause a running function and resume and call it on a timer.

But when running i get tons of warnings, even if i ignore them the script will not work. Example:

#include <Adlib.au3>

$ID =  _AdlibEnable("lol")

Func lol()
    WinActivate("Untitled - Notepad")
    Send("HEY I ACTIVATED A WINDOW!")
    _AdlibDisable($ID)
EndFunc

Can someone tell me what im doing wrong or if this script is working or not?

[Xand3r]

@jennico

nobody said that it's not working ...(well ... except Dinosaurr:P)

nobody said that it dosen't "emulate" multithreading

but this is NOT in any sense of the word anything else than multithreading emulation

not necessary speed is the issue... for example you have 1 function with a simple parameter

func _echo($echo)

sleep(random(1,10000,1))

consolewrite($echo)

endfunc

and then you use your udf with it... like:

1. _echo(1)

2. _echo(2)..

no mather what the random returns you will ALWAYS get 1 and then 2(or in the worst case something like 12,12,21,12) and at the same time with real multi threading you could for example get 10000 "1" and just 1 "2"

understand now?

[TurionAltec]

Looks interesting. I'm developing a program which will hopefully make use of these functions.

I read through the first script and came up with a couple suggestions:

-Move TimerDiff($al_timer) outside the For loop for performance reasons

-adding the ability to change the frequency of an existing function

Only to find those were already added!

As far as the arguing about whether it's actual multithreading or not. No it isn't, but that doesn't mean it doesn't have any purpose. If anything it's kind of like a cooperative multi-tasking scheme, where if a process fails to return control to the task scheduler in a timely manner, the entire system can freeze or respond poorly. This is why Windows 3.1 and Mac OS <10 suck at multitasking, and why poorly written driver ISRs & DPCs can cause stuttering in NT based Windows(eg: XP).

This is also an interesting study into how a simplistic multi-tasking scheduler could work, and can give you an appreciation of how well preemptive ones do work.

Edited January 2, 2009 by TurionAltec

[LuI]

Jennico,

at first thanx for that UDF. Looks like it could help me out in one or the other way.

My 1st idea was to get a 'watcher 'thread'' for unexpected or unwanted pop-ups.

Maybe it could be used for 'kind-of 'watches' when debugging code. Some more ideas might come.

You proposed on Nov 9 2008, 01:36 PM:

well I will look for that _CoProc UDF. Maybe they can be combined. could be interesting. I made some efforts before on that issue.

Did you find any time for that?

Greetings from Germany!

--

Uwe

[dmob]

Well I have found this UDF quite useful for my Internet Cafe application.

I use it to:

1. ping to check internet connection

2. check and close any unauthorised instances of IE and Firefox (when a customer uses Explorer to launch them)

3. connect with Firefox to use Firefox UDF

4. check and close Task Manager - I know I can disable it, but I do require it sometimes

5. check and track any downloads

6. display /close traybox which displays total number of downloads, size and cost

and its working perfectly... well except for _AdlibPause, which does not seem to work.

I luv it!

[isolation]

Hi

I've got some errors when I control the syntax

AutoIt3 Syntax Checker v1.54.8 Copyright © Tylo 2007

C:\Documents and Settings\***\Desktop\thread.au3(89,41) : WARNING: $al_func: possibly used before declaration.

If $sync < 0 Or $sync > $al_func[0] Or

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^

C:\Documents and Settings\***\Desktop\thread.au3(93,53) : WARNING: $al_time possibly not declared/created yet

ReDim $al_func[$al_ID + 1], $al_time[$al_ID + 1],

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^

C:\Documents and Settings\***\Desktop\thread.au3(93,78) : WARNING: $al_current possibly not declared/created yet

ReDim $al_func[$al_ID + 1], $al_time[$al_ID + 1], $al_current[$al_ID + 1],

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^

C:\Documents and Settings\***\Desktop\thread.au3(94,33) : WARNING: $al_next possibly not declared/created yet

$al_next[$al_ID + 1],

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^

C:\Documents and Settings\***\Desktop\thread.au3(94,56) : WARNING: $al_param possibly not declared/created yet

$al_next[$al_ID + 1], $al_param[$al_ID + 1],

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^

C:\Documents and Settings\***\Desktop\thread.au3(94,79) : WARNING: $al_count possibly not declared/created yet

$al_next[$al_ID + 1], $al_param[$al_ID + 1], $al_count[$al_ID + 1]

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^

C:\Documents and Settings\***\Desktop\thread.au3(142,25) : WARNING: $al_next possibly not declared/created yet

$al_next[$al_ID] = 0

~~~~~~~~~~~~~~~~~~~~~~~~^

C:\Documents and Settings\***\Desktop\thread.au3(143,26) : WARNING: $al_count possibly not declared/created yet

$al_count[$al_ID] = 0

~~~~~~~~~~~~~~~~~~~~~~~~~^

C:\Documents and Settings\***\Desktop\thread.au3(144,28) : WARNING: $al_current possibly not declared/created yet

$al_current[$al_ID] = 0

~~~~~~~~~~~~~~~~~~~~~~~~~~~^

C:\Documents and Settings\***\Desktop\thread.au3(145,27) : WARNING: $al_param possibly not declared/created yet

$al_param[$al_ID] = ""

~~~~~~~~~~~~~~~~~~~~~~~~~~^

C:\Documents and Settings\***\Desktop\thread.au3(183,36) : WARNING: $al_current possibly not declared/created yet

$al_current[$i] = 0

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^

C:\Documents and Settings\***\Desktop\thread.au3(184,39) : WARNING: $al_count possibly not declared/created yet

$al_count[$i] = $count

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^

C:\Documents and Settings\***\Desktop\thread.au3(224,47) : WARNING: $al_time: possibly used before declaration.

$al_current[$i] = $al_time[$i]

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^

C:\Documents and Settings\***\Desktop\thread.au3(224,47) : WARNING: $al_current possibly not declared/created yet

$al_current[$i] = $al_time[$i]

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^

C:\Documents and Settings\***\Desktop\thread.au3(273,48) : WARNING: $al_current possibly not declared/created yet

$al_current[$al_ID] = $time

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^

C:\Documents and Settings\***\Desktop\thread.au3(276,62) : WARNING: $al_count possibly not declared/created yet

If $count > 0 Then $al_count[$al_ID] = $count

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^

C:\Documents and Settings\***\Desktop\thread.au3(277,58) : WARNING: $al_param possibly not declared/created yet

If $param Then $al_param[$al_ID] = $param

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^

C:\Documents and Settings\***\Desktop\thread.au3(328,53) : WARNING: $al_next: possibly used before declaration.

$al_next[$al_ID] = $al_next[$al_ID2]

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^

C:\Documents and Settings\***\Desktop\thread.au3(364,40) : WARNING: $al_current: possibly used before declaration.

If $al_current[$al_ID] Then

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^

C:\Documents and Settings\***\Desktop\thread.au3(477,33) : WARNING: $al_count: possibly used before declaration.

$ret[4] = $al_count[$al_ID] *

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^

C:\Documents and Settings\***\Desktop\thread.au3(480,32) : WARNING: $al_param: possibly used before declaration.

$ret[5] = $al_param[$al_ID]

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^

C:\Documents and Settings\***\Desktop\thread.au3(558,19) : WARNING: $al_update: possibly used before declaration.

If $al_update Then

~~~~~~~~~~~~~~~~~~^

C:\Documents and Settings\***\Desktop\thread.au3 - 0 error(s), 22 warning(s)

>Exit code: 1 Time: 1.017