parilov

Процессор - это не просто электронная схема, по элементам которой течет ток, а логическая, или, цифровая схема. Это значит, что в зависимости от того, есть или нет напряжения в каком-то ее "месте", это самое "место" находится в одном из двух четко враженых состояний . Эти состояния мы и принимаем условно за 1 и 0. Назовем такое "место" - ячейкой памяти. Памяти - потому, что если в схеме ничего больше не будет изменяться, то эти значения останутся там, пока мы не выключим питание, и мы всегда сможем их еще раз узнать.

Мы договорились, что с помощью этих 1 и 0 мы будем кодировать числа, в двоичной системе, (а с помощью чисел будем кодировать все остальное - буквы, цвета, уровень громкости и т.д.) Таким образом, если мысленно выстроить в ряд (назовем его регистром), скажем, 8 таких ячеек (а мы помним, что про каждую из них мы можем точно сказать, там сейчас 1 или 0; например, измерить напряжение вольтметром), мы получим 1 байт, в котором может быть закодировано число от 0 до 255 примерно так:

0 - 00000000
1 - 00000001
2 - 00000010
3 - 00000011
и т.д. вплоть до
255 - 11111111

Далее. Т.к. все ячейки соединены между собой определенным образом, то от наличия или отсутствия напряжения в одном месте напрямую зависит, в каком состоянии будет соседнее с ним место... что-то вроде шестеренок в часах - если повернуть одну, так или иначе повернутся все остальные.

Несколько упрощая, можно сказать, что для построения процессора достаточно три таких "определенных образа" соединения ячеек (схем, или видов логических элементов):

1. Если две ячейки соединены в схему инвертор, это означает, что если в одной из них сейчас есть напряжение (1), то в другой его точно нет (0), и наоборот.
2. Если три ячейки соединены в схему И, то в одной из них есть напряжение (1) только тогда, когда оно есть в двух других. И, наконец,
3. схема ИЛИ - в одной из трех ячеек напряжение есть только, если оно есть хотя бы в одной из двух соседних.

Все эти схемы построены из полупроводников (в основном, транзисторов), а ячейки - места соединения отдельных логических элементов друг с другом.

Вот именно тут мы уже плавненько перешли от электричества к логике и цифрам, т.к. с помощью напряжения в разных ячейках можем однозначно отображать разные числа, а комбинируя такие элементарные логические схемы, можем создавать нужную нам логику работы процессора. Осталось только разобрать, а как же это все работает.

Далее из таких схем-кирпичиков выстроены более сложные схемы: сдвигающие регистры, сумматоры, компараторы, и, собственно, АЛУ. Его образно называют сердсем процессора, но на самом деле это его мозг. Это то, чем процессор выполняет программу. Очень сильно упрощая, его работу можно представить себе так:

Есть некий регистр, в котором сейчас находится код операции (некое закодированное число). Оно определяет, что конкретно АЛУ сейчас, вот на этом шаге должно делать, например, складывать. И есть еще два регистра, в которых находятся закодированные числа, например, 2 и 3. Эти регистры подключены к АЛУ. В такой ситуации АЛУ, выполняя шаг, складывает числа из регистров данных (2 и 3) и помещает результат (5) в первый из них (теперь там уже не 2 а 5), а в регистр операции - следующую инструкцию. Так процессор выполнил один шаг программы и готов к следующему.

Почему происходит именно так, а не как-то иначе? Потому, что мы объединили много разных логических элементов в сложную схему с именно такой логикой. Объединили бы иначе, логика и поведение схемы были бы другими... и это, возможно, был бы другой процессор, с другой архитектурой, системой команд и т.д. А эта конкретная схема в такой ситуации всегда будет делать именно это!

Ну, и, наконец, осталось выяснить, а что же такое этот шаг и что заставляет процессор совершать отдельные шаги?

Заставляет всю эту кухню крутиться тактовый генератор. Вот его было бы правильно называть сердцем. Это такая другая схема, построенная на кристалле кварца, которая ничего иного не делает, как очень быстро выдает то 1 то 0. Очень быстро - это те самые МГц и ГГц, которыми любят меряться владельцы крутых компьютеров, т.е. скорость, с которой процессор совершает шаги. Выход тактового генератора напрямую подключен к нужным частям всей схемы, и выдаваемые им 1 и 0 - это то самое, что и приводит всю схему в действие, заставляя все логические элементы переключаться по цепочке и изменять значения отдельных ячеек согласно заданной нами логике... и программе.

Вот, как-то так на пальцах можно описать работу процессора. Конечно же, там внутри все на порядки сложнее, схем и абстракций больше, транзисторов миллионы и т.д., но общий принцип работы полупроводникового процессора именно таков. И, кстати, полупроводниковый процессор - всего лишь один из вариантов, как построить процессор, способный выполнять программы. Вообще-то, его можно построить из чего угодно. Когда полупроводников еще не было, их строили на электронных лампах, до того - на железных механизмах, приводимых в действие моторами, или вручную, еще раньше - из дерева... ну, и конечно - в уме и на бумаге. Так что, электричество для этого вовсе даже и не обязательно :)

UPD: Несколько поверхностная, но весьма наглядная статья о схемотехнике логических элементов на Хабре.

мне больше нравится использовать Visual Format Language

    NSArray *verticalConstraints = [NSLayoutConstraint constraintsWithVisualFormat:@"V:[view(height)]-|"
                                                                           options:0
                                                                           metrics:@{
                                                                               @"height" : @(50)
                                                                           }
                                                                             views:@{
                                                                                 @"view" : view
                                                                             }];

    NSArray *horizontalConstraints = [NSLayoutConstraint constraintsWithVisualFormat:@"H:|-0-[view]-0-|"
                                                                             options:0
                                                                             metrics:nil
                                                                               views:@{
                                                                                   @"view" : view
                                                                               }];
    [self.view addConstraints:verticalConstraints];
    [self.view addConstraints:horizontalConstraints];

Увы, таких данных в России нет. Нет даже открытых данных с муниципальной статистикой — к сожалению МВД России изо всех сил сопротивляется раскрытию какой-либо информации о преступлениях, даже агрегированной.

Прокуратура РФ сейчас внедряет систему учета преступлений где, теоретически, должна быть информация о каждом из них, но и в этом случае они ничего не будут раскрывать без одобрения на уровне не менее Президента.

Мы (НП «Информационная культура») пытаемся «пробить» раскрытие этих данных — я озвучивал эту проблему на встрече Д. Медведевым по открытым данным в феврале 2013 года, несколько раз вопрос поднимался на встречах с представителями МВД России в рамках Открытого правительства. Но, скажу честно, пока что процесс идет очень тяжело.

void setup()
{
//------ Timer0 ----------
TCCR0A = (1<<WGM01);   // Режим CTC (сброс по совпадению)
TCCR0B = (1<<CS00);    // Тактирование от CLK.
                       // Если нужен предделитель :
// TCCR0B = (1<<CS01);           // CLK/8
// TCCR0B = (1<<CS00)|(1<<CS01); // CLK/64
// TCCR0B = (1<<CS02);           // CLK/256
// TCCR0B = (1<<CS00)|(1<<CS02); // CLK/1024

OCR0A = 123;            // Верхняя граница счета. Диапазон от 0 до 255.
                        // Частота прерываний будет = Fclk/(N*(1+OCR0A)) 
                        // где N - коэф. предделителя (1, 8, 64, 256 или 1024)
TIMSK0 = (1<<OCIE0A);   // Разрешить прерывание по совпадению

//------ Timer1 ----------
TCCR1B = (1<<WGM12);    // Режим CTC (сброс по совпадению)
TCCR1B |= (1<<CS10);    // Тактирование от CLK.
                        // Если нужен предделитель :
// TCCR1B |= (1<<CS11);           // CLK/8
// TCCR1B |= (1<<CS10)|(1<<CS11); // CLK/64
// TCCR1B |= (1<<CS12);           // CLK/256
// TCCR1B |= (1<<CS10)|(1<<CS12); // CLK/1024

OCR1A = 2678;           // Верхняя граница счета. Диапазон от 0 до 65535.
                        // Частота прерываний будет = Fclk/(N*(1+OCR1A)) 
                        // где N - коэф. предделителя (1, 8, 64, 256 или 1024)
TIMSK1 = (1<<OCIE1A);   // Разрешить прерывание по совпадению

//------ Timer2 ----------
TCCR2A = (1<<WGM21);    // Режим CTC (сброс по совпадению)
TCCR2B = (1<<CS20);     // Тактирование от CLK.
                        // Если нужен предделитель :
// TCCR2B = (1<<CS21);                     // CLK/8
// TCCR2B = (1<<CS20)|(1<<CS21);           // CLK/32
// TCCR2B = (1<<CS22);                     // CLK/64
// TCCR2B = (1<<CS20)|(1<<CS22);           // CLK/128
// TCCR2B = (1<<CS21)|(1<<CS22);           // CLK/256
// TCCR2B = (1<<CS20)|(1<<CS21)|(1<<CS22); // CLK/1024

OCR2A = 234;            // Верхняя граница счета. Диапазон от 0 до 255.
                        // Частота прерываний будет = Fclk/(N*(1+OCR2A)) 
                        // где N - коэф. предделителя (1, 8, 32, 64, 128, 256 или 1024)
TIMSK2 = (1<<OCIE2A);   // Разрешить прерывание по совпадению

sei ();                 // Глобально разрешить прерывания
}

ISR (TIMER0_COMPA_vect)
{
    // Обработчик прерывания таймера 0
}

ISR (TIMER1_COMPA_vect)
{
    // Обработчик прерывания таймера 1
}

ISR (TIMER2_COMPA_vect)
{
    // Обработчик прерывания таймера 2
}

Вместо тега CODE тег SOURCE используй, юный падаван.