Думаю, вся путаница возникла из-за того, что когда то разработчики Интела (я так думаю) назвали два байта — словом (word) — тогда 16 битные процессоры были прорывом. Соответственно, 4 байта — двойным словом. (DWORD, double word). Это сохранилось и в многих языках программирования (в том числе в с/с++). Почему два байта — слово? да видимо от того, что байт это как буква. А две буквы — это уже слово. (Хотя сейчас прибегут филологи и скажут, что это скорее всего слог, чем слово). В википедии есть хорошая фраза «* Для 32-битных процессоров x86: исторически машинным словом считается 16 бит, реально — 32 бита.»
А вот словосочетание «двойное машинное слово» я никогда не слышал. Даже гугл мало находит статей с таким сочетанием. А вот «двойное слово» или «машинное слово» — это нормально.
То есть как я понимаю если процессор 32-битный он может за один такт принять и обработать с оперативной памяти 32 бита информации
не все так просто. Далеко не факт, что он может даже принять 32 бита. Современные процессоры сложные, имеют кеш. Имеют сложные комманды, которые за один раз (не так, а именно раз) могут обработать до 16 байт памяти (всякие mmx и sse).
Обычно, машинным словом называют «разрядность процессора», так как разрядность обычно показывает оптимальный размер данных внутри процессора (регистры 32битного процессора 32 битные и с 32битными данными в основном все команды и работают). В некоторых процессорах слово было 60 бит:)
В любом случае рекомендую всегда всматриваться в контекст. Если о «слове» говорит программист на С/С++ — это 16 бит, если программист на ассемблере под 32 битные ARM процессоры — то скорее всего слово — это 32 бита.
Is there a more-or-less reliable way (not necessarily perfect) to detect the machine word size of the target architecture for which I’m compiling?
By machine word size I mean the size of the integer accumulator register (e.g. EAX on x86, RAX on x86_64 etc., not streaming extensions, segment or floating-point registers).
The standard does not seem to provide a «machine word» data type. So I’m not looking for a 100% portable way, just something that works in most common cases (Intel x86 Pentium+, ARM, MIPS, PPC — that is, register-based, contemporary commodity processors).
size_t and uintptr_t sound like good candidates (and in practice matched the register size everywhere I tested) but are of course something else and are thus not guaranteed to always do so as is already described in Is size_t the word size.
Context
Let’s assume I’m implementing a hashing loop over a block of contiguous data. It is OK to have the resulting hash depend on the compiler, only speed matters.
Example: http://rextester.com/VSANH87912
Testing on Windows shows that hashing in chunks of 64 bits is faster in 64-bit mode and in 32 bits in 32-bit mode:
64-bit mode
int64: 55 ms
int32: 111 ms
32-bit mode
int64: 252 ms
int32: 158 ms
asked Mar 7, 2016 at 12:08
14
Because the C and C++ languages deliberately abstract away such considerations as the machine word size, it’s unlikely that any method will be 100% reliable. However, there are the various int_fastXX_t types that may help you infer the size. For example, this simple C++ program:
#include <iostream>
#include <cstdint>
#define SHOW(x) std::cout << # x " = " << x << 'n'
int main()
{
SHOW(sizeof(int_fast8_t));
SHOW(sizeof(int_fast16_t));
SHOW(sizeof(int_fast32_t));
SHOW(sizeof(int_fast64_t));
}
produces this result using gcc version 5.3.1 on my 64-bit Linux machine:
sizeof(int_fast8_t) = 1
sizeof(int_fast16_t) = 8
sizeof(int_fast32_t) = 8
sizeof(int_fast64_t) = 8
This suggests that one means to discover the register size might be to look for the largest difference between a required size (e.g. 2 bytes for a 16-bit value) and the corresponding int_fastXX_t size and using the size of the int_fastXX_t as the register size.
Further results
Windows 7, gcc 4.9.3 under Cygwin on 64-bit machine: same as above
Windows 7, Visual Studio 2013 (v 12.0) on 64-bit machine:
sizeof(int_fast8_t) = 1
sizeof(int_fast16_t) = 4
sizeof(int_fast32_t) = 4
sizeof(int_fast64_t) = 8
Linux, gcc 4.6.3 on 32-bit ARM and also Linux, gcc 5.3.1 on 32-bit Atom:
sizeof(int_fast8_t) = 1
sizeof(int_fast16_t) = 4
sizeof(int_fast32_t) = 4
sizeof(int_fast64_t) = 8
answered Mar 7, 2016 at 13:56
EdwardEdward
6,8952 gold badges29 silver badges55 bronze badges
9
I think you want
sizeof(size_t) which is supposed to be the size of an index. ie. ar[index]
32 bit machine
char 1
int 4
long 4
long long 8
size_t 4
64 bit machine
char 1
int 4
long 8
long long 8
size_t 8
It may be more complicated because 32 bit compilers run on 64 bit machines. Their output 32 even though the machine is capable of more.
I added windows compilers below
Visual Studio 2012 compiled win32
char 1
int 4
long 4
long long 8
size_t 4
Visual Studio 2012 compiled x64
char 1
int 4
long 4
long long 8
size_t 8
answered Mar 7, 2016 at 14:01
Robert JacobsRobert Jacobs
3,2461 gold badge19 silver badges30 bronze badges
7
Even in machine architecture a word may be multiple things. AFAIK you have different hardware related quantities:
- character: generally speaking it is the smallest element that can be exchanged to or from memory — it is now almost everywhere 8 bits but used to be 6 on some older architectures (CDC in the early 80s)
- integer: an integer register (e.g.EAX on a x86). IMHO an acceptable approximation is
sizeof(int) - address: what can be addressed on the architecture. IMHO an acceptable approximation is
sizeof(uintptr_t) - not speaking of floating points…
Let’s do some history:
Machine class | character | integer | address
-----------------------------------------------------------
old CDC | 6 bits | 60 bits | ?
8086 | 8 bits | 16 bits | 2x16 bits(*)
80x86 (x >= 3) | 8 bits | 32 bits | 32 bits
64bits machines | 8 bits | 32 bits | 64 bits
| | |
general case(**) | 8 bits | sizeof(int) | sizeof(uintptr_t)
(*) it was a special addressing mode where the high word was shifted by only 8 bits to produce a 20 bits address — but far pointers used to bit 32bits long
(**) uintptr_t does not make much sense on old architecture because the compilers (when they existed) did not support that type. But if a decent compiler was ported on them, I assume that the values would be that.
But BEWARE: the types are defined by the compiler, not the architecture. That means that if you found an 8 bits compiler on a 64 machine, you would probably get sizeof(int) = 16 and sizeof(uintptr_t) = 16. So the above only make sense if you use a compiler adapted to the architecture…
answered Mar 7, 2016 at 14:27
Serge BallestaSerge Ballesta
143k11 gold badges122 silver badges248 bronze badges
2
I’ll give you the right answer to the question you should be asking:
Q: How do I choose the fastest hash routine for a particular machine if I don’t have to use a particular one and it doesn’t have to be the same except within a single build (or maybe run) of an application?
A: Implement a parametrized hashing routine, possibly using a variety of primitives including SIMD instructions. On a given piece of hardware, some set of these will work and you will want to enumerate that set using some combination of compile time #ifdefs and dynamic CPU feature detection. (E.g. you can’t use AVX2 on any ARM processor, determined at compile time, and you can’t use it on older x86, determined by the cpuinfo instruction.) Take the set that works and time them on test data on the machines of interest. Either do so dynamically at system/application startup or test as many cases as you can and hardcode which routine to use on which system based on some sniffing algorithm. (E.g. the Linux kernel does this to determine the fastest memcpy routine, etc.)
The circumstances under which you need the hash to be consistent will be application dependent. If you need the choice to be entirely at compile time, then you’ll need to craft a set of preprocessor macros the compiler defines. Often it is possible to have multiple implementations that produce the same hash but using different hardware approaches for different sizes.
Skipping SIMD is probably not a good idea if you are defining a new hash and want it to be really fast, though it may be possible in some applications to saturate the memory speed without using SIMD so it doesn’t matter.
If all of that sounds like too much work, use size_t as the accumulator size. Or use the largest size for which std::atomic tells you the type is lock free. See: std::atomic_is_lock_free, std::atomic::is_lock_free, or std::atomic::is_always_lock_free.
Toby Speight
26.5k47 gold badges66 silver badges99 bronze badges
answered Jan 12, 2018 at 4:24
Zalman SternZalman Stern
3,16111 silver badges18 bronze badges
By «machine word size» we’ll have to assume that the meaning is: the largest size of a piece of data that the CPU can process in a single instruction. (Sometimes called data bus width although that’s a simplicifaction.)
On various CPU:s, size_t, uintptr_t and ptrdiff_t could be anything — these are related to the address bus width, rather than the CPU data width. So we can forget about these types, they don’t tell us anything.
On all mainstream CPU:s, char is always 8 bits, short is always 16 bits and long long is always 64 bits. So the only interesting types remaining are int and long.
The following mainstream CPU:s do exist:
8 bits
int = 16 bits
long = 32 bits
16 bits
int = 16 bits
long = 32 bits
32 bits
int = 32 bits
long = 32 bits
64 bits
int = 32 bits
long = 32 bits
Unconventional variations to the above may exist, but generally there’s no telling from the above how to distinguish 8-bit from 16-bit or 32-bit from 64-bit.
Alignment is no help to us either, because it may or may not apply to various CPU:s. Many CPU:s can read misaligned words just fine, but at the expensive of slower code.
So there is no way to tell the «machine word size» by using standard C.
It is however possible to write fully portable C that can run on anything between 8 and 64 bits, by using the types from stdint.h, notably the uint_fast types. Some things to keep in mind are:
- Implicit integer promotions across different systems. Anything of
uint32_tor larger is generally safe and portable. - The default type of integer constants («literals»). This is most often (but not always)
int, and what anintis on a given system may vary. - Alignment and struct/union padding.
- Pointer size is not necessarily the same as machine word size. Particularly true on many 8, 16 and 64 bit computers.
answered Jan 23, 2018 at 15:50
LundinLundin
191k39 gold badges251 silver badges392 bronze badges
Choose sizeof(int *) * CHAR_BIT to get machine architecture size in bits.
The reason is that architecture may be segmented, size_t gives max size for a single object (which might be what you want, but not the same thing as the machine’s architecture natural bit size). If CHAR_BIT is 8 but underlying bytes not 8 bits, character and void pointers may have extra bits to allow them to address 8 bit units. int * most unlikely to have such padding. CHAR_BIT may not be 8, however.
answered Jan 30, 2017 at 10:30
Malcolm McLeanMalcolm McLean
6,2281 gold badge17 silver badges18 bronze badges
3
Данными принято
называть информацию, вводимую в компьютер
и выводимую из него.
Введенные в ЭВМ
данные помещаются в запоминающее
устройство. Следует отметить, что
независимо от содержания информации,
типа ее носителя и вида устройства ввода
(вывода), данные записываются в память
в одной и той же форме, а именно в виде
последовательности нулей и единиц.
Память машины
разбита на ячейки. В ячейке может хранится
любая последовательность двоичных цифр
фиксированной длины. Эту последовательность
принято называть машинным словом. Длина
машинного слова определяется конструкцией
ЭВМ. Будем считать, что ячейка ЭВМ хранит
машинные слова, состоящие из 32 двоичных
символов.
Двоичную цифру,
стоящую на каком-либо фиксированном
месте (03
i
1) слова, называют i-м
разрядом ячейки.
В качестве машинного
слова могут быть:
-
числа, участвующие
в вычислениях; -
символы, над
которыми производятся какие-либо
действия; -
инструкции самой
ЭВМ, составляющие программу решения
некоторой задачи.
Представление в
ЭВМ числовых данных. В математике широко
используются две формы записи чисел:
естественная и нормальная.
При естественной
форме число записывается в естественном
натуральном виде, например: 15 698-целое
число, 0,005786-правильная дробь,
4,45336-неправильная дробь.
При нормальной
форме запись одного числа может быть
различной в зависимости от ограничений,
накладываемых на ее форму. Например,
число 12560 может быть записано так:
12560=1,256*10=0,1256*10=125 600*10 и т.д.
Представление
чисел с фиксированной запятой. Ячейка
памяти ЭВМ, содержащая число с фиксированной
запятой, имеет знаковый и цифровые
разряды. Разряды ячейки нумеруются, как
правило, слева направо, причем каждому
разряду ячейки соответствует один и
тот же разряд числа.
Если мы говорим,
что ЭВМ умеет выполнять действия над
числами с фиксированной запятой, то это
означает, что на этапе конструирования
машины было определено, сколько и какие
разряды машинного слова отведены под
изображение целой и дробной частей
числа. Другими словами, в представлении
числа зафиксировано место запятой,
отделяющей целую часть от дробной.
Например, если для
изображения целой части числа отведено
10 двоичных знаков, а дробная часть
изображается 13 двоичными знаками (один
символ отводится для изображения знака
числа, например знаку «+» cоответствует
0, знаку «-» — единица), то число
11.2510=1011.012
запишется в виде машинного слова,
представленного на рис.1.
Рис. 1. Формат числа
с фиксированной запятой.
Можно условиться,
что под изображение целой части числа
отводятся разряды с 1 по 31 включительно,
тогда в ячейке памяти будут храниться
только целые числа. Легко видеть, что
максимальному по модулю целому числу
соответствует машинное слово, содержащее
единицы в разрядах 1-31.
Выполнение
арифметических операций над числами,
представленными в форме с фиксированной
запятой, реализуются достаточно просто,
так как запятая, отделяющая дробную и
целую части, находится у операндов на
одном и том же месте. Следовательно, для
получения результата достаточно
осуществить поразрядно действия,
определяемые видом выполняемой операции.
Простота реализации
операций — главное достоинство
представления чисел в форме с фиксированной
запятой. Однако такая форма представления
чисел имеет и существенный недостаток,
заключающийся в ограниченном диапазоне
чисел, с которыми ЭВМ может работать.
Действительно,
если ячейка ЭВМ имеет 32 разряда и запятая,
отделяющая целую часть от дробной,
находится после 16-го разряда, то
максимальное по абсолютной величине
число, которое можно записать в ячейку
памяти, имеет вид ()
1111111111111111,1111111111111112
, т.е. не
превышает 6553610.
Наименьшее же по абсолютной величине
отличное от нуля число равно
0000000000000000,0000000000000012
. Очевидно,
что оно соответствует десятичному числу
1*2-14
. Таким образом, в нашем примере, в 32-х
разрядную ячейку памяти ЭВМ с фиксированной
запятой можно записать любое число k,
такое, что
1*2-14
k
65536.
Как видно, диапазон
изменения числа не так уж велик, что
создает значительные трудности при
решении многих вычислительных задач,
так как любое число, меньшее по абсолютной
величине, чем левая граница допустимого
диапазона, представляется в ЭВМ нулями,
а число большее, чем правая граница
диапазона, будет представлено числом
не имеющим ничего общего с исходным.
Представление
чисел с плавающей запятой. Такое
представление основано на том, что любое
число k0
в системе счисления с основанием Q
имеет вид
k=(M)Qp,
где M
— правильная положительная дробь,
называемая мантиссой числа k;
p
— целое число, называемое порядком числа
k.
Представление числа в таком виде не
является единственным. Например,
десятичное число 136 можно записать
следующим образом:
13610=13.6*101=1.36*102=0.136*103=0.0136*104=…
Для выделения
одного-единственного вида записи числа
с плавающей запятой наложим следующее
ограничение. Пуст в первом разряде
мантиссы стоит отличная от нуля цифра,
т.е. 1/k
M
1. Такое представление числа k
называется нормализованным. Очевидно,
что число k=136
в нормализованном виде выглядит так:
k=0.125*103
Здесь мантисса
равна 0.136, а порядок равен 3. Все другие
записи этого числа являются
ненормализованными.
Так например, число
710=10111*0.111
запишется в ячейке ЭВМ в виде машинного
слова длиной в 32 разряда в формате числа
с плавающей запятой следующим образом
(см рис.2).
Рис. 2. Формат числа
с плавающей запятой.
Очевидно, что режим
с плавающей запятой обеспечивает более
широкий диапазон представления чисел
в ЭВМ. Заметим, что если в результате
каких-либо действий получим число,
порядок которого превышает максимально
возможный, то такое число воспринимается
как нуль.
В качестве
недостатков такого способа представления
чисел по сравнению с представлением
чисел с фиксированной запятой следует
отметить увеличение количества символов
для изображения числа (для изображения
мантиссы, порядка и знака порядка, знака
числа), а также в связи с этим усложнение
процесса выполнения арифметических
операций.
Мы рассмотрели
два способа представления чисел, отметили
достоинства и недостатки каждого из
них. Следует подчеркнуть тот факт, что
в современных компьютерах применяются
как правило, обе эти формы представления
чисел.
Представление
символов. Наряду с числами в качестве
данных могут выступать и всевозможные
символы. К символам относятся, например,
буквы русского и латинского алфавитов,
цифры, специальные символы (скобки,
кавычки, знаки препинания и др.). Каждому
символу ставится в соответствие вполне
определенный код — целое число. Таблица
соответствия символов кодам хранится
в памяти ЭВМ, а операции сопоставления
символов и цифровых кодов осуществляются
автоматически по специальным программам.
Так как машинное
слово в рассматриваемом нами случае
состоит из 32 разрядов, то максимальное
количество различных символов кодируемых
в одной ячейке памяти равно 232
. Такое количество различных символов
вряд ли необходимо. На практике обычно
для изображения одного символа отводят
8 разрядов машинного слова (один байт).
В этом случае мы можем иметь 28=256
различных символов. Этого вполне
достаточно для решения практических
задач. В одной ячейке машинного слова
хранится при этом несколько символов.
Представление
команд. В памяти ЭВМ хранятся не только
числа, символы, но и тексты программ
решения задач. Программа состоит их
набора отдельных команд. Команда
определяет действия ЭВМ на каждом шаге
ее работы. Следовательно, она должна
содержать информацию о том, над какими
объектами (операндами) и какие операции
должна выполнить машина, что нужно
сделать с полученным результатом, а
также определить следующую для исполнения
команду.
В ЭВМ вся эта
информация представлена машинным словом
— последовательностью двоичных цифр,
расположенных в ячейке памяти. Для того,
чтобы ЭВМ могла из последовательности
цифр извлечь необходимую для работы
информацию, в ее конструкции предусмотрена
возможность анализа определенных групп
цифр в такой записи. Каждая группа цифр
несет соответствующую информацию: одна
указывает вид операции, другая дает
информацию об операндах данной операции
(например указывает их адреса в памяти
ЭВМ).
Каждой операции,
которую может выполнять данная ЭВМ,
присваивается так называемый код
операции — некоторое целое число.
Соответствие операции и кода устанавливается
с помощью специальной таблицы, хранимой
в памяти ЭВМ, причем делается это
автоматически самой машиной.
Для изображения
кода операции в машинном слове отводятся
определенные разряды, например с 0 до
7, как это представлено на рис.3. Остальные
разряды, с 8 по 31, составляют так называемую
адресную часть, в которой находятся
адреса операндов, участвующих в операции.
В процессе работы ЭВМ извлекает слово
из ячейки памяти, расшифровывает его и
включает выполнение соответствующей
команды.
Рис. 3.
Формат
представления команд.
Следует
еще раз подчеркнуть, что информация,
независимо от ее содержания, представляется
в памяти в виде машинных слов, т.е.
последовательности нулей и единиц. По
виду машинного слова невозможно
определить, что это — число или команда.
Более того, одна и та же последовательность
цифр может выступать и как число, и как
некоторая команда. Все зависит от того,
куда данное машинное слово попадает в
процессе работы ЭВМ. Если оно попадает
в арифметическое устройство, то
рассматривается как операнд некоторой
операции, а если в устройство управления
машины, то расшифровывается как
соответствующая команда ЭВМ.
Соседние файлы в предмете [НЕСОРТИРОВАННОЕ]
- #
- #
- #
- #
- #
- #
- #
- #
- #
- #
- #
У этого термина существуют и другие значения, см. Слово (значения).
Машинное слово — машинно-зависимая и платформозависимая величина, измеряемая в битах или байтах (тритах или трайтах), равная разрядности регистров процессора и/или разрядности шины данных (обычно некоторая степень двойки). На ранних компьютерах размер слова совпадал также с минимальным размером адресуемой информации (разрядностью данных, расположенных по одному адресу); на современных компьютерах минимальным адресуемым блоком информации обычно является байт, а слово состоит из нескольких байтов. Машинное слово определяет следующие характеристики аппаратной платформы:
- разрядность данных, обрабатываемых процессором;
- разрядность адресуемых данных (разрядность шины данных);
- максимальное значение беззнакового целого типа, напрямую поддерживаемого процессором: если результат арифметической операции превосходит это значение, то происходит переполнение;
- максимальный объём оперативной памяти, напрямую адресуемой процессором.
Размер машинного слова на различных архитектурах[править | править вики-текст]
На ранних компьютерах встречалась самая разная длина слова. В те времена компьютеры делились на бизнес-ориентированные и научные. В бизнес-ориентированных компьютерах, занимавшихся экономическими и бухгалтерскими расчетами, не требовалась высокая точность вычислений, так как суммы всегда округлялись лишь до двух знаков после запятой. В научных же вычислениях наиболее часто проводятся операции с вещественными числами, и точность вычислений с большим количеством знаков после запятой очень важна. Так как модули памяти в ранних компьютерах стоили дорого, выбор размера слова напрямую отражался как на точности вычислений, которые мог выдавать компьютер, так и на его стоимости. 48-битное слово в научных компьютерах пользовалось большой популярностью[1], потому что 32-битное слово позволяло выразить вещественные числа с 6-7-ю знаками после запятой, что было недостаточно из-за накопления ошибки округления при больших расчетах, а 64-битное слово с 15-16 знаками после запятой выходило далеко за рамки требований к точности. 48-битное слово позволяло выразить вещественное число с 10-ю знаками после запятой, в самый раз для уровня научных вычислений того времени.
В 1950-х — 1960-х годах во многих компьютерах, производимых в США, длина слова была кратна шести битам, поскольку там использовалась шестибитная кодировка так как для представления всех цифр и букв английского алфавита достаточно было 6-бит: 64 возможных комбинации позволяли закодировать 32 буквы (в верхнем регистре), 10 цифр и достаточное количество символов пунктуации.
Первой машиной, в которой появилось 64-битное слово, стал суперкомпьютер Cray-1 (1974 г.), так как к тому времени требования к точности вещественных чисел при проведении научных вычислений возросли.
В подавляющем большинстве современных компьютеров длина слова является степенью двойки; при этом используются 8-битные символы.
На ранних компьютерах слово было минимально адресуемой ячейкой памяти; сейчас минимально адресуемой ячейкой памяти является байт, а слово состоит из нескольких байтов. Это приводит к неоднозначному толкованию размера слова. Например, на процессорах 80386 и их потомках «словом» традиционно называют 16 бит (2 байта), хотя эти процессоры могут одновременно обрабатывать и более крупные блоки данных.
Слова длиной 
битов принимают численные (беззнаковые) значения от 0 до 
включительно.
| Год | Архитектура | Размер слова (w), битов |
Размер целого | Размер чисел с плавающей запятой |
Размер инструкции |
|---|---|---|---|---|---|
| 1952 | IBM 701 | 36 | ½w, w | — | ½w |
| 1954 | IBM 704 | 36 | w | w | w |
| 1960 | PDP-1 | 18 | w | — | w |
| 1960 | CDC 1604 | 48 | w | w | ½w |
| 1964 | CDC 6600 | 60 | w | w | ¼w, ½w, w |
| 1965 | IBM 360 | 32 | ½w, w, 1d … 31d |
w, 2w | ½w, w, 1½w |
| 1965 | PDP-8 | 12 | w | — | w |
| 1968 | БЭСМ-6 | 48 | w | w, 2w | ½w |
| 1970 | IBM 370 | 32 | ½w, w, 1d … 31d |
w, 2w, 4w | ½w, w, 1½w |
| 1970 | PDP-11 | 16 | ½w, w | 2w, 4w | w, 2w, 3w |
| 1971 | Intel 4004 | 4 | w, d | — | 2w, 4w |
| 1972 | Intel 8008 | 8 | w, 2d | — | w, 2w, 3w |
| 1974 | Intel 8080 | 8 | w, 2w, 2d | — | w, 2w, 3w |
| 1975 | Cray-1 | 64 | 24 b, w | w | ¼w, ½w |
| 1975 | MOS Tech. 6501 MOS Tech. 6502 |
8 | w, 2d | — | w, 2w, 3w |
| 1976 | Zilog Z80 | 8 | w, 2w, 2d | — | w, 2w, 3w, 4w |
| 1978 (1980) |
Intel 8086 (w/Intel 8087) |
16 | ½w, w, 2d (w, 2w, 4w) |
— (2w, 4w, 5w, 17d) |
½w, w, … 7w |
| 1978 | VAX-11/780 | 32 | ¼w, ½w, w, 1d, … 31d, 1b, … 32b | w, 2w | ¼w, … 14¼w |
| 1979 | Motorola 68000 | 32 | ¼w, ½w, w, 2d | — | ½w, w, … 7½w |
| 1982 (1983) |
Motorola 68020 (w/Motorola 68881) |
32 | ¼w, ½w, w, 2d | — (w, 2w, 2½w) |
½w, w, … 7½w |
| 1985 | ARM1 | 32 | w | — | w |
| 1985 | MIPS32 | 32 | ¼w, ½w, w | w, 2w | w |
| 1989 | Intel 80486 | 16 (32)* | ½w, w, 2w, 2d w, 2w, 4w |
2w, 4w, 5w, 17d | ½w, w, … 7w |
| 1989 | Motorola 68040 | 32 | ¼w, ½w, w, 2d | w, 2w, 2½w | ½w, w, … 7½w |
| 1991 | MIPS64 | 64 | ¼w, ½w, w | w, 2w | w |
| 1991 | PowerPC | 32 | ¼w, ½w, w | w, 2w | w |
| 1992 | SPARC v8 | 32 | ¼w, ½w, w | w, 2w | w |
| 1994 | SPARC v9 | 64 | ¼w, ½w, w | w, 2w | w |
| 2000 | Itanium (IA-64) | 64 | 8 b, ¼w, ½w, w | ½w, w | 41 b |
| 2002 | XScale | 32 | w | w, 2w | ½w, w |
Обозначения: b — бит (двоичная цифра), d — децит (десятичная цифра), w — размер машинного слова, n — переменное значение.
* Для 32-битных процессоров x86: исторически машинным словом считается 16 бит, реально — 32 бита.
См. также[править | править вики-текст]
- Порядок байтов
- Регистр процессора
- Единицы измерения информации
Примечания[править | править вики-текст]
- ↑ Real Machines with 24-bit and 48-bit words
Ссылки[править | править вики-текст]
- Real Machines with 24-bit and 48-bit words сравнение различных компьютеров с 48-и разрядным словом
- Real Machines with 16, 32, and 30-bit words сравнение различных компьютеров с 16-, 32- и 30-и разрядным словом
 Единицы измерения информации |
|
|---|---|
| Базовые единицы | Бит · Байт · Кубит |
| Связанные единицы | Ниббл · Слово · Октет |
| Традиционные битовые единицы | Килобит · Мегабит · Гигабит · Терабит · Петабит · Эксабит · Зеттабит · Йоттабит |
| Традиционные байтовые единицы | Килобайт · Мегабайт · Гигабайт · Терабайт · Петабайт · Эксабайт · Зеттабайт · Йоттабайт |
| Битовые единицы МЭК (IEC) | Кибибит · Мебибит · Гибибит · Тебибит · Пебибит · Эксбибит · Зебибит · Йобибит |
| Байтовые единицы МЭК (IEC) | Кибибайт · Мебибайт · Гибибайт · Тебибайт · Пебибайт · Эксбибайт · Зебибайт · Йобибайт |
| Типы данных |
|
|---|---|
| Неинтерпретируемые |
Бит • Ниббл • Байт • Кубит • Трит • Трайт • Слово |
| Числовые |
Целый • С фиксированной запятой • С плавающей запятой • Рациональный • Комплексный • Длинный • Интервальный |
| Текстовые |
Символьный • Строковый |
| Ссылочные |
Адрес • Ссылка • Ссылка в С++ • Указатель |
| Композитные |
Алгебраический тип данных (обобщённый) • Массив • Ассоциативный массив • Класс • Список • Кортеж • Объект • Структура • Множество • Объединение (меченое) |
| Другие |
Логический • Низший • Высший • Перечисляемый • Коллекция • Исключение • Функциональный • Род (Метакласс) • Монада • Семафор • Поток • Void |
| Связанные темы |
Абстрактный тип данных • Примитивный тип • Структура данных • Дженерик • Переменная типа • Интерфейс • Конструктор данных • Конструктор типов • Приведение типа • Система типов |
dddd66
+20
Решено
5 лет назад
Информатика
10 — 11 классы
FF– шестнадцатеричный адрес последнего машинного слова оперативной памяти компьютера, объем которой составляет ½ Кбайт. Найти длину машинного слова (в байтах).
Смотреть ответ
1
Ответ проверен экспертом
4
(4 оценки)
5
ludmilagena
5 лет назад
Светило науки — 2517 ответов — 10637 раз оказано помощи
1) FF (16cc) =16*15+15=255
255+1=256 — количество слов
2) 1/2 Кбайт =512 байт — объём памяти в байтах
3) 512:256 = 2 байта — длина машинного слова
ответ 2 байта
(4 оценки)
https://vashotvet.com/task/4108729