Question on "Reverse Hyperthreading"

[Erasmus]

OK, Yes I know it doesn't exist (Well at least I think I do)

I am aware that processors are capable of executing calculations out of order, and then reshuffle them back into the correct order. My question is this: If one processor is capable of doing this, why can't Intel put silicon in place that enables the bare bones of two processors to work together doing these calculations, and then the result be shuffled around into the right order? Sorelly even the worst threaded applications could then use multiple processors close to their full potential?

No doubt their would be some technical hurdles to overcome, I imagine the processors would have to be able to share L1 Cache and things like that, but I can't see why it can't be done, with my extremely limited knowledge of how CPUs work.

So can anyone out there give me an explanation as to why?

Just thinking about it, but would doing this make the CPUs more like today's graphics cards? Or is that compleely different? I think it's different, but I could be wrong.

 

[gekko513]

Because one CPU has the logic and internal communication necessary to keep track of the out of order execution and make sure they are retired in the correct order. This logic and communication needs to keep up with the execution.

The G5, with the logic out-of-order execution was limited to 2.5GHz while the main core of the Cell processor that work on the same instruction set, but only in order, can run at 3.2GHz.

If two CPU cores should share the execution of one thread, they would need to do all this communication on a bus between them. This bus would probably limit the retirement rate of operations to much less than 0.5GHz, depending on the speed of the bus.

Graphics cards can share the load because the tasks they are doing are predictable and very easy to split into subtasks and recombine. General purpose code execution can't be split into subtasks on a general basis because the cpu has no way of telling how it can be split up. It's up to the programmer to split it up and make a multi-threaded solution to whatever she/he wants to accomplish.