OpenEuphoria

2. Re: Interesting benchmark results - Euphoria vs. Euphoria

• Posted by DerekParnell (admin) May 15, 2014
• 2737 views

The primary culprit has been the introduction of checking of GLOBAL variables and "better" dereferencing of temporary results.

As a general rules-of-thumb ...

• Never use variables that are declared outside of a routine.
• Explicitly use your own temporary result variable. This is not a big winner but may help sometimes, especially inside deeply nested loops.
• Avoid combinations of 'and' and 'or' in a loop exit condition. This is one area that Euphoria needs some optimising work done.
• Use the X op= Y operators instead of X = X op Y where possible

You can use the dis utility to view the generated Intermediate Language code generated by Euphoria's parser. This is the actual code that will be executed.

Here is your code with these suggestions included. On my system I got it down from 51 seconds to 21 seconds.

without type_check  
 
procedure main() -- Avoiding variables declared outside of routines. 
integer left_edge, right_edge, top_edge, bottom_edge, max_iter, x_step,  
    y_step, y0, x0, x, y, i, x_x, y_y, temp, the_char, accum, count  
 
atom t1    -- Explicit temporary used 
integer t2 -- Explicit temporary used 
   
atom t  
  
t = time()  
  
accum = 0  
count = 0  
while count < 1545 do  
    left_edge   = -420  
    right_edge  =  300  
    top_edge    =  300  
    bottom_edge = -300  
    x_step      =  7  
    y_step      =  15  
  
    max_iter    =  200  
  
    y0 = top_edge  
    while 1 do 
        if y0 <= bottom_edge then exit end if 
        x0 = left_edge  
        while 1 do 
            if x0 >= right_edge then exit end if  
            y = 0  
            x = 0  
            the_char = 32  
            x_x = 0  
            y_y = 0  
            i = 0 
            t1 = 0 
            while 1 do 
                if i >= max_iter then exit end if 
                if t1 > 800 then exit end if  
            	t1 = x * x 
                x_x = floor(t1 / 200)  
                t1 = y * y 
                y_y = floor(t1 / 200)  
                t1 = x_x + y_y 
                if t1 > 800 then  
                    the_char = 48 + i  
                    if i > 9 then  
                        the_char = 64  
                    end if  
                else  
                    temp = x_x - y_y 
                    temp = temp + x0  
                    t2 = x * y 
                    --if (x < 0 and y > 0) or (x > 0 and y < 0) then  
                    if t2 < 0 then 
                        t2 *= -1 
                        t1 = floor(t2 / 100) 
                        t1 *= -1 
                        y = t1 + y0 
                        --y = (-1 * floor((-1 * x * y) / 100)) + y0  
                    else  
                    	--t1 = x * y 
                    	t1 = floor(t2 / 100) 
                    	y = t1 + y0 
                        --y = floor(x * y / 100) + y0  
                    end if  
                    x = temp  
                end if  
  
                i = i + 1 
                t1 = x_x + y_y   
            end while  
            accum += the_char  
  
            x0 += x_step  
        end while  
  
        y0 -= y_step  
    end while  
  
    if remainder(count, 300) = 0 then  
        printf(1, "%d\n", accum)  
    end if  
  
    count += 1  
end while  
  
printf(1, "%d\n\nCompleted in %d seconds\n\n", {accum, time() - t})  
end procedure 
main() 

4. Re: Interesting benchmark results - Euphoria vs. Euphoria

• Posted by ed_davis May 21, 2014
• 2605 views

Hello Pete!

It has been a long time since PEU! I still have peu08 from August 1998.

Your new interpreter looks really promising. But (sorry about that), I had a problem with while loops. I could not get bench.ex or primes.ex to run - they both crashed. I traced it down to the while loop. For instance, this appears to work:

integer pc, k, p, lim, n 
 
lim = 5000000 
n = 1 
pc = 0 
 
--while n < lim do 
    k = 3 
    p = 1 
    n = n + 2 
--    while k * k < n and p do 
        p = floor(n / k) * k != n 
        k = k + 2 
--    end while 
    if p then 
        pc = pc + 1 
    end if 
--end while 
 
? pc 

But this crashes:

integer i 
i = 0 
while i < 10 do 
    i = i + 1 
    ? i 
end while 

The above generated:

00000101	0: load   r1, 0 
000A0201	1: load   r2, 10 
0301020A	2: jle    r2, r1, 3 (6) 
01010105	3: addu8  r1, r1, 1 
00000114	4: qprint r1 
FFFB000D	5: jmp    -5 (1) 
00000000	6: end 

I'm running Windows 7. I'm using: gcc (tdm64-2) 4.8.1

I compiled interpret.c with:

-m32 -O3 -march=native -mtune=native

I also tried it with:

-m64 -O3 -march=native -mtune=native

I also tried it without any options, save forcing 32-bit/64-bit compilation:

-m32

and

-m64

Let me know if there is something you'd like me try.

6. Re: Interesting benchmark results - Euphoria vs. Euphoria

• Posted by GreenEuphorian May 22, 2014
• 2508 views

64 seconds! Euphoria seems to be losing the edge of speed. Is there any option in the v4.1 interpreter that could allow for better speed? Anything that could bring back the old speed, at the cost of having a limited feature set?

8. Re: Interesting benchmark results - Euphoria vs. Euphoria

• Posted by ed_davis May 22, 2014
• 2720 views

Works much better now

Compiled for 32-bit under 64-bit Windows 7: 17.96 seconds

Compiled for 64-bit under 64-bit Windows 7: 14.26

And here is how it compares to some other language processors.

10. Re: Interesting benchmark results - Euphoria vs. Euphoria

• Posted by ed_davis May 22, 2014
• 2521 views

Which benchmark program did you run, my original, or Derek's modified version?

I also get much better times when I run Derek's modified version - not quite as good/consistent as yours though. But I consider Derek's version cheating

12. Re: Interesting benchmark results - Euphoria vs. Euphoria

• Posted by ed_davis May 22, 2014
• 2503 views

Yes, but I could do the same for many of the languages tested. Several of the simpler processors would greatly benefit from less complicated expressions. The goal was to have the same (as much as possible) code for each processor, without any programmer optimizations.

14. Re: Interesting benchmark results - Euphoria vs. Euphoria

• Posted by mattlewis (admin) May 22, 2014
• 2494 views

My times were with your code. Honestly, just putting it all in a main() function was the biggest difference. I did do some similar things as Derek's code in playing with it, and 4.0.5 and 3.1 were about the same (12-15s) and the 64 bit version of 4.1 was a little bit slower (~17s).

I think wrapping it in a main() function isn't much cheating, since many languages make you do that anyways. The top level variable checking is there due to the ability to forward reference and jump around in code. The interpreter doesn't / can't do the level of checking that the translator does, and in this case, the feature vastly outweighs the performance degradation.

The temp variable stuff is definitely something we need to work on, but again, it's a huge feature win, in my book.

Matt