Designing a computer is a complex task that requires the designers to achieve a certain desired performance level while staying within cost and time constraints. This process has many aspects, some of the most significant being instruction setdesign, logic design, functional organization, and implementation. Implementation includes problems of physical engineering: integrated circuit design, optimization of power consumption, cooling, and the like. To create a functional design that will be viable in the marketplace is a difficult task requiring attention to all these issues and more.
Classically, the term computer architecture referred solely to instruction set design--that is, the design of those commands that run the machine at its most basic level. Everything else was grouped under the rubric of implementation, implying that theoretical design was somehow more important or satisfying than the addressing of practical concerns. Recently this attitude has altered, and now it is possible to say that computer architecture refers to all the challenges to be faced in the design of a computer--instruction set architecture, organization, and hardware implementation.
Generally speaking computer architecture is concerned with all aspects of a computer that actually compute (execute code and handle data flow). However, the great majority of computers that are sold reside, physically, primarily on a single chip: a microprocessor. The design of such chips is often dictated in large part by functional requirements; chips that are otherwise excellent but have no niche market in which to stand out are practically useless. Thus chip design is often influenced by market forces and the likely use of the chip being designed. For instance, if there is a certain type of application software that is widely used in the market where the computer architect hopes to sell the chip, then it may be necessary that the chip implement an existing instruction set that the popular software can work with; the computer architect is in such a case not free to design a new (possibly improved) instruction set. A new version of a chip may thus have to emulate or carry over features that were present in earlier versions in order to make sure that software that ran on those earlier versions will still run on the new one--even where this results in a suboptimal design.
After a set of requirements is fixed, the job of the computer architect is to come up with a viable basic design and then improve it incrementally to get the best possible overall result. Beside raw performance--sheer computation speed--an architect must often consider design complexity. A design of greater complexity will probably take more time to complete, verify, and implement, and there would be more chance of something going wrong. Another important design issue is the effect on software (especially compiler) design; that is, if a chip is very hard to write compilers and other software for, it is possible that creators of software will avoid it, causing it to fail in the market due to lack of software availability for the end users.
Trends in specific technologies involved in implementation of chip design play an important role as well. For instance, the density allowed by semiconductor DRAM (dynamic random access memory) technology increases by better than 50% per year, effectively quadrupling every three years. Likewise, transistor density increases by about 50% per year. However, the technology used for wiring transistors together does not improve at anywhere near such a rate, so that wiring designs that were excellent just three years ago may no longer be usable. Assuming that on average a chip takes two years to design and two years to produce and bring to the marketplace, it is reasonable to suppose that DRAM technology, for instance, will have changed sufficiently even within that time that a reasonable architect must plan for this change in advance.
Once a chip has been built it becomes necessary to test it. This is done using benchmarks--software programs that are widely used and considered standard. The speed with which a benchmark program can be executed on a given machine gives a point of quantitative comparison between that machine and others. As it is difficult to say exactly which application an end user will use, a collection of benchmarks is often tested. Unfortunately, suites themselves are not very standardized, and there is no way to prevent chip companies from promoting test results that, though legally accurate, might convey the wrong impression because vital information is left out.
It is fashionable for computer manufacturers and others to speak of a chip's speed as the primary metric for a computer's performance. There is a well-known observation called Moore's Law, which says that computer chips double in speed roughly every 18 to 24 months, while their cost is cut in half over the same time period. This observation has held true for over three decades, though it has been regularly stated to be on the verge of coming false. However, while it is indeed impressive that clock rates on computer chips grow at such an impressive rate, the end user is liable to be misled by such numbers into thinking that the computer's overall performance also grows at the same rate. That it does not is another old observation, though it's not quite as well known. Called Amdahl's Law (after Gene M. Amdahl who stated it in 1967), this observation notes simply that if there are multiple tasks that must all be carried out to complete a large job, merely speeding up one of those tasks indefinitely will not help beyond a certain point; the large job cannot be completed until the slowest essential sub-task is completed. Thus if computing tasks like input, processing, storage, and communication do not improve at a sufficient rate, improving processor speeds is at best a limited virtue.
This is the complete article, containing 955 words
(approx. 3 pages at 300 words per page).
