View source for Execution Speed (compare to C++)

From wiki.visual-prolog.com

You do not have permission to edit this page, for the following reasons:

The action you have requested is limited to users in the group: emailconfirmed.
You must confirm your email address before editing pages. Please set and validate your email address through your user preferences.

You can view and copy the source of this page.

It is not completely trivial to compare the execution speed of different programming languages, because some problems may suit one language better than another.  Nevertheless such comparison is interesting.

This article describes a little simple comparison of Visual Prolog and Microsoft C++.  The comparison does not claim any scientific accuracy; it is just supposed to give an indication.

The classical Towers of Hanoi problem is used for the test, the actual writing of the result to the standard output stream is skipped, because otherwise the test take nearly the same time because all the time is spend in drawing and scrolling the console window.

The test is carried out with Visual Prolog 7.2 and Microsoft C++ (Visual Studio 2005).

=== Visual Prolog run ===

<vip>class main
predicates
    run : core::runnable.
end class main

implement main

clauses
    run():-
        console::init(),
        profileTime::init(),
        profileTime::start_pr("hanoi"),
        hanoi(25, "a", "b", "c"),
        profileTime::stop_pr("hanoi"),
        profileTime::printAndReset(stdio::getOutputStream()).

class predicates
    hanoi : (positive N, string SourcePole, string AuxPole, string TargetPole).
clauses
    hanoi(0, _SourcePole, _AuxPole, _TargetPole) :-
        !.
    hanoi(N, SourcePole, AuxPole, TargetPole) :-
        hanoi(N-1, SourcePole, TargetPole, AuxPole),
        /* stdio::writef("Move from % to %\n", SourePole, TargetPole),*/
        hanoi(N-1, AuxPole, SourcePole, TargetPole).

end implement main

goal
    mainExe::run(main::run).</vip>

The result was this 

<pre>Steps = 134217727

|  Predicate        | Calls |   AvgNet   |   Netto    |   Average  |    Total  |
+-------------------+-------+------------+------------+------------+-----------+
| hanoi             |     1 |  5.6989841 |   5.698984 |   5.698984 |   5.698984|
+-------------------+-------+------------+------------+------------+-----------+</pre>

=== C++ run ===

<source lang="cpp">#include "stdafx.h"

typedef wchar_t* string;

static int steps = 0;

void hanoi(int N, string A, string B, string C)
{
    if (N > 0)
    {
        hanoi(N-1, A, C, B);
        // move a disk from A to C
        steps++;
        hanoi(N-1, B, C, A);
    }
}

int _tmain(int argc, _TCHAR* argv[])
{
    clock_t start = clock();
    hanoi(27, L"left", L"middle", L"right");
    clock_t finish = clock();
    wprintf(L"Steps = %d\n", steps);
    double elapsed_time = (finish - start) / 1000.0;
    printf( "\nProgram takes %.2f seconds.\n", elapsed_time );
    return 0;
}</source>

In '''Debug''' mode this program produced: 

<pre>Steps = 134217727

Program takes 38.45 seconds.</pre>

In '''Release''' mode it produced:

<pre>Steps = 134217727

Program takes 1.95 seconds.</pre>

=== Summary ===

{| {{prettytable}}
! Test
! Time
! Relative
|-
| C++ Debug
| 38.45 sec
| 675%
|-
| Visual Prolog
| 5.70 sec
| 100%
|-
| C++ Release
| 1.95 sec
| 34%
|}

So the Release version of the C++ program is around 3 times faster than the Visual Prolog program which is 6.75 times faster than the Debug version of the C++ program.

So this Visual Prolog program though significantly slower than the optimized C++ program is however closer to the optimized C++ program than to the un-optimized C++ program.

[[Category:Basic Information]]

Template used on this page:

Template:Prettytable (view source)

Return to Execution Speed (compare to C++).

Retrieved from "https://wiki.visual-prolog.com/index.php?title=Execution_Speed_(compare_to_C%2B%2B)"

View source for Execution Speed (compare to C++)

Search

Navigation

external links

collaboration

Personal tools

Views