Wiki - Вклад участника [ru]

Спец курс (Избранные главы VHDL)/Верификация описания

2012-11-19T14:56:06Z

164.177.206.33: /* Слайд: Конструктор (SC_CTOR) */

<slideshow style="custis" headingmark="Слайд:" incmark=":step" scaled="true" >
;title: '''Верификация описания.'''
;author: Зайцев В.С.
</slideshow>

[[Файл:SystemC_From_the_ground_up.mm]]

==Слайд:Верификация описания==
[[Файл:Процевв_верификации.png]]

==Слайд:Верификация описания:step==
*{{Гол|''' <big>Среда моделирования</big>'''}}
** Active-HDL™
** Riviera-PRO™
** NC-Sim®
** ModelSim®
** QuestaSim®
** VCS-MX®
* {{Гол|'''<big>Структура проекта</big>'''}}
** Тестовое окружение
** RTL-модель (Verilog,VHDL)
** Эталонная модель (SystemC)
** Assert'ы (psl, OVVM, UVM)
** Отчеты и базы по результатам моделирования

==Слайд:Эталонная модель на языке ''{{Зел| <big>SystemC</big>}}''==

# Высокий уровень абстракции
# Скорость моделирования
# Возможности языка C++
# Инструменты для автоматизации
# Совместное моделирование с другими HDL-языками

== Основы языка SystemC ==

===Слайд:Типы данных (Форматы и способ представления данных) ===
[[Файл:Типы_данных.png]]

===Слайд:Типы данных (native)===
<source lang="cpp"> // Пример типа данных C++
int spark_offset;
unsigned repairs = 0 ; // Count repair
unsigned long mileage; // Miles driven
short int speedometer; // -20.. 0.. 100 MPH
float temperature; // Engine temp in C
double time_of_last_request; //Time of bus
std:: string license_plate; // Text for license
const bool WARNING_LIGHT = true; // Status
enum compass {SW,W,NW,N,NE,E, SE, S} ;
</source>

===Слайд:Типы данных (Arithmetic)===
<source lang="cpp"> // Пример целочисленных типов данных C++
sc_int<LENGTH> NAME...;
sc_uint<LENGTH> NAME...;
sc_bigint<BITWIDTH> NAME...;
sc_biguint<BITWIDTH> NAME...;
// SystemC integer data types
sc_int<5> seat_position=3; //5 bits: 4 plus sign
sc_uint<13> days_SLOC(4000); //13 bits: no sign
sc_biguint<80> revs_SLOC; // 80 bits: no sign
</source>

===Слайд:Типы данных (Boolean)===
<source lang="cpp"> // Пример типа данных SystemC
sc_bit NAME...;
sc_bv<BITWIDTH> NAME...;
</source>

* sc_bit и sc_bv могут принимать значения: '''SC_LOGIC_1''' и '''SC_LOGIC_0.'''
* Для сокращения типов, можно использовать '''Log_1 и Log_0''' или '''‘1’ и ‘0’.'''
* Над этим типом данных возможно выполнение битовых операций '''and, or, xor (&,|, ^).'''
* Для обращения к отдельным битам и массивам '''[], range()'''.

<source lang="cpp">
sc_bit flag(SC_LOGIC_1); // more efficient to use bool
sc_bv<5> positions = "01101";
sc_bv<6> mask = "100111";
sc_bv<5> active = positions & mask;// 00101
sc_bv<1> all = active. and_reduce (); // SC_LOGIC_0
positions. range (3,2) = "00"; // 00001
positions [2] = active[0] ^ flag;
</source>

===Слайд:Типы данных ( многозначные (ZX10))===
<source lang="cpp"> // Пример типа данных SystemC
sc_logic NAME[,NAME]...;
sc_lv<BITNIDTH> NAME[,NAME ]...;
sc_logic buf(sc_dt::Log_Z);
sc_lv<8> data_drive ("zz01XZ1Z");
data_drive.range (5,4) = "ZZ";// ZZZZXZ1Z
buf = '1';

</source>

===Слайд:Операторы SystemC ===
[[Файл:Операции.png]]

===Слайд:Главный модуль MAIN===
{{Гол|'''<big>Описание на языке C++</big>'''}}
<source lang="cpp">
int main(int argc, char* argv[]) {
BODY_OF_PROGRAM
return EXIT_CODE; //
}
</source>

{{Гол|'''<big>Описание на языке SystemC</big>'''}}
<source lang="cpp">
int sc_main(int argc, char* argv[]) {
//ELABORATION
sc_start(); // <-- Simulation begins & ends
// in this function!
//[POST-PROCESSING]
return EXIT_CODE; //
}
</source>

===Слайд: Модуль ===
<source lang="cpp">
#include <systemc.h>
SC_MODULE(module_name) {
MODULE_BODY
};</source>
Содержит:
* '''{{Фио|<big>Порты</big>}}'''
* '''{{Фио|<big>Каналы связи</big>}}'''
* '''{{Фио|<big>Объявления переменных для хранения данных</big>}}'''
* '''{{Фио|<big>Другие модули с большей вложенностью</big>}}'''
* '''{{Фио|<big>Конструктор</big>}}'''
* '''{{Фио|<big>Деструктор</big>}}'''
* '''{{Фио|<big>Функции -процессы</big>}}'''
* '''{{Фио|<big>Вспомогательные функции</big>}}'''

===Слайд: Конструктор (SC_CTOR)===
<source lang="cpp">
SC_CTOR(module_name)
: Initialization // могут отсутствовать объявления и инициализация сигналов
{
Subdesign_Allocation
Subdesign_Connectivity
Process_Registration
Miscellaneous_Setup
}</source>

* '''{{Фио|<big>Объявление под модулей</big>}}'''
* '''{{Фио|<big>Подключение и соединение с подмодулями</big>}}'''
* '''{{Фио|<big>Регистрация процессов на SystemC</big>}}'''
* '''{{Фио|<big>Объявление списка чувствительности</big>}}'''
* '''{{Фио|<big>Разнообразные пользовательские объявления</big>}}'''

===Слайд: Конструктор (SC_HAS_PROCESS)===
<source lang="cpp">
//FILE: module_name.h
SC_MODULE(module_name) {
SC_HAS_PROCESS(module_name);
module_name(sc_module_name instname[, other_args…])
: sc_module(instname)
[, other_initializers]
{
CONSTRUCTOR_BODY
}
};</source>

* '''{{Фио|<big>Все возможности конструктора SC_CTOR</big>}}'''
* '''{{Фио|<big>Альтернативный метод создания модуля</big>}}'''
* '''{{Фио|<big>Позволяет создавать конструктор с аргументами(+ к имени модуля)</big>}}'''
* '''{{Фио|<big>Используется, если желаете расположить конструктор в файле описания .cpp (не в файле .h)</big>}}'''

===Слайд: Процесс SC_THREAD ===

<source lang="cpp">
SC_MODULE(simple_process_ex) {
SC_CTOR(simple_process_ex) {
SC_THREAD(my_thread_process);
}
void my_thread_process(void);
};</source>

{{Зел|'''SC_THREAD'''}} в '''SystemC''':
# аналог {{Зел|'''initial block'''}} в '''Verilog'''
# {{Зел|'''process'''}} без списка чувствительности с оператором '''wait()''' в '''VHDL'''.

===Слайд:Введение времени===

{{Ор|<big>'''Единицы измерения времени'''</big>}}

<source lang="cpp">
SC_SEC // seconds
SC_MS // milliseconds
SC_US // microseconds
SC_NS // nanoseconds
SC_PS // picoseconds
SC_FS // femtoseconds
</source>
{{Ор|<big>'''Объявление переменной типа '''</big>}}{{Зел|<big>'''sc_time'''</big>}}
<source lang="cpp">
sc_time t_PERIOD(5, SC_NS) ;
sc_time t_TIMEOUT (100, SC_MS) ;
sc_time t_MEASURE, t_CURRENT, t_LAST_CLOCK;
t_MEASURE = (t_CURRENT-t_LAST_CLOCK) ;
if (t_MEASURE > t_HOLD) { error ("Setup violated") }
</source>

===Слайд:Запуск выполнения '''sc_start()'''===

{{Ор|<big>'''Функция запускающая выполнения главного процесса '''</big>}}

{{Сн|'''Пример запуска моделирования на 60 секунд модельного времени'''}}

<source lang="cpp">
int sc_main(int argc, char* argv[]) { // args unused
simple_process_ex my_instance ("my_instance");
sc_start(60.0,SC_SEC); // Limit sim to one minute
return 0 ;
}</source>

===Слайд:Контроль текущего времени моделирования '''sc_time_stamp ()'''===

<source lang="cpp">
std::cout << " The time is now "
<< sc_time_stamp()
<< "!" << std::endl;</source>

После запуска моделирования в консоли получим
The time is now 0 ns!

===Слайд: Остановка выполнения моделирования wait(sc_time)===

{{Ор|<big>'''Функция останавливающая выполнение процесса до заданного времени или до прихода события'''</big>}}

<source lang="cpp">
void simple_process_ex::my_thread_process (void) {
wait (10,SC_NS);
std::cout<< "Now at "<< sc_time_stamp() << std::endl;
sc_time t_DELAY(2,SC_MS); // keyboard debounce time
t_DELAY *= 2;
std::cout<< "Delaying "<< t_DELAY<< std::endl;
wait(t_DELAY);
std::cout << "Now at " << sc_time_stamp()
<< std::endl;
}</source>

% . /run_example
Now at 10 ns
Delaying 4 ms
Now at 4000010 ns

===Слайд:События '''sc_event'''===
<slides split="-----" width="400" >
[[Файл:Процес_моделирования_по_событиям.png]]
</slides>

===Слайд:События '''SC_THREAD::wait()'''===
Процесс '''SC_THREAD''' процес выполняющийся {{Кр|'''<big>один раз!!</big>'''}}, для управления работой такого процесса используют функцию задержки выполнения wait

<source lang="cpp">wait(time);
wait(event);
wait(event1 | event2) // до прихода любого из событий
wait(event1 & event2) // до прихода всех событий вместе
wait(timeout, event); // до прихода события ожидает в течении времени
wait ( timeout, event1 | event2 )
wait ( timeout, event1 & event2 )
wait(); // ожидание дельта цикла выполнения, статическая задержка
</source>
===Слайд:Запуск события (установка,назначение)===

Для запуска события используется атрибут {{Зел|<big>'''.notify()'''</big>}}

Он выполняет запуск событий, отсчет времени идет от запуска моделирования. Для сброса точки отсчета используют {{Зел|<big>'''.cancel()'''</big>}}

<source lang="cpp">sc_event action;
sc_time now(sc_time_stamp()); //вытягиваем текущее время моделирования
//стартуем событие немедленно
action.notify();
//следующее событие через 20 ms от текущего момента
action.notify(20, SC_MS);
//переопределим событие на время 1.5 ns от текущего момента
action.notify(1.5,SC_NS);
//продублируем событие (не имеет эффекта)
action.notify(1.5, SC_NS);
//зададим событие от предыдущего на 1.5 ns
action.notify(3.0,SC_NS);
//запустим дельта цикл (не имеет эффекта)
action.notify(SC_ZERO_TIME);
//сбросим время задания события
action.cancel();
//зададим событие на 20 fs после сброса
action.notify(20,SC_FS);</source>

===Слайд:Процесс со списком чувствительности SC_METHOD ===
{{ЖЛампа|24px}}Аналог '''process''' в '''VHDL'''

<source lang="cpp">SC_METHOD(process_name);</source>

{{ЖЛампа|24px}}Список чуствительности задаеться после ключевого слова {{Зел|'''sensitive'''}}

<source lang="cpp"> sensitive << event [<< event] ;// поточный стил
sensitive (event [, event] ); // стиль с использованием функции</source>

===Слайд:dont_initialize() ===
{{ЖЛампа|24px}} Отменяет начальную установку значений
* После запуска моделирования конструктор создает модуль и инициализирует все процессы и переменные.

* Это заставляет выполниться всем методам работающим по событию по одному разу во время запуска если событие устанавливалось в значение.

* Для исключения начального выполнения используется функция '''dont_initialize()'''

===Слайд: Стек событий '''sc_event_queue'''===

{{ЖЛампа|24px}} Событие можно задать не только от начального момента времени, а и от текущего.

Для этого используется функция '''sc_event_queue()'''

<source lang="cpp">
sc_event_queue action;
sc_time now(sc_time_stamp());
action.notify(20, SC_MS);
action.notify(1.5,SC_NS);
action.notify(1.5,SC_NS);
action.notify(3.0,SC_NS);
action.notify(SC_ZERO_TIME);
action.notify(1,SC_SEC);
action.cancel_all();
</source>

===Слайд:Совместное использование ресурсов===

* При совместном использовании ресурсов, шин, памяти нужно разграничить область полномочий каждого процесса.
* Иначе при одновременной, к примеру записи будет происходить сбой или некорректная запись.
Если управлением доступом к одному ресурсу
<source lang="cpp">sc_mutex NAME;
// блокируем mutex NAME (ждем пока разблокируется)
NAME.lock();
// Возвращает статус состояния блокировки
NAME.try lock()
// Снимает блокировку
NAME.unlock();</source>

Если управлением доступом к нескольким ресурсам

<source lang="cpp">sc_semaphore NAME(COUNT);
// блокируем mutex NAME (ждем пока разблокируеться)
NAME.wait();
// Возвращает статус состояния блокировки
NAME.trywait()
//Возвращает число свободных ресурсов
NAME.get_value()
// Снимает блокировку
NAME.post();</source>

===Слайд:Иерархия и структура проекта===
[[Файл:Иерархия.png]]

===Слайд:Иерархия и структура проекта (sc_main)===

{{ЖЛампа|24px}}Подключение и создание {{Зел|<big>'''модуля'''</big>}} внутри '''главного''' модуля аналогично созданию {{Зел|<big>'''объекта'''</big>}} заданного{{Зел| <big>'''класса'''</big>}}
{{Фио|<big>'''Стандартная конструкция блока хранения информации для RFID'''</big>}}
{| cellspacing="0" cellpadding="0" border="1"
|
* {{Гол|'''Статический метод'''}}
<source lang="cpp">//FILE: main.cpp
#include "Wheel.h"
int sc_main(int argc, char* argv[]) {
Wheel wheel_FL("wheel_FL");
Wheel wheel_FR("wheel_FR");
sc_start();
}</source>
|
* {{Гол|'''Динамический метод'''}}
<source lang="cpp">//FILE: main.cpp
#include "Wheel.h"
int sc_main(int argc, char* argv[]) {
Wheel* wheel_FL; // pointer to FL wheel
Wheel* wheel_FR; // pointer to FR wheel
wheel_FL = new Wheel ("wheel_FL"); // create FL
wheel_FR = new Wheel ("wheel_FR"); // create FR
sc_start();
delete wheel_FL;
delete wheel_FR;
}</source>
|}

===Слайд:Иерархия и структура проекта (SC_MODULE)===

{{ЖЛампа|24px}}Подключение и создание {{Зел|<big>'''модуля'''</big>}} внутри другого модуля аналогично созданию {{Зел|<big>'''объекта'''</big>}} заданного{{Зел| <big>'''класса'''</big>}}, внутри другого класса. Поэтому объявления производиться в конструкторе верхнего модуля
{| cellspacing="0" cellpadding="0" border="1"
|

* {{Гол|'''Статический метод'''}}
<source lang="cpp">//FILE:Body.h
#include "Wheel.h"
SC_MODULE(Body) {
Wheel wheel_FL;
Wheel wheel_FR;
SC_CTOR(Body)
: wheel_FL("wheel_FL"), //initialization
wheel_FR("wheel_FR") //initialization
{
// other initialization
}
};
}</source>
|
* {{Гол|'''Динамический метод'''}}
<source lang="cpp">//FILE:Body.h
#include "Wheel.h"
SC_MODULE(Body) {
Wheel* wheel_FL;
Wheel* wheel_FR;
SC_CTOR(Body) {
wheel_FL = new Wheel("wheel_FL");
wheel_FR = new Wheel("wheel_FR");
// other initialization
}
};
}</source>
|}

===Слайд:Порты - точки подачи и снятия внешних воздействий===
[[Файл:Порты_соединение_модулей.png]]

===Слайд:Типы портов ===

* {{Сн|'''sc_port'''}} - аналог inout порта в языке VHDL
* {{Сн|'''sc_in'''}} - аналог in порта в языке VHDL
* {{Сн|'''sc_out'''}} - аналог out порта в языке VHDL
* {{Сн|'''sc_export'''}} - внешний порт, порт который позволяет получить доступ к private данным модуля, но иерархически модулю не принадлежит.
{{ЖЛампа|24px}} Механизм использования '''sc_export''' порта напоминает '''доступ к сигналам по иерархии''', как в '''VHDL-2008'''.

===Слайд:Порты - точки подачи и снятия внешних воздействий===
[[Файл:Порты_соединение_модулей_экспорт.png]]
[[Файл:Порты_соединение_модулей_экспорт2.png]]

===Слайд:Управление процессом и контроль статуса моделирования===

== Слайд: VHDL и SystemC конструкции ==
===Слайд: Entity ===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример поведенческой модели накопителя (VHDL)'''}}
<source lang="vhdl">
entity soft is
generic (UART_Speed : integer := 115200; -- UART Speed
System_CLK : integer := 50000000; -- System CLK in Hz
comand_file : string :="/home/Vidokq/djin18reader/vhd/D18/comfile.txt"
);
port (
CLK : out std_logic; -- system clk
RST_N : out std_logic; -- system reset#
DATA_IN : out std_logic_vector(7 downto 0); -- Transmit data
DATA_OUT : in std_logic_vector(7 downto 0); -- Recieved data
RX_VALID : in std_logic; -- RX buffer data ready
TX_VALID : out std_logic; -- Data for TX avaible
TX_BUSY : in std_logic; --
RX_BUSY : in std_logic);

end soft;
</source>

|
{{Фио|'''<big></big>Пример поведенческой модели накопителя (Verilog)'''}}

<source lang="cpp">

SC_MODULE (soft_sc_module)
{
public :
sc_in < sc_logic > tx_busy;
sc_in < sc_logic > rx_busy;
sc_in < sc_lv < 8 > > data_out;
sc_in < sc_logic > rx_valid;
sc_out < sc_logic > tx_valid;
sc_out < bool > clk;
sc_out < sc_logic > rst_n;
sc_out < sc_lv < 8 > > data_in;

public:

ifstream fin;

SC_CTOR(soft_sc_module)
: rst_n("rst_n"),
data_in("data_in"),
data_out ("data_out"),
rx_valid("rx_valid"),
tx_valid("tx_valid"),
tx_busy("tx_busy"),
rx_busy("rx_busy"),
rst_n_i("rst_n_i"),
clk_i("clk_i"),
clk("clk")
{
}
~soft_sc_module()
{
delete [] str_b;
}
};

#endif
</source>
|}
</slides>

===Слайд: Architecture ===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример Архитектуры на VHDL'''}}
<source lang="vhdl">

architecture beh of soft is
file comfile : text open read_mode is comand_file;

begin -- beh
-- тело архитектуры
signal str : string(1 to 1000) := (others => ' ');
signal RST_N_i : std_logic;
signal DATA_IN_i : std_logic_vector(7 downto 0);
signal f_get_answer : boolean := false;
signal tmd : time := 0 ms;

end beh;
</source>

|
{{Фио|'''<big></big>Пример аналогичной конструкции на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public :
std::string comand_file;
public :
sc_signal< sc_logic > rst_n_i;
sc_signal< sc_lv < 8 > > data_in_i;
sc_signal < bool > f_get_answer;
sc_signal < sc_time > tmd;
sc_time btmd (0, SC_MS);
SC_CTOR(soft_sc_module)
:
rst_n_i("rst_n_i"),
data_in_i("data_in_i"),
f_get_answer("f_get_answer"),
tmd("tmd")
{
str = new char [1000];
//объявление функций
//выбор списка чувствительности
//установка значений по умолчанию
tmd.write(btmd);
// tmd = btmd;
//оператор присваивания перегружен и выолнит вызов функции write
}
~soft_sc_module()
{
delete [] str;
}
</source>
|}
</slides>

===Слайд: Generic ===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
entity soft is
generic (UART_Speed : integer := 115200;
System_CLK : integer := 50000000
);
--
--
--
architecture beh of soft is
CLK_i <= not CLK_i after 1 ns * (1000000000 / System_CLK );
end beh;
</source>

|
{{Фио|'''<big></big>Пример на SystemC (sc_get_param)'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module)
: rst_n("rst_n"),
tmd("tmd")
{
if (!sc_get_param("System_CLK",System_CLK)) cout << "error get generic";
if (!sc_get_param("UART_Speed",UART_Speed)) cout << "error get generic";
period_ns=(1000000000)/System_CLK;
str = new char [1000];
}
~soft_sc_module()
{
delete [] str_b;
}
};
</source>
|}
</slides>

===Слайд: Process без списка чувствительности ===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
wait_byte_timer: process
begin -- process wiat_timer
wait for 0.5 ms;
if (NOW - tmd) > 1 ms then
if f_start_get_answer then
f_byte_timer <= true;
wait for 0.1 ms;
f_byte_timer <= false;
end if;
end if;
end process wait_byte_timer;
</source>

|
{{Фио|'''<big></big>Пример на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module):
{ SC_METHOD (wait_byte_timer); }
~soft_sc_module()
{ }
};
void soft_sc_module :: wait_byte_timer ()
{
next_trigger (0.5,SC_MS);
if ((sc_time_stamp()-tmd) > sc_time(1, SC_MS) )
if (f_start_get_answer)
{f_byte_timer=true;
next_trigger (0.1,SC_MS);
f_byte_timer=false;
}
cout<< "wait_byte_timer work\n";
}
</source>
|}
</slides>

===Слайд: Process со списком чувствительности (пример 1)===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
CLK_i <= not CLK_i after 1 ns * (1000000000 / System_CLK );
--или
process (clk)
begin
if clk'event then
clk_i <= not clk_i after 1 ns * (1000000000 / System_CLK );
end if;
end process;
</source>
|
{{Фио|'''<big></big>Пример на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module):
{ clk_i=true;
period_ns=(1000000000)/System_CLK;
SC_METHOD (clk_gen);
}
~soft_sc_module()
{ }
};

void soft_sc_module :: clk_gen ()
{
clk_i.write(!clk_i.read());
next_trigger (period_ns, SC_NS);

}
</source>
|}
</slides>

===Слайд: Process со списком чувствительности (пример 2) ===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
RST_N <= RST_N_i;
--или
process (RST_N_i)
begin
if RST_N_i'event then
RST_N <= RST_N_i;
end if;
end process;
</source>
|
{{Фио|'''<big></big>Пример на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module):
{ clk_i=true;
SC_METHOD (rst_n_i2rst_n);
sensitive << rst_n_i;
dont_initialize();
}
~soft_sc_module()
{ }
};

void soft_sc_module :: reset_gen ()
{
rst_n_i.write( SC_LOGIC_0 );
wait (100, SC_NS);
cout << "run reset";
rst_n_i.write( SC_LOGIC_1 );
}
</source>
|}
</slides>

===Слайд: Работа с файлами ===
<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
p_send : process
variable l : line;
variable byte_r : std_logic_vector(0 to 7);
variable good : boolean;
variable f_first_byte : boolean:=false;
begin -- process p1

loop1: while not endfile(comfile) loop

readline (comfile,l);
skip_space (l);
next loop1 when l'length = 0;

for i in 1 to l'length loop
str(i) <= l(i);
end loop; -- i
str((l'length)+1 to 1000) <= (others => ' ');
str_l <= l'length;
</source>
|
<source lang="vhdl">
if l(1) = '#' then
assert false report "коментарий:"&str(1 to str_l) severity NOTE;
else
assert false report "коментарий"&str(1 to str_l) severity NOTE;
f_first_byte := true;
while l'length /= 0 loop
hread (l,byte_r,good);
assert good report "ошибка" severity FAILURE;
if f_first_byte then
f_first_byte := false;
comand <= byte_r;
end if;
TX_VALID_i <= '1';
DATA_IN_i <= byte_r;
skip_space (l);
wait until TX_BUSY = '1';
end loop;
f_start_timer <= true;
TX_VALID_i <= '0';
wait until f_get_answer or f_timer;
assert not f_timer report "1мкс" severity FAILURE;
f_start_timer <= false;
end if;
end loop;
assert false report "======" severity failure;
end process p_send;
</source>
|}
</slides>

===Слайд: Работа с файлами ===
<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на SystemC'''}}
<source lang="cpp">
void soft_sc_module :: p_send ()
{
fin.open(comand_file.c_str(),ios::out);
cout << "work4\n";
bool f_first_byte=false;
if (!fin){
std::cout << "File invalide open";
exit (0);
}
while (!fin.eof()){
fin.getline (str,1000);
skip_space (&(str));
if (strlen(str)){
if (str[0] == '#')
cout << "koment: "<< str <<endl;
else {
cout << "data: "<< str <<endl;
f_first_byte=true;
//while ( str[0] != '\0' ){
while ( strlen(str) ){
if ( str[0] == ' ' )
skip_space(&(str));
else {
//cout << "1/2\n";
byte_b.range(7,4)=str[0];
str++;
skip_space(&(str));
if (!strlen(str)){
cout<<endl<<"error";
sc_stop();
}
else {
//cout << "2/2\n";
byte_b.range(3,0)=str[0];
str++;
}
</source>
|
<source lang="cpp">

if (f_first_byte){
f_first_byte=false;
comand=byte_b;
}
//cout << byte_b << endl;
tx_valid_i.write(SC_LOGIC_1);
data_in.write(byte_b);
wait (tx_busy.posedge_event());
}
}
f_start_timer = true;
tx_valid_i.write(SC_LOGIC_0);
wait ( f_get_answer.posedge_event() | f_timer.posedge_event() );
if ( f_timer ) {cout << "error";sc_stop();}
f_start_timer = false;
}
}
str=str_b;
}
cout << "error";
fin.close();
sc_stop();
}
</source>
|}
</slides>

===Слайд: Работа с функциями ===
<slides split="-----" width="600" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
entity soft is
end soft;

architecture beh of soft is

procedure skip_space (variable l : inout line) is
variable char : character;
variable flag : boolean:=true;
begin -- skip_space
while flag loop
if l'length = 0 then
flag := false;
elsif l(1) = ' ' then
read(l, char);
else
flag := false;
end if;
end loop;
end skip_space;
end beh;
</source>
|
{{Фио|'''<big></big>Пример на SystemC'''}}
<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module):
{ SC_METHOD (wait_byte_timer); }

void skip_space (char ** str);
~soft_sc_module()
{ }
};
void soft_sc_module :: skip_space (char ** str)
{
bool flag = true;

while ( flag ) { //
if ( !strlen((*str)) )
flag = false;
else
if ((*str)[0]==' ')
(*str) += 1;
else
flag = false;
}
}

</source>
|}
</slides>

===Слайд: Работа с сигналами ===
===Слайд: Арифметические, логические, операции присваивания ===
===Слайд: Конструкции С++ ===
===Слайд: Создание модуля ===
===Слайд: Коммуникации между модулями ===
===Слайд: Управление процессом моделирования (сообщения, запуск останов моделирования)===
== Слайд: Компиляция описания ==
== Слайд: Запуск моделирования только SystemC описания ==
== Слайд: Запуск моделирования SystemC описания и VHDL ==

Спец курс (Избранные главы VHDL)/Верификация описания

2012-11-19T14:45:44Z

164.177.206.33: /* Слайд: Работа с переменными */

<slideshow style="custis" headingmark="Слайд:" incmark=":step" scaled="true" >
;title: '''Верификация описания.'''
;author: Зайцев В.С.
</slideshow>

[[Файл:SystemC_From_the_ground_up.mm]]

==Слайд:Верификация описания==
[[Файл:Процевв_верификации.png]]

==Слайд:Верификация описания:step==
*{{Гол|''' <big>Среда моделирования</big>'''}}
** Active-HDL™
** Riviera-PRO™
** NC-Sim®
** ModelSim®
** QuestaSim®
** VCS-MX®
* {{Гол|'''<big>Структура проекта</big>'''}}
** Тестовое окружение
** RTL-модель (Verilog,VHDL)
** Эталонная модель (SystemC)
** Assert'ы (psl, OVVM, UVM)
** Отчеты и базы по результатам моделирования

==Слайд:Эталонная модель на языке ''{{Зел| <big>SystemC</big>}}''==

# Высокий уровень абстракции
# Скорость моделирования
# Возможности языка C++
# Инструменты для автоматизации
# Совместное моделирование с другими HDL-языками

== Основы языка SystemC ==

===Слайд:Типы данных (Форматы и способ представления данных) ===
[[Файл:Типы_данных.png]]

===Слайд:Типы данных (native)===
<source lang="cpp"> // Пример типа данных C++
int spark_offset;
unsigned repairs = 0 ; // Count repair
unsigned long mileage; // Miles driven
short int speedometer; // -20.. 0.. 100 MPH
float temperature; // Engine temp in C
double time_of_last_request; //Time of bus
std:: string license_plate; // Text for license
const bool WARNING_LIGHT = true; // Status
enum compass {SW,W,NW,N,NE,E, SE, S} ;
</source>

===Слайд:Типы данных (Arithmetic)===
<source lang="cpp"> // Пример целочисленных типов данных C++
sc_int<LENGTH> NAME...;
sc_uint<LENGTH> NAME...;
sc_bigint<BITWIDTH> NAME...;
sc_biguint<BITWIDTH> NAME...;
// SystemC integer data types
sc_int<5> seat_position=3; //5 bits: 4 plus sign
sc_uint<13> days_SLOC(4000); //13 bits: no sign
sc_biguint<80> revs_SLOC; // 80 bits: no sign
</source>

===Слайд:Типы данных (Boolean)===
<source lang="cpp"> // Пример типа данных SystemC
sc_bit NAME...;
sc_bv<BITWIDTH> NAME...;
</source>

* sc_bit и sc_bv могут принимать значения: '''SC_LOGIC_1''' и '''SC_LOGIC_0.'''
* Для сокращения типов, можно использовать '''Log_1 и Log_0''' или '''‘1’ и ‘0’.'''
* Над этим типом данных возможно выполнение битовых операций '''and, or, xor (&,|, ^).'''
* Для обращения к отдельным битам и массивам '''[], range()'''.

<source lang="cpp">
sc_bit flag(SC_LOGIC_1); // more efficient to use bool
sc_bv<5> positions = "01101";
sc_bv<6> mask = "100111";
sc_bv<5> active = positions & mask;// 00101
sc_bv<1> all = active. and_reduce (); // SC_LOGIC_0
positions. range (3,2) = "00"; // 00001
positions [2] = active[0] ^ flag;
</source>

===Слайд:Типы данных ( многозначные (ZX10))===
<source lang="cpp"> // Пример типа данных SystemC
sc_logic NAME[,NAME]...;
sc_lv<BITNIDTH> NAME[,NAME ]...;
sc_logic buf(sc_dt::Log_Z);
sc_lv<8> data_drive ("zz01XZ1Z");
data_drive.range (5,4) = "ZZ";// ZZZZXZ1Z
buf = '1';

</source>

===Слайд:Операторы SystemC ===
[[Файл:Операции.png]]

===Слайд:Главный модуль MAIN===
{{Гол|'''<big>Описание на языке C++</big>'''}}
<source lang="cpp">
int main(int argc, char* argv[]) {
BODY_OF_PROGRAM
return EXIT_CODE; //
}
</source>

{{Гол|'''<big>Описание на языке SystemC</big>'''}}
<source lang="cpp">
int sc_main(int argc, char* argv[]) {
//ELABORATION
sc_start(); // <-- Simulation begins & ends
// in this function!
//[POST-PROCESSING]
return EXIT_CODE; //
}
</source>

===Слайд: Модуль ===
<source lang="cpp">
#include <systemc.h>
SC_MODULE(module_name) {
MODULE_BODY
};</source>
Содержит:
* '''{{Фио|<big>Порты</big>}}'''
* '''{{Фио|<big>Каналы связи</big>}}'''
* '''{{Фио|<big>Объявления переменных для хранения данных</big>}}'''
* '''{{Фио|<big>Другие модули с большей вложенностью</big>}}'''
* '''{{Фио|<big>Конструктор</big>}}'''
* '''{{Фио|<big>Деструктор</big>}}'''
* '''{{Фио|<big>Функции -процессы</big>}}'''
* '''{{Фио|<big>Вспомогательные функции</big>}}'''

===Слайд: Конструктор (SC_CTOR)===
<source lang="cpp">SC_CTOR(module_name)
: Initialization // OPTIONAL
{
Subdesign_Allocation
Subdesign_Connectivity
Process_Registration
Miscellaneous_Setup
}</source>

* '''{{Фио|<big>Объявление под модулей</big>}}'''
* '''{{Фио|<big>Подключение и соединение с подмодулями</big>}}'''
* '''{{Фио|<big>Регистрация процессов на SystemC</big>}}'''
* '''{{Фио|<big>Обеспечение постоянной чувствительности</big>}}'''
* '''{{Фио|<big>Разнообразные пользовательские объявления</big>}}''

===Слайд: Конструктор (SC_HAS_PROCESS)===
<source lang="cpp">
//FILE: module_name.h
SC_MODULE(module_name) {
SC_HAS_PROCESS(module_name);
module_name(sc_module_name instname[, other_args…])
: sc_module(instname)
[, other_initializers]
{
CONSTRUCTOR_BODY
}
};</source>

* '''{{Фио|<big>Все возможности конструктора SC_CTOR</big>}}'''
* '''{{Фио|<big>Альтернативный метод создания модуля</big>}}'''
* '''{{Фио|<big>Позволяет создавать конструктор с аргументами(+ к имени модуля)</big>}}'''
* '''{{Фио|<big>Используется, если желаете расположить конструктор в файле описания .cpp (не в файле .h)</big>}}'''

===Слайд: Процесс SC_THREAD ===

<source lang="cpp">
SC_MODULE(simple_process_ex) {
SC_CTOR(simple_process_ex) {
SC_THREAD(my_thread_process);
}
void my_thread_process(void);
};</source>

{{Зел|'''SC_THREAD'''}} в '''SystemC''':
# аналог {{Зел|'''initial block'''}} в '''Verilog'''
# {{Зел|'''process'''}} без списка чувствительности с оператором '''wait()''' в '''VHDL'''.

===Слайд:Введение времени===

{{Ор|<big>'''Единицы измерения времени'''</big>}}

<source lang="cpp">
SC_SEC // seconds
SC_MS // milliseconds
SC_US // microseconds
SC_NS // nanoseconds
SC_PS // picoseconds
SC_FS // femtoseconds
</source>
{{Ор|<big>'''Объявление переменной типа '''</big>}}{{Зел|<big>'''sc_time'''</big>}}
<source lang="cpp">
sc_time t_PERIOD(5, SC_NS) ;
sc_time t_TIMEOUT (100, SC_MS) ;
sc_time t_MEASURE, t_CURRENT, t_LAST_CLOCK;
t_MEASURE = (t_CURRENT-t_LAST_CLOCK) ;
if (t_MEASURE > t_HOLD) { error ("Setup violated") }
</source>

===Слайд:Запуск выполнения '''sc_start()'''===

{{Ор|<big>'''Функция запускающая выполнения главного процесса '''</big>}}

{{Сн|'''Пример запуска моделирования на 60 секунд модельного времени'''}}

<source lang="cpp">
int sc_main(int argc, char* argv[]) { // args unused
simple_process_ex my_instance ("my_instance");
sc_start(60.0,SC_SEC); // Limit sim to one minute
return 0 ;
}</source>

===Слайд:Контроль текущего времени моделирования '''sc_time_stamp ()'''===

<source lang="cpp">
std::cout << " The time is now "
<< sc_time_stamp()
<< "!" << std::endl;</source>

После запуска моделирования в консоли получим
The time is now 0 ns!

===Слайд: Остановка выполнения моделирования wait(sc_time)===

{{Ор|<big>'''Функция останавливающая выполнение процесса до заданного времени или до прихода события'''</big>}}

<source lang="cpp">
void simple_process_ex::my_thread_process (void) {
wait (10,SC_NS);
std::cout<< "Now at "<< sc_time_stamp() << std::endl;
sc_time t_DELAY(2,SC_MS); // keyboard debounce time
t_DELAY *= 2;
std::cout<< "Delaying "<< t_DELAY<< std::endl;
wait(t_DELAY);
std::cout << "Now at " << sc_time_stamp()
<< std::endl;
}</source>

% . /run_example
Now at 10 ns
Delaying 4 ms
Now at 4000010 ns

===Слайд:События '''sc_event'''===
<slides split="-----" width="400" >
[[Файл:Процес_моделирования_по_событиям.png]]
</slides>

===Слайд:События '''SC_THREAD::wait()'''===
Процесс '''SC_THREAD''' процес выполняющийся {{Кр|'''<big>один раз!!</big>'''}}, для управления работой такого процесса используют функцию задержки выполнения wait

<source lang="cpp">wait(time);
wait(event);
wait(event1 | event2) // до прихода любого из событий
wait(event1 & event2) // до прихода всех событий вместе
wait(timeout, event); // до прихода события ожидает в течении времени
wait ( timeout, event1 | event2 )
wait ( timeout, event1 & event2 )
wait(); // ожидание дельта цикла выполнения, статическая задержка
</source>
===Слайд:Запуск события (установка,назначение)===

Для запуска события используется атрибут {{Зел|<big>'''.notify()'''</big>}}

Он выполняет запуск событий, отсчет времени идет от запуска моделирования. Для сброса точки отсчета используют {{Зел|<big>'''.cancel()'''</big>}}

<source lang="cpp">sc_event action;
sc_time now(sc_time_stamp()); //вытягиваем текущее время моделирования
//стартуем событие немедленно
action.notify();
//следующее событие через 20 ms от текущего момента
action.notify(20, SC_MS);
//переопределим событие на время 1.5 ns от текущего момента
action.notify(1.5,SC_NS);
//продублируем событие (не имеет эффекта)
action.notify(1.5, SC_NS);
//зададим событие от предыдущего на 1.5 ns
action.notify(3.0,SC_NS);
//запустим дельта цикл (не имеет эффекта)
action.notify(SC_ZERO_TIME);
//сбросим время задания события
action.cancel();
//зададим событие на 20 fs после сброса
action.notify(20,SC_FS);</source>

===Слайд:Процесс со списком чувствительности SC_METHOD ===
{{ЖЛампа|24px}}Аналог '''process''' в '''VHDL'''

<source lang="cpp">SC_METHOD(process_name);</source>

{{ЖЛампа|24px}}Список чуствительности задаеться после ключевого слова {{Зел|'''sensitive'''}}

<source lang="cpp"> sensitive << event [<< event] ;// поточный стил
sensitive (event [, event] ); // стиль с использованием функции</source>

===Слайд:dont_initialize() ===
{{ЖЛампа|24px}} Отменяет начальную установку значений
* После запуска моделирования конструктор создает модуль и инициализирует все процессы и переменные.

* Это заставляет выполниться всем методам работающим по событию по одному разу во время запуска если событие устанавливалось в значение.

* Для исключения начального выполнения используется функция '''dont_initialize()'''

===Слайд: Стек событий '''sc_event_queue'''===

{{ЖЛампа|24px}} Событие можно задать не только от начального момента времени, а и от текущего.

Для этого используется функция '''sc_event_queue()'''

<source lang="cpp">
sc_event_queue action;
sc_time now(sc_time_stamp());
action.notify(20, SC_MS);
action.notify(1.5,SC_NS);
action.notify(1.5,SC_NS);
action.notify(3.0,SC_NS);
action.notify(SC_ZERO_TIME);
action.notify(1,SC_SEC);
action.cancel_all();
</source>

===Слайд:Совместное использование ресурсов===

* При совместном использовании ресурсов, шин, памяти нужно разграничить область полномочий каждого процесса.
* Иначе при одновременной, к примеру записи будет происходить сбой или некорректная запись.
Если управлением доступом к одному ресурсу
<source lang="cpp">sc_mutex NAME;
// блокируем mutex NAME (ждем пока разблокируется)
NAME.lock();
// Возвращает статус состояния блокировки
NAME.try lock()
// Снимает блокировку
NAME.unlock();</source>

Если управлением доступом к нескольким ресурсам

<source lang="cpp">sc_semaphore NAME(COUNT);
// блокируем mutex NAME (ждем пока разблокируеться)
NAME.wait();
// Возвращает статус состояния блокировки
NAME.trywait()
//Возвращает число свободных ресурсов
NAME.get_value()
// Снимает блокировку
NAME.post();</source>

===Слайд:Иерархия и структура проекта===
[[Файл:Иерархия.png]]

===Слайд:Иерархия и структура проекта (sc_main)===

{{ЖЛампа|24px}}Подключение и создание {{Зел|<big>'''модуля'''</big>}} внутри '''главного''' модуля аналогично созданию {{Зел|<big>'''объекта'''</big>}} заданного{{Зел| <big>'''класса'''</big>}}
{{Фио|<big>'''Стандартная конструкция блока хранения информации для RFID'''</big>}}
{| cellspacing="0" cellpadding="0" border="1"
|
* {{Гол|'''Статический метод'''}}
<source lang="cpp">//FILE: main.cpp
#include "Wheel.h"
int sc_main(int argc, char* argv[]) {
Wheel wheel_FL("wheel_FL");
Wheel wheel_FR("wheel_FR");
sc_start();
}</source>
|
* {{Гол|'''Динамический метод'''}}
<source lang="cpp">//FILE: main.cpp
#include "Wheel.h"
int sc_main(int argc, char* argv[]) {
Wheel* wheel_FL; // pointer to FL wheel
Wheel* wheel_FR; // pointer to FR wheel
wheel_FL = new Wheel ("wheel_FL"); // create FL
wheel_FR = new Wheel ("wheel_FR"); // create FR
sc_start();
delete wheel_FL;
delete wheel_FR;
}</source>
|}

===Слайд:Иерархия и структура проекта (SC_MODULE)===

{{ЖЛампа|24px}}Подключение и создание {{Зел|<big>'''модуля'''</big>}} внутри другого модуля аналогично созданию {{Зел|<big>'''объекта'''</big>}} заданного{{Зел| <big>'''класса'''</big>}}, внутри другого класса. Поэтому объявления производиться в конструкторе верхнего модуля
{| cellspacing="0" cellpadding="0" border="1"
|

* {{Гол|'''Статический метод'''}}
<source lang="cpp">//FILE:Body.h
#include "Wheel.h"
SC_MODULE(Body) {
Wheel wheel_FL;
Wheel wheel_FR;
SC_CTOR(Body)
: wheel_FL("wheel_FL"), //initialization
wheel_FR("wheel_FR") //initialization
{
// other initialization
}
};
}</source>
|
* {{Гол|'''Динамический метод'''}}
<source lang="cpp">//FILE:Body.h
#include "Wheel.h"
SC_MODULE(Body) {
Wheel* wheel_FL;
Wheel* wheel_FR;
SC_CTOR(Body) {
wheel_FL = new Wheel("wheel_FL");
wheel_FR = new Wheel("wheel_FR");
// other initialization
}
};
}</source>
|}

===Слайд:Порты - точки подачи и снятия внешних воздействий===
[[Файл:Порты_соединение_модулей.png]]

===Слайд:Типы портов ===

* {{Сн|'''sc_port'''}} - аналог inout порта в языке VHDL
* {{Сн|'''sc_in'''}} - аналог in порта в языке VHDL
* {{Сн|'''sc_out'''}} - аналог out порта в языке VHDL
* {{Сн|'''sc_export'''}} - внешний порт, порт который позволяет получить доступ к private данным модуля, но иерархически модулю не принадлежит.
{{ЖЛампа|24px}} Механизм использования '''sc_export''' порта напоминает '''доступ к сигналам по иерархии''', как в '''VHDL-2008'''.

===Слайд:Порты - точки подачи и снятия внешних воздействий===
[[Файл:Порты_соединение_модулей_экспорт.png]]
[[Файл:Порты_соединение_модулей_экспорт2.png]]

===Слайд:Управление процессом и контроль статуса моделирования===

== Слайд: VHDL и SystemC конструкции ==
===Слайд: Entity ===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример поведенческой модели накопителя (VHDL)'''}}
<source lang="vhdl">
entity soft is
generic (UART_Speed : integer := 115200; -- UART Speed
System_CLK : integer := 50000000; -- System CLK in Hz
comand_file : string :="/home/Vidokq/djin18reader/vhd/D18/comfile.txt"
);
port (
CLK : out std_logic; -- system clk
RST_N : out std_logic; -- system reset#
DATA_IN : out std_logic_vector(7 downto 0); -- Transmit data
DATA_OUT : in std_logic_vector(7 downto 0); -- Recieved data
RX_VALID : in std_logic; -- RX buffer data ready
TX_VALID : out std_logic; -- Data for TX avaible
TX_BUSY : in std_logic; --
RX_BUSY : in std_logic);

end soft;
</source>

|
{{Фио|'''<big></big>Пример поведенческой модели накопителя (Verilog)'''}}

<source lang="cpp">

SC_MODULE (soft_sc_module)
{
public :
sc_in < sc_logic > tx_busy;
sc_in < sc_logic > rx_busy;
sc_in < sc_lv < 8 > > data_out;
sc_in < sc_logic > rx_valid;
sc_out < sc_logic > tx_valid;
sc_out < bool > clk;
sc_out < sc_logic > rst_n;
sc_out < sc_lv < 8 > > data_in;

public:

ifstream fin;

SC_CTOR(soft_sc_module)
: rst_n("rst_n"),
data_in("data_in"),
data_out ("data_out"),
rx_valid("rx_valid"),
tx_valid("tx_valid"),
tx_busy("tx_busy"),
rx_busy("rx_busy"),
rst_n_i("rst_n_i"),
clk_i("clk_i"),
clk("clk")
{
}
~soft_sc_module()
{
delete [] str_b;
}
};

#endif
</source>
|}
</slides>

===Слайд: Architecture ===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример Архитектуры на VHDL'''}}
<source lang="vhdl">

architecture beh of soft is
file comfile : text open read_mode is comand_file;

begin -- beh
-- тело архитектуры
signal str : string(1 to 1000) := (others => ' ');
signal RST_N_i : std_logic;
signal DATA_IN_i : std_logic_vector(7 downto 0);
signal f_get_answer : boolean := false;
signal tmd : time := 0 ms;

end beh;
</source>

|
{{Фио|'''<big></big>Пример аналогичной конструкции на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public :
std::string comand_file;
public :
sc_signal< sc_logic > rst_n_i;
sc_signal< sc_lv < 8 > > data_in_i;
sc_signal < bool > f_get_answer;
sc_signal < sc_time > tmd;
sc_time btmd (0, SC_MS);
SC_CTOR(soft_sc_module)
:
rst_n_i("rst_n_i"),
data_in_i("data_in_i"),
f_get_answer("f_get_answer"),
tmd("tmd")
{
str = new char [1000];
//объявление функций
//выбор списка чувствительности
//установка значений по умолчанию
tmd.write(btmd);
// tmd = btmd;
//оператор присваивания перегружен и выолнит вызов функции write
}
~soft_sc_module()
{
delete [] str;
}
</source>
|}
</slides>

===Слайд: Generic ===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
entity soft is
generic (UART_Speed : integer := 115200;
System_CLK : integer := 50000000
);
--
--
--
architecture beh of soft is
CLK_i <= not CLK_i after 1 ns * (1000000000 / System_CLK );
end beh;
</source>

|
{{Фио|'''<big></big>Пример на SystemC (sc_get_param)'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module)
: rst_n("rst_n"),
tmd("tmd")
{
if (!sc_get_param("System_CLK",System_CLK)) cout << "error get generic";
if (!sc_get_param("UART_Speed",UART_Speed)) cout << "error get generic";
period_ns=(1000000000)/System_CLK;
str = new char [1000];
}
~soft_sc_module()
{
delete [] str_b;
}
};
</source>
|}
</slides>

===Слайд: Process без списка чувствительности ===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
wait_byte_timer: process
begin -- process wiat_timer
wait for 0.5 ms;
if (NOW - tmd) > 1 ms then
if f_start_get_answer then
f_byte_timer <= true;
wait for 0.1 ms;
f_byte_timer <= false;
end if;
end if;
end process wait_byte_timer;
</source>

|
{{Фио|'''<big></big>Пример на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module):
{ SC_METHOD (wait_byte_timer); }
~soft_sc_module()
{ }
};
void soft_sc_module :: wait_byte_timer ()
{
next_trigger (0.5,SC_MS);
if ((sc_time_stamp()-tmd) > sc_time(1, SC_MS) )
if (f_start_get_answer)
{f_byte_timer=true;
next_trigger (0.1,SC_MS);
f_byte_timer=false;
}
cout<< "wait_byte_timer work\n";
}
</source>
|}
</slides>

===Слайд: Process со списком чувствительности (пример 1)===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
CLK_i <= not CLK_i after 1 ns * (1000000000 / System_CLK );
--или
process (clk)
begin
if clk'event then
clk_i <= not clk_i after 1 ns * (1000000000 / System_CLK );
end if;
end process;
</source>
|
{{Фио|'''<big></big>Пример на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module):
{ clk_i=true;
period_ns=(1000000000)/System_CLK;
SC_METHOD (clk_gen);
}
~soft_sc_module()
{ }
};

void soft_sc_module :: clk_gen ()
{
clk_i.write(!clk_i.read());
next_trigger (period_ns, SC_NS);

}
</source>
|}
</slides>

===Слайд: Process со списком чувствительности (пример 2) ===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
RST_N <= RST_N_i;
--или
process (RST_N_i)
begin
if RST_N_i'event then
RST_N <= RST_N_i;
end if;
end process;
</source>
|
{{Фио|'''<big></big>Пример на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module):
{ clk_i=true;
SC_METHOD (rst_n_i2rst_n);
sensitive << rst_n_i;
dont_initialize();
}
~soft_sc_module()
{ }
};

void soft_sc_module :: reset_gen ()
{
rst_n_i.write( SC_LOGIC_0 );
wait (100, SC_NS);
cout << "run reset";
rst_n_i.write( SC_LOGIC_1 );
}
</source>
|}
</slides>

===Слайд: Работа с файлами ===
<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
p_send : process
variable l : line;
variable byte_r : std_logic_vector(0 to 7);
variable good : boolean;
variable f_first_byte : boolean:=false;
begin -- process p1

loop1: while not endfile(comfile) loop

readline (comfile,l);
skip_space (l);
next loop1 when l'length = 0;

for i in 1 to l'length loop
str(i) <= l(i);
end loop; -- i
str((l'length)+1 to 1000) <= (others => ' ');
str_l <= l'length;
</source>
|
<source lang="vhdl">
if l(1) = '#' then
assert false report "коментарий:"&str(1 to str_l) severity NOTE;
else
assert false report "коментарий"&str(1 to str_l) severity NOTE;
f_first_byte := true;
while l'length /= 0 loop
hread (l,byte_r,good);
assert good report "ошибка" severity FAILURE;
if f_first_byte then
f_first_byte := false;
comand <= byte_r;
end if;
TX_VALID_i <= '1';
DATA_IN_i <= byte_r;
skip_space (l);
wait until TX_BUSY = '1';
end loop;
f_start_timer <= true;
TX_VALID_i <= '0';
wait until f_get_answer or f_timer;
assert not f_timer report "1мкс" severity FAILURE;
f_start_timer <= false;
end if;
end loop;
assert false report "======" severity failure;
end process p_send;
</source>
|}
</slides>

===Слайд: Работа с файлами ===
<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на SystemC'''}}
<source lang="cpp">
void soft_sc_module :: p_send ()
{
fin.open(comand_file.c_str(),ios::out);
cout << "work4\n";
bool f_first_byte=false;
if (!fin){
std::cout << "File invalide open";
exit (0);
}
while (!fin.eof()){
fin.getline (str,1000);
skip_space (&(str));
if (strlen(str)){
if (str[0] == '#')
cout << "koment: "<< str <<endl;
else {
cout << "data: "<< str <<endl;
f_first_byte=true;
//while ( str[0] != '\0' ){
while ( strlen(str) ){
if ( str[0] == ' ' )
skip_space(&(str));
else {
//cout << "1/2\n";
byte_b.range(7,4)=str[0];
str++;
skip_space(&(str));
if (!strlen(str)){
cout<<endl<<"error";
sc_stop();
}
else {
//cout << "2/2\n";
byte_b.range(3,0)=str[0];
str++;
}
</source>
|
<source lang="cpp">

if (f_first_byte){
f_first_byte=false;
comand=byte_b;
}
//cout << byte_b << endl;
tx_valid_i.write(SC_LOGIC_1);
data_in.write(byte_b);
wait (tx_busy.posedge_event());
}
}
f_start_timer = true;
tx_valid_i.write(SC_LOGIC_0);
wait ( f_get_answer.posedge_event() | f_timer.posedge_event() );
if ( f_timer ) {cout << "error";sc_stop();}
f_start_timer = false;
}
}
str=str_b;
}
cout << "error";
fin.close();
sc_stop();
}
</source>
|}
</slides>

===Слайд: Работа с функциями ===
<slides split="-----" width="600" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
entity soft is
end soft;

architecture beh of soft is

procedure skip_space (variable l : inout line) is
variable char : character;
variable flag : boolean:=true;
begin -- skip_space
while flag loop
if l'length = 0 then
flag := false;
elsif l(1) = ' ' then
read(l, char);
else
flag := false;
end if;
end loop;
end skip_space;
end beh;
</source>
|
{{Фио|'''<big></big>Пример на SystemC'''}}
<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module):
{ SC_METHOD (wait_byte_timer); }

void skip_space (char ** str);
~soft_sc_module()
{ }
};
void soft_sc_module :: skip_space (char ** str)
{
bool flag = true;

while ( flag ) { //
if ( !strlen((*str)) )
flag = false;
else
if ((*str)[0]==' ')
(*str) += 1;
else
flag = false;
}
}

</source>
|}
</slides>

===Слайд: Работа с сигналами ===
===Слайд: Арифметические, логические, операции присваивания ===
===Слайд: Конструкции С++ ===
===Слайд: Создание модуля ===
===Слайд: Коммуникации между модулями ===
===Слайд: Управление процессом моделирования (сообщения, запуск останов моделирования)===
== Слайд: Компиляция описания ==
== Слайд: Запуск моделирования только SystemC описания ==
== Слайд: Запуск моделирования SystemC описания и VHDL ==

Спец курс (Избранные главы VHDL)/Верификация описания

2012-11-19T14:17:55Z

164.177.206.33: /* Слайд: Работа с файлами */

<slideshow style="custis" headingmark="Слайд:" incmark=":step" scaled="true" >
;title: '''Верификация описания.'''
;author: Зайцев В.С.
</slideshow>

[[Файл:SystemC_From_the_ground_up.mm]]

==Слайд:Верификация описания==
[[Файл:Процевв_верификации.png]]

==Слайд:Верификация описания:step==
*{{Гол|''' <big>Среда моделирования</big>'''}}
** Active-HDL™
** Riviera-PRO™
** NC-Sim®
** ModelSim®
** QuestaSim®
** VCS-MX®
* {{Гол|'''<big>Структура проекта</big>'''}}
** Тестовое окружение
** RTL-модель (Verilog,VHDL)
** Эталонная модель (SystemC)
** Assert'ы (psl, OVVM, UVM)
** Отчеты и базы по результатам моделирования

==Слайд:Эталонная модель на языке ''{{Зел| <big>SystemC</big>}}''==

# Высокий уровень абстракции
# Скорость моделирования
# Возможности языка C++
# Инструменты для автоматизации
# Совместное моделирование с другими HDL-языками

== Основы языка SystemC ==

===Слайд:Типы данных (Форматы и способ представления данных) ===
[[Файл:Типы_данных.png]]

===Слайд:Типы данных (native)===
<source lang="cpp"> // Пример типа данных C++
int spark_offset;
unsigned repairs = 0 ; // Count repair
unsigned long mileage; // Miles driven
short int speedometer; // -20.. 0.. 100 MPH
float temperature; // Engine temp in C
double time_of_last_request; //Time of bus
std:: string license_plate; // Text for license
const bool WARNING_LIGHT = true; // Status
enum compass {SW,W,NW,N,NE,E, SE, S} ;
</source>

===Слайд:Типы данных (Arithmetic)===
<source lang="cpp"> // Пример целочисленных типов данных C++
sc_int<LENGTH> NAME...;
sc_uint<LENGTH> NAME...;
sc_bigint<BITWIDTH> NAME...;
sc_biguint<BITWIDTH> NAME...;
// SystemC integer data types
sc_int<5> seat_position=3; //5 bits: 4 plus sign
sc_uint<13> days_SLOC(4000); //13 bits: no sign
sc_biguint<80> revs_SLOC; // 80 bits: no sign
</source>

===Слайд:Типы данных (Boolean)===
<source lang="cpp"> // Пример типа данных SystemC
sc_bit NAME...;
sc_bv<BITWIDTH> NAME...;
</source>

* sc_bit и sc_bv могут принимать значения: '''SC_LOGIC_1''' и '''SC_LOGIC_0.'''
* Для сокращения типов, можно использовать '''Log_1 и Log_0''' или '''‘1’ и ‘0’.'''
* Над этим типом данных возможно выполнение битовых операций '''and, or, xor (&,|, ^).'''
* Для обращения к отдельным битам и массивам '''[], range()'''.

<source lang="cpp">
sc_bit flag(SC_LOGIC_1); // more efficient to use bool
sc_bv<5> positions = "01101";
sc_bv<6> mask = "100111";
sc_bv<5> active = positions & mask;// 00101
sc_bv<1> all = active. and_reduce (); // SC_LOGIC_0
positions. range (3,2) = "00"; // 00001
positions [2] = active[0] ^ flag;
</source>

===Слайд:Типы данных ( многозначные (ZX10))===
<source lang="cpp"> // Пример типа данных SystemC
sc_logic NAME[,NAME]...;
sc_lv<BITNIDTH> NAME[,NAME ]...;
sc_logic buf(sc_dt::Log_Z);
sc_lv<8> data_drive ("zz01XZ1Z");
data_drive.range (5,4) = "ZZ";// ZZZZXZ1Z
buf = '1';

</source>

===Слайд:Операторы SystemC ===
[[Файл:Операции.png]]

===Слайд:Главный модуль MAIN===
{{Гол|'''<big>Описание на языке C++</big>'''}}
<source lang="cpp">
int main(int argc, char* argv[]) {
BODY_OF_PROGRAM
return EXIT_CODE; //
}
</source>

{{Гол|'''<big>Описание на языке SystemC</big>'''}}
<source lang="cpp">
int sc_main(int argc, char* argv[]) {
//ELABORATION
sc_start(); // <-- Simulation begins & ends
// in this function!
//[POST-PROCESSING]
return EXIT_CODE; //
}
</source>

===Слайд: Модуль ===
<source lang="cpp">
#include <systemc.h>
SC_MODULE(module_name) {
MODULE_BODY
};</source>
Содержит:
* '''{{Фио|<big>Порты</big>}}'''
* '''{{Фио|<big>Каналы связи</big>}}'''
* '''{{Фио|<big>Объявления переменных для хранения данных</big>}}'''
* '''{{Фио|<big>Другие модули с большей вложенностью</big>}}'''
* '''{{Фио|<big>Конструктор</big>}}'''
* '''{{Фио|<big>Деструктор</big>}}'''
* '''{{Фио|<big>Функции -процессы</big>}}'''
* '''{{Фио|<big>Вспомогательные функции</big>}}'''

===Слайд: Конструктор (SC_CTOR)===
<source lang="cpp">SC_CTOR(module_name)
: Initialization // OPTIONAL
{
Subdesign_Allocation
Subdesign_Connectivity
Process_Registration
Miscellaneous_Setup
}</source>

* '''{{Фио|<big>Объявление под модулей</big>}}'''
* '''{{Фио|<big>Подключение и соединение с подмодулями</big>}}'''
* '''{{Фио|<big>Регистрация процессов на SystemC</big>}}'''
* '''{{Фио|<big>Обеспечение постоянной чувствительности</big>}}'''
* '''{{Фио|<big>Разнообразные пользовательские объявления</big>}}''

===Слайд: Конструктор (SC_HAS_PROCESS)===
<source lang="cpp">
//FILE: module_name.h
SC_MODULE(module_name) {
SC_HAS_PROCESS(module_name);
module_name(sc_module_name instname[, other_args…])
: sc_module(instname)
[, other_initializers]
{
CONSTRUCTOR_BODY
}
};</source>

* '''{{Фио|<big>Все возможности конструктора SC_CTOR</big>}}'''
* '''{{Фио|<big>Альтернативный метод создания модуля</big>}}'''
* '''{{Фио|<big>Позволяет создавать конструктор с аргументами(+ к имени модуля)</big>}}'''
* '''{{Фио|<big>Используется, если желаете расположить конструктор в файле описания .cpp (не в файле .h)</big>}}'''

===Слайд: Процесс SC_THREAD ===

<source lang="cpp">
SC_MODULE(simple_process_ex) {
SC_CTOR(simple_process_ex) {
SC_THREAD(my_thread_process);
}
void my_thread_process(void);
};</source>

{{Зел|'''SC_THREAD'''}} в '''SystemC''':
# аналог {{Зел|'''initial block'''}} в '''Verilog'''
# {{Зел|'''process'''}} без списка чувствительности с оператором '''wait()''' в '''VHDL'''.

===Слайд:Введение времени===

{{Ор|<big>'''Единицы измерения времени'''</big>}}

<source lang="cpp">
SC_SEC // seconds
SC_MS // milliseconds
SC_US // microseconds
SC_NS // nanoseconds
SC_PS // picoseconds
SC_FS // femtoseconds
</source>
{{Ор|<big>'''Объявление переменной типа '''</big>}}{{Зел|<big>'''sc_time'''</big>}}
<source lang="cpp">
sc_time t_PERIOD(5, SC_NS) ;
sc_time t_TIMEOUT (100, SC_MS) ;
sc_time t_MEASURE, t_CURRENT, t_LAST_CLOCK;
t_MEASURE = (t_CURRENT-t_LAST_CLOCK) ;
if (t_MEASURE > t_HOLD) { error ("Setup violated") }
</source>

===Слайд:Запуск выполнения '''sc_start()'''===

{{Ор|<big>'''Функция запускающая выполнения главного процесса '''</big>}}

{{Сн|'''Пример запуска моделирования на 60 секунд модельного времени'''}}

<source lang="cpp">
int sc_main(int argc, char* argv[]) { // args unused
simple_process_ex my_instance ("my_instance");
sc_start(60.0,SC_SEC); // Limit sim to one minute
return 0 ;
}</source>

===Слайд:Контроль текущего времени моделирования '''sc_time_stamp ()'''===

<source lang="cpp">
std::cout << " The time is now "
<< sc_time_stamp()
<< "!" << std::endl;</source>

После запуска моделирования в консоли получим
The time is now 0 ns!

===Слайд: Остановка выполнения моделирования wait(sc_time)===

{{Ор|<big>'''Функция останавливающая выполнение процесса до заданного времени или до прихода события'''</big>}}

<source lang="cpp">
void simple_process_ex::my_thread_process (void) {
wait (10,SC_NS);
std::cout<< "Now at "<< sc_time_stamp() << std::endl;
sc_time t_DELAY(2,SC_MS); // keyboard debounce time
t_DELAY *= 2;
std::cout<< "Delaying "<< t_DELAY<< std::endl;
wait(t_DELAY);
std::cout << "Now at " << sc_time_stamp()
<< std::endl;
}</source>

% . /run_example
Now at 10 ns
Delaying 4 ms
Now at 4000010 ns

===Слайд:События '''sc_event'''===
<slides split="-----" width="400" >
[[Файл:Процес_моделирования_по_событиям.png]]
</slides>

===Слайд:События '''SC_THREAD::wait()'''===
Процесс '''SC_THREAD''' процес выполняющийся {{Кр|'''<big>один раз!!</big>'''}}, для управления работой такого процесса используют функцию задержки выполнения wait

<source lang="cpp">wait(time);
wait(event);
wait(event1 | event2) // до прихода любого из событий
wait(event1 & event2) // до прихода всех событий вместе
wait(timeout, event); // до прихода события ожидает в течении времени
wait ( timeout, event1 | event2 )
wait ( timeout, event1 & event2 )
wait(); // ожидание дельта цикла выполнения, статическая задержка
</source>
===Слайд:Запуск события (установка,назначение)===

Для запуска события используется атрибут {{Зел|<big>'''.notify()'''</big>}}

Он выполняет запуск событий, отсчет времени идет от запуска моделирования. Для сброса точки отсчета используют {{Зел|<big>'''.cancel()'''</big>}}

<source lang="cpp">sc_event action;
sc_time now(sc_time_stamp()); //вытягиваем текущее время моделирования
//стартуем событие немедленно
action.notify();
//следующее событие через 20 ms от текущего момента
action.notify(20, SC_MS);
//переопределим событие на время 1.5 ns от текущего момента
action.notify(1.5,SC_NS);
//продублируем событие (не имеет эффекта)
action.notify(1.5, SC_NS);
//зададим событие от предыдущего на 1.5 ns
action.notify(3.0,SC_NS);
//запустим дельта цикл (не имеет эффекта)
action.notify(SC_ZERO_TIME);
//сбросим время задания события
action.cancel();
//зададим событие на 20 fs после сброса
action.notify(20,SC_FS);</source>

===Слайд:Процесс со списком чувствительности SC_METHOD ===
{{ЖЛампа|24px}}Аналог '''process''' в '''VHDL'''

<source lang="cpp">SC_METHOD(process_name);</source>

{{ЖЛампа|24px}}Список чуствительности задаеться после ключевого слова {{Зел|'''sensitive'''}}

<source lang="cpp"> sensitive << event [<< event] ;// поточный стил
sensitive (event [, event] ); // стиль с использованием функции</source>

===Слайд:dont_initialize() ===
{{ЖЛампа|24px}} Отменяет начальную установку значений
* После запуска моделирования конструктор создает модуль и инициализирует все процессы и переменные.

* Это заставляет выполниться всем методам работающим по событию по одному разу во время запуска если событие устанавливалось в значение.

* Для исключения начального выполнения используется функция '''dont_initialize()'''

===Слайд: Стек событий '''sc_event_queue'''===

{{ЖЛампа|24px}} Событие можно задать не только от начального момента времени, а и от текущего.

Для этого используется функция '''sc_event_queue()'''

<source lang="cpp">
sc_event_queue action;
sc_time now(sc_time_stamp());
action.notify(20, SC_MS);
action.notify(1.5,SC_NS);
action.notify(1.5,SC_NS);
action.notify(3.0,SC_NS);
action.notify(SC_ZERO_TIME);
action.notify(1,SC_SEC);
action.cancel_all();
</source>

===Слайд:Совместное использование ресурсов===

* При совместном использовании ресурсов, шин, памяти нужно разграничить область полномочий каждого процесса.
* Иначе при одновременной, к примеру записи будет происходить сбой или некорректная запись.
Если управлением доступом к одному ресурсу
<source lang="cpp">sc_mutex NAME;
// блокируем mutex NAME (ждем пока разблокируется)
NAME.lock();
// Возвращает статус состояния блокировки
NAME.try lock()
// Снимает блокировку
NAME.unlock();</source>

Если управлением доступом к нескольким ресурсам

<source lang="cpp">sc_semaphore NAME(COUNT);
// блокируем mutex NAME (ждем пока разблокируеться)
NAME.wait();
// Возвращает статус состояния блокировки
NAME.trywait()
//Возвращает число свободных ресурсов
NAME.get_value()
// Снимает блокировку
NAME.post();</source>

===Слайд:Иерархия и структура проекта===
[[Файл:Иерархия.png]]

===Слайд:Иерархия и структура проекта (sc_main)===

{{ЖЛампа|24px}}Подключение и создание {{Зел|<big>'''модуля'''</big>}} внутри '''главного''' модуля аналогично созданию {{Зел|<big>'''объекта'''</big>}} заданного{{Зел| <big>'''класса'''</big>}}
{{Фио|<big>'''Стандартная конструкция блока хранения информации для RFID'''</big>}}
{| cellspacing="0" cellpadding="0" border="1"
|
* {{Гол|'''Статический метод'''}}
<source lang="cpp">//FILE: main.cpp
#include "Wheel.h"
int sc_main(int argc, char* argv[]) {
Wheel wheel_FL("wheel_FL");
Wheel wheel_FR("wheel_FR");
sc_start();
}</source>
|
* {{Гол|'''Динамический метод'''}}
<source lang="cpp">//FILE: main.cpp
#include "Wheel.h"
int sc_main(int argc, char* argv[]) {
Wheel* wheel_FL; // pointer to FL wheel
Wheel* wheel_FR; // pointer to FR wheel
wheel_FL = new Wheel ("wheel_FL"); // create FL
wheel_FR = new Wheel ("wheel_FR"); // create FR
sc_start();
delete wheel_FL;
delete wheel_FR;
}</source>
|}

===Слайд:Иерархия и структура проекта (SC_MODULE)===

{{ЖЛампа|24px}}Подключение и создание {{Зел|<big>'''модуля'''</big>}} внутри другого модуля аналогично созданию {{Зел|<big>'''объекта'''</big>}} заданного{{Зел| <big>'''класса'''</big>}}, внутри другого класса. Поэтому объявления производиться в конструкторе верхнего модуля
{| cellspacing="0" cellpadding="0" border="1"
|

* {{Гол|'''Статический метод'''}}
<source lang="cpp">//FILE:Body.h
#include "Wheel.h"
SC_MODULE(Body) {
Wheel wheel_FL;
Wheel wheel_FR;
SC_CTOR(Body)
: wheel_FL("wheel_FL"), //initialization
wheel_FR("wheel_FR") //initialization
{
// other initialization
}
};
}</source>
|
* {{Гол|'''Динамический метод'''}}
<source lang="cpp">//FILE:Body.h
#include "Wheel.h"
SC_MODULE(Body) {
Wheel* wheel_FL;
Wheel* wheel_FR;
SC_CTOR(Body) {
wheel_FL = new Wheel("wheel_FL");
wheel_FR = new Wheel("wheel_FR");
// other initialization
}
};
}</source>
|}

===Слайд:Порты - точки подачи и снятия внешних воздействий===
[[Файл:Порты_соединение_модулей.png]]

===Слайд:Типы портов ===

* {{Сн|'''sc_port'''}} - аналог inout порта в языке VHDL
* {{Сн|'''sc_in'''}} - аналог in порта в языке VHDL
* {{Сн|'''sc_out'''}} - аналог out порта в языке VHDL
* {{Сн|'''sc_export'''}} - внешний порт, порт который позволяет получить доступ к private данным модуля, но иерархически модулю не принадлежит.
{{ЖЛампа|24px}} Механизм использования '''sc_export''' порта напоминает '''доступ к сигналам по иерархии''', как в '''VHDL-2008'''.

===Слайд:Порты - точки подачи и снятия внешних воздействий===
[[Файл:Порты_соединение_модулей_экспорт.png]]
[[Файл:Порты_соединение_модулей_экспорт2.png]]

===Слайд:Управление процессом и контроль статуса моделирования===

== Слайд: VHDL и SystemC конструкции ==
===Слайд: Entity ===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример поведенческой модели накопителя (VHDL)'''}}
<source lang="vhdl">
entity soft is
generic (UART_Speed : integer := 115200; -- UART Speed
System_CLK : integer := 50000000; -- System CLK in Hz
comand_file : string :="/home/Vidokq/djin18reader/vhd/D18/comfile.txt"
);
port (
CLK : out std_logic; -- system clk
RST_N : out std_logic; -- system reset#
DATA_IN : out std_logic_vector(7 downto 0); -- Transmit data
DATA_OUT : in std_logic_vector(7 downto 0); -- Recieved data
RX_VALID : in std_logic; -- RX buffer data ready
TX_VALID : out std_logic; -- Data for TX avaible
TX_BUSY : in std_logic; --
RX_BUSY : in std_logic);

end soft;
</source>

|
{{Фио|'''<big></big>Пример поведенческой модели накопителя (Verilog)'''}}

<source lang="cpp">

SC_MODULE (soft_sc_module)
{
public :
sc_in < sc_logic > tx_busy;
sc_in < sc_logic > rx_busy;
sc_in < sc_lv < 8 > > data_out;
sc_in < sc_logic > rx_valid;
sc_out < sc_logic > tx_valid;
sc_out < bool > clk;
sc_out < sc_logic > rst_n;
sc_out < sc_lv < 8 > > data_in;

public:

ifstream fin;

SC_CTOR(soft_sc_module)
: rst_n("rst_n"),
data_in("data_in"),
data_out ("data_out"),
rx_valid("rx_valid"),
tx_valid("tx_valid"),
tx_busy("tx_busy"),
rx_busy("rx_busy"),
rst_n_i("rst_n_i"),
clk_i("clk_i"),
clk("clk")
{
}
~soft_sc_module()
{
delete [] str_b;
}
};

#endif
</source>
|}
</slides>

===Слайд: Architecture ===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример Архитектуры на VHDL'''}}
<source lang="vhdl">

architecture beh of soft is
file comfile : text open read_mode is comand_file;

begin -- beh
-- тело архитектуры
signal str : string(1 to 1000) := (others => ' ');
signal RST_N_i : std_logic;
signal DATA_IN_i : std_logic_vector(7 downto 0);
signal f_get_answer : boolean := false;
signal tmd : time := 0 ms;

end beh;
</source>

|
{{Фио|'''<big></big>Пример аналогичной конструкции на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public :
std::string comand_file;
public :
sc_signal< sc_logic > rst_n_i;
sc_signal< sc_lv < 8 > > data_in_i;
sc_signal < bool > f_get_answer;
sc_signal < sc_time > tmd;
sc_time btmd (0, SC_MS);
SC_CTOR(soft_sc_module)
:
rst_n_i("rst_n_i"),
data_in_i("data_in_i"),
f_get_answer("f_get_answer"),
tmd("tmd")
{
str = new char [1000];
//объявление функций
//выбор списка чувствительности
//установка значений по умолчанию
tmd.write(btmd);
// tmd = btmd;
//оператор присваивания перегружен и выолнит вызов функции write
}
~soft_sc_module()
{
delete [] str;
}
</source>
|}
</slides>

===Слайд: Generic ===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
entity soft is
generic (UART_Speed : integer := 115200;
System_CLK : integer := 50000000
);
--
--
--
architecture beh of soft is
CLK_i <= not CLK_i after 1 ns * (1000000000 / System_CLK );
end beh;
</source>

|
{{Фио|'''<big></big>Пример на SystemC (sc_get_param)'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module)
: rst_n("rst_n"),
tmd("tmd")
{
if (!sc_get_param("System_CLK",System_CLK)) cout << "error get generic";
if (!sc_get_param("UART_Speed",UART_Speed)) cout << "error get generic";
period_ns=(1000000000)/System_CLK;
str = new char [1000];
}
~soft_sc_module()
{
delete [] str_b;
}
};
</source>
|}
</slides>

===Слайд: Process без списка чувствительности ===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
wait_byte_timer: process
begin -- process wiat_timer
wait for 0.5 ms;
if (NOW - tmd) > 1 ms then
if f_start_get_answer then
f_byte_timer <= true;
wait for 0.1 ms;
f_byte_timer <= false;
end if;
end if;
end process wait_byte_timer;
</source>

|
{{Фио|'''<big></big>Пример на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module):
{ SC_METHOD (wait_byte_timer); }
~soft_sc_module()
{ }
};
void soft_sc_module :: wait_byte_timer ()
{
next_trigger (0.5,SC_MS);
if ((sc_time_stamp()-tmd) > sc_time(1, SC_MS) )
if (f_start_get_answer)
{f_byte_timer=true;
next_trigger (0.1,SC_MS);
f_byte_timer=false;
}
cout<< "wait_byte_timer work\n";
}
</source>
|}
</slides>

===Слайд: Process со списком чувствительности (пример 1)===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
CLK_i <= not CLK_i after 1 ns * (1000000000 / System_CLK );
--или
process (clk)
begin
if clk'event then
clk_i <= not clk_i after 1 ns * (1000000000 / System_CLK );
end if;
end process;
</source>
|
{{Фио|'''<big></big>Пример на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module):
{ clk_i=true;
period_ns=(1000000000)/System_CLK;
SC_METHOD (clk_gen);
}
~soft_sc_module()
{ }
};

void soft_sc_module :: clk_gen ()
{
clk_i.write(!clk_i.read());
next_trigger (period_ns, SC_NS);

}
</source>
|}
</slides>

===Слайд: Process со списком чувствительности (пример 2) ===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
RST_N <= RST_N_i;
--или
process (RST_N_i)
begin
if RST_N_i'event then
RST_N <= RST_N_i;
end if;
end process;
</source>
|
{{Фио|'''<big></big>Пример на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module):
{ clk_i=true;
SC_METHOD (rst_n_i2rst_n);
sensitive << rst_n_i;
dont_initialize();
}
~soft_sc_module()
{ }
};

void soft_sc_module :: reset_gen ()
{
rst_n_i.write( SC_LOGIC_0 );
wait (100, SC_NS);
cout << "run reset";
rst_n_i.write( SC_LOGIC_1 );
}
</source>
|}
</slides>

===Слайд: Работа с файлами ===
<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
p_send : process
variable l : line;
variable byte_r : std_logic_vector(0 to 7);
variable good : boolean;
variable f_first_byte : boolean:=false;
begin -- process p1

loop1: while not endfile(comfile) loop

readline (comfile,l);
skip_space (l);
next loop1 when l'length = 0;

for i in 1 to l'length loop
str(i) <= l(i);
end loop; -- i
str((l'length)+1 to 1000) <= (others => ' ');
str_l <= l'length;
</source>
|
<source lang="vhdl">
if l(1) = '#' then
assert false report "коментарий:"&str(1 to str_l) severity NOTE;
else
assert false report "коментарий"&str(1 to str_l) severity NOTE;
f_first_byte := true;
while l'length /= 0 loop
hread (l,byte_r,good);
assert good report "ошибка" severity FAILURE;
if f_first_byte then
f_first_byte := false;
comand <= byte_r;
end if;
TX_VALID_i <= '1';
DATA_IN_i <= byte_r;
skip_space (l);
wait until TX_BUSY = '1';
end loop;
f_start_timer <= true;
TX_VALID_i <= '0';
wait until f_get_answer or f_timer;
assert not f_timer report "1мкс" severity FAILURE;
f_start_timer <= false;
end if;
end loop;
assert false report "======" severity failure;
end process p_send;
</source>
|}
</slides>

===Слайд: Работа с файлами ===
<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на SystemC'''}}
<source lang="cpp">
void soft_sc_module :: p_send ()
{
fin.open(comand_file.c_str(),ios::out);
cout << "work4\n";
bool f_first_byte=false;
if (!fin){
std::cout << "File invalide open";
exit (0);
}
while (!fin.eof()){
fin.getline (str,1000);
skip_space (&(str));
if (strlen(str)){
if (str[0] == '#')
cout << "koment: "<< str <<endl;
else {
cout << "data: "<< str <<endl;
f_first_byte=true;
//while ( str[0] != '\0' ){
while ( strlen(str) ){
if ( str[0] == ' ' )
skip_space(&(str));
else {
//cout << "1/2\n";
byte_b.range(7,4)=str[0];
str++;
skip_space(&(str));
if (!strlen(str)){
cout<<endl<<"error";
sc_stop();
}
else {
//cout << "2/2\n";
byte_b.range(3,0)=str[0];
str++;
}
</source>
|
<source lang="cpp">

if (f_first_byte){
f_first_byte=false;
comand=byte_b;
}
//cout << byte_b << endl;
tx_valid_i.write(SC_LOGIC_1);
data_in.write(byte_b);
wait (tx_busy.posedge_event());
}
}
f_start_timer = true;
tx_valid_i.write(SC_LOGIC_0);
wait ( f_get_answer.posedge_event() | f_timer.posedge_event() );
if ( f_timer ) {cout << "error";sc_stop();}
f_start_timer = false;
}
}
str=str_b;
}
cout << "error";
fin.close();
sc_stop();
}
</source>
|}
</slides>

===Слайд: Работа с переменными ===
===Слайд: Работа с сигналами ===
===Слайд: Арифметические, логические, операции присваивания ===
===Слайд: Конструкции С++ ===
===Слайд: Создание модуля ===
===Слайд: Коммуникации между модулями ===
===Слайд: Управление процессом моделирования (сообщения, запуск останов моделирования)===
== Слайд: Компиляция описания ==
== Слайд: Запуск моделирования только SystemC описания ==
== Слайд: Запуск моделирования SystemC описания и VHDL ==

Спец курс (Избранные главы VHDL)/Верификация описания

2012-11-19T14:17:32Z

164.177.206.33: /* Слайд: Работа с файлами */

<slideshow style="custis" headingmark="Слайд:" incmark=":step" scaled="true" >
;title: '''Верификация описания.'''
;author: Зайцев В.С.
</slideshow>

[[Файл:SystemC_From_the_ground_up.mm]]

==Слайд:Верификация описания==
[[Файл:Процевв_верификации.png]]

==Слайд:Верификация описания:step==
*{{Гол|''' <big>Среда моделирования</big>'''}}
** Active-HDL™
** Riviera-PRO™
** NC-Sim®
** ModelSim®
** QuestaSim®
** VCS-MX®
* {{Гол|'''<big>Структура проекта</big>'''}}
** Тестовое окружение
** RTL-модель (Verilog,VHDL)
** Эталонная модель (SystemC)
** Assert'ы (psl, OVVM, UVM)
** Отчеты и базы по результатам моделирования

==Слайд:Эталонная модель на языке ''{{Зел| <big>SystemC</big>}}''==

# Высокий уровень абстракции
# Скорость моделирования
# Возможности языка C++
# Инструменты для автоматизации
# Совместное моделирование с другими HDL-языками

== Основы языка SystemC ==

===Слайд:Типы данных (Форматы и способ представления данных) ===
[[Файл:Типы_данных.png]]

===Слайд:Типы данных (native)===
<source lang="cpp"> // Пример типа данных C++
int spark_offset;
unsigned repairs = 0 ; // Count repair
unsigned long mileage; // Miles driven
short int speedometer; // -20.. 0.. 100 MPH
float temperature; // Engine temp in C
double time_of_last_request; //Time of bus
std:: string license_plate; // Text for license
const bool WARNING_LIGHT = true; // Status
enum compass {SW,W,NW,N,NE,E, SE, S} ;
</source>

===Слайд:Типы данных (Arithmetic)===
<source lang="cpp"> // Пример целочисленных типов данных C++
sc_int<LENGTH> NAME...;
sc_uint<LENGTH> NAME...;
sc_bigint<BITWIDTH> NAME...;
sc_biguint<BITWIDTH> NAME...;
// SystemC integer data types
sc_int<5> seat_position=3; //5 bits: 4 plus sign
sc_uint<13> days_SLOC(4000); //13 bits: no sign
sc_biguint<80> revs_SLOC; // 80 bits: no sign
</source>

===Слайд:Типы данных (Boolean)===
<source lang="cpp"> // Пример типа данных SystemC
sc_bit NAME...;
sc_bv<BITWIDTH> NAME...;
</source>

* sc_bit и sc_bv могут принимать значения: '''SC_LOGIC_1''' и '''SC_LOGIC_0.'''
* Для сокращения типов, можно использовать '''Log_1 и Log_0''' или '''‘1’ и ‘0’.'''
* Над этим типом данных возможно выполнение битовых операций '''and, or, xor (&,|, ^).'''
* Для обращения к отдельным битам и массивам '''[], range()'''.

<source lang="cpp">
sc_bit flag(SC_LOGIC_1); // more efficient to use bool
sc_bv<5> positions = "01101";
sc_bv<6> mask = "100111";
sc_bv<5> active = positions & mask;// 00101
sc_bv<1> all = active. and_reduce (); // SC_LOGIC_0
positions. range (3,2) = "00"; // 00001
positions [2] = active[0] ^ flag;
</source>

===Слайд:Типы данных ( многозначные (ZX10))===
<source lang="cpp"> // Пример типа данных SystemC
sc_logic NAME[,NAME]...;
sc_lv<BITNIDTH> NAME[,NAME ]...;
sc_logic buf(sc_dt::Log_Z);
sc_lv<8> data_drive ("zz01XZ1Z");
data_drive.range (5,4) = "ZZ";// ZZZZXZ1Z
buf = '1';

</source>

===Слайд:Операторы SystemC ===
[[Файл:Операции.png]]

===Слайд:Главный модуль MAIN===
{{Гол|'''<big>Описание на языке C++</big>'''}}
<source lang="cpp">
int main(int argc, char* argv[]) {
BODY_OF_PROGRAM
return EXIT_CODE; //
}
</source>

{{Гол|'''<big>Описание на языке SystemC</big>'''}}
<source lang="cpp">
int sc_main(int argc, char* argv[]) {
//ELABORATION
sc_start(); // <-- Simulation begins & ends
// in this function!
//[POST-PROCESSING]
return EXIT_CODE; //
}
</source>

===Слайд: Модуль ===
<source lang="cpp">
#include <systemc.h>
SC_MODULE(module_name) {
MODULE_BODY
};</source>
Содержит:
* '''{{Фио|<big>Порты</big>}}'''
* '''{{Фио|<big>Каналы связи</big>}}'''
* '''{{Фио|<big>Объявления переменных для хранения данных</big>}}'''
* '''{{Фио|<big>Другие модули с большей вложенностью</big>}}'''
* '''{{Фио|<big>Конструктор</big>}}'''
* '''{{Фио|<big>Деструктор</big>}}'''
* '''{{Фио|<big>Функции -процессы</big>}}'''
* '''{{Фио|<big>Вспомогательные функции</big>}}'''

===Слайд: Конструктор (SC_CTOR)===
<source lang="cpp">SC_CTOR(module_name)
: Initialization // OPTIONAL
{
Subdesign_Allocation
Subdesign_Connectivity
Process_Registration
Miscellaneous_Setup
}</source>

* '''{{Фио|<big>Объявление под модулей</big>}}'''
* '''{{Фио|<big>Подключение и соединение с подмодулями</big>}}'''
* '''{{Фио|<big>Регистрация процессов на SystemC</big>}}'''
* '''{{Фио|<big>Обеспечение постоянной чувствительности</big>}}'''
* '''{{Фио|<big>Разнообразные пользовательские объявления</big>}}''

===Слайд: Конструктор (SC_HAS_PROCESS)===
<source lang="cpp">
//FILE: module_name.h
SC_MODULE(module_name) {
SC_HAS_PROCESS(module_name);
module_name(sc_module_name instname[, other_args…])
: sc_module(instname)
[, other_initializers]
{
CONSTRUCTOR_BODY
}
};</source>

* '''{{Фио|<big>Все возможности конструктора SC_CTOR</big>}}'''
* '''{{Фио|<big>Альтернативный метод создания модуля</big>}}'''
* '''{{Фио|<big>Позволяет создавать конструктор с аргументами(+ к имени модуля)</big>}}'''
* '''{{Фио|<big>Используется, если желаете расположить конструктор в файле описания .cpp (не в файле .h)</big>}}'''

===Слайд: Процесс SC_THREAD ===

<source lang="cpp">
SC_MODULE(simple_process_ex) {
SC_CTOR(simple_process_ex) {
SC_THREAD(my_thread_process);
}
void my_thread_process(void);
};</source>

{{Зел|'''SC_THREAD'''}} в '''SystemC''':
# аналог {{Зел|'''initial block'''}} в '''Verilog'''
# {{Зел|'''process'''}} без списка чувствительности с оператором '''wait()''' в '''VHDL'''.

===Слайд:Введение времени===

{{Ор|<big>'''Единицы измерения времени'''</big>}}

<source lang="cpp">
SC_SEC // seconds
SC_MS // milliseconds
SC_US // microseconds
SC_NS // nanoseconds
SC_PS // picoseconds
SC_FS // femtoseconds
</source>
{{Ор|<big>'''Объявление переменной типа '''</big>}}{{Зел|<big>'''sc_time'''</big>}}
<source lang="cpp">
sc_time t_PERIOD(5, SC_NS) ;
sc_time t_TIMEOUT (100, SC_MS) ;
sc_time t_MEASURE, t_CURRENT, t_LAST_CLOCK;
t_MEASURE = (t_CURRENT-t_LAST_CLOCK) ;
if (t_MEASURE > t_HOLD) { error ("Setup violated") }
</source>

===Слайд:Запуск выполнения '''sc_start()'''===

{{Ор|<big>'''Функция запускающая выполнения главного процесса '''</big>}}

{{Сн|'''Пример запуска моделирования на 60 секунд модельного времени'''}}

<source lang="cpp">
int sc_main(int argc, char* argv[]) { // args unused
simple_process_ex my_instance ("my_instance");
sc_start(60.0,SC_SEC); // Limit sim to one minute
return 0 ;
}</source>

===Слайд:Контроль текущего времени моделирования '''sc_time_stamp ()'''===

<source lang="cpp">
std::cout << " The time is now "
<< sc_time_stamp()
<< "!" << std::endl;</source>

После запуска моделирования в консоли получим
The time is now 0 ns!

===Слайд: Остановка выполнения моделирования wait(sc_time)===

{{Ор|<big>'''Функция останавливающая выполнение процесса до заданного времени или до прихода события'''</big>}}

<source lang="cpp">
void simple_process_ex::my_thread_process (void) {
wait (10,SC_NS);
std::cout<< "Now at "<< sc_time_stamp() << std::endl;
sc_time t_DELAY(2,SC_MS); // keyboard debounce time
t_DELAY *= 2;
std::cout<< "Delaying "<< t_DELAY<< std::endl;
wait(t_DELAY);
std::cout << "Now at " << sc_time_stamp()
<< std::endl;
}</source>

% . /run_example
Now at 10 ns
Delaying 4 ms
Now at 4000010 ns

===Слайд:События '''sc_event'''===
<slides split="-----" width="400" >
[[Файл:Процес_моделирования_по_событиям.png]]
</slides>

===Слайд:События '''SC_THREAD::wait()'''===
Процесс '''SC_THREAD''' процес выполняющийся {{Кр|'''<big>один раз!!</big>'''}}, для управления работой такого процесса используют функцию задержки выполнения wait

<source lang="cpp">wait(time);
wait(event);
wait(event1 | event2) // до прихода любого из событий
wait(event1 & event2) // до прихода всех событий вместе
wait(timeout, event); // до прихода события ожидает в течении времени
wait ( timeout, event1 | event2 )
wait ( timeout, event1 & event2 )
wait(); // ожидание дельта цикла выполнения, статическая задержка
</source>
===Слайд:Запуск события (установка,назначение)===

Для запуска события используется атрибут {{Зел|<big>'''.notify()'''</big>}}

Он выполняет запуск событий, отсчет времени идет от запуска моделирования. Для сброса точки отсчета используют {{Зел|<big>'''.cancel()'''</big>}}

<source lang="cpp">sc_event action;
sc_time now(sc_time_stamp()); //вытягиваем текущее время моделирования
//стартуем событие немедленно
action.notify();
//следующее событие через 20 ms от текущего момента
action.notify(20, SC_MS);
//переопределим событие на время 1.5 ns от текущего момента
action.notify(1.5,SC_NS);
//продублируем событие (не имеет эффекта)
action.notify(1.5, SC_NS);
//зададим событие от предыдущего на 1.5 ns
action.notify(3.0,SC_NS);
//запустим дельта цикл (не имеет эффекта)
action.notify(SC_ZERO_TIME);
//сбросим время задания события
action.cancel();
//зададим событие на 20 fs после сброса
action.notify(20,SC_FS);</source>

===Слайд:Процесс со списком чувствительности SC_METHOD ===
{{ЖЛампа|24px}}Аналог '''process''' в '''VHDL'''

<source lang="cpp">SC_METHOD(process_name);</source>

{{ЖЛампа|24px}}Список чуствительности задаеться после ключевого слова {{Зел|'''sensitive'''}}

<source lang="cpp"> sensitive << event [<< event] ;// поточный стил
sensitive (event [, event] ); // стиль с использованием функции</source>

===Слайд:dont_initialize() ===
{{ЖЛампа|24px}} Отменяет начальную установку значений
* После запуска моделирования конструктор создает модуль и инициализирует все процессы и переменные.

* Это заставляет выполниться всем методам работающим по событию по одному разу во время запуска если событие устанавливалось в значение.

* Для исключения начального выполнения используется функция '''dont_initialize()'''

===Слайд: Стек событий '''sc_event_queue'''===

{{ЖЛампа|24px}} Событие можно задать не только от начального момента времени, а и от текущего.

Для этого используется функция '''sc_event_queue()'''

<source lang="cpp">
sc_event_queue action;
sc_time now(sc_time_stamp());
action.notify(20, SC_MS);
action.notify(1.5,SC_NS);
action.notify(1.5,SC_NS);
action.notify(3.0,SC_NS);
action.notify(SC_ZERO_TIME);
action.notify(1,SC_SEC);
action.cancel_all();
</source>

===Слайд:Совместное использование ресурсов===

* При совместном использовании ресурсов, шин, памяти нужно разграничить область полномочий каждого процесса.
* Иначе при одновременной, к примеру записи будет происходить сбой или некорректная запись.
Если управлением доступом к одному ресурсу
<source lang="cpp">sc_mutex NAME;
// блокируем mutex NAME (ждем пока разблокируется)
NAME.lock();
// Возвращает статус состояния блокировки
NAME.try lock()
// Снимает блокировку
NAME.unlock();</source>

Если управлением доступом к нескольким ресурсам

<source lang="cpp">sc_semaphore NAME(COUNT);
// блокируем mutex NAME (ждем пока разблокируеться)
NAME.wait();
// Возвращает статус состояния блокировки
NAME.trywait()
//Возвращает число свободных ресурсов
NAME.get_value()
// Снимает блокировку
NAME.post();</source>

===Слайд:Иерархия и структура проекта===
[[Файл:Иерархия.png]]

===Слайд:Иерархия и структура проекта (sc_main)===

{{ЖЛампа|24px}}Подключение и создание {{Зел|<big>'''модуля'''</big>}} внутри '''главного''' модуля аналогично созданию {{Зел|<big>'''объекта'''</big>}} заданного{{Зел| <big>'''класса'''</big>}}
{{Фио|<big>'''Стандартная конструкция блока хранения информации для RFID'''</big>}}
{| cellspacing="0" cellpadding="0" border="1"
|
* {{Гол|'''Статический метод'''}}
<source lang="cpp">//FILE: main.cpp
#include "Wheel.h"
int sc_main(int argc, char* argv[]) {
Wheel wheel_FL("wheel_FL");
Wheel wheel_FR("wheel_FR");
sc_start();
}</source>
|
* {{Гол|'''Динамический метод'''}}
<source lang="cpp">//FILE: main.cpp
#include "Wheel.h"
int sc_main(int argc, char* argv[]) {
Wheel* wheel_FL; // pointer to FL wheel
Wheel* wheel_FR; // pointer to FR wheel
wheel_FL = new Wheel ("wheel_FL"); // create FL
wheel_FR = new Wheel ("wheel_FR"); // create FR
sc_start();
delete wheel_FL;
delete wheel_FR;
}</source>
|}

===Слайд:Иерархия и структура проекта (SC_MODULE)===

{{ЖЛампа|24px}}Подключение и создание {{Зел|<big>'''модуля'''</big>}} внутри другого модуля аналогично созданию {{Зел|<big>'''объекта'''</big>}} заданного{{Зел| <big>'''класса'''</big>}}, внутри другого класса. Поэтому объявления производиться в конструкторе верхнего модуля
{| cellspacing="0" cellpadding="0" border="1"
|

* {{Гол|'''Статический метод'''}}
<source lang="cpp">//FILE:Body.h
#include "Wheel.h"
SC_MODULE(Body) {
Wheel wheel_FL;
Wheel wheel_FR;
SC_CTOR(Body)
: wheel_FL("wheel_FL"), //initialization
wheel_FR("wheel_FR") //initialization
{
// other initialization
}
};
}</source>
|
* {{Гол|'''Динамический метод'''}}
<source lang="cpp">//FILE:Body.h
#include "Wheel.h"
SC_MODULE(Body) {
Wheel* wheel_FL;
Wheel* wheel_FR;
SC_CTOR(Body) {
wheel_FL = new Wheel("wheel_FL");
wheel_FR = new Wheel("wheel_FR");
// other initialization
}
};
}</source>
|}

===Слайд:Порты - точки подачи и снятия внешних воздействий===
[[Файл:Порты_соединение_модулей.png]]

===Слайд:Типы портов ===

* {{Сн|'''sc_port'''}} - аналог inout порта в языке VHDL
* {{Сн|'''sc_in'''}} - аналог in порта в языке VHDL
* {{Сн|'''sc_out'''}} - аналог out порта в языке VHDL
* {{Сн|'''sc_export'''}} - внешний порт, порт который позволяет получить доступ к private данным модуля, но иерархически модулю не принадлежит.
{{ЖЛампа|24px}} Механизм использования '''sc_export''' порта напоминает '''доступ к сигналам по иерархии''', как в '''VHDL-2008'''.

===Слайд:Порты - точки подачи и снятия внешних воздействий===
[[Файл:Порты_соединение_модулей_экспорт.png]]
[[Файл:Порты_соединение_модулей_экспорт2.png]]

===Слайд:Управление процессом и контроль статуса моделирования===

== Слайд: VHDL и SystemC конструкции ==
===Слайд: Entity ===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример поведенческой модели накопителя (VHDL)'''}}
<source lang="vhdl">
entity soft is
generic (UART_Speed : integer := 115200; -- UART Speed
System_CLK : integer := 50000000; -- System CLK in Hz
comand_file : string :="/home/Vidokq/djin18reader/vhd/D18/comfile.txt"
);
port (
CLK : out std_logic; -- system clk
RST_N : out std_logic; -- system reset#
DATA_IN : out std_logic_vector(7 downto 0); -- Transmit data
DATA_OUT : in std_logic_vector(7 downto 0); -- Recieved data
RX_VALID : in std_logic; -- RX buffer data ready
TX_VALID : out std_logic; -- Data for TX avaible
TX_BUSY : in std_logic; --
RX_BUSY : in std_logic);

end soft;
</source>

|
{{Фио|'''<big></big>Пример поведенческой модели накопителя (Verilog)'''}}

<source lang="cpp">

SC_MODULE (soft_sc_module)
{
public :
sc_in < sc_logic > tx_busy;
sc_in < sc_logic > rx_busy;
sc_in < sc_lv < 8 > > data_out;
sc_in < sc_logic > rx_valid;
sc_out < sc_logic > tx_valid;
sc_out < bool > clk;
sc_out < sc_logic > rst_n;
sc_out < sc_lv < 8 > > data_in;

public:

ifstream fin;

SC_CTOR(soft_sc_module)
: rst_n("rst_n"),
data_in("data_in"),
data_out ("data_out"),
rx_valid("rx_valid"),
tx_valid("tx_valid"),
tx_busy("tx_busy"),
rx_busy("rx_busy"),
rst_n_i("rst_n_i"),
clk_i("clk_i"),
clk("clk")
{
}
~soft_sc_module()
{
delete [] str_b;
}
};

#endif
</source>
|}
</slides>

===Слайд: Architecture ===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример Архитектуры на VHDL'''}}
<source lang="vhdl">

architecture beh of soft is
file comfile : text open read_mode is comand_file;

begin -- beh
-- тело архитектуры
signal str : string(1 to 1000) := (others => ' ');
signal RST_N_i : std_logic;
signal DATA_IN_i : std_logic_vector(7 downto 0);
signal f_get_answer : boolean := false;
signal tmd : time := 0 ms;

end beh;
</source>

|
{{Фио|'''<big></big>Пример аналогичной конструкции на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public :
std::string comand_file;
public :
sc_signal< sc_logic > rst_n_i;
sc_signal< sc_lv < 8 > > data_in_i;
sc_signal < bool > f_get_answer;
sc_signal < sc_time > tmd;
sc_time btmd (0, SC_MS);
SC_CTOR(soft_sc_module)
:
rst_n_i("rst_n_i"),
data_in_i("data_in_i"),
f_get_answer("f_get_answer"),
tmd("tmd")
{
str = new char [1000];
//объявление функций
//выбор списка чувствительности
//установка значений по умолчанию
tmd.write(btmd);
// tmd = btmd;
//оператор присваивания перегружен и выолнит вызов функции write
}
~soft_sc_module()
{
delete [] str;
}
</source>
|}
</slides>

===Слайд: Generic ===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
entity soft is
generic (UART_Speed : integer := 115200;
System_CLK : integer := 50000000
);
--
--
--
architecture beh of soft is
CLK_i <= not CLK_i after 1 ns * (1000000000 / System_CLK );
end beh;
</source>

|
{{Фио|'''<big></big>Пример на SystemC (sc_get_param)'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module)
: rst_n("rst_n"),
tmd("tmd")
{
if (!sc_get_param("System_CLK",System_CLK)) cout << "error get generic";
if (!sc_get_param("UART_Speed",UART_Speed)) cout << "error get generic";
period_ns=(1000000000)/System_CLK;
str = new char [1000];
}
~soft_sc_module()
{
delete [] str_b;
}
};
</source>
|}
</slides>

===Слайд: Process без списка чувствительности ===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
wait_byte_timer: process
begin -- process wiat_timer
wait for 0.5 ms;
if (NOW - tmd) > 1 ms then
if f_start_get_answer then
f_byte_timer <= true;
wait for 0.1 ms;
f_byte_timer <= false;
end if;
end if;
end process wait_byte_timer;
</source>

|
{{Фио|'''<big></big>Пример на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module):
{ SC_METHOD (wait_byte_timer); }
~soft_sc_module()
{ }
};
void soft_sc_module :: wait_byte_timer ()
{
next_trigger (0.5,SC_MS);
if ((sc_time_stamp()-tmd) > sc_time(1, SC_MS) )
if (f_start_get_answer)
{f_byte_timer=true;
next_trigger (0.1,SC_MS);
f_byte_timer=false;
}
cout<< "wait_byte_timer work\n";
}
</source>
|}
</slides>

===Слайд: Process со списком чувствительности (пример 1)===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
CLK_i <= not CLK_i after 1 ns * (1000000000 / System_CLK );
--или
process (clk)
begin
if clk'event then
clk_i <= not clk_i after 1 ns * (1000000000 / System_CLK );
end if;
end process;
</source>
|
{{Фио|'''<big></big>Пример на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module):
{ clk_i=true;
period_ns=(1000000000)/System_CLK;
SC_METHOD (clk_gen);
}
~soft_sc_module()
{ }
};

void soft_sc_module :: clk_gen ()
{
clk_i.write(!clk_i.read());
next_trigger (period_ns, SC_NS);

}
</source>
|}
</slides>

===Слайд: Process со списком чувствительности (пример 2) ===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
RST_N <= RST_N_i;
--или
process (RST_N_i)
begin
if RST_N_i'event then
RST_N <= RST_N_i;
end if;
end process;
</source>
|
{{Фио|'''<big></big>Пример на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module):
{ clk_i=true;
SC_METHOD (rst_n_i2rst_n);
sensitive << rst_n_i;
dont_initialize();
}
~soft_sc_module()
{ }
};

void soft_sc_module :: reset_gen ()
{
rst_n_i.write( SC_LOGIC_0 );
wait (100, SC_NS);
cout << "run reset";
rst_n_i.write( SC_LOGIC_1 );
}
</source>
|}
</slides>

===Слайд: Работа с файлами ===
<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
p_send : process
variable l : line;
variable byte_r : std_logic_vector(0 to 7);
variable good : boolean;
variable f_first_byte : boolean:=false;
begin -- process p1

loop1: while not endfile(comfile) loop

readline (comfile,l);
skip_space (l);
next loop1 when l'length = 0;

for i in 1 to l'length loop
str(i) <= l(i);
end loop; -- i
str((l'length)+1 to 1000) <= (others => ' ');
str_l <= l'length;
</source>
|
<source lang="vhdl">
if l(1) = '#' then
assert false report "коментарий:"&str(1 to str_l) severity NOTE;
else
assert false report "коментарий"&str(1 to str_l) severity NOTE;
f_first_byte := true;
while l'length /= 0 loop
hread (l,byte_r,good);
assert good report "ошибка" severity FAILURE;
if f_first_byte then
f_first_byte := false;
comand <= byte_r;
end if;
TX_VALID_i <= '1';
DATA_IN_i <= byte_r;
skip_space (l);
wait until TX_BUSY = '1';
end loop;
f_start_timer <= true;
TX_VALID_i <= '0';
wait until f_get_answer or f_timer;
assert not f_timer report "1мкс" severity FAILURE;
f_start_timer <= false;
end if;
end loop;
assert false report "======" severity failure;
end process p_send;
</source>
|}
</slides>

===Слайд: Работа с файлами ===
<slides split="-----" width="800" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на SystemC'''}}
<source lang="cpp">
void soft_sc_module :: p_send ()
{
fin.open(comand_file.c_str(),ios::out);
cout << "work4\n";
bool f_first_byte=false;
if (!fin){
std::cout << "File invalide open";
exit (0);
}
while (!fin.eof()){
fin.getline (str,1000);
skip_space (&(str));
if (strlen(str)){
if (str[0] == '#')
cout << "koment: "<< str <<endl;
else {
cout << "data: "<< str <<endl;
f_first_byte=true;
//while ( str[0] != '\0' ){
while ( strlen(str) ){
if ( str[0] == ' ' )
skip_space(&(str));
else {
//cout << "1/2\n";
byte_b.range(7,4)=str[0];
str++;
skip_space(&(str));
if (!strlen(str)){
cout<<endl<<"error";
sc_stop();
}
else {
//cout << "2/2\n";
byte_b.range(3,0)=str[0];
str++;
}
</source>
|
<source lang="cpp">

if (f_first_byte){
f_first_byte=false;
comand=byte_b;
}
//cout << byte_b << endl;
tx_valid_i.write(SC_LOGIC_1);
data_in.write(byte_b);
wait (tx_busy.posedge_event());
}
}
f_start_timer = true;
tx_valid_i.write(SC_LOGIC_0);
wait ( f_get_answer.posedge_event() | f_timer.posedge_event() );
if ( f_timer ) {cout << "error";sc_stop();}
f_start_timer = false;
}
}
str=str_b;
}
cout << "error";
fin.close();
sc_stop();
}
</source>
|}
</slides>

===Слайд: Работа с переменными ===
===Слайд: Работа с сигналами ===
===Слайд: Арифметические, логические, операции присваивания ===
===Слайд: Конструкции С++ ===
===Слайд: Создание модуля ===
===Слайд: Коммуникации между модулями ===
===Слайд: Управление процессом моделирования (сообщения, запуск останов моделирования)===
== Слайд: Компиляция описания ==
== Слайд: Запуск моделирования только SystemC описания ==
== Слайд: Запуск моделирования SystemC описания и VHDL ==

Спец курс (Избранные главы VHDL)/Верификация описания

2012-11-19T14:17:11Z

164.177.206.33: /* Слайд: Process со списком чувствительности (пример 2) */

<slideshow style="custis" headingmark="Слайд:" incmark=":step" scaled="true" >
;title: '''Верификация описания.'''
;author: Зайцев В.С.
</slideshow>

[[Файл:SystemC_From_the_ground_up.mm]]

==Слайд:Верификация описания==
[[Файл:Процевв_верификации.png]]

==Слайд:Верификация описания:step==
*{{Гол|''' <big>Среда моделирования</big>'''}}
** Active-HDL™
** Riviera-PRO™
** NC-Sim®
** ModelSim®
** QuestaSim®
** VCS-MX®
* {{Гол|'''<big>Структура проекта</big>'''}}
** Тестовое окружение
** RTL-модель (Verilog,VHDL)
** Эталонная модель (SystemC)
** Assert'ы (psl, OVVM, UVM)
** Отчеты и базы по результатам моделирования

==Слайд:Эталонная модель на языке ''{{Зел| <big>SystemC</big>}}''==

# Высокий уровень абстракции
# Скорость моделирования
# Возможности языка C++
# Инструменты для автоматизации
# Совместное моделирование с другими HDL-языками

== Основы языка SystemC ==

===Слайд:Типы данных (Форматы и способ представления данных) ===
[[Файл:Типы_данных.png]]

===Слайд:Типы данных (native)===
<source lang="cpp"> // Пример типа данных C++
int spark_offset;
unsigned repairs = 0 ; // Count repair
unsigned long mileage; // Miles driven
short int speedometer; // -20.. 0.. 100 MPH
float temperature; // Engine temp in C
double time_of_last_request; //Time of bus
std:: string license_plate; // Text for license
const bool WARNING_LIGHT = true; // Status
enum compass {SW,W,NW,N,NE,E, SE, S} ;
</source>

===Слайд:Типы данных (Arithmetic)===
<source lang="cpp"> // Пример целочисленных типов данных C++
sc_int<LENGTH> NAME...;
sc_uint<LENGTH> NAME...;
sc_bigint<BITWIDTH> NAME...;
sc_biguint<BITWIDTH> NAME...;
// SystemC integer data types
sc_int<5> seat_position=3; //5 bits: 4 plus sign
sc_uint<13> days_SLOC(4000); //13 bits: no sign
sc_biguint<80> revs_SLOC; // 80 bits: no sign
</source>

===Слайд:Типы данных (Boolean)===
<source lang="cpp"> // Пример типа данных SystemC
sc_bit NAME...;
sc_bv<BITWIDTH> NAME...;
</source>

* sc_bit и sc_bv могут принимать значения: '''SC_LOGIC_1''' и '''SC_LOGIC_0.'''
* Для сокращения типов, можно использовать '''Log_1 и Log_0''' или '''‘1’ и ‘0’.'''
* Над этим типом данных возможно выполнение битовых операций '''and, or, xor (&,|, ^).'''
* Для обращения к отдельным битам и массивам '''[], range()'''.

<source lang="cpp">
sc_bit flag(SC_LOGIC_1); // more efficient to use bool
sc_bv<5> positions = "01101";
sc_bv<6> mask = "100111";
sc_bv<5> active = positions & mask;// 00101
sc_bv<1> all = active. and_reduce (); // SC_LOGIC_0
positions. range (3,2) = "00"; // 00001
positions [2] = active[0] ^ flag;
</source>

===Слайд:Типы данных ( многозначные (ZX10))===
<source lang="cpp"> // Пример типа данных SystemC
sc_logic NAME[,NAME]...;
sc_lv<BITNIDTH> NAME[,NAME ]...;
sc_logic buf(sc_dt::Log_Z);
sc_lv<8> data_drive ("zz01XZ1Z");
data_drive.range (5,4) = "ZZ";// ZZZZXZ1Z
buf = '1';

</source>

===Слайд:Операторы SystemC ===
[[Файл:Операции.png]]

===Слайд:Главный модуль MAIN===
{{Гол|'''<big>Описание на языке C++</big>'''}}
<source lang="cpp">
int main(int argc, char* argv[]) {
BODY_OF_PROGRAM
return EXIT_CODE; //
}
</source>

{{Гол|'''<big>Описание на языке SystemC</big>'''}}
<source lang="cpp">
int sc_main(int argc, char* argv[]) {
//ELABORATION
sc_start(); // <-- Simulation begins & ends
// in this function!
//[POST-PROCESSING]
return EXIT_CODE; //
}
</source>

===Слайд: Модуль ===
<source lang="cpp">
#include <systemc.h>
SC_MODULE(module_name) {
MODULE_BODY
};</source>
Содержит:
* '''{{Фио|<big>Порты</big>}}'''
* '''{{Фио|<big>Каналы связи</big>}}'''
* '''{{Фио|<big>Объявления переменных для хранения данных</big>}}'''
* '''{{Фио|<big>Другие модули с большей вложенностью</big>}}'''
* '''{{Фио|<big>Конструктор</big>}}'''
* '''{{Фио|<big>Деструктор</big>}}'''
* '''{{Фио|<big>Функции -процессы</big>}}'''
* '''{{Фио|<big>Вспомогательные функции</big>}}'''

===Слайд: Конструктор (SC_CTOR)===
<source lang="cpp">SC_CTOR(module_name)
: Initialization // OPTIONAL
{
Subdesign_Allocation
Subdesign_Connectivity
Process_Registration
Miscellaneous_Setup
}</source>

* '''{{Фио|<big>Объявление под модулей</big>}}'''
* '''{{Фио|<big>Подключение и соединение с подмодулями</big>}}'''
* '''{{Фио|<big>Регистрация процессов на SystemC</big>}}'''
* '''{{Фио|<big>Обеспечение постоянной чувствительности</big>}}'''
* '''{{Фио|<big>Разнообразные пользовательские объявления</big>}}''

===Слайд: Конструктор (SC_HAS_PROCESS)===
<source lang="cpp">
//FILE: module_name.h
SC_MODULE(module_name) {
SC_HAS_PROCESS(module_name);
module_name(sc_module_name instname[, other_args…])
: sc_module(instname)
[, other_initializers]
{
CONSTRUCTOR_BODY
}
};</source>

* '''{{Фио|<big>Все возможности конструктора SC_CTOR</big>}}'''
* '''{{Фио|<big>Альтернативный метод создания модуля</big>}}'''
* '''{{Фио|<big>Позволяет создавать конструктор с аргументами(+ к имени модуля)</big>}}'''
* '''{{Фио|<big>Используется, если желаете расположить конструктор в файле описания .cpp (не в файле .h)</big>}}'''

===Слайд: Процесс SC_THREAD ===

<source lang="cpp">
SC_MODULE(simple_process_ex) {
SC_CTOR(simple_process_ex) {
SC_THREAD(my_thread_process);
}
void my_thread_process(void);
};</source>

{{Зел|'''SC_THREAD'''}} в '''SystemC''':
# аналог {{Зел|'''initial block'''}} в '''Verilog'''
# {{Зел|'''process'''}} без списка чувствительности с оператором '''wait()''' в '''VHDL'''.

===Слайд:Введение времени===

{{Ор|<big>'''Единицы измерения времени'''</big>}}

<source lang="cpp">
SC_SEC // seconds
SC_MS // milliseconds
SC_US // microseconds
SC_NS // nanoseconds
SC_PS // picoseconds
SC_FS // femtoseconds
</source>
{{Ор|<big>'''Объявление переменной типа '''</big>}}{{Зел|<big>'''sc_time'''</big>}}
<source lang="cpp">
sc_time t_PERIOD(5, SC_NS) ;
sc_time t_TIMEOUT (100, SC_MS) ;
sc_time t_MEASURE, t_CURRENT, t_LAST_CLOCK;
t_MEASURE = (t_CURRENT-t_LAST_CLOCK) ;
if (t_MEASURE > t_HOLD) { error ("Setup violated") }
</source>

===Слайд:Запуск выполнения '''sc_start()'''===

{{Ор|<big>'''Функция запускающая выполнения главного процесса '''</big>}}

{{Сн|'''Пример запуска моделирования на 60 секунд модельного времени'''}}

<source lang="cpp">
int sc_main(int argc, char* argv[]) { // args unused
simple_process_ex my_instance ("my_instance");
sc_start(60.0,SC_SEC); // Limit sim to one minute
return 0 ;
}</source>

===Слайд:Контроль текущего времени моделирования '''sc_time_stamp ()'''===

<source lang="cpp">
std::cout << " The time is now "
<< sc_time_stamp()
<< "!" << std::endl;</source>

После запуска моделирования в консоли получим
The time is now 0 ns!

===Слайд: Остановка выполнения моделирования wait(sc_time)===

{{Ор|<big>'''Функция останавливающая выполнение процесса до заданного времени или до прихода события'''</big>}}

<source lang="cpp">
void simple_process_ex::my_thread_process (void) {
wait (10,SC_NS);
std::cout<< "Now at "<< sc_time_stamp() << std::endl;
sc_time t_DELAY(2,SC_MS); // keyboard debounce time
t_DELAY *= 2;
std::cout<< "Delaying "<< t_DELAY<< std::endl;
wait(t_DELAY);
std::cout << "Now at " << sc_time_stamp()
<< std::endl;
}</source>

% . /run_example
Now at 10 ns
Delaying 4 ms
Now at 4000010 ns

===Слайд:События '''sc_event'''===
<slides split="-----" width="400" >
[[Файл:Процес_моделирования_по_событиям.png]]
</slides>

===Слайд:События '''SC_THREAD::wait()'''===
Процесс '''SC_THREAD''' процес выполняющийся {{Кр|'''<big>один раз!!</big>'''}}, для управления работой такого процесса используют функцию задержки выполнения wait

<source lang="cpp">wait(time);
wait(event);
wait(event1 | event2) // до прихода любого из событий
wait(event1 & event2) // до прихода всех событий вместе
wait(timeout, event); // до прихода события ожидает в течении времени
wait ( timeout, event1 | event2 )
wait ( timeout, event1 & event2 )
wait(); // ожидание дельта цикла выполнения, статическая задержка
</source>
===Слайд:Запуск события (установка,назначение)===

Для запуска события используется атрибут {{Зел|<big>'''.notify()'''</big>}}

Он выполняет запуск событий, отсчет времени идет от запуска моделирования. Для сброса точки отсчета используют {{Зел|<big>'''.cancel()'''</big>}}

<source lang="cpp">sc_event action;
sc_time now(sc_time_stamp()); //вытягиваем текущее время моделирования
//стартуем событие немедленно
action.notify();
//следующее событие через 20 ms от текущего момента
action.notify(20, SC_MS);
//переопределим событие на время 1.5 ns от текущего момента
action.notify(1.5,SC_NS);
//продублируем событие (не имеет эффекта)
action.notify(1.5, SC_NS);
//зададим событие от предыдущего на 1.5 ns
action.notify(3.0,SC_NS);
//запустим дельта цикл (не имеет эффекта)
action.notify(SC_ZERO_TIME);
//сбросим время задания события
action.cancel();
//зададим событие на 20 fs после сброса
action.notify(20,SC_FS);</source>

===Слайд:Процесс со списком чувствительности SC_METHOD ===
{{ЖЛампа|24px}}Аналог '''process''' в '''VHDL'''

<source lang="cpp">SC_METHOD(process_name);</source>

{{ЖЛампа|24px}}Список чуствительности задаеться после ключевого слова {{Зел|'''sensitive'''}}

<source lang="cpp"> sensitive << event [<< event] ;// поточный стил
sensitive (event [, event] ); // стиль с использованием функции</source>

===Слайд:dont_initialize() ===
{{ЖЛампа|24px}} Отменяет начальную установку значений
* После запуска моделирования конструктор создает модуль и инициализирует все процессы и переменные.

* Это заставляет выполниться всем методам работающим по событию по одному разу во время запуска если событие устанавливалось в значение.

* Для исключения начального выполнения используется функция '''dont_initialize()'''

===Слайд: Стек событий '''sc_event_queue'''===

{{ЖЛампа|24px}} Событие можно задать не только от начального момента времени, а и от текущего.

Для этого используется функция '''sc_event_queue()'''

<source lang="cpp">
sc_event_queue action;
sc_time now(sc_time_stamp());
action.notify(20, SC_MS);
action.notify(1.5,SC_NS);
action.notify(1.5,SC_NS);
action.notify(3.0,SC_NS);
action.notify(SC_ZERO_TIME);
action.notify(1,SC_SEC);
action.cancel_all();
</source>

===Слайд:Совместное использование ресурсов===

* При совместном использовании ресурсов, шин, памяти нужно разграничить область полномочий каждого процесса.
* Иначе при одновременной, к примеру записи будет происходить сбой или некорректная запись.
Если управлением доступом к одному ресурсу
<source lang="cpp">sc_mutex NAME;
// блокируем mutex NAME (ждем пока разблокируется)
NAME.lock();
// Возвращает статус состояния блокировки
NAME.try lock()
// Снимает блокировку
NAME.unlock();</source>

Если управлением доступом к нескольким ресурсам

<source lang="cpp">sc_semaphore NAME(COUNT);
// блокируем mutex NAME (ждем пока разблокируеться)
NAME.wait();
// Возвращает статус состояния блокировки
NAME.trywait()
//Возвращает число свободных ресурсов
NAME.get_value()
// Снимает блокировку
NAME.post();</source>

===Слайд:Иерархия и структура проекта===
[[Файл:Иерархия.png]]

===Слайд:Иерархия и структура проекта (sc_main)===

{{ЖЛампа|24px}}Подключение и создание {{Зел|<big>'''модуля'''</big>}} внутри '''главного''' модуля аналогично созданию {{Зел|<big>'''объекта'''</big>}} заданного{{Зел| <big>'''класса'''</big>}}
{{Фио|<big>'''Стандартная конструкция блока хранения информации для RFID'''</big>}}
{| cellspacing="0" cellpadding="0" border="1"
|
* {{Гол|'''Статический метод'''}}
<source lang="cpp">//FILE: main.cpp
#include "Wheel.h"
int sc_main(int argc, char* argv[]) {
Wheel wheel_FL("wheel_FL");
Wheel wheel_FR("wheel_FR");
sc_start();
}</source>
|
* {{Гол|'''Динамический метод'''}}
<source lang="cpp">//FILE: main.cpp
#include "Wheel.h"
int sc_main(int argc, char* argv[]) {
Wheel* wheel_FL; // pointer to FL wheel
Wheel* wheel_FR; // pointer to FR wheel
wheel_FL = new Wheel ("wheel_FL"); // create FL
wheel_FR = new Wheel ("wheel_FR"); // create FR
sc_start();
delete wheel_FL;
delete wheel_FR;
}</source>
|}

===Слайд:Иерархия и структура проекта (SC_MODULE)===

{{ЖЛампа|24px}}Подключение и создание {{Зел|<big>'''модуля'''</big>}} внутри другого модуля аналогично созданию {{Зел|<big>'''объекта'''</big>}} заданного{{Зел| <big>'''класса'''</big>}}, внутри другого класса. Поэтому объявления производиться в конструкторе верхнего модуля
{| cellspacing="0" cellpadding="0" border="1"
|

* {{Гол|'''Статический метод'''}}
<source lang="cpp">//FILE:Body.h
#include "Wheel.h"
SC_MODULE(Body) {
Wheel wheel_FL;
Wheel wheel_FR;
SC_CTOR(Body)
: wheel_FL("wheel_FL"), //initialization
wheel_FR("wheel_FR") //initialization
{
// other initialization
}
};
}</source>
|
* {{Гол|'''Динамический метод'''}}
<source lang="cpp">//FILE:Body.h
#include "Wheel.h"
SC_MODULE(Body) {
Wheel* wheel_FL;
Wheel* wheel_FR;
SC_CTOR(Body) {
wheel_FL = new Wheel("wheel_FL");
wheel_FR = new Wheel("wheel_FR");
// other initialization
}
};
}</source>
|}

===Слайд:Порты - точки подачи и снятия внешних воздействий===
[[Файл:Порты_соединение_модулей.png]]

===Слайд:Типы портов ===

* {{Сн|'''sc_port'''}} - аналог inout порта в языке VHDL
* {{Сн|'''sc_in'''}} - аналог in порта в языке VHDL
* {{Сн|'''sc_out'''}} - аналог out порта в языке VHDL
* {{Сн|'''sc_export'''}} - внешний порт, порт который позволяет получить доступ к private данным модуля, но иерархически модулю не принадлежит.
{{ЖЛампа|24px}} Механизм использования '''sc_export''' порта напоминает '''доступ к сигналам по иерархии''', как в '''VHDL-2008'''.

===Слайд:Порты - точки подачи и снятия внешних воздействий===
[[Файл:Порты_соединение_модулей_экспорт.png]]
[[Файл:Порты_соединение_модулей_экспорт2.png]]

===Слайд:Управление процессом и контроль статуса моделирования===

== Слайд: VHDL и SystemC конструкции ==
===Слайд: Entity ===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример поведенческой модели накопителя (VHDL)'''}}
<source lang="vhdl">
entity soft is
generic (UART_Speed : integer := 115200; -- UART Speed
System_CLK : integer := 50000000; -- System CLK in Hz
comand_file : string :="/home/Vidokq/djin18reader/vhd/D18/comfile.txt"
);
port (
CLK : out std_logic; -- system clk
RST_N : out std_logic; -- system reset#
DATA_IN : out std_logic_vector(7 downto 0); -- Transmit data
DATA_OUT : in std_logic_vector(7 downto 0); -- Recieved data
RX_VALID : in std_logic; -- RX buffer data ready
TX_VALID : out std_logic; -- Data for TX avaible
TX_BUSY : in std_logic; --
RX_BUSY : in std_logic);

end soft;
</source>

|
{{Фио|'''<big></big>Пример поведенческой модели накопителя (Verilog)'''}}

<source lang="cpp">

SC_MODULE (soft_sc_module)
{
public :
sc_in < sc_logic > tx_busy;
sc_in < sc_logic > rx_busy;
sc_in < sc_lv < 8 > > data_out;
sc_in < sc_logic > rx_valid;
sc_out < sc_logic > tx_valid;
sc_out < bool > clk;
sc_out < sc_logic > rst_n;
sc_out < sc_lv < 8 > > data_in;

public:

ifstream fin;

SC_CTOR(soft_sc_module)
: rst_n("rst_n"),
data_in("data_in"),
data_out ("data_out"),
rx_valid("rx_valid"),
tx_valid("tx_valid"),
tx_busy("tx_busy"),
rx_busy("rx_busy"),
rst_n_i("rst_n_i"),
clk_i("clk_i"),
clk("clk")
{
}
~soft_sc_module()
{
delete [] str_b;
}
};

#endif
</source>
|}
</slides>

===Слайд: Architecture ===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример Архитектуры на VHDL'''}}
<source lang="vhdl">

architecture beh of soft is
file comfile : text open read_mode is comand_file;

begin -- beh
-- тело архитектуры
signal str : string(1 to 1000) := (others => ' ');
signal RST_N_i : std_logic;
signal DATA_IN_i : std_logic_vector(7 downto 0);
signal f_get_answer : boolean := false;
signal tmd : time := 0 ms;

end beh;
</source>

|
{{Фио|'''<big></big>Пример аналогичной конструкции на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public :
std::string comand_file;
public :
sc_signal< sc_logic > rst_n_i;
sc_signal< sc_lv < 8 > > data_in_i;
sc_signal < bool > f_get_answer;
sc_signal < sc_time > tmd;
sc_time btmd (0, SC_MS);
SC_CTOR(soft_sc_module)
:
rst_n_i("rst_n_i"),
data_in_i("data_in_i"),
f_get_answer("f_get_answer"),
tmd("tmd")
{
str = new char [1000];
//объявление функций
//выбор списка чувствительности
//установка значений по умолчанию
tmd.write(btmd);
// tmd = btmd;
//оператор присваивания перегружен и выолнит вызов функции write
}
~soft_sc_module()
{
delete [] str;
}
</source>
|}
</slides>

===Слайд: Generic ===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
entity soft is
generic (UART_Speed : integer := 115200;
System_CLK : integer := 50000000
);
--
--
--
architecture beh of soft is
CLK_i <= not CLK_i after 1 ns * (1000000000 / System_CLK );
end beh;
</source>

|
{{Фио|'''<big></big>Пример на SystemC (sc_get_param)'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module)
: rst_n("rst_n"),
tmd("tmd")
{
if (!sc_get_param("System_CLK",System_CLK)) cout << "error get generic";
if (!sc_get_param("UART_Speed",UART_Speed)) cout << "error get generic";
period_ns=(1000000000)/System_CLK;
str = new char [1000];
}
~soft_sc_module()
{
delete [] str_b;
}
};
</source>
|}
</slides>

===Слайд: Process без списка чувствительности ===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
wait_byte_timer: process
begin -- process wiat_timer
wait for 0.5 ms;
if (NOW - tmd) > 1 ms then
if f_start_get_answer then
f_byte_timer <= true;
wait for 0.1 ms;
f_byte_timer <= false;
end if;
end if;
end process wait_byte_timer;
</source>

|
{{Фио|'''<big></big>Пример на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module):
{ SC_METHOD (wait_byte_timer); }
~soft_sc_module()
{ }
};
void soft_sc_module :: wait_byte_timer ()
{
next_trigger (0.5,SC_MS);
if ((sc_time_stamp()-tmd) > sc_time(1, SC_MS) )
if (f_start_get_answer)
{f_byte_timer=true;
next_trigger (0.1,SC_MS);
f_byte_timer=false;
}
cout<< "wait_byte_timer work\n";
}
</source>
|}
</slides>

===Слайд: Process со списком чувствительности (пример 1)===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
CLK_i <= not CLK_i after 1 ns * (1000000000 / System_CLK );
--или
process (clk)
begin
if clk'event then
clk_i <= not clk_i after 1 ns * (1000000000 / System_CLK );
end if;
end process;
</source>
|
{{Фио|'''<big></big>Пример на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module):
{ clk_i=true;
period_ns=(1000000000)/System_CLK;
SC_METHOD (clk_gen);
}
~soft_sc_module()
{ }
};

void soft_sc_module :: clk_gen ()
{
clk_i.write(!clk_i.read());
next_trigger (period_ns, SC_NS);

}
</source>
|}
</slides>

===Слайд: Process со списком чувствительности (пример 2) ===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
RST_N <= RST_N_i;
--или
process (RST_N_i)
begin
if RST_N_i'event then
RST_N <= RST_N_i;
end if;
end process;
</source>
|
{{Фио|'''<big></big>Пример на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module):
{ clk_i=true;
SC_METHOD (rst_n_i2rst_n);
sensitive << rst_n_i;
dont_initialize();
}
~soft_sc_module()
{ }
};

void soft_sc_module :: reset_gen ()
{
rst_n_i.write( SC_LOGIC_0 );
wait (100, SC_NS);
cout << "run reset";
rst_n_i.write( SC_LOGIC_1 );
}
</source>
|}
</slides>

===Слайд: Работа с файлами ===
<slides split="-----" width="800" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
p_send : process
variable l : line;
variable byte_r : std_logic_vector(0 to 7);
variable good : boolean;
variable f_first_byte : boolean:=false;
begin -- process p1

loop1: while not endfile(comfile) loop

readline (comfile,l);
skip_space (l);
next loop1 when l'length = 0;

for i in 1 to l'length loop
str(i) <= l(i);
end loop; -- i
str((l'length)+1 to 1000) <= (others => ' ');
str_l <= l'length;
</source>
|
<source lang="vhdl">
if l(1) = '#' then
assert false report "коментарий:"&str(1 to str_l) severity NOTE;
else
assert false report "коментарий"&str(1 to str_l) severity NOTE;
f_first_byte := true;
while l'length /= 0 loop
hread (l,byte_r,good);
assert good report "ошибка" severity FAILURE;
if f_first_byte then
f_first_byte := false;
comand <= byte_r;
end if;
TX_VALID_i <= '1';
DATA_IN_i <= byte_r;
skip_space (l);
wait until TX_BUSY = '1';
end loop;
f_start_timer <= true;
TX_VALID_i <= '0';
wait until f_get_answer or f_timer;
assert not f_timer report "1мкс" severity FAILURE;
f_start_timer <= false;
end if;
end loop;
assert false report "======" severity failure;
end process p_send;
</source>
|}
</slides>

===Слайд: Работа с файлами ===
<slides split="-----" width="800" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на SystemC'''}}
<source lang="cpp">
void soft_sc_module :: p_send ()
{
fin.open(comand_file.c_str(),ios::out);
cout << "work4\n";
bool f_first_byte=false;
if (!fin){
std::cout << "File invalide open";
exit (0);
}
while (!fin.eof()){
fin.getline (str,1000);
skip_space (&(str));
if (strlen(str)){
if (str[0] == '#')
cout << "koment: "<< str <<endl;
else {
cout << "data: "<< str <<endl;
f_first_byte=true;
//while ( str[0] != '\0' ){
while ( strlen(str) ){
if ( str[0] == ' ' )
skip_space(&(str));
else {
//cout << "1/2\n";
byte_b.range(7,4)=str[0];
str++;
skip_space(&(str));
if (!strlen(str)){
cout<<endl<<"error";
sc_stop();
}
else {
//cout << "2/2\n";
byte_b.range(3,0)=str[0];
str++;
}
</source>
|
<source lang="cpp">

if (f_first_byte){
f_first_byte=false;
comand=byte_b;
}
//cout << byte_b << endl;
tx_valid_i.write(SC_LOGIC_1);
data_in.write(byte_b);
wait (tx_busy.posedge_event());
}
}
f_start_timer = true;
tx_valid_i.write(SC_LOGIC_0);
wait ( f_get_answer.posedge_event() | f_timer.posedge_event() );
if ( f_timer ) {cout << "error";sc_stop();}
f_start_timer = false;
}
}
str=str_b;
}
cout << "error";
fin.close();
sc_stop();
}
</source>
|}
</slides>

===Слайд: Работа с переменными ===
===Слайд: Работа с сигналами ===
===Слайд: Арифметические, логические, операции присваивания ===
===Слайд: Конструкции С++ ===
===Слайд: Создание модуля ===
===Слайд: Коммуникации между модулями ===
===Слайд: Управление процессом моделирования (сообщения, запуск останов моделирования)===
== Слайд: Компиляция описания ==
== Слайд: Запуск моделирования только SystemC описания ==
== Слайд: Запуск моделирования SystemC описания и VHDL ==

Спец курс (Избранные главы VHDL)/Верификация описания

2012-11-19T14:16:51Z

164.177.206.33: /* Слайд: Process со списком чувствительности (пример 1) */

<slideshow style="custis" headingmark="Слайд:" incmark=":step" scaled="true" >
;title: '''Верификация описания.'''
;author: Зайцев В.С.
</slideshow>

[[Файл:SystemC_From_the_ground_up.mm]]

==Слайд:Верификация описания==
[[Файл:Процевв_верификации.png]]

==Слайд:Верификация описания:step==
*{{Гол|''' <big>Среда моделирования</big>'''}}
** Active-HDL™
** Riviera-PRO™
** NC-Sim®
** ModelSim®
** QuestaSim®
** VCS-MX®
* {{Гол|'''<big>Структура проекта</big>'''}}
** Тестовое окружение
** RTL-модель (Verilog,VHDL)
** Эталонная модель (SystemC)
** Assert'ы (psl, OVVM, UVM)
** Отчеты и базы по результатам моделирования

==Слайд:Эталонная модель на языке ''{{Зел| <big>SystemC</big>}}''==

# Высокий уровень абстракции
# Скорость моделирования
# Возможности языка C++
# Инструменты для автоматизации
# Совместное моделирование с другими HDL-языками

== Основы языка SystemC ==

===Слайд:Типы данных (Форматы и способ представления данных) ===
[[Файл:Типы_данных.png]]

===Слайд:Типы данных (native)===
<source lang="cpp"> // Пример типа данных C++
int spark_offset;
unsigned repairs = 0 ; // Count repair
unsigned long mileage; // Miles driven
short int speedometer; // -20.. 0.. 100 MPH
float temperature; // Engine temp in C
double time_of_last_request; //Time of bus
std:: string license_plate; // Text for license
const bool WARNING_LIGHT = true; // Status
enum compass {SW,W,NW,N,NE,E, SE, S} ;
</source>

===Слайд:Типы данных (Arithmetic)===
<source lang="cpp"> // Пример целочисленных типов данных C++
sc_int<LENGTH> NAME...;
sc_uint<LENGTH> NAME...;
sc_bigint<BITWIDTH> NAME...;
sc_biguint<BITWIDTH> NAME...;
// SystemC integer data types
sc_int<5> seat_position=3; //5 bits: 4 plus sign
sc_uint<13> days_SLOC(4000); //13 bits: no sign
sc_biguint<80> revs_SLOC; // 80 bits: no sign
</source>

===Слайд:Типы данных (Boolean)===
<source lang="cpp"> // Пример типа данных SystemC
sc_bit NAME...;
sc_bv<BITWIDTH> NAME...;
</source>

* sc_bit и sc_bv могут принимать значения: '''SC_LOGIC_1''' и '''SC_LOGIC_0.'''
* Для сокращения типов, можно использовать '''Log_1 и Log_0''' или '''‘1’ и ‘0’.'''
* Над этим типом данных возможно выполнение битовых операций '''and, or, xor (&,|, ^).'''
* Для обращения к отдельным битам и массивам '''[], range()'''.

<source lang="cpp">
sc_bit flag(SC_LOGIC_1); // more efficient to use bool
sc_bv<5> positions = "01101";
sc_bv<6> mask = "100111";
sc_bv<5> active = positions & mask;// 00101
sc_bv<1> all = active. and_reduce (); // SC_LOGIC_0
positions. range (3,2) = "00"; // 00001
positions [2] = active[0] ^ flag;
</source>

===Слайд:Типы данных ( многозначные (ZX10))===
<source lang="cpp"> // Пример типа данных SystemC
sc_logic NAME[,NAME]...;
sc_lv<BITNIDTH> NAME[,NAME ]...;
sc_logic buf(sc_dt::Log_Z);
sc_lv<8> data_drive ("zz01XZ1Z");
data_drive.range (5,4) = "ZZ";// ZZZZXZ1Z
buf = '1';

</source>

===Слайд:Операторы SystemC ===
[[Файл:Операции.png]]

===Слайд:Главный модуль MAIN===
{{Гол|'''<big>Описание на языке C++</big>'''}}
<source lang="cpp">
int main(int argc, char* argv[]) {
BODY_OF_PROGRAM
return EXIT_CODE; //
}
</source>

{{Гол|'''<big>Описание на языке SystemC</big>'''}}
<source lang="cpp">
int sc_main(int argc, char* argv[]) {
//ELABORATION
sc_start(); // <-- Simulation begins & ends
// in this function!
//[POST-PROCESSING]
return EXIT_CODE; //
}
</source>

===Слайд: Модуль ===
<source lang="cpp">
#include <systemc.h>
SC_MODULE(module_name) {
MODULE_BODY
};</source>
Содержит:
* '''{{Фио|<big>Порты</big>}}'''
* '''{{Фио|<big>Каналы связи</big>}}'''
* '''{{Фио|<big>Объявления переменных для хранения данных</big>}}'''
* '''{{Фио|<big>Другие модули с большей вложенностью</big>}}'''
* '''{{Фио|<big>Конструктор</big>}}'''
* '''{{Фио|<big>Деструктор</big>}}'''
* '''{{Фио|<big>Функции -процессы</big>}}'''
* '''{{Фио|<big>Вспомогательные функции</big>}}'''

===Слайд: Конструктор (SC_CTOR)===
<source lang="cpp">SC_CTOR(module_name)
: Initialization // OPTIONAL
{
Subdesign_Allocation
Subdesign_Connectivity
Process_Registration
Miscellaneous_Setup
}</source>

* '''{{Фио|<big>Объявление под модулей</big>}}'''
* '''{{Фио|<big>Подключение и соединение с подмодулями</big>}}'''
* '''{{Фио|<big>Регистрация процессов на SystemC</big>}}'''
* '''{{Фио|<big>Обеспечение постоянной чувствительности</big>}}'''
* '''{{Фио|<big>Разнообразные пользовательские объявления</big>}}''

===Слайд: Конструктор (SC_HAS_PROCESS)===
<source lang="cpp">
//FILE: module_name.h
SC_MODULE(module_name) {
SC_HAS_PROCESS(module_name);
module_name(sc_module_name instname[, other_args…])
: sc_module(instname)
[, other_initializers]
{
CONSTRUCTOR_BODY
}
};</source>

* '''{{Фио|<big>Все возможности конструктора SC_CTOR</big>}}'''
* '''{{Фио|<big>Альтернативный метод создания модуля</big>}}'''
* '''{{Фио|<big>Позволяет создавать конструктор с аргументами(+ к имени модуля)</big>}}'''
* '''{{Фио|<big>Используется, если желаете расположить конструктор в файле описания .cpp (не в файле .h)</big>}}'''

===Слайд: Процесс SC_THREAD ===

<source lang="cpp">
SC_MODULE(simple_process_ex) {
SC_CTOR(simple_process_ex) {
SC_THREAD(my_thread_process);
}
void my_thread_process(void);
};</source>

{{Зел|'''SC_THREAD'''}} в '''SystemC''':
# аналог {{Зел|'''initial block'''}} в '''Verilog'''
# {{Зел|'''process'''}} без списка чувствительности с оператором '''wait()''' в '''VHDL'''.

===Слайд:Введение времени===

{{Ор|<big>'''Единицы измерения времени'''</big>}}

<source lang="cpp">
SC_SEC // seconds
SC_MS // milliseconds
SC_US // microseconds
SC_NS // nanoseconds
SC_PS // picoseconds
SC_FS // femtoseconds
</source>
{{Ор|<big>'''Объявление переменной типа '''</big>}}{{Зел|<big>'''sc_time'''</big>}}
<source lang="cpp">
sc_time t_PERIOD(5, SC_NS) ;
sc_time t_TIMEOUT (100, SC_MS) ;
sc_time t_MEASURE, t_CURRENT, t_LAST_CLOCK;
t_MEASURE = (t_CURRENT-t_LAST_CLOCK) ;
if (t_MEASURE > t_HOLD) { error ("Setup violated") }
</source>

===Слайд:Запуск выполнения '''sc_start()'''===

{{Ор|<big>'''Функция запускающая выполнения главного процесса '''</big>}}

{{Сн|'''Пример запуска моделирования на 60 секунд модельного времени'''}}

<source lang="cpp">
int sc_main(int argc, char* argv[]) { // args unused
simple_process_ex my_instance ("my_instance");
sc_start(60.0,SC_SEC); // Limit sim to one minute
return 0 ;
}</source>

===Слайд:Контроль текущего времени моделирования '''sc_time_stamp ()'''===

<source lang="cpp">
std::cout << " The time is now "
<< sc_time_stamp()
<< "!" << std::endl;</source>

После запуска моделирования в консоли получим
The time is now 0 ns!

===Слайд: Остановка выполнения моделирования wait(sc_time)===

{{Ор|<big>'''Функция останавливающая выполнение процесса до заданного времени или до прихода события'''</big>}}

<source lang="cpp">
void simple_process_ex::my_thread_process (void) {
wait (10,SC_NS);
std::cout<< "Now at "<< sc_time_stamp() << std::endl;
sc_time t_DELAY(2,SC_MS); // keyboard debounce time
t_DELAY *= 2;
std::cout<< "Delaying "<< t_DELAY<< std::endl;
wait(t_DELAY);
std::cout << "Now at " << sc_time_stamp()
<< std::endl;
}</source>

% . /run_example
Now at 10 ns
Delaying 4 ms
Now at 4000010 ns

===Слайд:События '''sc_event'''===
<slides split="-----" width="400" >
[[Файл:Процес_моделирования_по_событиям.png]]
</slides>

===Слайд:События '''SC_THREAD::wait()'''===
Процесс '''SC_THREAD''' процес выполняющийся {{Кр|'''<big>один раз!!</big>'''}}, для управления работой такого процесса используют функцию задержки выполнения wait

<source lang="cpp">wait(time);
wait(event);
wait(event1 | event2) // до прихода любого из событий
wait(event1 & event2) // до прихода всех событий вместе
wait(timeout, event); // до прихода события ожидает в течении времени
wait ( timeout, event1 | event2 )
wait ( timeout, event1 & event2 )
wait(); // ожидание дельта цикла выполнения, статическая задержка
</source>
===Слайд:Запуск события (установка,назначение)===

Для запуска события используется атрибут {{Зел|<big>'''.notify()'''</big>}}

Он выполняет запуск событий, отсчет времени идет от запуска моделирования. Для сброса точки отсчета используют {{Зел|<big>'''.cancel()'''</big>}}

<source lang="cpp">sc_event action;
sc_time now(sc_time_stamp()); //вытягиваем текущее время моделирования
//стартуем событие немедленно
action.notify();
//следующее событие через 20 ms от текущего момента
action.notify(20, SC_MS);
//переопределим событие на время 1.5 ns от текущего момента
action.notify(1.5,SC_NS);
//продублируем событие (не имеет эффекта)
action.notify(1.5, SC_NS);
//зададим событие от предыдущего на 1.5 ns
action.notify(3.0,SC_NS);
//запустим дельта цикл (не имеет эффекта)
action.notify(SC_ZERO_TIME);
//сбросим время задания события
action.cancel();
//зададим событие на 20 fs после сброса
action.notify(20,SC_FS);</source>

===Слайд:Процесс со списком чувствительности SC_METHOD ===
{{ЖЛампа|24px}}Аналог '''process''' в '''VHDL'''

<source lang="cpp">SC_METHOD(process_name);</source>

{{ЖЛампа|24px}}Список чуствительности задаеться после ключевого слова {{Зел|'''sensitive'''}}

<source lang="cpp"> sensitive << event [<< event] ;// поточный стил
sensitive (event [, event] ); // стиль с использованием функции</source>

===Слайд:dont_initialize() ===
{{ЖЛампа|24px}} Отменяет начальную установку значений
* После запуска моделирования конструктор создает модуль и инициализирует все процессы и переменные.

* Это заставляет выполниться всем методам работающим по событию по одному разу во время запуска если событие устанавливалось в значение.

* Для исключения начального выполнения используется функция '''dont_initialize()'''

===Слайд: Стек событий '''sc_event_queue'''===

{{ЖЛампа|24px}} Событие можно задать не только от начального момента времени, а и от текущего.

Для этого используется функция '''sc_event_queue()'''

<source lang="cpp">
sc_event_queue action;
sc_time now(sc_time_stamp());
action.notify(20, SC_MS);
action.notify(1.5,SC_NS);
action.notify(1.5,SC_NS);
action.notify(3.0,SC_NS);
action.notify(SC_ZERO_TIME);
action.notify(1,SC_SEC);
action.cancel_all();
</source>

===Слайд:Совместное использование ресурсов===

* При совместном использовании ресурсов, шин, памяти нужно разграничить область полномочий каждого процесса.
* Иначе при одновременной, к примеру записи будет происходить сбой или некорректная запись.
Если управлением доступом к одному ресурсу
<source lang="cpp">sc_mutex NAME;
// блокируем mutex NAME (ждем пока разблокируется)
NAME.lock();
// Возвращает статус состояния блокировки
NAME.try lock()
// Снимает блокировку
NAME.unlock();</source>

Если управлением доступом к нескольким ресурсам

<source lang="cpp">sc_semaphore NAME(COUNT);
// блокируем mutex NAME (ждем пока разблокируеться)
NAME.wait();
// Возвращает статус состояния блокировки
NAME.trywait()
//Возвращает число свободных ресурсов
NAME.get_value()
// Снимает блокировку
NAME.post();</source>

===Слайд:Иерархия и структура проекта===
[[Файл:Иерархия.png]]

===Слайд:Иерархия и структура проекта (sc_main)===

{{ЖЛампа|24px}}Подключение и создание {{Зел|<big>'''модуля'''</big>}} внутри '''главного''' модуля аналогично созданию {{Зел|<big>'''объекта'''</big>}} заданного{{Зел| <big>'''класса'''</big>}}
{{Фио|<big>'''Стандартная конструкция блока хранения информации для RFID'''</big>}}
{| cellspacing="0" cellpadding="0" border="1"
|
* {{Гол|'''Статический метод'''}}
<source lang="cpp">//FILE: main.cpp
#include "Wheel.h"
int sc_main(int argc, char* argv[]) {
Wheel wheel_FL("wheel_FL");
Wheel wheel_FR("wheel_FR");
sc_start();
}</source>
|
* {{Гол|'''Динамический метод'''}}
<source lang="cpp">//FILE: main.cpp
#include "Wheel.h"
int sc_main(int argc, char* argv[]) {
Wheel* wheel_FL; // pointer to FL wheel
Wheel* wheel_FR; // pointer to FR wheel
wheel_FL = new Wheel ("wheel_FL"); // create FL
wheel_FR = new Wheel ("wheel_FR"); // create FR
sc_start();
delete wheel_FL;
delete wheel_FR;
}</source>
|}

===Слайд:Иерархия и структура проекта (SC_MODULE)===

{{ЖЛампа|24px}}Подключение и создание {{Зел|<big>'''модуля'''</big>}} внутри другого модуля аналогично созданию {{Зел|<big>'''объекта'''</big>}} заданного{{Зел| <big>'''класса'''</big>}}, внутри другого класса. Поэтому объявления производиться в конструкторе верхнего модуля
{| cellspacing="0" cellpadding="0" border="1"
|

* {{Гол|'''Статический метод'''}}
<source lang="cpp">//FILE:Body.h
#include "Wheel.h"
SC_MODULE(Body) {
Wheel wheel_FL;
Wheel wheel_FR;
SC_CTOR(Body)
: wheel_FL("wheel_FL"), //initialization
wheel_FR("wheel_FR") //initialization
{
// other initialization
}
};
}</source>
|
* {{Гол|'''Динамический метод'''}}
<source lang="cpp">//FILE:Body.h
#include "Wheel.h"
SC_MODULE(Body) {
Wheel* wheel_FL;
Wheel* wheel_FR;
SC_CTOR(Body) {
wheel_FL = new Wheel("wheel_FL");
wheel_FR = new Wheel("wheel_FR");
// other initialization
}
};
}</source>
|}

===Слайд:Порты - точки подачи и снятия внешних воздействий===
[[Файл:Порты_соединение_модулей.png]]

===Слайд:Типы портов ===

* {{Сн|'''sc_port'''}} - аналог inout порта в языке VHDL
* {{Сн|'''sc_in'''}} - аналог in порта в языке VHDL
* {{Сн|'''sc_out'''}} - аналог out порта в языке VHDL
* {{Сн|'''sc_export'''}} - внешний порт, порт который позволяет получить доступ к private данным модуля, но иерархически модулю не принадлежит.
{{ЖЛампа|24px}} Механизм использования '''sc_export''' порта напоминает '''доступ к сигналам по иерархии''', как в '''VHDL-2008'''.

===Слайд:Порты - точки подачи и снятия внешних воздействий===
[[Файл:Порты_соединение_модулей_экспорт.png]]
[[Файл:Порты_соединение_модулей_экспорт2.png]]

===Слайд:Управление процессом и контроль статуса моделирования===

== Слайд: VHDL и SystemC конструкции ==
===Слайд: Entity ===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример поведенческой модели накопителя (VHDL)'''}}
<source lang="vhdl">
entity soft is
generic (UART_Speed : integer := 115200; -- UART Speed
System_CLK : integer := 50000000; -- System CLK in Hz
comand_file : string :="/home/Vidokq/djin18reader/vhd/D18/comfile.txt"
);
port (
CLK : out std_logic; -- system clk
RST_N : out std_logic; -- system reset#
DATA_IN : out std_logic_vector(7 downto 0); -- Transmit data
DATA_OUT : in std_logic_vector(7 downto 0); -- Recieved data
RX_VALID : in std_logic; -- RX buffer data ready
TX_VALID : out std_logic; -- Data for TX avaible
TX_BUSY : in std_logic; --
RX_BUSY : in std_logic);

end soft;
</source>

|
{{Фио|'''<big></big>Пример поведенческой модели накопителя (Verilog)'''}}

<source lang="cpp">

SC_MODULE (soft_sc_module)
{
public :
sc_in < sc_logic > tx_busy;
sc_in < sc_logic > rx_busy;
sc_in < sc_lv < 8 > > data_out;
sc_in < sc_logic > rx_valid;
sc_out < sc_logic > tx_valid;
sc_out < bool > clk;
sc_out < sc_logic > rst_n;
sc_out < sc_lv < 8 > > data_in;

public:

ifstream fin;

SC_CTOR(soft_sc_module)
: rst_n("rst_n"),
data_in("data_in"),
data_out ("data_out"),
rx_valid("rx_valid"),
tx_valid("tx_valid"),
tx_busy("tx_busy"),
rx_busy("rx_busy"),
rst_n_i("rst_n_i"),
clk_i("clk_i"),
clk("clk")
{
}
~soft_sc_module()
{
delete [] str_b;
}
};

#endif
</source>
|}
</slides>

===Слайд: Architecture ===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример Архитектуры на VHDL'''}}
<source lang="vhdl">

architecture beh of soft is
file comfile : text open read_mode is comand_file;

begin -- beh
-- тело архитектуры
signal str : string(1 to 1000) := (others => ' ');
signal RST_N_i : std_logic;
signal DATA_IN_i : std_logic_vector(7 downto 0);
signal f_get_answer : boolean := false;
signal tmd : time := 0 ms;

end beh;
</source>

|
{{Фио|'''<big></big>Пример аналогичной конструкции на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public :
std::string comand_file;
public :
sc_signal< sc_logic > rst_n_i;
sc_signal< sc_lv < 8 > > data_in_i;
sc_signal < bool > f_get_answer;
sc_signal < sc_time > tmd;
sc_time btmd (0, SC_MS);
SC_CTOR(soft_sc_module)
:
rst_n_i("rst_n_i"),
data_in_i("data_in_i"),
f_get_answer("f_get_answer"),
tmd("tmd")
{
str = new char [1000];
//объявление функций
//выбор списка чувствительности
//установка значений по умолчанию
tmd.write(btmd);
// tmd = btmd;
//оператор присваивания перегружен и выолнит вызов функции write
}
~soft_sc_module()
{
delete [] str;
}
</source>
|}
</slides>

===Слайд: Generic ===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
entity soft is
generic (UART_Speed : integer := 115200;
System_CLK : integer := 50000000
);
--
--
--
architecture beh of soft is
CLK_i <= not CLK_i after 1 ns * (1000000000 / System_CLK );
end beh;
</source>

|
{{Фио|'''<big></big>Пример на SystemC (sc_get_param)'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module)
: rst_n("rst_n"),
tmd("tmd")
{
if (!sc_get_param("System_CLK",System_CLK)) cout << "error get generic";
if (!sc_get_param("UART_Speed",UART_Speed)) cout << "error get generic";
period_ns=(1000000000)/System_CLK;
str = new char [1000];
}
~soft_sc_module()
{
delete [] str_b;
}
};
</source>
|}
</slides>

===Слайд: Process без списка чувствительности ===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
wait_byte_timer: process
begin -- process wiat_timer
wait for 0.5 ms;
if (NOW - tmd) > 1 ms then
if f_start_get_answer then
f_byte_timer <= true;
wait for 0.1 ms;
f_byte_timer <= false;
end if;
end if;
end process wait_byte_timer;
</source>

|
{{Фио|'''<big></big>Пример на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module):
{ SC_METHOD (wait_byte_timer); }
~soft_sc_module()
{ }
};
void soft_sc_module :: wait_byte_timer ()
{
next_trigger (0.5,SC_MS);
if ((sc_time_stamp()-tmd) > sc_time(1, SC_MS) )
if (f_start_get_answer)
{f_byte_timer=true;
next_trigger (0.1,SC_MS);
f_byte_timer=false;
}
cout<< "wait_byte_timer work\n";
}
</source>
|}
</slides>

===Слайд: Process со списком чувствительности (пример 1)===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
CLK_i <= not CLK_i after 1 ns * (1000000000 / System_CLK );
--или
process (clk)
begin
if clk'event then
clk_i <= not clk_i after 1 ns * (1000000000 / System_CLK );
end if;
end process;
</source>
|
{{Фио|'''<big></big>Пример на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module):
{ clk_i=true;
period_ns=(1000000000)/System_CLK;
SC_METHOD (clk_gen);
}
~soft_sc_module()
{ }
};

void soft_sc_module :: clk_gen ()
{
clk_i.write(!clk_i.read());
next_trigger (period_ns, SC_NS);

}
</source>
|}
</slides>

===Слайд: Process со списком чувствительности (пример 2) ===

<slides split="-----" width="400" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
RST_N <= RST_N_i;
--или
process (RST_N_i)
begin
if RST_N_i'event then
RST_N <= RST_N_i;
end if;
end process;
</source>
|
{{Фио|'''<big></big>Пример на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module):
{ clk_i=true;
SC_METHOD (rst_n_i2rst_n);
sensitive << rst_n_i;
dont_initialize();
}
~soft_sc_module()
{ }
};

void soft_sc_module :: reset_gen ()
{
rst_n_i.write( SC_LOGIC_0 );
wait (100, SC_NS);
cout << "run reset";
rst_n_i.write( SC_LOGIC_1 );
}
</source>
|}
</slides>

===Слайд: Работа с файлами ===
<slides split="-----" width="800" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
p_send : process
variable l : line;
variable byte_r : std_logic_vector(0 to 7);
variable good : boolean;
variable f_first_byte : boolean:=false;
begin -- process p1

loop1: while not endfile(comfile) loop

readline (comfile,l);
skip_space (l);
next loop1 when l'length = 0;

for i in 1 to l'length loop
str(i) <= l(i);
end loop; -- i
str((l'length)+1 to 1000) <= (others => ' ');
str_l <= l'length;
</source>
|
<source lang="vhdl">
if l(1) = '#' then
assert false report "коментарий:"&str(1 to str_l) severity NOTE;
else
assert false report "коментарий"&str(1 to str_l) severity NOTE;
f_first_byte := true;
while l'length /= 0 loop
hread (l,byte_r,good);
assert good report "ошибка" severity FAILURE;
if f_first_byte then
f_first_byte := false;
comand <= byte_r;
end if;
TX_VALID_i <= '1';
DATA_IN_i <= byte_r;
skip_space (l);
wait until TX_BUSY = '1';
end loop;
f_start_timer <= true;
TX_VALID_i <= '0';
wait until f_get_answer or f_timer;
assert not f_timer report "1мкс" severity FAILURE;
f_start_timer <= false;
end if;
end loop;
assert false report "======" severity failure;
end process p_send;
</source>
|}
</slides>

===Слайд: Работа с файлами ===
<slides split="-----" width="800" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на SystemC'''}}
<source lang="cpp">
void soft_sc_module :: p_send ()
{
fin.open(comand_file.c_str(),ios::out);
cout << "work4\n";
bool f_first_byte=false;
if (!fin){
std::cout << "File invalide open";
exit (0);
}
while (!fin.eof()){
fin.getline (str,1000);
skip_space (&(str));
if (strlen(str)){
if (str[0] == '#')
cout << "koment: "<< str <<endl;
else {
cout << "data: "<< str <<endl;
f_first_byte=true;
//while ( str[0] != '\0' ){
while ( strlen(str) ){
if ( str[0] == ' ' )
skip_space(&(str));
else {
//cout << "1/2\n";
byte_b.range(7,4)=str[0];
str++;
skip_space(&(str));
if (!strlen(str)){
cout<<endl<<"error";
sc_stop();
}
else {
//cout << "2/2\n";
byte_b.range(3,0)=str[0];
str++;
}
</source>
|
<source lang="cpp">

if (f_first_byte){
f_first_byte=false;
comand=byte_b;
}
//cout << byte_b << endl;
tx_valid_i.write(SC_LOGIC_1);
data_in.write(byte_b);
wait (tx_busy.posedge_event());
}
}
f_start_timer = true;
tx_valid_i.write(SC_LOGIC_0);
wait ( f_get_answer.posedge_event() | f_timer.posedge_event() );
if ( f_timer ) {cout << "error";sc_stop();}
f_start_timer = false;
}
}
str=str_b;
}
cout << "error";
fin.close();
sc_stop();
}
</source>
|}
</slides>

===Слайд: Работа с переменными ===
===Слайд: Работа с сигналами ===
===Слайд: Арифметические, логические, операции присваивания ===
===Слайд: Конструкции С++ ===
===Слайд: Создание модуля ===
===Слайд: Коммуникации между модулями ===
===Слайд: Управление процессом моделирования (сообщения, запуск останов моделирования)===
== Слайд: Компиляция описания ==
== Слайд: Запуск моделирования только SystemC описания ==
== Слайд: Запуск моделирования SystemC описания и VHDL ==

Спец курс (Избранные главы VHDL)/Верификация описания

2012-11-19T14:15:25Z

164.177.206.33: /* Слайд: Process без списка чувствительности */

<slideshow style="custis" headingmark="Слайд:" incmark=":step" scaled="true" >
;title: '''Верификация описания.'''
;author: Зайцев В.С.
</slideshow>

[[Файл:SystemC_From_the_ground_up.mm]]

==Слайд:Верификация описания==
[[Файл:Процевв_верификации.png]]

==Слайд:Верификация описания:step==
*{{Гол|''' <big>Среда моделирования</big>'''}}
** Active-HDL™
** Riviera-PRO™
** NC-Sim®
** ModelSim®
** QuestaSim®
** VCS-MX®
* {{Гол|'''<big>Структура проекта</big>'''}}
** Тестовое окружение
** RTL-модель (Verilog,VHDL)
** Эталонная модель (SystemC)
** Assert'ы (psl, OVVM, UVM)
** Отчеты и базы по результатам моделирования

==Слайд:Эталонная модель на языке ''{{Зел| <big>SystemC</big>}}''==

# Высокий уровень абстракции
# Скорость моделирования
# Возможности языка C++
# Инструменты для автоматизации
# Совместное моделирование с другими HDL-языками

== Основы языка SystemC ==

===Слайд:Типы данных (Форматы и способ представления данных) ===
[[Файл:Типы_данных.png]]

===Слайд:Типы данных (native)===
<source lang="cpp"> // Пример типа данных C++
int spark_offset;
unsigned repairs = 0 ; // Count repair
unsigned long mileage; // Miles driven
short int speedometer; // -20.. 0.. 100 MPH
float temperature; // Engine temp in C
double time_of_last_request; //Time of bus
std:: string license_plate; // Text for license
const bool WARNING_LIGHT = true; // Status
enum compass {SW,W,NW,N,NE,E, SE, S} ;
</source>

===Слайд:Типы данных (Arithmetic)===
<source lang="cpp"> // Пример целочисленных типов данных C++
sc_int<LENGTH> NAME...;
sc_uint<LENGTH> NAME...;
sc_bigint<BITWIDTH> NAME...;
sc_biguint<BITWIDTH> NAME...;
// SystemC integer data types
sc_int<5> seat_position=3; //5 bits: 4 plus sign
sc_uint<13> days_SLOC(4000); //13 bits: no sign
sc_biguint<80> revs_SLOC; // 80 bits: no sign
</source>

===Слайд:Типы данных (Boolean)===
<source lang="cpp"> // Пример типа данных SystemC
sc_bit NAME...;
sc_bv<BITWIDTH> NAME...;
</source>

* sc_bit и sc_bv могут принимать значения: '''SC_LOGIC_1''' и '''SC_LOGIC_0.'''
* Для сокращения типов, можно использовать '''Log_1 и Log_0''' или '''‘1’ и ‘0’.'''
* Над этим типом данных возможно выполнение битовых операций '''and, or, xor (&,|, ^).'''
* Для обращения к отдельным битам и массивам '''[], range()'''.

<source lang="cpp">
sc_bit flag(SC_LOGIC_1); // more efficient to use bool
sc_bv<5> positions = "01101";
sc_bv<6> mask = "100111";
sc_bv<5> active = positions & mask;// 00101
sc_bv<1> all = active. and_reduce (); // SC_LOGIC_0
positions. range (3,2) = "00"; // 00001
positions [2] = active[0] ^ flag;
</source>

===Слайд:Типы данных ( многозначные (ZX10))===
<source lang="cpp"> // Пример типа данных SystemC
sc_logic NAME[,NAME]...;
sc_lv<BITNIDTH> NAME[,NAME ]...;
sc_logic buf(sc_dt::Log_Z);
sc_lv<8> data_drive ("zz01XZ1Z");
data_drive.range (5,4) = "ZZ";// ZZZZXZ1Z
buf = '1';

</source>

===Слайд:Операторы SystemC ===
[[Файл:Операции.png]]

===Слайд:Главный модуль MAIN===
{{Гол|'''<big>Описание на языке C++</big>'''}}
<source lang="cpp">
int main(int argc, char* argv[]) {
BODY_OF_PROGRAM
return EXIT_CODE; //
}
</source>

{{Гол|'''<big>Описание на языке SystemC</big>'''}}
<source lang="cpp">
int sc_main(int argc, char* argv[]) {
//ELABORATION
sc_start(); // <-- Simulation begins & ends
// in this function!
//[POST-PROCESSING]
return EXIT_CODE; //
}
</source>

===Слайд: Модуль ===
<source lang="cpp">
#include <systemc.h>
SC_MODULE(module_name) {
MODULE_BODY
};</source>
Содержит:
* '''{{Фио|<big>Порты</big>}}'''
* '''{{Фио|<big>Каналы связи</big>}}'''
* '''{{Фио|<big>Объявления переменных для хранения данных</big>}}'''
* '''{{Фио|<big>Другие модули с большей вложенностью</big>}}'''
* '''{{Фио|<big>Конструктор</big>}}'''
* '''{{Фио|<big>Деструктор</big>}}'''
* '''{{Фио|<big>Функции -процессы</big>}}'''
* '''{{Фио|<big>Вспомогательные функции</big>}}'''

===Слайд: Конструктор (SC_CTOR)===
<source lang="cpp">SC_CTOR(module_name)
: Initialization // OPTIONAL
{
Subdesign_Allocation
Subdesign_Connectivity
Process_Registration
Miscellaneous_Setup
}</source>

* '''{{Фио|<big>Объявление под модулей</big>}}'''
* '''{{Фио|<big>Подключение и соединение с подмодулями</big>}}'''
* '''{{Фио|<big>Регистрация процессов на SystemC</big>}}'''
* '''{{Фио|<big>Обеспечение постоянной чувствительности</big>}}'''
* '''{{Фио|<big>Разнообразные пользовательские объявления</big>}}''

===Слайд: Конструктор (SC_HAS_PROCESS)===
<source lang="cpp">
//FILE: module_name.h
SC_MODULE(module_name) {
SC_HAS_PROCESS(module_name);
module_name(sc_module_name instname[, other_args…])
: sc_module(instname)
[, other_initializers]
{
CONSTRUCTOR_BODY
}
};</source>

* '''{{Фио|<big>Все возможности конструктора SC_CTOR</big>}}'''
* '''{{Фио|<big>Альтернативный метод создания модуля</big>}}'''
* '''{{Фио|<big>Позволяет создавать конструктор с аргументами(+ к имени модуля)</big>}}'''
* '''{{Фио|<big>Используется, если желаете расположить конструктор в файле описания .cpp (не в файле .h)</big>}}'''

===Слайд: Процесс SC_THREAD ===

<source lang="cpp">
SC_MODULE(simple_process_ex) {
SC_CTOR(simple_process_ex) {
SC_THREAD(my_thread_process);
}
void my_thread_process(void);
};</source>

{{Зел|'''SC_THREAD'''}} в '''SystemC''':
# аналог {{Зел|'''initial block'''}} в '''Verilog'''
# {{Зел|'''process'''}} без списка чувствительности с оператором '''wait()''' в '''VHDL'''.

===Слайд:Введение времени===

{{Ор|<big>'''Единицы измерения времени'''</big>}}

<source lang="cpp">
SC_SEC // seconds
SC_MS // milliseconds
SC_US // microseconds
SC_NS // nanoseconds
SC_PS // picoseconds
SC_FS // femtoseconds
</source>
{{Ор|<big>'''Объявление переменной типа '''</big>}}{{Зел|<big>'''sc_time'''</big>}}
<source lang="cpp">
sc_time t_PERIOD(5, SC_NS) ;
sc_time t_TIMEOUT (100, SC_MS) ;
sc_time t_MEASURE, t_CURRENT, t_LAST_CLOCK;
t_MEASURE = (t_CURRENT-t_LAST_CLOCK) ;
if (t_MEASURE > t_HOLD) { error ("Setup violated") }
</source>

===Слайд:Запуск выполнения '''sc_start()'''===

{{Ор|<big>'''Функция запускающая выполнения главного процесса '''</big>}}

{{Сн|'''Пример запуска моделирования на 60 секунд модельного времени'''}}

<source lang="cpp">
int sc_main(int argc, char* argv[]) { // args unused
simple_process_ex my_instance ("my_instance");
sc_start(60.0,SC_SEC); // Limit sim to one minute
return 0 ;
}</source>

===Слайд:Контроль текущего времени моделирования '''sc_time_stamp ()'''===

<source lang="cpp">
std::cout << " The time is now "
<< sc_time_stamp()
<< "!" << std::endl;</source>

После запуска моделирования в консоли получим
The time is now 0 ns!

===Слайд: Остановка выполнения моделирования wait(sc_time)===

{{Ор|<big>'''Функция останавливающая выполнение процесса до заданного времени или до прихода события'''</big>}}

<source lang="cpp">
void simple_process_ex::my_thread_process (void) {
wait (10,SC_NS);
std::cout<< "Now at "<< sc_time_stamp() << std::endl;
sc_time t_DELAY(2,SC_MS); // keyboard debounce time
t_DELAY *= 2;
std::cout<< "Delaying "<< t_DELAY<< std::endl;
wait(t_DELAY);
std::cout << "Now at " << sc_time_stamp()
<< std::endl;
}</source>

% . /run_example
Now at 10 ns
Delaying 4 ms
Now at 4000010 ns

===Слайд:События '''sc_event'''===
<slides split="-----" width="400" >
[[Файл:Процес_моделирования_по_событиям.png]]
</slides>

===Слайд:События '''SC_THREAD::wait()'''===
Процесс '''SC_THREAD''' процес выполняющийся {{Кр|'''<big>один раз!!</big>'''}}, для управления работой такого процесса используют функцию задержки выполнения wait

<source lang="cpp">wait(time);
wait(event);
wait(event1 | event2) // до прихода любого из событий
wait(event1 & event2) // до прихода всех событий вместе
wait(timeout, event); // до прихода события ожидает в течении времени
wait ( timeout, event1 | event2 )
wait ( timeout, event1 & event2 )
wait(); // ожидание дельта цикла выполнения, статическая задержка
</source>
===Слайд:Запуск события (установка,назначение)===

Для запуска события используется атрибут {{Зел|<big>'''.notify()'''</big>}}

Он выполняет запуск событий, отсчет времени идет от запуска моделирования. Для сброса точки отсчета используют {{Зел|<big>'''.cancel()'''</big>}}

<source lang="cpp">sc_event action;
sc_time now(sc_time_stamp()); //вытягиваем текущее время моделирования
//стартуем событие немедленно
action.notify();
//следующее событие через 20 ms от текущего момента
action.notify(20, SC_MS);
//переопределим событие на время 1.5 ns от текущего момента
action.notify(1.5,SC_NS);
//продублируем событие (не имеет эффекта)
action.notify(1.5, SC_NS);
//зададим событие от предыдущего на 1.5 ns
action.notify(3.0,SC_NS);
//запустим дельта цикл (не имеет эффекта)
action.notify(SC_ZERO_TIME);
//сбросим время задания события
action.cancel();
//зададим событие на 20 fs после сброса
action.notify(20,SC_FS);</source>

===Слайд:Процесс со списком чувствительности SC_METHOD ===
{{ЖЛампа|24px}}Аналог '''process''' в '''VHDL'''

<source lang="cpp">SC_METHOD(process_name);</source>

{{ЖЛампа|24px}}Список чуствительности задаеться после ключевого слова {{Зел|'''sensitive'''}}

<source lang="cpp"> sensitive << event [<< event] ;// поточный стил
sensitive (event [, event] ); // стиль с использованием функции</source>

===Слайд:dont_initialize() ===
{{ЖЛампа|24px}} Отменяет начальную установку значений
* После запуска моделирования конструктор создает модуль и инициализирует все процессы и переменные.

* Это заставляет выполниться всем методам работающим по событию по одному разу во время запуска если событие устанавливалось в значение.

* Для исключения начального выполнения используется функция '''dont_initialize()'''

===Слайд: Стек событий '''sc_event_queue'''===

{{ЖЛампа|24px}} Событие можно задать не только от начального момента времени, а и от текущего.

Для этого используется функция '''sc_event_queue()'''

<source lang="cpp">
sc_event_queue action;
sc_time now(sc_time_stamp());
action.notify(20, SC_MS);
action.notify(1.5,SC_NS);
action.notify(1.5,SC_NS);
action.notify(3.0,SC_NS);
action.notify(SC_ZERO_TIME);
action.notify(1,SC_SEC);
action.cancel_all();
</source>

===Слайд:Совместное использование ресурсов===

* При совместном использовании ресурсов, шин, памяти нужно разграничить область полномочий каждого процесса.
* Иначе при одновременной, к примеру записи будет происходить сбой или некорректная запись.
Если управлением доступом к одному ресурсу
<source lang="cpp">sc_mutex NAME;
// блокируем mutex NAME (ждем пока разблокируется)
NAME.lock();
// Возвращает статус состояния блокировки
NAME.try lock()
// Снимает блокировку
NAME.unlock();</source>

Если управлением доступом к нескольким ресурсам

<source lang="cpp">sc_semaphore NAME(COUNT);
// блокируем mutex NAME (ждем пока разблокируеться)
NAME.wait();
// Возвращает статус состояния блокировки
NAME.trywait()
//Возвращает число свободных ресурсов
NAME.get_value()
// Снимает блокировку
NAME.post();</source>

===Слайд:Иерархия и структура проекта===
[[Файл:Иерархия.png]]

===Слайд:Иерархия и структура проекта (sc_main)===

{{ЖЛампа|24px}}Подключение и создание {{Зел|<big>'''модуля'''</big>}} внутри '''главного''' модуля аналогично созданию {{Зел|<big>'''объекта'''</big>}} заданного{{Зел| <big>'''класса'''</big>}}
{{Фио|<big>'''Стандартная конструкция блока хранения информации для RFID'''</big>}}
{| cellspacing="0" cellpadding="0" border="1"
|
* {{Гол|'''Статический метод'''}}
<source lang="cpp">//FILE: main.cpp
#include "Wheel.h"
int sc_main(int argc, char* argv[]) {
Wheel wheel_FL("wheel_FL");
Wheel wheel_FR("wheel_FR");
sc_start();
}</source>
|
* {{Гол|'''Динамический метод'''}}
<source lang="cpp">//FILE: main.cpp
#include "Wheel.h"
int sc_main(int argc, char* argv[]) {
Wheel* wheel_FL; // pointer to FL wheel
Wheel* wheel_FR; // pointer to FR wheel
wheel_FL = new Wheel ("wheel_FL"); // create FL
wheel_FR = new Wheel ("wheel_FR"); // create FR
sc_start();
delete wheel_FL;
delete wheel_FR;
}</source>
|}

===Слайд:Иерархия и структура проекта (SC_MODULE)===

{{ЖЛампа|24px}}Подключение и создание {{Зел|<big>'''модуля'''</big>}} внутри другого модуля аналогично созданию {{Зел|<big>'''объекта'''</big>}} заданного{{Зел| <big>'''класса'''</big>}}, внутри другого класса. Поэтому объявления производиться в конструкторе верхнего модуля
{| cellspacing="0" cellpadding="0" border="1"
|

* {{Гол|'''Статический метод'''}}
<source lang="cpp">//FILE:Body.h
#include "Wheel.h"
SC_MODULE(Body) {
Wheel wheel_FL;
Wheel wheel_FR;
SC_CTOR(Body)
: wheel_FL("wheel_FL"), //initialization
wheel_FR("wheel_FR") //initialization
{
// other initialization
}
};
}</source>
|
* {{Гол|'''Динамический метод'''}}
<source lang="cpp">//FILE:Body.h
#include "Wheel.h"
SC_MODULE(Body) {
Wheel* wheel_FL;
Wheel* wheel_FR;
SC_CTOR(Body) {
wheel_FL = new Wheel("wheel_FL");
wheel_FR = new Wheel("wheel_FR");
// other initialization
}
};
}</source>
|}

===Слайд:Порты - точки подачи и снятия внешних воздействий===
[[Файл:Порты_соединение_модулей.png]]

===Слайд:Типы портов ===

* {{Сн|'''sc_port'''}} - аналог inout порта в языке VHDL
* {{Сн|'''sc_in'''}} - аналог in порта в языке VHDL
* {{Сн|'''sc_out'''}} - аналог out порта в языке VHDL
* {{Сн|'''sc_export'''}} - внешний порт, порт который позволяет получить доступ к private данным модуля, но иерархически модулю не принадлежит.
{{ЖЛампа|24px}} Механизм использования '''sc_export''' порта напоминает '''доступ к сигналам по иерархии''', как в '''VHDL-2008'''.

===Слайд:Порты - точки подачи и снятия внешних воздействий===
[[Файл:Порты_соединение_модулей_экспорт.png]]
[[Файл:Порты_соединение_модулей_экспорт2.png]]

===Слайд:Управление процессом и контроль статуса моделирования===

== Слайд: VHDL и SystemC конструкции ==
===Слайд: Entity ===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример поведенческой модели накопителя (VHDL)'''}}
<source lang="vhdl">
entity soft is
generic (UART_Speed : integer := 115200; -- UART Speed
System_CLK : integer := 50000000; -- System CLK in Hz
comand_file : string :="/home/Vidokq/djin18reader/vhd/D18/comfile.txt"
);
port (
CLK : out std_logic; -- system clk
RST_N : out std_logic; -- system reset#
DATA_IN : out std_logic_vector(7 downto 0); -- Transmit data
DATA_OUT : in std_logic_vector(7 downto 0); -- Recieved data
RX_VALID : in std_logic; -- RX buffer data ready
TX_VALID : out std_logic; -- Data for TX avaible
TX_BUSY : in std_logic; --
RX_BUSY : in std_logic);

end soft;
</source>

|
{{Фио|'''<big></big>Пример поведенческой модели накопителя (Verilog)'''}}

<source lang="cpp">

SC_MODULE (soft_sc_module)
{
public :
sc_in < sc_logic > tx_busy;
sc_in < sc_logic > rx_busy;
sc_in < sc_lv < 8 > > data_out;
sc_in < sc_logic > rx_valid;
sc_out < sc_logic > tx_valid;
sc_out < bool > clk;
sc_out < sc_logic > rst_n;
sc_out < sc_lv < 8 > > data_in;

public:

ifstream fin;

SC_CTOR(soft_sc_module)
: rst_n("rst_n"),
data_in("data_in"),
data_out ("data_out"),
rx_valid("rx_valid"),
tx_valid("tx_valid"),
tx_busy("tx_busy"),
rx_busy("rx_busy"),
rst_n_i("rst_n_i"),
clk_i("clk_i"),
clk("clk")
{
}
~soft_sc_module()
{
delete [] str_b;
}
};

#endif
</source>
|}
</slides>

===Слайд: Architecture ===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример Архитектуры на VHDL'''}}
<source lang="vhdl">

architecture beh of soft is
file comfile : text open read_mode is comand_file;

begin -- beh
-- тело архитектуры
signal str : string(1 to 1000) := (others => ' ');
signal RST_N_i : std_logic;
signal DATA_IN_i : std_logic_vector(7 downto 0);
signal f_get_answer : boolean := false;
signal tmd : time := 0 ms;

end beh;
</source>

|
{{Фио|'''<big></big>Пример аналогичной конструкции на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public :
std::string comand_file;
public :
sc_signal< sc_logic > rst_n_i;
sc_signal< sc_lv < 8 > > data_in_i;
sc_signal < bool > f_get_answer;
sc_signal < sc_time > tmd;
sc_time btmd (0, SC_MS);
SC_CTOR(soft_sc_module)
:
rst_n_i("rst_n_i"),
data_in_i("data_in_i"),
f_get_answer("f_get_answer"),
tmd("tmd")
{
str = new char [1000];
//объявление функций
//выбор списка чувствительности
//установка значений по умолчанию
tmd.write(btmd);
// tmd = btmd;
//оператор присваивания перегружен и выолнит вызов функции write
}
~soft_sc_module()
{
delete [] str;
}
</source>
|}
</slides>

===Слайд: Generic ===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
entity soft is
generic (UART_Speed : integer := 115200;
System_CLK : integer := 50000000
);
--
--
--
architecture beh of soft is
CLK_i <= not CLK_i after 1 ns * (1000000000 / System_CLK );
end beh;
</source>

|
{{Фио|'''<big></big>Пример на SystemC (sc_get_param)'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module)
: rst_n("rst_n"),
tmd("tmd")
{
if (!sc_get_param("System_CLK",System_CLK)) cout << "error get generic";
if (!sc_get_param("UART_Speed",UART_Speed)) cout << "error get generic";
period_ns=(1000000000)/System_CLK;
str = new char [1000];
}
~soft_sc_module()
{
delete [] str_b;
}
};
</source>
|}
</slides>

===Слайд: Process без списка чувствительности ===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
wait_byte_timer: process
begin -- process wiat_timer
wait for 0.5 ms;
if (NOW - tmd) > 1 ms then
if f_start_get_answer then
f_byte_timer <= true;
wait for 0.1 ms;
f_byte_timer <= false;
end if;
end if;
end process wait_byte_timer;
</source>

|
{{Фио|'''<big></big>Пример на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module):
{ SC_METHOD (wait_byte_timer); }
~soft_sc_module()
{ }
};
void soft_sc_module :: wait_byte_timer ()
{
next_trigger (0.5,SC_MS);
if ((sc_time_stamp()-tmd) > sc_time(1, SC_MS) )
if (f_start_get_answer)
{f_byte_timer=true;
next_trigger (0.1,SC_MS);
f_byte_timer=false;
}
cout<< "wait_byte_timer work\n";
}
</source>
|}
</slides>

===Слайд: Process со списком чувствительности (пример 1)===

<slides split="-----" width="400" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
CLK_i <= not CLK_i after 1 ns * (1000000000 / System_CLK );
--или
process (clk)
begin
if clk'event then
clk_i <= not clk_i after 1 ns * (1000000000 / System_CLK );
end if;
end process;
</source>
|
{{Фио|'''<big></big>Пример на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module):
{ clk_i=true;
period_ns=(1000000000)/System_CLK;
SC_METHOD (clk_gen);
}
~soft_sc_module()
{ }
};

void soft_sc_module :: clk_gen ()
{
clk_i.write(!clk_i.read());
next_trigger (period_ns, SC_NS);

}
</source>
|}
</slides>

===Слайд: Process со списком чувствительности (пример 2) ===

<slides split="-----" width="400" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
RST_N <= RST_N_i;
--или
process (RST_N_i)
begin
if RST_N_i'event then
RST_N <= RST_N_i;
end if;
end process;
</source>
|
{{Фио|'''<big></big>Пример на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module):
{ clk_i=true;
SC_METHOD (rst_n_i2rst_n);
sensitive << rst_n_i;
dont_initialize();
}
~soft_sc_module()
{ }
};

void soft_sc_module :: reset_gen ()
{
rst_n_i.write( SC_LOGIC_0 );
wait (100, SC_NS);
cout << "run reset";
rst_n_i.write( SC_LOGIC_1 );
}
</source>
|}
</slides>

===Слайд: Работа с файлами ===
<slides split="-----" width="800" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
p_send : process
variable l : line;
variable byte_r : std_logic_vector(0 to 7);
variable good : boolean;
variable f_first_byte : boolean:=false;
begin -- process p1

loop1: while not endfile(comfile) loop

readline (comfile,l);
skip_space (l);
next loop1 when l'length = 0;

for i in 1 to l'length loop
str(i) <= l(i);
end loop; -- i
str((l'length)+1 to 1000) <= (others => ' ');
str_l <= l'length;
</source>
|
<source lang="vhdl">
if l(1) = '#' then
assert false report "коментарий:"&str(1 to str_l) severity NOTE;
else
assert false report "коментарий"&str(1 to str_l) severity NOTE;
f_first_byte := true;
while l'length /= 0 loop
hread (l,byte_r,good);
assert good report "ошибка" severity FAILURE;
if f_first_byte then
f_first_byte := false;
comand <= byte_r;
end if;
TX_VALID_i <= '1';
DATA_IN_i <= byte_r;
skip_space (l);
wait until TX_BUSY = '1';
end loop;
f_start_timer <= true;
TX_VALID_i <= '0';
wait until f_get_answer or f_timer;
assert not f_timer report "1мкс" severity FAILURE;
f_start_timer <= false;
end if;
end loop;
assert false report "======" severity failure;
end process p_send;
</source>
|}
</slides>

===Слайд: Работа с файлами ===
<slides split="-----" width="800" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на SystemC'''}}
<source lang="cpp">
void soft_sc_module :: p_send ()
{
fin.open(comand_file.c_str(),ios::out);
cout << "work4\n";
bool f_first_byte=false;
if (!fin){
std::cout << "File invalide open";
exit (0);
}
while (!fin.eof()){
fin.getline (str,1000);
skip_space (&(str));
if (strlen(str)){
if (str[0] == '#')
cout << "koment: "<< str <<endl;
else {
cout << "data: "<< str <<endl;
f_first_byte=true;
//while ( str[0] != '\0' ){
while ( strlen(str) ){
if ( str[0] == ' ' )
skip_space(&(str));
else {
//cout << "1/2\n";
byte_b.range(7,4)=str[0];
str++;
skip_space(&(str));
if (!strlen(str)){
cout<<endl<<"error";
sc_stop();
}
else {
//cout << "2/2\n";
byte_b.range(3,0)=str[0];
str++;
}
</source>
|
<source lang="cpp">

if (f_first_byte){
f_first_byte=false;
comand=byte_b;
}
//cout << byte_b << endl;
tx_valid_i.write(SC_LOGIC_1);
data_in.write(byte_b);
wait (tx_busy.posedge_event());
}
}
f_start_timer = true;
tx_valid_i.write(SC_LOGIC_0);
wait ( f_get_answer.posedge_event() | f_timer.posedge_event() );
if ( f_timer ) {cout << "error";sc_stop();}
f_start_timer = false;
}
}
str=str_b;
}
cout << "error";
fin.close();
sc_stop();
}
</source>
|}
</slides>

===Слайд: Работа с переменными ===
===Слайд: Работа с сигналами ===
===Слайд: Арифметические, логические, операции присваивания ===
===Слайд: Конструкции С++ ===
===Слайд: Создание модуля ===
===Слайд: Коммуникации между модулями ===
===Слайд: Управление процессом моделирования (сообщения, запуск останов моделирования)===
== Слайд: Компиляция описания ==
== Слайд: Запуск моделирования только SystemC описания ==
== Слайд: Запуск моделирования SystemC описания и VHDL ==

Спец курс (Избранные главы VHDL)/Верификация описания

2012-11-19T14:15:06Z

164.177.206.33: /* Слайд: Generic */

<slideshow style="custis" headingmark="Слайд:" incmark=":step" scaled="true" >
;title: '''Верификация описания.'''
;author: Зайцев В.С.
</slideshow>

[[Файл:SystemC_From_the_ground_up.mm]]

==Слайд:Верификация описания==
[[Файл:Процевв_верификации.png]]

==Слайд:Верификация описания:step==
*{{Гол|''' <big>Среда моделирования</big>'''}}
** Active-HDL™
** Riviera-PRO™
** NC-Sim®
** ModelSim®
** QuestaSim®
** VCS-MX®
* {{Гол|'''<big>Структура проекта</big>'''}}
** Тестовое окружение
** RTL-модель (Verilog,VHDL)
** Эталонная модель (SystemC)
** Assert'ы (psl, OVVM, UVM)
** Отчеты и базы по результатам моделирования

==Слайд:Эталонная модель на языке ''{{Зел| <big>SystemC</big>}}''==

# Высокий уровень абстракции
# Скорость моделирования
# Возможности языка C++
# Инструменты для автоматизации
# Совместное моделирование с другими HDL-языками

== Основы языка SystemC ==

===Слайд:Типы данных (Форматы и способ представления данных) ===
[[Файл:Типы_данных.png]]

===Слайд:Типы данных (native)===
<source lang="cpp"> // Пример типа данных C++
int spark_offset;
unsigned repairs = 0 ; // Count repair
unsigned long mileage; // Miles driven
short int speedometer; // -20.. 0.. 100 MPH
float temperature; // Engine temp in C
double time_of_last_request; //Time of bus
std:: string license_plate; // Text for license
const bool WARNING_LIGHT = true; // Status
enum compass {SW,W,NW,N,NE,E, SE, S} ;
</source>

===Слайд:Типы данных (Arithmetic)===
<source lang="cpp"> // Пример целочисленных типов данных C++
sc_int<LENGTH> NAME...;
sc_uint<LENGTH> NAME...;
sc_bigint<BITWIDTH> NAME...;
sc_biguint<BITWIDTH> NAME...;
// SystemC integer data types
sc_int<5> seat_position=3; //5 bits: 4 plus sign
sc_uint<13> days_SLOC(4000); //13 bits: no sign
sc_biguint<80> revs_SLOC; // 80 bits: no sign
</source>

===Слайд:Типы данных (Boolean)===
<source lang="cpp"> // Пример типа данных SystemC
sc_bit NAME...;
sc_bv<BITWIDTH> NAME...;
</source>

* sc_bit и sc_bv могут принимать значения: '''SC_LOGIC_1''' и '''SC_LOGIC_0.'''
* Для сокращения типов, можно использовать '''Log_1 и Log_0''' или '''‘1’ и ‘0’.'''
* Над этим типом данных возможно выполнение битовых операций '''and, or, xor (&,|, ^).'''
* Для обращения к отдельным битам и массивам '''[], range()'''.

<source lang="cpp">
sc_bit flag(SC_LOGIC_1); // more efficient to use bool
sc_bv<5> positions = "01101";
sc_bv<6> mask = "100111";
sc_bv<5> active = positions & mask;// 00101
sc_bv<1> all = active. and_reduce (); // SC_LOGIC_0
positions. range (3,2) = "00"; // 00001
positions [2] = active[0] ^ flag;
</source>

===Слайд:Типы данных ( многозначные (ZX10))===
<source lang="cpp"> // Пример типа данных SystemC
sc_logic NAME[,NAME]...;
sc_lv<BITNIDTH> NAME[,NAME ]...;
sc_logic buf(sc_dt::Log_Z);
sc_lv<8> data_drive ("zz01XZ1Z");
data_drive.range (5,4) = "ZZ";// ZZZZXZ1Z
buf = '1';

</source>

===Слайд:Операторы SystemC ===
[[Файл:Операции.png]]

===Слайд:Главный модуль MAIN===
{{Гол|'''<big>Описание на языке C++</big>'''}}
<source lang="cpp">
int main(int argc, char* argv[]) {
BODY_OF_PROGRAM
return EXIT_CODE; //
}
</source>

{{Гол|'''<big>Описание на языке SystemC</big>'''}}
<source lang="cpp">
int sc_main(int argc, char* argv[]) {
//ELABORATION
sc_start(); // <-- Simulation begins & ends
// in this function!
//[POST-PROCESSING]
return EXIT_CODE; //
}
</source>

===Слайд: Модуль ===
<source lang="cpp">
#include <systemc.h>
SC_MODULE(module_name) {
MODULE_BODY
};</source>
Содержит:
* '''{{Фио|<big>Порты</big>}}'''
* '''{{Фио|<big>Каналы связи</big>}}'''
* '''{{Фио|<big>Объявления переменных для хранения данных</big>}}'''
* '''{{Фио|<big>Другие модули с большей вложенностью</big>}}'''
* '''{{Фио|<big>Конструктор</big>}}'''
* '''{{Фио|<big>Деструктор</big>}}'''
* '''{{Фио|<big>Функции -процессы</big>}}'''
* '''{{Фио|<big>Вспомогательные функции</big>}}'''

===Слайд: Конструктор (SC_CTOR)===
<source lang="cpp">SC_CTOR(module_name)
: Initialization // OPTIONAL
{
Subdesign_Allocation
Subdesign_Connectivity
Process_Registration
Miscellaneous_Setup
}</source>

* '''{{Фио|<big>Объявление под модулей</big>}}'''
* '''{{Фио|<big>Подключение и соединение с подмодулями</big>}}'''
* '''{{Фио|<big>Регистрация процессов на SystemC</big>}}'''
* '''{{Фио|<big>Обеспечение постоянной чувствительности</big>}}'''
* '''{{Фио|<big>Разнообразные пользовательские объявления</big>}}''

===Слайд: Конструктор (SC_HAS_PROCESS)===
<source lang="cpp">
//FILE: module_name.h
SC_MODULE(module_name) {
SC_HAS_PROCESS(module_name);
module_name(sc_module_name instname[, other_args…])
: sc_module(instname)
[, other_initializers]
{
CONSTRUCTOR_BODY
}
};</source>

* '''{{Фио|<big>Все возможности конструктора SC_CTOR</big>}}'''
* '''{{Фио|<big>Альтернативный метод создания модуля</big>}}'''
* '''{{Фио|<big>Позволяет создавать конструктор с аргументами(+ к имени модуля)</big>}}'''
* '''{{Фио|<big>Используется, если желаете расположить конструктор в файле описания .cpp (не в файле .h)</big>}}'''

===Слайд: Процесс SC_THREAD ===

<source lang="cpp">
SC_MODULE(simple_process_ex) {
SC_CTOR(simple_process_ex) {
SC_THREAD(my_thread_process);
}
void my_thread_process(void);
};</source>

{{Зел|'''SC_THREAD'''}} в '''SystemC''':
# аналог {{Зел|'''initial block'''}} в '''Verilog'''
# {{Зел|'''process'''}} без списка чувствительности с оператором '''wait()''' в '''VHDL'''.

===Слайд:Введение времени===

{{Ор|<big>'''Единицы измерения времени'''</big>}}

<source lang="cpp">
SC_SEC // seconds
SC_MS // milliseconds
SC_US // microseconds
SC_NS // nanoseconds
SC_PS // picoseconds
SC_FS // femtoseconds
</source>
{{Ор|<big>'''Объявление переменной типа '''</big>}}{{Зел|<big>'''sc_time'''</big>}}
<source lang="cpp">
sc_time t_PERIOD(5, SC_NS) ;
sc_time t_TIMEOUT (100, SC_MS) ;
sc_time t_MEASURE, t_CURRENT, t_LAST_CLOCK;
t_MEASURE = (t_CURRENT-t_LAST_CLOCK) ;
if (t_MEASURE > t_HOLD) { error ("Setup violated") }
</source>

===Слайд:Запуск выполнения '''sc_start()'''===

{{Ор|<big>'''Функция запускающая выполнения главного процесса '''</big>}}

{{Сн|'''Пример запуска моделирования на 60 секунд модельного времени'''}}

<source lang="cpp">
int sc_main(int argc, char* argv[]) { // args unused
simple_process_ex my_instance ("my_instance");
sc_start(60.0,SC_SEC); // Limit sim to one minute
return 0 ;
}</source>

===Слайд:Контроль текущего времени моделирования '''sc_time_stamp ()'''===

<source lang="cpp">
std::cout << " The time is now "
<< sc_time_stamp()
<< "!" << std::endl;</source>

После запуска моделирования в консоли получим
The time is now 0 ns!

===Слайд: Остановка выполнения моделирования wait(sc_time)===

{{Ор|<big>'''Функция останавливающая выполнение процесса до заданного времени или до прихода события'''</big>}}

<source lang="cpp">
void simple_process_ex::my_thread_process (void) {
wait (10,SC_NS);
std::cout<< "Now at "<< sc_time_stamp() << std::endl;
sc_time t_DELAY(2,SC_MS); // keyboard debounce time
t_DELAY *= 2;
std::cout<< "Delaying "<< t_DELAY<< std::endl;
wait(t_DELAY);
std::cout << "Now at " << sc_time_stamp()
<< std::endl;
}</source>

% . /run_example
Now at 10 ns
Delaying 4 ms
Now at 4000010 ns

===Слайд:События '''sc_event'''===
<slides split="-----" width="400" >
[[Файл:Процес_моделирования_по_событиям.png]]
</slides>

===Слайд:События '''SC_THREAD::wait()'''===
Процесс '''SC_THREAD''' процес выполняющийся {{Кр|'''<big>один раз!!</big>'''}}, для управления работой такого процесса используют функцию задержки выполнения wait

<source lang="cpp">wait(time);
wait(event);
wait(event1 | event2) // до прихода любого из событий
wait(event1 & event2) // до прихода всех событий вместе
wait(timeout, event); // до прихода события ожидает в течении времени
wait ( timeout, event1 | event2 )
wait ( timeout, event1 & event2 )
wait(); // ожидание дельта цикла выполнения, статическая задержка
</source>
===Слайд:Запуск события (установка,назначение)===

Для запуска события используется атрибут {{Зел|<big>'''.notify()'''</big>}}

Он выполняет запуск событий, отсчет времени идет от запуска моделирования. Для сброса точки отсчета используют {{Зел|<big>'''.cancel()'''</big>}}

<source lang="cpp">sc_event action;
sc_time now(sc_time_stamp()); //вытягиваем текущее время моделирования
//стартуем событие немедленно
action.notify();
//следующее событие через 20 ms от текущего момента
action.notify(20, SC_MS);
//переопределим событие на время 1.5 ns от текущего момента
action.notify(1.5,SC_NS);
//продублируем событие (не имеет эффекта)
action.notify(1.5, SC_NS);
//зададим событие от предыдущего на 1.5 ns
action.notify(3.0,SC_NS);
//запустим дельта цикл (не имеет эффекта)
action.notify(SC_ZERO_TIME);
//сбросим время задания события
action.cancel();
//зададим событие на 20 fs после сброса
action.notify(20,SC_FS);</source>

===Слайд:Процесс со списком чувствительности SC_METHOD ===
{{ЖЛампа|24px}}Аналог '''process''' в '''VHDL'''

<source lang="cpp">SC_METHOD(process_name);</source>

{{ЖЛампа|24px}}Список чуствительности задаеться после ключевого слова {{Зел|'''sensitive'''}}

<source lang="cpp"> sensitive << event [<< event] ;// поточный стил
sensitive (event [, event] ); // стиль с использованием функции</source>

===Слайд:dont_initialize() ===
{{ЖЛампа|24px}} Отменяет начальную установку значений
* После запуска моделирования конструктор создает модуль и инициализирует все процессы и переменные.

* Это заставляет выполниться всем методам работающим по событию по одному разу во время запуска если событие устанавливалось в значение.

* Для исключения начального выполнения используется функция '''dont_initialize()'''

===Слайд: Стек событий '''sc_event_queue'''===

{{ЖЛампа|24px}} Событие можно задать не только от начального момента времени, а и от текущего.

Для этого используется функция '''sc_event_queue()'''

<source lang="cpp">
sc_event_queue action;
sc_time now(sc_time_stamp());
action.notify(20, SC_MS);
action.notify(1.5,SC_NS);
action.notify(1.5,SC_NS);
action.notify(3.0,SC_NS);
action.notify(SC_ZERO_TIME);
action.notify(1,SC_SEC);
action.cancel_all();
</source>

===Слайд:Совместное использование ресурсов===

* При совместном использовании ресурсов, шин, памяти нужно разграничить область полномочий каждого процесса.
* Иначе при одновременной, к примеру записи будет происходить сбой или некорректная запись.
Если управлением доступом к одному ресурсу
<source lang="cpp">sc_mutex NAME;
// блокируем mutex NAME (ждем пока разблокируется)
NAME.lock();
// Возвращает статус состояния блокировки
NAME.try lock()
// Снимает блокировку
NAME.unlock();</source>

Если управлением доступом к нескольким ресурсам

<source lang="cpp">sc_semaphore NAME(COUNT);
// блокируем mutex NAME (ждем пока разблокируеться)
NAME.wait();
// Возвращает статус состояния блокировки
NAME.trywait()
//Возвращает число свободных ресурсов
NAME.get_value()
// Снимает блокировку
NAME.post();</source>

===Слайд:Иерархия и структура проекта===
[[Файл:Иерархия.png]]

===Слайд:Иерархия и структура проекта (sc_main)===

{{ЖЛампа|24px}}Подключение и создание {{Зел|<big>'''модуля'''</big>}} внутри '''главного''' модуля аналогично созданию {{Зел|<big>'''объекта'''</big>}} заданного{{Зел| <big>'''класса'''</big>}}
{{Фио|<big>'''Стандартная конструкция блока хранения информации для RFID'''</big>}}
{| cellspacing="0" cellpadding="0" border="1"
|
* {{Гол|'''Статический метод'''}}
<source lang="cpp">//FILE: main.cpp
#include "Wheel.h"
int sc_main(int argc, char* argv[]) {
Wheel wheel_FL("wheel_FL");
Wheel wheel_FR("wheel_FR");
sc_start();
}</source>
|
* {{Гол|'''Динамический метод'''}}
<source lang="cpp">//FILE: main.cpp
#include "Wheel.h"
int sc_main(int argc, char* argv[]) {
Wheel* wheel_FL; // pointer to FL wheel
Wheel* wheel_FR; // pointer to FR wheel
wheel_FL = new Wheel ("wheel_FL"); // create FL
wheel_FR = new Wheel ("wheel_FR"); // create FR
sc_start();
delete wheel_FL;
delete wheel_FR;
}</source>
|}

===Слайд:Иерархия и структура проекта (SC_MODULE)===

{{ЖЛампа|24px}}Подключение и создание {{Зел|<big>'''модуля'''</big>}} внутри другого модуля аналогично созданию {{Зел|<big>'''объекта'''</big>}} заданного{{Зел| <big>'''класса'''</big>}}, внутри другого класса. Поэтому объявления производиться в конструкторе верхнего модуля
{| cellspacing="0" cellpadding="0" border="1"
|

* {{Гол|'''Статический метод'''}}
<source lang="cpp">//FILE:Body.h
#include "Wheel.h"
SC_MODULE(Body) {
Wheel wheel_FL;
Wheel wheel_FR;
SC_CTOR(Body)
: wheel_FL("wheel_FL"), //initialization
wheel_FR("wheel_FR") //initialization
{
// other initialization
}
};
}</source>
|
* {{Гол|'''Динамический метод'''}}
<source lang="cpp">//FILE:Body.h
#include "Wheel.h"
SC_MODULE(Body) {
Wheel* wheel_FL;
Wheel* wheel_FR;
SC_CTOR(Body) {
wheel_FL = new Wheel("wheel_FL");
wheel_FR = new Wheel("wheel_FR");
// other initialization
}
};
}</source>
|}

===Слайд:Порты - точки подачи и снятия внешних воздействий===
[[Файл:Порты_соединение_модулей.png]]

===Слайд:Типы портов ===

* {{Сн|'''sc_port'''}} - аналог inout порта в языке VHDL
* {{Сн|'''sc_in'''}} - аналог in порта в языке VHDL
* {{Сн|'''sc_out'''}} - аналог out порта в языке VHDL
* {{Сн|'''sc_export'''}} - внешний порт, порт который позволяет получить доступ к private данным модуля, но иерархически модулю не принадлежит.
{{ЖЛампа|24px}} Механизм использования '''sc_export''' порта напоминает '''доступ к сигналам по иерархии''', как в '''VHDL-2008'''.

===Слайд:Порты - точки подачи и снятия внешних воздействий===
[[Файл:Порты_соединение_модулей_экспорт.png]]
[[Файл:Порты_соединение_модулей_экспорт2.png]]

===Слайд:Управление процессом и контроль статуса моделирования===

== Слайд: VHDL и SystemC конструкции ==
===Слайд: Entity ===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример поведенческой модели накопителя (VHDL)'''}}
<source lang="vhdl">
entity soft is
generic (UART_Speed : integer := 115200; -- UART Speed
System_CLK : integer := 50000000; -- System CLK in Hz
comand_file : string :="/home/Vidokq/djin18reader/vhd/D18/comfile.txt"
);
port (
CLK : out std_logic; -- system clk
RST_N : out std_logic; -- system reset#
DATA_IN : out std_logic_vector(7 downto 0); -- Transmit data
DATA_OUT : in std_logic_vector(7 downto 0); -- Recieved data
RX_VALID : in std_logic; -- RX buffer data ready
TX_VALID : out std_logic; -- Data for TX avaible
TX_BUSY : in std_logic; --
RX_BUSY : in std_logic);

end soft;
</source>

|
{{Фио|'''<big></big>Пример поведенческой модели накопителя (Verilog)'''}}

<source lang="cpp">

SC_MODULE (soft_sc_module)
{
public :
sc_in < sc_logic > tx_busy;
sc_in < sc_logic > rx_busy;
sc_in < sc_lv < 8 > > data_out;
sc_in < sc_logic > rx_valid;
sc_out < sc_logic > tx_valid;
sc_out < bool > clk;
sc_out < sc_logic > rst_n;
sc_out < sc_lv < 8 > > data_in;

public:

ifstream fin;

SC_CTOR(soft_sc_module)
: rst_n("rst_n"),
data_in("data_in"),
data_out ("data_out"),
rx_valid("rx_valid"),
tx_valid("tx_valid"),
tx_busy("tx_busy"),
rx_busy("rx_busy"),
rst_n_i("rst_n_i"),
clk_i("clk_i"),
clk("clk")
{
}
~soft_sc_module()
{
delete [] str_b;
}
};

#endif
</source>
|}
</slides>

===Слайд: Architecture ===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример Архитектуры на VHDL'''}}
<source lang="vhdl">

architecture beh of soft is
file comfile : text open read_mode is comand_file;

begin -- beh
-- тело архитектуры
signal str : string(1 to 1000) := (others => ' ');
signal RST_N_i : std_logic;
signal DATA_IN_i : std_logic_vector(7 downto 0);
signal f_get_answer : boolean := false;
signal tmd : time := 0 ms;

end beh;
</source>

|
{{Фио|'''<big></big>Пример аналогичной конструкции на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public :
std::string comand_file;
public :
sc_signal< sc_logic > rst_n_i;
sc_signal< sc_lv < 8 > > data_in_i;
sc_signal < bool > f_get_answer;
sc_signal < sc_time > tmd;
sc_time btmd (0, SC_MS);
SC_CTOR(soft_sc_module)
:
rst_n_i("rst_n_i"),
data_in_i("data_in_i"),
f_get_answer("f_get_answer"),
tmd("tmd")
{
str = new char [1000];
//объявление функций
//выбор списка чувствительности
//установка значений по умолчанию
tmd.write(btmd);
// tmd = btmd;
//оператор присваивания перегружен и выолнит вызов функции write
}
~soft_sc_module()
{
delete [] str;
}
</source>
|}
</slides>

===Слайд: Generic ===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
entity soft is
generic (UART_Speed : integer := 115200;
System_CLK : integer := 50000000
);
--
--
--
architecture beh of soft is
CLK_i <= not CLK_i after 1 ns * (1000000000 / System_CLK );
end beh;
</source>

|
{{Фио|'''<big></big>Пример на SystemC (sc_get_param)'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module)
: rst_n("rst_n"),
tmd("tmd")
{
if (!sc_get_param("System_CLK",System_CLK)) cout << "error get generic";
if (!sc_get_param("UART_Speed",UART_Speed)) cout << "error get generic";
period_ns=(1000000000)/System_CLK;
str = new char [1000];
}
~soft_sc_module()
{
delete [] str_b;
}
};
</source>
|}
</slides>

===Слайд: Process без списка чувствительности ===

<slides split="-----" width="400" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
wait_byte_timer: process
begin -- process wiat_timer
wait for 0.5 ms;
if (NOW - tmd) > 1 ms then
if f_start_get_answer then
f_byte_timer <= true;
wait for 0.1 ms;
f_byte_timer <= false;
end if;
end if;
end process wait_byte_timer;
</source>

|
{{Фио|'''<big></big>Пример на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module):
{ SC_METHOD (wait_byte_timer); }
~soft_sc_module()
{ }
};
void soft_sc_module :: wait_byte_timer ()
{
next_trigger (0.5,SC_MS);
if ((sc_time_stamp()-tmd) > sc_time(1, SC_MS) )
if (f_start_get_answer)
{f_byte_timer=true;
next_trigger (0.1,SC_MS);
f_byte_timer=false;
}
cout<< "wait_byte_timer work\n";
}
</source>
|}
</slides>

===Слайд: Process со списком чувствительности (пример 1)===

<slides split="-----" width="400" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
CLK_i <= not CLK_i after 1 ns * (1000000000 / System_CLK );
--или
process (clk)
begin
if clk'event then
clk_i <= not clk_i after 1 ns * (1000000000 / System_CLK );
end if;
end process;
</source>
|
{{Фио|'''<big></big>Пример на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module):
{ clk_i=true;
period_ns=(1000000000)/System_CLK;
SC_METHOD (clk_gen);
}
~soft_sc_module()
{ }
};

void soft_sc_module :: clk_gen ()
{
clk_i.write(!clk_i.read());
next_trigger (period_ns, SC_NS);

}
</source>
|}
</slides>

===Слайд: Process со списком чувствительности (пример 2) ===

<slides split="-----" width="400" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
RST_N <= RST_N_i;
--или
process (RST_N_i)
begin
if RST_N_i'event then
RST_N <= RST_N_i;
end if;
end process;
</source>
|
{{Фио|'''<big></big>Пример на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module):
{ clk_i=true;
SC_METHOD (rst_n_i2rst_n);
sensitive << rst_n_i;
dont_initialize();
}
~soft_sc_module()
{ }
};

void soft_sc_module :: reset_gen ()
{
rst_n_i.write( SC_LOGIC_0 );
wait (100, SC_NS);
cout << "run reset";
rst_n_i.write( SC_LOGIC_1 );
}
</source>
|}
</slides>

===Слайд: Работа с файлами ===
<slides split="-----" width="800" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
p_send : process
variable l : line;
variable byte_r : std_logic_vector(0 to 7);
variable good : boolean;
variable f_first_byte : boolean:=false;
begin -- process p1

loop1: while not endfile(comfile) loop

readline (comfile,l);
skip_space (l);
next loop1 when l'length = 0;

for i in 1 to l'length loop
str(i) <= l(i);
end loop; -- i
str((l'length)+1 to 1000) <= (others => ' ');
str_l <= l'length;
</source>
|
<source lang="vhdl">
if l(1) = '#' then
assert false report "коментарий:"&str(1 to str_l) severity NOTE;
else
assert false report "коментарий"&str(1 to str_l) severity NOTE;
f_first_byte := true;
while l'length /= 0 loop
hread (l,byte_r,good);
assert good report "ошибка" severity FAILURE;
if f_first_byte then
f_first_byte := false;
comand <= byte_r;
end if;
TX_VALID_i <= '1';
DATA_IN_i <= byte_r;
skip_space (l);
wait until TX_BUSY = '1';
end loop;
f_start_timer <= true;
TX_VALID_i <= '0';
wait until f_get_answer or f_timer;
assert not f_timer report "1мкс" severity FAILURE;
f_start_timer <= false;
end if;
end loop;
assert false report "======" severity failure;
end process p_send;
</source>
|}
</slides>

===Слайд: Работа с файлами ===
<slides split="-----" width="800" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на SystemC'''}}
<source lang="cpp">
void soft_sc_module :: p_send ()
{
fin.open(comand_file.c_str(),ios::out);
cout << "work4\n";
bool f_first_byte=false;
if (!fin){
std::cout << "File invalide open";
exit (0);
}
while (!fin.eof()){
fin.getline (str,1000);
skip_space (&(str));
if (strlen(str)){
if (str[0] == '#')
cout << "koment: "<< str <<endl;
else {
cout << "data: "<< str <<endl;
f_first_byte=true;
//while ( str[0] != '\0' ){
while ( strlen(str) ){
if ( str[0] == ' ' )
skip_space(&(str));
else {
//cout << "1/2\n";
byte_b.range(7,4)=str[0];
str++;
skip_space(&(str));
if (!strlen(str)){
cout<<endl<<"error";
sc_stop();
}
else {
//cout << "2/2\n";
byte_b.range(3,0)=str[0];
str++;
}
</source>
|
<source lang="cpp">

if (f_first_byte){
f_first_byte=false;
comand=byte_b;
}
//cout << byte_b << endl;
tx_valid_i.write(SC_LOGIC_1);
data_in.write(byte_b);
wait (tx_busy.posedge_event());
}
}
f_start_timer = true;
tx_valid_i.write(SC_LOGIC_0);
wait ( f_get_answer.posedge_event() | f_timer.posedge_event() );
if ( f_timer ) {cout << "error";sc_stop();}
f_start_timer = false;
}
}
str=str_b;
}
cout << "error";
fin.close();
sc_stop();
}
</source>
|}
</slides>

===Слайд: Работа с переменными ===
===Слайд: Работа с сигналами ===
===Слайд: Арифметические, логические, операции присваивания ===
===Слайд: Конструкции С++ ===
===Слайд: Создание модуля ===
===Слайд: Коммуникации между модулями ===
===Слайд: Управление процессом моделирования (сообщения, запуск останов моделирования)===
== Слайд: Компиляция описания ==
== Слайд: Запуск моделирования только SystemC описания ==
== Слайд: Запуск моделирования SystemC описания и VHDL ==

Спец курс (Избранные главы VHDL)/Верификация описания

2012-11-19T14:14:45Z

164.177.206.33: /* Слайд: Architecture */

<slideshow style="custis" headingmark="Слайд:" incmark=":step" scaled="true" >
;title: '''Верификация описания.'''
;author: Зайцев В.С.
</slideshow>

[[Файл:SystemC_From_the_ground_up.mm]]

==Слайд:Верификация описания==
[[Файл:Процевв_верификации.png]]

==Слайд:Верификация описания:step==
*{{Гол|''' <big>Среда моделирования</big>'''}}
** Active-HDL™
** Riviera-PRO™
** NC-Sim®
** ModelSim®
** QuestaSim®
** VCS-MX®
* {{Гол|'''<big>Структура проекта</big>'''}}
** Тестовое окружение
** RTL-модель (Verilog,VHDL)
** Эталонная модель (SystemC)
** Assert'ы (psl, OVVM, UVM)
** Отчеты и базы по результатам моделирования

==Слайд:Эталонная модель на языке ''{{Зел| <big>SystemC</big>}}''==

# Высокий уровень абстракции
# Скорость моделирования
# Возможности языка C++
# Инструменты для автоматизации
# Совместное моделирование с другими HDL-языками

== Основы языка SystemC ==

===Слайд:Типы данных (Форматы и способ представления данных) ===
[[Файл:Типы_данных.png]]

===Слайд:Типы данных (native)===
<source lang="cpp"> // Пример типа данных C++
int spark_offset;
unsigned repairs = 0 ; // Count repair
unsigned long mileage; // Miles driven
short int speedometer; // -20.. 0.. 100 MPH
float temperature; // Engine temp in C
double time_of_last_request; //Time of bus
std:: string license_plate; // Text for license
const bool WARNING_LIGHT = true; // Status
enum compass {SW,W,NW,N,NE,E, SE, S} ;
</source>

===Слайд:Типы данных (Arithmetic)===
<source lang="cpp"> // Пример целочисленных типов данных C++
sc_int<LENGTH> NAME...;
sc_uint<LENGTH> NAME...;
sc_bigint<BITWIDTH> NAME...;
sc_biguint<BITWIDTH> NAME...;
// SystemC integer data types
sc_int<5> seat_position=3; //5 bits: 4 plus sign
sc_uint<13> days_SLOC(4000); //13 bits: no sign
sc_biguint<80> revs_SLOC; // 80 bits: no sign
</source>

===Слайд:Типы данных (Boolean)===
<source lang="cpp"> // Пример типа данных SystemC
sc_bit NAME...;
sc_bv<BITWIDTH> NAME...;
</source>

* sc_bit и sc_bv могут принимать значения: '''SC_LOGIC_1''' и '''SC_LOGIC_0.'''
* Для сокращения типов, можно использовать '''Log_1 и Log_0''' или '''‘1’ и ‘0’.'''
* Над этим типом данных возможно выполнение битовых операций '''and, or, xor (&,|, ^).'''
* Для обращения к отдельным битам и массивам '''[], range()'''.

<source lang="cpp">
sc_bit flag(SC_LOGIC_1); // more efficient to use bool
sc_bv<5> positions = "01101";
sc_bv<6> mask = "100111";
sc_bv<5> active = positions & mask;// 00101
sc_bv<1> all = active. and_reduce (); // SC_LOGIC_0
positions. range (3,2) = "00"; // 00001
positions [2] = active[0] ^ flag;
</source>

===Слайд:Типы данных ( многозначные (ZX10))===
<source lang="cpp"> // Пример типа данных SystemC
sc_logic NAME[,NAME]...;
sc_lv<BITNIDTH> NAME[,NAME ]...;
sc_logic buf(sc_dt::Log_Z);
sc_lv<8> data_drive ("zz01XZ1Z");
data_drive.range (5,4) = "ZZ";// ZZZZXZ1Z
buf = '1';

</source>

===Слайд:Операторы SystemC ===
[[Файл:Операции.png]]

===Слайд:Главный модуль MAIN===
{{Гол|'''<big>Описание на языке C++</big>'''}}
<source lang="cpp">
int main(int argc, char* argv[]) {
BODY_OF_PROGRAM
return EXIT_CODE; //
}
</source>

{{Гол|'''<big>Описание на языке SystemC</big>'''}}
<source lang="cpp">
int sc_main(int argc, char* argv[]) {
//ELABORATION
sc_start(); // <-- Simulation begins & ends
// in this function!
//[POST-PROCESSING]
return EXIT_CODE; //
}
</source>

===Слайд: Модуль ===
<source lang="cpp">
#include <systemc.h>
SC_MODULE(module_name) {
MODULE_BODY
};</source>
Содержит:
* '''{{Фио|<big>Порты</big>}}'''
* '''{{Фио|<big>Каналы связи</big>}}'''
* '''{{Фио|<big>Объявления переменных для хранения данных</big>}}'''
* '''{{Фио|<big>Другие модули с большей вложенностью</big>}}'''
* '''{{Фио|<big>Конструктор</big>}}'''
* '''{{Фио|<big>Деструктор</big>}}'''
* '''{{Фио|<big>Функции -процессы</big>}}'''
* '''{{Фио|<big>Вспомогательные функции</big>}}'''

===Слайд: Конструктор (SC_CTOR)===
<source lang="cpp">SC_CTOR(module_name)
: Initialization // OPTIONAL
{
Subdesign_Allocation
Subdesign_Connectivity
Process_Registration
Miscellaneous_Setup
}</source>

* '''{{Фио|<big>Объявление под модулей</big>}}'''
* '''{{Фио|<big>Подключение и соединение с подмодулями</big>}}'''
* '''{{Фио|<big>Регистрация процессов на SystemC</big>}}'''
* '''{{Фио|<big>Обеспечение постоянной чувствительности</big>}}'''
* '''{{Фио|<big>Разнообразные пользовательские объявления</big>}}''

===Слайд: Конструктор (SC_HAS_PROCESS)===
<source lang="cpp">
//FILE: module_name.h
SC_MODULE(module_name) {
SC_HAS_PROCESS(module_name);
module_name(sc_module_name instname[, other_args…])
: sc_module(instname)
[, other_initializers]
{
CONSTRUCTOR_BODY
}
};</source>

* '''{{Фио|<big>Все возможности конструктора SC_CTOR</big>}}'''
* '''{{Фио|<big>Альтернативный метод создания модуля</big>}}'''
* '''{{Фио|<big>Позволяет создавать конструктор с аргументами(+ к имени модуля)</big>}}'''
* '''{{Фио|<big>Используется, если желаете расположить конструктор в файле описания .cpp (не в файле .h)</big>}}'''

===Слайд: Процесс SC_THREAD ===

<source lang="cpp">
SC_MODULE(simple_process_ex) {
SC_CTOR(simple_process_ex) {
SC_THREAD(my_thread_process);
}
void my_thread_process(void);
};</source>

{{Зел|'''SC_THREAD'''}} в '''SystemC''':
# аналог {{Зел|'''initial block'''}} в '''Verilog'''
# {{Зел|'''process'''}} без списка чувствительности с оператором '''wait()''' в '''VHDL'''.

===Слайд:Введение времени===

{{Ор|<big>'''Единицы измерения времени'''</big>}}

<source lang="cpp">
SC_SEC // seconds
SC_MS // milliseconds
SC_US // microseconds
SC_NS // nanoseconds
SC_PS // picoseconds
SC_FS // femtoseconds
</source>
{{Ор|<big>'''Объявление переменной типа '''</big>}}{{Зел|<big>'''sc_time'''</big>}}
<source lang="cpp">
sc_time t_PERIOD(5, SC_NS) ;
sc_time t_TIMEOUT (100, SC_MS) ;
sc_time t_MEASURE, t_CURRENT, t_LAST_CLOCK;
t_MEASURE = (t_CURRENT-t_LAST_CLOCK) ;
if (t_MEASURE > t_HOLD) { error ("Setup violated") }
</source>

===Слайд:Запуск выполнения '''sc_start()'''===

{{Ор|<big>'''Функция запускающая выполнения главного процесса '''</big>}}

{{Сн|'''Пример запуска моделирования на 60 секунд модельного времени'''}}

<source lang="cpp">
int sc_main(int argc, char* argv[]) { // args unused
simple_process_ex my_instance ("my_instance");
sc_start(60.0,SC_SEC); // Limit sim to one minute
return 0 ;
}</source>

===Слайд:Контроль текущего времени моделирования '''sc_time_stamp ()'''===

<source lang="cpp">
std::cout << " The time is now "
<< sc_time_stamp()
<< "!" << std::endl;</source>

После запуска моделирования в консоли получим
The time is now 0 ns!

===Слайд: Остановка выполнения моделирования wait(sc_time)===

{{Ор|<big>'''Функция останавливающая выполнение процесса до заданного времени или до прихода события'''</big>}}

<source lang="cpp">
void simple_process_ex::my_thread_process (void) {
wait (10,SC_NS);
std::cout<< "Now at "<< sc_time_stamp() << std::endl;
sc_time t_DELAY(2,SC_MS); // keyboard debounce time
t_DELAY *= 2;
std::cout<< "Delaying "<< t_DELAY<< std::endl;
wait(t_DELAY);
std::cout << "Now at " << sc_time_stamp()
<< std::endl;
}</source>

% . /run_example
Now at 10 ns
Delaying 4 ms
Now at 4000010 ns

===Слайд:События '''sc_event'''===
<slides split="-----" width="400" >
[[Файл:Процес_моделирования_по_событиям.png]]
</slides>

===Слайд:События '''SC_THREAD::wait()'''===
Процесс '''SC_THREAD''' процес выполняющийся {{Кр|'''<big>один раз!!</big>'''}}, для управления работой такого процесса используют функцию задержки выполнения wait

<source lang="cpp">wait(time);
wait(event);
wait(event1 | event2) // до прихода любого из событий
wait(event1 & event2) // до прихода всех событий вместе
wait(timeout, event); // до прихода события ожидает в течении времени
wait ( timeout, event1 | event2 )
wait ( timeout, event1 & event2 )
wait(); // ожидание дельта цикла выполнения, статическая задержка
</source>
===Слайд:Запуск события (установка,назначение)===

Для запуска события используется атрибут {{Зел|<big>'''.notify()'''</big>}}

Он выполняет запуск событий, отсчет времени идет от запуска моделирования. Для сброса точки отсчета используют {{Зел|<big>'''.cancel()'''</big>}}

<source lang="cpp">sc_event action;
sc_time now(sc_time_stamp()); //вытягиваем текущее время моделирования
//стартуем событие немедленно
action.notify();
//следующее событие через 20 ms от текущего момента
action.notify(20, SC_MS);
//переопределим событие на время 1.5 ns от текущего момента
action.notify(1.5,SC_NS);
//продублируем событие (не имеет эффекта)
action.notify(1.5, SC_NS);
//зададим событие от предыдущего на 1.5 ns
action.notify(3.0,SC_NS);
//запустим дельта цикл (не имеет эффекта)
action.notify(SC_ZERO_TIME);
//сбросим время задания события
action.cancel();
//зададим событие на 20 fs после сброса
action.notify(20,SC_FS);</source>

===Слайд:Процесс со списком чувствительности SC_METHOD ===
{{ЖЛампа|24px}}Аналог '''process''' в '''VHDL'''

<source lang="cpp">SC_METHOD(process_name);</source>

{{ЖЛампа|24px}}Список чуствительности задаеться после ключевого слова {{Зел|'''sensitive'''}}

<source lang="cpp"> sensitive << event [<< event] ;// поточный стил
sensitive (event [, event] ); // стиль с использованием функции</source>

===Слайд:dont_initialize() ===
{{ЖЛампа|24px}} Отменяет начальную установку значений
* После запуска моделирования конструктор создает модуль и инициализирует все процессы и переменные.

* Это заставляет выполниться всем методам работающим по событию по одному разу во время запуска если событие устанавливалось в значение.

* Для исключения начального выполнения используется функция '''dont_initialize()'''

===Слайд: Стек событий '''sc_event_queue'''===

{{ЖЛампа|24px}} Событие можно задать не только от начального момента времени, а и от текущего.

Для этого используется функция '''sc_event_queue()'''

<source lang="cpp">
sc_event_queue action;
sc_time now(sc_time_stamp());
action.notify(20, SC_MS);
action.notify(1.5,SC_NS);
action.notify(1.5,SC_NS);
action.notify(3.0,SC_NS);
action.notify(SC_ZERO_TIME);
action.notify(1,SC_SEC);
action.cancel_all();
</source>

===Слайд:Совместное использование ресурсов===

* При совместном использовании ресурсов, шин, памяти нужно разграничить область полномочий каждого процесса.
* Иначе при одновременной, к примеру записи будет происходить сбой или некорректная запись.
Если управлением доступом к одному ресурсу
<source lang="cpp">sc_mutex NAME;
// блокируем mutex NAME (ждем пока разблокируется)
NAME.lock();
// Возвращает статус состояния блокировки
NAME.try lock()
// Снимает блокировку
NAME.unlock();</source>

Если управлением доступом к нескольким ресурсам

<source lang="cpp">sc_semaphore NAME(COUNT);
// блокируем mutex NAME (ждем пока разблокируеться)
NAME.wait();
// Возвращает статус состояния блокировки
NAME.trywait()
//Возвращает число свободных ресурсов
NAME.get_value()
// Снимает блокировку
NAME.post();</source>

===Слайд:Иерархия и структура проекта===
[[Файл:Иерархия.png]]

===Слайд:Иерархия и структура проекта (sc_main)===

{{ЖЛампа|24px}}Подключение и создание {{Зел|<big>'''модуля'''</big>}} внутри '''главного''' модуля аналогично созданию {{Зел|<big>'''объекта'''</big>}} заданного{{Зел| <big>'''класса'''</big>}}
{{Фио|<big>'''Стандартная конструкция блока хранения информации для RFID'''</big>}}
{| cellspacing="0" cellpadding="0" border="1"
|
* {{Гол|'''Статический метод'''}}
<source lang="cpp">//FILE: main.cpp
#include "Wheel.h"
int sc_main(int argc, char* argv[]) {
Wheel wheel_FL("wheel_FL");
Wheel wheel_FR("wheel_FR");
sc_start();
}</source>
|
* {{Гол|'''Динамический метод'''}}
<source lang="cpp">//FILE: main.cpp
#include "Wheel.h"
int sc_main(int argc, char* argv[]) {
Wheel* wheel_FL; // pointer to FL wheel
Wheel* wheel_FR; // pointer to FR wheel
wheel_FL = new Wheel ("wheel_FL"); // create FL
wheel_FR = new Wheel ("wheel_FR"); // create FR
sc_start();
delete wheel_FL;
delete wheel_FR;
}</source>
|}

===Слайд:Иерархия и структура проекта (SC_MODULE)===

{{ЖЛампа|24px}}Подключение и создание {{Зел|<big>'''модуля'''</big>}} внутри другого модуля аналогично созданию {{Зел|<big>'''объекта'''</big>}} заданного{{Зел| <big>'''класса'''</big>}}, внутри другого класса. Поэтому объявления производиться в конструкторе верхнего модуля
{| cellspacing="0" cellpadding="0" border="1"
|

* {{Гол|'''Статический метод'''}}
<source lang="cpp">//FILE:Body.h
#include "Wheel.h"
SC_MODULE(Body) {
Wheel wheel_FL;
Wheel wheel_FR;
SC_CTOR(Body)
: wheel_FL("wheel_FL"), //initialization
wheel_FR("wheel_FR") //initialization
{
// other initialization
}
};
}</source>
|
* {{Гол|'''Динамический метод'''}}
<source lang="cpp">//FILE:Body.h
#include "Wheel.h"
SC_MODULE(Body) {
Wheel* wheel_FL;
Wheel* wheel_FR;
SC_CTOR(Body) {
wheel_FL = new Wheel("wheel_FL");
wheel_FR = new Wheel("wheel_FR");
// other initialization
}
};
}</source>
|}

===Слайд:Порты - точки подачи и снятия внешних воздействий===
[[Файл:Порты_соединение_модулей.png]]

===Слайд:Типы портов ===

* {{Сн|'''sc_port'''}} - аналог inout порта в языке VHDL
* {{Сн|'''sc_in'''}} - аналог in порта в языке VHDL
* {{Сн|'''sc_out'''}} - аналог out порта в языке VHDL
* {{Сн|'''sc_export'''}} - внешний порт, порт который позволяет получить доступ к private данным модуля, но иерархически модулю не принадлежит.
{{ЖЛампа|24px}} Механизм использования '''sc_export''' порта напоминает '''доступ к сигналам по иерархии''', как в '''VHDL-2008'''.

===Слайд:Порты - точки подачи и снятия внешних воздействий===
[[Файл:Порты_соединение_модулей_экспорт.png]]
[[Файл:Порты_соединение_модулей_экспорт2.png]]

===Слайд:Управление процессом и контроль статуса моделирования===

== Слайд: VHDL и SystemC конструкции ==
===Слайд: Entity ===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример поведенческой модели накопителя (VHDL)'''}}
<source lang="vhdl">
entity soft is
generic (UART_Speed : integer := 115200; -- UART Speed
System_CLK : integer := 50000000; -- System CLK in Hz
comand_file : string :="/home/Vidokq/djin18reader/vhd/D18/comfile.txt"
);
port (
CLK : out std_logic; -- system clk
RST_N : out std_logic; -- system reset#
DATA_IN : out std_logic_vector(7 downto 0); -- Transmit data
DATA_OUT : in std_logic_vector(7 downto 0); -- Recieved data
RX_VALID : in std_logic; -- RX buffer data ready
TX_VALID : out std_logic; -- Data for TX avaible
TX_BUSY : in std_logic; --
RX_BUSY : in std_logic);

end soft;
</source>

|
{{Фио|'''<big></big>Пример поведенческой модели накопителя (Verilog)'''}}

<source lang="cpp">

SC_MODULE (soft_sc_module)
{
public :
sc_in < sc_logic > tx_busy;
sc_in < sc_logic > rx_busy;
sc_in < sc_lv < 8 > > data_out;
sc_in < sc_logic > rx_valid;
sc_out < sc_logic > tx_valid;
sc_out < bool > clk;
sc_out < sc_logic > rst_n;
sc_out < sc_lv < 8 > > data_in;

public:

ifstream fin;

SC_CTOR(soft_sc_module)
: rst_n("rst_n"),
data_in("data_in"),
data_out ("data_out"),
rx_valid("rx_valid"),
tx_valid("tx_valid"),
tx_busy("tx_busy"),
rx_busy("rx_busy"),
rst_n_i("rst_n_i"),
clk_i("clk_i"),
clk("clk")
{
}
~soft_sc_module()
{
delete [] str_b;
}
};

#endif
</source>
|}
</slides>

===Слайд: Architecture ===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример Архитектуры на VHDL'''}}
<source lang="vhdl">

architecture beh of soft is
file comfile : text open read_mode is comand_file;

begin -- beh
-- тело архитектуры
signal str : string(1 to 1000) := (others => ' ');
signal RST_N_i : std_logic;
signal DATA_IN_i : std_logic_vector(7 downto 0);
signal f_get_answer : boolean := false;
signal tmd : time := 0 ms;

end beh;
</source>

|
{{Фио|'''<big></big>Пример аналогичной конструкции на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public :
std::string comand_file;
public :
sc_signal< sc_logic > rst_n_i;
sc_signal< sc_lv < 8 > > data_in_i;
sc_signal < bool > f_get_answer;
sc_signal < sc_time > tmd;
sc_time btmd (0, SC_MS);
SC_CTOR(soft_sc_module)
:
rst_n_i("rst_n_i"),
data_in_i("data_in_i"),
f_get_answer("f_get_answer"),
tmd("tmd")
{
str = new char [1000];
//объявление функций
//выбор списка чувствительности
//установка значений по умолчанию
tmd.write(btmd);
// tmd = btmd;
//оператор присваивания перегружен и выолнит вызов функции write
}
~soft_sc_module()
{
delete [] str;
}
</source>
|}
</slides>

===Слайд: Generic ===

<slides split="-----" width="400" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
entity soft is
generic (UART_Speed : integer := 115200;
System_CLK : integer := 50000000
);
--
--
--
architecture beh of soft is
CLK_i <= not CLK_i after 1 ns * (1000000000 / System_CLK );
end beh;
</source>

|
{{Фио|'''<big></big>Пример на SystemC (sc_get_param)'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module)
: rst_n("rst_n"),
tmd("tmd")
{
if (!sc_get_param("System_CLK",System_CLK)) cout << "error get generic";
if (!sc_get_param("UART_Speed",UART_Speed)) cout << "error get generic";
period_ns=(1000000000)/System_CLK;
str = new char [1000];
}
~soft_sc_module()
{
delete [] str_b;
}
};
</source>
|}
</slides>

===Слайд: Process без списка чувствительности ===

<slides split="-----" width="400" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
wait_byte_timer: process
begin -- process wiat_timer
wait for 0.5 ms;
if (NOW - tmd) > 1 ms then
if f_start_get_answer then
f_byte_timer <= true;
wait for 0.1 ms;
f_byte_timer <= false;
end if;
end if;
end process wait_byte_timer;
</source>

|
{{Фио|'''<big></big>Пример на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module):
{ SC_METHOD (wait_byte_timer); }
~soft_sc_module()
{ }
};
void soft_sc_module :: wait_byte_timer ()
{
next_trigger (0.5,SC_MS);
if ((sc_time_stamp()-tmd) > sc_time(1, SC_MS) )
if (f_start_get_answer)
{f_byte_timer=true;
next_trigger (0.1,SC_MS);
f_byte_timer=false;
}
cout<< "wait_byte_timer work\n";
}
</source>
|}
</slides>

===Слайд: Process со списком чувствительности (пример 1)===

<slides split="-----" width="400" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
CLK_i <= not CLK_i after 1 ns * (1000000000 / System_CLK );
--или
process (clk)
begin
if clk'event then
clk_i <= not clk_i after 1 ns * (1000000000 / System_CLK );
end if;
end process;
</source>
|
{{Фио|'''<big></big>Пример на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module):
{ clk_i=true;
period_ns=(1000000000)/System_CLK;
SC_METHOD (clk_gen);
}
~soft_sc_module()
{ }
};

void soft_sc_module :: clk_gen ()
{
clk_i.write(!clk_i.read());
next_trigger (period_ns, SC_NS);

}
</source>
|}
</slides>

===Слайд: Process со списком чувствительности (пример 2) ===

<slides split="-----" width="400" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
RST_N <= RST_N_i;
--или
process (RST_N_i)
begin
if RST_N_i'event then
RST_N <= RST_N_i;
end if;
end process;
</source>
|
{{Фио|'''<big></big>Пример на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module):
{ clk_i=true;
SC_METHOD (rst_n_i2rst_n);
sensitive << rst_n_i;
dont_initialize();
}
~soft_sc_module()
{ }
};

void soft_sc_module :: reset_gen ()
{
rst_n_i.write( SC_LOGIC_0 );
wait (100, SC_NS);
cout << "run reset";
rst_n_i.write( SC_LOGIC_1 );
}
</source>
|}
</slides>

===Слайд: Работа с файлами ===
<slides split="-----" width="800" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
p_send : process
variable l : line;
variable byte_r : std_logic_vector(0 to 7);
variable good : boolean;
variable f_first_byte : boolean:=false;
begin -- process p1

loop1: while not endfile(comfile) loop

readline (comfile,l);
skip_space (l);
next loop1 when l'length = 0;

for i in 1 to l'length loop
str(i) <= l(i);
end loop; -- i
str((l'length)+1 to 1000) <= (others => ' ');
str_l <= l'length;
</source>
|
<source lang="vhdl">
if l(1) = '#' then
assert false report "коментарий:"&str(1 to str_l) severity NOTE;
else
assert false report "коментарий"&str(1 to str_l) severity NOTE;
f_first_byte := true;
while l'length /= 0 loop
hread (l,byte_r,good);
assert good report "ошибка" severity FAILURE;
if f_first_byte then
f_first_byte := false;
comand <= byte_r;
end if;
TX_VALID_i <= '1';
DATA_IN_i <= byte_r;
skip_space (l);
wait until TX_BUSY = '1';
end loop;
f_start_timer <= true;
TX_VALID_i <= '0';
wait until f_get_answer or f_timer;
assert not f_timer report "1мкс" severity FAILURE;
f_start_timer <= false;
end if;
end loop;
assert false report "======" severity failure;
end process p_send;
</source>
|}
</slides>

===Слайд: Работа с файлами ===
<slides split="-----" width="800" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на SystemC'''}}
<source lang="cpp">
void soft_sc_module :: p_send ()
{
fin.open(comand_file.c_str(),ios::out);
cout << "work4\n";
bool f_first_byte=false;
if (!fin){
std::cout << "File invalide open";
exit (0);
}
while (!fin.eof()){
fin.getline (str,1000);
skip_space (&(str));
if (strlen(str)){
if (str[0] == '#')
cout << "koment: "<< str <<endl;
else {
cout << "data: "<< str <<endl;
f_first_byte=true;
//while ( str[0] != '\0' ){
while ( strlen(str) ){
if ( str[0] == ' ' )
skip_space(&(str));
else {
//cout << "1/2\n";
byte_b.range(7,4)=str[0];
str++;
skip_space(&(str));
if (!strlen(str)){
cout<<endl<<"error";
sc_stop();
}
else {
//cout << "2/2\n";
byte_b.range(3,0)=str[0];
str++;
}
</source>
|
<source lang="cpp">

if (f_first_byte){
f_first_byte=false;
comand=byte_b;
}
//cout << byte_b << endl;
tx_valid_i.write(SC_LOGIC_1);
data_in.write(byte_b);
wait (tx_busy.posedge_event());
}
}
f_start_timer = true;
tx_valid_i.write(SC_LOGIC_0);
wait ( f_get_answer.posedge_event() | f_timer.posedge_event() );
if ( f_timer ) {cout << "error";sc_stop();}
f_start_timer = false;
}
}
str=str_b;
}
cout << "error";
fin.close();
sc_stop();
}
</source>
|}
</slides>

===Слайд: Работа с переменными ===
===Слайд: Работа с сигналами ===
===Слайд: Арифметические, логические, операции присваивания ===
===Слайд: Конструкции С++ ===
===Слайд: Создание модуля ===
===Слайд: Коммуникации между модулями ===
===Слайд: Управление процессом моделирования (сообщения, запуск останов моделирования)===
== Слайд: Компиляция описания ==
== Слайд: Запуск моделирования только SystemC описания ==
== Слайд: Запуск моделирования SystemC описания и VHDL ==

Спец курс (Избранные главы VHDL)/Верификация описания

2012-11-19T14:14:19Z

164.177.206.33: /* Слайд: Entity */

<slideshow style="custis" headingmark="Слайд:" incmark=":step" scaled="true" >
;title: '''Верификация описания.'''
;author: Зайцев В.С.
</slideshow>

[[Файл:SystemC_From_the_ground_up.mm]]

==Слайд:Верификация описания==
[[Файл:Процевв_верификации.png]]

==Слайд:Верификация описания:step==
*{{Гол|''' <big>Среда моделирования</big>'''}}
** Active-HDL™
** Riviera-PRO™
** NC-Sim®
** ModelSim®
** QuestaSim®
** VCS-MX®
* {{Гол|'''<big>Структура проекта</big>'''}}
** Тестовое окружение
** RTL-модель (Verilog,VHDL)
** Эталонная модель (SystemC)
** Assert'ы (psl, OVVM, UVM)
** Отчеты и базы по результатам моделирования

==Слайд:Эталонная модель на языке ''{{Зел| <big>SystemC</big>}}''==

# Высокий уровень абстракции
# Скорость моделирования
# Возможности языка C++
# Инструменты для автоматизации
# Совместное моделирование с другими HDL-языками

== Основы языка SystemC ==

===Слайд:Типы данных (Форматы и способ представления данных) ===
[[Файл:Типы_данных.png]]

===Слайд:Типы данных (native)===
<source lang="cpp"> // Пример типа данных C++
int spark_offset;
unsigned repairs = 0 ; // Count repair
unsigned long mileage; // Miles driven
short int speedometer; // -20.. 0.. 100 MPH
float temperature; // Engine temp in C
double time_of_last_request; //Time of bus
std:: string license_plate; // Text for license
const bool WARNING_LIGHT = true; // Status
enum compass {SW,W,NW,N,NE,E, SE, S} ;
</source>

===Слайд:Типы данных (Arithmetic)===
<source lang="cpp"> // Пример целочисленных типов данных C++
sc_int<LENGTH> NAME...;
sc_uint<LENGTH> NAME...;
sc_bigint<BITWIDTH> NAME...;
sc_biguint<BITWIDTH> NAME...;
// SystemC integer data types
sc_int<5> seat_position=3; //5 bits: 4 plus sign
sc_uint<13> days_SLOC(4000); //13 bits: no sign
sc_biguint<80> revs_SLOC; // 80 bits: no sign
</source>

===Слайд:Типы данных (Boolean)===
<source lang="cpp"> // Пример типа данных SystemC
sc_bit NAME...;
sc_bv<BITWIDTH> NAME...;
</source>

* sc_bit и sc_bv могут принимать значения: '''SC_LOGIC_1''' и '''SC_LOGIC_0.'''
* Для сокращения типов, можно использовать '''Log_1 и Log_0''' или '''‘1’ и ‘0’.'''
* Над этим типом данных возможно выполнение битовых операций '''and, or, xor (&,|, ^).'''
* Для обращения к отдельным битам и массивам '''[], range()'''.

<source lang="cpp">
sc_bit flag(SC_LOGIC_1); // more efficient to use bool
sc_bv<5> positions = "01101";
sc_bv<6> mask = "100111";
sc_bv<5> active = positions & mask;// 00101
sc_bv<1> all = active. and_reduce (); // SC_LOGIC_0
positions. range (3,2) = "00"; // 00001
positions [2] = active[0] ^ flag;
</source>

===Слайд:Типы данных ( многозначные (ZX10))===
<source lang="cpp"> // Пример типа данных SystemC
sc_logic NAME[,NAME]...;
sc_lv<BITNIDTH> NAME[,NAME ]...;
sc_logic buf(sc_dt::Log_Z);
sc_lv<8> data_drive ("zz01XZ1Z");
data_drive.range (5,4) = "ZZ";// ZZZZXZ1Z
buf = '1';

</source>

===Слайд:Операторы SystemC ===
[[Файл:Операции.png]]

===Слайд:Главный модуль MAIN===
{{Гол|'''<big>Описание на языке C++</big>'''}}
<source lang="cpp">
int main(int argc, char* argv[]) {
BODY_OF_PROGRAM
return EXIT_CODE; //
}
</source>

{{Гол|'''<big>Описание на языке SystemC</big>'''}}
<source lang="cpp">
int sc_main(int argc, char* argv[]) {
//ELABORATION
sc_start(); // <-- Simulation begins & ends
// in this function!
//[POST-PROCESSING]
return EXIT_CODE; //
}
</source>

===Слайд: Модуль ===
<source lang="cpp">
#include <systemc.h>
SC_MODULE(module_name) {
MODULE_BODY
};</source>
Содержит:
* '''{{Фио|<big>Порты</big>}}'''
* '''{{Фио|<big>Каналы связи</big>}}'''
* '''{{Фио|<big>Объявления переменных для хранения данных</big>}}'''
* '''{{Фио|<big>Другие модули с большей вложенностью</big>}}'''
* '''{{Фио|<big>Конструктор</big>}}'''
* '''{{Фио|<big>Деструктор</big>}}'''
* '''{{Фио|<big>Функции -процессы</big>}}'''
* '''{{Фио|<big>Вспомогательные функции</big>}}'''

===Слайд: Конструктор (SC_CTOR)===
<source lang="cpp">SC_CTOR(module_name)
: Initialization // OPTIONAL
{
Subdesign_Allocation
Subdesign_Connectivity
Process_Registration
Miscellaneous_Setup
}</source>

* '''{{Фио|<big>Объявление под модулей</big>}}'''
* '''{{Фио|<big>Подключение и соединение с подмодулями</big>}}'''
* '''{{Фио|<big>Регистрация процессов на SystemC</big>}}'''
* '''{{Фио|<big>Обеспечение постоянной чувствительности</big>}}'''
* '''{{Фио|<big>Разнообразные пользовательские объявления</big>}}''

===Слайд: Конструктор (SC_HAS_PROCESS)===
<source lang="cpp">
//FILE: module_name.h
SC_MODULE(module_name) {
SC_HAS_PROCESS(module_name);
module_name(sc_module_name instname[, other_args…])
: sc_module(instname)
[, other_initializers]
{
CONSTRUCTOR_BODY
}
};</source>

* '''{{Фио|<big>Все возможности конструктора SC_CTOR</big>}}'''
* '''{{Фио|<big>Альтернативный метод создания модуля</big>}}'''
* '''{{Фио|<big>Позволяет создавать конструктор с аргументами(+ к имени модуля)</big>}}'''
* '''{{Фио|<big>Используется, если желаете расположить конструктор в файле описания .cpp (не в файле .h)</big>}}'''

===Слайд: Процесс SC_THREAD ===

<source lang="cpp">
SC_MODULE(simple_process_ex) {
SC_CTOR(simple_process_ex) {
SC_THREAD(my_thread_process);
}
void my_thread_process(void);
};</source>

{{Зел|'''SC_THREAD'''}} в '''SystemC''':
# аналог {{Зел|'''initial block'''}} в '''Verilog'''
# {{Зел|'''process'''}} без списка чувствительности с оператором '''wait()''' в '''VHDL'''.

===Слайд:Введение времени===

{{Ор|<big>'''Единицы измерения времени'''</big>}}

<source lang="cpp">
SC_SEC // seconds
SC_MS // milliseconds
SC_US // microseconds
SC_NS // nanoseconds
SC_PS // picoseconds
SC_FS // femtoseconds
</source>
{{Ор|<big>'''Объявление переменной типа '''</big>}}{{Зел|<big>'''sc_time'''</big>}}
<source lang="cpp">
sc_time t_PERIOD(5, SC_NS) ;
sc_time t_TIMEOUT (100, SC_MS) ;
sc_time t_MEASURE, t_CURRENT, t_LAST_CLOCK;
t_MEASURE = (t_CURRENT-t_LAST_CLOCK) ;
if (t_MEASURE > t_HOLD) { error ("Setup violated") }
</source>

===Слайд:Запуск выполнения '''sc_start()'''===

{{Ор|<big>'''Функция запускающая выполнения главного процесса '''</big>}}

{{Сн|'''Пример запуска моделирования на 60 секунд модельного времени'''}}

<source lang="cpp">
int sc_main(int argc, char* argv[]) { // args unused
simple_process_ex my_instance ("my_instance");
sc_start(60.0,SC_SEC); // Limit sim to one minute
return 0 ;
}</source>

===Слайд:Контроль текущего времени моделирования '''sc_time_stamp ()'''===

<source lang="cpp">
std::cout << " The time is now "
<< sc_time_stamp()
<< "!" << std::endl;</source>

После запуска моделирования в консоли получим
The time is now 0 ns!

===Слайд: Остановка выполнения моделирования wait(sc_time)===

{{Ор|<big>'''Функция останавливающая выполнение процесса до заданного времени или до прихода события'''</big>}}

<source lang="cpp">
void simple_process_ex::my_thread_process (void) {
wait (10,SC_NS);
std::cout<< "Now at "<< sc_time_stamp() << std::endl;
sc_time t_DELAY(2,SC_MS); // keyboard debounce time
t_DELAY *= 2;
std::cout<< "Delaying "<< t_DELAY<< std::endl;
wait(t_DELAY);
std::cout << "Now at " << sc_time_stamp()
<< std::endl;
}</source>

% . /run_example
Now at 10 ns
Delaying 4 ms
Now at 4000010 ns

===Слайд:События '''sc_event'''===
<slides split="-----" width="400" >
[[Файл:Процес_моделирования_по_событиям.png]]
</slides>

===Слайд:События '''SC_THREAD::wait()'''===
Процесс '''SC_THREAD''' процес выполняющийся {{Кр|'''<big>один раз!!</big>'''}}, для управления работой такого процесса используют функцию задержки выполнения wait

<source lang="cpp">wait(time);
wait(event);
wait(event1 | event2) // до прихода любого из событий
wait(event1 & event2) // до прихода всех событий вместе
wait(timeout, event); // до прихода события ожидает в течении времени
wait ( timeout, event1 | event2 )
wait ( timeout, event1 & event2 )
wait(); // ожидание дельта цикла выполнения, статическая задержка
</source>
===Слайд:Запуск события (установка,назначение)===

Для запуска события используется атрибут {{Зел|<big>'''.notify()'''</big>}}

Он выполняет запуск событий, отсчет времени идет от запуска моделирования. Для сброса точки отсчета используют {{Зел|<big>'''.cancel()'''</big>}}

<source lang="cpp">sc_event action;
sc_time now(sc_time_stamp()); //вытягиваем текущее время моделирования
//стартуем событие немедленно
action.notify();
//следующее событие через 20 ms от текущего момента
action.notify(20, SC_MS);
//переопределим событие на время 1.5 ns от текущего момента
action.notify(1.5,SC_NS);
//продублируем событие (не имеет эффекта)
action.notify(1.5, SC_NS);
//зададим событие от предыдущего на 1.5 ns
action.notify(3.0,SC_NS);
//запустим дельта цикл (не имеет эффекта)
action.notify(SC_ZERO_TIME);
//сбросим время задания события
action.cancel();
//зададим событие на 20 fs после сброса
action.notify(20,SC_FS);</source>

===Слайд:Процесс со списком чувствительности SC_METHOD ===
{{ЖЛампа|24px}}Аналог '''process''' в '''VHDL'''

<source lang="cpp">SC_METHOD(process_name);</source>

{{ЖЛампа|24px}}Список чуствительности задаеться после ключевого слова {{Зел|'''sensitive'''}}

<source lang="cpp"> sensitive << event [<< event] ;// поточный стил
sensitive (event [, event] ); // стиль с использованием функции</source>

===Слайд:dont_initialize() ===
{{ЖЛампа|24px}} Отменяет начальную установку значений
* После запуска моделирования конструктор создает модуль и инициализирует все процессы и переменные.

* Это заставляет выполниться всем методам работающим по событию по одному разу во время запуска если событие устанавливалось в значение.

* Для исключения начального выполнения используется функция '''dont_initialize()'''

===Слайд: Стек событий '''sc_event_queue'''===

{{ЖЛампа|24px}} Событие можно задать не только от начального момента времени, а и от текущего.

Для этого используется функция '''sc_event_queue()'''

<source lang="cpp">
sc_event_queue action;
sc_time now(sc_time_stamp());
action.notify(20, SC_MS);
action.notify(1.5,SC_NS);
action.notify(1.5,SC_NS);
action.notify(3.0,SC_NS);
action.notify(SC_ZERO_TIME);
action.notify(1,SC_SEC);
action.cancel_all();
</source>

===Слайд:Совместное использование ресурсов===

* При совместном использовании ресурсов, шин, памяти нужно разграничить область полномочий каждого процесса.
* Иначе при одновременной, к примеру записи будет происходить сбой или некорректная запись.
Если управлением доступом к одному ресурсу
<source lang="cpp">sc_mutex NAME;
// блокируем mutex NAME (ждем пока разблокируется)
NAME.lock();
// Возвращает статус состояния блокировки
NAME.try lock()
// Снимает блокировку
NAME.unlock();</source>

Если управлением доступом к нескольким ресурсам

<source lang="cpp">sc_semaphore NAME(COUNT);
// блокируем mutex NAME (ждем пока разблокируеться)
NAME.wait();
// Возвращает статус состояния блокировки
NAME.trywait()
//Возвращает число свободных ресурсов
NAME.get_value()
// Снимает блокировку
NAME.post();</source>

===Слайд:Иерархия и структура проекта===
[[Файл:Иерархия.png]]

===Слайд:Иерархия и структура проекта (sc_main)===

{{ЖЛампа|24px}}Подключение и создание {{Зел|<big>'''модуля'''</big>}} внутри '''главного''' модуля аналогично созданию {{Зел|<big>'''объекта'''</big>}} заданного{{Зел| <big>'''класса'''</big>}}
{{Фио|<big>'''Стандартная конструкция блока хранения информации для RFID'''</big>}}
{| cellspacing="0" cellpadding="0" border="1"
|
* {{Гол|'''Статический метод'''}}
<source lang="cpp">//FILE: main.cpp
#include "Wheel.h"
int sc_main(int argc, char* argv[]) {
Wheel wheel_FL("wheel_FL");
Wheel wheel_FR("wheel_FR");
sc_start();
}</source>
|
* {{Гол|'''Динамический метод'''}}
<source lang="cpp">//FILE: main.cpp
#include "Wheel.h"
int sc_main(int argc, char* argv[]) {
Wheel* wheel_FL; // pointer to FL wheel
Wheel* wheel_FR; // pointer to FR wheel
wheel_FL = new Wheel ("wheel_FL"); // create FL
wheel_FR = new Wheel ("wheel_FR"); // create FR
sc_start();
delete wheel_FL;
delete wheel_FR;
}</source>
|}

===Слайд:Иерархия и структура проекта (SC_MODULE)===

{{ЖЛампа|24px}}Подключение и создание {{Зел|<big>'''модуля'''</big>}} внутри другого модуля аналогично созданию {{Зел|<big>'''объекта'''</big>}} заданного{{Зел| <big>'''класса'''</big>}}, внутри другого класса. Поэтому объявления производиться в конструкторе верхнего модуля
{| cellspacing="0" cellpadding="0" border="1"
|

* {{Гол|'''Статический метод'''}}
<source lang="cpp">//FILE:Body.h
#include "Wheel.h"
SC_MODULE(Body) {
Wheel wheel_FL;
Wheel wheel_FR;
SC_CTOR(Body)
: wheel_FL("wheel_FL"), //initialization
wheel_FR("wheel_FR") //initialization
{
// other initialization
}
};
}</source>
|
* {{Гол|'''Динамический метод'''}}
<source lang="cpp">//FILE:Body.h
#include "Wheel.h"
SC_MODULE(Body) {
Wheel* wheel_FL;
Wheel* wheel_FR;
SC_CTOR(Body) {
wheel_FL = new Wheel("wheel_FL");
wheel_FR = new Wheel("wheel_FR");
// other initialization
}
};
}</source>
|}

===Слайд:Порты - точки подачи и снятия внешних воздействий===
[[Файл:Порты_соединение_модулей.png]]

===Слайд:Типы портов ===

* {{Сн|'''sc_port'''}} - аналог inout порта в языке VHDL
* {{Сн|'''sc_in'''}} - аналог in порта в языке VHDL
* {{Сн|'''sc_out'''}} - аналог out порта в языке VHDL
* {{Сн|'''sc_export'''}} - внешний порт, порт который позволяет получить доступ к private данным модуля, но иерархически модулю не принадлежит.
{{ЖЛампа|24px}} Механизм использования '''sc_export''' порта напоминает '''доступ к сигналам по иерархии''', как в '''VHDL-2008'''.

===Слайд:Порты - точки подачи и снятия внешних воздействий===
[[Файл:Порты_соединение_модулей_экспорт.png]]
[[Файл:Порты_соединение_модулей_экспорт2.png]]

===Слайд:Управление процессом и контроль статуса моделирования===

== Слайд: VHDL и SystemC конструкции ==
===Слайд: Entity ===

<slides split="-----" width="700" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример поведенческой модели накопителя (VHDL)'''}}
<source lang="vhdl">
entity soft is
generic (UART_Speed : integer := 115200; -- UART Speed
System_CLK : integer := 50000000; -- System CLK in Hz
comand_file : string :="/home/Vidokq/djin18reader/vhd/D18/comfile.txt"
);
port (
CLK : out std_logic; -- system clk
RST_N : out std_logic; -- system reset#
DATA_IN : out std_logic_vector(7 downto 0); -- Transmit data
DATA_OUT : in std_logic_vector(7 downto 0); -- Recieved data
RX_VALID : in std_logic; -- RX buffer data ready
TX_VALID : out std_logic; -- Data for TX avaible
TX_BUSY : in std_logic; --
RX_BUSY : in std_logic);

end soft;
</source>

|
{{Фио|'''<big></big>Пример поведенческой модели накопителя (Verilog)'''}}

<source lang="cpp">

SC_MODULE (soft_sc_module)
{
public :
sc_in < sc_logic > tx_busy;
sc_in < sc_logic > rx_busy;
sc_in < sc_lv < 8 > > data_out;
sc_in < sc_logic > rx_valid;
sc_out < sc_logic > tx_valid;
sc_out < bool > clk;
sc_out < sc_logic > rst_n;
sc_out < sc_lv < 8 > > data_in;

public:

ifstream fin;

SC_CTOR(soft_sc_module)
: rst_n("rst_n"),
data_in("data_in"),
data_out ("data_out"),
rx_valid("rx_valid"),
tx_valid("tx_valid"),
tx_busy("tx_busy"),
rx_busy("rx_busy"),
rst_n_i("rst_n_i"),
clk_i("clk_i"),
clk("clk")
{
}
~soft_sc_module()
{
delete [] str_b;
}
};

#endif
</source>
|}
</slides>

===Слайд: Architecture ===

<slides split="-----" width="400" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример Архитектуры на VHDL'''}}
<source lang="vhdl">

architecture beh of soft is
file comfile : text open read_mode is comand_file;

begin -- beh
-- тело архитектуры
signal str : string(1 to 1000) := (others => ' ');
signal RST_N_i : std_logic;
signal DATA_IN_i : std_logic_vector(7 downto 0);
signal f_get_answer : boolean := false;
signal tmd : time := 0 ms;

end beh;
</source>

|
{{Фио|'''<big></big>Пример аналогичной конструкции на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public :
std::string comand_file;
public :
sc_signal< sc_logic > rst_n_i;
sc_signal< sc_lv < 8 > > data_in_i;
sc_signal < bool > f_get_answer;
sc_signal < sc_time > tmd;
sc_time btmd (0, SC_MS);
SC_CTOR(soft_sc_module)
:
rst_n_i("rst_n_i"),
data_in_i("data_in_i"),
f_get_answer("f_get_answer"),
tmd("tmd")
{
str = new char [1000];
//объявление функций
//выбор списка чувствительности
//установка значений по умолчанию
tmd.write(btmd);
// tmd = btmd;
//оператор присваивания перегружен и выолнит вызов функции write
}
~soft_sc_module()
{
delete [] str;
}
</source>
|}
</slides>

===Слайд: Generic ===

<slides split="-----" width="400" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
entity soft is
generic (UART_Speed : integer := 115200;
System_CLK : integer := 50000000
);
--
--
--
architecture beh of soft is
CLK_i <= not CLK_i after 1 ns * (1000000000 / System_CLK );
end beh;
</source>

|
{{Фио|'''<big></big>Пример на SystemC (sc_get_param)'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module)
: rst_n("rst_n"),
tmd("tmd")
{
if (!sc_get_param("System_CLK",System_CLK)) cout << "error get generic";
if (!sc_get_param("UART_Speed",UART_Speed)) cout << "error get generic";
period_ns=(1000000000)/System_CLK;
str = new char [1000];
}
~soft_sc_module()
{
delete [] str_b;
}
};
</source>
|}
</slides>

===Слайд: Process без списка чувствительности ===

<slides split="-----" width="400" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
wait_byte_timer: process
begin -- process wiat_timer
wait for 0.5 ms;
if (NOW - tmd) > 1 ms then
if f_start_get_answer then
f_byte_timer <= true;
wait for 0.1 ms;
f_byte_timer <= false;
end if;
end if;
end process wait_byte_timer;
</source>

|
{{Фио|'''<big></big>Пример на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module):
{ SC_METHOD (wait_byte_timer); }
~soft_sc_module()
{ }
};
void soft_sc_module :: wait_byte_timer ()
{
next_trigger (0.5,SC_MS);
if ((sc_time_stamp()-tmd) > sc_time(1, SC_MS) )
if (f_start_get_answer)
{f_byte_timer=true;
next_trigger (0.1,SC_MS);
f_byte_timer=false;
}
cout<< "wait_byte_timer work\n";
}
</source>
|}
</slides>

===Слайд: Process со списком чувствительности (пример 1)===

<slides split="-----" width="400" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
CLK_i <= not CLK_i after 1 ns * (1000000000 / System_CLK );
--или
process (clk)
begin
if clk'event then
clk_i <= not clk_i after 1 ns * (1000000000 / System_CLK );
end if;
end process;
</source>
|
{{Фио|'''<big></big>Пример на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module):
{ clk_i=true;
period_ns=(1000000000)/System_CLK;
SC_METHOD (clk_gen);
}
~soft_sc_module()
{ }
};

void soft_sc_module :: clk_gen ()
{
clk_i.write(!clk_i.read());
next_trigger (period_ns, SC_NS);

}
</source>
|}
</slides>

===Слайд: Process со списком чувствительности (пример 2) ===

<slides split="-----" width="400" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
RST_N <= RST_N_i;
--или
process (RST_N_i)
begin
if RST_N_i'event then
RST_N <= RST_N_i;
end if;
end process;
</source>
|
{{Фио|'''<big></big>Пример на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module):
{ clk_i=true;
SC_METHOD (rst_n_i2rst_n);
sensitive << rst_n_i;
dont_initialize();
}
~soft_sc_module()
{ }
};

void soft_sc_module :: reset_gen ()
{
rst_n_i.write( SC_LOGIC_0 );
wait (100, SC_NS);
cout << "run reset";
rst_n_i.write( SC_LOGIC_1 );
}
</source>
|}
</slides>

===Слайд: Работа с файлами ===
<slides split="-----" width="800" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
p_send : process
variable l : line;
variable byte_r : std_logic_vector(0 to 7);
variable good : boolean;
variable f_first_byte : boolean:=false;
begin -- process p1

loop1: while not endfile(comfile) loop

readline (comfile,l);
skip_space (l);
next loop1 when l'length = 0;

for i in 1 to l'length loop
str(i) <= l(i);
end loop; -- i
str((l'length)+1 to 1000) <= (others => ' ');
str_l <= l'length;
</source>
|
<source lang="vhdl">
if l(1) = '#' then
assert false report "коментарий:"&str(1 to str_l) severity NOTE;
else
assert false report "коментарий"&str(1 to str_l) severity NOTE;
f_first_byte := true;
while l'length /= 0 loop
hread (l,byte_r,good);
assert good report "ошибка" severity FAILURE;
if f_first_byte then
f_first_byte := false;
comand <= byte_r;
end if;
TX_VALID_i <= '1';
DATA_IN_i <= byte_r;
skip_space (l);
wait until TX_BUSY = '1';
end loop;
f_start_timer <= true;
TX_VALID_i <= '0';
wait until f_get_answer or f_timer;
assert not f_timer report "1мкс" severity FAILURE;
f_start_timer <= false;
end if;
end loop;
assert false report "======" severity failure;
end process p_send;
</source>
|}
</slides>

===Слайд: Работа с файлами ===
<slides split="-----" width="800" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на SystemC'''}}
<source lang="cpp">
void soft_sc_module :: p_send ()
{
fin.open(comand_file.c_str(),ios::out);
cout << "work4\n";
bool f_first_byte=false;
if (!fin){
std::cout << "File invalide open";
exit (0);
}
while (!fin.eof()){
fin.getline (str,1000);
skip_space (&(str));
if (strlen(str)){
if (str[0] == '#')
cout << "koment: "<< str <<endl;
else {
cout << "data: "<< str <<endl;
f_first_byte=true;
//while ( str[0] != '\0' ){
while ( strlen(str) ){
if ( str[0] == ' ' )
skip_space(&(str));
else {
//cout << "1/2\n";
byte_b.range(7,4)=str[0];
str++;
skip_space(&(str));
if (!strlen(str)){
cout<<endl<<"error";
sc_stop();
}
else {
//cout << "2/2\n";
byte_b.range(3,0)=str[0];
str++;
}
</source>
|
<source lang="cpp">

if (f_first_byte){
f_first_byte=false;
comand=byte_b;
}
//cout << byte_b << endl;
tx_valid_i.write(SC_LOGIC_1);
data_in.write(byte_b);
wait (tx_busy.posedge_event());
}
}
f_start_timer = true;
tx_valid_i.write(SC_LOGIC_0);
wait ( f_get_answer.posedge_event() | f_timer.posedge_event() );
if ( f_timer ) {cout << "error";sc_stop();}
f_start_timer = false;
}
}
str=str_b;
}
cout << "error";
fin.close();
sc_stop();
}
</source>
|}
</slides>

===Слайд: Работа с переменными ===
===Слайд: Работа с сигналами ===
===Слайд: Арифметические, логические, операции присваивания ===
===Слайд: Конструкции С++ ===
===Слайд: Создание модуля ===
===Слайд: Коммуникации между модулями ===
===Слайд: Управление процессом моделирования (сообщения, запуск останов моделирования)===
== Слайд: Компиляция описания ==
== Слайд: Запуск моделирования только SystemC описания ==
== Слайд: Запуск моделирования SystemC описания и VHDL ==

Спец курс (Избранные главы VHDL)/Верификация описания

2012-11-19T14:13:54Z

164.177.206.33: /* Слайд: Entity */

<slideshow style="custis" headingmark="Слайд:" incmark=":step" scaled="true" >
;title: '''Верификация описания.'''
;author: Зайцев В.С.
</slideshow>

[[Файл:SystemC_From_the_ground_up.mm]]

==Слайд:Верификация описания==
[[Файл:Процевв_верификации.png]]

==Слайд:Верификация описания:step==
*{{Гол|''' <big>Среда моделирования</big>'''}}
** Active-HDL™
** Riviera-PRO™
** NC-Sim®
** ModelSim®
** QuestaSim®
** VCS-MX®
* {{Гол|'''<big>Структура проекта</big>'''}}
** Тестовое окружение
** RTL-модель (Verilog,VHDL)
** Эталонная модель (SystemC)
** Assert'ы (psl, OVVM, UVM)
** Отчеты и базы по результатам моделирования

==Слайд:Эталонная модель на языке ''{{Зел| <big>SystemC</big>}}''==

# Высокий уровень абстракции
# Скорость моделирования
# Возможности языка C++
# Инструменты для автоматизации
# Совместное моделирование с другими HDL-языками

== Основы языка SystemC ==

===Слайд:Типы данных (Форматы и способ представления данных) ===
[[Файл:Типы_данных.png]]

===Слайд:Типы данных (native)===
<source lang="cpp"> // Пример типа данных C++
int spark_offset;
unsigned repairs = 0 ; // Count repair
unsigned long mileage; // Miles driven
short int speedometer; // -20.. 0.. 100 MPH
float temperature; // Engine temp in C
double time_of_last_request; //Time of bus
std:: string license_plate; // Text for license
const bool WARNING_LIGHT = true; // Status
enum compass {SW,W,NW,N,NE,E, SE, S} ;
</source>

===Слайд:Типы данных (Arithmetic)===
<source lang="cpp"> // Пример целочисленных типов данных C++
sc_int<LENGTH> NAME...;
sc_uint<LENGTH> NAME...;
sc_bigint<BITWIDTH> NAME...;
sc_biguint<BITWIDTH> NAME...;
// SystemC integer data types
sc_int<5> seat_position=3; //5 bits: 4 plus sign
sc_uint<13> days_SLOC(4000); //13 bits: no sign
sc_biguint<80> revs_SLOC; // 80 bits: no sign
</source>

===Слайд:Типы данных (Boolean)===
<source lang="cpp"> // Пример типа данных SystemC
sc_bit NAME...;
sc_bv<BITWIDTH> NAME...;
</source>

* sc_bit и sc_bv могут принимать значения: '''SC_LOGIC_1''' и '''SC_LOGIC_0.'''
* Для сокращения типов, можно использовать '''Log_1 и Log_0''' или '''‘1’ и ‘0’.'''
* Над этим типом данных возможно выполнение битовых операций '''and, or, xor (&,|, ^).'''
* Для обращения к отдельным битам и массивам '''[], range()'''.

<source lang="cpp">
sc_bit flag(SC_LOGIC_1); // more efficient to use bool
sc_bv<5> positions = "01101";
sc_bv<6> mask = "100111";
sc_bv<5> active = positions & mask;// 00101
sc_bv<1> all = active. and_reduce (); // SC_LOGIC_0
positions. range (3,2) = "00"; // 00001
positions [2] = active[0] ^ flag;
</source>

===Слайд:Типы данных ( многозначные (ZX10))===
<source lang="cpp"> // Пример типа данных SystemC
sc_logic NAME[,NAME]...;
sc_lv<BITNIDTH> NAME[,NAME ]...;
sc_logic buf(sc_dt::Log_Z);
sc_lv<8> data_drive ("zz01XZ1Z");
data_drive.range (5,4) = "ZZ";// ZZZZXZ1Z
buf = '1';

</source>

===Слайд:Операторы SystemC ===
[[Файл:Операции.png]]

===Слайд:Главный модуль MAIN===
{{Гол|'''<big>Описание на языке C++</big>'''}}
<source lang="cpp">
int main(int argc, char* argv[]) {
BODY_OF_PROGRAM
return EXIT_CODE; //
}
</source>

{{Гол|'''<big>Описание на языке SystemC</big>'''}}
<source lang="cpp">
int sc_main(int argc, char* argv[]) {
//ELABORATION
sc_start(); // <-- Simulation begins & ends
// in this function!
//[POST-PROCESSING]
return EXIT_CODE; //
}
</source>

===Слайд: Модуль ===
<source lang="cpp">
#include <systemc.h>
SC_MODULE(module_name) {
MODULE_BODY
};</source>
Содержит:
* '''{{Фио|<big>Порты</big>}}'''
* '''{{Фио|<big>Каналы связи</big>}}'''
* '''{{Фио|<big>Объявления переменных для хранения данных</big>}}'''
* '''{{Фио|<big>Другие модули с большей вложенностью</big>}}'''
* '''{{Фио|<big>Конструктор</big>}}'''
* '''{{Фио|<big>Деструктор</big>}}'''
* '''{{Фио|<big>Функции -процессы</big>}}'''
* '''{{Фио|<big>Вспомогательные функции</big>}}'''

===Слайд: Конструктор (SC_CTOR)===
<source lang="cpp">SC_CTOR(module_name)
: Initialization // OPTIONAL
{
Subdesign_Allocation
Subdesign_Connectivity
Process_Registration
Miscellaneous_Setup
}</source>

* '''{{Фио|<big>Объявление под модулей</big>}}'''
* '''{{Фио|<big>Подключение и соединение с подмодулями</big>}}'''
* '''{{Фио|<big>Регистрация процессов на SystemC</big>}}'''
* '''{{Фио|<big>Обеспечение постоянной чувствительности</big>}}'''
* '''{{Фио|<big>Разнообразные пользовательские объявления</big>}}''

===Слайд: Конструктор (SC_HAS_PROCESS)===
<source lang="cpp">
//FILE: module_name.h
SC_MODULE(module_name) {
SC_HAS_PROCESS(module_name);
module_name(sc_module_name instname[, other_args…])
: sc_module(instname)
[, other_initializers]
{
CONSTRUCTOR_BODY
}
};</source>

* '''{{Фио|<big>Все возможности конструктора SC_CTOR</big>}}'''
* '''{{Фио|<big>Альтернативный метод создания модуля</big>}}'''
* '''{{Фио|<big>Позволяет создавать конструктор с аргументами(+ к имени модуля)</big>}}'''
* '''{{Фио|<big>Используется, если желаете расположить конструктор в файле описания .cpp (не в файле .h)</big>}}'''

===Слайд: Процесс SC_THREAD ===

<source lang="cpp">
SC_MODULE(simple_process_ex) {
SC_CTOR(simple_process_ex) {
SC_THREAD(my_thread_process);
}
void my_thread_process(void);
};</source>

{{Зел|'''SC_THREAD'''}} в '''SystemC''':
# аналог {{Зел|'''initial block'''}} в '''Verilog'''
# {{Зел|'''process'''}} без списка чувствительности с оператором '''wait()''' в '''VHDL'''.

===Слайд:Введение времени===

{{Ор|<big>'''Единицы измерения времени'''</big>}}

<source lang="cpp">
SC_SEC // seconds
SC_MS // milliseconds
SC_US // microseconds
SC_NS // nanoseconds
SC_PS // picoseconds
SC_FS // femtoseconds
</source>
{{Ор|<big>'''Объявление переменной типа '''</big>}}{{Зел|<big>'''sc_time'''</big>}}
<source lang="cpp">
sc_time t_PERIOD(5, SC_NS) ;
sc_time t_TIMEOUT (100, SC_MS) ;
sc_time t_MEASURE, t_CURRENT, t_LAST_CLOCK;
t_MEASURE = (t_CURRENT-t_LAST_CLOCK) ;
if (t_MEASURE > t_HOLD) { error ("Setup violated") }
</source>

===Слайд:Запуск выполнения '''sc_start()'''===

{{Ор|<big>'''Функция запускающая выполнения главного процесса '''</big>}}

{{Сн|'''Пример запуска моделирования на 60 секунд модельного времени'''}}

<source lang="cpp">
int sc_main(int argc, char* argv[]) { // args unused
simple_process_ex my_instance ("my_instance");
sc_start(60.0,SC_SEC); // Limit sim to one minute
return 0 ;
}</source>

===Слайд:Контроль текущего времени моделирования '''sc_time_stamp ()'''===

<source lang="cpp">
std::cout << " The time is now "
<< sc_time_stamp()
<< "!" << std::endl;</source>

После запуска моделирования в консоли получим
The time is now 0 ns!

===Слайд: Остановка выполнения моделирования wait(sc_time)===

{{Ор|<big>'''Функция останавливающая выполнение процесса до заданного времени или до прихода события'''</big>}}

<source lang="cpp">
void simple_process_ex::my_thread_process (void) {
wait (10,SC_NS);
std::cout<< "Now at "<< sc_time_stamp() << std::endl;
sc_time t_DELAY(2,SC_MS); // keyboard debounce time
t_DELAY *= 2;
std::cout<< "Delaying "<< t_DELAY<< std::endl;
wait(t_DELAY);
std::cout << "Now at " << sc_time_stamp()
<< std::endl;
}</source>

% . /run_example
Now at 10 ns
Delaying 4 ms
Now at 4000010 ns

===Слайд:События '''sc_event'''===
<slides split="-----" width="400" >
[[Файл:Процес_моделирования_по_событиям.png]]
</slides>

===Слайд:События '''SC_THREAD::wait()'''===
Процесс '''SC_THREAD''' процес выполняющийся {{Кр|'''<big>один раз!!</big>'''}}, для управления работой такого процесса используют функцию задержки выполнения wait

<source lang="cpp">wait(time);
wait(event);
wait(event1 | event2) // до прихода любого из событий
wait(event1 & event2) // до прихода всех событий вместе
wait(timeout, event); // до прихода события ожидает в течении времени
wait ( timeout, event1 | event2 )
wait ( timeout, event1 & event2 )
wait(); // ожидание дельта цикла выполнения, статическая задержка
</source>
===Слайд:Запуск события (установка,назначение)===

Для запуска события используется атрибут {{Зел|<big>'''.notify()'''</big>}}

Он выполняет запуск событий, отсчет времени идет от запуска моделирования. Для сброса точки отсчета используют {{Зел|<big>'''.cancel()'''</big>}}

<source lang="cpp">sc_event action;
sc_time now(sc_time_stamp()); //вытягиваем текущее время моделирования
//стартуем событие немедленно
action.notify();
//следующее событие через 20 ms от текущего момента
action.notify(20, SC_MS);
//переопределим событие на время 1.5 ns от текущего момента
action.notify(1.5,SC_NS);
//продублируем событие (не имеет эффекта)
action.notify(1.5, SC_NS);
//зададим событие от предыдущего на 1.5 ns
action.notify(3.0,SC_NS);
//запустим дельта цикл (не имеет эффекта)
action.notify(SC_ZERO_TIME);
//сбросим время задания события
action.cancel();
//зададим событие на 20 fs после сброса
action.notify(20,SC_FS);</source>

===Слайд:Процесс со списком чувствительности SC_METHOD ===
{{ЖЛампа|24px}}Аналог '''process''' в '''VHDL'''

<source lang="cpp">SC_METHOD(process_name);</source>

{{ЖЛампа|24px}}Список чуствительности задаеться после ключевого слова {{Зел|'''sensitive'''}}

<source lang="cpp"> sensitive << event [<< event] ;// поточный стил
sensitive (event [, event] ); // стиль с использованием функции</source>

===Слайд:dont_initialize() ===
{{ЖЛампа|24px}} Отменяет начальную установку значений
* После запуска моделирования конструктор создает модуль и инициализирует все процессы и переменные.

* Это заставляет выполниться всем методам работающим по событию по одному разу во время запуска если событие устанавливалось в значение.

* Для исключения начального выполнения используется функция '''dont_initialize()'''

===Слайд: Стек событий '''sc_event_queue'''===

{{ЖЛампа|24px}} Событие можно задать не только от начального момента времени, а и от текущего.

Для этого используется функция '''sc_event_queue()'''

<source lang="cpp">
sc_event_queue action;
sc_time now(sc_time_stamp());
action.notify(20, SC_MS);
action.notify(1.5,SC_NS);
action.notify(1.5,SC_NS);
action.notify(3.0,SC_NS);
action.notify(SC_ZERO_TIME);
action.notify(1,SC_SEC);
action.cancel_all();
</source>

===Слайд:Совместное использование ресурсов===

* При совместном использовании ресурсов, шин, памяти нужно разграничить область полномочий каждого процесса.
* Иначе при одновременной, к примеру записи будет происходить сбой или некорректная запись.
Если управлением доступом к одному ресурсу
<source lang="cpp">sc_mutex NAME;
// блокируем mutex NAME (ждем пока разблокируется)
NAME.lock();
// Возвращает статус состояния блокировки
NAME.try lock()
// Снимает блокировку
NAME.unlock();</source>

Если управлением доступом к нескольким ресурсам

<source lang="cpp">sc_semaphore NAME(COUNT);
// блокируем mutex NAME (ждем пока разблокируеться)
NAME.wait();
// Возвращает статус состояния блокировки
NAME.trywait()
//Возвращает число свободных ресурсов
NAME.get_value()
// Снимает блокировку
NAME.post();</source>

===Слайд:Иерархия и структура проекта===
[[Файл:Иерархия.png]]

===Слайд:Иерархия и структура проекта (sc_main)===

{{ЖЛампа|24px}}Подключение и создание {{Зел|<big>'''модуля'''</big>}} внутри '''главного''' модуля аналогично созданию {{Зел|<big>'''объекта'''</big>}} заданного{{Зел| <big>'''класса'''</big>}}
{{Фио|<big>'''Стандартная конструкция блока хранения информации для RFID'''</big>}}
{| cellspacing="0" cellpadding="0" border="1"
|
* {{Гол|'''Статический метод'''}}
<source lang="cpp">//FILE: main.cpp
#include "Wheel.h"
int sc_main(int argc, char* argv[]) {
Wheel wheel_FL("wheel_FL");
Wheel wheel_FR("wheel_FR");
sc_start();
}</source>
|
* {{Гол|'''Динамический метод'''}}
<source lang="cpp">//FILE: main.cpp
#include "Wheel.h"
int sc_main(int argc, char* argv[]) {
Wheel* wheel_FL; // pointer to FL wheel
Wheel* wheel_FR; // pointer to FR wheel
wheel_FL = new Wheel ("wheel_FL"); // create FL
wheel_FR = new Wheel ("wheel_FR"); // create FR
sc_start();
delete wheel_FL;
delete wheel_FR;
}</source>
|}

===Слайд:Иерархия и структура проекта (SC_MODULE)===

{{ЖЛампа|24px}}Подключение и создание {{Зел|<big>'''модуля'''</big>}} внутри другого модуля аналогично созданию {{Зел|<big>'''объекта'''</big>}} заданного{{Зел| <big>'''класса'''</big>}}, внутри другого класса. Поэтому объявления производиться в конструкторе верхнего модуля
{| cellspacing="0" cellpadding="0" border="1"
|

* {{Гол|'''Статический метод'''}}
<source lang="cpp">//FILE:Body.h
#include "Wheel.h"
SC_MODULE(Body) {
Wheel wheel_FL;
Wheel wheel_FR;
SC_CTOR(Body)
: wheel_FL("wheel_FL"), //initialization
wheel_FR("wheel_FR") //initialization
{
// other initialization
}
};
}</source>
|
* {{Гол|'''Динамический метод'''}}
<source lang="cpp">//FILE:Body.h
#include "Wheel.h"
SC_MODULE(Body) {
Wheel* wheel_FL;
Wheel* wheel_FR;
SC_CTOR(Body) {
wheel_FL = new Wheel("wheel_FL");
wheel_FR = new Wheel("wheel_FR");
// other initialization
}
};
}</source>
|}

===Слайд:Порты - точки подачи и снятия внешних воздействий===
[[Файл:Порты_соединение_модулей.png]]

===Слайд:Типы портов ===

* {{Сн|'''sc_port'''}} - аналог inout порта в языке VHDL
* {{Сн|'''sc_in'''}} - аналог in порта в языке VHDL
* {{Сн|'''sc_out'''}} - аналог out порта в языке VHDL
* {{Сн|'''sc_export'''}} - внешний порт, порт который позволяет получить доступ к private данным модуля, но иерархически модулю не принадлежит.
{{ЖЛампа|24px}} Механизм использования '''sc_export''' порта напоминает '''доступ к сигналам по иерархии''', как в '''VHDL-2008'''.

===Слайд:Порты - точки подачи и снятия внешних воздействий===
[[Файл:Порты_соединение_модулей_экспорт.png]]
[[Файл:Порты_соединение_модулей_экспорт2.png]]

===Слайд:Управление процессом и контроль статуса моделирования===

== Слайд: VHDL и SystemC конструкции ==
===Слайд: Entity ===

<slides split="-----" width="800" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример поведенческой модели накопителя (VHDL)'''}}
<source lang="vhdl">
entity soft is
generic (UART_Speed : integer := 115200; -- UART Speed
System_CLK : integer := 50000000; -- System CLK in Hz
comand_file : string :="/home/Vidokq/djin18reader/vhd/D18/comfile.txt"
);
port (
CLK : out std_logic; -- system clk
RST_N : out std_logic; -- system reset#
DATA_IN : out std_logic_vector(7 downto 0); -- Transmit data
DATA_OUT : in std_logic_vector(7 downto 0); -- Recieved data
RX_VALID : in std_logic; -- RX buffer data ready
TX_VALID : out std_logic; -- Data for TX avaible
TX_BUSY : in std_logic; --
RX_BUSY : in std_logic);

end soft;
</source>

|
{{Фио|'''<big></big>Пример поведенческой модели накопителя (Verilog)'''}}

<source lang="cpp">

SC_MODULE (soft_sc_module)
{
public :
sc_in < sc_logic > tx_busy;
sc_in < sc_logic > rx_busy;
sc_in < sc_lv < 8 > > data_out;
sc_in < sc_logic > rx_valid;
sc_out < sc_logic > tx_valid;
sc_out < bool > clk;
sc_out < sc_logic > rst_n;
sc_out < sc_lv < 8 > > data_in;

public:

ifstream fin;

SC_CTOR(soft_sc_module)
: rst_n("rst_n"),
data_in("data_in"),
data_out ("data_out"),
rx_valid("rx_valid"),
tx_valid("tx_valid"),
tx_busy("tx_busy"),
rx_busy("rx_busy"),
rst_n_i("rst_n_i"),
clk_i("clk_i"),
clk("clk")
{
}
~soft_sc_module()
{
delete [] str_b;
}
};

#endif
</source>
|}
</slides>

===Слайд: Architecture ===

<slides split="-----" width="400" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример Архитектуры на VHDL'''}}
<source lang="vhdl">

architecture beh of soft is
file comfile : text open read_mode is comand_file;

begin -- beh
-- тело архитектуры
signal str : string(1 to 1000) := (others => ' ');
signal RST_N_i : std_logic;
signal DATA_IN_i : std_logic_vector(7 downto 0);
signal f_get_answer : boolean := false;
signal tmd : time := 0 ms;

end beh;
</source>

|
{{Фио|'''<big></big>Пример аналогичной конструкции на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public :
std::string comand_file;
public :
sc_signal< sc_logic > rst_n_i;
sc_signal< sc_lv < 8 > > data_in_i;
sc_signal < bool > f_get_answer;
sc_signal < sc_time > tmd;
sc_time btmd (0, SC_MS);
SC_CTOR(soft_sc_module)
:
rst_n_i("rst_n_i"),
data_in_i("data_in_i"),
f_get_answer("f_get_answer"),
tmd("tmd")
{
str = new char [1000];
//объявление функций
//выбор списка чувствительности
//установка значений по умолчанию
tmd.write(btmd);
// tmd = btmd;
//оператор присваивания перегружен и выолнит вызов функции write
}
~soft_sc_module()
{
delete [] str;
}
</source>
|}
</slides>

===Слайд: Generic ===

<slides split="-----" width="400" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
entity soft is
generic (UART_Speed : integer := 115200;
System_CLK : integer := 50000000
);
--
--
--
architecture beh of soft is
CLK_i <= not CLK_i after 1 ns * (1000000000 / System_CLK );
end beh;
</source>

|
{{Фио|'''<big></big>Пример на SystemC (sc_get_param)'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module)
: rst_n("rst_n"),
tmd("tmd")
{
if (!sc_get_param("System_CLK",System_CLK)) cout << "error get generic";
if (!sc_get_param("UART_Speed",UART_Speed)) cout << "error get generic";
period_ns=(1000000000)/System_CLK;
str = new char [1000];
}
~soft_sc_module()
{
delete [] str_b;
}
};
</source>
|}
</slides>

===Слайд: Process без списка чувствительности ===

<slides split="-----" width="400" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
wait_byte_timer: process
begin -- process wiat_timer
wait for 0.5 ms;
if (NOW - tmd) > 1 ms then
if f_start_get_answer then
f_byte_timer <= true;
wait for 0.1 ms;
f_byte_timer <= false;
end if;
end if;
end process wait_byte_timer;
</source>

|
{{Фио|'''<big></big>Пример на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module):
{ SC_METHOD (wait_byte_timer); }
~soft_sc_module()
{ }
};
void soft_sc_module :: wait_byte_timer ()
{
next_trigger (0.5,SC_MS);
if ((sc_time_stamp()-tmd) > sc_time(1, SC_MS) )
if (f_start_get_answer)
{f_byte_timer=true;
next_trigger (0.1,SC_MS);
f_byte_timer=false;
}
cout<< "wait_byte_timer work\n";
}
</source>
|}
</slides>

===Слайд: Process со списком чувствительности (пример 1)===

<slides split="-----" width="400" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
CLK_i <= not CLK_i after 1 ns * (1000000000 / System_CLK );
--или
process (clk)
begin
if clk'event then
clk_i <= not clk_i after 1 ns * (1000000000 / System_CLK );
end if;
end process;
</source>
|
{{Фио|'''<big></big>Пример на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module):
{ clk_i=true;
period_ns=(1000000000)/System_CLK;
SC_METHOD (clk_gen);
}
~soft_sc_module()
{ }
};

void soft_sc_module :: clk_gen ()
{
clk_i.write(!clk_i.read());
next_trigger (period_ns, SC_NS);

}
</source>
|}
</slides>

===Слайд: Process со списком чувствительности (пример 2) ===

<slides split="-----" width="400" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
RST_N <= RST_N_i;
--или
process (RST_N_i)
begin
if RST_N_i'event then
RST_N <= RST_N_i;
end if;
end process;
</source>
|
{{Фио|'''<big></big>Пример на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module):
{ clk_i=true;
SC_METHOD (rst_n_i2rst_n);
sensitive << rst_n_i;
dont_initialize();
}
~soft_sc_module()
{ }
};

void soft_sc_module :: reset_gen ()
{
rst_n_i.write( SC_LOGIC_0 );
wait (100, SC_NS);
cout << "run reset";
rst_n_i.write( SC_LOGIC_1 );
}
</source>
|}
</slides>

===Слайд: Работа с файлами ===
<slides split="-----" width="800" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
p_send : process
variable l : line;
variable byte_r : std_logic_vector(0 to 7);
variable good : boolean;
variable f_first_byte : boolean:=false;
begin -- process p1

loop1: while not endfile(comfile) loop

readline (comfile,l);
skip_space (l);
next loop1 when l'length = 0;

for i in 1 to l'length loop
str(i) <= l(i);
end loop; -- i
str((l'length)+1 to 1000) <= (others => ' ');
str_l <= l'length;
</source>
|
<source lang="vhdl">
if l(1) = '#' then
assert false report "коментарий:"&str(1 to str_l) severity NOTE;
else
assert false report "коментарий"&str(1 to str_l) severity NOTE;
f_first_byte := true;
while l'length /= 0 loop
hread (l,byte_r,good);
assert good report "ошибка" severity FAILURE;
if f_first_byte then
f_first_byte := false;
comand <= byte_r;
end if;
TX_VALID_i <= '1';
DATA_IN_i <= byte_r;
skip_space (l);
wait until TX_BUSY = '1';
end loop;
f_start_timer <= true;
TX_VALID_i <= '0';
wait until f_get_answer or f_timer;
assert not f_timer report "1мкс" severity FAILURE;
f_start_timer <= false;
end if;
end loop;
assert false report "======" severity failure;
end process p_send;
</source>
|}
</slides>

===Слайд: Работа с файлами ===
<slides split="-----" width="800" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на SystemC'''}}
<source lang="cpp">
void soft_sc_module :: p_send ()
{
fin.open(comand_file.c_str(),ios::out);
cout << "work4\n";
bool f_first_byte=false;
if (!fin){
std::cout << "File invalide open";
exit (0);
}
while (!fin.eof()){
fin.getline (str,1000);
skip_space (&(str));
if (strlen(str)){
if (str[0] == '#')
cout << "koment: "<< str <<endl;
else {
cout << "data: "<< str <<endl;
f_first_byte=true;
//while ( str[0] != '\0' ){
while ( strlen(str) ){
if ( str[0] == ' ' )
skip_space(&(str));
else {
//cout << "1/2\n";
byte_b.range(7,4)=str[0];
str++;
skip_space(&(str));
if (!strlen(str)){
cout<<endl<<"error";
sc_stop();
}
else {
//cout << "2/2\n";
byte_b.range(3,0)=str[0];
str++;
}
</source>
|
<source lang="cpp">

if (f_first_byte){
f_first_byte=false;
comand=byte_b;
}
//cout << byte_b << endl;
tx_valid_i.write(SC_LOGIC_1);
data_in.write(byte_b);
wait (tx_busy.posedge_event());
}
}
f_start_timer = true;
tx_valid_i.write(SC_LOGIC_0);
wait ( f_get_answer.posedge_event() | f_timer.posedge_event() );
if ( f_timer ) {cout << "error";sc_stop();}
f_start_timer = false;
}
}
str=str_b;
}
cout << "error";
fin.close();
sc_stop();
}
</source>
|}
</slides>

===Слайд: Работа с переменными ===
===Слайд: Работа с сигналами ===
===Слайд: Арифметические, логические, операции присваивания ===
===Слайд: Конструкции С++ ===
===Слайд: Создание модуля ===
===Слайд: Коммуникации между модулями ===
===Слайд: Управление процессом моделирования (сообщения, запуск останов моделирования)===
== Слайд: Компиляция описания ==
== Слайд: Запуск моделирования только SystemC описания ==
== Слайд: Запуск моделирования SystemC описания и VHDL ==

Спец курс (Избранные главы VHDL)/Верификация описания

2012-11-19T14:13:13Z

164.177.206.33: /* Слайд: Работа с файлами */

<slideshow style="custis" headingmark="Слайд:" incmark=":step" scaled="true" >
;title: '''Верификация описания.'''
;author: Зайцев В.С.
</slideshow>

[[Файл:SystemC_From_the_ground_up.mm]]

==Слайд:Верификация описания==
[[Файл:Процевв_верификации.png]]

==Слайд:Верификация описания:step==
*{{Гол|''' <big>Среда моделирования</big>'''}}
** Active-HDL™
** Riviera-PRO™
** NC-Sim®
** ModelSim®
** QuestaSim®
** VCS-MX®
* {{Гол|'''<big>Структура проекта</big>'''}}
** Тестовое окружение
** RTL-модель (Verilog,VHDL)
** Эталонная модель (SystemC)
** Assert'ы (psl, OVVM, UVM)
** Отчеты и базы по результатам моделирования

==Слайд:Эталонная модель на языке ''{{Зел| <big>SystemC</big>}}''==

# Высокий уровень абстракции
# Скорость моделирования
# Возможности языка C++
# Инструменты для автоматизации
# Совместное моделирование с другими HDL-языками

== Основы языка SystemC ==

===Слайд:Типы данных (Форматы и способ представления данных) ===
[[Файл:Типы_данных.png]]

===Слайд:Типы данных (native)===
<source lang="cpp"> // Пример типа данных C++
int spark_offset;
unsigned repairs = 0 ; // Count repair
unsigned long mileage; // Miles driven
short int speedometer; // -20.. 0.. 100 MPH
float temperature; // Engine temp in C
double time_of_last_request; //Time of bus
std:: string license_plate; // Text for license
const bool WARNING_LIGHT = true; // Status
enum compass {SW,W,NW,N,NE,E, SE, S} ;
</source>

===Слайд:Типы данных (Arithmetic)===
<source lang="cpp"> // Пример целочисленных типов данных C++
sc_int<LENGTH> NAME...;
sc_uint<LENGTH> NAME...;
sc_bigint<BITWIDTH> NAME...;
sc_biguint<BITWIDTH> NAME...;
// SystemC integer data types
sc_int<5> seat_position=3; //5 bits: 4 plus sign
sc_uint<13> days_SLOC(4000); //13 bits: no sign
sc_biguint<80> revs_SLOC; // 80 bits: no sign
</source>

===Слайд:Типы данных (Boolean)===
<source lang="cpp"> // Пример типа данных SystemC
sc_bit NAME...;
sc_bv<BITWIDTH> NAME...;
</source>

* sc_bit и sc_bv могут принимать значения: '''SC_LOGIC_1''' и '''SC_LOGIC_0.'''
* Для сокращения типов, можно использовать '''Log_1 и Log_0''' или '''‘1’ и ‘0’.'''
* Над этим типом данных возможно выполнение битовых операций '''and, or, xor (&,|, ^).'''
* Для обращения к отдельным битам и массивам '''[], range()'''.

<source lang="cpp">
sc_bit flag(SC_LOGIC_1); // more efficient to use bool
sc_bv<5> positions = "01101";
sc_bv<6> mask = "100111";
sc_bv<5> active = positions & mask;// 00101
sc_bv<1> all = active. and_reduce (); // SC_LOGIC_0
positions. range (3,2) = "00"; // 00001
positions [2] = active[0] ^ flag;
</source>

===Слайд:Типы данных ( многозначные (ZX10))===
<source lang="cpp"> // Пример типа данных SystemC
sc_logic NAME[,NAME]...;
sc_lv<BITNIDTH> NAME[,NAME ]...;
sc_logic buf(sc_dt::Log_Z);
sc_lv<8> data_drive ("zz01XZ1Z");
data_drive.range (5,4) = "ZZ";// ZZZZXZ1Z
buf = '1';

</source>

===Слайд:Операторы SystemC ===
[[Файл:Операции.png]]

===Слайд:Главный модуль MAIN===
{{Гол|'''<big>Описание на языке C++</big>'''}}
<source lang="cpp">
int main(int argc, char* argv[]) {
BODY_OF_PROGRAM
return EXIT_CODE; //
}
</source>

{{Гол|'''<big>Описание на языке SystemC</big>'''}}
<source lang="cpp">
int sc_main(int argc, char* argv[]) {
//ELABORATION
sc_start(); // <-- Simulation begins & ends
// in this function!
//[POST-PROCESSING]
return EXIT_CODE; //
}
</source>

===Слайд: Модуль ===
<source lang="cpp">
#include <systemc.h>
SC_MODULE(module_name) {
MODULE_BODY
};</source>
Содержит:
* '''{{Фио|<big>Порты</big>}}'''
* '''{{Фио|<big>Каналы связи</big>}}'''
* '''{{Фио|<big>Объявления переменных для хранения данных</big>}}'''
* '''{{Фио|<big>Другие модули с большей вложенностью</big>}}'''
* '''{{Фио|<big>Конструктор</big>}}'''
* '''{{Фио|<big>Деструктор</big>}}'''
* '''{{Фио|<big>Функции -процессы</big>}}'''
* '''{{Фио|<big>Вспомогательные функции</big>}}'''

===Слайд: Конструктор (SC_CTOR)===
<source lang="cpp">SC_CTOR(module_name)
: Initialization // OPTIONAL
{
Subdesign_Allocation
Subdesign_Connectivity
Process_Registration
Miscellaneous_Setup
}</source>

* '''{{Фио|<big>Объявление под модулей</big>}}'''
* '''{{Фио|<big>Подключение и соединение с подмодулями</big>}}'''
* '''{{Фио|<big>Регистрация процессов на SystemC</big>}}'''
* '''{{Фио|<big>Обеспечение постоянной чувствительности</big>}}'''
* '''{{Фио|<big>Разнообразные пользовательские объявления</big>}}''

===Слайд: Конструктор (SC_HAS_PROCESS)===
<source lang="cpp">
//FILE: module_name.h
SC_MODULE(module_name) {
SC_HAS_PROCESS(module_name);
module_name(sc_module_name instname[, other_args…])
: sc_module(instname)
[, other_initializers]
{
CONSTRUCTOR_BODY
}
};</source>

* '''{{Фио|<big>Все возможности конструктора SC_CTOR</big>}}'''
* '''{{Фио|<big>Альтернативный метод создания модуля</big>}}'''
* '''{{Фио|<big>Позволяет создавать конструктор с аргументами(+ к имени модуля)</big>}}'''
* '''{{Фио|<big>Используется, если желаете расположить конструктор в файле описания .cpp (не в файле .h)</big>}}'''

===Слайд: Процесс SC_THREAD ===

<source lang="cpp">
SC_MODULE(simple_process_ex) {
SC_CTOR(simple_process_ex) {
SC_THREAD(my_thread_process);
}
void my_thread_process(void);
};</source>

{{Зел|'''SC_THREAD'''}} в '''SystemC''':
# аналог {{Зел|'''initial block'''}} в '''Verilog'''
# {{Зел|'''process'''}} без списка чувствительности с оператором '''wait()''' в '''VHDL'''.

===Слайд:Введение времени===

{{Ор|<big>'''Единицы измерения времени'''</big>}}

<source lang="cpp">
SC_SEC // seconds
SC_MS // milliseconds
SC_US // microseconds
SC_NS // nanoseconds
SC_PS // picoseconds
SC_FS // femtoseconds
</source>
{{Ор|<big>'''Объявление переменной типа '''</big>}}{{Зел|<big>'''sc_time'''</big>}}
<source lang="cpp">
sc_time t_PERIOD(5, SC_NS) ;
sc_time t_TIMEOUT (100, SC_MS) ;
sc_time t_MEASURE, t_CURRENT, t_LAST_CLOCK;
t_MEASURE = (t_CURRENT-t_LAST_CLOCK) ;
if (t_MEASURE > t_HOLD) { error ("Setup violated") }
</source>

===Слайд:Запуск выполнения '''sc_start()'''===

{{Ор|<big>'''Функция запускающая выполнения главного процесса '''</big>}}

{{Сн|'''Пример запуска моделирования на 60 секунд модельного времени'''}}

<source lang="cpp">
int sc_main(int argc, char* argv[]) { // args unused
simple_process_ex my_instance ("my_instance");
sc_start(60.0,SC_SEC); // Limit sim to one minute
return 0 ;
}</source>

===Слайд:Контроль текущего времени моделирования '''sc_time_stamp ()'''===

<source lang="cpp">
std::cout << " The time is now "
<< sc_time_stamp()
<< "!" << std::endl;</source>

После запуска моделирования в консоли получим
The time is now 0 ns!

===Слайд: Остановка выполнения моделирования wait(sc_time)===

{{Ор|<big>'''Функция останавливающая выполнение процесса до заданного времени или до прихода события'''</big>}}

<source lang="cpp">
void simple_process_ex::my_thread_process (void) {
wait (10,SC_NS);
std::cout<< "Now at "<< sc_time_stamp() << std::endl;
sc_time t_DELAY(2,SC_MS); // keyboard debounce time
t_DELAY *= 2;
std::cout<< "Delaying "<< t_DELAY<< std::endl;
wait(t_DELAY);
std::cout << "Now at " << sc_time_stamp()
<< std::endl;
}</source>

% . /run_example
Now at 10 ns
Delaying 4 ms
Now at 4000010 ns

===Слайд:События '''sc_event'''===
<slides split="-----" width="400" >
[[Файл:Процес_моделирования_по_событиям.png]]
</slides>

===Слайд:События '''SC_THREAD::wait()'''===
Процесс '''SC_THREAD''' процес выполняющийся {{Кр|'''<big>один раз!!</big>'''}}, для управления работой такого процесса используют функцию задержки выполнения wait

<source lang="cpp">wait(time);
wait(event);
wait(event1 | event2) // до прихода любого из событий
wait(event1 & event2) // до прихода всех событий вместе
wait(timeout, event); // до прихода события ожидает в течении времени
wait ( timeout, event1 | event2 )
wait ( timeout, event1 & event2 )
wait(); // ожидание дельта цикла выполнения, статическая задержка
</source>
===Слайд:Запуск события (установка,назначение)===

Для запуска события используется атрибут {{Зел|<big>'''.notify()'''</big>}}

Он выполняет запуск событий, отсчет времени идет от запуска моделирования. Для сброса точки отсчета используют {{Зел|<big>'''.cancel()'''</big>}}

<source lang="cpp">sc_event action;
sc_time now(sc_time_stamp()); //вытягиваем текущее время моделирования
//стартуем событие немедленно
action.notify();
//следующее событие через 20 ms от текущего момента
action.notify(20, SC_MS);
//переопределим событие на время 1.5 ns от текущего момента
action.notify(1.5,SC_NS);
//продублируем событие (не имеет эффекта)
action.notify(1.5, SC_NS);
//зададим событие от предыдущего на 1.5 ns
action.notify(3.0,SC_NS);
//запустим дельта цикл (не имеет эффекта)
action.notify(SC_ZERO_TIME);
//сбросим время задания события
action.cancel();
//зададим событие на 20 fs после сброса
action.notify(20,SC_FS);</source>

===Слайд:Процесс со списком чувствительности SC_METHOD ===
{{ЖЛампа|24px}}Аналог '''process''' в '''VHDL'''

<source lang="cpp">SC_METHOD(process_name);</source>

{{ЖЛампа|24px}}Список чуствительности задаеться после ключевого слова {{Зел|'''sensitive'''}}

<source lang="cpp"> sensitive << event [<< event] ;// поточный стил
sensitive (event [, event] ); // стиль с использованием функции</source>

===Слайд:dont_initialize() ===
{{ЖЛампа|24px}} Отменяет начальную установку значений
* После запуска моделирования конструктор создает модуль и инициализирует все процессы и переменные.

* Это заставляет выполниться всем методам работающим по событию по одному разу во время запуска если событие устанавливалось в значение.

* Для исключения начального выполнения используется функция '''dont_initialize()'''

===Слайд: Стек событий '''sc_event_queue'''===

{{ЖЛампа|24px}} Событие можно задать не только от начального момента времени, а и от текущего.

Для этого используется функция '''sc_event_queue()'''

<source lang="cpp">
sc_event_queue action;
sc_time now(sc_time_stamp());
action.notify(20, SC_MS);
action.notify(1.5,SC_NS);
action.notify(1.5,SC_NS);
action.notify(3.0,SC_NS);
action.notify(SC_ZERO_TIME);
action.notify(1,SC_SEC);
action.cancel_all();
</source>

===Слайд:Совместное использование ресурсов===

* При совместном использовании ресурсов, шин, памяти нужно разграничить область полномочий каждого процесса.
* Иначе при одновременной, к примеру записи будет происходить сбой или некорректная запись.
Если управлением доступом к одному ресурсу
<source lang="cpp">sc_mutex NAME;
// блокируем mutex NAME (ждем пока разблокируется)
NAME.lock();
// Возвращает статус состояния блокировки
NAME.try lock()
// Снимает блокировку
NAME.unlock();</source>

Если управлением доступом к нескольким ресурсам

<source lang="cpp">sc_semaphore NAME(COUNT);
// блокируем mutex NAME (ждем пока разблокируеться)
NAME.wait();
// Возвращает статус состояния блокировки
NAME.trywait()
//Возвращает число свободных ресурсов
NAME.get_value()
// Снимает блокировку
NAME.post();</source>

===Слайд:Иерархия и структура проекта===
[[Файл:Иерархия.png]]

===Слайд:Иерархия и структура проекта (sc_main)===

{{ЖЛампа|24px}}Подключение и создание {{Зел|<big>'''модуля'''</big>}} внутри '''главного''' модуля аналогично созданию {{Зел|<big>'''объекта'''</big>}} заданного{{Зел| <big>'''класса'''</big>}}
{{Фио|<big>'''Стандартная конструкция блока хранения информации для RFID'''</big>}}
{| cellspacing="0" cellpadding="0" border="1"
|
* {{Гол|'''Статический метод'''}}
<source lang="cpp">//FILE: main.cpp
#include "Wheel.h"
int sc_main(int argc, char* argv[]) {
Wheel wheel_FL("wheel_FL");
Wheel wheel_FR("wheel_FR");
sc_start();
}</source>
|
* {{Гол|'''Динамический метод'''}}
<source lang="cpp">//FILE: main.cpp
#include "Wheel.h"
int sc_main(int argc, char* argv[]) {
Wheel* wheel_FL; // pointer to FL wheel
Wheel* wheel_FR; // pointer to FR wheel
wheel_FL = new Wheel ("wheel_FL"); // create FL
wheel_FR = new Wheel ("wheel_FR"); // create FR
sc_start();
delete wheel_FL;
delete wheel_FR;
}</source>
|}

===Слайд:Иерархия и структура проекта (SC_MODULE)===

{{ЖЛампа|24px}}Подключение и создание {{Зел|<big>'''модуля'''</big>}} внутри другого модуля аналогично созданию {{Зел|<big>'''объекта'''</big>}} заданного{{Зел| <big>'''класса'''</big>}}, внутри другого класса. Поэтому объявления производиться в конструкторе верхнего модуля
{| cellspacing="0" cellpadding="0" border="1"
|

* {{Гол|'''Статический метод'''}}
<source lang="cpp">//FILE:Body.h
#include "Wheel.h"
SC_MODULE(Body) {
Wheel wheel_FL;
Wheel wheel_FR;
SC_CTOR(Body)
: wheel_FL("wheel_FL"), //initialization
wheel_FR("wheel_FR") //initialization
{
// other initialization
}
};
}</source>
|
* {{Гол|'''Динамический метод'''}}
<source lang="cpp">//FILE:Body.h
#include "Wheel.h"
SC_MODULE(Body) {
Wheel* wheel_FL;
Wheel* wheel_FR;
SC_CTOR(Body) {
wheel_FL = new Wheel("wheel_FL");
wheel_FR = new Wheel("wheel_FR");
// other initialization
}
};
}</source>
|}

===Слайд:Порты - точки подачи и снятия внешних воздействий===
[[Файл:Порты_соединение_модулей.png]]

===Слайд:Типы портов ===

* {{Сн|'''sc_port'''}} - аналог inout порта в языке VHDL
* {{Сн|'''sc_in'''}} - аналог in порта в языке VHDL
* {{Сн|'''sc_out'''}} - аналог out порта в языке VHDL
* {{Сн|'''sc_export'''}} - внешний порт, порт который позволяет получить доступ к private данным модуля, но иерархически модулю не принадлежит.
{{ЖЛампа|24px}} Механизм использования '''sc_export''' порта напоминает '''доступ к сигналам по иерархии''', как в '''VHDL-2008'''.

===Слайд:Порты - точки подачи и снятия внешних воздействий===
[[Файл:Порты_соединение_модулей_экспорт.png]]
[[Файл:Порты_соединение_модулей_экспорт2.png]]

===Слайд:Управление процессом и контроль статуса моделирования===

== Слайд: VHDL и SystemC конструкции ==
===Слайд: Entity ===

<slides split="-----" width="400" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример поведенческой модели накопителя (VHDL)'''}}
<source lang="vhdl">
entity soft is
generic (UART_Speed : integer := 115200; -- UART Speed
System_CLK : integer := 50000000; -- System CLK in Hz
comand_file : string :="/home/Vidokq/djin18reader/vhd/D18/comfile.txt"
);
port (
CLK : out std_logic; -- system clk
RST_N : out std_logic; -- system reset#
DATA_IN : out std_logic_vector(7 downto 0); -- Transmit data
DATA_OUT : in std_logic_vector(7 downto 0); -- Recieved data
RX_VALID : in std_logic; -- RX buffer data ready
TX_VALID : out std_logic; -- Data for TX avaible
TX_BUSY : in std_logic; --
RX_BUSY : in std_logic);

end soft;
</source>

|
{{Фио|'''<big></big>Пример поведенческой модели накопителя (Verilog)'''}}

<source lang="cpp">

SC_MODULE (soft_sc_module)
{
public :
sc_in < sc_logic > tx_busy;
sc_in < sc_logic > rx_busy;
sc_in < sc_lv < 8 > > data_out;
sc_in < sc_logic > rx_valid;
sc_out < sc_logic > tx_valid;
sc_out < bool > clk;
sc_out < sc_logic > rst_n;
sc_out < sc_lv < 8 > > data_in;

public:

ifstream fin;

SC_CTOR(soft_sc_module)
: rst_n("rst_n"),
data_in("data_in"),
data_out ("data_out"),
rx_valid("rx_valid"),
tx_valid("tx_valid"),
tx_busy("tx_busy"),
rx_busy("rx_busy"),
rst_n_i("rst_n_i"),
clk_i("clk_i"),
clk("clk")
{
}
~soft_sc_module()
{
delete [] str_b;
}
};

#endif
</source>
|}
</slides>

===Слайд: Architecture ===

<slides split="-----" width="400" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример Архитектуры на VHDL'''}}
<source lang="vhdl">

architecture beh of soft is
file comfile : text open read_mode is comand_file;

begin -- beh
-- тело архитектуры
signal str : string(1 to 1000) := (others => ' ');
signal RST_N_i : std_logic;
signal DATA_IN_i : std_logic_vector(7 downto 0);
signal f_get_answer : boolean := false;
signal tmd : time := 0 ms;

end beh;
</source>

|
{{Фио|'''<big></big>Пример аналогичной конструкции на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public :
std::string comand_file;
public :
sc_signal< sc_logic > rst_n_i;
sc_signal< sc_lv < 8 > > data_in_i;
sc_signal < bool > f_get_answer;
sc_signal < sc_time > tmd;
sc_time btmd (0, SC_MS);
SC_CTOR(soft_sc_module)
:
rst_n_i("rst_n_i"),
data_in_i("data_in_i"),
f_get_answer("f_get_answer"),
tmd("tmd")
{
str = new char [1000];
//объявление функций
//выбор списка чувствительности
//установка значений по умолчанию
tmd.write(btmd);
// tmd = btmd;
//оператор присваивания перегружен и выолнит вызов функции write
}
~soft_sc_module()
{
delete [] str;
}
</source>
|}
</slides>

===Слайд: Generic ===

<slides split="-----" width="400" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
entity soft is
generic (UART_Speed : integer := 115200;
System_CLK : integer := 50000000
);
--
--
--
architecture beh of soft is
CLK_i <= not CLK_i after 1 ns * (1000000000 / System_CLK );
end beh;
</source>

|
{{Фио|'''<big></big>Пример на SystemC (sc_get_param)'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module)
: rst_n("rst_n"),
tmd("tmd")
{
if (!sc_get_param("System_CLK",System_CLK)) cout << "error get generic";
if (!sc_get_param("UART_Speed",UART_Speed)) cout << "error get generic";
period_ns=(1000000000)/System_CLK;
str = new char [1000];
}
~soft_sc_module()
{
delete [] str_b;
}
};
</source>
|}
</slides>

===Слайд: Process без списка чувствительности ===

<slides split="-----" width="400" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
wait_byte_timer: process
begin -- process wiat_timer
wait for 0.5 ms;
if (NOW - tmd) > 1 ms then
if f_start_get_answer then
f_byte_timer <= true;
wait for 0.1 ms;
f_byte_timer <= false;
end if;
end if;
end process wait_byte_timer;
</source>

|
{{Фио|'''<big></big>Пример на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module):
{ SC_METHOD (wait_byte_timer); }
~soft_sc_module()
{ }
};
void soft_sc_module :: wait_byte_timer ()
{
next_trigger (0.5,SC_MS);
if ((sc_time_stamp()-tmd) > sc_time(1, SC_MS) )
if (f_start_get_answer)
{f_byte_timer=true;
next_trigger (0.1,SC_MS);
f_byte_timer=false;
}
cout<< "wait_byte_timer work\n";
}
</source>
|}
</slides>

===Слайд: Process со списком чувствительности (пример 1)===

<slides split="-----" width="400" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
CLK_i <= not CLK_i after 1 ns * (1000000000 / System_CLK );
--или
process (clk)
begin
if clk'event then
clk_i <= not clk_i after 1 ns * (1000000000 / System_CLK );
end if;
end process;
</source>
|
{{Фио|'''<big></big>Пример на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module):
{ clk_i=true;
period_ns=(1000000000)/System_CLK;
SC_METHOD (clk_gen);
}
~soft_sc_module()
{ }
};

void soft_sc_module :: clk_gen ()
{
clk_i.write(!clk_i.read());
next_trigger (period_ns, SC_NS);

}
</source>
|}
</slides>

===Слайд: Process со списком чувствительности (пример 2) ===

<slides split="-----" width="400" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
RST_N <= RST_N_i;
--или
process (RST_N_i)
begin
if RST_N_i'event then
RST_N <= RST_N_i;
end if;
end process;
</source>
|
{{Фио|'''<big></big>Пример на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module):
{ clk_i=true;
SC_METHOD (rst_n_i2rst_n);
sensitive << rst_n_i;
dont_initialize();
}
~soft_sc_module()
{ }
};

void soft_sc_module :: reset_gen ()
{
rst_n_i.write( SC_LOGIC_0 );
wait (100, SC_NS);
cout << "run reset";
rst_n_i.write( SC_LOGIC_1 );
}
</source>
|}
</slides>

===Слайд: Работа с файлами ===
<slides split="-----" width="800" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
p_send : process
variable l : line;
variable byte_r : std_logic_vector(0 to 7);
variable good : boolean;
variable f_first_byte : boolean:=false;
begin -- process p1

loop1: while not endfile(comfile) loop

readline (comfile,l);
skip_space (l);
next loop1 when l'length = 0;

for i in 1 to l'length loop
str(i) <= l(i);
end loop; -- i
str((l'length)+1 to 1000) <= (others => ' ');
str_l <= l'length;
</source>
|
<source lang="vhdl">
if l(1) = '#' then
assert false report "коментарий:"&str(1 to str_l) severity NOTE;
else
assert false report "коментарий"&str(1 to str_l) severity NOTE;
f_first_byte := true;
while l'length /= 0 loop
hread (l,byte_r,good);
assert good report "ошибка" severity FAILURE;
if f_first_byte then
f_first_byte := false;
comand <= byte_r;
end if;
TX_VALID_i <= '1';
DATA_IN_i <= byte_r;
skip_space (l);
wait until TX_BUSY = '1';
end loop;
f_start_timer <= true;
TX_VALID_i <= '0';
wait until f_get_answer or f_timer;
assert not f_timer report "1мкс" severity FAILURE;
f_start_timer <= false;
end if;
end loop;
assert false report "======" severity failure;
end process p_send;
</source>
|}
</slides>

===Слайд: Работа с файлами ===
<slides split="-----" width="800" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на SystemC'''}}
<source lang="cpp">
void soft_sc_module :: p_send ()
{
fin.open(comand_file.c_str(),ios::out);
cout << "work4\n";
bool f_first_byte=false;
if (!fin){
std::cout << "File invalide open";
exit (0);
}
while (!fin.eof()){
fin.getline (str,1000);
skip_space (&(str));
if (strlen(str)){
if (str[0] == '#')
cout << "koment: "<< str <<endl;
else {
cout << "data: "<< str <<endl;
f_first_byte=true;
//while ( str[0] != '\0' ){
while ( strlen(str) ){
if ( str[0] == ' ' )
skip_space(&(str));
else {
//cout << "1/2\n";
byte_b.range(7,4)=str[0];
str++;
skip_space(&(str));
if (!strlen(str)){
cout<<endl<<"error";
sc_stop();
}
else {
//cout << "2/2\n";
byte_b.range(3,0)=str[0];
str++;
}
</source>
|
<source lang="cpp">

if (f_first_byte){
f_first_byte=false;
comand=byte_b;
}
//cout << byte_b << endl;
tx_valid_i.write(SC_LOGIC_1);
data_in.write(byte_b);
wait (tx_busy.posedge_event());
}
}
f_start_timer = true;
tx_valid_i.write(SC_LOGIC_0);
wait ( f_get_answer.posedge_event() | f_timer.posedge_event() );
if ( f_timer ) {cout << "error";sc_stop();}
f_start_timer = false;
}
}
str=str_b;
}
cout << "error";
fin.close();
sc_stop();
}
</source>
|}
</slides>

===Слайд: Работа с переменными ===
===Слайд: Работа с сигналами ===
===Слайд: Арифметические, логические, операции присваивания ===
===Слайд: Конструкции С++ ===
===Слайд: Создание модуля ===
===Слайд: Коммуникации между модулями ===
===Слайд: Управление процессом моделирования (сообщения, запуск останов моделирования)===
== Слайд: Компиляция описания ==
== Слайд: Запуск моделирования только SystemC описания ==
== Слайд: Запуск моделирования SystemC описания и VHDL ==

Спец курс (Избранные главы VHDL)/Верификация описания

2012-11-19T14:01:28Z

164.177.206.33: /* Слайд: Process со списком чувствительности */

<slideshow style="custis" headingmark="Слайд:" incmark=":step" scaled="true" >
;title: '''Верификация описания.'''
;author: Зайцев В.С.
</slideshow>

[[Файл:SystemC_From_the_ground_up.mm]]

==Слайд:Верификация описания==
[[Файл:Процевв_верификации.png]]

==Слайд:Верификация описания:step==
*{{Гол|''' <big>Среда моделирования</big>'''}}
** Active-HDL™
** Riviera-PRO™
** NC-Sim®
** ModelSim®
** QuestaSim®
** VCS-MX®
* {{Гол|'''<big>Структура проекта</big>'''}}
** Тестовое окружение
** RTL-модель (Verilog,VHDL)
** Эталонная модель (SystemC)
** Assert'ы (psl, OVVM, UVM)
** Отчеты и базы по результатам моделирования

==Слайд:Эталонная модель на языке ''{{Зел| <big>SystemC</big>}}''==

# Высокий уровень абстракции
# Скорость моделирования
# Возможности языка C++
# Инструменты для автоматизации
# Совместное моделирование с другими HDL-языками

== Основы языка SystemC ==

===Слайд:Типы данных (Форматы и способ представления данных) ===
[[Файл:Типы_данных.png]]

===Слайд:Типы данных (native)===
<source lang="cpp"> // Пример типа данных C++
int spark_offset;
unsigned repairs = 0 ; // Count repair
unsigned long mileage; // Miles driven
short int speedometer; // -20.. 0.. 100 MPH
float temperature; // Engine temp in C
double time_of_last_request; //Time of bus
std:: string license_plate; // Text for license
const bool WARNING_LIGHT = true; // Status
enum compass {SW,W,NW,N,NE,E, SE, S} ;
</source>

===Слайд:Типы данных (Arithmetic)===
<source lang="cpp"> // Пример целочисленных типов данных C++
sc_int<LENGTH> NAME...;
sc_uint<LENGTH> NAME...;
sc_bigint<BITWIDTH> NAME...;
sc_biguint<BITWIDTH> NAME...;
// SystemC integer data types
sc_int<5> seat_position=3; //5 bits: 4 plus sign
sc_uint<13> days_SLOC(4000); //13 bits: no sign
sc_biguint<80> revs_SLOC; // 80 bits: no sign
</source>

===Слайд:Типы данных (Boolean)===
<source lang="cpp"> // Пример типа данных SystemC
sc_bit NAME...;
sc_bv<BITWIDTH> NAME...;
</source>

* sc_bit и sc_bv могут принимать значения: '''SC_LOGIC_1''' и '''SC_LOGIC_0.'''
* Для сокращения типов, можно использовать '''Log_1 и Log_0''' или '''‘1’ и ‘0’.'''
* Над этим типом данных возможно выполнение битовых операций '''and, or, xor (&,|, ^).'''
* Для обращения к отдельным битам и массивам '''[], range()'''.

<source lang="cpp">
sc_bit flag(SC_LOGIC_1); // more efficient to use bool
sc_bv<5> positions = "01101";
sc_bv<6> mask = "100111";
sc_bv<5> active = positions & mask;// 00101
sc_bv<1> all = active. and_reduce (); // SC_LOGIC_0
positions. range (3,2) = "00"; // 00001
positions [2] = active[0] ^ flag;
</source>

===Слайд:Типы данных ( многозначные (ZX10))===
<source lang="cpp"> // Пример типа данных SystemC
sc_logic NAME[,NAME]...;
sc_lv<BITNIDTH> NAME[,NAME ]...;
sc_logic buf(sc_dt::Log_Z);
sc_lv<8> data_drive ("zz01XZ1Z");
data_drive.range (5,4) = "ZZ";// ZZZZXZ1Z
buf = '1';

</source>

===Слайд:Операторы SystemC ===
[[Файл:Операции.png]]

===Слайд:Главный модуль MAIN===
{{Гол|'''<big>Описание на языке C++</big>'''}}
<source lang="cpp">
int main(int argc, char* argv[]) {
BODY_OF_PROGRAM
return EXIT_CODE; //
}
</source>

{{Гол|'''<big>Описание на языке SystemC</big>'''}}
<source lang="cpp">
int sc_main(int argc, char* argv[]) {
//ELABORATION
sc_start(); // <-- Simulation begins & ends
// in this function!
//[POST-PROCESSING]
return EXIT_CODE; //
}
</source>

===Слайд: Модуль ===
<source lang="cpp">
#include <systemc.h>
SC_MODULE(module_name) {
MODULE_BODY
};</source>
Содержит:
* '''{{Фио|<big>Порты</big>}}'''
* '''{{Фио|<big>Каналы связи</big>}}'''
* '''{{Фио|<big>Объявления переменных для хранения данных</big>}}'''
* '''{{Фио|<big>Другие модули с большей вложенностью</big>}}'''
* '''{{Фио|<big>Конструктор</big>}}'''
* '''{{Фио|<big>Деструктор</big>}}'''
* '''{{Фио|<big>Функции -процессы</big>}}'''
* '''{{Фио|<big>Вспомогательные функции</big>}}'''

===Слайд: Конструктор (SC_CTOR)===
<source lang="cpp">SC_CTOR(module_name)
: Initialization // OPTIONAL
{
Subdesign_Allocation
Subdesign_Connectivity
Process_Registration
Miscellaneous_Setup
}</source>

* '''{{Фио|<big>Объявление под модулей</big>}}'''
* '''{{Фио|<big>Подключение и соединение с подмодулями</big>}}'''
* '''{{Фио|<big>Регистрация процессов на SystemC</big>}}'''
* '''{{Фио|<big>Обеспечение постоянной чувствительности</big>}}'''
* '''{{Фио|<big>Разнообразные пользовательские объявления</big>}}''

===Слайд: Конструктор (SC_HAS_PROCESS)===
<source lang="cpp">
//FILE: module_name.h
SC_MODULE(module_name) {
SC_HAS_PROCESS(module_name);
module_name(sc_module_name instname[, other_args…])
: sc_module(instname)
[, other_initializers]
{
CONSTRUCTOR_BODY
}
};</source>

* '''{{Фио|<big>Все возможности конструктора SC_CTOR</big>}}'''
* '''{{Фио|<big>Альтернативный метод создания модуля</big>}}'''
* '''{{Фио|<big>Позволяет создавать конструктор с аргументами(+ к имени модуля)</big>}}'''
* '''{{Фио|<big>Используется, если желаете расположить конструктор в файле описания .cpp (не в файле .h)</big>}}'''

===Слайд: Процесс SC_THREAD ===

<source lang="cpp">
SC_MODULE(simple_process_ex) {
SC_CTOR(simple_process_ex) {
SC_THREAD(my_thread_process);
}
void my_thread_process(void);
};</source>

{{Зел|'''SC_THREAD'''}} в '''SystemC''':
# аналог {{Зел|'''initial block'''}} в '''Verilog'''
# {{Зел|'''process'''}} без списка чувствительности с оператором '''wait()''' в '''VHDL'''.

===Слайд:Введение времени===

{{Ор|<big>'''Единицы измерения времени'''</big>}}

<source lang="cpp">
SC_SEC // seconds
SC_MS // milliseconds
SC_US // microseconds
SC_NS // nanoseconds
SC_PS // picoseconds
SC_FS // femtoseconds
</source>
{{Ор|<big>'''Объявление переменной типа '''</big>}}{{Зел|<big>'''sc_time'''</big>}}
<source lang="cpp">
sc_time t_PERIOD(5, SC_NS) ;
sc_time t_TIMEOUT (100, SC_MS) ;
sc_time t_MEASURE, t_CURRENT, t_LAST_CLOCK;
t_MEASURE = (t_CURRENT-t_LAST_CLOCK) ;
if (t_MEASURE > t_HOLD) { error ("Setup violated") }
</source>

===Слайд:Запуск выполнения '''sc_start()'''===

{{Ор|<big>'''Функция запускающая выполнения главного процесса '''</big>}}

{{Сн|'''Пример запуска моделирования на 60 секунд модельного времени'''}}

<source lang="cpp">
int sc_main(int argc, char* argv[]) { // args unused
simple_process_ex my_instance ("my_instance");
sc_start(60.0,SC_SEC); // Limit sim to one minute
return 0 ;
}</source>

===Слайд:Контроль текущего времени моделирования '''sc_time_stamp ()'''===

<source lang="cpp">
std::cout << " The time is now "
<< sc_time_stamp()
<< "!" << std::endl;</source>

После запуска моделирования в консоли получим
The time is now 0 ns!

===Слайд: Остановка выполнения моделирования wait(sc_time)===

{{Ор|<big>'''Функция останавливающая выполнение процесса до заданного времени или до прихода события'''</big>}}

<source lang="cpp">
void simple_process_ex::my_thread_process (void) {
wait (10,SC_NS);
std::cout<< "Now at "<< sc_time_stamp() << std::endl;
sc_time t_DELAY(2,SC_MS); // keyboard debounce time
t_DELAY *= 2;
std::cout<< "Delaying "<< t_DELAY<< std::endl;
wait(t_DELAY);
std::cout << "Now at " << sc_time_stamp()
<< std::endl;
}</source>

% . /run_example
Now at 10 ns
Delaying 4 ms
Now at 4000010 ns

===Слайд:События '''sc_event'''===
<slides split="-----" width="400" >
[[Файл:Процес_моделирования_по_событиям.png]]
</slides>

===Слайд:События '''SC_THREAD::wait()'''===
Процесс '''SC_THREAD''' процес выполняющийся {{Кр|'''<big>один раз!!</big>'''}}, для управления работой такого процесса используют функцию задержки выполнения wait

<source lang="cpp">wait(time);
wait(event);
wait(event1 | event2) // до прихода любого из событий
wait(event1 & event2) // до прихода всех событий вместе
wait(timeout, event); // до прихода события ожидает в течении времени
wait ( timeout, event1 | event2 )
wait ( timeout, event1 & event2 )
wait(); // ожидание дельта цикла выполнения, статическая задержка
</source>
===Слайд:Запуск события (установка,назначение)===

Для запуска события используется атрибут {{Зел|<big>'''.notify()'''</big>}}

Он выполняет запуск событий, отсчет времени идет от запуска моделирования. Для сброса точки отсчета используют {{Зел|<big>'''.cancel()'''</big>}}

<source lang="cpp">sc_event action;
sc_time now(sc_time_stamp()); //вытягиваем текущее время моделирования
//стартуем событие немедленно
action.notify();
//следующее событие через 20 ms от текущего момента
action.notify(20, SC_MS);
//переопределим событие на время 1.5 ns от текущего момента
action.notify(1.5,SC_NS);
//продублируем событие (не имеет эффекта)
action.notify(1.5, SC_NS);
//зададим событие от предыдущего на 1.5 ns
action.notify(3.0,SC_NS);
//запустим дельта цикл (не имеет эффекта)
action.notify(SC_ZERO_TIME);
//сбросим время задания события
action.cancel();
//зададим событие на 20 fs после сброса
action.notify(20,SC_FS);</source>

===Слайд:Процесс со списком чувствительности SC_METHOD ===
{{ЖЛампа|24px}}Аналог '''process''' в '''VHDL'''

<source lang="cpp">SC_METHOD(process_name);</source>

{{ЖЛампа|24px}}Список чуствительности задаеться после ключевого слова {{Зел|'''sensitive'''}}

<source lang="cpp"> sensitive << event [<< event] ;// поточный стил
sensitive (event [, event] ); // стиль с использованием функции</source>

===Слайд:dont_initialize() ===
{{ЖЛампа|24px}} Отменяет начальную установку значений
* После запуска моделирования конструктор создает модуль и инициализирует все процессы и переменные.

* Это заставляет выполниться всем методам работающим по событию по одному разу во время запуска если событие устанавливалось в значение.

* Для исключения начального выполнения используется функция '''dont_initialize()'''

===Слайд: Стек событий '''sc_event_queue'''===

{{ЖЛампа|24px}} Событие можно задать не только от начального момента времени, а и от текущего.

Для этого используется функция '''sc_event_queue()'''

<source lang="cpp">
sc_event_queue action;
sc_time now(sc_time_stamp());
action.notify(20, SC_MS);
action.notify(1.5,SC_NS);
action.notify(1.5,SC_NS);
action.notify(3.0,SC_NS);
action.notify(SC_ZERO_TIME);
action.notify(1,SC_SEC);
action.cancel_all();
</source>

===Слайд:Совместное использование ресурсов===

* При совместном использовании ресурсов, шин, памяти нужно разграничить область полномочий каждого процесса.
* Иначе при одновременной, к примеру записи будет происходить сбой или некорректная запись.
Если управлением доступом к одному ресурсу
<source lang="cpp">sc_mutex NAME;
// блокируем mutex NAME (ждем пока разблокируется)
NAME.lock();
// Возвращает статус состояния блокировки
NAME.try lock()
// Снимает блокировку
NAME.unlock();</source>

Если управлением доступом к нескольким ресурсам

<source lang="cpp">sc_semaphore NAME(COUNT);
// блокируем mutex NAME (ждем пока разблокируеться)
NAME.wait();
// Возвращает статус состояния блокировки
NAME.trywait()
//Возвращает число свободных ресурсов
NAME.get_value()
// Снимает блокировку
NAME.post();</source>

===Слайд:Иерархия и структура проекта===
[[Файл:Иерархия.png]]

===Слайд:Иерархия и структура проекта (sc_main)===

{{ЖЛампа|24px}}Подключение и создание {{Зел|<big>'''модуля'''</big>}} внутри '''главного''' модуля аналогично созданию {{Зел|<big>'''объекта'''</big>}} заданного{{Зел| <big>'''класса'''</big>}}
{{Фио|<big>'''Стандартная конструкция блока хранения информации для RFID'''</big>}}
{| cellspacing="0" cellpadding="0" border="1"
|
* {{Гол|'''Статический метод'''}}
<source lang="cpp">//FILE: main.cpp
#include "Wheel.h"
int sc_main(int argc, char* argv[]) {
Wheel wheel_FL("wheel_FL");
Wheel wheel_FR("wheel_FR");
sc_start();
}</source>
|
* {{Гол|'''Динамический метод'''}}
<source lang="cpp">//FILE: main.cpp
#include "Wheel.h"
int sc_main(int argc, char* argv[]) {
Wheel* wheel_FL; // pointer to FL wheel
Wheel* wheel_FR; // pointer to FR wheel
wheel_FL = new Wheel ("wheel_FL"); // create FL
wheel_FR = new Wheel ("wheel_FR"); // create FR
sc_start();
delete wheel_FL;
delete wheel_FR;
}</source>
|}

===Слайд:Иерархия и структура проекта (SC_MODULE)===

{{ЖЛампа|24px}}Подключение и создание {{Зел|<big>'''модуля'''</big>}} внутри другого модуля аналогично созданию {{Зел|<big>'''объекта'''</big>}} заданного{{Зел| <big>'''класса'''</big>}}, внутри другого класса. Поэтому объявления производиться в конструкторе верхнего модуля
{| cellspacing="0" cellpadding="0" border="1"
|

* {{Гол|'''Статический метод'''}}
<source lang="cpp">//FILE:Body.h
#include "Wheel.h"
SC_MODULE(Body) {
Wheel wheel_FL;
Wheel wheel_FR;
SC_CTOR(Body)
: wheel_FL("wheel_FL"), //initialization
wheel_FR("wheel_FR") //initialization
{
// other initialization
}
};
}</source>
|
* {{Гол|'''Динамический метод'''}}
<source lang="cpp">//FILE:Body.h
#include "Wheel.h"
SC_MODULE(Body) {
Wheel* wheel_FL;
Wheel* wheel_FR;
SC_CTOR(Body) {
wheel_FL = new Wheel("wheel_FL");
wheel_FR = new Wheel("wheel_FR");
// other initialization
}
};
}</source>
|}

===Слайд:Порты - точки подачи и снятия внешних воздействий===
[[Файл:Порты_соединение_модулей.png]]

===Слайд:Типы портов ===

* {{Сн|'''sc_port'''}} - аналог inout порта в языке VHDL
* {{Сн|'''sc_in'''}} - аналог in порта в языке VHDL
* {{Сн|'''sc_out'''}} - аналог out порта в языке VHDL
* {{Сн|'''sc_export'''}} - внешний порт, порт который позволяет получить доступ к private данным модуля, но иерархически модулю не принадлежит.
{{ЖЛампа|24px}} Механизм использования '''sc_export''' порта напоминает '''доступ к сигналам по иерархии''', как в '''VHDL-2008'''.

===Слайд:Порты - точки подачи и снятия внешних воздействий===
[[Файл:Порты_соединение_модулей_экспорт.png]]
[[Файл:Порты_соединение_модулей_экспорт2.png]]

===Слайд:Управление процессом и контроль статуса моделирования===

== Слайд: VHDL и SystemC конструкции ==
===Слайд: Entity ===

<slides split="-----" width="400" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример поведенческой модели накопителя (VHDL)'''}}
<source lang="vhdl">
entity soft is
generic (UART_Speed : integer := 115200; -- UART Speed
System_CLK : integer := 50000000; -- System CLK in Hz
comand_file : string :="/home/Vidokq/djin18reader/vhd/D18/comfile.txt"
);
port (
CLK : out std_logic; -- system clk
RST_N : out std_logic; -- system reset#
DATA_IN : out std_logic_vector(7 downto 0); -- Transmit data
DATA_OUT : in std_logic_vector(7 downto 0); -- Recieved data
RX_VALID : in std_logic; -- RX buffer data ready
TX_VALID : out std_logic; -- Data for TX avaible
TX_BUSY : in std_logic; --
RX_BUSY : in std_logic);

end soft;
</source>

|
{{Фио|'''<big></big>Пример поведенческой модели накопителя (Verilog)'''}}

<source lang="cpp">

SC_MODULE (soft_sc_module)
{
public :
sc_in < sc_logic > tx_busy;
sc_in < sc_logic > rx_busy;
sc_in < sc_lv < 8 > > data_out;
sc_in < sc_logic > rx_valid;
sc_out < sc_logic > tx_valid;
sc_out < bool > clk;
sc_out < sc_logic > rst_n;
sc_out < sc_lv < 8 > > data_in;

public:

ifstream fin;

SC_CTOR(soft_sc_module)
: rst_n("rst_n"),
data_in("data_in"),
data_out ("data_out"),
rx_valid("rx_valid"),
tx_valid("tx_valid"),
tx_busy("tx_busy"),
rx_busy("rx_busy"),
rst_n_i("rst_n_i"),
clk_i("clk_i"),
clk("clk")
{
}
~soft_sc_module()
{
delete [] str_b;
}
};

#endif
</source>
|}
</slides>

===Слайд: Architecture ===

<slides split="-----" width="400" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример Архитектуры на VHDL'''}}
<source lang="vhdl">

architecture beh of soft is
file comfile : text open read_mode is comand_file;

begin -- beh
-- тело архитектуры
signal str : string(1 to 1000) := (others => ' ');
signal RST_N_i : std_logic;
signal DATA_IN_i : std_logic_vector(7 downto 0);
signal f_get_answer : boolean := false;
signal tmd : time := 0 ms;

end beh;
</source>

|
{{Фио|'''<big></big>Пример аналогичной конструкции на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public :
std::string comand_file;
public :
sc_signal< sc_logic > rst_n_i;
sc_signal< sc_lv < 8 > > data_in_i;
sc_signal < bool > f_get_answer;
sc_signal < sc_time > tmd;
sc_time btmd (0, SC_MS);
SC_CTOR(soft_sc_module)
:
rst_n_i("rst_n_i"),
data_in_i("data_in_i"),
f_get_answer("f_get_answer"),
tmd("tmd")
{
str = new char [1000];
//объявление функций
//выбор списка чувствительности
//установка значений по умолчанию
tmd.write(btmd);
// tmd = btmd;
//оператор присваивания перегружен и выолнит вызов функции write
}
~soft_sc_module()
{
delete [] str;
}
</source>
|}
</slides>

===Слайд: Generic ===

<slides split="-----" width="400" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
entity soft is
generic (UART_Speed : integer := 115200;
System_CLK : integer := 50000000
);
--
--
--
architecture beh of soft is
CLK_i <= not CLK_i after 1 ns * (1000000000 / System_CLK );
end beh;
</source>

|
{{Фио|'''<big></big>Пример на SystemC (sc_get_param)'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module)
: rst_n("rst_n"),
tmd("tmd")
{
if (!sc_get_param("System_CLK",System_CLK)) cout << "error get generic";
if (!sc_get_param("UART_Speed",UART_Speed)) cout << "error get generic";
period_ns=(1000000000)/System_CLK;
str = new char [1000];
}
~soft_sc_module()
{
delete [] str_b;
}
};
</source>
|}
</slides>

===Слайд: Process без списка чувствительности ===

<slides split="-----" width="400" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
wait_byte_timer: process
begin -- process wiat_timer
wait for 0.5 ms;
if (NOW - tmd) > 1 ms then
if f_start_get_answer then
f_byte_timer <= true;
wait for 0.1 ms;
f_byte_timer <= false;
end if;
end if;
end process wait_byte_timer;
</source>

|
{{Фио|'''<big></big>Пример на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module):
{ SC_METHOD (wait_byte_timer); }
~soft_sc_module()
{ }
};
void soft_sc_module :: wait_byte_timer ()
{
next_trigger (0.5,SC_MS);
if ((sc_time_stamp()-tmd) > sc_time(1, SC_MS) )
if (f_start_get_answer)
{f_byte_timer=true;
next_trigger (0.1,SC_MS);
f_byte_timer=false;
}
cout<< "wait_byte_timer work\n";
}
</source>
|}
</slides>

===Слайд: Process со списком чувствительности (пример 1)===

<slides split="-----" width="400" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
CLK_i <= not CLK_i after 1 ns * (1000000000 / System_CLK );
--или
process (clk)
begin
if clk'event then
clk_i <= not clk_i after 1 ns * (1000000000 / System_CLK );
end if;
end process;
</source>
|
{{Фио|'''<big></big>Пример на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module):
{ clk_i=true;
period_ns=(1000000000)/System_CLK;
SC_METHOD (clk_gen);
}
~soft_sc_module()
{ }
};

void soft_sc_module :: clk_gen ()
{
clk_i.write(!clk_i.read());
next_trigger (period_ns, SC_NS);

}
</source>
|}
</slides>

===Слайд: Process со списком чувствительности (пример 2) ===

<slides split="-----" width="400" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
RST_N <= RST_N_i;
--или
process (RST_N_i)
begin
if RST_N_i'event then
RST_N <= RST_N_i;
end if;
end process;
</source>
|
{{Фио|'''<big></big>Пример на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module):
{ clk_i=true;
SC_METHOD (rst_n_i2rst_n);
sensitive << rst_n_i;
dont_initialize();
}
~soft_sc_module()
{ }
};

void soft_sc_module :: reset_gen ()
{
rst_n_i.write( SC_LOGIC_0 );
wait (100, SC_NS);
cout << "run reset";
rst_n_i.write( SC_LOGIC_1 );
}
</source>
|}
</slides>

===Слайд: Работа с файлами ===
===Слайд: Работа с переменными ===
===Слайд: Работа с сигналами ===
===Слайд: Арифметические, логические, операции присваивания ===
===Слайд: Конструкции С++ ===
===Слайд: Создание модуля ===
===Слайд: Коммуникации между модулями ===
===Слайд: Управление процессом моделирования (сообщения, запуск останов моделирования)===
== Слайд: Компиляция описания ==
== Слайд: Запуск моделирования только SystemC описания ==
== Слайд: Запуск моделирования SystemC описания и VHDL ==

Спец курс (Избранные главы VHDL)/Верификация описания

2012-11-19T13:46:19Z

164.177.206.33: /* Слайд: Process без списка чувствительности */

<slideshow style="custis" headingmark="Слайд:" incmark=":step" scaled="true" >
;title: '''Верификация описания.'''
;author: Зайцев В.С.
</slideshow>

[[Файл:SystemC_From_the_ground_up.mm]]

==Слайд:Верификация описания==
[[Файл:Процевв_верификации.png]]

==Слайд:Верификация описания:step==
*{{Гол|''' <big>Среда моделирования</big>'''}}
** Active-HDL™
** Riviera-PRO™
** NC-Sim®
** ModelSim®
** QuestaSim®
** VCS-MX®
* {{Гол|'''<big>Структура проекта</big>'''}}
** Тестовое окружение
** RTL-модель (Verilog,VHDL)
** Эталонная модель (SystemC)
** Assert'ы (psl, OVVM, UVM)
** Отчеты и базы по результатам моделирования

==Слайд:Эталонная модель на языке ''{{Зел| <big>SystemC</big>}}''==

# Высокий уровень абстракции
# Скорость моделирования
# Возможности языка C++
# Инструменты для автоматизации
# Совместное моделирование с другими HDL-языками

== Основы языка SystemC ==

===Слайд:Типы данных (Форматы и способ представления данных) ===
[[Файл:Типы_данных.png]]

===Слайд:Типы данных (native)===
<source lang="cpp"> // Пример типа данных C++
int spark_offset;
unsigned repairs = 0 ; // Count repair
unsigned long mileage; // Miles driven
short int speedometer; // -20.. 0.. 100 MPH
float temperature; // Engine temp in C
double time_of_last_request; //Time of bus
std:: string license_plate; // Text for license
const bool WARNING_LIGHT = true; // Status
enum compass {SW,W,NW,N,NE,E, SE, S} ;
</source>

===Слайд:Типы данных (Arithmetic)===
<source lang="cpp"> // Пример целочисленных типов данных C++
sc_int<LENGTH> NAME...;
sc_uint<LENGTH> NAME...;
sc_bigint<BITWIDTH> NAME...;
sc_biguint<BITWIDTH> NAME...;
// SystemC integer data types
sc_int<5> seat_position=3; //5 bits: 4 plus sign
sc_uint<13> days_SLOC(4000); //13 bits: no sign
sc_biguint<80> revs_SLOC; // 80 bits: no sign
</source>

===Слайд:Типы данных (Boolean)===
<source lang="cpp"> // Пример типа данных SystemC
sc_bit NAME...;
sc_bv<BITWIDTH> NAME...;
</source>

* sc_bit и sc_bv могут принимать значения: '''SC_LOGIC_1''' и '''SC_LOGIC_0.'''
* Для сокращения типов, можно использовать '''Log_1 и Log_0''' или '''‘1’ и ‘0’.'''
* Над этим типом данных возможно выполнение битовых операций '''and, or, xor (&,|, ^).'''
* Для обращения к отдельным битам и массивам '''[], range()'''.

<source lang="cpp">
sc_bit flag(SC_LOGIC_1); // more efficient to use bool
sc_bv<5> positions = "01101";
sc_bv<6> mask = "100111";
sc_bv<5> active = positions & mask;// 00101
sc_bv<1> all = active. and_reduce (); // SC_LOGIC_0
positions. range (3,2) = "00"; // 00001
positions [2] = active[0] ^ flag;
</source>

===Слайд:Типы данных ( многозначные (ZX10))===
<source lang="cpp"> // Пример типа данных SystemC
sc_logic NAME[,NAME]...;
sc_lv<BITNIDTH> NAME[,NAME ]...;
sc_logic buf(sc_dt::Log_Z);
sc_lv<8> data_drive ("zz01XZ1Z");
data_drive.range (5,4) = "ZZ";// ZZZZXZ1Z
buf = '1';

</source>

===Слайд:Операторы SystemC ===
[[Файл:Операции.png]]

===Слайд:Главный модуль MAIN===
{{Гол|'''<big>Описание на языке C++</big>'''}}
<source lang="cpp">
int main(int argc, char* argv[]) {
BODY_OF_PROGRAM
return EXIT_CODE; //
}
</source>

{{Гол|'''<big>Описание на языке SystemC</big>'''}}
<source lang="cpp">
int sc_main(int argc, char* argv[]) {
//ELABORATION
sc_start(); // <-- Simulation begins & ends
// in this function!
//[POST-PROCESSING]
return EXIT_CODE; //
}
</source>

===Слайд: Модуль ===
<source lang="cpp">
#include <systemc.h>
SC_MODULE(module_name) {
MODULE_BODY
};</source>
Содержит:
* '''{{Фио|<big>Порты</big>}}'''
* '''{{Фио|<big>Каналы связи</big>}}'''
* '''{{Фио|<big>Объявления переменных для хранения данных</big>}}'''
* '''{{Фио|<big>Другие модули с большей вложенностью</big>}}'''
* '''{{Фио|<big>Конструктор</big>}}'''
* '''{{Фио|<big>Деструктор</big>}}'''
* '''{{Фио|<big>Функции -процессы</big>}}'''
* '''{{Фио|<big>Вспомогательные функции</big>}}'''

===Слайд: Конструктор (SC_CTOR)===
<source lang="cpp">SC_CTOR(module_name)
: Initialization // OPTIONAL
{
Subdesign_Allocation
Subdesign_Connectivity
Process_Registration
Miscellaneous_Setup
}</source>

* '''{{Фио|<big>Объявление под модулей</big>}}'''
* '''{{Фио|<big>Подключение и соединение с подмодулями</big>}}'''
* '''{{Фио|<big>Регистрация процессов на SystemC</big>}}'''
* '''{{Фио|<big>Обеспечение постоянной чувствительности</big>}}'''
* '''{{Фио|<big>Разнообразные пользовательские объявления</big>}}''

===Слайд: Конструктор (SC_HAS_PROCESS)===
<source lang="cpp">
//FILE: module_name.h
SC_MODULE(module_name) {
SC_HAS_PROCESS(module_name);
module_name(sc_module_name instname[, other_args…])
: sc_module(instname)
[, other_initializers]
{
CONSTRUCTOR_BODY
}
};</source>

* '''{{Фио|<big>Все возможности конструктора SC_CTOR</big>}}'''
* '''{{Фио|<big>Альтернативный метод создания модуля</big>}}'''
* '''{{Фио|<big>Позволяет создавать конструктор с аргументами(+ к имени модуля)</big>}}'''
* '''{{Фио|<big>Используется, если желаете расположить конструктор в файле описания .cpp (не в файле .h)</big>}}'''

===Слайд: Процесс SC_THREAD ===

<source lang="cpp">
SC_MODULE(simple_process_ex) {
SC_CTOR(simple_process_ex) {
SC_THREAD(my_thread_process);
}
void my_thread_process(void);
};</source>

{{Зел|'''SC_THREAD'''}} в '''SystemC''':
# аналог {{Зел|'''initial block'''}} в '''Verilog'''
# {{Зел|'''process'''}} без списка чувствительности с оператором '''wait()''' в '''VHDL'''.

===Слайд:Введение времени===

{{Ор|<big>'''Единицы измерения времени'''</big>}}

<source lang="cpp">
SC_SEC // seconds
SC_MS // milliseconds
SC_US // microseconds
SC_NS // nanoseconds
SC_PS // picoseconds
SC_FS // femtoseconds
</source>
{{Ор|<big>'''Объявление переменной типа '''</big>}}{{Зел|<big>'''sc_time'''</big>}}
<source lang="cpp">
sc_time t_PERIOD(5, SC_NS) ;
sc_time t_TIMEOUT (100, SC_MS) ;
sc_time t_MEASURE, t_CURRENT, t_LAST_CLOCK;
t_MEASURE = (t_CURRENT-t_LAST_CLOCK) ;
if (t_MEASURE > t_HOLD) { error ("Setup violated") }
</source>

===Слайд:Запуск выполнения '''sc_start()'''===

{{Ор|<big>'''Функция запускающая выполнения главного процесса '''</big>}}

{{Сн|'''Пример запуска моделирования на 60 секунд модельного времени'''}}

<source lang="cpp">
int sc_main(int argc, char* argv[]) { // args unused
simple_process_ex my_instance ("my_instance");
sc_start(60.0,SC_SEC); // Limit sim to one minute
return 0 ;
}</source>

===Слайд:Контроль текущего времени моделирования '''sc_time_stamp ()'''===

<source lang="cpp">
std::cout << " The time is now "
<< sc_time_stamp()
<< "!" << std::endl;</source>

После запуска моделирования в консоли получим
The time is now 0 ns!

===Слайд: Остановка выполнения моделирования wait(sc_time)===

{{Ор|<big>'''Функция останавливающая выполнение процесса до заданного времени или до прихода события'''</big>}}

<source lang="cpp">
void simple_process_ex::my_thread_process (void) {
wait (10,SC_NS);
std::cout<< "Now at "<< sc_time_stamp() << std::endl;
sc_time t_DELAY(2,SC_MS); // keyboard debounce time
t_DELAY *= 2;
std::cout<< "Delaying "<< t_DELAY<< std::endl;
wait(t_DELAY);
std::cout << "Now at " << sc_time_stamp()
<< std::endl;
}</source>

% . /run_example
Now at 10 ns
Delaying 4 ms
Now at 4000010 ns

===Слайд:События '''sc_event'''===
<slides split="-----" width="400" >
[[Файл:Процес_моделирования_по_событиям.png]]
</slides>

===Слайд:События '''SC_THREAD::wait()'''===
Процесс '''SC_THREAD''' процес выполняющийся {{Кр|'''<big>один раз!!</big>'''}}, для управления работой такого процесса используют функцию задержки выполнения wait

<source lang="cpp">wait(time);
wait(event);
wait(event1 | event2) // до прихода любого из событий
wait(event1 & event2) // до прихода всех событий вместе
wait(timeout, event); // до прихода события ожидает в течении времени
wait ( timeout, event1 | event2 )
wait ( timeout, event1 & event2 )
wait(); // ожидание дельта цикла выполнения, статическая задержка
</source>
===Слайд:Запуск события (установка,назначение)===

Для запуска события используется атрибут {{Зел|<big>'''.notify()'''</big>}}

Он выполняет запуск событий, отсчет времени идет от запуска моделирования. Для сброса точки отсчета используют {{Зел|<big>'''.cancel()'''</big>}}

<source lang="cpp">sc_event action;
sc_time now(sc_time_stamp()); //вытягиваем текущее время моделирования
//стартуем событие немедленно
action.notify();
//следующее событие через 20 ms от текущего момента
action.notify(20, SC_MS);
//переопределим событие на время 1.5 ns от текущего момента
action.notify(1.5,SC_NS);
//продублируем событие (не имеет эффекта)
action.notify(1.5, SC_NS);
//зададим событие от предыдущего на 1.5 ns
action.notify(3.0,SC_NS);
//запустим дельта цикл (не имеет эффекта)
action.notify(SC_ZERO_TIME);
//сбросим время задания события
action.cancel();
//зададим событие на 20 fs после сброса
action.notify(20,SC_FS);</source>

===Слайд:Процесс со списком чувствительности SC_METHOD ===
{{ЖЛампа|24px}}Аналог '''process''' в '''VHDL'''

<source lang="cpp">SC_METHOD(process_name);</source>

{{ЖЛампа|24px}}Список чуствительности задаеться после ключевого слова {{Зел|'''sensitive'''}}

<source lang="cpp"> sensitive << event [<< event] ;// поточный стил
sensitive (event [, event] ); // стиль с использованием функции</source>

===Слайд:dont_initialize() ===
{{ЖЛампа|24px}} Отменяет начальную установку значений
* После запуска моделирования конструктор создает модуль и инициализирует все процессы и переменные.

* Это заставляет выполниться всем методам работающим по событию по одному разу во время запуска если событие устанавливалось в значение.

* Для исключения начального выполнения используется функция '''dont_initialize()'''

===Слайд: Стек событий '''sc_event_queue'''===

{{ЖЛампа|24px}} Событие можно задать не только от начального момента времени, а и от текущего.

Для этого используется функция '''sc_event_queue()'''

<source lang="cpp">
sc_event_queue action;
sc_time now(sc_time_stamp());
action.notify(20, SC_MS);
action.notify(1.5,SC_NS);
action.notify(1.5,SC_NS);
action.notify(3.0,SC_NS);
action.notify(SC_ZERO_TIME);
action.notify(1,SC_SEC);
action.cancel_all();
</source>

===Слайд:Совместное использование ресурсов===

* При совместном использовании ресурсов, шин, памяти нужно разграничить область полномочий каждого процесса.
* Иначе при одновременной, к примеру записи будет происходить сбой или некорректная запись.
Если управлением доступом к одному ресурсу
<source lang="cpp">sc_mutex NAME;
// блокируем mutex NAME (ждем пока разблокируется)
NAME.lock();
// Возвращает статус состояния блокировки
NAME.try lock()
// Снимает блокировку
NAME.unlock();</source>

Если управлением доступом к нескольким ресурсам

<source lang="cpp">sc_semaphore NAME(COUNT);
// блокируем mutex NAME (ждем пока разблокируеться)
NAME.wait();
// Возвращает статус состояния блокировки
NAME.trywait()
//Возвращает число свободных ресурсов
NAME.get_value()
// Снимает блокировку
NAME.post();</source>

===Слайд:Иерархия и структура проекта===
[[Файл:Иерархия.png]]

===Слайд:Иерархия и структура проекта (sc_main)===

{{ЖЛампа|24px}}Подключение и создание {{Зел|<big>'''модуля'''</big>}} внутри '''главного''' модуля аналогично созданию {{Зел|<big>'''объекта'''</big>}} заданного{{Зел| <big>'''класса'''</big>}}
{{Фио|<big>'''Стандартная конструкция блока хранения информации для RFID'''</big>}}
{| cellspacing="0" cellpadding="0" border="1"
|
* {{Гол|'''Статический метод'''}}
<source lang="cpp">//FILE: main.cpp
#include "Wheel.h"
int sc_main(int argc, char* argv[]) {
Wheel wheel_FL("wheel_FL");
Wheel wheel_FR("wheel_FR");
sc_start();
}</source>
|
* {{Гол|'''Динамический метод'''}}
<source lang="cpp">//FILE: main.cpp
#include "Wheel.h"
int sc_main(int argc, char* argv[]) {
Wheel* wheel_FL; // pointer to FL wheel
Wheel* wheel_FR; // pointer to FR wheel
wheel_FL = new Wheel ("wheel_FL"); // create FL
wheel_FR = new Wheel ("wheel_FR"); // create FR
sc_start();
delete wheel_FL;
delete wheel_FR;
}</source>
|}

===Слайд:Иерархия и структура проекта (SC_MODULE)===

{{ЖЛампа|24px}}Подключение и создание {{Зел|<big>'''модуля'''</big>}} внутри другого модуля аналогично созданию {{Зел|<big>'''объекта'''</big>}} заданного{{Зел| <big>'''класса'''</big>}}, внутри другого класса. Поэтому объявления производиться в конструкторе верхнего модуля
{| cellspacing="0" cellpadding="0" border="1"
|

* {{Гол|'''Статический метод'''}}
<source lang="cpp">//FILE:Body.h
#include "Wheel.h"
SC_MODULE(Body) {
Wheel wheel_FL;
Wheel wheel_FR;
SC_CTOR(Body)
: wheel_FL("wheel_FL"), //initialization
wheel_FR("wheel_FR") //initialization
{
// other initialization
}
};
}</source>
|
* {{Гол|'''Динамический метод'''}}
<source lang="cpp">//FILE:Body.h
#include "Wheel.h"
SC_MODULE(Body) {
Wheel* wheel_FL;
Wheel* wheel_FR;
SC_CTOR(Body) {
wheel_FL = new Wheel("wheel_FL");
wheel_FR = new Wheel("wheel_FR");
// other initialization
}
};
}</source>
|}

===Слайд:Порты - точки подачи и снятия внешних воздействий===
[[Файл:Порты_соединение_модулей.png]]

===Слайд:Типы портов ===

* {{Сн|'''sc_port'''}} - аналог inout порта в языке VHDL
* {{Сн|'''sc_in'''}} - аналог in порта в языке VHDL
* {{Сн|'''sc_out'''}} - аналог out порта в языке VHDL
* {{Сн|'''sc_export'''}} - внешний порт, порт который позволяет получить доступ к private данным модуля, но иерархически модулю не принадлежит.
{{ЖЛампа|24px}} Механизм использования '''sc_export''' порта напоминает '''доступ к сигналам по иерархии''', как в '''VHDL-2008'''.

===Слайд:Порты - точки подачи и снятия внешних воздействий===
[[Файл:Порты_соединение_модулей_экспорт.png]]
[[Файл:Порты_соединение_модулей_экспорт2.png]]

===Слайд:Управление процессом и контроль статуса моделирования===

== Слайд: VHDL и SystemC конструкции ==
===Слайд: Entity ===

<slides split="-----" width="400" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример поведенческой модели накопителя (VHDL)'''}}
<source lang="vhdl">
entity soft is
generic (UART_Speed : integer := 115200; -- UART Speed
System_CLK : integer := 50000000; -- System CLK in Hz
comand_file : string :="/home/Vidokq/djin18reader/vhd/D18/comfile.txt"
);
port (
CLK : out std_logic; -- system clk
RST_N : out std_logic; -- system reset#
DATA_IN : out std_logic_vector(7 downto 0); -- Transmit data
DATA_OUT : in std_logic_vector(7 downto 0); -- Recieved data
RX_VALID : in std_logic; -- RX buffer data ready
TX_VALID : out std_logic; -- Data for TX avaible
TX_BUSY : in std_logic; --
RX_BUSY : in std_logic);

end soft;
</source>

|
{{Фио|'''<big></big>Пример поведенческой модели накопителя (Verilog)'''}}

<source lang="cpp">

SC_MODULE (soft_sc_module)
{
public :
sc_in < sc_logic > tx_busy;
sc_in < sc_logic > rx_busy;
sc_in < sc_lv < 8 > > data_out;
sc_in < sc_logic > rx_valid;
sc_out < sc_logic > tx_valid;
sc_out < bool > clk;
sc_out < sc_logic > rst_n;
sc_out < sc_lv < 8 > > data_in;

public:

ifstream fin;

SC_CTOR(soft_sc_module)
: rst_n("rst_n"),
data_in("data_in"),
data_out ("data_out"),
rx_valid("rx_valid"),
tx_valid("tx_valid"),
tx_busy("tx_busy"),
rx_busy("rx_busy"),
rst_n_i("rst_n_i"),
clk_i("clk_i"),
clk("clk")
{
}
~soft_sc_module()
{
delete [] str_b;
}
};

#endif
</source>
|}
</slides>

===Слайд: Architecture ===

<slides split="-----" width="400" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример Архитектуры на VHDL'''}}
<source lang="vhdl">

architecture beh of soft is
file comfile : text open read_mode is comand_file;

begin -- beh
-- тело архитектуры
signal str : string(1 to 1000) := (others => ' ');
signal RST_N_i : std_logic;
signal DATA_IN_i : std_logic_vector(7 downto 0);
signal f_get_answer : boolean := false;
signal tmd : time := 0 ms;

end beh;
</source>

|
{{Фио|'''<big></big>Пример аналогичной конструкции на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public :
std::string comand_file;
public :
sc_signal< sc_logic > rst_n_i;
sc_signal< sc_lv < 8 > > data_in_i;
sc_signal < bool > f_get_answer;
sc_signal < sc_time > tmd;
sc_time btmd (0, SC_MS);
SC_CTOR(soft_sc_module)
:
rst_n_i("rst_n_i"),
data_in_i("data_in_i"),
f_get_answer("f_get_answer"),
tmd("tmd")
{
str = new char [1000];
//объявление функций
//выбор списка чувствительности
//установка значений по умолчанию
tmd.write(btmd);
// tmd = btmd;
//оператор присваивания перегружен и выолнит вызов функции write
}
~soft_sc_module()
{
delete [] str;
}
</source>
|}
</slides>

===Слайд: Generic ===

<slides split="-----" width="400" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
entity soft is
generic (UART_Speed : integer := 115200;
System_CLK : integer := 50000000
);
--
--
--
architecture beh of soft is
CLK_i <= not CLK_i after 1 ns * (1000000000 / System_CLK );
end beh;
</source>

|
{{Фио|'''<big></big>Пример на SystemC (sc_get_param)'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module)
: rst_n("rst_n"),
tmd("tmd")
{
if (!sc_get_param("System_CLK",System_CLK)) cout << "error get generic";
if (!sc_get_param("UART_Speed",UART_Speed)) cout << "error get generic";
period_ns=(1000000000)/System_CLK;
str = new char [1000];
}
~soft_sc_module()
{
delete [] str_b;
}
};
</source>
|}
</slides>

===Слайд: Process без списка чувствительности ===

<slides split="-----" width="400" >
{| cellspacing="0" cellpadding="0" border="1"
|
{{Фио|'''<big></big>Пример на VHDL'''}}
<source lang="vhdl">
wait_byte_timer: process
begin -- process wiat_timer
wait for 0.5 ms;
if (NOW - tmd) > 1 ms then
if f_start_get_answer then
f_byte_timer <= true;
wait for 0.1 ms;
f_byte_timer <= false;
end if;
end if;
end process wait_byte_timer;
</source>

|
{{Фио|'''<big></big>Пример на SystemC'''}}

<source lang="cpp">
SC_MODULE (soft_sc_module)
{
public:
SC_CTOR(soft_sc_module):
{ SC_METHOD (wait_byte_timer); }
~soft_sc_module()
{ }
};
void soft_sc_module :: wait_byte_timer ()
{
next_trigger (0.5,SC_MS);
if ((sc_time_stamp()-tmd) > sc_time(1, SC_MS) )
if (f_start_get_answer)
{f_byte_timer=true;
next_trigger (0.1,SC_MS);
f_byte_timer=false;
}
cout<< "wait_byte_timer work\n";
}
</source>
|}
</slides>

===Слайд: Process со списком чувствительности ===
===Слайд: Работа с файлами ===
===Слайд: Работа с переменными ===
===Слайд: Работа с сигналами ===
===Слайд: Арифметические, логические, операции присваивания ===
===Слайд: Конструкции С++ ===
===Слайд: Создание модуля ===
===Слайд: Коммуникации между модулями ===
===Слайд: Управление процессом моделирования (сообщения, запуск останов моделирования)===
== Слайд: Компиляция описания ==
== Слайд: Запуск моделирования только SystemC описания ==
== Слайд: Запуск моделирования SystemC описания и VHDL ==