Подякувати Студентському архіву довільною сумою
Admin
26.02.2023 12:38
Дякуємо, що користуєтесь нашим архівом!
Дослідження програмної моделі блоків DCACHE і ІCACHE з моделі RISC CPU
Інформація про навчальний заклад
ВУЗ:
Національний університет Львівська політехніка
Інститут:
Не вказано
Факультет:
Не вказано
Кафедра:
Кафедра ЕОМ
Інформація про роботу
Рік:
2012
Тип роботи:
Звіт до лабораторної роботи
Предмет:
Комп’ютерні системи
Частина тексту файла (без зображень, графіків і формул):
Міністерство освіти і науки України
Національний університет «Львівська політехніка»
Кафедра ЕОМ
Звіт
до лабораторної роботи №6
з дисципліни: «Комп’ютерні системи»
на тему:
«Дослідження програмної моделі блоків DCACHE і ІCACHE
з моделі RISC CPU»
Львів – 2012
Мета роботи:
1. Дослідити програмну модель блоків DCACHE і ІCACHE, які входять до
складу програмної моделі RISK CPU, створеної на мові SystemC.
2. Побудувати структурну схему блоків DCACHE і ІCACHE.
Програмна модель блоку DCACHE:
dcache.h:
struct dcache : sc_module {
sc_in<signed> datain; // input data
sc_in<unsigned> statein; // input state bit MESI(=3210)
sc_in<bool> cs; // chip select
sc_in<bool> we; // write enable
sc_in<unsigned > addr; // address
sc_in<unsigned> dest; // write back to which register
sc_out<unsigned> destout; // write back to which register
sc_out<signed> dataout; // dataram data out
sc_out<bool> out_valid; // output valid
sc_out<unsigned> stateout; // state output
sc_in_clk CLK;
// Parameter
unsigned *dmemory; // data memory
unsigned *dsmemory; // data state memory
unsigned *dtagmemory; // tag memory
int wait_cycles; // cycles # it takes to access dmemory
void init_param(int given_delay_cycles) {
wait_cycles = given_delay_cycles;
}
//Constructor
SC_CTOR(dcache) {
SC_CTHREAD(entry, CLK.pos());
// initialize instruction dmemory from external file
FILE *fp = fopen("dcache","r");
int size=0;
int i=0;
unsigned mem_word;
dmemory = new unsigned[4000];
dsmemory = new unsigned[4000];
dtagmemory = new unsigned[4000];
printf("** ALERT ** DCU: initialize Data Cache\n");
while (fscanf(fp,"%x", &mem_word) != EOF) {
dmemory[size] = mem_word;
dsmemory[size] = 0;
dtagmemory[size] = size;
size++;
}
for (i=size; i<4000; i++) {
dtagmemory[i] = 0xdeadbeef;
dmemory[i] = 0xdeadbeef;
dsmemory[i] = 0;
}
}
// Process functionality in member function below
void entry();
};
dcache.cpp:
#include <iostream.h>
#include "systemc.h"
#include "dcache.h"
#include "directive.h"
void dcache::entry()
{
unsigned int address; // address to DataCache
unsigned int reg_tmp=0;
unsigned int dest_tmp = 0;
while (true) {
wait_until(cs.delayed() == true);
dest_tmp = dest.read();
reg_tmp = dest.read();
address = addr.read();
if (we.read() == true) { // Write operation
wait();
out_valid.write(false);
dmemory[address] = datain.read();
dsmemory[address] = statein.read();
dtagmemory[address] = addr.read();
cout << "\t\t\t\t\t\t\t-------------------------------" << endl;
printf("\t\t\t\t\t\t\tDCU :St %x->mem[%d]", dmemory[address], address);
cout << " at CSIM " << sc_time_stamp() << endl;
cout << "\t\t\t\t\t\t\t-------------------------------" << endl;
wait();
}
else { // Read operation
wait();
dataout.write(dmemory[address]);
stateout.write(dsmemory[address]);
destout.write(dest_tmp);
out_valid.write(true);
cout << "\t\t\t\t\t\t\t-------------------------------" << endl;
printf("\t\t\t\t\t\t\tDCU :ld %d<-mem[%d]->R%d\n", dmemory[address], address, dest_tmp);
printf("\t\t\t\t\t\t\tDCU :Tag = 0x%x", dtagmemory[address]);
if (dsmemory[address] == 3) {
printf(" (M)");
} else if (dsmemory[address] == 2) {
printf(" (E)");
} else if (dsmemory[address] == 1) {
printf(" (S)");
} else if (dsmemory[address] == 0) {
printf(" (I)");
} else
printf(" (X)");
cout << " at CSIM " << sc_time_stamp() << endl;
cout << "\t\t\t\t\t\t\t-------------------------------" << endl;
wait();
out_valid.write(false);
wait();
}
}
}
Рис. 1. Структурна схема блока DCACHE
icache.h:
#define BOOT_LENGTH 5
#define MAX_CODE_LENGTH 500
struct icache : sc_module {
sc_in<unsigned > datain; // modified instruction
sc_in<bool> cs; // chip select
sc_in<bool> we; // write enable for SMC
sc_in<unsigned > addr; // address
sc_in<bool> ld_valid; // load valid
sc_in<signed> ld_data; // load data value
sc_out<unsigned > dataout; // ram data out
sc_out<bool> icache_valid; // output valid
sc_out<bool> stall_fetch; // stall fetch if busy
sc_in_clk CLK;
// Parameter
unsigned *icmemory; // icache data memory
unsigned *ictagmemory; // icache tag memory
signed int pid; // process ID
int wait_cycles; // Number of cycles it takes to access imemory
void init_param(int given_delay_cycles) {
wait_cycles = given_delay_cycles;
}
//Constructor
SC_CTOR(icache) {
SC_CTHREAD(entry, CLK.pos());
// initialize instruction icmemory from external file
pid = 0;
FILE *fp = fopen("icache","r");
int size=0;
unsigned mem_word;
icmemory = new unsigned[MAX_CODE_LENGTH];
ictagmemory = new unsigned[MAX_CODE_LENGTH];
for (size = 0; size < MAX_CODE_LENGTH; size++) { // initialize bad data
icmemory[size] = 0xeeeeeeee;
ictagmemory[size] = 0xeeeeeeee;
}
size = 0;
while (fscanf(fp,"%x", &mem_word) != EOF) {
icmemory[size] = mem_word;
ictagmemory[size] = size;
size++;
}
}
// Process functionality in member function below
void entry();
};
icahce.cpp:
#include <iostream.h>
#include "systemc.h"
#include "icache.h"
#include "directive.h"
void icache::entry()
{
unsigned int address;
while (true) {
wait_until(cs.delayed() == true);
address = addr.read();
if (address == BOOT_LENGTH) {
printf("ICU ALERT: *********************************************************************\n");
printf(" : *****************************AFTER RESET*****************************\n");
printf("ICU ALERT: *********************************************************************\n");
}
if (address >= BOOT_LENGTH) {
if (ld_valid.read() == true) {
pid = ld_data.read();
printf("------------------------\n");
printf("ICU: PID = [%d]", pid);
cout << " at CSIM " << sc_time_stamp() << endl;
printf("------------------------\n");
wait();
wait();
}
if (we.read() == true) { // Write operation
wait();
if (address < MAX_CODE_LENGTH && address >= 0)
icmemory[address] = datain.read();
else
printf("ICU ALERT: **MEMORY OUT OF RANGE**\n");
wait();
}
else { // Read operation
wait(); // Introduce delay needed
if (address >= MAX_CODE_LENGTH || address < 0) {
dataout.write(0xffffffff);
printf("ICU ALERT: **MEMORY OUT OF RANGE**\n");
}
else
dataout.write(icmemory[address]);
icache_valid.write(true);
if (PRINT_ICU) {
printf("------------------------\n");
printf("ICU: fetching mem[%d]\n", address);
if (address < MAX_CODE_LENGTH && address >= 0)
printf("ICU: (%0x)", icmemory[address]);
cout.setf(ios::dec,ios::basefield);
cout << " at CSIM " << sc_time_stamp() << endl;
printf("------------------------\n");
}
wait();
icache_valid.write(false);
wait();
}
}
}
}
Рис. 2. Структурна схема блока ICACHE
Висновок: на даній лабораторній роботі дослідив програмну модель блоків DCACHE і ІCACHE, які входять до складу програмної моделі RISK CPU, створеної на мові SystemC. Побудував структурну схему блоків DCACHE і ІCACHE.
22.09.2013 19:09-
Ділись своїми роботами та отримуй миттєві бонуси!
0%
Оголошення від адміністратора