読者です 読者をやめる 読者になる 読者になる

shtaxxx日記

コンピュータアーキテクチャについて研究している研究者の日記や技術紹介

PythonとVeriloggenのデータフローライブラリでパイプライン回路をお手軽に設計する

Veriloggen 0.5.0をリリースしました。Python 3.5をサポートしたり、遅延評価・合成の仕組みを入れたり、かなり意欲的な更新です。

github.com

最近、GoogleTensorFlowが流行っていますね。データフローですね。そこで、今回の目玉は、パイプライン回路をお手軽に設計できる、データフローライブラリ(lib.dataflow)です。

データフローライブラリを使えば、、制御信号(ready, valid)を持つ、RTLでの設計が面倒なパイプライン回路をPythonだけで設計することができます。しかも、データフローの可視化にも対応しています。

更に、シミュレーションライブラリ(lib.simulation)を使えば、Pythonだけでそのまま回路シミュレーションもできます。

では早速試してみましょう!

準備(ダウンロード&インストール)

以前の記事を参考にインストールしてください。 Pythonのライブラリ一式に加えて、Icarus Verilogが別途インストールされている必要があります。

shtaxxx.hatenablog.com

早速データフローを書いてみる

veriloggen/examples/dataflow_example/ にある例を参考にデータフローモデルで回路を書いてみましょう。

ヘッダー部

Veriloggenを含む各種ライブラリをインポートします。

from __future__ import absolute_import
from __future__ import print_function
import sys
import os
from veriloggen import *

回路本体 入出力ポート

今回は x*c+y (Mutiply Add)を計算するデータフローパイプラインを作ります。

ModuleオブジェクトのmがVerilogのモジュール定義を管理します。データフローで書けるんじゃないの?と思うと思いますが、lib.dataflowもあくまでVeriloggenのライブラリの一つなので、Verilogソースコードの一部としてデータフローを高い抽象度で組み立てていきます。

x, vx, rxがそれぞれ入力xのdata・valid・readyの信号に対応します。入力y、出力zも同様です。入力cは定数を入力するためのポートなので、valid, readyがありません。

def mkMultAdd():
    m = Module('multadd')
    clk = m.Input('CLK')
    rst = m.Input('RST')

    # data in X
    x = m.Input('x', 32)
    vx = m.Input('vx')
    rx = m.Output('rx')
    
    # data in Y
    y = m.Input('y', 32)
    vy = m.Input('vy')
    ry = m.Output('ry')

    # constant
    c = m.Input('c', 32)

    # data out Z
    z = m.Output('z', 32)
    vz = m.Output('vz')
    rz = m.Input('rz')

回路本体 データフロー本体

lib.Dataflowオブジェクトのdfがデータフローの定義を管理します。データフローを追加するVerilogモジュールとデータフロー名のプレフィックス、クロック信号・リセット信号を引数で渡します。

まず、通常のVerilogの信号からデータフロー変数を作ります。df.input()メソッドに、データフロー変数を構成する生の信号を渡します。データフロー変数pxは、入力xのデータと制御信号で定義しています。入力yのデータフロー変数pyも同様です。

    # dataflow manager
    df = lib.Dataflow(m, 'df', clk, rst)

    # input -> dataflow variable
    px = df.input(x, valid=vx, ready=rx)
    py = df.input(y, valid=vy, ready=ry)

次に、実際に演算を定義しましょう。まず、x*cを定義します。入力xのデータフロー変数pxに定数cを掛け合わせます。データフロー管理オブジェクトdfをメソッドとして呼び出し、演算の定義を引数で渡します。データフローに基づく演算結果もデータフロー変数になるため、dfメソッド呼び出しは新しいデータフロー変数を返します。

次にyの加算を追加し、x*c+yを定義しましょう。pzは pxc(px*cの結果)とpy(入力yのデータフロー変数)との積で定義されています。

    # dataflow definitions
    pxc = df(px * c)
    pz = df(pxc + py)

そして、データフロー変数pzを生のVerilog信号に接続して、データフロー変数の世界からVerilogの世界に戻ります。 pz.output()メソッドに接続先のVerilog信号を渡せば、自動的に接続されます。

最後にmake_always()で順序回路としてデータフロー回路を出力します。ついでに、データフローの定義をdraw_graph()メソッドで可視化しましょう。これを使うにはpygraphvizのインストールが必要です。

    # dataflow variable -> output
    pz.output(z, valid=vz, ready=rz)

    # generate always statement
    df.make_always()

    # draw dataflow graph in png
    try:
        df.draw_graph()
    except:
        print('Dataflow graph could not be generated.', file=sys.stderr)
    
    return m

テストベンチを含めた記述全体

上記の回路本体だけではVerilogシミュレータでの検証ができないので、シミュレーション用コードを付加した、コード全体を以下に記します。

from __future__ import absolute_import
from __future__ import print_function
import sys
import os
from veriloggen import *

def mkMultAdd():
    m = Module('multadd')
    clk = m.Input('CLK')
    rst = m.Input('RST')

    # data in X
    x = m.Input('x', 32)
    vx = m.Input('vx')
    rx = m.Output('rx')
    
    # data in Y
    y = m.Input('y', 32)
    vy = m.Input('vy')
    ry = m.Output('ry')

    # constant
    c = m.Input('c', 32)

    # data out Z
    z = m.Output('z', 32)
    vz = m.Output('vz')
    rz = m.Input('rz')

    # dataflow manager
    df = lib.Dataflow(m, 'df', clk, rst)

    # input -> dataflow variable
    px = df.input(x, valid=vx, ready=rx)
    py = df.input(y, valid=vy, ready=ry)

    # dataflow definitions
    pxc = df(px * c)
    pz = df(pxc + py)

    # dataflow variable -> output
    pz.output(z, valid=vz, ready=rz)

    # generate always statement
    df.make_always()

    # draw dataflow graph in png
    try:
        df.draw_graph()
    except:
        print('Dataflow graph could not be generated.', file=sys.stderr)
    
    return m

def mkTest():
    m = Module('test')

    # target instance
    madd = mkMultAdd()
    
    # copy paras and ports
    params = m.copy_params(madd)
    ports = m.copy_sim_ports(madd)

    clk = ports['CLK']
    rst = ports['RST']
    
    x = ports['x']
    vx = ports['vx']
    rx = ports['rx']
    y = ports['y']
    vy = ports['vy']
    ry = ports['ry']
    c = ports['c']
    z = ports['z']
    vz = ports['vz']
    rz = ports['rz']
    
    uut = m.Instance(madd, 'uut',
                     params=m.connect_params(madd),
                     ports=m.connect_ports(madd))

    reset_done = m.Reg('reset_done', initval=0)
    
    reset_stmt = []
    reset_stmt.append( reset_done(0) )
    reset_stmt.append( x(0) )
    reset_stmt.append( y(0) )
    reset_stmt.append( c(8) )
    reset_stmt.append( vx(0) )
    reset_stmt.append( vy(0) )
    
    lib.simulation.setup_waveform(m, uut)
    lib.simulation.setup_clock(m, clk, hperiod=5)
    init = lib.simulation.setup_reset(m, rst, reset_stmt, period=100)

    nclk = lib.simulation.next_clock
    
    init.add(
        Delay(1000),
        reset_done(1),
        nclk(clk),
        Delay(10000),
        Systask('finish'),
    )
    
    x_count = m.TmpReg(32, initval=0)
    y_count = m.TmpReg(32, initval=0)
    z_count = m.TmpReg(32, initval=0)
    
    xfsm = lib.FSM(m, 'xfsm', clk, rst)
    xfsm.add(vx(0))
    xfsm.goto_next(cond=reset_done)
    xfsm.add(vx(1))
    xfsm.add(x.inc(), cond=rx)
    xfsm.add(x_count.inc(), cond=rx)
    xfsm.goto_next(cond=AndList(x_count==10, rx))
    xfsm.add(vx(0))
    xfsm.make_always()
    
    
    yfsm = lib.FSM(m, 'yfsm', clk, rst)
    yfsm.add(vy(0))
    yfsm.goto_next(cond=reset_done)
    yfsm.add(vy(1))
    yfsm.add(y.add(2), cond=ry)
    yfsm.add(y_count.inc(), cond=ry)
    yfsm.goto_next(cond=AndList(y_count==10, ry))
    yfsm.add(vy(0))
    yfsm.make_always()

    
    zfsm = lib.FSM(m, 'zfsm', clk, rst)
    zfsm.add(rz(0))
    zfsm.goto_next(cond=reset_done)
    zfsm.goto_next()
    zinit= zfsm.current()
    zfsm.add(rz(1), cond=vz)
    zfsm.goto_next(cond=vz)
    for i in range(10):
        zfsm.add(rz(0))
        zfsm.goto_next()
    zfsm.goto(zinit)
    zfsm.make_always()


    m.Always(Posedge(clk))(
        If(reset_done)(
            If(AndList(vx, rx))(
                Systask('display', 'x=%d', x)
            ),
            If(AndList(vy, ry))(
                Systask('display', 'y=%d', y)
            ),
            If(AndList(vz, rz))(
                Systask('display', 'z=%d', z)
            )
        )
    )
    
    return m
    
if __name__ == '__main__':
    test = mkTest()
    verilog = test.to_verilog('tmp.v')
    print(verilog)

    sim = lib.simulation.Simulator(test)
    rslt = sim.run()
    print(rslt)

    #sim.view_waveform()

スクリプト実行

では、上記のコードを実行してみましょう。test.pyなど、好きな名前で上記のコードを保存して、実行します。

python test.py

すると、Verilogの長いソースコードが表示された後、シミュレーション結果が表示されたはずです。

スクリプトを実行したディレクトリに"tmp.v"というVerilogのファイルができているので、中身を確認しましょう。その中に、以下の様な回路本体の記述があるはずです。

Veriloggenのコードでは、演算の関係だけを定義したのですが、実際に生成される回路は、入力が有効かどうかを示すvalidビットや、出力側で現在の値を受理できるかどうかを示すreadyビットでパイプラインの動作が制御される必要があるため、その制御ロジックが自動で追加されています。これは手では書きたくないですね・・・。

module multadd
(
  input CLK,
  input RST,
  input [(32 - 1):0] x,
  input vx,
  output rx,
  input [(32 - 1):0] y,
  input vy,
  output ry,
  input [(32 - 1):0] c,
  output [(32 - 1):0] z,
  output vz,
  input rz
);

  assign rx = (_df_ready_0 || (!_df_valid_0));
  assign ry = (_df_ready_1 || (!_df_valid_1));
  reg [(32 - 1):0] _df_data_0;
  reg _df_valid_0;
  wire _df_ready_0;
  assign _df_ready_0 = (_df_ready_2 || (!_df_valid_2));
  reg [(32 - 1):0] _df_data_1;
  reg _df_valid_1;
  wire _df_ready_1;
  assign _df_ready_1 = (_df_ready_2 || (!_df_valid_2));
  reg [(32 - 1):0] _df_data_2;
  reg _df_valid_2;
  wire _df_ready_2;
  assign _df_ready_2 = (_df_ready_3 || (!_df_valid_3));
  reg [(32 - 1):0] _df_data_3;
  reg _df_valid_3;
  wire _df_ready_3;
  assign _df_ready_3 = rz;
  assign z = _df_data_3;
  assign vz = _df_valid_3;

  always @(posedge CLK) begin
    if(RST) begin
      _df_data_0 <= 0;
      _df_valid_0 <= 0;
      _df_data_1 <= 0;
      _df_valid_1 <= 0;
      _df_data_2 <= 0;
      _df_valid_2 <= 0;
      _df_data_3 <= 0;
      _df_valid_3 <= 0;
    end else begin
      if(((vx && rx) && (_df_ready_0 || (!_df_valid_0)))) begin
        _df_data_0 <= (x * c);
      end 
      if((_df_ready_0 || (!_df_valid_0))) begin
        _df_valid_0 <= (vx && rx);
      end 
      if(((vy && ry) && (_df_ready_1 || (!_df_valid_1)))) begin
        _df_data_1 <= y;
      end 
      if((_df_ready_1 || (!_df_valid_1))) begin
        _df_valid_1 <= (vy && ry);
      end 
      if((((_df_valid_0 && _df_ready_0) && (_df_valid_1 && _df_ready_1)) && (_df_ready_2 || (!_df_valid_2)))) begin
        _df_data_2 <= (_df_data_0 + _df_data_1);
      end 
      if((_df_ready_2 || (!_df_valid_2))) begin
        _df_valid_2 <= ((_df_valid_0 && _df_ready_0) && (_df_valid_1 && _df_ready_1));
      end 
      if(((_df_valid_2 && _df_ready_2) && (_df_ready_3 || (!_df_valid_3)))) begin
        _df_data_3 <= _df_data_2;
      end 
      if((_df_ready_3 || (!_df_valid_3))) begin
        _df_valid_3 <= (_df_valid_2 && _df_ready_2);
      end 
    end
  end


endmodule

データフロー定義の可視化

定義したデータフローがどのようなものか、ソースコードだけではイメージしづらいので、可視化しましょう。 Pygraphvizが正しくインストールされていれば、すでに df.draw_graph() でデータフロー定義の可視化結果が画像として生成されているので、それを開きます。今回の例ではout.pngです。

f:id:sxhxtxa:20151117013146p:plain

長方形がデータフロー変数、楕円が演算子、三角形がVerilogの生信号、台形がデータフロー変数を定義するVerilogの生信号の組をそれぞれ表しています。

Verilog信号のx, vx, rxでデータフロー変数が定義されており、それとcを掛け合わせたものが_df_data_0となっています。そしてそれと、Verilog信号y, vy, ryで定義されるデータフロー変数の1ステージ分遅れた値が足し合わされ、_df_data_2、_df_data_3と伝搬していき、出力zに接続されています。

途中、データフロー変数が自動で追加されるのは、入力された世代(段数)が同じ値ごとに演算を適用するためです。入力からの段数が違うもの同士を演算する場合、段数が少ない方に調整用のデータフロー変数が自動で追加されます。Verilogでの設計の場合には、時刻・段数が違う場合には設計者が明示的にレジスタを挟む必要がありますが、Veriloggenのデータフローライブラリの場合には、自動的に調整を行ってくれます。

シミュレーション

先ほどのスクリプト実行で表示されたシミュレーション結果は以下の通りのはずです。 今回の例ではc=8なので、xの10倍の値がzから出力されていればOKです。

VCD info: dumpfile uut.vcd opened for output.
x=         1
y=         2
x=         2
y=         4
x=         3
y=         6
x=         4
y=         8
z=        10
x=         5
y=        10
z=        20
x=         6
y=        12
z=        30
x=         7
y=        14
z=        40
x=         8
y=        16
z=        50
x=         9
y=        18
z=        60
x=        10
y=        20
z=        70
z=        80
z=        90
z=       100

テキストではわかりにくいので、波形で確認しましょう。GTKwaveをインストールした上で、上記スクリプトの最終行"#sim.view_waveform()"のコメントアウトを削除して、再実行すればよいGTKwaveで波形が表示されます。もしくは、以下の様に直接GTKwaveを起動しても良いです。

gtkwave --giga uut.vcd &

図の様に、x, yの入力に応じて、zの値が変化していることが確認できます。上記のシミュレーションパターンでは、出力zのready信号rzを意図的にぱたぱた変化させ、連続的にデータを受信できないようなケースを検証しています。rzの変化に応じて、パイプライン全体が制御されているのがわかります。

f:id:sxhxtxa:20151117012915p:plain

まとめ

Veriloggenのデータフローライブラリを使うと、お手軽に高性能なデータフローパイプライン回路がPythonだけで開発できます。データフロー定義の可視化もできます。FPGAなどのハードウェアアクセレータで高い性能・電力効率を達成するには、高い稼働率を持つ演算パイプラインを構築することが非常に重要です。そのような場合にも、Veriloggenを使えば、既存のHDLよりも少ない労力で、既存の高位合成よりも高い性能のハードウェアを設計することができます。