On x86/x64 processors, a byte is 8 bits, and there are 256 possible binary states in 8 bits, 0 thru 255. This is how the OS translates your keyboard key strokes into letters on the screen. When you press the ‘A‘ key, the keyboard sends a binary signal equal to the number 97 to the computer, and the computer prints a lowercase ‘a‘ on the screen. You can confirm this in any Windows text editing software by holding an ALT key, typing 97 on the NUMPAD, then releasing the ALT key. If you replace ’97’ with any number from 0 to 255, you will see the character associated with that number on the system’s character code page printed on the screen.
If a character is 8 bits, or 1 byte, then a WORD must be at least 2 characters, so 16 bits or 2 bytes. Traditionally, you might think of a word as a varying number of characters, but in a computer, everything that is calculable is based on static rules. Besides, a computer doesn’t know what letters and symbols are, it only knows how to count numbers. So, in computer language, if a WORD is equal to 2 characters, then a double-word, or DWORD, is 2 WORDs, which is the same as 4 characters or bytes, which is equal to 32 bits. Furthermore, a quad-word, or QWORD, is 2 DWORDs, same as 4 WORDs, 8 characters, or 64 bits.
Note that these terms are limited in function to the Windows API for developers, but may appear in other circumstances (eg. the Linux dd command uses numerical suffixes to compound byte and block sizes, where c is 1 byte and w is bytes).
16 bits.
Data structures containing such different sized words refer to them as WORD (16 bits/2 bytes), DWORD (32 bits/4 bytes) and QWORD (64 bits/8 bytes) respectively.
Contents
- 1 Is a word 16 or 32 bits?
- 2 Is a word always 32 bits?
- 3 Can a word be 8 bits?
- 4 How many bits are in a name?
- 5 What is 64-bit system?
- 6 What is an 8 bit word?
- 7 What is 64-bit word size?
- 8 How big is a word in 64-bit?
- 9 What is word in C?
- 10 What is a Dataword?
- 11 How many values can 10 bits represent?
- 12 How do you write kilobytes?
- 13 What is a bit in a horse’s mouth?
- 14 How many bits is a letter?
- 15 What is a collection of 8 bits called?
- 16 Is my computer 32 or 64?
- 17 What is meant by 32-bit?
- 18 Do I need 32 or 64-bit?
- 19 What is better 8-bit or 16 bit?
- 20 What does 8-bit 16 bit 32 bit microprocessor mean?
Is a word 16 or 32 bits?
In x86 assembly language WORD , DOUBLEWORD ( DWORD ) and QUADWORD ( QWORD ) are used for 2, 4 and 8 byte sizes, regardless of the machine word size. A word is typically the “native” data size of the CPU. That is, on a 16-bit CPU, a word is 16 bits, on a 32-bit CPU, it’s 32 and so on.
Is a word always 32 bits?
The Intel/AMD instruction set concept of a “Word”, “Doubleword”, etc. In Intel docs, a “Word” (Win32 WORD ) is 16 bits. A “Doubleword” (Win32 DWORD ) is 32 bits. A “Quadword” (Win32 QWORD ) is 64 bits.
Can a word be 8 bits?
An 8-bit word greatly restricts the range of numbers that can be accommodated. But this is usually overcome by using larger words. With 8 bits, the maximum number of values is 256 or 0 through 255.
How many bits are in a name?
Find the 8-bit binary code sequence for each letter of your name, writing it down with a small space between each set of 8 bits. For example, if your name starts with the letter A, your first letter would be 01000001.
What is 64-bit system?
An operating system that is designed to work in a computer that processes 64 bits at a time.A 64-bit operating system will not work in a 32-bit computer, but a 32-bit operating system will run in a 64-bit computer. See 64-bit computing.
What is an 8 bit word?
A byte is eight bits, a word is 2 bytes (16 bits), a doubleword is 4 bytes (32 bits), and a quadword is 8 bytes (64 bits).
What is 64-bit word size?
Bits and Bytes
Each set of 8 bits is called a byte. Two bytes together as in a 16 bit machine make up a word , 32 bit machines are 4 bytes which is a double word and 64 bit machines are 8 bytes which is a quad word.
How big is a word in 64-bit?
8 bytes
Data structures containing such different sized words refer to them as WORD (16 bits/2 bytes), DWORD (32 bits/4 bytes) and QWORD (64 bits/8 bytes) respectively.
What is word in C?
A word is an integer number of bytes for example, one, two, four, or eight. When someone talks about the “n-bits” of a machine, they are generally talking about the machine’s word size. For example, when people say the Pentium is a 32-bit chip, they are referring to its word size, which is 32 bits, or four bytes.
What is a Dataword?
A data word is a standard unit of data. For example, most IBM compatible computers have an eight bit word known as byte. Data, Measurements, Word.
How many values can 10 bits represent?
1024
Binary number representation
| Length of bit string (b) | Number of possible values (N) |
|---|---|
| 8 | 256 |
| 9 | 512 |
| 10 | 1024 |
| … |
How do you write kilobytes?
In the International System of Units (SI) the prefix kilo means 1000 (103); therefore, one kilobyte is 1000 bytes. The unit symbol is kB.
What is a bit in a horse’s mouth?
By definition, a bit is a piece of metal or synthetic material that fits in a horse’s mouth and aids in the communication between the horse and rider.Most horses are worked in a bridle with a bit; however, horse owners who don’t care for bits will use a hackamore, or “bitless” bridle.
How many bits is a letter?
eight bits
Computer manufacturers agreed to use one code called the ASCII (American Standard Code for Information Interchange). ASCII is an 8-bit code. That is, it uses eight bits to represent a letter or a punctuation mark. Eight bits are called a byte.
What is a collection of 8 bits called?
A collection of eight bits is called Byte.
Is my computer 32 or 64?
Click Start, type system in the search box, and then click System Information in the Programs list. When System Summary is selected in the navigation pane, the operating system is displayed as follows: For a 64-bit version operating system: X64-based PC appears for the System Type under Item.
What is meant by 32-bit?
32-bit, in computer systems, refers to the number of bits that can be transmitted or processed in parallel.For microprocessors, it indicates the width of the registers and it can process any data and use memory addresses that are represented in 32-bits.
Do I need 32 or 64-bit?
For most people, 64-bit Windows is today’s standard and you should use it to take advantage of security features, better performance, and increased RAM capability. The only reasons you’d want to stick with 32-bit Windows are: Your computer has a 32-bit processor.
What is better 8-bit or 16 bit?
In terms of color, an 8-bit image can hold 16,000,000 colors, whereas a 16-bit image can hold 28,000,000,000. Note that you can’t just open an 8-bit image in Photoshop and convert it to 16-bit.More bits means bigger file sizes, making images more costly to process and store.
What does 8-bit 16 bit 32 bit microprocessor mean?
The main difference between 8 bit and 16 bit microcontrollers is the width of the data pipe. As you may have already deduced, an 8 bit microcontroller has an 8 bit data pipe while a 16 bit microcontroller has a 16 bit data pipe.A 16 bit number gives you a lot more precision than 8 bit numbers.
View Full Version : How do you pack bits into word in Unity Pro?
DanCrilly
March 7th, 2014, 03:19 PM
How do you pack bits into a word in Unity Pro?
TConnolly
March 7th, 2014, 03:45 PM
Welcome to the forum.
I’m not super familiar with Unity Pro, especially with some of the other languages, but in LL984 language you use MBIT to set a bit in a word, and SENS to read the state of a bit in a word.
Hope that helps.
DanCrilly
March 7th, 2014, 03:57 PM
Thanks for welcome.
Have already got some Modicon answers from this site by Googling, so joined.
New to Modicon, but plenty familiar with AB and GE.
Unfortunately I don’t find any Mask functions in the Unity Pro 4.1 libset, except MASKEVT, «global event mask».
Guess I’ll just give SCADA the Booleans as words, not my preference.
Lare
March 7th, 2014, 04:31 PM
Couple ways:
On variable editor:
(bits0..15/%MW0)
Name___________address____type______Comment
Word_bit0______%MW0.0_____bool______1st bit of word
Word_bit1______%MW0.1_____bool______2nd bit of word
…
Word_bit15_____%MW0.15____bool______15th bit of word
On %MW0 address you can see integer value of bits.
Or you can use alternative: bit_to_word + word_to_int conversion and int_to_word + word_to_bit conversion blocks, if you want use unlocated addresses
Welcome to the forum
DanCrilly
March 8th, 2014, 10:41 AM
So, to set individual bits in a word, in order to optimize transmitting them from PLC to SCADA, I use 16 BYTE_TO_BIT blocks, each using only BYTE_TO_BIT output BIT0:
Byte_0 to BYTE_TO_BIT IN, resulting BYTE_TO_BIT BIT0 to %MW500.0
Byte_1 to BYTE_TO_BIT IN, resulting BYTE_TO_BIT BIT0 to %MW500.1
Byte_2 to BYTE_TO_BIT IN, resulting BYTE_TO_BIT BIT0 to %MW500.2
etc.
lengthy but seems workable, and couldn’t use the direct addressing in a DFB.
(Need direct addressing to ensure contiguous addresses sent to SCADA)
Am assuming this will not write to the non-specified %MW500. bits.
Would love to test it but haven’t got Simulator past «This isn’t a valid PLC Address…» message yet; shutdown all AB RSlinx processes, set Windows Simple TCPIP to enabled.
Lare
March 8th, 2014, 11:46 AM
Can you post screenshot or zipped program of this?
ps.
Do you have 16 different integers with values 0 and 1 and you wan’t change them to 16 bools?
Or only 1 integer and you wan’t change it to individual bits?
DanCrilly
March 8th, 2014, 12:09 PM
I have 16 Booleans (16 bytes in Unity)
that I want to compress into one Integer %M500
I want to put the state of Boolean 0 into %M500.0
Boolean 1 into %M500.1
Boolean 2 into %M500.2
Lare
March 8th, 2014, 12:15 PM
Is fault_bit ebool or bool type variable.
If it is boolean type you can give %M500.0 address directly for it on varable editor window.
If fault bit is ebool and have allready %Mx address, then copy variable with move block to bool type variable (ex. fault_bit_hmi, then give address %M500.0 directly for this new variable on varable editor.)
And if fault_bit is ebool type variale, but don’t have address, easiest way is change variale type to bool and give %M500.0 address directly for it. No need to use conversion blocks for this.
GeoffC
March 9th, 2014, 12:21 AM
Just use the Bit_to_Word instruction. This is a function block with 16 Boolean inputs to 1 word output. Or to go the other way use the Word_to_bit instruction.
I note you said in a a dfb, if this word is an input to the dfb you can directly reference the individual bits, right click on the variable definition of the word (within the dfb) and select bit assign.
DanCrilly
March 10th, 2014, 08:22 AM
that’s exactly what I need. beautiful. thanks.
TConnolly
March 10th, 2014, 11:06 AM
New to Modicon, but plenty familiar with AB and GE.
Good luck with Modicon Dan.
I’m finally getting out of the Modicon world. Retired my last 984 in November. I can’t tell you how happy that made me.
Hopefully we’ll see you around the forum a lot more, lots of expertise and experience here.
Troy.
GeoffC
March 11th, 2014, 02:48 AM
Troy
Modicon has changed significantly from 984 days. It would be nearly 15 years since the 984 days.
The current range is all IEC1131 programming (all languages), tag based, etc etc.
The new M580 is one powerful little beast
suggesting but there are a number of caveats.
The recommended method where a bit is being written too, is to use
individual tags for each bit (i.e. address them to the bit level
such as start bit = n7:20/1). I understand customers may wish to do
it the other way to minimise the tag count. Indeed even when bits
are only being read it is good practice to use individual tags for
each as this results in a more maintainable system (despite
increasing the tag count).
To read a bit from a word the method is to use BITAND as you have
described. The only drawback with this method is the system becomes
less maintainable (i.e. its not exactly self documenting when you
have to refer to some external table to see that the function of
bit 3 is «running» for example). Technically however this method is
perfectly valid.
To write a bit from a word is a three step process known as
read-modify-write (there is no standard function in citect for
this, i.e. you will have to write your own cicode function, an
example is provided below). First read the word into a temporary
variable. Then modify just the bit you are interested in using
BITOR for example. Then write the temporary variable (the whole
word) back to the tag. The drawback of this method is that there is
a possibility that in between reading and writing back, the other
bits in the source tag may change and you could end up overwriting
them with what they used to be. Depending on how your system is
configured this may or may not be a concern.
The reasons for this are that if you configure a tag for an entire
word then the protocol driver is then sending messages to the PLC
to read/write entire words. Thus you need to use the above method
and consider the potential issues. However if you configure a tag
for an individual bit then the protocol driver is sending the
messages to read/write individual bits (i.e. without affecting the
adjacent bits in the same word).
I would expect that the Wonderware system works the same way (i.e.
with the same drawbacks) however I may be wrong in this. For a
system to work differently would require very tight integration
with the particular protocol and this would not be typical of a
system designed to work with controller hardware from multiple
vendors, such as Wonderware or Citect (as opposed to [for example]
RSView, which may or may not have the same issues).
Note: some protocol drivers in Citect use the read-modify-write
method to write bits since the protocols may not natively support
bit writes. Refer to KB Q1445 for a list
of protocols affected.
Example functions:
//
Bits.ci
// Functions for reading and writing individual bits in INT or LONG
variables or Cicode variables
//
// Note: BitWrite and BitToggle do not write to the original tag.
You must copy the return value
// into the desired tag. This allows Citect to use its own blocking
to improve performance,
// since TagRead() and TagWrite() aren’t used.
//
// Write TRUE or FALSE (0 or 1) to any bit (0-31) in an
integer
//
// Example:
// To set bit 31 in Tag1 to 0, use the following command:
// Tag1 = BitWrite(Tag1, 31, 0)
//
INT
FUNCTION
BitWrite(INT
iValue,
INT
iBitno,
INT
bState)
IF bState
= FALSE THEN
RETURN iValue
BITAND
(4294967295
BITXOR
Pow(2,
iBitNo));
ELSE
RETURN iValue
BITOR
Pow(2,
iBitNo);
END
END
//
Toggle any bit (0-31) in an integer
//
// Example:
// To toggle bit 16 in Tag1, use the following command:
// Tag1 = BitToggle(Tag1, 16)
//
INT
FUNCTION
BitToggle(INT
iValue,
INT
iBitNo)
RETURN iValue
BITXOR
Pow(2,
iBitNo);
END
// Read an indivual bit number (0-31) from an integer and
return
// the state (0 or 1)
INT
FUNCTION
BitRead(INT
iValue,
INT
iBitNo)
RETURN (iValue
BITAND
Pow(2,
iBitNo))
<> 0;
END
Word for Microsoft 365 Word 2021 Word 2019 Word 2016 Word 2013 Word 2010 More…Less
Insert a symbol using the keyboard with ASCII or Unicode character codes
Symbols and special characters are either inserted using ASCII or Unicode codes. You can tell which is which when you look up the code for the character.
-
Go to Insert >Symbol > More Symbols.
-
Find the symbol you want.
Tip: The Segoe UI Symbol font has a very large collection of Unicode symbols to choose from.
-
On the bottom right you’ll see Character code and from:. The Character code is what you’ll enter to insert this symbol from the keyboard. The from: field tells you if it’s a Unicode or an ASCII character.
Unicode
ASCII
Inserting Unicode Characters
-
Type the character code where you want to insert the Unicode symbol.
-
Press ALT+X to convert the code to the symbol.
If you’re placing your Unicode character immediately after another character, select just the code before pressing ALT+X.
Tip: If you don’t get the character you expected, make sure you have the correct font selected.
Inserting ASCII Characters
Use the numeric keypad with Num Lock on to type the ASCII numbers, not the numbers across the top of your keyboard.
All ASCII character codes are four digits long. If the code for the character you want is shorter than four digits, add zeros to the beginning to get to 4 digits.
-
Go to Home tab, in the Font group, change the font to Wingdings (or other font set).
-
Press and hold the ALT key and type the character code on the numeric keypad.
-
Change the font back to your previous font after inserting the symbol.
For more character symbols, see the Character Map installed on your computer, ASCII character codes, or Unicode character code charts by script.
|
Glyph |
Code |
Glyph |
Code |
|---|---|---|---|
|
Currency symbols |
|||
|
£ |
ALT+0163 |
¥ |
ALT+0165 |
|
¢ |
ALT+0162 |
$ |
0024+ALT+X |
|
€ |
ALT+0128 |
¤ |
ALT+0164 |
|
Legal symbols |
|||
|
© |
ALT+0169 |
® |
ALT+0174 |
|
§ |
ALT+0167 |
™ |
ALT+0153 |
|
Mathematical symbols |
|||
|
° |
ALT+0176 |
º |
ALT+0186 |
|
√ |
221A+ALT+X |
+ |
ALT+43 |
|
# |
ALT+35 |
µ |
ALT+0181 |
|
< |
ALT+60 |
> |
ALT+62 |
|
% |
ALT+37 |
( |
ALT+40 |
|
[ |
ALT+91 |
) |
ALT+41 |
|
] |
ALT+93 |
∆ |
2206+ALT+X |
|
Fractions |
|||
|
¼ |
ALT+0188 |
½ |
ALT+0189 |
|
¾ |
ALT+0190 |
||
|
Punctuation and dialectic symbols |
|||
|
? |
ALT+63 |
¿ |
ALT+0191 |
|
! |
ALT+33 |
‼ |
203+ALT+X |
|
— |
ALT+45 |
‘ |
ALT+39 |
|
« |
ALT+34 |
, |
ALT+44 |
|
. |
ALT+46 |
| |
ALT+124 |
|
/ |
ALT+47 |
ALT+92 |
|
|
` |
ALT+96 |
^ |
ALT+94 |
|
« |
ALT+0171 |
» |
ALT+0187 |
|
« |
ALT+174 |
» |
ALT+175 |
|
~ |
ALT+126 |
& |
ALT+38 |
|
: |
ALT+58 |
{ |
ALT+123 |
|
; |
ALT+59 |
} |
ALT+125 |
|
Form symbols |
|||
|
□ |
25A1+ALT+X |
√ |
221A+ALT+X |
For a complete list of the glyphs and their character codes, see the Character Map.
|
Glyph |
Code |
Glyph |
Code |
|
|---|---|---|---|---|
|
à |
ALT+0195 |
å |
ALT+0229 |
|
|
Å |
ALT+143 |
å |
ALT+134 |
|
|
Ä |
ALT+142 |
ä |
ALT+132 |
|
|
À |
ALT+0192 |
à |
ALT+133 |
|
|
Á |
ALT+0193 |
á |
ALT+160 |
|
|
 |
ALT+0194 |
â |
ALT+131 |
|
|
Ç |
ALT+128 |
ç |
ALT+135 |
|
|
Č |
010C+ALT+X |
č |
010D+ALT+X |
|
|
É |
ALT+144 |
é |
ALT+130 |
|
|
È |
ALT+0200 |
è |
ALT+138 |
|
|
Ê |
ALT+202 |
ê |
ALT+136 |
|
|
Ë |
ALT+203 |
ë |
ALT+137 |
|
|
Ĕ |
0114+ALT+X |
ĕ |
0115+ALT+X |
|
|
Ğ |
011E+ALT+X |
ğ |
011F+ALT+X |
|
|
Ģ |
0122+ALT+X |
ģ |
0123+ALT+X |
|
|
Ï |
ALT+0207 |
ï |
ALT+139 |
|
|
Î |
ALT+0206 |
î |
ALT+140 |
|
|
Í |
ALT+0205 |
í |
ALT+161 |
|
|
Ì |
ALT+0204 |
ì |
ALT+141 |
|
|
Ñ |
ALT+165 |
ñ |
ALT+164 |
|
|
Ö |
ALT+153 |
ö |
ALT+148 |
|
|
Ô |
ALT+212 |
ô |
ALT+147 |
|
|
Ō |
014C+ALT+X |
ō |
014D+ALT+X |
|
|
Ò |
ALT+0210 |
ò |
ALT+149 |
|
|
Ó |
ALT+0211 |
ó |
ALT+162 |
|
|
Ø |
ALT+0216 |
ø |
00F8+ALT+X |
|
|
Ŝ |
015C+ALT+X |
ŝ |
015D+ALT+X |
|
|
Ş |
015E+ALT+X |
ş |
015F+ALT+X |
|
|
Ü |
ALT+154 |
ü |
ALT+129 |
|
|
Ū |
ALT+016A |
ū |
016B+ALT+X |
|
|
Û |
ALT+0219 |
û |
ALT+150 |
|
|
Ù |
ALT+0217 |
ù |
ALT+151 |
|
|
Ú |
00DA+ALT+X |
ú |
ALT+163 |
|
|
Ÿ |
0159+ALT+X |
ÿ |
ALT+152 |
For more information about typographic ligatures, see Typographic ligature. For more, see Character Map.
|
Glyph |
Code |
Glyph |
Code |
|
|---|---|---|---|---|
|
Æ |
ALT+0198 |
æ |
ALT+0230 |
|
|
ß |
ALT+0223 |
ß |
ALT+225 |
|
|
Π|
ALT+0140 |
œ |
ALT+0156 |
|
|
ʩ |
02A9+ALT+X |
|||
|
ʣ |
02A3+ALT+X |
ʥ |
02A5+ALT+X |
|
|
ʪ |
02AA+ALT+X |
ʫ |
02AB+ALT+X |
|
|
ʦ |
0246+ALT+X |
ʧ |
02A7+ALT+X |
|
|
Љ |
0409+ALT+X |
Ю |
042E+ALT+X |
|
|
Њ |
040A+ALT+X |
Ѿ |
047E+ALT+x |
|
|
Ы |
042B+ALT+X |
Ѩ |
0468+ALT+X |
|
|
Ѭ |
049C+ALT+X |
ﷲ |
FDF2+ALT+X |
ASCII table numbers 0–31 are assigned for control characters used to control some peripheral devices such as printers.
|
Decimal |
Character |
Decimal |
Character |
|
|---|---|---|---|---|
|
null |
0 |
data link escape |
16 |
|
|
start of heading |
1 |
device control 1 |
17 |
|
|
start of text |
2 |
device control 2 |
18 |
|
|
end of text |
3 |
device control 3 |
19 |
|
|
end of transmission |
4 |
device control 4 |
20 |
|
|
inquiry |
5 |
negative acknowledge |
21 |
|
|
acknowledge |
6 |
synchronous idle |
22 |
|
|
bell |
7 |
end of transmission block |
23 |
|
|
backspace |
8 |
cancel |
24 |
|
|
horizontal tab |
9 |
end of medium |
25 |
|
|
line feed/new line |
10 |
substitute |
26 |
|
|
vertical tab |
11 |
escape |
27 |
|
|
form feed/new page |
12 |
file separator |
28 |
|
|
carriage return |
13 |
group separator |
29 |
|
|
shift out |
14 |
record separator |
30 |
|
|
shift in |
15 |
unit separator |
31 |
|
|
space |
32 |
DEL |
127 |
Need more help?
Want more options?
Explore subscription benefits, browse training courses, learn how to secure your device, and more.
Communities help you ask and answer questions, give feedback, and hear from experts with rich knowledge.
This example show how to add the Unicode U+202D before the last character of every word. It also ignores full stops (.) and comma (,) while making a replacement. Since this Unicode character is invisible and has no effect on visible effect on the left to right characters, you can see the replacement is being made by comparing the length of the strings.
str = ‘A quick brown fox, jumps over the lazy dog.’;
l1 = numel(str);
new_str = regexprep(str, ‘([A-Za-z][s.,])’, [char(hex2dec(‘202D’)) ‘$1’]);
l2 = numel(new_str);
>> l1
l1 =
43
>> l2
l2 =
52
You can also see that the replacement are being made by adding a dummy character (say a) after U+202D.
str = ‘A quick brown fox, jumps over the lazy dog.’;
new_str = regexprep(str, ‘([A-Za-z][s.,])’, [char(hex2dec(‘202D’)) ‘a$1’]);
new_str =
‘aA quicak browan foax, jumpas ovear thae lazay doag.’
From Wikipedia, the free encyclopedia
In computing, a word is the natural unit of data used by a particular processor design. A word is a fixed-sized datum handled as a unit by the instruction set or the hardware of the processor. The number of bits or digits[a] in a word (the word size, word width, or word length) is an important characteristic of any specific processor design or computer architecture.
The size of a word is reflected in many aspects of a computer’s structure and operation; the majority of the registers in a processor are usually word-sized and the largest datum that can be transferred to and from the working memory in a single operation is a word in many (not all) architectures. The largest possible address size, used to designate a location in memory, is typically a hardware word (here, «hardware word» means the full-sized natural word of the processor, as opposed to any other definition used).
Documentation for older computers with fixed word size commonly states memory sizes in words rather than bytes or characters. The documentation sometimes uses metric prefixes correctly, sometimes with rounding, e.g., 65 kilowords (KW) meaning for 65536 words, and sometimes uses them incorrectly, with kilowords (KW) meaning 1024 words (210) and megawords (MW) meaning 1,048,576 words (220). With standardization on 8-bit bytes and byte addressability, stating memory sizes in bytes, kilobytes, and megabytes with powers of 1024 rather than 1000 has become the norm, although there is some use of the IEC binary prefixes.
Several of the earliest computers (and a few modern as well) use binary-coded decimal rather than plain binary, typically having a word size of 10 or 12 decimal digits, and some early decimal computers have no fixed word length at all. Early binary systems tended to use word lengths that were some multiple of 6-bits, with the 36-bit word being especially common on mainframe computers. The introduction of ASCII led to the move to systems with word lengths that were a multiple of 8-bits, with 16-bit machines being popular in the 1970s before the move to modern processors with 32 or 64 bits.[1] Special-purpose designs like digital signal processors, may have any word length from 4 to 80 bits.[1]
The size of a word can sometimes differ from the expected due to backward compatibility with earlier computers. If multiple compatible variations or a family of processors share a common architecture and instruction set but differ in their word sizes, their documentation and software may become notationally complex to accommodate the difference (see Size families below).
Uses of words[edit]
Depending on how a computer is organized, word-size units may be used for:
- Fixed-point numbers
- Holders for fixed point, usually integer, numerical values may be available in one or in several different sizes, but one of the sizes available will almost always be the word. The other sizes, if any, are likely to be multiples or fractions of the word size. The smaller sizes are normally used only for efficient use of memory; when loaded into the processor, their values usually go into a larger, word sized holder.
- Floating-point numbers
- Holders for floating-point numerical values are typically either a word or a multiple of a word.
- Addresses
- Holders for memory addresses must be of a size capable of expressing the needed range of values but not be excessively large, so often the size used is the word though it can also be a multiple or fraction of the word size.
- Registers
- Processor registers are designed with a size appropriate for the type of data they hold, e.g. integers, floating-point numbers, or addresses. Many computer architectures use general-purpose registers that are capable of storing data in multiple representations.
- Memory–processor transfer
- When the processor reads from the memory subsystem into a register or writes a register’s value to memory, the amount of data transferred is often a word. Historically, this amount of bits which could be transferred in one cycle was also called a catena in some environments (such as the Bull GAMMA 60 [fr]).[2][3] In simple memory subsystems, the word is transferred over the memory data bus, which typically has a width of a word or half-word. In memory subsystems that use caches, the word-sized transfer is the one between the processor and the first level of cache; at lower levels of the memory hierarchy larger transfers (which are a multiple of the word size) are normally used.
- Unit of address resolution
- In a given architecture, successive address values designate successive units of memory; this unit is the unit of address resolution. In most computers, the unit is either a character (e.g. a byte) or a word. (A few computers have used bit resolution.) If the unit is a word, then a larger amount of memory can be accessed using an address of a given size at the cost of added complexity to access individual characters. On the other hand, if the unit is a byte, then individual characters can be addressed (i.e. selected during the memory operation).
- Instructions
- Machine instructions are normally the size of the architecture’s word, such as in RISC architectures, or a multiple of the «char» size that is a fraction of it. This is a natural choice since instructions and data usually share the same memory subsystem. In Harvard architectures the word sizes of instructions and data need not be related, as instructions and data are stored in different memories; for example, the processor in the 1ESS electronic telephone switch has 37-bit instructions and 23-bit data words.
Word size choice[edit]
When a computer architecture is designed, the choice of a word size is of substantial importance. There are design considerations which encourage particular bit-group sizes for particular uses (e.g. for addresses), and these considerations point to different sizes for different uses. However, considerations of economy in design strongly push for one size, or a very few sizes related by multiples or fractions (submultiples) to a primary size. That preferred size becomes the word size of the architecture.
Character size was in the past (pre-variable-sized character encoding) one of the influences on unit of address resolution and the choice of word size. Before the mid-1960s, characters were most often stored in six bits; this allowed no more than 64 characters, so the alphabet was limited to upper case. Since it is efficient in time and space to have the word size be a multiple of the character size, word sizes in this period were usually multiples of 6 bits (in binary machines). A common choice then was the 36-bit word, which is also a good size for the numeric properties of a floating point format.
After the introduction of the IBM System/360 design, which uses eight-bit characters and supports lower-case letters, the standard size of a character (or more accurately, a byte) becomes eight bits. Word sizes thereafter are naturally multiples of eight bits, with 16, 32, and 64 bits being commonly used.
Variable-word architectures[edit]
Early machine designs included some that used what is often termed a variable word length. In this type of organization, an operand has no fixed length. Depending on the machine and the instruction, the length might be denoted by a count field, by a delimiting character, or by an additional bit called, e.g., flag, or word mark. Such machines often use binary-coded decimal in 4-bit digits, or in 6-bit characters, for numbers. This class of machines includes the IBM 702, IBM 705, IBM 7080, IBM 7010, UNIVAC 1050, IBM 1401, IBM 1620, and RCA 301.
Most of these machines work on one unit of memory at a time and since each instruction or datum is several units long, each instruction takes several cycles just to access memory. These machines are often quite slow because of this. For example, instruction fetches on an IBM 1620 Model I take 8 cycles (160 μs) just to read the 12 digits of the instruction (the Model II reduced this to 6 cycles, or 4 cycles if the instruction did not need both address fields). Instruction execution takes a variable number of cycles, depending on the size of the operands.
Word, bit and byte addressing[edit]
The memory model of an architecture is strongly influenced by the word size. In particular, the resolution of a memory address, that is, the smallest unit that can be designated by an address, has often been chosen to be the word. In this approach, the word-addressable machine approach, address values which differ by one designate adjacent memory words. This is natural in machines which deal almost always in word (or multiple-word) units, and has the advantage of allowing instructions to use minimally sized fields to contain addresses, which can permit a smaller instruction size or a larger variety of instructions.
When byte processing is to be a significant part of the workload, it is usually more advantageous to use the byte, rather than the word, as the unit of address resolution. Address values which differ by one designate adjacent bytes in memory. This allows an arbitrary character within a character string to be addressed straightforwardly. A word can still be addressed, but the address to be used requires a few more bits than the word-resolution alternative. The word size needs to be an integer multiple of the character size in this organization. This addressing approach was used in the IBM 360, and has been the most common approach in machines designed since then.
When the workload involves processing fields of different sizes, it can be advantageous to address to the bit. Machines with bit addressing may have some instructions that use a programmer-defined byte size and other instructions that operate on fixed data sizes. As an example, on the IBM 7030[4] («Stretch»), a floating point instruction can only address words while an integer arithmetic instruction can specify a field length of 1-64 bits, a byte size of 1-8 bits and an accumulator offset of 0-127 bits.
In a byte-addressable machine with storage-to-storage (SS) instructions, there are typically move instructions to copy one or multiple bytes from one arbitrary location to another. In a byte-oriented (byte-addressable) machine without SS instructions, moving a single byte from one arbitrary location to another is typically:
- LOAD the source byte
- STORE the result back in the target byte
Individual bytes can be accessed on a word-oriented machine in one of two ways. Bytes can be manipulated by a combination of shift and mask operations in registers. Moving a single byte from one arbitrary location to another may require the equivalent of the following:
- LOAD the word containing the source byte
- SHIFT the source word to align the desired byte to the correct position in the target word
- AND the source word with a mask to zero out all but the desired bits
- LOAD the word containing the target byte
- AND the target word with a mask to zero out the target byte
- OR the registers containing the source and target words to insert the source byte
- STORE the result back in the target location
Alternatively many word-oriented machines implement byte operations with instructions using special byte pointers in registers or memory. For example, the PDP-10 byte pointer contained the size of the byte in bits (allowing different-sized bytes to be accessed), the bit position of the byte within the word, and the word address of the data. Instructions could automatically adjust the pointer to the next byte on, for example, load and deposit (store) operations.
Powers of two[edit]
Different amounts of memory are used to store data values with different degrees of precision. The commonly used sizes are usually a power of two multiple of the unit of address resolution (byte or word). Converting the index of an item in an array into the memory address offset of the item then requires only a shift operation rather than a multiplication. In some cases this relationship can also avoid the use of division operations. As a result, most modern computer designs have word sizes (and other operand sizes) that are a power of two times the size of a byte.
Size families[edit]
As computer designs have grown more complex, the central importance of a single word size to an architecture has decreased. Although more capable hardware can use a wider variety of sizes of data, market forces exert pressure to maintain backward compatibility while extending processor capability. As a result, what might have been the central word size in a fresh design has to coexist as an alternative size to the original word size in a backward compatible design. The original word size remains available in future designs, forming the basis of a size family.
In the mid-1970s, DEC designed the VAX to be a 32-bit successor of the 16-bit PDP-11. They used word for a 16-bit quantity, while longword referred to a 32-bit quantity; this terminology is the same as the terminology used for the PDP-11. This was in contrast to earlier machines, where the natural unit of addressing memory would be called a word, while a quantity that is one half a word would be called a halfword. In fitting with this scheme, a VAX quadword is 64 bits. They continued this 16-bit word/32-bit longword/64-bit quadword terminology with the 64-bit Alpha.
Another example is the x86 family, of which processors of three different word lengths (16-bit, later 32- and 64-bit) have been released, while word continues to designate a 16-bit quantity. As software is routinely ported from one word-length to the next, some APIs and documentation define or refer to an older (and thus shorter) word-length than the full word length on the CPU that software may be compiled for. Also, similar to how bytes are used for small numbers in many programs, a shorter word (16 or 32 bits) may be used in contexts where the range of a wider word is not needed (especially where this can save considerable stack space or cache memory space). For example, Microsoft’s Windows API maintains the programming language definition of WORD as 16 bits, despite the fact that the API may be used on a 32- or 64-bit x86 processor, where the standard word size would be 32 or 64 bits, respectively. Data structures containing such different sized words refer to them as:
- WORD (16 bits/2 bytes)
- DWORD (32 bits/4 bytes)
- QWORD (64 bits/8 bytes)
A similar phenomenon has developed in Intel’s x86 assembly language – because of the support for various sizes (and backward compatibility) in the instruction set, some instruction mnemonics carry «d» or «q» identifiers denoting «double-«, «quad-» or «double-quad-«, which are in terms of the architecture’s original 16-bit word size.
An example with a different word size is the IBM System/360 family. In the System/360 architecture, System/370 architecture and System/390 architecture, there are 8-bit bytes, 16-bit halfwords, 32-bit words and 64-bit doublewords. The z/Architecture, which is the 64-bit member of that architecture family, continues to refer to 16-bit halfwords, 32-bit words, and 64-bit doublewords, and additionally features 128-bit quadwords.
In general, new processors must use the same data word lengths and virtual address widths as an older processor to have binary compatibility with that older processor.
Often carefully written source code – written with source-code compatibility and software portability in mind – can be recompiled to run on a variety of processors, even ones with different data word lengths or different address widths or both.
Table of word sizes[edit]
| key: bit: bits, c: characters, d: decimal digits, w: word size of architecture, n: variable size, wm: Word mark | |||||||
|---|---|---|---|---|---|---|---|
| Year | Computer architecture |
Word size w | Integer sizes |
Floatingpoint sizes |
Instruction sizes |
Unit of address resolution |
Char size |
| 1837 | Babbage Analytical engine |
50 d | w | — | Five different cards were used for different functions, exact size of cards not known. | w | — |
| 1941 | Zuse Z3 | 22 bit | — | w | 8 bit | w | — |
| 1942 | ABC | 50 bit | w | — | — | — | — |
| 1944 | Harvard Mark I | 23 d | w | — | 24 bit | — | — |
| 1946 (1948) {1953} |
ENIAC (w/Panel #16[5]) {w/Panel #26[6]} |
10 d | w, 2w (w) {w} |
— | — (2 d, 4 d, 6 d, 8 d) {2 d, 4 d, 6 d, 8 d} |
— — {w} |
— |
| 1948 | Manchester Baby | 32 bit | w | — | w | w | — |
| 1951 | UNIVAC I | 12 d | w | — | 1⁄2w | w | 1 d |
| 1952 | IAS machine | 40 bit | w | — | 1⁄2w | w | 5 bit |
| 1952 | Fast Universal Digital Computer M-2 | 34 bit | w? | w | 34 bit = 4-bit opcode plus 3×10 bit address | 10 bit | — |
| 1952 | IBM 701 | 36 bit | 1⁄2w, w | — | 1⁄2w | 1⁄2w, w | 6 bit |
| 1952 | UNIVAC 60 | n d | 1 d, … 10 d | — | — | — | 2 d, 3 d |
| 1952 | ARRA I | 30 bit | w | — | w | w | 5 bit |
| 1953 | IBM 702 | n c | 0 c, … 511 c | — | 5 c | c | 6 bit |
| 1953 | UNIVAC 120 | n d | 1 d, … 10 d | — | — | — | 2 d, 3 d |
| 1953 | ARRA II | 30 bit | w | 2w | 1⁄2w | w | 5 bit |
| 1954 (1955) |
IBM 650 (w/IBM 653) |
10 d | w | — (w) |
w | w | 2 d |
| 1954 | IBM 704 | 36 bit | w | w | w | w | 6 bit |
| 1954 | IBM 705 | n c | 0 c, … 255 c | — | 5 c | c | 6 bit |
| 1954 | IBM NORC | 16 d | w | w, 2w | w | w | — |
| 1956 | IBM 305 | n d | 1 d, … 100 d | — | 10 d | d | 1 d |
| 1956 | ARMAC | 34 bit | w | w | 1⁄2w | w | 5 bit, 6 bit |
| 1956 | LGP-30 | 31 bit | w | — | 16 bit | w | 6 bit |
| 1957 | Autonetics Recomp I | 40 bit | w, 79 bit, 8 d, 15 d | — | 1⁄2w | 1⁄2w, w | 5 bit |
| 1958 | UNIVAC II | 12 d | w | — | 1⁄2w | w | 1 d |
| 1958 | SAGE | 32 bit | 1⁄2w | — | w | w | 6 bit |
| 1958 | Autonetics Recomp II | 40 bit | w, 79 bit, 8 d, 15 d | 2w | 1⁄2w | 1⁄2w, w | 5 bit |
| 1958 | Setun | 6 trit (~9.5 bits)[b] | up to 6 tryte | up to 3 trytes | 4 trit? | ||
| 1958 | Electrologica X1 | 27 bit | w | 2w | w | w | 5 bit, 6 bit |
| 1959 | IBM 1401 | n c | 1 c, … | — | 1 c, 2 c, 4 c, 5 c, 7 c, 8 c | c | 6 bit + wm |
| 1959 (TBD) |
IBM 1620 | n d | 2 d, … | — (4 d, … 102 d) |
12 d | d | 2 d |
| 1960 | LARC | 12 d | w, 2w | w, 2w | w | w | 2 d |
| 1960 | CDC 1604 | 48 bit | w | w | 1⁄2w | w | 6 bit |
| 1960 | IBM 1410 | n c | 1 c, … | — | 1 c, 2 c, 6 c, 7 c, 11 c, 12 c | c | 6 bit + wm |
| 1960 | IBM 7070 | 10 d[c] | w, 1-9 d | w | w | w, d | 2 d |
| 1960 | PDP-1 | 18 bit | w | — | w | w | 6 bit |
| 1960 | Elliott 803 | 39 bit | |||||
| 1961 | IBM 7030 (Stretch) |
64 bit | 1 bit, … 64 bit, 1 d, … 16 d |
w | 1⁄2w, w | bit (integer), 1⁄2w (branch), w (float) |
1 bit, … 8 bit |
| 1961 | IBM 7080 | n c | 0 c, … 255 c | — | 5 c | c | 6 bit |
| 1962 | GE-6xx | 36 bit | w, 2 w | w, 2 w, 80 bit | w | w | 6 bit, 9 bit |
| 1962 | UNIVAC III | 25 bit | w, 2w, 3w, 4w, 6 d, 12 d | — | w | w | 6 bit |
| 1962 | Autonetics D-17B Minuteman I Guidance Computer |
27 bit | 11 bit, 24 bit | — | 24 bit | w | — |
| 1962 | UNIVAC 1107 | 36 bit | 1⁄6w, 1⁄3w, 1⁄2w, w | w | w | w | 6 bit |
| 1962 | IBM 7010 | n c | 1 c, … | — | 1 c, 2 c, 6 c, 7 c, 11 c, 12 c | c | 6 b + wm |
| 1962 | IBM 7094 | 36 bit | w | w, 2w | w | w | 6 bit |
| 1962 | SDS 9 Series | 24 bit | w | 2w | w | w | |
| 1963 (1966) |
Apollo Guidance Computer | 15 bit | w | — | w, 2w | w | — |
| 1963 | Saturn Launch Vehicle Digital Computer | 26 bit | w | — | 13 bit | w | — |
| 1964/1966 | PDP-6/PDP-10 | 36 bit | w | w, 2 w | w | w | 6 bit 7 bit (typical) 9 bit |
| 1964 | Titan | 48 bit | w | w | w | w | w |
| 1964 | CDC 6600 | 60 bit | w | w | 1⁄4w, 1⁄2w | w | 6 bit |
| 1964 | Autonetics D-37C Minuteman II Guidance Computer |
27 bit | 11 bit, 24 bit | — | 24 bit | w | 4 bit, 5 bit |
| 1965 | Gemini Guidance Computer | 39 bit | 26 bit | — | 13 bit | 13 bit, 26 | —bit |
| 1965 | IBM 1130 | 16 bit | w, 2w | 2w, 3w | w, 2w | w | 8 bit |
| 1965 | IBM System/360 | 32 bit | 1⁄2w, w, 1 d, … 16 d |
w, 2w | 1⁄2w, w, 11⁄2w | 8 bit | 8 bit |
| 1965 | UNIVAC 1108 | 36 bit | 1⁄6w, 1⁄4w, 1⁄3w, 1⁄2w, w, 2w | w, 2w | w | w | 6 bit, 9 bit |
| 1965 | PDP-8 | 12 bit | w | — | w | w | 8 bit |
| 1965 | Electrologica X8 | 27 bit | w | 2w | w | w | 6 bit, 7 bit |
| 1966 | SDS Sigma 7 | 32 bit | 1⁄2w, w | w, 2w | w | 8 bit | 8 bit |
| 1969 | Four-Phase Systems AL1 | 8 bit | w | — | ? | ? | ? |
| 1970 | MP944 | 20 bit | w | — | ? | ? | ? |
| 1970 | PDP-11 | 16 bit | w | 2w, 4w | w, 2w, 3w | 8 bit | 8 bit |
| 1971 | CDC STAR-100 | 64 bit | 1⁄2w, w | 1⁄2w, w | 1⁄2w, w | bit | 8 bit |
| 1971 | TMS1802NC | 4 bit | w | — | ? | ? | — |
| 1971 | Intel 4004 | 4 bit | w, d | — | 2w, 4w | w | — |
| 1972 | Intel 8008 | 8 bit | w, 2 d | — | w, 2w, 3w | w | 8 bit |
| 1972 | Calcomp 900 | 9 bit | w | — | w, 2w | w | 8 bit |
| 1974 | Intel 8080 | 8 bit | w, 2w, 2 d | — | w, 2w, 3w | w | 8 bit |
| 1975 | ILLIAC IV | 64 bit | w | w, 1⁄2w | w | w | — |
| 1975 | Motorola 6800 | 8 bit | w, 2 d | — | w, 2w, 3w | w | 8 bit |
| 1975 | MOS Tech. 6501 MOS Tech. 6502 |
8 bit | w, 2 d | — | w, 2w, 3w | w | 8 bit |
| 1976 | Cray-1 | 64 bit | 24 bit, w | w | 1⁄4w, 1⁄2w | w | 8 bit |
| 1976 | Zilog Z80 | 8 bit | w, 2w, 2 d | — | w, 2w, 3w, 4w, 5w | w | 8 bit |
| 1978 (1980) |
16-bit x86 (Intel 8086) (w/floating point: Intel 8087) |
16 bit | 1⁄2w, w, 2 d | — (2w, 4w, 5w, 17 d) |
1⁄2w, w, … 7w | 8 bit | 8 bit |
| 1978 | VAX | 32 bit | 1⁄4w, 1⁄2w, w, 1 d, … 31 d, 1 bit, … 32 bit | w, 2w | 1⁄4w, … 141⁄4w | 8 bit | 8 bit |
| 1979 (1984) |
Motorola 68000 series (w/floating point) |
32 bit | 1⁄4w, 1⁄2w, w, 2 d | — (w, 2w, 21⁄2w) |
1⁄2w, w, … 71⁄2w | 8 bit | 8 bit |
| 1985 | IA-32 (Intel 80386) (w/floating point) | 32 bit | 1⁄4w, 1⁄2w, w | — (w, 2w, 80 bit) |
8 bit, … 120 bit 1⁄4w … 33⁄4w |
8 bit | 8 bit |
| 1985 | ARMv1 | 32 bit | 1⁄4w, w | — | w | 8 bit | 8 bit |
| 1985 | MIPS I | 32 bit | 1⁄4w, 1⁄2w, w | w, 2w | w | 8 bit | 8 bit |
| 1991 | Cray C90 | 64 bit | 32 bit, w | w | 1⁄4w, 1⁄2w, 48 bit | w | 8 bit |
| 1992 | Alpha | 64 bit | 8 bit, 1⁄4w, 1⁄2w, w | 1⁄2w, w | 1⁄2w | 8 bit | 8 bit |
| 1992 | PowerPC | 32 bit | 1⁄4w, 1⁄2w, w | w, 2w | w | 8 bit | 8 bit |
| 1996 | ARMv4 (w/Thumb) |
32 bit | 1⁄4w, 1⁄2w, w | — | w (1⁄2w, w) |
8 bit | 8 bit |
| 2000 | IBM z/Architecture (w/vector facility) |
64 bit | 1⁄4w, 1⁄2w, w 1 d, … 31 d |
1⁄2w, w, 2w | 1⁄4w, 1⁄2w, 3⁄4w | 8 bit | 8 bit, UTF-16, UTF-32 |
| 2001 | IA-64 | 64 bit | 8 bit, 1⁄4w, 1⁄2w, w | 1⁄2w, w | 41 bit (in 128-bit bundles)[7] | 8 bit | 8 bit |
| 2001 | ARMv6 (w/VFP) |
32 bit | 8 bit, 1⁄2w, w | — (w, 2w) |
1⁄2w, w | 8 bit | 8 bit |
| 2003 | x86-64 | 64 bit | 8 bit, 1⁄4w, 1⁄2w, w | 1⁄2w, w, 80 bit | 8 bit, … 120 bit | 8 bit | 8 bit |
| 2013 | ARMv8-A and ARMv9-A | 64 bit | 8 bit, 1⁄4w, 1⁄2w, w | 1⁄2w, w | 1⁄2w | 8 bit | 8 bit |
| Year | Computer architecture |
Word size w | Integer sizes |
Floatingpoint sizes |
Instruction sizes |
Unit of address resolution |
Char size |
| key: bit: bits, d: decimal digits, w: word size of architecture, n: variable size |
[8][9]
See also[edit]
- Integer (computer science)
Notes[edit]
- ^ Many early computers were decimal, and a few were ternary
- ^ The bit equivalent is computed by taking the amount of information entropy provided by the trit, which is
. This gives an equivalent of about 9.51 bits for 6 trits.
- ^ Three-state sign
References[edit]
- ^ a b Beebe, Nelson H. F. (2017-08-22). «Chapter I. Integer arithmetic». The Mathematical-Function Computation Handbook — Programming Using the MathCW Portable Software Library (1 ed.). Salt Lake City, UT, USA: Springer International Publishing AG. p. 970. doi:10.1007/978-3-319-64110-2. ISBN 978-3-319-64109-6. LCCN 2017947446. S2CID 30244721.
- ^ Dreyfus, Phillippe (1958-05-08) [1958-05-06]. Written at Los Angeles, California, USA. System design of the Gamma 60 (PDF). Western Joint Computer Conference: Contrasts in Computers. ACM, New York, NY, USA. pp. 130–133. IRE-ACM-AIEE ’58 (Western). Archived (PDF) from the original on 2017-04-03. Retrieved 2017-04-03.
[…] Internal data code is used: Quantitative (numerical) data are coded in a 4-bit decimal code; qualitative (alpha-numerical) data are coded in a 6-bit alphanumerical code. The internal instruction code means that the instructions are coded in straight binary code.
As to the internal information length, the information quantum is called a «catena,» and it is composed of 24 bits representing either 6 decimal digits, or 4 alphanumerical characters. This quantum must contain a multiple of 4 and 6 bits to represent a whole number of decimal or alphanumeric characters. Twenty-four bits was found to be a good compromise between the minimum 12 bits, which would lead to a too-low transfer flow from a parallel readout core memory, and 36 bits or more, which was judged as too large an information quantum. The catena is to be considered as the equivalent of a character in variable word length machines, but it cannot be called so, as it may contain several characters. It is transferred in series to and from the main memory.
Not wanting to call a «quantum» a word, or a set of characters a letter, (a word is a word, and a quantum is something else), a new word was made, and it was called a «catena.» It is an English word and exists in Webster’s although it does not in French. Webster’s definition of the word catena is, «a connected series;» therefore, a 24-bit information item. The word catena will be used hereafter.
The internal code, therefore, has been defined. Now what are the external data codes? These depend primarily upon the information handling device involved. The Gamma 60 [fr] is designed to handle information relevant to any binary coded structure. Thus an 80-column punched card is considered as a 960-bit information item; 12 rows multiplied by 80 columns equals 960 possible punches; is stored as an exact image in 960 magnetic cores of the main memory with 2 card columns occupying one catena. […] - ^ Blaauw, Gerrit Anne; Brooks, Jr., Frederick Phillips; Buchholz, Werner (1962). «4: Natural Data Units» (PDF). In Buchholz, Werner (ed.). Planning a Computer System – Project Stretch. McGraw-Hill Book Company, Inc. / The Maple Press Company, York, PA. pp. 39–40. LCCN 61-10466. Archived (PDF) from the original on 2017-04-03. Retrieved 2017-04-03.
[…] Terms used here to describe the structure imposed by the machine design, in addition to bit, are listed below.
Byte denotes a group of bits used to encode a character, or the number of bits transmitted in parallel to and from input-output units. A term other than character is used here because a given character may be represented in different applications by more than one code, and different codes may use different numbers of bits (i.e., different byte sizes). In input-output transmission the grouping of bits may be completely arbitrary and have no relation to actual characters. (The term is coined from bite, but respelled to avoid accidental mutation to bit.)
A word consists of the number of data bits transmitted in parallel from or to memory in one memory cycle. Word size is thus defined as a structural property of the memory. (The term catena was coined for this purpose by the designers of the Bull GAMMA 60 [fr] computer.)
Block refers to the number of words transmitted to or from an input-output unit in response to a single input-output instruction. Block size is a structural property of an input-output unit; it may have been fixed by the design or left to be varied by the program. […] - ^ «Format» (PDF). Reference Manual 7030 Data Processing System (PDF). IBM. August 1961. pp. 50–57. Retrieved 2021-12-15.
- ^ Clippinger, Richard F. [in German] (1948-09-29). «A Logical Coding System Applied to the ENIAC (Electronic Numerical Integrator and Computer)». Aberdeen Proving Ground, Maryland, US: Ballistic Research Laboratories. Report No. 673; Project No. TB3-0007 of the Research and Development Division, Ordnance Department. Retrieved 2017-04-05.
{{cite web}}: CS1 maint: url-status (link) - ^ Clippinger, Richard F. [in German] (1948-09-29). «A Logical Coding System Applied to the ENIAC». Aberdeen Proving Ground, Maryland, US: Ballistic Research Laboratories. Section VIII: Modified ENIAC. Retrieved 2017-04-05.
{{cite web}}: CS1 maint: url-status (link) - ^ «4. Instruction Formats» (PDF). Intel Itanium Architecture Software Developer’s Manual. Vol. 3: Intel Itanium Instruction Set Reference. p. 3:293. Retrieved 2022-04-25.
Three instructions are grouped together into 128-bit sized and aligned containers called bundles. Each bundle contains three 41-bit instruction slots and a 5-bit template field.
- ^ Blaauw, Gerrit Anne; Brooks, Jr., Frederick Phillips (1997). Computer Architecture: Concepts and Evolution (1 ed.). Addison-Wesley. ISBN 0-201-10557-8. (1213 pages) (NB. This is a single-volume edition. This work was also available in a two-volume version.)
- ^ Ralston, Anthony; Reilly, Edwin D. (1993). Encyclopedia of Computer Science (3rd ed.). Van Nostrand Reinhold. ISBN 0-442-27679-6.
Subjects>Jobs & Education>Education
Wiki User
∙ 14y ago
Best Answer
Copy
A word typically refers to a 16-bit quantity, where 32-bits is
called a longword.
Wiki User
∙ 14y ago
This answer is:
Study guides
Add your answer:
Earn +
20
pts
Q: How many bits in a word?
Write your answer…
Submit
Still have questions?
Related questions
People also asked