ABSTRACT

The labels "16-bit," "32-bit" or "64-bit," when applied to a microprocessor, characterize the processor's data stream. Although you may have heard the term "64-bit code," this designates code that operates on 64-bit data. In more specific terms, the labels "64-bit," 32-bit," etc. designate the number of bits that each of the processor's general-purpose registers (GPRs) can hold. So when someone uses the term "64-bit processor," what they mean is "a processor with GPRs that store 64-bit numbers." And in the same vein, a "64-bit instruction" is an instruction that operates on 64-bit numbers.

Table of Contents
Introduction..................................................................................................

Why computing?...................................................................................................

64-bit

What is 64 bit computing? ........................................................................................

Dynamic Range...........................................................................................

Explicit Paralellism ............................................................................. Speculation................................................................................... Predication..............................................................................................................

Rotating Registers ..............................................................................

64-Bit Architecture ................................................................................

Introduction.................................................................. Opteron Micro Architecture................................................................ Dual Channel Memory , More or Less.................................................................. Conclusion.............................................................................

References..

Introduction
Why 64-Bit Computing? The question of why we need 64-bit computing is often asked but rarely answered in a satisfactory manner. There are good reasons for the confusion surrounding the question. That is why first of all; let's look through the list of users who need 64 addressing and 64-bit calculations today:
y

Users of CAD, designing systems, simulators do need RAM over 4 GB. Although there are ways to avoid this limitation (for example, Intel PAE), it impacts the performance. Thus, the Xeon processors support the 36bit addressing mode where they can address up to 64GB RAM. The idea of this support is that the RAM is divided into segments, and an address consists of the numbers of segment and locations inside the segment. This approach causes almost 30% performance loss in operations with memory. Besides, programming is much simpler and more convenient for a flat memory model in the 64bit address space - due to the large address space a location has a simple address processed at one pass.

Users of data bases. Any big company has a huge data base, and extension of the maximum memory size and possibility to address data directly in the data base is very costly. Although in the special modes the 32bit architecture IA32 can address up to 64GB memory, a transition to the flat memory model

in the 64bit space is much more advantageous in terms of speed and ease of programming.
y

Scientific calculations. Memory size, a flat memory model and no limitation for processed data are the key factors here. Besides, some algorithms in the 64bit representation have a much simpler form.

Cryptography and safety ensuring applications get a great benefit from 64bit integer calculations.

What is 64-bit computing? The labels "16-bit," "32-bit" or "64-bit," when applied to a microprocessor, characterize the processor's data stream. Although you may have heard the term "64-bit code," this designates code that operates on 64-bit data. In more specific terms, the labels "64-bit," 32-bit," etc. designate the number of bits that each of the processor's general-purpose registers (GPRs) can hold. So when someone uses the term "64-bit processor," what they mean is "a processor with GPRs that store 64-bit numbers." And in the same vein, a "64-bit instruction" is an instruction that operates on 64-bit numbers.

The image cannot be displayed. Your computer may not have enough memory to open the image, or the image may have been corrupted. Restart your computer, and then open the file again. If the red x still appears, you may have to delete the image and then insert it again.

In the diagram above black boxes are code, white boxes are data, and gray boxes are results. The instruction and code "sizes" are not to be taken literally, since they're intended to convey a general feel for what it means to "widen" a processor from 32 bits to 64 bits. Not all the data either in memory, the cache, or the registers is 64-bit data. Rather, the data sizes are mixed, with 64 bits being the widest. Note that in the 64-bit CPU pictured above, the width of the code stream has not changed; the same-sized opcode could theoretically represent an instruction that operates on 32-bit numbers or an instruction that operates on 64-bit numbers, depending on what the opcode's default data size is. On the other hand, the width of the data stream has doubled. In order to accommodate the wider data stream, the sizes of the processor's registers and the sizes of the internal data paths that feed those registers must be doubled.

Now let's take a look at two programming models, one for a 32-bit processor and another for a 64-bit
The image cannot be displayed. Your computer may not have enough memory to open the image, or the image may have been corrupted. Restart your computer, and then open the file again. If the red x still appears, you may have to delete the image and then insert it again.

The registers in the 64-bit CPU pictured above are twice as wide as those in the 32bit CPU, but the size of the instruction register (IR) that holds the currently executing instruction is the same in both processors. Again, the data stream has doubled in size, but the instruction stream has not. Finally, the program counter (PC) has also doubled in size. For the simple processor pictured above, the two types of data that it can process are integer data and address data. Ultimately, addresses are really just integers that designate a memory address, so address data is just a special type of integer data. Hence, both data types are stored in the GPRs and both integer and address calculations are done by the ALU.

Many modern processors support two additional data types: floating-point data and vector data. Each of these two data types has its own set of registers and its own execution unit(s). The following table compares all four data types in 32-bit and 64-bit processors: Data Type Register Type Integer Address GPR GPR Execution Unit ALU ALU OR AGU Floating Point* Vector VR VPU 128 128 FPR FPU 64 64 32 32 64 64 x86 width x86-64 width

*x87 uses 80-bit registers to do double-precision floating-point. The floats themselves are 64-bit, but the processor converts them to an internal, 80-bit format for increased precision when doing computations.

From the table above that the difference the move to 64 bits makes is in the integer and address hardware. The floating-point and vector hardware stays the same.

Now that we know what 64-bit computing is, let's take a look at the benefits of increased integer and data sizes.

Dynamic range The main thing that a wider integer gives you is increased dynamic range. In the base-10 number system to which we're all accustomed, you can represent a maximum of ten integers (0 to 9) with a single digit. This is because base-10 has ten different symbols with which to represent numbers. To represent more than ten integers you need to add another digit, using a combination of two symbols chosen from among the set of ten to represent any one of 100 integers (00 to 99). The general formula that you can use to compute the number of integers (dynamic range, or DR) that you can represent with an n-digit base-ten number is: DR = 10n So a 1-digit number gives you 101 = 10 possible integers, a 2-digit number 102 = 100 integers, a 3-digit number 103 = 1000 integers, and so on. The base-2, or "binary," number system that computers use has only two symbols with which to represent integers: 0 and 1. Thus, a single-digit binary number allows you to represent only two integers, 0 and 1. With a two-digit (or "2-bit") binary, you can represent four integers by combining the two symbols (0 and 1) in any of the following four ways: 00 = 0 01 = 1 10 = 2 11 = 3

Similarly, a 3-bit binary number gives you eight possible combinations, which you can use to represent eight different integers. As you increase the number of bits, you increase the number of integers you can represent. In general, n bits will allow you to represent 2n integers in binary. So a 4-bit binary number can represent 24 or 16 integers, an 8-bit number gives you 28=256 integers, and so on. So in moving from a 32-bit GPR to a 64-bit GPR, the range of integers that a processor can manipulate goes from 232 = 4.3e9 to 264 = 1.8e19. The dynamic range, then, increases by a factor of 4.3 billion. Thus a 64-bit integer can represent a much larger range of numbers than a 32-bit integer. The benefits of increased dynamic range, Or, how the existing 64-bit computing market uses 64-bit integers? Since addresses are just special-purpose integers, an ALU and register combination that can handle more possible integer values can also handle that many more possible addresses. With all the recent press coverage that 64-bit architectures have garnered, it's fairly common knowledge that a 32-bit processor can address at most 4GB of memory. (Remember our 232 = 4.3 billion number? That 4.3 billion bytes is about 4GB.) A 64-bit architecture could theoretically, by contrast, address up to 18 million terabytes. So, what do you do with over 4GB of memory? Well, caching a very large database in it is a start. Back-end servers for mammoth databases are one place where 64 bits have long been a requirement, so it's no surprise to see upcoming 64-bit offerings billed as capable database platforms.

On the media and content creation side of things, folks who work with very large 2D image files also appreciate the extra RAM. And a related, much interesting application domain where large amounts of memory come in handy is in simulation and modeling. Under this heading you could put various CAD tools and 3D rendering programs, as well as things like weather and scientific simulations, and even real-time 3D games. Though the current crop of 3D games wouldn't benefit from greater than 4GB of RAM, it is quite possible that we'll see a game that benefits from greater than 4GB RAM within the next five years. Some applications, mostly in the realm of scientific computing (MATLAB, Mathematica, MAPLE, etc.) and simulations, require 64-bit integers because they work with numbers outside the dynamic range of 32-bit integers. When the result of a calculation exceeds the range of possible integer values, you get a situation called either overflow (i.e. the result was greater than the highest positive integer) or underflow (i.e. the result was less than the largest negative integer). When this happens, the number you get in the register isn't the right answer. There's a bit in the x86's processor status word that allows you to check to see if an integer has just exceeded the processor's dynamic range, so you know that the result is bogus. Such situations are rare in integer applications. Programmers who run into integer overflow or underflow problems on a 32-bit platform do have the option of using a 64-bit integer construct provided by a higher level language like C. In such cases, the compiler uses two registers per integer, one for each half of the integer, to do 64-bit calculations in 32-bit hardware. This has obvious performance drawbacks, making it less desirable than a true 64-bit integer implementation.

Finally, there is another application domain for which 64-bit integers can offer real benefits: cryptography. Most popular encryption schemes rely on the multiplication and factoring of very large integers and the larger the integers the more secure the encryption. 64-bit integer code runs slowly on a 32-bit machine, due to the fact that the 64-bit computations have to be split apart and processed as two separate 32-bit computations. So you could say that there's a performance penalty for running 64bit integer code on a 32-bit machine; this penalty is absent when running the same code on a 64-bit machine, since the computation doesn't have to be split in two. The take-home point here is that only applications that require and use 64-bit integers will see a performance increase on 64-bit hardware that is due solely to a 64-bit processor's wider registers and increased dynamic range. 64 bit Architectures Lets discuss 64 bit Architectures from the leaders of Processor Manufacturers AMD & Intel (AMDs Opteron & Intels Itanium). Intel 64-bit architecture (IA-64) By using a technique called VLIW, the letters VLIW mean Very Large Instruction Word. Processors that use this technique access the memory by transferring long program words, and in each word many instructions are packed. In the case of the IA-64, three instructions are used for each pack of 128 bits. As each instruction has 41 bits, there are 5 bits left that will be used to indicate the kinds of instruction that were packed. Figure 1 shows the instruction packaging scheme. This packaging lessens the number of memory accesses, leaving to the

compiler the task of grouping the instructions in order to get the best of the architecture.
The image cannot be displayed. Your computer may not have enough memory to open the image, or the image may have been corrupted. Restart your computer, and then open the file again. If the red x still appears, you may have to delete the image and then insert it again.

Instruction packaging used in the IA-64 architecture. As it has already been said, the 5-bit field, named as pointer, serves to indicate the kinds of instructions that are packed. Those 5 bits offer 32 kinds of packaging possible that, in fact, are reduced to 24 kinds, since 8 are not used. Each instruction uses one of the CPU features, which are listed below, and that can be identified in Figure given below. Unit I - integer data Unit F - floating-point operations Unit M - memory access and Unit B - branch prediction. The architecture that Intel suggests to execute those instructions, that was called Itanium, is versatile and promises performance by means of the simultaneous (parallel) execution of up to 6 instructions. Figure shows the diagram in blocks of this architecture that uses a pipeline of 10 stages.

The image cannot be displayed. Your computer may not have enough memory to open the image, or the image may have been corrupted. Restart your computer, and then open the file again. If the red x still appears, you may have to delete the image and then insert it again.

Block diagram of the Itanium CPU (IA-64 architecture).

The basic structural unit of the Itanium looks like the picture above. The data bus can cope according to Intel with a data rate of 2.1GB/sec. The Itanium processor contains 4 integer ALUs, 4 multimedia ALUs, 2 AGUs, 3 branching units and 4

FPUs for arithmetic with floating point numbers. The processor is capable of theoretically performing 20 operations in one clock cycle by loading 16 operands and evaluating 4 ALU operations. This possibility should not be confused with the number of instructions possible within one clock cycle - namely six. The instructions are retrieved from memory and are bundled by a process called bundle rotation; this prepares the execution of parallel instructions on the hardware level. The instructions are fetched from the cache speculatively. All this is implemented with the help of 128 floating point registers, 128 integer registers and 8 branching registers, which all support explicitly 64-bits The IA-64 architecture receives the sigla EPIC, which means Explicit Parallel Instruction Computing. By using this sigla, Intel wants to say that the compiler will be the great responsible for determining and clearing the parallelism present in the instructions to be executed. This is a combination of concepts called speculation, predication and explicit parallelism. Next, we will briefly study each one of them.

Explicit parallelism:
The image cannot be displayed. Your computer may not have enough memory to open the image, or the image may have been corrupted. Restart your computer, and then open the file again. If the red x still appears, you may have to delete the image and then insert it again.

The Instruction Level Parallelism - ILP is the ability of executing multiple instructions at the same time. As we have seen, the IA-64 architecture allows to pack independent instructions to be executed in parallel and, for each clock period, is capable of treating multiple packs. Due to the great number of features in parallel, as well as the great number of registers and multiple executing units, it is possible for the compiler to manage and program the parallel computing. The compilers used for the traditional architectures are limited in their speculative capacity because there is not always a way to be sure if the speculation will be correctly managed by the processor. The IA-64 architecture allows the compiler to

explore the speculative information without sacrificing the correct execution of an application. The IA-64 architecture has mechanisms denominated instruction pointer, suggestions for branches and cache, that allow the compiler to send to the processor information obtained during the time of compilation. That information minimizes the penalties that come from the branches and cache misses. Speculation: Itanium can load instructions and data onto the CPU before they're actually needed or even if they prove not to be needed, effectively using the processor itself as a cache. Presumably, this early loading is done when the processor is otherwise idle. The advantage gained by speculation limits the effects of memory latency by allowing loading of data before it is needed, thus making it ready to go the moment the processor can use it. There are two kinds of speculation: data and control. With the speculation, the compiler advances an operation in a way that its latency (time spent) is removed from the critical way. The speculation is a form of allowing the compiler to avoid that slow operations spoil the parallelism of the instructions. Control speculation is the execution of an operation before the branch that precedes it. On the other hand, data speculation is the execution of a memory load before a storage operation (store) that precedes it and with which it can be related. Speculation Benefits: Reduces impact of memory latency .Reduces impact of memory latency Performance improvement at 79% when combined with predication*.

Greatest improvement to code with many cache accesses large databases and operating systems.ems Scheduling flexibility enables new levels of performance headroom levels of performance headroom Predication: Branch prediction is currently used in today's processors. However, much processor time is taken by doing calculations for branches that end up being unneeded. Predication is a compiler-based technique of looking ahead to make more accurate predictions of which code branches will actually be used, thus limiting unneeded calculations. With the predication you mark with predicates all the branches of the conditional branches that, next, are sent to the execution in parallel, however only the necessary ones are executed. Therefore, it is possible to prepare the execution of the instructions even before having solved the conditional branches. Besides the removal of branches by means of predicates, IA-64 architecture has a series of mechanisms that should reduce the error in predicting the branches and the cost when this error happens. Predication Benefits: Reduces branches and mispredict penalties. Parallel compares further reduce critical paths Parallel compares further reduce itical paths Greatly improves code with hard to predict branches ranches Large server apps- capacity limited .e server apps- capacity limited Sorting, data mining- large database apps .Sorting, data mining- large database apps

Data compression Data compression Traditional architectures bolt-on approach cant efficiently approximate predication. Cmove: 39% more instructions, 30% lower performance.39% m Instructions must all be speculative.

The IA-64 architecture has a great number of registers. There are 128 integer registers, 128 floating-point registers, 64 predicate registers of 1 bit, and many other registers for configuration, management and monitoring of the CPUs performance. Rotating Registers On top of the frames, there's register rotation, a feature that helps loop unrolling more than parameter passing. With rotation, Itanium can shift up to 96 of its general-purpose registers (the first 32 are still fixed and global) by one or more apparent positions. Why? So that iterative loops that hammer on the same register(s) time after time can all be dispatched and executed at once without stepping on each other. Each instance of the loop actually targets different physical registers, allowing them all to be in flight at once.

If this sounds a lot like register renaming, it is. Itanium's register-rotation feature is less generic than all-purpose register renaming like Athlon's, so it's easier to implement and faster to execute. Chip-wide register renaming like Athlon's adds gobs of multiplexers, adders, and routing, one of the big drawbacks of a massively

out-of-order machine. On a smaller scale, ARM used this trick with its ill-fated Piccolo DSP coprocessor. At the high end, Cydrome also used this technique, a favorite feature that Cydrome alumnus and Itanium team member Bob Rau apparently brought with him. So IA-64 has two levels of indirection for its own registers: the logical-to-virtual mapping of the frames and the virtual-to-physical mapping of the rotation. All this means that programs usually aren't accessing the physical registers they think they are, but that's nothing new to high-end microprocessors. Arcane as it seems, this method still uses less hardware trickery than the full register renaming of Athlon, Pentium III, or P4.

Intel promises compatibility with the 32-bit software (IA-32). They should run without any change since the operating system and the firmware have features for that. It should be possible to run software in real mode (16 bits), protected mode (32 bits) and virtual mode 86 (16 bits). They mean that the CPU will be able to operate in IA-64 mode or IA-32 mode. There are special instructions to go from one mode to the other, as it is shown in Figure 3.
The image cannot be displayed. Your computer may not have enough memory to open the image, or the image may have been corrupted. Restart your computer, and then open the file again. If the red x still appears, you may have to delete the image and then insert it again.

Figure 3: Model of instruction sets transition.

The three instructions that make the transition between the instruction sets are: JMPE (IA-32): jumps to a 64-bit instruction and changes to IA-64 mode; br.ia (IA-64): moves to a 32-bit instruction and changes to IA-32 mode; Interruptions transit to IA-64 mode, allowing the fulfillment of all interruption conditions and rfi (IA-64): it is the return of the interruption; the return happens both to an IA32 situation depending on moment invoked.
The image cannot be displayed. Your computer may not have enough memory to open the image, or the image may have been corrupted. Restart your computer, and then open the file again. If the red x still appears, you may have to delete the image and then insert it again.

and to an IA-64, the situation present at the when the interruption is

Athlon 64 and AMD's 64-bit technology

64-bit architecture Introduction: To get a first idea, how the 64-bit architecture works and also how it differs significantly from a 32-bit implementation it is useful to consider one definition first: "A 64-bit processor is a microprocessor with a word size of 64 bits, a requirement for memory and data intensive applications such as computer-aided design (CAD) applications, database management systems, technical and scientific applications, and high-performance servers. 64-bit computer architecture provides higher performance than 32-bit architecture by handling twice as many bits of information in the same clock cycle. The most important parts, which define a 64-bit architecture are boldfaced and give a rough idea that one can now process not only 2^32 = 4294967296 basic units of information, but 2^64 = 18446744073709551616 units. The numbers are quite impressive and show that the architecture level has to be updated accordingly. There are several companies, which actually implemented 64-bit processors, but the two main companies are AMD and Intel. Other enterprises certainly have their place in the development of 64-bit processors, too, but the mainstream market is going to face those products by AMD and Intel. Therefore it is reasonable to explain, how those two companies designed the 64-bit processors and moreover there are only details to consider in translating the two special layouts and implementations to the general concept. There are quite some differences how the two companies chose to convert 32-bit programs to work with the 64-bit architecture and those differences will be outlined in the 32-bit part of this

document, but in the following part the structure of a "pure" 64-bit architectural level will be outlined. As there is not much public information available about the physical structure of current 64-bit processors due to the fact that neither AMD nor Intel want to provide crucial information to the corresponding rival on the processor market it is useful to focus on the instruction set architecture (ISA) and the general differences between a 32-bit processor and the new 64-bit one. With the successful introduction of the Opteron processor, AMD completed one half of its forecast entry into the 64-bit processing world. It is based on an evolution of the x86 instruction set used by current 32-bit processors made by Intel and AMD, the Opteron is targeted at the high to mid-range server and workstation market. The second processor released under the AMD64 architecture will be the Athlon 64, formerly known as 'Claw hammer,' which aims to bring 64-bit computing power to the desktop and mobile markets. The Athlon 64 will be a slightly hobbled version of the Opteron, and with its built in compatibility with current software and operating systems, will attempt to bridge the gap easily between 32-bit and 64-bit computing environments. We will focus on the Athlon 64 and what it will offer to home users and PC enthusiasts, as well as covering the important details of the AMD64 platform. The Opteron and the Athlon 64 share an identical base architecture.

AMD has positioned the Opteron as the solution to many system needs, with the primary goal of providing a 64-bit physical architecture while supplying high-end performance for both 64- and 32-bit software. This translates into architectural

advantages such as 64-bit data and address pathways, upgraded physical and virtual memory addressing, and a true 64-bit internal design. The other main innovation has been to move key Northbridge functions from the system chipset directly into the Opteron core. These include a memory controller, multiprocessing control, and data flow, along with a bridge to peripheral data traffic. Traditional Southbridge and AGP components are still present in the Opteron architecture, but AMD's eighth-generation processor has absconded with the main performance and CPU-centric duties. Opteron Micro architecture The Opteron core resembles the basic design of the Athlon XP, but the move to a 64-bit architecture has brought some inherent advantages. Both the Opteron and Athlon XP contain a few similar features, such as 64K apiece of Level 1 data and instruction cache and three apiece of integer and floating-point units, but there have been some noted improvements elsewhere. In terms of basic features, the Opteron includes a full 1MB of Level 2 cache on the inside, along with an integrated heat spreader and new Socket 940 packaging on the outside.
The image cannot be displayed. Your computer may not have enough memory to open the image, or the image may have been corrupted. Restart your computer, and then open the file again. If the red x still appears, you may have to delete the image and then insert it again.

Looking a bit deeper, AMD has improved on its seventh-generation design in other ways. A processor's registers are like miniature cache areas where crucial data is stored and retrieved; the Opteron features eight more general-purpose registers, and these have been extended to 64 bits. AMD has also added eight 128-bit Streaming SIMD Extension (SSE) registers for multimedia instructions, as well as compatibility with the SSE2 instructions that premiered in Intel's Pentium 4. The chip's transaction look-aside buffers are larger and offer lower latencies than those of the Athlon XP. Branch prediction is also enhanced, including an increase to 16K bimodal/history counters, or four times the level found on the Athlon XP. This last note is important, because in order to provide higher frequencies and better scalability, AMD has extended the Opteron pipelines. The Opteron features a 12-stage integer operation pipeline (versus 10 stages for the Athlon XP) and a 17-stage floating-point operation pipeline (versus 15 for the Athlon XP). While this pays dividends on higher potential clock speeds, it also incurs a risk of increased prediction misses, so AMD has adjusted the architecture to provide even higher pipeline efficiencies than the Athlon XP. The Opteron also has built-in core logic to support multiprocessor systems without the need for a Northbridge chip. Internal CPU data traffic is all routed through a crossbar (XBAR) communications architecture, which shuttles command and data information between the CPU, memory controller, and three HyperTransport links. This is a huge technological leap for multiprocessor workstation and server designs, as it provides a true standard for OEMs to work with, and takes the Northbridge component out of the equation.

Dual-Channel Memory, More Or Less The AMD Opteron includes an integrated memory controller, capable of supporting DDR200 through DDR333 speeds and a maximum of eight DIMM memory modules per processor. The controller provides up to 5.3GB/sec of memory bandwidth (with 333MHz DDR), yielding higher memory performance, lower memory latencies, and performance levels that can scale to processor frequencies. Since each CPU has its own memory controller, memory bandwidth will also scale in multiprocessor systems. For example, a 2-way Opteron workstation will yield 10.6GB/sec of memory bandwidth, while a 4-way Opteron server will double this again to an incredible 21.3GB/sec, along with supporting up to 32 DDR DIMMs. The Opteron's integrated memory controller has been referred to as a dual-channel design, but this isn't the exact truth. It certainly delivers double the bandwidth of a single-channel controller, but does so by taking two 64-bit DDR modules and viewing them as a single 128-bit DIMM with a corresponding 128-bit data path. This is similar to the design of Intel's dual-channel DDR chipsets such as the E7205 and 875P, but different than the true dual-channel memory architecture of the NVIDIA nForce2. This is actually a smart call when it comes to building an integrated memory controller, as for all intents and purposes, the bandwidth and performance are equivalent, but the 128-bit memory bus is more streamlined. In the Opteron architecture, there is no need for an arbiter chip to handle traffic along the dual physical memory channels, and no requirement for extra controller hardware. Of course, due to the "single-channel 128-bit" memory architecture, the pairs of DDR

modules but be matched in size, speed, and chip-count, though not necessarily in manufacturer

Conclusion
With this article and the previous one, that mention the 64-bit architectures by Intel and AMD, we finished to talk about the processors for the beginning of the millennium. In addition, it is important to mention that there already are computers running 64-bit versions of Windows and Linux. Now, more than performance, our biggest concern is the compatibility with our present programs. We really have to verify how much those 64-bit architectures are compatible with our 32- or 16-bit programs. We hope that in less than a year we already have the answer to this question. To finish this part of 64-bit CPUs, it is very good to see how the two companies compete in the market of high performance processors. This grants us access to even cheaper and better computers. To conclude, we would like to comment the great space that there still is to the evolution of electronics and consequently to the evolution of computers. More important than the creation of supercomputers, this new age will see the permeability of the computers. It will be the time of invisible computers. They will be present in nearly all modern devices. At the moment they inhabit our TV sets, microwave ovens, cars, watches, stereos, DVD, etc... In a near future, they will invade the refrigerator, the toaster, the air-conditioner and all everyday appliances. We have gone beyond the cheap electronics age and we are entering the cheap intelligence age.

References

References for this part are basically placed in the appropriate positions - this list gives an overview: - Search390.com: http://search390.techtarget.com/sDefinition/0,,sid10_gci498697,00.html - Hammer Review A1- Electronics: http://www.a1electronics.co.uk/AMD_Section/CPUs/Hammer_Review_pg2.shtml - Article X86-64 Hardware site: http://www.hardwaresite.net/x86-64.html - AMD Developer's Manual X86-64: http://www.amd.com/usen/assets/content_type/white_papers_and_tech_docs/24592.pdf - Article IA-64 Hardware site: http://www.hardwaresite.net/ia64.html - Presentation IA-64: http://www.eg.bucknell.edu/~bsprunt/comp_arch/intel/ia64_tutorial.pdf - Software Developer's Manual Itanium: http://developer.intel.com/design/itanium/manuals/245317.pdf - Hardware Developer's Manual Itanium: http://developer.intel.com/design/itanium/downloads/248701.htm

- AMD Opteron video: http://www.amd.com/usen/assets/content_type/DigitalMedia/AMD_Opteron.wmv - Article 64-bit computing: c't 12/99 page 28 - basic notations, definitons and concepts are taken from "Computer Organization and Design", Hennessey and Patterson