Abstract: Today everyone asks the question about what are we going to do with quad or even octal cores? Maybe we can put in a GPU, sound card or other cool things. But all this comes at the expense of the FSB being stressed out, it will be the bottleneck. I want to propose another view to this opportunity. Why not put in two cores that use two different ISA?
x86 have lived through a world where we are constantly trying to be independent from technology, so that we can upgrade to a new technology when it is present. We don't want to brake our 'legacy' programs and still we want a new and cleaner ISA.
Today we are totally capable of changing an ISA by utilizing the opportunities we have with multi-cores. Not because we couldn't have made the same thing with two processors on one motherboard, but this time it is much cheaper. And not that we don't have solutions for running different ISA's but this time it is natively done. My solution is two cores each running it's own ISA without any overhead, which means running two programs natively in different ISA.
With this solution we can still run the 'legacy' code with a 100 % guarantee that any bug that was present on a pure x86 CPU is still present on a multi-core CPU with two ISA!
What we need to make this work is a simple operating system that can detect the different binaries and assigning them to the right core. They will still run in the same memory, coexists on the same hard drive. Theoretically this is done easily. The only problem is that we need a real multi-core CPU that runs two different ISA simultaneously. Creating a simulation for this simple and elegant solution would be an overkill because anyone can see that this should work.
Benefit for Intel
Intel can now give a reason to why we need octal core processors. Also Intel has a once in a lifetime chance to create it's own ISA, that would make life easier for compilers and the gaming industry would love some extra registers. Intel would have a nice way of fazing out x86 code, maybe in 10 years no new code would be written in x86 but old code could still run as if nothing happened.
This is just the tip of the ice berg. Why not make a CPU that has 3-4 different ISA? Stack-based, Register-Register and maybe VLIW? And let the compiler choose the best ISA for a specific application?
I believe this is a really simple solution and can't really understand why no one hasn't thought about it? Or is there a real problem behind it that I have missed? Is it something you have considered and realized that there is not real benefit? I would really be happy if I could hear your response about this.