The Performance Effects of Functional Migration and Architectural Complexity in Object-Oriented Systems

CMU-CS-85-159

Robert Paul Colwell

August 1985 - Thesis oot Department of Electrical and Computer Engineering

Computer system research is a knowledge-based pursuit, but lacks even a rudimentary codification or taxonomy of that knowledge. There are no methodologies, no consistent guidelines, to help contemporary computer architects in creating new systems. They have only their own experience, and advice from the few published analyses of other machines to guide them. But this advice is inconsistent: emphasize instruction set regularity, symmetry, and orthogonality; design to minimize the semantic gaps; design for a minimal execution engine; design for maximum family compatibilty and profitability; design for minimum life-cycle cost. These admonitions are internally consistent, but because each design project had different goals, the architect must understand the context for every architecture before conclusions about it can be used in designing new machines. Unfortunately, that is problematical, because no models have yet emerged which can express the particular priorities a designer assigns to his sytem design goals e.g., performance, cost, size, design life, etc. and also show the degree to which the resulting system met those goals. Performance measurements have been used as a de facto standard medium of expression, but such measurements are notoriously error-prone and hard to interpret. Worst of all, most reported results concern hypothetical machines that are never built, and of the real machines that are built, only rarely are the failures brought to light. It is unsurprising that the computer architecture literature is difficult to use in designing new systems, especially those intended for production or experimentation.

This thesis proposes that the common thread through the literature is the assignment of system functionality to system level and choice of implementation technology within that level. The Reduced Instruction Set Computer RISC vs. Complex Instruction Set Computer CISC debate is largely a disagreement over the performance effects of function placement within an instruction set: e.g., compile-time vs. runtime functionality, high-semantic-content vs. primitive instructions, simple vs. complex addressing modes. Recent studies attempt to show that migrating functionality from the instruction set architecture into compilers or high-level software improves overall performance, but the reported results are monolithic, with no separation of the many architectural factors from their individual effects.

Proper mapping of function to level is critical to achieving acceptable system performance, but there is no methodology with which to make these decisions. Creation of such a methodology is far out of the reach of a single thesis.

The principles which are required of such a methodology have not been formulated, for there is no well-engineered and scientifically credible body of data on which to base them. This thesis contributes data on the efficacy of functional migrations in a restricted domain, object-oriented systems, using a real computer system as a case study.

It is imperative that real machines be used for functional migration research for several reasons. The first reason is that, although computer architecture has historically been considered apart from implementation details, there have not yet been enough machines incorporating functional migration produced and studied to allow for reasonable intuition as to how this dichotomy can be legitimately employed. The second reason is that much of the functional migration attempted recently seems to have been done simply because it had become possible , not necessarily because global system issues such as cost-effectiveness demanded it. A third reason is that the same researchers who most vigorously criticize this functional migration are quite explicit in their willingness to blur implementation and architectural details, and hence would view as unconvincing any work which did not take both into account.

This thesis studies an extreme case of traditional functional migration in a commercial product, the Intel 432 microprocessor, analyzes the various architectural and implementation tradeoffs and anomalies, and shows their individual effects on overall performance. The thesis demonstrates that, over a set of six benchmarks, performance can be improved by factors of two or more when these artifacts are removed. Had the technology been incrementally improved, another factor of two or three would have been attainable. Even with this improved performance, the 432 would be from one to four times slower than current conventional microprocessors, depending on the task; this ratio is the object-oriented overhead built into the architecture.

The 432 provides evidence for some key RISC assertions: the value of local data registers, easily decoded instruction formats, and the high cost of procedure calls. Others, such as the performance cost of a complex addressing mechanism, are arguable. The various contributions of architectural features to overall performance are explicitly discussed, so that these results are applicable to other systems, whether object-oriented or not. Downward functional migration is argued to be indispensable for access checking and expensive common operations, but improper migrations can be detrimental e.g., floating-point microcode included in the central processor without sufficient resources to make it fast . Other systems should be studied at the same level of detail so that architects no longer have to choose between faith in a given style of design or reliance on intuition in making their tradeoffs.

188 pages

Return to: SCS Technical Report Collection
School of Computer Science homepage

This page maintained by reports@cs.cmu.edu