Início / coding / Perguntas / 79528660
Accepted
ZiChong Lv
Asked: 2025-03-23 16:26:28 +0800 CST

Como a máquina lê as instruções do Risc-v

  • 772

A questão é como a máquina lê as instruções? Por exemplo: se for um tipo R, a máquina primeiro lê o opcode para saber o tipo de instrução e, com base no tipo, lê a instrução da direita para a esquerda para saber o rd e, em seguida, lê a função3, depois rs1, rs2 e, por último, a função7. Está correto? insira a descrição da imagem aqui

riscv

1 respostas

  1. Best Answer

    Se você estivesse escrevendo um emulador de software para RISC V, você poderia ter as seguintes etapas:

    Assumindo byte *pc;

    opcode = pc[0] & 0x7F;
if (opcode == 0x33) {
    // reg/reg instruction format
    rd = ((pc[0] & 0x80) >> 7) + ((pc[1] & 0x7) << 1);
    func3 = (pc[1] & 0x38) >> 3;
    rs1 = ...;
    rs2 = ...;
    s1 = reg[rs1];
    s2 = reg[rs2];
    switch (func3) {
    case ...:
       switch(func7) {
       case ...:
           answer = s1 + s2; break;
       case ...:
           answer = s1 & s2; break;
       case ...:
           answer = s1 | s2; break;
       case ...:
           answer = s1 - s2; break;
       }
    }
    reg[rd] = answer;
}

    Aqui você pode especificar que extrair o rdcampo é condicional, e feito somente com base no opcode sendo reg/reg. E você pode dizer que o rdcampo é extraído primeiro, seguido pelo func3campo.

    Contudo, o seguinte seria igualmente válido:

    opcode = pc[0] & 0x7F;
if (opcode == 0x33) {
    // reg/reg instruction format
    rs1 = ...;
    rs2 = ...;
    func3 = (pc[1] & 0x38) >> 3;
    rd = ((pc[0] & 0x80) >> 7) + ((pc[1] & 0x7) << 1);
    ...
}

    Então, em software, expressaríamos uma ordem de passos para decodificar, mas a ordem é um tanto arbitrária. O mais importante é extrair os campos sob a condição de saber que o formato da instrução é reg/reg.

    No entanto, o hardware fará mais como isto:

    parallel {
    rs1 = ...;
    rs2 = ...;
    func3 = (pc[1] & 0x38) >> 3;
    rd = ((pc[0] & 0x80) >> 7) + ((pc[1] & 0x7) << 1);
    opcode = pc[0] & 0x7F;
    imm = ...;
}

parallel {
    s1 = reg[rs1];
    s2 = reg[rs2];
}

parallel {
    answer1 = s1 + s2;
    answer2 = s1 - s2;
    answer3 = s1 & s2;
    answer4 = s1 | s2;
}

if opcode == 0x33 {
   switch (func3) {
      switch (func7) {
      case ...:
          reg[rd] = answer1; break;
      case ...:
          reg[rd] = answer2; break;
      }
   } 
}

    É difícil expressar um conceito de ordenação para o hardware — o que ele fará passo a passo, do primeiro ao último.

    Para o hardware, é melhor falar sobre as condições e dependências.

    Por exemplo, como uma dependência, não podemos obter s1sem primeiro obter rs1, já que s1 = reg[rs1].

    Como condição, ele deve aceitar answer1quando souber o suficiente sobre opcode, func3e func7.

    No entanto, isso não impede o processador de computar outras coisas em paralelo caso o valor correto seja answer2. Então, para o processador, trata-se de fazer o máximo que puder em paralelo, excluindo informações irrelevantes quando uma determinação completa for feita em relação às condições e dependências.

    Na emulação de software, não nos incomodaríamos em extrair campos imediatos para o formato de instrução reg/reg. No entanto, o hardware estaria extraindo o imediato em paralelo e, mais tarde, desconsiderando os dados do campo imediato, uma vez que se saiba que o formato da instrução é reg/reg.

    • 1

relate perguntas