16247

Созданоие приложения визуализирующего работу cash-памяти в 3-х архитектурах

Курсовая

Информатика, кибернетика и программирование

Содержание: Краткая информация о процессорах семейства х-86. Кэш-память Архитектура кэш-памяти Кэш-память с прямым отображением Полностью ассоциативная архитектура Наборно-ассоциативн...

Русский

2013-06-20

200.5 KB

4 чел.

Содержание:

[1]
Краткая информация о процессорах семейства х86.

[2]
Кэш-память

[2.1] Архитектура кэш-памяти

[2.1.1] Кэш-память с прямым отображением

[2.1.2] Полностью ассоциативная архитектура

[2.1.3] Наборно-ассоциативная архитектура

[2.1.4] Гарвардская и Принстонская архитектуры

[2.2] Размеры кэш-памяти

[2.3] Методы записи

[2.4] Обновление информации

[2.5] Кэш в процессорах с умножением частоты

[3]
Разработка приложения.

[3.1] Техническое задание.

[3.2] Интерфейс программы.

[3.3] Алгоритм приложения.

[3.4] Исходный текст программы.

[4] Описание программы.

[4.1] Краткое описание и минимальные требования.

[4.2] Оборудование применявшееся  при разработке приложения.

[5]
Заключение.

[6]
Используемая литература.

Приложение: Дискета с приложением MS Windows и с его исходным   текстом.

  1.  
    Краткая информация о процессорах семейства х86. 

История микропроцессоров началась в 1971 году, когда фирма Intel выпустила первый микропроцессор i4004. Он имел разрядность данных 4 бит, способность адресовать 640 байт памяти, тактовую частоту 108 КГц и производительность 0,06 MIPS. Такой процессор уже мог работать в качестве вычислительного ядра калькулятора. Он содержал 2300 транзисторов и выполнялся по технологии с разрешением 10 мкм. Через год появился его 8-разрядный «родственник» — i8008, адресующий уже 16 Кбайт памяти.

В 1974 году появился 8-разрядный процессор i8080, ставший весьма популярным устройством. Он имел частоту 2 МГц, адресовал 64 Кбайт памяти и вмещал 6000 транзисторов благодаря технологии 6 мкм. Процессор требовал трех источников питания (+5, +12 и -5 В) и сложной двухтактной синхронизации. На этом процессоре строились разнообразные терминалы, контроллеры и даже первый персональный компьютер — Altair. В нашей стране запоздалым «эхом» 8080 стали процессоры 580ИК80 и КР580ВМ80, на базе которых в начале и середине 80-х годов делалось много «самодельных» ПК .

Следующим этапом стал процессор i8085 (5 МГц, 0,37 MIPS, 6500 транзисторов, технология 3 мкм). Он сохранил популярную регистровую архитектуру 8080 и программную совместимость, но в него добавили порт последовательного интерфейса, упразднили специальные ИС поддержки (тактовый генератор и системный контроллер) и несколько изменили внешний интерфейс. Главным подарком разработчикам аппаратуры стал переход на единое питающее напряжение +5 В.

Процессор Z80 фирмы Zilog явился вариацией на тему 8080 и 8085. Сохранив программную совместимость с 8080, в него ввели дополнительные регистры, что позволило существенно повысить производительность. Результат оказался впечатляющим — еще недавно популярные компьютеры Sinclair, построенные на Z80, демонстрировали на играх графику, не уступающую PC на 16-разрядном процессоре 80286.

Первый 16-разрядный процессор i8086 фирма Intel выпустила в 1978 году. Частота — 5 МГц, производительность — 0,33 MIPS, но инструкции уже с 16-битными операндами (позже появились процессоры 8 и 10 МГц). Технология 3 мкм, 29 000 транзисторов. Адресуемая память 1 Мбайт (казалось, так много!). Регистровая архитектура и система команд существенно отличалась от 8080, но, естественно, прослеживаются общие идеи. Через год появился i8088 тот же процессор, но с 8-разрядной шиной данных. С него началась история IBM PC, неразрывно связанная со всем дальнейшим развитием процессоров Intel. Массовое распространение и открытость архитектуры IBM PC привели к лавинообразным темпам появления нового программного обеспечения, разрабатываемого крупными, средними и мелкими фирмами, а также энтузиастами-одиночками. Технический прогресс и тогда и сейчас был не мыслим без развития процессоров, но с учетом огромного объема уже существующего программного обеспечения для PC, уже тогда возник принцип обратной программной совместимости — старые программы должны работать на новых процессорах. Таким образом, все нововведения в архитектуре последующих процессоров должны были пристраиваться к существующему ядру. На процессорах отражались и особенности архитектуры PC. Взять, например, векторы прерываний. Фирма Intel зарезервировала первые 32 вектора «для служебного пользования», однако на них «наехали» прерывания BIOS PC. В результате появился дополнительный способ обработки исключений сопроцессора, применяемый в старших моделях процессоров.

Процессор i80286, знаменующий следующий этап архитектуры, появился только в 1982 году. Он уже имел 134 000 транзисторов (технология 1,5 мкм) и адресовал до 16 Мбайт физической памяти. Его принципиальные новшества — защищенный режим и виртуальная память размером до 1 Гбайт — не нашли массового применения; процессор большей частью использовался как очень быстрый 8088.

Рождение 32-разрядных процессоров ознаменовалось в 1985 году моделью i80386 (275 000 транзисторов, 1,5 мкм). Разрядность шины данных (как и внутренних регистров) достигла 32 бит, адресуемая физическая память — 4 Гбайт. Появились новые регистры, новые 32-битные операции, существенно доработан защищенный режим, были введены режим V86 и страничное управление памятью. Процессор нашел широкое применение в PC; на его благодатной почве стал разрастаться  — Microsoft Windows с приложениями. С этого времени стала заметна тенденция «положительной обратной связи»: на появление нового процессора производители ПО реагируют выпуском новых привлекательных продуктов, последующим версиям которых становится тесно на новом процессоре. Появляется более производительный процессор, но после непродолжительного восторга и его ресурсы быстро признаются недостаточными, и затем история повторяется. Этот «замкнутый круг», конечно, естественен, но есть обоснованное подозрение, что большие ресурсы развращают (или, по крайней мере, расслабляют) разработчика ПО, не принуждая его напрягаться в поисках более эффективных способов решения задачи. Примером эффективного программирования можно считать игрушки на Sinclair ZX-Spectrum, которые работают на «игрушечных»  ресурсах — 8-разрядном процессоре и 64 (128) Кбайт ОЗУ. С противоположными примерами большинство пользователей PC сталкиваются регулярно.

История процессора 80386 повторила судьбу 8086/8088: первую модель с 32-разрядной шиной данных (впоследствии названной 386DX) сменил 386SX с 16-разрядной шиной. Он довольно легко вписывался в архитектуру PC AT, ранее базировавшуюся на процессоре 80286.

Процессор Intel486DX появился в 1989 году. Транзисторов — 1,2 млн, технология 1 мкм. От процессора 80386 существенно отличается размещением на кристалле первичного кэша и встроенного математического сопроцессора — FPU (предыдущие процессоры использовали внешние сопроцессоры х87). Кроме того, для повышения производительности в этом CISC-процессоре (как и в последующих) применено RISC-ядро. Далее появились его разновидности, отличающиеся наличием или отсутствием сопроцессора, применением внутреннего умножения частоты, политикой кэширования и др. Тогда же Intel занялась энергосбережением, что отразилось и в линии 386 — появился процессор Intel386SL.

В 1993 году появились первые процессоры Pentium с частотой 60 и 66 МГц — 32-разрядные процессоры с 64-разрядной шиной данных. Транзисторов 3,1 млн, технология 0,8 мкм, питание 5 В. От 486 принципиально отличается суперскалярной архитектурой — способностью за один такт выпускать с конвейеров до двух инструкций (что, конечно, не означает возможности прохождения инструкции через процессор за полтакта или один такт). Интерес к процессору со стороны производителей и покупателей PC сдерживался его очень высокой ценой. Кроме того, возник скандал с ошибкой в сопроцессоре. Хотя фирма Intel математически обосновала невысокую вероятность ее проявления (раз в несколько лет), она (фирма, а не ошибка) все-таки пошла на бесплатную замену уже проданных процессоров на новые, исправленные.

Процессоры Pentium с частотой 75, 90 и 100 МГц, появившиеся в 1994 году, представляли второе поколение процессоров Pentium. При почти том же числе транзисторов они выполнялись по технологии 0,6 мкм, что позволило снизить потребляемую мощность. От первого поколения отличались внутренним умножением частоты, поддержкой мультипроцессорных конфигураций и другим типом корпуса. Появились версии (75 МГц в миниатюрном корпусе) для мобильных применений (блокнотных PC). Процессоры Pentium второго поколения стали весьма популярными в PC. В 1995 году были выпущены процессоры на 120 и 133 МГц, выполненные уже по технологии 0,35 мкм (первые процессоры на 120 МГц делались по технологии 0,6 мкм). 1996-й называют годом Pentium — появились процессоры на 150, 166 и 200 МГц, и Pentium стал рядовым процессором в массовых PC.

Параллельно с Pentium развивался и процессор Pentium Pro, который отличался «динамическим исполнением», направленным на увеличение числа параллельно исполняемых инструкций. Кроме того, в его корпусе разместили вторичный кэш, работающий на частоте ядра, — для начала объемом 256 Кбайт. Однако на 16-разрядных приложениях, а также в среде Windows 95 он был ничуть не быстрее Pentium. Процессор содержит 5,5 млн транзисторов ядра и 15,5 млн транзисторов для вторичного кэша объемом 256 Кбайт. Первый процессор с частотой 150 МГц появился в начале 1995 года (технология 0,6 мкм), а уже в конце года были достигнуты частоты 166, 180 и 200 МГц (технология 0,35 мкм), а кэш увеличен до 512 Кбайт.

После долгих обещаний в начале 1997 года Intel выпустила процессоры Pentium ММХ. Технология ММХ (MultiMedia extensions, мультимедийные расширения) предполагает параллельную обработку группы операндов одной инструкцией. Технология ММХ призвана ускорить выполнение мультимедийных приложений, в частности операции с изображениями и обработку сигналов. Ее эффективность вызывает споры в среде разработчиков, поскольку выигрыш в самих операциях обработки компенсируется проигрышем на дополнительных операциях упаковки-распаковки. Кроме того, ограниченная разрядность ставит под сомнение применение ММХ в декодерах MPEG-2, в которых требуется обработка 80-битных операндов. Кроме ММХ эти процессоры, по сравнению с обычным Pentium, имеют удвоенный объем первичного кэша и некоторые элементы архитектуры, позаимствованные у Pentium Pro, что повышает производительность Pentium ММХ на обычных приложениях. Процессоры Pentium ММХ имеют 4,5 млн транзисторов и выполнены по технологии 0,35 мкм. Развитие линейки моделей Pentium ММХ сейчас остановилось. Последние достигнутые тактовые частоты — 166, 200 и 233 МГц.

Технология ММХ была соединена с архитектурой Pentium Pro — и в мае 1997 года появился процессор Pentium II. Он представляет собой слегка урезанный вариант ядра Pentium Pro с более высокой внутренней тактовой частотой, в которое ввели поддержку ММХ. Трудности размещения вторичного кэша и процессорного ядра в корпусе одной микросхемы преодолели нехитрым способом — кристалл с ядром (processor core) и набор кристаллов статической памяти и дополнительных схем, реализующих вторичный кэш, разместили на небольшой печатной плате-картридже. Все кристаллы закрыты общей крышкой и охлаждаются специальным вентилятором. Первые процессоры имели тактовые частоты ядра 233, 266 и 300 МГц (технология 0,35 мкм), летом 1998 года была достигнута частота 450 МГц (технология 0,25 мкм), причем внешняя тактовая частота с 66 МГц повысилась до 100 МГц. Вторичный кэш этих процессоров работает на половине частоты ядра. Семейство Pentium II динамично развивается, причем имеется широкий спектр вариаций от относительно дешевых до очень дорогих моделей. Для систем начального уровня появилось семейство процессоров Celeron, младшие модели которого вообще не имеют вторичного кэша и стоят около $100. Новые модели имеют вторичный кэш 128 Кбайт, который теперь разместили прямо на кристалле ядра. Достигнута частота 333 МГц, при этом кэш работает на частоте ядра. В перспективах частота ядра будет поднята до 366 и 400 МГц, а частота шины — до 100 МГц. Для мощных систем имеется процессор Pentium II Хеon с частотой ядра 400 и 450 МГц (частота шины 100 МГц), у которого вторичный кэш объемом до 2 Мбайт работает на частоте ядра. В 1999 году обещают процессор Katmai — развитие Pentium II: частота ядра 450 МГц и выше, расширенный набор инструкций ММХ2, известный под именем KNI (Katmai New Instructions). Предполагается развитие и линии Хеоп — процессоры с кодовым названием Tanner будут иметь инструкции KNI и частоту ядра, начиная с 500 МГц.

Конечно же, перечисленными моделями не исчерпывается весь мировой ассортимент микропроцессоров. Это только представители семейства процессоров, имеющих обобщенное название х86 (конечно, исключая 4- и 8-разрядные процессоры). Ряд фирм (например, AMD, Cyrix, IBM) выпускают процессоры, совместимые с перечисленными процессорами Intel и имеющие свои характерные особенности. Обычно они слегка отставали от изделей Intel, выпускаемых в то же время. Однако процессор К7 от AMD, похоже, потеснит Katmai (оба эти процессора должны появились в начале 1999 года), поскольку его архитектура гораздо богаче. Ряд фирм (DEC, Motorola, Texas Instruments, IBM) имеют разработки процессоров, существенно отличающиеся от семейства х86; есть другие классы процессоров и у Intel. Среди них присутствуют и гораздо более мощные процессоры, относящиеся как к RISC-, так и к CISC-архитектуре.

RISCReduced (Restricted) Instruction Set Computer — процессоры (компьютеры) с сокращенной системой команд. Эти процессоры обычно имеют набор однородных регистров универсального назначения; их система команд отличается относительной простотой. В результате аппаратная реализация такой архитектуры позволяет с небольшими затратами выполнять эти инструкции за минимальное (в пределе 1) число тактов синхронизации.

CISCComplete Instruction Set Computer — процессоры (компьютеры) с полным набором инструкций, к которым относится и семейство х86. Состав и назначение их регистров существенно неоднородны, широкий набор команд усложняет декодирование инструкций, на что расходуются аппаратные ресурсы. Возрастает число тактов, необходимое для выполнения инструкций.

Процессоры Pentium  имеют самую сложную в мире систему команд. Хорошо ли это, вопрос спорный (правда, это все-таки лучше, чем отечественные «самые большие в мире» интегральные схемы). Но в чем семейство х8б имеет бесспорное превосходство, так это по числу установленных процессоров — число IBM PC-совместимых компьютеров, проданных во всем мире, и представить-то трудно. В процессорах рассматриваемого семейства, начиная с 486, применяется комбинированная архитектура — CISC-процессор имеет RISC-ядро.

Семейство 80x86 фирмы Intel началось с 16-разрядного процессора 8086. Все старшие модели процессоров, в том числе 32-разрядные (386, 486, Pentium, Pentium Pro, Pentium II, Celeron) и с 64-разрядным расширением ММХ, включают в себя систему команд и программную модель предыдущих, обеспечивая совместимость с ранее написанным ПО.

  1.  
    Кэш-память

Функционально кэш-память предназначена для согласования скорости работы сравнительно медленных устройств, таких, например, как динамическая память, с относительно быстрым микропроцессором. Дело в том, что работа большинства элементов, на которых построен процессор, во многом похожа на работу ячеек статической памяти — триггеров. Поэтому их быстродействие существенно выше, нежели элементов динамической памяти. Использование кэш-памяти позволяет избежать циклов ожидания в его работе, которые снижают производительность всей системы.

Для пользователей IBM PC-совместимых компьютеров использование кэш-памяти началось еще с 386-х микропроцессоров. Для таких устройств, синхронизируемых, например, частотой 33 МГц, тактовый период составляет приблизительно 30 нc. Обычные микросхемы динамической памяти имеют время выборки от 60 до 100 нc. Отсюда, в частности, следует, что центральный процессор вынужден простаивать 2—3 периода тактовой частоты (то есть имеет 2—3 цикла ожидания), пока информация из соответствующих микросхем памяти установится на системной шине данных компьютера. Понятно, что в это время процессор не может выполнять никакую другую работу. Такая ситуация приводит к снижению общей производительности системы, что, разумеется, крайне нежелательно. Таким образом, узким местом системы становится оперативная динамическая память. Из этого положения существует, казалось бы, простой выход — использовать в качестве основной памяти достаточно быструю статическую. Однако если основную оперативную память выполнить на микросхемах статической памяти, то стоимость компьютера возрастет очень существенно. Таким образом, с помощью технологии обработки, использующей кэш-память, найден определенный компромисс между стоимостью и производительностью системы.

Заметим, что работа кэш-памяти практически "прозрачна" (то есть невидима) для пользователя. Тем не менее она очень важна. В IBM PC-совместимых компьютерах технология использования кэш-памяти помимо обмена данными между микропроцессором и основной оперативной памятью находит применение также между основной оперативной памятью и внешней (накопителями на сменных и несменных носителях).

  1.  Архитектура кэш-памяти

Прежде чем говорить об архитектуре кэш-памяти, введем такое понятие, как длина строки-кэша (cache-line). Если при обмене данными между устройствами речь обычно идет о блоке информации, то для кэш-памяти существует некий набор данных, называемых строкой.

Итак, архитектура кэш-памяти определяется тем, каким образом достаточно большая по размеру основная память отображается на сравнительно небольшой кэш. Существуют, вообще говоря, три разновидности отображения: кэш-память с прямым отображением (direct-mapped cache), частично, или наборно-ассоциативная (set-associative cache) и полностью ассоциативная (rally associative cache). Все эти архитектуры так или иначе используются для построения кэш-памяти современных микропроцессоров.

  1.  Кэш-память с прямым отображением

Самой простой организацией обладает кэш-память с прямым отображением. В этом случае адрес памяти полностью определяет используемую строку кэша. Таким образом, один или несколько блоков оперативной памяти строго соответствуют одной строке кэша, однако поскольку занимать ее в одно и то же время может только один из них, то для каждой строки используется специальный признак — тег (tag). Более подробно рассмотрим работу кэш-памяти с прямым отображением по схеме, изображенной на рис. 22.

Допустим, что гипотетический микропроцессор использует 10-разрядный адрес, размер кэша составляет 8 строк, а длина каждой строки — 8 байт. В какой-то момент времени процессор хочет прочитать два байта информации, хранимой в оперативной памяти, с адреса 0010001100. Для кэш-памяти этот адрес подразделяется на три части. В данном случае три младших разряда называются смещением (offset) и полностью определяют положение каждого из восьми байт в строке. Средние три разряда позволяют однозначно выбрать одну из восьми строк (line) кэша. Оставшиеся старшие разряды несут информацию о теге. И только в том случае, если тег строки кэша совпадает со значением, определяемым старшими разрядами адреса, байты информации считываются из кэшпамяти. В противном случае чтение должно идти из основной памяти или информация в строке должна быть заменена. Разумеется, в случае ее замены меняется и значение ее тега.

Преимуществом реализации такого типа архитектуры являются довольно низкие затраты, поскольку, по сути, требуется всего лишь одна операция сравнения (для тегов). Недостатки ее, впрочем, также очевидны. Например, если два блока данных основной памяти, используемые одинаково часто, претендуют на одну и ту же строку в кэше. Внешняя кэш-память с прямым отображением используется, например, вместе с 386-ми процессорами (кэш-контроллер 182385), а внутренняя — в микропроцессоре DEC Alpha 21064.

  1.  Полностью ассоциативная архитектура

Другим типом архитектуры является полностью ассоциативная кэш-память. В этом случае любой блок памяти может занимать любую строку кэша. Полный адрес памяти делится только на две части: младшие разряды — смещение в строке и старшие разряды — информация о теге (см. рис. 23). В этой архитектуре решена проблема конфликтов адресов, однако сама кэш-память требует для своей реализации больших аппаратных затрат, поскольку значения тегов должны уже сравниваться для всех линий кэша. Тем не менее микропроцессор 6х86 фирмы Cyrix, по некоторым данным, имеет вторичную встроенную 256-байтную кэшпамять для команд, которая имеет полностью ассоциативную архитектуру.

  1.  Наборно-ассоциативная архитектура

Разумным компромиссом между двумя рассмотренными архитектурами является наборно-ассоциативная организация кэшпамяти. В этом случае несколько линий (две, четыре, пять, восемь) объединяются в наборы, и средние биты адреса памяти определяют уже не конкретную линию (как в прямом отображении), а набор (см. рис. 24). Сравнение тегов (со значением старших разрядов) производится только для линий, входящих в набор. Подобную архитектуру имеет подавляющее число процессоров, например 486DX, 486DX2, IntelDX4, Pentium и т.д.

По количеству линий кэша, входящих в набор, подобная архитектура может называться 2-входовой (2-way set associative), 4-входовой (4-way set associative) и т.д.

  1.  Гарвардская и Принстонская архитектуры

Теперь, что касается разделения кэш-памяти на память для команд и отдельно для данных. Вообще говоря, подобная архитектура носит название Гарвардской (Harvard architecture) в отличие от смешанной — Принстонской (Princeton architecture). Последний тип кэш-памяти называется обычно "смешанной", поскольку она используется как для чтения команд, так и для переноса данных. Кстати, название "Гарвардская архитектура" связано с компьютером "Марк-1" (1950 год), который имел отдельную память для команд. В противоположность этому в Принстоне создавались компьютеры с единой памятью для команд и данных (архитектура Джона фон Неймана).

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

Смешанную кэш-память имеют процессоры Alpha фирмы DEC и 6х86 фирмы Cyrix. Более известный микропроцессор фирмы Intel Pentium использует раздельные 2-входовые наборно-ассоциативные кэши для команд и данных размером по 8 Кбайт.

  1.  Размеры кэш-памяти

Как известно, большинство микропроцессоров (за исключением суперскалярных) в компьютере работают последовательно, то есть выполняют все команды одну за другой. Однако в программах часто используются конструкции, включающие в себя циклы или переходы по некоторому условию. Разумеется, желательно, чтобы такие программные конструкции целиком помещались в кэш-память, так как в противном случае процессор для выполнения соответствующей инструкции будет вынужден снова обращаться к оперативной памяти, что приведет к выполнению им бесполезных циклов ожидания. При обмене данными возникает похожая проблема. Адреса данных, которые вскоре понадобятся процессору для обработки, лежат в большинстве случаев рядом с адресами данных, обрабатываемых непосредственно в это же время. Поэтому кэш-контроллер должен также заботиться о размещении всего блока данных в статической памяти.

Таким образом, что касается размера кэш-памяти, то для микропроцессоров, используемых в IBM PC-совместимых компьютерах, он колеблется от 0,5 (Chips&Technologies 38605SX/DX) до 16 Кбайт (IntelDX4). А вот в микропроцессорах Pentium OverDrive, Nx586 фирмы NexGen и ряде других общий размер кэш-памяти составляет уже 32 Кбайта. Стоит напомнить, что объем оперативной памяти IBM PC составлял 64 Кбайта.

Разумеется, работа кэш-памяти немыслима без собственного контроллера, впрочем, так же, как и работа большинства других типов памяти. Главное, чтобы при каждом обращении микропроцессора оперативная память и кэш обеспечивали целостность данных. Для этого имеется несколько возможностей.

  1.  Методы записи

Метод Write Through, называемый также методом сквозной записи, предполагает наличие двух копий данных — одной в основной памяти, а другой — в кэш-памяти. Каждый цикл записи процессора в память идет через кэш. Это обусловливает высокую загрузку системной шины, так как на каждую операцию модификации данных приходятся две операции записи. Поэтому каждое обновление содержимого кэш-памяти ощутимо сказывается на работе шины. С другой стороны, микропроцессор по-прежнему вынужден ожидать окончания процесса записи в основную память. Хотя следует отметить, что в основной памяти в этом случае всегда содержатся правильные данные. Такой метод используют, например, микропроцессоры 486 (SX, SX2, DX, DX2. DX4), за исключением изделий Cx486DX и Cx486DX2 фирмы Cyrix.

Метод Buffered Write Through является некой разновидностью метода Write Through и называется также методом с буферизированной сквозной записью. Для того чтобы как-то уменьшить загрузку шины, процесс записи выполняется в один или несколько буферов, которые работают по принципу FIFO (First InputFirst Output — "первым вошел — первым вышел"). Таким образом, цикл записи для микропроцессора заканчивается практически мгновенно (то есть когда данные записаны в буфер), хотя информация в основной памяти еще не сохранена. Сам же микропроцессор может выполнять дальнейшую обработку команд. Конечно, соответствующая логика управления должна заботиться о том, чтобы своевременно "опустошать" заполненные буферы. При использовании данного метода процессор полностью освобожден от работы с основной памятью.

При использовании метода Write Back, называемого также методом обратной записи, цикл записи микропроцессора происходит сначала в кэш-память, если там присутствует адрес приемника. Если адреса приемника в кэш-памяти не оказывается, то информация записывается непосредственно в память. Содержимое основной памяти обновляется только тогда, когда из кэш-памяти в нее записывается полный блок данных, то есть строка кэша. Прежде чем будет произведена замена содержимого строки кэша на новый блок памяти, старый блок должен быть перезаписан в основную память. Дело в том, что данные в этом блоке (если он использовался, разумеется) не совпадают с его данными (старыми) в основной памяти и являются единственной действительной копией. В противном случае произойдет нарушение целостности данных.

Во избежание подобной ситуации каждая строка кэша содержит служебные биты. Если происходит операция замены (replacement) содержимого данной строки, то благодаря соответствующим установкам этих битов вызывается операция обновления блока основной памяти, когда это необходимо. Преимуществом данного метода является намного меньшая загрузка системной шины, потому что на ней выполняется меньше циклов записи. Указанный метод записи, как правило, быстрее двух предыдущих. Однако для его организации требуются и более высокие затраты, особенно чтобы обеспечить целостность данных. Такой метод записи используется, например, микропроцессорами Pentium и Cx486DX и Cx486DX2 фирмы Cyrix.

  1.  Обновление информации

Каждый раз, когда микропроцессору требуется информация, отсутствующая в кэше (cache-miss), он вынужден обращаться через системную шину к основной оперативной памяти. После этого обычно решается, должна ли происходить замена строки в кэшпамяти и какая конкретно строка кэша будет заменена. В подавляющем большинстве случаев об этом заботится встроенный в контроллер LRU-алгоритм (Last Recently Used), который обновляет именно ту строку кэша, которая используется менее интенсивно.

  1.  Кэш в процессорах с умножением частоты

Особое значение кэш-память имеет для микропроцессоров, которые работают с умножением внешней тактовой частоты. Как известно, эти микропроцессоры обеспечивают новую технологию, при которой скорость работы внутренних блоков микропроцессора в два или более раз выше скорости остальной части системы. Тем самым появилась возможность объединения высокой производительности микропроцессора с высокой внутренней тактовой частотой (до 100 МГц и выше) и эффективной по стоимости системной платой компьютера. Внутренние функциональные узлы подобных микропроцессоров — математический сопроцессор (если есть), кэш, устройство управления памятью, арифметико-логическое устройство — используют умноженную тактовую частоту, в то время как остальные элементы системной платы — системная и внешняя кэшпамять, вспомогательные микросхемы — работают с обычной скоростью. Это позволяет увеличить производительность всей системы, как правило, за счет хранения части данных и выполняемых кодов программ именно во внутренней кэш-памяти.

Хотя процессоры уровня 486-х и выше имеют внутреннюю кэшпамять, так называемую кэш-память первого уровня (Level I, LI), все системные платы предусматривают установку и внешней (второго уровня, L2) кэш-памяти до 256 Кбайт для 486-х систем и от 512 Кбайт для систем на основе Pentium. В качестве такой кэшпамяти обычно используются микросхемы статического ОЗУ (SRAM) с временем доступа 15—20 нc. Благодаря наличию внешней кэш-памяти работа динамической памяти с 1—2 циклами ожидания не приводит к заметному понижению производительности, и практически во всех платах можно применять модули с временем выборки 70 нc.

Системные платы на основе процессоров Pentium могут использовать синхронную пакетную (synchronous burst) или конвейерную пакетную (pipelined burst) кэш-память, выполненную, разумеется, на элементах статической памяти. Пакетная SRAM-память отличается от обычной асинхронной тем, что для нее достаточно только первого адреса строки данных, так как все остальные получаются автоувеличением базового адреса по тактовым сигналам. В конвейерной же памяти плюс к этому для хранения пакета выбранных данных используются регистры-"защелки", за счет чего основная матрица памяти микросхемы может быть менее быстродействующей, нежели в случае стандартной пакетной SRAM. Это обуславливает, разумеется, и стоимость самой памяти.

Микросхемы для кэш-памяти выполнены обычно в корпусах типа DIP или SOP, которые либо устанавливаются в соответствующие DIP-панельки, либо распаиваются непосредственно на системной плате. Синхронная кэш-память может поставляться в виде специальных модулей COAST, которые внешне очень напоминают обычные SIMM-модули и устанавливаются в специальный разъем на системной плате. Заметим, кстати, что при использовании синхронной памяти быстродействие компьютера может возрасти примерно на 10—15%.

  1.  
    Разработка приложения.

  1.  Техническое задание.

Разработать приложение, визуализирующее механизм работы с CASH-памятью. Программа должна быть написана на языке программирования Delphi.

  1.  Интерфейс программы.

Основная форма приложения в оконном режиме, без возможности изменения размеров.

В верхней части расположена таблица визуализирующие адреса в памяти.

В нижней части расположены панельки визуализирующие работы Cash с прямым доступом, с полностью ассоциативным доступом и наборно-ассоциативным доступом.

В нижней части находиться кнопка для очистки CASH-а.

  1.  Алгоритм приложения.

При запуске программы происходит инициализация программы:

  •  Заполняется таблица адресов по порядку;
  •  Очищаются таблицы содержащие CASH.

Программа переходит в режим ожидания событий:

  •  Событие TFTable.TableSGClick (нажатие на таблицу адресов)

Считывается строка и столбец таблицы, считывается значение из ячейки по столбцу и строке, выводятся адрес в битовой форме в нижней части, для каждой из архитектуре согласно алгоритму заполняется таблицы и отображаются значения в таблицах CASH-а.

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

  •  Событие Button1 Click – очистка таблиц КЭШ.

Обнуляем все значения в таблицах CASH.

  1.  Исходный текст программы.

unit TableU;

interface

uses

 Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,

 Grids, StdCtrls, ExtCtrls;

type

 TFTable = class(TForm)

   TableSG: TStringGrid;

   PCashForv: TPanel;

   PCashAsociat: TPanel;

   PCashAsocNabor: TPanel;

   SGForv: TStringGrid;

   SGAsoc: TStringGrid;

   Timer1: TTimer;

   SGAsNab: TStringGrid;

   Label1: TLabel;

   Label2: TLabel;

   Label3: TLabel;

   Shape1: TShape;

   Shape2: TShape;

   Shape3: TShape;

   Shape4: TShape;

   Label4: TLabel;

   Label5: TLabel;

   Label6: TLabel;

   Label7: TLabel;

   Label8: TLabel;

   Label9: TLabel;

   Label10: TLabel;

   Label11: TLabel;

   Label12: TLabel;

   Label13: TLabel;

   Label14: TLabel;

   Label15: TLabel;

   Label16: TLabel;

   Label17: TLabel;

   Label18: TLabel;

   Label19: TLabel;

   Label20: TLabel;

   Label21: TLabel;

   Label22: TLabel;

   Label23: TLabel;

   Label24: TLabel;

   Label25: TLabel;

   Label26: TLabel;

   Label27: TLabel;

   Label28: TLabel;

   Label29: TLabel;

   Label30: TLabel;

   Label31: TLabel;

   Label32: TLabel;

   Label33: TLabel;

   Label34: TLabel;

   Label35: TLabel;

   Label36: TLabel;

   Label37: TLabel;

   Label38: TLabel;

   Label39: TLabel;

   Label40: TLabel;

   Label41: TLabel;

   Label42: TLabel;

   Label43: TLabel;

   Label44: TLabel;

   Label45: TLabel;

   Label46: TLabel;

   Label47: TLabel;

   Label48: TLabel;

   Label49: TLabel;

   Label50: TLabel;

   LabelForv: TLabel;

   LabelAs: TLabel;

   LabelAsNab: TLabel;

   Shape5: TShape;

   Shape6: TShape;

   Shape7: TShape;

   Label51: TLabel;

   Label52: TLabel;

   Label53: TLabel;

   Label54: TLabel;

   Shape8: TShape;

   Shape9: TShape;

   Label55: TLabel;

   Label56: TLabel;

   Shape10: TShape;

   Shape11: TShape;

   Shape12: TShape;

   Label57: TLabel;

   Label58: TLabel;

   Label59: TLabel;

   Label60: TLabel;

   Label61: TLabel;

   Label62: TLabel;

   Label63: TLabel;

   Label64: TLabel;

   Label65: TLabel;

   Label66: TLabel;

   Label67: TLabel;

   Label68: TLabel;

   Label69: TLabel;

   Label70: TLabel;

   Label71: TLabel;

   Label72: TLabel;

   Label73: TLabel;

   Label74: TLabel;

   Label75: TLabel;

   Label76: TLabel;

   Label77: TLabel;

   Label78: TLabel;

   Label79: TLabel;

   Label80: TLabel;

   Label81: TLabel;

   Label82: TLabel;

   Label83: TLabel;

   Button1: TButton;

   procedure FormCreate(Sender: TObject);

   procedure TableSGMouseMove(Sender: TObject; Shift: TShiftState; X,

     Y: Integer);

   procedure TableSGClick(Sender: TObject);

   procedure Timer1Timer(Sender: TObject);

 private

   { Private declarations }

 public

   { Public declarations }

 end;

var

 FTable: TFTable;

 Column,Row,CColumn,CRow, T: Longint;

 AsNabTime, ForvTime, AsocTime : array [0..7] of integer;

 Forv, Asoc : array [0..7 , 0..7] of boolean;

 AsNab : array [0..7, 0..3, 0..1] of boolean;

 ForvTEGArray, AsocTEGArray, AsNabTEGArray : array [0..7] of integer;

 Time : integer;

 ForvT, AsocT, AsNabT, ForvRow, AssocRow, ForvColumn, AssocColumn, AsNabRow, AsNabNabor, AsNabColumn: byte;

implementation

{$R *.DFM}

function dectobinF (Dec: integer):string;

var i,temp:integer;

   strtemp : string [1];

   str1, hex: string;

begin

 temp := Dec;

 i := 1;

 For i := 1 to 5 do

   begin

   str1 := inttostr (temp mod 2) + str1;

   temp := temp div 2;

   end;

 dectobinF := str1;

end;

function dectobinA (Dec: integer):string;

var i,temp:integer;

   strtemp : string [1];

   str1, hex: string;

begin

 temp := Dec;

 i := 1;

 For i := 1 to 8 do

   begin

   str1 := inttostr (temp mod 2) + str1;

   temp := temp div 2;

   end;

 dectobinA := str1;

end;

function dectobinAN (Dec: integer):string;

var i,temp:integer;

   strtemp : string [1];

   str1, hex: string;

begin

 temp := Dec;

 i := 1;

 For i := 1 to 6 do

   begin

   str1 := inttostr (temp mod 2) + str1;

   temp := temp div 2;

   end;

 dectobinAN := str1;

end;

function dectobin (Dec: integer):string;

var i,temp:integer;

   strtemp : string [1];

   str1, hex: string;

begin

 temp := Dec;

 i := 1;

 For i := 1 to 11 do

   begin

   str1 := inttostr (temp mod 2) + str1;

   temp := temp div 2;

   end;

 dectobin := str1;

end;

procedure TFTable.FormCreate(Sender: TObject);

var i,j,k :byte;

begin

 for j := 0 to TableSG.RowCount do

   for i := 0 to TableSG.ColCount do

     TableSG.Cells[i,j] := inttohex ((j + i*TableSG.RowCount),3);

 for i := 1  to 7 do

   for j := 0 to 7 do

     begin

       SgForv.Cells[i,j] := '';

       SGAsoc.Cells [i, j] := '';

       SGAsNab.Cells [i, j] := '';

     end;

 For i:= 0 to 7 do

   For j:= 0 to 7 do

     begin

       Forv[i,j] := false;

       Asoc[i,j] := false;

     end;

 For i := 0 to 7 do

   For j := 0 to 3 do

     For k := 0 to 1 do

       AsNab [i,j,k] := False;

 for i := 0 to 7 do

   begin

     AsNabTime [i] := 0;

     ForvTime [i] := 0;

     AsocTime [i] := 0;

     ForvTEGArray [i] := 0;

     AsocTEGArray [i] := 0;

     AsNabTEGArray [i] := 0;

   end;

 Label60.Color := ClWhite;

 Label61.Color := ClWhite;

 Label62.Color := ClWhite;

 Label63.Color := ClWhite;

 Label64.Color := ClWhite;

 Label65.Color := ClWhite;

 Label66.Color := ClWhite;

 Label67.Color := ClWhite;

 Label68.Color := ClWhite;

 Label69.Color := ClWhite;

 Label70.Color := ClWhite;

 Label71.Color := ClWhite;

 Label72.Color := ClWhite;

 Label73.Color := ClWhite;

 Label74.Color := ClWhite;

 Label75.Color := ClWhite;

 Label76.Color := ClWhite;

 Label77.Color := ClWhite;

 Label78.Color := ClWhite;

 Label79.Color := ClWhite;

 Label80.Color := ClWhite;

 Label81.Color := ClWhite;

 Label82.Color := ClWhite;

 Label83.Color := ClWhite;

 Label60.font.Color := ClBlack;

 Label61.font.Color := ClBlack;

 Label62.font.Color := ClBlack;

 Label63.font.Color := ClBlack;

 Label64.font.Color := ClBlack;

 Label65.font.Color := ClBlack;

 Label66.font.Color := ClBlack;

 Label67.font.Color := ClBlack;

 Label68.font.Color := ClBlack;

 Label69.font.Color := ClBlack;

 Label70.font.Color := ClBlack;

 Label71.font.Color := ClBlack;

 Label72.font.Color := ClBlack;

 Label73.font.Color := ClBlack;

 Label74.font.Color := ClBlack;

 Label75.font.Color := ClBlack;

 Label76.font.Color := ClBlack;

 Label77.font.Color := ClBlack;

 Label78.font.Color := ClBlack;

 Label79.font.Color := ClBlack;

 Label80.font.Color := ClBlack;

 Label81.font.Color := ClBlack;

 Label82.font.Color := ClBlack;

 Label83.font.Color := ClBlack;

 Label60.caption := dectobinF (0);

 Label61.caption := dectobinF (0);

 Label62.caption := dectobinF (0);

 Label63.caption := dectobinF (0);

 Label64.caption := dectobinF (0);

 Label65.caption := dectobinF (0);

 Label66.caption := dectobinF (0);

 Label67.caption := dectobinF (0);

 Label68.caption := dectobinA (0);

 Label69.caption := dectobinA (0);

 Label70.caption := dectobinA (0);

 Label71.caption := dectobinA (0);

 Label72.caption := dectobinA (0);

 Label73.caption := dectobinA (0);

 Label74.caption := dectobinA (0);

 Label75.caption := dectobinA (0);

 Label76.caption := dectobinAN (0);

 Label77.caption := dectobinAN (0);

 Label78.caption := dectobinAN (0);

 Label79.caption := dectobinAN (0);

 Label80.caption := dectobinAN (0);

 Label81.caption := dectobinAN (0);

 Label82.caption := dectobinAN (0);

 Label83.caption := dectobinAN (0);

 ForvT := 0;

 AsocT := 0;

 AsNabT := 0;

 Time := 0;

 T := 0;

end;

procedure TFTable.TableSGMouseMove(Sender: TObject; Shift: TShiftState; X,

 Y: Integer);

begin

  TableSG.MouseToCell(X, Y, Column, Row);

end;

procedure TFTable.TableSGClick(Sender: TObject);

var

 Adres,ForvTEG, AssocTEG, AsNabTeg, min, vrem : integer;

 i,j,k, ForvTemp, AsocTemp : byte;

 flag : boolean;

begin

 Time := Time +1;

 Adres := Row + Column * 32;

 LabelForv.Caption := dectobin (Adres);

 LabelAs.Caption := dectobin (Adres);

 LabelAsNab.Caption := dectobin (Adres);

 // Для Cash с прямым отображением

 ForvColumn := Adres mod 8;

 ForvRow := (Adres div 8) mod 8;

 ForvTEG := (Adres div 8) div 8;

 If  ForvTime [0] = 0 Then Label60.Color := ClWhite

 Else Label60.Color := ClYellow;

 If  ForvTime [1] = 0 Then Label61.Color := ClWhite

 Else Label61.Color := ClYellow;

 If  ForvTime [2] = 0 Then Label62.Color := ClWhite

 Else Label62.Color := ClYellow;

 If  ForvTime [3] = 0 Then Label63.Color := ClWhite

 Else Label63.Color := ClYellow;

 If  ForvTime [4] = 0 Then Label64.Color := ClWhite

 Else Label64.Color := ClYellow;

 If  ForvTime [5] = 0 Then Label65.Color := ClWhite

 Else Label65.Color := ClYellow;

 If  ForvTime [6] = 0 Then Label66.Color := ClWhite

 Else Label66.Color := ClYellow;

 If  ForvTime [7] = 0 Then Label67.Color := ClWhite

 Else Label67.Color := ClYellow;

 If  ForvTEGArray [ForvRow] <> ForvTEG

 Then

   begin

     ForvT := ForvTEGArray [ForvRow];

     ForvTEGArray [ForvRow] := ForvTEG;

     ForvTime [ForvRow] := Time;

     for i := 0 to 7 do

       Forv [i, ForvRow] := false;

     Forv [ForvColumn, ForvRow] := true;

     case ForvRow of

       0 : Label60.Color := ClRed;

       1 : Label61.Color := ClRed;

       2 : Label62.Color := ClRed;

       3 : Label63.Color := ClRed;

       4 : Label64.Color := ClRed;

       5 : Label65.Color := ClRed;

       6 : Label66.Color := ClRed;

       7 : Label67.Color := ClRed;

     end;

   end

 Else

   begin

     ForvT := ForvTEG;

     Forv [ForvColumn, ForvRow] := true;

     ForvTime [ForvRow] := Time;

     case ForvRow of

       0 : Label60.Color := ClGreen;

       1 : Label61.Color := ClGreen;

       2 : Label62.Color := ClGreen;

       3 : Label63.Color := ClGreen;

       4 : Label64.Color := ClGreen;

       5 : Label65.Color := ClGreen;

       6 : Label66.Color := ClGreen;

       7 : Label67.Color := ClGreen;

     end;

   end;

 If ForvRow = 0 Then Label60.Font.Color := clblue

 Else Label60.Font.Color := clblack;

 If ForvRow = 1 Then Label61.Font.Color := clblue

 Else Label61.Font.Color := clblack;

 If ForvRow = 2 Then Label62.Font.Color := clblue

 Else Label62.Font.Color := clblack;

 If ForvRow = 3 Then Label63.Font.Color := clblue

 Else Label63.Font.Color := clblack;

 If ForvRow = 4 Then Label64.Font.Color := clblue

 Else Label64.Font.Color := clblack;

 If ForvRow = 5 Then Label65.Font.Color := clblue

 Else Label65.Font.Color := clblack;

 If ForvRow = 6 Then Label66.Font.Color := clblue

 Else Label66.Font.Color := clblack;

 If ForvRow = 7 Then Label67.Font.Color := clblue

 Else Label67.Font.Color := clblack;

 Label60.Caption := dectobinF (ForvTEGArray [0]);

 Label61.Caption := dectobinF (ForvTEGArray [1]);

 Label62.Caption := dectobinF (ForvTEGArray [2]);

 Label63.Caption := dectobinF (ForvTEGArray [3]);

 Label64.Caption := dectobinF (ForvTEGArray [4]);

 Label65.Caption := dectobinF (ForvTEGArray [5]);

 Label66.Caption := dectobinF (ForvTEGArray [6]);

 Label67.Caption := dectobinF (ForvTEGArray [7]);

 For i := 0 to 7 do

   for j := 0 to 7 do

     if  Forv [i,j] Then SGForv.Cells [i,j] := 'X'

     Else  SGForv.Cells [i,j] := '';

// Для Асоциативного КЕШ

 AssocColumn := Adres mod 8;

 AssocTEG := Adres div 8;

 If  AsocTime [0] = 0 Then Label68.Color := ClWhite

 Else Label68.Color := ClYellow;

 If  AsocTime [1] = 0 Then Label69.Color := ClWhite

 Else Label69.Color := ClYellow;

 If  AsocTime [2] = 0 Then Label70.Color := ClWhite

 Else Label70.Color := ClYellow;

 If  AsocTime [3] = 0 Then Label71.Color := ClWhite

 Else Label71.Color := ClYellow;

 If  AsocTime [4] = 0 Then Label72.Color := ClWhite

 Else Label72.Color := ClYellow;

 If  AsocTime [5] = 0 Then Label73.Color := ClWhite

 Else Label73.Color := ClYellow;

 If  AsocTime [6] = 0 Then Label74.Color := ClWhite

 Else Label74.Color := ClYellow;

 If  AsocTime [7] = 0 Then Label75.Color := ClWhite

 Else Label75.Color := ClYellow;

 min := AsocTime [0];

 AssocRow := 0;

 For i := 1 to 7 do

   if AsocTime [i] < AsocTime [AssocRow] Then

     begin

       min := AsocTime [i];

       AssocRow := i;

     end;

 flag := false;

 For i:= 0 to 7 do

   if AsocTEGArray [i] = AssocTEG

   Then

     Begin

       AssocRow := i;

       flag := true;

     end;

   if flag Then

     begin

       case AssocRow of

         0 : Label68.Color := ClGreen;

         1 : Label69.Color := ClGreen;

         2 : Label70.Color := ClGreen;

         3 : Label71.Color := ClGreen;

         4 : Label72.Color := ClGreen;

         5 : Label73.Color := ClGreen;

         6 : Label74.Color := ClGreen;

         7 : Label75.Color := ClGreen;

       end;

     end

   Else

     begin

       for j := 0 to 7 do Asoc [j, AssocRow] := false;

       case AssocRow of

         0 : Label68.Color := ClRed;

         1 : Label69.Color := ClRed;

         2 : Label70.Color := ClRed;

         3 : Label71.Color := ClRed;

         4 : Label72.Color := ClRed;

         5 : Label73.Color := ClRed;

         6 : Label74.Color := ClRed;

         7 : Label75.Color := ClRed;

       end;

     end;

 AsocT := AsocTEGArray [AssocRow];

 AsocTEGArray [AssocRow] := AssocTEG;

 Asoc [AssocColumn, AssocRow] := true;

 AsocTime [AssocRow] := Time;

 If AssocRow = 0 Then Label68.Font.Color := clblue

 Else Label68.Font.Color := clblack;

 If AssocRow = 1 Then Label69.Font.Color := clblue

 Else Label69.Font.Color := clblack;

 If AssocRow = 2 Then Label70.Font.Color := clblue

 Else Label70.Font.Color := clblack;

 If AssocRow = 3 Then Label71.Font.Color := clblue

 Else Label71.Font.Color := clblack;

 If AssocRow = 4 Then Label72.Font.Color := clblue

 Else Label72.Font.Color := clblack;

 If AssocRow = 5 Then Label73.Font.Color := clblue

 Else Label73.Font.Color := clblack;

 If AssocRow = 6 Then Label74.Font.Color := clblue

 Else Label74.Font.Color := clblack;

 If AssocRow = 7 Then Label75.Font.Color := clblue

 Else Label75.Font.Color := clblack;

 Label68.Caption := dectobinA (AsocTEGArray [0]);

 Label69.Caption := dectobinA (AsocTEGArray [1]);

 Label70.Caption := dectobinA (AsocTEGArray [2]);

 Label71.Caption := dectobinA (AsocTEGArray [3]);

 Label72.Caption := dectobinA (AsocTEGArray [4]);

 Label73.Caption := dectobinA (AsocTEGArray [5]);

 Label74.Caption := dectobinA (AsocTEGArray [6]);

 Label75.Caption := dectobinA (AsocTEGArray [7]);

 For i := 0 to 7 do

   for j := 0 to 7 do

     if  Asoc [i,j] Then SGAsoc.Cells [i,j] := 'X'

     Else  SGAsoc.Cells [i,j] := '';

// Для Ассоциативно-наборного КЕШ

 AsNabColumn := Adres mod 8;

 AsNabNabor := (adres div 8) mod 4;

 AsNabTeg := (adres div 8) div 4;

 If  AsNabTime [0] = 0 Then Label76.color := ClWhite

 Else Label76.Color := ClYellow;

 If  AsNabTime [1] = 0 Then Label77.Color := ClWhite

 Else Label77.Color := ClYellow;

 If  AsNabTime [2] = 0 Then Label78.Color := ClWhite

 Else Label78.Color := ClYellow;

 If  AsNabTime [3] = 0 Then Label79.Color := ClWhite

 Else Label79.Color := ClYellow;

 If  AsNabTime [4] = 0 Then Label80.Color := ClWhite

 Else Label80.Color := ClYellow;

 If  AsNabTime [5] = 0 Then Label81.Color := ClWhite

 Else Label81.Color := ClYellow;

 If  AsNabTime [6] = 0 Then Label82.Color := ClWhite

 Else Label82.Color := ClYellow;

 If  AsNabTime [7] = 0 Then Label83.Color := ClWhite

 Else Label83.Color := ClYellow;

 AsNabRow := 0;

 min := AsNabTime [AsNabNabor*2];

 For i := 0 to 1 do

   if AsNabTime [AsNabNabor*2 + i] < min

   Then

     begin

       AsNabRow := i;

       min := AsNabTime [AsNabNabor*2 + i];

     end;

 flag := false;

 For i := 0 to 1 do

   if AsNabTEGArray [AsNabNabor*2 + i] = AsNabTeg

   Then

     begin

       AsNabRow := i;

       flag := true;

     end;

 if flag Then

       case (AsNabNabor*2 + AsNabRow) of

         0 : Label76.Color := ClGreen;

         1 : Label77.Color := ClGreen;

         2 : Label78.Color := ClGreen;

         3 : Label79.Color := ClGreen;

         4 : Label80.Color := ClGreen;

         5 : Label81.Color := ClGreen;

         6 : Label82.Color := ClGreen;

         7 : Label83.Color := ClGreen;

      end

 Else

   begin

     for j := 0 to 7 do AsNab [j, AsNabNabor, AsNabRow] := false;

     case (AsNabNabor*2 + AsNabRow) of

         0 : Label76.Color := ClRed;

         1 : Label77.Color := ClRed;

         2 : Label78.Color := ClRed;

         3 : Label79.Color := ClRed;

         4 : Label80.Color := ClRed;

         5 : Label81.Color := ClRed;

         6 : Label82.Color := ClRed;

         7 : Label83.Color := ClRed;

     end;

   end;

 AsNabT := AsNabTEGArray [AsNabNabor*2 + AsNabRow];

 AsNabTEGArray [AsNabNabor*2 + AsNabRow] := AsNabTeg;

 AsNab [AsNabColumn, AsNabNabor, AsNabRow] := true;

 AsNabTime [AsNabNabor*2 + AsNabRow] := Time;

 If (AsNabNabor*2 + AsNabRow) = 0 Then Label76.Font.Color := clblue

 Else Label76.Font.Color := clblack;

 if (AsNabNabor*2 + AsNabRow) = 1 Then Label77.Font.Color := clblue

 Else Label77.Font.Color := clblack;

 If (AsNabNabor*2 + AsNabRow) = 2 Then Label78.Font.Color := clblue

 Else Label78.Font.Color := clblack;

 If (AsNabNabor*2 + AsNabRow) = 3 Then Label79.Font.Color := clblue

 Else Label79.Font.Color := clblack;

 If (AsNabNabor*2 + AsNabRow) = 4 Then Label80.Font.Color := clblue

 Else Label80.Font.Color := clblack;

 If (AsNabNabor*2 + AsNabRow) = 5 Then Label81.Font.Color := clblue

 Else Label81.Font.Color := clblack;

 If (AsNabNabor*2 + AsNabRow) = 6 Then Label82.Font.Color := clblue

 Else Label82.Font.Color := clblack;

 If (AsNabNabor*2 + AsNabRow) = 7 Then Label83.Font.Color := clblue

 Else Label83.Font.Color := clblack;

 For i := 0 to 7 do

   for j := 0 to 3 do

     for k := 0 to 1 do

       if  AsNab [i,j,k] Then SGAsNab.Cells [i,j*2+k] := 'X'

       Else  SGAsNab.Cells [i,j*2+k] := '';

 Label76.Caption := dectobinAN (AsNabTEGArray [0]);

 Label77.Caption := dectobinAN (AsNabTEGArray [1]);

 Label78.Caption := dectobinAN (AsNabTEGArray [2]);

 Label79.Caption := dectobinAN (AsNabTEGArray [3]);

 Label80.Caption := dectobinAN (AsNabTEGArray [4]);

 Label81.Caption := dectobinAN (AsNabTEGArray [5]);

 Label82.Caption := dectobinAN (AsNabTEGArray [6]);

 Label83.Caption := dectobinAN (AsNabTEGArray [7]);

 timer1.Enabled := true;

end;

procedure TFTable.Timer1Timer(Sender: TObject);

begin

 if (T mod 2) = 0 then

   begin

     case ForvRow of

       0 : Label60.Caption := dectobinF (ForvT);

       2 : Label62.Caption := dectobinF (ForvT);

       3 : Label63.Caption := dectobinF (ForvT);

       4 : Label64.Caption := dectobinF (ForvT);

       5 : Label65.Caption := dectobinF (ForvT);

       6 : Label66.Caption := dectobinF (ForvT);

       7 : Label67.Caption := dectobinF (ForvT);

     end;

       case AssocRow of

         0 : Label68.Caption := dectobinA (AsocT);

         1 : Label69.Caption := dectobinA (AsocT);

         2 : Label70.Caption := dectobinA (AsocT);

         3 : Label71.Caption := dectobinA (AsocT);

         4 : Label72.Caption := dectobinA (AsocT);

         5 : Label73.Caption := dectobinA (AsocT);

         6 : Label74.Caption := dectobinA (AsocT);

         7 : Label75.Caption := dectobinA (AsocT);

       end;

       case (AsNabNabor*2 + AsNabRow) of

         0 : Label76.Caption := dectobinAN (AsNabT);

         1 : Label77.Caption := dectobinAN (AsNabT);

         2 : Label78.Caption := dectobinAN (AsNabT);

         3 : Label79.Caption := dectobinAN (AsNabT);

         4 : Label80.Caption := dectobinAN (AsNabT);

         5 : Label81.Caption := dectobinAN (AsNabT);

         6 : Label82.Caption := dectobinAN (AsNabT);

         7 : Label83.Caption := dectobinAN (AsNabT);

       end;

   end

 else

   begin

     case ForvRow of

       0 : Label60.Caption := dectobinF (ForvTEGArray [ForvRow]);

       1 : Label61.Caption := dectobinF (ForvTEGArray [ForvRow]);

       2 : Label62.Caption := dectobinF (ForvTEGArray [ForvRow]);

       3 : Label63.Caption := dectobinF (ForvTEGArray [ForvRow]);

       4 : Label64.Caption := dectobinF (ForvTEGArray [ForvRow]);

       5 : Label65.Caption := dectobinF (ForvTEGArray [ForvRow]);

       6 : Label66.Caption := dectobinF (ForvTEGArray [ForvRow]);

       7 : Label67.Caption := dectobinF (ForvTEGArray [ForvRow]);

     end;

       case AssocRow of

         0 : Label68.Caption := dectobinA (AsocTEGArray [AssocRow]);

         1 : Label69.Caption := dectobinA (AsocTEGArray [AssocRow]);

         2 : Label70.Caption := dectobinA (AsocTEGArray [AssocRow]);

         3 : Label71.Caption := dectobinA (AsocTEGArray [AssocRow]);

         4 : Label72.Caption := dectobinA (AsocTEGArray [AssocRow]);

         5 : Label73.Caption := dectobinA (AsocTEGArray [AssocRow]);

         6 : Label74.Caption := dectobinA (AsocTEGArray [AssocRow]);

         7 : Label75.Caption := dectobinA (AsocTEGArray [AssocRow]);

       end;

       case (AsNabNabor*2 + AsNabRow) of

         0 : Label76.Caption := dectobinAN (AsNabTEGArray [AsNabNabor*2 + AsNabRow]);

         1 : Label77.Caption := dectobinAN (AsNabTEGArray [AsNabNabor*2 + AsNabRow]);

         2 : Label78.Caption := dectobinAN (AsNabTEGArray [AsNabNabor*2 + AsNabRow]);

         3 : Label79.Caption := dectobinAN (AsNabTEGArray [AsNabNabor*2 + AsNabRow]);

         4 : Label80.Caption := dectobinAN (AsNabTEGArray [AsNabNabor*2 + AsNabRow]);

         5 : Label81.Caption := dectobinAN (AsNabTEGArray [AsNabNabor*2 + AsNabRow]);

         6 : Label82.Caption := dectobinAN (AsNabTEGArray [AsNabNabor*2 + AsNabRow]);

         7 : Label83.Caption := dectobinAN (AsNabTEGArray [AsNabNabor*2 + AsNabRow]);

       end;

   end;

 T := T + 1 ;

end;

end.

  1.  Описание программы.

  1.  Краткое описание и минимальные требования.

Название приложения – VisualCASH.

Запускаемый файл – VisCASH.exe

Для установки программы необходимо скопировать файл VisCASH.exe на жесткий диск. Создать ярлык для запускаемого файла и разместить его в то место, откуда наиболее удобно запускать приложение.

Минимальные требования:

  •  Процессор Pentium 66МГ;
  •  Оперативная память 16 МБ;
  •  Место на жестком диске 700 кБ;
  •  SVGA 1024x768.
  •  Манипулятор “Мышь”

  1.  Оборудование применявшееся  при разработке приложения.

При разработке программы  «VisualCASH» использовался персональный компьютер со следующей конфигурацией:

  •  процессор AMD-Duron 750
  •  материнская плата Chaintech на чипсете VIA KT133;
  •  видеокарта Asus -Force MX-400
  •  SDRAM DIMM 133 Мгц 384 Mб
  •  HDD Western Digital 60 Гб UDMA100
  •  CD-ROM Asus 40x
  •  Creative Sound Blaster life 5.1

ОС Microsoft Windows 2000 Professional

  1.  
    Заключение.

В ходе выполнения данного курсового проекта было создано приложение визуализирующее работу cash-памяти в 3-х архитектурах

После проведенных тестов делаем следующие выводы:

  1.  Программа работоспособна и вероятность получения правильных данных близка к ста процентам;
  2.  Вероятность отказа программы минимальна.

  1.  
    Используемая литература.

  1.  М. Гук «Процессоры  Pentium II, Pentium Pro и просто Pentium».

  1.  А. Борзенко «IBM PC: устройство, ремонт, можернизация»

  1.  Электронная встроення гипертекстовая справочна ситема «Borland Delphi».

Электронная встроення гипертекстовая справочна ситема «Windows SDK».


 

А также другие работы, которые могут Вас заинтересовать

70102. Многомерная безусловная оптимизация (методы первого и нулевого порядков) 373 KB
  Цель работа: знакомство с методами многомерной безусловной оптимизации первого и нулевого порядка и их освоение, сравнение эффективности применения этих методов конкретных целевых функций.
70104. Статистический анализ параметров и показателей надежности 55.77 KB
  Цель работы Ознакомиться с методами статистического анализа надежности систем. Исходные данные В соответствии с вариантом получаем выборочные значения: N=40
70107. Автоматизация проектирования схем, содержащих триггеры и счётчики 2.15 MB
  Используя программу Electronics Workbench собрать схему для исследования асинхронного RSтриггера с инверсными входами базис ИНЕ на каждом входе поставить контакт реле составить полную таблицу истинности работы триггера.
70108. Многотабличные запросы 127.5 KB
  В секции FROM указывается источник данных – таблица или итоговый набор. Секция может содержать несколько источников, разделенных запятыми. Результат подобного перечисления функционально эквивалентен перекрестному объединению.
70109. Подготовка к установке OC Windows XP в среде VirtualBox 69.5 KB
  Анализ аппаратного обеспечения ПК Определите и запишите основные технические характеристики и конфигурацию вашего ПК в виде: Тип модель процессора его тактовая частота объем кеша Тип материнской платы и ёё тактовую частоту Тип оперативной памяти ёё объем и частоту работы...