Posts Tagged with "Design"

既に発行済みのブログであっても適宜修正・追加することがあります。
We may make changes and additions to blogs already published.

Pongと強化学習 (38)

posted by sakurai on July 5, 2024 #832

3x3 Convolutional LayerのBSVコードを要求してみます。


Bluespec SystemVerilog(BSV)で3x3の畳み込み層を実装するためのコンセプトを理解することは重要ですが、直接的なBSVコードの提供はできません。ただし、畳み込み層の基本的な概念をもとに、疑似コードや概念的な説明を提供することで、BSVでの実装への理解を深めることができます。

3x3畳み込み層の基本概念

3x3畳み込み層は、入力特徴マップ上で3x3のカーネル(またはフィルター)をスライドさせながら、カーネルと入力の各部分の要素積の和を計算します。この操作により、画像の特徴を抽出します。

疑似コード

以下の疑似コードは、3x3畳み込み層の操作を概念的に示しています。このコードは、BSVの構文ではなく、一般的なプログラミングの疑似コードです。

module mkConvolution3x3#(parameter WIDTH = 256, HEIGHT = 256)(
    input bit [WIDTH-1:0][HEIGHT-1:0] inputFeatureMap,
    input bit [8:0] kernel,  // 3x3カーネル、フラット化された9ビットの値
    output bit [WIDTH-2:0][HEIGHT-2:0] outputFeatureMap // 出力サイズはストライドとパディングに依存
);
    for (Integer row = 1; row < HEIGHT-1; row = row + 1) {
        for (Integer col = 1; col < WIDTH-1; col = col + 1) {
            Integer sum = 0;
            for (Integer kr = -1; kr <= 1; kr = kr + 1) {
                for (Integer kc = -1; kc <= 1; kc = kc + 1) {
                    // 入力特徴マップとカーネルの要素積の和を計算
                    sum += inputFeatureMap[row+kr][col+kc] * kernel[(kr+1)*3 + (kc+1)];
                }
            }
            // 出力特徴マップに畳み込み結果を代入
            outputFeatureMap[row-1][col-1] = sum;
        }
    }
endmodule

実装のポイント

  • フィルターと入力のデータタイプ: 上記の例では、簡略化のためにビット型を使用していますが、実際には固定小数点数や浮動小数点数を使用することが多いです。BSVでは、適切なデータタイプを使用して精度を管理します。
  • パラメータ化: カーネルサイズ、入力と出力のサイズ、ストライド、パディングなどのパラメータをモジュールの引数として設定できるようにします。
  • 並列処理: 畳み込み演算はデータの異なる部分で独立して行うことができるため、BSVの並列処理機能を活用して性能を向上させることができます。

左矢前のブログ 次のブログ右矢

Pongと強化学習 (37)

posted by sakurai on July 4, 2024 #831

mobilenetの論文を見ると、図831.1のように通常のレイヤと比べて深さ方向のコンボリューションが特徴のようなので、確認してみました。

図%%.1
図831.1 通常のCNNとMobilenet CNNの違い

Pongゲームの画像のように、入力チャネルが1つだけ(深さが1ビット)の場合、Depthwise Convolutionを適用するという考え方は通常の畳み込みと同義になります。Depthwise Convolutionの主な利点は、入力チャネルごとに畳み込みを行い、パラメータの数と計算コストを削減することにありますが、入力チャネルが1つだけの場合、この利点は生じません。

通常のCNNでは、3x3の畳み込み層に続いてバッチ正規化層とReLU活性化層が配置されます。この構成は、複数チャネルを持つ画像に対して非常に効果的で、特徴抽出と非線形性の導入により、高度なパターンを学習することができます。

MobileNetのようなアーキテクチャが採用するDepthwise Separable Convolutionは、計算コストとモデルのサイズを削減する目的で設計されていますが、Pongゲームのような1チャネル(または深さが1ビット)の入力に対しては、単純な3x3の畳み込み層を使用する方が適切です。この場合、計算の複雑さを増やすことなく、必要な特徴抽出を行うことができます。

PongゲームのCNN構成

Pongゲーム用のシンプルなCNNアーキテクチャでは、次のような層を検討することができます:

  1. 3x3 Convolutional Layer: 入力画像に対して畳み込みを行い、基本的な特徴を抽出します。
  2. Batch Normalization Layer (オプション): 学習を安定させ、高速化するために使用されることがあります。
  3. ReLU Activation Layer: 非線形性を導入し、モデルの表現力を高めます。

このような構成は、Pongゲームのシンプルな画像を効率的に処理し、ゲームの状態を理解するために必要な特徴を抽出するのに役立ちます。計算コストとモデルの複雑さを考慮しながら、タスクの要件に最適なアーキテクチャを選択することが重要です。


左矢前のブログ 次のブログ右矢

bsvのMakefile作成 (3)

posted by sakurai on July 3, 2024 #830

Makefile

過去記事でbsvのMakefileを作成しましたが、その後この記事によりtop.vが不要なことが判明したのでMakefileを再作成しました。以前のものよりtop.vを削除した分だけ若干シンプルになっています。

# ファイル名の生成
BSRCS = $(wildcard *.bsv) # BSVソースファイル
BASRCS = $(addprefix mk, $(addsuffix .ba, $(basename $(BSRCS)))) # BA中間ファイル
VSRCS = $(addprefix mk, $(addsuffix .v, $(basename $(BSRCS)))) # Verilogファイル

# .PHONY ターゲットの定義
.PHONY: all bsv_view verilog_view clean

# 全体のターゲット定義
all: bsv_view verilog_view

# BSV波形ビューアの起動
bsv_view: bsim.vcd
    gtkwave -A bsim.vcd

# BSV波形ファイルの生成
bsim.vcd: mkTb.exe
    ./mkTb.exe -V bsim.vcd

# BSV実行ファイルの生成
mkTb.exe: $(BASRCS)
    bsc -sim -e mkTb -parallel-sim-link 4 -o mkTb.exe

# BSVファイルのコンパイル
mk%.ba: %.bsv
    time bsc -sim -u -steps-warn-interval 1000000 -steps 8000000 -suppress-warnings T0054 $<

# Verilog波形ビューアの起動
verilog_view: verilog.vcd
    gtkwave -A verilog.vcd

# Verilog波形ファイルの生成
verilog.vcd: mkTb.exev
    ./mkTb.exev +bscvcd=verilog.vcd

# Verilog実行ファイルの生成
mkTb.exev: $(VSRCS)
     bsc -verilog -e mkTb -parallel-sim-link 4 -o mkTb.exev

# BSVファイルからVerilogファイルを生成
mk%.v: %.bsv
    time bsc -verilog -u -steps-warn-interval 1000000 -steps 8000000 -suppress-warnings T0054 $<

# クリーンアップ
clean:
    @rm -f mk*.v
    @rm -f *.bi *.bo *.ba a.out \#*
    @rm -f *.cxx *.h *.o *.so *.bexe
    @rm -f *.exe *.exev
    @rm -f *.vcd *~ *.fsdb *.log

依存関係グラフ

ここで、’Makefile'の依存関係の可視化の記事のプログラムをそのまま用いて、

$ LANG=C make -np | python3 make_p_to_json.py > graph.json; python json_to_dot.py workflow.png; xv workflow.png

このコマンドにより作成した依存関係図を図830.1に示します。

図%%.1
図830.1 依存関係図

左矢前のブログ 次のブログ右矢

Pongと強化学習 (36)

posted by sakurai on July 1, 2024 #828

プーリング層を実装するBSVコードを要求してみます。


Bluespec SystemVerilog(BSV)でプーリング層、特にMax Pooling層を実装するための基本的なアプローチを示します。プーリング層は、入力特徴マップのサブサンプリングを行い、特徴の位置変化に対するロバスト性を向上させるとともに、計算量とパラメータの数を減少させる役割を持っています。Max Poolingは、そのウィンドウ内の最大値を出力することでこの処理を行います。

以下の例は、2x2 Max Poolingを行うBSVモジュールの疑似コードです。実際の実装では、入力サイズやデータタイプに応じて適切に調整する必要があります。

interface PoolingIface;
    method ActionValue#(Bit#(32)) apply(Bit#(32) in1, Bit#(32) in2, Bit#(32) in3, Bit#(32) in4);
endinterface

module mkMaxPooling(PoolingIface);
    method ActionValue#(Bit#(32)) apply(Bit#(32) in1, Bit#(32) in2, Bit#(32) in3, Bit#(32) in4);
        Bit#(32) maxVal = in1;
        if (in2 > maxVal) maxVal = in2;
        if (in3 > maxVal) maxVal = in3;
        if (in4 > maxVal) maxVal = in4;
        return maxVal;
    endmethod
endmodule

このコードスニペットでは、mkMaxPoolingモジュールがPoolingIfaceインターフェイスを実装しています。applyメソッドは、4つの入力(2x2のプーリングウィンドウを想定)を受け取り、その中の最大値を返します。この簡単な例では、32ビット幅のビット型(Bit#(32))を使用していますが、実際のデータタイプはアプリケーションによって異なります。

注意点と拡張

  • パラメータ化と柔軟性: 実際のアプリケーションでは、プーリングウィンドウのサイズやストライド、パディングなどをパラメータとしてモジュールに渡すことができるように、モジュールをより柔軟に設計することが望まれます。
  • 並列処理: プーリング層の計算は、入力特徴マップの異なる領域で独立に行うことができるため、BSVの強力な並列処理能力を活用して、性能を向上させることが可能です。
  • データタイプとビット幅: 固定小数点数や浮動小数点数など、適切な数値表現を選択することが重要です。また、ビット幅は計算精度とハードウェアリソースのトレードオフを考慮して選定します。

この疑似コードと説明が、BSVでのプーリング層実装の出発点となり、具体的な実装への理解を深める助けになれば幸いです。


左矢前のブログ 次のブログ右矢

Pongと強化学習 (35)

posted by sakurai on June 28, 2024 #827

活性化関数についてBSVコードを要求してみます。


Bluespec SystemVerilog (BSV) で活性化関数であるReLU (Rectified Linear Unit) を実装する例を示します。ReLUは、入力が正であればその値を出力し、負であれば0を出力する非常にシンプルな関数です。この特性は、ハードウェアでの実装においても比較的直接的に表現することが可能です。

以下は、簡単なReLU活性化関数のBSVモジュールの例です。この例では、入力として32ビットの固定小数点数を想定していますが、実際のアプリケーションに応じてデータタイプやビット幅は調整する必要があります。

module mkReLU#(Integer dataWidth = 32)(ReLUIface);
    // ReLUIfaceは、入力と出力を含むインターフェイスを提供します。
    method ActionValue#(Bit#(dataWidth)) apply(Bit#(dataWidth) input);
        // ReLUの計算: 入力が0より大きい場合はそのまま、そうでなければ0を返す
        Bit#(dataWidth) output = (input > 0) ? input : 0;
        return output;
    endmethod
endmodule

このコードスニペットでは、mkReLUという名前のモジュールが定義されています。このモジュールは、ReLUIfaceというインターフェイスを通じて、ReLU関数のapplyメソッドを提供します。このメソッドは、入力値を受け取り、ReLUの計算を行った結果を返します。

注意点と拡張

  • データタイプとビット幅: 上記の例では、入力と出力のデータタイプをBit#(dataWidth)としていますが、実際のアプリケーションによっては、符号付き数や固定小数点数を使用する方が適切な場合があります。また、ビット幅(dataWidth)は、使用するデータの範囲や精度に応じて調整してください。
  • 性能と最適化: BSVで記述されたハードウェアモジュールの性能は、FPGAやASICでの実装によって異なります。特に、複数のReLUユニットを並列に実行することで、高いスループットを実現することが可能です。また、リソース使用量を抑えるための最適化も重要です。

この例は、BSVを用いたReLU活性化関数の基本的な実装を示しています。


左矢前のブログ 次のブログ右矢

Pongと強化学習 (34)

posted by sakurai on June 27, 2024 #826

次のステップのPointwise Convolutionのコードを要求してみます。


Pointwise Convolution(1x1の畳み込み)は、チャネル間の組み合わせを学習するために使用されます。この操作では、各位置において、入力チャネルの深さ方向に1x1のカーネルを適用して、出力チャネルを生成します。しかし、Bluespec SystemVerilog (BSV) における具体的なコードの提供は直接行えませんが、Pointwise Convolutionの実装に向けた疑似コードと概念説明を提供できます。

Pointwise Convolutionの概念

  • 入力: $H \times W \times C_{in}$ のサイズを持つ入力特徴マップ。ここで、$H$ は高さ、$W$ は幅、$C_{in}$ は入力チャネル数です。
  • カーネル: $1 \times 1 \times C_{in} \times C_{out}$のサイズを持つカーネル。ここで、$C_{out}$ は出力チャネル数です。
  • 出力: $H \times W \times C_{out}$ のサイズを持つ出力特徴マップ。

疑似コード

module PointwiseConvolution#(parameter WIDTH = 256, HEIGHT = 256, C_IN = 1, C_OUT = 1)(
    input bit [WIDTH-1:0][HEIGHT-1:0][C_IN-1:0] inputFeatureMap,
    input bit [C_IN-1:0][C_OUT-1:0] kernel,
    output bit [WIDTH-1:0][HEIGHT-1:0][C_OUT-1:0] outputFeatureMap
);
    // 点畳み込み処理の実装
    for (Integer h = 0; h < HEIGHT; h = h + 1) {
        for (Integer w = 0; w < WIDTH; w = w + 1) {
            for (Integer co = 0; co < C_OUT; co = co + 1) {
                bit convolutionResult = 0;
                for (Integer ci = 0; ci < C_IN; ci = ci + 1) {
                    convolutionResult = convolutionResult + inputFeatureMap[h][w][ci] * kernel[ci][co];
                }
                outputFeatureMap[h][w][co] = convolutionResult;
            }
        }
    }
endmodule

実装のヒント

  • パラメータ化: カーネルサイズやチャネル数など、異なるネットワーク設定に柔軟に対応できるように、モジュールのパラメータを適切に定義します。
  • 並列処理: 出力チャネルごと、あるいはピクセル位置ごとに処理を並列化することで、計算の高速化を図ります。BSVの強力な並列処理能力を活用してください。
  • リソース管理: FPGAのリソース(メモリ、演算ユニットなど)の限界を考慮しながら、効率的な実装を心がけます。不要なデータの転送や演算を避けるために、データの局所性を高める工夫が必要です。

この疑似コードと概念説明が、BSVでPointwise Convolutionを設計する際の出発点となり、より詳細な実装に向けた理解の助けになれば幸いです。


左矢前のブログ 次のブログ右矢

Pongと強化学習 (33)

posted by sakurai on June 26, 2024 #825

前稿で、Depthwise ConvolutionとPointwise Convolutionの2つのステップが出てきたので、ひとつずつコードを要求してみます。


直接的なBSV(Bluespec SystemVerilog)のコードを提供することは私の能力を超えていますが、Depthwise Convolutionを設計するための一般的なアプローチと概念を説明し、それに基づいた疑似コードを提供することで、BSVでの実装に向けた理解を深めるお手伝いができるかと思います。

Depthwise Convolutionの概要

Depthwise Convolutionでは、各入力チャネルに対して個別の畳み込みフィルターが適用されます。256x256x1の画像に対してこの処理を行う場合、各ピクセルに対して指定されたカーネル(例えば、3x3や5x5)を適用し、出力画像の対応する位置に畳み込み結果を格納します。1チャネルの画像の場合、Depthwise Convolutionは通常の畳み込みと同様になりますが、処理はチャネルごとに分離して行われます。

疑似コード

以下の疑似コードは、256x256の画像に対する3x3カーネルを用いたDepthwise Convolutionの概念を示しています。この例では、シンプルさを保つためにパディングとストライドは考慮していません。

module DepthwiseConvolution#(parameter WIDTH = 256, HEIGHT = 256, KERNEL_SIZE = 3)(
    input bit [WIDTH-1:0][HEIGHT-1:0] image,
    input bit [KERNEL_SIZE-1:0][KERNEL_SIZE-1:0] kernel,
    output bit [WIDTH-2:0][HEIGHT-2:0] outputImage // 出力サイズはパディングなしのため調整
);
    // 畳み込み処理の実装
    for (Integer row = 1; row < HEIGHT-1; row = row + 1) {
        for (Integer col = 1; col < WIDTH-1; col = col + 1) {
            bit convolutionResult = 0;
            for (Integer kr = -1; kr <= 1; kr = kr + 1) {
                for (Integer kc = -1; kc <= 1; kc = kc + 1) {
                    convolutionResult = convolutionResult + image[row+kr][col+kc] * kernel[kr+1][kc+1];
                }
            }
            outputImage[row-1][col-1] = convolutionResult > threshold; // 閾値を超えたら1, そうでなければ0
        }
    }
endmodule

実装のヒント

  • パラメータ化: 畳み込み層をパラメータ化することで、異なるサイズのカーネルや入力サイズに柔軟に対応できるようにします。
  • 並列処理: BSVの強力な並列処理機能を活用し、複数のピクセルに対する畳み込みを同時に実行できるようにします。特に、FPGAなどのハードウェアでは、この特性を最大限に利用することで高速な処理が可能になります。
  • 最適化: ハードウェア資源の利用を最適化するために、不要な計算の削減やメモリアクセスの最適化に注意を払います。また、固定小数点演算などのテクニックを用いて精度とリソース使用量のバランスを取ることも重要です。

BSVでの実際のコーディングには、Bluespec SystemVerilogの構文と特性に従って、上記の概念を具体的なコードに落とし込む必要があります。


左矢前のブログ 次のブログ右矢

Prismの拡張

posted by sakurai on June 25, 2024 #824

bsvのコードハイライティングを行う際に、Prism.jsを利用しました。ただしbsvはなくverilogまでなので、以下のjsを追加して文法を拡張しています。

bsv対応のcssやjsはChatGPTに作成してもらい人間がデバッグしました。ChatGPTはあっという間にほぼ完成度の高いcssやjsを作成するのですが、どうしてもバグが残ります。それをChatGPTに取らせるには却って工数がかかるので、人間がとってやったほうが今のところ全体工数が少なくて済みます。

そのためにはChatGPTをスーパーバイズする必要があるので、ChatGPTよりも知識が上である必要があります。つまり「ChatGPTには知ってることを聞け=知らないことを聞くな」と言うことです。

ソースコード

Prism.languages.bsv = {
  'comment': [
    {
      pattern: /\/\/.*/,
      alias: 'comment'
    },
    {
      pattern: /\/\*[\s\S]*?\*\//,
      alias: 'comment'
    }
  ],
  'module-name-outer': {
    pattern: /(\bmodule\s+|endmodule\s*:\s*)([a-z_]\w*)/,
    inside: {
      'keyword': /\b(?:module|endmodule)\b/,
      'punctuation': /:/,
      'module-name': /\b[a-z_]\w*\b/
    }
  },
  'interface-name-outer': {
    pattern: /(\binterface\s+|endinterface\s*:\s*)([A-Z]\w*)/,
    inside: {
      'keyword': /\b(?:interface|endinterface)\b/,
      'punctuation': /:/,
      'interface-name': /\b[A-Z]\w*\b/
    }
  },
  'package-name-outer': {
    pattern: /(\bpackage\s+|endpackage\s*:\s+|import\s+)([A-Z]\w*)/,
    inside: {
      'keyword': /\b(?:package|endpackage|import)\b/,
      'punctuation': /:/,
      'package-name': /\b[A-Z]\w*\b/
    }
  },
  'rule-name-outer': {
    pattern: /(\brule\s+|endrule\s*:\s*)([a-z_]\w*)/,
    inside: {
      'keyword': /\b(?:rule|endrule)\b/,
      'punctuation': /:/,
      'rule-name': /\b[a-z_]\w*\b/
    }
  },
  'method-name-outer': {
    pattern: /(\bmethod\s+|endmethod\s*:\s*)([a-z_]\w*)/,
    inside: {
      'keyword': /\b(?:method|endmethod)\b/,
      'punctuation': /:/,
      'method-name': /\b[a-z_]\w*\b/
    }
  },
  'return-variable': {
    pattern: /(\breturn\s+)([a-z_]\w*)/,
    inside: {
      'keyword': /\breturn\b/,
      'variable': /\b[a-z_]\w*\b/
    }
  },
  'keyword': {
    pattern: /\b(?:action|endaction|await|clocked_by|default_clock|deriving|else|function|endfunction|import|if|inout|input|interface|endinterface|match|method|endmethod|module|endmodule|no_clock|output|package|parameter|provisos|register|rule|endrule|rules|struct|type|typedef|union|value_of|var|while|seq|endseq|endpackage|return|let|case|endcase|delay|noAction|for|continue)\b/,
  },
  'right-hand-variable': {
    pattern: /([a-z_]\w*)\s*(?=\s*<=)/,
    alias: 'variable'
  },
  'right-hand-variable-operator': {
    pattern: /(\s*<=\s*)([a-z_]\w*)/,
    inside: {
      'operator': /<=/,
      'variable': /\b[a-z_]\w*\b/
    }
  },
  'generator-variable': {
    pattern: /([a-z_]\w*)\s*(?=\s*<-\s*)/,
    alias: 'variable'
  },
  'generator-operator': {
    pattern: /(\s*<-\s*)([a-z_]\w*)/,
    inside: {
      'operator': /<-/,
      'function': /\b[a-z_]\w*\b/
    }
  },
  'assignment-variable': {
    pattern: /([a-z_]\w*)\s*(?=\s*<=)/,
    alias: 'variable'
  },
  'function-definition': {
    pattern: /(?:\bfunction\s+\w+\s+)([a-z_]\w*)/,
    alias: 'function'
  },
  'system-function': {
    pattern: /\$\w+/,
    alias: 'function'
  },
  'function-call': {
    pattern: /(\b[a-z_]\w*)(?=\s*\()/,
    alias: 'function'
  },
  'function-call-no-parens': {
    pattern: /\b[a-z_]\w*(?=\s*;)/,
    alias: 'function'
  },
  'type': {
    pattern: /\b(Bit#\(\d+\)|UInt#\(\d+\)|Int#\(\d+\)|Bool|Maybe|Tuple2|Tuple3|Tuple4|Tuple5|Tuple6|Tuple7|Tuple8|Vector|Vector#\(\d+\)|Integer|Real|String|Fmt|Reg|FIFO|Clock|Reset|Inout|Action|ActionValue|Rules|UInt|Int)\b/,
    alias: 'type'
  },
  'directive': {
    pattern: /\(\*[\s\S]*?\*\)/,
    inside: {
      'comment': {
        pattern: /(\(\*|\*\))/,
        alias: 'comment'
      },
      'string': {
        pattern: /[\s\S]+/,
        alias: 'string'
      }
    }
  },
  'number': {
    pattern: /\b\d+(\.\d+)?([eE][+-]?\d+)?\b/,
    alias: 'number'
  },
  'class-name': {
    pattern: /\b[A-Z][a-zA-Z0-9_]*\b/,
    alias: 'class-name'
  },
  'string': {
    pattern: /(^|[^\\])(["'`])(?:\\.|(?!\2)[^\\\r\n])*\2/
  },
  'operator': {
    pattern: /(\+|\-|\!|\~|\&|\~\&|\||\~\||\^|\~\^|\^\~|\*|\/|\%|\<\<|\>\>|\<\=|\>\=|\<|\>|\=\=|\!\=|\&\&|\|\|)/
  }
};

左矢前のブログ 次のブログ右矢

BSVの例題 (4)

posted by sakurai on June 24, 2024 #823

もともとinuseが不定だったのはバグと言えます。ただ、初期値を設定する代わりに最初にputdownシーケンスを入れたら良いと考え、実行したところうまく動作しました。ついでにChatGPTにコメントを付けてもらいました。以下にソースコードを示します。

ソースコード

//
// CBG SQUANDERER : Dining Philosophers In Bluespec
// (C) 2012 David Greaves, University of Cambridge

// 必要なモジュールをインポート
import StmtFSM::*;

// スプーンのインターフェースを定義
interface Spoon_if;
   method Action pickup;             // スプーンを持ち上げるメソッド
   method Action putdown;            // スプーンを置くメソッド
   method Action putnumber(UInt#(5) value); // スプーンに番号を設定するメソッド
endinterface

// スプーンのモジュールを定義
(* synthesize *)
module spoon (Spoon_if);
   Reg#(Bool) inuse <- mkReg(?);       // スプーンの使用状況を表すレジスタ
   Reg#(UInt#(5)) number <- mkReg(?);  // スプーンの番号を保持するレジスタ

   // スプーンを持ち上げるメソッドの実装
   method Action pickup if (!inuse);
     inuse <= True;
   endmethod

   // スプーンを置くメソッドの実装
   method Action putdown;
     inuse <= False;
   endmethod

   // スプーンに番号を設定するメソッドの実装
   method Action putnumber(UInt#(5) value);
     number <= value;
   endmethod
endmodule

// 哲学者のベンチモジュールを定義
(* synthesize *)
module philoBENCH (Empty);
   // 5つのスプーンインスタンスを作成
   Spoon_if spoon0 <- spoon; 
   Spoon_if spoon1 <- spoon; 
   Spoon_if spoon2 <- spoon; 
   Spoon_if spoon3 <- spoon; 
   Spoon_if spoon4 <- spoon; 

   // 5人の哲学者インスタンスを作成
   Diner_if din0 <- mkDiner(0, 7, 7, spoon0, spoon1);
   Diner_if din1 <- mkDiner(1, 6, 4, spoon2, spoon1); // <---- 逆順で持ち上げる
   Diner_if din2 <- mkDiner(2, 5, 9, spoon2, spoon3);
   Diner_if din3 <- mkDiner(3, 6, 6, spoon3, spoon4);
   Diner_if din4 <- mkDiner(4, 8, 8, spoon4, spoon0);

   // タイマーのレジスタを作成
   Reg#(UInt#(15)) timer <- mkReg(1000);

   // タイマーをカウントダウンするルール
   rule foo;
      timer <= timer - 1;
      if (timer == 0) $finish;
   endrule
endmodule: philoBENCH

// ランダム数生成器のインターフェースを定義
interface Random_if;
   method ActionValue#(UInt#(15)) gen; // ランダムな値を生成するメソッド
endinterface    

// ランダム数生成器のモジュールを定義
module mkRandom_gen #(UInt#(15) seed) (Random_if);
   Reg#(UInt#(15)) prbs <- mkReg(seed); // ランダム数を保持するレジスタ

   // ランダムな値を生成するメソッドの実装
   method ActionValue#(UInt#(15)) gen;
      prbs <= (prbs << 1) | (((prbs >> 14) ^ (prbs >> 13)) & 1); // シフトとXORを使用してランダム値を生成
      return prbs;
   endmethod
endmodule 

// 哲学者のインターフェースを定義
interface Diner_if;
endinterface

// 哲学者のモジュールを定義
module mkDiner #(UInt#(5) number, UInt#(15) on, UInt#(15) seed) (Spoon_if left, Spoon_if right, Diner_if i);
   Reg#(Bool) eating <- mkReg(?);      // 食事中かどうかを表すレジスタ
   Reg#(UInt#(15)) timer <- mkReg(0);  // タイマーのレジスタ
   Random_if random<- mkRandom_gen(seed); // ランダム数生成器のインスタンスを作成

   // タイマーをカウントダウンするルール
   rule foo (timer != 0);
      timer <= timer - 1;
   endrule

   // 哲学者の動作シーケンスを定義
   Stmt seq_behaviour = (seq
      while (True) seq
         action // 初期状態を確定するサイクル(食事の後だったのを前に持ってきた)
            eating <= False;
            left.putdown; 
            right.putdown;
            left.putnumber(?);
            right.putnumber(?);
         endaction
         action
            UInt#(15) x <- random.gen;
            timer <= x & 31; // ランダムな時間を設定
         endaction
         await(timer== 0);
         left.pickup; // 左のスプーンを持ち上げる
         action
            UInt#(15) x <- random.gen;
            timer <= x & 31; // ランダムな時間を設定
         endaction
         await(timer== 0);
         right.pickup; // 右のスプーンを持ち上げる
         action
            eating <= True; // 食事を開始
            timer <= on;    // 食事時間を設定
            left.putnumber(number);  // スプーンに哲学者の番号を設定
            right.putnumber(number); // スプーンに哲学者の番号を設定
         endaction
         await(timer==0);
      endseq
   endseq);

   // シーケンスを自動的に実行するFSMを作成
   mkAutoFSM(seq_behaviour);
endmodule

以下にシミュレーション波形を示します。putdownは終了処理だった(pickup→putdown)ものをシーケンスの最初に持ってくる(putdown→pickup)ことにより、初期状態が確定し不定が継続しなくなりました。

図%%.1
図823.1 verilogシミュレーション

図らずも元のコードのバグを発見しましたが、あえて不定を設定しないと見つからないため、シミュレーションは不定も込みで実施したほうが良いと思います。


左矢前のブログ 次のブログ右矢

BSVの例題 (3)

posted by sakurai on June 21, 2024 #822

どの哲学者がどのスプーンを使っているかを見やすくするため、スプーンを使用中に哲学者の番号を付けることにします。初期状態は'X'ですが、bsvのシミュレータであるbsimでは'X'は取れないようです。

$ bsc -u -opt-undetermined-vals -unspecified-to X -no-warn-action-shadowing -sim philo.bsv
$ bsc -sim -e philoBENCH -o philoBENCH.exe
$ ./philoBENCH.exe -V bsim.vcd
$ gtkwave -A bsim.vcd

図%%.1
図822.1 bsimシミュレーション

spoonのナンバーを見ると、哲学者の取得するスプーンの様子が良くわかります。最初に1番の哲学者が(1, 2)を用いて食事し、次に0番が(0, 1)、4番が(0, 4)、3番が(3, 4)とたまたま順に食事します。次に2番が(2, 3)を使用し、ほぼ同時に4番が(0, 4)を用いて食事をしています。

verilogシミュレーション

$ bsc -u -opt-undetermined-vals -unspecified-to X -no-warn-action-shadowing -verilog philo.bsv
$ bsc -verilog -e philoBENCH -o philoBENCH.exev
$ ./philoBENCH.exev +bscvcd=verilog.vcd
$ gtkwave -A verilog.vcd

図%%.2
図822.2 verilogシミュレーション

最初に1番の哲学者が(1, 2)を用いて食事し、次に0番が(0, 1)、4番が(0, 4)、3番が(3, 4)とたまたま順に食事します。次に2番が(2, 3)を使用し、ほぼ同時に4番が(0, 4)に食事をしています。不定が赤なので確定信号が良く分かります。

なお当初全面Xになって動作しなかったのですが、原因はspoonモジュールのinuseの初期値がXとなっていたためでした。Falseにしたところ正しく動作しました。

(* synthesize *)
module spoon (Spoon_if) ;
   Reg#(Bool) inuse <- mkReg(?);
   method Action pickup if (!inuse);
     inuse <= True;
   endmethod

この記述で分かるように、inuseの初期値は?(bsvで言うX)にも関わらず、次の行のpickupというメソッドに if (!inuse);条件が付いています。条件が不定なのでpickupメソッドをコールすると結果が不定となり、不定が伝搬することでシミュレーションが真っ赤になってしまいます。


左矢前のブログ 次のブログ右矢


ページ: