Editing 64-bit computing (section)

== 64-bit applications ==
=== 32-bit vs 64-bit ===
A change from a [[32-bit computing|32-bit]] to a 64-bit architecture is a fundamental alteration, as most [[operating system]]s must be extensively modified to take advantage of the new architecture, because that software has to manage the actual memory addressing hardware.<ref>{{cite journal |title=The Long Road to 64 Bits |date=October 2006 |volume=4 |issue=8 |pages=85–94|first=John |last=Mashey |journal=ACM Queue|doi=10.1145/1165754.1165766 |doi-access=free}}</ref> Other software must also be [[Porting|ported]] to use the new abilities; older 32-bit software may be supported either by virtue of the 64-bit instruction set being a superset of the 32-bit instruction set, so that processors that support the 64-bit instruction set can also run code for the 32-bit instruction set, or through software [[emulator|emulation]], or by the actual implementation of a 32-bit processor core within the 64-bit processor, as with some [[Itanium]] processors from Intel, which included an [[IA-32]] processor core to run 32-bit [[x86]] applications. The operating systems for those 64-bit architectures generally support both 32-bit and 64-bit applications.<ref>{{cite web |title=Windows 7: 64 bit vs 32 bit? |date=2 April 2009 |url=https://www.w7forums.com/threads/windows-7-64-bit-vs-32-bit.484/ |url-status=live |archive-url=https://web.archive.org/web/20090405053428/https://www.w7forums.com/windows-7-64-bit-vs-32-bit-t484.html |archive-date=5 April 2009 |access-date=2009-04-05 |publisher=W7 Forums}}</ref>

One significant exception to this is the [[IBM AS/400]], software for which is compiled into a virtual [[instruction set architecture]] (ISA) called ''Technology Independent Machine Interface'' (TIMI); TIMI code is then translated to native machine code by low-level software before being executed. The translation software is all that must be rewritten to move the full OS and all software to a new platform, as when IBM transitioned the native instruction set for AS/400 from the older 32/48-bit ''IMPI'' to the newer 64-bit ''PowerPC-AS'', codenamed ''Amazon''. The IMPI instruction set was quite different from even 32-bit PowerPC, so this transition was even bigger than moving a given instruction set from 32 to 64 bits.

On 64-bit hardware with [[x86-64]] architecture (AMD64), most 32-bit operating systems and applications can run with no compatibility issues. While the larger address space of 64-bit architectures makes working with large data sets in applications such as [[digital video]], scientific computing, and large [[database]]s easier, there has been considerable debate on whether they or their 32-bit [[compatibility mode]]s will be faster than comparably priced 32-bit systems for other tasks.

A compiled Java program can run on a 32- or 64-bit Java virtual machine with no modification. The lengths and precision of all the built-in types, such as <code>char</code>, <code>short</code>, <code>int</code>, <code>long</code>, <code>float</code>, and <code>double</code>, and the types that can be used as array indices, are specified by the standard and are not dependent on the underlying architecture. Java programs that run on a 64-bit Java virtual machine have access to a larger address space.<ref>{{cite web
| title= Frequently Asked Questions About the Java HotSpot VM
| publisher=Oracle
| url=https://www.oracle.com/java/technologies/hotspotfaq.html
| access-date= 2024-12-13}}</ref>

Speed is not the only factor to consider in comparing 32-bit and 64-bit processors. Applications such as multi-tasking, stress testing, and clustering – for [[high-performance computing]] (HPC) – may be more suited to a 64-bit architecture when deployed appropriately. For this reason, 64-bit clusters have been widely deployed in large organizations, such as IBM, HP, and Microsoft.

'''Summary:'''

*A 64-bit processor performs best with 64-bit software.
*A 64-bit processor may have [[backward compatibility]], allowing it to run 32-bit application software for the 32-bit version of its instruction set, and may also support running 32-bit operating systems for the 32-bit version of its instruction set.
*A 32-bit processor is incompatible with 64-bit software.

=== Pros and cons ===
A common misconception is that 64-bit architectures are no better than 32-bit architectures unless the computer has more than 4&nbsp;GB of [[random-access memory]].<ref>{{cite web|title=A description of the differences between 32-bit versions of Windows Vista and 64-bit versions of Windows Vista|url=https://support.microsoft.com/kb/946765|access-date=2011-10-14|archive-url=https://web.archive.org/web/20111015085813/https://support.microsoft.com/kb/946765|archive-date=2011-10-15|url-status=dead}}</ref> This is not entirely true:

* Some operating systems and certain hardware configurations limit the physical memory space to 3&nbsp;GB on [[IA-32]] systems, due to much of the 3–4&nbsp;GB region being reserved for hardware addressing; see [[3 GB barrier]]; 64-bit architectures can address far more than 4&nbsp;GB. However, IA-32 processors from the [[Pentium Pro]] onward allow a 36-bit ''physical'' memory address space, using [[Physical Address Extension]] (PAE), which gives a 64&nbsp;GB physical address range, of which up to 62&nbsp;GB may be used by main memory; operating systems that support PAE may not be limited to 4&nbsp;GB of physical memory, even on IA-32 processors. However, drivers and other kernel mode software, more so older versions, may be incompatible with PAE; this has been cited as the reason for 32-bit versions of [[Microsoft Windows]] being limited to 4&nbsp;GB of physical RAM<ref name="markr200807">{{cite web|url=https://blogs.technet.microsoft.com/markrussinovich/2008/07/21/pushing-the-limits-of-windows-physical-memory/|title=Pushing the Limits of Windows: Physical Memory|date=2008-07-21|access-date=2017-03-09|author=Mark Russinovich|archive-url=https://web.archive.org/web/20170407050448/https://blogs.technet.microsoft.com/markrussinovich/2008/07/21/pushing-the-limits-of-windows-physical-memory/|archive-date=2017-04-07|url-status=dead}}</ref> (although the validity of this explanation has been disputed<ref name="geoffchappell.com">{{cite web|first=Geoff|last=Chappell|url=http://www.geoffchappell.com/notes/windows/license/memory.htm|title=Licensed Memory in 32-Bit Windows Vista|work=geoffchappell.com|publisher=[[WP:SPS]]|date=2009-01-27|access-date=9 March 2017}}</ref>).
* Some operating systems reserve portions of [[process (computing)|process]] [[address space]] for OS use, effectively reducing the total address space available for mapping memory for user programs. For instance, 32-bit Windows reserves 1 or 2&nbsp;GB (depending on the settings) of the total address space for the kernel, which leaves only 3 or 2&nbsp;GB (respectively) of the address space available for user mode. This limit is much higher on 64-bit operating systems.
* [[Memory-mapped file]]s are becoming more difficult to implement in 32-bit architectures as files of over 4&nbsp;GB become more common; such large files cannot be memory-mapped easily to 32-bit architectures, as only part of the file can be mapped into the address space at a time, and to access such a file by memory mapping, the parts mapped must be swapped into and out of the address space as needed. This is a problem, as memory mapping, if properly implemented by the OS, is one of the most efficient disk-to-memory methods.
* Some 64-bit programs, such as encoders, decoders and encryption software, can benefit greatly from 64-bit registers,{{Citation needed|date=February 2015}} while the performance of other programs, such as 3D graphics-oriented ones, remains unaffected when switching from a 32-bit to a 64-bit environment.{{Citation needed|date=February 2015}}
* Some 64-bit architectures, such as [[x86-64]] and [[AArch64]], support more general-purpose registers than their 32-bit counterparts (although this is not due specifically to the word length). This leads to a significant speed increase for tight loops since the processor does not have to fetch data from the cache or main memory if the data can fit in the available registers.
:Example in [[C (programming language)|C]]:
<syntaxhighlight lang="c">
int a, b, c, d, e;
for (a = 0; a < 100; a++) {
    b = a;
    c = b;
    d = c;
    e = d;
}
</syntaxhighlight>
: This code first creates 5 values: a, b, c, d and e; and then puts them in a loop. During the loop, this code changes the value of b to the value of a, the value of c to the value of b, the value of d to the value of c and the value of e to the value of d. This has the same effect as changing all the values to a.
:If a processor can keep only two or three values or variables in registers, it would need to move some values between memory and registers to be able to process variables d and e also; this is a process that takes many CPU cycles. A processor that can hold all values and variables in registers can loop through them with no need to move data between registers and memory for each iteration. This behavior can easily be compared with virtual memory, although any effects are contingent on the compiler.

The main disadvantage of 64-bit architectures is that, relative to 32-bit architectures, the same data occupies more space in memory (due to longer pointers and possibly other types, and alignment padding). This increases the memory requirements of a given process and can have implications for efficient processor cache use. Maintaining a partial 32-bit model is one way to handle this, and is in general reasonably effective. For example, the [[z/OS]] operating system takes this approach, requiring program code to reside in 31-bit address spaces (the high order bit is not used in address calculation on the underlying hardware platform) while data objects can optionally reside in 64-bit regions. Not all such applications require a large address space or manipulate 64-bit data items, so these applications do not benefit from these features.

=== Software availability ===
x86-based 64-bit systems sometimes lack equivalents of [[software]] that is written for 32-bit architectures. The most severe problem in Microsoft Windows is incompatible [[device driver]]s for obsolete hardware. Most 32-bit application software can run on a 64-bit operating system in a [[compatibility mode]], also termed an [[emulator|emulation]] mode, e.g., Microsoft [[WoW64]] Technology for IA-64 and AMD64. The 64-bit Windows Native Mode<ref>{{cite web |url=https://technet.microsoft.com/en-us/sysinternals/bb897447.aspx |title=Inside Native Applications |publisher=Technet.microsoft.com |date=2006-11-01 |access-date=2010-11-19 |archive-url= https://web.archive.org/web/20101023130328/http://technet.microsoft.com/en-us/sysinternals/bb897447.aspx |archive-date= 23 October 2010 |url-status= live}}</ref> driver environment runs atop 64-bit {{Mono|NTDLL.DLL}}, which cannot call 32-bit Win32 subsystem code (often devices whose actual hardware function is emulated in user mode software, like Winprinters). Because 64-bit drivers for most devices were unavailable until early 2007 (Vista x64), using a 64-bit version of Windows was considered a challenge. However, the trend has since moved toward 64-bit computing, more so as memory prices dropped and the use of more than 4&nbsp;GB of RAM increased. Most manufacturers started to provide both 32-bit and 64-bit drivers for new devices, so unavailability of 64-bit drivers ceased to be a problem. 64-bit drivers were not provided for many older devices, which could consequently not be used in 64-bit systems.

Driver compatibility was less of a problem with open-source drivers, as 32-bit ones could be modified for 64-bit use. Support for hardware made before early 2007, was problematic for open-source platforms,{{Citation needed|date=February 2013}} due to the relatively small number of users.

64-bit versions of Windows cannot run [[16-bit#16-bit application|16-bit software]]. However, most 32-bit applications will work well. 64-bit users are forced to install a [[virtual machine]] of a 16- or 32-bit operating system to run 16-bit applications or use one of the alternatives for [[NTVDM]].<ref>{{cite web|url=https://www.pcworld.com/article/2045345/run-an-old-program-on-a-new-pc.html|title=Run an old program on a new PC|author=Lincoln Spector|date=August 12, 2013}}</ref>

[[Mac OS X Tiger|Mac OS X 10.4]] "Tiger" and [[Mac OS X Leopard|Mac OS X 10.5]] "Leopard" had only a 32-bit kernel, but they can run 64-bit user-mode code on 64-bit processors. [[Mac OS X Snow Leopard|Mac OS X 10.6]] "Snow Leopard" had both 32- and 64-bit kernels, and, on most Macs, used the 32-bit kernel even on 64-bit processors. This allowed those Macs to support 64-bit processes while still supporting 32-bit device drivers; although not 64-bit drivers and performance advantages that can come with them. [[Mac OS X Lion|Mac OS X 10.7]] "Lion" ran with a 64-bit kernel on more Macs, and [[OS X Mountain Lion|OS X 10.8]] "Mountain Lion" and later [[macOS]] releases only have a 64-bit kernel. On systems with 64-bit processors, both the 32- and 64-bit macOS kernels can run 32-bit user-mode code, and all versions of macOS up to macOS Mojave (10.14) include 32-bit versions of libraries that 32-bit applications would use, so 32-bit user-mode software for macOS will run on those systems. The 32-bit versions of libraries have been removed by Apple in macOS Catalina (10.15).

[[Linux]] and most other [[Unix-like]] operating systems, and the [[C (programming language)|C]] and [[C++]] [[toolchain]]s for them, have supported 64-bit processors for many years. Many applications and libraries for those platforms are [[open-source software]], written in C and C++, so that if they are 64-bit-safe, they can be compiled into 64-bit versions. This source-based distribution model, with an emphasis on frequent releases, makes availability of application software for those operating systems less of an issue.