{"draftJsState":{"blocks":[{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":29,"offset":407,"style":"BOLD"},{"length":9,"offset":1140,"style":"BOLD"},{"length":15,"offset":1865,"style":"BOLD"},{"length":4,"offset":3080,"style":"BOLD"}],"text":"Verilator — это инструмент, который компилирует исходные коды Verilog и SystemVerilog в высокооптимизированный (и, возможно, многопоточный) циклически точный код C++ или SystemC. Преобразованные модули можно создавать и использовать в тестовом стенде C++ или SystemC для проверки и/или моделирования. \n\nДополнительную информацию можно найти на официальном сайте Verilator и в официальном руководстве.\n\nЗачем использовать Verilator?\n Verilator — это, по сути, симулятор Verilog/SystemVerilog. Это коммерческий продукт, сверхбыстрый, бесплатный и с открытым исходным кодом, но он не является прямой заменой Modelsim, Questa Sim, Synopsys VCS, Vivado Xsim и других симуляторов, основанных на событиях. Verilator — это симулятор, основанный на циклах, что означает, что он не оценивает время в пределах одного тактового цикла и не имитирует точную синхронизацию схемы. Вместо этого состояние схемы обычно оценивается один раз за такт, поэтому любые внутрипериодные сбои не наблюдаются, а временные задержки сигнала не поддерживаются. Это имеет как преимущества, так и недостатки при сравнении Verilator с другими симуляторами.\n\nСкорость \nПоскольку Verilator основан на циклах, его нельзя использовать для временной симуляции, списков соединений с обратными аннотациями, асинхронной (бестактовой) логики или вообще любых изменений сигнала, которые включают понятие времени - все выходы переключаются мгновенно всякий раз, когда оценивается схема. \nОднако, поскольку все, что находится между фронтами тактовых импульсов, игнорируется, симуляции Verilator выполняются очень быстро и отлично подходят для имитации функциональности синхронных цифровых логических схем с одним или несколькими тактовыми генераторами или для создания программных моделей из вашего кода Verilog/SystemVerilog для использования в разработке программного обеспечения.\n\nКачество кода \nПоскольку верилятор основан на циклах, он не может полностью поддерживать стандарты IEEE Verilog и SystemVerilog. Но не волнуйтесь, инструменты синтеза, как правило, также не полностью совместимы. \nСледовательно, Verilator очень строго относится к коду Verilog/SystemVerilog, который вы ему предоставляете. Помимо того, что он не поддерживает никаких временных задержек, он также не будет принимать большую часть несинтезируемого кода*, поэтому (как правило) вы не можете просто взять свой тестовый стенд SystemVerilog и построить его с помощью Verilator без каких-либо существенных модификаций. Вы быстро узнаете, не поддерживает ли Verilator ваш код, так как он будет бомбардировать вас кучей предупреждений и сообщений об ошибках. \nПоскольку Verilator не поддерживает несинтезируемый код, неожиданное преимущество заключается в том, что он ближе к поведению инструментов синтеза по сравнению с другими симуляторами. Это заставит вас писать более качественный код для синтеза, потенциально уменьшив количество проблем, с которыми вы столкнетесь позже в процессе разработки. * за исключением таких вещей, как $display(), $finish(), $fatal(), некоторых версий $assert и других.\n\nЦена\nVerilator имеет открытый исходный код и бесплатен как бесплатное пиво, так и свобода слова. Для имитации проекта с помощью Verilator из проверенного HDL-кода и тестового стенда C++ с помощью GCC и Make создается собственный двоичный исполняемый файл. Поскольку вся цепочка инструментов бесплатна, нет ограничений на количество экземпляров, которые вы можете запускать, или количество пользователей, которые могут ее использовать. Благодаря скорости Verilator моделирование еще более сложных проектов выполняется быстро на старых машинах и ноутбуках, поэтому вам не нужно покупать дорогостоящее вычислительное оборудование. Отлично подходит для студентов! \nОднако не позволяйте цене обмануть вас. Verilator также имеет широкий круг коммерческих пользователей:","type":"unstyled","key":"8fdlq"},{"data":{"image":{"id":"652ce5207a8a8e15f8cde84f"}},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"atomic:image","key":"6bgqe"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":18,"offset":0,"style":"BOLD"}],"text":"Приступая к работе","type":"unstyled","key":"93un1"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Это руководство написано для тех, кто в первую очередь знает Verilog/Systemverilog и немного C/C++, но никогда не использовал Verilator. Я предполагаю, что вы используете какую-то форму Linux в своей системе и в указанной системе установлены Verilator, GTKWave, Make и GCC. Вы можете получить готовые исходные коды для примера проекта Verilator, используемого в этом руководстве, на Github и изучить его по своему усмотрению:","type":"unstyled","key":"1413m"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":28,"offset":148,"style":"BOLD"}],"text":"git clone https://github.com/n-kremeris/verilator_basics\ngit checkout verilator_pt1\n\nИли следуйте инструкциям ниже, пока мы настраиваем все с нуля.\n\nНаше тестируемое устройство\nЧтобы проверить, как работает Verilator, нам понадобится какое-то DUT (тестируемое устройство). Я написал базовое ALU в SystemVerilog, которое мы проверим в этой серии руководств, состоящей из нескольких частей, источник которой приведен ниже:","type":"unstyled","key":"6176k"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":1128,"offset":1,"style":"ITALIC"}],"text":"\n/****** alu.sv ******/\n typedef enum logic [1:0] {\n add = 2'h1,\n sub = 2'h2,\n nop = 2'h0\n } operation_t /*verilator public*/;\n\n module alu #(\n parameter WIDTH = 6\n ) (\ninput clk,\n input rst,\n\n input operation_t op_in,\n input [WIDTH-1:0] a_in,\n input [WIDTH-1:0] b_in,\n input in_valid,\n\n output logic [WIDTH-1:0] out,\n output logic out_valid\n );\n\n operation_t op_in_r;\n logic [WIDTH-1:0] a_in_r;\n logic [WIDTH-1:0] b_in_r;\n logic in_valid_r;\n logic [WIDTH-1:0] result;\n\n // Register all inputs\n always_ff @ (posedge clk, posedge rst) begin\n if (rst) begin\n op_in_r <= '0;\n a_in_r <= '0;\n b_in_r <= '0;\n in_valid_r <= '0;\n end else begin\n op_in_r <= op_in;\n a_in_r <= a_in;\n b_in_r <= b_in;\n in_valid_r <= in_valid;\n end\n end\n\n // Compute the result\n always_comb begin\n result = '0;\n if (in_valid_r) begin\n case (op_in_r)\n add: result = a_in_r + b_in_r;\n sub: result = a_in_r + (~b_in_r+1'b1);\n default: result = '0;\n endcase\n end\n end\n\n // Register outputs\n always_ff @ (posedge clk, posedge rst) begin\n if (rst) begin\n out <= '0;\n out_valid <= '0;\n end else begin\n out <= result;\n out_valid <= in_valid_r;\n end\n end\n\n endmodule;","type":"unordered-list-item","key":"nq03"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"\n Чтобы следовать этому руководству, создайте новый рабочий каталог и сохраните исходный код ALU как alu.sv.\n\n Как видите, это АЛУ очень простое. Он имеет две ступени регистра, без задержек и поддерживает только две операции: сложение и вычитание. Вот пример сигнала того, как мы ожидаем, что ALU будет вести себя:","type":"unstyled","key":"91ju1"},{"data":{"image":{"id":"652ce56b7ccaeb00f2be6ae6"}},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Примитивный конвейер ALU","type":"atomic:image","key":"fu7ds"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":36,"offset":245,"style":"BOLD"},{"length":9,"offset":283,"style":"BOLD"},{"length":46,"offset":1977,"style":"BOLD"},{"length":28,"offset":2026,"style":"BOLD"}],"text":"Из рисунка 2 видно, что на первом этапе регистрируются входные сигналы, а на втором этапе комбинаторный результат регистрируется на выходах. Имея это в виду, давайте теперь рассмотрим шаги, необходимые для создания базового тестового стенда.\n\n Преобразование SystemVerilog в C++\n\n Проверка\n\n Как упоминалось во введении, Verilator требует, чтобы тестовая среда C++ была скомпилирована в собственный двоичный файл системы. Однако мы не можем включить наш SystemVerilog ALU в тестовую среду C++ как есть: сначала нам нужно использовать Verilator для преобразования кода SystemVerilog в C++ или «проверить» его, что в самой простой форме делается следующим образом:\n\n verilator --cc alu.sv\n\n Здесь параметр --cc указывает Verilator преобразовать код в C++. Verilator также поддерживает преобразование в SystemC, которое можно выполнить с помощью --sc, но пока мы не будем использовать эту функцию.\n\n Результаты конвертации\n\n Выполнение вышеуказанной команды создает новую папку с именем obj_dir в нашем рабочем каталоге. Вот куда пошли все наши конвертированные исходники:\n\n $ ls -l obj_dir/\n Valu___024unit.cpp Valu___024unit__Slow.cpp Valu.cpp Valu.mk\n Valu__Syms.cpp Valu__ver.d Valu___024unit.h Valu_classes.mk\n Valu.h Valu__Slow.cpp Valu__Syms.h Valu__verFiles.dat\n\n Сгенерированные файлы .mk будут использоваться с Make для создания нашего исполняемого файла моделирования, а файлы .h и .cpp содержат наши заголовки C++ и исходные коды реализации, полученные в результате преобразования SystemVerilog. Я предлагаю вам немного исследовать и посмотреть, сможете ли вы понять, что где.\n\n Сейчас нас больше всего интересуют два файла: Valu.h и Valu___024unit.h:\n\n 1. Valu.h — это основной заголовок проекта, который содержит преобразованное определение класса «ALU» — это то, что мы «создадим» в нашем тестовом стенде C++ в качестве DUT.\n\n 2.Valu___024unit.h — это внутренний заголовок для класса «ALU», и он содержит определение нашего типа operation_t.\n\n Разработка базового тестового стенда Verilator\n\n Пример тестового стенда C++\n\n Теперь, когда мы преобразовали наше тестируемое устройство в C++, мы можем приступить к написанию нашего тестового стенда. Наш тестовый стенд будет находиться в новом файле с именем tb_alu.cpp. Давайте начнем с изучения минимального примера кода тестового стенда C++:\n\n #include \n #include \n #include \n #include \n #include \"Valu.h\"\n #include \"Valu___024unit.h\"\n\n #define MAX_SIM_TIME 20\n vluint64_t sim_time = 0;\n\n int main(int argc, char** argv, char** env) {\n Valu *dut = new Valu;\n\n Verilated::traceEverOn(true);\n VerilatedVcdC *m_trace = new VerilatedVcdC;\n dut->trace(m_trace, 5);\n m_trace->open(\"waveform.vcd\");\n\n while (sim_time < MAX_SIM_TIME) {\n dut->clk ^= 1;\n dut->eval();\n m_trace->dump(sim_time);\n sim_time++;\n }\n\n m_trace->close();\n delete dut;\n exit(EXIT_SUCCESS);\n }\n\n\n Первые несколько строк с операторами include говорят сами за себя. Нам нужно включить и , которые поставляются с установкой Verilator, чтобы получить доступ к общим процедурам Verilator и записать сигналы в файл VCD (дамп изменения значений).\n\n Как описано ранее, «Valu.h» содержит верхний класс нашего модуля Verilated ALU, а «Valu___024unit.h» содержит проверенную версию нашего перечисления typedef.\n\n Далее у нас есть следующие две строки:\n #define MAX_SIM_TIME 20\n vluint64_t sim_time = 0;\n\n Мы будем использовать переменную sim_time, чтобы отслеживать, когда закончить симуляцию. Есть и другие способы завершить симуляцию, но сейчас мы просто выйдем, как только смоделируем 20 фронтов тактовых импульсов.\n\n Затем у нас получилась следующая неразбериха с основной функцией, которая будет выглядеть странно, если вы до этого не писали тестбенч на C++:\n\n int main(int argc, char** argv, char** env) {\n Valu *dut = new Valu;\n\n Verilated::traceEverOn(true);\n VerilatedVcdC *m_trace = new VerilatedVcdC;\n dut->trace(m_trace, 5);\n m_trace->open(\"waveform.vcd\");\n\n /* <...> */\n\n m_trace->close();\n delete dut;\n exit(EXIT_SUCCESS);\n }\n\n Строка Valu *dut = new Valu; создает экземпляр нашего преобразованного модуля ALU. В SystemVerilog это примерно соответствует alu dut (.*);.\n\n Следующие четыре строки настраивают сброс сигнала. Примечательно, что мы создаем объект m_trace и передаем его нашему dut в строке dut->trace(m_trace, 5);. Параметр 5 просто ограничивает глубину трассировки до 5 уровней ниже тестируемого устройства.\n\n Наконец, у нас есть то, что делает симуляцию реальностью:\n\n while (sim_time < MAX_SIM_TIME) {\n dut->clk ^= 1;\n dut->eval();\n m_trace->dump(sim_time);\n sim_time++;\n }\n\n Во время каждой итерации цикла while строка dut->clk ^= 1; инвертирует часы ALU (это создаст нарастающие/спадающие фронты частоты). Это будут единственные частоты, которые мы будем использовать в нашем тестовом стенде.\n\n Вызов dut->eval(); оценивает все сигналы в нашем модуле ALU, и m_trace->dump(sim_time); записывает все значения трассируемых сигналов в наш файл дампа сигнала. Как видите, в настоящее время модель оценивается только по частоте.\n\n Затем время моделирования увеличивается, и цикл продолжается до тех пор, пока не достигнет MAX_SIM_TIME. Обратите внимание, что на самом деле это не значение времени — переменная просто отслеживает, сколько раз мы инвертировали частоту.","type":"unstyled","key":"9fnf2"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Как видите, этот тестовый стенд не делает ничего, кроме синхронизации дизайна, но это хорошая отправная точка для дальнейшего развития.","type":"unstyled","key":"ev44i"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":41,"offset":0,"style":"BOLD"}],"text":"Создание исполняемого файла моделирования","type":"unstyled","key":"ccocb"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Теперь, когда наш тестовый стенд написан, нам нужно создать исполняемый файл для запуска моделирования.","type":"unstyled","key":"b1asl"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"В отличие от некоторых других симуляторов, например Modelsim, в которых вы либо открываете исходники в графическом интерфейсе, либо передаете их в исполняемый файл Modelsim, приложение Verilator не используется для имитации тестового стенда.","type":"unstyled","key":"7knod"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Вместо этого приложение Verilator используется только для преобразования Verilog в C++ и создания инструкций по сборке для Make. Симулятором в данном случае является сам тестовый стенд C++.","type":"unstyled","key":"eq08i"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Тестовый стенд и преобразованные исходные коды HDL, по сути, представляют собой приложение C++, которое создается и запускается на вашем компьютере. Запуск скомпилированного исполняемого файла — это то, что имитирует ваш проект, а коллекция компиляторов GNU (GCC) — это основной выбор для создания исполняемых файлов Verilator.","type":"unstyled","key":"dask2"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Чтобы создать исполняемый файл моделирования, нам нужно снова запустить Verilator, чтобы повторно сгенерировать файлы .mk для включения тестового стенда C++ — это делается с помощью --exe tb_alu.cpp:","type":"unstyled","key":"993gm"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"$ verilator -Wall --trace -cc alu.sv --exe tb_alu.cpp","type":"unstyled","key":"f529o"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Кроме того, теперь мы используем следующие дополнительные параметры:","type":"unstyled","key":"f5gh"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"-Wall - включить все предупреждения C++. Не обязательно, но полезно, когда вы только начинаете","type":"unstyled","key":"bei32"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"--trace — включить трассировку сигнала","type":"unstyled","key":"5142g"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Чтобы собрать наш исполняемый файл, мы делаем следующее:","type":"unstyled","key":"avq1g"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"$ make -C obj_dir -f Valu.mk Valu","type":"unstyled","key":"2ukre"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"-C obj_dir указывает make работать в каталоге obj_dir. Затем мы передаем необходимый make-файл, используя -f Valu.mk. Наконец, мы говорим make собрать целевое значение Valu, которое является именем скомпилированного исполняемого файла testbench.","type":"unstyled","key":"9nv20"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Если исполняемый файл testbench был собран успешно, вы найдете двоичный файл Valu в obj_dir.","type":"unstyled","key":"4n1j6"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":23,"offset":0,"style":"BOLD"}],"text":"Запуск тестового стенда","type":"unstyled","key":"e8qul"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"После сборки просто запустите двоичный файл Valu, чтобы запустить симуляцию:","type":"unstyled","key":"fdcbv"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"$ ./obj_dir/Valu","type":"unstyled","key":"4vsl"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"$","type":"unstyled","key":"6d3bj"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"На первый взгляд, не так уж и много. В конце концов, в нашем коде тестового стенда","type":"unstyled","key":"foabu"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":28,"offset":174,"style":"BOLD"}],"text":"нет операторов печати, так что это ожидаемо. Однако запуск моделирования привел к тому, что в нашем рабочем каталоге был сгенерирован файл сигнала с именем waveform.vcd. \n\nПросмотр сигналов Verilator \nВы можете открыть вышеупомянутый файл дампа сигнала Verilator с помощью GTKwave: \n\ngtkwave waveform.vcd \n\nЗатем вам будет представлено окно GTKWave, которое выглядит следующим образом:","type":"unstyled","key":"bhlmk"},{"data":{"image":{"id":"652ce593127cf366bd717522"}},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Новое окно GTKWave","type":"atomic:image","key":"eo0kj"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Выполните шаги, показанные здесь, чтобы загрузить сигналы из тестируемого устройства и просмотреть их формы:","type":"unstyled","key":"dces8"},{"data":{"image":{"id":"652ce5a56592826adf615ab1"}},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Представление волны GTKWave","type":"atomic:image","key":"34jd5"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Поздравляем! Вы только что завершили свою первую симуляцию с помощью Verilator!","type":"unstyled","key":"31e9l"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":10,"offset":0,"style":"BOLD"}],"text":"Наблюдения","type":"unstyled","key":"946tb"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Во-первых, вы, возможно, заметили, что в нашей симуляции нет никаких «x» или неизвестных значений. Это связано с тем, что Verilator является симулятором с двумя состояниями, и по умолчанию все сигналы инициализируются 0. Отлично подходит для скорости, так как 2 состояния меньше, чем 4, но не очень хорошо, если мы хотим проверить, насколько хорошо работает наша логика сброса. Мы рассмотрим это позже.","type":"unstyled","key":"9oja7"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":12,"offset":187,"style":"BOLD"}],"text":"Во-вторых, половина тактового цикла занимает 1 пс. Это шкала времени по умолчанию для Verilator, и в данном конкретном случае она не означает какого-либо конкретного значения времени. \n\nЧто дальше?\n После прочтения этого руководства вы, надеюсь, получили некоторое базовое представление о том, как работает Verilator. Однако, как вы можете видеть, мы едва коснулись поверхности, поэтому, пожалуйста, переходите к части 2, где мы реализуем некоторые базовые функции проверки в нашем тестовом стенде C++.","type":"unstyled","key":"9tg4q"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"marker","key":"vKqmBC9sTtSVYD7B3lYf"}],"entityMap":{}},"mentions":[]}