Comment by Marco Alka on "How does a computer machine understand 0s and 1s?"

What exactly is this bit-story?

Computers are digitial. Digital means we build components from "analog" hardware, like transistors, resistors, etc., which work with two states: On and Off. Usually we can do this by employing reversed Z-Diodes, which are not conductive until a certain voltage threshold is reached. That way, you either have 0V or <threshold>+ Volt. The resulting components are called "logical gates". Some examples for gates include "AND", "OR", "NAND", "XOR", etc. With these gates, your computer hardware can be built easily in a way which allows for storing states (e.g. NAND flip-flops) and do logical things, like mathematic computations. One storage-place can save the state of either 0 or 1. This state is called "bit". Bits work in the binary system. Let me translate that for you to our widely used decimal system:

Binary	Decimal
0	0
1	1
10	2
100	4
101	5
1010	10

(Taken from one of my previous posts about 64bit)

How your computer handles a bit-stream

In order to do some processing, your computer uses a clock generator with a very high frequency. The frequency is usually one of the selling points of a CPU, like 4GHz. It means the clock generator alternates between logical 0 and 1 ca. 4,000,000,000 times a second. The signal from the clock generator is used to transfer information through your logical gates and in order to give them time to do their thing. Logical gates do not provide instant calculations, because even electromagnetic alterations (important! It's not the electrons which have to travel fast) have to travel the distance and need a certain time to do so.

With the help of the logical gates, a computer is able to pump your data from memory into your CPU. Inside the CPU, there usually are one to several ALUs. ALU stands for Arithmetic Logical Unit and describes a circuit (out of logical gates) which is able to understand a certain combination of bits and do calculations on them. One ALU usually has an input of several bits which are filled in sequentially, meaning the bit stream is pumped into the one side of the ALU until the input is "full". Then the ALU is signalled that it should process the input.

CPU Schema

Let's take a look at a simple example. The example ALU can work on 8 bit and the input sequence is 11001000. One word is 3 bits long (a "word" is the length of a data entity). The first thing the ALU needs is a command set ("opcodes"), for example ADD (sum of two numbers), DEC (decrease), INC (increment data),... Those commands are evaluated via a simple logic. For the sake of simplicity, let's say the command is encoded in 2 bit (which sums up to 3 commands + NOOP (no operation; do nothing)) which are stored in the first two bits of the input sequence (usually an ALU has a separate opcode input). Let's say the ALU knows all of the mentioned commands above:

Bitcode	Command
00	NOOP
01	ADD
10	MOV
11	INC

Since the first two bits in our sequence are 11, the operation for the computation is "INC". The ALU can then proceed to increment the number which follows. Incrementing only takes one input: the number to increment. So the ALU takes the first word after the command (001) and increments it via mathematical logic (also implemented with logical gates). The result then is 010 which is pushed out of the ALU and then saved in a result memory location.

But how can we do logical things in addition to math?

The thing is that there are a few more commands which allow more logical operations, like jump or jump if equal. Those commands have to be executed by another part of the CPU: a Control Unit. It does the data fetching and executes certain memory related operations, but all in all is quite similar to how the ALU works.

By manipulating data and storing it in well defined places or pushing it to certain busses, the data can be used in other places, for example it can be sent to the PCI controller, then it can be consumed by the graphics card and sent to the monitor in order to display an image. It can be sent to a USB controller which stores it on your USB drive. It all depends on the operations and the content of certain memory locations, which are used by logical gates to decide stuff.

kirandeep singh First of all, your code is always translated into machine codes (it does not matter, if it is compiled to machine code, or if an interpreter translates it).

Machine code is nothing more than a sequence of specific signals on a bus. Chips with access to that bus will usually use a clock-signal to trigger transistors, which then allow the signals on the bus to enter the chip. Your signal itself will then trigger more transistors inside the chip to change their state, resulting in a new signal on the output side. That signal could be a write-operation on a memory chip. The clock-signal will then allow other chips to read that output.

A clock signal usually comes from the CPU. CPU vendors advertise their CPUs with the speed of the internal CPU clocks. For example, if you have an Intel processor with 3.4GHz, the internal clock will output an on-off-signal with a frequency of 3.4GHz. That's it. There are other chips in your computer, which have their own clocks (for example the RAM), though. That's why you have to make sure that your parts are compatible, or they won't be able to sync.

Take a look at this rough CPU schematic. See the clock generator inputting a CLK signal into the CPU? That's what triggers the read/write operations from/to the internal bus, which results in your code being read, triggering internal transistors and even telling others when to read from the CPU. Which leads to one sad truth: CPU outputs cannot be read as soon as they are ready, they always have a certain amount of time to finish and even if they finish earlier, everything has to wait for the set amount of time >.< It's easier that way, though!

Search Hashnode

What exactly is this bit-story?

How your computer handles a bit-stream

But how can we do logical things in addition to math?