This post by me from the other Natami thread is what started this thread:
The Natami is pushing the hardware limits but it will only be able to run OS 4+ if they add a PowerPC accelerator card to it. Before the Mac went to Intel the PowerPC was a vibrant design with lots of attention and now it is relegated only to game machines which are restricted by hypervisors so that they don't allow ordinary people to experience their full potential.
I think PowerPC is a dead-end as much now as ever and the Intel and AMD processors are reaching a dead end also due to the heat restrictions of higher clock frequencies and are turning their attention toward multiple cores. Since their software doesn't run well on multiple cores they are going to be at a standstill.
I think the Intels will make it further than the PowerPCs because they have a more compact instruction set but that will wear thin when easier-to-use instruction sets prevail. I think the way of the future is asymmetric multicore design where the cores are dedicated to the functionality they are intended for.
What makes an Amiga, in my opinion, is the dual-bus architecture. While most computers are stuck with a left-brain dominant design that didn't allow for parallelism, the Amiga introduced a computer with a right hemisphere for creative thinking. On most computers it may be considered a required peripheral for graphics and sound, but on the Amiga it was standard, integrated, and elegant. On the stock A1200 it was even right-brain dominant due to the underpowered main processor.
I could say more but if you want to hear more of why I think the way I do, I'll start a new thread.
So here I go:
Most software is serial with branches. Most hardware is parallel but controlled by a processor. Now the industry expects software engineers to develop parallel applications and hardware engineers to take the lazy way out and make duplicate cores. This can only lead to tears because they are asking hardware and software engineers to use the other one's work techniques.
Software engineering is supposed to be easier than hardware engineering because unique software is more common than unique hardware. The symmetric multiprocessing path will be used in high-end applications but will be impractical for low-end applications until new programming languages come out that take advantage of parallelism.
Hardware engineering is always more parallel than software engineering because that's the way gate layout works on a chip. It's always quickest to have many things done at once and only resort to serialization when you run out of space on the die.
What I'm proposing is a compromise: FPGAs are programmable hardware and the software that controls them is designed to convert serial programs into parallel programs whenever possible but, at the same, maintain synchronization with the other parts of the chip by counting clock cycles.
The type of parallelism that takes place on an FPGA is much more flexible than parallel processors because, as long as you've got space on the chip, you can expand the bus width to 128 bits or narrow it to 1 serial connection depending on the data type.
The Amiga championed the way into the multimedia age by allowing a serial threaded processor to multitask and by making the most processor-intensive tasks run on a separate bus for all of the right-brain graphics calculations and sound mixing.
The next generation of hardware will start there with asymmetric cores like Intel's Atom and the Natami70. These multicore chips have a processor, a graphics core, sound capabilties and have them all on one chip. To keep down the costs they will have to cache the accesses differently from the dual-bus architecture of the Amiga but there is a unique characteristic that the Amiga chipsets had that isn't on the others: The and/or/invert logic in the blitter's bit-masking mode is the same bit-twiddling technique used in the FPGA!
Now, by practicing the custom bit-masking modes of the blitter, software engineers can learn to become hardware engineers and hardware engineers have a more important role. Hardware engineers can take the bit-masking modes of the blitter programmers and make them into custom chips thus completing the cycle. Software makes new hardware and new hardware makes more efficent ways to make software.
For an example of software being translated into hardware, download this
PDF Slideshow from the LLVM Developers' Conference that took place last Friday. There's a
Quicktime Movie to go with it if you can view it.
