This essay explains orthogonality issues. The early portion of the essay defines the term. The next portions delve into common design issues that require orthogonality.
Subsequent portion provides brief explanation of components of instruction sets, and how an orthogonal instruction can be developed, and the advantages of orthogonal design to compiler writers. Subsequent section tackles a brief description of the orthogonality of the RISC architecture. The remaining portion provides a brief description of the development in the processor, and hardware/software industry and its impact on the computer architecture.Despite of the long acceptance of the orthogonality issue, is it really a significant component of all computer architecture designs? Three Design Issues That Should be Orthogonal In computer science, orthogonality of instructions simply means that an instruction can utilize any register and in any addressing mode, in the most common term, it implies independence. When dealing with orthogonality of instructions to the machine, the three components of instruction sets should be considered, and these are the: operations, data types, and addressing modes. These three components should be orthogonal.
From the definition above, we can also say that orthogonality is observed when each operation resulting from any instruction can be able to use each data type and likewise each data type should be able to use every addressing mode. This is made possible by uniquely encoding the combinations of registers and addressing modes into instruction fields: one which identifies the registers to be used and one to identify the addressing mode. It’s Advantages from a Point of View of a Compiler Writer A compiler is a program that transforms source code written in higher level languages into lower-level languages like assembly and machine languages.This is done to ensure that program compiled into executable form can be executed with different machines.
Designing a compiler is a complex task which compiler programmers later found that writing larger compiler source codes requires programming task to be divided into many orthogonal or independent parts or functions. Its collaborative design makes development faster, and its orthogonality made it possible to insert, eliminate, or modify each part or functions without affecting the other remaining parts. Making future adjustments is made easier with orthogonal design.However, at some time, orthogonality should be compromised considering speed and performance issues. This problem is brought by the complexities of hardware architecture, and software support.
That is why compiler programmers and hardware engineers requires to meet each group’s expectation in every development effort. For instance, pipelining can become very difficult when compiler writers find it hard to schedule complex task to the hardware. Pipelining is a technique that allows simultaneous and efficient execution of instructions.A sort of problem like this can be prevented by collaborative effort between hardware engineers and compiler programmers.
Compilers typically deal with instructions. Mentioned earlier, there are three components of instruction sets, and these should be orthogonal. Considering the effectiveness of the compiler, it helps compiler writer design optimized compilers by identifying reliable and robust architecture of memory addressing mode, data type allocation into (registers, stacks, heaps, and global data area), and quick and reliable instruction execution.As compiler understands how these complex processes works, the easier it is for them to divide tasks. The RISC Architecture and the Latest Developments A common example of an orthogonal architecture is the RISC.
The Reduced Instruction Set Computer Architecture utilizes a small but highly-optimized instruction sets. RISC processors have the following features: one cycle execution time, pipelining, large numbers of registers, retained the register-register, load/store architecture. This platform made RISC machines to perform faster.However, the latest developments in the processor industry allowed different architectures to adopt each other’s features. RISC nowadays is no longer pure RISC.
It is already blended with other architecture like the CISC. These developments had somehow inclined the RISC developers to compromise orthogonality for the purpose of retaining its competitive edge. What’s important is for their machines to show up excellent speed and performance whether in the observance of orthogonality or not.ConclusionOrthogonal design made a remarkable breakthrough in the development of computer architecture. Its introduction produced the robust computers that we have today.
It guides compiler programmers in developing optimized and efficient compilers that allows execution of one program into different types of computers. RISC Architecture which became famous of its one-cycle execution, and load/store architecture is one of the most successful orthogonal design-based machine. Apart from it, we also have the CISC architecture.However, the latest developments in the processor industry and in hardware and software support allowed different architectures to be blended with one another. Nowadays, RISC is no longer at its pure architecture as it is also blended with CISC architecture.
This series of developments have opened the question of when to observe orthogonality or not. The answer lies in which ever cases it can promotes speed and performance. Therefore, we can say that in some point any design requires orthogonality, but to some, it may not.
