スポンサーサイト

上記の広告は1ヶ月以上更新のないブログに表示されています。
新しい記事を書く事で広告が消せます。

TLMモデルからSystemCモデルへの7つの課題

Merry Christmas!!!


SystemC Advent Calendar2012 の 最後の記事です。


今回は、クリスマスプレゼントということで問題提起だけにしたいと思います。
っと言っても大した事ではないのですが。


では、本題です。
2つの顔を持つ SystemC(IEEE1666) というように
SystemCでは幅広い範囲の抽象度で記述することができます。
それではそれぞれのモデルを再度は以下のような感じになります。


モデリング例


  • Cycleモデル
  •  1|#include <stdlib.h>
     2|#include <vector>
     3|using namespace std;
     4|
     5|#include <systemc.h>
     6|
     7|SC_MODULE( hoge ) {
     8|
     9|  sc_in  <bool >        clk;
    10|  sc_in  <bool >        xrst;
    11|  sc_in  <bool >        ce;
    12|  sc_in  <bool >        we;
    13|  sc_in  <sc_uint<10> > address;
    14|  sc_in  <sc_uint<32> > wdata;
    15|  sc_out <sc_uint<32> > rdata;
    16|
    17|  vector<unsigned int>  mem;
    18|  unsigned int          mem_size;
    19|
    20|  void process();
    21|  void write(unsigned intunsigned int);
    22|  unsigned int read(unsigned int);
    23|
    24|  SC_CTOR( hoge )
    25|    :  clk("clk"), xrst("xrst"), ce("ce"), we("we")
    26|     , address("address"), wdata("wdata"), rdata("rdata")
    27|  {
    28|    SC_THREAD(process);
    29|      sensitive << clk.pos();
    30|      async_reset_signal_is(xrst, false);
    31|    // Size Of Memory 32bit x 256word
    32|    mem_size = 0x100;
    33|    mem.resize(mem_size);
    34|    for(unsigned int i=0; i<mem_size; i++){ mem[i] = 0; }
    35|  }
    36|};
    37|
    38|inline void hoge::process(){
    39|  rdata.write(0);
    40|  wait();
    41|
    42|  while (true) {
    43|    if ((ce.read() == 1)) {
    44|      unsigned int _adrs = address.read() >> 2;
    45|      if (we.read() == 1) {
    46|        unsigned int _data = wdata.read();
    47|        write(_adrs, _data);
    48|      } else {
    49|        rdata = read(_adrs);
    50|      }
    51|    } else {
    52|      wait();
    53|    }
    54|  }
    55|}
    56|
    57|inline void hoge::write(unsigned int _adrs, unsigned int _data){
    58|  mem[_adrs] = _data;
    59|  wait();
    60|}
    61|
    62|inline unsigned int hoge::read(unsigned int _adrs){
    63|  wait();
    64|  wait();
    65|  return mem[_adrs];
    66|}
  • モデルの実行波形
  • 20121225_waves.png
  • TLMモデル
  •  1|#include <stdlib.h>
     2|#include <vector>
     3|using namespace std;
     4|
     5|#include <systemc.h>
     6|#include <tlm.h>
     7|#include "tlm_utils/simple_target_socket.h"
     8|using namespace tlm;
     9|
    10|SC_MODULE( hoge ) {
    11|
    12|  tlm_utils::simple_target_socket<hoge, 32> target_socket;
    13|
    14|  vector<unsigned int> mem;
    15|  unsigned int         mem_size;
    16|
    17|  void my_b_transport(tlm_generic_payload&, sc_time&);
    18|  void write(unsigned intunsigned int);
    19|  unsigned int read(unsigned int);
    20|
    21|  SC_CTOR( hoge )
    22|    : target_socket("target_socket")
    23|  {
    24|
    25|    target_socket.register_b_transport(this, &hoge::my_b_transport);
    26|
    27|    // Size Of Memory 32bit x 256word
    28|    mem_size = 0x100;
    29|    mem.resize(mem_size);
    30|    for(unsigned int i=0; i<mem_size; i++){ mem[i] = 0; }
    31|  }
    32|};
    33|
    34|inline void hoge::my_b_transport(tlm_generic_payload& trans, sc_time& delay){
    35|
    36|  sc_dt::uint64  adr  = trans.get_address() >> 2;
    37|  unsigned char* ptr  = trans.get_data_ptr();
    38|  unsigned int   len  = trans.get_data_length();
    39|  unsigned int   _tmp;
    40|
    41|  if (trans.is_read()) {
    42|    delay += sc_time(30SC_NS);
    43|    _tmp = read(adr);
    44|    memcpy(ptr, &_tmp, len);
    45|  } else if (trans.is_write()) {
    46|    delay += sc_time(10SC_NS);
    47|    memcpy( &_tmp, ptr, len);
    48|    write(adr, _tmp);
    49|  } else {
    50|    delay += SC_ZERO_TIME;
    51|  }
    52|  trans.set_dmi_allowed(false);
    53|  trans.set_response_status( tlm::TLM_OK_RESPONSE );
    54|}
    55|
    56|inline void hoge::write(unsigned int _adrs, unsigned int _data){
    57|  mem[_adrs] = _data;
    58|}
    59|
    60|inline unsigned int hoge::read(unsigned int _adrs){
    61|  return mem[_adrs];
    62|}

差分はなにか?


例えば、 #define で記述するような場合はこんな感じです。

  1|#include <stdlib.h>
  2|#include <vector>
  3|using namespace std;
  4|
  5|#include <systemc.h>
  6|//###################################################################//
  7|//# 1.Include
  8|//###################################################################//
  9|#ifdef TLM
 10|  #include "tlm_utils/simple_target_socket.h"
 11|  using namespace tlm;
 12|#endif
 13|//###################################################################//
 14|
 15|SC_MODULE( hoge ) {
 16|
 17|//###################################################################//
 18|//# 2.Interface
 19|//###################################################################//
 20|#ifdef TLM
 21|  tlm_utils::simple_target_socket<hoge, 32> target_socket;
 22|#else
 23|  sc_in  <bool >        clk;
 24|  sc_in  <bool >        xrst;
 25|  sc_in  <bool >        ce;
 26|  sc_in  <bool >        we;
 27|  sc_in  <sc_uint<10> > address;
 28|  sc_in  <sc_uint<32> > wdata;
 29|  sc_out <sc_uint<32> > rdata;
 30|#endif
 31|//###################################################################//
 32|
 33|  vector<unsigned int> mem;
 34|  unsigned int         mem_size;
 35|
 36|//###################################################################//
 37|//# 3.process関数
 38|//###################################################################//
 39|#ifdef TLM
 40|  void my_b_transport(tlm_generic_payload&, sc_time&);
 41|#else
 42|  void process();
 43|#endif
 44|  void write(unsigned intunsigned int);
 45|  unsigned int read(unsigned int);
 46|//###################################################################//
 47|
 48|  SC_CTOR( hoge )
 49|//###################################################################//
 50|//# 4.初期化リスト
 51|//###################################################################//
 52|#ifdef TLM
 53|    : target_socket("target_socket")
 54|#else
 55|    :  clk("clk"), xrst("xrst"), ce("ce"), we("we")
 56|     , address("address"), wdata("wdata"), rdata("rdata")
 57|#endif
 58|//###################################################################//
 59|  {
 60|
 61|//###################################################################//
 62|//# 5.process起動条件
 63|//###################################################################//
 64|#ifdef TLM
 65|    target_socket.register_b_transport(this, &hoge::my_b_transport);
 66|#else
 67|    SC_THREAD(process);
 68|      sensitive << clk.pos();
 69|      async_reset_signal_is(xrst, false);
 70|#endif
 71|//###################################################################//
 72|    // Size Of Memory 32bit x 256word
 73|    mem_size = 0x100;
 74|    mem.resize(mem_size);
 75|    for(unsigned int i=0; i<mem_size; i++){ mem[i] = 0; }
 76|  }
 77|};
 78|
 79|//###################################################################//
 80|//# 6.process(処理)
 81|//###################################################################//
 82|#ifdef TLM
 83|inline void hoge::my_b_transport(tlm_generic_payload& trans, sc_time& delay){
 84|
 85|  sc_dt::uint64  adr  = trans.get_address() >> 2;
 86|  unsigned char* ptr  = trans.get_data_ptr();
 87|  unsigned int   len  = trans.get_data_length();
 88|  unsigned int   _tmp;
 89|
 90|  if (trans.is_read()) {
 91|    delay += sc_time(30SC_NS);
 92|    _tmp = read(adr);
 93|    memcpy(ptr, &_tmp, len);
 94|  } else if (trans.is_write()) {
 95|    delay += sc_time(10SC_NS);
 96|    memcpy( &_tmp, ptr, len);
 97|    write(adr, _tmp);
 98|  } else {
 99|    delay += SC_ZERO_TIME;
100|  }
101|  trans.set_dmi_allowed(false);
102|  trans.set_response_status( tlm::TLM_OK_RESPONSE );
103|}
104|#else
105|inline void hoge::process(){
106|  rdata.write(0);
107|  wait();
108|
109|  while (true) {
110|    if ((ce.read() == 1)) {
111|      unsigned int _adrs = address.read() >> 2;
112|      if (we.read() == 1) {
113|        unsigned int _data = wdata.read();
114|        write(_adrs, _data);
115|      } else {
116|        rdata = read(_adrs);
117|      }
118|    } else {
119|      wait();
120|    }
121|  }
122|}
123|#endif
124|//###################################################################//
125|
126|inline void hoge::write(unsigned int _adrs, unsigned int _data){
127|  mem[_adrs] = _data;
128|//###################################################################//
129|//# 7.タイミング
130|//###################################################################//
131|#ifndef TLM
132|  wait();
133|#endif
134|//###################################################################//
135|}
136|
137|inline unsigned int hoge::read(unsigned int _adrs){
138|//###################################################################//
139|//# 7.タイミング
140|//###################################################################//
141|#ifndef TLM
142|  wait();
143|  wait();
144|#endif
145|//###################################################################//
146|  return mem[_adrs];
147|}

まとめ


理想的な設計フローとして、TLMモデルから SystemCモデルにする場合に課題点についてでした。 ただ、これらの課題は簡単に解決するものもあるし、更に追求していくともっと壁があると思います(笑)

  • 課題点
  • 1. Include
    2. Interface
    3. process関数
    4. 初期化リスト
    5. process起動条件
    6. process(処理)
    7. Timing
関連記事

コメントの投稿

非公開コメント

プロフィール

Kocha

Author:Kocha
なんでもチャレンジ!(^o^)/
E-mail
github:Kocha
イベントカレンダー

カレンダー
04 | 2017/05 | 06
- 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 - - -
カテゴリ
OVP (4)
最新記事
最新コメント
アーカイブ
リンク
Twitter
アクセス人数
上記広告は1ヶ月以上更新のないブログに表示されています。新しい記事を書くことで広告を消せます。