Mi información de contacto
Correo[email protected]
2024-07-12
한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina
La razón por la que nos centramos directamente en riscv-arch-test es porque el marco de pruebas RISCOF utiliza riscv-arch-test.
Una prueba arquitectónica es una prueba única que representa el código de prueba más pequeño que se puede compilar y ejecutar. Está escrito en código ensamblador y su producto es una firma de prueba. Una prueba de arquitectura puede constar de varios casos de prueba.
El grupo de pruebas arquitectónicas de RISC-V consta de todas las pruebas arquitectónicas aprobadas que el marco de pruebas puede compilar en un conjunto de pruebas arquitectónicas. Las bibliotecas de prueba de arquitectura RISC-V deben ser independientes del objetivo de prueba (y, por lo tanto, deben ejecutarse correctamente en cualquier objetivo compatible). Tenga en cuenta que esta prueba no funcional no sustituye la verificación o prueba del dispositivo.
architectural-tests-suite (root)
|-- <architecture>_<mode>/<feature(s)>, where
<architecture> is [ RV32I | RV64I | RV32E ]
<mode> is [ M | MU | MS | MSU ], where
M Machine mode tests - tests execute in M-mode only
MU Machine/User mode tests - tests execute in both M- & U-modes (S-mode may exist)
MS Machine/Supv mode tests - tests execute in both M- & S-modes (not U-mode)
MSU All mode tests - tests execute in all of M-, S-, & U-Modes
<feature(s)> are the lettered extension [A | B | C | M ...] or subextension [Zifencei | Zam | ...] when the tests involve extensions, or more general names when tests cut across extension definitionss (e.g. Priv, Interrupt, Vm). The feature string consists of an initial capital letter, followed by any further letters in lower case.
Registro de características del conjunto de instrucciones del procesador en modo máquina (MISA)
error = 0x800000000094112f
Representación binaria: 100000000000000000000000000000000000000100101000001000100101111
riscv-arch-test/suite-de-pruebas-riscv$ ls
env/ Makefile.include README.md rv32e_m/ rv32i_m/ rv64i_m/
prueba-arquitectónica-riscv/suite-de-pruebas-riscv/rv64i_m$ ls
A/ B/ C/ CMO/ D/ F/ I/ K/ M/ privilegio/ P_no ratificado/ Zfh/ Zfinx/ Zicond/ Zifencei/
El conjunto de pruebas arquitectónicas RISC-V es un conjunto de pruebas seleccionadas del grupo de pruebas arquitectónicas para probar la conformidad de una configuración RISC-V específica. Los resultados de las pruebas se obtienen en forma de firma del conjunto de pruebas. La selección de la prueba se basa en la configuración de aserción, la especificación, el entorno de ejecución o los requisitos de plataforma del objetivo. Un procesador o modelo de procesador compatible debe mostrar la misma firma Gold Reference Test Suite que la configuración específica que se está probando.
Los casos de prueba son parte de las pruebas arquitectónicas y prueban solo una función de la especificación.
Nota: Una prueba puede contener varios casos de prueba, cada uno de los cuales tiene sus propias condiciones de inclusión de prueba (definidas por el parámetro cond_str de la macro RVTEST_CASE).
<test objective>-<test number>.S
prueba-de-arquitectura-riscv/suite-de-pruebas-riscv/rv64i_m/I/src$ ls
agregar-01.S y-01.S bge-01.S bne-01.S lb-align-01.S lhu-align-01.S misalign1-jalr-01.S sd-align-01.S slliw-01.S sltiu-01.S sraiw-01.S srliw-01.S sw-align-01.S
addi-01.S andi-01.S bgeu-01.S fence-01.S lbu-align-01.S lui-01.S or-01.S sh-align-01.S sllw-01.S sltu-01.S sraw-01.S srlw-01.S xor-01.S
addiw-01.S auipc-01.S blt-01.S jal-01.S ld-align-01.S lw-align-01.S ori-01.S sll-01.S slt-01.S sra-01.S srl-01.S sub-01.S xori-01.S
addw-01.S beq-01.S bltu-01.S jalr-01.S lh-align-01.S lwu-align-01.S sb-align-01.S slli-01.S slti-01.S srai-01.S srli-01.S subw-01.S
//
// This assembly file tests the add instruction of the RISC-V I extension for the add covergroup.
//
#include "model_test.h"
#include "arch_test.h"
RVTEST_ISA("RV32I")
.section .text.init
.globl rvtest_entry_point
rvtest_entry_point:
RVMODEL_BOOT
RVTEST_CODE_BEGIN
#ifdef TEST_CASE_1
RVTEST_CASE(0,"//check ISA:=regex(.*32.*);check ISA:=regex(.*I.*);def TEST_CASE_1=True;",add)
RVTEST_SIGBASE( x3,signature_x3_1)
inst_0:
// rs2 == rd != rs1, rs1==x4, rs2==x24, rd==x24, rs1_val > 0 and rs2_val > 0, rs2_val == 1, rs1_val == (2**(xlen-1)-1), rs1_val != rs2_val, rs1_val == 2147483647
// opcode: add ; op1:x4; op2:x24; dest:x24; op1val:0x7fffffff; op2val:0x1
TEST_RR_OP(add, x24, x4, x24, 0x80000000, 0x7fffffff, 0x1, x3, 0, x18)
inst_1:
// rs1 == rs2 != rd, rs1==x10, rs2==x10, rd==x28, rs1_val > 0 and rs2_val < 0, rs2_val == -257, rs1_val == 131072
// opcode: add ; op1:x10; op2:x10; dest:x28; op1val:0x20000; op2val:0x20000
TEST_RR_OP(add, x28, x10, x10, 0x40000, 0x20000, 0x20000, x3, 4, x18)
inst_2:
// rs1 == rs2 == rd, rs1==x21, rs2==x21, rd==x21, rs1_val < 0 and rs2_val < 0, rs1_val == -16777217
// opcode: add ; op1:x21; op2:x21; dest:x21; op1val:-0x1000001; op2val:-0x1000001
TEST_RR_OP(add, x21, x21, x21, 0xfdfffffe, -0x1000001, -0x1000001, x3, 8, x18)
......
......
......
RVTEST_CODE_END
RVMODEL_HALT
RVTEST_DATA_BEGIN
.align 4
rvtest_data:
.word 0xbabecafe
.word 0xbabecafe
.word 0xbabecafe
.word 0xbabecafe
RVTEST_DATA_END
RVMODEL_DATA_BEGIN
rvtest_sig_begin:
sig_begin_canary:
CANARY;
signature_x3_0:
.fill 0*(XLEN/32),4,0xdeadbeef
signature_x3_1:
.fill 17*(XLEN/32),4,0xdeadbeef
signature_x8_0:
.fill 16*(XLEN/32),4,0xdeadbeef
signature_x1_0:
.fill 512*(XLEN/32),4,0xdeadbeef
signature_x1_1:
.fill 43*(XLEN/32),4,0xdeadbeef
#ifdef rvtest_mtrap_routine
tsig_begin_canary:
CANARY;
mtrap_sigptr:
.fill 64*(XLEN/32),4,0xdeadbeef
tsig_end_canary:
CANARY;
#endif
#ifdef rvtest_gpr_save
gpr_save:
.fill 32*(XLEN/32),4,0xdeadbeef
#endif
sig_end_canary:
CANARY;
rvtest_sig_end:
RVMODEL_DATA_END
Una breve explicación del código ensamblador anterior es la siguiente:
#Este archivo de ensamblaje prueba la instrucción de adición de la extensión RISC-V I para el grupo de cobertura de adición.
#include “modelo_prueba.h”
#include “arch_test.h”
Cada prueba debe incluir solo los siguientes archivos de encabezado:
model_test.h: define macros específicas del objetivo, incluidas las macros obligatorias y opcionales: (por ejemplo, RVMODEL_xxx)
arch_test.h: define macros de prueba predefinidas, incluidas las macros requeridas y las macros opcionales: (como RVTEST_xxx)
RVTEST_ISA(“RV32I”)
Modelo RV_BOOT
CÓDIGO DE PRUEBA RVTEST_INICIO
#ifdef CASO DE PRUEBA 1
// Esta prueba está destinada a dispositivos que implementan la extensión rv32I y requiere habilitar la compilación
// macro TEST_CASE_1. Esta prueba contribuirá a la etiqueta de cobertura "add".
RVTEST_CASE(0,“//verificar ISA:=regex(.32.);comprobar ISA:=regex(.I.);def TEST_CASE_1=Verdadero;”,agregar)
RVTEST_SIGBASE( x16,signature_x16_1) // x16 apuntará a la etiqueta signature_x16_1 en la región de la firma
inst_0:
// rs2 == rd != rs1, rs1==x4, rs2==x24, rd==x24, rs1_val > 0 and rs2_val > 0, rs2_val == 1, rs1_val == (2**(xlen-1)-1), rs1_val != rs2_val, rs1_val == 2147483647
// opcode: add ; op1:x4; op2:x24; dest:x24; op1val:0x7fffffff; op2val:0x1
TEST_RR_OP(add, x24, x4, x24, 0x80000000, 0x7fffffff, 0x1, x3, 0, x18)
inst_1:
// rs1 == rs2 != rd, rs1==x10, rs2==x10, rd==x28, rs1_val > 0 and rs2_val < 0, rs2_val == -257, rs1_val == 131072
// opcode: add ; op1:x10; op2:x10; dest:x28; op1val:0x20000; op2val:0x20000
TEST_RR_OP(add, x28, x10, x10, 0x40000, 0x20000, 0x20000, x3, 4, x18)
...
...
//Tests for a instructions with register-register operand
#define TEST_RR_OP(inst, destreg, reg1, reg2, correctval, val1, val2, swreg, offset, testreg)
TEST_CASE(testreg, destreg, correctval, swreg, offset,
LI(reg1, MASK_XLEN(val1)) ;
LI(reg2, MASK_XLEN(val2)) ;
inst destreg, reg1, reg2 ;
)
#define TEST_CASE(testreg, destreg, correctval, swreg, offset, code... ) ;
code ;
RVTEST_SIGUPD(swreg,destreg,offset) ;
RVMODEL_IO_ASSERT_GPR_EQ(testreg, destreg, correctval)
/* automatically adjust base and offset if offset gets too big, resetting offset */
/* RVTEST_SIGUPD(basereg, sigreg) stores sigreg at offset(basereg) and updates offset by regwidth */
/* RVTEST_SIGUPD(basereg, sigreg,newoff) stores sigreg at newoff(basereg) and updates offset to regwidth+newoff */
#define RVTEST_SIGUPD(_BR,_R,...) ;
.if NARG(__VA_ARGS__) == 1 ;
.set offset,_ARG1(__VA_OPT__(__VA_ARGS__,0)) ;
.endif ;
CHK_OFFSET(_BR, REGWIDTH,0) ;
SREG _R,offset(_BR) ;
.set offset,offset+REGWIDTH
RVMODEL_IO_ASSERT_GPR_EQ 定义在target的model_test.h中```
在咱们得model_test.h中将RVMODEL_IO_ASSERT_GPR_EQ 宏定义如下：比较错误的话，往0xF0000080写1
```c
#define RVMODEL_IO_ASSERT_GPR_EQ(_S, _R, _I)
li _S, 0xF0000080;
mv t0, _R;
li t3, _I;
beq t0, t3, 1f;
li t2, 1;
sw t2, 0(_S);
j 2f;
1:
li t2, 0;
sw t2, 0(_S);
2:
nop;```
在tb.v中加入监测对AXI 写地址总线，地址0xF0000080的监测，如果出现fail_cnt >0，可以判断该testcase错误
```c
// RVMODEL_IO_ASSERT_GPR_EQ(testreg, destreg, correctval) used to check destreg == correctval
// destreg != correctva write testreg 1, else write testreg 0
always @(posedge `CPU_CLK) begin
if ((cpu_awaddr[31:0] == 32'hF000_0080) && cpu_wvalid && `clk_en && (cpu_wstrb[15:0] == 16'hf)) begin
if(`SOC_TOP.biu_pad_wdata == 1'b1) begin
fail_cnt ++;
end
end
end
// this will change the signature base register to x3. x3 will not point to signature_x3_0 in
// the signature region
RVTEST_SIGBASE( x3,signature_x3_0)
// continue with new test cases ..
TEST_RR_OP(add, x4, x24, x27, 0x55555955, 0x00000400, 0x55555555, x3, 0, x5)
...
...
RVTEST_CODE_END
RVMODEL_HALT
RVTEST_DATA_BEGIN
rvtest_data:
.word 0xbabecafe
RVTEST_DATA_END
RVMODEL_DATA_BEGIN
rvtest_sig_begin:
sig_begin_canary:
CANARY;
signature_x3_0:
.fill 0*(XLEN/32),4,0xdeadbeef
signature_x3_1:
.fill 17*(XLEN/32),4,0xdeadbeef
signature_x8_0:
.fill 16*(XLEN/32),4,0xdeadbeef
signature_x1_0:
.fill 512*(XLEN/32),4,0xdeadbeef
signature_x1_1:
.fill 43*(XLEN/32),4,0xdeadbeef
#ifdef rvtest_mtrap_routine
tsig_begin_canary:
CANARY;
mtrap_sigptr:
.fill 64*(XLEN/32),4,0xdeadbeef
tsig_end_canary:
CANARY;
#endif
#ifdef rvtest_gpr_save
gpr_save:
.fill 32*(XLEN/32),4,0xdeadbeef
#endif
sig_end_canary:
CANARY;
rvtest_sig_end:
RVMODEL_DATA_END
La firma de un caso de prueba está representada por uno o varios valores. El valor se escribirá en la memoria comenzando desde la dirección especificada por RVMODEL_DATA_BEGIN y terminando en la dirección especificada por RVMODEL_DATA_END. Las firmas se generan fácilmente utilizando la macro RVTEST_SIGUPD.
La firma de prueba es el valor característico generado por la ejecución de la prueba arquitectónica. Una firma de prueba puede consistir en varias firmas de casos de prueba, precedidas por una línea separada que contiene el nombre de la prueba y un valor único que indica su versión. El objetivo de prueba es responsable de extraer los valores de la memoria y formatearlos adecuadamente, utilizando los metadatos proporcionados por el marco, utilizando las macros RVMODEL_DATA_BEGIN y RVMODEL_DATA_END.El valor de la firma del caso de prueba se escribe en filas, comenzando desde el byte más significativo de la izquierda, en el formato<hex_value> , donde la longitud del valor será de 32 bits (es decir, 8 caracteres), mientras que el cálculo de prueba real no tiene en cuenta la longitud del valor. Los archivos deben almacenarse a partir del valor en la dirección de firma más baja (es decir, de RVMODEL_DATA_BEGIN a RVMODEL_DATA_END). Además, la firma siempre debe comenzar en un límite de 16 bytes (128 bits) y el tamaño de la firma debe ser un múltiplo de 4 bytes (es decir, también debe terminar en un límite de 4 bytes).
Una firma de conjunto de pruebas se define como un conjunto de firmas de prueba que son válidas para un conjunto de pruebas arquitectónicas determinado. Representa la firma de prueba del conjunto de pruebas arquitectónicas seleccionadas para una configuración RISC-V específica.
RISCOF: el marco de compatibilidad de RISC-V es un marco basado en Python que permite el uso de un conjunto de conjuntos de pruebas de arquitectura RISC-V para probar objetivos RISC-V (implementaciones de hardware o software) para determinar su compatibilidad con el estándar RISC-V Golden Reference. Sexo modelo.
Validador de configuración RISC-V: RISCV-Config
Generador de pruebas de conformidad con RISC-V: RISC-V CTG
Cobertura RISC-V ISA: RISC-V ISAC
Para que RISCOF ejecute la prueba normalmente, es necesario proporcionar el siguiente contenido:
Configuración de riesgo --dutname=spike
El comando anterior generará los siguientes archivos y directorios en el directorio actual:
├──config.ini # archivo de configuración para riscof
├──spike/ # Plantillas de complementos DUT
├── env
│ ├── link.ld # Script de enlazador DUT
│ └── model_test.h # Archivo de encabezado específico del DUT
├── riscof_spike.py # Complemento DUT para Python
├── spike_isa.yaml # ISA yaml de DUT basado en riscv-config
└── spike_platform.yaml # Yaml de la plataforma DUT basado en riscv-config
├──sail_cSim/ # plantillas de complementos de referencia
├── env
│ ├── link.ld # Script de referencia del enlazador
│ └── model_test.h # Archivo de encabezado específico del modelo de referencia
├── en eso.py
└── riscof_sail_cSim.py # Complemento de Python para el modelo de referencia.
Simplemente cambie el pico anterior al complemento C920. Por supuesto, debe modificar cada archivo de configuración y archivo de Python.
c920_isa.yaml
hart_ids: [0]
hart0:
ISA: RV64IMAFDCVZicsr_Zicbom_Zicbop_Zicboz_Zihintpause_Zfh_Zca_Zcb_Zcd_Zba_Zbb_Zbc_Zbs
physical_addr_sz: 40
User_Spec_Version: "2.2"
Privilege_Spec_Version: "1.10"
hw_data_misaligned_support: false
pmp_granularity: 4
supported_xlen: [64]
c920_platform.yaml
mtime:
implemented: true
address: 0xBFF8
mtimecmp:
implemented: true
address: 0x4000
nmi:
label: nmi_vector
reset:
address: 0x000000000
Al ejecutar el siguiente comando, se extraerá la lista de casos de test_list.yaml y se ejecutará cada caso. Puede comentar algunos de ellos y solo ejecutar algunos casos.
riesgo ejecutar --config=config.ini
–suite=riscv-arch-test/riscv-test-suite/
–env=riscv-arch-test/riscv-test-suite/env
–testfile=riesgo_del_trabajo/lista_de_pruebas.yaml
La ejecución del siguiente comando generará test_list.yaml y ejecutará la regresión
riesgo ejecutar --config=config.ini
–suite=riscv-arch-test/riscv-test-suite/
–env=riscv-arch-test/riscv-test-suite/env
Análisis de causa de error:
La primera:
Es porque ocurrió un error durante la compilación.
INFO | Compiling test: /ssd_fes/jiongz/desktop/github/c920_riscof1/riscv-arch-test/riscv-test-suite/rv64i_m/I/src/beq-01.S
ERROR | /opt/picocom/ThirdParty_Libs/T-head/C920_R2S0P21/C920_R2S0_manuals_and_tools/manuals_and_tools/08_toolchain_900_series_cpu_toolchain/V2.8.0/Xuantie-900-gcc-elf-newlib-x86_64-V2.8.0/bin/../lib/gcc/riscv64-unknown-elf/10.4.0/../../../../riscv64-unknown-elf/bin/ld: main.elf section `.text' will not fit in region `MEM1'
collect2: error: ld returned 1 exit status
Segundo tipo:
Es sólo que c920 no habilita un determinado comando de forma predeterminada.
También hay una macro en model_test.h para volcar la firma y finalizar la simulación.
// This will dump the test results (signature) via the testbench dump module.
#define RVMODEL_HALT
signature_dump:
la a0, begin_signature;
la a1, end_signature;
li a2, 0xF0000040;
signature_dump_loop:
bge a0, a1, signature_dump_end;
lw t0, 0(a0);
sw t0, 0(a2);
addi a0, a0, 4;
j signature_dump_loop;
signature_dump_end:
nop;
terminate_simulation:
li a0, 0xF0000000;
li a1, 0xCAFECAFE;
sw a1, 0(a0);
j terminate_simulation
Correspondiente a tb.v
always @(posedge `CPU_CLK or negedge `CPU_RST) begin
if (!`CPU_RST) begin
msi <= 1'b0;
mei <= 1'b0;
mti <= 1'b0;
end else begin
//if ((wb_cpu.cyc == 1'b1) && (wb_cpu.stb == 1'b1) && (wb_cpu.we == 1'b1) && (cpu_awaddr[31:0] == 32'hF000_0000)) begin
if ((cpu_awaddr[31:0] == 32'hF000_0000) && cpu_wvalid && `clk_en && (cpu_wstrb[15:0] == 16'hf)) begin
case (`SOC_TOP.biu_pad_wdata[31:0])
32'hCAFE_CAFE: begin // end simulation
$display("Finishing simulation.");
#100;
if(fail_cnt >0) begin
$error("This case test failed!");
end
$finish;
end
......
end
// Signature Dump
int dump_file; // Declare file handle
always @(posedge `CPU_CLK) begin
if ((cpu_awaddr[31:0] == 32'hF000_0040) && cpu_wvalid && `clk_en && (cpu_wstrb[15:0] == 16'hf)) begin
if (!dump_file) begin // Check if file is already open
dump_file = $fopen("DUT-c920.signature", "w"); // Open file if not already opened
end
//for (int i = 7; i >= 0; i--) begin
// $fwrite(dump_file, "%hn", `SOC_TOP.biu_pad_wdata[i*4 +: 4]); // Write data
//end
$fwrite(dump_file, "%hn", `SOC_TOP.biu_pad_wdata[31:0]); // Write data
end
else if((cpu_awaddr[31:0] == 32'hF000_0000) && cpu_wvalid && `clk_en && (cpu_wstrb[15:0] == 16'hf)) begin
if (dump_file) begin // If file is open, close it
$fclose(dump_file);
dump_file = 0; // Reset file handle to 0 indicating file is closed
end
end
end
// RVMODEL_IO_ASSERT_GPR_EQ(testreg, destreg, correctval) used to check destreg == correctval
// destreg != correctva write testreg 1, else write testreg 0
always @(posedge `CPU_CLK) begin
if ((cpu_awaddr[31:0] == 32'hF000_0080) && cpu_wvalid && `clk_en && (cpu_wstrb[15:0] == 16'hf)) begin
if(`SOC_TOP.biu_pad_wdata == 1'b1) begin
fail_cnt ++;
end
end
end
#include "model_test.h"
#include "arch_test.h"
RVTEST_ISA("RV64I")
.section .text.init
.globl rvtest_entry_point
rvtest_entry_point:
RVMODEL_BOOT
RVTEST_CODE_BEGIN
#ifdef TEST_CASE_1
RVTEST_CASE(0,"//check ISA:=regex(.*64.*);check ISA:=regex(.*I.*);def TEST_CASE_1=True;",add)
RVTEST_SIGBASE( x8,signature_x8_1)
inst_0:
// rs1 == rs2 != rd, rs1==x0, rs2==x0, rd==x20, rs1_val > 0 and rs2_val > 0, rs1_val == 4, rs1_val==4 and rs2_val==6148914691236517206, rs1_val != rs2_val
// opcode: add ; op1:x0; op2:x0; dest:x20; op1val:0x0; op2val:0x0
TEST_RR_OP(add, x20, x0, x0, 0x0, 0x0, 0x0, x8, 0, x16)
inst_1:
// rs2 == rd != rs1, rs1==x2, rs2==x26, rd==x26, rs1_val > 0 and rs2_val < 0, rs2_val == -1073741825
// opcode: add ; op1:x2; op2:x26; dest:x26; op1val:0x5; op2val:-0x40000001
TEST_RR_OP(add, x26, x2, x26, 0xffffffffc0000004, 0x5, -0x40000001, x8, 8, x16)
inst_2:
// rs1 == rs2 == rd, rs1==x22, rs2==x22, rd==x22, rs1_val < 0 and rs2_val < 0, rs1_val == -8388609
// opcode: add ; op1:x22; op2:x22; dest:x22; op1val:-0x800001; op2val:-0x800001
TEST_RR_OP(add, x22, x22, x22, 0xfffffffffefffffe, -0x800001, -0x800001, x8, 16, x16)
El contenido de “riscof_work/rv64i_m/I/src/add-01.S/dut/DUT-c920.signature” es el siguiente:
e7d4b281
6f5ca309
00000000
00000000
c0000004
ffffffff
ffffff
ffffffff
ffffffbf
007ffffff
00000080
00000000
66666665
e6666666
00000001
00000000
0001ffff
80000000
10000001
00000000
ffffffff
Se ha dedicado a la investigación de tecnología durante más de 30 años y domina varios lenguajes como java, linux, javascript, php, css, etc. Ha realizado muchas contribuciones en el campo del código abierto. Estación de documentación para desarrolladores para compartir algunos problemas en el desarrollo de tecnología para referencia futura.
Correo[email protected]