|
Processors Only
In computer architecture, 64-bit integers, memory addresses, or other data units are those that are at most 64 bits (8 bytes) wide. Also, 64-bit CPU and ALU architectures are those that are based on registers, address buses, or data buses of that size. more...
Home
Car Alarms & Security
Car Amplifiers
Car Audio In-Dash Units
Car CD Changers
Car Electronics
Car Electronics Parts &...
Car GPS Devices
Car Installation Products
Car Portable Appliances
Car Radar, Laser Detectors
Car Signal Processors
Combination Signal...
Crossovers Only
Equalizers Only
Processors Only
Car Speakers & Speaker...
Car Subwoofers & Enclosures
Car Video & Navigation
Other Car Electronics
Wholesale Car Audio Lots
64-bit CPUs have existed in supercomputers since the 1960s and in RISC-based workstations and servers since the early 1990s. In 2003 they were introduced to the (previously 32-bit) mainstream personal computer arena, in the form of the x86-64 and 64-bit PowerPC processor architectures.
A CPU that is 64-bit internally might have external data buses or address buses with a different size, either larger or smaller; the term "64-bit" is often used to describe the size of these buses as well. For instance, many current machines with 32-bit processors use 64-bit buses (e.g. the original Pentium and later CPUs), and may occasionally be referred to as "64-bit" for this reason. Likewise, some 16-bit processors (for instance, the MC68000) were referred to as 16-/32-bit processors as they had 16-bit busses, but had some internal 32-bit capabilities. The term may also refer to the size of an instruction in the computer's instruction set or to any other item of data (e.g. 64-bit double-precision floating-point quantities are common). Without further qualification, "64-bit" computer architecture generally has integer registers that are 64 bits wide, which allows it to support (both internally and externally) 64-bit "chunks" of integer data.
Architectural implications
Registers in a processor are generally divided into three groups: integer, floating point, and other. In all common general purpose processors, only the integer registers are capable of storing pointer values (that is, an address of some data in memory). The non-integer registers cannot be used to store pointers for the purpose of reading or writing to memory, and therefore cannot be used to bypass any memory restrictions imposed by the size of the integer registers.
Nearly all common general purpose processors (with the notable exception of most ARM and 32-bit MIPS implementations) have integrated floating point hardware, which may or may not use 64-bit registers to hold data for processing. For example, the x86 architecture includes the x87 floating-point instructions which use 8 80-bit registers in a stack configuration; later revisions of x86, and the x86-64 architecture, also include SSE instructions, which use 8 128-bit wide registers (16 registers in x86-64). By contrast, the 64-bit Alpha family of processors defines 32 64-bit wide floating point registers in addition to its 32 64-bit wide integer registers.
Memory limitations
Most CPUs are currently (as of 2005) designed so that the contents of a single integer register can store the address (location) of any datum in the computer's virtual memory. Therefore, the total number of addresses in the virtual memory — the total amount of data the computer can keep in its working area — is determined by the width of these registers. Beginning in the 1960s with the IBM System/360, then (amongst many others) the DEC VAX minicomputer in the 1970s, and then with the Intel 80386 in the mid-1980s, a de facto consensus developed that 32 bits was a convenient register size. A 32-bit register meant that 232 addresses, or 4 gigabytes of RAM, could be referenced. At the time these architectures were devised, 4 gigabytes of memory was so far beyond the typical quantities available in installations that this was considered to be enough "headroom" for addressing. 4-gigabyte addresses were considered an appropriate size to work with for another important reason: 4 billion integers are enough to assign unique references to most physically countable things in applications like databases.
Read more at Wikipedia.org
|
|