SCALA 程序的几种运行方式
方法1
脚本式的使用,scala a.scala
可正常打印1
2
3
4def main() = {
println("Hello, Scala way1")
}
main()
但这种写法不能被 scalac a.scala
正确编译,可能JVM对象必须要有个main入口函数
setp1 : 首先要确定向量的类型
比如你要做一个向量运算 Y = a*X + Y ,如果X, Y 都是双精度的浮点的向量,那么就需要申请两个F64类型的向量v0和v1,
如果是 Z = a*X + Y ,同样X,Y是双精度的浮点的向量,那么就需要至少申请3个F64类型的向量v0和v1,v2分别给X,Y,Z使用
RV32V 向量寄存器类型的编码如下
Type | Floating | Poing | Signed Interger | Unsigned Interger |
---|---|---|---|---|
Width | Name | vetype | Name vetype | Name vetype |
8bit | — | — | X8 10100 | X8U 11100 |
16bit | F16 | 01101 | X16 10101 | X16U 11101 |
32bits | F32 | 01110 | X32 10110 | X32U 11110 |
64bits | F64 | 01111 | X64 10111 | X64U 11111 |
首先在命令行中定义define
1 | vcs -sverilog -debug_all +define%s+CASENAME=\"%s\" |
尤其要注意CASENAME=\"%s\"
的转义“\”的应用,比如命令行被包含在python脚本内部,需要两次转义, 而shell可能只要一次
1 | def run(case,defines=""): |
否则verilog文件是无法获取CASENAM的意思
然后在verilog中通过宏取出
1 | fp_reg = $fopen({"./case/",`CASENAME,"/source_dpp.txt"},"r"); |
这种方式比较繁琐,而且转义嵌套难以理解,另外一种方便的方法如下
1 | 方法1 |
方法2是不是带优先级? 实际上是不带优先级
逻辑上if取的条件都是addr1的值,一定是互斥的,综合工具也能自动识别出这种if else
它有别于以下这种情况,这种情况下是真实带有优先级的电路,其中another_cond_A,another_cond_B
是独立的两个输入条件,和addr1的取值可能同时发生,所以不能被综合器当做查找表来对待。
同样的一份代码
src/main/scala/GCD.scala
src/test/scala/GCDTester.scala
其中生成vcd波形的代码1
2
3
4
5object GCDTester extends App {
iotesters.Driver.execute(Array("--target-dir", "generated", "--fint-write-vcd"), () => new GCD){
c => new GCDTests(c)
}
}
变量定义的3种方式
1 foo = bar (递归展开式变量)
会在引用$(foo)地方原地替换,直到不能再替换,这种方式称之为递归展开式变量
1 | foo = $(bar) |
以上例子会在@echo $(foo) 地方递归展开
缺点一 : 是当嵌套定义 foo = $(foo) bar
时讲进入死循环,导致Make失败
其他例子
x = $(y)
y = $(x) $(z)
同样会陷入死循环,所以这种定义方法只推荐在不引用变量的时候应用
缺点二 这种定义中如果使用函数,只会在变量被引用时展开,而不是在定义时展开
会使得Make的效率降低,另外有可能会在变量函数的引用会出现非预期结果,特别当变量
定义引用到shell wildcard 函数的情况下,出现不可控的结果
1 | x = foo |
1 | #include <stdio.h> |
riscv64-unknown-elf-gcc -S hello.c
只会生成汇编代码hello.s 不会生成.out文件
1 | .file "hello.c" |
首先生成.out文件riscv64-unknown-elf-gcc -o hello.out hello.c
然后反汇编 riscv64-unknown-elf-objdump -d hello.out > hello_disassemble.s
即可查看反汇编代码,搜索main函数如下,当然也包括其他内置函数1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48hello.out: file format elf64-littleriscv
Disassembly of section .text:
00000000000100b0 <_start>:
100b0: 0000d197 auipc gp,0xd
100b4: fd818193 addi gp,gp,-40 # 1d088 <__global_pointer$>
100b8: 84818513 addi a0,gp,-1976 # 1c8d0 <_edata>
100bc: 8d818613 addi a2,gp,-1832 # 1c960 <_end>
.....
...
000000000001038c <printf>:
1038c: 711d addi sp,sp,-96
1038e: f832 sd a2,48(sp)
10390: fc36 sd a3,56(sp)
....
..
0000000000010198 <main>:
10198: 1101 addi sp,sp,-32
1019a: ec06 sd ra,24(sp)
1019c: e822 sd s0,16(sp)
1019e: 1000 addi s0,sp,32
101a0: 67e9 lui a5,0x1a
101a2: a687b783 ld a5,-1432(a5) # 19a68 <__clzdi2+0x54>
101a6: fef43423 sd a5,-24(s0)
101aa: 67e9 lui a5,0x1a
101ac: a707a787 flw fa5,-1424(a5) # 19a70 <__clzdi2+0x5c>
101b0: fef42227 fsw fa5,-28(s0)
101b4: 67e9 lui a5,0x1a
101b6: a5078593 addi a1,a5,-1456 # 19a50 <__clzdi2+0x3c>
101ba: 67e9 lui a5,0x1a
101bc: a5878513 addi a0,a5,-1448 # 19a58 <__clzdi2+0x44>
101c0: 1cc000ef jal ra,1038c <printf>
101c4: fe843783 ld a5,-24(s0)
101c8: d027f753 fcvt.s.l fa4,a5
101cc: fe442787 flw fa5,-28(s0)
101d0: 10f777d3 fmul.s fa5,fa4,fa5
101d4: c02797d3 fcvt.l.s a5,fa5,rtz
101d8: fef43423 sd a5,-24(s0)
101dc: fe843783 ld a5,-24(s0)
101e0: 2781 sext.w a5,a5
101e2: 853e mv a0,a5
101e4: 60e2 ld ra,24(sp)
101e6: 6442 ld s0,16(sp)
101e8: 6105 addi sp,sp,32
101ea: 8082 ret
....
...
-print $x0
-p $x0
-p $pc
-info reg
-display $x0 ;每跑一步都会显示寄存器
-ni ;next inst
常见的方法
主要使用的是前两种方法
处理器之间不能通过消息传递模式通信,只能共享内存
处理器本身是异步执行的,消息队列没办法实现(接受消息和消耗消息有可能会冲突)
而共享内存的方法也有可能会导致冲突,可以为不同处理器划分不同地址空间来避免冲突
进程之间的通信最常见最安全的方法就是消息队列。
每个进程会维护一个消息队列(常见的是FIFO队列,也有带优先级的队列本文不做讨论)
进程A给进程B发消息,首先获取进程B消息队列(链表)的地址,将消息插入到链表后面。
当进程B执行是会去取消息队列最前面的消息然后执行。
由于进程A进程B是在同一处理器上占不同的时间片(跟操作系统进程的调度算法有关),
同一时刻消息队列不可能即recive 又 consume,所以不存在队列读写冲突的问题。
消息可以是简单的数据编码标志,也可以携带数据(数据起始地址以及长度),或者其他数据结构体格式
scala 的Actor的消息传递也是用此方式实现。