import time

from multiprocessing import Process

def get_primes7(n):

    """ standard optimized sieve algorithm to get a list of prime numbers
    --- this is the function to compare your functions against! --- """
    if n < 2:  return []
    if n == 2: return [2]
    # do only odd numbers starting at 3
    s = range(3, n+1, 2)
    # n**0.5 simpler than math.sqr(n)
    mroot = n ** 0.5
    half = len(s)
    i = 0
    m = 3
    while m <= mroot:
        if s[i]:
            j = (m*m-3)/2  # int div
            s[j] = 0
            while j < half:
                s[j] = 0
                j += m
        i = i+1
        m = 2*i+3
        res = [2]+[x for x in s if x]
        print "Found", len(res), "prime numbers."
        return res


t1 = time.time()
for t in range(10):
    print "start: "
    Process(target=get_primes7, args=(10000000,)).start()
t2 = time.time()
print 'Execution of all threads is complete, time: %.2f' % (t2-t1)

t1 = time.time()

Getting VERY dirty would mean, guess what, use assembler. A dedicated webserver with your application coded native in assembler. It will make C++ look like its standing still, but is it practical? Is it practical on a Linux or Windows box? No. And Yes. How bi-polar of me. It DEPENDS on what one need accomplish. If I care try distributing hundreds of thousands of incoming connections on a singular connection server and send them off where they need go, yes, assembler is going to perform far better than say a C++ solution.

Same is true of Web Applications. C++ / Java are clear winners in performance. But are they or which is more practical? A native high traffic say auction venue C++ or Java are up to the task. eBay uses C++ and of course, oodles of connection servers, database servers etc. Dedicated machines as does Amazon.

However, eBay’s or Amazons help or forums, or even static forms of pages need not get all performance freaky.

PHP and Apache Web Server are coded in C++. That in itself should (but doesnt) quell the PHP’rs who go, “PHP is the way to go for just about everything”. Its not.

Python, Ruby and other more vertical languages also have a their areas where they do quite well. Point being, planning ahead of time and understanding WHICH is best for a suited application is important. Very important.

In enterprise levels, C++, Java and Microsofts C# and subsequent oodles of CONSISTENCY supported applications are the clear choices.

C++ tends power the biggest complex, high traffic and gobs of DB query based sites on the net. Its the worst to maintain but yields best results. Java is used widely in enterprise applications, LOTS (I mean lots) of Points Of Sale systems accessible via terminals, online etc. In your AT&T store, Verizon, Walmarts etc. All Java. Regional inventory push/pull systems for the likes of Walmart, Target on and on, all Java. Java is fast and yes, tends be more maintainable than C++.

Microsoft as noted, gobs of applications supported consistently. .NET gives a enterprise the ability of desktop, client/server, use of ANY language in support of .NET (VB, C#, many others, even Cobol by other ISV’s) not to mention things such as Office (Word, Excel,etc), Sharepoint, on and on and on.

The handoff in all of this is development time, deployment, scalability, performance etc. We all know this as developers.

But what we as developers often DONT take into account is the future of HARDWARE.

This is actually where Microsoft is smart. Code generated, inefficient as the bloated beast .NET, Windows, SQL Server etc. are… Microsoft is banking on hardware coming to them. That is to say, Hardware performance will give them “the edge” in time. I believe they are right assuming the global economy doesnt collapse.

Eventually SSD’s will rid the world of mechanical drives and this will be an enormous leap across the board as we end up with enormous SSD drives with enormous data and addressing busses.

Enterprise level applications (on web/off web / client/server) will no longer need concern themselves with efficiency. We see this on Desktop PC usage and have for years. Linux is far more efficient than Windows or Windows Server, but, people in their homes choose Windows and pay for it .vs. free Linux. People pay for Mac’s w/ OS/X .vs. Linux.

Many development companies have tried to support Linux in commercial applications for home and business and sales just dont make it. As they say in a community, people who use free things tend to expect often free things. Dunno.

Eventually everything will end up in “the cloud” happily piped in to our home entertainment centers which are TV, Stereo, Computer, Game Machine etc etc all in one. People will pay, be happy (perhaps controlled) and then some.

But the software technology that sits behind that revolution when it happens? More than likely you will see Microsofts name on it.

There comes a time in other words where efficiency and all the compu-jibe becomes immaterial. This is the case with home computing, the Windows or Mac PC’s. If I were to take count of all the PC’s in say southern California and what OS they run the numbers would outpace every home linux installation and mac install in the world, perhaps more than both combined. Sad perhaps, but surely true.

In business and webs this is not the case. Not yet. But as the Net connectivity, hardware technologies continue to evolve naturally the same thing will occur. Businesses will go, “We want what works and gives us the most options to grow and is the LEAST complex for US to use daily”. That will be IMHO Microsoft who has continually now for years and years on end been advancing software technologies albeit not caring about efficiency as a “practical goal” as they consider efficiency of the shall we say “server based” technologies to become extinct as they have in home computing and even console gaming systems coding etc. Thus expending oodles of resources to make everything Microsoft efficient is simply wasting ones time as eventually the hardware technologies will make it moot as it has in home computing. Further, the cost of this hardware ALWAYS goes downward in time.

Hosting companies dont like talking about it. You dont see for example hosts of hosts offering 10 year old dedicated servers at costs of shared hosting packages. No No. Yet, those machines would do more for ones growing and slowing PHP based web(s) than any nifty new shared box they sit upon.

I recently deployed a site for some folks (PHP CMS deal) to a decent VPS host. Site runs fine. Sits on a machine thats a quad core zip zip machine. Know what? The AMD 1700 (yes you read that right) based machine I have LAMP on (and not loaded over a LAN but the net) runs RINGS around it and that 1700 has considerably more running on it than the slimmed down VPS. Sure… there are all forms of differences at play, but the results are quite dramatic. I’d benchmark it but again, doesnt matter. What matters is they got their site and are happy.

Ok, one last gripe? About some of the “biggie names” in open source. The Magento’s and Joomla’s etc.

Here are these weenies who develop these PHP based applications that are essentially not any better than similar applications that abound, in fact worse than many. But, they have a community of developers which make the software do lots of nifty things. Modules, plugins etc. Then THEY capitalize be it by making editions for “those who need pay for things” or jetsetting around the globe selling everyone on how wonderful they and their works are charging for seminars!

I call it “Open-a__” developers.

Perhaps brilliant in using others to become millionaires themselves and famous? LOL.

But ya know, I never see them or hear of em’ banging out say open source C++ frameworks, Java ones, those that are considered by the WORLD as PERFORMANCE based technologies etc. Uh Uh. IMHO and I know PHP its a mess, just a mess.

For example, look at Liferay (not sure if its still free these days) and Joomla or Drupal. Install em’. Use some nice profiling software and then pick your jaw up off the ground when you see the performance curves.

But see… again, doesnt seem to matter. Whats actually best, most efficient this/that becomes moot in the face of the masses.

Here are the benchmark on my system:
* nodejs (0.6.12): 5,724 s
* Ruby (1.9.3): 23,085 s
* Python (2.7.3): 31,294 s

If we linearly adjust the above times with a coefficient of “0,88″ so that they match the already done benchmarks in the blog post, we get the following numbers:
* nodejs (0.6.12): 5,037 s
* Ruby (1.9.3): 20,315 s
* Python (2.7.3): 27,539 s

This means that standard Python is almost 35% slower than Ruby. Interesting.

def get_primes7(n)
	if n < 2
		return []
	end
	
	if n == 2
		return [2]
	end
	
	#s = Range.new(3, n, 2)???
	s = []
	i = 3
	while i < n + 1
		s.push(i)
		i += 2
	end
	
	mroot = Math.sqrt(n)

	half = s.length
	i = 0
	m = 3
	while m <= mroot
		if s[i] != 0
			j = (m * m - 3) / 2
			s[j] = 0
			while j < half
				s[j] = 0
				j += m
			end
		end
		i = i + 1
		m = 2 * i + 3
	end
	
	res = [2]
	for v in s
		if v != 0
			res.push(v);
		end
	end
#	x = 0
#	while x < s.length
#		if s[x] != 0
#			res.push(s[x])
#		end
#		x = x + 1
#	end
	return res
end


res = [];
for i in 1..10
	res = get_primes7 10000000
	puts "Found #{res.length} prime numbers.\n"
end

(begin my questions)

Thanks for the comment and benchmark results. Something’s strange about the numbers though — they show almost nothing for “user” and “sys” times… I also see “gcc.exe” — did you run the tests on Windows?

Not knowing the real “user” and “sys” values leaves a small backdoor for the JS compiler to use multi-threading which is “unfair competition” here since all tests are strictly single-threaded. Furthermore, you should also provide the source code.

(end my questions)

Here is his very thorough and satisfying reply:

(begin “akesterson” reply)

Thanks for getting back to me!

Yes, I performed the tests on windows using mingw, as pointed out in the first paragraph of the comment (sorry if that wasn’t clear, I really didn’t belabor the point at all).

The user times on windows are confusing, the “real” times in mingw are the only ones that can really be trusted, or which should be considered.

As far as multithreading, SpiderMonkey is absolutely single threaded (see http://blog.mozilla.org/luke/2012/01/24/jsruntime-is-now-officially-single-threaded/ for a brief report of same; I was using the stock js.exe command line, which does not support the W3 web workers stuff).

Regarding the source, I did not change the source at all, except to change the javascript console.log to a print statement. here is the diff:

akesterson@andrew-laptop ~/source/unorganized
$ wget -O primes-js.txt.orig http://www.famzah.net/download/langs-performance/primes-js.txt
--2012-10-22 00:19:12--  http://www.famzah.net/download/langs-performance/primes-js.txt
Resolving http://www.famzah.net (www.famzah.net)... 64.14.78.45
Connecting to http://www.famzah.net (www.famzah.net)|64.14.78.45|:80... connected.
HTTP request sent, awaiting response... d200 OK
Length: 656 [text/plain]
Saving to: `primes-js.txt.orig'

     0K                                                       100%  476K=0.001s

2012-10-22 00:19:13 (476 KB/s) - `primes-js.txt.orig' saved [656/656]

akesterson@andrew-laptop ~/source/unorganized
$ diff primes-js.txt.orig primes-js.txt
39c39
<       console.log("Found " + res.length + " prime numbers.");
---
>       print("Found " + res.length + " prime numbers."); 

I hope these explanations are sufficient to clear up any confusion regarding the sanity of my test results. Thanks again.

(end “akesterson” reply)

——————–

akesterson@andrew-laptop ~/source
$ bash bench.sh
== C++ (optimized with -O2) ==

real 0m2.141s
user 0m0.015s
sys 0m0.015s

real 0m2.163s
user 0m0.047s
sys 0m0.000s

g++.exe (GCC) 4.5.2

== C++ (not optimized) ==

real 0m5.032s
user 0m0.000s
sys 0m0.000s

real 0m5.390s
user 0m0.031s
sys 0m0.000s

g++.exe (GCC) 4.5.2

== Python 2.7 ==

real 0m41.942s
user 0m0.031s
sys 0m0.000s

real 0m42.127s
user 0m0.015s
sys 0m0.031s

Python 2.7.2

== JavaScript (SpiderMonkey) ==

real 0m5.022s
user 0m0.015s
sys 0m0.031s

real 0m4.759s
user 0m0.000s
sys 0m0.015s

JavaScript-C 1.8.5+ 2011-04-16

—————

While this initially suggests that SpiderMonkey is only ~20% slower than V8/Node.js, this can be misleading. My C++ benchmarks are ~30% slower than yours with the same code and compiler (g++ 4.5.2), so it is probably safe to say that the performance of SpiderMonkey is similarly out of context. Adjusting the SpiderMonkey performance by -30%, we get an (average) real runtime of 6.357s, or ~40% slower than Node.js running under V8.

… But still faster than the other “made for serious work” scripting languages, by an astonishingly large margin.

package 
{
	import flash.display.Sprite;
	import flash.events.Event;
	import flash.text.TextField;
	import flash.utils.getTimer;
	
	/**
	 * ...
	 * @author Raphaël Benzazon
	 */
	public class Main extends Sprite 
	{
		
		public function Main():void 
		{
			if (stage) init();
			else addEventListener(Event.ADDED_TO_STAGE, init);
		}
		
		private function init(e:Event = null):void 
		{
			removeEventListener(Event.ADDED_TO_STAGE, init);
			// entry point
			var timeBefore:int = getTimer();
			for (var i:int = 0; i < 10; i++) {
				var res:Vector = get_primes7(10000000);				
			}			
			
			trace("Found " + res.length + " prime numbers.");
				
			var timeAfter:int = getTimer()-timeBefore;
			var text:TextField = new TextField();
			addChild(text);
			text.text = String(timeAfter);
		}
		private function get_primes7(n:int):Vector {
			var res:Vector;
			var lnt:int;
			if (n < 2) { return new Vector(); }
			if (n == 2) {
				res = new Vector();
				res.push(2)
				return res;
			}
			var j:int;
			var s:Vector = new Vector();
			lnt = n + 1;
			for (var i:int = 3; i < lnt; i += 2) {
				s.push(i);
			}

			var mroot:int = int(Math.sqrt(n));
			var half:int = s.length;
			i = 0;
			var m:int = 3;

			while (m <= mroot) {
				if (s[i]) {
					j = (m*m-3)/2;   // int div
					s[j] = 0;
					while (j < half) {
						s[j] = 0;
						j += m;
					}
				}
				i++;
				m = 2*i + 3;
			}

			res = new Vector();
			res.push(2);
			lnt = s.length;
			for (var x:int = 0; x < lnt; x++) {
				if (s[x]) {
					res.push(s[x]);
				}
			}
			return res;
		}


		
	}
	
}