Rerouting VLIW instructions to accommodate execution units deactivated upon detection by dispatch units of dedicated instruction alerting multiple successive removed NOPs

1. A parallel processor for executing code for that has been compiled to achieve code compaction, the code comprising a plurality of successive instruction bundles each comprising a plurality of instructions, one instruction for each of a corresponding plurality of execution units, the instructions including a do nothing instruction pertaining to a first duration in which a single instruction is executed and in response to which an execution unit performs no operation, the parallel processor comprising:

a memory;

an instruction dispatch stage comprising a plurality of dispatch units, the instruction dispatch stage being configured to detect in a first instruction bundle a dedicated instruction for a particular execution unit;

circuitry for flexibly routing different instructions of an instruction bundle from the memory to different ones of the dispatch units;

an instruction execution stage comprising a plurality of execution units, coupled to and following the instruction dispatch stage;

the instruction dispatch stage being configured to, in response to the dedicated instruction:

reduce power to or turn off the particular execution unit for a variable duration in which multiple instructions would otherwise have been executed by the particular execution unit; and

cause the circuitry to reroute instructions in a next successive instruction bundle following the first instruction bundle such that an instruction that logically corresponds to the particular execution unit is rerouted to a different execution unit.

2. A parallel processor as claimed in claim 1 , wherein the memory comprises a plurality of registers for storing instructions, the plurality of registers being coupled to said circuitry.

3. A parallel processor as claimed in claim 1 , wherein a dispatch unit is configured to at least partially deactivate itself in response to the dedicated instruction.

4. A parallel processor as claimed in claim 3 , comprising a control circuit for reactivating a dispatch unit after said variable duration.

5. A parallel processor as claimed in claim 4 , wherein the control circuit is configured to generate the reactivation signal responsive to a signal from an execution unit.

6. A parallel processor as claimed in claim 1 , wherein said circuitry comprises a data communication bus.

7. A parallel processor as claimed in claim 1 , wherein said circuitry comprises:

a plurality of demultiplexers coupled to the plurality of registers; and

a plurality of multiplexers coupled to the plurality of dispatch nodes units, with each demultiplexer of the plurality of demultiplexers being coupled to each multiplexer of from the plurality of multiplexers.

8. A method of executing code for a parallel processor that has been compiled to achieve code compaction, the code comprising a plurality of successive instruction bundles each comprising a plurality of instructions, one instruction for each of a corresponding plurality of execution units, the instructions including a do nothing instruction pertaining to a duration in which a single instruction is executed and in response to which an execution unit performs no operation, the method comprising:

at an instruction dispatch stage preceding an instruction execution stage, detecting in a first instruction bundle a dedicated instruction for a particular execution unit;

in response to the dedicated instruction:

reducing power to or turning off the particular execution unit for a duration in which multiple instructions would otherwise have been executed by the particular execution unit; and

rerouting instructions in a next successive instruction bundle following the first instruction bundle such that an instruction that logically corresponds to the particular execution unit is rerouted to a different execution unit.

9. A method of compiling code for a parallel processor to achieve code compaction, the code comprising a plurality of first successive instruction bundles each comprising a plurality of instructions, one instruction for each of a corresponding plurality of execution units, the instructions including a do nothing instruction pertaining to a duration in which a single instruction is executed and in response to which an execution unit performs no operation, the method comprising:

detecting within the plurality of first bundles of instructions a plurality of do nothing instructions that are successive instructions for a particular execution unit;

replacing a first one of the plurality of do nothing instructions with a dedicated instruction for the particular execution unit;

removing at least one other one of the plurality of do nothing instructions such that the code contains fewer total instructions; and

re-bundling the code to form a plurality of second different instructions bundles.

10. A method as claimed in claim 9 , wherein removing comprises removing all remaining do nothing instructions from the plurality of do nothing instructions from the plurality of first bundles of instruction.

11. A method as claimed in claim 10 , further comprising including information within the dedicated instruction indicating a number of removed do nothing instructions.