Compiler Optimization?

[403forbidden]

Does anyone know if the AutoIt compiler does any type of optimization? Eg:

Before Optimization:

MsgBox(0, "Test", (174/14) * 15.64)

After Optimization:

MsgBox(0, "Test", 194.38)

I know that this would barley make any speed difference at all, but if it were a large script, and not doing the calculations beforehand made it more readable, this could be a big time saver.

[jchd]

I don't believe/hope so.

(174/14) * 15.64 = 194.382857142857 (as displayed by AutoIt, but the internal value is different)

First we are not even close to 194.38

Then what should the following do?

ConsoleWrite(45678/99999 & @LF)

If 45678/99999 = 0.456784567845678 Then MsgBox(0, "Equality test", "Passed!")

Now how big is big, compared to the _utter_ complexity involved?

Common constants elimination can also give good results, as well as loop unrolling and about 1400 optimizations some top-notch C compilers know about. There are also nice trigonometric shortcuts that could save millions of cycles!

Seriously, there are certainly more urgent issues to address.

[403forbidden]

It was just an example, i figured putting all those decimal places in there would be unnecessary. I tried doing something like that, and timing it, and the times were much less when compiled. I was just wondering if it did something like that, or it was just faster because it was compiled.

[omikron48]

Did you try running the script multiple times to get an average process time?

From my experience, the first run of a script from SciTE usually takes a longer time then when I run it a second and third time. Must be because the interpreter hasn't been loaded into memory yet or something similar.

[403forbidden]

Yeah, I used a stupid useless equation that took a long time, and it did go faster compiled than when i right clicked and hit run script. It ran 10 times and was averaged out when the script was running.

[jchd]

Really?

I just tried a 10000 loop of 50 lines consisting of 12 FP operations involving constants each and on average on 100 runs

From SciTe: 0.00012724... ms each operation

Compiled: 0.00012683... ms each operation

If there is an actual difference it's in the vincinity of 0.32%, it will not haunt me! I can't measure anything that precisely without artificial means, that is I will never perceive the difference.

The stock 2-year old PC I use now makes roughly 7.7 Mflops wih AutoIt and you say we should care if the compiler packs constants to save, say, 1000 FP divide?

Where is the big saving you talked about?

We've all lost much more time chatting in this thread than any Intel or GNU C compiler could ever save with all peephole FP optimizations useable in script-like programs for a lifetime!

[403forbidden]

I used a much bigger equation, i´ll try to find it. I just want to find out if it does some kind of optimization.

[evilertoaster]

I can't speak as to exactly what it does now, but in the past it hasn't done any mathematical expression optimization. It's an on-the-fly script parser though, so when you think about it, it would not make sense to go though the trouble of optimizing the expression (the optimizations you talking about are done at compile time, but AutoIt doesn't actually "compile" like that). The lexer does cache the lines though, so if it's in a loop it doesn't have to get "re-tokenized".

Edited May 24, 2010 by evilertoaster

[Richard Robertson]

Normally, you wouldn't really want all those equations in there in the first place. It's much more efficient to optimize simple things like that yourself because you can't always count on an optimizing compiler.

[403forbidden]

Hmm, ok, I must have been mistaken, it doesn't look like there is any difference between compiled and normal script versions. :/ Something must have been running in the background that affected the speed for me. Sorry for the time waster, I guess it is food for thought though.