/var/log/mind - Latest Comments in Performance Comparison – C++ / Java / Python / Ruby/ Jython / JRuby / Groovy

Re: Performance Comparison – C++ / Java / Python / Ruby/ Jython / JRuby / Groovy

Vivek Khurana — Sat, 04 Jul 2009 16:08:26 -0000

Wont comment on any other language but your python code is definitely not upto the mark. If you say about comapring apples with apples... at least use all the benefits that a language offers. When you are using pointers in C++ to gain speed why are you are not using the built in constructs of python which will give speed advantage ?
Do you feel C++ would have given the same reults had you used array instead of pointers... ?

Re: Performance Comparison – C++ / Java / Python / Ruby/ Jython / JRuby / Groovy

Mark Essel — Fri, 26 Jun 2009 13:33:52 -0000

Hello Dhananjay.
I have a rather generic question concerning a specific implementation. I'm in the process of designing and coding up a social media/comment powered advertising engine. My background is C++, but I've been using PHP so far.

I'm curious what type of web based coding language you would suggest as the fastest for grabbing data from various locations and passing it back and forth.

Thanks for your time sir,
Mark Essel

Re: Performance Comparison – C++ / Java / Python / Ruby/ Jython / JRuby / Groovy

Ebrahim — Fri, 27 Mar 2009 19:13:00 -0000

Consider rebenchmarking, this time with profile-guided optimization for C++.

Re: Performance Comparison – C++ / Java / Python / Ruby/ Jython / JRuby / Groovy

Pete Kirkham — Mon, 23 Mar 2009 11:33:55 -0000

> it is probably close to the kind of code many programmers write (and maintain) on a day to day basis
Yes, but most of what many programmers write on a day-to-day basis is not remotely performance critical.

So it's nice that code that's inefficient is still tolerably fast, as it means your unit tests finish quickly, but what often matters to application performance is the degree to which you can tune the performance critical components of the system.

So to understand whether or not an application in the language can be made to perform well, you need to test code that's as fast as the language lets you tune it. This can make a big difference - for example, languages with constant vs mutable vs copy-on-write strings which are as fast as each other in benchmarks get big differences in applications.

Re: Performance Comparison – C++ / Java / Python / Ruby/ Jython / JRuby / Groovy

Andrey — Fri, 27 Feb 2009 10:01:32 -0000

I did another micro test that had simple GUI and discovered that

- memory consumption differs dramatically and can exclude Java from the list of options

- apparently sane code may run so slow that normal performance is irrelevant and the probability to hit a trap is what matters. If you want something that just works, C++/Pascal/C# are safe, Java is less safe possibly because the default VM does not JIT compile some code, and PHP/Ruby/Python may really surprise you.

Re: Performance Comparison – C++ / Java / Python / Ruby/ Jython / JRuby / Groovy

HamsterofDeath — Fri, 20 Feb 2009 17:31:46 -0000

this code:
public Person kill(int nth)
{
Person current = first;
while (nth-->=0)
{
current = current.getNext();
}
current.shout();
first = current;
return current;
}

reduces the time per iteration by 50%

i can optimize it further, but that would be a punch in the face of readability

Re: Performance Comparison – C++ / Java / Python / Ruby/ Jython / JRuby / Groovy

anonymous — Thu, 19 Feb 2009 22:52:22 -0000

for more fun, i copied the com.dnene.josephus implementation at the top, and ran it .. on my system it timed in at 1.5 microseconds, compared to 0,75 microseconds for mine. so my rather obfuscated implementation is twice as fast for JDK 1.5.

Re: Performance Comparison – C++ / Java / Python / Ruby/ Jython / JRuby / Groovy

anonymous — Thu, 19 Feb 2009 21:18:50 -0000

ok, i give up, this comment thing keeps mangling the code

Re: Performance Comparison – C++ / Java / Python / Ruby/ Jython / JRuby / Groovy

anonymous — Thu, 19 Feb 2009 21:17:40 -0000

ok, mangled again, this time i typed it instead of copy/pasted:
static int answer(int n, int k, int[] nextAlive) {
Arrays.fill(nextAlive, 1);
int die = 0;
int temp = n-1;
for(int ctr = 0; ctr < n - 1; ++ ctr) {
for(int skipAlive = 0; skipAlive = n) {
die -= n;
}
}
nextAlive[temp] += nextAlive[die];
die += nextAlive[die];
if (die >= n) {
die -= n;
}
}
return die + 1;
}

Re: Performance Comparison – C++ / Java / Python / Ruby/ Jython / JRuby / Groovy

anonymous — Thu, 19 Feb 2009 21:12:31 -0000

mangled again ... don'e know why:
static int answer(int n, int k, int[] nextAlive) {
Arrays.fill(nextAlive, 1);
int die = 0;
int temp = n - 1;
for (int ctr = 0; ctr < n - 1; ++ctr) {
for (int skipAlive = 0; skipAlive = n) {
die -= n;
}
}
nextAlive[temp] += nextAlive[die];
die += nextAlive[die];
if (die >= n) {
die -= n;
}
}
return die + 1;
}

Re: Performance Comparison – C++ / Java / Python / Ruby/ Jython / JRuby / Groovy

anonymous — Thu, 19 Feb 2009 21:09:42 -0000

somehow the "answer" function above got mangled, here it is:

Re: Performance Comparison – C++ / Java / Python / Ruby/ Jython / JRuby / Groovy

anonymous — Thu, 19 Feb 2009 21:07:00 -0000

actually i see it wasn't really any faster ... your times were microseconds, i was thinking milliseconds .. gosh, how embarassing

however, this version executes in 750 microseconds on a dual core 2.6 ghz intel, so presumably it's a bit faster ... a fair comparison to your time would be 750 * 2.6/2.1 = 928 microseconds. ALSO, i'm using jdk 1.5, not 1.6, how big a difference that makes i don' t know.

i would have thought the difference in speed would be greater, considering i'm using nothing but int's, no object references. shows how efficient javas heap management and object reference implementation is?

static int answer(int n, int k, int[] nextAlive) {
Arrays.fill(nextAlive, 1);
int die = 0;
int temp = n - 1;
for (int ctr = 0; ctr < n - 1; ++ctr) {
for (int skipAlive = 0; skipAlive = n) {
die -= n;
}
}
nextAlive[temp] += nextAlive[die];
die += nextAlive[die];
if (die >= n) {
die -= n;
}
}
return die + 1;
}
public static void main(String[] args) {
int ITER = 100000;
long start = System.nanoTime();
int n = 40;
int[] nextAlive = new int[n];
for (int i = 0 ; i < ITER ; i++) {
answer(n, 3, nextAlive);
}
long end = System.nanoTime();
System.out.println("Time per iteration = " + ((end - start) / (ITER )) + " nanoseconds.");
}
}

Re: Performance Comparison – C++ / Java / Python / Ruby/ Jython / JRuby / Groovy

anonymous — Thu, 19 Feb 2009 20:45:45 -0000

too much fun, i couldn't help myself ... OK, previous was almost right, but it wasn't handling the "skip 0" or depending how you enumerate, call that the "skip 1" kill case. I fixed that, so answer(10,1) is the kill w/o skipping case. I compared my answer with they guy who looked at Mathematica results, above, and I get the same.

** MY EXECUTION TIME ?? ** 1751 NANOSECONDS !!!

anonymous does ChurchLady superior dance, ala Dana Carvey =)

(of course C++ would probably be 2 to 4 times faster, I'm betting)

complete code list (27 lines !!! ... bit obfuscated, i admit =) )
import java.util.Arrays;
public class Main {
static int answer(int n, int k) {
int[] nextAlive = new int[n];
Arrays.fill(nextAlive, 1);
int die = 0;
int temp = n - 1;
for (int ctr = 0; ctr < n - 1; ++ctr) {
for (int skipAlive = 0; skipAlive < k - 1; ++skipAlive) {
temp = die;
die += nextAlive[die % n];
}
nextAlive[temp % n] += nextAlive[die % n];
die += nextAlive[die % n];
}
return (die % n) + 1;
}
public static void main(String[] args) {
int ITER = 100000;
long start = System.nanoTime();
for (int i = 0 ; i < ITER ; i++) {
answer(40, 3);
}
long end = System.nanoTime();
System.out.println("Time per iteration = " + ((end - start) / (ITER )) + " nanoseconds.");
}
}

Re: Performance Comparison – C++ / Java / Python / Ruby/ Jython / JRuby / Groovy

anonymous — Thu, 19 Feb 2009 10:45:37 -0000

comment - what im doing above is just maintaining a singly linked ciruclar list using modulo n arithmetic, where "nextAlive" gives the "pointer" to the next item in the list, provided you add that value to your current index location -- modulo n. when one of 'em get killed, i modify the "next item" pointer for the previous "alive" that got skipped (kept in temp), and reposition the current index to be the next alive, for the next round of skipping (die += nextAlive[die%n]).

Re: Performance Comparison – C++ / Java / Python / Ruby/ Jython / JRuby / Groovy

anonymous — Thu, 19 Feb 2009 10:37:06 -0000

actually that version probably has O(n^2) performance so wouldn't do well for large n. one more try

int answer(int n, int k) {
int[] nextAlive = new int[n];
Arrays.fill(nextAlive, 1);
int die = 0;
for(int ctr = 0; ctr < n-1; ++ ctr) {
int temp = 0;
for(int skipAlive = 0; skipAlive < k; ++ skipAlive) {
temp = die;
die += nextAlive[ die % n ];
}
nextAlive[ temp % n ] += nextAlive[ die % n ];
die += nextAlive[ die % n ];
}
return (die % n) + 1;
}

Re: Performance Comparison – C++ / Java / Python / Ruby/ Jython / JRuby / Groovy

anonymous — Thu, 19 Feb 2009 10:14:41 -0000

i now also think the \++die\ should be moved after the if (!hesDead...) { test in the while(skip<k) loop

Re: Performance Comparison – C++ / Java / Python / Ruby/ Jython / JRuby / Groovy

anonymous — Thu, 19 Feb 2009 10:04:03 -0000

last line should have been
"return (die % n) + 1;" since you want to number the people from 1 .. n, not 0 ... n-1.

otherwise still looks ok to me

Re: Performance Comparison – C++ / Java / Python / Ruby/ Jython / JRuby / Groovy

anonymous — Thu, 19 Feb 2009 10:00:24 -0000

this is an absurdly simple problem, i don't know how you managed to come up with such code. i'm predicting this will have a fast run time.

// looks ok to me at the moment ... after i hit submit
// i'll probably see a mistake ! arrgh
int answer(int n, int k) {
boolean[] hesDeadJim = new boolean[n];
Arrays.fill(hesDeadJim, false);
int die = 0;
for(int ctr = 0; ctr < n-1; ++ ctr) {
int skip = 0;
while(skip < k) {
++ die;
if (! hesDeadJim[die % n]) {
++ skip;
}
}
hesDeadJim[die % n] = true;
}
return die % n;
}

Re: Performance Comparison – C++ / Java / Python / Ruby/ Jython / JRuby / Groovy

Ben Racine — Thu, 29 Jan 2009 00:00:59 -0000

This would be a great place to post a Cython comparison as well.

Re: Performance Comparison – C++ / Java / Python / Ruby/ Jython / JRuby / Groovy

paulj — Thu, 21 Aug 2008 18:49:02 -0000

I like this 'deque' version since it adds a clarifying level of abstraction to the original problem formulation - that we are repeatedly selecting every nth item from a ring buffer.

It could be cast in an object form with the same external interface as the original. In some sense that makes it the same object implementation, since it shouldn't matter whether we implement the linked list pointers in Python or use the ones in the compiled deque code.

from collections import deque
class Person(object):
..__slots__ = 'count'
..def __init__(self, count):
....self.count = count
..def shout(self, cnt, nth): return cnt # dummy method
class Chain(deque):
..def __init__(self, size):
....alist = [Person(i) for i in xrange(size)]
....deque.__init__(self, alist)
..def kill(self, nth):
....n1 = -(nth-1)
....while len(self):
......self.rotate(n1)
......last=self.popleft()
....return last

Re: Performance Comparison – C++ / Java / Python / Ruby/ Jython / JRuby / Groovy

Alberto Bignotti — Mon, 18 Aug 2008 17:47:07 -0000

java version: 26922 milliseconds
my c++ version: 21422 milliseconds

sorry, previously I wrote microseconds intead of milliseconds

Re: Performance Comparison – C++ / Java / Python / Ruby/ Jython / JRuby / Groovy

Alberto Bignotti — Mon, 18 Aug 2008 13:14:59 -0000

the correct link is

www.bigno.it/speed/cppspeed...

sorry for the mistake

Re: Performance Comparison – C++ / Java / Python / Ruby/ Jython / JRuby / Groovy

Alberto Bignotti — Mon, 18 Aug 2008 13:05:45 -0000

I modified c++ version adding 21 lines of code.

On my machine, making a loop of 10000000 iterations:
java version: 26922 milliseconds
my c++ version: 21422 microseconds

see details on whttp://www.bigno.it/speed/...

Re: Performance Comparison – C++ / Java / Python / Ruby/ Jython / JRuby / Groovy

Francis Carr — Wed, 13 Aug 2008 12:22:20 -0000

For many software problems, it helps a lot to know the +libraries+, not just the +language+.

import time
from collections import deque
ITER = 100000
START_LEN = 40
KILL_EVERY = 3
start = time.time()
initial_chain = range(1, 1+START_LEN)
for i in xrange(ITER):
chain = deque(initial_chain)
while len(chain) > 1:
chain.rotate(-(KILL_EVERY-1))
chain.popleft()
end = time.time()
print 'Time per iteration = %s microseconds ' % ((end - start) / float(ITER) * 1e6)

Re: Performance Comparison – C++ / Java / Python / Ruby/ Jython / JRuby / Groovy

bruno — Thu, 07 Aug 2008 06:18:18 -0000

As usual with this kind of benchmarks, part of the differences comes from non-idiomatic code. wrt/ the Python version, it's not pythonic code, it's Java code written in Python. I don't have time for this right now, but I'll try and propose a more pythonic solution.