Slashdot Mirror
New Intermediate Language Proposed
WillOutPower writes "Sun is inviting Cray (of supercomputer fame) and IBM (needs no introduction...) to join and create a new intermediate run-time language for high-performance computing. Java's bytecode, Java Grande, and Microsoft's IL language for the Common Language Runtime, it seems a natural progression. I wonder if the format will be in XML? Does this mean ubiquitous grid computing? Maybe now I won't have to write my neural network in C for performance :-)"
Ok, so now that Java is on the retreat they try to enter a new area? May they succeed if it is worthy.
One thing puzzles me, however. What is Java grande? Was it so shortlived that I missed it?
I recall a system based on USCD Pascal. You would
write an interpreter on your target hardware that
would run the pascal p-code. It was supposed to
solve all sorts of problems. Except it was slow.
Nobody would write anything for it, I guess
because they didn't like Pascal, or USCD didn't
fire anybodies imagination with the product.
I don't see why we need to go through this again.
If you need performance write it in assembler or
use nicely optimized C. If you don't then an
interpreted scripting language will usually
suffice. What's the benefit to yet another
layer of abstraction?
-- Programming with boost is like building a house with lego. It's a cool but I wouldn't want to live in it
I really hope the author's smiley was to indicate that he understood that his string of buzzwords was meaningless.
What I hope is that Sun takes a good, long look at the only intermediate assembly that has been designed with language neutrality in mind, Parrot. While this article is over 2 years old, it's a decent starting point. Parrot has already been used to implement rudimentary versions of Perl 5, Perl 6, Python, Java, Scheme and a number of other languages. The proof of concept is done, and Sun could start with a wonderfully advanced next generation byte code language if they can avoid dismissing Parrot as, "a Perl thing" with their usual distain for things "not of Sun".... IBM on the other hand is usally more open to good ideas.
I don't think they're trying to create a language for "high-performance computing" but a language for a "high-performance multi-processor computer", since they're focusing on threads and sun isn't a very good example (jvm) of high-performance.
In my opinion I would like a C language variation that let me specify how many bits i would like to use for a variable, because it would save a lot time because of memory bandwidth (cache space included) and is very boring to make a good implementation of that in assembly.
Indeed it is, still, people want to use it for just about anything it _wasn't_ desgined for. ;-(
I think they are hoping that creating intermediate targets will make optimization and scaling easier. This is similar to the approach taken by gcc. The core compiler team can focus on creating a correct and effecient intermediate representation and the team porting to a new architecture focuses on taking the intermediate representation and creating correct and effecient assembly for that target.
[Set Cain on fire and steal his lute.]
So, one of the ideas behind C# was to make an intermediate laguage (MS-Java-byte-code, if you will) which could be quickly compiled for the CPU in question. Stick a system call envrionment and garbage collector around it and you have [roughly] what C# is. One of the nice things about Java was that it was for no specific machine... it was very very simple at the instruction level, but making native code from that can be a pain.
Now, from the looks of the posted article some folks now want an intermediate laguage that can represent concepts like instruction vectorization and maybe SMP (hypter threading) and perhaps some other more complicated constructs that Java's machine code just doesn't talk about.
The end result is that you would have very fast machine code for the number-crunching loops in the code and portability. The compile time would be fairly quick and the optimization for the local CPU would be "smart" and fast if you marked up what where vectorizable instructions.
Why C# falls short, I can't say. I've only looked at the Java machine, never at how C# represets a program.
Hope this is helpful!
Sam
Quite insighful... but it isn't as bad as it looks.
1) Nobody forces you to write in Java for PIII. Write hand-optimised asm sniplets for PIII and include them in bigger Java or C app for time-critical pieces. You get real PIII performance.
2) The software quality drops, but slower than CPU speed rises. That means your Java app for PIII will still work -slightly- faster than hand-coded ASM for 486.
3) Development cost. You can spend a week to write a really fast small piece of code in ASM. Or you can spend that week on writing quite a big, though slow app.
Most visible in games. Things like Morrowind, where crossing the map without stop takes a hour or more, and exploring all the corners is months of play, were plainly impossible when it all required hand-coding. Now for a developer it takes shorter to create a mountain in game than for a player to climb it. Of course the player needs better CPU to be able to display the mountain which wasn't hand-optimised, just created in an artificial high-level language defining the game world, but if you're going to enjoy the experience - why not?
45 5F E1 04 22 CA 29 C4 93 3F 95 05 2B 79 2A B2
Because that doesn't give you best performance. Machine code represents an exact processor implementation. Tradeoffs have to be made with backwards compatibility (eg Redhat is compiled for Pentium), expected cache sizes (optimising size vs performance), processor specifcs (Itanium has 4 instructions per bundle, Sparc has one instruction after branch) etc.
While it is true that you could compile for an exact machine, it is a horrible way of trying to ship stuff to other people, and it does require recompilation if anything changes. (The former is why Redhat pretty much picks base Pentium - if they didn't they would need 5 or so variants of each package just in the Intel/AMD space. Granted they do supply a few variants of some packages, but not everything, and Gentoo people can confirm that doing everything does help).
Using IL lets the system optimise for the exact system you are running at the point of invocation. It can even make choices not available at compile time. For example if memory is under pressure it can optimise for space rather than performance.
It also allows for way more aggressive optimisation based on what the program actually does. While whole program optimisation is becoming available now (generally implemented by considering all source as one unit at link time), that still doesn't address libraries. At runtime bits of the standard libraries (eg UI, networking) can be more optimally integrated the running program.
Machine code also holds back improvements. For example they could have made an x86 processor with double the number of registers years ago. If programs were using IL, a small change in the OS kernel and suddenly everything is running faster.
Needless to say, using IL aggresively is not new. To see it taken to the logical conclusion, look into the AS/400 (or whatever letter of the alphabet IBM calls it this week). I highly recommend Inside the AS/400 by Frank Soltis.
The effort is part of a government-sponsored program under which the three companies are competing to design a petascale-class computer by 2010.
We already have such a runtime: it's called "CLR". The CLR is roughly like the JVM but with features required for high performance computing added (foremost, value classes).
Sun wants the so-called Portable Intermediate Language and Run-Time Environment to become an open industry standard.
I hope people won't fall for that again. Sun promised that Java would be an "open industry standard", but they withdrew from two open standards institutions and then turned Java over to a privately run consortium, with specifications only available under restrictive licenses.
Sun's goal is to apply its expertise in Java to defining an architecture-independent, low-level software standard - like Java bytecodes - that a language could present to any computer's run-time environment.
Sun's "expertise" in this area is not a recommendation: the JVM has a number of serious design problems (e.g., conformant array types, arithmetic requirements, lack of multidimensional arrays) that attest to Sun's lack of expertise and competence in this area.
What this amounts to is Sun conceding that Java simply isn't suitable as a high-performance numerical platform and that it will never get fixed (another broken promise from Sun). But because the CLR actually has many of the features needed for a high-performance numerical platform, Sun is worried about their marketshare.
The question for potential users is: why wait until 2010 when the CLR is already here? And why trust Sun after they have disappointed the community so thoroughly, both in terms of broken promises on an open Java standard and in terms of technology?
Maybe we will be using a portable high-performance runtime other than the CLR by 2010, but I sure hope Sun will have nothing to do with it. (In fact, I think there is a good chance Sun won't even be around then anymore.)
All good compilers already use well-designed intermediate languages. A general intermediate language that aims to be equally suitable for many high level languages will most likely be inferior to the best intermediate language for a particular high level language.
The other benefits of using an IL are manifold. New languages can be implemented without having to write a compiler for each platform.
Great. Just what we need - another of those braindead technological "advances" like human-readable data interchange formats that makes life easier for a few developers (simpler, cheaper compiler development) and harder for millions of users (worse performance). Frankly, the only advantage for the rest of us I can think of would be the higher probability of the resulting tools being mostly bug-free.
"I love my job, but I hate talking to people like you" (Freddie Mercury)
I don't see how Sun is even relevant or why it matters who they "invite". They had their chance with Java and they blew it. I doubt the numerical community is going to give them another chance after what they have been through with Sun over the last decade.
I suspect the next intermediate language for high-performance numerical computing is either going to be the CLR, some extension of the CLR, or something entirely different, developed in academia.
Even if other big players like MS do not participate, this could really be cool for cross-platform applications. Imagine a caching JIT for such a language. Now imagine a converter that could take Java or .NET assemblies and convert them to this new "byte-code". I am sure a 3rd party would step-up to write the MS version!
Now we are talking! I want my C# to compile to native code on Linux, Sun, and IBM mainframes. I want to take Java programmers in my firm and have their code call my C# and visa-versa. This could be a big step towards that.
Great ideas often receive violent opposition from mediocre minds. - Albert Einstein
That is right on the money. Sun is trying to make an alternative to the CLR - a blantant attempt to take back developers who've switched from Sun J2EE to MS .Net.
.Net and Java apps to talk to each other natively - why then is Sun developing yet another IL standard? The Common Intermediate Language, the ECMA standard which is used by both .Net and Mono, is the only IL we need. On the other hand, building multiple implementations of the standard IL for running on different operating systems is where Sun should be focusing their efforts.
Now, I'm all for having alternatives, but what's going to happen to Java? Will Java compile to IL? The Mono project and DotGNU project both have plans for compiling Java to IL, allowing
Only if Sun's IL interoperates with the Common Intermediate Language will I be rooting for Sun.
Why not just use something like LLVM and/or extend it instead of re-inventing the wheel?
LLVM is already made to be low-level (like assembly language) but with high-level types (struct, int, array) like high-level languages. Sounds like just what they would want.
Don't limit your imagination to bounds of i386-compatibile architecture!
:)
Ever thought about writing interpreter or VM in VHDL and implementing it on a FPGA board? That would be pretty similar.
>if it supports things like procedures
Stacks substituted for local variables, CALL, RET, what a problem?
>nested complex arithmetic expressions,
Can be un-nested at compile time, not really going far from assembly. Just remember that each +, ( or % is a separate call. Can be RPN, why not? That's very close to assembly.
>and named varables
Is it a big problem in assembly? Just pick a register or memory cell and give it a name.
>and no sane high-level language can be without those things.
Implementing some of those in compiler (ASM needs compiler too!) and the rest in hardware is far from impossible
Simply start the design not like with modern languages "We need commands that do this, that and that" and then try to fit them into existing hardware through compilers, but build a hardware that can perform your basic commands directly. So if I call fork(), I don't get a ton of system commands launched, just a single CPU cycle gives me a nice copy of the process and it runs _really_ simultaneously, not by time-sharing. If I want to send signal to some other process, it doesn't go through several levels of OS indirection, it's handled by the hardware, like a hardware interrupt. To perform write() and consider it done in one cycle, or at most as many cycles as many characters i'm writing(). by having my Of course I'm limited by the hardware on how much I can do, but isn't that the case always? Just that next to limits on RAM and CPU speed I get limits on number of variables, number of processes etc? (especially if I can make those dynamic limits, buy better chip, get more processes)
The problem with C is that it's -a bit- too far from the hardware. A bit too much goes on without programmer's knowledge. How do I know ++ operator is 1-cycle CPU INC command or a 300-cycle call to math library to perform addition? I want to be able to select a chunk of code and see CPU cycle count. To have granted command execution time.
45 5F E1 04 22 CA 29 C4 93 3F 95 05 2B 79 2A B2
I was begining to wonder if the pcode code concept was ever going to catch on - it's what, 35 years old now?
.sig
-- this is not a
Granted, it doesn't (yet) have some database specific features such as server settings, but those settings are often managed by the DB sysadmin with command line tools anyway.
:) As an independant consultant doing everything from project management to programming to tech support, I end up doing pretty much everything and most of it remotely through ssh.
:-)
;o)
:)
:) FYI, the screenshots make it look like a very nice program.
Yep, that's me
As to a custom solution in VB, I'll bet it didn't have pie charts, graphs, "top 100" listings, and other great features that help find those lost ISOs, installers, temp files, etc. Oh, and did I mention that it's free?
Yes, all of those things... Is it as fast as du and find? Couple that with the fact that I really don't care about the graphs/etc and it's not something I'll probably ever bother with. Admining remote servers does something weird with the minds of people and prevents them from enjoying any nice GUI tool 'cause they're not real useful through ssh with X forwarding disabled
You use Linux and you don't use BitTorrent to download it?! String him up by his pinky toe!
Yep, no BitTorrent for me. Gentoo freak here. You use Linux and you need BitTorrent? Hand over your geek license now!
Wasn't able to get Wurm Online working... Looks like most of the people on Windows centric anyway, but I might post a message up on Monday and try to get it figured out.
As far as CVS goes, I'm command line. If I have to do a diff, I end up in kompare (very very sweet little program) and I've fired up Cervisia a couple times, but haven't really found it necessary. I don't do much tree maintence because I'm a pretty solitary developer, but for the times I have needed to look through changelogs, etc, the command line tools suffice. If times change and I actually get to hire employees (woot!), I'll have to hunt down a good tool like SmartCVS. If it's the only thing available, I'll run it even if it starts slow
Back to the topic at hand, I agree that apps can be written poorly in general and a slow startup time in an app doesn't mean that all apps written in that language will be slow to startup, but my personal experience thus far is not very promising.
When I said I avoid Java apps when I have a choice, it's because when I look for a new editor/tool/etc and I compare a couple of apps, I tend to gravitate towards those apps that *feel* fast. I have yet to find a Java app that I *enjoy* running.
Think big please. Hundreds of thousands of threads, is not enough, we need millions, thousads of millions of threads.
The only way to get to this level is changing hardware. Current computers, are big memory pools with a single (logical) execution unit, that's the fault.
We need to build thousands of simpler executions units, and parallelization will be a real issue. Switching threads/process is not the answer.
On the software front, two musts for a new languaje: a) it should be 'aspect oriented' (flexible interception). b) automatic paralelization extracted at compile time from objects sets analisys.
Next sig please..
What's in a sig?
I posted this before, but it looks to me that this is still on topic here. How about making Java Free, openning it to new possibilities, optimizations etc.
----------
I would like to see GNU/Linux to become a more powerful platform and by a more powerful platform I mean a platform that provides the user with a pleasant experience. Now, to provide a pleasant experience a platform must give the user a choice - a choice of applications that exist for the platform is a step in the right direction. However, GNU/Linux is not such a platform yet. If it were, it would have been embraced by the masses already and it is not. There are a few things that GNU/Linux system is lacking and one of the more important lacking components is a convenient tool that allows a novice create his/her own software for the platform, software that easily manipulates data imported from multiple sources and allows to create graphical interfaces to that data. In the Microsoft this functionality is provided by such a ubiquitous tool as Visual Basic. In the Free Software world there are many tools that are extremely powerful but none of them have the same kind of momentum that Visual Basic delivers on Microsoft platform.
To answer the question- "What can be the VB for Free Software?" we need to look at the kind of problems that will have to be solved by this tool. The problems solved by VB are of many kinds, but for the general public VB provides the bridge that closes the gap between a user and a multitude of small problems that the user wants to solve. Of-course it is possible to just create a VB IDE for FS platforms but I believe there is a more interesting solution to this problem and it is Java. Just like VB, Java runs in a virtual machine, so the user will never really have direct access to any hardware resources, but an abstract layer of JVM can provide a nice buffer between the user and the hardware and at the same time Java will always behave in the same way on multiple other platforms, including Windows. Java has thousands of convenience libraries, there is enough Free Software written for Java that can be integrated into an IDE. However there is a big problem with the language itself - it is not Free.
Sun allows anyone to use Java for free but nobody can modify the language itself except for Sun. In order for Java to become for Free Software and Gnu/Linux what VB became for Microsoft, Java has to be Freed and put out under the GPL. There is also probably a good business sense in it for the Sun Microsystems as well - their language suddenly becomes the language of choice for millions and thousands will work on improving the language, the virtual machine, the compiler etc. In this case Sun will stay in a position that Linus finds himself in - they become the gate-keepers for the vanilla Java tree, but Java will branch and will become much more spread than it is right now. Sun can capitalize on that by providing more Java based solutions and services.
Now it is likely that Sun management will not agree to the change of their Java's status, however, if there was an immediately profitable reason for them to do this, they just may turn around and start thinking about it. A reason that is profitable could be a large sum of cash available to them upon releasing Java under the GPL. Where could this money come from? These money could be collected by the FS and OS supporters, the developers and the users who would like to see more momentum in the GNU/Linux movement towards a successful (wide spread) desktop solution. I suppose no one will seriously object to have one more powerful tool in their Free Software tool-bag. Java can be this tool and it can be just the thing needed to tip the scales over towards quick appearance of a useful and a popular GNU/Linux desktop.
You can't handle the truth.