A Silicon Valley startup claims to have cracked one of most elusive goals of the software industry: a near-universal emulator that allows software developed for one platform to run on any other, with almost no performance hit.
A Step Toward Universal Computing
About The Author
Eugenia Loli
Ex-programmer, ex-editor in chief at OSNews.com, now a visual artist/filmmaker.
Follow me on Twitter @EugeniaLoli
I’ve been reading about this since /. covered it and i just dont know if it’s possible. There is definitely a performance loss regardless of what it says. The question is how small a loss.
this really really smells fake.
I’d easily buy a low-lever hardware emulation, but when they show off os emulation by running the gimp native on windows? claiming that it is run as a linux app?
if run as a linux app, wouldn’t they need to emulate way much more than hardware, sucha s part of the kernel, the fs and maybe /proc? and about library dependencies?
something this universal simply doesn’t happen. especially not as long as the source code for windows and OS X is closed.
My bet: it’s a fake.
“Analyst Rob Enderle of the Enderle Group said Transitive benefits from the fact that most modern machines are fast enough to emulate each other without much affecting performance.”
look no further, the man has spoken, write it in stone.
>>Analyst Rob Enderle of the Enderle Group said Transitive benefits from the fact that most modern machines are fast enough to emulate each other without much affecting performance.” <<
That is wrong on so many levels. the X86 processors are now just getting fast enough to emulate a 500mhz G4, or maybe a 500mhz Alpha, or Sparc. Yet those processors have been able to emulate x86’s for a long time.
Of course If Enderle(Rob or Mary) Says it you know for a fact, that it is a lie, at least in a major part.
And I’ve got some prime beach front property for sale in Antarctica.
As said above, x86 processors are just starting to be powerful enough to emulate a low-end G4 Mac.
Why is Enderle quoted in this article? Something smells fishy.
Let’s analyze what they are claiming. Don’t get fooled by the over-hyped headline, look at the tech on their website.
They are allowing one Unix like OS application, say compiled on PPC, to run on an x86 processor.
So, if you were running a unix-like OS on x86 then you could run that PPC binary from a unix-like system.
You could also conceivably run that x86 binary from a unix-like OS on PPC MacOS as its unix-like too.
Now the windows part threw me, but they could conceivably map X calls to windows, but I’m pretty sure going the other way and running windows apps on Linux or Macs is not possible and something THEY ARE NOT CLAIMING EITHER BY THE WAY.
So, it is possible I guess, but its more limited than the headline would lead us to believe.
You are not going to suddenly run Windows games on Linux or MacOS or anything. Just apps that utilise X probably can be run on different unix-like OSes transparently, with a special X compatability layer for running them on Windows.
how come all the apps they demoed are already available for all the platforms they were demoed on?
why weren’t they running Mail.app in windows, or x86 nautilus on the Mac? that could have made things slightly more convincing.
One wonders why they can’t run MacOS stuff on Windows then?
Or isn’t MacOS unix-like enough for them?
I think its all tied to X and they don’t have a MacOS API compatability layer they can port.
how come all the apps they demoed are already available for all the platforms they were demoed on?
My guess would be for “controlled” testing.
If I wanted to test performance as it relates to an emulated environment it would seem to make a certain amount of sense as to have test an application that has binaries in both environments. Thus I could compare the native win32 binary with the emulated binary.
Just my two cents.
Analyst Rob Enderle of the Enderle Group said
The master of all technology experts has spoken, therefore it must not be a hoax.
Subtracting all business buzzwords for technology experts, the http://www.transitive.com website states that it’s dynamic binary translation. Much similar to WINE and thus NOT emulation.
It’s just “expert” blah.
As it happens i just designed a similar solution enabling me to run ALL binarys regardless of what platform they were written for (except those binarys which somehow won’t work when i double-click them). As a proof i am running the famous Mozilla web browser, a well-known Windows application, on the Linux platform. And it’s just as fast as always, you would expect a lag, but there is none blah blah.
Now the windows part threw me, but they could conceivably map X calls to windows,
Called CygWin
but I’m pretty sure going the other way and running windows apps on Linux … is not possible
Called Wine (WineX, Crossover – there are many)
Actually universal emulator would be possible too, but it should include all guest OS layers from kernel to all needed libraries etc etc (look at CygWin or Wine packages). Described in article block translating and code caching theoretically would be very efficient – on second run native (pretranslated) code could be fetched from cache. This way performance loss wouldn’t big, especially on same architecture PCs (like running win apps on Linux with Wine isn’t much slower than running them in Windows). On different architecture it’s not easy (different instruction set, code and data addressing, hardware access and so on), but probably possible.
(On x86 VMWare and VirtualPC are running pretty good. They are slower mostly because of need of protecting host and guest OSes from each other.)
About emulating older processors – I’ve used that many years ago, when I worked with CPM/8080 emulator on DOS/AT386 – performance was way better than on original i8080 chip based PC
It won’t run Windows apps on Linux or MacOS.
It won’t run MacOS on Windows because the API translation is too complex.
It can run x86 Unix/Linux binaries on MacOS.
It can run x86 Unix/Linux binaries on Windows.
Now running Linux binaries on Windows could potentially be useful if:
a)It was kinda like a WineX, because it would minimise Linux porting effort to Windows and bring a greater userbase for Linux based apps.
b)It could undermine the Windows API stranglehold a little.
c)If windows users started running only Linux apps on windows they may soon feel compelled to switch to Linux proper come upgrade time rather than bother with Longhorn.
But its not going to be free so forget it.
>Called Wine (WineX, Crossover – there are many)
Yeah I know, I shouldn’t have said ‘not possible’, but I just doubt they’ve done it. It would be a lot of effort and there is no mention of such a thing on their website.
http://www.enderlegroup.com/perspectives/pers_47.htm
The master also has written!
The masters…
Rob Enderle
http://www.caldera.com/2004forum/agenda/Enderle_keynote_SCO-Forum20…
Nathan Brookwood
http://www.theinquirer.net/?article=15783
Tony Massimini
http://www.massimini.com/elvis.html
Alasdair Rawsthorne has written a few technical reports on the technology behind this which includes some discussion on performance. See:
http://citeseer.ist.psu.edu/cache/papers/cs/13891/http:zSzzSzwww.cs…
The paper’s a few years old, but I would definitely say this is not vaporware and I would expect them to have worked out most of their performance limitations since that time. Will it live up to the hype of this article and what people here seem to expect? That remains to be seen. In the meantime, instead of immediately crying foul, read up on the subject and come to an informed conclusion. It looks promising. Search around, there’s more up to date info.
Despite what other people have been saying something like this really is possible. Technology like this was demonstrated earlier on alpha style chips. The only thing about this which is new is the support for system calls on differnt platforms, unless it just emulates an entier OS.
The reason this seems so amazing is that all interpreters run nowdays are designed stupidly. In order to compensate for non-native code you need to store run-time information (branching tables etc..) and optimized chunks of code.
My guess is that this runs similar to the old translators for alpha. Namely the emulator translates snippets of commonly used code into snippets of native code, in some sense recompiling the stuff for the native processor. Thus the first few times you run something it will be dreadfully slow but as you accumulate optimizations and run-time data it will become faster and faster.
When technology like this finally becomes commonplace I really do expect interpreted languages to replace compiled languages.
Of course this is all technically possible… No question. But it is very questionable if this company has it running like they claim they do. They give no references, no detailed info, the demos in the article were multi-platform software… All in all it sounds very bloated, and i wouldn’t write “Finally!!” before they have proven that it’s solid, fast and just works.
hmmm
Seeing as they can only run software written for a unix-ish OS what would you have them demonstrate?
They can’t run Windows or MacOS software on Linux for example. Only Linux stuff on Windows or MacOS and its hardly surprising they would demo Open Source stuff.
If I’m understanding this right, basically all this thing does is allow the user to run x86 binaries on ppc and vice versa. So what? Just about the only linux program that’s not available nativly on mac that I know of is shockwave, big whoop. How relevent is the ppc platform at this point anyway? Whoo, this will make, like, 13% of the world happy, have a cookie.
let’s put it this way: If this program will allow me to run an OSX app, like, let’s say, Garage band, then I’ll pull out my wallet right now. Otherwise, I don’t see what the fuss is about. Cool sounding buzzwords, I guess.
Well, it is nothing like WINE, WINE is an ABI, Application Binary Interface where by the win32 API has been recreated on *NIX.
What this technology sounds like is the morphing like software that was used on Alpha which allowed one to run x86 software on an Alpha running Windows NT.
The concept isn’t new. Its the same crap, new name. Microsoft is doing the same thing now in regards to Windows for Itanium, which has resulted in an ever-so-slight increase in speed for x86 applications being run on Itanium.
I remember reading about something interesting in this department four years ago:
http://arstechnica.com/reviews/1q00/dynamo/dynamo-1.html
Something called Dynamo by HP. It emulates a cpu, and optimizes the code at runtime. Apperantly they managed to make some code run faster than native in emulated mode.
How do you go about emulating the vector units on the G3/G4 processors with no performance hit? I mean, as someone who works on PPC assembly as part of their job, I find it very very inconcievable that you could possibly write anything that dynamically translates compiled binaries especially with all the little dynamic code generation tricks that get used in performance critical sections of code.