chinoll blog
0%

Posted on Edited on

函数副作用

获取服务器所有玩家的列表

1
FMLCommonHandler.instance().getMinecraftServerInstance().getPlayerList();

获取玩家所在的世界

1
player.world

Posted on Edited on

Decoupled:标准的Ready-Valid接口

Chisel提供的常用接口之一是 DecoupledIO，为传输数据提供一个随时有效的接口。
DecoupledIO的原理是，当源端有数据要传入时使能valid信号，并且将数据传入bits。
当接收器准备好接受数据时，使能ready信号，当ready和 valid在一个周期内都被使能时，数据被认为是被传输的。

DecoupledIO Bundle的字段：

  • valid: Output(Bool)
  • ready: Input(Bool)
  • bits: Output(UInt(width.W(or U)))

    Flipped

    Flipped会改变DecoupledIO的bits字段的默认方向,DecoupledIO的bits字段默认方向是Output，在使用Flipped之后，bits字段的方向会变为Input。
    下面两段代码是等价的。
    1
    val in = Decoupled(UInt(8.W))
    1
    2
    3
    4
    5
    val in = new Bundle {
      val valid = Output(Bool())
      val ready = Input(Bool())
      val bits  = Output(UInt(8.W))
    }
    在使用Flipped之后，DecoupledIO的输出方向会变成Input。
    下面两段代码也是等价的。
    1
    val in = Flipped(Decoupled(UInt(8.W)))
    1
    2
    3
    4
    5
    val in = new Bundle {
      val valid = Input(Bool())
      val ready = Output(Bool())
      val bits  = Input(UInt(8.W))
    }

    Queue

    Queue创建一个FIFO队列，两边都有Decoupled接口，允许背压(backpressure)。数据类型和元素的数量都是可配置的。

Code

首先用sbt创建一个Scala项目，sbt scala/scala3.g8
然后进入项目文件夹
修改build.sbt，将build.sbt修改为以下内容

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
ThisBuild / scalaVersion     := "2.12.13"
ThisBuild / version          := "0.1.0"
ThisBuild / organization     := "%ORGANIZATION%"

lazy val root = (project in file("."))
  .settings(
    name := "%NAME%",
    libraryDependencies ++= Seq(
      "edu.berkeley.cs" %% "chisel3" % "3.4.3",
      "edu.berkeley.cs" %% "chiseltest" % "0.3.3" % "test",
      "edu.berkeley.cs" %% "rocketchip" % "1.2.6",
      "edu.berkeley.cs" %% "chisel-iotesters" % "1.5.+"
    ),
    scalacOptions ++= Seq(
      "-Xsource:2.11",
      "-language:reflectiveCalls",
      "-deprecation",
      "-feature",
      "-Xcheckinit",
      "-P:chiselplugin:useBundlePlugin"
    ),
    addCompilerPlugin("edu.berkeley.cs" % "chisel3-plugin" % "3.4.3" cross CrossVersion.full),
    addCompilerPlugin("org.scalamacros" % "paradise" % "2.1.1" cross CrossVersion.full)
  )

然后创建一个src/main/scala/QueueTest/QueueTest.scala文件，里面填入以下内容

1
2
3
4
5
6
7
8
9
10
11
12
13
package QueueTest

import chisel3._
import chisel3.util._

class QueueTest extends Module {
  val io = IO(new Bundle {
    val in = Flipped(Decoupled(UInt(8.W)))
    val out = Decoupled(UInt(8.W))
  })
  val queue = Queue(io.in,2)    //创建一个Queue
  io.out <> queue
}

再创建一个src/main/scala/QueueTest/QueueTestSpec.scala文件，里面填入以下内容

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
48
49
50
51
package QueueTest
 
import chisel3._
import chisel3.util._
import chisel3.tester._
import chisel3.tester.RawTester.test
import org.scalatest.FreeSpec

object testMain extends App {
    test(new QueueTest) { c =>
      c.io.out.ready.poke(false.B)
      c.io.in.valid.poke(true.B)  // Enqueue an element
      c.io.in.bits.poke(42.U)
      println(s"Starting:")
      println(s"\tio.in: ready=${c.io.in.ready.peek().litValue}")
      println(s"\tio.out: valid=${c.io.out.valid.peek().litValue}, bits=${c.io.out.bits.peek().litValue}")
      c.clock.step(1)

    c.io.in.valid.poke(true.B)  // Enqueue another element
    c.io.in.bits.poke(43.U)
    // What do you think io.out.valid and io.out.bits will be?
    println(s"After first enqueue:")
    println(s"\tio.in: ready=${c.io.in.ready.peek().litValue}")
    println(s"\tio.out: valid=${c.io.out.valid.peek().litValue}, bits=${c.io.out.bits.peek().litValue}")
    c.clock.step(1)

    c.io.in.valid.poke(true.B)  // Read a element, attempt to enqueue
    c.io.in.bits.poke(44.U)
    c.io.out.ready.poke(true.B)
    // What do you think io.in.ready will be, and will this enqueue succeed, and what will be read?
    println(s"On first read:")
    println(s"\tio.in: ready=${c.io.in.ready.peek()}")
    println(s"\tio.out: valid=${c.io.out.valid.peek()}, bits=${c.io.out.bits.peek()}")
    c.clock.step(1)

    c.io.in.valid.poke(false.B)  // Read elements out
    c.io.out.ready.poke(true.B)
    // What do you think will be read here?
    println(s"On second read:")
    println(s"\tio.in: ready=${c.io.in.ready.peek()}")
    println(s"\tio.out: valid=${c.io.out.valid.peek()}, bits=${c.io.out.bits.peek()}")
    c.clock.step(1)

    // Will a third read produce anything?
    println(s"On third read:")
    println(s"\tio.in: ready=${c.io.in.ready.peek()}")
    println(s"\tio.out: valid=${c.io.out.valid.peek()}, bits=${c.io.out.bits.peek()}")
    c.clock.step(1)
    }
  Driver.execute(args, () => new QueueTest)   //生成 .v文件
}

最后打开命令行，再命令行里如下以下代码，下面这行代码会在generated/QueueTest里生成verilog代码

1
sbt "test:runMain QueueTest.testMain --target-dir generated/QueueTest"

仿真结果

Starting:
io.in: ready=1
io.out: valid=0, bits=0
After first enqueue:
io.in: ready=1
io.out: valid=1, bits=42
On first read:
io.in: ready=Bool(false)
io.out: valid=Bool(true), bits=UInt<8>(42)
On second read:
io.in: ready=Bool(true)
io.out: valid=Bool(true), bits=UInt<8>(43)
On third read:
io.in: ready=Bool(true)
io.out: valid=Bool(false), bits=UInt<8>(42)

参考资料

Interlude: Chisel Standard Library
What does Flipped() do in Chisel3?

Posted on Edited on

近日，python的官网更新了3.10.0的alpha版本，我个人非常期待这次python的版本更新，因为在3.10.x中，python加入了结构模式匹配(Structural Pattern Matching)的语法。
python的结构模式匹配(下文简称模式匹配)类似于C/C++的switch语句。但python的模式匹配比C语言的switch语句功能强大。下面就来看看python的模式匹配。
python的模式匹配使用的关键字时match。

1
2
3
4
5
6
7
#运行上面的代码，如果输入1则输出"您输入了1",否则输出"您没输入1"。
x = int(input())
match x:
    case 1:
        print("您输入了1")
    case _:
        print("您没输入1")

下面是等价的C语言代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>
int main(void) {
    int x;
    scanf("%d",&x);
    switch(x) {
        case 1:
            printf("您输入了1\n");
            break;
        default:
            printf("您没输入1\n");
	    break;
    }
    return 0;
}

python的模式匹配不仅能匹配数字，还能直接匹配字符串。

1
2
3
4
5
6
7
#运行上面的代码，如果输入hello则输出"hello match"，否则输出"match hello"。
x = input()
match x:
    case "hello":
        print("hello match")
    case _:
        print("match hello")

下面是等价的C语言代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>
#include <string.h>
int main(void) {
    char array[10];
    scanf("%s",array);
    switch(strcmp(array,"hello")) {
        case 0:
            printf("hello match\n");
            break;
        default:
            printf("match hello\n");
            break;
    }
    return 0;
}

python的match还可以在一条case语句里匹配多项 
1
2
3
4
5
6
x = int(input())
match x:
    case 1 | 2:
        print("input %d!" % (x))
    case _:
        print("no!")

下面是等价的C代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>
int main(void) {
    int x;
    scanf("%d",&x);
    switch(x) {
        case 1:
        case 2:
            printf("input %d\n",x);
            break;
        default:
            printf("no!\n");
            break;
    }
    return 0;
}

Posted on Edited on In

在介绍chinoGL之前，先来介绍一下openGL。
什么是OpenGL?
OpenGL（英语：Open Graphics Library，译名：开放图形库或者“开放式图形库”）是用于渲染2D、3D矢量图形的API。
OpenGL常用于CAD、虚拟现实、科学可视化程序和电子游戏开发。
OpenGL的高效实现（利用图形加速硬件）存在于Windows，部分UNIX平台和Mac OS。这些实现一般由显示设备厂商提供，而且非常依赖于该厂商提供的硬件。开放源代码库Mesa是一个纯基于软件的图形API，它的代码兼容于OpenGL。但是，由于许可证的原因，它只声称是一个“非常相似”的API。

什么是chinoGL？
chinoGL是用于渲染2D，3D矢量图形的跨平台API，chinoGL使用纯软件实现，不使用硬件加速（暂时）。
chinoGL的目标是用纯软件来实现openGL的所有功能，但API和OpenGL的API不兼容。chinoGL用于给学习图形学的新手提供具体算法的参考代码。
chinoGL目前能处理3D矢量图形吗？
由于chinoGL还处于起步阶段，所以还不支持3D矢量图形的处理和绘制，目前只能处理2D图形。

chinoGL