Stories
Slash Boxes
Comments

SoylentNews is people

posted by martyb on Saturday August 08 2015, @11:38PM   Printer-friendly
from the nice-summer-beach-reading dept.

Raymond Chen recently posted a ten-part introduction to the ia64 architecture. Rapidly teaching me that while I might be able to write a brainfuck to perl compiler in a few minutes, there's no way in a million years that I'll ever be able to write a good compiler that targets ia64.

The Itanium is a 64-bit EPIC architecture. EPIC stands for Explicitly Parallel Instruction Computing, a design in which work is offloaded from the processor to the compiler. For example, the compiler decides which operations can be safely performed in parallel and which memory fetches can be productively speculated. This relieves the processor from having to make these decisions on the fly, thereby allowing it to focus on the real work of processing.


Original Submission

 
This discussion has been archived. No new comments can be posted.
Display Options Threshold/Breakthrough Mark All as Read Mark All as Unread
The Fine Print: The following comments are owned by whoever posted them. We are not responsible for them in any way.
  • (Score: 4, Interesting) by ledow on Sunday August 09 2015, @08:23AM

    by ledow (5567) on Sunday August 09 2015, @08:23AM (#220171) Homepage

    I'm not one for deep-level processor design, etc., but I come from the traditionalist, hand-crafted microcontroller assembly kind of background.

    Just reading the first few articles was enough to say "No wonder". Lots of registers, great. Different purpose registers, grand. And then it starts on that instruction template junk where instructions are grouped into threes (!) and have to be of certain combinations of those three, and each part can only do certain types of operation (memory, integer, etc.). It's at that point that you realise that targeting that processor architecture can only ever sensibly be done programmatically - there's no way to jump into that and make a small change, or debug a certain instruction, or hope to craft a single instruction by hand.

    So, you have to write a program to output the correct (and, hopefully, optimal) way to express what your code does into a highly-parallel, quite restrictive, assembly that cannot have certain combinations and that may well spend a lot of it's time "padding" because it doesn't have enough of the right type of instructions left over to do what you need. And presumably that program has to run on something other than Itanium before you can start converting compilers etc. And has to handle all the out-of-order executions and guarantee the order that your source language requires, etc.

    Obviously, by now, that's all been done for major compilers and platforms and whatever else - but is it really surprising that the market didn't embrace it? I pity the poor guy who was first tasked with moving the first compiler to Itanium. I'm sure he probably worked at Intel too but, hell, that's a whole different way of working, which needed a whole different way of coding, which really needs a whole different language to code in, which means re-writing basically everything from scratch.

    I realise that modern processors are way more complex that I would like them to be, and since the days of things like MMX, I've tended not to understand quite what it's doing or why, even if I understand the bigger-picture impact. But it seems to me that Itanium was just too much difference, too soon, and expecting the world to jump ship was more than a little optimistic.

    Starting Score:    1  point
    Moderation   +2  
       Interesting=2, Total=2
    Extra 'Interesting' Modifier   0  
    Karma-Bonus Modifier   +1  

    Total Score:   4  
  • (Score: 2, Interesting) by isj on Sunday August 09 2015, @11:50AM

    by isj (5249) on Sunday August 09 2015, @11:50AM (#220211) Homepage

    It's at that point that you realise that targeting that processor architecture can only ever sensibly be done programmatically - there's no way to jump into that and make a small change, or debug a certain instruction, or hope to craft a single instruction by hand.

    I did some hand-tuning/modification of itanium code in http://i1.dk/idh/ [i1.dk]
    It was no worse than eg.s/390.
    But I wouldn't want to code a whole program in assembler - on any architecture. Those days are hopefully gone.