Slashdot Mirror
Linux IA-64 Resource Portal
djmagic writes "SourceForge has opened it's IA-64 portal for porting projects to Linux running on (surprise) IA-64. " It's still a tad sparse, but you should be able to compile on the Compilefarm if you're interested in porting something. There's also a
news.com story on the thing.
The `advantage' of the P64 model is that you get fewer compiler warnings when you compile programs that were originally written for IA32. They could still be semantically wrong but at least the compiler doesn't complain.
The advantage of the the LP64 model is that there is a native type available for all integer sizes.
From my comments you can guess which model I believe is the correct one to follow, especially given that my experience has been that Linux applications just re-compile and work on IA64. There has been very little changes required by applications to get them to work. Of course, this is undoubtedly helped by the fact that Linux supports the Alpha.
--
Don Dugger
"Censeo Toto nos in Kansa esse decisse." - D. Gale
... you can hear the sound of furniture being thrown around in Seattle, WA.
I don't think that anyone is going to report it this way, but this just has to be a major black eye to Microsoft. Here we have an operating system that's open for public use, even in a sort-of-a-beta fashion...
Anyone seen a 64 bit of Windows, anywhere? I think I remember reading something in CNET, or somewhere else, about someone stumbling across some alleged 64 bit version of Windows being demoed at some demo show somewhere out there. That's about it. A production-quality Win-64 is NOT going to ship simultaneously with Itanium, no matter what anyone says otherwise.
Despite Microsoft's promise to deliver Win64 when Itanium ships, it's nowhere to be seen on horizon. All MS OS builds go through two or three public beta cycles, doesn't anyone remember that? For Win64 to ship with Itanium, we'd have to be on at least the second beta cycle by now.
My memory's a bit cloudy on this one, but I'm pretty sure that Win95 came out only two or three years after the first 32-bit Intel CPU, so it must be pretty clear to Intel now that they cannot rely on Microsoft software to drive their high-end chips. When Itanium ships, the only production-quality native 64-bit operating systems will be Linux and Monterey. Maybe Solaris, if Sun stops throwing their temper tantrums.
I can't wait to see how MS is going to react on this one. By the end of the day the story should be picked up by most mainstream 'zines. It should get interesting from that point on.
How about open-sourcing the CompileFarm setup and environment so us Alpha guys can put up a couple of systems for folks to compile away? This way the systems look the same from a users standpoint.
:)
Oh, and you can run benchmarks on ours.
FYI:I work at API
What's my Karma Mr. Burns? "Excellent"
Couldn't people just run an IA-64 emulator on their own machine? It would be really slow compared to the real thing, but a 600MHz 686 running an IA-64 emulator might be only a hundred times slower than the real thing. A hundred times slower is still a reasonable speed for many interactive programs that spend most of their time waiting for user input. And you'd still edit and compile your program natively.
Apparently HP are making an emulator, but I don't know if it will be free (speech or beer). ARM Ltd provide a GPLed emulator for their chips, it would be nice if Intel started doing the same. At the very least, it would show up hardware bugs if a program gave a different result when ran on the (debugged) emulator than on the real CPU.
-- Ed Avis ed@membled.com
-legolas
(Hmph... isn't it funny when you do kernel call 2 instead of 3 in an infinite loop... whoops ;^)
i've looked at love from both sides now. from win and lose, and still somehow...
I'd be interested if some knowledgeable person would explain here the current state of development of IA-64 compilers (gcc in particular).
IA-64 is peculiar in that respect, not so because it is 64-bit (though this is likely to hurt code that assumes 32-bit int's and pointers... and that's still quite a bit, look at the difficulties with Linux on Alpha). As decribed in Intel's documentation, IA-64 is a VLIW (Very Large Instruction Word) architecture where the burden of superscalar pipelining (deciding what assembler instructions can be executed in parallel) lies on the compiler. Let us take a simple example: where you are executing
imull %edx, %eax
addl $4, %eax the two instructions cannot be scheduled on two parallel pipelines since eax in the second depends on the output of the first. Advanced design allow the CPU to "swap" certain instructions (out-of-order execution).
From a hardware design point of view, the IA-64 design makes sense: out-of-order scheduling instructions over multiple pipelines in hardware is complicated. For this reason, IA-64 allows the assembly code to specify "bundles" of instructions that can be executed in parallel. The burden is then shifted to the compiler.
Such a design allows scheduling optimizations far further than the ordinary peephole optimizations (i.e. very local tricks). For instance, in numeric code like this:
x[i][j]=expression1;
x[j][k]=expression2;
the compiler could schedule expression1 and expression2 in parallel, if they are sufficiently simple. Of course, for this to respect the semantics of the program, (i,j) must never be equal to (j,k). Answering such questions mechanically is impossible in general (Rice's theorem, reduction to the Turing machine halting problem). However, there are analysis techniques that can give the right result in most cases (such techniques can also be used to check whether two pointers never point to the same variable, or whether some array bound checks are useless) (an active research topic; see some of the research in the area).
I would like to know the current state of the art of industrial-grade compilers with respect to this automatic local parallelization techniques.
So SourceForge now has compile farm resources for x86 and IA-64. What about the other architectures? Where's the PPC compile farm, the ARM compile farm, the Alpha and MIPS compile farms?
There's got to be a demand for these among open source developers. Most people don't have that many architectures that they can compile and test on, but most people would like their code to work on as many platforms as possible.
CVS is teh suck. Use Vesta instead.
IA-64, at least now, only means Itanium. Do we really hate the name Itanium so much that we refuse to call it that? Even the article in which the new name was announced, the title read "Itani-what". The other day, I submitted a story about Itanium prices. It was rejected. If I called it a story about IA-64 prices, Rob would have posted it right away.
sup
sizeof(short) == 2
sizeof(int) == 4
sizeof(long) == 4
sizeof(void *) == 8
Microsoft says it's for Win32 portability reasons. I think it's brain damaged.
Mea navis aericumbens anguillis abundat
Do free software developers really want to be putting there time and effort into helping intel push their IA64 systems onto the market?. Intel have show themselves to be just as evil as microsoft in abusing their power to push other companys out the way, up to now the've failed, no one likes Rambus, and AMD and VIA are doing better than ever. But we seen plenty of what intel is trying for, which is complete control over computer hardware from processors to serial ports. With no else being able to invent or produce anything. Intel will stop at nothing to prevent other companies from making chipsets for its processors, it tring its hardest to take over the graphics card industries, and generally being a monopolistic SOB. If we help to make IA-64 a sucess by giving a early platform to work on, then we've just given Intel the future. If we are lazy and what for someone else to do the work on IA-64, and let sledgehammer and alpha and ultrasparc architures gain market share until intel is small enough not be able a abuse its position then the next 15 years of computer hardware will be much freer and more inovative. Agree, Disagree, Give a Damn?
- because 'int' is usually for numbers, and you very very rarely need numbers bigger than 2^32 anyway, and
- because if char is 8bit, short is 16bit and int was 64bit, then there wouldnt' be a standard type with 32 bits, which would be annoying, and particularily silly to leave a gap like that while making int and long the same size
what this all means is that there's *still* one neat thing that you can assume: on all reasonable systems, sizeof(int) = 4 = 32bit.OTOH, if it's true that win64 has 32bit long, now *that* is really ridiculous.
I don't think that it is really an issue.
The most you can expect usually from the C brain damaged type system is something like
sizeof(short) == 2
sizeof(long) >= 4
sizeof(long long) == 8 if it exists..
In any case, I think that it is the C language which is brain damaged here!!
I did want to go over the NDA that you have to click through to use the service. Why the NDA? Intel is letting us use IA-64 engineering samples for the compile farm and they don't think that any public benchmarking done on engineering samples is fair. We agreed with them and wanted to see developers get thier hands on a working sample early. You're welcome to disagree, but we wanted to give a heads up to people, so be sure to read the NDA.
Intel has been pretty cool about this, I am pretty happy to see the GPL liberally sprinkled around an Intel legal document.
Some points from the NDA (most of the NDA is Intel covering its butt, limitation of liabilities and such):
In paragraph 3 Intel says the following (and this applies to paragraph 5,8 as well):
- "You may not reverse engineer, decompile, license or disassemble portions of any Intel Software provided in object code form."
Paragraph 4 is the Benchmarking Clause.The only code that is from Intel in object code form is the BIOS and motherboard controller firmware. There is no other object code on the system. The IA-64 Linux kernel is completely open and has been out of NDA and licensed under the GPL since February.
Paragraph 13, this is a tricky thing, they retain the right to receive activity logs of the compile farm, this is so they can verify for Paragraph 4. They are only able to request logs pertaining to the Compile Farm, not any other sections of the site.
Finally we ask for a brief description of the work you want to perform, this is because we (VA/Sourceforge) may have to throttle usage based on project importance. The persons judging this is Eric Sindelar here at VA. We really don't think we'll have to throttle usage, but we want to have the info available to do so if in fact we need to. As of this writing we already have 30 requests to use the service, so it shouldn't be all that necessary.
That is the overview that we've come up with, we hope that this will go a long way in finding out any IA-64 issues that your code may have. This will also be good for checking the IA-64 Linux Kernel out in real world conditions. If you have any other questions, pose them here and we'll answer them, or email me directly
Chris DiBona
VA Linux Systems
--
Grant Chair, Linux Int.
Pres, SVLUG
Co-Editor, Open Sources
Open Source Program Manager, Google, Inc.
And this surprises you why? M$ has a very entrenched history of brain damaged shit along the lines of "portability".
To check for 64 bit cleanness, you could probably get on Compaq's server farm. They have various 64-bit Linuxes running on Alpha processors, and they don't require your project to be open source. If you can compile and run on Alpha, chances are good it will work on the Itanium.
If tits were wings it'd be flying around.
Chris DiBona
VA Linux Systems
--
Grant Chair, Linux Int.
Pres, SVLUG
Co-Editor, Open Sources
Open Source Program Manager, Google, Inc.
It's also a portal to porting apps to Linux!!!!!
just wondering if i'm missing something or not.
How much work would go into porting the average appliction, like "pico" or "apache" to the IA-64 arch? Does most of the work have to go into the new compiler?
Just wondering...
Ryan
Hmm... never heard of Linuz before. Must have been using that M$ Word Spellchecker. Not that it would have picked up Lixux anyways. I think if the spellchecker in Word sees Linux, it barfs horribly. Of course... that's windows for ya...
--You will rephrase your request for me to go to hell. Goto statements are not acceptable programming constructs
At least Intel isn't going to screw their user base by making fake attempts to show support for other OS's like Apple.
This space for sale
why all the hype around ia-64? imnsho, it's just another overly complex arch from intel. also, there are already alpha systems available to test code on (eg, compaq's test drive program), for 64bit cleanliness(sp).
what the world needs is not another overly complicated arch. if you want to go the VLIW way, sun's majc is much cleaner (though, you really need to use java).
alpha, sparc, mips, and ppc are already better designed and are availiable now. intel's brand name and their $$$ are the only reasons ia-64 may survive.
Can anyone use the IA-64 Compile Farm, or does it have to be an open source project? I'm interested because I'm supposed to port to Itanium, but my boss hasn't given me a machine yet. I'm sure he'll dig one up...one week before we ship. I'd like to be ready before then.
--
Have Exchange users? Want to run Linux? Can't afford OpenMail?
Linux MAPI Server!
http://www.openone.com/software/MailOne/
(Exchange Migration HOWTO coming soon)
Atomic should be transparent on properly written
code.
May result in larger executables.
So, Itanium being 64-bit, that would mean:
sizeof(int) == 4
sizeof(float) == 4
sizeof(double) == 8
sizeof(void *) == 8
right? (I'm only sure about the first one-- at least that's how big ints are on Alpha)
ObWonder: Why don't 64-bit platforms have 64-bit ints? I mean, int has historically gone from 16 to 32 bits (was 16 in DOS, at least), so why not 32 to 64?
iSKUNK!
Intel provided the hardware. VA Linux Systems and SourceForge provided the resources to get the systems up and running. Eric Sindelar VA Linux Systems
This would seem a big advantage to Itanium's future. I would imagine that Intel are especially pleased to see this kind of thing going on. Does anyone know how sponsered the Itanium Compile Farm is, by Intel? Of course, this kind of thing lends itself SO well to linux/unix. Acheiving this with, windows, say would require so much more resources.
--
It's more of a shell than a portal :-)