Rocket-chip-RoCC(4)--software

最新推荐文章于 2023-11-08 17:22:30 发布
最新推荐文章于 2023-11-08 17:22:30 发布
阅读量1.1k 收藏 2
点赞数 1
分类专栏： RISC-V & rocket-chip 文章标签： RISC-V risc-v rocc rocket-chip software
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a_weiming/article/details/113359605
版权

ROCC软件代码介绍

  • 前情提要：
    需要注意的是custom0~3均采用R类指令格式。RISC-V各指令类别如下图所示。
    在这里插入图片描述

  • mstatus的XS域
    需要打开mstatus的XS域。
    https://blog.csdn.net/a_weiming/article/details/111600428
    我是在底层汇编*.S文件中打开的，代码如下：
    其中MSTATUS_XS在encoding.h有定义。

 # enable accelerator if present
  li t0, MSTATUS_XS
  csrs mstatus, t0
  • ROCC的底层汇编
    我这里有两个版本，一个是很久的，另一个是较新的，较新的需要gcc支持某些特定的语法，例如.inst，我的gcc比较旧，所以使用旧的版本。新旧都是IBM开源在github上的。
    https://github.com/IBM/rocc-software
  • 旧版本代码：
// Copyright 2018 IBM
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef ROCC_SOFTWARE_SRC_XCUSTOM_H_
#define ROCC_SOFTWARE_SRC_XCUSTOM_H_

#define STR1(x) #x
#ifndef STR
#define STR(x) STR1(x)
#endif
#define EXTRACT(a, size, offset) (((~(~0 << size) << offset) & a) >> offset)

// rd = rs2[offset + size - 1 : offset]
// rs1 is clobbered
// rs2 is left intact
#define EXTRACT_RAW(rd, rs1, rs2, size, offset) \
  not x ## rs1, x0;                             \
  slli x ## rs1, x ## rs1, size;                \
  not x ## rs1, x ## rs1;                       \
  slli x ## rs1, x ## rs1, offset;              \
  and x ## rd, x ## rs1, x ## rs2;              \
  srai x ## rd, x ## rd, offset;

#定制指令的opcode定义
#define XCUSTOM_OPCODE(x) XCUSTOM_OPCODE_ ## x
#define XCUSTOM_OPCODE_0 0b0001011
#define XCUSTOM_OPCODE_1 0b0101011
#define XCUSTOM_OPCODE_2 0b1011011
#define XCUSTOM_OPCODE_3 0b1111011

#R指令的格式，x为选择的定制指令编号，如0/1/2/3
#define XCUSTOM(x, rd, rs1, rs2, funct)         \
  XCUSTOM_OPCODE(x)                   |         \
  (rd                   << (7))       |         \
  (0x3                  << (7+5))     |         \
  ((rd != 0) & 1        << (7+5+2))   |         \
  (rs1                  << (7+5+3))   |         \
  (rs2                  << (7+5+3+5)) |         \
  (EXTRACT(funct, 7, 0) << (7+5+3+5+5))

#定义ROCC_INSTRUCTION_RAW_R_R_R()调用.word XCUSTOM()
#define ROCC_INSTRUCTION_RAW_R_R_R(x, rd, rs1, rs2, funct)      \
  .word XCUSTOM(x, ## rd, ## rs1, ## rs2, funct)

// Standard macro that passes rd, rs1, and rs2 via registers
#define ROCC_INSTRUCTION(x, rd, rs1, rs2, funct)                \
  ROCC_INSTRUCTION_R_R_R(x, rd, rs1, rs2, funct, 10, 11, 12)

// rd, rs1, and rs2 are data
// rd_n, rs1_n, and rs2_n are the register numbers to use
#define ROCC_INSTRUCTION_R_R_R(x, rd, rs1, rs2, funct, rd_n, rs1_n, rs2_n) \
  {                                                                     \
    register uint64_t rd_  asm ("x" # rd_n);                            \
    register uint64_t rs1_ asm ("x" # rs1_n) = (uint64_t) rs1;          \
    register uint64_t rs2_ asm ("x" # rs2_n) = (uint64_t) rs2;          \
    asm volatile (                                                      \
        ".word " STR(XCUSTOM(x, rd_n, rs1_n, rs2_n, funct)) "\n\t"      \
        : "=r" (rd_)                                                    \
        : [_rs1] "r" (rs1_), [_rs2] "r" (rs2_));                        \
    rd = rd_;                                                           \
  }

#define ROCC_INSTRUCTION_0_R_R(x, rs1, rs2, funct, rs1_n, rs2_n)  \
  {                                                               \
    register uint64_t rs1_ asm ("x" # rs1_n) = (uint64_t) rs1;    \
    register uint64_t rs2_ asm ("x" # rs2_n) = (uint64_t) rs2;    \
    asm volatile (                                                \
        ".word " STR(XCUSTOM(x, 0, rs1_n, rs2_n, funct)) "\n\t"   \
        :: [_rs1] "r" (rs1_), [_rs2] "r" (rs2_));                 \
  }

// [TODO] fix these to align with the above approach
// Macro to pass rs2_ as an immediate
/*
#define ROCC_INSTRUCTION_R_R_I(XCUSTOM_, rd_, rs1_, rs2_, funct_) \
  asm volatile (XCUSTOM_" %[rd], %[rs1], %[rs2], %[funct]"        \
                : [rd] "=r" (rd_)                                 \
                : [rs1] "r" (rs1_), [rs2] "i" (rs2_), [funct] "i" (funct_))

// Macro to pass rs1_ and rs2_ as immediates
#define ROCC_INSTRUCTION_R_I_I(XCUSTOM_, rd_, rs1_, rs2_, funct_) \
  asm volatile (XCUSTOM_" %[rd], %[rs1], %[rs2], %[funct]"        \
                : [rd] "=r" (rd_)                                 \
                : [rs1] "i" (rs1_), [rs2] "i" (rs2_), [funct] "i" (funct_))
*/

#endif  // ROCC_SOFTWARE_SRC_XCUSTOM_H_
  • 新版代码：
// Copyright 2018--2020 IBM
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef ROCC_SOFTWARE_SRC_XCUSTOM_H_
#define ROCC_SOFTWARE_SRC_XCUSTOM_H_

#define STR1(x) #x
#ifndef STR
#define STR(x) STR1(x)
#endif

#define CAT_(A, B) A##B
#define CAT(A, B) CAT_(A, B)

/** Assembly macro for creating "raw" Rocket Custom Coproessor (RoCC)
  * assembly language instructions that will return data in rd. These
  * are to be used only in assembly language programs (not C/C++).
  *
  * Example:
  *
  * Consider the following macro consisting of a CUSTOM_0 instruction
  * with func7 "42" that is doing some operation of "a0 = op(a1, a2)":
  *
  *     ROCC_INSTRUCTION_RAW_R_R_R(0, a0, a1, a2, 42)
  *
  * This will produce the following pseudo assembly language
  * instruction:
  *
  *     .insn r CUSTOM_0, 7, 42, a0, a1, a2
  *
  * @param x the custom instruction number: 0, 1, 2, or 3
  * @param rd the destination register, e.g., a0 or x10
  * @param rs1 the first source register, e.g., a0 or x10
  * @param rs2 the second source register, e.g., a0 or x10
  * @param func7 the value of the func7 field
  * @return a raw .insn RoCC instruction
  */
#define ROCC_INSTRUCTION_RAW_R_R_R(x, rd, rs1, rs2, func7) \
  .insn r CAT(CUSTOM_, x), 7, func7, rd, rs1, rs2

/** Assembly macro for creating "raw" Rocket Custom Coproessor (RoCC)
  * assembly language instructions that will *NOT* return data in rd.
  * These are to be used only in assembly language programs (not
  * C/C++).
  *
  * Example:
  *
  * Consider the following macro consisting of a CUSTOM_1 instruction
  * with func7 "42" that is doing some operation of "op(a1, a2)". *NO*
  * data is returned:
  *
  *     ROCC_INSTRUCTION_RAW_0_R_R(1, a1, a2, 42)
  *
  * This will produce the following pseudo assembly language
  * instruction:
  *
  *     .insn r CUSTOM_1, 3, 42, x0, a1, a2
  *
  * @param x the custom instruction number: 0, 1, 2, or 3
  * @param rs1 the first source register, e.g., a0 or x10
  * @param rs2 the second source register, e.g., a0 or x10
  * @param func7 the value of the func7 field
  * @return a raw .insn RoCC instruction
  */
#define ROCC_INSTRUCTION_RAW_0_R_R(x, rs1, rs2, func7) \
  .insn r CAT(CUSTOM_, x), 3, func7, x0, rs1, rs2

/** C/C++ inline assembly macro for creating Rocket Custom Coprocessor
  * (RoCC) instructions that return data in rd. These are to be used
  * only in C/C++ programs (not bare assembly).
  *
  * This is equivalent to ROCC_INSTRUCTION_R_R_R. See it's
  * documentation.
  */
#define ROCC_INSTRUCTION(x, rd, rs1, rs2, func7) \
  ROCC_INSTRUCTION_R_R_R(x, rd, rs1, rs2, func7)

/** C/C++ inline assembly macro for creating Rocket Custom Coprocessor
  * (RoCC) instructions that return data in C variable rd. 
  * These are to be used only in C/C++ programs (not bare assembly).
  *
  * Example:
  *
  * Consider the following macro consisting of a CUSTOM_2 instruction
  * with func7 "42" that is doing some operation of "a0 = op(a1, a2)"
  * (where a0, a1, and a2 are variables defined in C):
  *
  *     ROCC_INSTRUCTION(2, a0, a1, a2, 42)
  *
  * This will produce the following inline assembly:
  *
  *     asm volatile(
  *         ".insn r CUSTOM_2, 0x7, 42, %0, %1, %2"
  *         : "=r"(rd)
  *         : "r"(rs1), "r"(rs2));
  *
  * @param x the custom instruction number: 0, 1, 2, or 3
  * @param rd the C variable to capture as destination operand
  * @param rs1 the C variable to capture for first source register
  * @param rs2 the C variable to capture for second source register
  * @param func7 the value of the func7 field
  * @return an inline assembly RoCC instruction
  */
#define ROCC_INSTRUCTION_R_R_R(x, rd, rs1, rs2, func7)                               \
  {                                                                                  \
    asm volatile(                                                                    \
        ".insn r " STR(CAT(CUSTOM_, x)) ", " STR(0x7) ", " STR(func7) ", %0, %1, %2" \
        : "=r"(rd)                                                                   \
        : "r"(rs1), "r"(rs2));                                                       \
  }

/** C/C++ inline assembly macro for creating Rocket Custom Coprocessor
  * (RoCC) instructions that return data in C variable rd.
  * These are to be used only in C/C++ programs (not bare assembly).
  *
  * Example:
  *
  * Consider the following macro consisting of a CUSTOM_3 instruction
  * with func7 "42" that is doing some operation of "a0 = op(a1, a2)"
  * (where a0, a1, and a2 are variables defined in C):
  *
  *     ROCC_INSTRUCTION(3, a0, a1, a2, 42)
  *
  * This will produce the following inline assembly:
  *
  *     asm volatile(
  *         ".insn r CUSTOM_3, 0x7, 42, %0, %1, %2"
  *         :: "r"(rs1), "r"(rs2));
  *
  * @param x the custom instruction number: 0, 1, 2, or 3
  * @param rs1 the C variable to capture for first source register
  * @param rs2 the C variable to capture for second source register
  * @param funct7 the value of the funct7 f
  * @return an inline assembly RoCC instruction
  */
#define ROCC_INSTRUCTION_0_R_R(x, rs1, rs2, func7)                                   \
  {                                                                                  \
    asm volatile(                                                                    \
        ".insn r " STR(CAT(CUSTOM_, x)) ", " STR(0x3) ", " STR(func7) ", x0, %0, %1" \
        :                                                                            \
        : "r"(rs1), "r"(rs2));                                                       \
  }

// [TODO] fix these to align with the above approach
// Macro to pass rs2_ as an immediate
/*
#define ROCC_INSTRUCTION_R_R_I(XCUSTOM_, rd_, rs1_, rs2_, funct_) \
  asm volatile (XCUSTOM_" %[rd], %[rs1], %[rs2], %[funct]"        \
                : [rd] "=r" (rd_)                                 \
                : [rs1] "r" (rs1_), [rs2] "i" (rs2_), [funct] "i" (funct_))

// Macro to pass rs1_ and rs2_ as immediates
#define ROCC_INSTRUCTION_R_I_I(XCUSTOM_, rd_, rs1_, rs2_, funct_) \
  asm volatile (XCUSTOM_" %[rd], %[rs1], %[rs2], %[funct]"        \
                : [rd] "=r" (rd_)                                 \
                : [rs1] "i" (rs1_), [rs2] "i" (rs2_), [funct] "i" (funct_))
*/

#endif  // ROCC_SOFTWARE_SRC_XCUSTOM_H_

新版本的我没有试过，因为我的gcc还是旧版的，而我又不想重新编译gcc工具链，所以就用旧版吧，只要包上上面的代码，就能直接调用，可以参考我其他文章看怎么使用。

Xxxxxxx..
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
rocket-chip datasheet
02-26
Rocket是一款64bit的标量处理器，5级流水线，采用的是risc-v指令集，集成FPU，并有许多or1200没有的特性，比如：无阻塞缓存、分支预测、返回地址堆栈、硬件页表填充、cache支持ECC、支持...文档是rocket-chip的架构说明
rocket-chip_20.03.26.rar
03-26
rocket-chip RTL，带有以下功能： 2) 支持4KB-ICache和4KB-DCache。 3) 硬件断点数量为2。 4) PMP区域为8个。 5) 硬件性能计数器为2个。 6) 带有DCache flush功能。 7) 带有clock gtae功能。 8) 乘法器为pipeline...
Rocket-chip-RoCC(1)
a_weiming的博客
12-23 2596
rocket-chip-rocc 关于rocc的内容很多，我会分多章进行讲解。 初步规划以下面章节为划分。 1. 协议，自定义指令说明。 2. rocket-chip RoCC各模块的scala代码说明。 3. 软件代码编译实现。 4. rocket-chip RoCC各模块硬件实现和硬件仿真。 第一部分介绍的定制CSR寄存器和定制指令的协议内容。 1) CSR寄存器扩展 在The RISC-V Instruction Set Manual Volume II: Privileged Architectur
Rocket-chip-RoCC(3)
a_weiming的博客
01-19 1545
rocket-chip-rocc 下面是对accumulator、translator、counter和blackbox这四个模块的具体实现进行说明。 1、Accumulator 类AccumulatorExample，需要输入opcodes和n参数，里面使用new创建AccumulatorExampleModuleImp的对象。 class AccumulatorExample(opcodes: OpcodeSet, val n: Int = 4)(implicit p: Parameters) exte
Rocket-chip-RoCC(5)
a_weiming的博客
02-19 791
下面是对translator模块的具体实现进行说明。 2、Translator 类TranslatorExample，需要输入opcodes参数，里面使用new创建TranslatorExampleModuleImp的对象，且输入额外参数nPTWPorts，值为1。 class TranslatorExample(opcodes: OpcodeSet)(implicit p: Parameters) extends LazyRoCC(opcodes, nPTWPorts = 1) { override
Rocket-chip-RoCC(6)
a_weiming的博客
02-28 769
下面是对CharacterCount模块的具体实现进行说明。 3、CharacterCount 类CharacterCountExample，需要输入opcodes参数，里面使用new创建CharacterCountExampleModuleImp的对象。声明atlNode为TLClientNode的类，用于TileLink协议，TLClientNode应该是作为master方的，用于发起数据的请求 。 class CharacterCountExample(opcodes: OpcodeSet)(imp
Rocket-chip-RoCC(2)
a_weiming的博客
12-24 2466
rocket-chip-rocc 关于rocc的内容很多，我会分多章进行讲解。 初步规划以下面章节为划分。 1. 协议，自定义指令说明。 2. rocket-chip RoCC各模块的scala代码说明。 3. 软件代码编译实现。 4. rocket-chip RoCC各模块硬件实现和硬件仿真。 第二部分rocket-chip RoCC各模块的scala代码说明。 1) Rocket-chip中的定制CSR寄存器 利用grep指令搜索scala中关于0x7c0和0x7c1的内容，结果如下图。 顺着找下去可
在pynq-z1上实现RISC-V处理器Rocket-Chip，并在其上添加各种外设 Rocket Chip在ZYNQ上的实现
最新发布
02-23
在pynq-z1上实现RISC-V处理器Rocket-Chip，并在其上添加各种外设。Rocket Chip在ZYNQ上的实现。该仓库包含在Vivado 2016.2上的各种Zynq FPGA开发板（Zybo，Zedboard，ZC706，PYNQ-z2）上运行RISC-V rocket chip所需...
wp-rocket-2.10.10
12-09
**WordPress的WP-Rocket插件...定期更新如“wp-rocket-2.10.10”这样的新版本，意味着持续的性能提升和新功能的引入，以适应不断变化的Web环境。因此，如果你关心你的WordPress网站性能，WP-Rocket值得你考虑和投资。
rocket-console.zip
08-20
RocketMQ-Console。RocketMQ的控制台工具。运行指令：java -jar rocketmq-console-ng-1.0.0.jar -Drocketmq.config.namesrvAddr=localhost:9876
Rocket之加速器
qihao
11-01 6649
文章目录RoCC简介riscv-toolspk加速器fpga-zynq测试测试样例测试结果参考文献 RoCC简介 Rocket Custom Coprocessor riscv-tools 由于custom指令并不是标准指令集的一部分，所以最新的risc-tools（汇编器）不支持直接写custom0指令。 riscv-tools还是为custom指令预留了opcode。 可以参考这里。直接...
RISCV-RoCC简介
Frederick_Bala的博客
07-24 5324
RiscV作为一个新的开源指令集架构,由Aspire Lab开放,具有简单开放的特点,主要用于教育研究. 一个最主要的特点是其ISA通过支持自定义指令的方式，支持自定义硬件加速器，用于专用领域的计算加速设计。 本文简单介绍RiscV的RoCC，以及其与RiscV处理器核通信的接口RoCC Interface。 RiscV自定义指令 RiscV ISA定义了四种自定义指令用于与协处理器进行交互。 customX rd, rs1, rs2, funct 标准自定义指令格式如下： 其中rs1
RISC-V & rocket-chip
a_weiming的博客
11-26 4852
RISC-V &amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp; rocket-chip 大家好，为了使更多人认识和研究RISC-V与rocket-chip，我将分享我学习RISC-V和rocket-chip的资料。有部分是官方的开源资料，有部分是我个人对RISC-V和rocket-chip的研究。资源来源于网络和我自己的实验，若有侵权行为，请您联系我1300466447@qq.com。若有关于rocket-chip的问题与合作也可以联...
捡到RoCC的贝壳
http://www.icfgblog.com/
06-03 649
RISC-V RoCC时序图，内存模型介绍
使用RocketChip生成Verilog代码供外部工程使用
hao320rui的博客
06-29 524
非硬件实现部分：即在LazyModuleImp之外的所有内容，例如定义Nodes，解析参数等，这被认为是传统意义上的软件代码；硬件实现部分：即LazyModuleImp内部的所有内容，创建实际的硬件，通常是使用外部解析得到的参数来构建对应的硬件；因此，应该倾向于将LazyModule和Diplomacy视为创建硬件的两个步骤，第一步是定义硬件拓扑，这是在LazyModuleImp之外完成的，描述每个部分是如何连接的，并解析诸如地址宽度、数据宽度等参数；
RISC-V特权级寄存器及指令文档
热门推荐
Pandacooker的博客
05-08 1万+
RISC-V特权级寄存器及指令文档 M态寄存器 1. ISA寄存器 misa（read-write） base域： 1.编码了内部支持的ISA宽度. 2.当重置时，总是设置为支持的最宽ISA extensions域： 功能： 1.编码了现有的标准扩展。依照每个字母一位的方式 ，第0位代表A，第25位代表Z。 保留位总返回0 2.重置时为最大的扩展集合 2. mstatus 寄存器 XLEN-bit read/write register 寄存器结构： 位描述： xIE域： 当硬件线程运行于x模式，
保姆级Rocket-chip自定义指令/加速器教程-chipyard学习笔记
weixin_45491279的博客
11-08 1327
chipyard/generators/rocket-chip/src/main/scala/tile路径下包含的LazyRoCC.scala文件下自带accumulator、translator、counter和blackbox这四个自定义模块，可以在和tile同级的subsystem/Configs.scala文件中找到WithRoccExample的调用。在同级的system/Configs.scala文件中可以找到RoccExampleConfig的顶层配置尝试运行如下命令。
RISC-V SoC生成器---Rocket Chip介绍
耐心的小黑的博客
09-06 3664
一、Rocket Chip 基本结构 Rocket Chip是基于Chisel开发的一款开源SoC生成器（Generator），也即它自己其实并不是一款处理器。它根据不同的配置参数可以产生不同的处理器的RTL代码，当配置参数确定之后，生成的才是一个真正的“处理器”。 从图中可以看出，Rocket Chip有六个组成部分： A为Core Generator，用于生成处理器核，支持Rocket-core和BOOM两种 B为Cache，包括L1 Cache和L2 Cache C为RoCC，即Rocket的用户
rocket-chip 资料
03-28
4. Rocket-Chip的论文：https://people.eecs.berkeley.edu/~krste/papers/EECS-2016-17.pdf 5. Rocket-Chip的视频介绍：https://www.youtube.com/watch?v=ZJbg5A5r5bU 6. Rocket-Chip的社区讨论论坛：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值